@streamsy/storage 0.4.0 → 0.6.0

package/dist/bun.d.ts

@@ -1,4 +1,4 @@
-import { r as SqlStorageOptions } from "./storage-CrMmTyyG.js";
+import { r as SqlStorageOptions } from "./storage-Cb_kOO_g.js";
 import { Layer } from "effect";
 import { StorageFault, Streamsy } from "@streamsy/core";
 import { Protocol } from "@streamsy/core/protocol";
@@ -16,5 +16,4 @@ declare const storageLayer: (options: BunStorageOptions) => Layer.Layer<import("
 /** Complete persistent protocol Layer for an HttpRouter application. */
 declare const layerProtocol: (options: Options) => Layer.Layer<import("@streamsy/core").CommitBoundary | import("@streamsy/core/internal").OwnerRecords | import("effect/reactivity/Reactivity").Reactivity | import("effect/sql/SqlClient").SqlClient | import("@streamsy/core").Storage | import("@streamsy/core/protocol").StreamsReader | import("@streamsy/core/protocol").StreamsWriter, StorageFault, never>;
 declare function layer<const Keys extends ReadonlyArray<Streamsy.Any>>(group: Streamsy.Group<Keys>, options: Options): Layer.Layer<Layer.Success<ReturnType<typeof storageLayer>> | Streamsy.Host<Streamsy.Group<Keys>>, Layer.Error<ReturnType<typeof storageLayer>>>;
-//#endregion
 export { bun_storage_d_exports as BunStorage };

package/dist/bun.js

@@ -1,13 +1,13 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { a as storageLayer$1, d as retryWithPolicy, f as transactionRetryPolicy, o as inspectFormat, s as newerVersionFault, u as sharedSqlClientLayer } from "./storage-CpnFxwO5.js";
-import { Cause, Effect, FileSystem, Layer, Option, Path, Result, Schema } from "effect";
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.js";
+import { a as storageLayer$1, d as retryWithPolicy, f as transactionRetryPolicy, o as inspectFormat, s as newerVersionFault, u as sharedSqlClientLayer } from "./storage-DFCZf1UK.js";
+import { Array, Cause, Effect, FileSystem, Layer, Option, Path, Result, Schema } from "effect";
 import { StorageFault } from "@streamsy/core";
 import { Protocol } from "@streamsy/core/protocol";
 import * as BunFileSystem from "@effect/platform-bun/BunFileSystem";
 import * as BunPath from "@effect/platform-bun/BunPath";
 import { SqliteClient } from "@effect/sql-sqlite-bun";
 import { Database } from "bun:sqlite";
-//#region src/sqlite-file.ts
+// src/sqlite-file.ts
 const openFault$1 = (message) => new StorageFault({
 	operation: "migration.open",
 	message,
@@ -16,7 +16,7 @@ const openFault$1 = (message) => new StorageFault({
 const decodeTableNames = Schema.decodeUnknownSync(Schema.Array(Schema.Struct({ name: Schema.String })));
 const decodeVersions = Schema.decodeUnknownSync(Schema.Array(Schema.Struct({ version: Schema.NullOr(Schema.Finite) })));
 const readFormat = (reader) => {
-	const names = new Set(decodeTableNames(reader.all("SELECT name FROM sqlite_master WHERE type='table'")).map(({ name }) => name));
+	const names = new Set(Array.map(decodeTableNames(reader.all("SELECT name FROM sqlite_master WHERE type='table'")), ({ name }) => name));
 	return {
 		names,
 		version: names.has("streamsy_schema") ? decodeVersions(reader.all(`SELECT MAX(version) version FROM streamsy_schema`)).at(0)?.version ?? 0 : 0
@@ -54,8 +54,7 @@ const prepare = (driver, options, retry) => Effect.gen(function* () {
 		create: options.create ?? true
 	}, ["PRAGMA busy_timeout=0", "PRAGMA journal_mode=WAL"]));
 });
-//#endregion
-//#region src/bun-storage.ts
+// src/bun-storage.ts
 var bun_storage_exports = /* @__PURE__ */ __exportAll({
 	layer: () => layer,
 	layerProtocol: () => layerProtocol
@@ -105,5 +104,4 @@ function layer(group, options) {
 	const protocol = Protocol.layer(options).pipe(Layer.provideMerge(storage));
 	return Protocol.bind(protocol, group).pipe(Layer.provideMerge(storage));
 }
-//#endregion
 export { bun_storage_exports as BunStorage };

package/dist/durable-object.d.ts

@@ -1,4 +1,4 @@
-import { r as SqlStorageOptions } from "./storage-CrMmTyyG.js";
+import { r as SqlStorageOptions } from "./storage-Cb_kOO_g.js";
 import { Layer } from "effect";
 import { Streamsy } from "@streamsy/core";
 import { Protocol } from "@streamsy/core/protocol";
@@ -20,5 +20,4 @@ declare const storageLayer: (options: DurableObjectStorageOptions) => Layer.Laye
 /** Protocol over the official Durable Object SQLite layer. */
 declare const layerProtocol: (options: Options) => Layer.Layer<import("@streamsy/core").CommitBoundary | import("@streamsy/core/internal").OwnerRecords | import("effect/reactivity/Reactivity").Reactivity | import("effect/sql/SqlClient").SqlClient | import("@streamsy/core").Storage | import("@streamsy/core/protocol").StreamsReader | import("@streamsy/core/protocol").StreamsWriter, import("@streamsy/core").StorageFault, never>;
 declare function layer<const Keys extends ReadonlyArray<Streamsy.Any>>(group: Streamsy.Group<Keys>, options: Options): Layer.Layer<Layer.Success<ReturnType<typeof storageLayer>> | Streamsy.Host<Streamsy.Group<Keys>>, Layer.Error<ReturnType<typeof storageLayer>>>;
-//#endregion
 export { durable_object_storage_d_exports as DurableObjectStorage };

package/dist/durable-object.js

@@ -1,10 +1,10 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { i as layerWithDurableObjectTransactions, u as sharedSqlClientLayer } from "./storage-CpnFxwO5.js";
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.js";
+import { i as layerWithDurableObjectTransactions, u as sharedSqlClientLayer } from "./storage-DFCZf1UK.js";
 import { Layer } from "effect";
 import "@streamsy/core";
 import { Protocol } from "@streamsy/core/protocol";
 import { SqliteClient } from "@effect/sql-sqlite-do";
-//#region src/durable-object-storage.ts
+// src/durable-object-storage.ts
 var durable_object_storage_exports = /* @__PURE__ */ __exportAll({
 	DEFAULT_LONG_POLL_TIMEOUT_MS: () => DEFAULT_LONG_POLL_TIMEOUT_MS,
 	layer: () => layer,
@@ -29,5 +29,4 @@ function layer(group, options) {
 	}).pipe(Layer.provideMerge(storage));
 	return Protocol.bind(protocol, group).pipe(Layer.provideMerge(storage));
 }
-//#endregion
 export { durable_object_storage_exports as DurableObjectStorage };

package/dist/index.d.ts

@@ -1,6 +1,5 @@
-import { a as layerProtocol, c as DEFAULT_TRANSACTION_RETRY_DELAY_MS, i as layer, n as Options, o as clientLayer, s as DEFAULT_TRANSACTION_RETRY_ATTEMPTS, t as DEFAULT_REPAIR_INTERVAL_MS } from "./storage-CrMmTyyG.js";
+import { a as layerProtocol, c as DEFAULT_TRANSACTION_RETRY_DELAY_MS, i as layer, n as Options, o as clientLayer, s as DEFAULT_TRANSACTION_RETRY_ATTEMPTS, t as DEFAULT_REPAIR_INTERVAL_MS } from "./storage-Cb_kOO_g.js";
 declare namespace sql_storage_d_exports {
   export { DEFAULT_REPAIR_INTERVAL_MS, DEFAULT_TRANSACTION_RETRY_ATTEMPTS, DEFAULT_TRANSACTION_RETRY_DELAY_MS, Options, clientLayer, layer, layerProtocol };
 }
-//#endregion
 export { sql_storage_d_exports as SqlStorage };

package/dist/index.js

@@ -1,6 +1,6 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { l as clientLayer, n as layer, r as layerProtocol, t as DEFAULT_REPAIR_INTERVAL_MS } from "./storage-CpnFxwO5.js";
-//#region src/sql-storage.ts
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.js";
+import { l as clientLayer, n as layer, r as layerProtocol, t as DEFAULT_REPAIR_INTERVAL_MS } from "./storage-DFCZf1UK.js";
+// src/sql-storage.ts
 var sql_storage_exports = /* @__PURE__ */ __exportAll({
 	DEFAULT_REPAIR_INTERVAL_MS: () => DEFAULT_REPAIR_INTERVAL_MS,
 	DEFAULT_TRANSACTION_RETRY_ATTEMPTS: () => 16,
@@ -9,5 +9,4 @@ var sql_storage_exports = /* @__PURE__ */ __exportAll({
 	layer: () => layer,
 	layerProtocol: () => layerProtocol
 });
-//#endregion
 export { sql_storage_exports as SqlStorage };

package/dist/{rolldown-runtime-D7D4PA-g.js → rolldown-runtime-D8jQpDG7.js}

@@ -1,4 +1,4 @@
-//#region \0rolldown/runtime.js
+// \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
 	let target = {};
@@ -9,5 +9,4 @@ var __exportAll = (all, no_symbols) => {
 	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
 	return target;
 };
-//#endregion
 export { __exportAll as t };

package/dist/{storage-CrMmTyyG.d.ts → storage-Cb_kOO_g.d.ts}

@@ -1,15 +1,11 @@
-import { Context, Effect, Layer, Queue, Scope, Stream } from "effect";
-import * as Reactivity from "effect/reactivity/Reactivity";
-import * as SqlClient from "effect/sql/SqlClient";
-import "effect/sql/SqlError";
+import { Context, Effect, Layer, PubSub, Queue, Scope, Stream } from "effect";
+import { Reactivity } from "effect/reactivity";
+import { SqlClient, SqlError } from "effect/sql";
 import { OwnerRecords } from "@streamsy/core/internal";
-import { CommitBoundary, Storage, StorageFault, Streamsy } from "@streamsy/core";
+import { CommitBoundary, Storage, StorageFault, StreamId, Streamsy } from "@streamsy/core";
 import { Protocol } from "@streamsy/core/protocol";
-//#region src/transaction-retry.d.ts
 declare const DEFAULT_TRANSACTION_RETRY_ATTEMPTS = 16;
 declare const DEFAULT_TRANSACTION_RETRY_DELAY_MS = 25;
-//#endregion
-//#region src/boundary.d.ts
 /**
  * Build a `SqlClient` and provide it with the `Reactivity` it captured, so the
  * client and the storage boundary share one change graph.
@@ -21,8 +17,6 @@ declare const DEFAULT_TRANSACTION_RETRY_DELAY_MS = 25;
  * ```
  */
 declare const clientLayer: <A extends SqlClient.SqlClient, E>(makeClient: Effect.Effect<A, E, Scope.Scope | Reactivity.Reactivity>) => Layer.Layer<SqlClient.SqlClient | Reactivity.Reactivity, E>;
-//#endregion
-//#region src/storage.d.ts
 declare const DEFAULT_REPAIR_INTERVAL_MS = 1000;
 interface SqlStorageOptions {
   /** Cross-process and post-commit-interruption staleness bound. */
@@ -39,5 +33,4 @@ interface Options extends SqlStorageOptions, Protocol.ProtocolOptions {}
 /** Protocol over SQL storage. */
 declare const layerProtocol: (options?: Options) => Layer.Layer<CommitBoundary | OwnerRecords | Storage | import("@streamsy/core/protocol").StreamsReader | import("@streamsy/core/protocol").StreamsWriter, StorageFault, Reactivity.Reactivity | SqlClient.SqlClient>;
 declare function layer<const Keys extends ReadonlyArray<Streamsy.Any>>(group: Streamsy.Group<Keys>, options?: Options): Layer.Layer<Layer.Success<ReturnType<typeof storageLayer>> | Streamsy.Host<Streamsy.Group<Keys>>, Layer.Error<ReturnType<typeof storageLayer>>, Layer.Services<ReturnType<typeof storageLayer>>>;
-//#endregion
 export { layerProtocol as a, DEFAULT_TRANSACTION_RETRY_DELAY_MS as c, layer as i, Options as n, clientLayer as o, SqlStorageOptions as r, DEFAULT_TRANSACTION_RETRY_ATTEMPTS as s, DEFAULT_REPAIR_INTERVAL_MS as t };

package/dist/{storage-CpnFxwO5.js → storage-DFCZf1UK.js}

@@ -1,8 +1,6 @@
-import { Clock, Context, Deferred, Effect, Fiber, Layer, Option, Predicate, Queue, Schedule, Schema, Stream } from "effect";
-import * as Scheduler from "effect/Scheduler";
-import * as Reactivity from "effect/reactivity/Reactivity";
-import * as SqlClient from "effect/sql/SqlClient";
-import { isSqlError } from "effect/sql/SqlError";
+import { Array, Clock, Context, Deferred, Effect, Fiber, Layer, Option, Order, Predicate, PubSub, Queue, Schedule, Scheduler, Schema, Stream } from "effect";
+import { Reactivity } from "effect/reactivity";
+import { SqlClient, SqlError } from "effect/sql";
 import { OwnerRecords, attachOwner, ownerOf } from "@streamsy/core/internal";
 import { CommitBoundary, MutationRejected, Mutations, Offset, OperationResults, Storage, StorageFault, StreamId, ZERO_OFFSET } from "@streamsy/core";
 import { Protocol } from "@streamsy/core/protocol";
@@ -22,8 +20,7 @@ const retryWithPolicy = (transaction, policy, isRetryable) => transaction.pipe(E
 	schedule: Schedule.spaced(policy.delayMs),
 	while: isRetryable
 }));
-//#endregion
-//#region src/boundary.ts
+// src/boundary.ts
 var PendingInvalidations = class extends Context.Service()("@streamsy/storage/PendingInvalidations") {};
 const noop = () => {};
 var BoundaryRuntimeService = class extends Context.Service()("@streamsy/storage/BoundaryRuntime") {};
@@ -44,6 +41,7 @@ const makeBoundary = (repairIntervalMs, transactionRetry, probe, transactionMaxO
 	const sql = yield* SqlClient.SqlClient;
 	const reactivity = yield* Reactivity.Reactivity;
 	const subscriptions = /* @__PURE__ */ new Set();
+	const feed = yield* Effect.acquireRelease(PubSub.unbounded(), PubSub.shutdown);
 	let closed = false;
 	yield* Effect.addFinalizer(() => Effect.gen(function* () {
 		const active = yield* Effect.sync(() => {
@@ -55,17 +53,20 @@ const makeBoundary = (repairIntervalMs, transactionRetry, probe, transactionMaxO
 	}));
 	const ownedTransaction = (body) => Effect.suspend(() => {
 		if (probe !== void 0) probe.transactionAttempts += 1;
-		const pending = /* @__PURE__ */ new Set();
+		const pending = {
+			keys: /* @__PURE__ */ new Set(),
+			ids: /* @__PURE__ */ new Set()
+		};
 		let bodyCompleted = false;
 		const transactionBody = body.pipe(Effect.provideService(PendingInvalidations, pending), Effect.tap(() => Effect.sync(() => {
 			bodyCompleted = true;
 		})));
-		const transaction = sql.withTransaction(transactionBody).pipe(Effect.catchIf((error) => bodyCompleted && isSqlError(error), (error) => Effect.die(error)));
+		const transaction = sql.withTransaction(transactionBody).pipe(Effect.catchIf((error) => bodyCompleted && SqlError.isSqlError(error), (error) => Effect.die(error)));
 		return (transactionMaxOpsBeforeYield === void 0 ? transaction : transaction.pipe(Effect.provideService(Scheduler.MaxOpsBeforeYield, transactionMaxOpsBeforeYield))).pipe(Effect.tap(() => {
-			if (pending.size === 0) return Effect.void;
+			if (pending.keys.size === 0) return Effect.void;
 			if (probe !== void 0) probe.invalidations += 1;
-			return reactivity.invalidate([...pending]);
-		}));
+			return reactivity.invalidate([...pending.keys]);
+		}), Effect.tap(() => pending.ids.size === 0 ? Effect.void : PubSub.publish(feed, [...pending.ids])));
 	});
 	const withTransaction = (body) => Effect.flatMap(Effect.serviceOption(PendingInvalidations), (owned) => {
 		if (Option.isSome(owned)) return body;
@@ -74,15 +75,16 @@ const makeBoundary = (repairIntervalMs, transactionRetry, probe, transactionMaxO
 			return ownedTransaction(body);
 		});
 	});
-	const mutation = ({ keys, effect, retryable }) => Effect.flatMap(Effect.serviceOption(sql.transactionService), (ambient) => Effect.flatMap(Effect.serviceOption(PendingInvalidations), (pendingBefore) => {
+	const mutation = ({ keys, ids, effect, retryable }) => Effect.flatMap(Effect.serviceOption(sql.transactionService), (ambient) => Effect.flatMap(Effect.serviceOption(PendingInvalidations), (pendingBefore) => {
 		if (Option.isSome(ambient) && Option.isNone(pendingBefore)) return Effect.die(/* @__PURE__ */ new Error("Ambient SQL transaction is not owned by CommitBoundary"));
 		const run = Effect.tap(effect, () => Effect.flatMap(Effect.serviceOption(PendingInvalidations), (pending) => {
 			if (Option.isNone(pending)) return Effect.die(/* @__PURE__ */ new Error("CommitBoundary owner context disappeared"));
 			return Effect.sync(() => {
-				for (const key of keys) pending.value.add(key);
+				for (const key of keys) pending.value.keys.add(key);
+				for (const id of ids) pending.value.ids.add(id);
 			});
 		}));
-		return Option.isSome(ambient) ? run : retryWithPolicy(ownedTransaction(run), transactionRetry, (error) => isSqlError(error) ? error.isRetryable : retryable(error));
+		return Option.isSome(ambient) ? run : retryWithPolicy(ownedTransaction(run), transactionRetry, (error) => SqlError.isSqlError(error) ? error.isRetryable : retryable(error));
 	})).pipe(Effect.onExit(() => Effect.sync(() => {
 		if (probe !== void 0) probe.completedMutations += 1;
 	})));
@@ -137,12 +139,12 @@ const makeBoundary = (repairIntervalMs, transactionRetry, probe, transactionMaxO
 	return {
 		withTransaction,
 		mutation,
-		changes
+		changes,
+		committed: PubSub.subscribe(feed)
 	};
 });
 const boundaryLayer = (repairIntervalMs, transactionRetry, probe, transactionMaxOpsBeforeYield) => Layer.effect(BoundaryRuntimeService, makeBoundary(repairIntervalMs, transactionRetry, probe, transactionMaxOpsBeforeYield));
-//#endregion
-//#region src/dialect.ts
+// src/dialect.ts
 /** The client's dialect. Other dialects fail with a non-retryable fault. */
 const storageDialect = (sql) => sql.onDialectOrElse({
 	sqlite: () => Effect.succeed("sqlite"),
@@ -154,8 +156,7 @@ const storageDialect = (sql) => sql.onDialectOrElse({
 		retryable: false
 	}))
 });
-//#endregion
-//#region src/schema.ts
+// src/schema.ts
 const STORAGE_VERSION_TABLE = "streamsy_schema";
 /** Version tables of earlier formats. A database that holds one must not be migrated. */
 const LEGACY_VERSION_TABLES = ["streamsy_schema_version", "streamsy_storage_schema_version"];
@@ -258,8 +259,7 @@ const STORAGE_MIGRATIONS = [{
 ) ENGINE=InnoDB`
 	]
 }];
-//#endregion
-//#region src/migrations.ts
+// src/migrations.ts
 /** Fixed `pg_advisory_xact_lock` key: "streamsy" in ASCII, read as a 64-bit integer. */
 const PG_MIGRATION_LOCK_KEY = "8319400191411975033";
 /** Named lock that serialises MySQL migrations, whose DDL cannot share one transaction. */
@@ -275,7 +275,7 @@ const sqlAttempt = (operation, effect) => effect.pipe(Effect.mapError((error) =>
 /** Return whether the database already holds this format, or fail on an older format. */
 const inspectFormat = (tables) => {
 	const ownsFormat = tables.has(STORAGE_VERSION_TABLE);
-	return LEGACY_VERSION_TABLES.some((name) => tables.has(name)) || !ownsFormat && STORAGE_TABLES.some((name) => tables.has(name)) ? Effect.fail(new StorageFault({
+	return Array.some(LEGACY_VERSION_TABLES, (name) => tables.has(name)) || !ownsFormat && Array.some(STORAGE_TABLES, (name) => tables.has(name)) ? Effect.fail(new StorageFault({
 		operation: "migration.open",
 		message: "Unsupported older Streamsy storage format; use a fresh database path (the database was not modified)",
 		retryable: false
@@ -292,7 +292,7 @@ const listTables = (sql, dialect) => sqlAttempt("migration.inspect", {
  WHERE table_schema = current_schema()`,
 	mysql: () => sql`SELECT table_name AS name FROM information_schema.tables
  WHERE table_schema = DATABASE()`
-}[dialect]()).pipe(Effect.map((rows) => new Set(rows.map(({ name }) => name))));
+}[dialect]()).pipe(Effect.map((rows) => new Set(Array.map(rows, ({ name }) => name))));
 const migrateVersions = (sql, dialect, hooks) => Effect.gen(function* () {
 	if (!(yield* inspectFormat(yield* listTables(sql, dialect)))) yield* sqlAttempt("migration.create-version-table", sql.unsafe(STORAGE_VERSION_TABLE_DDL[dialect]).pipe(Effect.asVoid));
 	const current = yield* sqlAttempt("migration.read-version", sql`SELECT MAX(version) AS version FROM ${sql(STORAGE_VERSION_TABLE)}`.pipe(Effect.map((rows) => Number(rows[0]?.version ?? 0))));
@@ -332,9 +332,8 @@ const migrate = (sql, hooks = {}, transactionRetry = transactionRetryPolicy({}))
 	hooks.onTransactionAttempt?.();
 	if (dialect === "mysql") return migrateMysql(sql, hooks);
 	return sql.withTransaction(dialect === "pg" ? sqlAttempt("migration.lock", sql`SELECT pg_advisory_xact_lock(${sql.literal(PG_MIGRATION_LOCK_KEY)})`).pipe(Effect.andThen(migrateVersions(sql, dialect, hooks))) : migrateVersions(sql, dialect, hooks));
-}), transactionRetry, (error) => isSqlError(error) ? error.isRetryable : error.retryable).pipe(Effect.catchIf(isSqlError, (error) => Effect.fail(fault("migration.transaction", error)))));
-//#endregion
-//#region src/storage.ts
+}), transactionRetry, (error) => SqlError.isSqlError(error) ? error.isRetryable : error.retryable).pipe(Effect.catchIf(SqlError.isSqlError, (error) => Effect.fail(fault("migration.transaction", error)))));
+// src/storage.ts
 const DEFAULT_REPAIR_INTERVAL_MS = 1e3;
 const STORAGE_KEY = "streamsy:storage";
 const RecordRow = Schema.Struct({
@@ -467,7 +466,7 @@ const oversizedKey = (mutation) => {
 * Sorted ids give every writer one lock order. SQLite already has one writer.
 */
 const lockStreams = (sql, ids) => {
-	const sorted = [...new Set(ids)].toSorted();
+	const sorted = Array.sort(new Set(ids), Order.String);
 	return sql.onDialectOrElse({
 		sqlite: () => Effect.void,
 		orElse: () => execute("mutate.lock", sql`SELECT stream_id FROM streamsy_streams WHERE stream_id IN ${sql.in(sorted)}
@@ -493,7 +492,7 @@ const lockingRead = (sql, lock) => sql.onDialectOrElse({
 * mutation. Outside a transaction the read stays plain and takes no lock.
 */
 const planningLock = (sql) => Effect.map(Effect.serviceOption(sql.transactionService), (open) => Option.isSome(open) ? "update" : void 0);
-const lockIds = (mutation) => mutation.operations.flatMap((operation) => Predicate.isTagged(operation, "Create") ? operation.forkSource === void 0 ? [operation.record.id] : [operation.record.id, operation.forkSource.id] : [operation.streamId]);
+const lockIds = (mutation) => Array.flatMap(mutation.operations, (operation) => Predicate.isTagged(operation, "Create") ? operation.forkSource === void 0 ? [operation.record.id] : [operation.record.id, operation.forkSource.id] : [operation.streamId]);
 const recordColumns = (sql) => sql.literal("stream_id,content_type,ttl_seconds,expires_at,created_at,current_offset,last_seq,closed,closed_at,forked_from,fork_offset,fork_sub_offset,soft_deleted,expires_at_ms");
 const readRecord = (sql, id, lock) => attempt("record", sql`SELECT ${recordColumns(sql)} FROM streamsy_streams WHERE stream_id = ${id}${lockingRead(sql, lock)}`).pipe(Effect.flatMap((rows) => {
 	const row = rows[0];
@@ -689,7 +688,7 @@ const readMessages = (sql, id, window) => Effect.gen(function* () {
 		until = record.value.lifecycle.forkOffset;
 	}
 	const messages = [];
-	for (const segment of chain.toReversed()) {
+	for (const segment of Array.reverse(chain)) {
 		if (remaining === 0) break;
 		const upper = segment.until === void 0 ? window.until : window.until === void 0 || segment.until < window.until ? segment.until : window.until;
 		const predicates = [sql`stream_id = ${segment.id}`];
@@ -724,20 +723,22 @@ const makeStorage = (sql, boundary) => Storage.of({
 	messages: Effect.fn("SqlStorage.messages")((id, window) => readMessages(sql, id, window)),
 	producer: Effect.fn("SqlStorage.producer")((id, producerId) => Effect.flatMap(planningLock(sql), (lock) => readProducer(sql, "producer", id, producerId, lock))),
 	mutate: Effect.fn("SqlStorage.mutate")((mutation) => {
-		const ids = mutation.operations.map((operation) => Predicate.isTagged(operation, "Create") ? operation.record.id : operation.streamId);
+		const ids = Array.map(mutation.operations, (operation) => Predicate.isTagged(operation, "Create") ? operation.record.id : operation.streamId);
 		if (ids.length === 0 || new Set(ids).size !== ids.length) return Effect.die(/* @__PURE__ */ new Error("Mutation requires distinct streams within atomicScope"));
 		const oversized = oversizedKey(mutation);
 		if (Option.isSome(oversized)) return Effect.fail(oversized.value);
 		return boundary.mutation({
 			keys: [STORAGE_KEY],
+			ids,
 			effect: applyMutation(sql, mutation),
 			retryable: (error) => Predicate.isTagged(error, "StorageFault") && error.retryable
-		}).pipe(Effect.catchIf(isSqlError, (error) => Effect.fail(sqlFault("mutate.transaction", error))));
+		}).pipe(Effect.catchIf(SqlError.isSqlError, (error) => Effect.fail(sqlFault("mutate.transaction", error))));
 	}),
 	changes: (id) => boundary.changes({
 		keys: [STORAGE_KEY],
 		read: snapshot(sql, id)
 	}),
+	committed: boundary.committed,
 	nextExpiry: attempt("nextExpiry", sql`SELECT expires_at_ms AS at, stream_id FROM streamsy_streams
  WHERE expires_at_ms IS NOT NULL AND soft_deleted = 0
  ORDER BY expires_at_ms, stream_id LIMIT 1`).pipe(Effect.flatMap((rows) => rows[0] === void 0 ? Effect.succeed(Option.none()) : decodeExpiryRow(rows[0]).pipe(Effect.map(({ at, stream_id: streamId }) => Option.some({
@@ -834,5 +835,4 @@ function layer(group, options = {}) {
 	const protocol = Protocol.layer(options).pipe(Layer.provideMerge(storage));
 	return Protocol.bind(protocol, group).pipe(Layer.provideMerge(storage));
 }
-//#endregion
 export { storageLayer as a, STORAGE_VERSION_TABLE as c, retryWithPolicy as d, transactionRetryPolicy as f, layerWithDurableObjectTransactions as i, clientLayer as l, layer as n, inspectFormat as o, layerProtocol as r, newerVersionFault as s, DEFAULT_REPAIR_INTERVAL_MS as t, sharedSqlClientLayer as u };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@streamsy/storage",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Effect SQL storage for Streamsy on SQLite, Postgres and MySQL, with Bun and Durable Object SQLite host layers.",
   "license": "MIT",
   "repository": {
@@ -42,7 +42,7 @@
     "test:dialects": "bun --bun vitest run test/dialects"
   },
   "dependencies": {
-    "@streamsy/core": "^0.4.0"
+    "@streamsy/core": "^0.6.0"
   },
   "devDependencies": {
     "@cloudflare/workers-types": "4.20251228.0",
@@ -52,7 +52,7 @@
     "@effect/sql-sqlite-bun": "4.0.5",
     "@effect/sql-sqlite-do": "4.0.5",
     "@effect/vitest": "4.0.5",
-    "@streamsy/serve": "0.4.0",
+    "@streamsy/serve": "0.6.0",
     "@types/bun": "^1.4.3",
     "effect": "4.0.5",
     "miniflare": "4.20260730.0",