@voltro/sql-turso 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,159 @@
+import * as Client from '@effect/sql/SqlClient';
+import { ConfigError } from 'effect/ConfigError';
+import { ConnectionConfig } from '@voltro/database';
+import { Context } from 'effect';
+import { Duration } from 'effect';
+import { Layer } from 'effect';
+import { RetryDecision } from '@voltro/database';
+import { SqlClient } from '@effect/sql/SqlClient';
+import { SqlDialect } from '@voltro/database';
+import { SqlError } from '@effect/sql/SqlError';
+
+export declare const connectionFromConfig: (config: ConnectionConfig) => ParsedTursoConnection;
+
+export declare const isTursoRetryableFailure: (err: unknown) => boolean;
+
+/**
+ * @category models
+ */
+export declare interface LibsqlClient extends Client.SqlClient {
+    readonly [TypeId_2]: TypeId_2;
+    readonly config: LibsqlClientConfig;
+}
+
+/**
+ * @category tags
+ */
+export declare const LibsqlClient: Context.Tag<LibsqlClient, LibsqlClient>;
+
+/**
+ * @category models
+ */
+export declare interface LibsqlClientConfig {
+    /**
+     * The database URL. Remote Turso Cloud uses `libsql://`, `https://`, or
+     * `wss://`; an embedded replica uses a local `file:` path (paired with
+     * `syncUrl`).
+     */
+    readonly url: string;
+    /**
+     * Turso Cloud auth token. Sourced from config/env (`DB_AUTH_TOKEN`); never
+     * logged or baked into the build.
+     */
+    readonly authToken?: string | undefined;
+    /**
+     * Embedded-replica sync source: the remote Turso Cloud primary a local
+     * `file:` replica syncs FROM. When set with a `file:` url, the client runs an
+     * embedded replica — local reads, writes forwarded to the primary, periodic
+     * pull-sync of the primary's frames.
+     */
+    readonly syncUrl?: string | undefined;
+    /**
+     * Embedded-replica pull-sync interval. When set (and `syncUrl` is set), the
+     * client resyncs on this cadence; unset means sync only on explicit
+     * `client.sync()` (which this layer fires once at startup).
+     */
+    readonly syncInterval?: Duration.DurationInput | undefined;
+    /**
+     * Read-your-writes for an embedded replica: after a write to the primary,
+     * block local reads until the replica has caught up to that write. Defaults
+     * to the driver's default (on).
+     */
+    readonly readYourWrites?: boolean | undefined;
+    /** Encryption key for a local embedded-replica file at rest. */
+    readonly encryptionKey?: string | undefined;
+    readonly spanAttributes?: Record<string, unknown> | undefined;
+    readonly transformResultNames?: ((str: string) => string) | undefined;
+    readonly transformQueryNames?: ((str: string) => string) | undefined;
+}
+
+/** The parsed remote / embedded-replica (libsql-client) connection shape. */
+export declare interface LibsqlConnection {
+    readonly kind: 'remote';
+    /** `libsql://` / `https://` / `wss://` (Turso Cloud), or a `file:` embedded replica. */
+    readonly url: string;
+    /** Turso Cloud auth token (from env; never logged/baked). */
+    readonly authToken?: string;
+    /** Embedded-replica sync source — the remote primary a `file:` replica syncs from. */
+    readonly syncUrl?: string;
+    /** Embedded-replica pull-sync interval, in seconds. */
+    readonly syncIntervalSeconds?: number;
+    /** Read-your-writes for an embedded replica. */
+    readonly readYourWrites?: boolean;
+    /** Encryption key for a local embedded-replica file at rest. */
+    readonly encryptionKey?: string;
+}
+
+export declare const makeLibsqlSqlLayer: (options: Omit<LibsqlConnection, "kind">) => TursoSqlLayer;
+
+export declare const makeTursoSqlLayer: (options: Omit<TursoConnection, "kind">) => TursoSqlLayer;
+
+export declare const makeTursoSqlLayerFromConfig: (config: ConnectionConfig) => TursoSqlLayer;
+
+export declare type ParsedTursoConnection = TursoConnection | LibsqlConnection;
+
+/**
+ * @category models
+ */
+export declare interface TursoClient extends Client.SqlClient {
+    readonly [TypeId]: TypeId;
+    readonly config: TursoClientConfig;
+}
+
+/**
+ * @category tags
+ */
+export declare const TursoClient: Context.Tag<TursoClient, TursoClient>;
+
+/**
+ * @category models
+ */
+export declare interface TursoClientConfig {
+    /** `file:`-stripped path, or `:memory:` for an ephemeral in-process DB. */
+    readonly filename: string;
+    readonly readonly?: boolean | undefined;
+    /**
+     * Connection-pool size. The MVCC write-concurrency knob — this many
+     * `BEGIN CONCURRENT` transactions can run at once. Default 4. Forced to 1
+     * for `:memory:` (each `:memory:` connection is a PRIVATE database, so a
+     * pool would split state).
+     */
+    readonly maxConnections?: number | undefined;
+    readonly prepareCacheSize?: number | undefined;
+    readonly prepareCacheTTL?: Duration.DurationInput | undefined;
+    readonly spanAttributes?: Record<string, unknown> | undefined;
+    readonly transformResultNames?: ((str: string) => string) | undefined;
+    readonly transformQueryNames?: ((str: string) => string) | undefined;
+}
+
+/** The parsed local (Rust-engine) connection shape. */
+export declare interface TursoConnection {
+    readonly kind: 'local';
+    /** Absolute or relative path, or `:memory:` for ephemeral. */
+    readonly filename: string;
+    readonly readonly?: boolean;
+    /** Connection-pool size (the MVCC write-concurrency knob). */
+    readonly maxConnections?: number;
+}
+
+export declare const tursoDialect: SqlDialect;
+
+export declare const tursoRetryFilter: (err: unknown) => RetryDecision;
+
+declare type TursoSqlLayer = Layer.Layer<SqlClient, ConfigError | SqlError, never>;
+
+/**
+ * @category type ids
+ */
+declare const TypeId: unique symbol;
+
+declare type TypeId = typeof TypeId;
+
+/**
+ * @category type ids
+ */
+declare const TypeId_2: unique symbol;
+
+declare type TypeId_2 = typeof TypeId_2;
+
+export { }

