@streamsy/storage 0.0.0-stage → 0.4.0

package/dist/storage-CpnFxwO5.js

@@ -0,0 +1,838 @@
+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 { 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";
+const transactionRetryPolicy = (options) => {
+	const attempts = options.transactionRetryAttempts ?? 16;
+	const delayMs = options.transactionRetryDelayMs ?? 25;
+	if (!Number.isSafeInteger(attempts) || attempts <= 0) throw new RangeError("transactionRetryAttempts must be a positive safe integer");
+	if (!Number.isFinite(delayMs) || delayMs <= 0) throw new RangeError("transactionRetryDelayMs must be positive");
+	return {
+		attempts,
+		delayMs
+	};
+};
+/** Retry only explicitly classified failures; defects and interruption are never retried. */
+const retryWithPolicy = (transaction, policy, isRetryable) => transaction.pipe(Effect.retry({
+	times: policy.attempts - 1,
+	schedule: Schedule.spaced(policy.delayMs),
+	while: isRetryable
+}));
+//#endregion
+//#region src/boundary.ts
+var PendingInvalidations = class extends Context.Service()("@streamsy/storage/PendingInvalidations") {};
+const noop = () => {};
+var BoundaryRuntimeService = class extends Context.Service()("@streamsy/storage/BoundaryRuntime") {};
+const sharedSqlClientLayer = (makeClient) => Context.empty().pipe(Effect.succeed, Effect.flatMap(() => Reactivity.make), Effect.flatMap((reactivity) => makeClient.pipe(Effect.provideService(Reactivity.Reactivity, reactivity), Effect.map((client) => Context.empty().pipe(Context.add(SqlClient.SqlClient, client), Context.add(Reactivity.Reactivity, reactivity))))));
+/**
+* Build a `SqlClient` and provide it with the `Reactivity` it captured, so the
+* client and the storage boundary share one change graph.
+*
+* ```ts
+* const storage = Storage.layer(streams).pipe(
+*   Layer.provide(Storage.clientLayer(PgClient.make({ url: Redacted.make(url) }))),
+* );
+* ```
+*/
+const clientLayer = (makeClient) => Layer.effectContext(sharedSqlClientLayer(makeClient));
+const makeBoundary = (repairIntervalMs, transactionRetry, probe, transactionMaxOpsBeforeYield) => Effect.gen(function* () {
+	if (!Number.isFinite(repairIntervalMs) || repairIntervalMs <= 0) return yield* Effect.die(/* @__PURE__ */ new RangeError("repairIntervalMs must be positive"));
+	const sql = yield* SqlClient.SqlClient;
+	const reactivity = yield* Reactivity.Reactivity;
+	const subscriptions = /* @__PURE__ */ new Set();
+	let closed = false;
+	yield* Effect.addFinalizer(() => Effect.gen(function* () {
+		const active = yield* Effect.sync(() => {
+			closed = true;
+			if (probe !== void 0) probe.closed = true;
+			return [...subscriptions];
+		});
+		for (const subscription of active) yield* subscription.cleanup;
+	}));
+	const ownedTransaction = (body) => Effect.suspend(() => {
+		if (probe !== void 0) probe.transactionAttempts += 1;
+		const pending = /* @__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)));
+		return (transactionMaxOpsBeforeYield === void 0 ? transaction : transaction.pipe(Effect.provideService(Scheduler.MaxOpsBeforeYield, transactionMaxOpsBeforeYield))).pipe(Effect.tap(() => {
+			if (pending.size === 0) return Effect.void;
+			if (probe !== void 0) probe.invalidations += 1;
+			return reactivity.invalidate([...pending]);
+		}));
+	});
+	const withTransaction = (body) => Effect.flatMap(Effect.serviceOption(PendingInvalidations), (owned) => {
+		if (Option.isSome(owned)) return body;
+		return Effect.flatMap(Effect.serviceOption(sql.transactionService), (ambient) => {
+			if (Option.isSome(ambient)) return Effect.die(/* @__PURE__ */ new Error("Commit boundary cannot enter an unowned ambient SQL transaction"));
+			return ownedTransaction(body);
+		});
+	});
+	const mutation = ({ keys, 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);
+			});
+		}));
+		return Option.isSome(ambient) ? run : retryWithPolicy(ownedTransaction(run), transactionRetry, (error) => isSqlError(error) ? error.isRetryable : retryable(error));
+	})).pipe(Effect.onExit(() => Effect.sync(() => {
+		if (probe !== void 0) probe.completedMutations += 1;
+	})));
+	const changes = ({ keys, read }) => Stream.unwrap(Effect.gen(function* () {
+		const subscription = yield* Effect.acquireRelease(Effect.gen(function* () {
+			const queue = yield* Queue.make({
+				capacity: 1,
+				strategy: "dropping"
+			});
+			const repairStarted = yield* Deferred.make();
+			const repairFiber = yield* Effect.acquireUseRelease(Effect.sync(() => {
+				if (probe !== void 0) probe.activeRepairFibers += 1;
+			}), () => Deferred.succeed(repairStarted, void 0).pipe(Effect.andThen(Effect.sleep(repairIntervalMs)), Effect.andThen(Effect.suspend(() => {
+				if (probe?.repairsPaused === true) return Effect.void;
+				if (probe !== void 0) probe.repairPasses += 1;
+				return Queue.offer(queue, void 0);
+			})), Effect.repeat(Schedule.forever)), () => Effect.sync(() => {
+				if (probe !== void 0) probe.activeRepairFibers -= 1;
+			})).pipe(Effect.forkScoped);
+			yield* Deferred.await(repairStarted);
+			let cleaned = false;
+			let cancel = noop;
+			const active = {
+				queue,
+				cleanup: Effect.suspend(() => {
+					if (cleaned) return Effect.void;
+					cleaned = true;
+					subscriptions.delete(active);
+					probe?.queues.delete(queue);
+					if (probe !== void 0) probe.activeRegistrations -= 1;
+					cancel();
+					return Fiber.interrupt(repairFiber).pipe(Effect.andThen(Queue.shutdown(queue)));
+				})
+			};
+			if (!(yield* Effect.sync(() => {
+				if (closed) return false;
+				cancel = reactivity.registerUnsafe(keys, () => Queue.offerUnsafe(queue, void 0));
+				subscriptions.add(active);
+				probe?.queues.add(queue);
+				if (probe !== void 0) probe.activeRegistrations += 1;
+				return true;
+			}))) {
+				yield* Fiber.interrupt(repairFiber);
+				yield* Queue.shutdown(queue);
+				return yield* Effect.interrupt;
+			}
+			if (probe?.afterRegister !== void 0) yield* probe.afterRegister;
+			return active;
+		}), (active) => active.cleanup);
+		return Stream.concat(Stream.fromEffect(read), Stream.fromQueue(subscription.queue).pipe(Stream.mapEffect(() => read)));
+	}));
+	return {
+		withTransaction,
+		mutation,
+		changes
+	};
+});
+const boundaryLayer = (repairIntervalMs, transactionRetry, probe, transactionMaxOpsBeforeYield) => Layer.effect(BoundaryRuntimeService, makeBoundary(repairIntervalMs, transactionRetry, probe, transactionMaxOpsBeforeYield));
+//#endregion
+//#region src/dialect.ts
+/** The client's dialect. Other dialects fail with a non-retryable fault. */
+const storageDialect = (sql) => sql.onDialectOrElse({
+	sqlite: () => Effect.succeed("sqlite"),
+	pg: () => Effect.succeed("pg"),
+	mysql: () => Effect.succeed("mysql"),
+	orElse: () => Effect.fail(new StorageFault({
+		operation: "storage.dialect",
+		message: "Unsupported SQL dialect; Streamsy storage supports sqlite, pg and mysql",
+		retryable: false
+	}))
+});
+//#endregion
+//#region 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"];
+const STORAGE_TABLES = [
+	"streamsy_streams",
+	"streamsy_messages",
+	"streamsy_producers",
+	"streamsy_owner_records"
+];
+const STORAGE_VERSION_TABLE_DDL = {
+	sqlite: `CREATE TABLE ${STORAGE_VERSION_TABLE} (version INTEGER PRIMARY KEY, applied_at_ms INTEGER NOT NULL)`,
+	pg: `CREATE TABLE ${STORAGE_VERSION_TABLE} (version INTEGER PRIMARY KEY, applied_at_ms BIGINT NOT NULL)`,
+	mysql: `CREATE TABLE IF NOT EXISTS ${STORAGE_VERSION_TABLE} (version INT PRIMARY KEY, applied_at_ms BIGINT NOT NULL) ENGINE=InnoDB`
+};
+const MYSQL_STREAM_ID = "VARCHAR(512) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_bin";
+const MYSQL_PRODUCER_ID = "VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_bin";
+const MYSQL_OFFSET = "VARCHAR(33) CHARACTER SET ascii COLLATE ascii_bin";
+/**
+* Migration versions in order. Version `n` is entry `n - 1`. SQLite and
+* Postgres run one version inside the migration transaction. MySQL commits
+* each DDL statement by itself, so every MySQL statement must be safe to run
+* twice.
+*/
+const STORAGE_MIGRATIONS = [{
+	sqlite: [
+		`CREATE TABLE streamsy_streams (
+ stream_id TEXT PRIMARY KEY, content_type TEXT NOT NULL, ttl_seconds REAL, expires_at TEXT,
+ created_at REAL NOT NULL, current_offset TEXT NOT NULL, last_seq TEXT, closed INTEGER NOT NULL,
+ closed_at REAL, forked_from TEXT, fork_offset TEXT, fork_sub_offset REAL,
+ soft_deleted INTEGER NOT NULL, expires_at_ms REAL
+)`,
+		`CREATE TABLE streamsy_messages (
+ stream_id TEXT NOT NULL, msg_offset TEXT NOT NULL, timestamp REAL NOT NULL, data BLOB NOT NULL,
+ PRIMARY KEY(stream_id, msg_offset),
+ FOREIGN KEY(stream_id) REFERENCES streamsy_streams(stream_id) ON DELETE CASCADE
+)`,
+		`CREATE TABLE streamsy_producers (
+ stream_id TEXT NOT NULL, producer_id TEXT NOT NULL, epoch REAL NOT NULL, last_seq REAL NOT NULL,
+ PRIMARY KEY(stream_id, producer_id),
+ FOREIGN KEY(stream_id) REFERENCES streamsy_streams(stream_id) ON DELETE CASCADE
+)`,
+		`CREATE INDEX idx_streamsy_streams_forked_from ON streamsy_streams(forked_from)
+ WHERE forked_from IS NOT NULL`,
+		`CREATE INDEX idx_streamsy_streams_expiry ON streamsy_streams(expires_at_ms, stream_id)
+ WHERE expires_at_ms IS NOT NULL AND soft_deleted = 0`,
+		`CREATE TABLE streamsy_owner_records (owner_key TEXT PRIMARY KEY, owner_value TEXT NOT NULL)`
+	],
+	pg: [
+		`CREATE TABLE streamsy_streams (
+ stream_id TEXT COLLATE "C" PRIMARY KEY, content_type TEXT NOT NULL,
+ ttl_seconds DOUBLE PRECISION, expires_at TEXT, created_at DOUBLE PRECISION NOT NULL,
+ current_offset TEXT COLLATE "C" NOT NULL, last_seq TEXT, closed SMALLINT NOT NULL,
+ closed_at DOUBLE PRECISION, forked_from TEXT COLLATE "C", fork_offset TEXT COLLATE "C",
+ fork_sub_offset DOUBLE PRECISION, soft_deleted SMALLINT NOT NULL, expires_at_ms DOUBLE PRECISION
+)`,
+		`CREATE TABLE streamsy_messages (
+ stream_id TEXT COLLATE "C" NOT NULL, msg_offset TEXT COLLATE "C" NOT NULL,
+ timestamp DOUBLE PRECISION NOT NULL, data BYTEA NOT NULL,
+ PRIMARY KEY(stream_id, msg_offset),
+ FOREIGN KEY(stream_id) REFERENCES streamsy_streams(stream_id) ON DELETE CASCADE
+)`,
+		`CREATE TABLE streamsy_producers (
+ stream_id TEXT COLLATE "C" NOT NULL, producer_id TEXT COLLATE "C" NOT NULL,
+ epoch DOUBLE PRECISION NOT NULL, last_seq DOUBLE PRECISION NOT NULL,
+ PRIMARY KEY(stream_id, producer_id),
+ FOREIGN KEY(stream_id) REFERENCES streamsy_streams(stream_id) ON DELETE CASCADE
+)`,
+		`CREATE INDEX idx_streamsy_streams_forked_from ON streamsy_streams(forked_from)
+ WHERE forked_from IS NOT NULL`,
+		`CREATE INDEX idx_streamsy_streams_expiry ON streamsy_streams(expires_at_ms, stream_id)
+ WHERE expires_at_ms IS NOT NULL AND soft_deleted = 0`,
+		`CREATE TABLE streamsy_owner_records (
+ owner_key TEXT COLLATE "C" PRIMARY KEY, owner_value TEXT NOT NULL
+)`
+	],
+	mysql: [
+		`CREATE TABLE IF NOT EXISTS streamsy_streams (
+ stream_id ${MYSQL_STREAM_ID} PRIMARY KEY, content_type TEXT NOT NULL, ttl_seconds DOUBLE,
+ expires_at TEXT, created_at DOUBLE NOT NULL, current_offset ${MYSQL_OFFSET} NOT NULL,
+ last_seq TEXT, closed TINYINT NOT NULL, closed_at DOUBLE, forked_from ${MYSQL_STREAM_ID},
+ fork_offset ${MYSQL_OFFSET}, fork_sub_offset DOUBLE, soft_deleted TINYINT NOT NULL,
+ expires_at_ms DOUBLE,
+ INDEX idx_streamsy_streams_forked_from (forked_from),
+ INDEX idx_streamsy_streams_expiry (expires_at_ms, stream_id)
+) ENGINE=InnoDB`,
+		`CREATE TABLE IF NOT EXISTS streamsy_messages (
+ stream_id ${MYSQL_STREAM_ID} NOT NULL, msg_offset ${MYSQL_OFFSET} NOT NULL,
+ timestamp DOUBLE NOT NULL, data LONGBLOB NOT NULL,
+ PRIMARY KEY(stream_id, msg_offset),
+ FOREIGN KEY(stream_id) REFERENCES streamsy_streams(stream_id) ON DELETE CASCADE
+) ENGINE=InnoDB`,
+		`CREATE TABLE IF NOT EXISTS streamsy_producers (
+ stream_id ${MYSQL_STREAM_ID} NOT NULL, producer_id ${MYSQL_PRODUCER_ID} NOT NULL,
+ epoch DOUBLE NOT NULL, last_seq DOUBLE NOT NULL,
+ PRIMARY KEY(stream_id, producer_id),
+ FOREIGN KEY(stream_id) REFERENCES streamsy_streams(stream_id) ON DELETE CASCADE
+) ENGINE=InnoDB`,
+		`CREATE TABLE IF NOT EXISTS streamsy_owner_records (
+ owner_key VARCHAR(512) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_bin PRIMARY KEY, owner_value LONGTEXT NOT NULL
+) ENGINE=InnoDB`
+	]
+}];
+//#endregion
+//#region 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. */
+const MYSQL_MIGRATION_LOCK = STORAGE_VERSION_TABLE;
+const MYSQL_MIGRATION_LOCK_TIMEOUT_SECONDS = 30;
+const fault = (operation, error) => new StorageFault({
+	operation,
+	message: error.message,
+	retryable: error.isRetryable,
+	cause: error
+});
+const sqlAttempt = (operation, effect) => effect.pipe(Effect.mapError((error) => fault(operation, 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({
+		operation: "migration.open",
+		message: "Unsupported older Streamsy storage format; use a fresh database path (the database was not modified)",
+		retryable: false
+	})) : Effect.succeed(ownsFormat);
+};
+const newerVersionFault = (version) => new StorageFault({
+	operation: "migration.open",
+	message: `Unsupported newer Streamsy storage schema version ${version}; supported version is 1`,
+	retryable: false
+});
+const listTables = (sql, dialect) => sqlAttempt("migration.inspect", {
+	sqlite: () => sql`SELECT name FROM sqlite_master WHERE type = 'table'`,
+	pg: () => sql`SELECT table_name AS name FROM information_schema.tables
+ 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))));
+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))));
+	if (current > 1) return yield* newerVersionFault(current);
+	for (let version = current + 1; version <= 1; version++) {
+		if (hooks.beforeVersion !== void 0) yield* hooks.beforeVersion(version);
+		const statements = STORAGE_MIGRATIONS[version - 1]?.[dialect];
+		if (statements === void 0) return yield* Effect.die(/* @__PURE__ */ new Error("Missing migration"));
+		for (const statement of statements) yield* sqlAttempt(`migration.apply.${version}`, sql.unsafe(statement).pipe(Effect.asVoid));
+		const appliedAtMs = yield* Clock.currentTimeMillis;
+		yield* sqlAttempt(`migration.record.${version}`, (dialect === "mysql" ? sql`INSERT INTO ${sql(STORAGE_VERSION_TABLE)} (version, applied_at_ms) VALUES (${version}, ${appliedAtMs})
+ ON DUPLICATE KEY UPDATE applied_at_ms = applied_at_ms` : sql`INSERT INTO ${sql(STORAGE_VERSION_TABLE)} (version, applied_at_ms) VALUES (${version}, ${appliedAtMs})`).pipe(Effect.asVoid));
+	}
+});
+/**
+* MySQL commits each DDL statement by itself, so one transaction cannot hold
+* the migration. A named lock on one reserved connection serialises
+* instances instead, and every MySQL statement is safe to run twice.
+*/
+const migrateMysql = (sql, hooks) => Effect.scoped(Effect.gen(function* () {
+	const connection = yield* sqlAttempt("migration.connection", sql.reserve);
+	return yield* Effect.provideService(Effect.acquireUseRelease(sqlAttempt("migration.lock", sql`SELECT GET_LOCK(${MYSQL_MIGRATION_LOCK}, ${MYSQL_MIGRATION_LOCK_TIMEOUT_SECONDS}) AS acquired`).pipe(Effect.flatMap((rows) => Number(rows[0]?.acquired ?? 0) === 1 ? Effect.void : Effect.fail(new StorageFault({
+		operation: "migration.lock",
+		message: `Timed out waiting for the MySQL migration lock ${MYSQL_MIGRATION_LOCK}`,
+		retryable: false
+	})))), () => migrateVersions(sql, "mysql", hooks), () => sql`SELECT RELEASE_LOCK(${MYSQL_MIGRATION_LOCK})`.pipe(Effect.ignore)), sql.transactionService, [connection, 0]);
+}));
+/**
+* Migrate one fresh-format database. SQLite and Postgres run under a single
+* write transaction: the legacy check runs before the first write, and every
+* schema and version statement rolls back together if acquisition is
+* interrupted or a migration fails. Postgres takes an advisory lock first, so
+* concurrent instances migrate one after the other. MySQL uses a named lock
+* and statements that are safe to run twice.
+*/
+const migrate = (sql, hooks = {}, transactionRetry = transactionRetryPolicy({})) => Effect.flatMap(storageDialect(sql), (dialect) => retryWithPolicy(Effect.suspend(() => {
+	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
+const DEFAULT_REPAIR_INTERVAL_MS = 1e3;
+const STORAGE_KEY = "streamsy:storage";
+const RecordRow = Schema.Struct({
+	stream_id: StreamId,
+	content_type: Schema.String,
+	ttl_seconds: Schema.NullOr(Schema.Finite),
+	expires_at: Schema.NullOr(Schema.String),
+	created_at: Schema.Finite,
+	current_offset: Offset,
+	last_seq: Schema.NullOr(Schema.String),
+	closed: Schema.Literals([0, 1]),
+	closed_at: Schema.NullOr(Schema.Finite),
+	forked_from: Schema.NullOr(StreamId),
+	fork_offset: Schema.NullOr(Offset),
+	fork_sub_offset: Schema.NullOr(Schema.Finite),
+	soft_deleted: Schema.Literals([0, 1]),
+	expires_at_ms: Schema.NullOr(Schema.Finite)
+});
+const ProducerRow = Schema.Struct({
+	epoch: Schema.Finite,
+	last_seq: Schema.Finite
+});
+const ExpiryRow = Schema.Struct({
+	at: Schema.Finite,
+	stream_id: StreamId
+});
+const DependentsRow = Schema.Struct({ present: Schema.Literals([
+	0,
+	1,
+	0n,
+	1n,
+	false,
+	true
+]) });
+const SnapshotRow = Schema.Struct({
+	current_offset: Schema.NullOr(Offset),
+	closed: Schema.NullOr(Schema.Literals([0, 1])),
+	soft_deleted: Schema.NullOr(Schema.Literals([0, 1]))
+});
+const decodeRecordRow = (row) => Schema.decodeEffect(RecordRow)(row).pipe(Effect.orDie);
+const decodeProducerRow = (row) => Schema.decodeEffect(ProducerRow)(row).pipe(Effect.orDie);
+const decodeExpiryRow = (row) => Schema.decodeEffect(ExpiryRow)(row).pipe(Effect.orDie);
+const decodeSnapshotRow = (row) => Schema.decodeEffect(SnapshotRow)(row).pipe(Effect.orDie);
+const decodeDependentsRow = (row) => Schema.decodeEffect(DependentsRow)(row).pipe(Effect.orDie);
+const toRecord = (row) => {
+	const config = {
+		contentType: row.content_type,
+		createdAt: row.created_at
+	};
+	if (row.ttl_seconds !== null) config.ttlSeconds = row.ttl_seconds;
+	if (row.expires_at !== null) config.expiresAt = row.expires_at;
+	const lifecycle = {
+		closed: row.closed === 1,
+		softDeleted: row.soft_deleted === 1
+	};
+	if (row.last_seq !== null) lifecycle.lastSeq = row.last_seq;
+	if (row.closed_at !== null) lifecycle.closedAt = row.closed_at;
+	if (row.forked_from !== null) lifecycle.forkedFrom = row.forked_from;
+	if (row.fork_offset !== null) lifecycle.forkOffset = row.fork_offset;
+	if (row.fork_sub_offset !== null) lifecycle.forkSubOffset = row.fork_sub_offset;
+	if (row.expires_at_ms !== null) lifecycle.expiresAtMs = row.expires_at_ms;
+	return {
+		id: row.stream_id,
+		config,
+		lifecycle,
+		currentOffset: row.current_offset
+	};
+};
+const patchRecord = (record, patch) => {
+	const config = {
+		...record.config,
+		...patch.config
+	};
+	const lifecycle = {
+		...record.lifecycle,
+		...patch.lifecycle
+	};
+	for (const field of patch.clear ?? []) {
+		if (field === "ttlSeconds") delete config.ttlSeconds;
+		if (field === "expiresAt") delete config.expiresAt;
+		if (field === "expiresAtMs") delete lifecycle.expiresAtMs;
+		if (field === "lastSeq") delete lifecycle.lastSeq;
+	}
+	return {
+		id: record.id,
+		config,
+		lifecycle,
+		currentOffset: patch.currentOffset ?? record.currentOffset
+	};
+};
+const copyRecord = (record) => ({
+	id: record.id,
+	currentOffset: record.currentOffset,
+	config: { ...record.config },
+	lifecycle: { ...record.lifecycle }
+});
+const sqlFault = (operation, error) => new StorageFault({
+	operation,
+	message: error.message,
+	retryable: error.isRetryable,
+	cause: error
+});
+const createFault = (error) => Predicate.isTagged(error.reason, "UniqueViolation") ? new StorageFault({
+	operation: "mutate.create-record",
+	message: error.message,
+	retryable: true,
+	cause: error
+}) : sqlFault("mutate.create-record", error);
+const attempt = (operation, effect) => effect.pipe(Effect.mapError((error) => sqlFault(operation, error)));
+const execute = (operation, statement) => attempt(operation, statement).pipe(Effect.asVoid);
+const tooLong = (operation, label, value, limit) => {
+	const length = [...value].length;
+	return length > limit ? Option.some(new StorageFault({
+		operation,
+		message: `${label} has ${length} characters; the limit is ${limit}`,
+		retryable: false
+	})) : Option.none();
+};
+const oversizedKey = (mutation) => {
+	for (const operation of mutation.operations) {
+		const fault = Predicate.isTagged(operation, "Create") ? tooLong("mutate.stream-id", "Stream id", operation.record.id, 512) : Predicate.isTagged(operation, "Append") && operation.producer !== void 0 ? tooLong("mutate.producer-id", "Producer id", operation.producer.producerId, 255) : Option.none();
+		if (Option.isSome(fault)) return fault;
+	}
+	return Option.none();
+};
+/**
+* Serialise writers on the stream rows. This is the first statement of a
+* mutation transaction. On MySQL, the reads after it are locking reads, so they
+* see commits made while it waited, even when the caller read first.
+* Sorted ids give every writer one lock order. SQLite already has one writer.
+*/
+const lockStreams = (sql, ids) => {
+	const sorted = [...new Set(ids)].toSorted();
+	return sql.onDialectOrElse({
+		sqlite: () => Effect.void,
+		orElse: () => execute("mutate.lock", sql`SELECT stream_id FROM streamsy_streams WHERE stream_id IN ${sql.in(sorted)}
+ ORDER BY stream_id FOR UPDATE`)
+	});
+};
+/**
+* A mutation reads with a row lock on MySQL. At REPEATABLE READ a plain read uses
+* the snapshot of the transaction's first plain read, which app SQL in a fused
+* commit may have fixed before the stream lock. A locking read sees the latest
+* committed row. SQLite has one writer, and Postgres at READ COMMITTED reads the
+* latest commit in each statement, so both keep plain reads.
+*/
+const lockingRead = (sql, lock) => sql.onDialectOrElse({
+	mysql: () => sql.literal(lock === void 0 ? "" : lock === "update" ? " FOR UPDATE" : " FOR SHARE"),
+	orElse: () => sql.literal("")
+});
+/**
+* The lock for a read the protocol plans a mutation from. Inside an open
+* transaction on this client, such as a fused commit, it is `update`: on MySQL a
+* plain read would return the snapshot fixed by the transaction's first read, so
+* every replan would see the same stale tail. The row then stays locked until the
+* 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 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];
+	return row === void 0 ? Effect.succeed(Option.none()) : decodeRecordRow(row).pipe(Effect.map((decoded) => Option.some(toRecord(decoded))));
+}));
+const recordValues = (record) => ({
+	content_type: record.config.contentType,
+	ttl_seconds: record.config.ttlSeconds ?? null,
+	expires_at: record.config.expiresAt ?? null,
+	created_at: record.config.createdAt,
+	current_offset: record.currentOffset,
+	last_seq: record.lifecycle.lastSeq ?? null,
+	closed: record.lifecycle.closed ? 1 : 0,
+	closed_at: record.lifecycle.closedAt ?? null,
+	forked_from: record.lifecycle.forkedFrom ?? null,
+	fork_offset: record.lifecycle.forkOffset ?? null,
+	fork_sub_offset: record.lifecycle.forkSubOffset ?? null,
+	soft_deleted: record.lifecycle.softDeleted ? 1 : 0,
+	expires_at_ms: record.lifecycle.expiresAtMs ?? null
+});
+const insertRecord = (sql, record) => sql`INSERT INTO streamsy_streams ${sql.insert({
+	stream_id: record.id,
+	...recordValues(record)
+})}`.pipe(Effect.mapError(createFault), Effect.asVoid);
+const updateRecord = (sql, record) => execute("mutate.update-record", sql`UPDATE streamsy_streams SET ${sql.update(recordValues(record))} WHERE stream_id = ${record.id}`);
+const insertMessage = (sql, operation, id, message) => execute(operation, sql`INSERT INTO streamsy_messages ${sql.insert({
+	stream_id: id,
+	msg_offset: message.offset,
+	timestamp: message.timestamp,
+	data: new Uint8Array(message.data)
+})}`);
+const readProducer = (sql, operation, id, producerId, lock) => attempt(operation, sql`SELECT epoch, last_seq FROM streamsy_producers
+ WHERE stream_id = ${id} AND producer_id = ${producerId}${lockingRead(sql, lock)}`).pipe(Effect.flatMap((rows) => rows[0] === void 0 ? Effect.succeed(Option.none()) : decodeProducerRow(rows[0]).pipe(Effect.map(({ epoch, last_seq: lastSeq }) => Option.some({
+	epoch,
+	lastSeq
+})))));
+const upsertProducer = (sql, id, producerId, next) => {
+	const row = sql.insert({
+		stream_id: id,
+		producer_id: producerId,
+		epoch: next.epoch,
+		last_seq: next.lastSeq
+	});
+	return execute("mutate.producer", sql.onDialectOrElse({
+		mysql: () => sql`INSERT INTO streamsy_producers ${row}
+ ON DUPLICATE KEY UPDATE epoch = VALUES(epoch), last_seq = VALUES(last_seq)`,
+		orElse: () => sql`INSERT INTO streamsy_producers ${row}
+ ON CONFLICT (stream_id, producer_id) DO UPDATE SET epoch = excluded.epoch, last_seq = excluded.last_seq`
+	}));
+};
+const preflight = (sql, mutation) => Effect.gen(function* () {
+	for (const [index, operation] of mutation.operations.entries()) {
+		const id = Predicate.isTagged(operation, "Create") ? operation.record.id : operation.streamId;
+		const current = yield* readRecord(sql, id, "update");
+		if (Predicate.isTagged(operation, "Create")) {
+			if (Option.isSome(current)) return yield* new MutationRejected({
+				index,
+				reason: "exists",
+				record: current
+			});
+			if (operation.forkSource !== void 0) {
+				const source = yield* readRecord(sql, operation.forkSource.id, "share");
+				if (Option.isNone(source) || source.value.lifecycle.softDeleted || source.value.currentOffset < operation.forkSource.liveAtOffset) return yield* new MutationRejected({
+					index,
+					reason: "fork-source-gone",
+					record: Option.none()
+				});
+			}
+			continue;
+		}
+		if (Option.isNone(current)) return yield* new MutationRejected({
+			index,
+			reason: "not-found",
+			record: Option.none()
+		});
+		const record = current.value;
+		if (record.lifecycle.softDeleted) return yield* new MutationRejected({
+			index,
+			reason: "gone",
+			record: current
+		});
+		if (Predicate.isTagged(operation, "Delete")) {
+			if (operation.reason === "expiry" && (operation.expectedExpiresAtMs === void 0 || operation.expectedExpiresAtMs !== record.lifecycle.expiresAtMs)) return yield* new MutationRejected({
+				index,
+				reason: "expiry-mismatch",
+				record: current
+			});
+			continue;
+		}
+		if (operation.expectedOffset !== void 0 && operation.expectedOffset !== record.currentOffset) return yield* new MutationRejected({
+			index,
+			reason: "offset",
+			record: current
+		});
+		if (operation.expectedClosed !== void 0 && operation.expectedClosed !== record.lifecycle.closed) return yield* new MutationRejected({
+			index,
+			reason: "closed",
+			record: current
+		});
+		if (operation.producer !== void 0) {
+			const actual = yield* readProducer(sql, "mutate.preflight-producer", id, operation.producer.producerId, "update");
+			const expected = operation.producer.expected;
+			if (Option.isSome(actual) !== Option.isSome(expected) || Option.isSome(actual) && Option.isSome(expected) && (actual.value.epoch !== expected.value.epoch || actual.value.lastSeq !== expected.value.lastSeq)) return yield* new MutationRejected({
+				index,
+				reason: "producer",
+				record: current
+			});
+		}
+	}
+});
+const hasDependents = (sql, id) => attempt("mutate.dependents", sql`SELECT CASE WHEN EXISTS(
+ SELECT 1 FROM streamsy_streams WHERE forked_from = ${id}${lockingRead(sql, "share")}
+) THEN 1 ELSE 0 END AS present`).pipe(Effect.flatMap((rows) => decodeDependentsRow(rows[0] ?? { present: 0 })), Effect.map(({ present }) => present === 1 || present === 1n || present === true));
+const purge = (sql, start) => Effect.gen(function* () {
+	let current = start;
+	while (current !== void 0) {
+		const parentId = current.lifecycle.forkedFrom;
+		yield* execute("mutate.purge-messages", sql`DELETE FROM streamsy_messages WHERE stream_id = ${current.id}`);
+		yield* execute("mutate.purge-producers", sql`DELETE FROM streamsy_producers WHERE stream_id = ${current.id}`);
+		yield* execute("mutate.purge", sql`DELETE FROM streamsy_streams WHERE stream_id = ${current.id}`);
+		if (parentId === void 0) return;
+		yield* lockStreams(sql, [parentId]);
+		const parent = yield* readRecord(sql, parentId, "update");
+		if (Option.isNone(parent) || !parent.value.lifecycle.softDeleted || (yield* hasDependents(sql, parentId))) return;
+		current = parent.value;
+	}
+});
+const applyMutation = (sql, mutation) => Effect.gen(function* () {
+	yield* lockStreams(sql, lockIds(mutation));
+	yield* preflight(sql, mutation);
+	const records = /* @__PURE__ */ new Map();
+	const results = [];
+	for (const operation of mutation.operations) {
+		if (!Predicate.isTagged(operation, "Create")) continue;
+		yield* insertRecord(sql, operation.record);
+		for (const message of operation.initialMessages) yield* insertMessage(sql, "mutate.create-message", operation.record.id, message);
+		records.set(operation.record.id, operation.record);
+	}
+	for (const operation of mutation.operations) {
+		const id = Predicate.isTagged(operation, "Create") ? operation.record.id : operation.streamId;
+		const current = records.get(id) ?? Option.getOrThrow(yield* readRecord(sql, id, "update"));
+		if (Predicate.isTagged(operation, "Create")) {
+			results.push(OperationResults.Created({ record: copyRecord(current) }));
+			continue;
+		}
+		if (Predicate.isTagged(operation, "Append")) {
+			for (const message of operation.messages) yield* insertMessage(sql, "mutate.append-message", id, message);
+			const next = patchRecord(current, operation.patch);
+			yield* updateRecord(sql, next);
+			if (operation.producer !== void 0) yield* upsertProducer(sql, id, operation.producer.producerId, operation.producer.next);
+			records.set(id, next);
+			results.push(OperationResults.Appended({ record: next }));
+			continue;
+		}
+		if (yield* hasDependents(sql, id)) {
+			const next = patchRecord(current, { lifecycle: { softDeleted: true } });
+			yield* updateRecord(sql, next);
+			results.push(OperationResults.SoftDeleted({ record: next }));
+		} else {
+			results.push(OperationResults.Purged({ record: current }));
+			yield* purge(sql, current);
+		}
+	}
+	const [first, ...rest] = results;
+	if (first === void 0) return yield* Effect.die(/* @__PURE__ */ new Error("Empty mutation"));
+	return Mutations.Applied({ results: [first, ...rest] });
+});
+const directMessage = (row) => {
+	if (!Predicate.isString(row.msg_offset) || !/^\d{16}_\d{16}$/.test(row.msg_offset) || !Predicate.isNumber(row.timestamp) || !Number.isFinite(row.timestamp) || !Predicate.isUint8Array(row.data)) throw new Error("Corrupt persisted message row");
+	return {
+		offset: Offset.make(row.msg_offset),
+		timestamp: row.timestamp,
+		data: new Uint8Array(row.data)
+	};
+};
+const readMessages = (sql, id, window) => Effect.gen(function* () {
+	let remaining = window.limit === void 0 ? void 0 : Math.max(0, Math.trunc(window.limit));
+	if (remaining === 0) return [];
+	const visited = /* @__PURE__ */ new Set();
+	const chain = [];
+	let cursor = id;
+	let until;
+	while (cursor !== void 0) {
+		if (visited.has(cursor)) return yield* Effect.die(/* @__PURE__ */ new Error("Corrupt cyclic stream lineage"));
+		visited.add(cursor);
+		chain.push(until === void 0 ? { id: cursor } : {
+			id: cursor,
+			until
+		});
+		const record = yield* readRecord(sql, cursor);
+		if (Option.isNone(record)) break;
+		cursor = record.value.lifecycle.forkedFrom;
+		until = record.value.lifecycle.forkOffset;
+	}
+	const messages = [];
+	for (const segment of chain.toReversed()) {
+		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}`];
+		if (window.after !== void 0) predicates.push(sql`msg_offset > ${window.after}`);
+		if (upper !== void 0) predicates.push(sql`msg_offset <= ${upper}`);
+		const rows = yield* attempt("messages", sql`SELECT msg_offset, timestamp, data FROM streamsy_messages
+ WHERE ${sql.and(predicates)} ORDER BY msg_offset${remaining === void 0 ? sql.literal("") : sql` LIMIT ${remaining}`}`);
+		for (const row of rows) messages.push(yield* Effect.try(() => directMessage(row)).pipe(Effect.orDie));
+		if (remaining !== void 0) remaining -= rows.length;
+	}
+	return messages;
+});
+const snapshot = (sql, id) => attempt("changes", sql`SELECT current_offset, closed, soft_deleted FROM streamsy_streams
+ WHERE stream_id = ${id}`).pipe(Effect.flatMap((rows) => decodeSnapshotRow(rows[0] ?? {
+	current_offset: null,
+	closed: null,
+	soft_deleted: null
+})), Effect.map((row) => ({
+	present: row.current_offset !== null,
+	currentOffset: row.current_offset ?? ZERO_OFFSET,
+	closed: row.closed === 1,
+	softDeleted: row.soft_deleted === 1
+})));
+const makeStorage = (sql, boundary) => Storage.of({
+	capabilities: {
+		fork: "chain",
+		atomicScope: "store",
+		wake: "push",
+		expiryIndex: "indexed"
+	},
+	record: Effect.fn("SqlStorage.record")((id) => Effect.flatMap(planningLock(sql), (lock) => readRecord(sql, id, lock))),
+	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);
+		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],
+			effect: applyMutation(sql, mutation),
+			retryable: (error) => Predicate.isTagged(error, "StorageFault") && error.retryable
+		}).pipe(Effect.catchIf(isSqlError, (error) => Effect.fail(sqlFault("mutate.transaction", error))));
+	}),
+	changes: (id) => boundary.changes({
+		keys: [STORAGE_KEY],
+		read: snapshot(sql, id)
+	}),
+	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({
+		at,
+		streamId
+	})))))
+});
+/**
+* The fault operation of an owner record write that lost a first-write race.
+* `CheckpointStore.layer` in `@streamsy/projection` reports it as a token conflict.
+*/
+const OWNER_RECORD_CONFLICT = "records.conflict";
+/**
+* Encoded owner records; statements join the boundary transaction when one is open.
+*
+* The checkpoint store reads a record, compares its token and writes it back in one
+* transaction. Inside a transaction, a found record is read again with
+* `FOR UPDATE` on Postgres and MySQL, so a concurrent save waits and then sees the
+* new token. An absent key has no row to lock, and on MySQL a locking read of it
+* takes a gap lock that turns two first saves into a deadlock. So the first read
+* stays plain, the transaction remembers the absent key, and its write is a plain
+* insert: a concurrent first save then fails on the primary key and is not lost.
+*/
+const makeOwnerRecords = (sql) => {
+	const absentKeys = /* @__PURE__ */ new WeakMap();
+	const select = (key, forUpdate) => attempt("records.read", sql`SELECT owner_value FROM streamsy_owner_records WHERE owner_key = ${key}${sql.literal(forUpdate ? " FOR UPDATE" : "")}`).pipe(Effect.map((rows) => Option.fromUndefinedOr(rows[0]?.owner_value)));
+	const lockFound = (key, found) => Option.isNone(found) ? Effect.succeed(found) : sql.onDialectOrElse({
+		sqlite: () => Effect.succeed(found),
+		orElse: () => select(key, true)
+	});
+	const upsert = (key, encoded) => {
+		const row = sql.insert({
+			owner_key: key,
+			owner_value: encoded
+		});
+		return execute("records.write", sql.onDialectOrElse({
+			mysql: () => sql`INSERT INTO streamsy_owner_records ${row}
+ ON DUPLICATE KEY UPDATE owner_value = VALUES(owner_value)`,
+			orElse: () => sql`INSERT INTO streamsy_owner_records ${row}
+ ON CONFLICT (owner_key) DO UPDATE SET owner_value = excluded.owner_value`
+		}));
+	};
+	const insert = (key, encoded) => sql`INSERT INTO streamsy_owner_records ${sql.insert({
+		owner_key: key,
+		owner_value: encoded
+	})}`.pipe(Effect.mapError((error) => Predicate.isTagged(error.reason, "UniqueViolation") ? new StorageFault({
+		operation: OWNER_RECORD_CONFLICT,
+		message: `Owner record ${key} was created by a concurrent writer`,
+		retryable: false,
+		cause: error
+	}) : sqlFault("records.write", error)), Effect.asVoid);
+	return OwnerRecords.of({
+		read: Effect.fn("SqlStorage.records.read")(function* (key) {
+			const transaction = yield* Effect.serviceOption(sql.transactionService);
+			if (Option.isNone(transaction)) return yield* select(key, false);
+			const found = yield* Effect.flatMap(select(key, false), (first) => lockFound(key, first));
+			const absent = absentKeys.get(transaction.value) ?? /* @__PURE__ */ new Set();
+			absentKeys.set(transaction.value, absent);
+			if (Option.isNone(found)) absent.add(key);
+			else absent.delete(key);
+			return found;
+		}),
+		write: Effect.fn("SqlStorage.records.write")(function* (key, encoded) {
+			const transaction = yield* Effect.serviceOption(sql.transactionService);
+			const absent = Option.isSome(transaction) ? absentKeys.get(transaction.value) : void 0;
+			if (absent?.has(key) === true) {
+				yield* insert(key, encoded);
+				absent.delete(key);
+			} else yield* upsert(key, encoded);
+		}),
+		remove: Effect.fn("SqlStorage.records.remove")((key) => execute("records.remove", sql`DELETE FROM streamsy_owner_records WHERE owner_key = ${key}`))
+	});
+};
+const makeLayer = (options, probe, transactionMaxOpsBeforeYield) => {
+	const transactionRetry = transactionRetryPolicy(options);
+	return Layer.effectContext(Effect.gen(function* () {
+		const sql = yield* SqlClient.SqlClient;
+		yield* migrate(sql, { onTransactionAttempt: probe === void 0 ? void 0 : () => {
+			probe.migrationAttempts += 1;
+		} }, transactionRetry);
+		const boundary = yield* BoundaryRuntimeService;
+		const owner = ownerOf(boundary);
+		return Context.empty().pipe(Context.add(Storage, attachOwner(makeStorage(sql, boundary), owner)), Context.add(CommitBoundary, CommitBoundary.of(boundary)), Context.add(OwnerRecords, attachOwner(makeOwnerRecords(sql), owner)));
+	})).pipe(Layer.provide(boundaryLayer(options.repairIntervalMs ?? 1e3, transactionRetry, probe, transactionMaxOpsBeforeYield)));
+};
+/** Generic SQLite-stream SQL layer. Hosts supply one matching SqlClient/Reactivity graph. */
+const storageLayer = (options = {}) => makeLayer(options);
+/** Internal host seam for the official Durable Object transaction boundary. */
+const layerWithDurableObjectTransactions = (options) => makeLayer(options, void 0, Number.MAX_SAFE_INTEGER);
+/** Protocol over SQL storage. */
+const layerProtocol = (options = {}) => Protocol.layer(options).pipe(Layer.provideMerge(storageLayer(options)));
+function layer(group, options = {}) {
+	const storage = storageLayer(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 };