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

package/dist/cjs/Consensus.js

@@ -0,0 +1,251 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Consensus_exports = {};
+__export(Consensus_exports, {
+  ActivateOutcome: () => ActivateOutcome,
+  Activated: () => Activated,
+  ClaimOutcome: () => ClaimOutcome,
+  Claimed: () => Claimed,
+  Consensus: () => Consensus,
+  ConsensusError: () => ConsensusError,
+  HeartbeatOutcome: () => HeartbeatOutcome,
+  LivenessEvidence: () => LivenessEvidence,
+  Lost: () => Lost,
+  RecoverOutcome: () => RecoverOutcome,
+  Recovered: () => Recovered,
+  Rejected: () => Rejected,
+  RejectionReason: () => RejectionReason,
+  Renewed: () => Renewed,
+  fenceLost: () => fenceLost,
+  heartbeatInterval: () => heartbeatInterval,
+  heartbeatSkewAllowance: () => heartbeatSkewAllowance,
+  heartbeatStaleAfter: () => heartbeatStaleAfter,
+  heartbeatWriteTolerance: () => heartbeatWriteTolerance,
+  layerLocal: () => layerLocal,
+  layerNoop: () => layerNoop,
+  make: () => make,
+  makeLocal: () => makeLocal,
+  makeNoop: () => makeNoop,
+  matchesEvidence: () => matchesEvidence,
+  sameOwner: () => sameOwner
+});
+module.exports = __toCommonJS(Consensus_exports);
+var Context = __toESM(require("effect/Context"), 1);
+var Duration = __toESM(require("effect/Duration"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Layer = __toESM(require("effect/Layer"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+var import_OwnerId = require("./OwnerId.js");
+const heartbeatInterval = Duration.seconds(1);
+const heartbeatStaleAfter = Duration.seconds(30);
+const heartbeatSkewAllowance = Duration.seconds(10);
+const heartbeatWriteTolerance = Duration.millis(
+  Duration.toMillis(heartbeatStaleAfter) - Duration.toMillis(heartbeatSkewAllowance) - Duration.toMillis(heartbeatInterval)
+);
+const staleAfterMs = Duration.toMillis(heartbeatStaleAfter);
+const LivenessEvidence = Schema.Struct({
+  expectedOwner: import_OwnerId.OwnerId,
+  checkedAtMs: Schema.Number,
+  kind: Schema.Literals(["same-host-pid-dead", "cross-host-unreachable-stale", "lease-expired"])
+});
+const sameOwner = (left, right) => left.hostId === right.hostId && left.pid === right.pid && left.nonce === right.nonce;
+const matchesEvidence = (expectedOwner, observer, nowMs, evidence) => {
+  if (!sameOwner(expectedOwner, evidence.expectedOwner) || evidence.checkedAtMs !== nowMs) return false;
+  switch (evidence.kind) {
+    // A pid means nothing outside the host that owns the process namespace.
+    case "same-host-pid-dead":
+      return expectedOwner.hostId === observer.hostId;
+    // Unreachability is what a peer host observes; on the owner's own host it
+    // would be an unprobed guess dressed as evidence.
+    case "cross-host-unreachable-stale":
+      return expectedOwner.hostId !== observer.hostId;
+    // The lease is host-neutral, and the strategy verifies the same
+    // caller-clock cutoff named by this evidence.
+    case "lease-expired":
+      return true;
+  }
+};
+const RejectionReason = Schema.Literals([
+  "already_claimed",
+  "owner_held",
+  "owner_live",
+  "evidence_invalid",
+  "claim_fresh",
+  "claim_changed",
+  "unavailable"
+]);
+const Claimed = Schema.TaggedStruct("Claimed", {
+  grantedAtMs: Schema.Number
+});
+const Rejected = Schema.TaggedStruct("Rejected", {
+  reason: RejectionReason
+});
+const ClaimOutcome = Schema.Union([Claimed, Rejected]);
+const Activated = Schema.TaggedStruct("Activated", {});
+const Lost = Schema.TaggedStruct("Lost", {});
+const ActivateOutcome = Schema.Union([Activated, Lost]);
+const Renewed = Schema.TaggedStruct("Renewed", {
+  heartbeatAtMs: Schema.Number
+});
+const HeartbeatOutcome = Schema.Union([Renewed, Lost]);
+const Recovered = Schema.TaggedStruct("Recovered", {});
+const RecoverOutcome = Schema.Union([Recovered, Rejected]);
+class ConsensusError extends Schema.TaggedError()("@smthrs/journal/ConsensusError", {
+  code: Schema.Literals(["fence_lost", "persistence_failed"]),
+  message: Schema.String,
+  cause: Schema.optional(Schema.Unknown)
+}) {
+}
+class Consensus extends Context.Service()("@smthrs/journal/Consensus") {
+}
+const make = (implementation) => Consensus.of(implementation);
+const rejected = (reason) => ({ _tag: "Rejected", reason });
+const claimed = (grantedAtMs) => ({ _tag: "Claimed", grantedAtMs });
+const lost = { _tag: "Lost" };
+const activated = { _tag: "Activated" };
+const recovered = { _tag: "Recovered" };
+const fenceLost = (runId, owner) => new ConsensusError({
+  code: "fence_lost",
+  message: `run ${runId} is no longer owned by ${owner.hostId}:${owner.pid}:${owner.nonce}`
+});
+const makeNoop = (overrides = {}) => Consensus.of({
+  claim: Effect.fn("Consensus.claim")(() => Effect.succeed(rejected("unavailable"))),
+  activate: Effect.fn("Consensus.activate")(() => Effect.succeed(lost)),
+  heartbeat: Effect.fn("Consensus.heartbeat")(() => Effect.succeed(lost)),
+  reconfirm: Effect.fn("Consensus.reconfirm")(() => Effect.succeed(lost)),
+  release: Effect.fn("Consensus.release")(() => Effect.void),
+  steal: Effect.fn("Consensus.steal")(() => Effect.succeed(rejected("unavailable"))),
+  recover: Effect.fn("Consensus.recover")(() => Effect.succeed(rejected("unavailable"))),
+  guard: Effect.fn("Consensus.guard")((runId, owner) => Effect.fail(fenceLost(runId, owner))),
+  ...overrides
+});
+const layerNoop = (overrides = {}) => Layer.succeed(Consensus)(makeNoop(overrides));
+const makeLocal = Effect.sync(() => {
+  const leases = /* @__PURE__ */ new Map();
+  const leaseOf = (runId) => {
+    const existing = leases.get(runId);
+    if (existing !== void 0) return existing;
+    const fresh = { owner: void 0, claim: void 0 };
+    leases.set(runId, fresh);
+    return fresh;
+  };
+  const prune = (runId, lease) => {
+    if (lease.owner === void 0 && lease.claim === void 0) {
+      leases.delete(runId);
+    }
+  };
+  return Consensus.of({
+    claim: Effect.fn("Consensus.claim")(
+      (runId, claimant, nowMs) => Effect.sync(() => {
+        const lease = leaseOf(runId);
+        if (lease.claim !== void 0) return rejected("already_claimed");
+        if (lease.owner !== void 0) return rejected("owner_held");
+        lease.claim = { id: claimant, claimedAtMs: nowMs };
+        return claimed(nowMs);
+      })
+    ),
+    activate: Effect.fn("Consensus.activate")(
+      (runId, owner, grantedAtMs, nowMs) => Effect.sync(() => {
+        const lease = leaseOf(runId);
+        if (lease.claim === void 0 || !sameOwner(lease.claim.id, owner) || lease.claim.claimedAtMs !== grantedAtMs) {
+          prune(runId, lease);
+          return lost;
+        }
+        lease.claim = void 0;
+        lease.owner = { id: owner, grantedAtMs, heartbeatAtMs: nowMs };
+        return activated;
+      })
+    ),
+    heartbeat: Effect.fn("Consensus.heartbeat")(
+      (runId, owner, nowMs) => Effect.sync(() => {
+        const lease = leases.get(runId);
+        if (lease?.owner === void 0 || !sameOwner(lease.owner.id, owner)) return lost;
+        lease.owner.heartbeatAtMs = Math.max(lease.owner.heartbeatAtMs, nowMs);
+        return { _tag: "Renewed", heartbeatAtMs: lease.owner.heartbeatAtMs };
+      })
+    ),
+    reconfirm: Effect.fn("Consensus.reconfirm")(
+      (runId, owner, nowMs) => Effect.sync(() => {
+        const lease = leases.get(runId);
+        if (lease?.owner === void 0 || lease.claim !== void 0 || !sameOwner(lease.owner.id, owner)) return lost;
+        lease.owner.heartbeatAtMs = Math.max(lease.owner.heartbeatAtMs, nowMs);
+        return { _tag: "Renewed", heartbeatAtMs: lease.owner.heartbeatAtMs };
+      })
+    ),
+    release: Effect.fn("Consensus.release")(
+      (runId, owner) => Effect.sync(() => {
+        const lease = leases.get(runId);
+        if (lease === void 0) return;
+        if (lease.claim !== void 0 && sameOwner(lease.claim.id, owner)) {
+          lease.claim = void 0;
+        }
+        if (lease.owner !== void 0 && sameOwner(lease.owner.id, owner)) {
+          lease.owner = void 0;
+        }
+        prune(runId, lease);
+      })
+    ),
+    steal: Effect.fn("Consensus.steal")(
+      (runId, claimant, nowMs, evidence) => Effect.sync(() => {
+        if (!matchesEvidence(evidence.expectedOwner, claimant, nowMs, evidence)) {
+          return rejected("evidence_invalid");
+        }
+        const lease = leases.get(runId);
+        if (lease?.claim !== void 0) return rejected("already_claimed");
+        if (lease?.owner === void 0 || !sameOwner(lease.owner.id, evidence.expectedOwner)) {
+          return rejected("evidence_invalid");
+        }
+        if (lease.owner.heartbeatAtMs >= nowMs - staleAfterMs) return rejected("owner_live");
+        lease.claim = { id: claimant, claimedAtMs: nowMs };
+        return claimed(nowMs);
+      })
+    ),
+    recover: Effect.fn("Consensus.recover")(
+      (runId, staleClaimant, grantedAtMs, observer, nowMs, evidence) => Effect.sync(() => {
+        if (!matchesEvidence(staleClaimant, observer, nowMs, evidence)) return rejected("evidence_invalid");
+        const lease = leases.get(runId);
+        if (lease?.claim === void 0 || !sameOwner(lease.claim.id, staleClaimant) || lease.claim.claimedAtMs !== grantedAtMs) {
+          return rejected("claim_changed");
+        }
+        if (lease.claim.claimedAtMs >= nowMs - staleAfterMs) return rejected("claim_fresh");
+        lease.claim = void 0;
+        prune(runId, lease);
+        return recovered;
+      })
+    ),
+    guard: Effect.fn("Consensus.guard")(
+      (runId, owner) => Effect.suspend(() => {
+        const lease = leases.get(runId);
+        return lease?.owner !== void 0 && sameOwner(lease.owner.id, owner) ? Effect.void : Effect.fail(fenceLost(runId, owner));
+      })
+    )
+  });
+});
+const layerLocal = Layer.effect(Consensus, makeLocal);
+//# sourceMappingURL=Consensus.js.map

package/dist/cjs/Consensus.js.map

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