shioricode 0.5.2 → 0.5.3

package/dist/NodePTY-BNeKL1sW.cjs

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+
+const require_bin = require('./bin.cjs');
+let node_module = require("node:module");
+
+//#region src/terminal/Layers/NodePTY.ts
+let didEnsureSpawnHelperExecutable = false;
+const resolveNodePtySpawnHelperPath = require_bin.gen(function* () {
+	const requireForNodePty = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
+	const path = yield* require_bin.Path;
+	const fs = yield* require_bin.FileSystem;
+	const packageJsonPath = requireForNodePty.resolve("node-pty/package.json");
+	const packageDir = path.dirname(packageJsonPath);
+	const candidates = [
+		path.join(packageDir, "build", "Release", "spawn-helper"),
+		path.join(packageDir, "build", "Debug", "spawn-helper"),
+		path.join(packageDir, "prebuilds", `${process.platform}-${process.arch}`, "spawn-helper")
+	];
+	for (const candidate of candidates) if (yield* fs.exists(candidate)) return candidate;
+	return null;
+}).pipe(require_bin.orElseSucceed(() => null));
+const ensureNodePtySpawnHelperExecutable = require_bin.fn(function* (explicitPath) {
+	const fs = yield* require_bin.FileSystem;
+	if (process.platform === "win32") return;
+	if (!explicitPath && didEnsureSpawnHelperExecutable) return;
+	const helperPath = explicitPath ?? (yield* resolveNodePtySpawnHelperPath);
+	if (!helperPath) return;
+	if (!explicitPath) didEnsureSpawnHelperExecutable = true;
+	if (!(yield* fs.exists(helperPath))) return;
+	yield* fs.chmod(helperPath, 493).pipe(require_bin.orElseSucceed(() => void 0));
+});
+var NodePtyProcess = class {
+	constructor(process) {
+		this.process = process;
+	}
+	get pid() {
+		return this.process.pid;
+	}
+	write(data) {
+		this.process.write(data);
+	}
+	resize(cols, rows) {
+		this.process.resize(cols, rows);
+	}
+	kill(signal) {
+		this.process.kill(signal);
+	}
+	onData(callback) {
+		const disposable = this.process.onData(callback);
+		return () => {
+			disposable.dispose();
+		};
+	}
+	onExit(callback) {
+		const disposable = this.process.onExit((event) => {
+			callback({
+				exitCode: event.exitCode,
+				signal: event.signal ?? null
+			});
+		});
+		return () => {
+			disposable.dispose();
+		};
+	}
+};
+const layer = require_bin.effect(require_bin.PtyAdapter, require_bin.gen(function* () {
+	const fs = yield* require_bin.FileSystem;
+	const path = yield* require_bin.Path;
+	const nodePty = yield* require_bin.promise(() => import("node-pty"));
+	const ensureNodePtySpawnHelperExecutableCached = yield* require_bin.cached(ensureNodePtySpawnHelperExecutable().pipe(require_bin.provideService(require_bin.FileSystem, fs), require_bin.provideService(require_bin.Path, path), require_bin.orElseSucceed(() => void 0)));
+	return { spawn: require_bin.fn(function* (input) {
+		yield* ensureNodePtySpawnHelperExecutableCached;
+		return new NodePtyProcess(nodePty.spawn(input.shell, input.args ?? [], {
+			cwd: input.cwd,
+			cols: input.cols,
+			rows: input.rows,
+			env: input.env,
+			name: globalThis.process.platform === "win32" ? "xterm-color" : "xterm-256color"
+		}));
+	}) };
+}));
+
+//#endregion
+exports.ensureNodePtySpawnHelperExecutable = ensureNodePtySpawnHelperExecutable;
+exports.layer = layer;
+//# sourceMappingURL=NodePTY-BNeKL1sW.cjs.map

package/dist/NodeSqliteClient-K1HOOjni.cjs

