@mannyc1/ts-release 0.0.6 → 0.2.2

package/dist/publication/coordinator.d.ts

@@ -0,0 +1,246 @@
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { SubjectId, type CredentialRequest } from "../model/authority.js";
+import { CredentialProvider, type CredentialGrant, type MutationCredentialGrant } from "./authority.js";
+import { ConclusiveProviderRejection, DependencyBlocked, InconclusiveObservation, ObservedSubject, OutcomeUnknown, PresentEquivalent, ProviderBlocked, RejectedBeforeDispatch, Started, type Applied, type MutationAttempt, type MutationDecision, type Observation, type ProviderDecision, type RejectedByProvider } from "./report.js";
+import { type RecoveryCapabilityProfile as RecoveryCapabilityProfileType } from "./recovery.js";
+declare const ReleaseSubjectError_base: Schema.Class<ReleaseSubjectError, Schema.TaggedStruct<"ReleaseSubjectError", {
+    readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+    readonly phase: Schema.Literals<readonly ["observe", "mutate"]>;
+    readonly commitment: Schema.Literals<readonly ["before-dispatch", "unknown"]>;
+    readonly reason: Schema.brand<Schema.String, "SafeReason">;
+}>, import("effect/Cause").YieldableError>;
+export declare class ReleaseSubjectError extends ReleaseSubjectError_base {
+}
+declare const ReleaseCoordinatorConstructionError_base: Schema.Class<ReleaseCoordinatorConstructionError, Schema.TaggedStruct<"ReleaseCoordinatorConstructionError", {
+    readonly reason: Schema.brand<Schema.String, "SafeReason">;
+}>, import("effect/Cause").YieldableError>;
+export declare class ReleaseCoordinatorConstructionError extends ReleaseCoordinatorConstructionError_base {
+}
+/** Provider-neutral subject derived from one verified prepared intent. */
+export type ReleaseObservationContext = {
+    readonly phase: "pre-mutation";
+} | {
+    readonly phase: "post-mutation";
+    readonly attempt: MutationAttempt;
+};
+export interface ReleaseSubject {
+    readonly id: SubjectId;
+    /** Durable provider policy. Coordinator retries are derived only from this value. */
+    readonly recovery: RecoveryCapabilityProfileType;
+    /** Earlier prepared subjects that must converge before this subject may run. */
+    readonly prerequisites?: ReadonlyArray<SubjectId>;
+    readonly observationRequests: readonly [CredentialRequest, ...Array<CredentialRequest>];
+    readonly mutationRequest: CredentialRequest;
+    /** Required by every durable-cas-required recovery profile. Runs before mutation authority acquisition. */
+    readonly claimMutation?: (decision: MutationDecision) => Effect.Effect<void, ReleaseSubjectError>;
+    readonly observe: (grant: CredentialGrant, context: ReleaseObservationContext) => Effect.Effect<Observation, ReleaseSubjectError>;
+    readonly decide: (observation: Observation) => ProviderDecision;
+    readonly mutate: (decision: MutationDecision, grant: MutationCredentialGrant) => Effect.Effect<MutationAttempt, ReleaseSubjectError>;
+}
+export interface ReleaseSubjectsInput {
+    /** Local, already-verified prepared identity; always makes the report nonempty. */
+    readonly prepared: SubjectId;
+    /** Dependency-ordered remote subjects. */
+    readonly subjects: ReadonlyArray<ReleaseSubject>;
+}
+/** Read-only projection. It never asks for publish or correction authority. */
+export declare const observeReleaseSubjects: (input: ReleaseSubjectsInput) => Effect.Effect<{
+    readonly subjects: readonly [ObservedSubject, ...ObservedSubject[]];
+    readonly status: "equivalent" | "different" | "inconclusive";
+}, ReleaseCoordinatorConstructionError, CredentialProvider>;
+/** Dependency-ordered observation, lazy authority, mutation, and reobservation. */
+export declare const publishReleaseSubjects: (input: ReleaseSubjectsInput) => Effect.Effect<{
+    readonly subjects: readonly [{
+        readonly _tag: "NotReached";
+        readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+        readonly reason: DependencyBlocked | import("./report.js").RunAborted;
+    } | {
+        readonly _tag: "AlreadyEquivalent";
+        readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+        readonly observationAuthorities: readonly {
+            readonly _tag: "AuthorityAcquired";
+            readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+            readonly provider: string & import("effect/Brand").Brand<"ProviderId">;
+            readonly audience: string & import("effect/Brand").Brand<"CanonicalAudience">;
+            readonly requestedPurpose: "observe" | "publish" | "correct";
+            readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+            readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+        }[];
+        readonly observations: readonly [PresentEquivalent | import("./report.js").PresentDifferent | import("./report.js").AuthoritativelyAbsent | import("./report.js").VisibilityPending | InconclusiveObservation, ...(PresentEquivalent | import("./report.js").PresentDifferent | import("./report.js").AuthoritativelyAbsent | import("./report.js").VisibilityPending | InconclusiveObservation)[]];
+    } | {
+        readonly _tag: "ConvergedAfterMutation";
+        readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+        readonly observationAuthorities: readonly {
+            readonly _tag: "AuthorityAcquired";
+            readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+            readonly provider: string & import("effect/Brand").Brand<"ProviderId">;
+            readonly audience: string & import("effect/Brand").Brand<"CanonicalAudience">;
+            readonly requestedPurpose: "observe" | "publish" | "correct";
+            readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+            readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+        }[];
+        readonly preObservations: readonly [PresentEquivalent | import("./report.js").PresentDifferent | import("./report.js").AuthoritativelyAbsent | import("./report.js").VisibilityPending | InconclusiveObservation, ...(PresentEquivalent | import("./report.js").PresentDifferent | import("./report.js").AuthoritativelyAbsent | import("./report.js").VisibilityPending | InconclusiveObservation)[]];
+        readonly decision: import("./report.js").NeedsMutation | import("./report.js").ProviderAuthorizedCreate;
+        readonly authority: {
+            readonly _tag: "AuthorityAcquired";
+            readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+            readonly provider: string & import("effect/Brand").Brand<"ProviderId">;
+            readonly audience: string & import("effect/Brand").Brand<"CanonicalAudience">;
+            readonly requestedPurpose: "observe" | "publish" | "correct";
+            readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+            readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+        };
+        readonly attempt: RejectedByProvider | Applied | OutcomeUnknown;
+        readonly postObservations: readonly [PresentEquivalent | import("./report.js").PresentDifferent | import("./report.js").AuthoritativelyAbsent | import("./report.js").VisibilityPending | InconclusiveObservation, ...(PresentEquivalent | import("./report.js").PresentDifferent | import("./report.js").AuthoritativelyAbsent | import("./report.js").VisibilityPending | InconclusiveObservation)[]];
+    } | {
+        readonly _tag: "BlockedSubject";
+        readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+        readonly observationAuthorities: readonly {
+            readonly _tag: "AuthorityAcquired";
+            readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+            readonly provider: string & import("effect/Brand").Brand<"ProviderId">;
+            readonly audience: string & import("effect/Brand").Brand<"CanonicalAudience">;
+            readonly requestedPurpose: "observe" | "publish" | "correct";
+            readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+            readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+        }[];
+        readonly observations: readonly [PresentEquivalent | import("./report.js").PresentDifferent | import("./report.js").AuthoritativelyAbsent | import("./report.js").VisibilityPending | InconclusiveObservation, ...(PresentEquivalent | import("./report.js").PresentDifferent | import("./report.js").AuthoritativelyAbsent | import("./report.js").VisibilityPending | InconclusiveObservation)[]];
+        readonly cause: import("./report.js").Conflict | ProviderBlocked | RejectedBeforeDispatch | {
+            readonly _tag: "AuthorityAcquiredButMutationNotDispatched";
+            readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+            readonly authority: {
+                readonly _tag: "AuthorityAcquired";
+                readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+                readonly provider: string & import("effect/Brand").Brand<"ProviderId">;
+                readonly audience: string & import("effect/Brand").Brand<"CanonicalAudience">;
+                readonly requestedPurpose: "observe" | "publish" | "correct";
+                readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+                readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+            };
+            readonly attempt: RejectedBeforeDispatch;
+        } | ConclusiveProviderRejection;
+    } | {
+        readonly _tag: "UncertainSubject";
+        readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+        readonly observationAuthorities: readonly {
+            readonly _tag: "AuthorityAcquired";
+            readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+            readonly provider: string & import("effect/Brand").Brand<"ProviderId">;
+            readonly audience: string & import("effect/Brand").Brand<"CanonicalAudience">;
+            readonly requestedPurpose: "observe" | "publish" | "correct";
+            readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+            readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+        }[];
+        readonly observations: readonly [PresentEquivalent | import("./report.js").PresentDifferent | import("./report.js").AuthoritativelyAbsent | import("./report.js").VisibilityPending | InconclusiveObservation, ...(PresentEquivalent | import("./report.js").PresentDifferent | import("./report.js").AuthoritativelyAbsent | import("./report.js").VisibilityPending | InconclusiveObservation)[]];
+        readonly authority: {
+            readonly _tag: "AuthorityAcquired";
+            readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+            readonly provider: string & import("effect/Brand").Brand<"ProviderId">;
+            readonly audience: string & import("effect/Brand").Brand<"CanonicalAudience">;
+            readonly requestedPurpose: "observe" | "publish" | "correct";
+            readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+            readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+        };
+        readonly attempt: Started | RejectedByProvider | Applied | OutcomeUnknown;
+        readonly trace: readonly [PresentEquivalent | import("./report.js").PresentDifferent | import("./report.js").AuthoritativelyAbsent | import("./report.js").VisibilityPending | InconclusiveObservation, ...(PresentEquivalent | import("./report.js").PresentDifferent | import("./report.js").AuthoritativelyAbsent | import("./report.js").VisibilityPending | InconclusiveObservation)[]];
+        readonly decision?: import("./report.js").NeedsMutation | import("./report.js").ProviderAuthorizedCreate | import("./report.js").ProviderAlreadyEquivalent | import("./report.js").Conflict | ProviderBlocked;
+    }, ...({
+        readonly _tag: "NotReached";
+        readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+        readonly reason: DependencyBlocked | import("./report.js").RunAborted;
+    } | {
+        readonly _tag: "AlreadyEquivalent";
+        readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+        readonly observationAuthorities: readonly {
+            readonly _tag: "AuthorityAcquired";
+            readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+            readonly provider: string & import("effect/Brand").Brand<"ProviderId">;
+            readonly audience: string & import("effect/Brand").Brand<"CanonicalAudience">;
+            readonly requestedPurpose: "observe" | "publish" | "correct";
+            readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+            readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+        }[];
+        readonly observations: readonly [PresentEquivalent | import("./report.js").PresentDifferent | import("./report.js").AuthoritativelyAbsent | import("./report.js").VisibilityPending | InconclusiveObservation, ...(PresentEquivalent | import("./report.js").PresentDifferent | import("./report.js").AuthoritativelyAbsent | import("./report.js").VisibilityPending | InconclusiveObservation)[]];
+    } | {
+        readonly _tag: "ConvergedAfterMutation";
+        readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+        readonly observationAuthorities: readonly {
+            readonly _tag: "AuthorityAcquired";
+            readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+            readonly provider: string & import("effect/Brand").Brand<"ProviderId">;
+            readonly audience: string & import("effect/Brand").Brand<"CanonicalAudience">;
+            readonly requestedPurpose: "observe" | "publish" | "correct";
+            readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+            readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+        }[];
+        readonly preObservations: readonly [PresentEquivalent | import("./report.js").PresentDifferent | import("./report.js").AuthoritativelyAbsent | import("./report.js").VisibilityPending | InconclusiveObservation, ...(PresentEquivalent | import("./report.js").PresentDifferent | import("./report.js").AuthoritativelyAbsent | import("./report.js").VisibilityPending | InconclusiveObservation)[]];
+        readonly decision: import("./report.js").NeedsMutation | import("./report.js").ProviderAuthorizedCreate;
+        readonly authority: {
+            readonly _tag: "AuthorityAcquired";
+            readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+            readonly provider: string & import("effect/Brand").Brand<"ProviderId">;
+            readonly audience: string & import("effect/Brand").Brand<"CanonicalAudience">;
+            readonly requestedPurpose: "observe" | "publish" | "correct";
+            readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+            readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+        };
+        readonly attempt: RejectedByProvider | Applied | OutcomeUnknown;
+        readonly postObservations: readonly [PresentEquivalent | import("./report.js").PresentDifferent | import("./report.js").AuthoritativelyAbsent | import("./report.js").VisibilityPending | InconclusiveObservation, ...(PresentEquivalent | import("./report.js").PresentDifferent | import("./report.js").AuthoritativelyAbsent | import("./report.js").VisibilityPending | InconclusiveObservation)[]];
+    } | {
+        readonly _tag: "BlockedSubject";
+        readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+        readonly observationAuthorities: readonly {
+            readonly _tag: "AuthorityAcquired";
+            readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+            readonly provider: string & import("effect/Brand").Brand<"ProviderId">;
+            readonly audience: string & import("effect/Brand").Brand<"CanonicalAudience">;
+            readonly requestedPurpose: "observe" | "publish" | "correct";
+            readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+            readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+        }[];
+        readonly observations: readonly [PresentEquivalent | import("./report.js").PresentDifferent | import("./report.js").AuthoritativelyAbsent | import("./report.js").VisibilityPending | InconclusiveObservation, ...(PresentEquivalent | import("./report.js").PresentDifferent | import("./report.js").AuthoritativelyAbsent | import("./report.js").VisibilityPending | InconclusiveObservation)[]];
+        readonly cause: import("./report.js").Conflict | ProviderBlocked | RejectedBeforeDispatch | {
+            readonly _tag: "AuthorityAcquiredButMutationNotDispatched";
+            readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+            readonly authority: {
+                readonly _tag: "AuthorityAcquired";
+                readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+                readonly provider: string & import("effect/Brand").Brand<"ProviderId">;
+                readonly audience: string & import("effect/Brand").Brand<"CanonicalAudience">;
+                readonly requestedPurpose: "observe" | "publish" | "correct";
+                readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+                readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+            };
+            readonly attempt: RejectedBeforeDispatch;
+        } | ConclusiveProviderRejection;
+    } | {
+        readonly _tag: "UncertainSubject";
+        readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+        readonly observationAuthorities: readonly {
+            readonly _tag: "AuthorityAcquired";
+            readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+            readonly provider: string & import("effect/Brand").Brand<"ProviderId">;
+            readonly audience: string & import("effect/Brand").Brand<"CanonicalAudience">;
+            readonly requestedPurpose: "observe" | "publish" | "correct";
+            readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+            readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+        }[];
+        readonly observations: readonly [PresentEquivalent | import("./report.js").PresentDifferent | import("./report.js").AuthoritativelyAbsent | import("./report.js").VisibilityPending | InconclusiveObservation, ...(PresentEquivalent | import("./report.js").PresentDifferent | import("./report.js").AuthoritativelyAbsent | import("./report.js").VisibilityPending | InconclusiveObservation)[]];
+        readonly authority: {
+            readonly _tag: "AuthorityAcquired";
+            readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+            readonly provider: string & import("effect/Brand").Brand<"ProviderId">;
+            readonly audience: string & import("effect/Brand").Brand<"CanonicalAudience">;
+            readonly requestedPurpose: "observe" | "publish" | "correct";
+            readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+            readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+        };
+        readonly attempt: Started | RejectedByProvider | Applied | OutcomeUnknown;
+        readonly trace: readonly [PresentEquivalent | import("./report.js").PresentDifferent | import("./report.js").AuthoritativelyAbsent | import("./report.js").VisibilityPending | InconclusiveObservation, ...(PresentEquivalent | import("./report.js").PresentDifferent | import("./report.js").AuthoritativelyAbsent | import("./report.js").VisibilityPending | InconclusiveObservation)[]];
+        readonly decision?: import("./report.js").NeedsMutation | import("./report.js").ProviderAuthorizedCreate | import("./report.js").ProviderAlreadyEquivalent | import("./report.js").Conflict | ProviderBlocked;
+    })[]];
+    readonly status: "complete" | "blocked" | "uncertain";
+}, ReleaseCoordinatorConstructionError, CredentialProvider>;
+export {};
+//# sourceMappingURL=coordinator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"coordinator.d.ts","sourceRoot":"","sources":["../../src/publication/coordinator.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,EACL,SAAS,EACT,KAAK,iBAAiB,EACvB,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EACL,kBAAkB,EAElB,KAAK,eAAe,EAGpB,KAAK,uBAAuB,EAC7B,MAAM,gBAAgB,CAAA;AACvB,OAAO,EACL,2BAA2B,EAG3B,iBAAiB,EACjB,uBAAuB,EACvB,eAAe,EACf,cAAc,EACd,iBAAiB,EACjB,eAAe,EACf,sBAAsB,EACtB,OAAO,EAeP,KAAK,OAAO,EAGZ,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,WAAW,EAGhB,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EAIxB,MAAM,aAAa,CAAA;AACpB,OAAO,EAGL,KAAK,yBAAyB,IAAI,6BAA6B,EAChE,MAAM,eAAe,CAAA;;;;;;;AAEtB,qBAAa,mBACX,SAAQ,wBAKN;CAAG;;;;AAEP,qBAAa,mCACX,SAAQ,wCAGP;CAAG;AAEN,0EAA0E;AAC1E,MAAM,MAAM,yBAAyB,GACjC;IAAE,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAA;CAAE,GAClC;IAAE,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAA;CAAE,CAAA;AAE1E,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,EAAE,EAAE,SAAS,CAAA;IACtB,qFAAqF;IACrF,QAAQ,CAAC,QAAQ,EAAE,6BAA6B,CAAA;IAChD,gFAAgF;IAChF,QAAQ,CAAC,aAAa,CAAC,EAAE,aAAa,CAAC,SAAS,CAAC,CAAA;IACjD,QAAQ,CAAC,mBAAmB,EAAE,SAAS,CAAC,iBAAiB,EAAE,GAAG,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAA;IACvF,QAAQ,CAAC,eAAe,EAAE,iBAAiB,CAAA;IAC3C,2GAA2G;IAC3G,QAAQ,CAAC,aAAa,CAAC,EAAE,CACvB,QAAQ,EAAE,gBAAgB,KACvB,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,mBAAmB,CAAC,CAAA;IAC7C,QAAQ,CAAC,OAAO,EAAE,CAChB,KAAK,EAAE,eAAe,EACtB,OAAO,EAAE,yBAAyB,KAC/B,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,mBAAmB,CAAC,CAAA;IACpD,QAAQ,CAAC,MAAM,EAAE,CAAC,WAAW,EAAE,WAAW,KAAK,gBAAgB,CAAA;IAC/D,QAAQ,CAAC,MAAM,EAAE,CACf,QAAQ,EAAE,gBAAgB,EAC1B,KAAK,EAAE,uBAAuB,KAC3B,MAAM,CAAC,MAAM,CAAC,eAAe,EAAE,mBAAmB,CAAC,CAAA;CACzD;AAED,MAAM,WAAW,oBAAoB;IACnC,mFAAmF;IACnF,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAA;IAC5B,0CAA0C;IAC1C,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC,cAAc,CAAC,CAAA;CACjD;AA8ZD,+EAA+E;AAC/E,eAAO,MAAM,sBAAsB;;;2DAqBjC,CAAA;AAEF,mFAAmF;AACnF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2DA2BjC,CAAA"}

