@akterjs/effect 0.0.0-stage → 0.1.1

package/dist/host/outbox/outbox-runner.service.mjs

@@ -0,0 +1,155 @@
+import { Caller, actorKind } from "../../contract/caller/caller.schema.mjs";
+import { jsonCodec } from "../../contract/json-codec.pure.mjs";
+import { pendingThrough, pendingWindow, recordFailedDelivery } from "./actor-outbox.sql.mjs";
+import { acknowledgements } from "./outbox-acknowledgements.sql.mjs";
+import { Array, Clock, Context, Effect, Layer, Option, Predicate, Result, Schema, Scope } from "effect";
+// src/host/outbox/outbox-runner.service.ts
+const noSequence = 0;
+const targetWindow = 64;
+const refusals = [
+	"ActorAlreadyExistsError",
+	"ActorNotCreatedError",
+	"CallerNotAllowedError",
+	"CommandIdExpiredError",
+	"InvalidRequestError"
+];
+const refused = Effect.fnUntraced(function* refused(opened, message, error) {
+	const at = yield* Clock.currentTimeMillis;
+	yield* recordFailedDelivery({
+		at,
+		error,
+		message,
+		seq: message.seq,
+		sql: opened.sql
+	});
+	yield* Effect.logWarning(`${message.commandId} was refused by ${message.actor}/${message.key} with ${error}`);
+});
+const sequentialDeliveries = (send) => Effect.fnUntraced(function* sendSequential(deliveries) {
+	const results = [];
+	for (const delivery of deliveries) {
+		const result = yield* Effect.result(Effect.asVoid(send(delivery)));
+		results.push(result);
+		if (Result.isFailure(result)) break;
+	}
+	return results;
+});
+const flushSettled = Effect.fnUntraced(function* flushSettled(acknowledger, state) {
+	const last = Array.last(state.prefix);
+	if (Option.isSome(last)) {
+		yield* acknowledger.acknowledge(last.value.seq);
+		state.ids.push(...Array.map(state.prefix, (message) => message.commandId));
+		state.through = last.value.seq;
+		state.prefix = [];
+	}
+});
+const settleOne = Effect.fnUntraced(function* settleOne({ acknowledger, delivering }, state, [message, result]) {
+	if (Result.isSuccess(result) || Predicate.isTagged(result.failure, "HandlerFailedError")) {
+		state.prefix = Array.append(state.prefix, message);
+		return;
+	}
+	yield* flushSettled(acknowledger, state);
+	const refusal = Array.findFirst(refusals, (tag) => Predicate.isTagged(result.failure, tag));
+	yield* Option.match(refusal, {
+		onNone: () => Effect.fail(result.failure),
+		onSome: (error) => Effect.andThen(acknowledger.flush, delivering.exclusive(refused(delivering.opened, message, error)))
+	});
+	state.ids.push(message.commandId);
+	state.through = message.seq;
+});
+const settleWindow = Effect.fnUntraced(function* settleWindow(kit, messages, results) {
+	const state = {
+		ids: [],
+		prefix: [],
+		through: noSequence
+	};
+	yield* Effect.forEach(Array.zip(messages, results), (entry) => settleOne(kit, state, entry), { discard: true });
+	yield* flushSettled(kit.acknowledger, state);
+	if (Array.isReadonlyArrayEmpty(state.ids)) return yield* Effect.die("the target batch returned no acknowledgement");
+	return state;
+});
+const sendWindow = Effect.fnUntraced(function* sendWindow(kit, messages, principal) {
+	const deliveries = Array.map(messages, ({ seq: _seq, ...outgoing }) => ({
+		...outgoing,
+		principal
+	}));
+	const sent = yield* Effect.result(kit.delivering.send(deliveries));
+	const results = Result.match(sent, {
+		onFailure: (failure) => [Result.fail(failure)],
+		onSuccess: (outcomes) => outcomes
+	});
+	return yield* settleWindow(kit, messages, results);
+});
+const deliverBlock = Effect.fnUntraced(function* deliverBlock(kit, pending, principal) {
+	const state = {
+		ids: [],
+		prefix: pending,
+		through: noSequence
+	};
+	while (Array.isReadonlyArrayNonEmpty(state.prefix)) {
+		const [first] = state.prefix;
+		const window = Array.take(Array.takeWhile(state.prefix, (message) => message.actor === first.actor && message.key === first.key), targetWindow);
+		const settled = yield* sendWindow(kit, window, principal);
+		state.ids.push(...settled.ids);
+		state.through = settled.through;
+		state.prefix = Array.drop(state.prefix, settled.ids.length);
+	}
+	return state;
+});
+const open = Effect.fnUntraced(function* open(delivering) {
+	const scope = yield* Effect.scope;
+	const actor = delivering.opened.actor.name;
+	const principal = yield* Effect.orDie(Schema.encodeEffect(jsonCodec(Caller))({
+		kind: actorKind,
+		principal: {
+			actor,
+			id: `${actor}/${delivering.key}`,
+			key: delivering.key
+		}
+	}));
+	const acknowledger = yield* acknowledgements({
+		exclusive: delivering.exclusive,
+		sql: delivering.opened.sql
+	});
+	let after = noSequence;
+	const pendingAfter = (through) => {
+		if (through <= after) return Effect.succeed([]);
+		return pendingWindow({
+			after,
+			principal,
+			sql: delivering.opened.sql,
+			through
+		});
+	};
+	return {
+		deliver: Effect.gen(function* nextBlock() {
+			const pending = yield* delivering.read(Effect.flatMap(delivering.committed, pendingAfter));
+			const settled = yield* deliverBlock({
+				acknowledger,
+				delivering
+			}, pending, principal);
+			if (Array.isReadonlyArrayNonEmpty(settled.ids)) after = settled.through;
+			else yield* acknowledger.flush;
+			return settled.ids;
+		}).pipe(Scope.provide(scope)),
+		flush: acknowledger.flush
+	};
+});
+const deliver = (delivering) => Effect.scoped(Effect.gen(function* deliverOnce() {
+	const through = yield* delivering.exclusive(pendingThrough(delivering.opened.sql));
+	const session = yield* open({
+		...delivering,
+		committed: Effect.succeed(through),
+		read: delivering.exclusive
+	});
+	const result = yield* Effect.exit(session.deliver);
+	yield* session.flush;
+	return yield* result;
+}));
+var OutboxRunner = class extends Context.Service()("@akterjs/effect/host/outbox/outbox-runner.service/OutboxRunner", { make: Effect.succeed({
+	deliver,
+	open
+}) }) {
+	static sequentialDeliveries = sequentialDeliveries;
+	static layer = Layer.effect(this, this.make);
+};
+export { OutboxRunner };

