@roj-ai/kompjutr-platform 0.0.0 → 0.2.10

package/dist/shell.js

@@ -0,0 +1,36 @@
+import { createGitCommand } from '@kompjutr/do/git-shell';
+import { createShell } from '@kompjutr/do/shell';
+function quoteShellWord(value) {
+    return `'${value.replaceAll("'", "'\\''")}'`;
+}
+export function createKompjutrShellRunner(options) {
+    const commands = options.git === undefined ? undefined : new Map([['git', createGitCommand(options.git)]]);
+    return {
+        confinement: options.confinement ?? 'none',
+        supportsTimeout: false,
+        async run(runOptions) {
+            if (!runOptions.cwd.startsWith('/'))
+                throw new Error('kompjutr shell requires an absolute cwd');
+            if ((runOptions.grants?.length ?? 0) > 0) {
+                throw new Error('kompjutr shell does not support path grants');
+            }
+            // ShellSession caches cwd per instance, even though instances share the default SQL row.
+            const shell = createShell({ fs: options.filesystem, commands });
+            const cwdResult = await shell.run(`cd ${quoteShellWord(runOptions.cwd)}`);
+            const result = cwdResult.exitCode === 0
+                ? await shell.run(runOptions.command, {
+                    env: runOptions.env,
+                    stdin: runOptions.stdin,
+                })
+                : cwdResult;
+            return {
+                stdout: result.stdout,
+                stderr: result.stderr,
+                exitCode: result.exitCode,
+                timedOut: false,
+                truncated: result.truncated,
+            };
+        },
+    };
+}
+//# sourceMappingURL=shell.js.map

package/dist/shell.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shell.js","sourceRoot":"","sources":["../src/shell.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AACzD,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAUhD,SAAS,cAAc,CAAC,KAAa;IACpC,OAAO,IAAI,KAAK,CAAC,UAAU,CAAC,GAAG,EAAE,OAAO,CAAC,GAAG,CAAA;AAC7C,CAAC;AAED,MAAM,UAAU,yBAAyB,CAAC,OAAmC;IAC5E,MAAM,QAAQ,GAAG,OAAO,CAAC,GAAG,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,EAAE,gBAAgB,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAA;IAE1G,OAAO;QACN,WAAW,EAAE,OAAO,CAAC,WAAW,IAAI,MAAM;QAC1C,eAAe,EAAE,KAAK;QACtB,KAAK,CAAC,GAAG,CAAC,UAAU;YACnB,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC;gBAAE,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAA;YAC/F,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,IAAI,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC;gBAC1C,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAA;YAC/D,CAAC;YAED,yFAAyF;YACzF,MAAM,KAAK,GAAG,WAAW,CAAC,EAAE,EAAE,EAAE,OAAO,CAAC,UAAU,EAAE,QAAQ,EAAE,CAAC,CAAA;YAC/D,MAAM,SAAS,GAAG,MAAM,KAAK,CAAC,GAAG,CAAC,MAAM,cAAc,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC,CAAA;YACzE,MAAM,MAAM,GACX,SAAS,CAAC,QAAQ,KAAK,CAAC;gBACvB,CAAC,CAAC,MAAM,KAAK,CAAC,GAAG,CAAC,UAAU,CAAC,OAAO,EAAE;oBACpC,GAAG,EAAE,UAAU,CAAC,GAAG;oBACnB,KAAK,EAAE,UAAU,CAAC,KAAK;iBACvB,CAAC;gBACH,CAAC,CAAC,SAAS,CAAA;YACb,OAAO;gBACN,MAAM,EAAE,MAAM,CAAC,MAAM;gBACrB,MAAM,EAAE,MAAM,CAAC,MAAM;gBACrB,QAAQ,EAAE,MAAM,CAAC,QAAQ;gBACzB,QAAQ,EAAE,KAAK;gBACf,SAAS,EAAE,MAAM,CAAC,SAAS;aAC3B,CAAA;QACF,CAAC;KACD,CAAA;AACF,CAAC"}

package/dist/testing/index.d.ts