package/dist/index.js

@@ -0,0 +1,330 @@
+import { makeSqliteStore as e } from "@voltro/sql-sqlite";
+import { Cache as t, Chunk as n, Config as r, Context as i, Duration as a, Effect as o, FiberRef as s, Layer as c, Pool as l, Scope as u, Stream as d } from "effect";
+import * as f from "@effect/experimental/Reactivity";
+import * as p from "@effect/sql/SqlClient";
+import { SqlError as m } from "@effect/sql/SqlError";
+import * as h from "@effect/sql/Statement";
+import { identity as ee } from "effect/Function";
+import { connect as te } from "@tursodatabase/database";
+import { createLogger as g } from "@voltro/logger";
+import { createClient as _ } from "@libsql/client";
+//#region src/sqlClient.ts
+var v = g({ scope: "voltro:turso" }), y = "db.system.name", ne = /no transaction is active|no active transaction|cannot rollback|cannot commit/i, b = s.unsafeMake(!1), x = (e) => o.locally(e, b, !0), S = Symbol.for("@voltro/sql-turso/TursoClient"), C = i.GenericTag("@voltro/sql-turso/TursoClient"), w = (e) => (t) => {
+	let n = t?.message;
+	return new m({
+		cause: t,
+		message: typeof n == "string" ? `${e}: ${n}` : e
+	});
+}, re = /file is locked|locking error|failed locking file/i, T = (e) => (t) => {
+	let n = String(t?.message ?? t);
+	return re.test(n) ? new m({
+		cause: t,
+		message: `@voltro/sql-turso: database file '${e}' is locked by another process. Turso is single-process (it takes an exclusive file lock) — you cannot run multiple instances / replicas against one file. For a multi-replica deployment use DB_DIALECT=postgres (or mysql / mariadb / mssql).`
+	}) : new m({
+		cause: t,
+		message: `Failed to open Turso database: ${n}`
+	});
+}, E = (e) => o.gen(function* () {
+	let r = yield* o.scope, c = yield* o.tryPromise({
+		try: () => te(e.filename, {
+			readonly: e.readonly ?? !1,
+			experimental: ["attach"]
+		}),
+		catch: T(e.filename)
+	});
+	yield* u.addFinalizer(r, o.promise(async () => {
+		try {
+			await c.close();
+		} catch {}
+	})), yield* o.tryPromise({
+		try: () => c.pragma("journal_mode=experimental_mvcc", void 0),
+		catch: w("Failed to enable Turso MVCC (journal_mode=experimental_mvcc)")
+	}), yield* o.tryPromise({
+		try: () => c.pragma("foreign_keys=ON", void 0),
+		catch: w("Failed to enable foreign-key enforcement (foreign_keys=ON)")
+	});
+	let l = (e) => c.prepare(e), f = yield* t.make({
+		capacity: e.prepareCacheSize ?? 200,
+		timeToLive: e.prepareCacheTTL ?? a.minutes(10),
+		lookup: (e) => o.try({
+			try: () => l(e),
+			catch: w("Failed to prepare statement")
+		})
+	}), h = (e, t, n) => o.withFiberRuntime((r) => (i.get(r.currentContext, p.SafeIntegers) && e.safeIntegers(!0), e.reader ? o.tryPromise({
+		try: () => e.all(...t),
+		catch: w("Failed to execute statement")
+	}) : o.tryPromise({
+		try: async () => {
+			let r = await e.run(...t);
+			return n ? r : [];
+		},
+		catch: w("Failed to execute statement")
+	}))), g = (e, t, n = !1) => o.flatMap(f.get(e), (e) => h(e, t, n)), _ = (e, t) => o.acquireUseRelease(f.get(e), (e) => o.tryPromise({
+		try: async () => e.reader ? (e.raw(!0), await e.all(...t)) : (await e.run(...t), []),
+		catch: w("Failed to execute statement")
+	}), (e) => o.sync(() => {
+		e.reader && e.raw(!1);
+	}));
+	return ee({
+		execute(e, t, n) {
+			return n ? o.map(g(e, t), n) : g(e, t);
+		},
+		executeRaw(e, t) {
+			return g(e, t, !0);
+		},
+		executeValues(e, t) {
+			return _(e, t);
+		},
+		executeUnprepared(e, t, n) {
+			let r = o.flatMap(s.get(b), (n) => {
+				let r = n && e === "BEGIN" ? "BEGIN CONCURRENT" : e;
+				return o.acquireUseRelease(o.try({
+					try: () => l(r),
+					catch: w("Failed to prepare statement")
+				}), (e) => h(e, t ?? [], !1).pipe(o.catchIf((e) => ne.test(String(e?.message ?? "")), () => o.succeed([]))), (e) => o.sync(() => {
+					try {
+						e.close();
+					} catch {}
+				}));
+			});
+			return n ? o.map(r, n) : r;
+		},
+		executeStream(e, t, r) {
+			let i = d.acquireRelease(o.try({
+				try: () => l(e),
+				catch: w("Failed to prepare statement")
+			}), (e) => o.sync(() => {
+				try {
+					e.close();
+				} catch {}
+			})).pipe(d.flatMap((e) => d.fromAsyncIterable(e.iterate(...t), (e) => new m({
+				cause: e,
+				message: "Failed to stream statement"
+			}))));
+			return r ? d.mapChunks(i, (e) => n.unsafeFromArray(r(n.toReadonlyArray(e)))) : i;
+		}
+	});
+}), D = (e) => o.gen(function* () {
+	let t = h.makeCompilerSqlite(e.transformQueryNames), n = e.transformResultNames ? h.defaultTransforms(e.transformResultNames).array : void 0, r = e.filename === ":memory:" || e.filename === "" || e.filename.startsWith("file::memory:"), i = e.maxConnections ?? 4;
+	r && i > 1 && v.warn(`:memory: Turso DB is per-connection — clamping pool size ${i} → 1`);
+	let a = r ? 1 : Math.max(1, i), o = yield* l.make({
+		acquire: E(e),
+		size: a
+	}), s = l.get(o), c = l.get(o), u = yield* p.make({
+		acquirer: s,
+		compiler: t,
+		transactionAcquirer: c,
+		beginTransaction: "BEGIN",
+		spanAttributes: [...e.spanAttributes ? Object.entries(e.spanAttributes) : [], [y, "turso"]],
+		transformRows: n
+	});
+	return Object.assign(u, {
+		[S]: S,
+		config: e
+	});
+}), ie = (e) => c.scopedContext(r.unwrap(e).pipe(o.flatMap(D), o.map((e) => i.make(C, e).pipe(i.add(p.SqlClient, e))))).pipe(c.provide(f.layer)), ae = g({ scope: "voltro:turso:libsql" }), oe = "db.system.name", O = Symbol.for("@voltro/sql-turso/LibsqlClient"), k = i.GenericTag("@voltro/sql-turso/LibsqlClient"), A = (e) => (t) => {
+	let n = t?.message;
+	return new m({
+		cause: t,
+		message: typeof n == "string" ? `${e}: ${n}` : e
+	});
+}, se = (e, t) => {
+	let n = {};
+	for (let r of t) n[r] = e[r];
+	return n;
+}, j = (e) => e.rows.map((t) => se(t, e.columns)), M = (e) => e.rows.map((t) => e.columns.map((e, n) => t[n])), N = (e) => e, P = (e) => /^\s*BEGIN\b/i.test(e), F = (e) => /^\s*(COMMIT|END)\b/i.test(e), I = (e) => /^\s*ROLLBACK\b/i.test(e), L = (e) => ({
+	execute(t, n, r) {
+		let i = o.map(o.tryPromise({
+			try: () => e(t, n),
+			catch: A("Failed to execute statement")
+		}), j);
+		return r ? o.map(i, r) : i;
+	},
+	executeRaw(t, n) {
+		return o.map(o.tryPromise({
+			try: () => e(t, n),
+			catch: A("Failed to execute statement")
+		}), j);
+	},
+	executeValues(t, n) {
+		return o.map(o.tryPromise({
+			try: () => e(t, n),
+			catch: A("Failed to execute statement")
+		}), M);
+	},
+	executeUnprepared(t, n, r) {
+		let i = o.map(o.tryPromise({
+			try: () => e(t, n),
+			catch: A("Failed to execute statement")
+		}), j);
+		return r ? o.map(i, r) : i;
+	},
+	executeStream(t, r, i) {
+		let a = d.fromIterableEffect(o.map(o.tryPromise({
+			try: () => e(t, r),
+			catch: A("Failed to stream statement")
+		}), j));
+		return i ? d.mapChunks(a, (e) => n.unsafeFromArray(i(n.toReadonlyArray(e)))) : a;
+	}
+}), R = (e) => L((t, n) => n.length === 0 ? e.execute(t) : e.execute({
+	sql: t,
+	args: N(n)
+})), z = (e) => o.gen(function* () {
+	let t = yield* o.scope, n = yield* o.tryPromise({
+		try: () => e.transaction("write"),
+		catch: A("Failed to begin transaction")
+	});
+	return yield* u.addFinalizer(t, o.sync(() => {
+		try {
+			n.close();
+		} catch {}
+	})), L((e, t) => P(e) ? Promise.resolve(B) : F(e) ? n.commit().then(() => B) : I(e) ? n.rollback().then(() => B) : t.length === 0 ? n.execute(e) : n.execute({
+		sql: e,
+		args: N(t)
+	}));
+}), B = {
+	columns: [],
+	columnTypes: [],
+	rows: [],
+	rowsAffected: 0,
+	lastInsertRowid: void 0,
+	toJSON: () => ({})
+}, V = (e) => e.url.startsWith("file:") && e.syncUrl !== void 0, H = (e) => o.gen(function* () {
+	let t = h.makeCompilerSqlite(e.transformQueryNames), n = e.transformResultNames ? h.defaultTransforms(e.transformResultNames).array : void 0, r = {
+		url: e.url,
+		...e.authToken === void 0 ? {} : { authToken: e.authToken },
+		...e.syncUrl === void 0 ? {} : { syncUrl: e.syncUrl },
+		...e.syncInterval === void 0 ? {} : { syncInterval: a.toSeconds(a.decode(e.syncInterval)) },
+		...e.readYourWrites === void 0 ? {} : { readYourWrites: e.readYourWrites },
+		...e.encryptionKey === void 0 ? {} : { encryptionKey: e.encryptionKey }
+	}, i = V(e);
+	ae.info(`libsql client: ${i ? "embedded replica" : "remote"} (url scheme=${e.url.split(":")[0]}${e.syncUrl ? ", sync enabled" : ""})`);
+	let s = yield* o.acquireRelease(o.try({
+		try: () => _(r),
+		catch: A("Failed to create libsql client")
+	}), (e) => o.sync(() => {
+		try {
+			e.close();
+		} catch {}
+	}));
+	i && (yield* o.tryPromise({
+		try: () => s.sync(),
+		catch: A("Failed initial embedded-replica sync")
+	}));
+	let c = o.succeed(R(s)), l = z(s), u = yield* p.make({
+		acquirer: c,
+		compiler: t,
+		transactionAcquirer: l,
+		beginTransaction: "BEGIN",
+		spanAttributes: [...e.spanAttributes ? Object.entries(e.spanAttributes) : [], [oe, "turso"]],
+		transformRows: n
+	});
+	return Object.assign(u, {
+		[O]: O,
+		config: e
+	});
+}), U = (e) => c.scopedContext(r.unwrap(e).pipe(o.flatMap(H), o.map((e) => i.make(k, e).pipe(i.add(p.SqlClient, e))))).pipe(c.provide(f.layer)), W = /^(libsql|wss?|https?):/i, G = () => process.env.DB_AUTH_TOKEN ?? process.env.TURSO_AUTH_TOKEN, ce = () => process.env.DB_SYNC_URL ?? process.env.TURSO_SYNC_URL, le = () => {
+	let e = process.env.DB_SYNC_INTERVAL ?? process.env.TURSO_SYNC_INTERVAL;
+	if (e === void 0 || e.trim() === "") return;
+	let t = Number(e);
+	if (!Number.isFinite(t) || t <= 0) throw Error(`@voltro/sql-turso: invalid DB_SYNC_INTERVAL '${e}' — expected a positive number of seconds.`);
+	return t;
+}, ue = () => process.env.DB_ENCRYPTION_KEY ?? process.env.TURSO_ENCRYPTION_KEY, de = () => {
+	let e = process.env.DB_READ_YOUR_WRITES;
+	if (e !== void 0) return e !== "false" && e !== "0";
+}, K = (e, t, n) => {
+	let r = le(), i = de(), a = ue();
+	return {
+		kind: "remote",
+		url: e,
+		authToken: t,
+		...n === void 0 ? {} : { syncUrl: n },
+		...r === void 0 ? {} : { syncIntervalSeconds: r },
+		...i === void 0 ? {} : { readYourWrites: i },
+		...a === void 0 ? {} : { encryptionKey: a }
+	};
+}, q = (e) => {
+	let t = e.maxConnections, n = t === void 0 ? {} : { maxConnections: t }, r = ce();
+	if (e.url) {
+		if (W.test(e.url)) {
+			let t = G();
+			if (t === void 0) throw Error(`@voltro/sql-turso: remote Turso url '${e.url}' needs an auth token. Set DB_AUTH_TOKEN (or TURSO_AUTH_TOKEN) to the token from 'turso db tokens create <db>'.`);
+			return K(e.url, t, r);
+		}
+		if (e.url === ":memory:") return {
+			kind: "local",
+			filename: ":memory:",
+			...n
+		};
+		if (e.url.startsWith("file:")) {
+			if (r !== void 0) {
+				let t = G();
+				if (t === void 0) throw Error(`@voltro/sql-turso: embedded replica (file '${e.url}' + DB_SYNC_URL='${r}') needs an auth token for the remote primary. Set DB_AUTH_TOKEN (or TURSO_AUTH_TOKEN).`);
+				return K(e.url, t, r);
+			}
+			return {
+				kind: "local",
+				filename: e.url.slice(5),
+				...n
+			};
+		}
+		throw Error(`@voltro/sql-turso: unsupported url '${e.url}'. Accepted: 'file:./db.turso', ':memory:' (local Rust engine), or 'libsql://…'/'https://…'/'wss://…' (remote Turso Cloud).`);
+	}
+	if (e.database) return {
+		kind: "local",
+		filename: e.database,
+		...n
+	};
+	throw Error("@voltro/sql-turso: no url/filename supplied. Set DB_URL=file:./db.turso (local), DB_URL=libsql://<db>.turso.io + DB_AUTH_TOKEN (remote), or DB_DATABASE=path/to/db.turso.");
+}, J = (e) => ie({
+	filename: r.succeed(e.filename),
+	...e.readonly === void 0 ? {} : { readonly: r.succeed(e.readonly) },
+	...e.maxConnections === void 0 ? {} : { maxConnections: r.succeed(e.maxConnections) }
+}), Y = (e) => U({
+	url: r.succeed(e.url),
+	...e.authToken === void 0 ? {} : { authToken: r.succeed(e.authToken) },
+	...e.syncUrl === void 0 ? {} : { syncUrl: r.succeed(e.syncUrl) },
+	...e.syncIntervalSeconds === void 0 ? {} : { syncInterval: r.succeed(`${e.syncIntervalSeconds} seconds`) },
+	...e.readYourWrites === void 0 ? {} : { readYourWrites: r.succeed(e.readYourWrites) },
+	...e.encryptionKey === void 0 ? {} : { encryptionKey: r.succeed(e.encryptionKey) }
+}), X = (e) => {
+	let t = q(e);
+	return t.kind === "remote" ? Y(t) : J(t);
+}, fe = /write-write conflict|write-read conflict|database is locked|table is locked|database is busy/i, pe = /* @__PURE__ */ new Set([
+	"SQLITE_BUSY",
+	"SQLITE_LOCKED",
+	"5",
+	"6"
+]), Z = (e, t) => {
+	let n = e, r = "";
+	for (let e = 0; e < 6 && typeof n == "object" && n; e++) {
+		let e = t(n);
+		e !== void 0 && (r += ` ${e}`), n = n.cause;
+	}
+	return r;
+}, me = (e) => Z(e, (e) => typeof e.message == "string" ? e.message : void 0), he = (e) => {
+	let t = e;
+	for (let e = 0; e < 6 && typeof t == "object" && t; e++) {
+		let e = t.code;
+		if (typeof e == "string" && e !== "GenericFailure") return e;
+		if (typeof e == "number") return String(e);
+		t = t.cause;
+	}
+}, Q = (e) => {
+	if (fe.test(me(e))) return !0;
+	let t = he(e);
+	return t !== void 0 && pe.has(t);
+}, $ = (e) => Q(e) ? "retry" : "noRetry", ge = {
+	id: "turso",
+	makeSqlLayer: (e) => X(e),
+	makeStore: (t) => e({
+		...t,
+		isRetryable: Q,
+		systemName: "turso",
+		wrapTransaction: x
+	}),
+	compileContains: (e, t, n) => n`${e} LIKE ${`%${t.replace(/[\\%_]/g, (e) => `\\${e}`)}%`} ESCAPE '\\'`,
+	retryFilter: $
+};
+//#endregion
+export { k as LibsqlClient, C as TursoClient, q as connectionFromConfig, Q as isTursoRetryableFailure, Y as makeLibsqlSqlLayer, J as makeTursoSqlLayer, X as makeTursoSqlLayerFromConfig, ge as tursoDialect, $ as tursoRetryFilter };

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@voltro/sql-turso",
+  "version": "0.1.0",
+  "description": "Turso dialect adapter for Voltro's cross-dialect DataStore — local Rust SQLite with MVCC BEGIN CONCURRENT, or remote Turso Cloud (libsql://) with embedded-replica sync.",
+  "keywords": [
+    "voltro",
+    "typescript",
+    "framework"
+  ],
+  "license": "SEE LICENSE IN LICENSE",
+  "homepage": "https://voltro.dev",
+  "bugs": {
+    "email": "support@voltro.dev"
+  },
+  "author": {
+    "name": "Voltro UG",
+    "url": "https://voltro.dev"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "dependencies": {
+    "@effect/experimental": "^0.60.0",
+    "@effect/sql": "^0.51.1",
+    "@libsql/client": "^0.17.4",
+    "@tursodatabase/database": "^0.6.1",
+    "@voltro/database": "0.1.0",
+    "@voltro/logger": "0.1.0",
+    "@voltro/sql-sqlite": "0.1.0"
+  },
+  "peerDependencies": {
+    "effect": "^3.21.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}