reactor-effect-client 0.7.1 → 0.8.0

package/dist/ReactorError.d.ts

@@ -0,0 +1,331 @@
+/**
+ * The client's failures. `ReactorError` carries a tagged `reason` (route with
+ * `Effect.catchReason`) and a `context` of dispatch evidence; `CommandFailure`
+ * is the same with the evidence a dispatched command must have, and
+ * `AcquisitionFailure` adds the cleanup report of a partial lease.
+ *
+ * `message` is written by the library and never holds provider or payload
+ * text. That text, native backend text and diagnostic detail live in
+ * `Redacted` fields, so logs, spans and `toJSON` show `<redacted>` for them.
+ * Persisted evidence stores a `FailureSummary`, never the error itself.
+ */
+import * as Duration from "effect/Duration";
+import * as Schema from "effect/Schema";
+import type { CloseReport } from "./Session.js";
+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", "Moderated"]>;
+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", "Moderated"]>;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** A reason whose `_tag` is its code. */
+export declare class Failure extends Failure_base {
+}
+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.Redacted<Schema.String>>;
+}>, import("effect/Cause").YieldableError>;
+/** A coordinator HTTP failure; `status` is absent when no response arrived. */
+export declare class Http extends Http_base {
+}
+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, for explicit inspection only. */
+    readonly remoteCode: Schema.optionalKey<Schema.Redacted<Schema.String>>;
+    /** The provider's error text, for explicit inspection only. */
+    readonly body: Schema.optionalKey<Schema.Redacted<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 {
+}
+declare const Native_base: Schema.Class<Native, Schema.Struct<{
+    readonly _tag: Schema.tag<"Native">;
+    readonly message: Schema.String;
+    /** libwebrtc's own text; it can contain peer SDP or signaling material. */
+    readonly backendMessage: Schema.optionalKey<Schema.Redacted<Schema.String>>;
+}>, import("effect/Cause").YieldableError>;
+/** A failure of the native WebRTC addon or its host process. */
+export declare class Native extends Native_base {
+}
+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 {
+}
+declare const TransportFailed_base: Schema.Class<TransportFailed, Schema.Struct<{
+    readonly _tag: Schema.tag<"TransportFailed">;
+    readonly message: Schema.String;
+    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 {
+}
+declare const ClipEnded_base: Schema.Class<ClipEnded, Schema.Struct<{
+    readonly _tag: Schema.tag<"ClipEnded">;
+    readonly message: Schema.String;
+    readonly clipId: Schema.String;
+    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, by `clip_failed` or `clip_popped`, before it reached the phase awaited. */
+export declare class ClipEnded extends ClipEnded_base {
+}
+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. */
+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">;
+/** Whether a remote mutation may have happened: never sent, maybe sent, or answered. */
+export declare const RemoteOutcome: Schema.Literals<readonly ["not-submitted", "unknown", "replied"]>;
+export type RemoteOutcome = typeof RemoteOutcome.Type;
+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"]>>;
+    /** A cause or diagnostic record; it may hold provider or payload text. */
+    readonly detail: Schema.optionalKey<Schema.Redacted<Schema.Unknown>>;
+}>;
+export type ErrorContext = typeof ErrorContext.Type;
+/** An `ErrorContext` whose `detail` is still plain; `fromCode` redacts it. */
+export type ContextInput = Omit<ErrorContext, "detail"> & {
+    readonly detail?: unknown;
+};
+/** 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>;
+    /** A cause or diagnostic record; it may hold provider or payload text. */
+    readonly detail: Schema.optionalKey<Schema.Redacted<Schema.Unknown>>;
+    readonly outcome: Schema.Literal<"not-submitted">;
+    readonly operation: Schema.String;
+}>;
+export type NotSubmitted = typeof NotSubmitted.Type;
+/** A command's dispatch evidence: never sent, or sent with its request identity. */
+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>;
+    /** A cause or diagnostic record; it may hold provider or payload text. */
+    readonly detail: Schema.optionalKey<Schema.Redacted<Schema.Unknown>>;
+    readonly outcome: Schema.Literal<"not-submitted">;
+    readonly operation: Schema.String;
+}>, Schema.Struct<{
+    readonly sessionId: Schema.optionalKey<Schema.String>;
+    /** A cause or diagnostic record; it may hold provider or payload text. */
+    readonly detail: Schema.optionalKey<Schema.Redacted<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;
+/** `C` with a plain `detail`, member by member, so a union keeps its members. */
+type PlainDetail<C> = C extends unknown ? Omit<C, "detail"> & {
+    readonly detail?: unknown;
+} : never;
+declare const ReactorError_base: Schema.Class<ReactorError, Schema.TaggedStruct<"ReactorError", {
+    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"]>>;
+        /** A cause or diagnostic record; it may hold provider or payload text. */
+        readonly detail: Schema.optionalKey<Schema.Redacted<Schema.Unknown>>;
+    }>>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A failure category never implies a mutation was rolled back: inspect
+ * `context.outcome`, and route on `reason._tag`.
+ */
+export declare class ReactorError extends ReactorError_base {
+    readonly [TypeId]: "~reactor-effect-client/ReactorFailure";
+    /** The reason is library-authored, so it is the native cause. */
+    readonly cause: ClipEnded | Failure | Http | IceFailed | Native | Remote | TransportFailed;
+    get message(): string;
+    get isRetryable(): boolean;
+    get retryAfter(): Duration.Duration | undefined;
+    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?: ContextInput): ReactorError;
+}
+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>;
+        /** A cause or diagnostic record; it may hold provider or payload text. */
+        readonly detail: Schema.optionalKey<Schema.Redacted<Schema.Unknown>>;
+        readonly outcome: Schema.Literal<"not-submitted">;
+        readonly operation: Schema.String;
+    }>, Schema.Struct<{
+        readonly sessionId: Schema.optionalKey<Schema.String>;
+        /** A cause or diagnostic record; it may hold provider or payload text. */
+        readonly detail: Schema.optionalKey<Schema.Redacted<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 its owner established. */
+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;
+    get isRetryable(): boolean;
+    get retryAfter(): Duration.Duration | undefined;
+    static is(u: unknown): u is CommandFailure;
+    /** `error`'s reason with the dispatch evidence its command established. */
+    static from(error: ReactorError | CommandFailure | AcquisitionFailure, context: PlainDetail<CommandContext>): CommandFailure;
+}
+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"]>>;
+        /** A cause or diagnostic record; it may hold provider or payload text. */
+        readonly detail: Schema.optionalKey<Schema.Redacted<Schema.Unknown>>;
+    }>>;
+    readonly cleanup: Schema.declare<{
+        readonly localClosed: boolean;
+        readonly allocation: "known" | "none" | "unknown";
+        readonly ownership?: "attached" | "owned";
+        readonly sessionId?: string;
+        readonly remote: {
+            readonly attempted: boolean;
+            readonly responseReceived: boolean;
+            readonly confirmed: boolean;
+            readonly evidence: "absent" | "terminal" | null;
+            readonly deleteStatus: number | null;
+            readonly state: string | null;
+            readonly error?: {
+                readonly _tag: string;
+                readonly reason: string;
+                readonly message: string;
+                readonly operation?: string;
+                readonly requestId?: string;
+                readonly sessionId?: string;
+                readonly generation?: string;
+                readonly outcome?: "not-submitted" | "replied" | "unknown";
+            };
+        };
+        readonly unpublishSubmitted: readonly string[];
+        readonly unresolvedPublications: readonly string[];
+        readonly localErrors: readonly {
+            readonly _tag: string;
+            readonly reason: string;
+            readonly message: string;
+            readonly operation?: string;
+            readonly requestId?: string;
+            readonly sessionId?: string;
+            readonly generation?: string;
+            readonly outcome?: "not-submitted" | "replied" | "unknown";
+        }[];
+    }, {
+        readonly localClosed: boolean;
+        readonly allocation: "known" | "none" | "unknown";
+        readonly ownership?: "attached" | "owned";
+        readonly sessionId?: string;
+        readonly remote: {
+            readonly attempted: boolean;
+            readonly responseReceived: boolean;
+            readonly confirmed: boolean;
+            readonly evidence: "absent" | "terminal" | null;
+            readonly deleteStatus: number | null;
+            readonly state: string | null;
+            readonly error?: {
+                readonly _tag: string;
+                readonly reason: string;
+                readonly message: string;
+                readonly operation?: string;
+                readonly requestId?: string;
+                readonly sessionId?: string;
+                readonly generation?: string;
+                readonly outcome?: "not-submitted" | "replied" | "unknown";
+            };
+        };
+        readonly unpublishSubmitted: readonly string[];
+        readonly unresolvedPublications: readonly string[];
+        readonly localErrors: readonly {
+            readonly _tag: string;
+            readonly reason: string;
+            readonly message: string;
+            readonly operation?: string;
+            readonly requestId?: string;
+            readonly sessionId?: string;
+            readonly generation?: string;
+            readonly outcome?: "not-submitted" | "replied" | "unknown";
+        }[];
+    }>;
+}>, 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;
+    get isRetryable(): boolean;
+    get retryAfter(): Duration.Duration | undefined;
+    static is(u: unknown): u is AcquisitionFailure;
+    /** `error`'s reason and context, with the cleanup its partial lease reported. */
+    static from(error: ReactorError | CommandFailure | AcquisitionFailure, cleanup: CloseReport): AcquisitionFailure;
+}
+/** Any failure this client raises. Each class keeps its own `_tag`. */
+export type ReactorFailure = ReactorError | CommandFailure | AcquisitionFailure;
+/**
+ * Whether `u` is one of the client's failures. A passthrough re-raises a known
+ * failure through this guard or a class's `is`, so the evidence a class carries
+ * is kept instead of re-wrapped.
+ */
+export declare const isReactorFailure: (u: unknown) => u is ReactorFailure;
+/** A failure as persisted evidence: its routing facts, without any redacted text. */
+export declare const FailureSummary: Schema.Struct<{
+    readonly _tag: Schema.String;
+    readonly reason: Schema.String;
+    readonly message: Schema.String;
+    readonly operation: Schema.optionalKey<Schema.String>;
+    readonly requestId: Schema.optionalKey<Schema.String>;
+    readonly sessionId: Schema.optionalKey<Schema.String>;
+    readonly generation: Schema.optionalKey<Schema.String>;
+    readonly outcome: Schema.optionalKey<Schema.Literals<readonly ["not-submitted", "unknown", "replied"]>>;
+}>;
+export type FailureSummary = typeof FailureSummary.Type;
+/** The summary of any failure with a tagged reason and a context, the client's or a policy's. */
+export declare const summarize: (error: {
+    readonly _tag: string;
+    readonly message: string;
+    readonly reason: {
+        readonly _tag: string;
+    };
+    readonly context: Omit<ErrorContext, "detail">;
+}) => FailureSummary;
+export {};
+//# sourceMappingURL=ReactorError.d.ts.map