package/dist/host/query/query-policy.pure.d.mts

@@ -0,0 +1,15 @@
+import { Context, Option } from "effect";
+import { SqlError } from "effect/sql";
+interface QueryReadScope {
+  readonly refusal: () => Option.Option<SqlError.SqlError>;
+  readonly refuse: (failure: SqlError.SqlError) => void;
+}
+declare const QueryReadOnly: Context.Reference<Option.Option<QueryReadScope>>;
+/**
+ * True while a statement comes from an actor's own handler code. A handler may read the engine-owned `akter_*`
+ * tables but never write them; the engine's own journal, state and outbox writes run with this false.
+ */
+declare const HandlerSql: Context.Reference<boolean>;
+/** Whether a write to `table` in the main database is refused to handler SQL. */
+declare const engineOwned: (table: string) => boolean;
+export { HandlerSql, QueryReadOnly, type QueryReadScope, engineOwned };

package/dist/host/query/query-policy.pure.mjs

@@ -0,0 +1,12 @@
+import { Context, Option, String } from "effect";
+// src/host/query/query-policy.pure.ts
+const QueryReadOnly = Context.Reference("@akterjs/effect/host/query/query-policy.pure/QueryReadOnly", { defaultValue: Option.none });
+/**
+* True while a statement comes from an actor's own handler code. A handler may read the engine-owned `akter_*`
+* tables but never write them; the engine's own journal, state and outbox writes run with this false.
+*/
+const HandlerSql = Context.Reference("@akterjs/effect/host/query/query-policy.pure/HandlerSql", { defaultValue: () => false });
+const engineTablePrefix = "akter_";
+/** Whether a write to `table` in the main database is refused to handler SQL. */
+const engineOwned = (table) => String.startsWith(engineTablePrefix)(String.toLowerCase(table));
+export { HandlerSql, QueryReadOnly, engineOwned };

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