@@ -0,0 +1,2 @@
+export { BunSqliteStorage, MAX_BIND_PARAMETERS } from './storage.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/testing/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/testing/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA"}

package/dist/testing/index.js

@@ -0,0 +1,2 @@
+export { BunSqliteStorage, MAX_BIND_PARAMETERS } from './storage.js';
+//# sourceMappingURL=index.js.map

package/dist/testing/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/testing/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA"}

package/dist/testing/storage.d.ts

@@ -0,0 +1,29 @@
+/**
+ * `bun:sqlite` standing in for Durable Object SQL storage, so the adapter can
+ * be driven by `bun test` without a Worker runtime.
+ *
+ * It is deliberately *stricter* than its backing engine on one point. A Durable
+ * Object binds at most 100 parameters per statement; bun:sqlite binds far more,
+ * and an earlier attempt at this port shipped a batch insert that passed every
+ * test and failed in production for exactly that reason. A fake that is more
+ * permissive than the thing it stands for hides the bugs worth catching, so the
+ * limit is enforced here rather than discovered on a deploy.
+ */
+import { Database as BunDatabase } from 'bun:sqlite';
+import type { DurableObjectStorageLike, SQLStorageLike } from '@kompjutr/do';
+/** What a Durable Object binds per statement. The 101st raises, as workerd does. */
+export declare const MAX_BIND_PARAMETERS = 100;
+export declare class BunSqliteStorage implements DurableObjectStorageLike {
+    #private;
+    readonly db: BunDatabase;
+    readonly sql: SQLStorageLike;
+    /** Statements executed since the last reset — what a cost test asserts on. */
+    statementCount: number;
+    /** Rows the caller actually pulled. Approximate: a cursor abandoned early stops counting. */
+    rowCount: number;
+    constructor(path?: string);
+    transactionSync<T>(closure: () => T): T;
+    resetCounters(): void;
+    close(): void;
+}
+//# sourceMappingURL=storage.d.ts.map

package/dist/testing/storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../src/testing/storage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,QAAQ,IAAI,WAAW,EAAyB,MAAM,YAAY,CAAA;AAC3E,OAAO,KAAK,EAAE,wBAAwB,EAAiB,cAAc,EAAE,MAAM,cAAc,CAAA;AAE3F,oFAAoF;AACpF,eAAO,MAAM,mBAAmB,MAAM,CAAA;AAuEtC,qBAAa,gBAAiB,YAAW,wBAAwB;;IAChE,QAAQ,CAAC,EAAE,EAAE,WAAW,CAAA;IACxB,QAAQ,CAAC,GAAG,EAAE,cAAc,CAAA;IAE5B,8EAA8E;IAC9E,cAAc,SAAI;IAClB,6FAA6F;IAC7F,QAAQ,SAAI;gBAIA,IAAI,SAAa;IAkB7B,eAAe,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,GAAG,CAAC;IAgBvC,aAAa,IAAI,IAAI;IAKrB,KAAK,IAAI,IAAI;CAGb"}

package/dist/testing/storage.js

