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

package/dist/esm/JournalGeneration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"JournalGeneration.js","sourceRoot":"","sources":["../../src/JournalGeneration.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,OAAO,MAAM,0BAA0B,CAAA;AACnD,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,SAAS,MAAM,+BAA+B,CAAA;AAE1D;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IAC5C,MAAM,GAAG,GAAG,KAAK,CAAC,CAAC,SAAS,CAAC,SAAS,CAAA;IACtC,uEAAuE;IACvE,IAAI,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC;QAAE,OAAM;IACnC,KAAK,CAAC,CAAC,GAAG,CAAA;;;mBAGO,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,oBACnC,OAAO,CAAC,SAAS,CAAC,GAAG,EAAE,GAAG,CAAA,YAAY,CACxC;kBACgB,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,oBAClC,OAAO,CAAC,SAAS,CAAC,GAAG,EAAE,GAAG,CAAA,WAAW,CACvC;;GAEC,CAAA;AACH,CAAC,CAAC,CAAA;AAEF,MAAM,QAAQ,GAAG,IAAI,OAAO,EAAqE,CAAA;AAEjG;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,MAA+C,EAAE,EAAE,CAC5E,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IAClB,MAAM,GAAG,GAAG,KAAK,CAAC,CAAC,SAAS,CAAC,SAAS,CAAA;IACtC,IAAI,SAAS,GAAG,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;IACjC,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;QAC5B,SAAS,GAAG,IAAI,GAAG,EAAE,CAAA;QACrB,QAAQ,CAAC,GAAG,CAAC,GAAG,EAAE,SAAS,CAAC,CAAA;IAC9B,CAAC;IACD,MAAM,UAAU,GAAG,SAAS,CAAA;IAC5B,KAAK,CAAC,CAAC,MAAM,CAAC,cAAc,CAC1B,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,EACzC,GAAG,EAAE,CACH,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE;QACf,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;IAC3B,CAAC,CAAC,CACL,CAAA;AACH,CAAC,CAAC,CAAA;AAEJ;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,CAAC,MAA6B,EAAE,EAAE,CACtD,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IAClB,MAAM,GAAG,GAAG,KAAK,CAAC,CAAC,SAAS,CAAC,SAAS,CAAA;IACtC,KAAK,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE;QACtB,KAAK,MAAM,UAAU,IAAI,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,EAAE;YAAE,UAAU,CAAC,MAAM,CAAC,CAAA;IACtE,CAAC,CAAC,CAAA;AACJ,CAAC,CAAC,CAAA","sourcesContent":["/**\n * Durable generations distinguish histories that reuse journal sequences.\n *\n * @since 1.0.0-rc.0\n */\n\nimport * as Dialect from \"@smthrs/database/Dialect\"\nimport * as Effect from \"effect/Effect\"\nimport * as SqlClient from \"effect/unstable/sql/SqlClient\"\n\n/**\n * Installs the generation table idempotently. Both the SQL journal and time\n * travel initialize it, including databases whose migration ladder already\n * passed the journal's reserved block. A read-only client installs nothing.\n *\n * @category migrations\n * @since 1.0.0-rc.0\n */\nexport const initialize = Effect.gen(function*() {\n  const sql = yield* SqlClient.SqlClient\n  // A read-only observer reads the schema it finds and installs nothing.\n  if (Dialect.isReadOnly(sql)) return\n  yield* sql`\n    CREATE TABLE IF NOT EXISTS flows_journal_generations (\n      run_id TEXT PRIMARY KEY NOT NULL CHECK (length(run_id) > 0),\n      generation ${Dialect.integer(sql)} NOT NULL CHECK (${\n    Dialect.isInteger(sql, sql`generation`)\n  } AND generation > 0 AND generation <= 9007199254740991),\n      after_seq ${Dialect.integer(sql)} NOT NULL CHECK (${\n    Dialect.isInteger(sql, sql`after_seq`)\n  } AND after_seq >= -1 AND after_seq <= 9007199254740991)\n    )\n  `\n})\n\nconst journals = new WeakMap<SqlClient.SqlClient, Set<(runIds: ReadonlyArray<string>) => void>>()\n\n/**\n * Registers a live journal's cache invalidation until its scope closes.\n * Multiple journals over the same SQL client must observe the same rewind.\n *\n * @category lifecycle\n * @since 1.0.0-rc.0\n */\nexport const onTruncate = (forget: (runIds: ReadonlyArray<string>) => void) =>\n  Effect.gen(function*() {\n    const sql = yield* SqlClient.SqlClient\n    let listeners = journals.get(sql)\n    if (listeners === undefined) {\n      listeners = new Set()\n      journals.set(sql, listeners)\n    }\n    const registered = listeners\n    yield* Effect.acquireRelease(\n      Effect.sync(() => registered.add(forget)),\n      () =>\n        Effect.sync(() => {\n          registered.delete(forget)\n        })\n    )\n  })\n\n/**\n * Forgets cached identities and allocation floors after a committed truncation.\n * The rewinder must quiesce producers and flush pending admissions first.\n * Database rows remain authoritative; this operation changes no durable data.\n *\n * @category lifecycle\n * @since 1.0.0-rc.0\n */\nexport const forget = (runIds: ReadonlyArray<string>) =>\n  Effect.gen(function*() {\n    const sql = yield* SqlClient.SqlClient\n    yield* Effect.sync(() => {\n      for (const invalidate of journals.get(sql) ?? []) invalidate(runIds)\n    })\n  })\n"]}