@@ -0,0 +1,42 @@
+import { JournalWindow } from "../../contract/history/actor-journal.service.mjs";
+import "../../contract/actor/actor.contract.mjs";
+import { HostedError } from "../../contract/hosted/hosted-error.contract.mjs";
+import { OpenedActor } from "../actor/actor-database.service.mjs";
+import { fileUsagePage } from "../blob/reference/blob-file-page.sql.mjs";
+import { FileListing, FileUsagePage } from "../../contract/file/actor-files.contract.mjs";
+import { stepByKey, stepsPage } from "../computer/computer-steps.sql.mjs";
+import { Context, Effect, Layer } from "effect";
+import { SqlError } from "effect/sql";
+interface QueryRequest {
+  readonly key: string;
+  readonly member: string;
+  readonly payload: string;
+  readonly principal: string;
+}
+interface Querying {
+  readonly opened: OpenedActor;
+  readonly request: QueryRequest;
+}
+interface CoverageReading {
+  readonly opened: OpenedActor;
+  readonly since: number;
+}
+interface HistoryReading extends CoverageReading {
+  readonly after: number;
+  readonly limit: number;
+}
+declare const QueryRunner_base: Context.ServiceClass<QueryRunner, "@akterjs/effect/host/query/query-runner.service/QueryRunner", {
+  readonly coveredSince: (reading: CoverageReading) => Effect.Effect<number, SqlError.SqlError>;
+  readonly files: (opened: OpenedActor, listing?: FileListing) => ReturnType<typeof fileUsagePage>;
+  readonly history: (reading: HistoryReading) => Effect.Effect<JournalWindow, SqlError.SqlError>;
+  readonly run: (querying: Querying) => Effect.Effect<string, HostedError | SqlError.SqlError>;
+  readonly runLocked: (querying: Querying) => Effect.Effect<string, HostedError | SqlError.SqlError>;
+  /** The actor's durable computer steps, newest first, without output (`Akter`'s `step`). */
+  readonly steps: (opened: OpenedActor, limit?: number) => ReturnType<typeof stepsPage>;
+  /** One durable computer step by its key, with its output. */
+  readonly step: (opened: OpenedActor, step: string) => ReturnType<typeof stepByKey>;
+}>;
+export declare class QueryRunner extends QueryRunner_base {
+  static readonly layer: Layer.Layer<QueryRunner, never, never>;
+}
+export type { FileUsagePage as FileUsage, QueryRequest };

package/dist/host/query/query-runner.service.mjs