@@ -0,0 +1,147 @@
+#!/usr/bin/env node
+
+const require_bin = require('./bin.cjs');
+const require_SqlError = require('./SqlError-UTW5yuSG.cjs');
+let node_sqlite = require("node:sqlite");
+
+//#region src/persistence/NodeSqliteClient.ts
+/**
+* Port of `@effect/sql-sqlite-node` that uses the native `node:sqlite`
+* bindings instead of `better-sqlite3`.
+*
+* @module SqliteClient
+*/
+const ATTR_DB_SYSTEM_NAME = "db.system.name";
+const TypeId = "~local/sqlite-node/SqliteClient";
+/**
+* SqliteClient - Effect service tag for the sqlite SQL client.
+*/
+const SqliteClient = require_bin.Service("t3/persistence/NodeSqliteClient");
+/**
+* Verify that the current Node.js version includes the `node:sqlite` APIs
+* used by `NodeSqliteClient` — specifically `StatementSync.columns()` (added
+* in Node 22.16.0 / 23.11.0).
+*
+* @see https://github.com/nodejs/node/pull/57490
+*/
+const checkNodeSqliteCompat = () => {
+	const parts = process.versions.node.split(".").map(Number);
+	const major = parts[0] ?? 0;
+	const minor = parts[1] ?? 0;
+	if (!(major === 22 && minor >= 16 || major === 23 && minor >= 11 || major >= 24)) return require_bin.die$1(`Node.js ${process.versions.node} is missing required node:sqlite APIs (StatementSync.columns). Upgrade to Node.js >=22.16, >=23.11, or >=24.`);
+	return require_bin.void_;
+};
+const makeWithDatabase = require_bin.fn("makeWithDatabase")(function* (options, openDatabase) {
+	yield* checkNodeSqliteCompat();
+	const compiler = require_bin.makeCompilerSqlite(options.transformQueryNames);
+	const transformRows = options.transformResultNames ? require_bin.defaultTransforms(options.transformResultNames).array : void 0;
+	const makeConnection = require_bin.gen(function* () {
+		const scope$1 = yield* require_bin.scope;
+		const db = openDatabase();
+		yield* require_bin.addFinalizer$1(scope$1, require_bin.sync(() => db.close()));
+		const statementReaderCache = /* @__PURE__ */ new WeakMap();
+		const hasRows = (statement) => {
+			const cached = statementReaderCache.get(statement);
+			if (cached !== void 0) return cached;
+			const value = statement.columns().length > 0;
+			statementReaderCache.set(statement, value);
+			return value;
+		};
+		const prepareCache = yield* require_bin.make$5({
+			capacity: options.prepareCacheSize ?? 200,
+			timeToLive: options.prepareCacheTTL ?? require_bin.minutes(10),
+			lookup: (sql) => require_bin.try_({
+				try: () => db.prepare(sql),
+				catch: (cause) => new require_SqlError.SqlError({ reason: require_SqlError.classifySqliteError(cause, {
+					message: "Failed to prepare statement",
+					operation: "prepare"
+				}) })
+			})
+		});
+		const runStatement = (statement, params, raw) => require_bin.withFiber((fiber) => {
+			statement.setReadBigInts(Boolean(require_bin.get$1(fiber.services, require_bin.SafeIntegers)));
+			try {
+				if (hasRows(statement)) return require_bin.succeed(statement.all(...params));
+				const result = statement.run(...params);
+				return require_bin.succeed(raw ? result : []);
+			} catch (cause) {
+				return require_bin.fail$1(new require_SqlError.SqlError({ reason: require_SqlError.classifySqliteError(cause, {
+					message: "Failed to execute statement",
+					operation: "execute"
+				}) }));
+			}
+		});
+		const run = (sql, params, raw = false) => require_bin.flatMap(require_bin.get(prepareCache, sql), (s) => runStatement(s, params, raw));
+		const runValues = (sql, params) => require_bin.acquireUseRelease(require_bin.get(prepareCache, sql), (statement) => require_bin.try_({
+			try: () => {
+				if (hasRows(statement)) {
+					statement.setReturnArrays(true);
+					return statement.all(...params);
+				}
+				statement.run(...params);
+				return [];
+			},
+			catch: (cause) => new require_SqlError.SqlError({ reason: require_SqlError.classifySqliteError(cause, {
+				message: "Failed to execute statement",
+				operation: "execute"
+			}) })
+		}), (statement) => require_bin.sync(() => {
+			if (hasRows(statement)) statement.setReturnArrays(false);
+		}));
+		return require_bin.identity({
+			execute(sql, params, rowTransform) {
+				return rowTransform ? require_bin.map$1(run(sql, params), rowTransform) : run(sql, params);
+			},
+			executeRaw(sql, params) {
+				return run(sql, params, true);
+			},
+			executeValues(sql, params) {
+				return runValues(sql, params);
+			},
+			executeUnprepared(sql, params, rowTransform) {
+				const effect = runStatement(db.prepare(sql), params ?? [], false);
+				return rowTransform ? require_bin.map$1(effect, rowTransform) : effect;
+			},
+			executeStream(_sql, _params) {
+				return require_bin.die("executeStream not implemented");
+			}
+		});
+	});
+	const semaphore = yield* require_bin.make$7(1);
+	const connection = yield* makeConnection;
+	const acquirer = semaphore.withPermits(1)(require_bin.succeed(connection));
+	const transactionAcquirer = require_bin.uninterruptibleMask((restore) => {
+		const fiber = require_bin.getCurrent();
+		const scope = require_bin.getUnsafe(fiber.services, require_bin.Scope);
+		return require_bin.as(require_bin.tap(restore(semaphore.take(1)), () => require_bin.addFinalizer$1(scope, semaphore.release(1))), connection);
+	});
+	return yield* require_bin.make$3({
+		acquirer,
+		compiler,
+		transactionAcquirer,
+		spanAttributes: [...options.spanAttributes ? Object.entries(options.spanAttributes) : [], [ATTR_DB_SYSTEM_NAME, "sqlite"]],
+		transformRows
+	});
+});
+const make = (options) => makeWithDatabase(options, () => new node_sqlite.DatabaseSync(options.filename, {
+	readOnly: options.readonly ?? false,
+	allowExtension: options.allowExtension ?? false
+}));
+const makeMemory = (config = {}) => makeWithDatabase({
+	...config,
+	filename: ":memory:",
+	readonly: false
+}, () => {
+	return new node_sqlite.DatabaseSync(":memory:", { allowExtension: config.allowExtension ?? false });
+});
+const layerConfig = (config) => require_bin.effectServices(require_bin.unwrap(config).asEffect().pipe(require_bin.flatMap(make), require_bin.map$1((client) => require_bin.make$8(SqliteClient, client).pipe(require_bin.add(require_bin.SqlClient, client))))).pipe(require_bin.provide(require_bin.layer$2));
+const layer = (config) => require_bin.effectServices(require_bin.map$1(make(config), (client) => require_bin.make$8(SqliteClient, client).pipe(require_bin.add(require_bin.SqlClient, client)))).pipe(require_bin.provide(require_bin.layer$2));
+const layerMemory = (config = {}) => require_bin.effectServices(require_bin.map$1(makeMemory(config), (client) => require_bin.make$8(SqliteClient, client).pipe(require_bin.add(require_bin.SqlClient, client)))).pipe(require_bin.provide(require_bin.layer$2));
+
+//#endregion
+exports.SqliteClient = SqliteClient;
+exports.TypeId = TypeId;
+exports.layer = layer;
+exports.layerConfig = layerConfig;
+exports.layerMemory = layerMemory;
+//# sourceMappingURL=NodeSqliteClient-K1HOOjni.cjs.map