@@ -0,0 +1,132 @@
+/**
+ * `bun:sqlite` standing in for Durable Object SQL storage, so the adapter can
+ * be driven by `bun test` without a Worker runtime.
+ *
+ * It is deliberately *stricter* than its backing engine on one point. A Durable
+ * Object binds at most 100 parameters per statement; bun:sqlite binds far more,
+ * and an earlier attempt at this port shipped a batch insert that passed every
+ * test and failed in production for exactly that reason. A fake that is more
+ * permissive than the thing it stands for hides the bugs worth catching, so the
+ * limit is enforced here rather than discovered on a deploy.
+ */
+import { Database as BunDatabase } from 'bun:sqlite';
+/** What a Durable Object binds per statement. The 101st raises, as workerd does. */
+export const MAX_BIND_PARAMETERS = 100;
+/** SQLite takes bytes, numbers, strings and null; everything else is converted or refused. */
+function toBinding(value) {
+    if (value === undefined || value === null)
+        return null;
+    if (typeof value === 'boolean')
+        return value ? 1 : 0;
+    if (value instanceof ArrayBuffer)
+        return new Uint8Array(value);
+    if (ArrayBuffer.isView(value) && !(value instanceof Uint8Array)) {
+        return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    }
+    if (typeof value === 'number' || typeof value === 'bigint' || typeof value === 'string' || value instanceof Uint8Array) {
+        return value;
+    }
+    throw new TypeError(`unsupported SQLite binding: ${typeof value}`);
+}
+/**
+ * Rows arrive lazily, because `Filesystem.scan` pages a range scan and a cursor
+ * that materialised would turn every page into the whole table.
+ *
+ * One step is taken up front all the same: a statement nobody iterates is a
+ * statement bun:sqlite never runs, and a `CREATE TABLE` has no rows to pull.
+ */
+class Cursor {
+    onRow;
+    #rows;
+    #prefetched;
+    #done = false;
+    constructor(rows, onRow) {
+        this.onRow = onRow;
+        this.#rows = rows;
+        this.#prefetched = this.#pull();
+    }
+    #pull() {
+        const step = this.#rows.next();
+        if (step.done === true)
+            this.#done = true;
+        else
+            this.onRow();
+        return step;
+    }
+    next() {
+        if (this.#prefetched !== null) {
+            const first = this.#prefetched;
+            this.#prefetched = null;
+            return first;
+        }
+        if (this.#done)
+            return { done: true, value: undefined };
+        return this.#pull();
+    }
+    return() {
+        if (!this.#done) {
+            this.#rows.return?.();
+            this.#done = true;
+        }
+        this.#prefetched = null;
+        return { done: true, value: undefined };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+    toArray() {
+        return Array.from(this);
+    }
+}
+export class BunSqliteStorage {
+    db;
+    sql;
+    /** Statements executed since the last reset — what a cost test asserts on. */
+    statementCount = 0;
+    /** Rows the caller actually pulled. Approximate: a cursor abandoned early stops counting. */
+    rowCount = 0;
+    #depth = 0;
+    constructor(path = ':memory:') {
+        this.db = new BunDatabase(path, { create: true });
+        this.db.run('PRAGMA journal_mode = WAL');
+        this.sql = {
+            exec: (query, ...bindings) => {
+                if (bindings.length > MAX_BIND_PARAMETERS) {
+                    throw new Error(`too many SQL variables: ${bindings.length} exceeds the ${MAX_BIND_PARAMETERS} a Durable Object binds`);
+                }
+                this.statementCount++;
+                const statement = this.db.query(query);
+                const rows = statement.iterate(...bindings.map(toBinding));
+                return new Cursor(rows, () => {
+                    this.rowCount++;
+                });
+            },
+        };
+    }
+    transactionSync(closure) {
+        if (this.#depth > 0)
+            return closure();
+        this.#depth++;
+        this.db.run('BEGIN');
+        try {
+            const result = closure();
+            this.db.run('COMMIT');
+            return result;
+        }
+        catch (error) {
+            this.db.run('ROLLBACK');
+            throw error;
+        }
+        finally {
+            this.#depth--;
+        }
+    }
+    resetCounters() {
+        this.statementCount = 0;
+        this.rowCount = 0;
+    }
+    close() {
+        this.db.close();
+    }
+}
+//# sourceMappingURL=storage.js.map

package/dist/testing/storage.js.map

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

package/package.json

@@ -1,13 +1,53 @@
 {
 	"name": "@roj-ai/kompjutr-platform",
-	"version": "0.0.0",
-	"description": "Placeholder that reserves the package name for trusted publishing. Real releases come from CI.",
+	"version": "0.2.10",
+	"type": "module",
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"roj": {
+		"bunOnlyExports": [
+			"./testing"
+		]
+	},
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js",
+			"default": "./dist/index.js"
+		},
+		"./testing": {
+			"types": "./dist/testing/index.d.ts",
+			"import": "./dist/testing/index.js",
+			"default": "./dist/testing/index.js"
+		}
+	},
+	"files": [
+		"src",
+		"dist",
+		"!src/**/*.test.ts",
+		"!dist/**/*.test.*"
+	],
+	"publishConfig": {
+		"access": "public"
+	},
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/contember/roj.git",
 		"directory": "packages/kompjutr-platform"
 	},