package/dist/esm/JournalMetrics.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Standard metric definitions for the journal write path.
+ *
+ * This module only defines the metric handles, following the shape of Effect's
+ * `ClusterMetrics`. `SqlJournal` updates them as emission receipts are
+ * produced, so the counters measure admissions on the hot path rather than
+ * rows read back. No exporter ships in this package; provide one, for
+ * example `@smthrs/observability`, and these counters appear in it.
+ *
+ * @since 0.1.0
+ */
+import * as Metric from "effect/Metric";
+/**
+ * Counter over journal emissions, dimensioned by `channel` (`durable` or
+ * `lossy`) and `receipt` (`accepted`, `duplicate`, or `dropped`).
+ *
+ * **Details**
+ *
+ * A `durable` emission counts when its receipt is produced, which is after the
+ * write transaction returned; under `Journal.transact` that is still inside
+ * the caller's transaction, so a receipt that later rolls back with the
+ * enclosing transaction has already counted. The counter is throughput
+ * evidence, not commit evidence: the journal rows themselves are the latter.
+ *
+ * @category metrics
+ * @since 0.1.0
+ */
+export declare const writes: Metric.Counter<number>;
+/**
+ * `writes` views for the durable channel, keyed by the receipt tag
+ * `Journal.emitDurable` resolves to.
+ *
+ * @category metrics
+ * @since 0.1.0
+ */
+export declare const durable: {
+    readonly [Tag in "Accepted" | "Duplicate"]: Metric.Metric<number, Metric.CounterState<number>>;
+};
+/**
+ * `writes` views for the lossy channel, keyed by the receipt tag
+ * `Journal.emitLossy` resolves to.
+ *
+ * @category metrics
+ * @since 0.1.0
+ */
+export declare const lossy: {
+    readonly [Tag in "Accepted" | "Duplicate" | "Dropped"]: Metric.Metric<number, Metric.CounterState<number>>;
+};
+/**
+ * Counter over lossy entries the writer admitted and then failed to commit,
+ * dimensioned by `channel` (always `lossy`) and the `code` of the
+ * `JournalError` that lost them.
+ *
+ * **Details**
+ *
+ * A lossy producer rarely calls `flush`, so the failure `flush` reports is not
+ * where an operator learns about a lost batch. This counter moves by the number
+ * of entries lost the moment the writer gives them up, whether or not anyone
+ * is waiting on them.
+ *
+ * @category metrics
+ * @since 1.0.0-rc.1
+ */
+export declare const lostEntries: Metric.Counter<number>;
+/**
+ * The {@link lostEntries} view for one `JournalError` code.
+ *
+ * @category metrics
+ * @since 1.0.0-rc.1
+ */
+export declare const lost: (code: string) => Metric.Metric<number, Metric.CounterState<number>>;
+//# sourceMappingURL=JournalMetrics.d.ts.map

package/dist/esm/JournalMetrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JournalMetrics.d.ts","sourceRoot":"","sources":["../../src/JournalMetrics.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,MAAM,wBAEjB,CAAA;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,EAAE;IACpB,QAAQ,EAAE,GAAG,IAAI,UAAU,GAAG,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;CAI/F,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,KAAK,EAAE;IAClB,QAAQ,EAAE,GAAG,IAAI,UAAU,GAAG,WAAW,GAAG,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;CAK3G,CAAA;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,WAAW,wBAEtB,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,IAAI,GAAI,MAAM,MAAM,KAAG,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,YAAY,CAAC,MAAM,CAAC,CACrB,CAAA"}

package/dist/esm/JournalMetrics.js