package/dist/SqlError-UTW5yuSG.cjs

@@ -0,0 +1,262 @@
+#!/usr/bin/env node
+
+const require_bin = require('./bin.cjs');
+
+//#region ../../node_modules/effect/dist/unstable/sql/SqlError.js
+/**
+* @since 4.0.0
+*/
+const TypeId = "~effect/sql/SqlError";
+const ReasonTypeId = "~effect/sql/SqlError/Reason";
+const ReasonFields = {
+	cause: require_bin.Defect,
+	message: /* @__PURE__ */ require_bin.optional(require_bin.String),
+	operation: /* @__PURE__ */ require_bin.optional(require_bin.String)
+};
+/**
+* @since 4.0.0
+*/
+var ConnectionError = class extends require_bin.TaggedErrorClass("effect/sql/SqlError/ConnectionError")("ConnectionError", ReasonFields) {
+	/**
+	* @since 4.0.0
+	*/
+	[ReasonTypeId] = ReasonTypeId;
+	/**
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return true;
+	}
+};
+/**
+* @since 4.0.0
+*/
+var AuthenticationError = class extends require_bin.TaggedErrorClass("effect/sql/SqlError/AuthenticationError")("AuthenticationError", ReasonFields) {
+	/**
+	* @since 4.0.0
+	*/
+	[ReasonTypeId] = ReasonTypeId;
+	/**
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return false;
+	}
+};
+/**
+* @since 4.0.0
+*/
+var AuthorizationError = class extends require_bin.TaggedErrorClass("effect/sql/SqlError/AuthorizationError")("AuthorizationError", ReasonFields) {
+	/**
+	* @since 4.0.0
+	*/
+	[ReasonTypeId] = ReasonTypeId;
+	/**
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return false;
+	}
+};
+/**
+* @since 4.0.0
+*/
+var SqlSyntaxError = class extends require_bin.TaggedErrorClass("effect/sql/SqlError/SqlSyntaxError")("SqlSyntaxError", ReasonFields) {
+	/**
+	* @since 4.0.0
+	*/
+	[ReasonTypeId] = ReasonTypeId;
+	/**
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return false;
+	}
+};
+/**
+* @since 4.0.0
+*/
+var ConstraintError = class extends require_bin.TaggedErrorClass("effect/sql/SqlError/ConstraintError")("ConstraintError", ReasonFields) {
+	/**
+	* @since 4.0.0
+	*/
+	[ReasonTypeId] = ReasonTypeId;
+	/**
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return false;
+	}
+};
+/**
+* @since 4.0.0
+*/
+var DeadlockError = class extends require_bin.TaggedErrorClass("effect/sql/SqlError/DeadlockError")("DeadlockError", ReasonFields) {
+	/**
+	* @since 4.0.0
+	*/
+	[ReasonTypeId] = ReasonTypeId;
+	/**
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return true;
+	}
+};
+/**
+* @since 4.0.0
+*/
+var SerializationError = class extends require_bin.TaggedErrorClass("effect/sql/SqlError/SerializationError")("SerializationError", ReasonFields) {
+	/**
+	* @since 4.0.0
+	*/
+	[ReasonTypeId] = ReasonTypeId;
+	/**
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return true;
+	}
+};
+/**
+* @since 4.0.0
+*/
+var LockTimeoutError = class extends require_bin.TaggedErrorClass("effect/sql/SqlError/LockTimeoutError")("LockTimeoutError", ReasonFields) {
+	/**
+	* @since 4.0.0
+	*/
+	[ReasonTypeId] = ReasonTypeId;
+	/**
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return true;
+	}
+};
+/**
+* @since 4.0.0
+*/
+var StatementTimeoutError = class extends require_bin.TaggedErrorClass("effect/sql/SqlError/StatementTimeoutError")("StatementTimeoutError", ReasonFields) {
+	/**
+	* @since 4.0.0
+	*/
+	[ReasonTypeId] = ReasonTypeId;
+	/**
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return true;
+	}
+};
+/**
+* @since 4.0.0
+*/
+var UnknownError = class extends require_bin.TaggedErrorClass("effect/sql/SqlError/UnknownError")("UnknownError", ReasonFields) {
+	/**
+	* @since 4.0.0
+	*/
+	[ReasonTypeId] = ReasonTypeId;
+	/**
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return false;
+	}
+};
+/**
+* @since 4.0.0
+*/
+const SqlErrorReason = /* @__PURE__ */ require_bin.Union([
+	ConnectionError,
+	AuthenticationError,
+	AuthorizationError,
+	SqlSyntaxError,
+	ConstraintError,
+	DeadlockError,
+	SerializationError,
+	LockTimeoutError,
+	StatementTimeoutError,
+	UnknownError
+]);
+/**
+* @since 4.0.0
+*/
+var SqlError = class extends require_bin.TaggedErrorClass("effect/sql/SqlError")("SqlError", { reason: SqlErrorReason }) {
+	/**
+	* @since 4.0.0
+	*/
+	[TypeId] = TypeId;
+	/**
+	* @since 4.0.0
+	*/
+	cause = this.reason;
+	/**
+	* @since 4.0.0
+	*/
+	get message() {
+		return this.reason.message || this.reason._tag;
+	}
+	/**
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return this.reason.isRetryable;
+	}
+};
+const sqliteCodeFromCause = (cause) => {
+	if (!require_bin.hasProperty(cause, "code")) return;
+	const code = cause.code;
+	return typeof code === "string" || typeof code === "number" ? code : void 0;
+};
+const sqliteNumericCodeFromCause = (cause) => {
+	const code = sqliteCodeFromCause(cause);
+	if (typeof code === "number") return code;
+	if (!require_bin.hasProperty(cause, "errno")) return;
+	const errno = cause.errno;
+	return typeof errno === "number" ? errno : void 0;
+};
+const matchesSqliteCode = (code, expected) => code === expected || code.startsWith(expected + "_");
+/**
+* @since 4.0.0
+*/
+const classifySqliteError = (cause, { message, operation } = {}) => {
+	const props = {
+		cause,
+		message,
+		operation
+	};
+	const code = sqliteCodeFromCause(cause);
+	if (typeof code === "string") {
+		if (matchesSqliteCode(code, "SQLITE_AUTH")) return new AuthenticationError(props);
+		if (matchesSqliteCode(code, "SQLITE_PERM")) return new AuthorizationError(props);
+		if (matchesSqliteCode(code, "SQLITE_CONSTRAINT")) return new ConstraintError(props);
+		if (matchesSqliteCode(code, "SQLITE_BUSY") || matchesSqliteCode(code, "SQLITE_LOCKED")) return new LockTimeoutError(props);
+		if (matchesSqliteCode(code, "SQLITE_CANTOPEN")) return new ConnectionError(props);
+	}
+	const numericCode = sqliteNumericCodeFromCause(cause);
+	if (typeof numericCode === "number") switch (numericCode & 255) {
+		case 23: return new AuthenticationError(props);
+		case 3: return new AuthorizationError(props);
+		case 19: return new ConstraintError(props);
+		case 5:
+		case 6: return new LockTimeoutError(props);
+		case 14: return new ConnectionError(props);
+		default: return new UnknownError(props);
+	}
+	return new UnknownError(props);
+};
+
+//#endregion
+Object.defineProperty(exports, 'SqlError', {
+  enumerable: true,
+  get: function () {
+    return SqlError;
+  }
+});
+Object.defineProperty(exports, 'classifySqliteError', {
+  enumerable: true,
+  get: function () {
+    return classifySqliteError;
+  }
+});
+//# sourceMappingURL=SqlError-UTW5yuSG.cjs.map

package/dist/SqliteClient-CVOnk2wf.cjs

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+
+const require_bin = require('./bin.cjs');
+const require_SqlError = require('./SqlError-UTW5yuSG.cjs');
+let bun_sqlite = require("bun:sqlite");
+
+//#region ../../node_modules/@effect/sql-sqlite-bun/dist/SqliteClient.js
+/**
+* @since 1.0.0
+*/
+const ATTR_DB_SYSTEM_NAME = "db.system.name";
+const classifyError = (cause, message, operation) => require_SqlError.classifySqliteError(cause, {
+	message,
+	operation
+});
+/**
+* @category type ids
+* @since 1.0.0
+*/
+const TypeId = "~@effect/sql-sqlite-bun/SqliteClient";
+/**
+* @category tags
+* @since 1.0.0
+*/
+const SqliteClient = /* @__PURE__ */ require_bin.Service("@effect/sql-sqlite-bun/Client");
+/**
+* @category constructor
+* @since 1.0.0
+*/
+const make = (options) => require_bin.gen(function* () {
+	const compiler = require_bin.makeCompilerSqlite(options.transformQueryNames);
+	const transformRows = options.transformResultNames ? require_bin.defaultTransforms(options.transformResultNames).array : void 0;
+	const makeConnection = require_bin.gen(function* () {
+		const db = new bun_sqlite.Database(options.filename, {
+			readonly: options.readonly,
+			readwrite: options.readwrite ?? true,
+			create: options.create ?? true
+		});
+		yield* require_bin.addFinalizer(() => require_bin.sync(() => db.close()));
+		if (options.disableWAL !== true) db.run("PRAGMA journal_mode = WAL;");
+		const run = (sql, params = []) => require_bin.withFiber((fiber) => {
+			const statement = db.query(sql);
+			const useSafeIntegers = require_bin.get$1(fiber.services, require_bin.SafeIntegers);
+			statement.safeIntegers(useSafeIntegers);
+			try {
+				return require_bin.succeed(statement.all(...params) ?? []);
+			} catch (cause) {
+				return require_bin.fail$1(new require_SqlError.SqlError({ reason: classifyError(cause, "Failed to execute statement", "execute") }));
+			}
+		});
+		const runValues = (sql, params = []) => require_bin.withFiber((fiber) => {
+			const statement = db.query(sql);
+			const useSafeIntegers = require_bin.get$1(fiber.services, require_bin.SafeIntegers);
+			statement.safeIntegers(useSafeIntegers);
+			try {
+				return require_bin.succeed(statement.values(...params) ?? []);
+			} catch (cause) {
+				return require_bin.fail$1(new require_SqlError.SqlError({ reason: classifyError(cause, "Failed to execute statement", "execute") }));
+			}
+		});
+		return require_bin.identity({
+			execute(sql, params, transformRows) {
+				return transformRows ? require_bin.map$1(run(sql, params), transformRows) : run(sql, params);
+			},
+			executeRaw(sql, params) {
+				return run(sql, params);
+			},
+			executeValues(sql, params) {
+				return runValues(sql, params);
+			},
+			executeUnprepared(sql, params, transformRows) {
+				return this.execute(sql, params, transformRows);
+			},
+			executeStream(_sql, _params) {
+				return require_bin.die("executeStream not implemented");
+			},
+			export: require_bin.try_({
+				try: () => db.serialize(),
+				catch: (cause) => new require_SqlError.SqlError({ reason: classifyError(cause, "Failed to export database", "export") })
+			}),
+			loadExtension: (path) => require_bin.try_({
+				try: () => db.loadExtension(path),
+				catch: (cause) => new require_SqlError.SqlError({ reason: classifyError(cause, "Failed to load extension", "loadExtension") })
+			})
+		});
+	});
+	const semaphore = yield* require_bin.make$7(1);
+	const connection = yield* makeConnection;
+	const acquirer = semaphore.withPermits(1)(require_bin.succeed(connection));
+	const transactionAcquirer = require_bin.uninterruptibleMask((restore) => {
+		const fiber = require_bin.getCurrent();
+		const scope = require_bin.getUnsafe(fiber.services, require_bin.Scope);
+		return require_bin.as(require_bin.tap(restore(semaphore.take(1)), () => require_bin.addFinalizer$1(scope, semaphore.release(1))), connection);
+	});
+	return Object.assign(yield* require_bin.make$3({
+		acquirer,
+		compiler,
+		transactionAcquirer,
+		spanAttributes: [...options.spanAttributes ? Object.entries(options.spanAttributes) : [], [ATTR_DB_SYSTEM_NAME, "sqlite"]],
+		transformRows
+	}), {
+		[TypeId]: TypeId,
+		config: options,
+		export: require_bin.flatMap(acquirer, (_) => _.export),
+		loadExtension: (path) => require_bin.flatMap(acquirer, (_) => _.loadExtension(path))
+	});
+});
+/**
+* @category layers
+* @since 1.0.0
+*/
+const layerConfig = (config) => require_bin.effectServices(require_bin.unwrap(config).asEffect().pipe(require_bin.flatMap(make), require_bin.map$1((client) => require_bin.make$8(SqliteClient, client).pipe(require_bin.add(require_bin.SqlClient, client))))).pipe(require_bin.provide(require_bin.layer$2));
+/**
+* @category layers
+* @since 1.0.0
+*/
+const layer = (config) => require_bin.effectServices(require_bin.map$1(make(config), (client) => require_bin.make$8(SqliteClient, client).pipe(require_bin.add(require_bin.SqlClient, client)))).pipe(require_bin.provide(require_bin.layer$2));
+
+//#endregion
+exports.SqliteClient = SqliteClient;
+exports.TypeId = TypeId;
+exports.layer = layer;
+exports.layerConfig = layerConfig;
+exports.make = make;
+//# sourceMappingURL=SqliteClient-CVOnk2wf.cjs.map