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

package/dist/cjs/SqlJournal.js

@@ -0,0 +1,1568 @@
+"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 SqlJournal_exports = {};
+__export(SqlJournal_exports, {
+  layer: () => layer,
+  layerWith: () => layerWith,
+  make: () => make
+});
+module.exports = __toCommonJS(SqlJournal_exports);
+var Dialect = __toESM(require("@smthrs/database/Dialect"), 1);
+var import_DurableWriter = require("@smthrs/database/DurableWriter");
+var Cause = __toESM(require("effect/Cause"), 1);
+var Clock = __toESM(require("effect/Clock"), 1);
+var Deferred = __toESM(require("effect/Deferred"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Exit = __toESM(require("effect/Exit"), 1);
+var Layer = __toESM(require("effect/Layer"), 1);
+var Metric = __toESM(require("effect/Metric"), 1);
+var Option = __toESM(require("effect/Option"), 1);
+var PubSub = __toESM(require("effect/PubSub"), 1);
+var Queue = __toESM(require("effect/Queue"), 1);
+var Result = __toESM(require("effect/Result"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+var Scope = __toESM(require("effect/Scope"), 1);
+var Semaphore = __toESM(require("effect/Semaphore"), 1);
+var Stream = __toESM(require("effect/Stream"), 1);
+var SqlClient = __toESM(require("effect/unstable/sql/SqlClient"), 1);
+var import_Consensus = require("./Consensus.js");
+var import_JournalInternalFault = require("./internal/JournalInternalFault.js");
+var import_Journal = require("./Journal.js");
+var import_JournalEvent = require("./JournalEvent.js");
+var JournalGeneration = __toESM(require("./JournalGeneration.js"), 1);
+var JournalMetrics = __toESM(require("./JournalMetrics.js"), 1);
+var import_OwnerId = require("./OwnerId.js");
+var Redaction = __toESM(require("./Redaction.js"), 1);
+var SqlConsensus = __toESM(require("./SqlConsensus.js"), 1);
+const UnknownFromJsonString = Schema.fromJsonString(Schema.Unknown);
+const defaultSourceEventCache = 4096;
+const compactionCaptureTimeout = "30 seconds";
+const error = (code, message, cause) => new import_Journal.JournalError({
+  code,
+  message,
+  ...cause === void 0 ? {} : { cause }
+});
+const sourceKey = (runId, sourceId) => `${runId.length}:${runId}${sourceId.length}:${sourceId}`;
+const sourceEventKey = (runId, sourceId, sourceSeq) => `${sourceKey(runId, sourceId)}:${sourceSeq}`;
+const canonicalizeFingerprint = (value, depth) => {
+  if (depth > Redaction.maxDepth) {
+    throw new RangeError(`journal value nests deeper than ${Redaction.maxDepth} containers`);
+  }
+  if (Array.isArray(value)) return value.map((element) => canonicalizeFingerprint(element, depth + 1));
+  if (value === null || typeof value !== "object") return value;
+  const record = value;
+  return Object.fromEntries(
+    Object.keys(record).sort().map((key) => [key, canonicalizeFingerprint(record[key], depth + 1)])
+  );
+};
+const encodeJson = (value, field) => Schema.encodeUnknownResult(UnknownFromJsonString)(value).pipe(
+  Result.mapError((cause) => error("invalid_event", `${field} must be JSON-serializable`, cause))
+);
+const encodeFingerprint = (value, field) => Result.flatMap(encodeJson(value, field), (json) => Result.try({
+  try: () => JSON.stringify(canonicalizeFingerprint(JSON.parse(json), 0)),
+  catch: (cause) => error("invalid_event", `${field} could not be canonicalized`, cause)
+}));
+const unfenced = { _tag: "Unfenced" };
+const decodeOwner = Schema.decodeUnknownResult(import_OwnerId.OwnerId);
+const requireFence = (owner, method) => Result.match(decodeOwner(owner), {
+  onFailure: (cause) => Result.fail(error("invalid_event", `${method} requires a well-formed owner fence`, cause)),
+  onSuccess: (value) => Result.succeed({ _tag: "Owned", owner: value })
+});
+const decodeInput = Schema.decodeUnknownResult(import_JournalEvent.Input);
+const decodeEntry = Schema.decodeUnknownEffect(import_JournalEvent.Entry);
+const decodeEntriesOptions = Schema.decodeUnknownResult(import_Journal.EntriesOptions);
+const decodeStreamOptions = Schema.decodeUnknownResult(import_Journal.StreamOptions);
+const decodeCheckpointOptions = Schema.decodeUnknownResult(import_Journal.CheckpointOptions);
+const decodeCompactOptions = Schema.decodeUnknownResult(import_Journal.CompactOptions);
+const decodeRunId = Schema.decodeUnknownResult(import_JournalEvent.RunId);
+const decodeRow = (row) => Effect.all({
+  payload: Schema.decodeUnknownEffect(UnknownFromJsonString)(row.payload_json),
+  meta: Schema.decodeUnknownEffect(UnknownFromJsonString)(row.meta_json)
+}).pipe(
+  Effect.map(({ meta, payload }) => ({
+    runId: row.run_id,
+    seq: Number(row.seq),
+    eventId: row.event_id,
+    sourceId: row.source_id,
+    sourceSeq: Number(row.source_seq),
+    emittedAtMs: Number(row.emitted_at_ms),
+    eventType: row.event_type,
+    payload,
+    meta
+  })),
+  Effect.flatMap(decodeEntry),
+  Effect.mapError((cause) => error("decode_failed", "could not decode a durable journal row", cause))
+);
+const decodeCheckpoint = Schema.decodeUnknownEffect(import_Journal.Checkpoint);
+const decodeCheckpointRow = (row) => Schema.decodeUnknownEffect(UnknownFromJsonString)(row.state_json).pipe(
+  Effect.flatMap(
+    (state) => decodeCheckpoint({
+      runId: row.run_id,
+      seq: Number(row.seq),
+      state,
+      createdAtMs: Number(row.created_at_ms),
+      compactedAtMs: row.compacted_at_ms === null ? null : Number(row.compacted_at_ms)
+    })
+  ),
+  Effect.mapError((cause) => error("decode_failed", "could not decode a durable checkpoint row", cause))
+);
+const freezePublished = (value) => {
+  const seen = /* @__PURE__ */ new WeakSet();
+  const walk = (node) => {
+    if (node === null || typeof node !== "object") return;
+    if (seen.has(node)) return;
+    seen.add(node);
+    for (const key of Reflect.ownKeys(node)) {
+      walk(node[key]);
+    }
+    Object.freeze(node);
+  };
+  walk(value);
+  return value;
+};
+const encodedBytes = (encoder, payloadJson, metaJson) => encoder.encode(payloadJson).length + encoder.encode(metaJson).length;
+const validateOptions = (options) => Effect.suspend(() => {
+  if (!Number.isSafeInteger(options.capacity) || options.capacity <= 0) {
+    return Effect.fail(error("invalid_event", "capacity must be a positive safe integer"));
+  }
+  const batchSize = options.batchSize ?? Math.min(options.capacity, 64);
+  if (!Number.isSafeInteger(batchSize) || batchSize <= 0) {
+    return Effect.fail(error("invalid_event", "batchSize must be a positive safe integer"));
+  }
+  const sourceEventCache = options.sourceEventCache ?? defaultSourceEventCache;
+  if (!Number.isSafeInteger(sourceEventCache) || sourceEventCache <= 0) {
+    return Effect.fail(error("invalid_event", "sourceEventCache must be a positive safe integer"));
+  }
+  if (options.maxEntryBytes !== void 0 && (!Number.isSafeInteger(options.maxEntryBytes) || options.maxEntryBytes <= 0)) {
+    return Effect.fail(error("invalid_event", "maxEntryBytes must be a positive safe integer"));
+  }
+  if (options.compaction !== void 0 && (!Number.isSafeInteger(options.compaction.entryThreshold) || options.compaction.entryThreshold <= 0)) {
+    return Effect.fail(error("invalid_event", "compaction.entryThreshold must be a positive safe integer"));
+  }
+  return Effect.succeed({
+    batchSize,
+    sourceEventCache,
+    maxEntryBytes: options.maxEntryBytes,
+    redact: options.redact ?? Redaction.make()
+  });
+});
+const isJournalError = Schema.is(import_Journal.JournalError);
+const make = (options) => Effect.gen(function* () {
+  const { batchSize, maxEntryBytes, redact, sourceEventCache } = yield* validateOptions(options);
+  const readPageSize = Math.min(batchSize, import_Journal.maxEntriesLimit);
+  const sql = yield* Effect.service(SqlClient.SqlClient);
+  const writer = yield* import_DurableWriter.DurableWriter;
+  const consensus = yield* import_Consensus.Consensus;
+  yield* JournalGeneration.initialize.pipe(
+    Effect.mapError((cause) => error("read_failed", "could not initialize journal generations", cause))
+  );
+  const byteCounter = new TextEncoder();
+  const contentFingerprint = (eventType, payloadJson, metaJson) => Effect.tryPromise({
+    try: () => crypto.subtle.digest("SHA-256", byteCounter.encode(JSON.stringify([eventType, payloadJson, metaJson]))),
+    catch: (cause) => error("sink_failed", "could not fingerprint journal content", cause)
+  }).pipe(
+    Effect.map(
+      (digest) => Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("")
+    )
+  );
+  const queue = yield* Queue.dropping(options.capacity);
+  const changes = yield* PubSub.sliding(options.capacity);
+  const wakes = /* @__PURE__ */ new Map();
+  const readers = /* @__PURE__ */ new Map();
+  const sourceEventRows = yield* sql`
+        SELECT run_id, seq, event_id, source_id, source_seq, emitted_at_ms,
+          event_type, payload_json, meta_json
+        FROM flows_journal_events
+        ORDER BY emitted_at_ms DESC, run_id DESC, seq DESC
+        LIMIT ${sourceEventCache}
+      `.pipe(
+    Effect.mapError((cause) => error("sink_failed", "could not initialize journal source events", cause))
+  );
+  const durableEntries = yield* Effect.forEach(sourceEventRows, decodeRow);
+  const initialized = yield* Effect.fromResult(
+    Result.gen(function* () {
+      const sequences = /* @__PURE__ */ new Map();
+      const sourceSequences = /* @__PURE__ */ new Map();
+      const sourceEvents = /* @__PURE__ */ new Map();
+      for (const entry of [...durableEntries].reverse()) {
+        if (!Number.isSafeInteger(entry.seq) || !Number.isSafeInteger(entry.sourceSeq) || entry.seq === Number.MAX_SAFE_INTEGER || entry.sourceSeq === Number.MAX_SAFE_INTEGER) {
+          return yield* Result.fail(
+            error("decode_failed", "durable event sequence is outside the allocatable safe integer range")
+          );
+        }
+        sourceEvents.set(sourceEventKey(entry.runId, entry.sourceId, entry.sourceSeq), {
+          seq: entry.seq,
+          eventType: entry.eventType,
+          payloadJson: yield* encodeFingerprint(entry.payload, "payload"),
+          metaJson: yield* encodeFingerprint(entry.meta, "meta"),
+          status: "committed"
+        });
+      }
+      return {
+        sequences,
+        sourceSequences,
+        sourceEvents
+      };
+    })
+  );
+  const state = {
+    status: "open",
+    sinkFailure: void 0,
+    lossEpoch: 0,
+    flushedLossEpoch: 0,
+    pending: 0,
+    pendingByRun: /* @__PURE__ */ new Map(),
+    sequences: initialized.sequences,
+    sourceSequences: initialized.sourceSequences,
+    sourceEvents: initialized.sourceEvents,
+    flushWaiters: /* @__PURE__ */ new Set()
+  };
+  const allocation = yield* Semaphore.make(1);
+  const maintenanceScope = yield* Scope.make();
+  yield* Effect.addFinalizer((exit) => Scope.close(maintenanceScope, exit));
+  let pendingMaintenance = 0;
+  const compactionCounts = /* @__PURE__ */ new Map();
+  const compactingRuns = /* @__PURE__ */ new Set();
+  const runBarriers = /* @__PURE__ */ new Map();
+  const runDrainWaiters = /* @__PURE__ */ new Map();
+  const activeWritesByRun = /* @__PURE__ */ new Map();
+  const barrierFor = (runId) => {
+    const existing = runBarriers.get(runId);
+    if (existing !== void 0) return existing;
+    const created = {
+      semaphore: Semaphore.makeUnsafe(1),
+      compactionLock: Semaphore.makeUnsafe(1),
+      maintenance: Semaphore.makeUnsafe(1),
+      users: 0,
+      compaction: void 0
+    };
+    runBarriers.set(runId, created);
+    return created;
+  };
+  const withRunBarrier = (runId, use) => Effect.suspend(() => {
+    const barrier = barrierFor(runId);
+    barrier.users += 1;
+    return use(barrier).pipe(Effect.ensuring(Effect.sync(() => {
+      barrier.users -= 1;
+    })));
+  });
+  const retireQuiescentRuns = () => {
+    for (const [runId, barrier] of runBarriers) {
+      if (barrier.users > 0 || barrier.compaction !== void 0 || state.pendingByRun.has(runId) || activeWritesByRun.has(runId) || runDrainWaiters.has(runId) || readers.has(runId) || wakes.has(runId) || compactingRuns.has(runId)) continue;
+      runBarriers.delete(runId);
+      compactionCounts.delete(runId);
+    }
+  };
+  const withRunAdmission = (runId, effect) => withRunBarrier(runId, (barrier) => barrier.semaphore.withPermit(
+    Effect.suspend(() => {
+      const gate = barrier.compaction;
+      return gate === void 0 ? Effect.map(effect, (value) => ({ _tag: "Done", value })) : Effect.succeed({ _tag: "Wait", gate });
+    })
+  ).pipe(
+    Effect.flatMap(
+      (attempt) => attempt._tag === "Done" ? Effect.succeed(attempt.value) : Deferred.await(attempt.gate).pipe(
+        Effect.andThen(withRunAdmission(runId, effect))
+      )
+    )
+  ));
+  const withRunPermits = (runIds, effect) => {
+    const ordered = [...new Set(runIds)].sort();
+    const acquire = (index) => index === ordered.length ? effect : withRunBarrier(ordered[index], (barrier) => barrier.semaphore.withPermit(acquire(index + 1)));
+    return acquire(0);
+  };
+  const admitRunPending = (queued) => {
+    const pending = state.pendingByRun.get(queued.runId) ?? /* @__PURE__ */ new Set();
+    pending.add(queued);
+    state.pendingByRun.set(queued.runId, pending);
+  };
+  const completeRunDrain = (runId) => {
+    if ((state.pendingByRun.get(runId)?.size ?? 0) + (activeWritesByRun.get(runId) ?? 0) > 0) return;
+    const waiters = runDrainWaiters.get(runId);
+    runDrainWaiters.delete(runId);
+    for (const waiter of waiters ?? []) {
+      Deferred.doneUnsafe(waiter, Effect.void);
+    }
+  };
+  const settleRunPending = (batch) => {
+    for (const queued of batch) {
+      const pending = state.pendingByRun.get(queued.runId);
+      pending.delete(queued);
+      if (pending.size > 0) continue;
+      state.pendingByRun.delete(queued.runId);
+      completeRunDrain(queued.runId);
+    }
+  };
+  const endRunWrite = (runId) => {
+    const remaining = activeWritesByRun.get(runId) - 1;
+    if (remaining > 0) {
+      activeWritesByRun.set(runId, remaining);
+      return;
+    }
+    activeWritesByRun.delete(runId);
+    completeRunDrain(runId);
+  };
+  const withActiveRunWrite = (runId, effect) => withRunBarrier(runId, () => Effect.suspend(() => {
+    activeWritesByRun.set(runId, (activeWritesByRun.get(runId) ?? 0) + 1);
+    return effect.pipe(Effect.ensuring(Effect.sync(() => endRunWrite(runId))));
+  }));
+  const awaitRunDrained = (runId) => Effect.suspend(() => {
+    if ((state.pendingByRun.get(runId)?.size ?? 0) + (activeWritesByRun.get(runId) ?? 0) === 0) {
+      return Effect.void;
+    }
+    const waiter = Deferred.makeUnsafe();
+    const waiters = runDrainWaiters.get(runId) ?? /* @__PURE__ */ new Set();
+    waiters.add(waiter);
+    runDrainWaiters.set(runId, waiters);
+    return Deferred.await(waiter);
+  });
+  const withCompactionBarrier = (runId, effect) => Effect.flatMap(Effect.serviceOption(sql.transactionService), (enclosing) => withRunBarrier(runId, (barrier) => {
+    const nested = Option.isSome(enclosing);
+    const attempt = (nested ? Effect.void : awaitRunDrained(runId)).pipe(
+      Effect.andThen(writer.write(
+        barrier.compactionLock.withPermit(Effect.uninterruptibleMask(
+          (restore) => barrier.semaphore.withPermit(Effect.sync(() => {
+            if (!nested && (state.pendingByRun.get(runId)?.size ?? 0) + (activeWritesByRun.get(runId) ?? 0) > 0) {
+              return void 0;
+            }
+            const gate = Deferred.makeUnsafe();
+            barrier.compaction = gate;
+            return gate;
+          })).pipe(Effect.flatMap(
+            (gate) => gate === void 0 ? Effect.succeed(Option.none()) : restore(Effect.gen(function* () {
+              if (nested) {
+                const outcome = yield* insertBatch([...state.pendingByRun.get(runId) ?? []]);
+                for (const { queued, commit } of outcome.commits) {
+                  yield* settleCommit(queued, commit, restore);
+                }
+              }
+              return yield* Effect.asSome(effect);
+            })).pipe(Effect.ensuring(Effect.sync(() => {
+              barrier.compaction = void 0;
+              Deferred.doneUnsafe(gate, Effect.void);
+            })))
+          ))
+        ))
+      )),
+      Effect.flatMap(
+        (result) => Option.isSome(result) ? Effect.succeed(result.value) : attempt
+      )
+    );
+    return attempt;
+  }));
+  const raiseSequenceFloor = (runId, seq) => {
+    state.sequences.set(runId, Math.max(state.sequences.get(runId) ?? 0, seq + 1));
+  };
+  const raiseSourceSequenceFloor = (runId, sourceId, sourceSeq) => {
+    const key = sourceKey(runId, sourceId);
+    state.sourceSequences.set(key, Math.max(state.sourceSequences.get(key) ?? 0, sourceSeq + 1));
+  };
+  const retain = (identity, event) => {
+    state.sourceEvents.delete(identity);
+    state.sourceEvents.set(identity, event);
+    if (state.sourceEvents.size <= sourceEventCache) {
+      return;
+    }
+    for (const [candidate, retained] of state.sourceEvents) {
+      if (retained.status !== "committed" || candidate === identity) {
+        continue;
+      }
+      state.sourceEvents.delete(candidate);
+      return;
+    }
+  };
+  const completeFlushWaiters = (exit) => {
+    const waiters = Array.from(state.flushWaiters);
+    state.flushWaiters.clear();
+    for (const waiter of waiters) {
+      Deferred.doneUnsafe(waiter, exit);
+    }
+  };
+  const flushInternal = Effect.suspend(() => {
+    if (state.sinkFailure !== void 0 && state.lossEpoch > state.flushedLossEpoch) {
+      state.flushedLossEpoch = state.lossEpoch;
+      return Effect.fail(state.sinkFailure);
+    }
+    if (state.status === "closed") {
+      return Effect.fail(error("journal_closed", "journal is closed"));
+    }
+    if (state.pending === 0 && pendingMaintenance === 0) {
+      return Effect.void;
+    }
+    const waiter = Deferred.makeUnsafe();
+    state.flushWaiters.add(waiter);
+    return Deferred.await(waiter).pipe(
+      Effect.ensuring(Effect.sync(() => {
+        state.flushWaiters.delete(waiter);
+      }))
+    );
+  }).pipe(Effect.ensuring(Effect.sync(retireQuiescentRuns)));
+  const prepare = (input, emittedAtMs) => Result.gen(function* () {
+    if (state.status !== "open") {
+      return yield* Result.fail(error("journal_closed", "journal is closed"));
+    }
+    const validated = yield* Result.mapError(
+      decodeInput(input),
+      (cause) => error("invalid_event", "event violates the journal input contract", cause)
+    );
+    if (!Number.isSafeInteger(emittedAtMs) || emittedAtMs < 0) {
+      return yield* Result.fail(
+        error("invalid_event", "emittedAtMs must be a non-negative safe integer")
+      );
+    }
+    const redactedPayload = yield* Result.try({
+      try: () => redact(validated.payload),
+      catch: () => error("invalid_event", "payload could not be redacted")
+    });
+    const redactedMeta = yield* Result.try({
+      try: () => redact(validated.meta ?? null),
+      catch: () => error("invalid_event", "meta could not be redacted")
+    });
+    const payloadJson = yield* encodeFingerprint(redactedPayload, "payload");
+    const metaJson = yield* encodeFingerprint(redactedMeta, "meta");
+    if (maxEntryBytes !== void 0) {
+      const bytes = encodedBytes(byteCounter, payloadJson, metaJson);
+      if (bytes > maxEntryBytes) {
+        return yield* Result.fail(
+          error(
+            "invalid_event",
+            `event is ${bytes} bytes, over the ${maxEntryBytes}-byte maxEntryBytes bound`
+          )
+        );
+      }
+    }
+    return { validated, payloadJson, metaJson };
+  });
+  const compareSourceEvent = (prepared, sourceSeq, existing) => {
+    const { metaJson, payloadJson, validated } = prepared;
+    if (validated.dedupe !== "identity" && (existing.eventType !== validated.eventType || existing.payloadJson !== payloadJson || existing.metaJson !== metaJson)) {
+      return Result.fail(error(
+        "idempotency_conflict",
+        `source event ${validated.sourceId}:${sourceSeq} for run ${validated.runId} was reused with different content`
+      ));
+    }
+    return Result.succeed({
+      _tag: "Duplicate",
+      seq: existing.seq,
+      sourceSeq,
+      status: existing.status
+    });
+  };
+  const admitFromIndex = (prepared) => {
+    const { validated } = prepared;
+    const sourceSeq = validated.sourceSeq;
+    if (sourceSeq === void 0) return Result.succeed(void 0);
+    if (!Number.isSafeInteger(sourceSeq) || sourceSeq < 0 || sourceSeq === Number.MAX_SAFE_INTEGER) {
+      return Result.fail(
+        error("invalid_event", "journal sequence is outside the allocatable safe integer range")
+      );
+    }
+    const cached = state.sourceEvents.get(sourceEventKey(validated.runId, validated.sourceId, sourceSeq));
+    return cached === void 0 ? Result.succeed(void 0) : compareSourceEvent(prepared, sourceSeq, cached);
+  };
+  const admitQueued = (prepared, floors, emittedAtMs) => Effect.suspend(() => {
+    if (state.status !== "open") {
+      return Effect.fail(error("journal_closed", "journal is closed"));
+    }
+    return Effect.flatMap(
+      Effect.fromResult(admitFromIndex(prepared)),
+      (indexed) => indexed !== void 0 ? Effect.succeed(indexed) : allocation.withPermit(Effect.fromResult(
+        Result.gen(function* () {
+          const { metaJson, payloadJson, validated } = prepared;
+          const key = sourceKey(validated.runId, validated.sourceId);
+          const nextSourceSeq = Math.max(
+            floors.sourceSeq,
+            state.sourceSequences.get(key) ?? 0
+          );
+          const sourceSeq = validated.sourceSeq ?? nextSourceSeq;
+          if (sourceSeq === Number.MAX_SAFE_INTEGER) {
+            return yield* Result.fail(
+              error(
+                "invalid_event",
+                "journal sequence is outside the allocatable safe integer range"
+              )
+            );
+          }
+          const nextSeq = Math.max(
+            floors.seq,
+            state.sequences.get(validated.runId) ?? 0
+          );
+          if (nextSeq === Number.MAX_SAFE_INTEGER) {
+            return yield* Result.fail(
+              error(
+                "invalid_event",
+                "journal sequence is outside the allocatable safe integer range"
+              )
+            );
+          }
+          const seq = nextSeq;
+          raiseSequenceFloor(validated.runId, seq);
+          state.sourceSequences.set(key, Math.max(nextSourceSeq, sourceSeq + 1));
+          const queued = {
+            runId: validated.runId,
+            seq,
+            eventId: (0, import_JournalEvent.makeEventId)(validated.runId, validated.sourceId, sourceSeq),
+            sourceId: validated.sourceId,
+            sourceSeq,
+            emittedAtMs,
+            eventType: validated.eventType,
+            payloadJson,
+            metaJson,
+            dedupe: validated.dedupe ?? "content"
+          };
+          let evicted;
+          if (Queue.sizeUnsafe(queue) >= options.capacity && options.overflow === "drop-oldest") {
+            const exit = Queue.takeUnsafe(queue);
+            if (exit === void 0 || !Exit.isSuccess(exit)) {
+              return yield* Result.fail(
+                error("journal_closed", "journal admission queue is unavailable")
+              );
+            }
+            evicted = exit.value;
+            const evictedIdentity = sourceEventKey(
+              evicted.runId,
+              evicted.sourceId,
+              evicted.sourceSeq
+            );
+            state.sourceEvents.delete(evictedIdentity);
+            state.pending = Math.max(0, state.pending - 1);
+            settleRunPending([evicted]);
+          }
+          const accepted = Queue.offerUnsafe(queue, queued);
+          if (!accepted) {
+            if (options.overflow === "reject") {
+              return yield* Result.fail(
+                error("queue_overflow", "journal admission queue is full")
+              );
+            }
+            return {
+              _tag: "Dropped",
+              seq,
+              sourceSeq,
+              policy: "drop-newest"
+            };
+          }
+          retain(sourceEventKey(validated.runId, validated.sourceId, sourceSeq), {
+            seq,
+            eventType: validated.eventType,
+            payloadJson,
+            metaJson,
+            status: "pending"
+          });
+          state.pending += 1;
+          admitRunPending(queued);
+          if (evicted !== void 0) {
+            return {
+              _tag: "Accepted",
+              seq,
+              sourceSeq,
+              evicted: {
+                policy: "drop-oldest",
+                count: 1
+              }
+            };
+          }
+          return {
+            _tag: "Accepted",
+            seq,
+            sourceSeq
+          };
+        })
+      ))
+    );
+  });
+  const queuedEmit = Effect.fn("Journal.emitLossy")(
+    (input) => Effect.annotateCurrentSpan({
+      runId: input.runId,
+      sourceId: input.sourceId,
+      eventType: input.eventType
+    }).pipe(
+      Effect.andThen(Clock.currentTimeMillis.pipe(Effect.map(Math.floor))),
+      Effect.flatMap(
+        (emittedAtMs) => Effect.flatMap(
+          withRunAdmission(
+            input.runId,
+            Effect.suspend(
+              () => Effect.fromResult(Result.gen(function* () {
+                const prepared = yield* prepare(input, emittedAtMs);
+                const indexed = yield* admitFromIndex(prepared);
+                return { prepared, indexed };
+              }))
+            )
+          ),
+          ({ prepared, indexed }) => (
+            // A cached duplicate needs neither allocation floor, including
+            // after startup when the identity index is warm but floors are
+            // cold. On a miss, release the permit before reading SQL, then
+            // recheck identity and allocation under a fresh admission.
+            indexed !== void 0 ? Effect.succeed(indexed) : Effect.flatMap(
+              ensureFloors(prepared.validated),
+              (floors) => withRunAdmission(prepared.validated.runId, admitQueued(prepared, floors, emittedAtMs))
+            )
+          )
+        )
+      ),
+      Effect.tap((receipt) => Metric.update(JournalMetrics.lossy[receipt._tag], 1))
+    )
+  );
+  const compactionFloor = (runId) => Effect.map(
+    sql`
+            SELECT MAX(seq) AS floor FROM flows_journal_checkpoints
+            WHERE run_id = ${runId} AND compacted_at_ms IS NOT NULL
+          `,
+    (rows) => {
+      const floor = rows[0]?.floor;
+      return floor === null || floor === void 0 ? void 0 : Number(floor);
+    }
+  );
+  const readPage = Effect.fn("Journal.entries")(
+    (pageOptions) => Effect.gen(function* () {
+      const options2 = {
+        ...pageOptions,
+        ...Array.isArray(pageOptions.eventTypes) ? { eventTypes: [...pageOptions.eventTypes] } : {}
+      };
+      yield* Effect.annotateCurrentSpan({
+        runId: options2.runId,
+        limit: options2.limit,
+        ...options2.eventTypes === void 0 ? {} : { eventTypes: options2.eventTypes },
+        ...options2.after === void 0 ? {} : { after: options2.after }
+      });
+      yield* Effect.fromResult(Result.mapError(
+        decodeEntriesOptions(options2),
+        (cause) => error("invalid_event", "entries options violate the journal read contract", cause)
+      ));
+      const after = options2.after ?? -1;
+      const rows = yield* (options2.eventTypes === void 0 ? sql`
+            SELECT run_id, seq, event_id, source_id, source_seq, emitted_at_ms,
+              event_type, payload_json, meta_json
+            FROM flows_journal_events
+            WHERE run_id = ${options2.runId} AND seq > ${after}
+            ORDER BY seq ASC
+            LIMIT ${options2.limit + 1}
+          ` : sql`
+            SELECT run_id, seq, event_id, source_id, source_seq, emitted_at_ms,
+              event_type, payload_json, meta_json
+            FROM flows_journal_events ${Dialect.indexHint(sql, "flows_journal_events_run_event_type_idx")}
+            WHERE run_id = ${options2.runId} AND ${sql.in("event_type", options2.eventTypes)} AND seq > ${after}
+            ORDER BY seq ASC
+            LIMIT ${options2.limit + 1}
+          `).pipe(
+        Effect.mapError((cause) => error("read_failed", "durable journal read failed", cause))
+      );
+      const floor = yield* compactionFloor(options2.runId).pipe(
+        Effect.mapError((cause) => error("read_failed", "durable journal read failed", cause))
+      );
+      if (floor !== void 0 && after < floor - 1) {
+        return yield* Effect.fail(
+          new import_Journal.JournalError({
+            code: "compacted",
+            message: `run ${options2.runId} is compacted through sequence ${floor}; resync from its checkpoint`,
+            checkpointSeq: floor
+          })
+        );
+      }
+      const page = rows.slice(0, options2.limit);
+      const entries = yield* Effect.forEach(page, decodeRow);
+      return {
+        entries,
+        hasMore: rows.length > options2.limit
+      };
+    })
+  );
+  const subscribeRun = (runId) => Effect.gen(function* () {
+    const wake = yield* PubSub.sliding(1);
+    const subscription = yield* PubSub.subscribe(wake);
+    yield* Effect.acquireRelease(
+      Effect.sync(() => {
+        const subscribers = wakes.get(runId) ?? /* @__PURE__ */ new Set();
+        subscribers.add(wake);
+        wakes.set(runId, subscribers);
+      }),
+      () => Effect.sync(() => {
+        const subscribers = wakes.get(runId);
+        subscribers?.delete(wake);
+        if (subscribers?.size === 0) {
+          wakes.delete(runId);
+        }
+      }).pipe(Effect.andThen(PubSub.shutdown(wake)))
+    );
+    return subscription;
+  });
+  const stream = (streamOptions) => Stream.unwrap(
+    Effect.fn("Journal.stream")(function* () {
+      yield* Effect.annotateCurrentSpan({
+        runId: streamOptions.runId,
+        ...streamOptions.afterSequence === void 0 ? {} : { afterSequence: streamOptions.afterSequence }
+      });
+      yield* Effect.fromResult(Result.mapError(
+        decodeStreamOptions(streamOptions),
+        (cause) => error("invalid_event", "stream options violate the journal read contract", cause)
+      ));
+      const wake = yield* subscribeRun(streamOptions.runId);
+      const reader = { cursor: streamOptions.afterSequence ?? -1 };
+      yield* Effect.acquireRelease(
+        Effect.sync(() => {
+          const registered = readers.get(streamOptions.runId) ?? /* @__PURE__ */ new Set();
+          registered.add(reader);
+          readers.set(streamOptions.runId, registered);
+        }),
+        () => Effect.sync(() => {
+          const registered = readers.get(streamOptions.runId);
+          registered?.delete(reader);
+          if (registered?.size === 0) {
+            readers.delete(streamOptions.runId);
+          }
+        })
+      );
+      const subscribedLossEpoch = state.lossEpoch;
+      const readPages = (initialCursor) => Stream.paginate(initialCursor, (cursor) => Effect.suspend(
+        () => state.sinkFailure !== void 0 && state.lossEpoch > subscribedLossEpoch ? Effect.fail(state.sinkFailure) : readPage({
+          runId: streamOptions.runId,
+          ...cursor < 0 ? {} : { after: cursor },
+          limit: readPageSize
+        })
+      ).pipe(
+        Effect.map((page) => {
+          const last = page.entries.at(-1);
+          if (last !== void 0) {
+            reader.cursor = last.seq;
+          }
+          return [
+            page.entries,
+            page.hasMore ? Option.some(reader.cursor) : Option.none()
+          ];
+        })
+      ));
+      const historical = readPages(reader.cursor);
+      const live = Stream.fromEffectRepeat(
+        Effect.raceFirst(PubSub.take(wake), Effect.sleep("1 second"))
+      ).pipe(Stream.flatMap(
+        () => readPages(reader.cursor)
+      ));
+      return Stream.concat(historical, live);
+    })()
+  );
+  const fenceGuard = (runId, owner) => consensus.guard(runId, owner).pipe(
+    Effect.mapError(
+      (cause) => cause.code === "fence_lost" ? error("fence_lost", cause.message) : error("sink_failed", "consensus guard failed", cause)
+    )
+  );
+  const selectExisting = (queued) => Effect.gen(function* () {
+    const existing = yield* sql`
+            SELECT run_id, seq, event_id, source_id, source_seq, emitted_at_ms,
+              event_type, payload_json, meta_json, NULL AS content_hash
+            FROM flows_journal_events
+            WHERE event_id = ${queued.eventId}
+              OR (
+                run_id = ${queued.runId}
+                AND source_id = ${queued.sourceId}
+                AND source_seq = ${queued.sourceSeq}
+              )
+            UNION ALL
+            SELECT run_id, seq, event_id, source_id, source_seq, 0 AS emitted_at_ms,
+              '' AS event_type, '' AS payload_json, '' AS meta_json, content_hash
+            FROM flows_journal_dedup
+            WHERE event_id = ${queued.eventId}
+              OR (
+                run_id = ${queued.runId}
+                AND source_id = ${queued.sourceId}
+                AND source_seq = ${queued.sourceSeq}
+              )
+            ORDER BY seq ASC
+            LIMIT 1
+          `;
+    if (existing.length === 0) {
+      return void 0;
+    }
+    const row = existing[0];
+    if (queued.dedupe !== "identity" && (row.content_hash === null ? row.event_type !== queued.eventType || row.payload_json !== queued.payloadJson || row.meta_json !== queued.metaJson : row.content_hash !== (yield* contentFingerprint(queued.eventType, queued.payloadJson, queued.metaJson)))) {
+      return yield* Effect.fail(
+        error(
+          "idempotency_conflict",
+          `source event ${queued.sourceId}:${queued.sourceSeq} for run ${queued.runId} was reused with different content`
+        )
+      );
+    }
+    return {
+      entry: row.content_hash === null ? yield* decodeRow(row) : { seq: Number(row.seq) },
+      inserted: false
+    };
+  });
+  const insertOne = (queued, fence, enforceCompactionFloor = false) => Effect.gen(function* () {
+    if (fence._tag === "Owned") {
+      yield* fenceGuard(queued.runId, fence.owner);
+    } else if (!enforceCompactionFloor) {
+      const duplicate = yield* selectExisting(queued);
+      if (duplicate !== void 0) {
+        return duplicate;
+      }
+    }
+    const insert = enforceCompactionFloor ? sql`
+              INSERT INTO flows_journal_events (
+                run_id, seq, event_id, source_id, source_seq, emitted_at_ms,
+                event_type, payload_json, meta_json
+              )
+              SELECT
+                ${queued.runId},
+                (SELECT ${Dialect.greatest(sql)}(${queued.seq}, COALESCE(MAX(seq), -1) + 1)
+                  FROM flows_journal_events WHERE run_id = ${queued.runId}),
+                ${queued.eventId},
+                ${queued.sourceId},
+                ${queued.sourceSeq},
+                ${queued.emittedAtMs},
+                ${queued.eventType},
+                ${queued.payloadJson},
+                ${queued.metaJson}
+              WHERE NOT EXISTS (
+                SELECT 1 FROM flows_journal_checkpoints
+                WHERE run_id = ${queued.runId}
+                  AND compacted_at_ms IS NOT NULL
+                  AND seq >= ${queued.seq}
+              ) AND NOT EXISTS (
+                SELECT 1 FROM flows_journal_events
+                WHERE run_id = ${queued.runId} AND seq >= ${Number.MAX_SAFE_INTEGER - 1}
+              )
+              ON CONFLICT DO NOTHING
+              RETURNING run_id, seq, event_id, source_id, source_seq, emitted_at_ms,
+                event_type, payload_json, meta_json
+            ` : sql`
+              INSERT INTO flows_journal_events (
+                run_id, seq, event_id, source_id, source_seq, emitted_at_ms,
+                event_type, payload_json, meta_json
+              ) VALUES (
+                ${queued.runId},
+                ${queued.seq},
+                ${queued.eventId},
+                ${queued.sourceId},
+                ${queued.sourceSeq},
+                ${queued.emittedAtMs},
+                ${queued.eventType},
+                ${queued.payloadJson},
+                ${queued.metaJson}
+              )
+              ON CONFLICT DO NOTHING
+              RETURNING run_id, seq, event_id, source_id, source_seq, emitted_at_ms,
+                event_type, payload_json, meta_json
+            `;
+    const inserted = yield* insert;
+    if (inserted.length > 0) {
+      return {
+        entry: yield* decodeRow(inserted[0]),
+        inserted: true
+      };
+    }
+    const racedDuplicate = yield* selectExisting(queued);
+    if (racedDuplicate !== void 0) {
+      return racedDuplicate;
+    }
+    {
+      const floor = yield* compactionFloor(queued.runId);
+      if (floor !== void 0 && queued.seq <= floor) {
+        return yield* Effect.fail(
+          new import_Journal.JournalError({
+            code: "compacted",
+            message: `queued sequence ${queued.seq} for run ${queued.runId} was dropped below compaction floor ${floor}`,
+            checkpointSeq: floor
+          })
+        );
+      }
+    }
+    return yield* Effect.fail(
+      error(
+        "invalid_event",
+        "journal sequence is outside the allocatable safe integer range"
+      )
+    );
+  });
+  const insertBatch = (batch) => Effect.gen(function* () {
+    const results = yield* Effect.forEach(
+      batch,
+      (queued) => Effect.map(Effect.result(insertOne(queued, unfenced, true)), (result) => ({ queued, result }))
+    );
+    const commits = [];
+    const losses = [];
+    for (const settled of results) {
+      if (Result.isSuccess(settled.result)) {
+        commits.push({ queued: settled.queued, commit: settled.result.success });
+      } else if (isJournalError(settled.result.failure)) {
+        losses.push({ queued: settled.queued, cause: settled.result.failure });
+      } else {
+        return yield* Effect.fail(settled.result.failure);
+      }
+    }
+    return { commits, losses };
+  });
+  const persistBatch = (batch) => writer.write(withRunPermits(
+    batch.map((queued) => queued.runId),
+    insertBatch(batch)
+  )).pipe(
+    // Every per-entry `JournalError` is settled inside the transaction
+    // above, so the only failure that escapes is the transaction itself:
+    // a database outage, which is what `sink_failed` names.
+    Effect.mapError((cause) => error("sink_failed", "journal sink failed", cause))
+  );
+  const publish = (commits) => Effect.forEach(
+    commits,
+    (commit) => {
+      if (!commit.inserted) {
+        return Effect.void;
+      }
+      return PubSub.publish(changes, freezePublished(commit.entry)).pipe(
+        Effect.andThen(
+          Effect.forEach(
+            wakes.get(commit.entry.runId) ?? [],
+            (wake) => PubSub.publish(wake, void 0),
+            { discard: true }
+          )
+        ),
+        Effect.asVoid
+      );
+    },
+    { discard: true }
+  );
+  const rememberCommitted = (queued, seq) => {
+    retain(sourceEventKey(queued.runId, queued.sourceId, queued.sourceSeq), {
+      seq,
+      eventType: queued.eventType,
+      payloadJson: queued.payloadJson,
+      metaJson: queued.metaJson,
+      status: "committed"
+    });
+    raiseSequenceFloor(queued.runId, seq);
+    raiseSourceSequenceFloor(queued.runId, queued.sourceId, queued.sourceSeq);
+  };
+  const nextDurable = (column, runId, sourceId) => Effect.map(
+    column === "seq" ? sql`
+              SELECT MAX(seq) + 1 AS next FROM flows_journal_events WHERE run_id = ${runId}
+            ` : sql`
+              SELECT MAX(source_seq) + 1 AS next FROM (
+                SELECT MAX(source_seq) AS source_seq FROM flows_journal_events
+                WHERE run_id = ${runId} AND source_id = ${sourceId}
+                UNION ALL
+                SELECT MAX(source_seq) AS source_seq FROM flows_journal_dedup
+                WHERE run_id = ${runId} AND source_id = ${sourceId}
+              )
+            `,
+    (rows) => Number(rows[0]?.next ?? 0)
+  );
+  const ensureFloors = (input) => Effect.suspend(() => {
+    const runId = input.runId;
+    const key = sourceKey(runId, input.sourceId);
+    const seq = state.sequences.get(runId);
+    const sourceSeq = input.sourceSeq === void 0 ? state.sourceSequences.get(key) : 0;
+    if (seq !== void 0 && sourceSeq !== void 0) {
+      return Effect.succeed({ seq, sourceSeq });
+    }
+    return Effect.all({
+      seq: seq === void 0 ? nextDurable("seq", runId, void 0) : Effect.succeed(seq),
+      sourceSeq: sourceSeq === void 0 ? nextDurable("source_seq", runId, input.sourceId) : Effect.succeed(sourceSeq)
+    }).pipe(
+      Effect.mapError((cause) => error("sink_failed", "could not read journal allocation floor", cause)),
+      Effect.flatMap((floors) => {
+        if (!Number.isSafeInteger(floors.seq) || floors.seq < 0 || !Number.isSafeInteger(floors.sourceSeq) || floors.sourceSeq < 0) {
+          return Effect.fail(
+            error("invalid_event", "journal sequence is outside the allocatable safe integer range")
+          );
+        }
+        return Effect.succeed(floors);
+      })
+    );
+  });
+  const settleCommit = (queued, commit, restoreMaintenance) => Effect.gen(function* () {
+    const mandatory = Effect.sync(() => rememberCommitted(queued, commit.entry.seq)).pipe(
+      Effect.andThen(publish([commit]))
+    );
+    const maintenance = restoreMaintenance(noteCommitted(queued.runId, commit.inserted ? 1 : 0));
+    const enclosing = yield* Effect.serviceOption(sql.transactionService);
+    if (Option.isNone(enclosing)) {
+      yield* mandatory;
+      return maintenance;
+    }
+    yield* (0, import_DurableWriter.afterCommit)(mandatory.pipe(Effect.andThen(maintenance)), sql);
+    return Effect.void;
+  });
+  const transact = (effect) => writer.write(effect).pipe(
+    Effect.catchIf(
+      (cause) => cause instanceof import_DurableWriter.DatabaseError,
+      (cause) => Effect.fail(error("sink_failed", "journal transaction failed", cause))
+    )
+  );
+  const writeDurable = (input, fence) => Effect.uninterruptibleMask(
+    (restoreMaintenance) => restoreMaintenance(Effect.gen(function* () {
+      yield* Effect.annotateCurrentSpan({
+        runId: input.runId,
+        sourceId: input.sourceId,
+        eventType: input.eventType
+      });
+      const emittedAtMs = yield* Clock.currentTimeMillis.pipe(Effect.map(Math.floor));
+      const prepared = yield* Effect.fromResult(prepare(input, emittedAtMs));
+      const committed = yield* Effect.gen(function* () {
+        const { metaJson, payloadJson, validated } = prepared;
+        return yield* Effect.uninterruptibleMask(
+          (restore) => restore(writer.write(withActiveRunWrite(
+            prepared.validated.runId,
+            Effect.gen(function* () {
+              const durableSourceSeq = validated.sourceSeq === void 0 ? yield* nextDurable("source_seq", validated.runId, validated.sourceId) : 0;
+              const durableSeq = yield* nextDurable("seq", validated.runId, void 0);
+              const reserved = yield* allocation.withPermit(Effect.fromResult(Result.gen(function* () {
+                const key = sourceKey(validated.runId, validated.sourceId);
+                const sourceSeq2 = validated.sourceSeq ?? Math.max(
+                  durableSourceSeq,
+                  state.sourceSequences.get(key) ?? 0
+                );
+                if (!Number.isSafeInteger(sourceSeq2) || sourceSeq2 < 0 || sourceSeq2 === Number.MAX_SAFE_INTEGER) {
+                  return yield* Result.fail(
+                    error("invalid_event", "journal sequence is outside the allocatable safe integer range")
+                  );
+                }
+                const seq2 = Math.max(
+                  durableSeq,
+                  state.sequences.get(validated.runId) ?? 0
+                );
+                if (!Number.isSafeInteger(seq2) || seq2 === Number.MAX_SAFE_INTEGER) {
+                  return yield* Result.fail(
+                    error("invalid_event", "journal sequence is outside the allocatable safe integer range")
+                  );
+                }
+                raiseSequenceFloor(validated.runId, seq2);
+                raiseSourceSequenceFloor(validated.runId, validated.sourceId, sourceSeq2);
+                return { seq: seq2, sourceSeq: sourceSeq2 };
+              })));
+              const { seq, sourceSeq } = reserved;
+              const queued = {
+                runId: validated.runId,
+                seq,
+                eventId: (0, import_JournalEvent.makeEventId)(validated.runId, validated.sourceId, sourceSeq),
+                sourceId: validated.sourceId,
+                sourceSeq,
+                emittedAtMs,
+                eventType: validated.eventType,
+                payloadJson,
+                metaJson,
+                dedupe: validated.dedupe ?? "content"
+              };
+              const commit = yield* insertOne(queued, fence);
+              return { commit, queued, sourceSeq };
+            })
+          ))).pipe(
+            /**
+             * `writer.write` is a retrying transaction: its body replays on
+             * `SQLITE_BUSY(_SNAPSHOT)` and can still abort at COMMIT after the
+             * body succeeded. Cache mutation and publication therefore happen
+             * strictly after the transaction returns, so subscribers never
+             * observe a rolled-back entry and a replayed body never publishes
+             * twice. Mirrors the queued path, which publishes in a `.tap`
+             * outside `persistBatch`. Only the transaction is restored: an
+             * interruption that lands after it returns waits for the index
+             * update and publication, so a committed row always reaches
+             * `changes`.
+             *
+             * Under `transact` "after the transaction returns" is not yet
+             * "after COMMIT": this write is a savepoint of the caller's
+             * transaction, so `settleCommit` parks both effects until the
+             * outermost transaction commits. The active-write reference
+             * is released before that outer commit, which lets automatic
+             * compaction drain the run before its maintenance transaction.
+             */
+            Effect.flatMap(
+              (written) => Effect.gen(function* () {
+                const maintenance = yield* settleCommit(written.queued, written.commit, restoreMaintenance);
+                const receipt = written.commit.inserted ? { _tag: "Accepted", seq: written.commit.entry.seq, sourceSeq: written.sourceSeq } : {
+                  _tag: "Duplicate",
+                  seq: written.commit.entry.seq,
+                  sourceSeq: written.sourceSeq,
+                  status: "committed"
+                };
+                yield* Metric.update(JournalMetrics.durable[receipt._tag], 1);
+                return { maintenance, receipt };
+              })
+            )
+          )
+        );
+      }).pipe(
+        Effect.mapError(
+          (cause) => isJournalError(cause) ? cause : error("sink_failed", "durable journal write failed", cause)
+        )
+      );
+      yield* committed.maintenance;
+      return committed.receipt;
+    }))
+  );
+  const emitDurable = Effect.fn("Journal.emitDurable")(
+    (input, owner) => Effect.flatMap(
+      Effect.fromResult(requireFence(owner, "emitDurable")),
+      (fence) => writeDurable(input, fence)
+    )
+  );
+  const emitDurableUnfenced = Effect.fn("Journal.emitDurableUnfenced")((input) => writeDurable(input, unfenced));
+  const emitLossy = queuedEmit;
+  const checkpointInternal = (checkpointOptions, fence) => Effect.gen(function* () {
+    yield* Effect.annotateCurrentSpan({
+      runId: checkpointOptions.runId,
+      seq: checkpointOptions.seq
+    });
+    yield* Effect.fromResult(Result.mapError(
+      decodeCheckpointOptions(checkpointOptions),
+      (cause) => error("invalid_event", "checkpoint options violate the journal contract", cause)
+    ));
+    const stateJson = yield* Effect.fromResult(encodeJson(checkpointOptions.state, "state"));
+    const receiptState = yield* Schema.decodeUnknownEffect(UnknownFromJsonString)(stateJson).pipe(
+      Effect.mapError(
+        /* v8 ignore next -- encodeJson produced these valid JSON bytes immediately above */
+        (cause) => error("decode_failed", "could not decode persisted checkpoint state", cause)
+      )
+    );
+    const createdAtMs = yield* Clock.currentTimeMillis.pipe(Effect.map(Math.floor));
+    return yield* writer.write(Effect.gen(function* () {
+      if (fence._tag === "Owned") {
+        yield* fenceGuard(checkpointOptions.runId, fence.owner);
+      }
+      const target = yield* sql`
+              SELECT 1 AS ok FROM flows_journal_events
+              WHERE run_id = ${checkpointOptions.runId} AND seq = ${checkpointOptions.seq}
+            `;
+      if (target.length === 0) {
+        return yield* Effect.fail(error(
+          "checkpoint_invalid",
+          `checkpoint sequence ${checkpointOptions.seq} names no committed entry of run ${checkpointOptions.runId}`
+        ));
+      }
+      const floor = yield* compactionFloor(checkpointOptions.runId);
+      if (floor !== void 0 && checkpointOptions.seq <= floor) {
+        return yield* Effect.fail(
+          new import_Journal.JournalError({
+            code: "checkpoint_invalid",
+            message: `run ${checkpointOptions.runId} is already compacted through sequence ${floor}`,
+            checkpointSeq: floor
+          })
+        );
+      }
+      yield* sql`
+              INSERT INTO flows_journal_checkpoints (run_id, seq, state_json, created_at_ms)
+              VALUES (${checkpointOptions.runId}, ${checkpointOptions.seq}, ${stateJson}, ${createdAtMs})
+              ON CONFLICT (run_id, seq) DO UPDATE SET
+                state_json = excluded.state_json,
+                created_at_ms = excluded.created_at_ms
+            `;
+      return new import_Journal.Checkpoint({
+        runId: checkpointOptions.runId,
+        seq: checkpointOptions.seq,
+        state: receiptState,
+        createdAtMs,
+        compactedAtMs: null
+      });
+    })).pipe(
+      Effect.mapError(
+        (cause) => isJournalError(cause) ? cause : error("sink_failed", "durable checkpoint write failed", cause)
+      )
+    );
+  });
+  const checkpoint = Effect.fn("Journal.checkpoint")(
+    (checkpointOptions, owner) => Effect.flatMap(
+      Effect.fromResult(requireFence(owner, "checkpoint")),
+      (fence) => checkpointInternal(checkpointOptions, fence)
+    )
+  );
+  const latestCheckpoint = Effect.fn("Journal.latestCheckpoint")(
+    (runId) => Effect.gen(function* () {
+      yield* Effect.annotateCurrentSpan({ runId });
+      yield* Effect.fromResult(Result.mapError(
+        decodeRunId(runId),
+        (cause) => error("invalid_event", "runId violates the journal identifier contract", cause)
+      ));
+      const rows = yield* sql`
+            SELECT run_id, seq, state_json, created_at_ms, compacted_at_ms
+            FROM flows_journal_checkpoints
+            WHERE run_id = ${runId}
+            ORDER BY seq DESC
+            LIMIT 1
+          `.pipe(Effect.mapError((cause) => error("read_failed", "durable checkpoint read failed", cause)));
+      const row = rows[0];
+      return row === void 0 ? Option.none() : Option.some(yield* decodeCheckpointRow(row));
+    })
+  );
+  const compactInternal = (compactOptions, fence) => Effect.gen(function* () {
+    yield* Effect.annotateCurrentSpan({
+      runId: compactOptions.runId,
+      ...compactOptions.upTo === void 0 ? {} : { upTo: compactOptions.upTo }
+    });
+    yield* Effect.fromResult(Result.mapError(
+      decodeCompactOptions(compactOptions),
+      (cause) => error("invalid_event", "compact options violate the journal contract", cause)
+    ));
+    const compactedAtMs = yield* Clock.currentTimeMillis.pipe(Effect.map(Math.floor));
+    return yield* withCompactionBarrier(
+      compactOptions.runId,
+      Effect.gen(function* () {
+        if (fence._tag === "Owned") {
+          yield* fenceGuard(compactOptions.runId, fence.owner);
+        }
+        const upTo = compactOptions.upTo;
+        const rows = upTo === void 0 ? yield* sql`
+                SELECT run_id, seq, state_json, created_at_ms, compacted_at_ms
+                FROM flows_journal_checkpoints
+                WHERE run_id = ${compactOptions.runId}
+                ORDER BY seq DESC
+                LIMIT 1
+              ` : yield* sql`
+                SELECT run_id, seq, state_json, created_at_ms, compacted_at_ms
+                FROM flows_journal_checkpoints
+                WHERE run_id = ${compactOptions.runId} AND seq = ${upTo}
+              `;
+        const row = rows[0];
+        if (row === void 0) {
+          return yield* Effect.fail(error(
+            "checkpoint_invalid",
+            `run ${compactOptions.runId} has no checkpoint${upTo === void 0 ? "" : ` at sequence ${upTo}`} to compact to`
+          ));
+        }
+        const checkpointSeq = Number(row.seq);
+        if (row.compacted_at_ms !== null) {
+          return { runId: compactOptions.runId, checkpointSeq, deleted: 0 };
+        }
+        for (const reader of readers.get(compactOptions.runId) ?? []) {
+          if (reader.cursor < checkpointSeq - 1) {
+            return yield* Effect.fail(
+              new import_Journal.JournalError({
+                code: "reader_behind",
+                message: `a live stream of run ${compactOptions.runId} still needs sequences below checkpoint ${checkpointSeq}`,
+                checkpointSeq
+              })
+            );
+          }
+        }
+        const doomed = yield* sql`
+              SELECT COUNT(*) AS total FROM flows_journal_events
+              WHERE run_id = ${compactOptions.runId} AND seq < ${checkpointSeq}
+            `;
+        let after = -1;
+        while (true) {
+          const retiring = yield* sql`
+                  SELECT run_id, seq, event_id, source_id, source_seq, emitted_at_ms,
+                    event_type, payload_json, meta_json
+                  FROM flows_journal_events
+                  WHERE run_id = ${compactOptions.runId} AND seq > ${after} AND seq < ${checkpointSeq}
+                  ORDER BY seq ASC LIMIT 256
+                `;
+          if (retiring.length === 0) break;
+          for (const entry of retiring) {
+            const fingerprint = yield* contentFingerprint(entry.event_type, entry.payload_json, entry.meta_json);
+            yield* sql`
+                    INSERT INTO flows_journal_dedup (run_id, source_id, source_seq, event_id, seq, content_hash)
+                    VALUES (${entry.run_id}, ${entry.source_id}, ${entry.source_seq}, ${entry.event_id},
+                      ${entry.seq}, ${fingerprint})
+                  `;
+          }
+          after = Number(retiring[retiring.length - 1].seq);
+        }
+        yield* sql`
+              DELETE FROM flows_journal_events
+              WHERE run_id = ${compactOptions.runId} AND seq < ${checkpointSeq}
+            `;
+        yield* sql`
+              DELETE FROM flows_journal_checkpoints
+              WHERE run_id = ${compactOptions.runId} AND seq < ${checkpointSeq}
+            `;
+        yield* sql`
+              UPDATE flows_journal_checkpoints
+              SET compacted_at_ms = ${compactedAtMs}
+              WHERE run_id = ${compactOptions.runId} AND seq = ${checkpointSeq}
+            `;
+        return {
+          runId: compactOptions.runId,
+          checkpointSeq,
+          deleted: Number(doomed[0]?.total ?? 0)
+        };
+      })
+    ).pipe(
+      Effect.mapError(
+        (cause) => isJournalError(cause) ? cause : error("sink_failed", "journal compaction failed", cause)
+      )
+    );
+  });
+  const compact = Effect.fn("Journal.compact")(
+    (compactOptions, owner) => Effect.flatMap(
+      Effect.fromResult(requireFence(owner, "compact")),
+      (fence) => compactInternal(compactOptions, fence)
+    )
+  );
+  const compactionPolicy = options.compaction;
+  const countEntries = (runId) => Effect.map(
+    sql`
+            SELECT COUNT(*) AS total FROM flows_journal_events WHERE run_id = ${runId}
+          `,
+    (rows) => Number(rows[0]?.total ?? 0)
+  );
+  const policyCompact = (policy, runId) => Effect.gen(function* () {
+    const tail = yield* sql`
+            SELECT MAX(seq) AS last FROM flows_journal_events WHERE run_id = ${runId}
+          `;
+    const last = tail[0]?.last;
+    if (last === null || last === void 0) {
+      return;
+    }
+    const upTo = Number(last);
+    const captured = yield* Effect.timeoutOrElse(policy.capture(runId, upTo), {
+      duration: compactionCaptureTimeout,
+      orElse: () => Effect.fail(
+        new import_JournalInternalFault.JournalInternalFault({
+          code: "compaction_capture_timeout",
+          message: `journal compaction capture for run ${runId} exceeded ${compactionCaptureTimeout}`
+        })
+      )
+    });
+    yield* checkpointInternal({ runId, seq: upTo, state: captured }, unfenced);
+    yield* compactInternal({ runId, upTo }, unfenced);
+    compactionCounts.set(runId, yield* countEntries(runId));
+  }).pipe(
+    Effect.catchCause(
+      (cause) => Cause.hasInterruptsOnly(cause) ? Effect.failCause(cause) : Effect.sync(() => {
+        compactionCounts.set(runId, 0);
+      }).pipe(
+        Effect.andThen(
+          Effect.logWarning("journal auto-compaction failed; retrying after the next threshold", cause)
+        )
+      )
+    )
+  );
+  const noteCommitted = (runId, committed, background = false) => {
+    const policy = compactionPolicy;
+    if (policy === void 0 || committed <= 0) {
+      return Effect.void;
+    }
+    return Effect.uninterruptibleMask(
+      (restore) => withRunBarrier(runId, (barrier) => restore(barrier.maintenance.withPermit(
+        Effect.gen(function* () {
+          if (compactingRuns.has(runId)) {
+            return false;
+          }
+          const known = compactionCounts.get(runId);
+          const current = known === void 0 ? yield* countEntries(runId) : known + committed;
+          compactionCounts.set(runId, current);
+          if (current < policy.entryThreshold) {
+            return false;
+          }
+          compactingRuns.add(runId);
+          pendingMaintenance += 1;
+          return true;
+        })
+      )).pipe(
+        Effect.flatMap((triggered) => {
+          if (!triggered) return Effect.void;
+          const attempt = policyCompact(policy, runId).pipe(Effect.ensuring(Effect.sync(() => {
+            compactingRuns.delete(runId);
+            pendingMaintenance -= 1;
+            if (state.pending === 0 && pendingMaintenance === 0) completeFlushWaiters(Effect.void);
+          })));
+          return background ? Effect.asVoid(Effect.forkIn(Effect.interruptible(attempt), maintenanceScope)) : restore(attempt);
+        }),
+        Effect.catchCause(
+          (cause) => Cause.hasInterruptsOnly(cause) ? Effect.failCause(cause) : Effect.logWarning("journal compaction policy bookkeeping failed", cause)
+        )
+      ))
+    );
+  };
+  const recordCommits = (commits) => {
+    for (const { commit, queued } of commits) {
+      rememberCommitted(queued, commit.entry.seq);
+    }
+  };
+  const settle = (count) => {
+    state.pending = Math.max(0, state.pending - count);
+    if (state.pending === 0 && pendingMaintenance === 0) {
+      completeFlushWaiters(Effect.void);
+    }
+  };
+  const reportLoss = (cause, batch) => {
+    for (const queued of batch) {
+      const identity = sourceEventKey(queued.runId, queued.sourceId, queued.sourceSeq);
+      state.sourceEvents.delete(identity);
+    }
+    state.sinkFailure = cause;
+    state.lossEpoch += 1;
+    state.pending = Math.max(0, state.pending - batch.length);
+    if (state.flushWaiters.size > 0) {
+      state.flushedLossEpoch = state.lossEpoch;
+    }
+    completeFlushWaiters(Effect.fail(cause));
+    for (const subscribers of wakes.values()) {
+      for (const wake of subscribers) {
+        PubSub.publishUnsafe(wake, void 0);
+      }
+    }
+  };
+  const observeLoss = (cause, batch) => Effect.andThen(
+    Metric.update(JournalMetrics.lost(cause.code), batch.length),
+    Effect.logWarning(
+      `journal lost ${batch.length} lossy entries (${cause.code}) for runs ${[...new Set(batch.map((queued) => queued.runId))].join(", ")}`,
+      cause
+    )
+  );
+  const failSink = (cause, batch) => {
+    settleRunPending(batch);
+    reportLoss(cause, batch);
+  };
+  const writeBatch = Queue.takeBetween(queue, 1, batchSize).pipe(
+    Effect.flatMap(
+      (batch) => persistBatch(batch).pipe(
+        Effect.tap((outcome) => Effect.sync(() => recordCommits(outcome.commits))),
+        Effect.tap((outcome) => publish(outcome.commits.map(({ commit }) => commit))),
+        // The transaction has committed and publication is complete. Drop
+        // the barrier counts before policy compaction takes this run's
+        // permit. Maintenance has its own global flush count.
+        Effect.tap(() => Effect.sync(() => settleRunPending(batch))),
+        // Register maintenance BEFORE settling the batch, so flush cannot
+        // observe a gap between queued work and its policy attempt.
+        Effect.tap((outcome) => {
+          const perRun = /* @__PURE__ */ new Map();
+          outcome.commits.forEach(({ commit, queued }) => {
+            if (!commit.inserted) {
+              return;
+            }
+            perRun.set(queued.runId, (perRun.get(queued.runId) ?? 0) + 1);
+          });
+          return Effect.forEach(perRun, ([runId, committed]) => noteCommitted(runId, committed, true), {
+            discard: true
+          });
+        }),
+        Effect.tap(
+          (outcome) => (
+            // Observed before it is reported, so a flush the report wakes
+            // already sees the loss in the log and the registry.
+            Effect.uninterruptible(Effect.andThen(
+              Effect.forEach(outcome.losses, (loss) => observeLoss(loss.cause, [loss.queued]), { discard: true }),
+              Effect.sync(() => {
+                for (const loss of outcome.losses) {
+                  reportLoss(loss.cause, [loss.queued]);
+                }
+                settle(outcome.commits.length);
+              })
+            ))
+          )
+        ),
+        Effect.catch(
+          (cause) => Effect.uninterruptible(
+            Effect.andThen(observeLoss(cause, batch), Effect.sync(() => failSink(cause, batch)))
+          )
+        ),
+        // Defects only: an interruption is scope closure, and it must end
+        // the writer rather than be reported as a lost batch.
+        Effect.catchDefect((defect) => {
+          const cause = error("sink_failed", "journal writer failed", Cause.die(defect));
+          return Effect.uninterruptible(
+            Effect.andThen(observeLoss(cause, batch), Effect.sync(() => failSink(cause, batch)))
+          );
+        })
+      )
+    )
+  );
+  const drain = Effect.forever(writeBatch);
+  yield* Effect.forkScoped(drain);
+  yield* Effect.addFinalizer(
+    () => Effect.gen(function* () {
+      yield* Effect.sync(() => {
+        state.status = "closing";
+      });
+      yield* flushInternal.pipe(
+        Effect.catch((cause) => Effect.logWarning("journal final flush failed while closing", cause))
+      );
+      yield* Effect.sync(() => {
+        state.status = "closed";
+      });
+      yield* Queue.shutdown(queue);
+      yield* PubSub.shutdown(changes);
+      wakes.clear();
+    })
+  );
+  const project = (projection, streamOptions) => Stream.unwrap(
+    Effect.fn("Journal.project")(
+      (activeProjection, activeOptions) => Effect.annotateCurrentSpan({
+        projection: activeProjection.name,
+        runId: activeOptions.runId,
+        ...activeOptions.afterSequence === void 0 ? {} : { afterSequence: activeOptions.afterSequence }
+      }).pipe(Effect.andThen(Effect.succeed(
+        stream(activeOptions).pipe(
+          Stream.scanEffect(activeProjection.initial, (state2, entry) => Effect.suspend(() => activeProjection.reduce(state2, entry)).pipe(
+            Effect.catchCause(
+              (cause) => Cause.hasInterruptsOnly(cause) ? Effect.failCause(cause) : Effect.fail(
+                error(
+                  "projection_failed",
+                  `projection ${activeProjection.name} failed`,
+                  cause
+                )
+              )
+            )
+          ))
+        )
+      )))
+    )(projection, streamOptions)
+  );
+  yield* JournalGeneration.onTruncate((runIds) => {
+    for (const runId of runIds) {
+      state.sequences.delete(runId);
+      const prefix = `${runId.length}:${runId}`;
+      for (const key of state.sourceSequences.keys()) {
+        if (key.startsWith(prefix)) state.sourceSequences.delete(key);
+      }
+      for (const key of state.sourceEvents.keys()) {
+        if (key.startsWith(prefix)) state.sourceEvents.delete(key);
+      }
+    }
+  });
+  return (0, import_Journal.make)({
+    generation: (runId) => sql`
+          SELECT generation, after_seq AS "afterSeq" FROM flows_journal_generations WHERE run_id = ${runId}
+        `.pipe(
+      Effect.map((rows) => rows[0] ?? { generation: 0, afterSeq: -1 }),
+      Effect.mapError((cause) => error("read_failed", "could not read journal generation", cause))
+    ),
+    emitLossy,
+    emitDurable,
+    emitDurableUnfenced,
+    transact,
+    whenCommitted: (update) => Effect.flatMap(
+      Effect.serviceOption(sql.transactionService),
+      (transaction) => Option.isNone(transaction) ? Effect.as(update, true) : (0, import_DurableWriter.afterCommit)(update, sql)
+    ),
+    stream,
+    entries: readPage,
+    changes: PubSub.subscribe(changes),
+    project,
+    flush: Effect.fn("Journal.flush")(
+      () => Effect.suspend(() => Effect.annotateCurrentSpan({ pending: state.pending })).pipe(
+        Effect.andThen(flushInternal)
+      )
+    )(),
+    checkpoint,
+    latestCheckpoint,
+    compact
+  });
+});
+const layerWith = (options) => Layer.effect(import_Journal.Journal, make(options));
+const layer = (options) => layerWith(options).pipe(Layer.provide(SqlConsensus.layer));
+//# sourceMappingURL=SqlJournal.js.map