@demlik/tea 0.12.0 → 0.13.0

package/dist/{durable-effects-D8SqU_if.d.ts → durable-effects-C6uwzjb5.d.ts}

@@ -1,4 +1,4 @@
-import { C as Cmd } from './core-Bjc0bS8j.js';
+import { C as Cmd } from './core-Co0LWkIA.js';
 
 /**
  * @demlik/tea/do — the durable pending-effects ledger (substrate primitive #1).

package/dist/extension/index.d.ts

@@ -1,6 +1,7 @@
-import { R as Runtime, S as Store } from '../runtime-types-Bxc637bp.js';
+import { R as Runtime, S as Store } from '../runtime-types-CNLmhWif.js';
 import 'better-result';
-import '../core-Bjc0bS8j.js';
+import '../core-Co0LWkIA.js';
+import 'zod';
 
 /**
  * Runtime bridge — expose a `@demlik/tea` runtime running in one chrome context

package/dist/extension/index.js

@@ -1,7 +1,7 @@
-export { bridgeClient, bridgeRuntime, bridgeTabClient, passThroughMsg } from '../chunk-A56OR5RF.js';
+export { bridgeClient, bridgeRuntime, bridgeTabClient, passThroughMsg } from '../chunk-L57ZOT5K.js';
 import '../chunk-G5E74IJB.js';
-import '../chunk-5EHLEUTL.js';
-import '../chunk-B5VXOFMZ.js';
+import '../chunk-ZSUUOEPL.js';
+import '../chunk-OOYD44JI.js';
 
 // src/extension/index.ts
 var MALFORMED = "chromeStorageStore: stored value is not a string";

package/dist/extension/react.js

@@ -1,7 +1,7 @@
-import { bridgeClient, passThroughMsg } from '../chunk-A56OR5RF.js';
+import { bridgeClient, passThroughMsg } from '../chunk-L57ZOT5K.js';
 import '../chunk-G5E74IJB.js';
-import '../chunk-5EHLEUTL.js';
-import '../chunk-B5VXOFMZ.js';
+import '../chunk-ZSUUOEPL.js';
+import '../chunk-OOYD44JI.js';
 import { useRef, useSyncExternalStore, useEffect, useCallback, createContext, useMemo, useContext } from 'react';
 import { jsx } from 'react/jsx-runtime';
 

package/dist/extension/subs/index.d.ts

@@ -1,5 +1,6 @@
-import { S as Sub } from '../../core-Bjc0bS8j.js';
-import { S as SubscribeHandler } from '../../types-D7u9DkH7.js';
+import { S as Sub } from '../../core-Co0LWkIA.js';
+import { S as SubscribeHandler } from '../../types-XS_miRnB.js';
+import 'zod';
 
 type AlarmSubData = {
     alarmName: string;

package/dist/fan-out/index.d.ts

@@ -1,6 +1,7 @@
-import { C as Cmd, a as Port } from '../core-Bjc0bS8j.js';
+import { C as Cmd, a as Port } from '../core-Co0LWkIA.js';
 import { QueueItem } from '../work-queue/index.js';
-import '../runtime-types-Bxc637bp.js';
+import 'zod';
+import '../runtime-types-CNLmhWif.js';
 import 'better-result';
 
 /**

package/dist/{fold-Blbhru48.d.ts → fold-BJPdjc9w.d.ts}

@@ -1,4 +1,4 @@
-import { k as EventOrigin } from './graph-CcjWZVrd.js';
+import { k as EventOrigin } from './graph-B3L5e0N1.js';
 
 /** `TASK_1.DONE` and `DONE` are the same event; the namespace is presentation. */
 declare const bareEvent: (event: string) => string;

package/dist/{graph-CcjWZVrd.d.ts → graph-B3L5e0N1.d.ts}