package/dist/ReactorError.d.ts.map

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

package/dist/ReactorError.js

@@ -0,0 +1,316 @@
+/**
+ * The client's failures. `ReactorError` carries a tagged `reason` (route with
+ * `Effect.catchReason`) and a `context` of dispatch evidence; `CommandFailure`
+ * is the same with the evidence a dispatched command must have, and
+ * `AcquisitionFailure` adds the cleanup report of a partial lease.
+ *
+ * `message` is written by the library and never holds provider or payload
+ * text. That text, native backend text and diagnostic detail live in
+ * `Redacted` fields, so logs, spans and `toJSON` show `<redacted>` for them.
+ * Persisted evidence stores a `FailureSummary`, never the error itself.
+ */
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Predicate from "effect/Predicate";
+import * as Redacted from "effect/Redacted";
+import * as Schema from "effect/Schema";
+const TypeId = "~reactor-effect-client/ReactorFailure";
+/** The codes whose reason carries nothing beyond a library-written message. */
+export const FailureCode = Schema.Literals([
+    "InvalidInput",
+    "Protocol",
+    "VersionMismatch",
+    "UnsupportedHost",
+    "UnsupportedCapability",
+    "InvalidState",
+    "TerminalSession",
+    "Timeout",
+    "Disconnected",
+    "Aborted",
+    "Overflow",
+    "UnexpectedReply",
+    "Upload",
+    "Closed",
+    "AlreadyReading",
+    "Shutdown",
+    "SdpRejected",
+    "ChannelClosed",
+    "Indeterminate",
+    /** Reactor's content moderation ended the session. */
+    "Moderated",
+]);
+/** A reason whose `_tag` is its code. */
+export class Failure extends Schema.Error("reactor-effect-client/ReactorError/Failure")({
+    _tag: FailureCode,
+    message: Schema.String,
+}) {
+}
+/** A coordinator HTTP failure; `status` is absent when no response arrived. */
+export class Http extends Schema.Error("reactor-effect-client/ReactorError/Http")({
+    _tag: Schema.tag("Http"),
+    message: Schema.String,
+    status: Schema.optionalKey(Schema.Int),
+    /** The response's `Retry-After`, when it named a delay. */
+    retryAfter: Schema.optionalKey(Schema.Duration),
+    /** The response body, for explicit inspection only. */
+    body: Schema.String.pipe(Schema.Redacted, Schema.optionalKey),
+}) {
+}
+/**
+ * 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 class Remote extends Schema.Error("reactor-effect-client/ReactorError/Remote")({
+    _tag: Schema.Literals(["Remote", "RecorderDisabled"]),
+    message: Schema.String,
+    /** The provider's own error code, verbatim, for explicit inspection only. */
+    remoteCode: Schema.String.pipe(Schema.Redacted, Schema.optionalKey),
+    /** The provider's error text, for explicit inspection only. */
+    body: Schema.String.pipe(Schema.Redacted, Schema.optionalKey),
+}) {
+}
+/** A failure of the native WebRTC addon or its host process. */
+export class Native extends Schema.Error("reactor-effect-client/ReactorError/Native")({
+    _tag: Schema.tag("Native"),
+    message: Schema.String,
+    /** libwebrtc's own text; it can contain peer SDP or signaling material. */
+    backendMessage: Schema.optionalKey(Schema.Redacted(Schema.String, { disallowJsonEncode: true })),
+}) {
+}
+/** No ICE candidate pair worked. */
+export class IceFailed extends Schema.Error("reactor-effect-client/ReactorError/IceFailed")({
+    _tag: Schema.tag("IceFailed"),
+    message: Schema.String,
+    /** Candidate pairs the connection's statistics listed. */
+    pairs: Schema.Int,
+    /** The local candidate types gathered, such as `host` or `relay`. */
+    candidateTypes: Schema.Array(Schema.String),
+}) {
+}
+/** ICE connectivity succeeded and the DTLS or SCTP transport above it failed. */
+export class TransportFailed extends Schema.Error("reactor-effect-client/ReactorError/TransportFailed")({
+    _tag: Schema.tag("TransportFailed"),
+    message: Schema.String,
+    pairs: Schema.Int,
+}) {
+}
+/** A clip ended, by `clip_failed` or `clip_popped`, before it reached the phase awaited. */
+export class ClipEnded extends Schema.Error("reactor-effect-client/ReactorError/ClipEnded")({
+    _tag: Schema.tag("ClipEnded"),
+    message: Schema.String,
+    clipId: Schema.String,
+    lifecycle: Schema.Literals(["clip_failed", "clip_popped"]),
+    /** The transport generation whose evidence ended it. */
+    transportGeneration: Schema.BigInt,
+}) {
+}
+export const ReactorErrorReason = Schema.Union([
+    Failure,
+    Http,
+    Remote,
+    Native,
+    IceFailed,
+    TransportFailed,
+    ClipEnded,
+]);
+/** Whether a remote mutation may have happened: never sent, maybe sent, or answered. */
+export const RemoteOutcome = Schema.Literals(["not-submitted", "unknown", "replied"]);
+export const ErrorContext = Schema.Struct({
+    operation: Schema.optionalKey(Schema.String),
+    requestId: Schema.optionalKey(Schema.String),
+    sessionId: Schema.optionalKey(Schema.String),
+    generation: Schema.optionalKey(Schema.BigInt),
+    outcome: Schema.optionalKey(RemoteOutcome),
+    /** A cause or diagnostic record; it may hold provider or payload text. */
+    detail: Schema.Unknown.pipe(Schema.Redacted, Schema.optionalKey),
+});
+/** Dispatch evidence proving that a request was never handed to the remote. */
+export const NotSubmitted = Schema.Struct({
+    ...ErrorContext.fields,
+    outcome: Schema.Literal("not-submitted"),
+    operation: Schema.String,
+});
+/** A command's dispatch evidence: never sent, or sent with its request identity. */
+export const CommandContext = Schema.Union([
+    NotSubmitted,
+    Schema.Struct({
+        ...ErrorContext.fields,
+        outcome: Schema.Literals(["unknown", "replied"]),
+        operation: Schema.String,
+        requestId: Schema.String,
+        generation: Schema.BigInt,
+    }),
+]);
+const redactErrorContext = (context) => {
+    const { detail, ...rest } = context;
+    if (detail === undefined)
+        return rest;
+    return { ...rest, detail: Redacted.isRedacted(detail) ? detail : Redacted.make(detail) };
+};
+const redactCommandContext = (context) => {
+    const { detail, ...rest } = context;
+    if (detail === undefined)
+        return rest;
+    return { ...rest, detail: Redacted.isRedacted(detail) ? detail : Redacted.make(detail) };
+};
+const reasonFor = (code, message) => {
+    switch (code) {
+        case "Http":
+            return Http.make({ message });
+        case "Remote":
+        case "RecorderDisabled":
+            return Remote.make({ _tag: code, message });
+        case "Native":
+            return Native.make({ message });
+        default:
+            return Failure.make({ _tag: code, message });
+    }
+};
+/**
+ * Whether a later attempt may succeed: backpressure, a lost connection, or an
+ * HTTP refusal for now. Never when the first attempt's outcome is unknown,
+ * since the remote may already have applied it.
+ */
+const retryable = (reason, outcome) => {
+    if (outcome === "unknown")
+        return false;
+    switch (reason._tag) {
+        case "Overflow":
+        case "Disconnected":
+        case "ChannelClosed":
+            return true;
+        case "Http":
+            // Reactor classes a server error as recoverable; a refusal of authority or a conflict is not.
+            return (reason.status === undefined ||
+                reason.status === 408 ||
+                reason.status === 429 ||
+                reason.status >= 500 ||
+                reason.retryAfter !== undefined);
+        default:
+            return false;
+    }
+};
+const retryAfterOf = (reason) => reason._tag === "Http" ? reason.retryAfter : undefined;
+/**
+ * A failure category never implies a mutation was rolled back: inspect
+ * `context.outcome`, and route on `reason._tag`.
+ */
+export class ReactorError extends Schema.TaggedError("reactor-effect-client/ReactorError")("ReactorError", {
+    reason: ReactorErrorReason,
+    context: ErrorContext.pipe(Schema.withConstructorDefault(Effect.succeed({}))),
+}) {
+    [TypeId] = TypeId;
+    /** The reason is library-authored, so it is the native cause. */
+    cause = this.reason;
+    get message() {
+        return this.reason.message;
+    }
+    get isRetryable() {
+        return retryable(this.reason, this.context.outcome);
+    }
+    get retryAfter() {
+        return retryAfterOf(this.reason);
+    }
+    static is(u) {
+        return Predicate.hasProperty(u, TypeId) && Predicate.isTagged(u, "ReactorError");
+    }
+    /** A failure whose reason is `code` with a library-written `message`. */
+    static fromCode(code, message, context = {}) {
+        return ReactorError.make({
+            reason: reasonFor(code, message),
+            context: redactErrorContext(context),
+        });
+    }
+}
+/** Every failed command carries the dispatch evidence its owner established. */
+export class CommandFailure extends Schema.TaggedError("reactor-effect-client/CommandFailure")("CommandFailure", {
+    reason: ReactorErrorReason,
+    context: CommandContext,
+}) {
+    [TypeId] = TypeId;
+    cause = this.reason;
+    get message() {
+        return this.reason.message;
+    }
+    get isRetryable() {
+        return retryable(this.reason, this.context.outcome);
+    }
+    get retryAfter() {
+        return retryAfterOf(this.reason);
+    }
+    static is(u) {
+        return Predicate.hasProperty(u, TypeId) && Predicate.isTagged(u, "CommandFailure");
+    }
+    /** `error`'s reason with the dispatch evidence its command established. */
+    static from(error, context) {
+        return CommandFailure.make({
+            reason: error.reason,
+            context: redactCommandContext(context),
+        });
+    }
+}
+/**
+ * A partial lease's cleanup report. `Session` owns its Schema and imports this
+ * module at run time, so the report is declared here by type alone.
+ */
+const Cleanup = Schema.declare((u) => Predicate.isObject(u), {
+    expected: "CloseReport",
+});
+/** A failed acquisition still returns the lifetime evidence of its partial lease. */
+export class AcquisitionFailure extends Schema.TaggedError("reactor-effect-client/AcquisitionFailure")("AcquisitionFailure", {
+    reason: ReactorErrorReason,
+    context: ErrorContext.pipe(Schema.withConstructorDefault(Effect.succeed({}))),
+    cleanup: Cleanup,
+}) {
+    [TypeId] = TypeId;
+    cause = this.reason;
+    get message() {
+        return this.reason.message;
+    }
+    get isRetryable() {
+        return retryable(this.reason, this.context.outcome);
+    }
+    get retryAfter() {
+        return retryAfterOf(this.reason);
+    }
+    static is(u) {
+        return Predicate.hasProperty(u, TypeId) && Predicate.isTagged(u, "AcquisitionFailure");
+    }
+    /** `error`'s reason and context, with the cleanup its partial lease reported. */
+    static from(error, cleanup) {
+        return AcquisitionFailure.make({ reason: error.reason, context: error.context, cleanup });
+    }
+}
+/**
+ * Whether `u` is one of the client's failures. A passthrough re-raises a known
+ * failure through this guard or a class's `is`, so the evidence a class carries
+ * is kept instead of re-wrapped.
+ */
+export const isReactorFailure = (u) => Predicate.hasProperty(u, TypeId);
+/** A failure as persisted evidence: its routing facts, without any redacted text. */
+export const FailureSummary = Schema.Struct({
+    _tag: Schema.String,
+    reason: Schema.String,
+    message: Schema.String,
+    operation: Schema.optionalKey(Schema.String),
+    requestId: Schema.optionalKey(Schema.String),
+    sessionId: Schema.optionalKey(Schema.String),
+    generation: Schema.optionalKey(Schema.String),
+    outcome: Schema.optionalKey(RemoteOutcome),
+});
+/** The summary of any failure with a tagged reason and a context, the client's or a policy's. */
+export const summarize = (error) => {
+    const { operation, requestId, sessionId, generation, outcome } = error.context;
+    return {
+        _tag: error._tag,
+        reason: error.reason._tag,
+        message: error.message,
+        ...(operation === undefined ? {} : { operation }),
+        ...(requestId === undefined ? {} : { requestId }),
+        ...(sessionId === undefined ? {} : { sessionId }),
+        ...(generation === undefined ? {} : { generation: String(generation) }),
+        ...(outcome === undefined ? {} : { outcome }),
+    };
+};
+//# sourceMappingURL=ReactorError.js.map