@effect-agent/storage-sqlite 0.1.0-beta.40 → 0.1.0-beta.42

package/dist/index.mjs

@@ -4,7 +4,7 @@ import { Clock, Context, Crypto, DateTime, Duration, Effect, Exit, Layer, Option
 import { SqliteClient, SqliteMigrator } from "@effect/sql-sqlite-node";
 import * as SqlClient from "effect/unstable/sql/SqlClient";
 import { NodeCrypto } from "@effect/platform-node";
-import { MemoryDocument, MemoryKey, MemoryMutationFailpoint, MemoryNamespaceAddress, MemoryOperationConflict, MemoryReader, MemoryStorageError, MemoryWrite, MemoryWriter, applyMemoryWrite } from "@effect-agent/core";
+import { memoryReaderLayer, memoryStoreLayer, memoryStoreLayerWithFailpoints } from "@effect-agent/thread/sql-memory";
 //#region src/errors.ts
 /** The SQLite file uses a private-development format this adapter cannot read. */
 var SqliteStorageCompatibilityError = class extends Schema.TaggedError()("SqliteStorageCompatibilityError", {
@@ -419,10 +419,10 @@ const sqliteMigrations = SqliteMigrator.fromRecord({ "1_current_thread_storage":
 }) });
 //#endregion
 //#region src/sqlite-activity-store.ts
-const STORAGE_VERSION$1 = 1;
-const METADATA_COMPONENT$1 = "activity";
+const STORAGE_VERSION = 1;
+const METADATA_COMPONENT = "activity";
 const STATE_TABLE = "effect_agent_activity_processor_state_v1";
-const StoredJson$2 = Schema.String.check(Schema.isMaxLength(16777216));
+const StoredJson$1 = Schema.String.check(Schema.isMaxLength(16777216));
 const sameKey = Schema.toEquivalence(ActivityProcessorKey);
 const sameWork = Schema.toEquivalence(PreparedActivity);
 var ActivityMetadataRow = class extends Schema.Class("@effect-agent/storage-sqlite/ActivityMetadataRow")({ version: Schema.Int }) {};
@@ -436,26 +436,26 @@ var ActivityStateRow = class extends Schema.Class("@effect-agent/storage-sqlite/
 	epoch: ActivityProgress.fields.epoch,
 	owner: ActivityProgress.fields.owner,
 	lease_expires_at: ActivityProgress.fields.leaseExpiresAt,
-	progress_json: StoredJson$2
+	progress_json: StoredJson$1
 }) {};
 var ActivityChangeCountRow = class extends Schema.Class("@effect-agent/storage-sqlite/ActivityChangeCountRow")({ changed: Schema.Int }) {};
-const StoredVersionHeader$1 = Schema.Struct({ version: Schema.Int });
+const StoredVersionHeader = Schema.Struct({ version: Schema.Int });
 const storeError$1 = (operation, reason = "unavailable") => ActivityStoreError.make({
 	operation,
 	reason
 });