package/dist/publication/coordinator.js

@@ -0,0 +1,370 @@
+import * as Clock from "effect/Clock";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import { SubjectId } from "../model/authority.js";
+import { CredentialProvider } from "./authority.js";
+import { ConclusiveProviderRejection, CredentialStrategyUnsupportedCause, CredentialUnavailableCause, DependencyBlocked, InconclusiveObservation, ObservedSubject, OutcomeUnknown, PresentEquivalent, ProviderBlocked, RejectedBeforeDispatch, SafeReason, absentObservation, differentObservation, equivalentObservation, inconclusiveObservation, makeAlreadyEquivalent, makeAuthorityAcquired, makeAuthorityAcquiredButMutationNotDispatched, makeBlockedSubject, makeConvergedAfterMutation, makeNotReached, makeObservationReport, makeReleaseReport, makeUncertainSubject } from "./report.js";
+import { RecoveryCapabilityProfile, isReadConvergenceLagCapable } from "./recovery.js";
+export class ReleaseSubjectError extends Schema.TaggedErrorClass()("ReleaseSubjectError", {
+    subject: SubjectId,
+    phase: Schema.Literals(["observe", "mutate"]),
+    commitment: Schema.Literals(["before-dispatch", "unknown"]),
+    reason: SafeReason
+}) {
+}
+export class ReleaseCoordinatorConstructionError extends Schema.TaggedErrorClass()("ReleaseCoordinatorConstructionError", { reason: SafeReason }) {
+}
+const constructionFailure = (reason) => new ReleaseCoordinatorConstructionError({
+    reason: typeof reason === "string" ? SafeReason.make(reason) : reason
+});
+const validateRequestIdentity = (subject, request, purpose) => {
+    if (request.subject !== subject.id) {
+        throw constructionFailure("A credential request does not match its prepared subject identity.");
+    }
+    if (purpose === "observe" ? request.purpose !== "observe" : request.purpose === "observe") {
+        throw constructionFailure("A credential request is assigned to the wrong authority phase.");
+    }
+    if (purpose === "mutation" && request.strategy.kind === "anonymous") {
+        throw constructionFailure("A mutation credential request cannot use anonymous authority.");
+    }
+};
+const validateInput = (input) => Effect.try({
+    try: () => {
+        const identities = new Set([input.prepared]);
+        for (const subject of input.subjects) {
+            if (identities.has(subject.id)) {
+                throw constructionFailure("Prepared and remote subject identities must be unique.");
+            }
+            const prerequisites = new Set();
+            for (const prerequisite of subject.prerequisites ?? []) {
+                if (!identities.has(prerequisite)) {
+                    throw constructionFailure("Every prerequisite must identify the prepared subject or an earlier remote subject.");
+                }
+                if (prerequisites.has(prerequisite)) {
+                    throw constructionFailure("A release subject cannot declare the same prerequisite twice.");
+                }
+                prerequisites.add(prerequisite);
+            }
+            if (subject.observationRequests.length === 0) {
+                throw constructionFailure("Every remote subject requires at least one observation strategy.");
+            }
+            Schema.decodeUnknownSync(RecoveryCapabilityProfile, { onExcessProperty: "error" })(subject.recovery);
+            if (subject.recovery.historyRequirement === "durable-cas-required" && subject.claimMutation === undefined) {
+                throw constructionFailure("A durable-cas-required subject has no terminal mutation-claim boundary.");
+            }
+            subject.observationRequests.forEach((request, index) => {
+                validateRequestIdentity(subject, request, "observe");
+                if (request.strategy.kind === "anonymous" && index !== 0) {
+                    throw constructionFailure("Anonymous observation must be the first declared strategy.");
+                }
+            });
+            validateRequestIdentity(subject, subject.mutationRequest, "mutation");
+            identities.add(subject.id);
+        }
+    },
+    catch: (cause) => cause instanceof ReleaseCoordinatorConstructionError
+        ? cause
+        : constructionFailure("The release subject contract is invalid.")
+});
+const fromReportResult = (result) => Result.isFailure(result)
+    ? Effect.fail(constructionFailure(result.failure.reason))
+    : Effect.succeed(result.success);
+// The error contributes only its closed tag. Host error fields, especially
+// `reason`, are transient diagnostics and may contain credential material.
+const credentialFailureCause = (request, error) => error._tag === "CredentialUnavailable"
+    ? CredentialUnavailableCause.make({
+        provider: request.provider,
+        purpose: request.purpose,
+        strategy: request.strategy.kind
+    })
+    : CredentialStrategyUnsupportedCause.make({
+        provider: request.provider,
+        purpose: request.purpose,
+        strategy: request.strategy.kind
+    });
+const unavailableObservation = (subject, request, error) => InconclusiveObservation.make({
+    subject,
+    reason: SafeReason.make("Observation authority or provider read was unavailable."),
+    ...(request === undefined || error === undefined ? {} : { cause: credentialFailureCause(request, error) })
+});
+const subjectObservationFailure = (subject, error) => error.subject !== subject.id
+    ? Effect.fail(constructionFailure("A subject error does not match its prepared subject identity."))
+    : Effect.succeed(InconclusiveObservation.make({ subject: subject.id, reason: error.reason }));
+const observeOnce = (credentials, subject, request, context) => credentials.acquireForObservation(request).pipe(Effect.flatMap((grant) => makeAuthority(request, grant).pipe(Effect.flatMap((authority) => subject.observe(grant, context).pipe(Effect.catch((error) => subjectObservationFailure(subject, error)), Effect.map((observation) => ({ observation, authorities: [authority] })))))), Effect.catchTags({
+    CredentialUnavailable: (error) => Effect.succeed({
+        observation: unavailableObservation(subject.id, request, error), authorities: []
+    }),
+    CredentialAudienceMismatch: () => Effect.succeed({
+        observation: unavailableObservation(subject.id), authorities: []
+    }),
+    CredentialPurposeMismatch: () => Effect.succeed({
+        observation: unavailableObservation(subject.id), authorities: []
+    }),
+    CredentialStrategyUnsupported: (error) => Effect.succeed({
+        observation: unavailableObservation(subject.id, request, error), authorities: []
+    }),
+    CredentialSubjectMismatch: () => Effect.succeed({
+        observation: unavailableObservation(subject.id), authorities: []
+    })
+}), Effect.flatMap((result) => result.observation.subject === subject.id
+    ? Effect.succeed(result)
+    : Effect.fail(constructionFailure("An observation does not match its prepared subject identity."))));
+const observeTrace = Effect.fn("observeReleaseSubject")(function* (credentials, subject, context) {
+    const observations = [];
+    const authorities = [];
+    for (const request of subject.observationRequests) {
+        const observed = yield* observeOnce(credentials, subject, request, context);
+        let observation = observed.observation;
+        authorities.push(...observed.authorities);
+        const visibilityPendingIsAdmitted = context.phase === "post-mutation" &&
+            context.attempt._tag !== "RejectedBeforeDispatch" &&
+            context.attempt._tag !== "RejectedByProvider" &&
+            isReadConvergenceLagCapable(subject.recovery);
+        if (observation._tag === "VisibilityPending" && !visibilityPendingIsAdmitted) {
+            observation = InconclusiveObservation.make({
+                subject: subject.id,
+                reason: SafeReason.make("VisibilityPending was not admitted by a lag-capable same-invocation mutation profile and was treated as inconclusive.")
+            });
+        }
+        observations.push(observation);
+        if (observation._tag !== "Inconclusive")
+            break;
+    }
+    return {
+        observations: observations,
+        authorities
+    };
+});
+const retryEligibleObservation = (observation) => observation._tag === "VisibilityPending" || observation._tag === "Inconclusive";
+const retryDelayMs = (profile, completedAttempts) => {
+    const { baseMs, factor, capMs } = profile.readConvergence.observationRetry.backoff;
+    const scaled = baseMs * factor ** Math.max(0, completedAttempts - 1);
+    return Math.min(capMs, scaled);
+};
+const observeAfterMutation = Effect.fn("observeReleaseSubjectAfterMutation")(function* (credentials, subject, attempt) {
+    const observations = [];
+    const authorities = [];
+    const policy = subject.recovery.readConvergence.observationRetry;
+    const maxAttempts = attempt._tag === "RejectedBeforeDispatch" ? 1 : policy.maxAttempts;
+    const startedAt = yield* Clock.currentTimeMillis;
+    let completedAttempts = 0;
+    while (completedAttempts < maxAttempts) {
+        if (completedAttempts > 0) {
+            const delayMs = retryDelayMs(subject.recovery, completedAttempts);
+            const now = yield* Clock.currentTimeMillis;
+            const elapsedMs = Math.max(0, now - startedAt);
+            if (elapsedMs + delayMs > policy.totalBudgetMs)
+                break;
+            yield* Effect.sleep(Duration.millis(delayMs));
+        }
+        const observed = yield* observeTrace(credentials, subject, { phase: "post-mutation", attempt });
+        observations.push(...observed.observations);
+        authorities.push(...observed.authorities);
+        completedAttempts += 1;
+        if (!retryEligibleObservation(observed.observations.at(-1)))
+            break;
+    }
+    return {
+        observations: observations,
+        authorities
+    };
+});
+const classifyObservation = (observation) => {
+    switch (observation._tag) {
+        case "PresentEquivalent":
+            return equivalentObservation();
+        case "PresentDifferent":
+            return differentObservation(observation.differences);
+        case "AuthoritativelyAbsent":
+            return absentObservation(observation.basis);
+        case "VisibilityPending":
+            return inconclusiveObservation(SafeReason.make("Provider visibility remains pending."));
+        case "Inconclusive":
+            return inconclusiveObservation(observation.reason, observation.cause);
+    }
+};
+const providerBlockedFromAuthority = (subject, request, error) => ProviderBlocked.make({
+    subject,
+    reason: SafeReason.make("Mutation authority was unavailable for the exact prepared request."),
+    ...(error._tag === "CredentialUnavailable" || error._tag === "CredentialStrategyUnsupported"
+        ? { cause: credentialFailureCause(request, error) }
+        : {})
+});
+const makeAuthority = (request, grant) => {
+    const purposes = [...grant.purposes];
+    if (purposes.length === 0) {
+        return Effect.fail(constructionFailure("A credential grant carries no authority purpose."));
+    }
+    if (grant.subject !== request.subject || grant.provider !== request.provider ||
+        grant.audience !== request.audience || !grant.purposes.has(request.purpose)) {
+        return Effect.fail(constructionFailure("A credential grant does not match the exact prepared request."));
+    }
+    return fromReportResult(makeAuthorityAcquired({
+        subject: request.subject,
+        provider: request.provider,
+        audience: request.audience,
+        requestedPurpose: request.purpose,
+        grantKind: grant._tag,
+        purposes: purposes
+    }));
+};
+const decide = (subject, observation) => Effect.try({
+    try: () => subject.decide(observation),
+    catch: () => constructionFailure("The provider decision function did not return a total decision.")
+}).pipe(Effect.flatMap((decision) => decision.subject === subject.id
+    ? Effect.succeed(decision)
+    : Effect.fail(constructionFailure("A provider decision does not match its prepared subject identity."))));
+const performMutation = (subject, decision, grant) => subject.mutate(decision, grant).pipe(Effect.catch((error) => error.subject !== subject.id
+    ? Effect.fail(constructionFailure("A mutation error does not match its prepared subject identity."))
+    : Effect.succeed(error.commitment === "before-dispatch"
+        ? RejectedBeforeDispatch.make({ subject: subject.id, reason: error.reason })
+        : OutcomeUnknown.make({ subject: subject.id, reason: error.reason }))), Effect.flatMap((attempt) => attempt.subject === subject.id
+    ? Effect.succeed(attempt)
+    : Effect.fail(constructionFailure("A mutation attempt does not match its prepared subject identity."))));
+const uncertainAttempt = (attempt) => attempt;
+const convergedAttempt = (attempt) => attempt._tag === "Started"
+    ? OutcomeUnknown.make({
+        subject: attempt.subject,
+        reason: SafeReason.make("Mutation started without a terminal provider response before reobservation.")
+    })
+    : attempt;
+const publishSubject = Effect.fn("publishReleaseSubject")(function* (credentials, subject) {
+    const before = yield* observeTrace(credentials, subject, { phase: "pre-mutation" });
+    const decision = yield* decide(subject, before.observations.at(-1));
+    switch (decision._tag) {
+        case "AlreadyEquivalent":
+            return yield* fromReportResult(makeAlreadyEquivalent(subject.id, before.observations, before.authorities));
+        case "Conflict":
+        case "Blocked":
+            return yield* fromReportResult(makeBlockedSubject({
+                subject: subject.id,
+                observationAuthorities: before.authorities,
+                observations: before.observations,
+                cause: decision
+            }));
+        case "NeedsMutation":
+        case "ProviderAuthorizedCreate": {
+            if (subject.claimMutation !== undefined) {
+                const claimed = yield* Effect.exit(subject.claimMutation(decision));
+                if (Exit.isFailure(claimed)) {
+                    return yield* fromReportResult(makeBlockedSubject({
+                        subject: subject.id,
+                        observationAuthorities: before.authorities,
+                        observations: before.observations,
+                        cause: ProviderBlocked.make({
+                            subject: subject.id,
+                            reason: SafeReason.make("The terminal publication claim was unavailable or already occupied.")
+                        })
+                    }));
+                }
+            }
+            const acquisition = yield* credentials.acquireForMutation(subject.mutationRequest, decision).pipe(Effect.map((grant) => ({ _tag: "Granted", grant })), Effect.catch((error) => Effect.succeed({ _tag: "Denied", error })));
+            if (acquisition._tag === "Denied") {
+                return yield* fromReportResult(makeBlockedSubject({
+                    subject: subject.id,
+                    observationAuthorities: before.authorities,
+                    observations: before.observations,
+                    cause: providerBlockedFromAuthority(subject.id, subject.mutationRequest, acquisition.error)
+                }));
+            }
+            const grant = acquisition.grant;
+            const authority = yield* makeAuthority(subject.mutationRequest, grant);
+            const attempt = yield* performMutation(subject, decision, grant);
+            const after = yield* observeAfterMutation(credentials, subject, attempt);
+            const observationAuthorities = [...before.authorities, ...after.authorities];
+            if (attempt._tag === "RejectedBeforeDispatch") {
+                const cause = yield* fromReportResult(makeAuthorityAcquiredButMutationNotDispatched({
+                    subject: subject.id,
+                    authority,
+                    attempt
+                }));
+                return yield* fromReportResult(makeBlockedSubject({
+                    subject: subject.id,
+                    observationAuthorities,
+                    observations: [...before.observations, ...after.observations],
+                    cause
+                }));
+            }
+            if (after.observations.at(-1)?._tag === "PresentEquivalent") {
+                return yield* fromReportResult(makeConvergedAfterMutation({
+                    subject: subject.id,
+                    observationAuthorities,
+                    preObservations: before.observations,
+                    decision,
+                    authority,
+                    attempt: convergedAttempt(attempt),
+                    postObservations: after.observations
+                }));
+            }
+            if (attempt._tag === "RejectedByProvider" &&
+                after.observations.at(-1)?._tag !== "Inconclusive" &&
+                after.observations.at(-1)?._tag !== "VisibilityPending") {
+                return yield* fromReportResult(makeBlockedSubject({
+                    subject: subject.id,
+                    observationAuthorities,
+                    observations: before.observations,
+                    cause: ConclusiveProviderRejection.make({
+                        subject: subject.id,
+                        fact: attempt.fact,
+                        postObservations: after.observations
+                    })
+                }));
+            }
+            return yield* fromReportResult(makeUncertainSubject({
+                subject: subject.id,
+                observationAuthorities,
+                observations: before.observations,
+                decision,
+                authority,
+                attempt: uncertainAttempt(attempt),
+                trace: after.observations
+            }));
+        }
+    }
+});
+/** Read-only projection. It never asks for publish or correction authority. */
+export const observeReleaseSubjects = Effect.fn("observeReleaseSubjects")(function* (input) {
+    yield* validateInput(input);
+    const credentials = yield* CredentialProvider;
+    const observed = [
+        new ObservedSubject({
+            subject: input.prepared,
+            observationAuthorities: [],
+            observation: equivalentObservation()
+        })
+    ];
+    for (const subject of input.subjects) {
+        const trace = yield* observeTrace(credentials, subject, { phase: "pre-mutation" });
+        observed.push(new ObservedSubject({
+            subject: subject.id,
+            observationAuthorities: trace.authorities,
+            observation: classifyObservation(trace.observations.at(-1))
+        }));
+    }
+    return makeObservationReport(observed);
+});
+/** Dependency-ordered observation, lazy authority, mutation, and reobservation. */
+export const publishReleaseSubjects = Effect.fn("publishReleaseSubjects")(function* (input) {
+    yield* validateInput(input);
+    const credentials = yield* CredentialProvider;
+    const localObservation = PresentEquivalent.make({ subject: input.prepared });
+    const local = yield* fromReportResult(makeAlreadyEquivalent(input.prepared, [localObservation], []));
+    const reports = [local];
+    const converged = new Map([[input.prepared, true]]);
+    for (const subject of input.subjects) {
+        const prerequisite = (subject.prerequisites ?? []).find((candidate) => converged.get(candidate) !== true);
+        if (prerequisite !== undefined) {
+            reports.push(yield* fromReportResult(makeNotReached(subject.id, new DependencyBlocked({ prerequisite }))));
+            converged.set(subject.id, false);
+            continue;
+        }
+        const report = yield* publishSubject(credentials, subject);
+        reports.push(report);
+        converged.set(subject.id, report._tag === "AlreadyEquivalent" || report._tag === "ConvergedAfterMutation");
+    }
+    return makeReleaseReport(reports);
+});
+//# sourceMappingURL=coordinator.js.map