@akterjs/effect 0.0.0-stage → 0.1.0

package/dist/host/migration/actor-migrations.service.d.mts

@@ -0,0 +1,46 @@
+import { StateUnreadableError } from "../../contract/state/state-unreadable.errors.mjs";
+import { LayoutVersionError } from "../layout/layout-version.errors.mjs";
+import { MigrationEditedError } from "./migration-edited.errors.mjs";
+import { MigrationFailedError } from "./migration-failed.errors.mjs";
+import { MigrationMissingError } from "./migration-missing.errors.mjs";
+import { ReservedNameError } from "../actor/reserved-name.errors.mjs";
+import "../../runtime/akter.layer.mjs";
+import { HostedActor } from "../../contract/actor/actor.contract.mjs";
+import { MigrationHasher } from "./migration-hasher.adapter.mjs";
+import { DeclaredMigration } from "./migration-plan.pure.mjs";
+import { Context, Effect, Layer, Option } from "effect";
+import { SqlClient } from "effect/sql";
+interface Preparing {
+  readonly actor: HostedActor;
+  readonly sql: SqlClient.SqlClient;
+}
+interface PreparingActor extends Preparing {
+  readonly declared: readonly DeclaredMigration[];
+}
+interface Reserving extends PreparingActor {
+  readonly reserved: readonly string[];
+}
+interface MigrationStep {
+  readonly from: number;
+  readonly to: number;
+}
+declare const prepareActor: (args_0: Reserving) => Effect.Effect<MigrationStep, LayoutVersionError | MigrationEditedError | MigrationFailedError | MigrationMissingError | ReservedNameError | import("effect/sql/SqlError").SqlError | StateUnreadableError, never>;
+type ActorOpenError = Effect.Error<ReturnType<typeof prepareActor>>;
+declare const ActorMigrations_base: Context.ServiceClass<ActorMigrations, "@akterjs/effect/host/migration/actor-migrations.service/ActorMigrations", {
+  readonly apply: (preparing: PreparingActor) => Effect.Effect<MigrationStep, ActorOpenError>;
+  readonly declare: (actor: HostedActor) => Effect.Effect<readonly DeclaredMigration[], ActorOpenError>;
+  readonly plan: (preparing: Preparing) => Effect.Effect<MigrationStep, ActorOpenError>;
+  readonly prepare: (preparing: Preparing) => Effect.Effect<MigrationStep, ActorOpenError>;
+}> & {
+  readonly make: Effect.Effect<{
+    readonly apply: (preparing: PreparingActor) => Effect.Effect<MigrationStep, ActorOpenError>;
+    readonly declare: (actor: HostedActor) => Effect.Effect<readonly DeclaredMigration[], ActorOpenError>;
+    readonly plan: (preparing: Preparing) => Effect.Effect<MigrationStep, ActorOpenError>;
+    readonly prepare: (preparing: Preparing) => Effect.Effect<MigrationStep, ActorOpenError>;
+  }, never, MigrationHasher>;
+};
+export declare class ActorMigrations extends ActorMigrations_base {
+  static readonly hostTables: Context.Reference<Option.Option<string>>;
+  static readonly layer: Layer.Layer<ActorMigrations, never, never>;
+}
+export type { ActorOpenError, MigrationStep, PreparingActor };

package/dist/host/migration/actor-migrations.service.mjs