@@ -0,0 +1,72 @@
+import { currentState, journalSince, prunedBefore } from "../command/command-journal.sql.mjs";
+import { fileUsagePage } from "../blob/reference/blob-file-page.sql.mjs";
+import { stepByKey, stepsPage } from "../computer/computer-steps.sql.mjs";
+import { QueryReadOnly } from "./query-policy.pure.mjs";
+import { Clock, Context, Effect, Layer, Option, Record } from "effect";
+// src/host/query/query-runner.service.ts
+const coveredSince = ({ opened, since }) => Effect.map(prunedBefore(opened.reader), (cut) => Math.max(since, Option.getOrElse(cut, () => since)));
+const history = Effect.fn("QueryRunner.history")(function* history(reading) {
+	const entries = yield* journalSince({
+		after: reading.after,
+		limit: reading.limit,
+		since: reading.since,
+		sql: reading.opened.reader
+	});
+	return {
+		coveredSince: yield* coveredSince(reading),
+		entries
+	};
+});
+const runLocked = Effect.fn("QueryRunner.runLocked")(function* run({ opened: { actor, files, reader }, request }) {
+	const policy = { refused: Option.none() };
+	const scope = {
+		refusal: () => policy.refused,
+		refuse: (failure) => {
+			if (Option.isNone(policy.refused)) policy.refused = Option.some(failure);
+		}
+	};
+	const reading = reader.withTransaction(Effect.gen(function* snapshot() {
+		const state = yield* currentState(reader);
+		return yield* actor.runQuery({
+			...request,
+			state
+		}, {
+			files: files(reader),
+			id: Effect.die(`${actor.name}: a query never mints ids`),
+			key: request.key,
+			now: Clock.currentTimeMillis,
+			sql: reader
+		});
+	})).pipe(Effect.provideService(QueryReadOnly, Option.some(scope)));
+	const exit = yield* Effect.exit(reading);
+	return yield* Option.match(scope.refusal(), {
+		onNone: () => exit,
+		onSome: Effect.fail
+	});
+});
+const run = (querying) => Option.match(Option.fromNullishOr(querying.opened.fileSession), {
+	onNone: () => runLocked(querying),
+	onSome: ({ home, owner }) => home.transfers.admit(owner.snapshot(runLocked(querying)))
+});
+var QueryRunner = class extends Context.Service()("@akterjs/effect/host/query/query-runner.service/QueryRunner") {
+	static layer = Layer.succeed(this, {
+		coveredSince,
+		files: (opened, listing = {}) => fileUsagePage({
+			actor: opened.fileSession?.owner.actor ?? "",
+			listing,
+			sql: opened.reader
+		}),
+		history,
+		run,
+		runLocked,
+		step: (opened, step) => stepByKey({
+			sql: opened.reader,
+			step
+		}),
+		steps: (opened, limit) => stepsPage({
+			...Record.getSomes({ limit: Option.fromUndefinedOr(limit) }),
+			sql: opened.reader
+		})
+	});
+};
+export { QueryRunner };

package/dist/host/sqlite/actor-connections.pure.d.mts

@@ -0,0 +1,26 @@
+import { ActorErasedError } from "../../contract/actor/actor-erased.errors.mjs";
+import { Context, Effect, Option } from "effect";
+import { SqlError } from "effect/sql";
+type SqliteValue = null | number | bigint | string | Uint8Array;
+type SqliteRow = Readonly<Record<string, SqliteValue>>;
+interface SqliteStatement {
+  readonly all: (...params: SqliteValue[]) => readonly SqliteRow[];
+}
+interface SqliteHandle {
+  readonly close: () => void;
+  readonly exec: (sql: string) => void;
+  readonly isTransaction: () => boolean;
+  readonly prepare: (sql: string) => SqliteStatement;
+  readonly queryOnly?: (enabled: boolean) => void;
+  /** Refuses writes to the engine-owned `akter_*` tables while handler SQL runs (`HandlerSql`). */
+  readonly handlerWrites?: (refused: boolean) => void;
+  /** The engine-owned table the last refused write named, cleared as it is read. */
+  readonly refusedTable?: () => Option.Option<string>;
+}
+interface ActorDatabaseTarget {
+  readonly actor: string;
+  readonly filename: string;
+}
+type ActorConnectionOpener = (target: ActorDatabaseTarget, plain: Effect.Effect<SqliteHandle, SqlError.SqlError>) => Effect.Effect<SqliteHandle, ActorErasedError | SqlError.SqlError>;
+declare const ActorConnections: Context.Reference<ActorConnectionOpener>;
+export { type ActorConnectionOpener, ActorConnections, type ActorDatabaseTarget, type SqliteHandle, type SqliteRow, type SqliteStatement, type SqliteValue };

package/dist/host/sqlite/actor-connections.pure.mjs

@@ -0,0 +1,4 @@
+import { Context } from "effect";
+// src/host/sqlite/actor-connections.pure.ts
+const ActorConnections = Context.Reference("@akterjs/effect/host/sqlite/actor-connections.pure/ActorConnections", { defaultValue: () => (_target, plain) => plain });
+export { ActorConnections };

package/dist/host/sqlite/sqlite-connection.adapter.d.mts