@@ -0,0 +1,79 @@
+/**
+ * Standard metric definitions for the journal write path.
+ *
+ * This module only defines the metric handles, following the shape of Effect's
+ * `ClusterMetrics`. `SqlJournal` updates them as emission receipts are
+ * produced, so the counters measure admissions on the hot path rather than
+ * rows read back. No exporter ships in this package; provide one, for
+ * example `@smthrs/observability`, and these counters appear in it.
+ *
+ * @since 0.1.0
+ */
+import * as Metric from "effect/Metric";
+/**
+ * Counter over journal emissions, dimensioned by `channel` (`durable` or
+ * `lossy`) and `receipt` (`accepted`, `duplicate`, or `dropped`).
+ *
+ * **Details**
+ *
+ * A `durable` emission counts when its receipt is produced, which is after the
+ * write transaction returned; under `Journal.transact` that is still inside
+ * the caller's transaction, so a receipt that later rolls back with the
+ * enclosing transaction has already counted. The counter is throughput
+ * evidence, not commit evidence: the journal rows themselves are the latter.
+ *
+ * @category metrics
+ * @since 0.1.0
+ */
+export const writes = Metric.counter("flows_journal_writes", {
+    description: "Journal emissions by channel and receipt"
+});
+/**
+ * `writes` views for the durable channel, keyed by the receipt tag
+ * `Journal.emitDurable` resolves to.
+ *
+ * @category metrics
+ * @since 0.1.0
+ */
+export const durable = {
+    Accepted: Metric.withAttributes(writes, { channel: "durable", receipt: "accepted" }),
+    Duplicate: Metric.withAttributes(writes, { channel: "durable", receipt: "duplicate" })
+};
+/**
+ * `writes` views for the lossy channel, keyed by the receipt tag
+ * `Journal.emitLossy` resolves to.
+ *
+ * @category metrics
+ * @since 0.1.0
+ */
+export const lossy = {
+    Accepted: Metric.withAttributes(writes, { channel: "lossy", receipt: "accepted" }),
+    Duplicate: Metric.withAttributes(writes, { channel: "lossy", receipt: "duplicate" }),
+    Dropped: Metric.withAttributes(writes, { channel: "lossy", receipt: "dropped" })
+};
+/**
+ * Counter over lossy entries the writer admitted and then failed to commit,
+ * dimensioned by `channel` (always `lossy`) and the `code` of the
+ * `JournalError` that lost them.
+ *
+ * **Details**
+ *
+ * A lossy producer rarely calls `flush`, so the failure `flush` reports is not
+ * where an operator learns about a lost batch. This counter moves by the number
+ * of entries lost the moment the writer gives them up, whether or not anyone
+ * is waiting on them.
+ *
+ * @category metrics
+ * @since 1.0.0-rc.1
+ */
+export const lostEntries = Metric.counter("flows_journal_lost", {
+    description: "Admitted lossy journal entries the writer failed to commit"
+});
+/**
+ * The {@link lostEntries} view for one `JournalError` code.
+ *
+ * @category metrics
+ * @since 1.0.0-rc.1
+ */
+export const lost = (code) => Metric.withAttributes(lostEntries, { channel: "lossy", code });
+//# sourceMappingURL=JournalMetrics.js.map

package/dist/esm/JournalMetrics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"JournalMetrics.js","sourceRoot":"","sources":["../../src/JournalMetrics.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,sBAAsB,EAAE;IAC3D,WAAW,EAAE,0CAA0C;CACxD,CAAC,CAAA;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,OAAO,GAEhB;IACF,QAAQ,EAAE,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,UAAU,EAAE,CAAC;IACpF,SAAS,EAAE,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,WAAW,EAAE,CAAC;CACvF,CAAA;AAED;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,KAAK,GAEd;IACF,QAAQ,EAAE,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,CAAC;IAClF,SAAS,EAAE,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,CAAC;IACpF,OAAO,EAAE,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC;CACjF,CAAA;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC,oBAAoB,EAAE;IAC9D,WAAW,EAAE,4DAA4D;CAC1E,CAAC,CAAA;AAEF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,CAAC,IAAY,EAAsD,EAAE,CACvF,MAAM,CAAC,cAAc,CAAC,WAAW,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAA","sourcesContent":["/**\n * Standard metric definitions for the journal write path.\n *\n * This module only defines the metric handles, following the shape of Effect's\n * `ClusterMetrics`. `SqlJournal` updates them as emission receipts are\n * produced, so the counters measure admissions on the hot path rather than\n * rows read back. No exporter ships in this package; provide one, for\n * example `@smthrs/observability`, and these counters appear in it.\n *\n * @since 0.1.0\n */\n\nimport * as Metric from \"effect/Metric\"\n\n/**\n * Counter over journal emissions, dimensioned by `channel` (`durable` or\n * `lossy`) and `receipt` (`accepted`, `duplicate`, or `dropped`).\n *\n * **Details**\n *\n * A `durable` emission counts when its receipt is produced, which is after the\n * write transaction returned; under `Journal.transact` that is still inside\n * the caller's transaction, so a receipt that later rolls back with the\n * enclosing transaction has already counted. The counter is throughput\n * evidence, not commit evidence: the journal rows themselves are the latter.\n *\n * @category metrics\n * @since 0.1.0\n */\nexport const writes = Metric.counter(\"flows_journal_writes\", {\n  description: \"Journal emissions by channel and receipt\"\n})\n\n/**\n * `writes` views for the durable channel, keyed by the receipt tag\n * `Journal.emitDurable` resolves to.\n *\n * @category metrics\n * @since 0.1.0\n */\nexport const durable: {\n  readonly [Tag in \"Accepted\" | \"Duplicate\"]: Metric.Metric<number, Metric.CounterState<number>>\n} = {\n  Accepted: Metric.withAttributes(writes, { channel: \"durable\", receipt: \"accepted\" }),\n  Duplicate: Metric.withAttributes(writes, { channel: \"durable\", receipt: \"duplicate\" })\n}\n\n/**\n * `writes` views for the lossy channel, keyed by the receipt tag\n * `Journal.emitLossy` resolves to.\n *\n * @category metrics\n * @since 0.1.0\n */\nexport const lossy: {\n  readonly [Tag in \"Accepted\" | \"Duplicate\" | \"Dropped\"]: Metric.Metric<number, Metric.CounterState<number>>\n} = {\n  Accepted: Metric.withAttributes(writes, { channel: \"lossy\", receipt: \"accepted\" }),\n  Duplicate: Metric.withAttributes(writes, { channel: \"lossy\", receipt: \"duplicate\" }),\n  Dropped: Metric.withAttributes(writes, { channel: \"lossy\", receipt: \"dropped\" })\n}\n\n/**\n * Counter over lossy entries the writer admitted and then failed to commit,\n * dimensioned by `channel` (always `lossy`) and the `code` of the\n * `JournalError` that lost them.\n *\n * **Details**\n *\n * A lossy producer rarely calls `flush`, so the failure `flush` reports is not\n * where an operator learns about a lost batch. This counter moves by the number\n * of entries lost the moment the writer gives them up, whether or not anyone\n * is waiting on them.\n *\n * @category metrics\n * @since 1.0.0-rc.1\n */\nexport const lostEntries = Metric.counter(\"flows_journal_lost\", {\n  description: \"Admitted lossy journal entries the writer failed to commit\"\n})\n\n/**\n * The {@link lostEntries} view for one `JournalError` code.\n *\n * @category metrics\n * @since 1.0.0-rc.1\n */\nexport const lost = (code: string): Metric.Metric<number, Metric.CounterState<number>> =>\n  Metric.withAttributes(lostEntries, { channel: \"lossy\", code })\n"]}

