@das-org/dascode 0.0.31

package/dist/NodePtyAdapter-H8kyf9St.mjs

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+
+import { F as TaggedErrorClass, Fi as orElseSucceed, Jr as fn, M as String, Pi as orDie, br as cached, ha as try_, ii as gen, l as Defect, ma as tryPromise, vo as effect, zi as provideService } from "./Schema-DuQUv9rO.mjs";
+import { i as FileSystem, t as Path } from "./Path-BB53LP8h.mjs";
+import { c as HostProcessPlatform, n as PtySpawnError, r as HostProcessArchitecture, t as PtyAdapter } from "./PtyAdapter-mAqTlv3d.mjs";
+import * as NodeModule from "node:module";
+//#region src/terminal/NodePtyAdapter.ts
+var NodePtyModuleLoadError = class extends TaggedErrorClass()("NodePtyModuleLoadError", {
+	platform: String,
+	architecture: String,
+	cause: Defect()
+}) {
+	get message() {
+		return `Failed to load node-pty for ${this.platform}-${this.architecture}.`;
+	}
+};
+let didEnsureSpawnHelperExecutable = false;
+const resolveNodePtySpawnHelperPath = gen(function* () {
+	const requireForNodePty = NodeModule.createRequire(import.meta.url);
+	const path = yield* Path;
+	const fs = yield* FileSystem;
+	const platform = yield* HostProcessPlatform;
+	const architecture = yield* HostProcessArchitecture;
+	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", `${platform}-${architecture}`, "spawn-helper")
+	];
+	for (const candidate of candidates) if (yield* fs.exists(candidate)) return candidate;
+	return null;
+}).pipe(orElseSucceed(() => null));
+const ensureNodePtySpawnHelperExecutable = fn(function* () {
+	const fs = yield* FileSystem;
+	if ((yield* HostProcessPlatform) === "win32") return;
+	if (didEnsureSpawnHelperExecutable) return;
+	const helperPath = yield* resolveNodePtySpawnHelperPath;
+	if (!helperPath) return;
+	didEnsureSpawnHelperExecutable = true;
+	if (!(yield* fs.exists(helperPath))) return;
+	yield* fs.chmod(helperPath, 493).pipe(orElseSucceed(() => void 0));
+});
+var NodePtyProcess = class {
+	process;
+	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 make = fn("NodePtyAdapter.make")(function* (loadNodePtyModule = () => import("node-pty")) {
+	const fs = yield* FileSystem;
+	const path = yield* Path;
+	const platform = yield* HostProcessPlatform;
+	const architecture = yield* HostProcessArchitecture;
+	const nodePty = yield* tryPromise({
+		try: loadNodePtyModule,
+		catch: (cause) => new NodePtyModuleLoadError({
+			platform,
+			architecture,
+			cause
+		})
+	}).pipe(orDie);
+	const ensureNodePtySpawnHelperExecutableCached = yield* cached(ensureNodePtySpawnHelperExecutable().pipe(provideService(FileSystem, fs), provideService(Path, path), provideService(HostProcessPlatform, platform), provideService(HostProcessArchitecture, architecture), orElseSucceed(() => void 0)));
+	return PtyAdapter.of({ spawn: fn("NodePtyAdapter.spawn")(function* (input) {
+		yield* ensureNodePtySpawnHelperExecutableCached;
+		return new NodePtyProcess(yield* try_({
+			try: () => nodePty.spawn(input.shell, input.args ?? [], {
+				cwd: input.cwd,
+				cols: input.cols,
+				rows: input.rows,
+				env: input.env,
+				name: platform === "win32" ? "xterm-color" : "xterm-256color"
+			}),
+			catch: (cause) => new PtySpawnError({
+				adapter: "node-pty",
+				shell: input.shell,
+				cause
+			})
+		}));
+	}) });
+});
+const layer = effect(PtyAdapter, make());
+//#endregion
+export { NodePtyModuleLoadError, layer, make };
+
+//# sourceMappingURL=NodePtyAdapter-H8kyf9St.mjs.map

package/dist/NodeServices-D8d9bE2V.mjs

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+
+import { Do as provideMerge, To as mergeAll } from "./Schema-DuQUv9rO.mjs";
+import { a as layer$9, c as layer$8, f as layer$11, l as layer$7, t as layer$10, u as layer$6 } from "./NodeTerminal-C6yhrF1E.mjs";
+import { createRequire } from "node:module";
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
+//#endregion
+//#region ../../node_modules/.pnpm/@effect+platform-node@4.0.0_ff59e7969d72cff182ae78f763b9fa2b/node_modules/@effect/platform-node/dist/NodeCrypto.js
+/**
+* The `NodeCrypto` module provides the Node.js `Crypto` service layer for
+* Effect programs. Provide {@link layer} at the edge of a Node application,
+* CLI, script, or test to satisfy `effect/Crypto` with Node's `node:crypto`
+* implementation for secure random bytes, UUID generation, random values, and
+* SHA digest operations.
+*
+* This module is the public Node adapter around the shared Node-compatible
+* implementation. Digest failures are reported as platform errors, and SHA-1
+* remains available only for interoperability with existing protocols.
+*
+* @since 1.0.0
+*/
+/**
+* Layer that provides the Node.js Crypto service implementation.
+*
+* @category layers
+* @since 1.0.0
+*/
+const layer$5 = layer$6;
+//#endregion
+//#region ../../node_modules/.pnpm/@effect+platform-node@4.0.0_ff59e7969d72cff182ae78f763b9fa2b/node_modules/@effect/platform-node/dist/NodeFileSystem.js
+/**
+* Node.js `FileSystem` layer for programs that perform real filesystem I/O.
+*
+* The exported layer satisfies the platform-independent `FileSystem` service
+* with Node-backed operations for files, directories, metadata, permissions,
+* links, temporary paths, and path watching. Effects still call the service from
+* `effect/FileSystem`; this module only chooses the Node implementation.
+*
+* @since 4.0.0
+*/
+/**
+* Provides the `FileSystem` service backed by Node filesystem APIs.
+*
+* @category layers
+* @since 4.0.0
+*/
+const layer$4 = layer$7;
+//#endregion
+//#region ../../node_modules/.pnpm/@effect+platform-node@4.0.0_ff59e7969d72cff182ae78f763b9fa2b/node_modules/@effect/platform-node/dist/NodePath.js
+/**
+* Node.js layers for Effect's `Path` service.
+*
+* This module provides the default, POSIX, and Windows variants of the
+* platform-independent `Path` service by reusing the shared Node path
+* implementation. The provided path services include Node file URL conversion
+* behavior.
+*
+* @since 4.0.0
+*/
+/**
+* Provides the default Node `Path` service using the platform's `node:path`
+* implementation.
+*
+* @category layers
+* @since 4.0.0
+*/
+const layer$3 = layer$8;
+//#endregion
+//#region ../../node_modules/.pnpm/@effect+platform-node@4.0.0_ff59e7969d72cff182ae78f763b9fa2b/node_modules/@effect/platform-node/dist/NodeStdio.js
+/**
+* Node.js `Stdio` layer for the current process.
+*
+* The exported layer reuses the shared Node stdio implementation. It satisfies
+* the platform-independent `Stdio` service by reading command-line arguments
+* from `process.argv`, consuming input from `process.stdin`, and writing output
+* streams to `process.stdout` and `process.stderr`.
+*
+* @since 4.0.0
+*/
+/**
+* Provides the `Stdio` service backed by the current process arguments,
+* stdin, stdout, and stderr streams.
+*
+* @category layers
+* @since 4.0.0
+*/
+const layer$2 = layer$9;
+//#endregion
+//#region ../../node_modules/.pnpm/@effect+platform-node@4.0.0_ff59e7969d72cff182ae78f763b9fa2b/node_modules/@effect/platform-node/dist/NodeTerminal.js
+/**
+* Node.js implementation of the Effect `Terminal` service.
+*
+* This module reuses the shared Node terminal implementation. `make` creates a
+* scoped process-backed `Terminal` service, and `layer` provides the default
+* service with the standard quit behavior for key input.
+*
+* @since 4.0.0
+*/
+/**
+* Provides the default process-backed `Terminal` service, ending key input on
+* the default quit keys.
+*
+* @category layers
+* @since 4.0.0
+*/
+const layer$1 = layer$10;
+//#endregion
+//#region ../../node_modules/.pnpm/@effect+platform-node@4.0.0_ff59e7969d72cff182ae78f763b9fa2b/node_modules/@effect/platform-node/dist/NodeServices.js
+var NodeServices_exports = /* @__PURE__ */ __exportAll({ layer: () => layer });
+/**
+* Provides the default Node implementations for child process spawning,
+* filesystem, path, stdio, and terminal services.
+*
+* @category layers
+* @since 4.0.0
+*/
+const layer = /*#__PURE__*/ provideMerge(layer$11, /*#__PURE__*/ mergeAll(layer$4, layer$5, layer$3, layer$2, layer$1));
+//#endregion
+export { __exportAll as a, __commonJSMin as i, layer as n, __require as o, layer$4 as r, __toESM as s, NodeServices_exports as t };
+
+//# sourceMappingURL=NodeServices-D8d9bE2V.mjs.map

package/dist/NodeSqliteClient-CmuXRT3w.mjs

@@ -0,0 +1,178 @@
+#!/usr/bin/env node
+
+import { $c as minutes, Cd as identity, Ea as withFiber, Eo as provide, F as TaggedErrorClass, Fr as die, Gr as flatMap, Jr as fn, M as String, No as Scope, Pi as orDie, Po as addFinalizer, Sa as void_, Xi as scope, Xl as get, _r as as, eu as getUnsafe, ha as try_, ii as gen, lr as acquireUseRelease, na as succeed, sa as tap, vo as effect, ya as uninterruptibleMask, yi as map, zr as fail } from "./Schema-DuQUv9rO.mjs";
+import { Ht as make$1, g as die$1, vn as getCurrent } from "./Path-BB53LP8h.mjs";
+import { y as unwrap } from "./Config-DcF-IZjO.mjs";
+import { a as make$2, t as get$1 } from "./Cache-DyGeujxI.mjs";
+import { a as makeCompilerSqlite, i as defaultTransforms, n as SqlClient, o as layer$1, r as make$3, t as SafeIntegers } from "./SqlClient-Dp5XVCmr.mjs";
+import { n as classifySqliteError, t as SqlError } from "./SqlError-D49f1UD-.mjs";
+import * as NodeSqlite from "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";
+var UnsupportedNodeSqliteVersionError = class extends TaggedErrorClass()("UnsupportedNodeSqliteVersionError", {
+	nodeVersion: String,
+	requirement: String
+}) {
+	get message() {
+		return `Node.js ${this.nodeVersion} is missing required node:sqlite APIs. Upgrade to ${this.requirement}.`;
+	}
+};
+var UnsupportedNodeSqliteOperationError = class extends TaggedErrorClass()("UnsupportedNodeSqliteOperationError", {}) {
+	get message() {
+		return "Node SQLite does not support executeStream.";
+	}
+};
+/**
+* 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 die(new UnsupportedNodeSqliteVersionError({
+		nodeVersion: process.versions.node,
+		requirement: "Node.js >=22.16, >=23.11, or >=24"
+	}));
+	return void_;
+};
+const makeWithDatabase = fn("makeWithDatabase")(function* (options, openDatabase) {
+	yield* checkNodeSqliteCompat();
+	const compiler = makeCompilerSqlite(options.transformQueryNames);
+	const transformRows = options.transformResultNames ? defaultTransforms(options.transformResultNames).array : void 0;
+	const makeConnection = gen(function* () {
+		const scope$1 = yield* scope;
+		const db = yield* try_({
+			try: openDatabase,
+			catch: (cause) => new SqlError({ reason: classifySqliteError(cause, {
+				message: "Failed to open database",
+				operation: "open"
+			}) })
+		});
+		yield* addFinalizer(scope$1, try_({
+			try: () => db.close(),
+			catch: (cause) => new SqlError({ reason: classifySqliteError(cause, {
+				message: "Failed to close database",
+				operation: "close"
+			}) })
+		}).pipe(orDie));
+		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 prepare = (sql) => try_({
+			try: () => db.prepare(sql),
+			catch: (cause) => new SqlError({ reason: classifySqliteError(cause, {
+				message: "Failed to prepare statement",
+				operation: "prepare"
+			}) })
+		});
+		const prepareCache = yield* make$2({
+			capacity: options.prepareCacheSize ?? 200,
+			timeToLive: options.prepareCacheTTL ?? minutes(10),
+			lookup: prepare
+		});
+		const runStatement = (statement, params, raw) => withFiber((fiber) => {
+			try {
+				statement.setReadBigInts(Boolean(get(fiber.context, SafeIntegers)));
+				if (hasRows(statement)) return succeed(statement.all(...params));
+				const result = statement.run(...params);
+				return succeed(raw ? result : []);
+			} catch (cause) {
+				return fail(new SqlError({ reason: classifySqliteError(cause, {
+					message: "Failed to execute statement",
+					operation: "execute"
+				}) }));
+			}
+		});
+		const run = (sql, params, raw = false) => flatMap(get$1(prepareCache, sql), (s) => runStatement(s, params, raw));
+		const runStatementValues = (statement, params) => acquireUseRelease(succeed(statement), (statement) => try_({
+			try: () => {
+				if (hasRows(statement)) {
+					statement.setReturnArrays(true);
+					return statement.all(...params);
+				}
+				statement.run(...params);
+				return [];
+			},
+			catch: (cause) => new SqlError({ reason: classifySqliteError(cause, {
+				message: "Failed to execute statement",
+				operation: "execute"
+			}) })
+		}), (statement) => try_({
+			try: () => {
+				if (hasRows(statement)) statement.setReturnArrays(false);
+			},
+			catch: (cause) => new SqlError({ reason: classifySqliteError(cause, {
+				message: "Failed to reset statement result mode",
+				operation: "resetResultMode"
+			}) })
+		}).pipe(orDie));
+		const runValues = (sql, params) => flatMap(get$1(prepareCache, sql), (statement) => runStatementValues(statement, params));
+		return identity({
+			execute(sql, params, rowTransform) {
+				return rowTransform ? map(run(sql, params), rowTransform) : run(sql, params);
+			},
+			executeRaw(sql, params) {
+				return run(sql, params, true);
+			},
+			executeValues(sql, params) {
+				return runValues(sql, params);
+			},
+			executeValuesUnprepared(sql, params) {
+				return flatMap(prepare(sql), (statement) => runStatementValues(statement, params ?? []));
+			},
+			executeUnprepared(sql, params, rowTransform) {
+				const effect = prepare(sql).pipe(flatMap((statement) => runStatement(statement, params ?? [], false)));
+				return rowTransform ? map(effect, rowTransform) : effect;
+			},
+			executeStream(_sql, _params) {
+				return die$1(new UnsupportedNodeSqliteOperationError());
+			}
+		});
+	});
+	const semaphore = yield* make$1(1);
+	const connection = yield* makeConnection;
+	return yield* make$3({
+		acquirer: semaphore.withPermits(1)(succeed(connection)),
+		compiler,
+		transactionAcquirer: uninterruptibleMask((restore) => {
+			const scope = getUnsafe(getCurrent().context, Scope);
+			return as(tap(restore(semaphore.take(1)), () => addFinalizer(scope, semaphore.release(1))), connection);
+		}),
+		spanAttributes: [...options.spanAttributes ? Object.entries(options.spanAttributes) : [], [ATTR_DB_SYSTEM_NAME, "sqlite"]],
+		transformRows
+	});
+});
+const make = (options) => makeWithDatabase(options, () => new NodeSqlite.DatabaseSync(options.filename, {
+	readOnly: options.readonly ?? false,
+	allowExtension: options.allowExtension ?? false
+}));
+const makeMemory = (config = {}) => makeWithDatabase({
+	...config,
+	filename: ":memory:",
+	readonly: false
+}, () => {
+	return new NodeSqlite.DatabaseSync(":memory:", { allowExtension: config.allowExtension ?? false });
+});
+const layerConfig = (config) => effect(SqlClient, unwrap(config).pipe(flatMap(make))).pipe(provide(layer$1));
+const layer = (config) => effect(SqlClient, make(config)).pipe(provide(layer$1));
+const layerMemory = (config = {}) => effect(SqlClient, makeMemory(config)).pipe(provide(layer$1));
+//#endregion
+export { TypeId, UnsupportedNodeSqliteOperationError, UnsupportedNodeSqliteVersionError, layer, layerConfig, layerMemory };
+
+//# sourceMappingURL=NodeSqliteClient-CmuXRT3w.mjs.map