@@ -1,4 +1,4 @@
-import { C as Cmd } from './core-Bjc0bS8j.js';
+import { C as Cmd } from './core-Co0LWkIA.js';
 
 /**
  * A type smuggled through a value position. `ty<{ at: number }>()` is an empty

package/dist/idempotent-intake/index.d.ts

@@ -1,7 +1,8 @@
 import { IdempotencyStore } from '../idempotency/index.js';
-import { C as Cmd } from '../core-Bjc0bS8j.js';
+import { C as Cmd } from '../core-Co0LWkIA.js';
 import { QueueItem } from '../work-queue/index.js';
-import '../runtime-types-Bxc637bp.js';
+import 'zod';
+import '../runtime-types-CNLmhWif.js';
 import 'better-result';
 
 /**

package/dist/index.d.ts

@@ -1,8 +1,9 @@
-import { B as BootingRuntime, C as CtxArg, S as Store, O as OnError, a as Supervision } from './runtime-types-Bxc637bp.js';
-export { b as Branded, D as DispatchDiscardedError, c as DispatchSettle, d as DisposeTimeoutNotice, F as FoldRefusal, I as IdentityDropNotice, P as PortNameCollisionError, Q as QuiescenceTimeoutError, R as Runtime, e as RuntimeDiscardNotice, f as RuntimeDiscardedError, g as RuntimeErrorContext, h as RuntimeErrorPhase, i as RuntimeRef, j as Schema, k as SubIdCollisionError, l as SupervisionStrategy, _ as __resetPortRegistry, m as absurd, n as asReducer, o as defineMachine, p as definePort, q as noop, r as replay, s as schemaMigrate, t as tryApplyCell, u as tryFoldMsgs, v as tryInterpret, w as wrapDetached } from './runtime-types-Bxc637bp.js';
-import { C as Cmd, S as Sub, M as Machine } from './core-Bjc0bS8j.js';
-export { d as ContextFree, D as DepKeyedSub, e as Dispose, f as Identity, I as Interpret, c as InterpretDetached, g as MachineShape, N as NoCellError, h as NoCtx, a as Port, P as PortEmitter, R as Reducer, b as SubId, i as Subscribe, j as SyncReturn, T as Transitions, U as UpdateForm, k as acceptsOf, l as applyCell, m as applyCellChecked, n as describeMachine, o as detectUpdateForm, p as foldMsgs, q as foldUpdates, r as formOf, s as msgKeysOf, t as structuralHash, u as subId } from './core-Bjc0bS8j.js';
+import { B as BootingRuntime, C as CtxArg, S as Store, O as OnError, a as Supervision } from './runtime-types-CNLmhWif.js';
+export { b as Branded, D as DispatchDiscardedError, c as DispatchSettle, d as DisposeTimeoutNotice, F as FoldRefusal, I as IdentityDropNotice, P as PortNameCollisionError, Q as QuiescenceTimeoutError, R as Runtime, e as RuntimeDiscardNotice, f as RuntimeDiscardedError, g as RuntimeErrorContext, h as RuntimeErrorPhase, i as RuntimeRef, j as Schema, k as SubIdCollisionError, l as SupervisionStrategy, _ as __resetPortRegistry, m as absurd, n as asReducer, o as defineMachine, p as definePort, q as noop, r as replay, s as schemaMigrate, t as settle, u as tryApplyCell, v as tryFoldMsgs, w as tryInterpret, x as wrapDetached } from './runtime-types-CNLmhWif.js';
+import { C as Cmd, S as Sub, M as Machine, R as RequiredCtx } from './core-Co0LWkIA.js';
+export { A as AnyCmdDef, h as CmdDef, i as CmdInput, e as CmdOf, j as CmdValue, k as ContextFree, D as DepKeyedSub, l as Dispose, E as ErrOf, m as ErrorsOf, n as Identity, I as Interpret, g as InterpretDetached, o as MachineShape, p as MalformedResult, q as Needs, f as NeedsOf, N as NoCellError, r as NoCtx, O as OkOf, a as Port, P as PortEmitter, c as Reducer, d as Settled, s as SettledErr, t as SettledOk, b as SubId, u as Subscribe, v as SyncReturn, w as Tagged, x as TaggedError, T as Transitions, U as UpdateForm, y as acceptsOf, z as applyCell, B as applyCellChecked, F as describeMachine, G as detectUpdateForm, H as foldMsgs, J as foldUpdates, K as formOf, L as msgKeysOf, Q as structuralHash, V as subId } from './core-Co0LWkIA.js';
 import 'better-result';
+import 'zod';
 
 interface HistoryTracker<S, M extends {
     type: string;
@@ -60,9 +61,16 @@ declare function run<S, M extends {
     type: string;
 }, C extends Cmd, U extends Sub, Ctx, E extends {
     type: string;
-} = never>(machine: Machine<S, M, C, U, Ctx>, opts: CtxArg<Ctx> & {
+} = never>(machine: Machine<S, M, C, U, Ctx>, opts: CtxArg<Ctx & RequiredCtx<C>> & {
     store?: Store<S>;
     onError?: OnError;
+    /**
+     * The clock that stamps `at` on a `Cmd.define`d effect's settled Msg at
+     * the interpret edge. Defaults to `Date.now`. Inject a fixed one for a
+     * deterministic run; a `replay` log carries its own `at`s and never reads
+     * this.
+     */
+    clock?: () => number;
     /**
      * The SEMANTIC event projector. Maps one APPLIED transition `(msg, state)`
      * to zero-or-more public events of `E`; `[]` skips the transition. Maps the
@@ -104,4 +112,4 @@ declare function run<S, M extends {
     __idleCap?: number;
 }): BootingRuntime<S, M, E>;
 
-export { BootingRuntime, Cmd, CtxArg, type HistoryTracker, Machine, OnError, Store, Sub, Supervision, historyTracker, run };
+export { BootingRuntime, Cmd, CtxArg, type HistoryTracker, Machine, OnError, RequiredCtx, Store, Sub, Supervision, historyTracker, run };

package/dist/index.js

@@ -1,4 +1,4 @@
-export { DispatchDiscardedError, DisposeTimeoutNotice, IdentityDropNotice, PortNameCollisionError, QuiescenceTimeoutError, RuntimeDiscardNotice, RuntimeDiscardedError, SubIdCollisionError, __resetPortRegistry, absurd, asReducer, defineMachine, definePort, historyTracker, noop, replay, run, schemaMigrate, tryApplyCell, tryFoldMsgs, tryInterpret, wrapDetached } from './chunk-5EHLEUTL.js';
-export { Cmd, NoCellError, acceptsOf, applyCell, applyCellChecked, describeMachine, detectUpdateForm, foldMsgs, foldUpdates, formOf, msgKeysOf, structuralHash, subId } from './chunk-B5VXOFMZ.js';
+export { DispatchDiscardedError, DisposeTimeoutNotice, IdentityDropNotice, PortNameCollisionError, QuiescenceTimeoutError, RuntimeDiscardNotice, RuntimeDiscardedError, SubIdCollisionError, __resetPortRegistry, absurd, asReducer, defineMachine, definePort, historyTracker, noop, replay, run, schemaMigrate, settle, tryApplyCell, tryFoldMsgs, tryInterpret, wrapDetached } from './chunk-ZSUUOEPL.js';
+export { Cmd, NoCellError, acceptsOf, applyCell, applyCellChecked, describeMachine, detectUpdateForm, foldMsgs, foldUpdates, formOf, msgKeysOf, structuralHash, subId } from './chunk-OOYD44JI.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/journal/index.d.ts

@@ -0,0 +1,373 @@
+/**
+ * journal sync — a remote journal and per-remote cursors, so two local journals
+ * meet in one order.
+ *
+ * `Journal<R>` (`./index`) is the LOCAL append-only log a single machine replays
+ * from. This is the second half: a **remote** journal that many local journals
+ * push their appends into and pull everyone else's out of, with the remote
+ * assigning the one `seq` that counts. Records are append-only, so there is
+ * nothing to merge — the fold over the remote's order *is* the merge. This is
+ * the network-in-the-middle twin of the append-then-fold shape already proven
+ * in-repo by `src/do/event-sourced-store.ts` (append each record to a
+ * monotonically-keyed log; rebuild state by folding the log via `replay`).
+ *
+ * The three moving parts:
+ *   - `RemoteJournal<R>` — the append-only remote. `push` sends the records a
+ *     client has not yet had acked and gets back the `seq` the remote assigned
+ *     each; `pull` reads everyone's records after a given `seq`. One monotonic
+ *     `seq` per stream, assigned by the remote, is the whole ordering contract.
+ *   - a per-`(client, stream)` **cursor** (`CursorStore`) kept locally — the
+ *     last remote `seq` a client has pulled — so `push`/`pull` resume
+ *     incrementally instead of re-sending or re-reading the whole stream.
+ *   - `SyncClient<R>` — a local `Journal<R>` joined to a `RemoteJournal<R>`
+ *     through that cursor and a stable author identity. A local `append` is
+ *     PROVISIONAL (it has a local order but no remote `seq`) until `sync` pushes
+ *     it and pulls it back under the `seq` the remote assigned.
+ *
+ * Domain-blind and auth-blind: the remote takes an opaque `token` and an opaque
+ * `stream` key and does nothing with the token — who-may-push-to-which-stream is
+ * the host's concern, not this primitive's (the same way the local `Journal` is
+ * blind to what a record means). Interface shape follows Effect
+ * `unstable/eventlog` `EventJournal` (`writeFromRemote`, per-remote cursors, a
+ * `changes` stream) as prior art, not a dependency.
+ */
+
+/**
+ * A remote-assigned order key. Like a local `Seq` it starts at 1 and increments
+ * by one per record within a stream, but it is assigned by the REMOTE — it is
+ * the authoritative order every client folds over, not any one client's local
+ * append order.
+ */
+type RemoteSeq = number;
+/**
+ * A record paired with the stable identity of whoever authored it. Author
+ * identity is the one fact a team-mode record needs that a solo record does not:
+ * once records from many clients interleave in the remote's order, the fold
+ * still has to know who wrote each. It is opaque — a string the host assigns
+ * meaning to (a device id, a user handle) — never interpreted here.
+ */
+interface AuthoredRecord<R> {
+    /** The stable identity of the client that authored `record`. */
+    readonly author: string;
+    /** The domain record itself; this primitive knows nothing of its shape. */
+    readonly record: R;
+}
+/**
+ * One record as it lives on the remote: the `seq` the remote assigned, the
+ * `author` that wrote it, the `stream` it belongs to, and the record. This is
+ * the entry every client pulls and folds; two clients that pull the same stream
+ * see identical `RemoteEntry`s in identical `seq` order, which is what lets
+ * their folds agree.
+ */
+interface RemoteEntry<R> {
+    /** The stream this entry belongs to. */
+    readonly stream: string;
+    /** The remote-assigned order key — 1-based, gap-free, monotonic per stream. */
+    readonly seq: RemoteSeq;
+    /** The stable identity of the client that authored the record. */
+    readonly author: string;
+    /** The domain record. */
+    readonly record: R;
+}
+/** A `push` — the records a client wants acked, presented under its token. */
+interface PushRequest<R> {
+    /**
+     * An opaque credential the host's remote may check. This primitive does
+     * nothing with it: authorization (who may push to which stream) is the host's
+     * concern, deliberately out of scope here.
+     */
+    readonly token: unknown;
+    /** The opaque stream key to append to. */
+    readonly stream: string;
+    /**
+     * The records to append, in the client's local order. Normally these are the
+     * client's own appends made since its last successful push — the incremental
+     * tail, not the whole stream.
+     */
+    readonly records: ReadonlyArray<AuthoredRecord<R>>;
+}
+/** The remote's answer to a `push`: the `seq` it assigned each record, in order. */
+interface PushResult {
+    /**
+     * The remote `seq` assigned to each record of the request, in the same order.
+     * `seqs[i]` is the seq of `records[i]`. A client does not need to fold these —
+     * it learns the full ordered stream (its own records included) through `pull`,
+     * which is the single reader of converged state.
+     */
+    readonly seqs: ReadonlyArray<RemoteSeq>;
+}
+/** A `pull` — read everyone's records after a `seq` the client already has. */
+interface PullRequest {
+    /** The opaque credential; ignored here, see {@link PushRequest.token}. */
+    readonly token: unknown;
+    /** The opaque stream key to read. */
+    readonly stream: string;
+    /**
+     * Return only entries with `seq` strictly greater than this. A client passes
+     * its cursor (the last `seq` it pulled), so it reads only what is new — never
+     * re-reading the whole stream. `0` (the cursor's initial value) reads from the
+     * start.
+     */
+    readonly since: RemoteSeq;
+}
+/** The remote's answer to a `pull`: the new entries, in `seq` order. */
+interface PullResult<R> {
+    /** Every entry with `seq > since`, in ascending `seq` order. */
+    readonly entries: ReadonlyArray<RemoteEntry<R>>;
+}
+/**
+ * An append-only remote journal: many clients push into it, all pull from it,
+ * and it assigns the one monotonic `seq` per stream that every client's fold
+ * agrees over. It is the network-in-the-middle: a real one is a server; this
+ * interface is what a client talks to, host- and transport-blind.
+ *
+ * The remote never merges and never resolves conflicts — records are
+ * append-only, so its only job is to assign an honest total order. That order
+ * is enough: two clients that both push and both pull fold the same sequence and
+ * reach the same state (the append-then-fold result proven in phoenix spike
+ * #6673, reused here rather than reinvented).
+ */
+interface RemoteJournal<R> {
+    /**
+     * Append `records` to `stream` durably and return the `seq` assigned to each,
+     * in order. Concurrent pushes to one stream are serialised into a single total
+     * order — the seq assignment is the remote's whole ordering guarantee.
+     */
+    push(request: PushRequest<R>): Promise<PushResult>;
+    /**
+     * Read every entry of `stream` with `seq` strictly greater than
+     * `request.since`, in ascending `seq` order. Empty when the client is already
+     * caught up.
+     */
+    pull(request: PullRequest): Promise<PullResult<R>>;
+}
+/**
+ * An in-memory `RemoteJournal<R>` — the standard test/reference substrate,
+ * mirroring `memoryStore` (`@demlik/tea/mem`) and `memoryJournal` (`./index`).
+ *
+ * It is built ON `memoryJournal`: the remote's authoritative `seq` assignment IS
+ * a local `Journal`'s per-stream total order. `push` appends each record under
+ * the stream's lock (so concurrent pushes serialise into one order and never
+ * race the seq), and `pull` is `list` filtered past the client's cursor. The
+ * seq machinery is `makeJournal`'s, reused — this substrate reinvents none of
+ * it, exactly as the issue's seam was designed to be consumed.
+ *
+ * The `token` is accepted and ignored: this substrate enforces no authorization,
+ * because who-may-push-to-which-stream is the host's concern, out of scope here.
+ */
+declare function memoryRemoteJournal<R>(): RemoteJournal<R>;
+/**
+ * Where a client keeps its per-`(client, stream)` cursor — the last remote `seq`
+ * it has pulled. Kept LOCALLY (the client's own disk/memory), never on the
+ * remote, so `push`/`pull` resume incrementally after a restart instead of
+ * re-reading the whole stream. `get` returns `0` for a stream never pulled.
+ */
+interface CursorStore {
+    /** The last remote `seq` pulled for `stream`, or `0` if none yet. */
+    get(stream: string): Promise<RemoteSeq>;
+    /** Record `seq` as the last remote `seq` pulled for `stream`. */
+    set(stream: string, seq: RemoteSeq): Promise<void>;
+}
+/**
+ * An in-memory `CursorStore`, mirroring `memoryStore`. A durable client swaps in
+ * a file- or DB-backed one so its cursor survives a restart; the semantics are
+ * identical.
+ */
+declare function memoryCursorStore(): CursorStore;
+/** How to build a {@link SyncClient}. */
+interface SyncClientOptions<R> {
+    /** The remote every push/pull talks to. */
+    readonly remote: RemoteJournal<R>;
+    /**
+     * This client's stable author identity, stamped on every record it appends —
+     * the one fact team mode needs that solo mode does not.
+     */
+    readonly author: string;
+    /**
+     * The opaque credential presented on every push/pull. Optional because this
+     * primitive never checks it; a host that runs an authorizing remote supplies
+     * it here.
+     */
+    readonly token?: unknown;
+    /**
+     * The client's LOCAL append-only journal — its own provisional appends live
+     * here. Defaults to a `memoryJournal`; a durable client passes a `fileJournal`
+     * (or any `Journal<R>`), which is the #30 substrate seam this consumes.
+     */
+    readonly local?: LocalJournal<R>;
+    /**
+     * Where the per-stream pull cursor lives. Defaults to a `memoryCursorStore`; a
+     * durable client passes one backed by its own storage.
+     */
+    readonly cursors?: CursorStore;
+}
+/**
+ * The slice of a local `Journal<R>` a `SyncClient` drives — its own provisional
+ * appends and reading them back in local order. This is structurally the #30
+ * `Journal<R>` interface narrowed to what sync needs, so a `memoryJournal` or a
+ * `fileJournal` satisfies it as-is.
+ */
+interface LocalJournal<R> {
+    append(stream: string, record: R): Promise<{
+        seq: number;
+    }>;
+    list(stream: string): Promise<ReadonlyArray<JournalEntry<R>>>;
+}
+/**
+ * A local `Journal` joined to a `RemoteJournal` through a cursor and an author
+ * identity. It is what makes two local journals "meet in one order": each
+ * appends offline, both `sync`, and both converge on the remote's order.
+ */
+interface SyncClient<R> {
+    /**
+     * Append `record` to the client's LOCAL journal. The append is PROVISIONAL: it
+     * has a local order immediately, but no remote `seq` — and so no place in the
+     * converged order — until a later `sync` pushes it and pulls it back. Resolves
+     * once the local append is durable.
+     */
+    append(stream: string, record: R): Promise<void>;
+    /**
+     * The client's local appends for `stream` that have not yet been pushed — the
+     * provisional tail. Empty right after a successful `sync`.
+     */
+    pending(stream: string): Promise<ReadonlyArray<AuthoredRecord<R>>>;
+    /**
+     * Reconcile `stream` with the remote: PUSH every local append not yet pushed,
+     * then PULL every remote entry after the cursor and fold it into the converged
+     * log, advancing the cursor. One `sync` may not see records a peer pushes
+     * concurrently (they may land after this pull); a second `sync` — with nothing
+     * new to push — pulls them, which is how two racing clients converge.
+     */
+    sync(stream: string): Promise<void>;
+    /**
+     * The converged log for `stream`: every entry the client has pulled, in remote
+     * `seq` order. This is the fold's input — reducing over it yields the client's
+     * state. After both of two racing clients sync to quiescence, their `log`s are
+     * identical, which is the convergence guarantee.
+     */
+    log(stream: string): ReadonlyArray<RemoteEntry<R>>;
+}
+/**
+ * Build a {@link SyncClient} over a remote, an author identity, and (optionally)
+ * a local journal and cursor store.
+ *
+ * The client holds two watermarks per stream: how many of its own local appends
+ * it has PUSHED (so a re-`sync` sends only the new tail), and — in the
+ * `CursorStore` — the last remote `seq` it has PULLED (so it reads only what is
+ * new). Its converged `log` is built solely from `pull`, so `pull` is the single
+ * source of converged truth; a client learns even its OWN records' remote order
+ * by pulling them back.
+ */
+declare function makeSyncClient<R>(options: SyncClientOptions<R>): SyncClient<R>;
+
+/**
+ * @packageDocumentation
+ * @demlik/tea/journal — an append-only, ordered record log for `@demlik/tea`.
+ *
+ * The log a "durable, replayable state machine" replays from. tea already ships
+ * the log's neighbours — `fileStore`/`memoryStore` (`Store<S>`: snapshot with
+ * whole-load / whole-save), `recorder` (JSONL debug traces), `durable-effects`
+ * (`foldLedger` over an owed-effect ledger) — but not the log itself, so every
+ * consumer hand-rolled it. This is that log, domain-blind: a `Journal<R>` over
+ * an opaque record `R`, with no pipeline/ledger vocabulary of its own.
+ *
+ * Three operations carry the contract:
+ *   - `append(stream, record)` — durable before it returns, assigning a
+ *     per-stream total-order `seq` (1, 2, 3, …). Concurrent appenders to one
+ *     stream converge on one order; the lock's only job is an honest order key.
+ *   - `list(stream)` — every entry of a stream in `seq` order.
+ *   - `changes(listener)` — a subscription over appends made through this
+ *     instance after subscribing.
+ *
+ * `withLock(stream, fx)` runs `fx` with exclusive access to a stream, so a
+ * read-decide-append sequence is atomic against other writers. It is
+ * re-entrant for the same stream: an `append` inside `fx` does not deadlock on
+ * the lock `fx` already holds.
+ *
+ * The substrate is a `JournalBackend<R>` — how a stream is read, how one record
+ * is appended durably, and how a stream is locked across processes.
+ * `makeJournal` wires the domain-blind orchestration (per-stream serialisation,
+ * `seq` assignment, `changes` fan-out) over any backend. `memoryJournal` is the
+ * in-process backend that mirrors `memoryStore` for tests; the Node file
+ * backend (`fileJournal`) homes in `@demlik/tea/node` beside `fileStore`.
+ *
+ * Interface shape follows Effect `unstable/eventlog` `EventJournal`
+ * (`entries`/`write`/`changes`/`withLock`) as prior art, not a dependency.
+ */
+/** A per-stream total-order key. Starts at 1 and increments by one per append. */
+type Seq = number;
+/** One appended record, tagged with its stream and its per-stream `seq`. */
+interface JournalEntry<R> {
+    readonly stream: string;
+    readonly seq: Seq;
+    readonly record: R;
+}
+/**
+ * An append-only, ordered record log over an opaque record `R`.
+ *
+ * Domain-blind: it knows nothing of what a record means. Ordering, durability
+ * and the honest order key are its whole contract.
+ */
+interface Journal<R> {
+    /**
+     * Append `record` to `stream`, durable before the promise resolves, and
+     * resolve with the `seq` it was assigned — the next integer in the stream's
+     * total order.
+     */
+    append(stream: string, record: R): Promise<{
+        seq: Seq;
+    }>;
+    /** Every entry of `stream`, in `seq` order. Empty for an unwritten stream. */
+    list(stream: string): Promise<ReadonlyArray<JournalEntry<R>>>;
+    /**
+     * Subscribe to appends made through this instance after this call. Returns an
+     * unsubscribe. Cross-process appends are not delivered — a cross-process
+     * subscription is a polling concern this log leaves to its consumer.
+     */
+    changes(listener: (entry: JournalEntry<R>) => void): () => void;
+    /**
+     * Run `fx` with exclusive access to `stream` — the in-process mutex against
+     * other callers here, the backend lock against other processes. Re-entrant
+     * for the same stream, so an `append` (or nested `withLock`) inside `fx` runs
+     * under the lock this call already holds rather than deadlocking on it.
+     */
+    withLock<A>(stream: string, fx: () => Promise<A>): Promise<A>;
+}
+/**
+ * The substrate a `Journal<R>` is built over. Everything host-specific lives
+ * here; `makeJournal` owns the host-blind rest.
+ *
+ * `append` is always invoked under `lock` for the same stream, so a backend
+ * assigns `seq` from `read().length + 1` without racing itself.
+ */
+interface JournalBackend<R> {
+    /** Every entry of `stream` in `seq` order; empty for an unwritten stream. */
+    read(stream: string): Promise<ReadonlyArray<JournalEntry<R>>>;
+    /**
+     * Persist `record` as the next entry of `stream`, durable before resolving,
+     * and resolve with the entry it wrote. Invoked only while `lock` holds the
+     * stream, so `seq` is safely the current length plus one.
+     */
+    append(stream: string, record: R): Promise<JournalEntry<R>>;
+    /** Run `fx` while holding `stream`'s cross-process lock. */
+    lock<A>(stream: string, fx: () => Promise<A>): Promise<A>;
+}
+/**
+ * Build a `Journal<R>` over `backend`. Owns the host-blind half: per-stream
+ * serialisation, re-entrant exclusion, and the `changes` fan-out. `append` and
+ * `withLock` both route through `exclusive`, which holds the in-process mutex
+ * and the backend lock for one stream and is re-entrant for that stream within
+ * a single call chain.
+ */
+declare function makeJournal<R>(backend: JournalBackend<R>): Journal<R>;
+/**
+ * An in-process `Journal<R>` — the standard test substrate, mirroring
+ * `memoryStore` from `@demlik/tea/mem`. Reference semantics: a record handed to
+ * `append` is stored by reference, exactly as `memoryStore` stores state. No
+ * cross-process lock is needed — a single process owns the whole log — so the
+ * backend lock is identity and `makeJournal`'s in-process mutex is the only
+ * ordering guarantee.
+ */
+declare function memoryJournal<R>(): Journal<R>;
+
+export { type AuthoredRecord, type CursorStore, type Journal, type JournalBackend, type JournalEntry, type LocalJournal, type PullRequest, type PullResult, type PushRequest, type PushResult, type RemoteEntry, type RemoteJournal, type RemoteSeq, type Seq, type SyncClient, type SyncClientOptions, makeJournal, makeSyncClient, memoryCursorStore, memoryJournal, memoryRemoteJournal };