package/dist/esm/Migrations.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Journal schema migrations.
+ *
+ * The journal owns four tables: `flows_journal_events` and its event-type
+ * index in `0001_initial`, `flows_journal_checkpoints` in
+ * `0002_checkpoints`, the bounded startup ordering index in
+ * `0003_startup_index`, compacted producer identities in `0004_dedup`, the
+ * per-run exact event-type cursor index in `0005_run_event_type`, and the
+ * `SqlConsensus` lease table `flows_consensus_leases` in `0006_consensus`. Run
+ * and attempt state migrate from `@smthrs/run-store`, the step cache from
+ * `@smthrs/step-cache`, and the durable deferred/clock tables from
+ * `@smthrs/engine-store`; an application composes those sets with this one
+ * through `@smthrs/database`'s `Migrations.layer`.
+ *
+ * @since 0.1.0
+ */
+import * as DatabaseMigrations from "@smthrs/database/Migrations";
+import * as Layer from "effect/Layer";
+/**
+ * The journal's namespaced migration set, for composition with the other
+ * storage packages.
+ *
+ * @category migrations
+ * @since 0.1.0
+ */
+export declare const set: DatabaseMigrations.MigrationSet;
+/**
+ * Creates the journal's authoritative durable schema.
+ *
+ * @category migrations
+ * @since 0.1.0
+ */
+export declare const run: import("effect/Effect").Effect<readonly (readonly [id: number, name: string])[], import("effect/unstable/sql/SqlError").SqlError | import("effect/unstable/sql/Migrator").MigrationError, import("effect/unstable/sql/SqlClient").SqlClient>;
+/**
+ * Layer that runs journal migrations before exposing the database to journal
+ * services.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const layer: Layer.Layer<never, import("effect/unstable/sql/SqlError").SqlError | import("effect/unstable/sql/Migrator").MigrationError, import("effect/unstable/sql/SqlClient").SqlClient>;
+//# sourceMappingURL=Migrations.d.ts.map

package/dist/esm/Migrations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Migrations.d.ts","sourceRoot":"","sources":["../../src/Migrations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,kBAAkB,MAAM,6BAA6B,CAAA;AACjE,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAQrC;;;;;;GAMG;AACH,eAAO,MAAM,GAAG,EAAE,kBAAkB,CAAC,YAWpC,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,GAAG,8OAAgC,CAAA;AAEhD;;;;;;GAMG;AACH,eAAO,MAAM,KAAK,gLAA2B,CAAA"}

package/dist/esm/Migrations.js

@@ -0,0 +1,59 @@
+/**
+ * Journal schema migrations.
+ *
+ * The journal owns four tables: `flows_journal_events` and its event-type
+ * index in `0001_initial`, `flows_journal_checkpoints` in
+ * `0002_checkpoints`, the bounded startup ordering index in
+ * `0003_startup_index`, compacted producer identities in `0004_dedup`, the
+ * per-run exact event-type cursor index in `0005_run_event_type`, and the
+ * `SqlConsensus` lease table `flows_consensus_leases` in `0006_consensus`. Run
+ * and attempt state migrate from `@smthrs/run-store`, the step cache from
+ * `@smthrs/step-cache`, and the durable deferred/clock tables from
+ * `@smthrs/engine-store`; an application composes those sets with this one
+ * through `@smthrs/database`'s `Migrations.layer`.
+ *
+ * @since 0.1.0
+ */
+import * as DatabaseMigrations from "@smthrs/database/Migrations";
+import * as Layer from "effect/Layer";
+import { initial } from "./migrations/0001_initial.js";
+import { checkpoints } from "./migrations/0002_checkpoints.js";
+import { startupIndex } from "./migrations/0003_startup_index.js";
+import { dedup } from "./migrations/0004_dedup.js";
+import { runEventType } from "./migrations/0005_run_event_type.js";
+import { consensus } from "./migrations/0006_consensus.js";
+/**
+ * The journal's namespaced migration set, for composition with the other
+ * storage packages.
+ *
+ * @category migrations
+ * @since 0.1.0
+ */
+export const set = {
+    namespace: "journal",
+    idOffset: 0,
+    migrations: {
+        "0001_initial": initial,
+        "0002_checkpoints": checkpoints,
+        "0003_startup_index": startupIndex,
+        "0004_dedup": dedup,
+        "0005_run_event_type": runEventType,
+        "0006_consensus": consensus
+    }
+};
+/**
+ * Creates the journal's authoritative durable schema.
+ *
+ * @category migrations
+ * @since 0.1.0
+ */
+export const run = DatabaseMigrations.run([set]);
+/**
+ * Layer that runs journal migrations before exposing the database to journal
+ * services.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export const layer = Layer.effectDiscard(run);
+//# sourceMappingURL=Migrations.js.map

package/dist/esm/Migrations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Migrations.js","sourceRoot":"","sources":["../../src/Migrations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,kBAAkB,MAAM,6BAA6B,CAAA;AACjE,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,EAAE,OAAO,EAAE,MAAM,8BAA8B,CAAA;AACtD,OAAO,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAA;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAA;AACjE,OAAO,EAAE,KAAK,EAAE,MAAM,4BAA4B,CAAA;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAA;AAClE,OAAO,EAAE,SAAS,EAAE,MAAM,gCAAgC,CAAA;AAE1D;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,GAAG,GAAoC;IAClD,SAAS,EAAE,SAAS;IACpB,QAAQ,EAAE,CAAC;IACX,UAAU,EAAE;QACV,cAAc,EAAE,OAAO;QACvB,kBAAkB,EAAE,WAAW;QAC/B,oBAAoB,EAAE,YAAY;QAClC,YAAY,EAAE,KAAK;QACnB,qBAAqB,EAAE,YAAY;QACnC,gBAAgB,EAAE,SAAS;KAC5B;CACF,CAAA;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,GAAG,GAAG,kBAAkB,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAA;AAEhD;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,KAAK,CAAC,aAAa,CAAC,GAAG,CAAC,CAAA","sourcesContent":["/**\n * Journal schema migrations.\n *\n * The journal owns four tables: `flows_journal_events` and its event-type\n * index in `0001_initial`, `flows_journal_checkpoints` in\n * `0002_checkpoints`, the bounded startup ordering index in\n * `0003_startup_index`, compacted producer identities in `0004_dedup`, the\n * per-run exact event-type cursor index in `0005_run_event_type`, and the\n * `SqlConsensus` lease table `flows_consensus_leases` in `0006_consensus`. Run\n * and attempt state migrate from `@smthrs/run-store`, the step cache from\n * `@smthrs/step-cache`, and the durable deferred/clock tables from\n * `@smthrs/engine-store`; an application composes those sets with this one\n * through `@smthrs/database`'s `Migrations.layer`.\n *\n * @since 0.1.0\n */\n\nimport * as DatabaseMigrations from \"@smthrs/database/Migrations\"\nimport * as Layer from \"effect/Layer\"\nimport { initial } from \"./migrations/0001_initial.ts\"\nimport { checkpoints } from \"./migrations/0002_checkpoints.ts\"\nimport { startupIndex } from \"./migrations/0003_startup_index.ts\"\nimport { dedup } from \"./migrations/0004_dedup.ts\"\nimport { runEventType } from \"./migrations/0005_run_event_type.ts\"\nimport { consensus } from \"./migrations/0006_consensus.ts\"\n\n/**\n * The journal's namespaced migration set, for composition with the other\n * storage packages.\n *\n * @category migrations\n * @since 0.1.0\n */\nexport const set: DatabaseMigrations.MigrationSet = {\n  namespace: \"journal\",\n  idOffset: 0,\n  migrations: {\n    \"0001_initial\": initial,\n    \"0002_checkpoints\": checkpoints,\n    \"0003_startup_index\": startupIndex,\n    \"0004_dedup\": dedup,\n    \"0005_run_event_type\": runEventType,\n    \"0006_consensus\": consensus\n  }\n}\n\n/**\n * Creates the journal's authoritative durable schema.\n *\n * @category migrations\n * @since 0.1.0\n */\nexport const run = DatabaseMigrations.run([set])\n\n/**\n * Layer that runs journal migrations before exposing the database to journal\n * services.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layer = Layer.effectDiscard(run)\n"]}

