actor-ts 0.9.0

package/dist/persistence/journals/SqliteJournal.js

@@ -0,0 +1,225 @@
+import { getSqliteDriver } from '../../runtime/sqlite/index.js';
+import { InProcessJournalEventBus } from '../JournalEventBus.js';
+import { JournalConcurrencyError, JournalError, } from '../JournalTypes.js';
+/**
+ * Journal backed by SQLite — zero-dependency, single-file persistence.
+ *
+ * Works on Bun (`bun:sqlite`) and Node.js (`better-sqlite3`) via the
+ * `SqliteDriver` abstraction in `src/runtime/sqlite/`.  Both backends
+ * share the same prepared-statement + transaction shape, so the journal
+ * code itself is unchanged across runtimes.
+ *
+ * Construction is lazy: the native DB is opened on the first `append` /
+ * `read` / `highestSeq` / `delete` / `persistenceIds` call.  This keeps
+ * `new SqliteJournal({ path })` sync-friendly (matches the pre-abstraction
+ * shape) while still supporting the async driver-resolution flow Node
+ * requires.
+ */
+export class SqliteJournal {
+    options;
+    table;
+    closed = { value: false };
+    /**
+     * In-process event bus — published-to inside `append` so the query
+     * layer can do sub-poll-interval push delivery in the same process.
+     * Cross-process subscribers (separate Bun/Node instance reading
+     * the same SQLite file) still need to poll; that's the inherent
+     * limit of in-process notifications.
+     */
+    events = new InProcessJournalEventBus();
+    db = null;
+    stmts = null;
+    initPromise = null;
+    constructor(options = {}) {
+        this.options = options;
+        this.table = options.eventsTable ?? 'events';
+    }
+    async append(pid, events, expectedSeq, tags) {
+        await this.ensureOpen();
+        if (events.length === 0)
+            return [];
+        const db = this.db;
+        const stmts = this.stmts;
+        const now = Date.now();
+        const txn = db.transaction((items) => {
+            const row = stmts.highestSeq.get(pid);
+            const actualSeq = row?.hi ?? 0;
+            if (actualSeq !== expectedSeq) {
+                throw new JournalConcurrencyError(pid, expectedSeq, actualSeq);
+            }
+            const out = [];
+            let seq = actualSeq;
+            for (const ev of items) {
+                seq++;
+                const payload = JSON.stringify(ev);
+                const tagString = tags && tags.length ? tags.join(',') : null;
+                stmts.insert.run(pid, seq, payload, tagString, now);
+                // Also populate the tags join table so SqliteQuery's
+                // tag-search can do an indexed lookup instead of a CSV scan.
+                // Both inserts run inside the same transaction — partial
+                // writes are impossible.
+                if (tags) {
+                    for (const tag of tags) {
+                        if (tag.length === 0)
+                            continue;
+                        stmts.insertTag.run(pid, seq, tag, now);
+                    }
+                }
+                out.push({
+                    persistenceId: pid,
+                    sequenceNr: seq,
+                    event: ev,
+                    timestamp: now,
+                    tags: tags ? [...tags] : undefined,
+                });
+            }
+            return out;
+        });
+        let written;
+        try {
+            written = txn([...events]);
+        }
+        catch (e) {
+            if (e instanceof JournalConcurrencyError)
+                throw e;
+            throw new JournalError(`SqliteJournal.append failed: ${e.message}`, e);
+        }
+        // Publish AFTER the transaction commits so subscribers that
+        // re-read see the events they were notified about.
+        for (const pe of written)
+            this.events.publish(pe);
+        return written;
+    }
+    async read(pid, fromSeq, toSeq) {
+        await this.ensureOpen();
+        const stmts = this.stmts;
+        try {
+            const rows = toSeq === undefined
+                ? stmts.readAll.all(pid, fromSeq)
+                : stmts.readRange.all(pid, fromSeq, toSeq);
+            return rows.map(r => ({
+                persistenceId: r.persistence_id,
+                sequenceNr: r.sequence_nr,
+                event: JSON.parse(r.payload),
+                timestamp: r.timestamp,
+                tags: r.tags ? r.tags.split(',') : undefined,
+            }));
+        }
+        catch (e) {
+            throw new JournalError(`SqliteJournal.read failed: ${e.message}`, e);
+        }
+    }
+    async highestSeq(pid) {
+        await this.ensureOpen();
+        const row = this.stmts.highestSeq.get(pid);
+        return row?.hi ?? 0;
+    }
+    async delete(pid, toSeq) {
+        await this.ensureOpen();
+        // Order matters: delete from the tags-table FIRST so that a
+        // crash mid-delete leaves an inconsistent state where tags exist
+        // for events that don't — recoverable via a manual cleanup or a
+        // future backfill.  Doing it the other way around would produce
+        // events with missing tags, which the JOIN-based query path
+        // would silently miss.
+        this.stmts.deleteTagsUpTo.run(pid, toSeq);
+        this.stmts.deleteUpTo.run(pid, toSeq);
+    }
+    async persistenceIds() {
+        await this.ensureOpen();
+        const rows = this.stmts.pids.all();
+        return rows.map(r => r.persistence_id);
+    }
+    async close() {
+        if (this.closed.value)
+            return;
+        this.closed.value = true;
+        try {
+            this.db?.close();
+        }
+        catch { /* ignore */ }
+    }
+    /* --------------------------- internals -------------------------------- */
+    async ensureOpen() {
+        if (this.closed.value)
+            throw new JournalError('SqliteJournal is closed');
+        if (this.db && this.stmts)
+            return;
+        if (!this.initPromise)
+            this.initPromise = this.init();
+        await this.initPromise;
+    }
+    async init() {
+        const driver = this.options.driver ?? await getSqliteDriver();
+        const db = driver.open(this.options.path ?? ':memory:');
+        const tagsTable = `${this.table}_tags`;
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS ${this.table} (
+        persistence_id TEXT NOT NULL,
+        sequence_nr    INTEGER NOT NULL,
+        payload        TEXT NOT NULL,
+        tags           TEXT,
+        timestamp      INTEGER NOT NULL,
+        PRIMARY KEY (persistence_id, sequence_nr)
+      );
+      CREATE INDEX IF NOT EXISTS idx_${this.table}_pid ON ${this.table}(persistence_id);
+      CREATE TABLE IF NOT EXISTS ${tagsTable} (
+        persistence_id TEXT NOT NULL,
+        sequence_nr    INTEGER NOT NULL,
+        tag            TEXT NOT NULL,
+        timestamp      INTEGER NOT NULL,
+        PRIMARY KEY (tag, timestamp, persistence_id, sequence_nr)
+      );
+      CREATE INDEX IF NOT EXISTS idx_${tagsTable}_pid_seq ON ${tagsTable}(persistence_id, sequence_nr);
+    `);
+        if (this.options.wal)
+            db.exec('PRAGMA journal_mode = WAL;');
+        this.stmts = {
+            insert: db.prepare(`INSERT INTO ${this.table}(persistence_id, sequence_nr, payload, tags, timestamp) VALUES (?, ?, ?, ?, ?)`),
+            insertTag: db.prepare(`INSERT OR IGNORE INTO ${tagsTable}(persistence_id, sequence_nr, tag, timestamp) VALUES (?, ?, ?, ?)`),
+            readAll: db.prepare(`SELECT persistence_id, sequence_nr, payload, tags, timestamp FROM ${this.table} WHERE persistence_id = ? AND sequence_nr >= ? ORDER BY sequence_nr ASC`),
+            readRange: db.prepare(`SELECT persistence_id, sequence_nr, payload, tags, timestamp FROM ${this.table} WHERE persistence_id = ? AND sequence_nr >= ? AND sequence_nr <= ? ORDER BY sequence_nr ASC`),
+            highestSeq: db.prepare(`SELECT MAX(sequence_nr) AS hi FROM ${this.table} WHERE persistence_id = ?`),
+            deleteUpTo: db.prepare(`DELETE FROM ${this.table} WHERE persistence_id = ? AND sequence_nr <= ?`),
+            deleteTagsUpTo: db.prepare(`DELETE FROM ${tagsTable} WHERE persistence_id = ? AND sequence_nr <= ?`),
+            pids: db.prepare(`SELECT DISTINCT persistence_id FROM ${this.table}`),
+            countTags: db.prepare(`SELECT COUNT(*) AS n FROM ${tagsTable}`),
+            rowsWithCsvTags: db.prepare(`SELECT persistence_id, sequence_nr, tags, timestamp FROM ${this.table} WHERE tags IS NOT NULL AND tags <> ''`),
+        };
+        this.db = db;
+        // Backfill — for databases written by SqliteJournal v0 (before
+        // this commit) the tags table doesn't exist yet, OR exists empty
+        // because the user upgraded the dependency.  Populate it from
+        // the CSV column once.  Idempotent: if the tags table already
+        // has rows, this skips entirely.
+        this.backfillTagsTableIfNeeded(db);
+    }
+    /**
+     * One-shot backfill of the tags join table from the legacy CSV
+     * `tags` column.  Runs at most once per init — when `event_tags`
+     * is empty AND the `events` table still has tagged rows we'd
+     * otherwise leave un-indexed.  Re-running is a no-op (the count
+     * check skips it) and the underlying inserts use `INSERT OR
+     * IGNORE` as a defence-in-depth so a partial backfill that gets
+     * interrupted can be resumed without duplicate-key errors.
+     */
+    backfillTagsTableIfNeeded(db) {
+        const stmts = this.stmts;
+        const tagsCount = stmts.countTags.get()?.n ?? 0;
+        if (tagsCount > 0)
+            return;
+        const rows = stmts.rowsWithCsvTags.all();
+        if (rows.length === 0)
+            return;
+        const fill = db.transaction((items) => {
+            for (const r of items) {
+                const tagList = r.tags.split(',').filter((t) => t.length > 0);
+                for (const tag of tagList) {
+                    stmts.insertTag.run(r.persistence_id, r.sequence_nr, tag, r.timestamp);
+                }
+            }
+        });
+        fill(rows);
+    }
+}
+//# sourceMappingURL=SqliteJournal.js.map

package/dist/persistence/journals/SqliteJournal.js.map

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

package/dist/persistence/migration/Adapter.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Schema-evolution adapters for persistent actors.
+ *
+ * The actor framework stores events / state as opaque JSON in the journal
+ * and snapshot store.  When a domain type evolves (new field, renamed
+ * field, type change), already-persisted history must still be replayable
+ * — the user supplies an `EventAdapter` (for events) or a `SnapshotAdapter`
+ * / `StateAdapter` (for snapshots and durable state) which:
+ *
+ *   - tags every value written with a stable `manifest` string and a
+ *     numeric `version` (the wire-format envelope is `{ _v, _t, _e }`,
+ *     applied transparently by `PersistentActor` / `DurableStateActor`),
+ *   - on read, takes the stored triple `{ manifest, version, payload }`
+ *     and returns a current-version domain value, typically by delegating
+ *     to a `MigrationChain` of pure upcaster functions.
+ *
+ * The adapter contract is intentionally separate from the wire envelope:
+ * adapters return / accept *triples*, the actor is responsible for the
+ * `_v / _t / _e` JSON shape.  That keeps user code focused on the domain
+ * mapping and lets us evolve the wire format later without breaking
+ * adapters.
+ */
+/** Wire-format envelope written into the `event` / `state` JSON slot. */
+export interface JournalEnvelope<P = unknown> {
+    /** Schema version of the payload — monotonic, increments per breaking change. */
+    readonly _v: number;
+    /** Manifest — stable type identity, e.g. `'BankAccount.Deposited'`. */
+    readonly _t: string;
+    /** The (possibly-old) payload itself. */
+    readonly _e: P;
+}
+/** Stored shape that adapters see on the read path — the unwrapped envelope. */
+export interface StoredFrame {
+    readonly manifest: string;
+    readonly version: number;
+    readonly payload: unknown;
+}
+/** Triple emitted by adapters on the write path — the actor wraps this into an envelope. */
+export interface OutboundFrame<JournalShape = unknown> {
+    readonly manifest: string;
+    readonly version: number;
+    readonly payload: JournalShape;
+}
+/**
+ * Adapter for `PersistentActor` events.  `DomainEvent` is the *current*
+ * event union the actor knows; `JournalShape` defaults to the same type
+ * but may diverge if the user wants to store a slimmer wire representation.
+ */
+export interface EventAdapter<DomainEvent, JournalShape = DomainEvent> {
+    /** Stable identifier for the *current* event variant — used as `_t` on disk. */
+    manifest(event: DomainEvent): string;
+    /** Convert a domain event to the journal triple. */
+    toJournal(event: DomainEvent): OutboundFrame<JournalShape>;
+    /** Inverse: take any past version off disk, return a current-version domain event. */
+    fromJournal(stored: StoredFrame): DomainEvent;
+}
+/**
+ * Adapter for `PersistentActor` snapshots.  Structurally identical to
+ * `EventAdapter` but kept as a separate type so signatures read clearly
+ * (a `snapshotAdapter()` returning an `EventAdapter` would be misleading).
+ */
+export interface SnapshotAdapter<DomainState, StoredShape = DomainState> {
+    manifest(state: DomainState): string;
+    toJournal(state: DomainState): OutboundFrame<StoredShape>;
+    fromJournal(stored: StoredFrame): DomainState;
+}
+/**
+ * Adapter for `DurableStateActor` — same shape as `SnapshotAdapter`, alias
+ * for naming clarity at the actor level.
+ */
+export type StateAdapter<DomainState> = SnapshotAdapter<DomainState>;
+//# sourceMappingURL=Adapter.d.ts.map

package/dist/persistence/migration/Adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Adapter.d.ts","sourceRoot":"","sources":["../../../src/persistence/migration/Adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,yEAAyE;AACzE,MAAM,WAAW,eAAe,CAAC,CAAC,GAAG,OAAO;IAC1C,iFAAiF;IACjF,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,uEAAuE;IACvE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,yCAAyC;IACzC,QAAQ,CAAC,EAAE,EAAE,CAAC,CAAC;CAChB;AAED,gFAAgF;AAChF,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED,4FAA4F;AAC5F,MAAM,WAAW,aAAa,CAAC,YAAY,GAAG,OAAO;IACnD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAC;CAChC;AAED;;;;GAIG;AACH,MAAM,WAAW,YAAY,CAAC,WAAW,EAAE,YAAY,GAAG,WAAW;IACnE,gFAAgF;IAChF,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAAC;IACrC,oDAAoD;IACpD,SAAS,CAAC,KAAK,EAAE,WAAW,GAAG,aAAa,CAAC,YAAY,CAAC,CAAC;IAC3D,sFAAsF;IACtF,WAAW,CAAC,MAAM,EAAE,WAAW,GAAG,WAAW,CAAC;CAC/C;AAED;;;;GAIG;AACH,MAAM,WAAW,eAAe,CAAC,WAAW,EAAE,WAAW,GAAG,WAAW;IACrE,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAAC;IACrC,SAAS,CAAC,KAAK,EAAE,WAAW,GAAG,aAAa,CAAC,WAAW,CAAC,CAAC;IAC1D,WAAW,CAAC,MAAM,EAAE,WAAW,GAAG,WAAW,CAAC;CAC/C;AAED;;;GAGG;AACH,MAAM,MAAM,YAAY,CAAC,WAAW,IAAI,eAAe,CAAC,WAAW,CAAC,CAAC"}

package/dist/persistence/migration/Adapter.js

@@ -0,0 +1,24 @@
+/**
+ * Schema-evolution adapters for persistent actors.
+ *
+ * The actor framework stores events / state as opaque JSON in the journal
+ * and snapshot store.  When a domain type evolves (new field, renamed
+ * field, type change), already-persisted history must still be replayable
+ * — the user supplies an `EventAdapter` (for events) or a `SnapshotAdapter`
+ * / `StateAdapter` (for snapshots and durable state) which:
+ *
+ *   - tags every value written with a stable `manifest` string and a
+ *     numeric `version` (the wire-format envelope is `{ _v, _t, _e }`,
+ *     applied transparently by `PersistentActor` / `DurableStateActor`),
+ *   - on read, takes the stored triple `{ manifest, version, payload }`
+ *     and returns a current-version domain value, typically by delegating
+ *     to a `MigrationChain` of pure upcaster functions.
+ *
+ * The adapter contract is intentionally separate from the wire envelope:
+ * adapters return / accept *triples*, the actor is responsible for the
+ * `_v / _t / _e` JSON shape.  That keeps user code focused on the domain
+ * mapping and lets us evolve the wire format later without breaking
+ * adapters.
+ */
+export {};
+//# sourceMappingURL=Adapter.js.map

package/dist/persistence/migration/Adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Adapter.js","sourceRoot":"","sources":["../../../src/persistence/migration/Adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG"}

package/dist/persistence/migration/Codec.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Pluggable wire codec for journal payloads (#6).
+ *
+ * The persistence layer serialises everything as JSON — that's the
+ * baseline contract.  But user code often wants stronger guarantees
+ * about the *shape* of the JSON it stores: every event matches a
+ * known schema, every snapshot decodes cleanly, malformed wire
+ * data is rejected loud and early instead of crashing somewhere in
+ * `onEvent`.  A `Codec<T>` is the validate-on-encode/decode hook
+ * that gets you that.
+ *
+ * Two shipped impls:
+ *
+ *   - `jsonCodec<T>()` — pass-through.  No validation.  Same as the
+ *     framework's default behaviour.  Use when you don't have or
+ *     don't need schema validation.
+ *   - `zodCodec<T>(schema)` — validates against any object exposing
+ *     a `parse(unknown): T` method.  Zod schemas, `valibot` schemas
+ *     with a `parse` adapter, and any hand-rolled validator all
+ *     fit.  We don't import `zod` directly — the user brings their
+ *     own dependency and passes the schema in.
+ *
+ * Avro / Protobuf wire codecs are out-of-scope for v1.  The hooks
+ * here are wide enough that a user can build them on top: `encode`
+ * returns the shape that ends up in the JSON envelope, so writing
+ * an Avro codec means returning a base64 string; the journal is
+ * agnostic.
+ */
+/**
+ * A bidirectional value-transform with validation on both sides.
+ * `encode` is called when the actor is about to persist; `decode`
+ * is called after a successful journal read but **before** the
+ * domain handler sees the payload.  Errors thrown from either
+ * surface as `PersistError` / `MigrationError` at the actor layer.
+ */
+export interface Codec<T> {
+    /**
+     * Validate / serialise a domain value for the wire.  Returning
+     * the input unchanged is fine — the codec's job is to throw on
+     * invalid input, not necessarily to reshape the payload.
+     */
+    encode(value: T): unknown;
+    /** Inverse of `encode`. */
+    decode(wire: unknown): T;
+    /** Diagnostic name shown in error messages. */
+    readonly name?: string;
+}
+/**
+ * Pass-through codec — no validation, identity transform.  Same
+ * shape as the framework's default behaviour when no codec is
+ * supplied.  Useful as a default in generic helpers, and as the
+ * baseline you compose richer codecs on top of.
+ */
+export declare function jsonCodec<T>(): Codec<T>;
+/**
+ * Minimal interface a schema must satisfy to plug into `zodCodec`.
+ * Zod's `ZodSchema<T>` matches it; valibot exposes a compatible
+ * `parse` via its standard helpers; any hand-rolled validator
+ * with a single `parse` method that throws on invalid input works.
+ */
+export interface ParserLike<T> {
+    /** Validate `input` and return a typed value.  Throws on invalid. */
+    parse(input: unknown): T;
+}
+/**
+ * Codec that validates with any `parse`-style schema (Zod, valibot,
+ * hand-rolled).  We don't import `zod` directly — the user's
+ * project owns the dependency and passes the schema in.
+ *
+ *   import { z } from 'zod';
+ *
+ *   const Deposited = z.object({
+ *     kind: z.literal('deposited'),
+ *     amount: z.number().int().nonnegative(),
+ *     currency: z.enum(['USD', 'EUR']),
+ *   });
+ *
+ *   const adapter = validatedEventAdapter(
+ *     defaultsAdapter<DepositedV2>({ ... }),
+ *     zodCodec(Deposited),
+ *   );
+ *
+ * Validates:
+ *   - On `toJournal`: a programmer-bug malformed event is caught
+ *     at write time, not after it's already on disk.
+ *   - On `fromJournal`: a corrupted / hand-edited journal record
+ *     fails the deserialise instead of silently producing garbage.
+ *
+ * `zodCodec` does NOT participate in **schema-evolution** by
+ * itself — pair it with `defaultsAdapter`, `migratingAdapter`, or
+ * the SchemaRegistry to cover version differences.  This codec
+ * validates one specific shape; it has no idea what older or newer
+ * versions look like.
+ */
+export declare function zodCodec<T>(schema: ParserLike<T>, name?: string): Codec<T>;
+/**
+ * Compose two codecs serially: the first transforms domain → mid,
+ * the second transforms mid → wire.  Decoding runs in reverse.
+ * Handy when you want validation on top of a structural transform
+ * (e.g. `composeCodecs(camelCaseCodec, zodCodec(schema))`).
+ */
+export declare function composeCodecs<A, B>(first: Codec<A>, second: Codec<B>, name?: string): Codec<A>;
+//# sourceMappingURL=Codec.d.ts.map

package/dist/persistence/migration/Codec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Codec.d.ts","sourceRoot":"","sources":["../../../src/persistence/migration/Codec.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH;;;;;;GAMG;AACH,MAAM,WAAW,KAAK,CAAC,CAAC;IACtB;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC;IAC1B,2BAA2B;IAC3B,MAAM,CAAC,IAAI,EAAE,OAAO,GAAG,CAAC,CAAC;IACzB,+CAA+C;IAC/C,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAMvC;AAED;;;;;GAKG;AACH,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B,qEAAqE;IACrE,KAAK,CAAC,KAAK,EAAE,OAAO,GAAG,CAAC,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,IAAI,SAAQ,GAAG,KAAK,CAAC,CAAC,CAAC,CAMzE;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,CAAC,EAChC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,EACf,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,EAChB,IAAI,CAAC,EAAE,MAAM,GACZ,KAAK,CAAC,CAAC,CAAC,CAMV"}

package/dist/persistence/migration/Codec.js

@@ -0,0 +1,92 @@
+/**
+ * Pluggable wire codec for journal payloads (#6).
+ *
+ * The persistence layer serialises everything as JSON — that's the
+ * baseline contract.  But user code often wants stronger guarantees
+ * about the *shape* of the JSON it stores: every event matches a
+ * known schema, every snapshot decodes cleanly, malformed wire
+ * data is rejected loud and early instead of crashing somewhere in
+ * `onEvent`.  A `Codec<T>` is the validate-on-encode/decode hook
+ * that gets you that.
+ *
+ * Two shipped impls:
+ *
+ *   - `jsonCodec<T>()` — pass-through.  No validation.  Same as the
+ *     framework's default behaviour.  Use when you don't have or
+ *     don't need schema validation.
+ *   - `zodCodec<T>(schema)` — validates against any object exposing
+ *     a `parse(unknown): T` method.  Zod schemas, `valibot` schemas
+ *     with a `parse` adapter, and any hand-rolled validator all
+ *     fit.  We don't import `zod` directly — the user brings their
+ *     own dependency and passes the schema in.
+ *
+ * Avro / Protobuf wire codecs are out-of-scope for v1.  The hooks
+ * here are wide enough that a user can build them on top: `encode`
+ * returns the shape that ends up in the JSON envelope, so writing
+ * an Avro codec means returning a base64 string; the journal is
+ * agnostic.
+ */
+/**
+ * Pass-through codec — no validation, identity transform.  Same
+ * shape as the framework's default behaviour when no codec is
+ * supplied.  Useful as a default in generic helpers, and as the
+ * baseline you compose richer codecs on top of.
+ */
+export function jsonCodec() {
+    return {
+        name: 'json',
+        encode: (v) => v,
+        decode: (w) => w,
+    };
+}
+/**
+ * Codec that validates with any `parse`-style schema (Zod, valibot,
+ * hand-rolled).  We don't import `zod` directly — the user's
+ * project owns the dependency and passes the schema in.
+ *
+ *   import { z } from 'zod';
+ *
+ *   const Deposited = z.object({
+ *     kind: z.literal('deposited'),
+ *     amount: z.number().int().nonnegative(),
+ *     currency: z.enum(['USD', 'EUR']),
+ *   });
+ *
+ *   const adapter = validatedEventAdapter(
+ *     defaultsAdapter<DepositedV2>({ ... }),
+ *     zodCodec(Deposited),
+ *   );
+ *
+ * Validates:
+ *   - On `toJournal`: a programmer-bug malformed event is caught
+ *     at write time, not after it's already on disk.
+ *   - On `fromJournal`: a corrupted / hand-edited journal record
+ *     fails the deserialise instead of silently producing garbage.
+ *
+ * `zodCodec` does NOT participate in **schema-evolution** by
+ * itself — pair it with `defaultsAdapter`, `migratingAdapter`, or
+ * the SchemaRegistry to cover version differences.  This codec
+ * validates one specific shape; it has no idea what older or newer
+ * versions look like.
+ */
+export function zodCodec(schema, name = 'zod') {
+    return {
+        name,
+        encode: (value) => schema.parse(value),
+        decode: (wire) => schema.parse(wire),
+    };
+}
+/**
+ * Compose two codecs serially: the first transforms domain → mid,
+ * the second transforms mid → wire.  Decoding runs in reverse.
+ * Handy when you want validation on top of a structural transform
+ * (e.g. `composeCodecs(camelCaseCodec, zodCodec(schema))`).
+ */
+export function composeCodecs(first, second, name) {
+    return {
+        name: name ?? `${first.name ?? 'a'}>>${second.name ?? 'b'}`,
+        encode: (a) => second.encode(first.encode(a)),
+        decode: (c) => first.decode(second.decode(c)),
+    };
+}
+//# sourceMappingURL=Codec.js.map

package/dist/persistence/migration/Codec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Codec.js","sourceRoot":"","sources":["../../../src/persistence/migration/Codec.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAsBH;;;;;GAKG;AACH,MAAM,UAAU,SAAS;IACvB,OAAO;QACL,IAAI,EAAE,MAAM;QACZ,MAAM,EAAE,CAAC,CAAI,EAAE,EAAE,CAAC,CAAY;QAC9B,MAAM,EAAE,CAAC,CAAU,EAAE,EAAE,CAAC,CAAM;KAC/B,CAAC;AACJ,CAAC;AAaD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,UAAU,QAAQ,CAAI,MAAqB,EAAE,IAAI,GAAG,KAAK;IAC7D,OAAO;QACL,IAAI;QACJ,MAAM,EAAE,CAAC,KAAQ,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC;QACzC,MAAM,EAAE,CAAC,IAAa,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC;KAC9C,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,aAAa,CAC3B,KAAe,EACf,MAAgB,EAChB,IAAa;IAEb,OAAO;QACL,IAAI,EAAE,IAAI,IAAI,GAAG,KAAK,CAAC,IAAI,IAAI,GAAG,KAAK,MAAM,CAAC,IAAI,IAAI,GAAG,EAAE;QAC3D,MAAM,EAAE,CAAC,CAAI,EAAW,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAM,CAAC;QAC9D,MAAM,EAAE,CAAC,CAAU,EAAK,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;KAC1D,CAAC;AACJ,CAAC"}

package/dist/persistence/migration/Envelope.d.ts

@@ -0,0 +1,37 @@
+import type { EventAdapter, JournalEnvelope, SnapshotAdapter } from './Adapter.js';
+/**
+ * Wire-format helpers for the `_v / _t / _e` JSON envelope used by
+ * `PersistentActor` and `DurableStateActor` when an adapter is active.
+ *
+ * The envelope rides inside the existing `event` / `state` JSON slot of
+ * the journal / snapshot store, so no backend (InMemory, SQLite,
+ * Cassandra, object-storage) needs schema changes.  The magic keys are
+ * `_v`, `_t`, `_e` — underscore-prefixed to make accidental collisions
+ * with domain types vanishingly unlikely.
+ */
+/** Raised when adapter-driven decoding hits a malformed/legacy payload. */
+export declare class MigrationError extends Error {
+    readonly manifest?: string | undefined;
+    readonly version?: number | undefined;
+    constructor(message: string, manifest?: string | undefined, version?: number | undefined);
+}
+/** True iff `o` looks like a `JournalEnvelope`. */
+export declare function isEnvelope(o: unknown): o is JournalEnvelope;
+/** Wrap a domain event into an envelope using the supplied adapter. */
+export declare function encodeEvent<E, J>(event: E, adapter: EventAdapter<E, J>): JournalEnvelope<J>;
+/**
+ * Decode a value read from the journal.  When `adapter` is undefined the
+ * caller has not opted into the migration system — the value is returned
+ * as-is and is assumed to be a raw domain event.  When `adapter` is
+ * defined, the value MUST be an envelope; otherwise a `MigrationError` is
+ * raised (strict mode — see plan §1).
+ */
+export declare function decodeEvent<E>(stored: unknown, adapter: EventAdapter<E> | undefined): E;
+/** Wrap a snapshot state into an envelope using the supplied adapter. */
+export declare function encodeState<S, J>(state: S, adapter: SnapshotAdapter<S, J>): JournalEnvelope<J>;
+/**
+ * Decode a state read from the snapshot store / durable-state store.
+ * Same strict semantics as `decodeEvent`.
+ */
+export declare function decodeState<S>(stored: unknown, adapter: SnapshotAdapter<S> | undefined): S;
+//# sourceMappingURL=Envelope.d.ts.map

package/dist/persistence/migration/Envelope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Envelope.d.ts","sourceRoot":"","sources":["../../../src/persistence/migration/Envelope.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,YAAY,EACZ,eAAe,EACf,eAAe,EAEhB,MAAM,cAAc,CAAC;AAEtB;;;;;;;;;GASG;AAEH,2EAA2E;AAC3E,qBAAa,cAAe,SAAQ,KAAK;aAGrB,QAAQ,CAAC,EAAE,MAAM;aACjB,OAAO,CAAC,EAAE,MAAM;gBAFhC,OAAO,EAAE,MAAM,EACC,QAAQ,CAAC,EAAE,MAAM,YAAA,EACjB,OAAO,CAAC,EAAE,MAAM,YAAA;CAKnC;AAED,mDAAmD;AACnD,wBAAgB,UAAU,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,eAAe,CAM3D;AAID,uEAAuE;AACvE,wBAAgB,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,CAG3F;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,SAAS,GAAG,CAAC,CAWvF;AAID,yEAAyE;AACzE,wBAAgB,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,CAG9F;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,CAAC,CAAC,CAAC,GAAG,SAAS,GAAG,CAAC,CAU1F"}