-const query$1 = (effect, operation) => effect.pipe(Effect.mapError(() => storeError$1(operation)));
-const decodeRows$4 = Effect.fn("SqliteActivityStore.decodeRows")(function* (schema, rows, operation) {
+const query = (effect, operation) => effect.pipe(Effect.mapError(() => storeError$1(operation)));
+const decodeRows$3 = Effect.fn("SqliteActivityStore.decodeRows")(function* (schema, rows, operation) {
 	return yield* Schema.decodeUnknownEffect(Schema.Array(schema))(rows).pipe(Effect.mapError(() => storeError$1(operation, "corrupt")));
 });
-const decodeInput$2 = Effect.fn("SqliteActivityStore.decodeInput")(function* (schema, value, operation) {
+const decodeInput$1 = Effect.fn("SqliteActivityStore.decodeInput")(function* (schema, value, operation) {
 	return yield* Schema.decodeUnknownEffect(schema)(value).pipe(Effect.mapError(() => storeError$1(operation, "invalid-input")));
 });
 const encodeProgress = Effect.fn("SqliteActivityStore.encodeProgress")(function* (progress, operation) {
-	return yield* Schema.encodeEffect(Schema.fromJsonString(ActivityProgress))(progress).pipe(Effect.mapError(() => storeError$1(operation, "corrupt")), Effect.flatMap((encoded) => Schema.decodeEffect(StoredJson$2)(encoded).pipe(Effect.mapError(() => storeError$1(operation, "invalid-input")))));
+	return yield* Schema.encodeEffect(Schema.fromJsonString(ActivityProgress))(progress).pipe(Effect.mapError(() => storeError$1(operation, "corrupt")), Effect.flatMap((encoded) => Schema.decodeEffect(StoredJson$1)(encoded).pipe(Effect.mapError(() => storeError$1(operation, "invalid-input")))));
 });
 const decodeProgress = Effect.fn("SqliteActivityStore.decodeProgress")(function* (value, operation) {
-	if ((yield* Schema.decodeEffect(Schema.fromJsonString(StoredVersionHeader$1))(value).pipe(Effect.mapError(() => storeError$1(operation, "corrupt")))).version !== STORAGE_VERSION$1) return yield* storeError$1(operation, "incompatible");
+	if ((yield* Schema.decodeEffect(Schema.fromJsonString(StoredVersionHeader))(value).pipe(Effect.mapError(() => storeError$1(operation, "corrupt")))).version !== STORAGE_VERSION) return yield* storeError$1(operation, "incompatible");
 	const progress = yield* Schema.decodeEffect(Schema.fromJsonString(ActivityProgress))(value).pipe(Effect.mapError(() => storeError$1(operation, "corrupt")));
 	if ((yield* encodeProgress(progress, operation)) !== value) return yield* storeError$1(operation, "corrupt");
 	return progress;
@@ -490,18 +490,18 @@ const makeActivityStore = Effect.fn("SqliteActivityStore.make")(function* () {
         `;
 		const metadataRows = yield* sql`
           SELECT version FROM effect_agent_activity_metadata
-          WHERE component = ${METADATA_COMPONENT$1}
+          WHERE component = ${METADATA_COMPONENT}
         `;
-		const metadata = yield* decodeRows$4(ActivityMetadataRow, metadataRows, "decode activity schema version");
+		const metadata = yield* decodeRows$3(ActivityMetadataRow, metadataRows, "decode activity schema version");
 		if (metadata.length > 1) return yield* storeError$1("decode activity schema version", "corrupt");
 		const currentVersion = metadata[0]?.version;
-		if (currentVersion !== void 0 && currentVersion !== STORAGE_VERSION$1) return yield* storeError$1("initialize activity schema", "incompatible");
+		if (currentVersion !== void 0 && currentVersion !== STORAGE_VERSION) return yield* storeError$1("initialize activity schema", "incompatible");
 		if (currentVersion === void 0) {
 			const tableRows = yield* sql`
             SELECT name FROM sqlite_master
             WHERE type = 'table' AND name = ${STATE_TABLE}
           `;
-			if ((yield* decodeRows$4(ActivityTableRow, tableRows, "inspect activity schema")).length > 0) return yield* storeError$1("initialize activity schema", "incompatible");
+			if ((yield* decodeRows$3(ActivityTableRow, tableRows, "inspect activity schema")).length > 0) return yield* storeError$1("initialize activity schema", "incompatible");
 			yield* sql`
             CREATE TABLE effect_agent_activity_processor_state_v1 (
               processor_id TEXT NOT NULL,
@@ -518,7 +518,7 @@ const makeActivityStore = Effect.fn("SqliteActivityStore.make")(function* () {
           `;
 			yield* sql`
             INSERT INTO effect_agent_activity_metadata (component, version)
-            VALUES (${METADATA_COMPONENT$1}, ${STORAGE_VERSION$1})
+            VALUES (${METADATA_COMPONENT}, ${STORAGE_VERSION})
           `;
 		}
 		yield* sql`
@@ -530,7 +530,7 @@ const makeActivityStore = Effect.fn("SqliteActivityStore.make")(function* () {
 	})).pipe(Effect.catchTag("SqlError", () => Effect.fail(storeError$1("initialize activity schema"))));
 	yield* failpoint.hit("activity:initialize:after");
 	const readProgress = Effect.fn("SqliteActivityStore.readProgress")(function* (key, operation) {
-		const rawRows = yield* query$1(sql`
+		const rawRows = yield* query(sql`
         SELECT processor_id, processor_version, thread_id, format_version,
           through_sequence, epoch, owner, lease_expires_at, progress_json
         FROM effect_agent_activity_processor_state_v1
@@ -538,19 +538,19 @@ const makeActivityStore = Effect.fn("SqliteActivityStore.make")(function* () {
           AND processor_version = ${key.processorVersion}
           AND thread_id = ${key.threadId}
       `, operation);
-		const rows = yield* decodeRows$4(ActivityStateRow, rawRows, operation);
+		const rows = yield* decodeRows$3(ActivityStateRow, rawRows, operation);
 		if (rows.length === 0) return null;
 		if (rows.length !== 1) return yield* storeError$1(operation, "corrupt");
 		const row = rows[0];
-		if (row.format_version !== STORAGE_VERSION$1) return yield* storeError$1(operation, "incompatible");
+		if (row.format_version !== STORAGE_VERSION) return yield* storeError$1(operation, "incompatible");
 		const progress = yield* decodeProgress(row.progress_json, operation);
 		yield* validateProgress(progress, operation);
 		if (!sameKey(progress.key, key) || row.processor_id !== key.processorId || row.processor_version !== key.processorVersion || row.thread_id !== key.threadId || row.through_sequence !== progress.throughSequence || row.epoch !== progress.epoch || row.owner !== progress.owner || row.lease_expires_at !== progress.leaseExpiresAt) return yield* storeError$1(operation, "corrupt");
 		return progress;
 	});
 	const checkChanged = Effect.fn("SqliteActivityStore.checkChanged")(function* (operation) {
-		const rawRows = yield* query$1(sql`SELECT changes() AS changed`, operation);
-		const rows = yield* decodeRows$4(ActivityChangeCountRow, rawRows, operation);
+		const rawRows = yield* query(sql`SELECT changes() AS changed`, operation);
+		const rows = yield* decodeRows$3(ActivityChangeCountRow, rawRows, operation);
 		if (rows.length !== 1 || rows[0].changed !== 1) return yield* storeError$1(operation, "corrupt");
 	});
 	const insertProgress = Effect.fn("SqliteActivityStore.insertProgress")(function* (progress, operation) {
@@ -561,7 +561,7 @@ const makeActivityStore = Effect.fn("SqliteActivityStore.make")(function* () {
         epoch, owner, lease_expires_at, progress_json
       ) VALUES (
         ${progress.key.processorId}, ${progress.key.processorVersion}, ${progress.key.threadId},
-        ${STORAGE_VERSION$1}, ${progress.throughSequence}, ${progress.epoch}, ${progress.owner},
+        ${STORAGE_VERSION}, ${progress.throughSequence}, ${progress.epoch}, ${progress.owner},
         ${progress.leaseExpiresAt}, ${progressJson}
       )
     `;
@@ -571,7 +571,7 @@ const makeActivityStore = Effect.fn("SqliteActivityStore.make")(function* () {
 		const progressJson = yield* encodeProgress(next, operation);
 		yield* sql`
       UPDATE effect_agent_activity_processor_state_v1
-      SET format_version = ${STORAGE_VERSION$1},
+      SET format_version = ${STORAGE_VERSION},
           through_sequence = ${next.throughSequence},
           epoch = ${next.epoch},
           owner = ${next.owner},
@@ -591,12 +591,12 @@ const makeActivityStore = Effect.fn("SqliteActivityStore.make")(function* () {
 		return progress;
 	});
 	const inspect = Effect.fn("SqliteActivityStore.inspect")(function* (key) {
-		const decodedKey = yield* decodeInput$2(ActivityProcessorKey, key, "inspect activity progress");
+		const decodedKey = yield* decodeInput$1(ActivityProcessorKey, key, "inspect activity progress");
 		return yield* readProgress(decodedKey, "inspect activity progress");
 	});
 	const claim = Effect.fn("SqliteActivityStore.claim")(function* (request) {
 		const operation = "claim activity progress";
-		const decoded = yield* decodeInput$2(ActivityClaimRequest, request, operation);
+		const decoded = yield* decodeInput$1(ActivityClaimRequest, request, operation);
 		yield* failpoint.hit("activity:claim:before");
 		const claimed = yield* sql.withTransaction(Effect.gen(function* () {
 			const current = yield* readProgress(decoded.key, operation);
@@ -606,7 +606,7 @@ const makeActivityStore = Effect.fn("SqliteActivityStore.make")(function* () {
 				leaseExpiresAt: current.leaseExpiresAt
 			});
 			const next = yield* Schema.decodeUnknownEffect(ActivityProgress)({
-				version: STORAGE_VERSION$1,
+				version: STORAGE_VERSION,
 				key: decoded.key,
 				throughSequence: current?.throughSequence ?? 0,
 				epoch: (current?.epoch ?? 0) + 1,
@@ -627,8 +627,8 @@ const makeActivityStore = Effect.fn("SqliteActivityStore.make")(function* () {
 	});
 	const prepare = Effect.fn("SqliteActivityStore.prepare")(function* (request) {
 		const operation = "prepare activity output";
-		const claim = yield* decodeInput$2(ActivityClaim, request.claim, operation);
-		const work = yield* decodeInput$2(PreparedActivity, request.work, operation);
+		const claim = yield* decodeInput$1(ActivityClaim, request.claim, operation);
+		const work = yield* decodeInput$1(PreparedActivity, request.work, operation);
 		yield* failpoint.hit("activity:prepare:before");
 		const result = yield* sql.withTransaction(Effect.gen(function* () {
 			const current = yield* requireLive(yield* readProgress(claim.key, operation), claim, true);
@@ -662,8 +662,8 @@ const makeActivityStore = Effect.fn("SqliteActivityStore.make")(function* () {
 	});
 	const advance = Effect.fn("SqliteActivityStore.advance")(function* (request) {
 		const operation = "advance activity progress";
-		const claim = yield* decodeInput$2(ActivityClaim, request.claim, operation);
-		const workId = yield* decodeInput$2(Digest, request.workId, operation);
+		const claim = yield* decodeInput$1(ActivityClaim, request.claim, operation);
+		const workId = yield* decodeInput$1(Digest, request.workId, operation);
 		yield* failpoint.hit("activity:advance:before");
 		const nextClaim = yield* sql.withTransaction(Effect.gen(function* () {
 			const current = yield* requireLive(yield* readProgress(claim.key, operation), claim, true);
@@ -688,7 +688,7 @@ const makeActivityStore = Effect.fn("SqliteActivityStore.make")(function* () {
 	});
 	const release = Effect.fn("SqliteActivityStore.release")(function* (claim) {
 		const operation = "release activity claim";
-		const decoded = yield* decodeInput$2(ActivityClaim, claim, operation);
+		const decoded = yield* decodeInput$1(ActivityClaim, claim, operation);
 		yield* failpoint.hit("activity:release:before");
 		yield* sql.withTransaction(Effect.gen(function* () {
 			const current = yield* readProgress(decoded.key, operation);
@@ -824,19 +824,19 @@ var RawThreadExport = class extends Schema.Class("@effect-agent/storage-sqlite/R
 	thread: ThreadRow,
 	records: Schema.Array(RecordRow)
 }) {};
-const storageError$1 = (operation) => (error) => SqliteStorageError.make({
+const storageError = (operation) => (error) => SqliteStorageError.make({
 	cause: error,
 	operation,
 	message: error.message
 });
 /** Decode raw SQLite rows against a Schema, reporting failures as typed corruption. */
-const decodeRows$3 = Effect.fn("SqliteJournal.decodeRows")((schema, table, rowKey, rows) => Schema.decodeUnknownEffect(schema)(rows).pipe(Effect.mapError((error) => SqliteStorageCorruptionError.make({
+const decodeRows$2 = Effect.fn("SqliteJournal.decodeRows")((schema, table, rowKey, rows) => Schema.decodeUnknownEffect(schema)(rows).pipe(Effect.mapError((error) => SqliteStorageCorruptionError.make({
 	table,
 	rowKey,
 	message: String(error)
 }))));
 /** Decode exactly one raw SQLite row against a Schema, reporting failures as typed corruption. */
-const decodeSingleRow = Effect.fn("SqliteJournal.decodeSingleRow")((schema, table, rowKey, rows) => decodeRows$3(schema, table, rowKey, rows).pipe(Effect.flatMap((decoded) => decoded.length === 1 ? Effect.succeed(decoded[0]) : Effect.fail(SqliteStorageCorruptionError.make({
+const decodeSingleRow = Effect.fn("SqliteJournal.decodeSingleRow")((schema, table, rowKey, rows) => decodeRows$2(schema, table, rowKey, rows).pipe(Effect.flatMap((decoded) => decoded.length === 1 ? Effect.succeed(decoded[0]) : Effect.fail(SqliteStorageCorruptionError.make({
 	table,
 	rowKey,
 	message: `Expected exactly one row but found ${decoded.length}.`
@@ -845,16 +845,16 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
 	const sql = yield* SqlClient.SqlClient;
 	const { hit: failpoint } = yield* SqliteStorageFailpoint;
 	const { busyTimeout } = yield* SqliteStorageConfig;
-	yield* sql`PRAGMA foreign_keys = ON`.pipe(Effect.mapError(storageError$1("enable foreign keys")));
-	yield* sql.unsafe(`PRAGMA busy_timeout = ${busyTimeout}`).pipe(Effect.mapError(storageError$1("configure busy timeout")));
-	const journalModeRows = yield* sql`PRAGMA journal_mode`.pipe(Effect.mapError(storageError$1("read journal mode")));
+	yield* sql`PRAGMA foreign_keys = ON`.pipe(Effect.mapError(storageError("enable foreign keys")));
+	yield* sql.unsafe(`PRAGMA busy_timeout = ${busyTimeout}`).pipe(Effect.mapError(storageError("configure busy timeout")));
+	const journalModeRows = yield* sql`PRAGMA journal_mode`.pipe(Effect.mapError(storageError("read journal mode")));
 	const journalMode = yield* decodeSingleRow(Schema.Array(SqliteJournalModeRow), "pragma_journal_mode", "singleton", journalModeRows);
 	if (journalMode.journal_mode.toLowerCase() !== "wal") return yield* SqliteStorageCompatibilityError.make({
 		actualVersion: 0,
 		supportedVersion: 7,
 		message: `SQLite WAL mode is required; the database reported ${journalMode.journal_mode}.`
 	});
-	const versionRows = yield* sql`PRAGMA user_version`.pipe(Effect.mapError(storageError$1("read storage version")));
+	const versionRows = yield* sql`PRAGMA user_version`.pipe(Effect.mapError(storageError("read storage version")));
 	const version = yield* decodeSingleRow(Schema.Array(SqliteVersionRow), "pragma_user_version", "singleton", versionRows);
 	if (version.user_version !== 0 && version.user_version !== 7) return yield* SqliteStorageCompatibilityError.make({
 		actualVersion: version.user_version,
@@ -868,8 +868,8 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
       WHERE type = 'table'
         AND name LIKE 'effect_agent_%'
       ORDER BY name
-    `.pipe(Effect.mapError(storageError$1("inspect unversioned storage")));
-		if ((yield* decodeRows$3(Schema.Array(SqliteNameRow), "sqlite_master", "effect_agent_%", existingRows)).length > 0) return yield* SqliteStorageCompatibilityError.make({
+    `.pipe(Effect.mapError(storageError("inspect unversioned storage")));
+		if ((yield* decodeRows$2(Schema.Array(SqliteNameRow), "sqlite_master", "effect_agent_%", existingRows)).length > 0) return yield* SqliteStorageCompatibilityError.make({
 			actualVersion: 0,
 			supportedVersion: 7,
 			message: "The SQLite file contains unversioned Effect Agent tables. Reset it explicitly; refusing to mutate ambiguous stored data."
@@ -899,8 +899,8 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
         'effect_agent_schedules'
       )
     ORDER BY name
-  `.pipe(Effect.mapError(storageError$1("verify storage tables")));
-	if ((yield* decodeRows$3(Schema.Array(SqliteNameRow), "sqlite_master", "required_tables", requiredRows)).length !== 12) return yield* SqliteStorageCompatibilityError.make({
+  `.pipe(Effect.mapError(storageError("verify storage tables")));
+	if ((yield* decodeRows$2(Schema.Array(SqliteNameRow), "sqlite_master", "required_tables", requiredRows)).length !== 12) return yield* SqliteStorageCompatibilityError.make({
 		actualVersion: 7,
 		supportedVersion: 7,
 		message: "The SQLite file claims the current format but is missing required tables. Reset the corrupt private-development data."
@@ -909,7 +909,7 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
 		cause: error,
 		operation,
 		message: `Another producer holds the SQLite write lock; ${operation} is safe to retry.`
-	}) : storageError$1(operation)(error);
+	}) : storageError(operation)(error);
 	/**
 	* Runs one journal write transaction under `BEGIN IMMEDIATE`. SQLite's deferred `BEGIN`
 	* would let a read-then-write transaction start as a reader and fail with
@@ -942,11 +942,11 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
 	* `BEGIN` is reported directly because there is no transaction to roll back.
 	*/
 	const withReadTransaction = (operation) => (effect) => Effect.uninterruptibleMask((restore) => Effect.scoped(Effect.gen(function* () {
-		const connection = yield* sql.reserve.pipe(Effect.mapError(storageError$1(operation)));
-		yield* connection.executeUnprepared("BEGIN", [], void 0).pipe(Effect.mapError(storageError$1(operation)));
+		const connection = yield* sql.reserve.pipe(Effect.mapError(storageError(operation)));
+		yield* connection.executeUnprepared("BEGIN", [], void 0).pipe(Effect.mapError(storageError(operation)));
 		const exit = yield* restore(Effect.provideService(effect, sql.transactionService, [connection, 0])).pipe(Effect.exit);
 		if (Exit.isSuccess(exit)) {
-			yield* connection.executeUnprepared("COMMIT", [], void 0).pipe(Effect.mapError(storageError$1(operation)));
+			yield* connection.executeUnprepared("COMMIT", [], void 0).pipe(Effect.mapError(storageError(operation)));
 			return exit.value;
 		}
 		yield* Effect.orDie(connection.executeUnprepared("ROLLBACK", [], void 0));
@@ -967,8 +967,8 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
             producer_epoch
           FROM effect_agent_threads
           WHERE thread_id = ${threadId}
-        `.pipe(Effect.mapError(storageError$1("read materialized thread")));
-			const existing = yield* decodeRows$3(Schema.Array(ThreadRow), "effect_agent_threads", threadId, existingRows);
+        `.pipe(Effect.mapError(storageError("read materialized thread")));
+			const existing = yield* decodeRows$2(Schema.Array(ThreadRow), "effect_agent_threads", threadId, existingRows);
 			if (existing.length > 1) return yield* SqliteStorageCorruptionError.make({
 				table: "effect_agent_threads",
 				rowKey: threadId,
@@ -989,7 +989,7 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
               ${emptyTailDigest},
               ${producerEpoch}
             )
-          `.pipe(Effect.mapError(storageError$1("materialize thread")));
+          `.pipe(Effect.mapError(storageError("materialize thread")));
 				return;
 			}
 			if (producerEpoch < existing[0].producer_epoch) return yield* SqliteFenceRejected.make({
@@ -1001,7 +1001,7 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
             UPDATE effect_agent_threads
             SET producer_epoch = ${producerEpoch}
             WHERE thread_id = ${threadId}
-          `.pipe(Effect.mapError(storageError$1("advance materialization epoch")));
+          `.pipe(Effect.mapError(storageError("advance materialization epoch")));
 		}));
 	});
 	const getThread = Effect.fn("SqliteJournal.getThread")(function* (threadId) {
@@ -1014,8 +1014,8 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
         producer_epoch
       FROM effect_agent_threads
       WHERE thread_id = ${threadId}
-    `.pipe(Effect.mapError(storageError$1("read thread")));
-		return yield* decodeRows$3(Schema.Array(ThreadRow), "effect_agent_threads", threadId, rows);
+    `.pipe(Effect.mapError(storageError("read thread")));
+		return yield* decodeRows$2(Schema.Array(ThreadRow), "effect_agent_threads", threadId, rows);
 	});
 	const append = Effect.fn("SqliteJournal.append")(function* (request) {
 		if (request.threadId.length > MAX_IDENTIFIER_LENGTH || request.batchId.length > MAX_IDENTIFIER_LENGTH || storedTextBytes(request.batchJson) > MAX_STORED_TEXT_BYTES || storedTextBytes(request.batchDigest) > MAX_STORED_TEXT_BYTES || storedTextBytes(request.tailDigest) > MAX_STORED_TEXT_BYTES || request.records.some((record) => record.recordId.length > MAX_IDENTIFIER_LENGTH || storedTextBytes(record.recordJson) > MAX_STORED_TEXT_BYTES)) return yield* SqliteStorageError.make({
@@ -1037,7 +1037,7 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
             producer_epoch
           FROM effect_agent_threads
           WHERE thread_id = ${request.threadId}
-        `.pipe(Effect.mapError(storageError$1("read append tail")));
+        `.pipe(Effect.mapError(storageError("read append tail")));
 			const thread = yield* decodeSingleRow(Schema.Array(ThreadRow), "effect_agent_threads", request.threadId, threadRows);
 			if (request.producerEpoch !== thread.producer_epoch) return yield* SqliteFenceRejected.make({
 				producerEpoch: request.producerEpoch,
@@ -1056,8 +1056,8 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
           FROM effect_agent_canonical_batches
           WHERE thread_id = ${request.threadId}
             AND batch_id = ${request.batchId}
-        `.pipe(Effect.mapError(storageError$1("read idempotent batch")));
-			const batches = yield* decodeRows$3(Schema.Array(BatchRow), "effect_agent_canonical_batches", `${request.threadId}/${request.batchId}`, batchRows);
+        `.pipe(Effect.mapError(storageError("read idempotent batch")));
+			const batches = yield* decodeRows$2(Schema.Array(BatchRow), "effect_agent_canonical_batches", `${request.threadId}/${request.batchId}`, batchRows);
 			if (batches.length > 1) return yield* SqliteStorageCorruptionError.make({
 				table: "effect_agent_canonical_batches",
 				rowKey: `${request.threadId}/${request.batchId}`,
@@ -1097,8 +1097,8 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
           WHERE thread_id = ${request.threadId}
             AND record_id IN ${sql.in(recordIds)}
           ORDER BY sequence
-        `.pipe(Effect.mapError(storageError$1("check canonical record identities")));
-			const existingRecords = yield* decodeRows$3(Schema.Array(RecordRow), "effect_agent_canonical_records", `${request.threadId}/record_ids`, existingRecordRows);
+        `.pipe(Effect.mapError(storageError("check canonical record identities")));
+			const existingRecords = yield* decodeRows$2(Schema.Array(RecordRow), "effect_agent_canonical_records", `${request.threadId}/record_ids`, existingRecordRows);
 			if (existingRecords.length > 0) return yield* SqliteAppendConflict.make({
 				message: `Canonical record ID ${existingRecords[0].record_id} already exists.`,
 				reason: "record-identity"
@@ -1131,7 +1131,7 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
             ${request.tailDigest},
             ${request.batchJson}
           )
-        `.pipe(Effect.mapError(storageError$1("insert canonical batch")));
+        `.pipe(Effect.mapError(storageError("insert canonical batch")));
 			yield* failpoint("append:after-batch-insert");
 			yield* Effect.forEach(request.records, (record, index) => Effect.gen(function* () {
 				yield* sql`
@@ -1148,7 +1148,7 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
                     ${request.batchId},
                     ${record.recordJson}
                   )
-                `.pipe(Effect.mapError(storageError$1("insert canonical record")));
+                `.pipe(Effect.mapError(storageError("insert canonical record")));
 				yield* failpoint("append:after-record-insert");
 			}), { discard: true });
 			yield* sql`
@@ -1158,7 +1158,7 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
             tail_digest = ${request.tailDigest},
             producer_epoch = ${request.producerEpoch}
           WHERE thread_id = ${request.threadId}
-        `.pipe(Effect.mapError(storageError$1("advance thread tail")));
+        `.pipe(Effect.mapError(storageError("advance thread tail")));
 			yield* failpoint("append:after-tail-update");
 			return RawAppendResult.make({
 				firstSequence,
@@ -1181,8 +1181,8 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
         AND sequence > ${request.fromSequenceExclusive}
       ORDER BY sequence
       LIMIT ${request.limit}
-    `.pipe(Effect.mapError(storageError$1("read canonical records")));
-		return yield* decodeRows$3(Schema.Array(RecordRow), "effect_agent_canonical_records", `${request.threadId}>${request.fromSequenceExclusive}`, rows);
+    `.pipe(Effect.mapError(storageError("read canonical records")));
+		return yield* decodeRows$2(Schema.Array(RecordRow), "effect_agent_canonical_records", `${request.threadId}>${request.fromSequenceExclusive}`, rows);
 	});
 	const exportThread = Effect.fn("SqliteJournal.exportThread")(function* (threadId) {
 		return yield* withReadTransaction("export transaction")(Effect.gen(function* () {
@@ -1195,7 +1195,7 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
               producer_epoch
             FROM effect_agent_threads
             WHERE thread_id = ${threadId}
-          `.pipe(Effect.mapError(storageError$1("export thread")));
+          `.pipe(Effect.mapError(storageError("export thread")));
 			const thread = yield* decodeSingleRow(Schema.Array(ThreadRow), "effect_agent_threads", threadId, threadRows);
 			yield* failpoint("export:after-thread-read");
 			const batchRows = yield* sql`
@@ -1210,7 +1210,7 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
             FROM effect_agent_canonical_batches
             WHERE thread_id = ${threadId}
             ORDER BY first_sequence
-          `.pipe(Effect.mapError(storageError$1("export canonical batches")));
+          `.pipe(Effect.mapError(storageError("export canonical batches")));
 			const recordRows = yield* sql`
             SELECT
               thread_id,
@@ -1221,7 +1221,7 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
             FROM effect_agent_canonical_records
             WHERE thread_id = ${threadId}
             ORDER BY sequence
-          `.pipe(Effect.mapError(storageError$1("export canonical records")));
+          `.pipe(Effect.mapError(storageError("export canonical records")));
 			const checkpointRows = yield* sql`
             SELECT
               thread_id,
@@ -1231,12 +1231,12 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
             FROM effect_agent_checkpoints
             WHERE thread_id = ${threadId}
             ORDER BY through_sequence
-          `.pipe(Effect.mapError(storageError$1("export checkpoints")));
+          `.pipe(Effect.mapError(storageError("export checkpoints")));
 			return RawThreadExport.make({
 				thread,
-				batches: yield* decodeRows$3(Schema.Array(BatchRow), "effect_agent_canonical_batches", threadId, batchRows),
-				records: yield* decodeRows$3(Schema.Array(RecordRow), "effect_agent_canonical_records", threadId, recordRows),
-				checkpoints: yield* decodeRows$3(Schema.Array(CheckpointRow), "effect_agent_checkpoints", threadId, checkpointRows)
+				batches: yield* decodeRows$2(Schema.Array(BatchRow), "effect_agent_canonical_batches", threadId, batchRows),
+				records: yield* decodeRows$2(Schema.Array(RecordRow), "effect_agent_canonical_records", threadId, recordRows),
+				checkpoints: yield* decodeRows$2(Schema.Array(CheckpointRow), "effect_agent_checkpoints", threadId, checkpointRows)
 			});
 		}));
 	});
@@ -1255,7 +1255,7 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
             producer_epoch
           FROM effect_agent_threads
           WHERE thread_id = ${checkpoint.threadId}
-        `.pipe(Effect.mapError(storageError$1("read checkpoint tail")));
+        `.pipe(Effect.mapError(storageError("read checkpoint tail")));
 			const thread = yield* decodeSingleRow(Schema.Array(ThreadRow), "effect_agent_threads", checkpoint.threadId, threadRows);
 			if (checkpoint.throughSequence > thread.tail_sequence) return yield* SqliteCheckpointConflict.make({ message: `Checkpoint sequence ${checkpoint.throughSequence} is after canonical tail ${thread.tail_sequence}.` });
 			const checkpointRows = yield* sql`
@@ -1267,8 +1267,8 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
           FROM effect_agent_checkpoints
           WHERE thread_id = ${checkpoint.threadId}
             AND through_sequence = ${checkpoint.throughSequence}
-        `.pipe(Effect.mapError(storageError$1("read idempotent checkpoint")));
-			const existing = yield* decodeRows$3(Schema.Array(CheckpointRow), "effect_agent_checkpoints", `${checkpoint.threadId}/${checkpoint.throughSequence}`, checkpointRows);
+        `.pipe(Effect.mapError(storageError("read idempotent checkpoint")));
+			const existing = yield* decodeRows$2(Schema.Array(CheckpointRow), "effect_agent_checkpoints", `${checkpoint.threadId}/${checkpoint.throughSequence}`, checkpointRows);
 			if (existing.length > 1) return yield* SqliteStorageCorruptionError.make({
 				table: "effect_agent_checkpoints",
 				rowKey: `${checkpoint.threadId}/${checkpoint.throughSequence}`,
@@ -1290,7 +1290,7 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
             ${checkpoint.tailDigest},
             ${checkpoint.checkpointJson}
           )
-        `.pipe(Effect.mapError(storageError$1("insert checkpoint")));
+        `.pipe(Effect.mapError(storageError("insert checkpoint")));
 		}));
 	});
 	const loadCheckpoint = Effect.fn("SqliteJournal.loadCheckpoint")(function* (threadId, atOrBeforeSequence) {
@@ -1305,8 +1305,8 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
         AND through_sequence <= ${atOrBeforeSequence}
       ORDER BY through_sequence DESC
       LIMIT 1
-    `.pipe(Effect.mapError(storageError$1("load checkpoint")));
-		return yield* decodeRows$3(Schema.Array(CheckpointRow), "effect_agent_checkpoints", `${threadId}<=${atOrBeforeSequence}`, rows);
+    `.pipe(Effect.mapError(storageError("load checkpoint")));
+		return yield* decodeRows$2(Schema.Array(CheckpointRow), "effect_agent_checkpoints", `${threadId}<=${atOrBeforeSequence}`, rows);
 	});
 	return {
 		append,
@@ -1329,8 +1329,8 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
       FROM effect_agent_canonical_batches
       WHERE thread_id = ${threadId}
         AND last_sequence = ${sequence}
-    `.pipe(Effect.mapError(storageError$1("read canonical digest at sequence")));
-			return (yield* decodeRows$3(Schema.Array(BatchRow), "effect_agent_canonical_batches", `${threadId}/${sequence}`, rows)).map((batch) => batch.tail_digest);
+    `.pipe(Effect.mapError(storageError("read canonical digest at sequence")));
+			return (yield* decodeRows$2(Schema.Array(BatchRow), "effect_agent_canonical_batches", `${threadId}/${sequence}`, rows)).map((batch) => batch.tail_digest);
 		}),
 		loadCheckpoint,
 		materialize,
@@ -1347,7 +1347,7 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
               producer_epoch
             FROM effect_agent_threads
             ORDER BY thread_id
-          `.pipe(Effect.mapError(storageError$1("scan threads")));
+          `.pipe(Effect.mapError(storageError("scan threads")));
 				const batches = yield* sql`
             SELECT
               thread_id,
@@ -1359,7 +1359,7 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
               batch_json
             FROM effect_agent_canonical_batches
             ORDER BY thread_id, first_sequence
-          `.pipe(Effect.mapError(storageError$1("scan canonical batches")));
+          `.pipe(Effect.mapError(storageError("scan canonical batches")));
 				const records = yield* sql`
             SELECT
               thread_id,
@@ -1369,7 +1369,7 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
               record_json
             FROM effect_agent_canonical_records
             ORDER BY thread_id, sequence
-          `.pipe(Effect.mapError(storageError$1("scan canonical records")));
+          `.pipe(Effect.mapError(storageError("scan canonical records")));
 				const checkpoints = yield* sql`
             SELECT
               thread_id,
@@ -1378,12 +1378,12 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
               checkpoint_json
             FROM effect_agent_checkpoints
             ORDER BY thread_id, through_sequence
-          `.pipe(Effect.mapError(storageError$1("scan checkpoints")));
+          `.pipe(Effect.mapError(storageError("scan checkpoints")));
 				return {
-					threads: yield* decodeRows$3(Schema.Array(ThreadRow), "effect_agent_threads", "startup_scan", threads),
-					batches: yield* decodeRows$3(Schema.Array(BatchRow), "effect_agent_canonical_batches", "startup_scan", batches),
-					records: yield* decodeRows$3(Schema.Array(RecordRow), "effect_agent_canonical_records", "startup_scan", records),
-					checkpoints: yield* decodeRows$3(Schema.Array(CheckpointRow), "effect_agent_checkpoints", "startup_scan", checkpoints)
+					threads: yield* decodeRows$2(Schema.Array(ThreadRow), "effect_agent_threads", "startup_scan", threads),
+					batches: yield* decodeRows$2(Schema.Array(BatchRow), "effect_agent_canonical_batches", "startup_scan", batches),
+					records: yield* decodeRows$2(Schema.Array(RecordRow), "effect_agent_canonical_records", "startup_scan", records),
+					checkpoints: yield* decodeRows$2(Schema.Array(CheckpointRow), "effect_agent_checkpoints", "startup_scan", checkpoints)
 				};
 			}));
 		}),
@@ -2004,7 +2004,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
 		iso: new Date(millis).toISOString()
 	}));
 	const timestampMillis = (operation, rowKey) => (timestamp) => decodeUtcInstant(timestamp).pipe(Effect.map(DateTime.toEpochMillis), Effect.mapError((error) => corruptionFailure(operation, "effect_agent_submission_ownership", rowKey, error.message)));
-	const decodeSubmissionRows = (operation, rowKey, rows) => decodeRows$3(Schema.Array(SubmissionRow), "effect_agent_submissions", rowKey, rows).pipe(Effect.mapError(internalFailure(operation)));
+	const decodeSubmissionRows = (operation, rowKey, rows) => decodeRows$2(Schema.Array(SubmissionRow), "effect_agent_submissions", rowKey, rows).pipe(Effect.mapError(internalFailure(operation)));
 	const readSubmission = Effect.fn("SqliteSubmissionLedger.readSubmission")(function* (operation, submissionId) {
 		const rows = yield* sql`
       SELECT ${sql.literal(SUBMISSION_COLUMNS)}
@@ -2035,7 +2035,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
       FROM effect_agent_submission_ownership
       WHERE submission_id = ${submissionId}
     `.pipe(Effect.mapError(sqlFailure(operation)));
-		const decoded = yield* decodeRows$3(Schema.Array(OwnershipRow), "effect_agent_submission_ownership", submissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
+		const decoded = yield* decodeRows$2(Schema.Array(OwnershipRow), "effect_agent_submission_ownership", submissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
 		if (decoded.length > 1) return yield* corruptionFailure(operation, "effect_agent_submission_ownership", submissionId, "An ownership primary key returned more than one row.");
 		return decoded.length === 0 ? Option.none() : Option.some(decoded[0]);
 	});
@@ -2100,7 +2100,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
       FROM effect_agent_settlement_reservations
       WHERE submission_id = ${submissionId}
     `.pipe(Effect.mapError(sqlFailure(operation)));
-		const decoded = yield* decodeRows$3(Schema.Array(ReservationRow), "effect_agent_settlement_reservations", submissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
+		const decoded = yield* decodeRows$2(Schema.Array(ReservationRow), "effect_agent_settlement_reservations", submissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
 		if (decoded.length > 1) return yield* corruptionFailure(operation, "effect_agent_settlement_reservations", submissionId, "A settlement reservation primary key returned more than one row.");
 		return decoded.length === 0 ? Option.none() : Option.some(decoded[0]);
 	});
@@ -2115,11 +2115,11 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
       FROM effect_agent_abort_intents
       WHERE submission_id = ${submissionId}
     `.pipe(Effect.mapError(sqlFailure(operation)));
-		const decoded = yield* decodeRows$3(Schema.Array(AbortIntentRow), "effect_agent_abort_intents", submissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
+		const decoded = yield* decodeRows$2(Schema.Array(AbortIntentRow), "effect_agent_abort_intents", submissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
 		if (decoded.length > 1) return yield* corruptionFailure(operation, "effect_agent_abort_intents", submissionId, "An abort intent primary key returned more than one row.");
 		return decoded.length === 0 ? Option.none() : Option.some(decoded[0]);
 	});
-	const decodeChildReservationRows = (operation, rowKey, rows) => decodeRows$3(Schema.Array(ChildReservationRow), "effect_agent_child_reservations", rowKey, rows).pipe(Effect.mapError(internalFailure(operation)));
+	const decodeChildReservationRows = (operation, rowKey, rows) => decodeRows$2(Schema.Array(ChildReservationRow), "effect_agent_child_reservations", rowKey, rows).pipe(Effect.mapError(internalFailure(operation)));
 	const readChildReservation = Effect.fn("SqliteSubmissionLedger.readChildReservation")(function* (operation, reservationId) {
 		const rows = yield* sql`
       SELECT ${sql.literal(CHILD_RESERVATION_COLUMNS)}
@@ -2172,7 +2172,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
         WHERE submission_id = ${submissionId}
         ORDER BY tool_call_id ASC
       `.pipe(Effect.mapError(sqlFailure(operation)));
-		return yield* decodeRows$3(Schema.Array(ApprovalDecisionRow), "effect_agent_approval_decisions", submissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
+		return yield* decodeRows$2(Schema.Array(ApprovalDecisionRow), "effect_agent_approval_decisions", submissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
 	});
 	const approvalIntentFromRow = Effect.fn("SqliteSubmissionLedger.approvalIntentFromRow")(function* (operation, row) {
 		return yield* decodeApprovalDecisionIntent({
@@ -2197,7 +2197,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
         WHERE submission_id = ${submissionId}
         ORDER BY tool_call_id ASC
       `.pipe(Effect.mapError(sqlFailure(operation)));
-		return yield* decodeRows$3(Schema.Array(UnknownResolutionRow), "effect_agent_unknown_resolutions", submissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
+		return yield* decodeRows$2(Schema.Array(UnknownResolutionRow), "effect_agent_unknown_resolutions", submissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
 	});
 	const unknownResolutionIntentFromRow = Effect.fn("SqliteSubmissionLedger.unknownResolutionIntentFromRow")(function* (operation, row) {
 		const resolution = yield* parseStoredJsonText(row.resolution_json).pipe(Effect.mapError((error) => corruptionFailure(operation, "effect_agent_unknown_resolutions", `${row.submission_id}/${row.tool_call_id}`, error.message)));
@@ -2228,7 +2228,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
         WHERE thread_id = ${threadId}
           AND record_id = ${recordId}
       `.pipe(Effect.mapError(sqlFailure(operation)));
-		return (yield* decodeRows$3(Schema.Array(CanonicalRecordIdRow), "effect_agent_canonical_records", `${threadId}/${recordId}`, rows).pipe(Effect.mapError(internalFailure(operation)))).length === 0 ? void 0 : recordId;
+		return (yield* decodeRows$2(Schema.Array(CanonicalRecordIdRow), "effect_agent_canonical_records", `${threadId}/${recordId}`, rows).pipe(Effect.mapError(internalFailure(operation)))).length === 0 ? void 0 : recordId;
 	});
 	const abortIntentFromRow = Effect.fn("SqliteSubmissionLedger.abortIntentFromRow")(function* (operation, submission, submissionId, row) {
 		const canonicalRecordId = yield* canonicalAbortRecordId(operation, submission.thread_id, submissionId);
@@ -2282,7 +2282,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
             FROM effect_agent_submissions
             WHERE thread_id = ${validated.threadId}
           `.pipe(Effect.mapError(sqlFailure(operation)));
-			const decodedMax = yield* decodeRows$3(Schema.Array(MaxQueueSequenceRow), "effect_agent_submissions", validated.threadId, maxRows).pipe(Effect.mapError(internalFailure(operation)));
+			const decodedMax = yield* decodeRows$2(Schema.Array(MaxQueueSequenceRow), "effect_agent_submissions", validated.threadId, maxRows).pipe(Effect.mapError(internalFailure(operation)));
 			const queueSequence = yield* decodeQueueSequence((decodedMax[0]?.max_queue_sequence ?? 0) + 1).pipe(Effect.mapError(internalFailure(operation)));
 			const now = yield* currentInstant;
 			yield* sql`
@@ -3430,306 +3430,6 @@ const submissionLedgerLayer = Layer.effectContext(makeServices());
 */
 const ledgerLayer = (options) => Layer.unwrap(Effect.map(SqliteStorageConfig, (config) => submissionLedgerLayer.pipe(Layer.provide(Layer.mergeAll(Layer.succeed(SqliteStorageConfig)(config), storageFailpointLayer(options), SqliteClient.layer({ filename: options.filename }), NodeCrypto.layer))))).pipe(Layer.provide(storageConfigLayer(options)));
 //#endregion
-//#region src/sqlite-memory-store.ts
-const STORAGE_VERSION = 2;
-const METADATA_COMPONENT = "memory";
-const DOCUMENT_TABLE = "effect_agent_memory_documents_v1";
-const RECEIPT_TABLE = "effect_agent_memory_receipts_v1";
-const StoredJson$1 = Schema.String.check(Schema.isMaxLength(16777216));
-const EncodedMemoryChange = Schema.Struct({
-	commandJson: StoredJson$1,
-	documentJson: StoredJson$1,
-	resultJson: StoredJson$1
-});
-const equivalentContent = Schema.toEquivalence(MemoryWrite.Wire.members[0].fields.content);
-const equivalentScopes = Schema.toEquivalence(MemoryWrite.Wire.members[0].fields.scopes);
-var MemoryMetadataRow = class extends Schema.Class("@effect-agent/storage-sqlite/MemoryMetadataRow")({ version: Schema.Int }) {};
-var MemoryTableRow = class extends Schema.Class("@effect-agent/storage-sqlite/MemoryTableRow")({ name: Schema.NonEmptyString }) {};
-var MemoryDocumentRow = class extends Schema.Class("@effect-agent/storage-sqlite/MemoryDocumentRow")({
-	namespace: MemoryNamespaceAddress,
-	source_id: MemoryKey.Wire.fields.id,
-	format_version: Schema.Int,
-	generation: Schema.Int,
-	revision: Schema.NonEmptyString,
-	document_json: StoredJson$1
-}) {};
-var MemoryReceiptRow = class extends Schema.Class("@effect-agent/storage-sqlite/MemoryReceiptRow")({
-	namespace: MemoryNamespaceAddress,
-	operation_id: MemoryWrite.Wire.members[0].fields.operationId,
-	source_id: MemoryKey.Wire.fields.id,
-	format_version: Schema.Int,
-	command_json: StoredJson$1,
-	result_json: StoredJson$1
-}) {};
-var MemoryChangeCountRow = class extends Schema.Class("@effect-agent/storage-sqlite/MemoryChangeCountRow")({ changed: Schema.Int }) {};
-var StoredMemoryCommand = class extends Schema.Class("@effect-agent/storage-sqlite/StoredMemoryCommand")({
-	version: Schema.Literal(STORAGE_VERSION),
-	value: MemoryWrite.Wire
-}) {};
-var StoredMemoryResult = class extends Schema.Class("@effect-agent/storage-sqlite/StoredMemoryResult")({
-	version: Schema.Literal(STORAGE_VERSION),
-	value: MemoryDocument.Wire
-}) {};
-const StoredVersionHeader = Schema.Struct({ version: Schema.Int });
-const storageError = (operation, reason = "unavailable") => MemoryStorageError.make({
-	operation,
-	reason
-});
-const query = (effect, operation) => effect.pipe(Effect.mapError(() => storageError(operation)));
-const decodeRows$2 = Effect.fn("SqliteMemoryStore.decodeRows")(function* (schema, rows, operation) {
-	return yield* Schema.decodeUnknownEffect(Schema.Array(schema))(rows).pipe(Effect.mapError(() => storageError(operation, "corrupt")));
-});
-const decodeInput$1 = Effect.fn("SqliteMemoryStore.decodeInput")(function* (schema, value, operation) {
-	return yield* Schema.decodeUnknownEffect(schema)(value).pipe(Effect.mapError(() => storageError(operation, "invalid-input")));
-});
-const encodeJson = Effect.fn("SqliteMemoryStore.encodeJson")(function* (schema, value, operation) {
-	return yield* Schema.encodeEffect(Schema.fromJsonString(schema))(value).pipe(Effect.mapError(() => storageError(operation, "corrupt")));
-});
-const validateEncodedChange = Effect.fn("SqliteMemoryStore.validateEncodedChange")(function* (encoded, operation) {
-	yield* Schema.decodeEffect(EncodedMemoryChange)(encoded).pipe(Effect.mapError(() => storageError(operation, "invalid-input")));
-});
-const decodeVersionedJson = Effect.fn("SqliteMemoryStore.decodeVersionedJson")(function* (schema, value, operation) {
-	if ((yield* Schema.decodeEffect(Schema.fromJsonString(StoredVersionHeader))(value).pipe(Effect.mapError(() => storageError(operation, "corrupt")))).version !== STORAGE_VERSION) return yield* storageError(operation, "incompatible");
-	const decoded = yield* Schema.decodeEffect(Schema.fromJsonString(schema))(value).pipe(Effect.mapError(() => storageError(operation, "corrupt")));
-	if ((yield* encodeJson(schema, decoded, operation)) !== value) return yield* storageError(operation, "corrupt");
-	return decoded;
-});
-const validateDocument = Effect.fn("SqliteMemoryStore.validateDocument")(function* (document, key, operation) {
-	if (document.key.namespace.address !== key.namespace.address || document.key.id !== key.id || document.source.id !== key.id || document.source.revision !== String(document.generation) || document.generation === 1 !== (document.predecessor === null) || document.predecessor !== null && (document.predecessor.id !== key.id || document.predecessor.revision !== String(document.generation - 1))) return yield* storageError(operation, "corrupt");
-	return document;
-});
-const validateReceiptResult = Effect.fn("SqliteMemoryStore.validateReceiptResult")(function* (command, result, operation) {
-	if ((result.predecessor?.revision ?? null) !== command.expectedRevision) return yield* storageError(operation, "corrupt");
-	if (command._tag === "Put") {
-		if (result._tag !== "ActiveMemoryDocument" || result.source.locator !== command.locator) return yield* storageError(operation, "corrupt");
-		if (!equivalentContent(command.content, result.content) || !equivalentScopes(command.scopes, result.scopes)) return yield* storageError(operation, "corrupt");
-		return;
-	}
-	if (result._tag !== "WithdrawnMemoryDocument" || result.reason !== command.reason || result.predecessor === null || result.source.locator !== result.predecessor.locator) return yield* storageError(operation, "corrupt");
-});
-const initializeMemorySchema = Effect.fn("SqliteMemoryStore.initialize")(function* () {
-	const sql = yield* SqlClient.SqlClient;
-	const failpoint = yield* MemoryMutationFailpoint;
-	yield* failpoint.hit("memory:initialize:before");
-	yield* sql.withTransaction(Effect.gen(function* () {
-		yield* sql`
-          CREATE TABLE IF NOT EXISTS effect_agent_memory_metadata (
-            component TEXT PRIMARY KEY NOT NULL,
-            version INTEGER NOT NULL
-          )
-        `;
-		const metadataRows = yield* sql`
-          SELECT version
-          FROM effect_agent_memory_metadata
-          WHERE component = ${METADATA_COMPONENT}
-        `;
-		const metadata = yield* decodeRows$2(MemoryMetadataRow, metadataRows, "decode memory schema version");
-		if (metadata.length > 1) return yield* storageError("decode memory schema version", "corrupt");
-		const currentVersion = metadata[0]?.version;
-		if (currentVersion !== void 0 && currentVersion !== STORAGE_VERSION) return yield* storageError("initialize memory schema", "incompatible");
-		if (currentVersion === void 0) {
-			const tableRows = yield* sql`
-            SELECT name
-            FROM sqlite_master
-            WHERE type = 'table' AND name IN (${DOCUMENT_TABLE}, ${RECEIPT_TABLE})
-          `;
-			if ((yield* decodeRows$2(MemoryTableRow, tableRows, "inspect memory schema")).length > 0) return yield* storageError("initialize memory schema", "incompatible");
-			yield* sql`
-            CREATE TABLE effect_agent_memory_documents_v1 (
-              namespace TEXT NOT NULL,
-              source_id TEXT NOT NULL,
-              format_version INTEGER NOT NULL,
-              generation INTEGER NOT NULL,
-              revision TEXT NOT NULL,
-              document_json TEXT NOT NULL,
-              PRIMARY KEY (namespace, source_id)
-            )
-          `;
-			yield* sql`
-            CREATE TABLE effect_agent_memory_receipts_v1 (
-              namespace TEXT NOT NULL,
-              operation_id TEXT NOT NULL,
-              source_id TEXT NOT NULL,
-              format_version INTEGER NOT NULL,
-              command_json TEXT NOT NULL,
-              result_json TEXT NOT NULL,
-              PRIMARY KEY (namespace, operation_id)
-            )
-          `;
-			yield* sql`
-            INSERT INTO effect_agent_memory_metadata (component, version)
-            VALUES (${METADATA_COMPONENT}, ${STORAGE_VERSION})
-          `;
-		}
-		yield* sql`
-          SELECT namespace, source_id, format_version, generation, revision, document_json
-          FROM effect_agent_memory_documents_v1
-          LIMIT 0
-        `;
-		yield* sql`
-          SELECT namespace, operation_id, source_id, format_version, command_json, result_json
-          FROM effect_agent_memory_receipts_v1
-          LIMIT 0
-        `;
-	})).pipe(Effect.catchTag("SqlError", () => Effect.fail(storageError("initialize memory schema"))));
-	yield* failpoint.hit("memory:initialize:after");
-});
-const makeMemoryReader = Effect.fn("SqliteMemoryStore.makeReader")(function* () {
-	const sql = yield* SqlClient.SqlClient;
-	const readDocument = Effect.fn("SqliteMemoryStore.readDocument")(function* (key, operation) {
-		const rawRows = yield* query(sql`
-        SELECT namespace, source_id, format_version, generation, revision, document_json
-        FROM effect_agent_memory_documents_v1
-        WHERE namespace = ${key.namespace.address} AND source_id = ${key.id}
-      `, operation);
-		const rows = yield* decodeRows$2(MemoryDocumentRow, rawRows, operation);
-		if (rows.length === 0) return null;
-		if (rows.length !== 1) return yield* storageError(operation, "corrupt");
-		const row = rows[0];
-		if (row.format_version !== STORAGE_VERSION) return yield* storageError(operation, "incompatible");
-		const document = (yield* decodeVersionedJson(StoredMemoryResult, row.document_json, operation)).value;
-		yield* validateDocument(document, key, operation);
-		if (row.namespace !== key.namespace.address || row.source_id !== key.id || row.generation !== document.generation || row.revision !== document.source.revision) return yield* storageError(operation, "corrupt");
-		return document;
-	});
-	return {
-		get: Effect.fn("SqliteMemoryStore.get")(function* (key) {
-			const decodedKey = yield* decodeInput$1(MemoryKey.Wire, key, "get memory document");
-			return yield* readDocument(decodedKey, "get memory document");
-		}),
-		readDocument
-	};
-});
-const makeMemoryServices = Effect.fn("SqliteMemoryStore.make")(function* () {
-	const sql = yield* SqlClient.SqlClient;
-	const failpoint = yield* MemoryMutationFailpoint;
-	yield* initializeMemorySchema();
-	const { get, readDocument } = yield* makeMemoryReader();
-	const readReceipt = Effect.fn("SqliteMemoryStore.readReceipt")(function* (write, operation) {
-		const rawRows = yield* query(sql`
-        SELECT namespace, operation_id, source_id, format_version, command_json, result_json
-        FROM effect_agent_memory_receipts_v1
-        WHERE namespace = ${write.key.namespace.address} AND operation_id = ${write.operationId}
-      `, operation);
-		const rows = yield* decodeRows$2(MemoryReceiptRow, rawRows, operation);
-		if (rows.length === 0) return null;
-		if (rows.length !== 1) return yield* storageError(operation, "corrupt");
-		const row = rows[0];
-		if (row.format_version !== STORAGE_VERSION) return yield* storageError(operation, "incompatible");
-		const command = yield* decodeVersionedJson(StoredMemoryCommand, row.command_json, `${operation} command`);
-		const result = yield* decodeVersionedJson(StoredMemoryResult, row.result_json, `${operation} result`);
-		if (row.namespace !== command.value.key.namespace.address || row.operation_id !== command.value.operationId || row.source_id !== command.value.key.id || result.value.key.namespace.address !== command.value.key.namespace.address || result.value.key.id !== command.value.key.id) return yield* storageError(operation, "corrupt");
-		yield* validateDocument(result.value, command.value.key, operation);
-		yield* validateReceiptResult(command.value, result.value, operation);
-		return {
-			commandJson: row.command_json,
-			result: result.value
-		};
-	});
-	const change = Effect.fn("SqliteMemoryStore.change")(function* (write) {
-		const operation = "change memory document";
-		const decodedWrite = yield* decodeInput$1(MemoryWrite.Wire, write, operation);
-		const commandJson = yield* encodeJson(StoredMemoryCommand, StoredMemoryCommand.make({
-			version: STORAGE_VERSION,
-			value: decodedWrite
-		}), "encode memory command");
-		yield* failpoint.hit("memory:change:before");
-		const transactionResult = yield* sql.withTransaction(Effect.gen(function* () {
-			const receipt = yield* readReceipt(decodedWrite, operation);
-			if (receipt !== null) {
-				if (receipt.commandJson !== commandJson) return yield* MemoryOperationConflict.make({
-					key: decodedWrite.key,
-					operationId: decodedWrite.operationId
-				});
-				return {
-					document: receipt.result,
-					changed: false
-				};
-			}
-			const current = yield* readDocument(decodedWrite.key, operation);
-			const modifiedAt = yield* Clock.currentTimeMillis;
-			const next = yield* applyMemoryWrite(current, decodedWrite, modifiedAt);
-			const resultJson = yield* encodeJson(StoredMemoryResult, StoredMemoryResult.make({
-				version: STORAGE_VERSION,
-				value: next
-			}), "encode memory result");
-			const documentJson = resultJson;
-			yield* validateEncodedChange({
-				commandJson,
-				documentJson,
-				resultJson
-			}, operation);
-			if (current === null) yield* sql`
-                INSERT INTO effect_agent_memory_documents_v1 (
-                  namespace, source_id, format_version, generation, revision, document_json
-                ) VALUES (
-                  ${next.key.namespace.address}, ${next.key.id}, ${STORAGE_VERSION},
-                  ${next.generation}, ${next.source.revision}, ${documentJson}
-                )
-              `;
-			else yield* sql`
-                UPDATE effect_agent_memory_documents_v1
-                SET format_version = ${STORAGE_VERSION},
-                    generation = ${next.generation},
-                    revision = ${next.source.revision},
-                    document_json = ${documentJson}
-                WHERE namespace = ${next.key.namespace.address}
-                  AND source_id = ${next.key.id}
-                  AND generation = ${current.generation}
-                  AND revision = ${current.source.revision}
-              `;
-			const changedRows = yield* sql`
-              SELECT changes() AS changed
-            `;
-			const changed = yield* decodeRows$2(MemoryChangeCountRow, changedRows, operation);
-			if (changed.length !== 1 || changed[0].changed !== 1) return yield* storageError(operation, "corrupt");
-			yield* failpoint.hit("memory:change:after-state");
-			yield* sql`
-              INSERT INTO effect_agent_memory_receipts_v1 (
-                namespace, operation_id, source_id, format_version, command_json, result_json
-              ) VALUES (
-                ${decodedWrite.key.namespace.address}, ${decodedWrite.operationId}, ${decodedWrite.key.id},
-                ${STORAGE_VERSION}, ${commandJson}, ${resultJson}
-              )
-            `;
-			yield* failpoint.hit("memory:change:after-receipt");
-			return {
-				document: next,
-				changed: true
-			};
-		})).pipe(Effect.catchTag("SqlError", () => Effect.fail(storageError(operation))));
-		if (transactionResult.changed) yield* failpoint.hit("memory:change:after");
-		return transactionResult.document;
-	});
-	return Context.make(MemoryReader, MemoryReader.fromAdapter({ get })).pipe(Context.add(MemoryWriter, MemoryWriter.fromAdapter({ change })));
-});
-/** SQLite memory ports with the mutation failpoint kept injectable for recovery tests. */
-const memoryStoreLayerWithFailpoints = Layer.effectContext(makeMemoryServices());
-/** SQLite memory reader and writer with the production no-op mutation failpoint. */
-const memoryStoreLayer = memoryStoreLayerWithFailpoints.pipe(Layer.provide(MemoryMutationFailpoint.layer));
-/** Reads an existing memory schema without writes, transactions, or mutation failpoints. */
-const memoryReaderLayer = Layer.effect(MemoryReader, Effect.gen(function* () {
-	const sql = yield* SqlClient.SqlClient;
-	const operation = "open memory reader";
-	const tables = yield* query(sql`
-        SELECT name FROM sqlite_master
-        WHERE type = 'table' AND name IN (
-          'effect_agent_memory_metadata', ${DOCUMENT_TABLE}, ${RECEIPT_TABLE}
-        )
-      `, operation).pipe(Effect.flatMap((rows) => decodeRows$2(MemoryTableRow, rows, operation)));
-	if (tables.length !== 3) return yield* storageError(operation, tables.length === 0 ? "unavailable" : "incompatible");
-	const metadata = yield* query(sql`
-        SELECT version FROM effect_agent_memory_metadata WHERE component = ${METADATA_COMPONENT}
-      `, operation).pipe(Effect.flatMap((rows) => decodeRows$2(MemoryMetadataRow, rows, operation)));
-	if (metadata.length !== 1 || metadata[0].version !== STORAGE_VERSION) return yield* storageError(operation, "incompatible");
-	yield* query(sql`
-        SELECT namespace, source_id, format_version, generation, revision, document_json
-        FROM effect_agent_memory_documents_v1 LIMIT 0
-      `, operation);
-	const { get } = yield* makeMemoryReader();
-	return MemoryReader.fromAdapter({ get });
-}));
-//#endregion
 //#region src/sqlite-schedule-store.ts
 const StoredScheduleJson = Schema.String.check(Schema.isMaxLength(16777216));
 const StoredDeadline = Schema.NullOr(ScheduleInstant);