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

package/dist/esm/Journal.js

@@ -0,0 +1,323 @@
+/**
+ * Logical journal contract with durable lifecycle and lossy telemetry channels.
+ *
+ * The ownership fence and the lossless `emitDurable` / lossy `emitLossy`
+ * split are described at https://journal.smithers.sh/concepts/owner-fence/
+ * and https://journal.smithers.sh/concepts/two-channels/.
+ *
+ * @since 0.1.0
+ */
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as PubSub from "effect/PubSub";
+import * as Schema from "effect/Schema";
+import * as Stream from "effect/Stream";
+import { Entry, RunId, Seq, SourceSeq } from "./JournalEvent.js";
+/**
+ * Defers a fold/cache update until the outermost durable write commits.
+ * Returns false without running it when no managed commit is available.
+ * Failed savepoints and retried transaction attempts never publish the update.
+ *
+ * @category transactions
+ * @since 1.0.0
+ */
+export { afterCommit } from "@smthrs/database/DurableWriter";
+/**
+ * Stable error codes returned by journal operations.
+ *
+ * `read_failed` identifies a database failure on a durable read path. Callers
+ * can distinguish that retryable storage condition from an unclassified
+ * `unknown` journal defect.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export const JournalErrorCode = Schema.Literals([
+    "invalid_event",
+    "idempotency_conflict",
+    "sequence_conflict",
+    "fence_lost",
+    "queue_overflow",
+    "journal_closed",
+    "sink_failed",
+    "read_failed",
+    "decode_failed",
+    "projection_failed",
+    "checkpoint_invalid",
+    "reader_behind",
+    "compacted",
+    "unknown"
+]);
+/**
+ * Error raised by journal admission, persistence, replay, or projection.
+ *
+ * `checkpointSeq` is set on the compaction-aware codes: on `compacted` it is
+ * the run's compaction floor, the checkpoint sequence a reader must resync
+ * from, and on `reader_behind` it is the checkpoint a compaction refused to
+ * truncate below.
+ *
+ * @category errors
+ * @since 0.1.0
+ */
+export class JournalError extends Schema.TaggedError()("@smthrs/journal/JournalError", {
+    code: JournalErrorCode,
+    message: Schema.String,
+    cause: Schema.optional(Schema.Unknown),
+    checkpointSeq: Schema.optional(Seq)
+}) {
+}
+/**
+ * Policy applied when the non-blocking admission queue is full.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export const OverflowPolicy = Schema.Literals(["reject", "drop-newest", "drop-oldest"]);
+/**
+ * Receipt for a newly admitted event.
+ *
+ * On the lossy channel, `seq` and `sourceSeq` are allocated synchronously and
+ * returned before SQL commits. This `seq` is provisional: the SQL writer
+ * moves it above the committed tail if another commit overtakes its reservation.
+ * Use committed entries for durable cursors. On the durable channel, the same
+ * receipt shape is returned only after the entry commits. `seq` orders the run;
+ * `sourceSeq` identifies producer retries and does not change at commit.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export const Accepted = Schema.TaggedStruct("Accepted", {
+    seq: Seq,
+    sourceSeq: SourceSeq,
+    evicted: Schema.optionalKey(Schema.Struct({
+        policy: Schema.Literal("drop-oldest"),
+        count: Schema.Int.check(Schema.isGreaterThan(0))
+    }))
+});
+/**
+ * Receipt for an exact retry of an already pending or committed source event.
+ *
+ * `seq` is the original event's sequence, provisional while pending and
+ * canonical after commit. A duplicate does not allocate another sequence or
+ * enqueue another write. `status` distinguishes
+ * an optimistic retry from one whose original event is already durable.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export const Duplicate = Schema.TaggedStruct("Duplicate", {
+    seq: Seq,
+    sourceSeq: SourceSeq,
+    status: Schema.Literals(["pending", "committed"])
+});
+/**
+ * Receipt for an event discarded by an explicit dropping policy.
+ *
+ * A dropped admission still consumes its synchronously allocated `seq` and
+ * `sourceSeq`, so sequence gaps are expected.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export const Dropped = Schema.TaggedStruct("Dropped", {
+    seq: Seq,
+    sourceSeq: SourceSeq,
+    policy: Schema.Literal("drop-newest")
+});
+/**
+ * Receipt union for admission that may use the lossy queue.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export const EmitReceipt = Schema.Union([Accepted, Duplicate, Dropped]);
+/**
+ * Result of a synchronously durable journal admission.
+ *
+ * A durable admission is never dropped: it either commits, returns the
+ * committed sequence of an exact producer retry, or fails.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export const DurableReceipt = Schema.Union([Accepted, Duplicate]);
+/**
+ * Cursor used to replay a run and then follow its committed tail.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export const StreamOptions = Schema.Struct({
+    runId: RunId,
+    afterSequence: Schema.optionalKey(Seq)
+});
+/**
+ * Largest page `entries` will read.
+ *
+ * A page is decoded into memory in full before the caller sees its first
+ * entry, so an unbounded limit lets one call materialize a whole run. The
+ * largest page any caller in this repository asks for is 512, so this
+ * ceiling refuses only a limit that was going to be a memory incident.
+ *
+ * @since 1.0.0
+ * @category constants
+ */
+export const maxEntriesLimit = 10_000;
+/**
+ * Cursor and page size for durable journal reads.
+ *
+ * `limit` is at most `maxEntriesLimit` (10,000 entries). Optional `eventTypes`
+ * selects a nonempty list of at most 64 exact types before pagination; cursors remain canonical run
+ * sequences and `hasMore` describes matching entries. Omit it for the full run.
+ * Filtering does not bypass the run's compaction floor.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export const EntriesOptions = Schema.Struct({
+    runId: RunId,
+    after: Schema.optionalKey(Seq),
+    eventTypes: Schema.optionalKey(Schema.Array(Entry.fields.eventType).check(Schema.isMinLength(1), Schema.isMaxLength(64))),
+    limit: Schema.Int.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(maxEntriesLimit))
+});
+/**
+ * One page of canonical durable journal entries.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export const EntriesPage = Schema.Struct({
+    entries: Schema.Array(Entry),
+    hasMore: Schema.Boolean
+});
+/**
+ * A durable checkpoint: the caller-captured state that replays a run from
+ * `seq` without the entries before it.
+ *
+ * `state` is the caller's own replay snapshot and round-trips verbatim: the
+ * journal never interprets it, and redaction deliberately does not apply,
+ * exactly as it does not apply to executable state. A checkpoint at `seq`
+ * must subsume every entry with a sequence at or below `seq`: replay is
+ * `state` plus `stream({ runId, afterSequence: seq })`.
+ *
+ * `compactedAtMs` is `null` until a compaction has truncated the entries
+ * strictly below `seq`. The largest compacted `seq` for a run is its
+ * compaction floor.
+ *
+ * Prior art: Temporal's mutable state, a durable snapshot pinned to a
+ * history offset, with history below it never replayed
+ * (`reference/temporal/common/persistence/data_interfaces.go`,
+ * `WorkflowSnapshot`).
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export class Checkpoint extends Schema.Class("@smthrs/journal/Journal/Checkpoint")({
+    runId: RunId,
+    seq: Seq,
+    state: Schema.Unknown,
+    createdAtMs: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+    compactedAtMs: Schema.NullOr(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)))
+}) {
+}
+/**
+ * Arguments for writing a checkpoint.
+ *
+ * `seq` must name a committed entry of the run: the surviving row is what
+ * keeps the run's durable `MAX(seq)` allocation floor at or above the
+ * compaction boundary, so a process restarted after compaction can never
+ * re-allocate a truncated sequence.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export const CheckpointOptions = Schema.Struct({
+    runId: RunId,
+    seq: Seq,
+    state: Schema.Unknown
+});
+/**
+ * Arguments for compacting a run.
+ *
+ * `upTo` selects the checkpoint to truncate below; omitted, the run's latest
+ * checkpoint is used.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export const CompactOptions = Schema.Struct({
+    runId: RunId,
+    upTo: Schema.optionalKey(Seq)
+});
+/**
+ * Receipt for a completed compaction.
+ *
+ * `deleted` is `0` when the checkpoint was already the compaction floor, a
+ * retried compaction is idempotent.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export const Compacted = Schema.Struct({
+    runId: RunId,
+    checkpointSeq: Seq,
+    deleted: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))
+});
+/**
+ * Context service for durable lifecycle evidence and lossy telemetry.
+ *
+ * @category services
+ * @since 0.1.0
+ */
+export class Journal extends Context.Service()("@smthrs/journal/Journal") {
+}
+/**
+ * Constructs a journal service from an implementation.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export const make = (implementation) => Journal.of(implementation);
+const unavailable = (method) => new JournalError({
+    code: "journal_closed",
+    message: `${method} is unavailable`
+});
+/**
+ * Constructs a closed journal stub, optionally overriding individual methods.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export const makeNoop = (overrides = {}) => {
+    const service = {
+        emitLossy: Effect.fn("Journal.emitLossy")(() => Effect.fail(unavailable("emitLossy"))),
+        emitDurable: Effect.fn("Journal.emitDurable")(() => Effect.fail(unavailable("emitDurable"))),
+        emitDurableUnfenced: Effect.fn("Journal.emitDurableUnfenced")(() => Effect.fail(unavailable("emitDurableUnfenced"))),
+        /**
+         * The closed stub has no sink and therefore no transaction to open, so it
+         * runs the effect directly, the same posture as
+         * `DurableEngineState`'s in-memory twin, whose `transaction` has no crash
+         * window to close. A test double that models rollback overrides it.
+         */
+        transact: (effect) => effect,
+        whenCommitted: (update) => Effect.as(update, true),
+        stream: (options) => Stream.unwrap(Effect.fn("Journal.stream")((_options) => Effect.succeed(Stream.fail(unavailable("stream"))))(options)),
+        entries: Effect.fn("Journal.entries")(() => Effect.fail(unavailable("entries"))),
+        changes: Effect.acquireRelease(PubSub.sliding(1), PubSub.shutdown).pipe(Effect.flatMap(PubSub.subscribe)),
+        project: (projection, options) => Stream.unwrap(Effect.fn("Journal.project")((_projection, _options) => Effect.succeed(Stream.fail(unavailable("project"))))(projection, options)),
+        flush: Effect.fn("Journal.flush")(() => Effect.fail(unavailable("flush")))(),
+        checkpoint: Effect.fn("Journal.checkpoint")(() => Effect.fail(unavailable("checkpoint"))),
+        latestCheckpoint: Effect.fn("Journal.latestCheckpoint")(() => Effect.fail(unavailable("latestCheckpoint"))),
+        compact: Effect.fn("Journal.compact")(() => Effect.fail(unavailable("compact")))
+    };
+    return Journal.of({ ...service, ...overrides });
+};
+/**
+ * Provides a closed journal stub.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export const layerNoop = (overrides = {}) => Layer.succeed(Journal)(makeNoop(overrides));
+//# sourceMappingURL=Journal.js.map

package/dist/esm/Journal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Journal.js","sourceRoot":"","sources":["../../src/Journal.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Logical journal contract with durable lifecycle and lossy telemetry channels.\n *\n * The ownership fence and the lossless `emitDurable` / lossy `emitLossy`\n * split are described at https://journal.smithers.sh/concepts/owner-fence/\n * and https://journal.smithers.sh/concepts/two-channels/.\n *\n * @since 0.1.0\n */\n\nimport * as Context from \"effect/Context\"\nimport * as Effect from \"effect/Effect\"\nimport * as Layer from \"effect/Layer\"\nimport type * as Option from \"effect/Option\"\nimport * as PubSub from \"effect/PubSub\"\nimport * as Schema from \"effect/Schema\"\nimport type * as Scope from \"effect/Scope\"\nimport * as Stream from \"effect/Stream\"\nimport { Entry, RunId, Seq, SourceSeq } from \"./JournalEvent.ts\"\nimport type { Input } from \"./JournalEvent.ts\"\nimport type { OwnerId } from \"./OwnerId.ts\"\nimport type { Projection } from \"./Projection.ts\"\n\n/**\n * Defers a fold/cache update until the outermost durable write commits.\n * Returns false without running it when no managed commit is available.\n * Failed savepoints and retried transaction attempts never publish the update.\n *\n * @category transactions\n * @since 1.0.0\n */\nexport { afterCommit } from \"@smthrs/database/DurableWriter\"\n\n/**\n * Stable error codes returned by journal operations.\n *\n * `read_failed` identifies a database failure on a durable read path. Callers\n * can distinguish that retryable storage condition from an unclassified\n * `unknown` journal defect.\n *\n * @category models\n * @since 0.1.0\n */\nexport const JournalErrorCode = Schema.Literals([\n  \"invalid_event\",\n  \"idempotency_conflict\",\n  \"sequence_conflict\",\n  \"fence_lost\",\n  \"queue_overflow\",\n  \"journal_closed\",\n  \"sink_failed\",\n  \"read_failed\",\n  \"decode_failed\",\n  \"projection_failed\",\n  \"checkpoint_invalid\",\n  \"reader_behind\",\n  \"compacted\",\n  \"unknown\"\n])\n\n/**\n * Stable error codes returned by journal operations.\n *\n * @category models\n * @since 0.1.0\n */\nexport type JournalErrorCode = typeof JournalErrorCode.Type\n\n/**\n * Error raised by journal admission, persistence, replay, or projection.\n *\n * `checkpointSeq` is set on the compaction-aware codes: on `compacted` it is\n * the run's compaction floor, the checkpoint sequence a reader must resync\n * from, and on `reader_behind` it is the checkpoint a compaction refused to\n * truncate below.\n *\n * @category errors\n * @since 0.1.0\n */\nexport class JournalError extends Schema.TaggedError<JournalError>()(\"@smthrs/journal/JournalError\", {\n  code: JournalErrorCode,\n  message: Schema.String,\n  cause: Schema.optional(Schema.Unknown),\n  checkpointSeq: Schema.optional(Seq)\n}) {}\n\n/**\n * Policy applied when the non-blocking admission queue is full.\n *\n * @category models\n * @since 0.1.0\n */\nexport const OverflowPolicy = Schema.Literals([\"reject\", \"drop-newest\", \"drop-oldest\"])\n\n/**\n * Policy applied when the non-blocking admission queue is full.\n *\n * @category models\n * @since 0.1.0\n */\nexport type OverflowPolicy = typeof OverflowPolicy.Type\n\n/**\n * Receipt for a newly admitted event.\n *\n * On the lossy channel, `seq` and `sourceSeq` are allocated synchronously and\n * returned before SQL commits. This `seq` is provisional: the SQL writer\n * moves it above the committed tail if another commit overtakes its reservation.\n * Use committed entries for durable cursors. On the durable channel, the same\n * receipt shape is returned only after the entry commits. `seq` orders the run;\n * `sourceSeq` identifies producer retries and does not change at commit.\n *\n * @category models\n * @since 0.1.0\n */\nexport const Accepted = Schema.TaggedStruct(\"Accepted\", {\n  seq: Seq,\n  sourceSeq: SourceSeq,\n  evicted: Schema.optionalKey(Schema.Struct({\n    policy: Schema.Literal(\"drop-oldest\"),\n    count: Schema.Int.check(Schema.isGreaterThan(0))\n  }))\n})\n\n/**\n * Receipt for a newly admitted event.\n *\n * @category models\n * @since 0.1.0\n */\nexport type Accepted = typeof Accepted.Type\n\n/**\n * Receipt for an exact retry of an already pending or committed source event.\n *\n * `seq` is the original event's sequence, provisional while pending and\n * canonical after commit. A duplicate does not allocate another sequence or\n * enqueue another write. `status` distinguishes\n * an optimistic retry from one whose original event is already durable.\n *\n * @category models\n * @since 0.1.0\n */\nexport const Duplicate = Schema.TaggedStruct(\"Duplicate\", {\n  seq: Seq,\n  sourceSeq: SourceSeq,\n  status: Schema.Literals([\"pending\", \"committed\"])\n})\n\n/**\n * Receipt for an exact producer retry.\n *\n * @category models\n * @since 0.1.0\n */\nexport type Duplicate = typeof Duplicate.Type\n\n/**\n * Receipt for an event discarded by an explicit dropping policy.\n *\n * A dropped admission still consumes its synchronously allocated `seq` and\n * `sourceSeq`, so sequence gaps are expected.\n *\n * @category models\n * @since 0.1.0\n */\nexport const Dropped = Schema.TaggedStruct(\"Dropped\", {\n  seq: Seq,\n  sourceSeq: SourceSeq,\n  policy: Schema.Literal(\"drop-newest\")\n})\n\n/**\n * Receipt for an event discarded by policy.\n *\n * @category models\n * @since 0.1.0\n */\nexport type Dropped = typeof Dropped.Type\n\n/**\n * Receipt union for admission that may use the lossy queue.\n *\n * @category models\n * @since 0.1.0\n */\nexport const EmitReceipt = Schema.Union([Accepted, Duplicate, Dropped])\n\n/**\n * Receipt union for the lossy channel.\n *\n * @category models\n * @since 0.1.0\n */\nexport type EmitReceipt = typeof EmitReceipt.Type\n\n/**\n * Result of a synchronously durable journal admission.\n *\n * A durable admission is never dropped: it either commits, returns the\n * committed sequence of an exact producer retry, or fails.\n *\n * @category models\n * @since 0.1.0\n */\nexport const DurableReceipt = Schema.Union([Accepted, Duplicate])\n\n/**\n * Receipt union for the durable channel.\n *\n * @category models\n * @since 0.1.0\n */\nexport type DurableReceipt = typeof DurableReceipt.Type\n\n/**\n * Cursor used to replay a run and then follow its committed tail.\n *\n * @category models\n * @since 0.1.0\n */\nexport const StreamOptions = Schema.Struct({\n  runId: RunId,\n  afterSequence: Schema.optionalKey(Seq)\n})\n\n/**\n * Cursor used to replay a run and follow its committed tail.\n *\n * @category models\n * @since 0.1.0\n */\nexport type StreamOptions = typeof StreamOptions.Type\n\n/**\n * Largest page `entries` will read.\n *\n * A page is decoded into memory in full before the caller sees its first\n * entry, so an unbounded limit lets one call materialize a whole run. The\n * largest page any caller in this repository asks for is 512, so this\n * ceiling refuses only a limit that was going to be a memory incident.\n *\n * @since 1.0.0\n * @category constants\n */\nexport const maxEntriesLimit = 10_000\n\n/**\n * Cursor and page size for durable journal reads.\n *\n * `limit` is at most `maxEntriesLimit` (10,000 entries). Optional `eventTypes`\n * selects a nonempty list of at most 64 exact types before pagination; cursors remain canonical run\n * sequences and `hasMore` describes matching entries. Omit it for the full run.\n * Filtering does not bypass the run's compaction floor.\n *\n * @category models\n * @since 0.1.0\n */\nexport const EntriesOptions = Schema.Struct({\n  runId: RunId,\n  after: Schema.optionalKey(Seq),\n  eventTypes: Schema.optionalKey(\n    Schema.Array(Entry.fields.eventType).check(Schema.isMinLength(1), Schema.isMaxLength(64))\n  ),\n  limit: Schema.Int.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(maxEntriesLimit))\n})\n\n/**\n * Cursor and page size for durable journal reads.\n *\n * @category models\n * @since 0.1.0\n */\nexport type EntriesOptions = typeof EntriesOptions.Type\n\n/**\n * One page of canonical durable journal entries.\n *\n * @category models\n * @since 0.1.0\n */\nexport const EntriesPage = Schema.Struct({\n  entries: Schema.Array(Entry),\n  hasMore: Schema.Boolean\n})\n\n/**\n * One page of durable journal entries.\n *\n * @category models\n * @since 0.1.0\n */\nexport type EntriesPage = typeof EntriesPage.Type\n\n/**\n * A durable checkpoint: the caller-captured state that replays a run from\n * `seq` without the entries before it.\n *\n * `state` is the caller's own replay snapshot and round-trips verbatim: the\n * journal never interprets it, and redaction deliberately does not apply,\n * exactly as it does not apply to executable state. A checkpoint at `seq`\n * must subsume every entry with a sequence at or below `seq`: replay is\n * `state` plus `stream({ runId, afterSequence: seq })`.\n *\n * `compactedAtMs` is `null` until a compaction has truncated the entries\n * strictly below `seq`. The largest compacted `seq` for a run is its\n * compaction floor.\n *\n * Prior art: Temporal's mutable state, a durable snapshot pinned to a\n * history offset, with history below it never replayed\n * (`reference/temporal/common/persistence/data_interfaces.go`,\n * `WorkflowSnapshot`).\n *\n * @category models\n * @since 0.1.0\n */\nexport class Checkpoint extends Schema.Class<Checkpoint>(\"@smthrs/journal/Journal/Checkpoint\")({\n  runId: RunId,\n  seq: Seq,\n  state: Schema.Unknown,\n  createdAtMs: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),\n  compactedAtMs: Schema.NullOr(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)))\n}) {}\n\n/**\n * Arguments for writing a checkpoint.\n *\n * `seq` must name a committed entry of the run: the surviving row is what\n * keeps the run's durable `MAX(seq)` allocation floor at or above the\n * compaction boundary, so a process restarted after compaction can never\n * re-allocate a truncated sequence.\n *\n * @category models\n * @since 0.1.0\n */\nexport const CheckpointOptions = Schema.Struct({\n  runId: RunId,\n  seq: Seq,\n  state: Schema.Unknown\n})\n\n/**\n * Arguments for writing a checkpoint.\n *\n * @category models\n * @since 0.1.0\n */\nexport type CheckpointOptions = typeof CheckpointOptions.Type\n\n/**\n * Arguments for compacting a run.\n *\n * `upTo` selects the checkpoint to truncate below; omitted, the run's latest\n * checkpoint is used.\n *\n * @category models\n * @since 0.1.0\n */\nexport const CompactOptions = Schema.Struct({\n  runId: RunId,\n  upTo: Schema.optionalKey(Seq)\n})\n\n/**\n * Arguments for compacting a run.\n *\n * @category models\n * @since 0.1.0\n */\nexport type CompactOptions = typeof CompactOptions.Type\n\n/**\n * Receipt for a completed compaction.\n *\n * `deleted` is `0` when the checkpoint was already the compaction floor, a\n * retried compaction is idempotent.\n *\n * @category models\n * @since 0.1.0\n */\nexport const Compacted = Schema.Struct({\n  runId: RunId,\n  checkpointSeq: Seq,\n  deleted: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))\n})\n\n/**\n * Receipt for a completed compaction.\n *\n * @category models\n * @since 0.1.0\n */\nexport type Compacted = typeof Compacted.Type\n\n/**\n * Journal operations.\n *\n * There are two sequence domains:\n *\n * - `seq` is reserved synchronously per run. A lossy reservation is provisional;\n *   the SQL writer moves it above the committed tail if overtaken. The committed\n *   sequence is the canonical order for replay, paging, streams, and projections.\n * - `sourceSeq` is assigned synchronously per `(runId, sourceId)`, or supplied\n *   by the producer, and is the idempotency key for producer retries.\n *\n * Rejected or dropped admissions consume both allocations, so gaps are valid.\n * A retry the in-process index still holds returns `Duplicate` with the\n * original `seq` (provisional while pending) and consumes neither allocation.\n *\n * A retry it no longer holds is admitted optimistically and settled by\n * `UNIQUE (run_id, source_id, source_seq)` at the insert: admission issues no\n * dedup read, so the receipt is `Accepted`, the entry collapses onto the\n * committed row instead of doubling it, and a reused identity carrying\n * different bytes surfaces its `idempotency_conflict` through `flush` rather\n * than through the emit. The read is deliberately absent. `emitLossy` exists\n * to be callable from inside somebody else's open write transaction, and a\n * SELECT there waits on the writer that is waiting on the caller: the agent\n * executor's exit flush deadlocked exactly so. What a producer keeps in\n * exchange is the choice of what a collision means, through `Input.dedupe`.\n *\n * This table is Smithers' logical (domain) write-ahead log and is intended to\n * become the authoritative state history. The storage engine's own WAL\n * underneath it is a durability substrate only and is never consumed as the\n * application event API. A durable boundary must not advance a run or expose\n * its result until its lifecycle entry is committed. No local commit makes a\n * remote effect atomic, so external effects still need idempotency keys,\n * fencing tokens, or compensation.\n *\n * `emitDurable` allocates `seq` inside the writer's SQL transaction, so the\n * returned sequence is already committed and independent writers never fork\n * the per-run clock.\n *\n * Caveat on scope: the stores above this log (`RunStore`, `AttemptStore`,\n * `CacheStore`, and engine-store's `DurableEngineState`) hold the executable\n * authoritative state, and no state is derived from these entries today.\n * `transact` is what keeps the two halves consistent anyway: a state\n * transition and the lifecycle entry describing it are appended in ONE write\n * transaction, so a crash can never leave durable state the journal does not\n * explain (or an entry for a transition that never landed).\n *\n * The surface is split into two channels:\n *\n * - The lifecycle channel, `emitDurable`, returns `DurableReceipt`, so a\n *   dropped lifecycle event is unrepresentable: the write commits, dedupes, or\n *   fails with a typed error.\n * - The lossy channel, `emitLossy`, keeps the optimistic queue and its\n *   overflow policies for telemetry, where `Dropped` receipts and\n *   `drop-oldest` evictions are acceptable.\n *\n * `emitDurable` is fenced on the run's ownership as arbitrated by the\n * injected `Consensus` strategy: the caller hands over its `OwnerId`, the\n * durable insert only commits while that strategy still records the owner as\n * holding the run, and a reclaimed run fails the write with a `fence_lost`\n * error. The fence is mandatory on the lifecycle channel: a lifecycle write is\n * what advances a run, and a zombie owner must not advance anything. The one\n * escape is {@link Service.emitDurableUnfenced}, for the rare admission that\n * is genuinely ownerless.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface Service {\n  /**\n   * The durable rewind generation and its archive boundary. An append-only\n   * adapter may omit this operation, which means generation zero forever.\n   * Rewinding adapters must advance the generation atomically with truncation.\n   */\n  readonly generation?:\n    | ((runId: RunId) => Effect.Effect<{\n      readonly generation: number\n      readonly afterSeq: number\n    }, JournalError>)\n    | undefined\n  readonly emitLossy: (input: Input) => Effect.Effect<EmitReceipt, JournalError>\n  readonly emitDurable: (input: Input, owner: OwnerId) => Effect.Effect<DurableReceipt, JournalError>\n  /**\n   * The unfenced durable write: same durability and receipt contract as\n   * {@link Service.emitDurable}, with no ownership fence.\n   *\n   * This exists ONLY for admissions that are genuinely ownerless: writes\n   * whose correctness does not depend on who currently owns the run because\n   * they are first-writer-wins by design. The canonical case is the\n   * external-trigger admission: a deferred completion or clock-schedule\n   * record delivered by a sweeper that owns nothing, where the dedup index,\n   * not the fence, is the idempotency mechanism. A caller that holds an\n   * `OwnerId` must use `emitDurable`; reaching for this channel to dodge a\n   * `fence_lost` is exactly the zombie write the fence exists to reject.\n   */\n  readonly emitDurableUnfenced: (input: Input) => Effect.Effect<DurableReceipt, JournalError>\n  /**\n   * Runs `effect`, a state projection plus the `emitDurable` calls describing\n   * it, inside ONE write transaction.\n   *\n   * This is the seam that makes the logical WAL crash-consistent with\n   * executable state. The stores above the journal (`RunStore`,\n   * `AttemptStore`, `CacheStore`, `DurableEngineState`) write through the same\n   * `DurableWriter`, so their writes join this transaction as savepoints: either\n   * the transition and its lifecycle entry both commit, or neither does. It is\n   * the local analogue of Temporal closing mutable state into a mutation plus\n   * event batches and submitting them as one persistence request\n   * (`reference/temporal/service/history/workflow/transaction_impl.go`).\n   *\n   * A `Duplicate` receipt is unaffected: an exact producer retry still\n   * collapses onto the already-committed sequence.\n   *\n   * Two consequences a caller must plan for:\n   *\n   * - Publication (`changes`, `stream`, and the in-process source-event index)\n   *   is deferred until the transaction commits, so a subscriber never\n   *   observes an entry that later rolls back, and a rolled-back producer\n   *   identity stays re-emittable rather than deduplicating against a\n   *   sequence that does not exist.\n   * - Everything inside runs while a write transaction is open. Keep it to\n   *   storage work: no flow bodies, no host calls, no waits.\n   *\n   * Nesting is safe: an inner `transact` becomes a savepoint of the outer\n   * one and defers its publication to the outermost commit.\n   */\n  readonly transact: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | JournalError, R>\n  /**\n   * Publishes a short, non-failing process-local update after the current\n   * transaction commits, or immediately when no transaction is open.\n   *\n   * Returns false without publishing inside a raw SQL transaction whose\n   * commit this journal cannot observe. A true result can mean deferred, not\n   * already run. Failed savepoints and retries discard their registrations.\n   * Test doubles that implement transactions must preserve this contract.\n   */\n  readonly whenCommitted: (update: Effect.Effect<void>) => Effect.Effect<boolean>\n  /**\n   * Replays the run's durable history from `afterSequence`, then follows it.\n   *\n   * This is the lossless follower. It pages the history rather than\n   * materializing it, so the first entry arrives after one page rather than\n   * after the whole run; it reports a sink loss that happens while it is\n   * following; and a cursor below the run's compaction floor fails with\n   * `compacted` and the sequence to resync from, never a silently shortened\n   * history.\n   */\n  readonly stream: (options: StreamOptions) => Stream.Stream<Entry, JournalError>\n  /**\n   * Reads one page of the run's durable history in sequence order.\n   *\n   * `hasMore` reports whether another page follows. A cursor below the run's\n   * compaction floor fails with `compacted`, exactly as `stream` does, so a\n   * poller and a follower cannot disagree about what history exists.\n   */\n  readonly entries: (options: EntriesOptions) => Effect.Effect<EntriesPage, JournalError>\n  /**\n   * Subscribes to entries this process commits, across every run.\n   *\n   * This is a bounded SLIDING buffer sized by the layer's `capacity`: a slow\n   * consumer silently loses entries, with no error and no gap signal. Use it\n   * for a local tail or a UI feed, and use `stream` wherever a missing entry\n   * would be a correctness bug, because that is the lossless path and the one\n   * that reports sink losses.\n   *\n   * Only this process's commits arrive here. Another writer on the same\n   * database publishes into its own buffer, which is the second reason\n   * `stream` exists: it rechecks the durable tail.\n   *\n   * Published entries are deeply frozen, so one subscriber cannot mutate the\n   * value another subscriber is about to read.\n   */\n  readonly changes: Effect.Effect<PubSub.Subscription<Entry>, never, Scope.Scope>\n  readonly project: <S, E, R>(\n    projection: Projection<S, E, R>,\n    options: StreamOptions\n  ) => Stream.Stream<S, JournalError, R>\n  readonly flush: Effect.Effect<void, JournalError>\n  /**\n   * Durably records the state that replays the run from `options.seq`.\n   *\n   * The write shares `transact`'s discipline: it runs through the same\n   * `DurableWriter`, so inside an open `transact` it joins the caller's\n   * transaction as a savepoint and rolls back with it. `options.seq` must\n   * name a committed entry and must lie above the run's compaction floor;\n   * otherwise the write fails with `checkpoint_invalid`. Re-checkpointing an\n   * uncompacted `seq` replaces its state: last writer wins.\n   *\n   * The write is fenced on the run's ownership through the consensus\n   * strategy, exactly as `emitDurable` is: a reclaimed run fails with\n   * `fence_lost`. The fence is mandatory: a zombie owner must not replace\n   * replay state behind a live successor.\n   */\n  readonly checkpoint: (options: CheckpointOptions, owner: OwnerId) => Effect.Effect<Checkpoint, JournalError>\n  /**\n   * Reads the run's most recent checkpoint, compacted or not.\n   *\n   * A reader that fails with `compacted` resyncs here: apply\n   * `checkpoint.state`, then continue from\n   * `stream({ runId, afterSequence: checkpoint.seq })`.\n   */\n  readonly latestCheckpoint: (runId: RunId) => Effect.Effect<Option.Option<Checkpoint>, JournalError>\n  /**\n   * Deletes the run's entries strictly below a checkpoint, atomically with\n   * advancing the run's compaction floor.\n   *\n   * Refusals are typed: `checkpoint_invalid` when the run has no checkpoint\n   * to truncate below, `reader_behind` when a live in-process stream still\n   * needs a sequence the truncation would delete, and `fence_lost` when the\n   * supplied `owner` no longer holds the run. The fence is mandatory, so a\n   * zombie owner can never truncate history behind a live successor. Readers\n   * this process cannot see (pollers of `entries` and followers in other\n   * processes) are protected by the read-side guard instead: any read whose cursor starts\n   * below the floor fails with `compacted` and the floor to resync from,\n   * never a silently shortened history.\n   */\n  readonly compact: (options: CompactOptions, owner: OwnerId) => Effect.Effect<Compacted, JournalError>\n}\n\n/**\n * Context service for durable lifecycle evidence and lossy telemetry.\n *\n * @category services\n * @since 0.1.0\n */\nexport class Journal extends Context.Service<Journal, Service>()(\"@smthrs/journal/Journal\") {}\n\n/**\n * Constructs a journal service from an implementation.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const make = (implementation: Service): Service => Journal.of(implementation)\n\nconst unavailable = (method: string): JournalError =>\n  new JournalError({\n    code: \"journal_closed\",\n    message: `${method} is unavailable`\n  })\n\n/**\n * Constructs a closed journal stub, optionally overriding individual methods.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const makeNoop = (overrides: Partial<Service> = {}): Service => {\n  const service: Service = {\n    emitLossy: Effect.fn(\"Journal.emitLossy\")(() => Effect.fail(unavailable(\"emitLossy\"))),\n    emitDurable: Effect.fn(\"Journal.emitDurable\")(() => Effect.fail(unavailable(\"emitDurable\"))),\n    emitDurableUnfenced: Effect.fn(\"Journal.emitDurableUnfenced\")(() =>\n      Effect.fail(unavailable(\"emitDurableUnfenced\"))\n    ),\n    /**\n     * The closed stub has no sink and therefore no transaction to open, so it\n     * runs the effect directly, the same posture as\n     * `DurableEngineState`'s in-memory twin, whose `transaction` has no crash\n     * window to close. A test double that models rollback overrides it.\n     */\n    transact: <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E | JournalError, R> => effect,\n    whenCommitted: (update) => Effect.as(update, true),\n    stream: (options) =>\n      Stream.unwrap(\n        Effect.fn(\"Journal.stream\")((_options: StreamOptions) => Effect.succeed(Stream.fail(unavailable(\"stream\"))))(\n          options\n        )\n      ),\n    entries: Effect.fn(\"Journal.entries\")(() => Effect.fail(unavailable(\"entries\"))),\n    changes: Effect.acquireRelease(\n      PubSub.sliding<Entry>(1),\n      PubSub.shutdown\n    ).pipe(Effect.flatMap(PubSub.subscribe)),\n    project: (projection, options) =>\n      Stream.unwrap(\n        Effect.fn(\"Journal.project\")(\n          <S, E, R>(_projection: Projection<S, E, R>, _options: StreamOptions) =>\n            Effect.succeed(Stream.fail(unavailable(\"project\")))\n        )(projection, options)\n      ),\n    flush: Effect.fn(\"Journal.flush\")(() => Effect.fail(unavailable(\"flush\")))(),\n    checkpoint: Effect.fn(\"Journal.checkpoint\")(() => Effect.fail(unavailable(\"checkpoint\"))),\n    latestCheckpoint: Effect.fn(\"Journal.latestCheckpoint\")(() => Effect.fail(unavailable(\"latestCheckpoint\"))),\n    compact: Effect.fn(\"Journal.compact\")(() => Effect.fail(unavailable(\"compact\")))\n  }\n  return Journal.of({ ...service, ...overrides })\n}\n\n/**\n * Provides a closed journal stub.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layerNoop = (overrides: Partial<Service> = {}): Layer.Layer<Journal> =>\n  Layer.succeed(Journal)(makeNoop(overrides))\n"]}