@@ -0,0 +1,143 @@
+import { createLayout, storedLayoutVersion, upgradeLayout } from "../layout/actor-layout.sql.mjs";
+import { appliedMigrations, recordMigration, reservedObjects, upgradeStoredState } from "../actor/actor-records.sql.mjs";
+import { checkLayoutVersion } from "../layout/layout-version.pure.mjs";
+import { migrationFailure } from "./migration-failure.pure.mjs";
+import { MigrationHasher } from "./migration-hasher.adapter.mjs";
+import { orderedMigrations, pendingMigrations } from "./migration-plan.pure.mjs";
+import { checkReserved } from "../actor/reserved-names.pure.mjs";
+import { Clock, Context, Effect, Layer, Option } from "effect";
+// src/host/migration/actor-migrations.service.ts
+const akterTables = "akter_";
+const HostTables = Context.Reference("@akterjs/effect/host/migration/actor-migrations.service/HostTables", { defaultValue: () => Option.none() });
+const migrationStep = (applied, pending) => ({
+	from: applied.length,
+	to: applied.length + pending.length
+});
+const ensureLayout = Effect.fnUntraced(function* ensureLayout({ actor, sql }) {
+	const stored = yield* storedLayoutVersion(sql);
+	if (Option.isNone(stored)) return yield* createLayout(sql);
+	yield* checkLayoutVersion({
+		actor: actor.name,
+		found: stored.value
+	});
+	return yield* upgradeLayout(sql);
+});
+const applyMigration = Effect.fnUntraced(function* applyMigration({ actor, migration, reserved, sql }) {
+	const before = yield* reservedObjects({
+		prefixes: reserved,
+		sql
+	});
+	yield* Effect.mapError(migration.run(sql), (error) => migrationFailure({
+		actor,
+		error,
+		version: migration.version
+	}));
+	const after = yield* reservedObjects({
+		prefixes: reserved,
+		sql
+	});
+	yield* checkReserved({
+		actor,
+		after,
+		before,
+		version: migration.version
+	});
+	const at = yield* Clock.currentTimeMillis;
+	yield* recordMigration({
+		row: {
+			at,
+			hash: migration.hash,
+			version: migration.version
+		},
+		sql
+	});
+});
+const prepareActor = Effect.fnUntraced(function* prepareActor({ actor, declared, reserved, sql }) {
+	yield* ensureLayout({
+		actor,
+		sql
+	});
+	const applied = yield* appliedMigrations(sql);
+	const pending = yield* pendingMigrations({
+		actor: actor.name,
+		applied,
+		declared
+	});
+	yield* Effect.forEach(pending, (migration) => applyMigration({
+		actor: actor.name,
+		migration,
+		reserved,
+		sql
+	}), { discard: true });
+	yield* upgradeStoredState({
+		actor,
+		sql
+	});
+	return migrationStep(applied, pending);
+});
+const planActor = Effect.fnUntraced(function* planActor({ actor, declared, sql }) {
+	const stored = yield* storedLayoutVersion(sql);
+	const applied = yield* Option.match(stored, {
+		onNone: () => Effect.succeed([]),
+		onSome: (found) => Effect.andThen(checkLayoutVersion({
+			actor: actor.name,
+			found
+		}), appliedMigrations(sql))
+	});
+	const pending = yield* pendingMigrations({
+		actor: actor.name,
+		applied,
+		declared
+	});
+	return migrationStep(applied, pending);
+});
+var ActorMigrations = class extends Context.Service()("@akterjs/effect/host/migration/actor-migrations.service/ActorMigrations", { make: Effect.gen(function* makeActorMigrations() {
+	const hasher = yield* MigrationHasher;
+	const hostTables = yield* HostTables;
+	const reserved = [akterTables, ...Option.toArray(hostTables)];
+	const declare = Effect.fnUntraced(function* declare(actor) {
+		return yield* Effect.forEach(orderedMigrations(actor.migrations), ([version, run]) => Effect.mapBoth(hasher.hash(run), {
+			onFailure: (error) => migrationFailure({
+				actor: actor.name,
+				error,
+				version
+			}),
+			onSuccess: (hash) => ({
+				hash,
+				run,
+				version
+			})
+		}));
+	});
+	const plan = Effect.fn("ActorMigrations.plan")(function* plan({ actor, sql }) {
+		const declared = yield* declare(actor);
+		return yield* planActor({
+			actor,
+			declared,
+			sql
+		});
+	});
+	const apply = Effect.fn("ActorMigrations.apply")(function* apply(preparing) {
+		return yield* preparing.sql.withTransaction(prepareActor({
+			...preparing,
+			reserved
+		}));
+	});
+	return {
+		apply,
+		declare,
+		plan,
+		prepare: Effect.fn("ActorMigrations.prepare")(function* prepare({ actor, sql }) {
+			const declared = yield* declare(actor);
+			return yield* apply({
+				actor,
+				declared,
+				sql
+			});
+		})
+	};
+}) }) {
+	static hostTables = HostTables;
+	static layer = Layer.effect(this, this.make).pipe(Layer.provide(MigrationHasher.layer));
+};
+export { ActorMigrations };

