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

package/dist/cjs/Journal.js

@@ -0,0 +1,190 @@
+"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 Journal_exports = {};
+__export(Journal_exports, {
+  Accepted: () => Accepted,
+  Checkpoint: () => Checkpoint,
+  CheckpointOptions: () => CheckpointOptions,
+  CompactOptions: () => CompactOptions,
+  Compacted: () => Compacted,
+  Dropped: () => Dropped,
+  Duplicate: () => Duplicate,
+  DurableReceipt: () => DurableReceipt,
+  EmitReceipt: () => EmitReceipt,
+  EntriesOptions: () => EntriesOptions,
+  EntriesPage: () => EntriesPage,
+  Journal: () => Journal,
+  JournalError: () => JournalError,
+  JournalErrorCode: () => JournalErrorCode,
+  OverflowPolicy: () => OverflowPolicy,
+  StreamOptions: () => StreamOptions,
+  afterCommit: () => import_DurableWriter.afterCommit,
+  layerNoop: () => layerNoop,
+  make: () => make,
+  makeNoop: () => makeNoop,
+  maxEntriesLimit: () => maxEntriesLimit
+});
+module.exports = __toCommonJS(Journal_exports);
+var Context = __toESM(require("effect/Context"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Layer = __toESM(require("effect/Layer"), 1);
+var PubSub = __toESM(require("effect/PubSub"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+var Stream = __toESM(require("effect/Stream"), 1);
+var import_JournalEvent = require("./JournalEvent.js");
+var import_DurableWriter = require("@smthrs/database/DurableWriter");
+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"
+]);
+class JournalError extends Schema.TaggedError()("@smthrs/journal/JournalError", {
+  code: JournalErrorCode,
+  message: Schema.String,
+  cause: Schema.optional(Schema.Unknown),
+  checkpointSeq: Schema.optional(import_JournalEvent.Seq)
+}) {
+}
+const OverflowPolicy = Schema.Literals(["reject", "drop-newest", "drop-oldest"]);
+const Accepted = Schema.TaggedStruct("Accepted", {
+  seq: import_JournalEvent.Seq,
+  sourceSeq: import_JournalEvent.SourceSeq,
+  evicted: Schema.optionalKey(Schema.Struct({
+    policy: Schema.Literal("drop-oldest"),
+    count: Schema.Int.check(Schema.isGreaterThan(0))
+  }))
+});
+const Duplicate = Schema.TaggedStruct("Duplicate", {
+  seq: import_JournalEvent.Seq,
+  sourceSeq: import_JournalEvent.SourceSeq,
+  status: Schema.Literals(["pending", "committed"])
+});
+const Dropped = Schema.TaggedStruct("Dropped", {
+  seq: import_JournalEvent.Seq,
+  sourceSeq: import_JournalEvent.SourceSeq,
+  policy: Schema.Literal("drop-newest")
+});
+const EmitReceipt = Schema.Union([Accepted, Duplicate, Dropped]);
+const DurableReceipt = Schema.Union([Accepted, Duplicate]);
+const StreamOptions = Schema.Struct({
+  runId: import_JournalEvent.RunId,
+  afterSequence: Schema.optionalKey(import_JournalEvent.Seq)
+});
+const maxEntriesLimit = 1e4;
+const EntriesOptions = Schema.Struct({
+  runId: import_JournalEvent.RunId,
+  after: Schema.optionalKey(import_JournalEvent.Seq),
+  eventTypes: Schema.optionalKey(
+    Schema.Array(import_JournalEvent.Entry.fields.eventType).check(Schema.isMinLength(1), Schema.isMaxLength(64))
+  ),
+  limit: Schema.Int.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(maxEntriesLimit))
+});
+const EntriesPage = Schema.Struct({
+  entries: Schema.Array(import_JournalEvent.Entry),
+  hasMore: Schema.Boolean
+});
+class Checkpoint extends Schema.Class("@smthrs/journal/Journal/Checkpoint")({
+  runId: import_JournalEvent.RunId,
+  seq: import_JournalEvent.Seq,
+  state: Schema.Unknown,
+  createdAtMs: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+  compactedAtMs: Schema.NullOr(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)))
+}) {
+}
+const CheckpointOptions = Schema.Struct({
+  runId: import_JournalEvent.RunId,
+  seq: import_JournalEvent.Seq,
+  state: Schema.Unknown
+});
+const CompactOptions = Schema.Struct({
+  runId: import_JournalEvent.RunId,
+  upTo: Schema.optionalKey(import_JournalEvent.Seq)
+});
+const Compacted = Schema.Struct({
+  runId: import_JournalEvent.RunId,
+  checkpointSeq: import_JournalEvent.Seq,
+  deleted: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))
+});
+class Journal extends Context.Service()("@smthrs/journal/Journal") {
+}
+const make = (implementation) => Journal.of(implementation);
+const unavailable = (method) => new JournalError({
+  code: "journal_closed",
+  message: `${method} is unavailable`
+});
+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 });
+};
+const layerNoop = (overrides = {}) => Layer.succeed(Journal)(makeNoop(overrides));
+//# sourceMappingURL=Journal.js.map