package/dist/esm/OwnerId.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The fencing token the journal accepts on durable appends.
+ *
+ * `OwnerId` lives here rather than with the ownership *arbitration* in
+ * `@smthrs/run-store` because the journal is what it fences: `emitDurable`
+ * takes an owner and refuses the append when the persisted fence has moved on.
+ * The journal therefore defines the token, and the run store (which stores it
+ * on runs and arbitrates who holds it) imports it.
+ *
+ * @since 0.1.0
+ */
+import * as Schema from "effect/Schema";
+/**
+ * A process identity scoped to a host and a unique ownership nonce.
+ *
+ * `pid` is a real operating-system process id, so the schema states that: a
+ * non-negative integer. A fractional, `NaN`, or negative `pid` is a caller
+ * bug, and the fenced methods reject it as `invalid_event` rather than
+ * degrading it into `fence_lost`, which would read as "someone else owns this
+ * run" and send the caller looking for a race that never happened.
+ *
+ * `hostId` and `nonce` stay plain strings. An empty one is a legal value that
+ * simply matches no persisted owner, which is exactly `fence_lost`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const OwnerId: Schema.Struct<{
+    readonly hostId: Schema.String;
+    readonly pid: Schema.Int;
+    readonly nonce: Schema.String;
+}>;
+/**
+ * A process identity scoped to a host and a unique ownership nonce.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type OwnerId = typeof OwnerId.Type;
+//# sourceMappingURL=OwnerId.d.ts.map

package/dist/esm/OwnerId.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OwnerId.d.ts","sourceRoot":"","sources":["../../src/OwnerId.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,OAAO;;;;EAIlB,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,OAAO,GAAG,OAAO,OAAO,CAAC,IAAI,CAAA"}

package/dist/esm/OwnerId.js

@@ -0,0 +1,33 @@
+/**
+ * The fencing token the journal accepts on durable appends.
+ *
+ * `OwnerId` lives here rather than with the ownership *arbitration* in
+ * `@smthrs/run-store` because the journal is what it fences: `emitDurable`
+ * takes an owner and refuses the append when the persisted fence has moved on.
+ * The journal therefore defines the token, and the run store (which stores it
+ * on runs and arbitrates who holds it) imports it.
+ *
+ * @since 0.1.0
+ */
+import * as Schema from "effect/Schema";
+/**
+ * A process identity scoped to a host and a unique ownership nonce.
+ *
+ * `pid` is a real operating-system process id, so the schema states that: a
+ * non-negative integer. A fractional, `NaN`, or negative `pid` is a caller
+ * bug, and the fenced methods reject it as `invalid_event` rather than
+ * degrading it into `fence_lost`, which would read as "someone else owns this
+ * run" and send the caller looking for a race that never happened.
+ *
+ * `hostId` and `nonce` stay plain strings. An empty one is a legal value that
+ * simply matches no persisted owner, which is exactly `fence_lost`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export const OwnerId = Schema.Struct({
+    hostId: Schema.String,
+    pid: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+    nonce: Schema.String
+});
+//# sourceMappingURL=OwnerId.js.map

package/dist/esm/OwnerId.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"OwnerId.js","sourceRoot":"","sources":["../../src/OwnerId.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC;IACnC,MAAM,EAAE,MAAM,CAAC,MAAM;IACrB,GAAG,EAAE,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,sBAAsB,CAAC,CAAC,CAAC,CAAC;IACvD,KAAK,EAAE,MAAM,CAAC,MAAM;CACrB,CAAC,CAAA","sourcesContent":["/**\n * The fencing token the journal accepts on durable appends.\n *\n * `OwnerId` lives here rather than with the ownership *arbitration* in\n * `@smthrs/run-store` because the journal is what it fences: `emitDurable`\n * takes an owner and refuses the append when the persisted fence has moved on.\n * The journal therefore defines the token, and the run store (which stores it\n * on runs and arbitrates who holds it) imports it.\n *\n * @since 0.1.0\n */\n\nimport * as Schema from \"effect/Schema\"\n\n/**\n * A process identity scoped to a host and a unique ownership nonce.\n *\n * `pid` is a real operating-system process id, so the schema states that: a\n * non-negative integer. A fractional, `NaN`, or negative `pid` is a caller\n * bug, and the fenced methods reject it as `invalid_event` rather than\n * degrading it into `fence_lost`, which would read as \"someone else owns this\n * run\" and send the caller looking for a race that never happened.\n *\n * `hostId` and `nonce` stay plain strings. An empty one is a legal value that\n * simply matches no persisted owner, which is exactly `fence_lost`.\n *\n * @since 0.1.0\n * @category models\n */\nexport const OwnerId = Schema.Struct({\n  hostId: Schema.String,\n  pid: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),\n  nonce: Schema.String\n})\n\n/**\n * A process identity scoped to a host and a unique ownership nonce.\n *\n * @since 0.1.0\n * @category models\n */\nexport type OwnerId = typeof OwnerId.Type\n"]}