-	"publishConfig": {
-		"access": "public"
+	"homepage": "https://github.com/contember/roj/tree/main/packages/kompjutr-platform#readme",
+	"bugs": {
+		"url": "https://github.com/contember/roj/issues"
+	},
+	"scripts": {
+		"type-check": "tsc --noEmit"
+	},
+	"dependencies": {
+		"@kompjutr/do": "0.1.2",
+		"@roj-ai/sdk": "^0.2.10"
+	},
+	"devDependencies": {
+		"@types/bun": "^1.3.3",
+		"typescript": "^5.9.3"
 	}
 }

package/src/event-store.ts

@@ -0,0 +1,250 @@
+/**
+ * `EventStore` over the workspace's own SQLite rather than a JSONL file in it.
+ *
+ * The file store rewrites a blob through the filesystem on every append and
+ * parses the whole file on every load. One row per event turns an append into
+ * an insert and `loadRange` into a seek down the clustered `(session_id, seq)`
+ * key. This is the write path an event-sourced session spends its day on.
+ */
+
+import { BaseEventStore, domainEventSchema, EventAppendError, EventStoreError, isDomainEvent, SessionId, sessionMetadataSchema } from '@roj-ai/sdk'
+import type { DomainEvent, LoadRangeOptions, LoadRangeResult, Logger, SessionMetadata } from '@roj-ai/sdk'
+import type { SqlDatabase } from '@kompjutr/do'
+
+const EVENTS_TABLE = 'roj_events'
+const METADATA_TABLE = 'roj_session_metadata'
+
+/** A Durable Object binds at most 100 parameters per statement, and a row costs three. */
+const EVENTS_PER_INSERT = 33
+
+/** `seq` is the 0-based event index the contract reports as fromIndex/toIndex. */
+interface EventRow {
+	seq: number
+	payload: string
+}
+
+export class KompjutrEventStore extends BaseEventStore {
+	/** Tail of the append chain per session; see #serialized. */
+	readonly #appendTails = new Map<SessionId, Promise<void>>()
+
+	constructor(
+		private readonly db: SqlDatabase,
+		private readonly logger?: Logger,
+	) {
+		super()
+
+		// WITHOUT ROWID stores rows in primary-key order, so a session's events are
+		// contiguous and loadRange never leaves the index.
+		this.db.run(
+			`CREATE TABLE IF NOT EXISTS ${EVENTS_TABLE} (
+				session_id TEXT NOT NULL,
+				seq INTEGER NOT NULL,
+				payload TEXT NOT NULL,
+				PRIMARY KEY (session_id, seq)
+			) WITHOUT ROWID`,
+		)
+		this.db.run(
+			`CREATE TABLE IF NOT EXISTS ${METADATA_TABLE} (
+				session_id TEXT PRIMARY KEY,
+				metadata TEXT NOT NULL
+			)`,
+		)
+	}
+
+	protected async doAppend(sessionId: SessionId, event: DomainEvent): Promise<void> {
+		await this.doAppendBatch(sessionId, [event])
+	}
+
+	protected async doAppendBatch(sessionId: SessionId, events: DomainEvent[]): Promise<void> {
+		if (events.length === 0) return
+
+		await this.#serialized(sessionId, async () => {
+			try {
+				// One transaction, so a batch too wide for a single statement still
+				// lands whole. The old shape relied on the host committing a
+				// synchronous run together, which only a Durable Object promises.
+				this.db.transactionSync(() => {
+					const firstSeq = this.#lastSeq(sessionId) + 1
+					for (let offset = 0; offset < events.length; offset += EVENTS_PER_INSERT) {
+						const chunk = events.slice(offset, offset + EVENTS_PER_INSERT)
+						const tuples = chunk.map(() => '(?, ?, ?)').join(', ')
+						const bindings = chunk.flatMap((event, index) => [sessionId, firstSeq + offset + index, JSON.stringify(event)])
+						this.db.run(`INSERT INTO ${EVENTS_TABLE} (session_id, seq, payload) VALUES ${tuples}`, ...bindings)
+					}
+				})
+
+				await this.updateMetadataFromEvents(sessionId, events)
+			} catch (error) {
+				throw new EventAppendError(sessionId, error)
+			}
+		})
+	}
+
+	async load(sessionId: SessionId): Promise<DomainEvent[]> {
+		const rows = this.db.all<EventRow>(`SELECT seq, payload FROM ${EVENTS_TABLE} WHERE session_id = ? ORDER BY seq`, sessionId)
+		return rows.map((row) => this.#decodeEvent(sessionId, row))
+	}
+
+	async loadRange(sessionId: SessionId, options?: LoadRangeOptions): Promise<LoadRangeResult> {
+		const since = options?.since ?? -1
+		const limit = options?.limit
+
+		const rows = this.db.all<EventRow>(
+			`SELECT seq, payload FROM ${EVENTS_TABLE} WHERE session_id = ? AND seq > ? ORDER BY seq LIMIT ?`,
+			sessionId,
+			since,
+			// SQLite reads a negative limit as unlimited; clamp rather than inherit that.
+			limit === undefined ? -1 : Math.max(limit, 0),
+		)
+
+		const first = rows[0]
+		const last = rows[rows.length - 1]
+		if (first === undefined || last === undefined) {
+			// Report the store's last index instead, so a poller keeps its cursor.
+			return { events: [], fromIndex: -1, toIndex: this.#lastSeq(sessionId) }
+		}
+
+		return {
+			events: rows.map((row) => this.#decodeEvent(sessionId, row)),
+			fromIndex: first.seq,
+			toIndex: last.seq,
+		}
+	}
+
+	async exists(sessionId: SessionId): Promise<boolean> {
+		return this.db.one(`SELECT 1 FROM ${EVENTS_TABLE} WHERE session_id = ? LIMIT 1`, sessionId) !== undefined
+	}
+
+	/**
+	 * Every session this store holds, from either side of the pair.
+	 *
+	 * Neither side implies the other. A session created by `updateMetadata` alone
+	 * has no events yet and the file store still lists it; a session whose
+	 * metadata write failed after its rows landed has events and no metadata, and
+	 * then the log is the only record it ran. So the answer is a union — taken
+	 * without reading the log, because a status poll counts these.
+	 *
+	 * The recursive term seeks from one distinct id straight to the next down the
+	 * `(session_id, seq)` primary key, so the cost follows sessions rather than
+	 * events. `SELECT DISTINCT session_id` reads every row instead.
+	 */
+	async listSessions(): Promise<SessionId[]> {
+		const rows = this.db.all<{ session_id: string }>(
+			`WITH RECURSIVE event_sessions(session_id) AS (
+				SELECT MIN(session_id) FROM ${EVENTS_TABLE}
+				UNION ALL
+				SELECT (SELECT MIN(session_id) FROM ${EVENTS_TABLE} WHERE session_id > previous.session_id)
+				FROM event_sessions AS previous
+				WHERE previous.session_id IS NOT NULL
+			)
+			SELECT session_id FROM event_sessions WHERE session_id IS NOT NULL
+			UNION
+			SELECT session_id FROM ${METADATA_TABLE}
+			ORDER BY session_id`,
+		)
+
+		return rows.map((row) => SessionId(row.session_id))
+	}
+
+	/**
+	 * Drop every row this store holds for one session, and report how many events went.
+	 *
+	 * Deliberately outside the `EventStore` contract: the log is the only record
+	 * that a session existed, so nothing in the SDK can reach this by accident.
+	 * Whether a session may be dropped is the caller's policy.
+	 */
+	async deleteSession(sessionId: SessionId): Promise<number> {
+		let events = 0
+
+		// Serialized with appends, so a delete cannot land between a batch's
+		// sequence claim and its inserts and leave the tail of that batch behind.
+		await this.#serialized(sessionId, async () => {
+			this.db.transactionSync(() => {
+				events = this.db.scalar<number>(`SELECT COUNT(*) FROM ${EVENTS_TABLE} WHERE session_id = ?`, sessionId) ?? 0
+				this.db.run(`DELETE FROM ${EVENTS_TABLE} WHERE session_id = ?`, sessionId)
+				this.db.run(`DELETE FROM ${METADATA_TABLE} WHERE session_id = ?`, sessionId)
+			})
+		})
+
+		return events
+	}
+
+	protected async readMetadata(sessionId: SessionId): Promise<SessionMetadata | null> {
+		const row = this.db.one<{ metadata: string }>(`SELECT metadata FROM ${METADATA_TABLE} WHERE session_id = ?`, sessionId)
+		return row === undefined ? null : this.#decodeMetadata(sessionId, row.metadata)
+	}
+
+	/** A session whose metadata does not parse is skipped, never thrown over. */
+	#skip(sessionId: SessionId, reason: string): null {
+		this.logger?.warn('Skipping invalid session metadata', {
+			sessionId,
+			reason,
+		})
+		return null
+	}
+
+	protected async writeMetadata(sessionId: SessionId, metadata: SessionMetadata): Promise<void> {
+		this.db.run(
+			`INSERT INTO ${METADATA_TABLE} (session_id, metadata) VALUES (?, ?)
+			ON CONFLICT(session_id) DO UPDATE SET metadata = excluded.metadata`,
+			sessionId,
+			JSON.stringify(metadata),
+		)
+	}
+
+	protected async getAllSessionMetadata(): Promise<SessionMetadata[]> {
+		const rows = this.db.all<{ session_id: string; metadata: string }>(`SELECT session_id, metadata FROM ${METADATA_TABLE} ORDER BY session_id`)
+		return rows.map((row) => this.#decodeMetadata(SessionId(row.session_id), row.metadata)).filter((metadata): metadata is SessionMetadata => metadata !== null)
+	}
+
+	/** Index of the last stored event, -1 when the session has none. */
+	#lastSeq(sessionId: SessionId): number {
+		return this.db.scalar<number | null>(`SELECT MAX(seq) FROM ${EVENTS_TABLE} WHERE session_id = ?`, sessionId) ?? -1
+	}
+
+	/**
+	 * Run appends for one session one at a time.
+	 *
+	 * The SQL is synchronous but the metadata update that follows it is not, so
+	 * concurrent appends would otherwise read-modify-write the same metrics.
+	 */
+	#serialized(sessionId: SessionId, task: () => Promise<void>): Promise<void> {
+		const previous = this.#appendTails.get(sessionId) ?? Promise.resolve()
+		const next = previous.then(task)
+		// The stored tail must never reject, or the next append inherits this failure.
+		const tail = next
+			.catch(() => undefined)
+			.then(() => {
+				if (this.#appendTails.get(sessionId) === tail) this.#appendTails.delete(sessionId)
+			})
+		this.#appendTails.set(sessionId, tail)
+		return next
+	}
+
+	#decodeEvent(sessionId: SessionId, row: EventRow): DomainEvent {
+		try {
+			const parsed = domainEventSchema.parse(JSON.parse(row.payload))
+			// The schema validates fields; the SDK guard supplies the domain event brand.
+			if (!isDomainEvent(parsed)) throw new Error('Invalid domain event')
+			return parsed
+		} catch (error) {
+			throw new EventStoreError(`Failed to parse event at index ${row.seq}`, sessionId, error)
+		}
+	}
+
+	/**
+	 * Null rather than a throw, matching `FileEventStore`: one unreadable row must
+	 * not take out the listing every other session appears in.
+	 */
+	#decodeMetadata(sessionId: SessionId, raw: string): SessionMetadata | null {
+		let parsed: unknown
+		try {
+			parsed = JSON.parse(raw)
+		} catch (error) {
+			return this.#skip(sessionId, String(error))
+		}
+
+		const result = sessionMetadataSchema.safeParse(parsed)
+		return result.success ? result.data : this.#skip(sessionId, result.error.message)
+	}
+}