package/dist/cjs/Journal.js.map

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

package/dist/cjs/JournalEvent.d.ts

@@ -0,0 +1,421 @@
+/**
+ * Durable event-envelope schemas for the journal.
+ *
+ * @since 0.1.0
+ */
+import * as Schema from "effect/Schema";
+/**
+ * Longest identifier the journal persists.
+ *
+ * A run id, a source id and an event type are index columns of a permanent
+ * table and are held in per-run maps for the layer's lifetime, so an
+ * unbounded one costs durable index space and heap that nothing ever
+ * reclaims. Every identifier this repository mints is a uuid or a short
+ * dotted name, two orders of magnitude below this bound, so the ceiling
+ * refuses only the shapes that were never identifiers.
+ *
+ * @since 1.0.0
+ * @category constants
+ */
+export declare const maxIdentifierLength = 1024;
+/**
+ * Schema for an identifier of one durable run.
+ *
+ * Between 1 and 1,024 UTF-16 code units, free of unpaired UTF-16 surrogates
+ * because the store cannot tell two ill-formed identifiers apart, and free of
+ * NUL because the store's own length check cannot see past one.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const RunId: Schema.brand<Schema.String, "@smthrs/journal/JournalEvent/RunId">;
+/**
+ * Branded identifier of one durable run.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type RunId = typeof RunId.Type;
+/**
+ * Schema for the canonical, durable sequence number within a run.
+ *
+ * `Number.MAX_SAFE_INTEGER` is excluded because the journal must always be
+ * able to allocate the next sequence. `Number.MAX_SAFE_INTEGER + 1` is not a
+ * distinct integer, so the maximum is not an allocatable sequence.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const Seq: Schema.brand<Schema.Int, "@smthrs/journal/JournalEvent/Seq">;
+/**
+ * Canonical durable per-run sequence number.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type Seq = typeof Seq.Type;
+/**
+ * Schema for an event producer identifier.
+ *
+ * The same shape `RunId` accepts, on the same terms: the pair identifies a
+ * producer's retries in the database.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const SourceId: Schema.brand<Schema.String, "@smthrs/journal/JournalEvent/SourceId">;
+/**
+ * Identifier of an event producer.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type SourceId = typeof SourceId.Type;
+/**
+ * Schema for a producer-local event sequence number.
+ *
+ * `Number.MAX_SAFE_INTEGER` is excluded because the journal must always be
+ * able to allocate the next sequence. `Number.MAX_SAFE_INTEGER + 1` is not a
+ * distinct integer, so the maximum is not an allocatable sequence.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const SourceSeq: Schema.brand<Schema.Int, "@smthrs/journal/JournalEvent/SourceSeq">;
+/**
+ * Producer-local event sequence number.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type SourceSeq = typeof SourceSeq.Type;
+/**
+ * Schema for what a re-emitted `(runId, sourceId, sourceSeq)` identity means.
+ *
+ * `content` is the default and the strict reading: the identity names one set
+ * of bytes, so a producer that re-emits it with different bytes has a bug and
+ * the journal says so with `idempotency_conflict`.
+ *
+ * `identity` is for a producer that derives the sequence from the event
+ * itself. There a collision IS the same event observed twice, and the bytes
+ * that differ between the two observations are metadata ABOUT the observation
+ * rather than the event: when a replayed frame was re-recorded, how long a
+ * step took the second time a durable engine served it from its record. The
+ * first admitted row stands and the re-emission settles as `Duplicate`. Only
+ * declare it with a sequence derived from the event's own content, because
+ * the journal then has nothing else with which to notice two different events
+ * wearing one identity.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const Dedupe: Schema.Literals<readonly ["content", "identity"]>;
+/**
+ * What a re-emitted producer identity means.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type Dedupe = typeof Dedupe.Type;
+declare const Input_base: Schema.Class<Input, Schema.Struct<{
+    readonly runId: Schema.brand<Schema.String, "@smthrs/journal/JournalEvent/RunId">;
+    readonly sourceId: Schema.brand<Schema.String, "@smthrs/journal/JournalEvent/SourceId">;
+    readonly sourceSeq: Schema.optional<Schema.brand<Schema.Int, "@smthrs/journal/JournalEvent/SourceSeq">>;
+    /** How a collision on this event's identity is settled. Defaults to `content`. */
+    readonly dedupe: Schema.optional<Schema.Literals<readonly ["content", "identity"]>>;
+    /** Non-empty, NUL-free, well-formed UTF-16 of at most 1,024 code units. */
+    readonly eventType: Schema.String;
+    readonly payload: Schema.Unknown;
+    readonly meta: Schema.optional<Schema.Unknown>;
+}>, {}>;
+/**
+ * Schema for an event submitted to the journal.
+ *
+ * Event types and values intentionally remain an open envelope. The durable
+ * core never closes this into an interpreter-specific union.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare class Input extends Input_base {
+}
+declare const Entry_base: Schema.Class<Entry, Schema.Struct<{
+    readonly runId: Schema.brand<Schema.String, "@smthrs/journal/JournalEvent/RunId">;
+    readonly seq: Schema.brand<Schema.Int, "@smthrs/journal/JournalEvent/Seq">;
+    /**
+     * Derived by {@link makeEventId} from the other three identity members, never
+     * supplied by a caller, so it carries no check of its own.
+     */
+    readonly eventId: Schema.String;
+    readonly sourceId: Schema.brand<Schema.String, "@smthrs/journal/JournalEvent/SourceId">;
+    readonly sourceSeq: Schema.brand<Schema.Int, "@smthrs/journal/JournalEvent/SourceSeq">;
+    readonly emittedAtMs: Schema.Int;
+    /**
+     * The same bounded identifier `Input.eventType` accepts. It used to be a bare
+     * `Schema.String` here, so a consumer decoding an `Entry` accepted an empty,
+     * over-long, NUL-bearing, or ill-formed-UTF-16 event type that no emit could
+     * ever have produced.
+     */
+    readonly eventType: Schema.String;
+    readonly payload: Schema.Unknown;
+    readonly meta: Schema.Unknown;
+}>, {}>;
+/**
+ * Schema for a committed durable journal row.
+ *
+ * `seq` is allocated synchronously at journal admission and is the only
+ * sequence used for replay and durable provenance. `sourceSeq` identifies
+ * retries from one producer.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare class Entry extends Entry_base {
+}
+/**
+ * Makes a collision-free deterministic event identifier from the idempotency
+ * key `(runId, sourceId, sourceSeq)`.
+ *
+ * Length prefixes preserve tuple boundaries even when identifiers contain the
+ * separator. The value is deliberately not random: retrying the same source
+ * event must produce the same durable id.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const makeEventId: (runId: RunId, sourceId: SourceId, sourceSeq: SourceSeq) => string;
+/**
+ * The reserved prefix of every companion stream id.
+ *
+ * A run id that begins with it names a companion stream, never a run: stores
+ * that admit run ids (`@smthrs/run-store`'s `RunStore.create`) refuse it.
+ *
+ * @category constants
+ * @since 1.0.0
+ */
+export declare const companionPrefix = "flows.companion/";
+/**
+ * The digest a journal fact uses to reference bytes kept outside the journal:
+ * the SHA-256 of the UTF-8 encoding of `text`, as 64 lowercase hex digits.
+ *
+ * The journal redacts every payload, so a fact never carries executable
+ * values. A store that folds state from its facts keeps the bytes in its own
+ * rows and records only their digest, which a rebuild checks the row against.
+ *
+ * @category constructors
+ * @since 1.0.0
+ */
+export declare const contentDigest: (text: string) => string;
+/**
+ * The id of the companion stream that carries one store's facts about a run.
+ *
+ * A companion stream is an ordinary journal stream with its own sequence
+ * clock, kept beside the run's own stream rather than inside it. A consumer
+ * that reads the run's stream by position never sees a companion fact, and a
+ * rewind or compaction of the run's stream never truncates one. The id is
+ * `flows.companion/<stream>/<sha-256 of the run id>`, so it stays within
+ * {@link maxIdentifierLength} for every run id; each fact carries its run id
+ * in its payload.
+ *
+ * @category constructors
+ * @since 1.0.0
+ */
+export declare const companionRunId: (stream: string, runId: string) => RunId;
+/**
+ * Whether a run id names a companion stream.
+ *
+ * @category predicates
+ * @since 1.0.0
+ */
+export declare const isCompanionRunId: (runId: string) => boolean;
+/**
+ * Bounded durable text shared by namespace contracts.
+ *
+ * @category schemas
+ * @since 1.0.0
+ */
+export declare const Identifier: Schema.String;
+/**
+ * A lineage coordinate, distinct from the run that currently hosts it.
+ *
+ * @category schemas
+ * @since 1.0.0
+ */
+export declare const LineageId: Schema.brand<Schema.String, "@smthrs/journal/LineageId">;
+/**
+ * A lineage coordinate.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type LineageId = typeof LineageId.Type;
+/**
+ * A concrete wait identity.
+ *
+ * @category schemas
+ * @since 1.0.0
+ */
+export declare const WaitId: Schema.brand<Schema.String, "@smthrs/journal/WaitId">;
+/**
+ * A concrete wait identity.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type WaitId = typeof WaitId.Type;
+/**
+ * An admitted command identity.
+ *
+ * @category schemas
+ * @since 1.0.0
+ */
+export declare const CommandId: Schema.brand<Schema.String, "@smthrs/journal/CommandId">;
+/**
+ * An admitted command identity.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type CommandId = typeof CommandId.Type;
+/**
+ * A plan identity, never interchangeable with a dispatch or artifact.
+ *
+ * @category schemas
+ * @since 1.0.0
+ */
+export declare const PlanId: Schema.brand<Schema.String, "@smthrs/journal/PlanId">;
+/**
+ * A plan identity.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type PlanId = typeof PlanId.Type;
+/**
+ * A dispatch identity. Branding does not verify its digest.
+ *
+ * @category schemas
+ * @since 1.0.0
+ */
+export declare const DispatchId: Schema.brand<Schema.String, "@smthrs/journal/DispatchId">;
+/**
+ * A dispatch identity.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type DispatchId = typeof DispatchId.Type;
+/**
+ * An artifact identity. Branding does not verify content.
+ *
+ * @category schemas
+ * @since 1.0.0
+ */
+export declare const ArtifactId: Schema.brand<Schema.String, "@smthrs/journal/ArtifactId">;
+/**
+ * An artifact identity.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type ArtifactId = typeof ArtifactId.Type;
+/**
+ * Integer quantities in the inclusive safe range, including zero.
+ *
+ * @category schemas
+ * @since 1.0.0
+ */
+export declare const NonNegativeQuantity: Schema.Int;
+/**
+ * Integer quantities in the inclusive safe range, excluding zero.
+ *
+ * @category schemas
+ * @since 1.0.0
+ */
+export declare const PositiveQuantity: Schema.Int;
+/**
+ * Non-negative integral milliseconds since the Unix epoch.
+ *
+ * @category schemas
+ * @since 1.0.0
+ */
+export declare const TimestampMs: Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">;
+/**
+ * Non-negative integral milliseconds since the Unix epoch.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type TimestampMs = typeof TimestampMs.Type;
+/**
+ * Decode a run id without a cast; schema failures retain their issue.
+ *
+ * @category decoders
+ * @since 1.0.0
+ */
+export declare const decodeRunId: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<string & import("effect/Brand").Brand<"@smthrs/journal/JournalEvent/RunId">, Schema.SchemaError, never>;
+/**
+ * Decode a lineage id without a cast.
+ *
+ * @category decoders
+ * @since 1.0.0
+ */
+export declare const decodeLineageId: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<string & import("effect/Brand").Brand<"@smthrs/journal/LineageId">, Schema.SchemaError, never>;
+/**
+ * Decode a wait id without a cast.
+ *
+ * @category decoders
+ * @since 1.0.0
+ */
+export declare const decodeWaitId: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<string & import("effect/Brand").Brand<"@smthrs/journal/WaitId">, Schema.SchemaError, never>;
+/**
+ * Decode a command id without a cast.
+ *
+ * @category decoders
+ * @since 1.0.0
+ */
+export declare const decodeCommandId: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<string & import("effect/Brand").Brand<"@smthrs/journal/CommandId">, Schema.SchemaError, never>;
+/**
+ * Decode a plan id without a cast.
+ *
+ * @category decoders
+ * @since 1.0.0
+ */
+export declare const decodePlanId: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<string & import("effect/Brand").Brand<"@smthrs/journal/PlanId">, Schema.SchemaError, never>;
+/**
+ * Decode a dispatch id without a cast.
+ *
+ * @category decoders
+ * @since 1.0.0
+ */
+export declare const decodeDispatchId: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<string & import("effect/Brand").Brand<"@smthrs/journal/DispatchId">, Schema.SchemaError, never>;
+/**
+ * Decode an artifact id without a cast.
+ *
+ * @category decoders
+ * @since 1.0.0
+ */
+export declare const decodeArtifactId: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<string & import("effect/Brand").Brand<"@smthrs/journal/ArtifactId">, Schema.SchemaError, never>;
+/**
+ * Decode an absolute timestamp without coercion.
+ *
+ * @category decoders
+ * @since 1.0.0
+ */
+export declare const decodeTimestampMs: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<number & import("effect/Brand").Brand<"@smthrs/journal/TimestampMs">, Schema.SchemaError, never>;
+/**
+ * Decode a budget that permits zero. Units belong to the field.
+ *
+ * @category decoders
+ * @since 1.0.0
+ */
+export declare const decodeNonNegativeQuantity: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<number, Schema.SchemaError, never>;
+/**
+ * Decode a budget that requires positive capacity.
+ *
+ * @category decoders
+ * @since 1.0.0
+ */
+export declare const decodePositiveQuantity: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<number, Schema.SchemaError, never>;
+export {};
+//# sourceMappingURL=JournalEvent.d.ts.map