package/dist/esm/Projection.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Reproducible journal projections.
+ *
+ * @since 0.1.0
+ */
+import type * as Effect from "effect/Effect";
+import type { Entry } from "./JournalEvent.ts";
+/**
+ * An effectful fold over committed journal entries.
+ *
+ * Projections have no independent durable state. Replaying the same entries
+ * through the same reducer must reproduce the same result.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface Projection<S, E = never, R = never> {
+    readonly name: string;
+    readonly initial: S;
+    readonly reduce: (state: S, entry: Entry) => Effect.Effect<S, E, R>;
+}
+/**
+ * Constructs a reproducible journal projection.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const make: <S, E = never, R = never>(projection: Projection<S, E, R>) => Projection<S, E, R>;
+//# sourceMappingURL=Projection.d.ts.map

package/dist/esm/Projection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Projection.d.ts","sourceRoot":"","sources":["../../src/Projection.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAE9C;;;;;;;;GAQG;AACH,MAAM,WAAW,UAAU,CAAC,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,KAAK;IACjD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAA;IACnB,QAAQ,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,KAAK,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;CACpE;AAED;;;;;GAKG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,KAAK,EAAE,YAAY,UAAU,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAG,UAAU,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAe,CAAA"}

package/dist/esm/Projection.js

@@ -0,0 +1,13 @@
+/**
+ * Reproducible journal projections.
+ *
+ * @since 0.1.0
+ */
+/**
+ * Constructs a reproducible journal projection.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export const make = (projection) => projection;
+//# sourceMappingURL=Projection.js.map

package/dist/esm/Projection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Projection.js","sourceRoot":"","sources":["../../src/Projection.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAoBH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,CAA0B,UAA+B,EAAuB,EAAE,CAAC,UAAU,CAAA","sourcesContent":["/**\n * Reproducible journal projections.\n *\n * @since 0.1.0\n */\n\nimport type * as Effect from \"effect/Effect\"\nimport type { Entry } from \"./JournalEvent.ts\"\n\n/**\n * An effectful fold over committed journal entries.\n *\n * Projections have no independent durable state. Replaying the same entries\n * through the same reducer must reproduce the same result.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface Projection<S, E = never, R = never> {\n  readonly name: string\n  readonly initial: S\n  readonly reduce: (state: S, entry: Entry) => Effect.Effect<S, E, R>\n}\n\n/**\n * Constructs a reproducible journal projection.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const make = <S, E = never, R = never>(projection: Projection<S, E, R>): Projection<S, E, R> => projection\n"]}