@@ -0,0 +1,22 @@
+import { ActorErasedError } from "../../contract/actor/actor-erased.errors.mjs";
+import { ActorDatabaseTarget } from "./actor-connections.pure.mjs";
+import { Context, Effect, Layer, Option, Scope } from "effect";
+import { SqlConnection, SqlError } from "effect/sql";
+interface OpenConnection {
+  readonly connection: SqlConnection.Connection;
+  readonly isTransaction: () => boolean;
+}
+interface ActorConnection extends OpenConnection {
+  readonly reads: Option.Option<SqlConnection.Connection>;
+}
+interface OpenOptions {
+  readonly readOnly: boolean;
+}
+declare const SqliteConnection_base: Context.ServiceClass<SqliteConnection, "@akterjs/effect/host/sqlite/sqlite-connection.adapter/SqliteConnection", {
+  readonly open: (filename: string, options?: OpenOptions) => Effect.Effect<OpenConnection, SqlError.SqlError, Scope.Scope>;
+  readonly openActor: (target: ActorDatabaseTarget) => Effect.Effect<ActorConnection, ActorErasedError | SqlError.SqlError, Scope.Scope>;
+}>;
+export declare class SqliteConnection extends SqliteConnection_base {
+  static readonly layerNode: Layer.Layer<SqliteConnection, never, never>;
+}
+export type { ActorConnection, OpenConnection, OpenOptions };

package/dist/host/sqlite/sqlite-connection.adapter.mjs

