@smthrs/journal 0.0.0-stage → 1.0.0-rc.3

package/dist/cjs/Consensus.d.ts

@@ -0,0 +1,440 @@
+/**
+ * The injectable consensus strategy arbitrating the journal's ownership rules.
+ *
+ * The journal owns the consensus rules — single writer per run, fenced and
+ * unfenced appends, commit-time admission, the generation fence, and steal
+ * only on staleness plus liveness evidence — and this service is how a deployment chooses *how* those rules are
+ * arbitrated: where the lease lives, how liveness is probed, and how the
+ * fence is checked at commit time. `Consensus` lives here beside `OwnerId`
+ * for the same reason `OwnerId` does: the journal is what it fences.
+ * `@smthrs/run-store`'s `Ownership` keeps its public API and rules but
+ * delegates arbitration to this strategy.
+ *
+ * Every operation that reasons about staleness takes the caller's clock
+ * reading (`nowMs`) rather than reading a clock itself: staleness (R5) and
+ * the monotonic lease stamp are defined against the arbitrating caller's
+ * reading, exactly as `RunStore`'s compare-and-swap operations always were,
+ * so the recorded lease never differs from the outcome the caller observed.
+ *
+ * Governing design: `packages/smithers/flows/journal/docs/concepts/owner-fence.md`.
+ * Rule constants and their provenance:
+ * `packages/smithers/flows/run-store/docs/concepts/leases.md`.
+ *
+ * Prior art: Effect `EventJournal` (`reference/effect` `unstable/eventlog`)
+ * resolves multi-writer by merge with conflict surfacing; driving a run is not
+ * mergeable, so this surface deviates to exclusive-writer admission. The
+ * fencing and generation semantics follow Temporal's shard `rangeID`
+ * (`reference/temporal/service/history/shard/context_impl.go`).
+ *
+ * @since 1.0.0
+ */
+import * as Context from "effect/Context";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import { OwnerId } from "./OwnerId.ts";
+/**
+ * How often the supervision loop pulses to renew the owner's lease.
+ *
+ * @since 1.0.0
+ * @category constants
+ */
+export declare const heartbeatInterval: Duration.Duration;
+/**
+ * How old a persisted heartbeat must be before a peer may steal the run.
+ * Every strategy judges R5 staleness against this one definition.
+ *
+ * @since 1.0.0
+ * @category constants
+ */
+export declare const heartbeatStaleAfter: Duration.Duration;
+/**
+ * How far the owner's wall clock may run behind a peer's before the lease
+ * reasoning stops holding.
+ *
+ * The owner stamps its heartbeat from *its* clock and a would-be stealer
+ * compares that stamp against *its own*, so the two hosts' clock offset is
+ * subtracted directly from the owner's real safety margin. This constant names
+ * that allowance instead of leaving it implicit in a "two ticks" arithmetic
+ * accident, and it is a budgeted allowance, not a guarantee: see
+ * {@link heartbeatWriteTolerance} for what happens once it is exceeded.
+ *
+ * @since 1.0.0
+ * @category constants
+ */
+export declare const heartbeatSkewAllowance: Duration.Duration;
+/**
+ * How long heartbeat writes may go unconfirmed before ownership must be reconfirmed.
+ *
+ * A peer judges staleness by the persisted heartbeat and may steal the run the
+ * instant it is {@link heartbeatStaleAfter} old, so an owner that tolerated
+ * write failures for exactly that long would still be executing side effects
+ * when the steal is admitted. The budget is therefore
+ * {@link heartbeatStaleAfter} minus {@link heartbeatSkewAllowance} (the peer's
+ * clock may already read that much later than the owner's) minus one
+ * {@link heartbeatInterval} (reserved for one bounded compare-and-swap
+ * reconfirmation before the owner interrupts).
+ *
+ * This bounds, but does not eliminate, overlap. Beyond
+ * {@link heartbeatSkewAllowance} of clock offset a peer can be admitted while
+ * the old owner is still running. *Durable* writes stay safe regardless — they
+ * are fenced by the strategy's commit-time admission, so the displaced owner's
+ * writes fail rather than corrupt. Non-durable external side effects (an HTTP
+ * call, a spawned process) can genuinely overlap. That is inherent to any
+ * wall-clock lease and is stated here rather than asserted away; a caller that
+ * cannot tolerate any overlap needs an external fencing token at the side
+ * effect itself, not a larger timeout.
+ *
+ * @since 1.0.0
+ * @category constants
+ */
+export declare const heartbeatWriteTolerance: Duration.Duration;
+/**
+ * Evidence that the owner in an exact run snapshot is no longer live.
+ *
+ * Defined here because R5 — steal requires staleness plus liveness evidence —
+ * is a consensus rule every strategy validates. `@smthrs/run-store`'s
+ * `Ownership` re-exports it alongside the probes that mint it.
+ *
+ * Two of the three kinds are collected outside the strategy:
+ * `same-host-pid-dead` is a local process probe, and
+ * `cross-host-unreachable-stale` is a reachability judgement the deployment
+ * makes. `lease-expired` is different — it asserts only that the persisted
+ * heartbeat is older than the staleness cutoff, which is the one claim a
+ * strategy can check for itself, and `steal` checks it: the takeover refuses
+ * any lease whose heartbeat is still inside the window. It is therefore
+ * accepted from a claimant on any host, while the other two stay bound to the
+ * host relation that makes them meaningful. The observation must carry the
+ * exact instant supplied to the consuming operation: `checkedAtMs` must equal
+ * that operation's `nowMs`. A caller that probes at T and calls at T+1 is
+ * refused and must build fresh evidence.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export declare const LivenessEvidence: Schema.Struct<{
+    readonly expectedOwner: Schema.Struct<{
+        readonly hostId: Schema.String;
+        readonly pid: Schema.Int;
+        readonly nonce: Schema.String;
+    }>;
+    readonly checkedAtMs: Schema.Number;
+    readonly kind: Schema.Literals<readonly ["same-host-pid-dead", "cross-host-unreachable-stale", "lease-expired"]>;
+}>;
+/**
+ * Evidence that the owner in an exact run snapshot is no longer live.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export type LivenessEvidence = typeof LivenessEvidence.Type;
+/**
+ * Structural equality on the process identity tuple.
+ *
+ * @since 1.0.0
+ * @category predicates
+ */
+export declare const sameOwner: (left: OwnerId, right: OwnerId) => boolean;
+/**
+ * Validates liveness evidence against the owner it claims to disprove.
+ *
+ * The evidence must name the expected owner, carry the observer's current
+ * clock reading, and respect the host rule: a `same-host-pid-dead` probe is
+ * only meaningful from the same host, a `cross-host-unreachable-stale`
+ * observation only from a different one, and `lease-expired` is host-neutral
+ * because the strategy verifies the cutoff it names for itself.
+ *
+ * @since 1.0.0
+ * @category predicates
+ */
+export declare const matchesEvidence: (expectedOwner: OwnerId, observer: OwnerId, nowMs: number, evidence: LivenessEvidence) => boolean;
+/**
+ * Why a strategy refused a claim, steal, or recovery.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export declare const RejectionReason: Schema.Literals<readonly ["already_claimed", "owner_held", "owner_live", "evidence_invalid", "claim_fresh", "claim_changed", "unavailable"]>;
+/**
+ * Why a strategy refused a claim, steal, or recovery.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export type RejectionReason = typeof RejectionReason.Type;
+/**
+ * A granted claim, carrying the grant timestamp the later activation must
+ * present (R4 — the generation fence).
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export declare const Claimed: Schema.TaggedStruct<"Claimed", {
+    readonly grantedAtMs: Schema.Number;
+}>;
+/**
+ * A granted claim.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export type Claimed = typeof Claimed.Type;
+/**
+ * A refused claim, steal, or recovery, with the strategy's typed reason.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export declare const Rejected: Schema.TaggedStruct<"Rejected", {
+    readonly reason: Schema.Literals<readonly ["already_claimed", "owner_held", "owner_live", "evidence_invalid", "claim_fresh", "claim_changed", "unavailable"]>;
+}>;
+/**
+ * A refused claim, steal, or recovery.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export type Rejected = typeof Rejected.Type;
+/**
+ * Outcome of `claim` and `steal`.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export declare const ClaimOutcome: Schema.Union<readonly [Schema.TaggedStruct<"Claimed", {
+    readonly grantedAtMs: Schema.Number;
+}>, Schema.TaggedStruct<"Rejected", {
+    readonly reason: Schema.Literals<readonly ["already_claimed", "owner_held", "owner_live", "evidence_invalid", "claim_fresh", "claim_changed", "unavailable"]>;
+}>]>;
+/**
+ * Outcome of `claim` and `steal`.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export type ClaimOutcome = typeof ClaimOutcome.Type;
+/**
+ * A claim promoted to ownership.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export declare const Activated: Schema.TaggedStruct<"Activated", {}>;
+/**
+ * A claim promoted to ownership.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export type Activated = typeof Activated.Type;
+/**
+ * The claim or lease the caller presented no longer exists.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export declare const Lost: Schema.TaggedStruct<"Lost", {}>;
+/**
+ * The claim or lease the caller presented no longer exists.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export type Lost = typeof Lost.Type;
+/**
+ * Outcome of `activate`.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export declare const ActivateOutcome: Schema.Union<readonly [Schema.TaggedStruct<"Activated", {}>, Schema.TaggedStruct<"Lost", {}>]>;
+/**
+ * Outcome of `activate`.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export type ActivateOutcome = typeof ActivateOutcome.Type;
+/**
+ * A renewed lease, carrying the monotonic heartbeat stamp the strategy
+ * recorded — the maximum of the stored stamp and the caller's reading, so a
+ * late pulse never moves the lease backwards.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export declare const Renewed: Schema.TaggedStruct<"Renewed", {
+    readonly heartbeatAtMs: Schema.Number;
+}>;
+/**
+ * A renewed lease.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export type Renewed = typeof Renewed.Type;
+/**
+ * Outcome of `heartbeat` and `reconfirm`.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export declare const HeartbeatOutcome: Schema.Union<readonly [Schema.TaggedStruct<"Renewed", {
+    readonly heartbeatAtMs: Schema.Number;
+}>, Schema.TaggedStruct<"Lost", {}>]>;
+/**
+ * Outcome of `heartbeat` and `reconfirm`.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export type HeartbeatOutcome = typeof HeartbeatOutcome.Type;
+/**
+ * A stale claim cleared after its claimant was proven dead.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export declare const Recovered: Schema.TaggedStruct<"Recovered", {}>;
+/**
+ * A stale claim cleared after its claimant was proven dead.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export type Recovered = typeof Recovered.Type;
+/**
+ * Outcome of `recover`.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export declare const RecoverOutcome: Schema.Union<readonly [Schema.TaggedStruct<"Recovered", {}>, Schema.TaggedStruct<"Rejected", {
+    readonly reason: Schema.Literals<readonly ["already_claimed", "owner_held", "owner_live", "evidence_invalid", "claim_fresh", "claim_changed", "unavailable"]>;
+}>]>;
+/**
+ * Outcome of `recover`.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export type RecoverOutcome = typeof RecoverOutcome.Type;
+declare const ConsensusError_base: Schema.Class<ConsensusError, Schema.TaggedStruct<"@smthrs/journal/ConsensusError", {
+    readonly code: Schema.Literals<readonly ["fence_lost", "persistence_failed"]>;
+    readonly message: Schema.String;
+    readonly cause: Schema.optional<Schema.Unknown>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Failure raised by a consensus strategy.
+ *
+ * `fence_lost` is `guard`'s refusal: the supplied owner no longer holds the
+ * run, so the fenced write it joins must not commit. `persistence_failed`
+ * wraps a strategy's storage failure; the original cause is preserved so the
+ * durable writer's retry classification still sees a transient conflict
+ * through the wrapper.
+ *
+ * @since 1.0.0
+ * @category errors
+ */
+export declare class ConsensusError extends ConsensusError_base {
+}
+/**
+ * Consensus operations.
+ *
+ * The rules being arbitrated are strategy-independent; a strategy
+ * chooses where the lease lives and how the fence is checked at commit time.
+ * The claim lifecycle is two-phase, exactly as `RunStore`'s always was:
+ * `claim` (or `steal`, its evidence-gated form) reserves the run and returns
+ * the grant timestamp, `activate` presents that grant to take ownership, and
+ * `release` clears whichever of the caller's claim or ownership still stands.
+ * `recover` clears a *third party's* stale claim after its claimant was proven
+ * dead — the relocated `recoverClaim` mechanic. `guard` is the commit-time
+ * admission check (R3) `Journal.emitDurable`, `checkpoint`, and `compact`
+ * join: it succeeds while the owner holds the run and fails with `fence_lost`
+ * otherwise.
+ *
+ * Heartbeats and lease state are the strategy's private evidence and never
+ * enter the journal.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export interface Service {
+    readonly claim: (runId: string, claimant: OwnerId, nowMs: number) => Effect.Effect<ClaimOutcome, ConsensusError>;
+    readonly activate: (runId: string, owner: OwnerId, grantedAtMs: number, nowMs: number) => Effect.Effect<ActivateOutcome, ConsensusError>;
+    readonly heartbeat: (runId: string, owner: OwnerId, nowMs: number) => Effect.Effect<HeartbeatOutcome, ConsensusError>;
+    /** Renews only while this owner holds the lease and no takeover claim is pending. */
+    readonly reconfirm: (runId: string, owner: OwnerId, nowMs: number) => Effect.Effect<HeartbeatOutcome, ConsensusError>;
+    readonly release: (runId: string, owner: OwnerId) => Effect.Effect<void, ConsensusError>;
+    readonly steal: (runId: string, claimant: OwnerId, nowMs: number, evidence: LivenessEvidence) => Effect.Effect<ClaimOutcome, ConsensusError>;
+    readonly recover: (runId: string, staleClaimant: OwnerId, grantedAtMs: number, observer: OwnerId, nowMs: number, evidence: LivenessEvidence) => Effect.Effect<RecoverOutcome, ConsensusError>;
+    readonly guard: (runId: string, owner: OwnerId) => Effect.Effect<void, ConsensusError>;
+}
+declare const Consensus_base: Context.ServiceClass<Consensus, "@smthrs/journal/Consensus", Service>;
+/**
+ * Context service for the injected consensus strategy.
+ *
+ * @since 1.0.0
+ * @category services
+ */
+export declare class Consensus extends Consensus_base {
+}
+/**
+ * Constructs a consensus service from an implementation.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const make: (implementation: Service) => Service;
+/**
+ * The refusal `guard` raises for an owner that no longer holds the run.
+ *
+ * @since 1.0.0
+ * @category errors
+ */
+export declare const fenceLost: (runId: string, owner: OwnerId) => ConsensusError;
+/**
+ * Constructs a strategy that arbitrates nothing: claims are refused, leases
+ * are never held, and every fenced write is rejected.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const makeNoop: (overrides?: Partial<Service>) => Service;
+/**
+ * Provides the refusing strategy stub.
+ *
+ * @since 1.0.0
+ * @category layers
+ */
+export declare const layerNoop: (overrides?: Partial<Service>) => Layer.Layer<Consensus>;
+/**
+ * Constructs the in-memory single-process strategy.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const makeLocal: Effect.Effect<Service>;
+/**
+ * Provides the in-memory single-process strategy.
+ *
+ * The lease lives in process memory, so R3 is exact within the process — the
+ * strategy's transitions and the serialized append transactions interleave
+ * atomically on one event loop — and browser support needs nothing beyond
+ * this layer plus the browser-safe journal. State is per layer build: provide
+ * one instance to every service that must agree on it, which is what
+ * `SqlJournal.layerWith` and `RunStore.layerWith` exist for.
+ *
+ * The lease is not part of any database transaction: a transition made inside
+ * a `Journal.transact` that later rolls back stays applied in memory, so the
+ * lease and a rolled-back run row can disagree until the next transition.
+ * `SqlConsensus` keeps the two in one transaction; prefer it wherever a
+ * database is present.
+ *
+ * @since 1.0.0
+ * @category layers
+ */
+export declare const layerLocal: Layer.Layer<Consensus>;
+export {};
+//# sourceMappingURL=Consensus.d.ts.map

package/dist/cjs/Consensus.d.ts.map

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