reactor-effect-client 0.2.0 → 0.3.0

package/dist/errors.d.ts

@@ -1,88 +1,1303 @@
+/**
+ * The client's error algebra. Four wrapper classes, each with its own `_tag`,
+ * carry a tagged `reason` (handled with `Effect.catchReason`, `catchReasons`
+ * and `unwrapReason`) and a `context` of cross-cutting evidence: the operation
+ * and its dispatch outcome.
+ *
+ * Privacy: `message` is written by the library and never contains provider or
+ * payload text, so spans and logs that record it stay payload-free. Provider
+ * text lives only in fields for explicit inspection: `body` on `Http` and
+ * `Remote`, the Redacted `backendMessage` on `Native`, and `context.detail`.
+ * Diagnostic JSON (`toJSON`) leaves all three out. Only a cause the library
+ * authored becomes the native `cause`: each wrapper hoists its reason, and a
+ * reason never holds a raw cause, because exporters such as OtlpTracer render
+ * the whole cause chain. A response body, a wire message, native backend text
+ * or a `JSON.parse` SyntaxError (whose message quotes its input) stays in
+ * `detail` or a typed field.
+ */
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Result from "effect/Result";
 import * as Schema from "effect/Schema";
-export declare const ErrorCode: Schema.Literals<readonly ["InvalidInput", "Protocol", "Http", "VersionMismatch", "UnsupportedHost", "UnsupportedCapability", "InvalidState", "TerminalSession", "Timeout", "Disconnected", "Aborted", "Overflow", "Remote", "UnexpectedReply", "Upload", "RecorderDisabled", "Native", "Closed", "AlreadyReading", "Shutdown"]>;
-export type ErrorCode = typeof ErrorCode.Type;
-export type RemoteOutcome = "not-submitted" | "unknown" | "replied";
-export declare const ProviderFailure: Schema.Struct<{
-    readonly code: Schema.String;
+import { SequenceCode } from "./Sequence.js";
+import type { CloseReport } from "./SessionTypes.js";
+/**
+ * The client's four failure classes share this marker so one guard recognizes
+ * each of them, although each has its own `_tag` (the ClusterError precedent).
+ */
+declare const TypeId: "~reactor-effect-client/ReactorFailure";
+/** The codes whose reason carries nothing beyond a library-written message. */
+export declare const FailureCode: Schema.Literals<readonly ["InvalidInput", "Protocol", "VersionMismatch", "UnsupportedHost", "UnsupportedCapability", "InvalidState", "TerminalSession", "Timeout", "Disconnected", "Aborted", "Overflow", "UnexpectedReply", "Upload", "Closed", "AlreadyReading", "Shutdown", "SdpRejected", "ChannelClosed", "Indeterminate"]>;
+export type FailureCode = typeof FailureCode.Type;
+declare const Failure_base: Schema.Class<Failure, Schema.Struct<{
+    readonly _tag: Schema.Literals<readonly ["InvalidInput", "Protocol", "VersionMismatch", "UnsupportedHost", "UnsupportedCapability", "InvalidState", "TerminalSession", "Timeout", "Disconnected", "Aborted", "Overflow", "UnexpectedReply", "Upload", "Closed", "AlreadyReading", "Shutdown", "SdpRejected", "ChannelClosed", "Indeterminate"]>;
     readonly message: Schema.String;
-    readonly recoverable: Schema.Boolean;
-    readonly operation: Schema.optionalKey<Schema.String>;
-    readonly status: Schema.optionalKey<Schema.Number>;
-    readonly retryAfterMs: Schema.optionalKey<Schema.Number>;
-}>;
-export type ProviderFailure = typeof ProviderFailure.Type;
+}>, import("effect/Cause").YieldableError>;
+/** One reason class whose `_tag` is the code (the PlatformError.SystemError precedent). */
+export declare class Failure extends Failure_base {
+    /** Local backpressure (`Overflow`) and a lost connection may succeed on a later attempt. */
+    get isRetryable(): boolean;
+}
+declare const Http_base: Schema.Class<Http, Schema.Struct<{
+    readonly _tag: Schema.tag<"Http">;
+    readonly message: Schema.String;
+    readonly status: Schema.optionalKey<Schema.Int>;
+    /** The response's `Retry-After`, when it named a delay. */
+    readonly retryAfter: Schema.optionalKey<Schema.Duration>;
+    /** The response body, for explicit inspection only. */
+    readonly body: Schema.optionalKey<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+/** A coordinator HTTP failure; `status` is absent when no response arrived. */
+export declare class Http extends Http_base {
+    /**
+     * No response arrived, or the coordinator refused for now: 408, 429, 503, or
+     * any status that named a Retry-After delay.
+     */
+    get isRetryable(): boolean;
+    /** Diagnostic JSON: the body stays out. */
+    toJSON(): {
+        _tag: "Http";
+        message: string;
+        status?: number;
+        retryAfterMillis?: number;
+        candidateTypes?: never;
+        pairs?: never;
+        clipId?: never;
+        lifecycle?: never;
+        transportGeneration?: never;
+        purpose?: never;
+        sequenceId?: never;
+        code?: never;
+    } | {
+        _tag: "RecorderDisabled" | "Remote";
+        message: string;
+        remoteCode?: string;
+        candidateTypes?: never;
+        pairs?: never;
+        clipId?: never;
+        lifecycle?: never;
+        transportGeneration?: never;
+        purpose?: never;
+        sequenceId?: never;
+        code?: never;
+    } | {
+        _tag: "Native";
+        message: string;
+        status?: number;
+        candidateTypes?: never;
+        pairs?: never;
+        clipId?: never;
+        lifecycle?: never;
+        transportGeneration?: never;
+        purpose?: never;
+        sequenceId?: never;
+        code?: never;
+    } | {
+        _tag: "IceFailed";
+        message: string;
+        pairs: number;
+        candidateTypes: readonly string[];
+        clipId?: never;
+        lifecycle?: never;
+        transportGeneration?: never;
+        purpose?: never;
+        sequenceId?: never;
+        code?: never;
+    } | {
+        candidateTypes?: never;
+        _tag: "TransportFailed";
+        message: string;
+        pairs: number;
+        clipId?: never;
+        lifecycle?: never;
+        transportGeneration?: never;
+        purpose?: never;
+        sequenceId?: never;
+        code?: never;
+    } | {
+        candidateTypes?: never;
+        pairs?: never;
+        _tag: "ClipEnded";
+        message: string;
+        clipId: string;
+        lifecycle: "clip_failed" | "clip_popped";
+        transportGeneration: string;
+        purpose?: never;
+        sequenceId?: never;
+        code?: never;
+    } | {
+        candidateTypes?: never;
+        pairs?: never;
+        clipId?: never;
+        lifecycle?: never;
+        transportGeneration?: never;
+        _tag: "Missing";
+        message: string;
+        purpose: "anchor" | "continuation" | "session_anchor";
+        sequenceId?: never;
+        code?: never;
+    } | {
+        candidateTypes?: never;
+        pairs?: never;
+        clipId?: never;
+        lifecycle?: never;
+        transportGeneration?: never;
+        purpose?: never;
+        _tag: "Sequence";
+        message: string;
+        sequenceId: string;
+        code: "capacity" | "indeterminate" | "member-capacity" | "member-duplicate" | "member-missing" | "missing" | "not-releasable" | "owner-mismatch" | "retired" | "sealed" | "sealing";
+    } | {
+        candidateTypes?: never;
+        pairs?: never;
+        clipId?: never;
+        lifecycle?: never;
+        transportGeneration?: never;
+        purpose?: never;
+        sequenceId?: never;
+        code?: never;
+        _tag: "Aborted" | "AlreadyReading" | "AnchorUnavailable" | "AnnotationCapacity" | "Busy" | "ChannelClosed" | "Closed" | "ContinuationUnavailable" | "Disconnected" | "IdentityExhausted" | "Indeterminate" | "InvalidInput" | "InvalidRequest" | "InvalidState" | "NotFound" | "Overflow" | "OwnerConflict" | "PositionConflict" | "Protocol" | "QueueChanged" | "QueueFull" | "RouteChanged" | "SdpRejected" | "SessionClosed" | "SessionRecovering" | "SessionRetired" | "Shutdown" | "SubmissionCapacity" | "TerminalSession" | "Timeout" | "UnexpectedReply" | "UnsupportedCapability" | "UnsupportedHost" | "Upload" | "VersionMismatch";
+        message: string;
+    };
+}
+declare const Remote_base: Schema.Class<Remote, Schema.Struct<{
+    readonly _tag: Schema.Literals<readonly ["Remote", "RecorderDisabled"]>;
+    readonly message: Schema.String;
+    /** The provider's own error code, verbatim. */
+    readonly remoteCode: Schema.optionalKey<Schema.String>;
+    /** The provider's error text, for explicit inspection only. */
+    readonly body: Schema.optionalKey<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The provider replied with an error or a refusal. `RecorderDisabled` is a
+ * clip failure recognized from its reason, the one documented classification
+ * of provider text.
+ */
+export declare class Remote extends Remote_base {
+    /** The provider refused; the same request would be refused again. */
+    get isRetryable(): boolean;
+    /** Diagnostic JSON: the body stays out. */
+    toJSON(): {
+        _tag: "Http";
+        message: string;
+        status?: number;
+        retryAfterMillis?: number;
+        candidateTypes?: never;
+        pairs?: never;
+        clipId?: never;
+        lifecycle?: never;
+        transportGeneration?: never;
+        purpose?: never;
+        sequenceId?: never;
+        code?: never;
+    } | {
+        _tag: "RecorderDisabled" | "Remote";
+        message: string;
+        remoteCode?: string;
+        candidateTypes?: never;
+        pairs?: never;
+        clipId?: never;
+        lifecycle?: never;
+        transportGeneration?: never;
+        purpose?: never;
+        sequenceId?: never;
+        code?: never;
+    } | {
+        _tag: "Native";
+        message: string;
+        status?: number;
+        candidateTypes?: never;
+        pairs?: never;
+        clipId?: never;
+        lifecycle?: never;
+        transportGeneration?: never;
+        purpose?: never;
+        sequenceId?: never;
+        code?: never;
+    } | {
+        _tag: "IceFailed";
+        message: string;
+        pairs: number;
+        candidateTypes: readonly string[];
+        clipId?: never;
+        lifecycle?: never;
+        transportGeneration?: never;
+        purpose?: never;
+        sequenceId?: never;
+        code?: never;
+    } | {
+        candidateTypes?: never;
+        _tag: "TransportFailed";
+        message: string;
+        pairs: number;
+        clipId?: never;
+        lifecycle?: never;
+        transportGeneration?: never;
+        purpose?: never;
+        sequenceId?: never;
+        code?: never;
+    } | {
+        candidateTypes?: never;
+        pairs?: never;
+        _tag: "ClipEnded";
+        message: string;
+        clipId: string;
+        lifecycle: "clip_failed" | "clip_popped";
+        transportGeneration: string;
+        purpose?: never;
+        sequenceId?: never;
+        code?: never;
+    } | {
+        candidateTypes?: never;
+        pairs?: never;
+        clipId?: never;
+        lifecycle?: never;
+        transportGeneration?: never;
+        _tag: "Missing";
+        message: string;
+        purpose: "anchor" | "continuation" | "session_anchor";
+        sequenceId?: never;
+        code?: never;
+    } | {
+        candidateTypes?: never;
+        pairs?: never;
+        clipId?: never;
+        lifecycle?: never;
+        transportGeneration?: never;
+        purpose?: never;
+        _tag: "Sequence";
+        message: string;
+        sequenceId: string;
+        code: "capacity" | "indeterminate" | "member-capacity" | "member-duplicate" | "member-missing" | "missing" | "not-releasable" | "owner-mismatch" | "retired" | "sealed" | "sealing";
+    } | {
+        candidateTypes?: never;
+        pairs?: never;
+        clipId?: never;
+        lifecycle?: never;
+        transportGeneration?: never;
+        purpose?: never;
+        sequenceId?: never;
+        code?: never;
+        _tag: "Aborted" | "AlreadyReading" | "AnchorUnavailable" | "AnnotationCapacity" | "Busy" | "ChannelClosed" | "Closed" | "ContinuationUnavailable" | "Disconnected" | "IdentityExhausted" | "Indeterminate" | "InvalidInput" | "InvalidRequest" | "InvalidState" | "NotFound" | "Overflow" | "OwnerConflict" | "PositionConflict" | "Protocol" | "QueueChanged" | "QueueFull" | "RouteChanged" | "SdpRejected" | "SessionClosed" | "SessionRecovering" | "SessionRetired" | "Shutdown" | "SubmissionCapacity" | "TerminalSession" | "Timeout" | "UnexpectedReply" | "UnsupportedCapability" | "UnsupportedHost" | "Upload" | "VersionMismatch";
+        message: string;
+    };
+}
+declare const Native_base: Schema.Class<Native, Schema.Struct<{
+    readonly _tag: Schema.tag<"Native">;
+    readonly message: Schema.String;
+    readonly status: Schema.optionalKey<Schema.Int>;
+    /**
+     * libwebrtc's own text. It can contain peer SDP or caller-supplied signaling
+     * material, so it is Redacted and refuses JSON encoding.
+     */
+    readonly backendMessage: Schema.optionalKey<Schema.Redacted<Schema.String>>;
+}>, import("effect/Cause").YieldableError>;
+/** A native bridge failure; `status` is the ABI's failure class when one was returned. */
+export declare class Native extends Native_base {
+    get isRetryable(): boolean;
+    /** Diagnostic JSON: the backend text stays out. */
+    toJSON(): {
+        _tag: "Http";
+        message: string;
+        status?: number;
+        retryAfterMillis?: number;
+        candidateTypes?: never;
+        pairs?: never;
+        clipId?: never;
+        lifecycle?: never;
+        transportGeneration?: never;
+        purpose?: never;
+        sequenceId?: never;
+        code?: never;
+    } | {
+        _tag: "RecorderDisabled" | "Remote";
+        message: string;
+        remoteCode?: string;
+        candidateTypes?: never;
+        pairs?: never;
+        clipId?: never;
+        lifecycle?: never;
+        transportGeneration?: never;
+        purpose?: never;
+        sequenceId?: never;
+        code?: never;
+    } | {
+        _tag: "Native";
+        message: string;
+        status?: number;
+        candidateTypes?: never;
+        pairs?: never;
+        clipId?: never;
+        lifecycle?: never;
+        transportGeneration?: never;
+        purpose?: never;
+        sequenceId?: never;
+        code?: never;
+    } | {
+        _tag: "IceFailed";
+        message: string;
+        pairs: number;
+        candidateTypes: readonly string[];
+        clipId?: never;
+        lifecycle?: never;
+        transportGeneration?: never;
+        purpose?: never;
+        sequenceId?: never;
+        code?: never;
+    } | {
+        candidateTypes?: never;
+        _tag: "TransportFailed";
+        message: string;
+        pairs: number;
+        clipId?: never;
+        lifecycle?: never;
+        transportGeneration?: never;
+        purpose?: never;
+        sequenceId?: never;
+        code?: never;
+    } | {
+        candidateTypes?: never;
+        pairs?: never;
+        _tag: "ClipEnded";
+        message: string;
+        clipId: string;
+        lifecycle: "clip_failed" | "clip_popped";
+        transportGeneration: string;
+        purpose?: never;
+        sequenceId?: never;
+        code?: never;
+    } | {
+        candidateTypes?: never;
+        pairs?: never;
+        clipId?: never;
+        lifecycle?: never;
+        transportGeneration?: never;
+        _tag: "Missing";
+        message: string;
+        purpose: "anchor" | "continuation" | "session_anchor";
+        sequenceId?: never;
+        code?: never;
+    } | {
+        candidateTypes?: never;
+        pairs?: never;
+        clipId?: never;
+        lifecycle?: never;
+        transportGeneration?: never;
+        purpose?: never;
+        _tag: "Sequence";
+        message: string;
+        sequenceId: string;
+        code: "capacity" | "indeterminate" | "member-capacity" | "member-duplicate" | "member-missing" | "missing" | "not-releasable" | "owner-mismatch" | "retired" | "sealed" | "sealing";
+    } | {
+        candidateTypes?: never;
+        pairs?: never;
+        clipId?: never;
+        lifecycle?: never;
+        transportGeneration?: never;
+        purpose?: never;
+        sequenceId?: never;
+        code?: never;
+        _tag: "Aborted" | "AlreadyReading" | "AnchorUnavailable" | "AnnotationCapacity" | "Busy" | "ChannelClosed" | "Closed" | "ContinuationUnavailable" | "Disconnected" | "IdentityExhausted" | "Indeterminate" | "InvalidInput" | "InvalidRequest" | "InvalidState" | "NotFound" | "Overflow" | "OwnerConflict" | "PositionConflict" | "Protocol" | "QueueChanged" | "QueueFull" | "RouteChanged" | "SdpRejected" | "SessionClosed" | "SessionRecovering" | "SessionRetired" | "Shutdown" | "SubmissionCapacity" | "TerminalSession" | "Timeout" | "UnexpectedReply" | "UnsupportedCapability" | "UnsupportedHost" | "Upload" | "VersionMismatch";
+        message: string;
+    };
+}
+declare const IceFailed_base: Schema.Class<IceFailed, Schema.Struct<{
+    readonly _tag: Schema.tag<"IceFailed">;
+    readonly message: Schema.String;
+    /** Candidate pairs the connection's statistics listed. */
+    readonly pairs: Schema.Int;
+    /** The local candidate types gathered, such as `host` or `relay`. */
+    readonly candidateTypes: Schema.$Array<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+/** No ICE candidate pair worked. */
+export declare class IceFailed extends IceFailed_base {
+    get isRetryable(): boolean;
+}
+declare const TransportFailed_base: Schema.Class<TransportFailed, Schema.Struct<{
+    readonly _tag: Schema.tag<"TransportFailed">;
+    readonly message: Schema.String;
+    /** Candidate pairs the connection's statistics listed. */
+    readonly pairs: Schema.Int;
+}>, import("effect/Cause").YieldableError>;
+/** ICE connectivity succeeded and the DTLS or SCTP transport above it failed. */
+export declare class TransportFailed extends TransportFailed_base {
+    get isRetryable(): boolean;
+}
+declare const ClipEnded_base: Schema.Class<ClipEnded, Schema.Struct<{
+    readonly _tag: Schema.tag<"ClipEnded">;
+    readonly message: Schema.String;
+    readonly clipId: Schema.String;
+    /** The lifecycle message that ended the clip. */
+    readonly lifecycle: Schema.Literals<readonly ["clip_failed", "clip_popped"]>;
+    /** The transport generation whose evidence ended it. */
+    readonly transportGeneration: Schema.BigInt;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A clip ended before it reached the phase awaited: it failed, or it was
+ * popped from the queue, first.
+ */
+export declare class ClipEnded extends ClipEnded_base {
+    get isRetryable(): boolean;
+}
+export declare const ReactorErrorReason: Schema.Union<readonly [typeof Failure, typeof Http, typeof Remote, typeof Native, typeof IceFailed, typeof TransportFailed, typeof ClipEnded]>;
+export type ReactorErrorReason = typeof ReactorErrorReason.Type;
+/** Every reason tag a ReactorError, CommandFailure or AcquisitionFailure can carry. */
+export declare const ErrorCode: Schema.Literals<readonly ["InvalidInput", "Protocol", "VersionMismatch", "UnsupportedHost", "UnsupportedCapability", "InvalidState", "TerminalSession", "Timeout", "Disconnected", "Aborted", "Overflow", "UnexpectedReply", "Upload", "Closed", "AlreadyReading", "Shutdown", "SdpRejected", "ChannelClosed", "Indeterminate", "Http", "Remote", "RecorderDisabled", "Native", "IceFailed", "TransportFailed", "ClipEnded"]>;
+export type ErrorCode = ReactorErrorReason["_tag"];
+/** The codes a reason can be built from with a message alone. */
+export type MessageCode = Exclude<ErrorCode, "IceFailed" | "TransportFailed" | "ClipEnded">;
+export type RemoteOutcome = "not-submitted" | "unknown" | "replied";
 export declare const ErrorContext: Schema.Struct<{
     readonly operation: Schema.optionalKey<Schema.String>;
     readonly requestId: Schema.optionalKey<Schema.String>;
     readonly sessionId: Schema.optionalKey<Schema.String>;
     readonly generation: Schema.optionalKey<Schema.BigInt>;
     readonly outcome: Schema.optionalKey<Schema.Literals<readonly ["not-submitted", "unknown", "replied"]>>;
-    readonly status: Schema.optionalKey<Schema.Number>;
-    readonly retryAfterMs: Schema.optionalKey<Schema.Number>;
-    readonly remoteCode: Schema.optionalKey<Schema.String>;
-    /** Explicit inspection only. Diagnostic serialization excludes response bodies and causes. */
-    readonly body: Schema.optionalKey<Schema.String>;
+    /**
+     * The underlying cause or diagnostic record, for explicit inspection only. It
+     * may hold provider or payload text, so it is never the native `cause` and
+     * diagnostic JSON leaves it out.
+     */
     readonly detail: Schema.optionalKey<Schema.Unknown>;
 }>;
 export type ErrorContext = typeof ErrorContext.Type;
-interface Fields {
-    readonly code: ErrorCode;
-    readonly message: string;
-    readonly context?: ErrorContext;
-    readonly nativeError?: ProviderFailure;
+/** Dispatch evidence proving that a request was never handed to the remote. */
+export declare const NotSubmitted: Schema.Struct<{
+    readonly requestId: Schema.optionalKey<Schema.String>;
+    readonly sessionId: Schema.optionalKey<Schema.String>;
+    readonly generation: Schema.optionalKey<Schema.BigInt>;
+    /**
+     * The underlying cause or diagnostic record, for explicit inspection only. It
+     * may hold provider or payload text, so it is never the native `cause` and
+     * diagnostic JSON leaves it out.
+     */
+    readonly detail: Schema.optionalKey<Schema.Unknown>;
+    readonly outcome: Schema.Literal<"not-submitted">;
+    readonly operation: Schema.String;
+}>;
+export type NotSubmitted = typeof NotSubmitted.Type;
+/** Dispatch evidence is independent of the failure's transport category. */
+export declare const CommandContext: Schema.Union<readonly [Schema.Struct<{
+    readonly requestId: Schema.optionalKey<Schema.String>;
+    readonly sessionId: Schema.optionalKey<Schema.String>;
+    readonly generation: Schema.optionalKey<Schema.BigInt>;
+    /**
+     * The underlying cause or diagnostic record, for explicit inspection only. It
+     * may hold provider or payload text, so it is never the native `cause` and
+     * diagnostic JSON leaves it out.
+     */
+    readonly detail: Schema.optionalKey<Schema.Unknown>;
+    readonly outcome: Schema.Literal<"not-submitted">;
+    readonly operation: Schema.String;
+}>, Schema.Struct<{
+    readonly sessionId: Schema.optionalKey<Schema.String>;
+    /**
+     * The underlying cause or diagnostic record, for explicit inspection only. It
+     * may hold provider or payload text, so it is never the native `cause` and
+     * diagnostic JSON leaves it out.
+     */
+    readonly detail: Schema.optionalKey<Schema.Unknown>;
+    readonly outcome: Schema.Literals<readonly ["unknown", "replied"]>;
+    readonly operation: Schema.String;
+    readonly requestId: Schema.String;
+    readonly generation: Schema.BigInt;
+}>]>;
+export type CommandContext = typeof CommandContext.Type;
+/** Local admission refusals that carry only a message. */
+export declare const RefusalCode: Schema.Literals<readonly ["QueueFull", "SessionRecovering", "SessionClosed", "SessionRetired", "NotFound", "OwnerConflict", "Busy", "InvalidRequest", "PositionConflict", "QueueChanged", "RouteChanged", "AnchorUnavailable", "ContinuationUnavailable", "AnnotationCapacity", "SubmissionCapacity", "IdentityExhausted"]>;
+export type RefusalCode = typeof RefusalCode.Type;
+declare const Refusal_base: Schema.Class<Refusal, Schema.Struct<{
+    readonly _tag: Schema.Literals<readonly ["QueueFull", "SessionRecovering", "SessionClosed", "SessionRetired", "NotFound", "OwnerConflict", "Busy", "InvalidRequest", "PositionConflict", "QueueChanged", "RouteChanged", "AnchorUnavailable", "ContinuationUnavailable", "AnnotationCapacity", "SubmissionCapacity", "IdentityExhausted"]>;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** A local refusal whose `_tag` is its code. */
+export declare class Refusal extends Refusal_base {
+    /** A full queue and a recovering session are backpressure: the request can wait. */
+    get isRetryable(): boolean;
 }
+declare const Missing_base: Schema.Class<Missing, Schema.Struct<{
+    readonly _tag: Schema.tag<"Missing">;
+    /** The field: `before` (anchor), `sameSessionAs` (session_anchor) or `continueFrom`. */
+    readonly purpose: Schema.Literals<readonly ["anchor", "session_anchor", "continuation"]>;
+}>, import("effect/Cause").YieldableError>;
+/** A request field names a clip that no session is known to own. */
+export declare class Missing extends Missing_base {
+    get message(): string;
+    get isRetryable(): boolean;
+}
+declare const SequenceRefusal_base: Schema.Class<SequenceRefusal, Schema.Struct<{
+    readonly _tag: Schema.tag<"Sequence">;
+    readonly sequenceId: Schema.String;
+    readonly code: Schema.Literals<readonly ["capacity", "member-capacity", "owner-mismatch", "sealed", "sealing", "indeterminate", "retired", "missing", "member-missing", "member-duplicate", "not-releasable"]>;
+}>, import("effect/Cause").YieldableError>;
+/** Sequence affinity refused the request; `code` is the SequenceError code. */
+export declare class SequenceRefusal extends SequenceRefusal_base {
+    get message(): string;
+    get isRetryable(): boolean;
+}
+export declare const PolicyReason: Schema.Union<readonly [typeof Refusal, typeof Missing, typeof SequenceRefusal]>;
+export type PolicyReason = typeof PolicyReason.Type;
 declare const ReactorError_base: Schema.Class<ReactorError, Schema.TaggedStruct<"ReactorError", {
-    readonly code: Schema.Literals<readonly ["InvalidInput", "Protocol", "Http", "VersionMismatch", "UnsupportedHost", "UnsupportedCapability", "InvalidState", "TerminalSession", "Timeout", "Disconnected", "Aborted", "Overflow", "Remote", "UnexpectedReply", "Upload", "RecorderDisabled", "Native", "Closed", "AlreadyReading", "Shutdown"]>;
-    readonly message: Schema.String;
-    readonly context: Schema.Struct<{
+    readonly reason: Schema.Union<readonly [typeof Failure, typeof Http, typeof Remote, typeof Native, typeof IceFailed, typeof TransportFailed, typeof ClipEnded]>;
+    readonly context: Schema.withConstructorDefault<Schema.Struct<{
         readonly operation: Schema.optionalKey<Schema.String>;
         readonly requestId: Schema.optionalKey<Schema.String>;
         readonly sessionId: Schema.optionalKey<Schema.String>;
         readonly generation: Schema.optionalKey<Schema.BigInt>;
         readonly outcome: Schema.optionalKey<Schema.Literals<readonly ["not-submitted", "unknown", "replied"]>>;
-        readonly status: Schema.optionalKey<Schema.Number>;
-        readonly retryAfterMs: Schema.optionalKey<Schema.Number>;
-        readonly remoteCode: Schema.optionalKey<Schema.String>;
-        /** Explicit inspection only. Diagnostic serialization excludes response bodies and causes. */
-        readonly body: Schema.optionalKey<Schema.String>;
+        /**
+         * The underlying cause or diagnostic record, for explicit inspection only. It
+         * may hold provider or payload text, so it is never the native `cause` and
+         * diagnostic JSON leaves it out.
+         */
         readonly detail: Schema.optionalKey<Schema.Unknown>;
-    }>;
-    readonly nativeError: Schema.optionalKey<Schema.Struct<{
-        readonly code: Schema.String;
-        readonly message: Schema.String;
-        readonly recoverable: Schema.Boolean;
-        readonly operation: Schema.optionalKey<Schema.String>;
-        readonly status: Schema.optionalKey<Schema.Number>;
-        readonly retryAfterMs: Schema.optionalKey<Schema.Number>;
     }>>;
 }>, import("effect/Cause").YieldableError>;
-/** A failure category never implies a mutation was rolled back. Inspect context.outcome. */
+/**
+ * A failure category never implies a mutation was rolled back. Inspect
+ * `context.outcome`, and route on `reason._tag`.
+ *
+ * Construct it from its fields, as with any Schema class (`context` defaults
+ * to empty), or with `ReactorError.fromCode`.
+ */
 export declare class ReactorError extends ReactorError_base {
-    constructor(fields: Fields);
-    constructor(code: ErrorCode, message: string, context?: ErrorContext);
+    readonly [TypeId]: "~reactor-effect-client/ReactorFailure";
+    /** The reason is library-authored, so it is the native cause (the AiError precedent). */
+    readonly cause: ClipEnded | Failure | Http | IceFailed | Native | Remote | TransportFailed;
+    get message(): string;
+    /**
+     * Whether a later attempt may succeed. Never true when `context.outcome` is
+     * "unknown": the remote may already have applied the first attempt.
+     */
+    get isRetryable(): boolean;
+    /** The delay the remote asked for, when it named one (the AiError precedent). */
+    get retryAfter(): Duration.Duration | undefined;
+    /** Whether `u` is a `ReactorError`, and not one of the other client failures. */
+    static is(u: unknown): u is ReactorError;
+    /** A failure whose reason is `code` with a library-written `message`. */
+    static fromCode(code: MessageCode, message: string, context?: ErrorContext): ReactorError;
+    toJSON(): {
+        _tag: string;
+        message: string;
+        reason: {
+            _tag: "Http";
+            message: string;
+            status?: number;
+            retryAfterMillis?: number;
+            candidateTypes?: never;
+            pairs?: never;
+            clipId?: never;
+            lifecycle?: never;
+            transportGeneration?: never;
+            purpose?: never;
+            sequenceId?: never;
+            code?: never;
+        } | {
+            _tag: "RecorderDisabled" | "Remote";
+            message: string;
+            remoteCode?: string;
+            candidateTypes?: never;
+            pairs?: never;
+            clipId?: never;
+            lifecycle?: never;
+            transportGeneration?: never;
+            purpose?: never;
+            sequenceId?: never;
+            code?: never;
+        } | {
+            _tag: "Native";
+            message: string;
+            status?: number;
+            candidateTypes?: never;
+            pairs?: never;
+            clipId?: never;
+            lifecycle?: never;
+            transportGeneration?: never;
+            purpose?: never;
+            sequenceId?: never;
+            code?: never;
+        } | {
+            _tag: "IceFailed";
+            message: string;
+            pairs: number;
+            candidateTypes: readonly string[];
+            clipId?: never;
+            lifecycle?: never;
+            transportGeneration?: never;
+            purpose?: never;
+            sequenceId?: never;
+            code?: never;
+        } | {
+            candidateTypes?: never;
+            _tag: "TransportFailed";
+            message: string;
+            pairs: number;
+            clipId?: never;
+            lifecycle?: never;
+            transportGeneration?: never;
+            purpose?: never;
+            sequenceId?: never;
+            code?: never;
+        } | {
+            candidateTypes?: never;
+            pairs?: never;
+            _tag: "ClipEnded";
+            message: string;
+            clipId: string;
+            lifecycle: "clip_failed" | "clip_popped";
+            transportGeneration: string;
+            purpose?: never;
+            sequenceId?: never;
+            code?: never;
+        } | {
+            candidateTypes?: never;
+            pairs?: never;
+            clipId?: never;
+            lifecycle?: never;
+            transportGeneration?: never;
+            _tag: "Missing";
+            message: string;
+            purpose: "anchor" | "continuation" | "session_anchor";
+            sequenceId?: never;
+            code?: never;
+        } | {
+            candidateTypes?: never;
+            pairs?: never;
+            clipId?: never;
+            lifecycle?: never;
+            transportGeneration?: never;
+            purpose?: never;
+            _tag: "Sequence";
+            message: string;
+            sequenceId: string;
+            code: "capacity" | "indeterminate" | "member-capacity" | "member-duplicate" | "member-missing" | "missing" | "not-releasable" | "owner-mismatch" | "retired" | "sealed" | "sealing";
+        } | {
+            candidateTypes?: never;
+            pairs?: never;
+            clipId?: never;
+            lifecycle?: never;
+            transportGeneration?: never;
+            purpose?: never;
+            sequenceId?: never;
+            code?: never;
+            _tag: "Aborted" | "AlreadyReading" | "AnchorUnavailable" | "AnnotationCapacity" | "Busy" | "ChannelClosed" | "Closed" | "ContinuationUnavailable" | "Disconnected" | "IdentityExhausted" | "Indeterminate" | "InvalidInput" | "InvalidRequest" | "InvalidState" | "NotFound" | "Overflow" | "OwnerConflict" | "PositionConflict" | "Protocol" | "QueueChanged" | "QueueFull" | "RouteChanged" | "SdpRejected" | "SessionClosed" | "SessionRecovering" | "SessionRetired" | "Shutdown" | "SubmissionCapacity" | "TerminalSession" | "Timeout" | "UnexpectedReply" | "UnsupportedCapability" | "UnsupportedHost" | "Upload" | "VersionMismatch";
+            message: string;
+        };
+        context: {
+            operation?: string;
+            requestId?: string;
+            sessionId?: string;
+            outcome?: "not-submitted" | "replied" | "unknown";
+            generation?: string;
+        };
+    };
+}
+declare const CommandFailure_base: Schema.Class<CommandFailure, Schema.TaggedStruct<"CommandFailure", {
+    readonly reason: Schema.Union<readonly [typeof Failure, typeof Http, typeof Remote, typeof Native, typeof IceFailed, typeof TransportFailed, typeof ClipEnded]>;
+    readonly context: Schema.Union<readonly [Schema.Struct<{
+        readonly requestId: Schema.optionalKey<Schema.String>;
+        readonly sessionId: Schema.optionalKey<Schema.String>;
+        readonly generation: Schema.optionalKey<Schema.BigInt>;
+        /**
+         * The underlying cause or diagnostic record, for explicit inspection only. It
+         * may hold provider or payload text, so it is never the native `cause` and
+         * diagnostic JSON leaves it out.
+         */
+        readonly detail: Schema.optionalKey<Schema.Unknown>;
+        readonly outcome: Schema.Literal<"not-submitted">;
+        readonly operation: Schema.String;
+    }>, Schema.Struct<{
+        readonly sessionId: Schema.optionalKey<Schema.String>;
+        /**
+         * The underlying cause or diagnostic record, for explicit inspection only. It
+         * may hold provider or payload text, so it is never the native `cause` and
+         * diagnostic JSON leaves it out.
+         */
+        readonly detail: Schema.optionalKey<Schema.Unknown>;
+        readonly outcome: Schema.Literals<readonly ["unknown", "replied"]>;
+        readonly operation: Schema.String;
+        readonly requestId: Schema.String;
+        readonly generation: Schema.BigInt;
+    }>]>;
+}>, import("effect/Cause").YieldableError>;
+/** Every failed command carries the dispatch evidence established by its owner. */
+export declare class CommandFailure extends CommandFailure_base {
+    readonly [TypeId]: "~reactor-effect-client/ReactorFailure";
+    readonly cause: ClipEnded | Failure | Http | IceFailed | Native | Remote | TransportFailed;
+    get message(): string;
+    /**
+     * Whether a later attempt may succeed. Never true when `context.outcome` is
+     * "unknown": the remote may already have applied the first attempt.
+     */
+    get isRetryable(): boolean;
+    /** The delay the remote asked for, when it named one (the AiError precedent). */
+    get retryAfter(): Duration.Duration | undefined;
+    /** Whether `u` is a `CommandFailure`. */
+    static is(u: unknown): u is CommandFailure;
+    /** `error`'s reason, with the dispatch evidence its command established. */
+    static from(error: ReactorFailure, context: CommandContext): CommandFailure;
     toJSON(): {
-        _tag: "ReactorError";
-        code: "Aborted" | "AlreadyReading" | "Closed" | "Disconnected" | "Http" | "InvalidInput" | "InvalidState" | "Native" | "Overflow" | "Protocol" | "RecorderDisabled" | "Remote" | "Shutdown" | "TerminalSession" | "Timeout" | "UnexpectedReply" | "UnsupportedCapability" | "UnsupportedHost" | "Upload" | "VersionMismatch";
+        _tag: string;
         message: string;
+        reason: {
+            _tag: "Http";
+            message: string;
+            status?: number;
+            retryAfterMillis?: number;
+            candidateTypes?: never;
+            pairs?: never;
+            clipId?: never;
+            lifecycle?: never;
+            transportGeneration?: never;
+            purpose?: never;
+            sequenceId?: never;
+            code?: never;
+        } | {
+            _tag: "RecorderDisabled" | "Remote";
+            message: string;
+            remoteCode?: string;
+            candidateTypes?: never;
+            pairs?: never;
+            clipId?: never;
+            lifecycle?: never;
+            transportGeneration?: never;
+            purpose?: never;
+            sequenceId?: never;
+            code?: never;
+        } | {
+            _tag: "Native";
+            message: string;
+            status?: number;
+            candidateTypes?: never;
+            pairs?: never;
+            clipId?: never;
+            lifecycle?: never;
+            transportGeneration?: never;
+            purpose?: never;
+            sequenceId?: never;
+            code?: never;
+        } | {
+            _tag: "IceFailed";
+            message: string;
+            pairs: number;
+            candidateTypes: readonly string[];
+            clipId?: never;
+            lifecycle?: never;
+            transportGeneration?: never;
+            purpose?: never;
+            sequenceId?: never;
+            code?: never;
+        } | {
+            candidateTypes?: never;
+            _tag: "TransportFailed";
+            message: string;
+            pairs: number;
+            clipId?: never;
+            lifecycle?: never;
+            transportGeneration?: never;
+            purpose?: never;
+            sequenceId?: never;
+            code?: never;
+        } | {
+            candidateTypes?: never;
+            pairs?: never;
+            _tag: "ClipEnded";
+            message: string;
+            clipId: string;
+            lifecycle: "clip_failed" | "clip_popped";
+            transportGeneration: string;
+            purpose?: never;
+            sequenceId?: never;
+            code?: never;
+        } | {
+            candidateTypes?: never;
+            pairs?: never;
+            clipId?: never;
+            lifecycle?: never;
+            transportGeneration?: never;
+            _tag: "Missing";
+            message: string;
+            purpose: "anchor" | "continuation" | "session_anchor";
+            sequenceId?: never;
+            code?: never;
+        } | {
+            candidateTypes?: never;
+            pairs?: never;
+            clipId?: never;
+            lifecycle?: never;
+            transportGeneration?: never;
+            purpose?: never;
+            _tag: "Sequence";
+            message: string;
+            sequenceId: string;
+            code: "capacity" | "indeterminate" | "member-capacity" | "member-duplicate" | "member-missing" | "missing" | "not-releasable" | "owner-mismatch" | "retired" | "sealed" | "sealing";
+        } | {
+            candidateTypes?: never;
+            pairs?: never;
+            clipId?: never;
+            lifecycle?: never;
+            transportGeneration?: never;
+            purpose?: never;
+            sequenceId?: never;
+            code?: never;
+            _tag: "Aborted" | "AlreadyReading" | "AnchorUnavailable" | "AnnotationCapacity" | "Busy" | "ChannelClosed" | "Closed" | "ContinuationUnavailable" | "Disconnected" | "IdentityExhausted" | "Indeterminate" | "InvalidInput" | "InvalidRequest" | "InvalidState" | "NotFound" | "Overflow" | "OwnerConflict" | "PositionConflict" | "Protocol" | "QueueChanged" | "QueueFull" | "RouteChanged" | "SdpRejected" | "SessionClosed" | "SessionRecovering" | "SessionRetired" | "Shutdown" | "SubmissionCapacity" | "TerminalSession" | "Timeout" | "UnexpectedReply" | "UnsupportedCapability" | "UnsupportedHost" | "Upload" | "VersionMismatch";
+            message: string;
+        };
         context: {
             operation?: string;
             requestId?: string;
             sessionId?: string;
             outcome?: "not-submitted" | "replied" | "unknown";
+            generation?: string;
+        };
+    };
+}
+declare const AcquisitionFailure_base: Schema.Class<AcquisitionFailure, Schema.TaggedStruct<"AcquisitionFailure", {
+    readonly reason: Schema.Union<readonly [typeof Failure, typeof Http, typeof Remote, typeof Native, typeof IceFailed, typeof TransportFailed, typeof ClipEnded]>;
+    readonly context: Schema.withConstructorDefault<Schema.Struct<{
+        readonly operation: Schema.optionalKey<Schema.String>;
+        readonly requestId: Schema.optionalKey<Schema.String>;
+        readonly sessionId: Schema.optionalKey<Schema.String>;
+        readonly generation: Schema.optionalKey<Schema.BigInt>;
+        readonly outcome: Schema.optionalKey<Schema.Literals<readonly ["not-submitted", "unknown", "replied"]>>;
+        /**
+         * The underlying cause or diagnostic record, for explicit inspection only. It
+         * may hold provider or payload text, so it is never the native `cause` and
+         * diagnostic JSON leaves it out.
+         */
+        readonly detail: Schema.optionalKey<Schema.Unknown>;
+    }>>;
+    readonly cleanup: Schema.declare<CloseReport, CloseReport>;
+}>, import("effect/Cause").YieldableError>;
+/** A failed acquisition still returns the lifetime evidence of its partial lease. */
+export declare class AcquisitionFailure extends AcquisitionFailure_base {
+    readonly [TypeId]: "~reactor-effect-client/ReactorFailure";
+    readonly cause: ClipEnded | Failure | Http | IceFailed | Native | Remote | TransportFailed;
+    get message(): string;
+    /**
+     * Whether a later attempt may succeed. Never true when `context.outcome` is
+     * "unknown": the remote may already have applied the first attempt.
+     */
+    get isRetryable(): boolean;
+    /** The delay the remote asked for, when it named one (the AiError precedent). */
+    get retryAfter(): Duration.Duration | undefined;
+    /** Whether `u` is an `AcquisitionFailure`. */
+    static is(u: unknown): u is AcquisitionFailure;
+    /** `error`'s reason and context, with the cleanup its partial lease reported. */
+    static from(error: ReactorFailure, cleanup: CloseReport): AcquisitionFailure;
+    toJSON(): {
+        _tag: string;
+        message: string;
+        reason: {
+            _tag: "Http";
+            message: string;
             status?: number;
-            retryAfterMs?: number;
+            retryAfterMillis?: number;
+            candidateTypes?: never;
+            pairs?: never;
+            clipId?: never;
+            lifecycle?: never;
+            transportGeneration?: never;
+            purpose?: never;
+            sequenceId?: never;
+            code?: never;
+        } | {
+            _tag: "RecorderDisabled" | "Remote";
+            message: string;
             remoteCode?: string;
+            candidateTypes?: never;
+            pairs?: never;
+            clipId?: never;
+            lifecycle?: never;
+            transportGeneration?: never;
+            purpose?: never;
+            sequenceId?: never;
+            code?: never;
+        } | {
+            _tag: "Native";
+            message: string;
+            status?: number;
+            candidateTypes?: never;
+            pairs?: never;
+            clipId?: never;
+            lifecycle?: never;
+            transportGeneration?: never;
+            purpose?: never;
+            sequenceId?: never;
+            code?: never;
+        } | {
+            _tag: "IceFailed";
+            message: string;
+            pairs: number;
+            candidateTypes: readonly string[];
+            clipId?: never;
+            lifecycle?: never;
+            transportGeneration?: never;
+            purpose?: never;
+            sequenceId?: never;
+            code?: never;
+        } | {
+            candidateTypes?: never;
+            _tag: "TransportFailed";
+            message: string;
+            pairs: number;
+            clipId?: never;
+            lifecycle?: never;
+            transportGeneration?: never;
+            purpose?: never;
+            sequenceId?: never;
+            code?: never;
+        } | {
+            candidateTypes?: never;
+            pairs?: never;
+            _tag: "ClipEnded";
+            message: string;
+            clipId: string;
+            lifecycle: "clip_failed" | "clip_popped";
+            transportGeneration: string;
+            purpose?: never;
+            sequenceId?: never;
+            code?: never;
+        } | {
+            candidateTypes?: never;
+            pairs?: never;
+            clipId?: never;
+            lifecycle?: never;
+            transportGeneration?: never;
+            _tag: "Missing";
+            message: string;
+            purpose: "anchor" | "continuation" | "session_anchor";
+            sequenceId?: never;
+            code?: never;
+        } | {
+            candidateTypes?: never;
+            pairs?: never;
+            clipId?: never;
+            lifecycle?: never;
+            transportGeneration?: never;
+            purpose?: never;
+            _tag: "Sequence";
+            message: string;
+            sequenceId: string;
+            code: "capacity" | "indeterminate" | "member-capacity" | "member-duplicate" | "member-missing" | "missing" | "not-releasable" | "owner-mismatch" | "retired" | "sealed" | "sealing";
+        } | {
+            candidateTypes?: never;
+            pairs?: never;
+            clipId?: never;
+            lifecycle?: never;
+            transportGeneration?: never;
+            purpose?: never;
+            sequenceId?: never;
+            code?: never;
+            _tag: "Aborted" | "AlreadyReading" | "AnchorUnavailable" | "AnnotationCapacity" | "Busy" | "ChannelClosed" | "Closed" | "ContinuationUnavailable" | "Disconnected" | "IdentityExhausted" | "Indeterminate" | "InvalidInput" | "InvalidRequest" | "InvalidState" | "NotFound" | "Overflow" | "OwnerConflict" | "PositionConflict" | "Protocol" | "QueueChanged" | "QueueFull" | "RouteChanged" | "SdpRejected" | "SessionClosed" | "SessionRecovering" | "SessionRetired" | "Shutdown" | "SubmissionCapacity" | "TerminalSession" | "Timeout" | "UnexpectedReply" | "UnsupportedCapability" | "UnsupportedHost" | "Upload" | "VersionMismatch";
+            message: string;
+        };
+        context: {
+            operation?: string;
+            requestId?: string;
+            sessionId?: string;
+            outcome?: "not-submitted" | "replied" | "unknown";
             generation?: string;
         };
-        provider?: {
-            code: string;
-            operation: string | undefined;
-            status: number | undefined;
+    };
+}
+declare const PolicyFailure_base: Schema.Class<PolicyFailure, Schema.TaggedStruct<"PolicyFailure", {
+    readonly reason: Schema.Union<readonly [typeof Refusal, typeof Missing, typeof SequenceRefusal]>;
+    readonly context: Schema.Struct<{
+        readonly requestId: Schema.optionalKey<Schema.String>;
+        readonly sessionId: Schema.optionalKey<Schema.String>;
+        readonly generation: Schema.optionalKey<Schema.BigInt>;
+        /**
+         * The underlying cause or diagnostic record, for explicit inspection only. It
+         * may hold provider or payload text, so it is never the native `cause` and
+         * diagnostic JSON leaves it out.
+         */
+        readonly detail: Schema.optionalKey<Schema.Unknown>;
+        readonly outcome: Schema.Literal<"not-submitted">;
+        readonly operation: Schema.String;
+    }>;
+}>, import("effect/Cause").YieldableError>;
+/** Local admission is a policy decision, with explicit proof of no dispatch. */
+export declare class PolicyFailure extends PolicyFailure_base {
+    readonly [TypeId]: "~reactor-effect-client/ReactorFailure";
+    readonly cause: Missing | Refusal | SequenceRefusal;
+    get message(): string;
+    /**
+     * Whether a later attempt may succeed: a full queue or a recovering session.
+     * Nothing was dispatched, so the outcome never stands in the way.
+     */
+    get isRetryable(): boolean;
+    /** A local refusal names no delay. */
+    get retryAfter(): Duration.Duration | undefined;
+    /** Whether `u` is a `PolicyFailure`. */
+    static is(u: unknown): u is PolicyFailure;
+    /** A local refusal of `operation`, which was therefore never dispatched. */
+    static refuse(code: RefusalCode, message: string, operation?: string, cause?: unknown): PolicyFailure;
+    /** A refusal because the clip a request field names has no known owner. */
+    static missing(purpose: Missing["purpose"], operation?: string): PolicyFailure;
+    /** A refusal by sequence affinity, with its SequenceError code. */
+    static sequence(sequenceId: string, code: SequenceCode, operation?: string): PolicyFailure;
+    toJSON(): {
+        _tag: string;
+        message: string;
+        reason: {
+            _tag: "Http";
+            message: string;
+            status?: number;
+            retryAfterMillis?: number;
+            candidateTypes?: never;
+            pairs?: never;
+            clipId?: never;
+            lifecycle?: never;
+            transportGeneration?: never;
+            purpose?: never;
+            sequenceId?: never;
+            code?: never;
+        } | {
+            _tag: "RecorderDisabled" | "Remote";
+            message: string;
+            remoteCode?: string;
+            candidateTypes?: never;
+            pairs?: never;
+            clipId?: never;
+            lifecycle?: never;
+            transportGeneration?: never;
+            purpose?: never;
+            sequenceId?: never;
+            code?: never;
+        } | {
+            _tag: "Native";
+            message: string;
+            status?: number;
+            candidateTypes?: never;
+            pairs?: never;
+            clipId?: never;
+            lifecycle?: never;
+            transportGeneration?: never;
+            purpose?: never;
+            sequenceId?: never;
+            code?: never;
+        } | {
+            _tag: "IceFailed";
+            message: string;
+            pairs: number;
+            candidateTypes: readonly string[];
+            clipId?: never;
+            lifecycle?: never;
+            transportGeneration?: never;
+            purpose?: never;
+            sequenceId?: never;
+            code?: never;
+        } | {
+            candidateTypes?: never;
+            _tag: "TransportFailed";
+            message: string;
+            pairs: number;
+            clipId?: never;
+            lifecycle?: never;
+            transportGeneration?: never;
+            purpose?: never;
+            sequenceId?: never;
+            code?: never;
+        } | {
+            candidateTypes?: never;
+            pairs?: never;
+            _tag: "ClipEnded";
+            message: string;
+            clipId: string;
+            lifecycle: "clip_failed" | "clip_popped";
+            transportGeneration: string;
+            purpose?: never;
+            sequenceId?: never;
+            code?: never;
+        } | {
+            candidateTypes?: never;
+            pairs?: never;
+            clipId?: never;
+            lifecycle?: never;
+            transportGeneration?: never;
+            _tag: "Missing";
+            message: string;
+            purpose: "anchor" | "continuation" | "session_anchor";
+            sequenceId?: never;
+            code?: never;
+        } | {
+            candidateTypes?: never;
+            pairs?: never;
+            clipId?: never;
+            lifecycle?: never;
+            transportGeneration?: never;
+            purpose?: never;
+            _tag: "Sequence";
+            message: string;
+            sequenceId: string;
+            code: "capacity" | "indeterminate" | "member-capacity" | "member-duplicate" | "member-missing" | "missing" | "not-releasable" | "owner-mismatch" | "retired" | "sealed" | "sealing";
+        } | {
+            candidateTypes?: never;
+            pairs?: never;
+            clipId?: never;
+            lifecycle?: never;
+            transportGeneration?: never;
+            purpose?: never;
+            sequenceId?: never;
+            code?: never;
+            _tag: "Aborted" | "AlreadyReading" | "AnchorUnavailable" | "AnnotationCapacity" | "Busy" | "ChannelClosed" | "Closed" | "ContinuationUnavailable" | "Disconnected" | "IdentityExhausted" | "Indeterminate" | "InvalidInput" | "InvalidRequest" | "InvalidState" | "NotFound" | "Overflow" | "OwnerConflict" | "PositionConflict" | "Protocol" | "QueueChanged" | "QueueFull" | "RouteChanged" | "SdpRejected" | "SessionClosed" | "SessionRecovering" | "SessionRetired" | "Shutdown" | "SubmissionCapacity" | "TerminalSession" | "Timeout" | "UnexpectedReply" | "UnsupportedCapability" | "UnsupportedHost" | "Upload" | "VersionMismatch";
+            message: string;
+        };
+        context: {
+            operation?: string;
+            requestId?: string;
+            sessionId?: string;
+            outcome?: "not-submitted" | "replied" | "unknown";
+            generation?: string;
         };
     };
 }
-/** Keep the original cause for deliberate inspection without including it in the message. */
-export declare const errorOf: (cause: unknown, code?: ErrorCode, operation?: string) => ReactorError;
+/** A `ReactorError` as its diagnostic JSON. */
+export declare const ReactorErrorFromJson: Schema.decodeTo<Schema.declare<ReactorError, ReactorError>, Schema.Codec<{
+    readonly _tag: "ReactorError";
+    readonly message: string;
+    readonly reason: {
+        readonly _tag: "Aborted" | "AlreadyReading" | "ChannelClosed" | "Closed" | "Disconnected" | "Indeterminate" | "InvalidInput" | "InvalidState" | "Overflow" | "Protocol" | "SdpRejected" | "Shutdown" | "TerminalSession" | "Timeout" | "UnexpectedReply" | "UnsupportedCapability" | "UnsupportedHost" | "Upload" | "VersionMismatch";
+        readonly message: string;
+    } | {
+        readonly _tag: "Http";
+        readonly message: string;
+        readonly status?: number;
+        readonly retryAfterMillis?: number;
+    } | {
+        readonly _tag: "RecorderDisabled" | "Remote";
+        readonly message: string;
+        readonly remoteCode?: string;
+    } | {
+        readonly _tag: "Native";
+        readonly message: string;
+        readonly status?: number;
+    } | {
+        readonly _tag: "IceFailed";
+        readonly message: string;
+        readonly pairs: number;
+        readonly candidateTypes: readonly string[];
+    } | {
+        readonly _tag: "TransportFailed";
+        readonly message: string;
+        readonly pairs: number;
+    } | {
+        readonly _tag: "ClipEnded";
+        readonly message: string;
+        readonly clipId: string;
+        readonly lifecycle: "clip_failed" | "clip_popped";
+        readonly transportGeneration: string;
+    };
+    readonly context: {
+        readonly operation?: string;
+        readonly requestId?: string;
+        readonly sessionId?: string;
+        readonly generation?: string;
+        readonly outcome?: "not-submitted" | "replied" | "unknown";
+    };
+}, unknown, never, never>, never, never>;
+/** A `CommandFailure` as its diagnostic JSON. */
+export declare const CommandFailureFromJson: Schema.decodeTo<Schema.declare<CommandFailure, CommandFailure>, Schema.Codec<{
+    readonly _tag: "CommandFailure";
+    readonly message: string;
+    readonly reason: {
+        readonly _tag: "Aborted" | "AlreadyReading" | "ChannelClosed" | "Closed" | "Disconnected" | "Indeterminate" | "InvalidInput" | "InvalidState" | "Overflow" | "Protocol" | "SdpRejected" | "Shutdown" | "TerminalSession" | "Timeout" | "UnexpectedReply" | "UnsupportedCapability" | "UnsupportedHost" | "Upload" | "VersionMismatch";
+        readonly message: string;
+    } | {
+        readonly _tag: "Http";
+        readonly message: string;
+        readonly status?: number;
+        readonly retryAfterMillis?: number;
+    } | {
+        readonly _tag: "RecorderDisabled" | "Remote";
+        readonly message: string;
+        readonly remoteCode?: string;
+    } | {
+        readonly _tag: "Native";
+        readonly message: string;
+        readonly status?: number;
+    } | {
+        readonly _tag: "IceFailed";
+        readonly message: string;
+        readonly pairs: number;
+        readonly candidateTypes: readonly string[];
+    } | {
+        readonly _tag: "TransportFailed";
+        readonly message: string;
+        readonly pairs: number;
+    } | {
+        readonly _tag: "ClipEnded";
+        readonly message: string;
+        readonly clipId: string;
+        readonly lifecycle: "clip_failed" | "clip_popped";
+        readonly transportGeneration: string;
+    };
+    readonly context: {
+        readonly operation?: string;
+        readonly requestId?: string;
+        readonly sessionId?: string;
+        readonly generation?: string;
+        readonly outcome?: "not-submitted" | "replied" | "unknown";
+    };
+}, unknown, never, never>, never, never>;
+/** A `PolicyFailure` as its diagnostic JSON. */
+export declare const PolicyFailureFromJson: Schema.decodeTo<Schema.declare<PolicyFailure, PolicyFailure>, Schema.Codec<{
+    readonly _tag: "PolicyFailure";
+    readonly message: string;
+    readonly reason: {
+        readonly _tag: "AnchorUnavailable" | "AnnotationCapacity" | "Busy" | "ContinuationUnavailable" | "IdentityExhausted" | "InvalidRequest" | "NotFound" | "OwnerConflict" | "PositionConflict" | "QueueChanged" | "QueueFull" | "RouteChanged" | "SessionClosed" | "SessionRecovering" | "SessionRetired" | "SubmissionCapacity";
+        readonly message: string;
+    } | {
+        readonly _tag: "Missing";
+        readonly message: string;
+        readonly purpose: "anchor" | "continuation" | "session_anchor";
+    } | {
+        readonly _tag: "Sequence";
+        readonly message: string;
+        readonly sequenceId: string;
+        readonly code: "capacity" | "indeterminate" | "member-capacity" | "member-duplicate" | "member-missing" | "missing" | "not-releasable" | "owner-mismatch" | "retired" | "sealed" | "sealing";
+    };
+    readonly context: {
+        readonly operation?: string;
+        readonly requestId?: string;
+        readonly sessionId?: string;
+        readonly generation?: string;
+        readonly outcome?: "not-submitted" | "replied" | "unknown";
+    };
+}, unknown, never, never>, never, never>;
+/** Any failure this client raises. Each class keeps its own `_tag`. */
+export type ReactorFailure = ReactorError | CommandFailure | AcquisitionFailure | PolicyFailure;
+/**
+ * Whether `u` is one of the client's failures. A passthrough that re-raises a
+ * known failure uses this guard or a class's `is`, never `instanceof
+ * ReactorError`, so the evidence a class carries (the dispatch outcome,
+ * `AcquisitionFailure.cleanup`) is kept instead of re-wrapped.
+ */
+export declare const isReactorFailure: (u: unknown) => u is ReactorFailure;
+/**
+ * Runs a synchronous parser or check that rejects by throwing a ReactorError,
+ * and returns that rejection as the Result's failure. Anything else it throws
+ * is a bug and propagates, so it stays a defect rather than becoming a typed
+ * failure.
+ */
+export declare const parse: <A>(evaluate: () => A) => Result.Result<A, ReactorError>;
+/** `parse`, lifted with `Effect.fromResult`: a rejection fails it and a bug is a defect. */
+export declare const parsed: <A>(evaluate: () => A) => Effect.Effect<A, ReactorError>;
+/**
+ * A rejected caller input: `InvalidInput`, never submitted, whatever category
+ * the parser that rejected it uses for remote data.
+ */
+export declare const invalidInput: (error: ReactorError, operation?: string) => ReactorError;
+/** `parsed` for caller input: a rejection is `invalidInput`. */
+export declare const parsedInput: <A>(evaluate: () => A, operation?: string) => Effect.Effect<A, ReactorError>;
+/**
+ * A platform call's expected exception (a DOMException, a rejected browser
+ * promise, a native library call), as a failure of the category `code`; the
+ * exception stays in the inspection-only `detail`. Parsers and checks use
+ * `parse` instead, so a bug in them stays a defect.
+ */
+export declare const errorOf: (cause: unknown, code: MessageCode, operation?: string) => ReactorError;
 export declare const positiveLimit: (value: number, name: string, maximum?: number) => number;
 export {};
 //# sourceMappingURL=errors.d.ts.map