@@ -0,0 +1,151 @@
+import { engineOwnedRefusal } from "../../contract/hosted/handler-failure.pure.mjs";
+import { HandlerSql, engineOwned } from "../query/query-policy.pure.mjs";
+import { ActorConnections } from "./actor-connections.pure.mjs";
+import { bindParameters, sqliteFailure } from "./sqlite-parameters.pure.mjs";
+import { Array, Context, Effect, Exit, Layer, Option, Predicate, Record, Stream, identity } from "effect";
+import { SqlError } from "effect/sql";
+import { DatabaseSync, constants } from "node:sqlite";
+// src/host/sqlite/sqlite-connection.adapter.ts
+const busyTimeoutMillis = 5e3;
+const writable = { readOnly: false };
+const checkpointSql = "PRAGMA wal_checkpoint(TRUNCATE)";
+const busyTimeoutSql = `PRAGMA busy_timeout = ${busyTimeoutMillis}`;
+const schemaVersionSql = "PRAGMA schema_version";
+const rollbackSql = "ROLLBACK";
+const openFailure = sqliteFailure("open database");
+const checkpointFailure = sqliteFailure("checkpoint the WAL at close");
+const refusedWrite = (database, cause) => Option.match(Option.flatMap(Option.fromNullishOr(database.refusedTable), (taken) => taken()), {
+	onNone: () => sqliteFailure("execute statement")(cause),
+	onSome: (table) => SqlError.SqlError.make({ reason: SqlError.classifySqliteError(cause, {
+		message: engineOwnedRefusal(table),
+		operation: "execute statement"
+	}) })
+});
+const connect = (database, queryOnly) => {
+	const rows = (...[sql, params]) => Effect.flatMap(Effect.all([HandlerSql, bindParameters(params)]), ([handler, inputs]) => Effect.try({
+		catch: (cause) => refusedWrite(database, cause),
+		try: () => {
+			database.queryOnly?.(queryOnly);
+			database.handlerWrites?.(handler && !queryOnly);
+			return Array.map(database.prepare(sql).all(...inputs), Record.map(identity));
+		}
+	}));
+	const execute = (sql, params, transformRows) => Effect.map(rows(sql, params), transformRows ?? identity);
+	const executeValues = (sql, params) => Effect.map(rows(sql, params), Array.map(Record.values));
+	return {
+		execute,
+		executeRaw: rows,
+		executeStream: () => Stream.die("node:sqlite does not stream"),
+		executeUnprepared: execute,
+		executeValues,
+		executeValuesUnprepared: executeValues
+	};
+};
+const readable = (opened) => Effect.as(Effect.tapError(Effect.try({
+	catch: openFailure,
+	try: () => {
+		opened.exec(busyTimeoutSql);
+		opened.exec(schemaVersionSql);
+	}
+}), () => Effect.sync(() => {
+	opened.close();
+})), opened);
+const checkpoint = (database) => Effect.try({
+	catch: checkpointFailure,
+	try: () => {
+		database.queryOnly?.(false);
+		database.exec(checkpointSql);
+	}
+});
+const releaseDatabase = (database) => Effect.sync(() => {
+	database.queryOnly?.(false);
+	if (database.isTransaction()) database.exec(rollbackSql);
+	database.close();
+});
+const closeDatabase = (database, exit, readOnly) => {
+	if (readOnly) return releaseDatabase(database);
+	return Effect.ensuring(checkpoint(database).pipe(Effect.tapError((failure) => Effect.logError(failure.message)), Effect.catchTag("SqlError", (failure) => Exit.match(exit, {
+		onFailure: () => Effect.void,
+		onSuccess: () => Effect.die(failure)
+	}))), releaseDatabase(database));
+};
+const engineWrites = /* @__PURE__ */ new Set([
+	constants.SQLITE_INSERT,
+	constants.SQLITE_UPDATE,
+	constants.SQLITE_DELETE
+]);
+/** An authorizer, installed only while handler SQL runs, that refuses writes to the main database's `akter_*` tables. */
+const handlerGuard = (database) => {
+	const guard = {
+		denied: Option.none(),
+		refusing: false
+	};
+	/** SQLite passes the table second and the database fourth for INSERT, UPDATE and DELETE. */
+	const authorize = (action, ...names) => {
+		const [table, , schema] = names;
+		if (engineWrites.has(action) && schema === "main" && Predicate.isString(table) && engineOwned(table)) {
+			guard.denied = Option.some(table);
+			return constants.SQLITE_DENY;
+		}
+		return constants.SQLITE_OK;
+	};
+	return {
+		handlerWrites: (refused) => {
+			if (refused !== guard.refusing) {
+				guard.refusing = refused;
+				database.setAuthorizer(Option.getOrNull(Option.liftPredicate(authorize, () => refused)));
+			}
+		},
+		refusedTable: () => {
+			const { denied } = guard;
+			guard.denied = Option.none();
+			return denied;
+		}
+	};
+};
+const openPlain = (filename, { readOnly } = writable) => Effect.try({
+	catch: openFailure,
+	try: () => {
+		const database = new DatabaseSync(filename, {
+			readOnly,
+			timeout: busyTimeoutMillis
+		});
+		return {
+			close: () => {
+				database.close();
+			},
+			exec: (sql) => {
+				database.exec(sql);
+			},
+			isTransaction: () => database.isTransaction,
+			prepare: (sql) => database.prepare(sql),
+			...handlerGuard(database)
+		};
+	}
+});
+const held = (opening, { readOnly } = writable) => Effect.acquireRelease(Effect.flatMap(opening, readable), (opened, exit) => closeDatabase(opened, exit, readOnly));
+const openNode = Effect.fn("SqliteConnection.openNode")(function* openNode(filename, options = writable) {
+	const database = yield* held(openPlain(filename, options), options);
+	return {
+		connection: connect(database, false),
+		isTransaction: database.isTransaction
+	};
+});
+const actorConnectionOf = (database) => ({
+	connection: connect(database, false),
+	isTransaction: database.isTransaction,
+	reads: Option.map(Option.fromNullishOr(database.queryOnly), () => connect(database, true))
+});
+var SqliteConnection = class extends Context.Service()("@akterjs/effect/host/sqlite/sqlite-connection.adapter/SqliteConnection") {
+	static layerNode = Layer.effect(this, Effect.gen(function* makeSqliteConnection() {
+		const opener = yield* ActorConnections;
+		return {
+			open: openNode,
+			openActor: (target) => {
+				const opening = opener(target, openPlain(target.filename));
+				return Effect.map(held(opening), actorConnectionOf);
+			}
+		};
+	}));
+};
+export { SqliteConnection };

package/dist/host/sqlite/sqlite-driver.service.d.mts