package/dist/esm/RedactedLogger.d.ts

@@ -0,0 +1,121 @@
+/**
+ * The redacting logger: the journal's redaction rules applied to log output.
+ *
+ * The journal redacts on the write path, so a credential a cell logs or
+ * returns never reaches a committed row (`./Redaction.ts`). The operator's
+ * terminal was the other place the same credential surfaces: every built-in
+ * Effect logger renders through the fiber's `Console`, so an action that hands
+ * a token to `Effect.logInfo` wrote it to stderr in full and it reached
+ * whatever collected that stream.
+ *
+ * This module closes that half with the SAME rules rather than a second rule
+ * set. {@link wrap} does not re-implement redaction and does not re-format a
+ * log line. It redacts the log event itself — the message, the cause, and the
+ * log annotations — before the wrapped logger is handed it, and it hands that
+ * logger a view of the fiber whose `Console` is a redacting console, so
+ * whatever the logger renders for itself — a pretty line, a JSON document —
+ * passes through `Redaction.redact` on its way to the stream as well.
+ *
+ * Both halves carry load. Most built-in loggers write through the fiber's
+ * `Console`, which is what covers the pretty line, the `--json` document, and
+ * the `.flows/logs/<runId>.log` stream. But a logger is free to read the event
+ * instead of rendering it, and one in Effect's own default logger set does:
+ * `Logger.tracerLogger` publishes the message as a span event name and
+ * `Cause.pretty` of the cause as the span's `effect.cause` attribute, and
+ * never reads `Console` at all. Redacting only the console would hide a
+ * credential on stderr and export it in clear to whatever OTLP collector is
+ * configured.
+ *
+ * Cost is bounded by the rules themselves: every alternation inside a
+ * repetition in `Redaction.diagnosticRules` starts its branches with disjoint
+ * characters, so each rule is linear in the length of the line and no input
+ * backtracks catastrophically.
+ *
+ * One deliberate difference from the journal write path. `Redaction.redact`
+ * rebuilds an object from its own enumerable entries, which is right for a row
+ * that is about to be JSON-encoded and wrong for a terminal: an `Error` keeps
+ * `message` and `stack` on non-enumerable properties, so rebuilding one prints
+ * `{}` where the operator expected a failure. An `Error` is rebuilt as a plain
+ * `Error` instead, carrying its name, message, stack and own members with the
+ * rules applied. Its class is NOT preserved. A copy built on the original's
+ * prototype inherits everything the prototype defines, an own-key walk sees
+ * none of it, and each of `name`, `cause`, `toJSON`, `Symbol.toStringTag` and
+ * `nodejs.util.inspect.custom` carried a credential out that way.
+ *
+ * @since 0.1.0
+ */
+import * as Console from "effect/Console";
+import * as Layer from "effect/Layer";
+import * as Logger from "effect/Logger";
+import * as Redaction from "./Redaction.ts";
+/**
+ * Marks a logger this module already wrapped.
+ *
+ * Both the CLI and the durable runtime install {@link layer}, and a detached
+ * `smithers run` is both at once. Wrapping twice would be correct but pay the
+ * rules twice per line, so a wrapped logger is returned unchanged.
+ *
+ * @since 0.1.0
+ * @category type ids
+ */
+export declare const TypeId: unique symbol;
+/**
+ * Whether {@link wrap} already wrapped this logger.
+ *
+ * @since 0.1.0
+ * @category predicates
+ */
+export declare const isRedacted: (logger: Logger.Logger<any, any>) => boolean;
+/**
+ * Redacts one value on its way out of the logger.
+ *
+ * An `Error` is rebuilt as a plain `Error` whose name, message, stack and own
+ * members are redacted, so a renderer that special-cases an `Error` still gets
+ * one. Everything else goes through the journal's own rules, which rebuild a
+ * value from its plain data: a `Date`, a `Map`, a class instance or a host
+ * object therefore reaches the operator in that plain form rather than as
+ * itself.
+ *
+ * That collapse is deliberate, and it now covers the `Error` too. An earlier
+ * version rebuilt each value on its own prototype to keep the rendering
+ * faithful. Three rounds of review found three ways that could kill the run it
+ * was logging, because a host class keeps state a property walk cannot see and
+ * a copy of one throws the moment a brand check reads it, and four more found
+ * that the prototype an `Error` copy kept was itself the leak: everything it
+ * defines is read by a renderer and seen by no own-key walk. A log line is not
+ * worth a run, and the rendering it buys is cosmetic.
+ *
+ * @since 0.1.0
+ * @category redaction
+ */
+export declare const redactArgument: (value: unknown, redactor: Redaction.Redactor) => unknown;
+/**
+ * A console that runs every value it is handed through `redactor` and then
+ * delegates to `target`.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+export declare const redactingConsole: (target: Console.Console, redactor: Redaction.Redactor) => Console.Console;
+/**
+ * Returns `logger` with the journal's redaction rules over everything it
+ * renders. A logger this module already wrapped is returned unchanged.
+ *
+ * @since 0.1.0
+ * @category combinators
+ */
+export declare const wrap: <Message, Output>(logger: Logger.Logger<Message, Output>, options?: Redaction.Options) => Logger.Logger<Message, Output>;
+/**
+ * Replaces the active logger set with redacting wrappers of the same loggers.
+ *
+ * It composes over whatever loggers are already installed rather than
+ * choosing one, so an operator keeps the FORMAT they had, meaning their own
+ * logger and its layout, though a value inside a line is rendered from its
+ * redacted plain data rather than as its own class, and a host that
+ * installed its own logger keeps it too.
+ *
+ * @since 0.1.0
+ * @category layers
+ */
+export declare const layer: (options?: Redaction.Options) => Layer.Layer<never>;
+//# sourceMappingURL=RedactedLogger.d.ts.map

package/dist/esm/RedactedLogger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RedactedLogger.d.ts","sourceRoot":"","sources":["../../src/RedactedLogger.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAGH,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAA;AAIzC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAE3C;;;;;;;;;GASG;AACH,eAAO,MAAM,MAAM,EAAE,OAAO,MAAqD,CAAA;AAEjF;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GAAI,QAAQ,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,KAAG,OAA2B,CAAA;AA2LxF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,cAAc,GAAI,OAAO,OAAO,EAAE,UAAU,SAAS,CAAC,QAAQ,KAAG,OAW7E,CAAA;AAKD;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,GAAI,QAAQ,OAAO,CAAC,OAAO,EAAE,UAAU,SAAS,CAAC,QAAQ,KAAG,OAAO,CAAC,OA0BhG,CAAA;AAkFD;;;;;;GAMG;AACH,eAAO,MAAM,IAAI,GAAI,OAAO,EAAE,MAAM,EAClC,QAAQ,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,EACtC,UAAU,SAAS,CAAC,OAAO,KAC1B,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,CAiC/B,CAAA;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,KAAK,GAAI,UAAU,SAAS,CAAC,OAAO,KAAG,KAAK,CAAC,KAAK,CAAC,KAAK,CAUlE,CAAA"}