package/dist/journal/index.js

@@ -0,0 +1,3 @@
+export { makeJournal, makeSyncClient, memoryCursorStore, memoryJournal, memoryRemoteJournal } from '../chunk-XGELA764.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/journal/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/llm-call/index.d.ts

@@ -1,10 +1,11 @@
-import { C as Cmd } from '../core-Bjc0bS8j.js';
+import { C as Cmd } from '../core-Co0LWkIA.js';
 import { RunCmd, SucceedMsg, FailMsg, ResilientState } from '../resilient-call/index.js';
 import { RetryPolicy } from '../retry-backoff/index.js';
 import { DeadlineExceeded, DeadlineSub } from '../deadline/index.js';
 export { deadlineSub, subscribeDeadline } from '../deadline/index.js';
+import 'zod';
 import '../cache/index.js';
-import '../types-D7u9DkH7.js';
+import '../types-XS_miRnB.js';
 import '../circuit-breaker/index.js';
 import '../protocol-B5YmJr0d.js';
 import '../rate-limit/index.js';

package/dist/llm-call/index.js

@@ -1,16 +1,16 @@
-export { createLlmCall, liftLlmCall } from '../chunk-ND3DH6KM.js';
-import '../chunk-EUF7XOEE.js';
+export { createLlmCall, liftLlmCall } from '../chunk-COS5MSTO.js';
+import '../chunk-4KLG43GY.js';
 import '../chunk-JELSZN25.js';