@@ -0,0 +1,33 @@
+import { ActorErasedError } from "../../contract/actor/actor-erased.errors.mjs";
+import { ActorDatabaseTarget } from "./actor-connections.pure.mjs";
+import { OpenOptions, SqliteConnection } from "./sqlite-connection.adapter.mjs";
+import { Context, Effect, Layer, Scope } from "effect";
+import { SqlClient, SqlError } from "effect/sql";
+type Open = (filename: string, options?: OpenOptions) => Effect.Effect<SqlClient.SqlClient, SqlError.SqlError, Scope.Scope>;
+type ActorFailure = ActorErasedError | SqlError.SqlError;
+interface ActorClients {
+  readonly reader: Effect.Effect<SqlClient.SqlClient, ActorFailure, Scope.Scope>;
+  readonly sql: SqlClient.SqlClient;
+}
+interface InMemory {
+  readonly reader: SqlClient.SqlClient;
+  readonly sql: SqlClient.SqlClient;
+}
+declare const SqliteDriver_base: Context.ServiceClass<SqliteDriver, "@akterjs/effect/host/sqlite/sqlite-driver.service/SqliteDriver", {
+  readonly open: Open;
+  readonly openActor: (target: ActorDatabaseTarget) => Effect.Effect<ActorClients, ActorFailure, Scope.Scope>;
+  readonly openInMemory: Effect.Effect<InMemory, SqlError.SqlError, Scope.Scope>;
+  readonly openQueryOnly: Open;
+}> & {
+  readonly make: Effect.Effect<{
+    readonly open: Open;
+    readonly openActor: (target: ActorDatabaseTarget) => Effect.Effect<ActorClients, ActorFailure, Scope.Scope>;
+    readonly openInMemory: Effect.Effect<InMemory, SqlError.SqlError, Scope.Scope>;
+    readonly openQueryOnly: Open;
+  }, never, SqliteConnection>;
+};
+export declare class SqliteDriver extends SqliteDriver_base {
+  static readonly layer: Layer.Layer<SqliteDriver, never, SqliteConnection>;
+  static readonly layerNode: Layer.Layer<SqliteDriver, never, never>;
+}
+export {};

package/dist/host/sqlite/sqlite-driver.service.mjs

@@ -0,0 +1,88 @@
+import { SqliteConnection } from "./sqlite-connection.adapter.mjs";
+import { Context, Effect, Layer, Option, Semaphore } from "effect";
+import { SqlClient, Statement } from "effect/sql";
+import { Reactivity } from "effect/reactivity";
+// src/host/sqlite/sqlite-driver.service.ts
+const holders = 1;
+const writerMode = {
+	beginTransaction: "BEGIN IMMEDIATE",
+	pragmas: ["PRAGMA journal_mode = WAL", "PRAGMA synchronous = FULL"]
+};
+const queryOnlyMode = {
+	beginTransaction: "BEGIN DEFERRED",
+	pragmas: ["PRAGMA query_only = ON"]
+};
+const inMemory = ":memory:";
+const clientOf = Effect.fnUntraced(function* clientOf({ connection, isTransaction }, beginTransaction, semaphore) {
+	const reactivity = yield* Reactivity.make;
+	const acquirers = SqlClient.makeSqliteAcquirers({
+		connection: Effect.succeed(connection),
+		isTransaction,
+		semaphore
+	});
+	return yield* Effect.provideService(SqlClient.make({
+		acquirer: acquirers.acquirer,
+		beginTransaction,
+		borrower: acquirers.borrower,
+		compiler: Statement.makeCompilerSqlite(),
+		driver: "sqlite",
+		isTransaction: acquirers.isTransaction,
+		onCommitFailure: acquirers.onCommitFailure,
+		releaseSavepoint: (name) => `RELEASE SAVEPOINT ${name}`,
+		spanAttributes: [["db.system.name", "sqlite"]],
+		transactionAcquirer: acquirers.transactionAcquirer
+	}), Reactivity.Reactivity, reactivity);
+});
+const prepared = Effect.fnUntraced(function* prepared({ beginTransaction, pragmas }, opened, semaphore) {
+	const client = yield* clientOf(opened, beginTransaction, semaphore);
+	yield* Effect.forEach(pragmas, (pragma) => client.unsafe(pragma), { discard: true });
+	return client;
+});
+var SqliteDriver = class extends Context.Service()("@akterjs/effect/host/sqlite/sqlite-driver.service/SqliteDriver", { make: Effect.gen(function* makeSqliteDriver() {
+	const connections = yield* SqliteConnection;
+	const openIn = (mode) => Effect.fn("SqliteDriver.open")(function* open(filename, options) {
+		const opened = yield* connections.open(filename, options);
+		const semaphore = yield* Semaphore.make(holders);
+		return yield* prepared(mode, opened, semaphore);
+	});
+	const ownReader = Effect.fnUntraced(function* ownReader(target) {
+		const opened = yield* connections.openActor(target);
+		const semaphore = yield* Semaphore.make(holders);
+		return yield* prepared(queryOnlyMode, opened, semaphore);
+	});
+	const openActor = Effect.fn("SqliteDriver.openActor")(function* openActor(target) {
+		const opened = yield* connections.openActor(target);
+		const semaphore = yield* Semaphore.make(holders);
+		const sql = yield* prepared(writerMode, opened, semaphore);
+		return {
+			reader: Option.match(opened.reads, {
+				onNone: () => ownReader(target),
+				onSome: (connection) => clientOf({
+					connection,
+					isTransaction: opened.isTransaction
+				}, queryOnlyMode.beginTransaction, semaphore)
+			}),
+			sql
+		};
+	});
+	const openInMemory = Effect.gen(function* openInMemory() {
+		const opened = yield* connections.open(inMemory);
+		const writes = yield* Semaphore.make(holders);
+		const reads = yield* Semaphore.make(holders);
+		const sql = yield* clientOf(opened, writerMode.beginTransaction, writes);
+		return {
+			reader: yield* clientOf(opened, queryOnlyMode.beginTransaction, reads),
+			sql
+		};
+	});
+	return {
+		open: openIn(writerMode),
+		openActor,
+		openInMemory,
+		openQueryOnly: openIn(queryOnlyMode)
+	};
+}) }) {
+	static layer = Layer.effect(this, this.make);
+	static layerNode = this.layer.pipe(Layer.provide(SqliteConnection.layerNode));
+};
+export { SqliteDriver };

