effect-agent 0.1.0-beta.155 → 0.1.0-beta.157

package/dist/durable/SqlMemoryStore.mjs

@@ -18,6 +18,16 @@ const EncodedMemoryChange = Schema.Struct({
 });
 const equivalentContent = Schema.toEquivalence(Schema.toEncoded(MemoryWrite.Wire.members[0].fields.content));
 const equivalentScopes = Schema.toEquivalence(MemoryWrite.Wire.members[0].fields.scopes);
+/** Ordered commands committed atomically by the SQL memory adapter. */
+const SqlMemoryWriteBatch = Schema.Array(MemoryWrite.Wire).check(Schema.isMaxLength(128));
+/**
+* SQL-only bulk writing. Results preserve input order, including exact operation replays.
+* Commands see earlier staged revisions; any refusal rolls back the entire batch. Storage
+* limits apply to every intermediate transition. Empty batches succeed without mutation.
+* Supplied by the memory store Layers alongside MemoryWriter's single-command API.
+*/
+var SqlMemoryBatchWriter = class extends Context.Service()("@effect-agent/thread/SqlMemoryBatchWriter") {};
+const SqlStorageOwner = Context.Reference("@effect-agent/thread/SqlStorageOwner", { defaultValue: () => void 0 });
 /**
 * Independent adapter limits. Counts and encoded bytes include durable operation receipts.
 * Bytes count UTF-8 row payloads plus 128 bytes per row, excluding SQLite pages/indexes.
@@ -45,6 +55,61 @@ const UsageRow = Schema.Struct({
 	receipts: Schema.Natural,
 	bytes: Schema.Natural
 });
+var MemoryViews = class {
+	entries = /* @__PURE__ */ new Map();
+	bytes = 0;
+	clear = () => {
+		this.entries.clear();
+		this.bytes = 0;
+	};
+	get(key) {
+		const entry = this.entries.get(key);
+		if (entry === void 0) return void 0;
+		this.entries.delete(key);
+		this.entries.set(key, entry);
+		return entry.view;
+	}
+	set(key, view) {
+		const previous = this.entries.get(key);
+		if (previous !== void 0) this.bytes -= previous.bytes;
+		this.entries.delete(key);
+		const bytes = utf8ByteLength(key) + utf8ByteLength(JSON.stringify(view)) + 128;
+		if (bytes > 4194304) return;
+		this.entries.set(key, {
+			view,
+			bytes
+		});
+		this.bytes += bytes;
+		while (this.entries.size > 128 || this.bytes > 4194304) {
+			const oldest = this.entries.entries().next().value;
+			if (oldest === void 0) break;
+			this.bytes -= oldest[1].bytes;
+			this.entries.delete(oldest[0]);
+		}
+	}
+};
+const ownedViews = /* @__PURE__ */ new WeakMap();
+const memoryViews = Effect.fn("SqliteMemoryStore.memoryViews")(function* () {
+	const owner = yield* SqlStorageOwner;
+	if (owner === void 0) return void 0;
+	let views = ownedViews.get(owner);
+	if (views === void 0) {
+		views = new MemoryViews();
+		ownedViews.set(owner, views);
+		owner.invalidators.add(views.clear);
+	}
+	return views;
+});
+const documentViewKey = (key) => JSON.stringify([
+	"document",
+	key.namespace.address,
+	key.id
+]);
+const receiptViewKey = (write) => JSON.stringify([
+	"receipt",
+	write.key.namespace.address,
+	write.operationId
+]);
 const documentBytesSql = (row) => `length(CAST(${row}.namespace AS BLOB)) + length(CAST(${row}.source_id AS BLOB)) + length(CAST(${row}.document_json AS BLOB)) + 128`;
 const receiptBytesSql = (row) => `length(CAST(${row}.namespace AS BLOB)) + length(CAST(${row}.source_id AS BLOB)) + length(CAST(${row}.operation_id AS BLOB)) + length(CAST(${row}.command_json AS BLOB)) + length(CAST(${row}.result_json AS BLOB)) + 128`;
 const usageTriggers = [{
@@ -137,11 +202,16 @@ const validateReceiptResult = Effect.fn("SqliteMemoryStore.validateReceiptResult
 });
 const readUsage = Effect.fn("SqliteMemoryStore.readUsage")(function* () {
 	const sql = yield* SqlClientService.SqlClient;
+	const views = yield* memoryViews();
 	const operation = "read memory usage";
 	const rows = yield* query(sql`
       SELECT documents, receipts, bytes FROM effect_agent_memory_usage_v1 WHERE singleton = 1
     `, operation).pipe(Effect.flatMap((rows) => decodeRows(UsageRow, rows, operation)));
 	if (rows.length !== 1) return yield* storageError(operation, "corrupt");
+	views?.set("usage", {
+		_tag: "Usage",
+		value: rows[0]
+	});
 	return rows[0];
 });
 const initializeMemoryUsage = Effect.fn("SqliteMemoryStore.initializeUsage")(function* () {
@@ -190,9 +260,11 @@ const initializeMemoryUsage = Effect.fn("SqliteMemoryStore.initializeUsage")(fun
 });
 const initializeMemorySchema = Effect.fn("SqliteMemoryStore.initialize")(function* () {
 	const sql = yield* SqlClientService.SqlClient;
+	const owner = yield* SqlStorageOwner;
+	const transaction = owner === void 0 ? sql.withTransaction : owner.transaction;
 	const failpoint = yield* MemoryMutationFailpoint;
 	yield* failpoint.hit("memory:initialize:before");
-	yield* sql.withTransaction(Effect.gen(function* () {
+	yield* transaction(Effect.gen(function* () {
 		yield* sql`
           CREATE TABLE IF NOT EXISTS effect_agent_memory_metadata (
             component TEXT PRIMARY KEY NOT NULL,
@@ -258,155 +330,273 @@ const initializeMemorySchema = Effect.fn("SqliteMemoryStore.initialize")(functio
 });
 const makeMemoryReader = Effect.fn("SqliteMemoryStore.makeReader")(function* () {
 	const sql = yield* SqlClientService.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,
-          length(CAST(namespace AS BLOB)) + length(CAST(source_id AS BLOB)) +
-          length(CAST(document_json AS BLOB)) + 128 AS stored_bytes
-        FROM effect_agent_memory_documents_v1
-        WHERE namespace = ${key.namespace.address} AND source_id = ${key.id}
-      `, operation);
-		const rows = yield* decodeRows(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,
-			bytes: row.stored_bytes
-		};
-	});
+	const owner = yield* SqlStorageOwner;
+	const views = yield* memoryViews();
+	const readDocuments = Effect.fn("SqliteMemoryStore.readDocuments")(function* (keys, operation) {
+		const found = /* @__PURE__ */ new Map();
+		const missing = /* @__PURE__ */ new Map();
+		for (const key of keys) {
+			const viewKey = documentViewKey(key);
+			const cached = views?.get(viewKey);
+			if (cached?._tag === "Document") found.set(viewKey, cached.value);
+			else missing.set(viewKey, key);
+		}
+		const pending = Array.from(missing);
+		for (let index = 0; index < pending.length; index += 50) {
+			const requested = new Map(pending.slice(index, index + 50));
+			const rawRows = yield* query(sql`
+            SELECT namespace, source_id, format_version, generation, revision, document_json,
+              length(CAST(namespace AS BLOB)) + length(CAST(source_id AS BLOB)) +
+              length(CAST(document_json AS BLOB)) + 128 AS stored_bytes
+            FROM effect_agent_memory_documents_v1
+            WHERE ${sql.or(Array.from(requested.values(), (key) => sql`(namespace = ${key.namespace.address} AND source_id = ${key.id})`))}
+          `, operation);
+			const rows = yield* decodeRows(MemoryDocumentRow, rawRows, operation);
+			for (const row of rows) {
+				const viewKey = JSON.stringify([
+					"document",
+					row.namespace,
+					row.source_id
+				]);
+				const key = requested.get(viewKey);
+				if (key === void 0 || found.has(viewKey)) return yield* storageError(operation, "corrupt");
+				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.generation !== document.generation || row.revision !== document.source.revision) return yield* storageError(operation, "corrupt");
+				found.set(viewKey, {
+					document,
+					bytes: row.stored_bytes
+				});
+			}
+			for (const viewKey of requested.keys()) {
+				const value = found.get(viewKey) ?? null;
+				found.set(viewKey, value);
+				views?.set(viewKey, {
+					_tag: "Document",
+					value
+				});
+			}
+		}
+		return found;
+	}, (effect) => owner === void 0 ? effect : owner.read(effect));
 	return {
 		get: Effect.fn("SqliteMemoryStore.get")(function* (key) {
 			const decodedKey = yield* decodeInput(MemoryKey.Wire, key, "get memory document");
-			return (yield* readDocument(decodedKey, "get memory document"))?.document ?? null;
+			return (yield* readDocuments([decodedKey], "get memory document")).get(documentViewKey(decodedKey))?.document ?? null;
 		}),
-		readDocument
+		readDocuments
 	};
 });
 const makeMemoryServices = Effect.fn("SqliteMemoryStore.make")(function* () {
 	const sql = yield* SqlClientService.SqlClient;
-	const usage = readUsage().pipe(Effect.provideService(SqlClientService.SqlClient, sql));
+	const owner = yield* SqlStorageOwner;
+	const views = yield* memoryViews();
+	const usage = readUsage().pipe(Effect.provideService(SqlClientService.SqlClient, sql), Effect.provideService(SqlStorageOwner, owner));
+	const transaction = (effect) => owner === void 0 ? sql.withTransaction(effect) : owner.transaction(effect).pipe(Effect.provideService(SqlClientService.SqlClient, sql));
 	const failpoint = yield* MemoryMutationFailpoint;
 	const limits = yield* decodeInput(Limits, yield* SqlMemoryLimits, "memory storage limits");
 	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(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 { get, readDocuments } = yield* makeMemoryReader();
+	const readReceipts = Effect.fn("SqliteMemoryStore.readReceipts")(function* (writes, operation) {
+		const found = /* @__PURE__ */ new Map();
+		const missing = /* @__PURE__ */ new Map();
+		for (const write of writes) {
+			const viewKey = receiptViewKey(write);
+			const cached = views?.get(viewKey);
+			if (cached?._tag === "Receipt") found.set(viewKey, cached.value);
+			else missing.set(viewKey, write);
+		}
+		const pending = Array.from(missing);
+		for (let index = 0; index < pending.length; index += 50) {
+			const requested = new Map(pending.slice(index, index + 50));
+			const rawRows = yield* query(sql`
+          SELECT namespace, operation_id, source_id, format_version, command_json, result_json
+          FROM effect_agent_memory_receipts_v1
+          WHERE ${sql.or(Array.from(requested.values(), (write) => sql`(namespace = ${write.key.namespace.address} AND operation_id = ${write.operationId})`))}
+        `, operation);
+			const rows = yield* decodeRows(MemoryReceiptRow, rawRows, operation);
+			for (const row of rows) {
+				const viewKey = JSON.stringify([
+					"receipt",
+					row.namespace,
+					row.operation_id
+				]);
+				if (!requested.has(viewKey) || found.has(viewKey)) return yield* storageError(operation, "corrupt");
+				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);
+				found.set(viewKey, {
+					commandJson: row.command_json,
+					result: result.value
+				});
+			}
+			for (const viewKey of requested.keys()) {
+				const value = found.get(viewKey) ?? null;
+				found.set(viewKey, value);
+				views?.set(viewKey, {
+					_tag: "Receipt",
+					value
+				});
+			}
+		}
+		return found;
 	});
-	const change = Effect.fn("SqliteMemoryStore.change")(function* (write) {
+	const changeMany = Effect.fn("SqliteMemoryStore.changeMany")(function* (writes) {
 		const operation = "change memory document";
-		const decodedWrite = yield* decodeInput(MemoryWrite.Wire, write, operation);
-		const commandJson = yield* encodeJson(StoredMemoryCommand, StoredMemoryCommand.make({
+		const decodedWrites = yield* decodeInput(SqlMemoryWriteBatch, writes, operation);
+		if (decodedWrites.length === 0) return [];
+		const commands = yield* Effect.forEach(decodedWrites, (write) => encodeJson(StoredMemoryCommand, StoredMemoryCommand.make({
 			version: STORAGE_VERSION,
-			value: decodedWrite
-		}), "encode memory command");
+			value: write
+		}), "encode memory command").pipe(Effect.map((commandJson) => ({
+			write,
+			commandJson
+		}))));
 		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 transactionResult = yield* transaction(Effect.gen(function* () {
+			const retainedReceipts = yield* readReceipts(decodedWrites, operation);
+			const retainedDocuments = yield* readDocuments(decodedWrites.filter((write) => retainedReceipts.get(receiptViewKey(write)) === null).map((write) => write.key), operation);
+			const documents = /* @__PURE__ */ new Map();
+			const receipts = /* @__PURE__ */ new Map();
+			const results = [];
+			let projectedUsage;
+			for (const { write, commandJson } of commands) {
+				const receiptKey = receiptViewKey(write);
+				const receipt = receipts.get(receiptKey) ?? retainedReceipts.get(receiptKey) ?? null;
+				if (receipt !== null) {
+					if (receipt.commandJson !== commandJson) return yield* MemoryOperationConflict.make({
+						key: write.key,
+						operationId: write.operationId
+					});
+					results.push(receipt.result);
+					continue;
+				}
+				const documentKey = documentViewKey(write.key);
+				const currentRow = documents.get(documentKey) ?? retainedDocuments.get(documentKey) ?? null;
+				const current = currentRow?.document ?? null;
+				const modifiedAt = yield* Clock.currentTimeMillis;
+				const next = yield* applyMemoryWrite(current, write, 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);
+				const bytes = utf8ByteLength;
+				const identityBytes = bytes(next.key.namespace.address) + bytes(next.key.id);
+				const resultBytes = bytes(resultJson);
+				const documentBytes = identityBytes + resultBytes + 128;
+				const receiptBytes = identityBytes + bytes(write.operationId) + bytes(commandJson) + resultBytes + 128;
+				if (Math.max(documentBytes, receiptBytes) > limits.maxRowBytes) return yield* storageError("memory row byte limit", "invalid-input");
+				const cachedUsage = views?.get("usage");
+				const used = projectedUsage ?? (cachedUsage?._tag === "Usage" ? cachedUsage.value : yield* usage);
+				if (used.bytes < (currentRow?.bytes ?? 0) || current !== null && used.documents === 0) return yield* storageError("read memory usage", "corrupt");
+				const maxReceipts = limits.maxReceipts - (write._tag === "Put" ? limits.reservedWithdrawalReceipts ?? 0 : 0);
+				const maxStorageBytes = limits.maxStorageBytes - (write._tag === "Put" ? limits.reservedWithdrawalBytes ?? 0 : 0);
+				if (used.documents > limits.maxDocuments - (current === null ? 1 : 0) || used.receipts >= maxReceipts || used.bytes - (currentRow?.bytes ?? 0) > maxStorageBytes - documentBytes - receiptBytes) return yield* storageError("memory storage limit", "invalid-input");
+				projectedUsage = {
+					documents: used.documents + (current === null ? 1 : 0),
+					receipts: used.receipts + 1,
+					bytes: used.bytes - (currentRow?.bytes ?? 0) + documentBytes + receiptBytes
 				};
+				documents.set(documentKey, {
+					document: next,
+					bytes: documentBytes,
+					documentJson
+				});
+				receipts.set(receiptKey, {
+					write,
+					commandJson,
+					resultJson,
+					result: next
+				});
+				results.push(next);
+			}
+			if (projectedUsage === void 0) return {
+				documents: results,
+				changed: false
+			};
+			const documentRows = Array.from(documents.values(), ({ document, documentJson }) => ({
+				namespace: document.key.namespace.address,
+				source_id: document.key.id,
+				format_version: STORAGE_VERSION,
+				generation: document.generation,
+				revision: document.source.revision,
+				document_json: documentJson
+			}));
+			for (let index = 0; index < documentRows.length; index += 16) {
+				const chunk = documentRows.slice(index, index + 16);
+				const changedRows = yield* sql`
+            INSERT INTO effect_agent_memory_documents_v1 ${sql.insert(chunk)}
+            ON CONFLICT (namespace, source_id) DO UPDATE SET
+              format_version = excluded.format_version,
+              generation = excluded.generation,
+              revision = excluded.revision,
+              document_json = excluded.document_json
+            RETURNING 1 AS changed
+          `;
+				const changed = yield* decodeRows(MemoryChangeCountRow, changedRows, operation);
+				if (changed.length !== chunk.length || changed.some((row) => row.changed !== 1)) return yield* storageError(operation, "corrupt");
 			}
-			const currentRow = yield* readDocument(decodedWrite.key, operation);
-			const current = currentRow?.document ?? null;
-			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);
-			const bytes = utf8ByteLength;
-			const identityBytes = bytes(next.key.namespace.address) + bytes(next.key.id);
-			const resultBytes = bytes(resultJson);
-			const documentBytes = identityBytes + resultBytes + 128;
-			const receiptBytes = identityBytes + bytes(decodedWrite.operationId) + bytes(commandJson) + resultBytes + 128;
-			if (Math.max(documentBytes, receiptBytes) > limits.maxRowBytes) return yield* storageError("memory row byte limit", "invalid-input");
-			const used = yield* usage;
-			if (used.bytes < (currentRow?.bytes ?? 0) || current !== null && used.documents === 0) return yield* storageError("read memory usage", "corrupt");
-			const maxReceipts = limits.maxReceipts - (decodedWrite._tag === "Put" ? limits.reservedWithdrawalReceipts ?? 0 : 0);
-			const maxStorageBytes = limits.maxStorageBytes - (decodedWrite._tag === "Put" ? limits.reservedWithdrawalBytes ?? 0 : 0);
-			if (used.documents > limits.maxDocuments - (current === null ? 1 : 0) || used.receipts >= maxReceipts || used.bytes - (currentRow?.bytes ?? 0) > maxStorageBytes - documentBytes - receiptBytes) return yield* storageError("memory storage limit", "invalid-input");
-			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(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}
-              )
-            `;
+			const receiptRows = Array.from(receipts.values(), ({ write, commandJson, resultJson }) => ({
+				namespace: write.key.namespace.address,
+				operation_id: write.operationId,
+				source_id: write.key.id,
+				format_version: STORAGE_VERSION,
+				command_json: commandJson,
+				result_json: resultJson
+			}));
+			for (let index = 0; index < receiptRows.length; index += 16) yield* sql`
+            INSERT INTO effect_agent_memory_receipts_v1 ${sql.insert(receiptRows.slice(index, index + 16))}
+          `;
 			yield* failpoint.hit("memory:change:after-receipt");
+			for (const [key, { document, bytes }] of documents) views?.set(key, {
+				_tag: "Document",
+				value: {
+					document,
+					bytes
+				}
+			});
+			for (const [key, { commandJson, result }] of receipts) views?.set(key, {
+				_tag: "Receipt",
+				value: {
+					commandJson,
+					result
+				}
+			});
+			views?.set("usage", {
+				_tag: "Usage",
+				value: projectedUsage
+			});
 			return {
-				document: next,
+				documents: results,
 				changed: true
 			};
 		})).pipe(Effect.catchTag("SqlError", () => Effect.fail(storageError(operation))));
 		if (transactionResult.changed) yield* failpoint.hit("memory:change:after");
-		return transactionResult.document;
+		return transactionResult.documents;
+	});
+	const change = Effect.fn("SqliteMemoryStore.change")(function* (write) {
+		return (yield* changeMany([write]))[0];
 	});
-	return Context.make(MemoryReader, MemoryReader.fromAdapter({ get })).pipe(Context.add(MemoryWriter, MemoryWriter.fromAdapter({ change })));
+	const batchWriter = SqlMemoryBatchWriter.of({ changeMany: Effect.fn("SqlMemoryBatchWriter.changeMany")(function* (writes) {
+		const documents = yield* changeMany(writes);
+		return yield* Effect.forEach(documents, (document, index) => MemoryDocument.restore(writes[index].key.namespace, document));
+	}) });
+	return Context.make(MemoryReader, MemoryReader.fromAdapter({ get })).pipe(Context.add(MemoryWriter, MemoryWriter.fromAdapter({ change })), Context.add(SqlMemoryBatchWriter, batchWriter));
 });
 /** 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. */
+/** SQLite memory reader, single writer and batch writer with the production no-op 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* () {
@@ -431,6 +621,6 @@ const memoryReaderLayer = Layer.effect(MemoryReader, Effect.gen(function* () {
 	return MemoryReader.fromAdapter({ get });
 }));
 //#endregion
-export { SqlMemoryLimits, memoryReaderLayer, memoryStoreLayer, memoryStoreLayerWithFailpoints };
+export { SqlMemoryBatchWriter, SqlMemoryLimits, SqlMemoryWriteBatch, SqlStorageOwner, memoryReaderLayer, memoryStoreLayer, memoryStoreLayerWithFailpoints };
 
 //# sourceMappingURL=SqlMemoryStore.mjs.map