clanka 0.7.0 → 0.7.2

package/dist/bin/SemanticSearch-D9iZ_Mi9.mjs

@@ -0,0 +1,3372 @@
+import { $a as done, B as TaggedError, Bi as void_$1, Bo as onExit$1, Bs as isZero, Co as exitHasInterrupts, Cs as sort, Ct as isSchema, Da as effect, Dc as Prototype, Di as sync, Dr as forEach, Ei as suspend, Er as fnUntraced, Fc as assignProperty, Fo as forkUnsafe, Fr as interrupt, Gc as byReferenceUnsafe, Gn as all, Ha as addFinalizer, Hn as acquireRelease, Hs as minutes, I as String$1, Ia as provide$1, Ii as uninterruptibleMask, Ja as provide, Jc as hash, Ji as Class$2, Jn as annotateLogs, Jo as updateContext, Js as add, Ka as make$8, Kc as equals, Ki as withSpan, Ks as Reference, Kt as evolve, L as Struct$2, La as provideMerge, Lr as isEffect, Ls as fromInputUnsafe, Mi as tryPromise, Mo as fiberJoin, Ni as try_, Nr as gen, O as Number$1, Oa as effectContext, Oi as tap, Oo as fiberInterrupt, Or as forever, Ot as mutable, Pc as withFiber$1, Pr as ignore, Q as brand, Qs as getOrUndefined, Rr as logDebug, Rs as infinity, S as Natural, Sc as some, Si as serviceOption, So as endSpan, Sr as flatMap, Tc as make$10, Tr as fn, Ui as withFiber, Un as acquireUseRelease, Uo as succeed$1, Ur as makeSpanScoped, Us as seconds, Va as Scope, Vr as logInfo, Vs as millis, Wa as close, Wi as withLogSpan, Wr as map, Ws as toMillis, Xc as symbol$1, Xr as matchCauseEager, Xs as get$1, Y as Union$2, Yn as as, Yo as void_$2, Za as TracerTimingEnabled, Zc as hasProperty, Zn as asVoid, Zo as ParentSpan, Zs as getOption, _c as map$1, _i as runForkWith, ai as orDie, ao as makeUnsafe$2, bi as scoped, co as failCause, cr as catchTag, d as Defect, da as NoSuchElementError, dl as constUndefined, do as isFailure, ds as flatMapNullishOr, dt as instanceOf, ec as getUnsafe, eo as doneUnsafe, fo as isSuccess, fr as context, fs as fromIterable, gc as isSome, gi as runFork, gl as identity, hc as isNone, hl as flow, ho as ClockRef, hr as die, it as decodeUnknownEffect, jr as forkScoped, ka as effectDiscard, kc as PipeInspectableProto, kt as optional, la as Clock, li as provideContext, lr as catchTags, ml as dual, mo as void_$3, mr as delay, ms as isArrayNonEmpty, n as ArraySchema, ni as onExitPrimitive, no as into, nr as catchDefect, o as Class$1, oi as orElseSucceed, or as catchNoSuchElement, pi as request$1, po as succeed$2, pr as contextWith, qc as symbol, qn as annotateCurrentSpan, qr as mapError, qs as Service, rc as merge, rs as TaggedError$1, rt as decodeTo, so as fail, ss as empty, st as encodeEffect, tc as make$9, ti as onExit, tr as catchCause, uc as fromNullishOr, ui as provideService, ur as catch_, va as filterInterruptors, vc as match, vl as pipe, wc as Number$2, wi as succeed, wn as transform$1, xa as hasInterruptsOnly, xo as contextWith$1, xr as filterOrFail, yc as none, yi as scope, yl as pipeArguments, yr as fail$1, ys as map$2, zi as useSpan, zo as makeSpanUnsafe, zs as isFinite } from "./Schema-D6y3R-At.mjs";
+import { A as isEmpty, B as getCurrent, C as runCollect, D as empty$1, E as unwrap, F as make$14, G as has, H as join$1, I as makeUnsafe$3, K as toPredicate, L as failCauseUnsafe, M as remove, N as set, O as forEach$1, P as size, R as make$11, S as provideService$1, T as tap$1, U as runIn, V as interruptAs, W as compose, _ as die$1, a as makeGrouped, b as fromArrayEffect, c as SemanticSearch, f as make$13, g as FileSystem, h as Path, i as batchN, j as make$12, k as get$2, l as maybeRemoveFile, m as Console, n as EmbeddingModel, o as setDelay, p as ChildProcessSpawner, r as EmbeddingRequest, s as withSpan$1, t as Dimensions, u as maybeUpdateFile, v as flatMap$1, w as runDrain, x as fromQueue, y as fromArray, z as offerUnsafe } from "./cli.mjs";
+import { createHash } from "node:crypto";
+import TreeSitter from "tree-sitter";
+import TreeSitterJavaScript from "tree-sitter-javascript";
+import TreeSitterTypeScript from "tree-sitter-typescript";
+import { DatabaseSync, backup } from "node:sqlite";
+import { getLoadablePath } from "sqlite-vec";
+//#region node_modules/.pnpm/effect@4.0.0-rc.115/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
+*/
+/**
+* Brand for `Reactivity` implementations.
+*
+* @category type IDs
+* @since 4.0.0
+*/
+const TypeId$6 = "~effect/reactivity/Reactivity";
+/**
+* Service key for reactive invalidation.
+*
+* @category services
+* @since 4.0.0
+*/
+const Reactivity = /*#__PURE__*/ 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$7 = /*#__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 = getOrUndefined(services, PendingInvalidation);
+		if (pending) keysToHashes(keys, (hash) => {
+			pending.add(hash);
+		});
+		else invalidateUnsafe(keys);
+		return void_$1;
+	});
+	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]);
+				if (set === void 0) continue;
+				set.delete(handler);
+				if (set.size === 0) handlers.delete(resolvedKeys[i]);
+			}
+		};
+	};
+	const query = (keys, effect) => gen(function* () {
+		const services = yield* context();
+		const scope = get$1(services, Scope);
+		const results = yield* make$11();
+		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);
+		}
+		const cancel = registerUnsafe(keys, run);
+		yield* addFinalizer(scope, sync(cancel));
+		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({
+		[TypeId$6]: TypeId$6,
+		mutation,
+		query,
+		stream,
+		invalidateUnsafe,
+		invalidate,
+		registerUnsafe,
+		withBatch
+	});
+});
+var PendingInvalidation = class extends (/*#__PURE__*/ Service()("effect/reactivity/Reactivity/PendingInvalidation")) {};
+/**
+* The default layer that provides an in-memory `Reactivity` service.
+*
+* @category layers
+* @since 4.0.0
+*/
+const layer$5 = /*#__PURE__*/ effect(Reactivity)(make$7);
+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-rc.115/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/Statement/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 services
+* @since 4.0.0
+*/
+const CurrentTransformer = /*#__PURE__*/ Reference("effect/sql/CurrentTransformer", { defaultValue: constUndefined });
+/**
+* Parents driver spans under `sql.execute` for every client in the current scope,
+* including acquisition and stream pulls. Defaults to `false`; ignored when tracing is disabled.
+*
+* @category services
+* @since 4.0.0
+*/
+const SpanPropagationEnabled = /*#__PURE__*/ Reference("effect/sql/SpanPropagationEnabled", { defaultValue: () => false });
+/**
+* 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: typeof sql === "string" || isFragment(sql) ? sql : fragment([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$6 = (acquirer, compiler, spanAttributes, transformRows, borrower) => {
+	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, borrower);
+		throw "absurd";
+	}, {
+		unsafe(sql, params) {
+			return makeUnsafe$1([literal(sql, params)], acquirer, compiler, spanAttributes, transformRows, borrower);
+		},
+		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, borrower) => {
+	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$1(segments, acquirer, compiler, spanAttributes, transformRows, borrower);
+};
+/**
+* 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 constructors
+* @since 4.0.0
+*/
+const makeCompiler = (options) => {
+	const self = Object.create(CompilerProto);
+	self.options = options;
+	self.dialect = options.dialect;
+	self.disableTransforms = false;
+	self.statementCache = /* @__PURE__ */ new WeakMap();
+	self.statementCacheNoTransform = /* @__PURE__ */ new WeakMap();
+	return self;
+};
+const CompilerProto = {
+	compile(statement, withoutTransform = false, placeholderOverride) {
+		const opts = this.options;
+		withoutTransform = withoutTransform || this.disableTransforms;
+		const cache = withoutTransform ? this.statementCacheNoTransform : this.statementCache;
+		const cached = cache.get(statement);
+		if (cached !== void 0 && placeholderOverride === void 0) return cached;
+		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];
+								const primitive = extractPrimitive(value, opts.onCustom, placeholderNoIncrement, withoutTransform);
+								row[j] = primitive;
+								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;
+		cache.set(statement, result);
+		return 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 constructors
+* @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$1 = (segments, acquirer, compiler, spanAttributes, transformRows, borrower) => {
+	const self = Object.create(StatementProto);
+	self.segments = segments;
+	self.acquirer = acquirer;
+	self.compiler = compiler;
+	self.spanAttributes = spanAttributes;
+	self.transformRows = transformRows;
+	self.borrower = borrower;
+	return self;
+};
+const StatementProto = {
+	[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, fiber) => {
+			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);
+			const execute = this.borrower === void 0 ? scoped(flatMap(this.acquirer, (_) => f(_, sql, params))) : this.borrower((connection) => f(connection, sql, params));
+			return fiber.cache.tracerEnabled && fiber.getRef(SpanPropagationEnabled) ? provideService(execute, ParentSpan, span) : execute;
+		});
+	},
+	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, fiber) => {
+			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);
+			const acquire = map(self.acquirer, (_) => _.executeStream(sql, params, self.transformRows));
+			return fiber.cache.tracerEnabled && fiber.getRef(SpanPropagationEnabled) ? succeed(provideService$1(unwrap(acquire), ParentSpan, span)) : acquire;
+		})));
+	},
+	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));
+	},
+	.../*#__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));
+		}
+	}),
+	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, fiber);
+	return flatMap(transform(self, make$6(self.acquirer, self.compiler, self.spanAttributes, self.transformRows, self.borrower), fiber, span), (statement) => f(statement, fiber));
+});
+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-rc.115/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$5 = "~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;
+let transactionSemaphoreIdCounter = 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$5 = /*#__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 control = options.prepareTransactionControls === true ? (conn, sql) => conn.execute(sql, [], void 0) : (conn, sql) => conn.executeUnprepared(sql, [], void 0);
+	const withTransaction = makeWithTransaction({
+		transactionService,
+		spanAttributes: options.spanAttributes,
+		acquireConnection: flatMap(make$8(), (scope) => map(provide(transactionAcquirer, scope), (conn) => [scope, conn])),
+		begin: (conn) => control(conn, beginTransaction),
+		savepoint: (conn, id) => control(conn, savepoint(`effect_sql_${id}`)),
+		commit: (conn) => control(conn, commit),
+		rollback: (conn) => control(conn, rollback),
+		rollbackSavepoint: (conn, id) => control(conn, rollbackSavepoint(`effect_sql_${id}`))
+	});
+	const reactivity = yield* Reactivity;
+	const borrower = options.borrower === void 0 ? void 0 : (f) => flatMap(serviceOption(transactionService), match({
+		onNone: () => options.borrower(f),
+		onSome: ([conn]) => f(conn)
+	}));
+	const client = Object.assign(make$6(getConnection, options.compiler, options.spanAttributes, options.transformRows, borrower), {
+		[TypeId$5]: TypeId$5,
+		safe: void 0,
+		withTransaction,
+		transactionService,
+		reserve: transactionAcquirer,
+		withoutTransforms() {
+			if (options.transformRows === void 0) return this;
+			const statement = make$6(getConnection, options.compiler.withoutTransform, options.spanAttributes, void 0, borrower);
+			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) => {
+	const transactionSemaphore = Service(`effect/sql/SqlClient/TransactionSemaphore/${transactionSemaphoreIdCounter++}`);
+	return (effect) => 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;
+		const transaction = flatMap(conn, ([scope, conn]) => (id === 0 ? options.begin(conn) : options.savepoint(conn, id)).pipe(flatMap(() => onExitPrimitive(provideContext(restore(effect), services.pipe(add(options.transactionService, [conn, id]), add(transactionSemaphore, makeUnsafe$3(1)), add(ParentSpan, span))), (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_$1;
+				}
+			} else {
+				span.event("db.transaction.rollback", clock.currentTimeNanosUnsafe());
+				effect = orDie(id > 0 ? options.rollbackSavepoint(conn, id) : options.rollback(conn));
+			}
+			return flatMap(effect, () => exit);
+		}, true)), scope ? (eff) => onExitPrimitive(eff, (exit) => close(scope, exit), true) : identity));
+		return id === 0 ? transaction : getUnsafe(services, transactionSemaphore).withPermit(transaction);
+	})));
+};
+/**
+* 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 services
+* @since 4.0.0
+*/
+const SafeIntegers = /*#__PURE__*/ Reference("effect/sql/SqlClient/SafeIntegers", { defaultValue: () => false });
+//#endregion
+//#region node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Cache.js
+/**
+* Caches values loaded by an Effect lookup function.
+*
+* A cache stores successful and failed lookup results, shares an in-progress
+* lookup when multiple callers request the same missing key, and limits entries
+* by capacity and optional time-to-live rules. This module includes helpers for
+* reading, setting, refreshing, invalidating, and inspecting cache contents.
+*
+* @since 4.0.0
+*/
+const TypeId$4 = "~effect/Cache";
+/**
+* Creates a cache with dynamic time-to-live based on the result and key.
+*
+* **When to use**
+*
+* Use when you need different cache entry lifetimes based on the lookup result
+* or key characteristics.
+*
+* **Details**
+*
+* The timeToLive function receives both the exit result and the key, allowing
+* for flexible TTL policies based on success/failure state and key characteristics.
+*
+* **Example** (Configuring dynamic time to live)
+*
+* ```ts import.meta.vitest
+* import { Cache, Effect, Exit } from "effect"
+*
+* // Cache with TTL based on computed value
+* const program = Effect.gen(function*() {
+*   const cache = yield* Cache.makeWith(
+*     (id: number) => Effect.succeed({ id, active: id % 2 === 0 }),
+*     {
+*       capacity: 1000,
+*       timeToLive(exit) {
+*         if (Exit.isSuccess(exit)) {
+*           const user = exit.value
+*           return user.active ? "1 hour" : "5 minutes"
+*         }
+*         return "30 seconds"
+*       }
+*     }
+*   )
+*
+*   return cache.capacity
+* })
+*
+* const actual = await Effect.runPromise(program)
+* actual // => 1000
+* ```
+*
+* @see {@link make} for a simpler cache constructor with a fixed time-to-live for all entries
+* @category constructors
+* @since 2.0.0
+*/
+const makeWith = (lookup, options) => contextWith$1((context) => {
+	const self = Object.create(Proto$1);
+	self.lookup = (key) => updateContext(lookup(key), (input) => merge(context, input));
+	self.map = make$12();
+	self.capacity = options.capacity;
+	self.timeToLive = options.timeToLive ? (exit, key) => fromInputUnsafe(options.timeToLive(exit, key)) : defaultTimeToLive;
+	return succeed$1(self);
+});
+/**
+* Creates a cache with a fixed time-to-live for all entries.
+*
+* **Details**
+*
+* This is the basic cache constructor where all entries share the same TTL.
+* The lookup function will be called when a key is not found or has expired.
+*
+* **Example** (Creating a basic cache)
+*
+* ```ts import.meta.vitest
+* import { Cache, Effect } from "effect"
+*
+* // Basic cache with string keys
+* const program = Effect.gen(function*() {
+*   const cache = yield* Cache.make<string, number>({
+*     capacity: 100,
+*     lookup: (key) => Effect.succeed(key.length)
+*   })
+*
+*   const result1 = yield* Cache.get(cache, "hello")
+*   const result2 = yield* Cache.get(cache, "world")
+*   return { result1, result2 }
+* })
+*
+* const actual = await Effect.runPromise(program)
+* actual // => { result1: 5, result2: 5 }
+* ```
+*
+* **Example** (Creating a cache with TTL)
+*
+* ```ts import.meta.vitest
+* import { Cache, Effect } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const users = new Map([
+*     [123, { name: "Ada", email: "ada@example.com" }],
+*     [456, { name: "Grace", email: "grace@example.com" }]
+*   ])
+*
+*   const cache = yield* Cache.make<
+*     number,
+*     { name: string; email: string },
+*     string
+*   >({
+*     capacity: 500,
+*     lookup: (userId) =>
+*       Effect.suspend(() => {
+*         const user = users.get(userId)
+*         return user === undefined
+*           ? Effect.fail(`User ${userId} not found`)
+*           : Effect.succeed(user)
+*       }),
+*     timeToLive: "15 minutes"
+*   })
+*
+*   const user1 = yield* Cache.get(cache, 123)
+*   const user2 = yield* Cache.get(cache, 123)
+*   return [user1, user2, user1 === user2] as const
+* })
+*
+* const actual = await Effect.runPromise(program)
+* actual // => [{ name: "Ada", email: "ada@example.com" }, { name: "Ada", email: "ada@example.com" }, true]
+* ```
+*
+* @category constructors
+* @since 2.0.0
+*/
+const make$4 = (options) => makeWith(options.lookup, {
+	...options,
+	timeToLive: options.timeToLive !== void 0 ? () => options.timeToLive : defaultTimeToLive
+});
+const Proto$1 = {
+	...PipeInspectableProto,
+	[TypeId$4]: TypeId$4,
+	toJSON() {
+		return {
+			_id: "Cache",
+			capacity: this.capacity,
+			map: this.map
+		};
+	}
+};
+const defaultTimeToLive = (_, _key) => infinity;
+/**
+* Retrieves the value for a key, invoking the lookup function on a cache miss
+* or expired entry.
+*
+* **Details**
+*
+* Concurrent `get` calls for the same missing key share the same pending
+* lookup. The cache stores the lookup `Exit`, so failed lookups are cached and
+* will fail again until the entry expires, is invalidated, or is refreshed.
+*
+* **Example** (Getting cached values)
+*
+* ```ts import.meta.vitest
+* import { Cache, Effect } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const cache = yield* Cache.make({
+*     capacity: 10,
+*     lookup: (key: string) => Effect.succeed(key.length)
+*   })
+*
+*   // Cache miss - triggers lookup function
+*   const result1 = yield* Cache.get(cache, "hello")
+*
+*   // Cache hit - returns cached value without lookup
+*   const result2 = yield* Cache.get(cache, "hello")
+*
+*   return { result1, result2 }
+* })
+*
+* const actual = await Effect.runPromise(program)
+* actual // => { result1: 5, result2: 5 }
+* ```
+*
+* **Example** (Handling lookup failures)
+*
+* ```ts import.meta.vitest
+* import { Cache, Effect, Exit } from "effect"
+*
+* // Error handling when lookup fails
+* const program = Effect.gen(function*() {
+*   const cache = yield* Cache.make<string, number, string>({
+*     capacity: 10,
+*     lookup: (key: string) =>
+*       key === "error"
+*         ? Effect.fail("Lookup failed")
+*         : Effect.succeed(key.length)
+*   })
+*
+*   // Successful lookup
+*   const success = yield* Cache.get(cache, "hello")
+*
+*   // Failed lookup - returns error
+*   const failure = yield* Effect.exit(Cache.get(cache, "error"))
+*   return [success, failure] as const
+* })
+*
+* const actual = await Effect.runPromise(program)
+* actual // => [5, Exit.fail("Lookup failed")]
+* ```
+*
+* **Example** (Sharing concurrent lookups)
+*
+* ```ts import.meta.vitest
+* import { Cache, Effect } from "effect"
+*
+* // Concurrent access - multiple gets of same key only invoke lookup once
+* const program = Effect.gen(function*() {
+*   let lookupCount = 0
+*   const cache = yield* Cache.make({
+*     capacity: 10,
+*     lookup: (key: string) =>
+*       Effect.sync(() => {
+*         lookupCount++
+*         return key.length
+*       })
+*   })
+*
+*   // Multiple concurrent gets
+*   const results = yield* Effect.all([
+*     Cache.get(cache, "hello"),
+*     Cache.get(cache, "hello"),
+*     Cache.get(cache, "hello")
+*   ], { concurrency: "unbounded" })
+*
+*   return { results, lookupCount }
+* })
+*
+* const actual = await Effect.runPromise(program)
+* actual // => { results: [5, 5, 5], lookupCount: 1 }
+* ```
+*
+* @category combinators
+* @since 4.0.0
+*/
+const get = /*#__PURE__*/ dual(2, (self, key) => withFiber$1((fiber) => {
+	const oentry = get$2(self.map, key);
+	if (isSome(oentry) && !hasExpired(oentry.value, fiber)) {
+		remove(self.map, key);
+		set(self.map, key, oentry.value);
+		return oentry.value.await();
+	}
+	const entry = new EntryImpl(fiber, self.lookup(key));
+	entry.fiber.addObserver((exit) => {
+		if (exitHasInterrupts(exit)) {
+			const current = get$2(self.map, key);
+			if (isSome(current) && current.value === entry) remove(self.map, key);
+			return;
+		}
+		const ttl = self.timeToLive(exit, key);
+		if (isFinite(ttl)) entry.expiresAt = fiber.getRef(ClockRef).currentTimeMillisUnsafe() + toMillis(ttl);
+		else if (isZero(ttl)) remove(self.map, key);
+	});
+	const exit = entry.fiber.pollUnsafe();
+	if (exit === void 0 || !exitHasInterrupts(exit)) set(self.map, key, entry);
+	if (Number.isFinite(self.capacity)) checkCapacity(self);
+	return entry.await();
+}));
+var EntryImpl = class {
+	expiresAt;
+	awaiters;
+	fiber;
+	constructor(parent, valueEffect) {
+		this.fiber = forkUnsafe(parent, valueEffect, true, true);
+		this.awaiters = 0;
+		this.expiresAt = void 0;
+	}
+	await() {
+		const exit = this.fiber.pollUnsafe();
+		if (exit) return exit;
+		this.awaiters++;
+		return onExit$1(fiberJoin(this.fiber), () => {
+			this.awaiters--;
+			if (this.awaiters > 0 || this.fiber.pollUnsafe()) return void_$2;
+			return fiberInterrupt(this.fiber);
+		});
+	}
+};
+const hasExpired = (entry, fiber) => {
+	if (entry.expiresAt === void 0) return false;
+	return fiber.getRef(ClockRef).currentTimeMillisUnsafe() >= entry.expiresAt;
+};
+const checkCapacity = (self) => {
+	let diff = size(self.map) - self.capacity;
+	if (diff <= 0) return;
+	for (const [key] of self.map) {
+		remove(self.map, key);
+		diff--;
+		if (diff === 0) return;
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/schema/VariantSchema.js
+/**
+* Runtime type identifier attached to variant schema structs.
+*
+* @category type IDs
+* @since 4.0.0
+*/
+const TypeId$3 = "~effect/schema/VariantSchema";
+const cacheSymbol = /*#__PURE__*/ Symbol.for(`${TypeId$3}/cache`);
+const defaultCacheSymbol = /*#__PURE__*/ Symbol.for(`${TypeId$3}/defaultCache`);
+/**
+* Returns `true` when a value is a variant schema struct.
+*
+* @category guards
+* @since 4.0.0
+*/
+const isStruct = (u) => hasProperty(u, TypeId$3);
+const FieldTypeId = "~effect/schema/VariantSchema/Field";
+/**
+* Returns `true` when a value is a variant schema field.
+*
+* @category guards
+* @since 4.0.0
+*/
+const isField = (u) => hasProperty(u, FieldTypeId);
+const extract$1 = /*#__PURE__*/ dual((args) => isStruct(args[0]), (self, variant, options) => {
+	if (options?.isDefault === true && isSchema(self)) return self;
+	const cache = options?.isDefault === true ? self[defaultCacheSymbol] ?? (self[defaultCacheSymbol] = Object.create(null)) : self[cacheSymbol] ?? (self[cacheSymbol] = Object.create(null));
+	if (Object.hasOwn(cache, variant)) return cache[variant];
+	const fields = {};
+	for (const key of Object.keys(self[TypeId$3])) {
+		const value = self[TypeId$3][key];
+		if (value === void 0) continue;
+		if ("~effect/schema/VariantSchema" in value) {
+			if (options?.isDefault === true && isSchema(value)) assignProperty(fields, key, value);
+			else assignProperty(fields, key, extract$1(value, variant));
+		} else if (FieldTypeId in value) {
+			if (Object.hasOwn(value.schemas, variant)) {
+				const schema = value.schemas[variant];
+				if (schema !== void 0) assignProperty(fields, key, schema);
+			}
+		} else assignProperty(fields, key, value);
+	}
+	const schema = Struct$2(fields);
+	cache[variant] = schema;
+	return schema;
+});
+/**
+* Creates a variant schema toolkit for a fixed set of variant names and a default
+* variant.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const make$3 = (options) => {
+	function Class(identifier) {
+		return function(fields, annotations) {
+			const variantStruct = Struct$1(fields);
+			const schema = extract$1(variantStruct, options.defaultVariant, { isDefault: true });
+			const SClass = Class$1;
+			class Base extends SClass(identifier)(schema.fields, annotations) {
+				static [TypeId$3] = fields;
+			}
+			for (const variant of options.variants) Object.defineProperty(Base, variant, { value: extract$1(variantStruct, variant).annotate({
+				id: `${identifier}.${variant}`,
+				title: `${identifier}.${variant}`
+			}) });
+			return Base;
+		};
+	}
+	function FieldOnly(keys) {
+		return function(schema) {
+			const obj = {};
+			for (const key of keys) assignProperty(obj, key, schema);
+			return Field$1(obj);
+		};
+	}
+	function FieldExcept(keys) {
+		return function(schema) {
+			const obj = {};
+			for (const variant of options.variants) if (!keys.includes(variant)) assignProperty(obj, variant, schema);
+			return Field$1(obj);
+		};
+	}
+	function UnionVariants(members) {
+		return Union$1(members, options.defaultVariant, options.variants);
+	}
+	const fieldEvolve = dual(2, (self, f) => {
+		const field = isField(self) ? self : Field$1(Object.fromEntries(options.variants.map((variant) => [variant, self])));
+		return Field$1(evolve(field.schemas, f));
+	});
+	const extractVariants = dual(2, (self, variant) => extract$1(self, variant, { isDefault: variant === options.defaultVariant }));
+	return {
+		Struct: Struct$1,
+		Field: Field$1,
+		FieldOnly,
+		FieldExcept,
+		Class,
+		Union: UnionVariants,
+		fieldEvolve,
+		extract: extractVariants
+	};
+};
+const StructProto = { pipe() {
+	return pipeArguments(this, arguments);
+} };
+const Struct$1 = (fields) => {
+	const self = Object.create(StructProto);
+	self[TypeId$3] = fields;
+	return self;
+};
+const FieldProto = {
+	[FieldTypeId]: FieldTypeId,
+	pipe() {
+		return pipeArguments(this, arguments);
+	}
+};
+const Field$1 = (schemas) => {
+	const self = Object.create(FieldProto);
+	self.schemas = schemas;
+	return self;
+};
+const Union$1 = (members, defaultVariant, variants) => {
+	const VariantUnion = Union$2(members.map((member) => isSchema(member) ? member : extract$1(member, defaultVariant, { isDefault: true })));
+	for (const variant of variants) Object.defineProperty(VariantUnion, variant, { value: Union$2(members.map((member) => extract$1(member, variant))) });
+	return VariantUnion;
+};
+//#endregion
+//#region node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/schema/Model.js
+const { Class, Field, FieldExcept, FieldOnly, Struct, Union, extract, fieldEvolve } = /*#__PURE__*/ make$3({
+	variants: [
+		"select",
+		"insert",
+		"update",
+		"json",
+		"jsonCreate",
+		"jsonUpdate"
+	],
+	defaultVariant: "select"
+});
+//#endregion
+//#region node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/sql/SqlError.js
+/**
+* Defines structured failures for SQL clients and driver integrations.
+*
+* `SqlError` wraps the different reasons a SQL operation can fail, such as
+* connection, authentication, authorization, syntax, constraint, or transaction
+* problems. Each reason keeps the original cause, optional message and
+* operation metadata, and whether retrying may succeed. This module also
+* includes schemas, guards, a SQLite error classifier, and the
+* `ResultLengthMismatch` error used by ordered batched SQL resolvers.
+*
+* @since 4.0.0
+*/
+const TypeId$2 = "~effect/sql/SqlError";
+const ReasonTypeId = "~effect/sql/SqlError/Reason";
+const ReasonFields = {
+	cause: /*#__PURE__*/ Defect(),
+	message: /*#__PURE__*/ optional(String$1),
+	operation: /*#__PURE__*/ optional(String$1)
+};
+/**
+* SQL error reason for connection or open failures; marked retryable.
+*
+* @category errors
+* @since 4.0.0
+*/
+var ConnectionError = class extends (/*#__PURE__*/ TaggedError("effect/sql/SqlError/ConnectionError")("ConnectionError", ReasonFields)) {
+	/**
+	* Marks this value as a structured SQL error reason for runtime guards.
+	*
+	* @since 4.0.0
+	*/
+	[ReasonTypeId] = ReasonTypeId;
+	/**
+	* Indicates whether retrying the failed SQL operation may succeed.
+	*
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return true;
+	}
+};
+/**
+* SQL error reason for authentication failures such as invalid credentials; not
+* marked retryable.
+*
+* @category errors
+* @since 4.0.0
+*/
+var AuthenticationError = class extends (/*#__PURE__*/ TaggedError("effect/sql/SqlError/AuthenticationError")("AuthenticationError", ReasonFields)) {
+	/**
+	* Marks this value as a structured SQL error reason for runtime guards.
+	*
+	* @since 4.0.0
+	*/
+	[ReasonTypeId] = ReasonTypeId;
+	/**
+	* Indicates whether retrying the failed SQL operation may succeed.
+	*
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return false;
+	}
+};
+/**
+* SQL error reason for authorization or permission failures; not marked
+* retryable.
+*
+* @category errors
+* @since 4.0.0
+*/
+var AuthorizationError = class extends (/*#__PURE__*/ TaggedError("effect/sql/SqlError/AuthorizationError")("AuthorizationError", ReasonFields)) {
+	/**
+	* Marks this value as a structured SQL error reason for runtime guards.
+	*
+	* @since 4.0.0
+	*/
+	[ReasonTypeId] = ReasonTypeId;
+	/**
+	* Indicates whether retrying the failed SQL operation may succeed.
+	*
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return false;
+	}
+};
+/**
+* SQL error reason for invalid SQL syntax; not marked retryable.
+*
+* @category errors
+* @since 4.0.0
+*/
+var SqlSyntaxError = class extends (/*#__PURE__*/ TaggedError("effect/sql/SqlError/SqlSyntaxError")("SqlSyntaxError", ReasonFields)) {
+	/**
+	* Marks this value as a structured SQL error reason for runtime guards.
+	*
+	* @since 4.0.0
+	*/
+	[ReasonTypeId] = ReasonTypeId;
+	/**
+	* Indicates whether retrying the failed SQL operation may succeed.
+	*
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return false;
+	}
+};
+const UniqueViolationFields = {
+	...ReasonFields,
+	constraint: String$1
+};
+/**
+* SQL error reason for a unique constraint violation, including the violated
+* constraint identifier; not marked retryable.
+*
+* @category errors
+* @since 4.0.0
+*/
+var UniqueViolation = class extends (/*#__PURE__*/ TaggedError("effect/sql/SqlError/UniqueViolation")("UniqueViolation", UniqueViolationFields)) {
+	/**
+	* Marks this value as a structured SQL error reason for runtime guards.
+	*
+	* @since 4.0.0
+	*/
+	[ReasonTypeId] = ReasonTypeId;
+	/**
+	* Indicates whether retrying the failed SQL operation may succeed.
+	*
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return false;
+	}
+};
+/**
+* SQL error reason for a non-unique constraint violation; not marked retryable.
+*
+* @category errors
+* @since 4.0.0
+*/
+var ConstraintError = class extends (/*#__PURE__*/ TaggedError("effect/sql/SqlError/ConstraintError")("ConstraintError", ReasonFields)) {
+	/**
+	* Marks this value as a structured SQL error reason for runtime guards.
+	*
+	* @since 4.0.0
+	*/
+	[ReasonTypeId] = ReasonTypeId;
+	/**
+	* Indicates whether retrying the failed SQL operation may succeed.
+	*
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return false;
+	}
+};
+/**
+* SQL error reason for a database deadlock; marked retryable.
+*
+* @category errors
+* @since 4.0.0
+*/
+var DeadlockError = class extends (/*#__PURE__*/ TaggedError("effect/sql/SqlError/DeadlockError")("DeadlockError", ReasonFields)) {
+	/**
+	* Marks this value as a structured SQL error reason for runtime guards.
+	*
+	* @since 4.0.0
+	*/
+	[ReasonTypeId] = ReasonTypeId;
+	/**
+	* Indicates whether retrying the failed SQL operation may succeed.
+	*
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return true;
+	}
+};
+/**
+* SQL error reason for a transaction serialization or isolation conflict;
+* marked retryable.
+*
+* @category errors
+* @since 4.0.0
+*/
+var SerializationError = class extends (/*#__PURE__*/ TaggedError("effect/sql/SqlError/SerializationError")("SerializationError", ReasonFields)) {
+	/**
+	* Marks this value as a structured SQL error reason for runtime guards.
+	*
+	* @since 4.0.0
+	*/
+	[ReasonTypeId] = ReasonTypeId;
+	/**
+	* Indicates whether retrying the failed SQL operation may succeed.
+	*
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return true;
+	}
+};
+/**
+* SQL error reason for timing out while waiting on a database lock; marked
+* retryable.
+*
+* @category errors
+* @since 4.0.0
+*/
+var LockTimeoutError = class extends (/*#__PURE__*/ TaggedError("effect/sql/SqlError/LockTimeoutError")("LockTimeoutError", ReasonFields)) {
+	/**
+	* Marks this value as a structured SQL error reason for runtime guards.
+	*
+	* @since 4.0.0
+	*/
+	[ReasonTypeId] = ReasonTypeId;
+	/**
+	* Indicates whether retrying the failed SQL operation may succeed.
+	*
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return true;
+	}
+};
+/**
+* SQL error reason for a statement or query timeout; marked retryable.
+*
+* @category errors
+* @since 4.0.0
+*/
+var StatementTimeoutError = class extends (/*#__PURE__*/ TaggedError("effect/sql/SqlError/StatementTimeoutError")("StatementTimeoutError", ReasonFields)) {
+	/**
+	* Marks this value as a structured SQL error reason for runtime guards.
+	*
+	* @since 4.0.0
+	*/
+	[ReasonTypeId] = ReasonTypeId;
+	/**
+	* Indicates whether retrying the failed SQL operation may succeed.
+	*
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return true;
+	}
+};
+/**
+* SQL error reason for an unclassified database failure; not marked retryable.
+*
+* @category errors
+* @since 4.0.0
+*/
+var UnknownError = class extends (/*#__PURE__*/ TaggedError("effect/sql/SqlError/UnknownError")("UnknownError", ReasonFields)) {
+	/**
+	* Marks this value as a structured SQL error reason for runtime guards.
+	*
+	* @since 4.0.0
+	*/
+	[ReasonTypeId] = ReasonTypeId;
+	/**
+	* Indicates whether retrying the failed SQL operation may succeed.
+	*
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return false;
+	}
+};
+/**
+* Schema for encoding and decoding SQL error reasons.
+*
+* @category schemas
+* @since 4.0.0
+*/
+const SqlErrorReason = /*#__PURE__*/ Union$2([
+	ConnectionError,
+	AuthenticationError,
+	AuthorizationError,
+	SqlSyntaxError,
+	UniqueViolation,
+	ConstraintError,
+	DeadlockError,
+	SerializationError,
+	LockTimeoutError,
+	StatementTimeoutError,
+	UnknownError
+]);
+/**
+* Error wrapper for SQL failures whose `message`, `cause`, and `isRetryable`
+* values are derived from its `SqlErrorReason`.
+*
+* @category errors
+* @since 4.0.0
+*/
+var SqlError = class extends (/*#__PURE__*/ TaggedError("effect/sql/SqlError")("SqlError", { reason: SqlErrorReason })) {
+	/**
+	* Marks this value as the top-level SQL error wrapper for runtime guards.
+	*
+	* @since 4.0.0
+	*/
+	[TypeId$2] = TypeId$2;
+	/**
+	* Exposes the structured SQL reason as the JavaScript error cause.
+	*
+	* @since 4.0.0
+	*/
+	cause = this.reason;
+	/**
+	* Uses the reason message when present, otherwise falls back to the reason tag.
+	*
+	* @since 4.0.0
+	*/
+	get message() {
+		return this.reason.message || this.reason._tag;
+	}
+	/**
+	* Delegates retryability to the underlying SQL error reason.
+	*
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return this.reason.isRetryable;
+	}
+};
+const sqliteCodeFromCause = (cause) => {
+	if (!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 (!hasProperty(cause, "errno")) return;
+	const errno = cause.errno;
+	return typeof errno === "number" ? errno : void 0;
+};
+const matchesSqliteNumericCode = (cause, expected) => {
+	if (sqliteCodeFromCause(cause) === expected) return true;
+	if (!hasProperty(cause, "errno")) return false;
+	return cause.errno === expected;
+};
+const matchesSqliteCode = (code, expected) => code === expected || code.startsWith(expected + "_");
+const UNKNOWN_CONSTRAINT = "unknown";
+const SQLITE_CONSTRAINT_UNIQUE = "SQLITE_CONSTRAINT_UNIQUE";
+const SQLITE_CONSTRAINT_UNIQUE_CODE = 2067;
+const normalizeConstraintIdentifier = (identifier) => {
+	if (typeof identifier !== "string") return UNKNOWN_CONSTRAINT;
+	const trimmed = identifier.trim();
+	return trimmed.length === 0 ? UNKNOWN_CONSTRAINT : trimmed;
+};
+const sqliteUniqueConstraintFromCause = (cause) => {
+	if (hasProperty(cause, "constraint")) return normalizeConstraintIdentifier(cause.constraint);
+	if (!hasProperty(cause, "message")) return UNKNOWN_CONSTRAINT;
+	const message = cause.message;
+	if (typeof message !== "string") return UNKNOWN_CONSTRAINT;
+	const index = message.indexOf("UNIQUE constraint failed:");
+	return index === -1 ? UNKNOWN_CONSTRAINT : normalizeConstraintIdentifier(message.slice(index + 25));
+};
+/**
+* Classifies a native SQLite error cause into a `SqlErrorReason` using its
+* `code` or `errno`, with optional message and operation metadata.
+*
+* @category converting
+* @since 4.0.0
+*/
+const classifySqliteError = (cause, { message, operation } = {}) => {
+	const props = {
+		cause,
+		message,
+		operation
+	};
+	const code = sqliteCodeFromCause(cause);
+	const numericCode = sqliteNumericCodeFromCause(cause);
+	if (code === SQLITE_CONSTRAINT_UNIQUE || matchesSqliteNumericCode(cause, SQLITE_CONSTRAINT_UNIQUE_CODE)) return new UniqueViolation({
+		...props,
+		constraint: sqliteUniqueConstraintFromCause(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);
+	}
+	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);
+};
+/**
+* Error raised when an ordered batched SQL resolver receives a different number
+* of result rows than requests.
+*
+* @category errors
+* @since 4.0.0
+*/
+var ResultLengthMismatch = class extends (/*#__PURE__*/ TaggedError("effect/sql/ResultLengthMismatch")("ResultLengthMismatch", {
+	expected: Natural,
+	actual: Natural
+})) {
+	/**
+	* Explains the mismatch between expected and actual batched SQL result counts.
+	*
+	* @since 4.0.0
+	*/
+	get message() {
+		return `Expected ${this.expected} results but got ${this.actual}`;
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/sql/SqlResolver.js
+/**
+* Schema-aware `RequestResolver` helpers for SQL-backed data loading.
+*
+* This module represents each lookup or mutation as a `SqlRequest` and batches
+* concurrent requests into SQL operations. Request payloads are encoded with the
+* request schema before `execute` is called, and returned rows are decoded with
+* the result schema before requests are completed. It provides ordered,
+* grouped, id-based, and side-effect-only resolver constructors, and keeps
+* batches separated by the active SQL transaction connection.
+*
+* @since 4.0.0
+*/
+const SqlRequestProto = {
+	...Class$2.prototype,
+	[symbol](that) {
+		return equals(this.payload, that.payload);
+	},
+	[symbol$1]() {
+		return hash(this.payload);
+	}
+};
+/**
+* Runs a payload as a `SqlRequest` through a request resolver, either directly
+* with a payload and resolver or curried by resolver.
+*
+* @category running
+* @since 4.0.0
+*/
+const request = function() {
+	if (arguments.length === 1) {
+		const resolver = arguments[0];
+		return (payload) => request$1(SqlRequest(payload), resolver);
+	}
+	return request$1(SqlRequest(arguments[0]), arguments[1]);
+};
+/**
+* Constructs a `SqlRequest` from a payload. Equality and hashing are based on
+* the payload so equal requests can be batched and deduplicated.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const SqlRequest = (payload) => {
+	const self = Object.create(SqlRequestProto);
+	self.payload = payload;
+	return self;
+};
+/**
+* Creates a resolver for a SQL query with a request schema and a result schema.
+*
+* **Details**
+*
+* The request schema is used to validate the input of the query, and the result
+* schema is used to validate the output of the query. Results are mapped to the
+* requests in order, so the length of the results must match the length of the
+* requests.
+*
+* @category resolvers
+* @since 4.0.0
+*/
+const ordered = (options) => {
+	const decodeArray = decodeUnknownEffect(ArraySchema(options.Result));
+	return makeGrouped({
+		key: transactionKey,
+		resolver: fnUntraced(function* (entries) {
+			const [inputs, encodedEntries] = yield* partitionRequests(entries, options.Request);
+			if (!isArrayNonEmpty(inputs)) return;
+			const results = yield* options.execute(inputs).pipe(provideContext(entries[0].context));
+			if (results.length !== inputs.length) return yield* new ResultLengthMismatch({
+				expected: inputs.length,
+				actual: results.length
+			});
+			const decodedResults = yield* decodeArray(results).pipe(provideContext(entries[0].context));
+			for (let i = 0; i < encodedEntries.length; i++) encodedEntries[i].completeUnsafe(succeed$2(decodedResults[i]));
+		})
+	});
+};
+/**
+* Creates a batched resolver that fetches rows for encoded ids, decodes
+* results, completes each matching request using `ResultId`, and fails missing
+* ids with `NoSuchElementError`.
+*
+* @category resolvers
+* @since 4.0.0
+*/
+const findById = (options) => {
+	const decodeResults = decodeUnknownEffect(ArraySchema(options.Result));
+	return makeGrouped({
+		key: transactionKey,
+		resolver: fnUntraced(function* (entries) {
+			const [inputs, idMap] = yield* partitionRequestsById(entries, options.Id);
+			if (!isArrayNonEmpty(inputs)) return;
+			const results = yield* options.execute(inputs).pipe(provideContext(entries[0].context));
+			const decodedResults = yield* decodeResults(results).pipe(provideContext(entries[0].context));
+			for (let i = 0; i < decodedResults.length; i++) {
+				const result = decodedResults[i];
+				const id = options.ResultId(result, results[i]);
+				const request = get$2(idMap, id);
+				if (request._tag === "None") continue;
+				remove(idMap, id);
+				request.value.completeUnsafe(succeed$2(result));
+			}
+			if (isEmpty(idMap)) return;
+			forEach$1(idMap, (request) => {
+				request.completeUnsafe(constNoSuchElement);
+			});
+		})
+	});
+};
+const void_ = (options) => makeGrouped({
+	key: transactionKey,
+	resolver: fnUntraced(function* (entries) {
+		const [inputs] = yield* partitionRequests(entries, options.Request);
+		if (!isArrayNonEmpty(inputs)) return;
+		yield* options.execute(inputs).pipe(provideContext(entries[0].context));
+		for (let i = 0; i < entries.length; i++) entries[i].completeUnsafe(void_$3);
+	})
+});
+const constNoSuchElement = /*#__PURE__*/ fail(/*#__PURE__*/ new NoSuchElementError());
+const partitionRequests = function* (requests, schema) {
+	const len = requests.length;
+	const inputs = empty();
+	const encodedEntries = empty();
+	let entry;
+	const encode = encodeEffect(schema);
+	const handle = matchCauseEager({
+		onFailure(cause) {
+			entry.completeUnsafe(failCause(cause));
+		},
+		onSuccess(value) {
+			inputs.push(value);
+			encodedEntries.push(entry);
+		}
+	});
+	for (let i = 0; i < len; i++) {
+		entry = requests[i];
+		yield provideContext(handle(encode(entry.request.payload)), entry.context);
+	}
+	return [inputs, encodedEntries];
+};
+const partitionRequestsById = function* (requests, schema) {
+	const len = requests.length;
+	const inputs = empty();
+	const byIdMap = empty$1();
+	for (let i = 0; i < len; i++) {
+		const entry = requests[i];
+		const existing = get$2(byIdMap, entry.request.payload);
+		if (isSome(existing)) {
+			const previous = existing.value;
+			set(byIdMap, entry.request.payload, {
+				...previous,
+				completeUnsafe(exit) {
+					previous.completeUnsafe(exit);
+					entry.completeUnsafe(exit);
+				}
+			});
+		} else set(byIdMap, entry.request.payload, entry);
+	}
+	const encode = encodeEffect(schema);
+	for (const [, entry] of byIdMap) yield* provideContext(matchCauseEager(encode(entry.request.payload), {
+		onFailure(cause) {
+			entry.completeUnsafe(failCause(cause));
+		},
+		onSuccess(value) {
+			inputs.push(value);
+		}
+	}), entry.context);
+	return [inputs, byIdMap];
+};
+function transactionKey(entry) {
+	const client = getOrUndefined(entry.context, SqlClient);
+	if (!client) return void 0;
+	const conn = getOrUndefined(entry.context, client.transactionService);
+	if (!conn) return void 0;
+	return byReferenceUnsafe(conn);
+}
+//#endregion
+//#region node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/sql/SqlSchema.js
+/**
+* Builds a query function that encodes the request and decodes all result rows,
+* allowing an empty result set.
+*
+* **When to use**
+*
+* Use when you need to run a query that may return zero or more rows and
+* represent an empty result as an empty array.
+*
+* @see {@link findNonEmpty} for queries where an empty result is a failure
+*
+* @category constructors
+* @since 4.0.0
+*/
+const findAll = (options) => {
+	const encodeRequest = encodeEffect(options.Request);
+	const decode = decodeUnknownEffect(mutable(ArraySchema(options.Result)));
+	return (request) => flatMap(flatMap(encodeRequest(request), options.execute), decode);
+};
+//#endregion
+//#region node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/sql/SqlModel.js
+/**
+* Creates batched request resolvers for a schema model's insert, insert-void,
+* find-by-id, and delete operations, honoring the optional soft-delete column.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const makeResolvers = (Model, options) => gen(function* () {
+	const sql = yield* SqlClient;
+	const idSchema = Model.fields[options.idColumn];
+	const idColumn = options.idColumn;
+	const softDeleteColumn = options.softDeleteColumn;
+	const withSoftDeleteFilter = (where) => softDeleteColumn === void 0 ? where : sql.and([where, sql`${sql(softDeleteColumn)} is null`]);
+	const setSoftDeleted = softDeleteColumn === void 0 ? void 0 : sql`${sql(softDeleteColumn)} = CURRENT_TIMESTAMP`;
+	return {
+		insert: ordered({
+			Request: Model.insert,
+			Result: Model,
+			execute: (request) => sql.onDialectOrElse({
+				mysql: () => forEach(request, (request) => sql`insert into ${sql(options.tableName)} ${sql.insert(request)};
+select * from ${sql(options.tableName)} where ${withSoftDeleteFilter(sql`${sql(idColumn)} = LAST_INSERT_ID()`)};`.unprepared.pipe(map(([, results]) => results[0])), { concurrency: 10 }),
+				orElse: () => sql`insert into ${sql(options.tableName)} ${sql.insert(request).returning("*")}`
+			})
+		}).pipe(withSpan$1(`${options.spanPrefix}.insertResolver`)),
+		insertVoid: void_({
+			Request: Model.insert,
+			execute: (request) => sql`insert into ${sql(options.tableName)} ${sql.insert(request)}`
+		}).pipe(withSpan$1(`${options.spanPrefix}.insertVoidResolver`)),
+		findById: findById({
+			Id: idSchema,
+			Result: Model,
+			ResultId(request) {
+				return request[idColumn];
+			},
+			execute: (ids) => sql`select * from ${sql(options.tableName)} where ${withSoftDeleteFilter(sql.in(idColumn, ids))}`
+		}).pipe(withSpan$1(`${options.spanPrefix}.findByIdResolver`)),
+		delete: void_({
+			Request: idSchema,
+			execute: (ids) => softDeleteColumn === void 0 ? sql`delete from ${sql(options.tableName)} where ${sql.in(idColumn, ids)}` : sql`update ${sql(options.tableName)} set ${setSoftDeleted} where ${withSoftDeleteFilter(sql.in(idColumn, ids))}`
+		}).pipe(withSpan$1(`${options.spanPrefix}.deleteResolver`))
+	};
+});
+//#endregion
+//#region src/ChunkRepo.ts
+/** @effect-diagnostics schemaNumber:off */
+/**
+* @since 1.0.0
+* @category Models
+*/
+const ChunkId = Number$1.pipe(brand("ChunkRepo/ChunkId"));
+/**
+* @since 1.0.0
+* @category Models
+*/
+const SyncId = String$1.pipe(brand("ChunkRepo/SyncId"));
+/**
+* @since 1.0.0
+* @category Models
+*/
+const Float32ArraySchema = instanceOf(Float32Array);
+/**
+* @since 1.0.0
+* @category Models
+*/
+const Float32ArrayFromArray = ArraySchema(Number$1).pipe(decodeTo(Float32ArraySchema, transform$1({
+	decode: (arr) => new Float32Array(arr),
+	encode: (array) => Array.from(array)
+})));
+/**
+* @since 1.0.0
+* @category Models
+*/
+const Float32ArrayField = Field({
+	insert: Float32ArraySchema,
+	update: Float32ArraySchema,
+	jsonCreate: Float32ArrayFromArray,
+	jsonUpdate: Float32ArrayFromArray
+});
+/**
+* @since 1.0.0
+* @category Models
+*/
+var Chunk = class extends Class("Chunk")({
+	id: ChunkId.pipe(FieldExcept(["insert", "jsonCreate"])),
+	path: String$1,
+	content: String$1,
+	hash: String$1,
+	vector: Float32ArrayField,
+	syncId: SyncId
+}) {};
+/**
+* @since 1.0.0
+* @category Services
+*/
+var ChunkRepo = class extends Service()("clanka/ChunkRepo") {};
+/**
+* @since 1.0.0
+* @category Errors
+*/
+var ChunkRepoError = class extends TaggedError()("ChunkRepoError", { reason: Union$2([SqlError]) }) {
+	cause = this.reason;
+	message = this.reason.message;
+};
+/**
+* @since 1.0.0
+* @category Layers
+*/
+const layer$4 = effect(ChunkRepo, gen(function* () {
+	const sql = yield* SqlClient;
+	const dimensions = yield* Dimensions;
+	yield* gen(function* () {
+		yield* sql`CREATE VIRTUAL TABLE IF NOT EXISTS chunk_vectors USING vec0(
+        vector float[${sql.literal(String(dimensions))}]
+      )`;
+		yield* sql`CREATE TRIGGER IF NOT EXISTS chunks_vector_insert
+        AFTER INSERT ON chunks
+        BEGIN
+          INSERT INTO chunk_vectors(rowid, vector) VALUES (new.id, new.vector);
+        END`;
+		yield* sql`CREATE TRIGGER IF NOT EXISTS chunks_vector_update
+        AFTER UPDATE OF vector ON chunks
+        BEGIN
+          DELETE FROM chunk_vectors WHERE rowid = old.id;
+          INSERT INTO chunk_vectors(rowid, vector) VALUES (new.id, new.vector);
+        END`;
+		yield* sql`CREATE TRIGGER IF NOT EXISTS chunks_vector_delete
+        AFTER DELETE ON chunks
+        BEGIN
+          DELETE FROM chunk_vectors WHERE rowid = old.id;
+        END`;
+		yield* sql`DELETE FROM chunk_vectors
+        WHERE rowid NOT IN (SELECT id FROM chunks)`;
+		yield* sql`INSERT INTO chunk_vectors(rowid, vector)
+        SELECT id, vector FROM chunks
+        WHERE id NOT IN (SELECT rowid FROM chunk_vectors)`;
+	}).pipe(sql.withTransaction);
+	const loaders = yield* makeResolvers(Chunk, {
+		tableName: "chunks",
+		idColumn: "id",
+		spanPrefix: "ChunkRepo"
+	});
+	const search = findAll({
+		Request: Struct$2({
+			vector: Float32ArraySchema,
+			limit: Number$1
+		}),
+		Result: Chunk,
+		execute: ({ vector, limit }) => sql`
+          select chunks.id, chunks.path, chunks.content, chunks.hash, chunks.syncId
+          from chunk_vectors
+          JOIN chunks ON chunks.id = chunk_vectors.rowid
+          WHERE chunk_vectors.vector MATCH ${vector}
+          AND k = CAST(${limit} AS INTEGER)
+          ORDER BY chunk_vectors.distance
+        `
+	});
+	const exists = findById({
+		Id: String$1,
+		Result: Struct$2({
+			id: ChunkId,
+			hash: String$1
+		}),
+		ResultId(result) {
+			return result.hash;
+		},
+		execute: (hashes) => sql`select id, hash from chunks where ${sql.in("hash", hashes)}`
+	}).pipe(setDelay(5));
+	const insertResolver = loaders.insert.pipe(setDelay(5));
+	const findByIdResolver = loaders.findById.pipe(setDelay(5));
+	return ChunkRepo.of({
+		insert: (insert) => request(insert, insertResolver).pipe(catchTags({
+			SchemaError: die,
+			ResultLengthMismatch: die
+		}, (reason) => fail$1(new ChunkRepoError({ reason })))),
+		findById: (id) => request(id, findByIdResolver).pipe(catchTags({
+			SchemaError: die,
+			SqlError: (reason) => fail$1(new ChunkRepoError({ reason }))
+		})),
+		exists: (hash) => request(hash, exists).pipe(map((result) => result.id), catchNoSuchElement, catchTags({
+			SqlError: (reason) => fail$1(new ChunkRepoError({ reason })),
+			SchemaError: die
+		})),
+		search: fn("ChunkRepo.search")(function* (options) {
+			return yield* search(options).pipe(catchTags({
+				SqlError: (reason) => fail$1(new ChunkRepoError({ reason })),
+				SchemaError: die
+			}));
+		}),
+		quantize: void_$1,
+		setSyncId: (chunkId, syncId) => sql`update chunks set syncId = ${syncId} where id = ${chunkId}`.pipe(mapError((reason) => new ChunkRepoError({ reason }))),
+		deleteByPath: (path) => sql`delete from chunks where path = ${path}`.pipe(mapError((reason) => new ChunkRepoError({ reason }))),
+		deleteForSyncId: (syncId) => sql`delete from chunks where syncId != ${syncId}`.pipe(mapError((reason) => new ChunkRepoError({ reason })))
+	});
+}));
+//#endregion
+//#region src/CodeChunker.ts
+/**
+* @since 1.0.0
+*/
+/**
+* @since 1.0.0
+* @category Services
+*/
+var CodeChunker = class extends Service()("clanka/CodeChunker") {};
+const sourceExtensions = /* @__PURE__ */ new Set([
+	"c",
+	"cc",
+	"cpp",
+	"cs",
+	"css",
+	"cts",
+	"cxx",
+	"go",
+	"gql",
+	"graphql",
+	"h",
+	"hpp",
+	"html",
+	"ini",
+	"java",
+	"js",
+	"jsx",
+	"kt",
+	"kts",
+	"less",
+	"lua",
+	"mjs",
+	"mts",
+	"php",
+	"py",
+	"rb",
+	"rs",
+	"sass",
+	"scala",
+	"scss",
+	"sh",
+	"sql",
+	"svelte",
+	"swift",
+	"ts",
+	"tsx",
+	"vue",
+	"xml",
+	"zsh"
+]);
+const documentationExtensions = /* @__PURE__ */ new Set([
+	"adoc",
+	"asciidoc",
+	"md",
+	"mdx",
+	"rst",
+	"txt"
+]);
+const ignoredDirectories = /* @__PURE__ */ new Set([
+	".git",
+	".next",
+	".nuxt",
+	".svelte-kit",
+	".turbo",
+	"build",
+	"coverage",
+	"dist",
+	"node_modules",
+	"target"
+]);
+const normalizePath$1 = (path) => path.replace(/\\/g, "/");
+const normalizeText = (content) => content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+const meaningfulLinePattern = /[^\s\p{P}]/u;
+const isMeaningfulLine = (line) => meaningfulLinePattern.test(line);
+const languageByExtension = /* @__PURE__ */ new Map([
+	["js", TreeSitterJavaScript],
+	["jsx", TreeSitterJavaScript],
+	["ts", TreeSitterTypeScript.typescript],
+	["tsx", TreeSitterTypeScript.tsx]
+]);
+/**
+* @since 1.0.0
+* @category Predicates
+*/
+const isProbablyMinified = (content) => {
+	const normalized = normalizeText(content);
+	if (normalized.length < 2e3) return false;
+	const lines = normalized.split("\n");
+	if (lines.length <= 2) return true;
+	let longLines = 0;
+	for (const line of lines) if (line.length >= 300) longLines++;
+	return lines.length <= 20 && longLines / lines.length >= .8;
+};
+/**
+* @since 1.0.0
+* @category Predicates
+*/
+const isMeaningfulFile = (path) => {
+	const parts = normalizePath$1(path).toLowerCase().split("/");
+	const fileName = parts.at(-1);
+	if (fileName === void 0 || fileName.length === 0) return false;
+	if (parts.some((part) => ignoredDirectories.has(part))) return false;
+	if (/\.min\.(?:css|js)$/i.test(fileName)) return false;
+	const extensionIndex = fileName.lastIndexOf(".");
+	if (extensionIndex === -1) return false;
+	const extension = fileName.slice(extensionIndex + 1);
+	return sourceExtensions.has(extension) || documentationExtensions.has(extension);
+};
+const resolveChunkSettings = (options) => {
+	const chunkSize = Math.max(1, options.chunkSize);
+	return {
+		chunkSize,
+		chunkOverlap: Math.max(0, Math.min(chunkSize - 1, options.chunkOverlap)),
+		chunkMaxCharacters: options.chunkMaxCharacters !== void 0 && Number.isFinite(options.chunkMaxCharacters) ? Math.max(1, Math.floor(options.chunkMaxCharacters)) : Number.POSITIVE_INFINITY
+	};
+};
+const getPathExtension = (path) => {
+	const fileName = path.split("/").at(-1);
+	if (fileName === void 0) return;
+	const extensionIndex = fileName.lastIndexOf(".");
+	if (extensionIndex === -1) return;
+	return fileName.slice(extensionIndex + 1).toLowerCase();
+};
+const resolveAstLanguage = (path) => {
+	const extension = getPathExtension(path);
+	if (extension === void 0) return;
+	return languageByExtension.get(extension);
+};
+const lineRangeFromNode = (node) => {
+	const startLine = node.startPosition.row + 1;
+	return {
+		startLine,
+		endLine: Math.max(startLine, node.endPosition.row + 1)
+	};
+};
+const hasOnlyWhitespaceLines = (lines, startLine, endLine) => {
+	if (startLine > endLine) return true;
+	for (let lineIndex = startLine; lineIndex <= endLine; lineIndex++) if ((lines[lineIndex - 1] ?? "").trim().length > 0) return false;
+	return true;
+};
+const lineRangeWithLeadingComments = (node, siblings, nodeIndex, lines) => {
+	const baseRange = lineRangeFromNode(node);
+	let startLine = baseRange.startLine;
+	for (let index = nodeIndex - 1; index >= 0; index--) {
+		const sibling = siblings[index];
+		if (sibling.type !== "comment") break;
+		const commentRange = lineRangeFromNode(sibling);
+		if (!hasOnlyWhitespaceLines(lines, commentRange.endLine + 1, startLine - 1)) break;
+		startLine = commentRange.startLine;
+	}
+	return {
+		startLine,
+		endLine: baseRange.endLine
+	};
+};
+const normalizeLineRange = (range, lineCount) => {
+	const startLine = Math.max(1, Math.min(lineCount, range.startLine));
+	const endLine = Math.max(1, Math.min(lineCount, range.endLine));
+	if (endLine < startLine) return;
+	return {
+		startLine,
+		endLine
+	};
+};
+const lineLengthPrefixSums = (lines) => {
+	const sums = [0];
+	for (let index = 0; index < lines.length; index++) sums.push(sums[index] + lines[index].length);
+	return sums;
+};
+const lineRangeCharacterLength = (prefixSums, range) => prefixSums[range.endLine] - prefixSums[range.startLine - 1] + (range.endLine - range.startLine);
+const resolveSegmentEndLine = (options) => {
+	if (options.settings.chunkMaxCharacters === Number.POSITIVE_INFINITY) return options.maxEndLine;
+	let endLine = options.maxEndLine;
+	while (endLine > options.startLine && lineRangeCharacterLength(options.prefixSums, {
+		startLine: options.startLine,
+		endLine
+	}) > options.settings.chunkMaxCharacters) endLine--;
+	return endLine;
+};
+const splitRange = (range, settings, prefixSums) => {
+	if (range.endLine - range.startLine + 1 <= settings.chunkSize && lineRangeCharacterLength(prefixSums, range) <= settings.chunkMaxCharacters) return [range];
+	const out = [];
+	for (let startLine = range.startLine; startLine <= range.endLine;) {
+		const maxEndLine = Math.min(range.endLine, startLine + settings.chunkSize - 1);
+		const endLine = resolveSegmentEndLine({
+			startLine,
+			maxEndLine,
+			settings,
+			prefixSums
+		});
+		out.push({
+			startLine,
+			endLine
+		});
+		if (endLine >= range.endLine) break;
+		startLine = Math.max(startLine + 1, endLine - settings.chunkOverlap + 1);
+	}
+	return out;
+};
+const nodeText = (node) => {
+	if (node === null) return;
+	const value = node.text.trim().replace(/\s+/g, " ");
+	return value.length === 0 ? void 0 : value;
+};
+const nodeFieldText = (node, fieldName) => nodeText(node.childForFieldName(fieldName));
+const isNamespaceNode = (node) => node.type === "internal_module" || node.type === "module";
+const unwrapDeclarationNode = (node) => {
+	let current = node;
+	while (true) {
+		if (current.type === "export_statement") {
+			const declaration = current.childForFieldName("declaration") ?? current.namedChildren[0];
+			if (declaration === void 0) return current;
+			current = declaration;
+			continue;
+		}
+		if (current.type === "ambient_declaration") {
+			const declaration = current.namedChildren.find((child) => child.type.endsWith("_declaration") || isNamespaceNode(child));
+			if (declaration === void 0) return current;
+			current = declaration;
+			continue;
+		}
+		return current;
+	}
+};
+const variableDeclarators = (node) => node.namedChildren.filter((child) => child.type === "variable_declarator");
+const variableTypeFromDeclarator = (node) => {
+	const value = node.childForFieldName("value");
+	if (value !== null && value.type.includes("function")) return "function";
+	return "variable";
+};
+const variableTypeFromDeclaration = (node) => {
+	if (variableDeclarators(node).some((declarator) => variableTypeFromDeclarator(declarator) === "function")) return "function";
+	return "variable";
+};
+const chunkTypeFromNode = (node) => {
+	switch (node.type) {
+		case "class_declaration": return "class";
+		case "enum_declaration": return "enum";
+		case "function_declaration":
+		case "generator_function_declaration": return "function";
+		case "internal_module":
+		case "module": return "namespace";
+		case "interface_declaration": return "interface";
+		case "generator_method_definition":
+		case "method_definition": return "method";
+		case "type_alias_declaration": return "type-alias";
+		case "lexical_declaration":
+		case "variable_declaration": return variableTypeFromDeclaration(node);
+		case "variable_declarator": return variableTypeFromDeclarator(node);
+		default: return;
+	}
+};
+const variableNamesFromDeclaration = (node) => {
+	const names = variableDeclarators(node).map((declarator) => nodeFieldText(declarator, "name")).filter((name) => name !== void 0);
+	if (names.length === 0) return;
+	return names.join(", ");
+};
+const nameFromNode = (node) => {
+	switch (node.type) {
+		case "class_declaration":
+		case "enum_declaration":
+		case "function_declaration":
+		case "generator_function_declaration":
+		case "internal_module":
+		case "interface_declaration":
+		case "module":
+		case "generator_method_definition":
+		case "method_definition":
+		case "type_alias_declaration":
+		case "variable_declarator": return nodeFieldText(node, "name");
+		case "lexical_declaration":
+		case "variable_declaration": return variableNamesFromDeclaration(node);
+		default: return;
+	}
+};
+const formatParent = (type, name) => {
+	if (type === void 0 && name === void 0) return;
+	if (type === void 0) return name;
+	if (name === void 0) return type;
+	return type + " " + name;
+};
+const collectClassMethodRanges = (classNode, parent, lines) => {
+	const body = classNode.childForFieldName("body");
+	if (body === null) return [];
+	const out = [];
+	for (let index = 0; index < body.namedChildren.length; index++) {
+		const child = body.namedChildren[index];
+		if (!child.type.includes("method")) continue;
+		out.push({
+			...lineRangeWithLeadingComments(child, body.namedChildren, index, lines),
+			name: nameFromNode(child),
+			type: chunkTypeFromNode(child),
+			parent
+		});
+	}
+	return out;
+};
+const collectAstRanges = (path, content, lines) => {
+	const language = resolveAstLanguage(path);
+	if (language === void 0) return [];
+	try {
+		const parser = new TreeSitter();
+		parser.setLanguage(language);
+		const tree = parser.parse(content, void 0, { bufferSize: 1048576 });
+		const collectDeclarationRanges = (siblings, parent) => {
+			const out = [];
+			for (let index = 0; index < siblings.length; index++) {
+				const sibling = siblings[index];
+				if (sibling.type === "comment" || sibling.type.includes("import")) continue;
+				const declarationNode = unwrapDeclarationNode(sibling);
+				const type = chunkTypeFromNode(declarationNode);
+				const name = nameFromNode(declarationNode);
+				if (type === void 0 && name === void 0) continue;
+				out.push({
+					...lineRangeWithLeadingComments(sibling, siblings, index, lines),
+					name,
+					type,
+					parent
+				});
+				if (declarationNode.type === "class_declaration") out.push(...collectClassMethodRanges(declarationNode, formatParent(type, name), lines));
+				if (isNamespaceNode(declarationNode)) {
+					const body = declarationNode.childForFieldName("body");
+					if (body !== null) out.push(...collectDeclarationRanges(body.namedChildren, formatParent(type, name)));
+				}
+			}
+			return out;
+		};
+		return collectDeclarationRanges(tree.rootNode.namedChildren, void 0);
+	} catch {
+		return [];
+	}
+};
+const chunksFromRanges = (path, lines, ranges, settings) => {
+	const hasMethodChildRange = (classRange) => {
+		const parent = formatParent("class", classRange.name);
+		return ranges.some((range) => range.type === "method" && range.parent === parent && range.startLine >= classRange.startLine && range.endLine <= classRange.endLine);
+	};
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	const prefixSums = lineLengthPrefixSums(lines);
+	for (const range of ranges) {
+		const normalizedRange = normalizeLineRange(range, lines.length);
+		if (normalizedRange === void 0) continue;
+		const allSegments = splitRange(normalizedRange, settings, prefixSums);
+		const segments = range.type === "class" && allSegments.length > 1 && hasMethodChildRange({
+			...normalizedRange,
+			name: range.name
+		}) ? [allSegments[0]] : allSegments;
+		for (const segment of segments) {
+			const key = String(segment.startLine) + ":" + String(segment.endLine) + ":" + (range.name ?? "") + ":" + (range.type ?? "") + ":" + (range.parent ?? "");
+			if (seen.has(key)) continue;
+			seen.add(key);
+			const chunkLines = lines.slice(segment.startLine - 1, segment.endLine);
+			if (!chunkLines.some(isMeaningfulLine)) continue;
+			out.push({
+				path,
+				startLine: segment.startLine,
+				endLine: segment.endLine,
+				name: range.name,
+				type: range.type,
+				parent: range.parent,
+				content: chunkLines.join("\n")
+			});
+		}
+	}
+	return out.toSorted((left, right) => left.startLine - right.startLine || left.endLine - right.endLine || (left.name ?? "").localeCompare(right.name ?? ""));
+};
+const chunkWithLineWindows = (path, lines, settings) => {
+	const out = [];
+	const prefixSums = lineLengthPrefixSums(lines);
+	for (let index = 0; index < lines.length;) {
+		if (!isMeaningfulLine(lines[index])) {
+			index++;
+			continue;
+		}
+		const startLine = index + 1;
+		const maxEndLine = Math.min(lines.length, startLine + settings.chunkSize - 1);
+		const endLine = resolveSegmentEndLine({
+			startLine,
+			maxEndLine,
+			settings,
+			prefixSums
+		});
+		const chunkLines = lines.slice(startLine - 1, endLine);
+		out.push({
+			path,
+			startLine,
+			endLine,
+			name: void 0,
+			type: void 0,
+			parent: void 0,
+			content: chunkLines.join("\n")
+		});
+		if (endLine >= lines.length) break;
+		index = Math.max(startLine + 1, endLine - settings.chunkOverlap + 1) - 1;
+	}
+	return out;
+};
+const splitOversizedChunks = (chunks, maxCharacters) => chunks.flatMap((chunk) => {
+	if (chunk.content.length <= maxCharacters) return [chunk];
+	const pieces = [];
+	for (let offset = 0; offset < chunk.content.length; offset += maxCharacters) pieces.push({
+		...chunk,
+		content: chunk.content.slice(offset, offset + maxCharacters)
+	});
+	return pieces;
+});
+/**
+* @since 1.0.0
+* @category Constructors
+*/
+const chunkFileContent = (path, content, options) => {
+	if (content.trim().length === 0 || isProbablyMinified(content)) return [];
+	const normalizedPath = normalizePath$1(path);
+	const normalizedContent = normalizeText(content);
+	const lines = normalizedContent.split("\n");
+	if (lines.at(-1) === "") lines.pop();
+	if (lines.length === 0) return [];
+	const settings = resolveChunkSettings(options);
+	const astRanges = collectAstRanges(normalizedPath, normalizedContent, lines);
+	if (astRanges.length > 0) {
+		const astChunks = chunksFromRanges(normalizedPath, lines, astRanges, settings);
+		if (astChunks.length > 0) return splitOversizedChunks(astChunks, settings.chunkMaxCharacters);
+	}
+	return splitOversizedChunks(chunkWithLineWindows(normalizedPath, lines, settings), settings.chunkMaxCharacters);
+};
+/**
+* @since 1.0.0
+* @category Layers
+*/
+const layer$3 = effect(CodeChunker, gen(function* () {
+	const spawner = yield* ChildProcessSpawner;
+	const fs = yield* FileSystem;
+	const pathService = yield* Path;
+	const listFiles = fn("CodeChunker.listFiles")(function* (options) {
+		const root = pathService.resolve(options.root);
+		const maxFileSize = options.maxFileSize ?? "1M";
+		return yield* pipe(spawner.streamLines(make$13("rg", [
+			"--files",
+			"--hidden",
+			"--max-filesize",
+			maxFileSize,
+			"--glob",
+			"!.git"
+		], {
+			cwd: root,
+			stdin: "ignore"
+		})), runCollect, map(fromIterable), map((entries) => entries.map((entry) => normalizePath$1(entry.trim())).filter((entry) => entry.length > 0 && isMeaningfulFile(entry)).toSorted((left, right) => left.localeCompare(right))), orDie);
+	});
+	const chunkFile = fn("CodeChunker.chunkFile")(function* (options) {
+		const root = pathService.resolve(options.root);
+		const absolutePath = pathService.resolve(root, options.path);
+		const path = normalizePath$1(pathService.relative(root, absolutePath));
+		if (path.length === 0 || path === ".." || path.startsWith("../") || !isMeaningfulFile(path)) return [];
+		return yield* pipe(fs.readFileString(absolutePath), map((content) => chunkFileContent(path, content, options)), orElseSucceed(() => []));
+	});
+	const chunkFiles = (options) => fromArray(options.paths).pipe(flatMap$1((path) => pipe(chunkFile({
+		root: options.root,
+		path,
+		chunkSize: options.chunkSize,
+		chunkOverlap: options.chunkOverlap,
+		...options.chunkMaxCharacters === void 0 ? {} : { chunkMaxCharacters: options.chunkMaxCharacters }
+	}), fromArrayEffect), { concurrency: 5 }));
+	const chunkCodebase = fnUntraced(function* (options) {
+		const root = pathService.resolve(options.root);
+		const files = yield* listFiles({
+			root,
+			...options.maxFileSize === void 0 ? {} : { maxFileSize: options.maxFileSize }
+		});
+		return chunkFiles({
+			root,
+			paths: files,
+			chunkSize: options.chunkSize,
+			chunkOverlap: options.chunkOverlap,
+			...options.chunkMaxCharacters === void 0 ? {} : { chunkMaxCharacters: options.chunkMaxCharacters }
+		});
+	}, unwrap);
+	return CodeChunker.of({
+		listFiles,
+		chunkFile,
+		chunkFiles,
+		chunkCodebase
+	});
+}));
+//#endregion
+//#region node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/FiberHandle.js
+/**
+* Manages at most one fiber inside a scope.
+*
+* A `FiberHandle<A, E>` can hold one `Fiber<A, E>`. Installing a new fiber
+* interrupts the previous one unless the operation is configured with
+* `onlyIfMissing`, and closing the owning scope interrupts the current fiber.
+* This module includes constructors for handles and scoped runtimes, helpers
+* for setting, reading, clearing, and running fibers, and operations for joining
+* the current fiber or waiting until the handle is empty.
+*
+* @since 2.0.0
+*/
+const TypeId$1 = "~effect/FiberHandle";
+/**
+* Returns `true` if a value is a `FiberHandle` by checking for the
+* `FiberHandle` runtime marker.
+*
+* **Example** (Checking fiber handles)
+*
+* ```ts import.meta.vitest
+* import { Effect, FiberHandle } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const handle = yield* FiberHandle.make()
+*
+*   return [FiberHandle.isFiberHandle(handle), FiberHandle.isFiberHandle("not a handle")]
+* })
+*
+* const actual = await Effect.runPromise(Effect.scoped(program))
+* actual // => [true, false]
+* ```
+*
+* @category guards
+* @since 2.0.0
+*/
+const isFiberHandle = (u) => hasProperty(u, TypeId$1);
+const Proto = {
+	[TypeId$1]: TypeId$1,
+	...PipeInspectableProto,
+	toJSON() {
+		return {
+			_id: "FiberHandle",
+			state: this.state
+		};
+	}
+};
+const makeUnsafe = () => {
+	const self = Object.create(Proto);
+	self.state = {
+		_tag: "Open",
+		fiber: void 0
+	};
+	self.deferred = makeUnsafe$2();
+	return self;
+};
+/**
+* Creates a scoped `FiberHandle` that can store a single fiber.
+*
+* **Details**
+*
+* When the associated `Scope` is closed, the contained fiber will be
+* interrupted. You can add a fiber to the handle using `FiberHandle.run`, and
+* the fiber will be automatically removed from the `FiberHandle` when it
+* completes.
+*
+* **Example** (Creating a scoped fiber handle)
+*
+* ```ts import.meta.vitest
+* import { Effect, FiberHandle } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const handle = yield* FiberHandle.make()
+*
+*   // run some effects
+*   yield* FiberHandle.run(handle, Effect.never)
+*   // this will interrupt the previous fiber
+*   yield* FiberHandle.run(handle, Effect.never)
+*
+*   yield* Effect.yieldNow
+*   return handle.state._tag === "Open" && handle.state.fiber !== undefined
+* }).pipe(
+*   Effect.scoped // The fiber will be interrupted when the scope is closed
+* )
+*
+* const actual = await Effect.runPromise(program)
+* actual // => true
+* ```
+*
+* @category constructors
+* @since 2.0.0
+*/
+const make$2 = () => acquireRelease(sync(() => makeUnsafe()), (handle) => {
+	const state = handle.state;
+	if (state._tag === "Closed") return void_$1;
+	handle.state = { _tag: "Closed" };
+	return state.fiber ? into(asVoid(interruptAs(state.fiber, internalFiberId)), handle.deferred) : done(handle.deferred, void_$3);
+});
+const internalFiberId = -1;
+const isInternalInterruption = /*#__PURE__*/ toPredicate(/*#__PURE__*/ compose(filterInterruptors, /*#__PURE__*/ has(internalFiberId)));
+/**
+* Sets the fiber in a FiberHandle. When the fiber completes, it will be removed from the FiberHandle.
+* If a fiber is already running, it will be interrupted unless `options.onlyIfMissing` is set.
+*
+* **When to use**
+*
+* Use when an existing forked fiber must be installed synchronously into a
+* handle and immediate interruption of replaced or closed fibers is acceptable.
+*
+* **Example** (Setting a fiber unsafely)
+*
+* ```ts import.meta.vitest
+* import { Effect, Fiber, FiberHandle } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const handle = yield* FiberHandle.make()
+*   const fiber = Effect.runFork(Effect.succeed("hello"))
+*
+*   // Set the fiber directly (unsafe)
+*   FiberHandle.setUnsafe(handle, fiber)
+*
+*   // The fiber is now managed by the handle
+*   return yield* Fiber.join(fiber)
+* })
+*
+* const actual = await Effect.runPromise(Effect.scoped(program))
+* actual // => "hello"
+* ```
+*
+* @category combinators
+* @since 4.0.0
+*/
+const setUnsafe = /*#__PURE__*/ dual((args) => isFiberHandle(args[0]), (self, fiber, options) => {
+	if (self.state._tag === "Closed") {
+		fiber.interruptUnsafe(internalFiberId);
+		return;
+	} else if (self.state.fiber !== void 0) {
+		if (self.state.fiber === fiber) return;
+		else if (options?.onlyIfMissing === true) {
+			fiber.interruptUnsafe(internalFiberId);
+			return;
+		}
+		self.state.fiber.interruptUnsafe(internalFiberId);
+		self.state.fiber = void 0;
+	}
+	self.state.fiber = fiber;
+	fiber.addObserver((exit) => {
+		if (self.state._tag === "Open" && fiber === self.state.fiber) self.state.fiber = void 0;
+		if (isFailure(exit) && (options?.propagateInterruption === true ? !isInternalInterruption(exit.cause) : !hasInterruptsOnly(exit.cause))) doneUnsafe(self.deferred, exit);
+	});
+});
+const constInterruptedFiber = /*#__PURE__*/ function() {
+	let fiber = void 0;
+	return () => {
+		if (fiber === void 0) fiber = runFork(interrupt);
+		return fiber;
+	};
+}();
+/**
+* Forks an Effect and stores the resulting fiber in the `FiberHandle`.
+*
+* **Details**
+*
+* The handle manages only one fiber: running a new effect interrupts the
+* previous fiber unless `onlyIfMissing` is set. When the managed fiber
+* completes, it is removed from the handle.
+*
+* **Example** (Running an effect in a fiber handle)
+*
+* ```ts import.meta.vitest
+* import { Effect, Fiber, FiberHandle } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const handle = yield* FiberHandle.make()
+*
+*   // Run an effect and get the fiber
+*   const fiber = yield* FiberHandle.run(handle, Effect.succeed("hello"))
+*   const result = yield* Fiber.join(fiber)
+*
+*   // Running another effect will interrupt the previous one
+*   const fiber2 = yield* FiberHandle.run(handle, Effect.succeed("world"))
+*   const result2 = yield* Fiber.join(fiber2)
+*   return [result, result2]
+* })
+*
+* const actual = await Effect.runPromise(Effect.scoped(program))
+* actual // => ["hello", "world"]
+* ```
+*
+* @category combinators
+* @since 2.0.0
+*/
+const run$1 = function() {
+	const self = arguments[0];
+	if (isEffect(arguments[1])) return runImpl(self, arguments[1], arguments[2]);
+	const options = arguments[1];
+	return (effect) => runImpl(self, effect, options);
+};
+const runImpl = (self, effect, options) => withFiber((parent) => {
+	if (self.state._tag === "Closed") return interrupt;
+	else if (self.state.fiber !== void 0 && options?.onlyIfMissing === true) return sync(constInterruptedFiber);
+	const fiber = runForkWith(parent.context)(effect);
+	setUnsafe(self, fiber, options);
+	return succeed(fiber);
+});
+//#endregion
+//#region node_modules/.pnpm/@effect+sql-sqlite-node@4.0.0-rc.115_effect@4.0.0-rc.115/node_modules/@effect/sql-sqlite-node/dist/SqliteClient.js
+/**
+* Connects Effect SQL to SQLite on Node.js using `node:sqlite`.
+*
+* This module opens a SQLite database and exposes it as both `SqliteClient` and
+* the generic Effect SQL client. It serializes access through one connection,
+* caches prepared statements, enables WAL mode unless disabled, and waits up
+* to five seconds for busy databases by default. Explicit transactions on
+* writable connections use `BEGIN IMMEDIATE` to avoid read-to-write lock
+* upgrades, which serializes them behind other writers even when they only
+* read. Clients opened with `readonly: true` are unaffected. Busy waits block
+* the Node.js event loop because `node:sqlite` is synchronous. Database backup
+* and extension loading are supported; streaming queries and `updateValues`
+* are not.
+*
+* @since 4.0.0
+*/
+const ATTR_DB_SYSTEM_NAME = "db.system.name";
+const MAX_BUSY_TIMEOUT = 2147483647;
+/**
+* Runtime type identifier used to mark Node `SqliteClient` values.
+*
+* @category type IDs
+* @since 4.0.0
+*/
+const TypeId = "~@effect/sql-sqlite-node/SqliteClient";
+/**
+* Service tag for the node SQLite client implementation.
+*
+* @category services
+* @since 4.0.0
+*/
+const SqliteClient = /*#__PURE__*/ Service("@effect/sql-sqlite-node/SqliteClient");
+/**
+* Creates a scoped node SQLite client from the supplied configuration, using a single serialized connection with WAL and a 5-second busy timeout enabled by default. Explicit transactions on writable connections take the write lock for their duration, even when they only read; clients opened with `readonly: true` are unaffected.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const make$1 = (options) => gen(function* () {
+	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 = new DatabaseSync(options.filename, {
+			readOnly: options.readonly ?? false,
+			allowExtension: true
+		});
+		yield* addFinalizer(scope$1, sync(() => db.close()));
+		db.enableLoadExtension(false);
+		const busyTimeout = Math.min(MAX_BUSY_TIMEOUT, Math.max(0, Math.round(toMillis(options.busyTimeout ?? seconds(5)))));
+		db.exec(`PRAGMA busy_timeout = ${busyTimeout}`);
+		if (options.disableWAL !== true) db.exec("PRAGMA journal_mode = WAL");
+		const prepare = (sql) => try_({
+			try: () => db.prepare(sql),
+			catch: (cause) => new SqlError({ reason: classifyError(cause, "Failed to prepare statement", "prepare") })
+		});
+		const prepareCache = yield* make$4({
+			capacity: options.prepareCacheSize ?? 200,
+			timeToLive: options.prepareCacheTTL ?? minutes(10),
+			lookup: prepare
+		});
+		const runStatement = (statement, params, raw) => withFiber((fiber) => {
+			const useSafeIntegers = get$1(fiber.context, SafeIntegers);
+			return try_({
+				try: () => {
+					statement.setReadBigInts(useSafeIntegers);
+					if (statement.columns().length > 0) return statement.all(...params);
+					const result = statement.run(...params);
+					return raw ? {
+						changes: result.changes,
+						lastInsertRowid: result.lastInsertRowid
+					} : [];
+				},
+				catch: (cause) => new SqlError({ reason: classifyError(cause, "Failed to execute statement", "execute") })
+			});
+		});
+		const runStatementValues = (statement, params) => withFiber((fiber) => {
+			const useSafeIntegers = get$1(fiber.context, SafeIntegers);
+			return try_({
+				try: () => {
+					statement.setReadBigInts(useSafeIntegers);
+					if (statement.columns().length > 0) return statement.all(...params);
+					statement.run(...params);
+					return [];
+				},
+				catch: (cause) => new SqlError({ reason: classifyError(cause, "Failed to execute statement", "execute") })
+			});
+		});
+		const runStatementValuesUnprepared = (statement, params) => withFiber((fiber) => {
+			const useSafeIntegers = get$1(fiber.context, SafeIntegers);
+			return try_({
+				try: () => {
+					statement.setReadBigInts(useSafeIntegers);
+					statement.setReturnArrays(true);
+					if (statement.columns().length > 0) return statement.all(...params);
+					statement.run(...params);
+					return [];
+				},
+				catch: (cause) => new SqlError({ reason: classifyError(cause, "Failed to execute statement", "execute") })
+			});
+		});
+		const run = (sql, params, raw = false) => flatMap(get(prepareCache, sql), (s) => runStatement(s, params, raw));
+		const runValues = (sql, params) => acquireUseRelease(get(prepareCache, sql), (statement) => {
+			statement.setReturnArrays(true);
+			return runStatementValues(statement, params);
+		}, (statement) => sync(() => statement.setReturnArrays(false)));
+		const runValuesUnprepared = (sql, params) => flatMap(prepare(sql), (statement) => runStatementValuesUnprepared(statement, params));
+		return identity({
+			execute(sql, params, transformRows) {
+				return transformRows ? map(run(sql, params), transformRows) : run(sql, params);
+			},
+			executeRaw(sql, params) {
+				return run(sql, params, true);
+			},
+			executeValues(sql, params) {
+				return runValues(sql, params);
+			},
+			executeValuesUnprepared(sql, params) {
+				return runValuesUnprepared(sql, params);
+			},
+			executeUnprepared(sql, params, transformRows) {
+				const effect = flatMap(prepare(sql), (statement) => runStatement(statement, params ?? [], false));
+				return transformRows ? map(effect, transformRows) : effect;
+			},
+			executeStream(_sql, _params) {
+				return die$1("executeStream not implemented");
+			},
+			backup(destination) {
+				return suspend(() => {
+					let totalPages = 0;
+					return tryPromise({
+						try: () => backup(db, destination, { progress: (progress) => {
+							totalPages = progress.totalPages;
+						} }).then((pages) => ({
+							totalPages: totalPages || pages,
+							remainingPages: 0
+						})),
+						catch: (cause) => new SqlError({ reason: classifyError(cause, "Failed to backup database", "backup") })
+					});
+				});
+			},
+			loadExtension(path) {
+				return acquireUseRelease(sync(() => db.enableLoadExtension(true)), () => try_({
+					try: () => db.loadExtension(path),
+					catch: (cause) => new SqlError({ reason: classifyError(cause, "Failed to load extension", "loadExtension") })
+				}), () => sync(() => db.enableLoadExtension(false)));
+			}
+		});
+	});
+	const semaphore = yield* make$14(1);
+	const connection = yield* makeConnection;
+	const acquirer = semaphore.withPermits(1)(succeed(connection));
+	const transactionAcquirer = uninterruptibleMask((restore) => {
+		const fiber = getCurrent();
+		const scope = getUnsafe(fiber.context, Scope);
+		return as(tap(restore(semaphore.take(1)), () => addFinalizer(scope, semaphore.release(1))), connection);
+	});
+	return Object.assign(yield* make$5({
+		acquirer,
+		compiler,
+		transactionAcquirer,
+		beginTransaction: options.readonly === true ? "BEGIN" : "BEGIN IMMEDIATE",
+		spanAttributes: [...options.spanAttributes ? Object.entries(options.spanAttributes) : [], [ATTR_DB_SYSTEM_NAME, "sqlite"]],
+		transformRows
+	}), {
+		[TypeId]: TypeId,
+		config: options,
+		backup: (destination) => flatMap(acquirer, (_) => _.backup(destination)),
+		loadExtension: (path) => flatMap(acquirer, (_) => _.loadExtension(path))
+	});
+});
+/**
+* Builds a layer from a node SQLite client configuration, providing both `SqliteClient` and the generic `SqlClient` service.
+*
+* @category layers
+* @since 4.0.0
+*/
+const layer$2 = (config) => effectContext(map(make$1(config), (client) => make$9(SqliteClient, client).pipe(add(SqlClient, client)))).pipe(provide$1(layer$5));
+const classifyError = (cause, message, operation) => classifySqliteError(sqliteCauseWithErrno(cause), {
+	message,
+	operation
+});
+const sqliteCauseWithErrno = (cause) => {
+	if (typeof cause !== "object" || cause === null || !("errcode" in cause) || "errno" in cause) return cause;
+	const errcode = cause.errcode;
+	if (typeof errcode !== "number") return cause;
+	return Object.assign(cause, { errno: errcode });
+};
+/**
+* Error raised while loading, validating, locking, or running SQL migrations.
+*
+* @category errors
+* @since 4.0.0
+*/
+var MigrationError = class extends (/*#__PURE__*/ TaggedError$1("MigrationError")) {};
+/**
+* Creates a migrator that ensures the migrations table exists, runs pending
+* migrations in a transaction, and optionally dumps the schema after successful
+* migrations.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const make = ({ dumpSchema = () => void_$1 }) => ({ loader, schemaDirectory, table = "effect_sql_migrations" }) => gen(function* () {
+	const sql = yield* SqlClient;
+	const ensureMigrationsTable = sql.onDialectOrElse({
+		mssql: () => sql`IF OBJECT_ID(N'${sql.literal(table)}', N'U') IS NULL
+  CREATE TABLE ${sql(table)} (
+    migration_id INT NOT NULL PRIMARY KEY,
+    name VARCHAR(255) NOT NULL,
+    created_at DATETIME NOT NULL DEFAULT GETDATE()
+  )`,
+		mysql: () => sql`CREATE TABLE IF NOT EXISTS ${sql(table)} (
+  migration_id INTEGER UNSIGNED NOT NULL,
+  created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  name VARCHAR(255) NOT NULL,
+  PRIMARY KEY (migration_id)
+)`,
+		pg: () => catch_(sql`select ${table}::regclass`, () => sql`CREATE TABLE ${sql(table)} (
+  migration_id integer primary key,
+  created_at timestamp with time zone not null default now(),
+  name text not null
+)`),
+		orElse: () => sql`CREATE TABLE IF NOT EXISTS ${sql(table)} (
+  migration_id integer PRIMARY KEY NOT NULL,
+  created_at datetime NOT NULL DEFAULT current_timestamp,
+  name VARCHAR(255) NOT NULL
+)`
+	});
+	const insertMigrations = (rows) => sql`INSERT INTO ${sql(table)} ${sql.insert(rows.map(([migration_id, name]) => ({
+		migration_id,
+		name
+	})))}`.withoutTransform;
+	const latestMigration = map(sql`SELECT migration_id, name, created_at FROM ${sql(table)} ORDER BY migration_id DESC`.withoutTransform, (_) => map$1(fromNullishOr(_[0]), ({ created_at, migration_id, name }) => ({
+		id: migration_id,
+		name,
+		createdAt: created_at
+	})));
+	const loadMigration = ([id, name, load]) => catchDefect(load, (_) => fail$1(new MigrationError({
+		kind: "ImportError",
+		message: `Could not import migration "${id}_${name}"\n\n${_}`
+	}))).pipe(flatMap((_) => isEffect(_) ? succeed(_) : _.default ? succeed(_.default?.default ?? _.default) : fail$1(new MigrationError({
+		kind: "ImportError",
+		message: `Default export not found for migration "${id}_${name}"`
+	}))), filterOrFail(isEffect, () => new MigrationError({
+		kind: "ImportError",
+		message: `Default export was not an Effect for migration "${id}_${name}"`
+	})));
+	const runMigration = (id, name, effect) => catch_(effect, (error) => die(new MigrationError({
+		cause: error,
+		kind: "Failed",
+		message: `Migration "${id}_${name}" failed`
+	})));
+	const run = gen(function* () {
+		yield* sql.onDialectOrElse({
+			pg: () => sql`LOCK TABLE ${sql(table)} IN ACCESS EXCLUSIVE MODE`,
+			orElse: () => void_$1
+		});
+		const [latestMigrationId, current] = yield* all([map(latestMigration, match({
+			onNone: () => 0,
+			onSome: (_) => _.id
+		})), loader]);
+		if (new Set(current.map(([id]) => id)).size !== current.length) return yield* new MigrationError({
+			kind: "Duplicates",
+			message: "Found duplicate migration id's"
+		});
+		const required = [];
+		for (const resolved of current) {
+			const [currentId, currentName] = resolved;
+			if (currentId <= latestMigrationId) continue;
+			required.push([
+				currentId,
+				currentName,
+				yield* loadMigration(resolved)
+			]);
+		}
+		if (required.length > 0) yield* pipe(insertMigrations(required.map(([id, name]) => [id, name])), mapError((error) => isConstraintConflict(error) ? new MigrationError({
+			kind: "Locked",
+			message: "Migrations already running"
+		}) : error));
+		yield* forEach(required, ([id, name, effect]) => logDebug(`Running migration`).pipe(flatMap(() => runMigration(id, name, effect)), annotateLogs("migration_id", String(id)), annotateLogs("migration_name", name), withSpan(`Migrator ${id}_${name}`)), { discard: true });
+		yield* pipe(latestMigration, flatMap(match({
+			onNone: () => logDebug(`Migrations complete`),
+			onSome: (_) => logDebug(`Migrations complete`).pipe(annotateLogs("latest_migration_id", _.id.toString()), annotateLogs("latest_migration_name", _.name))
+		})));
+		return required.map(([id, name]) => [id, name]);
+	});
+	yield* ensureMigrationsTable;
+	const completed = yield* pipe(sql.withTransaction(run), catchTag("MigrationError", (_) => _.kind === "Locked" ? as(logDebug(_.message), []) : fail$1(_)));
+	if (schemaDirectory && completed.length > 0) yield* dumpSchema(`${schemaDirectory}/_schema.sql`, table).pipe(catchCause((cause) => logInfo("Could not dump schema", cause)));
+	return completed;
+});
+const migrationOrder = /*#__PURE__*/ make$10(([a], [b]) => Number$2(a, b));
+const isConstraintConflict = (error) => error.reason._tag === "ConstraintError" || error.reason._tag === "UniqueViolation";
+/**
+* Creates a migration loader from a record of migration effects keyed by
+* `<id>_<name>`, sorted by migration id.
+*
+* @category loaders
+* @since 4.0.0
+*/
+const fromRecord = (migrations) => pipe(Object.keys(migrations), flatMapNullishOr((_) => _.match(/^(\d+)_(.+)$/)), map$2(([key, id, name]) => [
+	Number(id),
+	name,
+	succeed(migrations[key])
+]), sort(migrationOrder), succeed);
+//#endregion
+//#region node_modules/.pnpm/@effect+sql-sqlite-node@4.0.0-rc.115_effect@4.0.0-rc.115/node_modules/@effect/sql-sqlite-node/dist/SqliteMigrator.js
+/**
+* Runs SQL migrations for a SQLite database using the shared `Migrator` implementation and the current `SqlClient`.
+*
+* @category running
+* @since 4.0.0
+*/
+const run = /*#__PURE__*/ make({});
+/**
+* Creates a layer that runs the configured SQLite migrations during layer construction and provides no services.
+*
+* @category layers
+* @since 4.0.0
+*/
+const layer$1 = (options) => effectDiscard(run(options));
+//#endregion
+//#region src/Sqlite.ts
+/**
+* @since 1.0.0
+*/
+/**
+* @since 1.0.0
+* @category Layers
+*/
+const SqliteLayer = (database) => layer$1({ loader: fromRecord({ "0001_create_chunks": gen(function* () {
+	const sql = yield* SqlClient;
+	yield* sql`CREATE TABLE IF NOT EXISTS chunks (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          path TEXT NOT NULL,
+          content TEXT NOT NULL,
+          hash TEXT NOT NULL,
+          vector BLOB NOT NULL,
+          syncId TEXT NOT NULL
+        )`;
+	yield* sql`CREATE INDEX IF NOT EXISTS idx_chunks_hash ON chunks (hash)`;
+}) }) }).pipe(provide$1(effectDiscard(gen(function* () {
+	yield* (yield* SqliteClient).loadExtension(getLoadablePath());
+}))), provideMerge(layer$2({ filename: database })), provide$1(effectDiscard(gen(function* () {
+	const fs = yield* FileSystem;
+	const directory = (yield* Path).dirname(database);
+	if (directory === ".") return;
+	yield* fs.makeDirectory(directory, { recursive: true });
+}))));
+//#endregion
+//#region src/SemanticSearch.ts
+/**
+* @since 1.0.0
+*/
+const normalizePath = (path) => path.replace(/\\/g, "/");
+const resolveChunkConfig = (options) => ({
+	chunkSize: 30,
+	chunkOverlap: 0,
+	chunkMaxCharacters: options.chunkMaxCharacters ?? 15e3
+});
+const makeEmbeddingResolver = (resolver, options) => resolver.pipe(setDelay(options.embeddingRequestDelay ?? millis(50)), batchN(options.embeddingBatchSize ?? 32));
+const chunkEmbeddingInput = (chunk) => {
+	const headerLines = ["---", "file: " + chunk.path];
+	if (chunk.name !== void 0) headerLines.push("name: " + chunk.name);
+	if (chunk.type !== void 0) headerLines.push("type: " + chunk.type);
+	if (chunk.parent !== void 0) headerLines.push("parent: " + chunk.parent);
+	headerLines.push("---");
+	const contentLines = chunk.content.split("\n");
+	let contentWithLines = "";
+	for (let i = 0; i < contentLines.length; i++) {
+		if (i > 0) contentWithLines += "\n";
+		contentWithLines += `${chunk.startLine + i}: ${contentLines[i]}`;
+	}
+	return headerLines.join("\n") + "\n\n" + contentWithLines;
+};
+const hashChunkInput = (input) => createHash("sha256").update(input).digest("hex");
+/**
+* @since 1.0.0
+* @category Layers
+*/
+const layer = (options) => effect(SemanticSearch, gen(function* () {
+	const chunker = yield* CodeChunker;
+	const repo = yield* ChunkRepo;
+	const embeddings = yield* EmbeddingModel;
+	const pathService = yield* Path;
+	const root = pathService.resolve(options.directory);
+	const resolver = makeEmbeddingResolver(embeddings.resolver, options);
+	const concurrency = options.concurrency ?? 2e3;
+	const chunkConfig = resolveChunkConfig(options);
+	const indexHandle = yield* make$2();
+	const console = yield* Console;
+	const resolveIndexedPath = (path) => {
+		const absolutePath = pathService.resolve(root, path);
+		const relativePath = normalizePath(pathService.relative(root, absolutePath));
+		if (relativePath.length === 0 || relativePath === ".." || relativePath.startsWith("../")) return none();
+		return some(relativePath);
+	};
+	const processChunk = fnUntraced(function* (options) {
+		const input = chunkEmbeddingInput(options.chunk);
+		const hash = hashChunkInput(input);
+		if (options.checkExisting) {
+			const id = yield* repo.exists(hash);
+			if (isSome(id)) {
+				yield* repo.setSyncId(id.value, options.syncId);
+				return;
+			}
+		}
+		const result = yield* request$1(new EmbeddingRequest({ input }), resolver);
+		const vector = new Float32Array(result.vector);
+		yield* repo.insert(Chunk.insert.make({
+			path: options.chunk.path,
+			hash,
+			content: input,
+			vector,
+			syncId: options.syncId
+		}));
+	}, ignore({
+		log: "Warn",
+		message: "Failed to process chunk for embedding"
+	}), (effect, options) => annotateLogs(effect, { chunk: `${options.chunk.path}/${options.chunk.startLine}` }));
+	const index = gen(function* () {
+		const syncId = SyncId.make(crypto.randomUUID());
+		yield* logInfo("Starting SemanticSearch index");
+		yield* pipe(chunker.chunkCodebase({
+			root,
+			...chunkConfig
+		}), tap$1((chunk) => processChunk({
+			chunk,
+			syncId,
+			checkExisting: true
+		}), { concurrency }), runDrain);
+		yield* repo.deleteForSyncId(syncId);
+		yield* logInfo("Finished SemanticSearch index");
+	}).pipe(withSpan("SemanticSearch.index"), withLogSpan("SemanticSearch.index"), provideService(Console, console));
+	const runIndex = run$1(indexHandle, index, { onlyIfMissing: true });
+	const initialIndex = yield* runIndex;
+	yield* runIndex.pipe(delay(minutes(3)), forever, forkScoped);
+	return SemanticSearch.of({
+		search: fn("SemanticSearch.search")(function* (options) {
+			yield* join$1(initialIndex);
+			yield* annotateCurrentSpan(options);
+			const { vector } = yield* embeddings.embed(options.query);
+			return (yield* repo.search({
+				vector: new Float32Array(vector),
+				limit: options.limit
+			})).map((r) => r.content).join("\n\n");
+		}, orDie),
+		updateFile: fn("SemanticSearch.updateFile")(function* (path) {
+			yield* join$1(initialIndex);
+			const indexedPath = resolveIndexedPath(path);
+			if (isNone(indexedPath)) return;
+			yield* repo.deleteByPath(indexedPath.value);
+			const chunks = yield* chunker.chunkFile({
+				root,
+				path: indexedPath.value,
+				...chunkConfig
+			});
+			if (chunks.length === 0) return;
+			const syncId = SyncId.make(crypto.randomUUID());
+			yield* pipe(fromArray(chunks), tap$1((chunk) => processChunk({
+				chunk,
+				syncId,
+				checkExisting: false
+			}), { concurrency }), runDrain);
+		}, orDie),
+		removeFile: fn("SemanticSearch.removeFile")(function* (path) {
+			yield* join$1(initialIndex);
+			const indexedPath = resolveIndexedPath(path);
+			if (isNone(indexedPath)) return;
+			yield* repo.deleteByPath(indexedPath.value);
+		}, orDie)
+	});
+})).pipe(provide$1([layer$3, layer$4.pipe(provide$1(SqliteLayer(options.database ?? ".clanka/search.sqlite")))]));
+//#endregion
+export { SemanticSearch, chunkEmbeddingInput, layer, makeEmbeddingResolver, maybeRemoveFile, maybeUpdateFile };
+
+//# sourceMappingURL=SemanticSearch-D9iZ_Mi9.mjs.map