package/dist/host/sqlite/sqlite-parameters.pure.d.mts

@@ -0,0 +1,5 @@
+import { Effect } from "effect";
+import { SqlError } from "effect/sql";
+declare const sqliteFailure: (operation: string) => ((cause: unknown) => SqlError.SqlError);
+declare const bindParameters: (input: unknown, options?: import("effect/SchemaAST").ParseOptions | undefined) => Effect.Effect<readonly (string | number | bigint | Uint8Array<ArrayBufferLike> | null)[], SqlError.SqlError, never>;
+export { bindParameters, sqliteFailure };

package/dist/host/sqlite/sqlite-parameters.pure.mjs

@@ -0,0 +1,21 @@
+import { reasonText, sqliteReason } from "./sqlite-reason.pure.mjs";
+import { Effect, Option, Schema, flow } from "effect";
+import { SqlError } from "effect/sql";
+// src/host/sqlite/sqlite-parameters.pure.ts
+const SqliteParameters = Schema.Array(Schema.Union([
+	Schema.Null,
+	Schema.Finite,
+	Schema.BigInt,
+	Schema.String,
+	Schema.Uint8Array
+]));
+const failureMessage = (operation, cause) => Option.match(sqliteReason(cause), {
+	onNone: () => `Failed to ${operation}`,
+	onSome: (reason) => `Failed to ${operation}: ${reasonText(reason)}`
+});
+const sqliteFailure = (operation) => (cause) => SqlError.SqlError.make({ reason: SqlError.classifySqliteError(cause, {
+	message: failureMessage(operation, cause),
+	operation
+}) });
+const bindParameters = flow(Schema.decodeUnknownEffect(SqliteParameters), Effect.mapError(sqliteFailure("bind parameters")));
+export { bindParameters, sqliteFailure };

package/dist/host/sqlite/sqlite-reason.pure.d.mts

@@ -0,0 +1,8 @@
+import { Option } from "effect";
+interface SqliteReason {
+  readonly code: number;
+  readonly message: string;
+}
+declare const sqliteReason: (cause: unknown) => Option.Option<SqliteReason>;
+declare const reasonText: ({ code, message }: SqliteReason) => string;
+export { type SqliteReason, reasonText, sqliteReason };