@mannyc1/ts-release 0.0.7 → 0.2.2

package/dist/publication/recovery.d.ts

@@ -0,0 +1,663 @@
+import * as Schema from "effect/Schema";
+/** Independent recovery axes. None of these values implies another axis. */
+export declare const ObservationStrength: Schema.Literals<readonly ["exact", "conditional", "none"]>;
+export type ObservationStrength = typeof ObservationStrength.Type;
+export declare const AuthoritativeAbsenceCapability: Schema.Literals<readonly ["proved", "provider-specific", "unavailable"]>;
+export type AuthoritativeAbsenceCapability = typeof AuthoritativeAbsenceCapability.Type;
+export declare const CreateAuthorizationCapability: Schema.Literals<readonly ["none", "authenticated-namespace-and-unique-coordinate"]>;
+export type CreateAuthorizationCapability = typeof CreateAuthorizationCapability.Type;
+export declare const ReplayCapability: Schema.Literals<readonly ["coordinate-unique", "idempotency-key", "conditional", "unsafe"]>;
+export type ReplayCapability = typeof ReplayCapability.Type;
+export declare const IdentifierReuseCapability: Schema.Literals<readonly ["reusable", "consumed-after-delete", "not-applicable"]>;
+export type IdentifierReuseCapability = typeof IdentifierReuseCapability.Type;
+export declare const CorrectionKind: Schema.Literals<readonly ["deprecate", "amend-release-metadata", "yank-file", "forward-catalog-state"]>;
+export type CorrectionKind = typeof CorrectionKind.Type;
+export declare const ExposureCapability: Schema.Literals<readonly ["retractable", "persistent-to-consumers", "append-only"]>;
+export type ExposureCapability = typeof ExposureCapability.Type;
+export declare const HistoryStoreRequirement: Schema.Literals<readonly ["optional-evidence", "durable-cas-required"]>;
+export type HistoryStoreRequirement = typeof HistoryStoreRequirement.Type;
+declare const DocumentedReadConvergenceContract_base: Schema.Class<DocumentedReadConvergenceContract, Schema.TaggedStruct<"documented", {
+    readonly url: Schema.String;
+    readonly date: Schema.String;
+}>, {}>;
+export declare class DocumentedReadConvergenceContract extends DocumentedReadConvergenceContract_base {
+}
+declare const AssumedReadConvergenceContract_base: Schema.Class<AssumedReadConvergenceContract, Schema.TaggedStruct<"assumed", {
+    readonly basis: Schema.brand<Schema.String, "SafeReason">;
+}>, {}>;
+export declare class AssumedReadConvergenceContract extends AssumedReadConvergenceContract_base {
+}
+declare const UnknownReadConvergenceContract_base: Schema.Class<UnknownReadConvergenceContract, Schema.TaggedStruct<"unknown", {}>, {}>;
+export declare class UnknownReadConvergenceContract extends UnknownReadConvergenceContract_base {
+}
+export declare const ReadConvergenceContract: Schema.Union<readonly [typeof DocumentedReadConvergenceContract, typeof AssumedReadConvergenceContract, typeof UnknownReadConvergenceContract]>;
+export type ReadConvergenceContract = typeof ReadConvergenceContract.Type;
+declare const ObservationRetryBackoff_base: Schema.Class<ObservationRetryBackoff, Schema.Struct<{
+    readonly baseMs: Schema.Number;
+    readonly factor: Schema.Number;
+    readonly capMs: Schema.Number;
+}>, {}>;
+export declare class ObservationRetryBackoff extends ObservationRetryBackoff_base {
+}
+declare const ObservationRetryRecord_base: Schema.Class<ObservationRetryRecord, Schema.Struct<{
+    readonly maxAttempts: Schema.Number;
+    readonly backoff: typeof ObservationRetryBackoff;
+    readonly totalBudgetMs: Schema.Number;
+}>, {}>;
+declare class ObservationRetryRecord extends ObservationRetryRecord_base {
+}
+export declare const ObservationRetry: Schema.decodeTo<Schema.declareConstructor<ObservationRetryRecord, {
+    readonly maxAttempts: number;
+    readonly backoff: {
+        readonly baseMs: number;
+        readonly factor: number;
+        readonly capMs: number;
+    };
+    readonly totalBudgetMs: number;
+}, readonly [Schema.Struct<{
+    readonly maxAttempts: Schema.Number;
+    readonly backoff: typeof ObservationRetryBackoff;
+    readonly totalBudgetMs: Schema.Number;
+}>], {
+    readonly maxAttempts: number;
+    readonly backoff: {
+        readonly baseMs: number;
+        readonly factor: number;
+        readonly capMs: number;
+    };
+    readonly totalBudgetMs: number;
+}>, Schema.Struct<{
+    readonly maxAttempts: Schema.Number;
+    readonly backoff: typeof ObservationRetryBackoff;
+    readonly totalBudgetMs: Schema.Number;
+}>, never, never>;
+export type ObservationRetry = typeof ObservationRetry.Type;
+export declare const RetryEligible: Schema.Literal<"VisibilityPending | Inconclusive">;
+export type RetryEligible = typeof RetryEligible.Type;
+export declare const RetryExhaustion: Schema.Literal<"UncertainSubject with full trace">;
+export type RetryExhaustion = typeof RetryExhaustion.Type;
+declare const ReadConvergenceProfileRecord_base: Schema.Class<ReadConvergenceProfileRecord, Schema.Struct<{
+    readonly contract: Schema.Union<readonly [typeof DocumentedReadConvergenceContract, typeof AssumedReadConvergenceContract, typeof UnknownReadConvergenceContract]>;
+    readonly observationRetry: Schema.decodeTo<Schema.declareConstructor<ObservationRetryRecord, {
+        readonly maxAttempts: number;
+        readonly backoff: {
+            readonly baseMs: number;
+            readonly factor: number;
+            readonly capMs: number;
+        };
+        readonly totalBudgetMs: number;
+    }, readonly [Schema.Struct<{
+        readonly maxAttempts: Schema.Number;
+        readonly backoff: typeof ObservationRetryBackoff;
+        readonly totalBudgetMs: Schema.Number;
+    }>], {
+        readonly maxAttempts: number;
+        readonly backoff: {
+            readonly baseMs: number;
+            readonly factor: number;
+            readonly capMs: number;
+        };
+        readonly totalBudgetMs: number;
+    }>, Schema.Struct<{
+        readonly maxAttempts: Schema.Number;
+        readonly backoff: typeof ObservationRetryBackoff;
+        readonly totalBudgetMs: Schema.Number;
+    }>, never, never>;
+    readonly retryEligible: Schema.Literal<"VisibilityPending | Inconclusive">;
+    readonly exhaustion: Schema.Literal<"UncertainSubject with full trace">;
+}>, {}>;
+declare class ReadConvergenceProfileRecord extends ReadConvergenceProfileRecord_base {
+}
+export declare const ReadConvergenceProfile: Schema.decodeTo<Schema.declareConstructor<ReadConvergenceProfileRecord, {
+    readonly contract: {
+        readonly _tag: "documented";
+        readonly url: string;
+        readonly date: string;
+    } | {
+        readonly _tag: "assumed";
+        readonly basis: string;
+    } | {
+        readonly _tag: "unknown";
+    };
+    readonly observationRetry: {
+        readonly maxAttempts: number;
+        readonly backoff: {
+            readonly baseMs: number;
+            readonly factor: number;
+            readonly capMs: number;
+        };
+        readonly totalBudgetMs: number;
+    };
+    readonly retryEligible: "VisibilityPending | Inconclusive";
+    readonly exhaustion: "UncertainSubject with full trace";
+}, readonly [Schema.Struct<{
+    readonly contract: Schema.Union<readonly [typeof DocumentedReadConvergenceContract, typeof AssumedReadConvergenceContract, typeof UnknownReadConvergenceContract]>;
+    readonly observationRetry: Schema.decodeTo<Schema.declareConstructor<ObservationRetryRecord, {
+        readonly maxAttempts: number;
+        readonly backoff: {
+            readonly baseMs: number;
+            readonly factor: number;
+            readonly capMs: number;
+        };
+        readonly totalBudgetMs: number;
+    }, readonly [Schema.Struct<{
+        readonly maxAttempts: Schema.Number;
+        readonly backoff: typeof ObservationRetryBackoff;
+        readonly totalBudgetMs: Schema.Number;
+    }>], {
+        readonly maxAttempts: number;
+        readonly backoff: {
+            readonly baseMs: number;
+            readonly factor: number;
+            readonly capMs: number;
+        };
+        readonly totalBudgetMs: number;
+    }>, Schema.Struct<{
+        readonly maxAttempts: Schema.Number;
+        readonly backoff: typeof ObservationRetryBackoff;
+        readonly totalBudgetMs: Schema.Number;
+    }>, never, never>;
+    readonly retryEligible: Schema.Literal<"VisibilityPending | Inconclusive">;
+    readonly exhaustion: Schema.Literal<"UncertainSubject with full trace">;
+}>], {
+    readonly contract: {
+        readonly _tag: "documented";
+        readonly url: string;
+        readonly date: string;
+    } | {
+        readonly _tag: "assumed";
+        readonly basis: string & import("effect/Brand").Brand<"SafeReason">;
+    } | {
+        readonly _tag: "unknown";
+    };
+    readonly observationRetry: {
+        readonly maxAttempts: number;
+        readonly backoff: {
+            readonly baseMs: number;
+            readonly factor: number;
+            readonly capMs: number;
+        };
+        readonly totalBudgetMs: number;
+    };
+    readonly retryEligible: "VisibilityPending | Inconclusive";
+    readonly exhaustion: "UncertainSubject with full trace";
+}>, Schema.Struct<{
+    readonly contract: Schema.Union<readonly [typeof DocumentedReadConvergenceContract, typeof AssumedReadConvergenceContract, typeof UnknownReadConvergenceContract]>;
+    readonly observationRetry: Schema.decodeTo<Schema.declareConstructor<ObservationRetryRecord, {
+        readonly maxAttempts: number;
+        readonly backoff: {
+            readonly baseMs: number;
+            readonly factor: number;
+            readonly capMs: number;
+        };
+        readonly totalBudgetMs: number;
+    }, readonly [Schema.Struct<{
+        readonly maxAttempts: Schema.Number;
+        readonly backoff: typeof ObservationRetryBackoff;
+        readonly totalBudgetMs: Schema.Number;
+    }>], {
+        readonly maxAttempts: number;
+        readonly backoff: {
+            readonly baseMs: number;
+            readonly factor: number;
+            readonly capMs: number;
+        };
+        readonly totalBudgetMs: number;
+    }>, Schema.Struct<{
+        readonly maxAttempts: Schema.Number;
+        readonly backoff: typeof ObservationRetryBackoff;
+        readonly totalBudgetMs: Schema.Number;
+    }>, never, never>;
+    readonly retryEligible: Schema.Literal<"VisibilityPending | Inconclusive">;
+    readonly exhaustion: Schema.Literal<"UncertainSubject with full trace">;
+}>, never, never>;
+export type ReadConvergenceProfile = typeof ReadConvergenceProfile.Type;
+declare const RecoveryCapabilityProfileRecord_base: Schema.Class<RecoveryCapabilityProfileRecord, Schema.Struct<{
+    readonly observation: Schema.Literals<readonly ["exact", "conditional", "none"]>;
+    readonly authoritativeAbsence: Schema.Literals<readonly ["proved", "provider-specific", "unavailable"]>;
+    readonly createAuthorization: Schema.Literals<readonly ["none", "authenticated-namespace-and-unique-coordinate"]>;
+    readonly replay: Schema.Literals<readonly ["coordinate-unique", "idempotency-key", "conditional", "unsafe"]>;
+    readonly identifierReuse: Schema.Literals<readonly ["reusable", "consumed-after-delete", "not-applicable"]>;
+    readonly correction: Schema.$Array<Schema.Literals<readonly ["deprecate", "amend-release-metadata", "yank-file", "forward-catalog-state"]>>;
+    readonly exposure: Schema.Literals<readonly ["retractable", "persistent-to-consumers", "append-only"]>;
+    readonly historyRequirement: Schema.Literals<readonly ["optional-evidence", "durable-cas-required"]>;
+    readonly readConvergence: Schema.decodeTo<Schema.declareConstructor<ReadConvergenceProfileRecord, {
+        readonly contract: {
+            readonly _tag: "documented";
+            readonly url: string;
+            readonly date: string;
+        } | {
+            readonly _tag: "assumed";
+            readonly basis: string;
+        } | {
+            readonly _tag: "unknown";
+        };
+        readonly observationRetry: {
+            readonly maxAttempts: number;
+            readonly backoff: {
+                readonly baseMs: number;
+                readonly factor: number;
+                readonly capMs: number;
+            };
+            readonly totalBudgetMs: number;
+        };
+        readonly retryEligible: "VisibilityPending | Inconclusive";
+        readonly exhaustion: "UncertainSubject with full trace";
+    }, readonly [Schema.Struct<{
+        readonly contract: Schema.Union<readonly [typeof DocumentedReadConvergenceContract, typeof AssumedReadConvergenceContract, typeof UnknownReadConvergenceContract]>;
+        readonly observationRetry: Schema.decodeTo<Schema.declareConstructor<ObservationRetryRecord, {
+            readonly maxAttempts: number;
+            readonly backoff: {
+                readonly baseMs: number;
+                readonly factor: number;
+                readonly capMs: number;
+            };
+            readonly totalBudgetMs: number;
+        }, readonly [Schema.Struct<{
+            readonly maxAttempts: Schema.Number;
+            readonly backoff: typeof ObservationRetryBackoff;
+            readonly totalBudgetMs: Schema.Number;
+        }>], {
+            readonly maxAttempts: number;
+            readonly backoff: {
+                readonly baseMs: number;
+                readonly factor: number;
+                readonly capMs: number;
+            };
+            readonly totalBudgetMs: number;
+        }>, Schema.Struct<{
+            readonly maxAttempts: Schema.Number;
+            readonly backoff: typeof ObservationRetryBackoff;
+            readonly totalBudgetMs: Schema.Number;
+        }>, never, never>;
+        readonly retryEligible: Schema.Literal<"VisibilityPending | Inconclusive">;
+        readonly exhaustion: Schema.Literal<"UncertainSubject with full trace">;
+    }>], {
+        readonly contract: {
+            readonly _tag: "documented";
+            readonly url: string;
+            readonly date: string;
+        } | {
+            readonly _tag: "assumed";
+            readonly basis: string & import("effect/Brand").Brand<"SafeReason">;
+        } | {
+            readonly _tag: "unknown";
+        };
+        readonly observationRetry: {
+            readonly maxAttempts: number;
+            readonly backoff: {
+                readonly baseMs: number;
+                readonly factor: number;
+                readonly capMs: number;
+            };
+            readonly totalBudgetMs: number;
+        };
+        readonly retryEligible: "VisibilityPending | Inconclusive";
+        readonly exhaustion: "UncertainSubject with full trace";
+    }>, Schema.Struct<{
+        readonly contract: Schema.Union<readonly [typeof DocumentedReadConvergenceContract, typeof AssumedReadConvergenceContract, typeof UnknownReadConvergenceContract]>;
+        readonly observationRetry: Schema.decodeTo<Schema.declareConstructor<ObservationRetryRecord, {
+            readonly maxAttempts: number;
+            readonly backoff: {
+                readonly baseMs: number;
+                readonly factor: number;
+                readonly capMs: number;
+            };
+            readonly totalBudgetMs: number;
+        }, readonly [Schema.Struct<{
+            readonly maxAttempts: Schema.Number;
+            readonly backoff: typeof ObservationRetryBackoff;
+            readonly totalBudgetMs: Schema.Number;
+        }>], {
+            readonly maxAttempts: number;
+            readonly backoff: {
+                readonly baseMs: number;
+                readonly factor: number;
+                readonly capMs: number;
+            };
+            readonly totalBudgetMs: number;
+        }>, Schema.Struct<{
+            readonly maxAttempts: Schema.Number;
+            readonly backoff: typeof ObservationRetryBackoff;
+            readonly totalBudgetMs: Schema.Number;
+        }>, never, never>;
+        readonly retryEligible: Schema.Literal<"VisibilityPending | Inconclusive">;
+        readonly exhaustion: Schema.Literal<"UncertainSubject with full trace">;
+    }>, never, never>;
+}>, {}>;
+declare class RecoveryCapabilityProfileRecord extends RecoveryCapabilityProfileRecord_base {
+}
+export declare const RecoveryCapabilityProfile: Schema.decodeTo<Schema.declareConstructor<RecoveryCapabilityProfileRecord, {
+    readonly observation: "exact" | "none" | "conditional";
+    readonly authoritativeAbsence: "proved" | "provider-specific" | "unavailable";
+    readonly createAuthorization: "none" | "authenticated-namespace-and-unique-coordinate";
+    readonly replay: "conditional" | "coordinate-unique" | "idempotency-key" | "unsafe";
+    readonly identifierReuse: "reusable" | "consumed-after-delete" | "not-applicable";
+    readonly correction: readonly ("deprecate" | "amend-release-metadata" | "forward-catalog-state" | "yank-file")[];
+    readonly exposure: "retractable" | "persistent-to-consumers" | "append-only";
+    readonly historyRequirement: "optional-evidence" | "durable-cas-required";
+    readonly readConvergence: {
+        readonly contract: {
+            readonly _tag: "documented";
+            readonly url: string;
+            readonly date: string;
+        } | {
+            readonly _tag: "assumed";
+            readonly basis: string;
+        } | {
+            readonly _tag: "unknown";
+        };
+        readonly observationRetry: {
+            readonly maxAttempts: number;
+            readonly backoff: {
+                readonly baseMs: number;
+                readonly factor: number;
+                readonly capMs: number;
+            };
+            readonly totalBudgetMs: number;
+        };
+        readonly retryEligible: "VisibilityPending | Inconclusive";
+        readonly exhaustion: "UncertainSubject with full trace";
+    };
+}, readonly [Schema.Struct<{
+    readonly observation: Schema.Literals<readonly ["exact", "conditional", "none"]>;
+    readonly authoritativeAbsence: Schema.Literals<readonly ["proved", "provider-specific", "unavailable"]>;
+    readonly createAuthorization: Schema.Literals<readonly ["none", "authenticated-namespace-and-unique-coordinate"]>;
+    readonly replay: Schema.Literals<readonly ["coordinate-unique", "idempotency-key", "conditional", "unsafe"]>;
+    readonly identifierReuse: Schema.Literals<readonly ["reusable", "consumed-after-delete", "not-applicable"]>;
+    readonly correction: Schema.$Array<Schema.Literals<readonly ["deprecate", "amend-release-metadata", "yank-file", "forward-catalog-state"]>>;
+    readonly exposure: Schema.Literals<readonly ["retractable", "persistent-to-consumers", "append-only"]>;
+    readonly historyRequirement: Schema.Literals<readonly ["optional-evidence", "durable-cas-required"]>;
+    readonly readConvergence: Schema.decodeTo<Schema.declareConstructor<ReadConvergenceProfileRecord, {
+        readonly contract: {
+            readonly _tag: "documented";
+            readonly url: string;
+            readonly date: string;
+        } | {
+            readonly _tag: "assumed";
+            readonly basis: string;
+        } | {
+            readonly _tag: "unknown";
+        };
+        readonly observationRetry: {
+            readonly maxAttempts: number;
+            readonly backoff: {
+                readonly baseMs: number;
+                readonly factor: number;
+                readonly capMs: number;
+            };
+            readonly totalBudgetMs: number;
+        };
+        readonly retryEligible: "VisibilityPending | Inconclusive";
+        readonly exhaustion: "UncertainSubject with full trace";
+    }, readonly [Schema.Struct<{
+        readonly contract: Schema.Union<readonly [typeof DocumentedReadConvergenceContract, typeof AssumedReadConvergenceContract, typeof UnknownReadConvergenceContract]>;
+        readonly observationRetry: Schema.decodeTo<Schema.declareConstructor<ObservationRetryRecord, {
+            readonly maxAttempts: number;
+            readonly backoff: {
+                readonly baseMs: number;
+                readonly factor: number;
+                readonly capMs: number;
+            };
+            readonly totalBudgetMs: number;
+        }, readonly [Schema.Struct<{
+            readonly maxAttempts: Schema.Number;
+            readonly backoff: typeof ObservationRetryBackoff;
+            readonly totalBudgetMs: Schema.Number;
+        }>], {
+            readonly maxAttempts: number;
+            readonly backoff: {
+                readonly baseMs: number;
+                readonly factor: number;
+                readonly capMs: number;
+            };
+            readonly totalBudgetMs: number;
+        }>, Schema.Struct<{
+            readonly maxAttempts: Schema.Number;
+            readonly backoff: typeof ObservationRetryBackoff;
+            readonly totalBudgetMs: Schema.Number;
+        }>, never, never>;
+        readonly retryEligible: Schema.Literal<"VisibilityPending | Inconclusive">;
+        readonly exhaustion: Schema.Literal<"UncertainSubject with full trace">;
+    }>], {
+        readonly contract: {
+            readonly _tag: "documented";
+            readonly url: string;
+            readonly date: string;
+        } | {
+            readonly _tag: "assumed";
+            readonly basis: string & import("effect/Brand").Brand<"SafeReason">;
+        } | {
+            readonly _tag: "unknown";
+        };
+        readonly observationRetry: {
+            readonly maxAttempts: number;
+            readonly backoff: {
+                readonly baseMs: number;
+                readonly factor: number;
+                readonly capMs: number;
+            };
+            readonly totalBudgetMs: number;
+        };
+        readonly retryEligible: "VisibilityPending | Inconclusive";
+        readonly exhaustion: "UncertainSubject with full trace";
+    }>, Schema.Struct<{
+        readonly contract: Schema.Union<readonly [typeof DocumentedReadConvergenceContract, typeof AssumedReadConvergenceContract, typeof UnknownReadConvergenceContract]>;
+        readonly observationRetry: Schema.decodeTo<Schema.declareConstructor<ObservationRetryRecord, {
+            readonly maxAttempts: number;
+            readonly backoff: {
+                readonly baseMs: number;
+                readonly factor: number;
+                readonly capMs: number;
+            };
+            readonly totalBudgetMs: number;
+        }, readonly [Schema.Struct<{
+            readonly maxAttempts: Schema.Number;
+            readonly backoff: typeof ObservationRetryBackoff;
+            readonly totalBudgetMs: Schema.Number;
+        }>], {
+            readonly maxAttempts: number;
+            readonly backoff: {
+                readonly baseMs: number;
+                readonly factor: number;
+                readonly capMs: number;
+            };
+            readonly totalBudgetMs: number;
+        }>, Schema.Struct<{
+            readonly maxAttempts: Schema.Number;
+            readonly backoff: typeof ObservationRetryBackoff;
+            readonly totalBudgetMs: Schema.Number;
+        }>, never, never>;
+        readonly retryEligible: Schema.Literal<"VisibilityPending | Inconclusive">;
+        readonly exhaustion: Schema.Literal<"UncertainSubject with full trace">;
+    }>, never, never>;
+}>], {
+    readonly observation: "exact" | "none" | "conditional";
+    readonly authoritativeAbsence: "proved" | "provider-specific" | "unavailable";
+    readonly createAuthorization: "none" | "authenticated-namespace-and-unique-coordinate";
+    readonly replay: "conditional" | "coordinate-unique" | "idempotency-key" | "unsafe";
+    readonly identifierReuse: "reusable" | "consumed-after-delete" | "not-applicable";
+    readonly correction: readonly ("deprecate" | "amend-release-metadata" | "forward-catalog-state" | "yank-file")[];
+    readonly exposure: "retractable" | "persistent-to-consumers" | "append-only";
+    readonly historyRequirement: "optional-evidence" | "durable-cas-required";
+    readonly readConvergence: {
+        readonly contract: {
+            readonly _tag: "documented";
+            readonly url: string;
+            readonly date: string;
+        } | {
+            readonly _tag: "assumed";
+            readonly basis: string & import("effect/Brand").Brand<"SafeReason">;
+        } | {
+            readonly _tag: "unknown";
+        };
+        readonly observationRetry: {
+            readonly maxAttempts: number;
+            readonly backoff: {
+                readonly baseMs: number;
+                readonly factor: number;
+                readonly capMs: number;
+            };
+            readonly totalBudgetMs: number;
+        };
+        readonly retryEligible: "VisibilityPending | Inconclusive";
+        readonly exhaustion: "UncertainSubject with full trace";
+    };
+}>, Schema.Struct<{
+    readonly observation: Schema.Literals<readonly ["exact", "conditional", "none"]>;
+    readonly authoritativeAbsence: Schema.Literals<readonly ["proved", "provider-specific", "unavailable"]>;
+    readonly createAuthorization: Schema.Literals<readonly ["none", "authenticated-namespace-and-unique-coordinate"]>;
+    readonly replay: Schema.Literals<readonly ["coordinate-unique", "idempotency-key", "conditional", "unsafe"]>;
+    readonly identifierReuse: Schema.Literals<readonly ["reusable", "consumed-after-delete", "not-applicable"]>;
+    readonly correction: Schema.$Array<Schema.Literals<readonly ["deprecate", "amend-release-metadata", "yank-file", "forward-catalog-state"]>>;
+    readonly exposure: Schema.Literals<readonly ["retractable", "persistent-to-consumers", "append-only"]>;
+    readonly historyRequirement: Schema.Literals<readonly ["optional-evidence", "durable-cas-required"]>;
+    readonly readConvergence: Schema.decodeTo<Schema.declareConstructor<ReadConvergenceProfileRecord, {
+        readonly contract: {
+            readonly _tag: "documented";
+            readonly url: string;
+            readonly date: string;
+        } | {
+            readonly _tag: "assumed";
+            readonly basis: string;
+        } | {
+            readonly _tag: "unknown";
+        };
+        readonly observationRetry: {
+            readonly maxAttempts: number;
+            readonly backoff: {
+                readonly baseMs: number;
+                readonly factor: number;
+                readonly capMs: number;
+            };
+            readonly totalBudgetMs: number;
+        };
+        readonly retryEligible: "VisibilityPending | Inconclusive";
+        readonly exhaustion: "UncertainSubject with full trace";
+    }, readonly [Schema.Struct<{
+        readonly contract: Schema.Union<readonly [typeof DocumentedReadConvergenceContract, typeof AssumedReadConvergenceContract, typeof UnknownReadConvergenceContract]>;
+        readonly observationRetry: Schema.decodeTo<Schema.declareConstructor<ObservationRetryRecord, {
+            readonly maxAttempts: number;
+            readonly backoff: {
+                readonly baseMs: number;
+                readonly factor: number;
+                readonly capMs: number;
+            };
+            readonly totalBudgetMs: number;
+        }, readonly [Schema.Struct<{
+            readonly maxAttempts: Schema.Number;
+            readonly backoff: typeof ObservationRetryBackoff;
+            readonly totalBudgetMs: Schema.Number;
+        }>], {
+            readonly maxAttempts: number;
+            readonly backoff: {
+                readonly baseMs: number;
+                readonly factor: number;
+                readonly capMs: number;
+            };
+            readonly totalBudgetMs: number;
+        }>, Schema.Struct<{
+            readonly maxAttempts: Schema.Number;
+            readonly backoff: typeof ObservationRetryBackoff;
+            readonly totalBudgetMs: Schema.Number;
+        }>, never, never>;
+        readonly retryEligible: Schema.Literal<"VisibilityPending | Inconclusive">;
+        readonly exhaustion: Schema.Literal<"UncertainSubject with full trace">;
+    }>], {
+        readonly contract: {
+            readonly _tag: "documented";
+            readonly url: string;
+            readonly date: string;
+        } | {
+            readonly _tag: "assumed";
+            readonly basis: string & import("effect/Brand").Brand<"SafeReason">;
+        } | {
+            readonly _tag: "unknown";
+        };
+        readonly observationRetry: {
+            readonly maxAttempts: number;
+            readonly backoff: {
+                readonly baseMs: number;
+                readonly factor: number;
+                readonly capMs: number;
+            };
+            readonly totalBudgetMs: number;
+        };
+        readonly retryEligible: "VisibilityPending | Inconclusive";
+        readonly exhaustion: "UncertainSubject with full trace";
+    }>, Schema.Struct<{
+        readonly contract: Schema.Union<readonly [typeof DocumentedReadConvergenceContract, typeof AssumedReadConvergenceContract, typeof UnknownReadConvergenceContract]>;
+        readonly observationRetry: Schema.decodeTo<Schema.declareConstructor<ObservationRetryRecord, {
+            readonly maxAttempts: number;
+            readonly backoff: {
+                readonly baseMs: number;
+                readonly factor: number;
+                readonly capMs: number;
+            };
+            readonly totalBudgetMs: number;
+        }, readonly [Schema.Struct<{
+            readonly maxAttempts: Schema.Number;
+            readonly backoff: typeof ObservationRetryBackoff;
+            readonly totalBudgetMs: Schema.Number;
+        }>], {
+            readonly maxAttempts: number;
+            readonly backoff: {
+                readonly baseMs: number;
+                readonly factor: number;
+                readonly capMs: number;
+            };
+            readonly totalBudgetMs: number;
+        }>, Schema.Struct<{
+            readonly maxAttempts: Schema.Number;
+            readonly backoff: typeof ObservationRetryBackoff;
+            readonly totalBudgetMs: Schema.Number;
+        }>, never, never>;
+        readonly retryEligible: Schema.Literal<"VisibilityPending | Inconclusive">;
+        readonly exhaustion: Schema.Literal<"UncertainSubject with full trace">;
+    }>, never, never>;
+}>, never, never>;
+export type RecoveryCapabilityProfile = typeof RecoveryCapabilityProfile.Type;
+/**
+ * One executable publication adapter and the durable recovery profile it
+ * promises to honor. `correctionAdapters` names only actually installed
+ * conditional correction implementations; an authored operator proposal is
+ * not an adapter.
+ */
+export interface PublicationProfileRegistration {
+    readonly id: string;
+    readonly provider: string;
+    readonly preparedTag: string;
+    readonly recovery: RecoveryCapabilityProfile;
+    readonly correctionAdapters: ReadonlyArray<CorrectionKind>;
+    readonly evidence: {
+        readonly reviewedAt: string;
+        readonly observationSources: ReadonlyArray<string>;
+        readonly correctionSources: ReadonlyArray<string>;
+        readonly correctionFinding: string;
+    };
+}
+declare const RecoveryProfileRegistrationError_base: Schema.Class<RecoveryProfileRegistrationError, Schema.TaggedStruct<"RecoveryProfileRegistrationError", {
+    readonly registration: Schema.NonEmptyString;
+    readonly reason: Schema.brand<Schema.String, "SafeReason">;
+}>, import("effect/Cause").YieldableError>;
+export declare class RecoveryProfileRegistrationError extends RecoveryProfileRegistrationError_base {
+}
+/** Canonical profile bytes are shared by registration checks and generators. */
+export declare const encodeRecoveryCapabilityProfile: (value: unknown) => string;
+export declare const recoveryCapabilityProfilesEqual: (left: unknown, right: unknown) => boolean;
+/**
+ * Fail module registration before any provider operation when the declared
+ * profile or installed correction behavior is incoherent.
+ */
+export declare const validatePublicationProfiles: <const Profiles extends Readonly<Record<string, PublicationProfileRegistration>>>(profiles: Profiles) => Profiles;
+/** Refuse a subject factory whose executable subject advertises another policy. */
+export declare const assertRecoveryProfileMatches: (registration: string, expected: RecoveryCapabilityProfile, actual: unknown) => void;
+export declare const validateRecoveryProfileSubjects: (registration: string, expected: RecoveryCapabilityProfile, actualProfiles: ReadonlyArray<unknown>) => void;
+/** Decode at module/registration boundaries so malformed policies never run. */
+export declare const makeRecoveryCapabilityProfile: (value: unknown) => RecoveryCapabilityProfile;
+/** Unknown provider timing permits the mandatory first reread and nothing else. */
+export declare const conservativeUnknownRecoveryProfile: RecoveryCapabilityProfileRecord;
+/** Additional reads are permitted only when their timing basis is explicit. */
+export declare const isReadConvergenceLagCapable: (profile: RecoveryCapabilityProfile) => boolean;
+export {};
+//# sourceMappingURL=recovery.d.ts.map

package/dist/publication/recovery.d.ts.map

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