package/dist/host/migration/migration-edited.errors.d.mts

@@ -0,0 +1,9 @@
+import { Schema } from "effect";
+declare const MigrationEditedError_base: Schema.Class<MigrationEditedError, Schema.TaggedStruct<"MigrationEditedError", {
+  readonly actor: Schema.String;
+  readonly version: Schema.Int;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+export declare class MigrationEditedError extends MigrationEditedError_base {}
+export {};

package/dist/host/migration/migration-edited.errors.mjs

@@ -0,0 +1,7 @@
+import { Schema } from "effect";
+// src/host/migration/migration-edited.errors.ts
+var MigrationEditedError = class extends Schema.TaggedError()("MigrationEditedError", {
+	actor: Schema.String,
+	version: Schema.Int
+}) {};
+export { MigrationEditedError };

package/dist/host/migration/migration-failed.errors.d.mts

@@ -0,0 +1,12 @@
+import { Schema } from "effect";
+declare const MigrationFailedError_base: Schema.Class<MigrationFailedError, Schema.TaggedStruct<"MigrationFailedError", {
+  readonly actor: Schema.String;
+  readonly message: Schema.String;
+  readonly sqliteCode: Schema.optional<Schema.Int>;
+  readonly sqliteMessage: Schema.optional<Schema.String>;
+  readonly version: Schema.Int;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+export declare class MigrationFailedError extends MigrationFailedError_base {}
+export {};

package/dist/host/migration/migration-failed.errors.mjs

@@ -0,0 +1,10 @@
+import { Schema } from "effect";
+// src/host/migration/migration-failed.errors.ts
+var MigrationFailedError = class extends Schema.TaggedError()("MigrationFailedError", {
+	actor: Schema.String,
+	message: Schema.String,
+	sqliteCode: Schema.optional(Schema.Int),
+	sqliteMessage: Schema.optional(Schema.String),
+	version: Schema.Int
+}) {};
+export { MigrationFailedError };

package/dist/host/migration/migration-failure.pure.d.mts

@@ -0,0 +1,9 @@
+import { MigrationFailedError } from "./migration-failed.errors.mjs";
+import { SqlError } from "effect/sql";
+interface FailedMigration {
+  readonly actor: string;
+  readonly error: SqlError.SqlError;
+  readonly version: number;
+}
+declare const migrationFailure: ({ actor, error, version }: FailedMigration) => MigrationFailedError;
+export { type FailedMigration, migrationFailure };

package/dist/host/migration/migration-failure.pure.mjs

@@ -0,0 +1,19 @@
+import { MigrationFailedError } from "./migration-failed.errors.mjs";
+import { reasonText, sqliteReason } from "../sqlite/sqlite-reason.pure.mjs";
+import { Option } from "effect";
+// src/host/migration/migration-failure.pure.ts
+const migrationFailure = ({ actor, error, version }) => Option.match(sqliteReason(error.reason.cause), {
+	onNone: () => MigrationFailedError.make({
+		actor,
+		message: error.message,
+		version
+	}),
+	onSome: (reason) => MigrationFailedError.make({
+		actor,
+		message: `migration ${version} failed: ${reasonText(reason)}`,
+		sqliteCode: reason.code,
+		sqliteMessage: reason.message,
+		version
+	})
+});
+export { migrationFailure };

package/dist/host/migration/migration-hasher.adapter.d.mts

@@ -0,0 +1,15 @@
+import { Migration } from "../../contract/actor/actor.contract.mjs";
+import { Context, Effect, Layer } from "effect";
+import { Digest } from "effect/crypto";
+import { SqlError } from "effect/sql";
+declare const MigrationHasher_base: Context.ServiceClass<MigrationHasher, "@akterjs/effect/host/migration/migration-hasher.adapter/MigrationHasher", {
+  readonly hash: (migration: Migration) => Effect.Effect<string, SqlError.SqlError>;
+}> & {
+  readonly make: Effect.Effect<{
+    readonly hash: (migration: Migration) => Effect.Effect<string, SqlError.SqlError>;
+  }, never, Digest.Digest>;
+};
+export declare class MigrationHasher extends MigrationHasher_base {
+  static readonly layer: Layer.Layer<MigrationHasher, never, never>;
+}
+export {};

package/dist/host/migration/migration-hasher.adapter.mjs

@@ -0,0 +1,40 @@
+import { Array, Context, Effect, Layer, Ref, Stream } from "effect";
+import { Digest } from "effect/crypto";
+import { SqlClient, Statement } from "effect/sql";
+import { Reactivity } from "effect/reactivity";
+// src/host/migration/migration-hasher.adapter.ts
+const recorder = (statements) => {
+	const record = (sql, params) => Effect.as(Ref.update(statements, (recorded) => Array.appendAll(recorded, [sql, ...Array.map(params, String)])), []);
+	return {
+		execute: record,
+		executeRaw: record,
+		executeStream: () => Stream.empty,
+		executeUnprepared: record,
+		executeValues: record,
+		executeValuesUnprepared: record
+	};
+};
+const recordedStatements = Effect.fnUntraced(function* recordedStatements(migration) {
+	const statements = yield* Ref.make([]);
+	const reactivity = yield* Reactivity.make;
+	const recording = SqlClient.make({
+		acquirer: Effect.succeed(recorder(statements)),
+		compiler: Statement.makeCompilerSqlite(),
+		driver: "akter-migration-hasher",
+		spanAttributes: []
+	});
+	yield* migration(yield* Effect.provideService(recording, Reactivity.Reactivity, reactivity));
+	return yield* Ref.get(statements);
+});
+const hashMigration = Effect.fnUntraced(function* hashMigration(digest, migration) {
+	const recorded = yield* recordedStatements(migration);
+	const text = new globalThis.TextEncoder().encode(Array.join(recorded, "\0"));
+	return yield* digest.digestHex(Digest.sha256, text);
+});
+var MigrationHasher = class extends Context.Service()("@akterjs/effect/host/migration/migration-hasher.adapter/MigrationHasher", { make: Effect.gen(function* makeMigrationHasher() {
+	const digest = yield* Digest.Digest;
+	return { hash: (migration) => hashMigration(digest, migration) };
+}) }) {
+	static layer = Layer.effect(this, this.make).pipe(Layer.provide(Digest.layerWebCrypto));
+};
+export { MigrationHasher };

package/dist/host/migration/migration-missing.errors.d.mts

@@ -0,0 +1,9 @@
+import { Schema } from "effect";
+declare const MigrationMissingError_base: Schema.Class<MigrationMissingError, Schema.TaggedStruct<"MigrationMissingError", {
+  readonly actor: Schema.String;
+  readonly version: Schema.Int;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+export declare class MigrationMissingError extends MigrationMissingError_base {}
+export {};

package/dist/host/migration/migration-missing.errors.mjs

@@ -0,0 +1,7 @@
+import { Schema } from "effect";
+// src/host/migration/migration-missing.errors.ts
+var MigrationMissingError = class extends Schema.TaggedError()("MigrationMissingError", {
+	actor: Schema.String,
+	version: Schema.Int
+}) {};
+export { MigrationMissingError };

package/dist/host/migration/migration-plan.pure.d.mts

@@ -0,0 +1,20 @@
+import { Migration, Migrations } from "../../contract/actor/actor.contract.mjs";
+import { MigrationEditedError } from "./migration-edited.errors.mjs";
+import { MigrationMissingError } from "./migration-missing.errors.mjs";
+import { Effect } from "effect";
+interface AppliedMigration {
+  readonly hash: string;
+  readonly version: number;
+}
+interface DeclaredMigration extends AppliedMigration {
+  readonly run: Migration;
+}
+interface MigrationHistory {
+  readonly actor: string;
+  readonly applied: readonly AppliedMigration[];
+  readonly declared: readonly DeclaredMigration[];
+}
+type NumberedMigration = readonly [number, Migration];
+declare const orderedMigrations: (migrations: Migrations) => readonly NumberedMigration[];
+declare const pendingMigrations: (history: MigrationHistory) => Effect.Effect<readonly DeclaredMigration[], MigrationEditedError | MigrationMissingError>;
+export { type AppliedMigration, type DeclaredMigration, orderedMigrations, pendingMigrations };

package/dist/host/migration/migration-plan.pure.mjs

@@ -0,0 +1,32 @@
+import { MigrationEditedError } from "./migration-edited.errors.mjs";
+import { MigrationMissingError } from "./migration-missing.errors.mjs";
+import { Array, Effect, Option, Order, Record, pipe } from "effect";
+// src/host/migration/migration-plan.pure.ts
+const firstVersion = 1;
+const orderedMigrations = (migrations) => pipe(Record.toEntries(migrations), Array.map(([version, run]) => [Number(version), run]), Array.sortWith(([version]) => version, Order.Number));
+const conflictError = (history, version) => {
+	if (version > history.declared.length) return MigrationMissingError.make({
+		actor: history.actor,
+		version
+	});
+	return MigrationEditedError.make({
+		actor: history.actor,
+		version
+	});
+};
+const pendingMigrations = (history) => {
+	const gap = Array.findFirstIndex(history.declared, (migration, index) => migration.version !== index + firstVersion);
+	if (Option.isSome(gap)) return Effect.fail(MigrationMissingError.make({
+		actor: history.actor,
+		version: gap.value + firstVersion
+	}));
+	const conflict = Array.findFirst(history.applied, (applied) => Option.match(Array.get(history.declared, applied.version - firstVersion), {
+		onNone: () => true,
+		onSome: (declared) => declared.hash !== applied.hash
+	}));
+	return Option.match(conflict, {
+		onNone: () => Effect.succeed(Array.drop(history.declared, history.applied.length)),
+		onSome: (applied) => Effect.fail(conflictError(history, applied.version))
+	});
+};
+export { orderedMigrations, pendingMigrations };

package/dist/host/outbox/actor-outbox.sql.d.mts

@@ -0,0 +1,33 @@
+import { OutboxMessage } from "../../contract/command/outbox.schema.mjs";
+import { Effect } from "effect";
+import { SqlClient, SqlError } from "effect/sql";
+interface MessageWrite {
+  readonly messages: readonly OutboxMessage[];
+  readonly sql: SqlClient.SqlClient;
+}
+interface MessageRemoval {
+  readonly seq: number;
+  readonly sql: SqlClient.SqlClient;
+}
+interface FailedDelivery extends MessageRemoval {
+  readonly at: number;
+  readonly error: string;
+  readonly message: PendingMessage;
+}
+interface PendingMessage extends OutboxMessage {
+  readonly seq: number;
+}
+type Sql<Value> = Effect.Effect<Value, SqlError.SqlError>;
+declare const saveMessages: ({ messages, sql }: MessageWrite) => Sql<void>;
+declare const pendingMessages: (sql: SqlClient.SqlClient) => Sql<readonly PendingMessage[]>;
+declare const pendingThrough: (sql: SqlClient.SqlClient) => Sql<number>;
+declare const removeMessage: ({ seq, sql }: MessageRemoval) => Sql<void>;
+declare const pendingWindow: ({ after, principal, sql, through }: {
+  readonly after: number;
+  readonly principal: string;
+  readonly sql: SqlClient.SqlClient;
+  readonly through?: number;
+}) => Sql<readonly PendingMessage[]>;
+declare const removePrefix: ({ seq, sql }: MessageRemoval) => Sql<void>;
+declare const recordFailedDelivery: ({ at, error, message, seq, sql }: FailedDelivery) => Sql<void>;
+export { type PendingMessage, pendingMessages, pendingThrough, pendingWindow, recordFailedDelivery, removeMessage, removePrefix, saveMessages };

package/dist/host/outbox/actor-outbox.sql.mjs

@@ -0,0 +1,28 @@
+import { Effect } from "effect";
+// src/host/outbox/actor-outbox.sql.ts
+const noSequence = 0;
+const deliveryBytes = 262144;
+const saveMessages = ({ messages, sql }) => Effect.forEach(messages, (message) => sql`INSERT INTO akter_outbox (command_id, actor, key, member, payload) VALUES (${message.commandId}, ${message.actor}, ${message.key}, ${message.member}, ${message.payload})`, { discard: true });
+const pendingMessages = (sql) => sql`SELECT seq, command_id AS "commandId", actor, key, member, payload FROM akter_outbox ORDER BY seq`;
+const pendingThrough = (sql) => Effect.map(sql`SELECT coalesce(max(seq), 0) AS seq FROM akter_outbox`, (rows) => rows[noSequence]?.seq ?? noSequence);
+const removeMessage = ({ seq, sql }) => Effect.asVoid(sql`DELETE FROM akter_outbox WHERE seq = ${seq}`);
+const pendingWindow = ({ after, principal, sql, through = Number.MAX_SAFE_INTEGER }) => sql`WITH RECURSIVE candidates(seq, bytes) AS (
+    SELECT seq, bytes FROM (
+      SELECT seq, length(CAST(command_id AS BLOB)) + length(CAST(actor AS BLOB)) + length(CAST(key AS BLOB))
+        + length(CAST(member AS BLOB)) + length(CAST(payload AS BLOB)) + length(CAST(${principal} AS BLOB)) AS bytes
+      FROM akter_outbox WHERE seq > ${after} AND seq <= ${through} ORDER BY seq LIMIT 1
+    ) UNION ALL
+    SELECT next.seq, previous.bytes + next.bytes FROM candidates previous JOIN (
+      SELECT seq, length(CAST(command_id AS BLOB)) + length(CAST(actor AS BLOB)) + length(CAST(key AS BLOB))
+        + length(CAST(member AS BLOB)) + length(CAST(payload AS BLOB)) + length(CAST(${principal} AS BLOB)) AS bytes
+      FROM akter_outbox
+    ) next ON next.seq = (SELECT seq FROM akter_outbox WHERE seq > previous.seq AND seq <= ${through} ORDER BY seq LIMIT 1)
+    WHERE previous.bytes + next.bytes <= ${deliveryBytes}
+  ) SELECT seq, command_id AS "commandId", actor, key, member, payload FROM akter_outbox
+    WHERE seq IN (SELECT seq FROM candidates) ORDER BY seq`;
+const removePrefix = ({ seq, sql }) => Effect.asVoid(sql`DELETE FROM akter_outbox WHERE seq <= ${seq}`);
+const recordFailedDelivery = ({ at, error, message, seq, sql }) => sql.withTransaction(Effect.andThen(sql`INSERT INTO akter_failed_deliveries (command_id, actor, key, member, error, at) VALUES (${message.commandId}, ${message.actor}, ${message.key}, ${message.member}, ${error}, ${at})`, removeMessage({
+	seq,
+	sql
+})));
+export { pendingMessages, pendingThrough, pendingWindow, recordFailedDelivery, removeMessage, removePrefix, saveMessages };

package/dist/host/outbox/outbox-acknowledgements.sql.d.mts

@@ -0,0 +1,12 @@
+import { Effect, Scope } from "effect";
+import { SqlClient, SqlError } from "effect/sql";
+type Exclusive = <Value, Failure>(effect: Effect.Effect<Value, Failure>) => Effect.Effect<Value, Failure>;
+interface Acknowledgements {
+  readonly acknowledge: (seq: number) => Effect.Effect<void, SqlError.SqlError, Scope.Scope>;
+  readonly flush: Effect.Effect<void, SqlError.SqlError>;
+}
+declare const acknowledgements: ({ exclusive, sql }: {
+  readonly exclusive: Exclusive;
+  readonly sql: SqlClient.SqlClient;
+}) => Effect.Effect<Acknowledgements>;
+export { type Acknowledgements, acknowledgements };

package/dist/host/outbox/outbox-acknowledgements.sql.mjs

@@ -0,0 +1,47 @@
+import { removePrefix } from "./actor-outbox.sql.mjs";
+import { Effect, Fiber, Option } from "effect";
+// src/host/outbox/outbox-acknowledgements.sql.ts
+const noAcknowledgements = 0;
+const queuePrefix = Effect.fnUntraced(function* queuePrefix({ state, write }, seq) {
+	state.through = Math.max(state.through, seq);
+	if (state.through <= state.committed) return;
+	if (Option.isSome(state.pending)) {
+		const previous = state.pending.value;
+		if (Option.isNone(Option.fromNullishOr(previous.pollUnsafe()))) return;
+		state.pending = Option.none();
+		yield* Fiber.join(previous);
+	}
+	state.pending = yield* Effect.asSome(Effect.forkScoped(write));
+});
+const flushPrefix = ({ state, write }) => Effect.gen(function* flushPendingPrefix() {
+	if (Option.isSome(state.pending)) {
+		const pending = state.pending.value;
+		state.pending = Option.none();
+		yield* Fiber.join(pending);
+	}
+	if (state.committed < state.through) yield* write;
+});
+const acknowledgements = ({ exclusive, sql }) => Effect.sync(() => {
+	const state = {
+		committed: noAcknowledgements,
+		pending: Option.none(),
+		through: noAcknowledgements
+	};
+	const writing = {
+		state,
+		write: exclusive(Effect.suspend(() => {
+			const seq = state.through;
+			return Effect.as(removePrefix({
+				seq,
+				sql
+			}), seq);
+		})).pipe(Effect.tap((seq) => Effect.sync(() => {
+			state.committed = Math.max(state.committed, seq);
+		})))
+	};
+	return {
+		acknowledge: (seq) => queuePrefix(writing, seq),
+		flush: flushPrefix(writing)
+	};
+});
+export { acknowledgements };

package/dist/host/outbox/outbox-runner.service.d.mts

@@ -0,0 +1,37 @@
+import { OutboxMessage } from "../../contract/command/outbox.schema.mjs";
+import { OpenedActor } from "../actor/actor-database.service.mjs";
+import { Context, Effect, Layer, Result, Scope } from "effect";
+import { SqlError } from "effect/sql";
+interface Delivery extends OutboxMessage {
+  readonly principal: string;
+}
+type DeliveryBatch<Failure> = (deliveries: readonly Delivery[]) => Effect.Effect<readonly Result.Result<void, Failure>[], Failure>;
+interface Delivering<Failure> {
+  readonly exclusive: <Success, Error, Needs>(effect: Effect.Effect<Success, Error, Needs>) => Effect.Effect<Success, Error, Needs>;
+  readonly key: string;
+  readonly opened: OpenedActor;
+  readonly send: DeliveryBatch<Failure>;
+}
+interface Producing<Failure> extends Delivering<Failure> {
+  readonly committed: Effect.Effect<number>;
+  readonly read: Delivering<Failure>["exclusive"];
+}
+interface DeliverySession<Failure> {
+  readonly deliver: Effect.Effect<readonly string[], Failure | SqlError.SqlError>;
+  readonly flush: Effect.Effect<void, SqlError.SqlError>;
+}
+declare const sequentialDeliveries: <Failure, Needs>(send: (delivery: Delivery) => Effect.Effect<unknown, Failure, Needs>) => ((deliveries: readonly Delivery[]) => Effect.Effect<readonly Result.Result<void, Failure>[], never, Needs>);
+declare const OutboxRunner_base: Context.ServiceClass<OutboxRunner, "@akterjs/effect/host/outbox/outbox-runner.service/OutboxRunner", {
+  readonly deliver: <Failure>(delivering: Delivering<Failure>) => Effect.Effect<readonly string[], Failure | SqlError.SqlError>;
+  readonly open: <Failure>(delivering: Producing<Failure>) => Effect.Effect<DeliverySession<Failure>, never, Scope.Scope>;
+}> & {
+  readonly make: Effect.Effect<{
+    readonly deliver: <Failure>(delivering: Delivering<Failure>) => Effect.Effect<readonly string[], Failure | SqlError.SqlError>;
+    readonly open: <Failure>(delivering: Producing<Failure>) => Effect.Effect<DeliverySession<Failure>, never, Scope.Scope>;
+  }, never, never>;
+};
+export declare class OutboxRunner extends OutboxRunner_base {
+  static readonly sequentialDeliveries: typeof sequentialDeliveries;
+  static readonly layer: Layer.Layer<OutboxRunner, never, never>;
+}
+export type { Delivery, DeliveryBatch, DeliverySession };