-export { deadlineSub, subscribeDeadline } from '../chunk-JGVL3WPL.js';
+import '../chunk-RH5EFRVJ.js';
+export { deadlineSub, subscribeDeadline } from '../chunk-DGE4PV4A.js';
 import '../chunk-Q2UM7BXU.js';
 import '../chunk-S2EGRPCM.js';
 import '../chunk-UF4MZSLT.js';
-import '../chunk-7SVIRMC6.js';
-import '../chunk-3JU6657S.js';
+import '../chunk-G5E74IJB.js';
+import '../chunk-VYFAZN3F.js';
 import '../chunk-2YFLOCWX.js';
 import '../chunk-ZJ5AOYBH.js';
-import '../chunk-G5E74IJB.js';
-import '../chunk-5EHLEUTL.js';
-import '../chunk-B5VXOFMZ.js';
+import '../chunk-ZSUUOEPL.js';
+import '../chunk-OOYD44JI.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/{machine-0OmPvsy_.d.ts → machine-BtFWQmmq.d.ts}

@@ -1,4 +1,4 @@
-import { C as Cmd, I as Interpret, M as Machine } from './core-Bjc0bS8j.js';
+import { C as Cmd, I as Interpret, M as Machine } from './core-Co0LWkIA.js';
 import { ModelFactory, Schema, MessageLoader, LlmCall, LlmOk, LlmErr, LlmRunCmd, LlmSucceedMsg, LlmFailMsg, LlmTimerMsg, LlmCallPorts } from './llm-call/index.js';
 import { MonitoredRunState, RunFailure, MonitoredRunCmd } from './monitored-run/index.js';
 import { M as MsgType } from './protocol-B5YmJr0d.js';

