@das-org/dascode 0.0.31

package/dist/SqlClient-Dp5XVCmr.mjs

@@ -0,0 +1,922 @@
+#!/usr/bin/env node
+
+import { Ai as onExit, Bo as make$3, Cu as match, Ea as withFiber, Fc as ParentSpan, Fu as Prototype, Gr as flatMap, Ho as provide, Io as close, Jl as add, Ki as runForkWith, Kl as Reference, Ko as TracerTimingEnabled, Lr as ensuring, Mr as contextWith, No as Scope, Pi as orDie, Po as addFinalizer, Ri as provideContext, Rr as exit, Sa as void_, Sd as flow, Wu as assignProperty, Xl as get, Yr as fnUntraced, Zi as scoped, Zl as getOption, aa as suspend, ad as hasProperty, ea as serviceOption, ii as gen, iu as mutate, jr as context, na as succeed, nc as endSpan, oa as sync, ps as isSuccess, ql as Service, sa as tap, so as Clock, td as hash, vc as makeSpanUnsafe, vd as constUndefined, vi as makeSpanScoped, vo as effect, xa as useSpan, ya as uninterruptibleMask, yi as map, zi as provideService } from "./Schema-DuQUv9rO.mjs";
+import { Qt as make$4, Sn as runIn, Zt as failCauseUnsafe, j as fromQueue, mt as unwrap, tn as offerUnsafe } from "./Path-BB53LP8h.mjs";
+//#region ../../node_modules/.pnpm/effect@4.0.0-beta.102_patch_10dcca2e28a1e6c67a3825e6da1ff253/node_modules/effect/dist/unstable/reactivity/Reactivity.js
+/**
+* Process-local invalidation for connecting writes to dependent reads.
+*
+* This module does not cache values itself. It lets callers register handlers
+* for keys, invalidate those keys, wrap successful mutations so they invalidate
+* keys, and expose effects as queues or streams that rerun when matching keys
+* change. The service can also batch invalidations so handlers run after the
+* batch completes.
+*
+* @since 4.0.0
+*/
+/**
+* Service for key-based reactive invalidation.
+*
+* **When to use**
+*
+* Use to provide the invalidation service that refreshes queries, streams, and
+* atoms when application keys change.
+*
+* **Details**
+*
+* The service can register handlers for keys, invalidate those keys, wrap
+* mutations so successful effects invalidate keys, and turn query effects into
+* queues or streams that rerun when keys are invalidated.
+*
+* @category services
+* @since 4.0.0
+*/
+var Reactivity = class extends Service()("effect/reactivity/Reactivity") {};
+/**
+* Creates an in-memory `Reactivity` service.
+*
+* **Details**
+*
+* The service tracks handlers by hashed keys and runs the registered handlers when
+* matching keys are invalidated.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const make$2 = /*#__PURE__*/ sync(() => {
+	const handlers = /* @__PURE__ */ new Map();
+	const invalidateUnsafe = (keys) => {
+		keysToHashes(keys, (hash) => {
+			const set = handlers.get(hash);
+			if (set === void 0) return;
+			set.forEach((run) => run());
+		});
+	};
+	const invalidate = (keys) => contextWith((services) => {
+		const pending = services.mapUnsafe.get(PendingInvalidation.key);
+		if (pending) keysToHashes(keys, (hash) => {
+			pending.add(hash);
+		});
+		else invalidateUnsafe(keys);
+		return void_;
+	});
+	const mutation = (keys, effect) => tap(effect, invalidate(keys));
+	const registerUnsafe = (keys, handler) => {
+		const resolvedKeys = [];
+		keysToHashes(keys, (hash) => {
+			resolvedKeys.push(hash);
+			let set = handlers.get(hash);
+			if (set === void 0) {
+				set = /* @__PURE__ */ new Set();
+				handlers.set(hash, set);
+			}
+			set.add(handler);
+		});
+		return () => {
+			for (let i = 0; i < resolvedKeys.length; i++) {
+				const set = handlers.get(resolvedKeys[i]);
+				set.delete(handler);
+				if (set.size === 0) handlers.delete(resolvedKeys[i]);
+			}
+		};
+	};
+	const query = (keys, effect) => gen(function* () {
+		const services = yield* context();
+		const scope = get(services, Scope);
+		const results = yield* make$4();
+		const runFork = flow(runForkWith(services), runIn(scope));
+		let running = false;
+		let pending = false;
+		const handleExit = (exit) => {
+			if (exit._tag === "Failure") failCauseUnsafe(results, exit.cause);
+			else offerUnsafe(results, exit.value);
+			if (pending) {
+				pending = false;
+				runFork(effect).addObserver(handleExit);
+			} else running = false;
+		};
+		function run() {
+			if (running) {
+				pending = true;
+				return;
+			}
+			running = true;
+			runFork(effect).addObserver(handleExit);
+		}
+		yield* addFinalizer(scope, sync(registerUnsafe(keys, run)));
+		run();
+		return results;
+	});
+	const stream = (tables, effect) => query(tables, effect).pipe(map(fromQueue), unwrap);
+	const withBatch = (effect) => suspend(() => {
+		const pending = /* @__PURE__ */ new Set();
+		return effect.pipe(provideService(PendingInvalidation, pending), onExit((_) => sync(() => {
+			pending.forEach((hash) => {
+				const set = handlers.get(hash);
+				if (set === void 0) return;
+				set.forEach((run) => run());
+			});
+		})));
+	});
+	return Reactivity.of({
+		mutation,
+		query,
+		stream,
+		invalidateUnsafe,
+		invalidate,
+		registerUnsafe,
+		withBatch
+	});
+});
+var PendingInvalidation = class extends Service()("effect/reactivity/Reactivity/PendingInvalidation") {};
+/**
+* The default layer that provides an in-memory `Reactivity` service.
+*
+* @category layers
+* @since 4.0.0
+*/
+const layer = /*#__PURE__*/ effect(Reactivity)(make$2);
+function stringOrHash(u) {
+	switch (typeof u) {
+		case "string":
+		case "number":
+		case "bigint":
+		case "boolean": return String(u);
+		default: return hash(u);
+	}
+}
+const keysToHashes = (keys, f) => {
+	if (Array.isArray(keys)) {
+		for (let i = 0; i < keys.length; i++) f(stringOrHash(keys[i]));
+		return;
+	}
+	for (const key in keys) {
+		f(key);
+		const ids = keys[key];
+		for (let i = 0; i < ids.length; i++) f(`${key}:${stringOrHash(ids[i])}`);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/effect@4.0.0-beta.102_patch_10dcca2e28a1e6c67a3825e6da1ff253/node_modules/effect/dist/unstable/sql/Statement.js
+/**
+* Low-level SQL statement and fragment primitives.
+*
+* `SqlClient` uses this module to build executable, parameterized SQL from
+* reusable fragments. A statement can be executed, streamed, run without row
+* transformation, or compiled to SQL text and parameters for a specific
+* dialect. The module also contains helpers for identifiers, parameters,
+* inserts, updates, custom dialect fragments, statement compilation, and row
+* transformation.
+*
+* @since 4.0.0
+*/
+const FragmentTypeId = "~effect/sql/Fragment";
+/**
+* Constructs a SQL `Fragment` from low-level statement segments.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const fragment = (segments) => ({
+	[FragmentTypeId]: FragmentTypeId,
+	segments
+});
+/**
+* Context reference for an optional current SQL statement transformer applied
+* before statement execution.
+*
+* @category transformer
+* @since 4.0.0
+*/
+const CurrentTransformer = /*#__PURE__*/ Reference("effect/sql/CurrentTransformer", { defaultValue: constUndefined });
+/**
+* Returns `true` when a value is a SQL `Fragment`.
+*
+* @category guards
+* @since 4.0.0
+*/
+const isFragment = (u) => hasProperty(u, FragmentTypeId);
+/**
+* Constructs a raw SQL literal segment. The literal text is not escaped, so use
+* bound parameters for untrusted values.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const literal = (value, params) => ({
+	_tag: "Literal",
+	value,
+	params
+});
+/**
+* Constructs a SQL identifier segment that will be escaped by the active
+* compiler.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const identifier = (value) => ({
+	_tag: "Identifier",
+	value
+});
+/**
+* Constructs a bound parameter segment for a statement value.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const parameter = (value) => ({
+	_tag: "Parameter",
+	value
+});
+/**
+* Constructs an `ArrayHelper` segment for an array of values or fragments.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const arrayHelper = (value) => ({
+	_tag: "ArrayHelper",
+	value
+});
+const RecordInsertHelperProto = {
+	_tag: "RecordInsertHelper",
+	returning(sql) {
+		const self = Object.create(Object.getPrototypeOf(this));
+		Object.assign(self, this, { returningIdentifier: sql });
+		return self;
+	}
+};
+/**
+* Constructs a `RecordInsertHelper` from one or more row objects.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const recordInsertHelper = (value) => Object.assign(Object.create(RecordInsertHelperProto), {
+	value,
+	returningIdentifier: void 0
+});
+const RecordUpdateHelperProto = {
+	...RecordInsertHelperProto,
+	_tag: "RecordUpdateHelper"
+};
+/**
+* Constructs a `RecordUpdateHelper` for multi-row update compilation using the
+* provided alias.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const recordUpdateHelper = (value, alias) => Object.assign(Object.create(RecordUpdateHelperProto), {
+	value,
+	alias,
+	returningIdentifier: void 0
+});
+const RecordUpdateHelperSingleProto = {
+	...RecordInsertHelperProto,
+	_tag: "RecordUpdateHelperSingle"
+};
+/**
+* Constructs a `RecordUpdateHelperSingle` from a record and a list of columns
+* to omit from the update.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const recordUpdateHelperSingle = (value, omit) => Object.assign(Object.create(RecordUpdateHelperSingleProto), {
+	value,
+	omit,
+	returningIdentifier: void 0
+});
+/**
+* Creates a cached SQL statement constructor from a connection acquirer,
+* compiler, tracing attributes, and optional row transformation function.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const make$1 = (acquirer, compiler, spanAttributes, transformRows) => {
+	const cache = transformRows === void 0 ? constructorCache.noTransforms : constructorCache.transforms;
+	if (cache.has(acquirer)) return cache.get(acquirer);
+	const self = Object.assign(function sql(strings, ...args) {
+		if (typeof strings === "string") return identifier(strings);
+		else if (Array.isArray(strings) && "raw" in strings) return statement(acquirer, compiler, strings, args, spanAttributes, transformRows);
+		throw "absurd";
+	}, {
+		unsafe(sql, params) {
+			return makeUnsafe([literal(sql, params)], acquirer, compiler, spanAttributes, transformRows);
+		},
+		literal(sql) {
+			return fragment([literal(sql)]);
+		},
+		in: in_,
+		insert(value) {
+			return recordInsertHelper(Array.isArray(value) ? value : [value]);
+		},
+		update(value, omit) {
+			return recordUpdateHelperSingle(value, omit ?? []);
+		},
+		updateValues(value, alias) {
+			return recordUpdateHelper(value, alias);
+		},
+		and,
+		or,
+		csv,
+		join,
+		onDialect(options) {
+			return options[compiler.dialect]();
+		},
+		onDialectOrElse(options) {
+			return options[compiler.dialect] !== void 0 ? options[compiler.dialect]() : options.orElse();
+		}
+	});
+	cache.set(acquirer, self);
+	return self;
+};
+const constructorCache = {
+	transforms: /*#__PURE__*/ new WeakMap(),
+	noTransforms: /*#__PURE__*/ new WeakMap()
+};
+/**
+* Builds a `Statement` from template strings and arguments, preserving
+* fragments and helper segments while converting ordinary interpolated values
+* into bound parameters.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const statement = (acquirer, compiler, strings, args, spanAttributes, transformRows) => {
+	const segments = strings[0].length > 0 ? [literal(strings[0])] : [];
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (isFragment(arg)) segments.push(...arg.segments);
+		else if (isSegment(arg)) segments.push(arg);
+		else segments.push(parameter(arg));
+		if (strings[i + 1].length > 0) segments.push(literal(strings[i + 1]));
+	}
+	return makeUnsafe(segments, acquirer, compiler, spanAttributes, transformRows);
+};
+/**
+* Creates a helper that joins SQL clauses with a literal separator, optionally
+* wrapping multiple clauses in parentheses and using a fallback for an empty
+* list.
+*
+* @category constructors
+* @since 4.0.0
+*/
+function join(lit, addParens = true, fallback = "") {
+	const literalStatement = literal(lit);
+	const fallbackFragment = fragment([literal(fallback)]);
+	return (clauses) => {
+		if (clauses.length === 0) return fallbackFragment;
+		else if (clauses.length === 1) return fragment(convertLiteralOrFragment(clauses[0]));
+		const segments = [];
+		if (addParens) segments.push(literal("("));
+		segments.push.apply(segments, convertLiteralOrFragment(clauses[0]));
+		for (let i = 1; i < clauses.length; i++) {
+			segments.push(literalStatement);
+			segments.push.apply(segments, convertLiteralOrFragment(clauses[i]));
+		}
+		if (addParens) segments.push(literal(")"));
+		return fragment(segments);
+	};
+}
+/**
+* Combines clauses with `AND`, parenthesizing multiple clauses and returning
+* `1=1` when the list is empty.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const and = /*#__PURE__*/ join(" AND ", true, "1=1");
+/**
+* Combines clauses with `OR`, parenthesizing multiple clauses and returning
+* `1=1` when the list is empty.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const or = /*#__PURE__*/ join(" OR ", true, "1=1");
+/**
+* Creates a comma-separated SQL fragment from values, optionally adding a
+* prefix, and returns an empty fragment when no values are provided.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const csv = function(...args) {
+	if (args[args.length - 1].length === 0) return emptyFragment;
+	if (args.length === 1) return csvRaw(args[0]);
+	return fragment([literal(`${args[0]} `), ...csvRaw(args[1]).segments]);
+};
+const csvRaw = /*#__PURE__*/ join(",", false);
+const emptyFragment = /*#__PURE__*/ fragment([/*#__PURE__*/ literal("")]);
+/**
+* Creates a dialect-specific SQL `Compiler` from rendering callbacks.
+*
+* @category compiler
+* @since 4.0.0
+*/
+const makeCompiler = (options) => {
+	const self = Object.create(CompilerProto);
+	self.options = options;
+	self.dialect = options.dialect;
+	self.disableTransforms = false;
+	return self;
+};
+const statementCacheSymbol = /*#__PURE__*/ Symbol.for("effect/unstable/sql/Statement/statementCache");
+const statementCacheNoTransformSymbol = /*#__PURE__*/ Symbol.for("effect/unstable/sql/Statement/statementCacheNoTransform");
+const CompilerProto = {
+	compile(statement, withoutTransform = false, placeholderOverride) {
+		const opts = this.options;
+		withoutTransform = withoutTransform || this.disableTransforms;
+		const cacheSymbol = withoutTransform ? statementCacheNoTransformSymbol : statementCacheSymbol;
+		if (cacheSymbol in statement) return statement[cacheSymbol];
+		const segments = statement.segments;
+		const len = segments.length;
+		let sql = "";
+		const binds = [];
+		let placeholderCount = 0;
+		const placeholder = placeholderOverride ?? ((u) => opts.placeholder(++placeholderCount, u));
+		const placeholderNoIncrement = (u) => opts.placeholder(placeholderCount, u);
+		const placeholders = makePlaceholdersArray(placeholder);
+		for (let i = 0; i < len; i++) {
+			const segment = segments[i];
+			switch (segment._tag) {
+				case "Literal":
+					sql += segment.value;
+					if (segment.params) binds.push.apply(binds, segment.params);
+					break;
+				case "Identifier":
+					sql += opts.onIdentifier(segment.value, withoutTransform);
+					break;
+				case "Parameter":
+					sql += placeholder(segment.value);
+					binds.push(segment.value);
+					break;
+				case "ArrayHelper":
+					sql += `(${placeholders(segment.value)})`;
+					binds.push.apply(binds, segment.value);
+					break;
+				case "RecordInsertHelper": {
+					const keys = Object.keys(segment.value[0]);
+					if (opts.onInsert) {
+						const values = new Array(segment.value.length);
+						let placeholders = "";
+						for (let i = 0; i < segment.value.length; i++) {
+							const row = new Array(keys.length);
+							values[i] = row;
+							placeholders += i === 0 ? "(" : ",(";
+							for (let j = 0; j < keys.length; j++) {
+								const key = keys[j];
+								const value = segment.value[i][key];
+								row[j] = extractPrimitive(value, opts.onCustom, placeholderNoIncrement, withoutTransform);
+								placeholders += j === 0 ? placeholder(value) : `,${placeholder(value)}`;
+							}
+							placeholders += ")";
+						}
+						const [s, b] = opts.onInsert(keys.map((_) => opts.onIdentifier(_, withoutTransform)), placeholders, values, typeof segment.returningIdentifier === "string" ? [segment.returningIdentifier, []] : segment.returningIdentifier ? this.compile(segment.returningIdentifier, withoutTransform, placeholder) : void 0);
+						sql += s;
+						binds.push.apply(binds, b);
+					} else {
+						let placeholders = "";
+						for (let i = 0; i < segment.value.length; i++) {
+							placeholders += i === 0 ? "(" : ",(";
+							for (let j = 0; j < keys.length; j++) {
+								const value = segment.value[i][keys[j]];
+								const primitive = extractPrimitive(value, opts.onCustom, placeholderNoIncrement, withoutTransform);
+								binds.push(primitive);
+								placeholders += j === 0 ? placeholder(value) : `,${placeholder(value)}`;
+							}
+							placeholders += ")";
+						}
+						sql += `${generateColumns(keys, opts.onIdentifier, withoutTransform)} VALUES ${placeholders}`;
+						if (typeof segment.returningIdentifier === "string") sql += ` RETURNING ${segment.returningIdentifier}`;
+						else if (segment.returningIdentifier) {
+							sql += " RETURNING ";
+							const [s, b] = this.compile(segment.returningIdentifier, withoutTransform, placeholder);
+							sql += s;
+							binds.push.apply(binds, b);
+						}
+					}
+					break;
+				}
+				case "RecordUpdateHelperSingle": {
+					let keys = Object.keys(segment.value);
+					if (segment.omit.length > 0) keys = keys.filter((key) => !segment.omit.includes(key));
+					if (opts.onRecordUpdateSingle) {
+						const [s, b] = opts.onRecordUpdateSingle(keys.map((_) => opts.onIdentifier(_, withoutTransform)), keys.map((key) => extractPrimitive(segment.value[key], opts.onCustom, placeholderNoIncrement, withoutTransform)), typeof segment.returningIdentifier === "string" ? [segment.returningIdentifier, []] : segment.returningIdentifier ? this.compile(segment.returningIdentifier, withoutTransform, placeholder) : void 0);
+						sql += s;
+						binds.push.apply(binds, b);
+					} else {
+						for (let i = 0, len = keys.length; i < len; i++) {
+							const column = opts.onIdentifier(keys[i], withoutTransform);
+							if (i === 0) sql += `${column} = ${placeholder(segment.value[keys[i]])}`;
+							else sql += `, ${column} = ${placeholder(segment.value[keys[i]])}`;
+							binds.push(extractPrimitive(segment.value[keys[i]], opts.onCustom, placeholderNoIncrement, withoutTransform));
+						}
+						if (typeof segment.returningIdentifier === "string") if (this.dialect === "mssql") sql += ` OUTPUT ${segment.returningIdentifier === "*" ? "INSERTED.*" : segment.returningIdentifier}`;
+						else sql += ` RETURNING ${segment.returningIdentifier}`;
+						else if (segment.returningIdentifier) {
+							sql += this.dialect === "mssql" ? " OUTPUT " : " RETURNING ";
+							const [s, b] = this.compile(segment.returningIdentifier, withoutTransform, placeholder);
+							sql += s;
+							binds.push.apply(binds, b);
+						}
+					}
+					break;
+				}
+				case "RecordUpdateHelper": {
+					const keys = Object.keys(segment.value[0]);
+					const values = new Array(segment.value.length);
+					let placeholders = "";
+					for (let i = 0; i < segment.value.length; i++) {
+						const row = new Array(keys.length);
+						values[i] = row;
+						placeholders += i === 0 ? "(" : ",(";
+						for (let j = 0; j < keys.length; j++) {
+							const key = keys[j];
+							const value = segment.value[i][key];
+							row[j] = extractPrimitive(value, opts.onCustom, placeholderNoIncrement, withoutTransform);
+							placeholders += j === 0 ? placeholder(value) : `,${placeholder(value)}`;
+						}
+						placeholders += ")";
+					}
+					const [s, b] = opts.onRecordUpdate(placeholders, segment.alias, generateColumns(keys, opts.onIdentifier, withoutTransform), values, typeof segment.returningIdentifier === "string" ? [segment.returningIdentifier, []] : segment.returningIdentifier ? this.compile(segment.returningIdentifier, withoutTransform, placeholder) : void 0);
+					sql += s;
+					binds.push.apply(binds, b);
+					break;
+				}
+				case "Custom": {
+					const [s, b] = opts.onCustom(segment, placeholder, withoutTransform);
+					sql += s;
+					binds.push.apply(binds, b);
+					break;
+				}
+			}
+		}
+		const result = [sql, binds];
+		if (placeholderOverride !== void 0) return result;
+		return statement[cacheSymbol] = result;
+	},
+	get withoutTransform() {
+		const self = Object.create(CompilerProto);
+		Object.assign(self, this, { disableTransforms: true });
+		return self;
+	}
+};
+/**
+* Creates a SQLite compiler that uses `?` placeholders and quoted identifiers,
+* optionally transforming identifier names before escaping.
+*
+* @category compiler
+* @since 4.0.0
+*/
+const makeCompilerSqlite = (transform) => makeCompiler({
+	dialect: "sqlite",
+	placeholder(_) {
+		return "?";
+	},
+	onIdentifier: transform ? function(value, withoutTransform) {
+		return withoutTransform ? escapeSqlite(value) : escapeSqlite(transform(value));
+	} : escapeSqlite,
+	onRecordUpdate() {
+		return ["", []];
+	},
+	onCustom() {
+		return ["", []];
+	}
+});
+/**
+* Creates an identifier escaping function that wraps names in the given
+* delimiter, doubles delimiter characters, and escapes dots between identifier
+* parts.
+*
+* @category constructors
+* @since 4.0.0
+*/
+function defaultEscape(c) {
+	const re = new RegExp(c, "g");
+	const double = c + c;
+	const dot = c + "." + c;
+	return function(str) {
+		return c + str.replace(re, double).replace(/\./g, dot) + c;
+	};
+}
+/**
+* Builds value, object, and row-array transformers that rename object keys with
+* the supplied function and optionally recurse into nested object arrays.
+*
+* @category transforming
+* @since 4.0.0
+*/
+const defaultTransforms = (transformer, nested = true) => {
+	const transformValue = (value) => {
+		if (Array.isArray(value)) {
+			if (value.length === 0 || value[0].constructor !== Object) return value;
+			return array(value);
+		} else if (value?.constructor === Object) return transformObject(value);
+		return value;
+	};
+	const transformObject = (obj) => {
+		const newObj = {};
+		for (const key of Object.keys(obj)) assignProperty(newObj, transformer(key), transformValue(obj[key]));
+		return newObj;
+	};
+	const transformArrayNested = (rows) => {
+		const newRows = new Array(rows.length);
+		for (let i = 0, len = rows.length; i < len; i++) {
+			const row = rows[i];
+			if (Array.isArray(row)) newRows[i] = transformArrayNested(row);
+			else {
+				const obj = {};
+				for (const [key, value] of Object.entries(row)) assignProperty(obj, transformer(key), transformValue(value));
+				newRows[i] = obj;
+			}
+		}
+		return newRows;
+	};
+	const transformArray = (rows) => {
+		const newRows = new Array(rows.length);
+		for (let i = 0, len = rows.length; i < len; i++) {
+			const row = rows[i];
+			if (Array.isArray(row)) newRows[i] = transformArray(row);
+			else {
+				const obj = {};
+				for (const [key, value] of Object.entries(row)) assignProperty(obj, transformer(key), value);
+				newRows[i] = obj;
+			}
+		}
+		return newRows;
+	};
+	const array = nested ? transformArrayNested : transformArray;
+	return {
+		value: transformValue,
+		object: transformObject,
+		array
+	};
+};
+const ATTR_DB_OPERATION_NAME = "db.operation.name";
+const ATTR_DB_QUERY_TEXT = "db.query.text";
+const makeUnsafe = (segments, acquirer, compiler, spanAttributes, transformRows) => {
+	const self = Object.create(StatementProto);
+	self.segments = segments;
+	self.acquirer = acquirer;
+	self.compiler = compiler;
+	self.spanAttributes = spanAttributes;
+	self.transformRows = transformRows;
+	return self;
+};
+const StatementProto = {
+	.../*#__PURE__*/ Prototype({
+		label: "Statement",
+		evaluate(fiber) {
+			const span = makeSpanUnsafe(fiber, "sql.execute", { kind: "client" });
+			const clock = fiber.getRef(Clock);
+			const timingEnabled = fiber.getRef(TracerTimingEnabled);
+			return onExit(this.withConnectionSpan("execute", (connection, sql, params) => connection.execute(sql, params, this.transformRows), false, span), (exit) => endSpan(span, exit, clock, timingEnabled));
+		}
+	}),
+	[FragmentTypeId]: FragmentTypeId,
+	withConnection(operation, f, withoutTransform = false) {
+		return useSpan("sql.execute", { kind: "client" }, (span) => this.withConnectionSpan(operation, f, withoutTransform, span));
+	},
+	withConnectionSpan(operation, f, withoutTransform, span) {
+		return withStatement(this, span, (statement) => {
+			const [sql, params] = statement.compile(withoutTransform);
+			for (const [key, value] of this.spanAttributes) span.attribute(key, value);
+			span.attribute(ATTR_DB_OPERATION_NAME, operation);
+			span.attribute(ATTR_DB_QUERY_TEXT, sql);
+			return scoped(flatMap(this.acquirer, (_) => f(_, sql, params)));
+		});
+	},
+	get withoutTransform() {
+		return this.withConnection("executeWithoutTransform", (connection, sql, params) => connection.execute(sql, params, void 0), true);
+	},
+	get raw() {
+		return this.withConnection("executeRaw", (connection, sql, params) => connection.executeRaw(sql, params), true);
+	},
+	get stream() {
+		const self = this;
+		return unwrap(flatMap(makeSpanScoped("sql.execute", { kind: "client" }), (span) => withStatement(self, span, (statement) => {
+			const [sql, params] = statement.compile();
+			for (const [key, value] of self.spanAttributes) span.attribute(key, value);
+			span.attribute(ATTR_DB_OPERATION_NAME, "executeStream");
+			span.attribute(ATTR_DB_QUERY_TEXT, sql);
+			return map(self.acquirer, (_) => _.executeStream(sql, params, self.transformRows));
+		})));
+	},
+	get values() {
+		return this.withConnection("executeValues", (connection, sql, params) => connection.executeValues(sql, params));
+	},
+	get valuesUnprepared() {
+		return this.withConnection("executeValuesUnprepared", (connection, sql, params) => connection.executeValuesUnprepared(sql, params));
+	},
+	get unprepared() {
+		const self = this;
+		return self.withConnection("executeUnprepared", (connection, sql, params) => connection.executeUnprepared(sql, params, self.transformRows));
+	},
+	compile(withoutTransform) {
+		return this.compiler.compile(this, withoutTransform ?? false);
+	},
+	toJSON() {
+		const [sql, params] = this.compile();
+		return {
+			_id: "Statement",
+			segments: this.segments,
+			sql,
+			params
+		};
+	}
+};
+const withStatement = (self, span, f) => withFiber((fiber) => {
+	const transform = fiber.getRef(CurrentTransformer);
+	if (transform === void 0) return f(self);
+	return flatMap(transform(self, make$1(self.acquirer, self.compiler, self.spanAttributes, self.transformRows), fiber, span), f);
+});
+const isSegment = (u) => {
+	if (!hasProperty(u, "_tag")) return false;
+	switch (u._tag) {
+		case "Literal":
+		case "Parameter":
+		case "ArrayHelper":
+		case "RecordInsertHelper":
+		case "RecordUpdateHelper":
+		case "RecordUpdateHelperSingle":
+		case "Identifier":
+		case "Custom": return true;
+		default: return false;
+	}
+};
+function convertLiteralOrFragment(clause) {
+	if (typeof clause === "string") return [literal(clause)];
+	return clause.segments;
+}
+const makePlaceholdersArray = (evaluate) => (values) => {
+	if (values.length === 0) return "";
+	let result = evaluate(values[0]);
+	for (let i = 1; i < values.length; i++) result += `,${evaluate(values[i])}`;
+	return result;
+};
+const generateColumns = (keys, escape, withoutTransform) => {
+	if (keys.length === 0) return "()";
+	let str = `(${escape(keys[0], withoutTransform)}`;
+	for (let i = 1; i < keys.length; i++) str += `,${escape(keys[i], withoutTransform)}`;
+	return str + ")";
+};
+const extractPrimitive = (value, onCustom, placeholder, withoutTransform) => {
+	if (value === void 0) return null;
+	else if (isFragment(value)) {
+		const head = value.segments[0];
+		if (head._tag === "Custom") return onCustom(head, placeholder, withoutTransform)[1][0] ?? null;
+		else if (head._tag === "Parameter") return head.value;
+		return null;
+	}
+	return value;
+};
+const escapeSqlite = /*#__PURE__*/ defaultEscape("\"");
+function in_() {
+	if (arguments.length === 1) return arrayHelper(arguments[0]);
+	const column = arguments[0];
+	const values = arguments[1];
+	return values.length === 0 ? neverFragment : fragment([
+		identifier(column),
+		literal(" IN "),
+		arrayHelper(values)
+	]);
+}
+const neverFragment = /*#__PURE__*/ fragment([/*#__PURE__*/ literal("1=0")]);
+//#endregion
+//#region ../../node_modules/.pnpm/effect@4.0.0-beta.102_patch_10dcca2e28a1e6c67a3825e6da1ff253/node_modules/effect/dist/unstable/sql/SqlClient.js
+/**
+* Main SQL client service for tagged-template queries.
+*
+* `SqlClient` combines the tagged-template statement constructor with
+* connection acquisition, dialect compilation, transactions, row transforms,
+* tracing, and reactive query helpers. Driver integrations build this service
+* from their connection and compiler pieces.
+*
+* @since 4.0.0
+*/
+const TypeId = "~effect/sql/SqlClient";
+/**
+* Service tag for the active SQL client service.
+*
+* **When to use**
+*
+* Use to access or provide the SQL client used to build statements, stream
+* rows, reserve connections, and run transactions.
+*
+* @category services
+* @since 4.0.0
+*/
+const SqlClient = /*#__PURE__*/ Service("effect/sql/SqlClient");
+let clientIdCounter = 0;
+/**
+* Constructs a `SqlClient` from connection acquirers, a compiler, transaction
+* commands, tracing attributes, optional row transforms, and reactive query
+* integration.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const make = /*#__PURE__*/ fnUntraced(function* (options) {
+	const transactionService = options.transactionService ?? TransactionConnection(clientIdCounter++);
+	const getConnection = flatMap(serviceOption(transactionService), match({
+		onNone: () => options.acquirer,
+		onSome: ([conn]) => succeed(conn)
+	}));
+	const beginTransaction = options.beginTransaction ?? "BEGIN";
+	const commit = options.commit ?? "COMMIT";
+	const savepoint = options.savepoint ?? ((name) => `SAVEPOINT ${name}`);
+	const rollback = options.rollback ?? "ROLLBACK";
+	const rollbackSavepoint = options.rollbackSavepoint ?? ((name) => `ROLLBACK TO SAVEPOINT ${name}`);
+	const transactionAcquirer = options.transactionAcquirer ?? options.acquirer;
+	const withTransaction = makeWithTransaction({
+		transactionService,
+		spanAttributes: options.spanAttributes,
+		acquireConnection: flatMap(make$3(), (scope) => map(provide(transactionAcquirer, scope), (conn) => [scope, conn])),
+		begin: (conn) => conn.executeUnprepared(beginTransaction, [], void 0),
+		savepoint: (conn, id) => conn.executeUnprepared(savepoint(`effect_sql_${id}`), [], void 0),
+		commit: (conn) => conn.executeUnprepared(commit, [], void 0),
+		rollback: (conn) => conn.executeUnprepared(rollback, [], void 0),
+		rollbackSavepoint: (conn, id) => conn.executeUnprepared(rollbackSavepoint(`effect_sql_${id}`), [], void 0)
+	});
+	const reactivity = yield* Reactivity;
+	const client = Object.assign(make$1(getConnection, options.compiler, options.spanAttributes, options.transformRows), {
+		[TypeId]: TypeId,
+		safe: void 0,
+		withTransaction,
+		transactionService,
+		reserve: transactionAcquirer,
+		withoutTransforms() {
+			if (options.transformRows === void 0) return this;
+			const statement = make$1(getConnection, options.compiler.withoutTransform, options.spanAttributes, void 0);
+			const client = Object.assign(statement, {
+				...this,
+				...statement
+			});
+			client.safe = client;
+			client.withoutTransforms = () => client;
+			return client;
+		},
+		reactive: options.reactiveQueue ? (keys, effect) => options.reactiveQueue(keys, effect).pipe(map(fromQueue), unwrap) : reactivity.stream,
+		reactiveMailbox: options.reactiveQueue ?? reactivity.query
+	});
+	client.safe = client;
+	return client;
+});
+/**
+* Builds a transaction wrapper that begins top-level transactions, uses
+* savepoints for nested transactions, commits on success, and rolls back on
+* failure or interruption.
+*
+* @category transactions
+* @since 4.0.0
+*/
+const makeWithTransaction = (options) => (effect) => {
+	return uninterruptibleMask((restore) => useSpan("sql.transaction", { kind: "client" }, (span) => withFiber((fiber) => {
+		for (const [key, value] of options.spanAttributes) span.attribute(key, value);
+		const services = fiber.context;
+		const clock = fiber.getRef(Clock);
+		const connOption = getOption(services, options.transactionService);
+		const conn = connOption._tag === "Some" ? succeed([void 0, connOption.value[0]]) : options.acquireConnection;
+		const id = connOption._tag === "Some" ? connOption.value[1] + 1 : 0;
+		return flatMap(conn, ([scope, conn]) => (id === 0 ? options.begin(conn) : options.savepoint(conn, id)).pipe(flatMap(() => provideContext(restore(effect), mutate(services, (services) => services.pipe(add(options.transactionService, [conn, id]), add(ParentSpan, span))))), exit, flatMap((exit) => {
+			let effect;
+			if (isSuccess(exit)) if (id === 0) {
+				span.event("db.transaction.commit", clock.currentTimeNanosUnsafe());
+				effect = orDie(options.commit(conn));
+			} else {
+				span.event("db.transaction.savepoint", clock.currentTimeNanosUnsafe());
+				effect = void_;
+			}
+			else {
+				span.event("db.transaction.rollback", clock.currentTimeNanosUnsafe());
+				effect = orDie(id > 0 ? options.rollbackSavepoint(conn, id) : options.rollback(conn));
+			}
+			return flatMap(scope !== void 0 ? ensuring(effect, close(scope, exit)) : effect, () => exit);
+		})));
+	})));
+};
+/**
+* Creates a unique context service tag for the active transaction connection of
+* a specific SQL client.
+*
+* @category services
+* @since 4.0.0
+*/
+const TransactionConnection = (clientId) => Service(`effect/sql/SqlClient/TransactionConnection/${clientId}`);
+/**
+* Context reference used by SQL integrations to opt in to safe integer
+* handling; defaults to `false`.
+*
+* @category references
+* @since 4.0.0
+*/
+const SafeIntegers = /*#__PURE__*/ Reference("effect/sql/SqlClient/SafeIntegers", { defaultValue: () => false });
+//#endregion
+export { makeCompilerSqlite as a, defaultTransforms as i, SqlClient as n, layer as o, make as r, SafeIntegers as t };
+
+//# sourceMappingURL=SqlClient-Dp5XVCmr.mjs.map