package/dist/machine-viz/index.d.ts

@@ -1,4 +1,5 @@
-import { C as Cmd, S as Sub, M as Machine } from '../core-Bjc0bS8j.js';
+import { C as Cmd, S as Sub, M as Machine } from '../core-Co0LWkIA.js';
+import 'zod';
 
 /**
  * Sanitize a discriminant string into a Mermaid-safe node identifier.

package/dist/machine-viz/index.js

@@ -1,7 +1,7 @@
 import { safeId, safeLabel } from '../chunk-UOC2PL46.js';
 export { safeId, safeLabel } from '../chunk-UOC2PL46.js';
-import '../chunk-5EHLEUTL.js';
-import { formOf } from '../chunk-B5VXOFMZ.js';
+import '../chunk-ZSUUOEPL.js';
+import { formOf } from '../chunk-OOYD44JI.js';
 
 // src/machine-viz/index.ts
 function toMermaid(machine, opts = {}) {

package/dist/mem/index.d.ts

@@ -1,6 +1,7 @@
-import { S as Store } from '../runtime-types-Bxc637bp.js';
+import { S as Store } from '../runtime-types-CNLmhWif.js';
 import 'better-result';
-import '../core-Bjc0bS8j.js';
+import '../core-Co0LWkIA.js';
+import 'zod';
 
 /**
  * @packageDocumentation

package/dist/monitored-run/index.d.ts

@@ -1,10 +1,11 @@
 import { DeadlineExceeded, DeadlineSub } from '../deadline/index.js';
 export { deadlineSub, subscribeDeadline } from '../deadline/index.js';
-import { I as Interpret, C as Cmd } from '../core-Bjc0bS8j.js';
+import { I as Interpret, C as Cmd } from '../core-Co0LWkIA.js';
 import { SnapshotWriteCmd, SnapshotState, SnapshotStore, SnapshotSavedMsg, SnapshotFailedMsg, SnapshotLoadedMsg, SnapshotLoadFailedMsg, SnapshotLoadCmd } from '../snapshot/index.js';
 import { QueueItem } from '../work-queue/index.js';
-import '../types-D7u9DkH7.js';
-import '../runtime-types-Bxc637bp.js';
+import '../types-XS_miRnB.js';
+import 'zod';
+import '../runtime-types-CNLmhWif.js';
 import 'better-result';
 
 /**

package/dist/monitored-run/index.js

@@ -1,10 +1,10 @@
-export { createMonitoredRun, liftRun } from '../chunk-WLGO64WC.js';
-import '../chunk-7V4EVLZA.js';
-export { deadlineSub, subscribeDeadline } from '../chunk-JGVL3WPL.js';
+export { createMonitoredRun, liftRun } from '../chunk-DMYGQB4O.js';
+import '../chunk-O4MVQTEJ.js';
+export { deadlineSub, subscribeDeadline } from '../chunk-DGE4PV4A.js';
 import '../chunk-MU6MCIAC.js';
 import '../chunk-FV3Z5MBE.js';
 import '../chunk-2YFLOCWX.js';
-import '../chunk-5EHLEUTL.js';
-import '../chunk-B5VXOFMZ.js';
+import '../chunk-ZSUUOEPL.js';
+import '../chunk-OOYD44JI.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map