alink-cli 0.7.2 → 0.7.4

package/dist/SqlClient-DcM69ZvI.mjs

@@ -0,0 +1,1554 @@
+#!/usr/bin/env node
+
+import { Bl as void_, Bo as provideContext, Cc as make$6, Cd as match, Cl as asSome, Cs as void_$1, Dl as exitHasInterrupts, El as endSpan, Es as withFiber$1, Fi as failCauseUnsafe, Fl as succeed, Gc as isSuccess, Ha as context, Hu as failVoid, Id as withFiber, Ii as make$5, Il as succeedNone, Io as orDie, Ja as exit, Jd as hash, Ju as succeed$1, Ld as assignProperty, Ll as sync, Md as Prototype, Ml as makeSpanUnsafe, Mo as onExit$1, Nd as PipeInspectableProto, Nl as onExit, Oc as TracerTimingEnabled, Ol as fiberInterrupt, Pd as exitSucceed, Qa as flatMap, Qd as hasProperty, Qu as add, Ru as filterMap, So as map, Ss as useSpan, Tc as provide, Tl as contextWith, Ua as contextWith$1, Vo as provideService, Wl as ParentSpan, Xu as Reference, Zo as scoped, Zu as Service, _c as Scope, aa as runIn, as as suspend, bc as close, bd as isNone, bl as ClockRef, bs as uninterruptibleMask, df as constUndefined, di as make$4, ed as get$2, es as serviceOption, eu as fromInputUnsafe, fi as remove, hf as flow, iu as isZero, jl as forkUnsafe, kl as fiberJoin, lo as gen, mf as dual, mi as size, ni as unwrap, no as fnUntraced, ns as succeed$2, nu as infinity, os as sync$1, pi as set$1, qa as ensuring, qo as runForkWith, qs as Clock, rc as effect, ru as isFinite, sd as merge, ss as tap, td as getOption$1, ui as get$1, uu as toMillis, vc as addFinalizer, xd as isSome, xo as makeSpanScoped, xr as fromQueue, zi as offerUnsafe, zl as updateContext } from "./Schema-B3i-HrZQ.mjs";
+//#region ../../node_modules/.pnpm/effect@4.0.0-beta.103_patch_hash=a18f963109656ddbeb2a99ca45f942ecf54830986259eb01ce6a970421c9c6a9/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$1 = "~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((context) => {
+	const self = Object.create(Proto);
+	self.lookup = (key) => updateContext(lookup(key), (input) => merge(context, input));
+	self.map = make$4();
+	self.capacity = options.capacity;
+	self.timeToLive = options.timeToLive ? (exit, key) => fromInputUnsafe(options.timeToLive(exit, key)) : defaultTimeToLive;
+	return succeed(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$3 = (options) => makeWith(options.lookup, {
+	...options,
+	timeToLive: options.timeToLive ? () => options.timeToLive : defaultTimeToLive
+});
+const Proto = {
+	...PipeInspectableProto,
+	[TypeId$1]: TypeId$1,
+	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((fiber) => {
+	const oentry = get$1(self.map, key);
+	if (isSome(oentry) && !hasExpired(oentry.value, fiber)) {
+		remove(self.map, key);
+		set$1(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$1(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);
+	});
+	set$1(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(fiberJoin(this.fiber), () => {
+			this.awaiters--;
+			if (this.awaiters > 0 || this.fiber.pollUnsafe()) return void_;
+			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;
+	}
+};
+/**
+* Reads an existing cache entry without invoking the lookup function.
+*
+* **Details**
+*
+* Returns `Option.none()` when the key is missing or expired, and `Option.some`
+* when a cached lookup has succeeded. If the entry is still pending, waits for
+* it to complete. If the cached or pending lookup fails, this effect fails with
+* the same error.
+*
+* **Example** (Reading cached values without lookup)
+*
+* ```ts import.meta.vitest
+* import { Cache, Effect, Option } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const cache = yield* Cache.make({
+*     capacity: 10,
+*     lookup: (key: string) => Effect.succeed(key.length)
+*   })
+*
+*   // No value in cache yet - returns None without lookup
+*   const empty = yield* Cache.getOption(cache, "hello")
+*
+*   // Populate cache using get
+*   yield* Cache.get(cache, "hello")
+*
+*   // Now getOption returns the cached value
+*   const cached = yield* Cache.getOption(cache, "hello")
+*   return [empty, cached] as const
+* })
+*
+* const actual = await Effect.runPromise(program)
+* actual // => [Option.none(), Option.some(5)]
+* ```
+*
+* **Example** (Skipping expired entries)
+*
+* ```ts import.meta.vitest
+* import { Cache, Effect, Option } from "effect"
+* import { TestClock } from "effect/testing"
+*
+* // Expired entries return None
+* const program = Effect.gen(function*() {
+*   const cache = yield* Cache.make({
+*     capacity: 10,
+*     lookup: (key: string) => Effect.succeed(key.length),
+*     timeToLive: "1 hour"
+*   })
+*
+*   // Add value to cache
+*   yield* Cache.get(cache, "hello")
+*
+*   // Value exists before expiration
+*   const beforeExpiry = yield* Cache.getOption(cache, "hello")
+*
+*   // Simulate time passing
+*   yield* TestClock.adjust("2 hours")
+*
+*   // Value expired - returns None
+*   const afterExpiry = yield* Cache.getOption(cache, "hello")
+*   return [beforeExpiry, afterExpiry] as const
+* })
+*
+* const actual = await Effect.runPromise(Effect.provide(program, TestClock.layer()))
+* actual // => [Option.some(5), Option.none()]
+* ```
+*
+* **Example** (Waiting for pending lookups)
+*
+* ```ts import.meta.vitest
+* import { Cache, Deferred, Effect, Fiber, Option } from "effect"
+*
+* // Waits for ongoing computation to complete
+* const program = Effect.gen(function*() {
+*   const deferred = yield* Deferred.make<void>()
+*   const cache = yield* Cache.make({
+*     capacity: 10,
+*     lookup: (_key: string) => Deferred.await(deferred).pipe(Effect.as(42))
+*   })
+*
+*   // Start lookup in background
+*   const getFiber = yield* Effect.forkChild(Cache.get(cache, "key"))
+*
+*   // getOption waits for ongoing computation
+*   const optionFiber = yield* Effect.forkChild(Cache.getOption(cache, "key"))
+*
+*   // Complete the computation
+*   yield* Deferred.succeed(deferred, void 0)
+*
+*   const result = yield* Fiber.join(optionFiber)
+*   const value = yield* Fiber.join(getFiber)
+*   return [result, value] as const
+* })
+*
+* const actual = await Effect.runPromise(program)
+* actual // => [Option.some(42), 42]
+* ```
+*
+* @category combinators
+* @since 4.0.0
+*/
+const getOption = /*#__PURE__*/ dual(2, (self, key) => withFiber((fiber) => {
+	const entry = getImpl(self, key, fiber);
+	return entry ? asSome(entry.await()) : succeedNone;
+}));
+const getImpl = (self, key, fiber, isRead = true) => {
+	const oentry = get$1(self.map, key);
+	if (isNone(oentry)) return;
+	else if (hasExpired(oentry.value, fiber)) {
+		remove(self.map, key);
+		return;
+	} else if (isRead) {
+		remove(self.map, key);
+		set$1(self.map, key, oentry.value);
+	}
+	return oentry.value;
+};
+/**
+* Sets the value associated with the specified key in the cache. This will
+* overwrite any existing value for that key, skipping the lookup function.
+*
+* **Example** (Setting values directly)
+*
+* ```ts import.meta.vitest
+* import { Cache, Effect } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const cache = yield* Cache.make({
+*     capacity: 100,
+*     lookup: (key: string) => Effect.succeed(key.length)
+*   })
+*
+*   // Set a value directly without invoking lookup
+*   yield* Cache.set(cache, "hello", 42)
+*   return yield* Cache.get(cache, "hello")
+* })
+*
+* const actual = await Effect.runPromise(program)
+* actual // => 42
+* ```
+*
+* **Example** (Overwriting cached values)
+*
+* ```ts import.meta.vitest
+* import { Cache, Effect } from "effect"
+*
+* // Overwriting existing cached values
+* const program = Effect.gen(function*() {
+*   const cache = yield* Cache.make({
+*     capacity: 100,
+*     lookup: (key: string) => Effect.succeed(key.length)
+*   })
+*
+*   // First get populates via lookup
+*   const original = yield* Cache.get(cache, "test") // 4
+*
+*   // Set overwrites the cached value
+*   yield* Cache.set(cache, "test", 999)
+*   const updated = yield* Cache.get(cache, "test") // 999
+*
+*   return { original, updated }
+* })
+*
+* const actual = await Effect.runPromise(program)
+* actual // => { original: 4, updated: 999 }
+* ```
+*
+* **Example** (Applying TTL to set values)
+*
+* ```ts import.meta.vitest
+* import { Cache, Effect } from "effect"
+* import { TestClock } from "effect/testing"
+*
+* // TTL behavior with set operations
+* const program = Effect.gen(function*() {
+*   const cache = yield* Cache.make({
+*     capacity: 100,
+*     lookup: (key: string) => Effect.succeed(key.length),
+*     timeToLive: "1 hour"
+*   })
+*
+*   // Set value with TTL applied
+*   yield* Cache.set(cache, "temporary", 123)
+*   const beforeExpiry = yield* Cache.has(cache, "temporary")
+*
+*   // Advance time past TTL
+*   yield* TestClock.adjust("2 hours")
+*   const afterExpiry = yield* Cache.has(cache, "temporary")
+*   return [beforeExpiry, afterExpiry]
+* })
+*
+* const actual = await Effect.runPromise(Effect.provide(program, TestClock.layer()))
+* actual // => [true, false]
+* ```
+*
+* **Example** (Enforcing capacity when setting values)
+*
+* ```ts import.meta.vitest
+* import { Cache, Effect } from "effect"
+*
+* // Capacity enforcement with set operations
+* const program = Effect.gen(function*() {
+*   const cache = yield* Cache.make({
+*     capacity: 2,
+*     lookup: (key: string) => Effect.succeed(key.length)
+*   })
+*
+*   // Fill cache to capacity
+*   yield* Cache.set(cache, "a", 1)
+*   yield* Cache.set(cache, "b", 2)
+*   const sizeBeforeEviction = yield* Cache.size(cache)
+*
+*   // Adding another entry evicts oldest
+*   yield* Cache.set(cache, "c", 3)
+*   const sizeAfterEviction = yield* Cache.size(cache)
+*   const hasOldest = yield* Cache.has(cache, "a")
+*   const hasNewest = yield* Cache.has(cache, "c")
+*   return [sizeBeforeEviction, sizeAfterEviction, hasOldest, hasNewest]
+* })
+*
+* const actual = await Effect.runPromise(program)
+* actual // => [2, 2, false, true]
+* ```
+*
+* @category combinators
+* @since 4.0.0
+*/
+const set = /*#__PURE__*/ dual(3, (self, key, value) => withFiber((fiber) => {
+	const exit = exitSucceed(value);
+	const entry = new EntryImpl(fiber, exit);
+	const ttl = self.timeToLive(exit, key);
+	if (isZero(ttl)) {
+		remove(self.map, key);
+		return void_;
+	}
+	entry.expiresAt = isFinite(ttl) ? fiber.getRef(ClockRef).currentTimeMillisUnsafe() + toMillis(ttl) : void 0;
+	set$1(self.map, key, entry);
+	checkCapacity(self);
+	return void_;
+}));
+/**
+* Invalidates the entry associated with the specified key in the cache.
+*
+* **Example** (Invalidating cached entries)
+*
+* ```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)
+*   })
+*
+*   // Add a value to the cache
+*   yield* Cache.get(cache, "hello")
+*   const beforeInvalidation = yield* Cache.has(cache, "hello")
+*
+*   // Invalidate the entry
+*   yield* Cache.invalidate(cache, "hello")
+*   const afterInvalidation = yield* Cache.has(cache, "hello")
+*
+*   // Invalidating non-existent keys doesn't error
+*   yield* Cache.invalidate(cache, "nonexistent")
+*
+*   // Get after invalidation will invoke lookup again
+*   let lookupCount = 0
+*   const cache2 = yield* Cache.make({
+*     capacity: 10,
+*     lookup: (key: string) =>
+*       Effect.sync(() => {
+*         lookupCount++
+*         return key.length
+*       })
+*   })
+*
+*   yield* Cache.get(cache2, "test") // lookupCount = 1
+*   yield* Cache.invalidate(cache2, "test")
+*   yield* Cache.get(cache2, "test") // lookupCount = 2 (lookup called again)
+*   return { beforeInvalidation, afterInvalidation, lookupCount }
+* })
+*
+* const actual = await Effect.runPromise(program)
+* actual // => { beforeInvalidation: true, afterInvalidation: false, lookupCount: 2 }
+* ```
+*
+* @category combinators
+* @since 4.0.0
+*/
+const invalidate = /*#__PURE__*/ dual(2, (self, key) => sync(() => {
+	remove(self.map, key);
+}));
+/**
+* Retrieves all active keys from the cache, automatically filtering out expired entries.
+*
+* **Example** (Reading active keys)
+*
+* ```ts import.meta.vitest
+* import { Cache, Effect } from "effect"
+*
+* // Basic key enumeration
+* const program = Effect.gen(function*() {
+*   const cache = yield* Cache.make({
+*     capacity: 10,
+*     lookup: (key: string) => Effect.succeed(key.length)
+*   })
+*
+*   // Add some entries to the cache
+*   yield* Cache.get(cache, "hello")
+*   yield* Cache.get(cache, "world")
+*   yield* Cache.get(cache, "cache")
+*
+*   // Retrieve all active keys
+*   const keys = yield* Cache.keys(cache)
+*   return Array.from(keys).sort()
+* })
+*
+* const actual = await Effect.runPromise(program)
+* actual // => ["cache", "hello", "world"]
+* ```
+*
+* @category combinators
+* @since 4.0.0
+*/
+const keys = (self) => withFiber((fiber) => {
+	const now = fiber.getRef(ClockRef).currentTimeMillisUnsafe();
+	return succeed(filterMap(self.map, ([key, entry]) => {
+		if (entry.expiresAt === void 0 || entry.expiresAt > now) return succeed$1(key);
+		remove(self.map, key);
+		return failVoid;
+	}));
+});
+//#endregion
+//#region ../../node_modules/.pnpm/effect@4.0.0-beta.103_patch_hash=a18f963109656ddbeb2a99ca45f942ecf54830986259eb01ce6a970421c9c6a9/node_modules/effect/dist/unstable/reactivity/Reactivity.js
+/**
+* Process-local invalidation for connecting writes to dependent reads.
+*
+* This module does not cache values itself. It lets callers register handlers
+* for keys, invalidate those keys, wrap successful mutations so they invalidate
+* keys, and expose effects as queues or streams that rerun when matching keys
+* change. The service can also batch invalidations so handlers run after the
+* batch completes.
+*
+* @since 4.0.0
+*/
+/**
+* Service for key-based reactive invalidation.
+*
+* **When to use**
+*
+* Use to provide the invalidation service that refreshes queries, streams, and
+* atoms when application keys change.
+*
+* **Details**
+*
+* The service can register handlers for keys, invalidate those keys, wrap
+* mutations so successful effects invalidate keys, and turn query effects into
+* queues or streams that rerun when keys are invalidated.
+*
+* @category services
+* @since 4.0.0
+*/
+var Reactivity = class extends Service()("effect/reactivity/Reactivity") {};
+/**
+* Creates an in-memory `Reactivity` service.
+*
+* **Details**
+*
+* The service tracks handlers by hashed keys and runs the registered handlers when
+* matching keys are invalidated.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const make$2 = /*#__PURE__*/ sync$1(() => {
+	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$1((services) => {
+		const pending = services.mapUnsafe.get(PendingInvalidation.key);
+		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]);
+				set.delete(handler);
+				if (set.size === 0) handlers.delete(resolvedKeys[i]);
+			}
+		};
+	};
+	const query = (keys, effect) => gen(function* () {
+		const services = yield* context();
+		const scope = get$2(services, Scope);
+		const results = yield* make$5();
+		const runFork = flow(runForkWith(services), runIn(scope));
+		let running = false;
+		let pending = false;
+		const handleExit = (exit) => {
+			if (exit._tag === "Failure") failCauseUnsafe(results, exit.cause);
+			else offerUnsafe(results, exit.value);
+			if (pending) {
+				pending = false;
+				runFork(effect).addObserver(handleExit);
+			} else running = false;
+		};
+		function run() {
+			if (running) {
+				pending = true;
+				return;
+			}
+			running = true;
+			runFork(effect).addObserver(handleExit);
+		}
+		yield* addFinalizer(scope, sync$1(registerUnsafe(keys, run)));
+		run();
+		return results;
+	});
+	const stream = (tables, effect) => query(tables, effect).pipe(map(fromQueue), unwrap);
+	const withBatch = (effect) => suspend(() => {
+		const pending = /* @__PURE__ */ new Set();
+		return effect.pipe(provideService(PendingInvalidation, pending), onExit$1((_) => sync$1(() => {
+			pending.forEach((hash) => {
+				const set = handlers.get(hash);
+				if (set === void 0) return;
+				set.forEach((run) => run());
+			});
+		})));
+	});
+	return Reactivity.of({
+		mutation,
+		query,
+		stream,
+		invalidateUnsafe,
+		invalidate,
+		registerUnsafe,
+		withBatch
+	});
+});
+var PendingInvalidation = class extends Service()("effect/reactivity/Reactivity/PendingInvalidation") {};
+/**
+* The default layer that provides an in-memory `Reactivity` service.
+*
+* @category layers
+* @since 4.0.0
+*/
+const layer = /*#__PURE__*/ effect(Reactivity)(make$2);
+function stringOrHash(u) {
+	switch (typeof u) {
+		case "string":
+		case "number":
+		case "bigint":
+		case "boolean": return String(u);
+		default: return hash(u);
+	}
+}
+const keysToHashes = (keys, f) => {
+	if (Array.isArray(keys)) {
+		for (let i = 0; i < keys.length; i++) f(stringOrHash(keys[i]));
+		return;
+	}
+	for (const key in keys) {
+		f(key);
+		const ids = keys[key];
+		for (let i = 0; i < ids.length; i++) f(`${key}:${stringOrHash(ids[i])}`);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/effect@4.0.0-beta.103_patch_hash=a18f963109656ddbeb2a99ca45f942ecf54830986259eb01ce6a970421c9c6a9/node_modules/effect/dist/unstable/sql/Statement.js
+/**
+* Low-level SQL statement and fragment primitives.
+*
+* `SqlClient` uses this module to build executable, parameterized SQL from
+* reusable fragments. A statement can be executed, streamed, run without row
+* transformation, or compiled to SQL text and parameters for a specific
+* dialect. The module also contains helpers for identifiers, parameters,
+* inserts, updates, custom dialect fragments, statement compilation, and row
+* transformation.
+*
+* @since 4.0.0
+*/
+const FragmentTypeId = "~effect/sql/Fragment";
+/**
+* Constructs a SQL `Fragment` from low-level statement segments.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const fragment = (segments) => ({
+	[FragmentTypeId]: FragmentTypeId,
+	segments
+});
+/**
+* Context reference for an optional current SQL statement transformer applied
+* before statement execution.
+*
+* @category services
+* @since 4.0.0
+*/
+const CurrentTransformer = /*#__PURE__*/ Reference("effect/sql/CurrentTransformer", { defaultValue: constUndefined });
+/**
+* Returns `true` when a value is a SQL `Fragment`.
+*
+* @category guards
+* @since 4.0.0
+*/
+const isFragment = (u) => hasProperty(u, FragmentTypeId);
+/**
+* Constructs a raw SQL literal segment. The literal text is not escaped, so use
+* bound parameters for untrusted values.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const literal = (value, params) => ({
+	_tag: "Literal",
+	value,
+	params
+});
+/**
+* Constructs a SQL identifier segment that will be escaped by the active
+* compiler.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const identifier = (value) => ({
+	_tag: "Identifier",
+	value
+});
+/**
+* Constructs a bound parameter segment for a statement value.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const parameter = (value) => ({
+	_tag: "Parameter",
+	value
+});
+/**
+* Constructs an `ArrayHelper` segment for an array of values or fragments.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const arrayHelper = (value) => ({
+	_tag: "ArrayHelper",
+	value
+});
+const RecordInsertHelperProto = {
+	_tag: "RecordInsertHelper",
+	returning(sql) {
+		const self = Object.create(Object.getPrototypeOf(this));
+		Object.assign(self, this, { returningIdentifier: sql });
+		return self;
+	}
+};
+/**
+* Constructs a `RecordInsertHelper` from one or more row objects.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const recordInsertHelper = (value) => Object.assign(Object.create(RecordInsertHelperProto), {
+	value,
+	returningIdentifier: void 0
+});
+const RecordUpdateHelperProto = {
+	...RecordInsertHelperProto,
+	_tag: "RecordUpdateHelper"
+};
+/**
+* Constructs a `RecordUpdateHelper` for multi-row update compilation using the
+* provided alias.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const recordUpdateHelper = (value, alias) => Object.assign(Object.create(RecordUpdateHelperProto), {
+	value,
+	alias,
+	returningIdentifier: void 0
+});
+const RecordUpdateHelperSingleProto = {
+	...RecordInsertHelperProto,
+	_tag: "RecordUpdateHelperSingle"
+};
+/**
+* Constructs a `RecordUpdateHelperSingle` from a record and a list of columns
+* to omit from the update.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const recordUpdateHelperSingle = (value, omit) => Object.assign(Object.create(RecordUpdateHelperSingleProto), {
+	value,
+	omit,
+	returningIdentifier: void 0
+});
+/**
+* Creates a cached SQL statement constructor from a connection acquirer,
+* compiler, tracing attributes, and optional row transformation function.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const make$1 = (acquirer, compiler, spanAttributes, transformRows) => {
+	const cache = transformRows === void 0 ? constructorCache.noTransforms : constructorCache.transforms;
+	if (cache.has(acquirer)) return cache.get(acquirer);
+	const self = Object.assign(function sql(strings, ...args) {
+		if (typeof strings === "string") return identifier(strings);
+		else if (Array.isArray(strings) && "raw" in strings) return statement(acquirer, compiler, strings, args, spanAttributes, transformRows);
+		throw "absurd";
+	}, {
+		unsafe(sql, params) {
+			return makeUnsafe([literal(sql, params)], acquirer, compiler, spanAttributes, transformRows);
+		},
+		literal(sql) {
+			return fragment([literal(sql)]);
+		},
+		in: in_,
+		insert(value) {
+			return recordInsertHelper(Array.isArray(value) ? value : [value]);
+		},
+		update(value, omit) {
+			return recordUpdateHelperSingle(value, omit ?? []);
+		},
+		updateValues(value, alias) {
+			return recordUpdateHelper(value, alias);
+		},
+		and,
+		or,
+		csv,
+		join,
+		onDialect(options) {
+			return options[compiler.dialect]();
+		},
+		onDialectOrElse(options) {
+			return options[compiler.dialect] !== void 0 ? options[compiler.dialect]() : options.orElse();
+		}
+	});
+	cache.set(acquirer, self);
+	return self;
+};
+const constructorCache = {
+	transforms: /*#__PURE__*/ new WeakMap(),
+	noTransforms: /*#__PURE__*/ new WeakMap()
+};
+/**
+* Builds a `Statement` from template strings and arguments, preserving
+* fragments and helper segments while converting ordinary interpolated values
+* into bound parameters.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const statement = (acquirer, compiler, strings, args, spanAttributes, transformRows) => {
+	const segments = strings[0].length > 0 ? [literal(strings[0])] : [];
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (isFragment(arg)) segments.push(...arg.segments);
+		else if (isSegment(arg)) segments.push(arg);
+		else segments.push(parameter(arg));
+		if (strings[i + 1].length > 0) segments.push(literal(strings[i + 1]));
+	}
+	return makeUnsafe(segments, acquirer, compiler, spanAttributes, transformRows);
+};
+/**
+* Creates a helper that joins SQL clauses with a literal separator, optionally
+* wrapping multiple clauses in parentheses and using a fallback for an empty
+* list.
+*
+* @category constructors
+* @since 4.0.0
+*/
+function join(lit, addParens = true, fallback = "") {
+	const literalStatement = literal(lit);
+	const fallbackFragment = fragment([literal(fallback)]);
+	return (clauses) => {
+		if (clauses.length === 0) return fallbackFragment;
+		else if (clauses.length === 1) return fragment(convertLiteralOrFragment(clauses[0]));
+		const segments = [];
+		if (addParens) segments.push(literal("("));
+		segments.push.apply(segments, convertLiteralOrFragment(clauses[0]));
+		for (let i = 1; i < clauses.length; i++) {
+			segments.push(literalStatement);
+			segments.push.apply(segments, convertLiteralOrFragment(clauses[i]));
+		}
+		if (addParens) segments.push(literal(")"));
+		return fragment(segments);
+	};
+}
+/**
+* Combines clauses with `AND`, parenthesizing multiple clauses and returning
+* `1=1` when the list is empty.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const and = /*#__PURE__*/ join(" AND ", true, "1=1");
+/**
+* Combines clauses with `OR`, parenthesizing multiple clauses and returning
+* `1=1` when the list is empty.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const or = /*#__PURE__*/ join(" OR ", true, "1=1");
+/**
+* Creates a comma-separated SQL fragment from values, optionally adding a
+* prefix, and returns an empty fragment when no values are provided.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const csv = function(...args) {
+	if (args[args.length - 1].length === 0) return emptyFragment;
+	if (args.length === 1) return csvRaw(args[0]);
+	return fragment([literal(`${args[0]} `), ...csvRaw(args[1]).segments]);
+};
+const csvRaw = /*#__PURE__*/ join(",", false);
+const emptyFragment = /*#__PURE__*/ fragment([/*#__PURE__*/ literal("")]);
+/**
+* Creates a dialect-specific SQL `Compiler` from rendering callbacks.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const makeCompiler = (options) => {
+	const self = Object.create(CompilerProto);
+	self.options = options;
+	self.dialect = options.dialect;
+	self.disableTransforms = false;
+	return self;
+};
+const statementCacheSymbol = /*#__PURE__*/ Symbol.for("effect/unstable/sql/Statement/statementCache");
+const statementCacheNoTransformSymbol = /*#__PURE__*/ Symbol.for("effect/unstable/sql/Statement/statementCacheNoTransform");
+const CompilerProto = {
+	compile(statement, withoutTransform = false, placeholderOverride) {
+		const opts = this.options;
+		withoutTransform = withoutTransform || this.disableTransforms;
+		const cacheSymbol = withoutTransform ? statementCacheNoTransformSymbol : statementCacheSymbol;
+		if (cacheSymbol in statement) return statement[cacheSymbol];
+		const segments = statement.segments;
+		const len = segments.length;
+		let sql = "";
+		const binds = [];
+		let placeholderCount = 0;
+		const placeholder = placeholderOverride ?? ((u) => opts.placeholder(++placeholderCount, u));
+		const placeholderNoIncrement = (u) => opts.placeholder(placeholderCount, u);
+		const placeholders = makePlaceholdersArray(placeholder);
+		for (let i = 0; i < len; i++) {
+			const segment = segments[i];
+			switch (segment._tag) {
+				case "Literal":
+					sql += segment.value;
+					if (segment.params) binds.push.apply(binds, segment.params);
+					break;
+				case "Identifier":
+					sql += opts.onIdentifier(segment.value, withoutTransform);
+					break;
+				case "Parameter":
+					sql += placeholder(segment.value);
+					binds.push(segment.value);
+					break;
+				case "ArrayHelper":
+					sql += `(${placeholders(segment.value)})`;
+					binds.push.apply(binds, segment.value);
+					break;
+				case "RecordInsertHelper": {
+					const keys = Object.keys(segment.value[0]);
+					if (opts.onInsert) {
+						const values = new Array(segment.value.length);
+						let placeholders = "";
+						for (let i = 0; i < segment.value.length; i++) {
+							const row = new Array(keys.length);
+							values[i] = row;
+							placeholders += i === 0 ? "(" : ",(";
+							for (let j = 0; j < keys.length; j++) {
+								const key = keys[j];
+								const value = segment.value[i][key];
+								row[j] = extractPrimitive(value, opts.onCustom, placeholderNoIncrement, withoutTransform);
+								placeholders += j === 0 ? placeholder(value) : `,${placeholder(value)}`;
+							}
+							placeholders += ")";
+						}
+						const [s, b] = opts.onInsert(keys.map((_) => opts.onIdentifier(_, withoutTransform)), placeholders, values, typeof segment.returningIdentifier === "string" ? [segment.returningIdentifier, []] : segment.returningIdentifier ? this.compile(segment.returningIdentifier, withoutTransform, placeholder) : void 0);
+						sql += s;
+						binds.push.apply(binds, b);
+					} else {
+						let placeholders = "";
+						for (let i = 0; i < segment.value.length; i++) {
+							placeholders += i === 0 ? "(" : ",(";
+							for (let j = 0; j < keys.length; j++) {
+								const value = segment.value[i][keys[j]];
+								const primitive = extractPrimitive(value, opts.onCustom, placeholderNoIncrement, withoutTransform);
+								binds.push(primitive);
+								placeholders += j === 0 ? placeholder(value) : `,${placeholder(value)}`;
+							}
+							placeholders += ")";
+						}
+						sql += `${generateColumns(keys, opts.onIdentifier, withoutTransform)} VALUES ${placeholders}`;
+						if (typeof segment.returningIdentifier === "string") sql += ` RETURNING ${segment.returningIdentifier}`;
+						else if (segment.returningIdentifier) {
+							sql += " RETURNING ";
+							const [s, b] = this.compile(segment.returningIdentifier, withoutTransform, placeholder);
+							sql += s;
+							binds.push.apply(binds, b);
+						}
+					}
+					break;
+				}
+				case "RecordUpdateHelperSingle": {
+					let keys = Object.keys(segment.value);
+					if (segment.omit.length > 0) keys = keys.filter((key) => !segment.omit.includes(key));
+					if (opts.onRecordUpdateSingle) {
+						const [s, b] = opts.onRecordUpdateSingle(keys.map((_) => opts.onIdentifier(_, withoutTransform)), keys.map((key) => extractPrimitive(segment.value[key], opts.onCustom, placeholderNoIncrement, withoutTransform)), typeof segment.returningIdentifier === "string" ? [segment.returningIdentifier, []] : segment.returningIdentifier ? this.compile(segment.returningIdentifier, withoutTransform, placeholder) : void 0);
+						sql += s;
+						binds.push.apply(binds, b);
+					} else {
+						for (let i = 0, len = keys.length; i < len; i++) {
+							const column = opts.onIdentifier(keys[i], withoutTransform);
+							if (i === 0) sql += `${column} = ${placeholder(segment.value[keys[i]])}`;
+							else sql += `, ${column} = ${placeholder(segment.value[keys[i]])}`;
+							binds.push(extractPrimitive(segment.value[keys[i]], opts.onCustom, placeholderNoIncrement, withoutTransform));
+						}
+						if (typeof segment.returningIdentifier === "string") if (this.dialect === "mssql") sql += ` OUTPUT ${segment.returningIdentifier === "*" ? "INSERTED.*" : segment.returningIdentifier}`;
+						else sql += ` RETURNING ${segment.returningIdentifier}`;
+						else if (segment.returningIdentifier) {
+							sql += this.dialect === "mssql" ? " OUTPUT " : " RETURNING ";
+							const [s, b] = this.compile(segment.returningIdentifier, withoutTransform, placeholder);
+							sql += s;
+							binds.push.apply(binds, b);
+						}
+					}
+					break;
+				}
+				case "RecordUpdateHelper": {
+					const keys = Object.keys(segment.value[0]);
+					const values = new Array(segment.value.length);
+					let placeholders = "";
+					for (let i = 0; i < segment.value.length; i++) {
+						const row = new Array(keys.length);
+						values[i] = row;
+						placeholders += i === 0 ? "(" : ",(";
+						for (let j = 0; j < keys.length; j++) {
+							const key = keys[j];
+							const value = segment.value[i][key];
+							row[j] = extractPrimitive(value, opts.onCustom, placeholderNoIncrement, withoutTransform);
+							placeholders += j === 0 ? placeholder(value) : `,${placeholder(value)}`;
+						}
+						placeholders += ")";
+					}
+					const [s, b] = opts.onRecordUpdate(placeholders, segment.alias, generateColumns(keys, opts.onIdentifier, withoutTransform), values, typeof segment.returningIdentifier === "string" ? [segment.returningIdentifier, []] : segment.returningIdentifier ? this.compile(segment.returningIdentifier, withoutTransform, placeholder) : void 0);
+					sql += s;
+					binds.push.apply(binds, b);
+					break;
+				}
+				case "Custom": {
+					const [s, b] = opts.onCustom(segment, placeholder, withoutTransform);
+					sql += s;
+					binds.push.apply(binds, b);
+					break;
+				}
+			}
+		}
+		const result = [sql, binds];
+		if (placeholderOverride !== void 0) return result;
+		return statement[cacheSymbol] = result;
+	},
+	get withoutTransform() {
+		const self = Object.create(CompilerProto);
+		Object.assign(self, this, { disableTransforms: true });
+		return self;
+	}
+};
+/**
+* Creates a SQLite compiler that uses `?` placeholders and quoted identifiers,
+* optionally transforming identifier names before escaping.
+*
+* @category 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 = (segments, acquirer, compiler, spanAttributes, transformRows) => {
+	const self = Object.create(StatementProto);
+	self.segments = segments;
+	self.acquirer = acquirer;
+	self.compiler = compiler;
+	self.spanAttributes = spanAttributes;
+	self.transformRows = transformRows;
+	return self;
+};
+const StatementProto = {
+	[FragmentTypeId]: FragmentTypeId,
+	withConnection(operation, f, withoutTransform = false) {
+		return useSpan("sql.execute", { kind: "client" }, (span) => this.withConnectionSpan(operation, f, withoutTransform, span));
+	},
+	withConnectionSpan(operation, f, withoutTransform, span) {
+		return withStatement(this, span, (statement) => {
+			const [sql, params] = statement.compile(withoutTransform);
+			for (const [key, value] of this.spanAttributes) span.attribute(key, value);
+			span.attribute(ATTR_DB_OPERATION_NAME, operation);
+			span.attribute(ATTR_DB_QUERY_TEXT, sql);
+			return scoped(flatMap(this.acquirer, (_) => f(_, sql, params)));
+		});
+	},
+	get withoutTransform() {
+		return this.withConnection("executeWithoutTransform", (connection, sql, params) => connection.execute(sql, params, void 0), true);
+	},
+	get raw() {
+		return this.withConnection("executeRaw", (connection, sql, params) => connection.executeRaw(sql, params), true);
+	},
+	get stream() {
+		const self = this;
+		return unwrap(flatMap(makeSpanScoped("sql.execute", { kind: "client" }), (span) => withStatement(self, span, (statement) => {
+			const [sql, params] = statement.compile();
+			for (const [key, value] of self.spanAttributes) span.attribute(key, value);
+			span.attribute(ATTR_DB_OPERATION_NAME, "executeStream");
+			span.attribute(ATTR_DB_QUERY_TEXT, sql);
+			return map(self.acquirer, (_) => _.executeStream(sql, params, self.transformRows));
+		})));
+	},
+	get values() {
+		return this.withConnection("executeValues", (connection, sql, params) => connection.executeValues(sql, params));
+	},
+	get valuesUnprepared() {
+		return this.withConnection("executeValuesUnprepared", (connection, sql, params) => connection.executeValuesUnprepared(sql, params));
+	},
+	get unprepared() {
+		const self = this;
+		return self.withConnection("executeUnprepared", (connection, sql, params) => connection.executeUnprepared(sql, params, self.transformRows));
+	},
+	.../*#__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$1(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$1((fiber) => {
+	const transform = fiber.getRef(CurrentTransformer);
+	if (transform === void 0) return f(self);
+	return flatMap(transform(self, make$1(self.acquirer, self.compiler, self.spanAttributes, self.transformRows), fiber, span), f);
+});
+const isSegment = (u) => {
+	if (!hasProperty(u, "_tag")) return false;
+	switch (u._tag) {
+		case "Literal":
+		case "Parameter":
+		case "ArrayHelper":
+		case "RecordInsertHelper":
+		case "RecordUpdateHelper":
+		case "RecordUpdateHelperSingle":
+		case "Identifier":
+		case "Custom": return true;
+		default: return false;
+	}
+};
+function convertLiteralOrFragment(clause) {
+	if (typeof clause === "string") return [literal(clause)];
+	return clause.segments;
+}
+const makePlaceholdersArray = (evaluate) => (values) => {
+	if (values.length === 0) return "";
+	let result = evaluate(values[0]);
+	for (let i = 1; i < values.length; i++) result += `,${evaluate(values[i])}`;
+	return result;
+};
+const generateColumns = (keys, escape, withoutTransform) => {
+	if (keys.length === 0) return "()";
+	let str = `(${escape(keys[0], withoutTransform)}`;
+	for (let i = 1; i < keys.length; i++) str += `,${escape(keys[i], withoutTransform)}`;
+	return str + ")";
+};
+const extractPrimitive = (value, onCustom, placeholder, withoutTransform) => {
+	if (value === void 0) return null;
+	else if (isFragment(value)) {
+		const head = value.segments[0];
+		if (head._tag === "Custom") return onCustom(head, placeholder, withoutTransform)[1][0] ?? null;
+		else if (head._tag === "Parameter") return head.value;
+		return null;
+	}
+	return value;
+};
+const escapeSqlite = /*#__PURE__*/ defaultEscape("\"");
+function in_() {
+	if (arguments.length === 1) return arrayHelper(arguments[0]);
+	const column = arguments[0];
+	const values = arguments[1];
+	return values.length === 0 ? neverFragment : fragment([
+		identifier(column),
+		literal(" IN "),
+		arrayHelper(values)
+	]);
+}
+const neverFragment = /*#__PURE__*/ fragment([/*#__PURE__*/ literal("1=0")]);
+//#endregion
+//#region ../../node_modules/.pnpm/effect@4.0.0-beta.103_patch_hash=a18f963109656ddbeb2a99ca45f942ecf54830986259eb01ce6a970421c9c6a9/node_modules/effect/dist/unstable/sql/SqlClient.js
+/**
+* Main SQL client service for tagged-template queries.
+*
+* `SqlClient` combines the tagged-template statement constructor with
+* connection acquisition, dialect compilation, transactions, row transforms,
+* tracing, and reactive query helpers. Driver integrations build this service
+* from their connection and compiler pieces.
+*
+* @since 4.0.0
+*/
+const TypeId = "~effect/sql/SqlClient";
+/**
+* Service tag for the active SQL client service.
+*
+* **When to use**
+*
+* Use to access or provide the SQL client used to build statements, stream
+* rows, reserve connections, and run transactions.
+*
+* @category services
+* @since 4.0.0
+*/
+const SqlClient = /*#__PURE__*/ Service("effect/sql/SqlClient");
+let clientIdCounter = 0;
+/**
+* Constructs a `SqlClient` from connection acquirers, a compiler, transaction
+* commands, tracing attributes, optional row transforms, and reactive query
+* integration.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const make = /*#__PURE__*/ fnUntraced(function* (options) {
+	const transactionService = options.transactionService ?? TransactionConnection(clientIdCounter++);
+	const getConnection = flatMap(serviceOption(transactionService), match({
+		onNone: () => options.acquirer,
+		onSome: ([conn]) => succeed$2(conn)
+	}));
+	const beginTransaction = options.beginTransaction ?? "BEGIN";
+	const commit = options.commit ?? "COMMIT";
+	const savepoint = options.savepoint ?? ((name) => `SAVEPOINT ${name}`);
+	const rollback = options.rollback ?? "ROLLBACK";
+	const rollbackSavepoint = options.rollbackSavepoint ?? ((name) => `ROLLBACK TO SAVEPOINT ${name}`);
+	const transactionAcquirer = options.transactionAcquirer ?? options.acquirer;
+	const withTransaction = makeWithTransaction({
+		transactionService,
+		spanAttributes: options.spanAttributes,
+		acquireConnection: flatMap(make$6(), (scope) => map(provide(transactionAcquirer, scope), (conn) => [scope, conn])),
+		begin: (conn) => conn.executeUnprepared(beginTransaction, [], void 0),
+		savepoint: (conn, id) => conn.executeUnprepared(savepoint(`effect_sql_${id}`), [], void 0),
+		commit: (conn) => conn.executeUnprepared(commit, [], void 0),
+		rollback: (conn) => conn.executeUnprepared(rollback, [], void 0),
+		rollbackSavepoint: (conn, id) => conn.executeUnprepared(rollbackSavepoint(`effect_sql_${id}`), [], void 0)
+	});
+	const reactivity = yield* Reactivity;
+	const client = Object.assign(make$1(getConnection, options.compiler, options.spanAttributes, options.transformRows), {
+		[TypeId]: TypeId,
+		safe: void 0,
+		withTransaction,
+		transactionService,
+		reserve: transactionAcquirer,
+		withoutTransforms() {
+			if (options.transformRows === void 0) return this;
+			const statement = make$1(getConnection, options.compiler.withoutTransform, options.spanAttributes, void 0);
+			const client = Object.assign(statement, {
+				...this,
+				...statement
+			});
+			client.safe = client;
+			client.withoutTransforms = () => client;
+			return client;
+		},
+		reactive: options.reactiveQueue ? (keys, effect) => options.reactiveQueue(keys, effect).pipe(map(fromQueue), unwrap) : reactivity.stream,
+		reactiveMailbox: options.reactiveQueue ?? reactivity.query
+	});
+	client.safe = client;
+	return client;
+});
+/**
+* Builds a transaction wrapper that begins top-level transactions, uses
+* savepoints for nested transactions, commits on success, and rolls back on
+* failure or interruption.
+*
+* @category transactions
+* @since 4.0.0
+*/
+const makeWithTransaction = (options) => (effect) => {
+	return uninterruptibleMask((restore) => useSpan("sql.transaction", { kind: "client" }, (span) => withFiber$1((fiber) => {
+		for (const [key, value] of options.spanAttributes) span.attribute(key, value);
+		const services = fiber.context;
+		const clock = fiber.getRef(Clock);
+		const connOption = getOption$1(services, options.transactionService);
+		const conn = connOption._tag === "Some" ? succeed$2([void 0, connOption.value[0]]) : options.acquireConnection;
+		const id = connOption._tag === "Some" ? connOption.value[1] + 1 : 0;
+		return flatMap(conn, ([scope, conn]) => (id === 0 ? options.begin(conn) : options.savepoint(conn, id)).pipe(flatMap(() => provideContext(restore(effect), services.pipe(add(options.transactionService, [conn, id]), add(ParentSpan, span)))), exit, flatMap((exit) => {
+			let effect;
+			if (isSuccess(exit)) if (id === 0) {
+				span.event("db.transaction.commit", clock.currentTimeNanosUnsafe());
+				effect = orDie(options.commit(conn));
+			} else {
+				span.event("db.transaction.savepoint", clock.currentTimeNanosUnsafe());
+				effect = void_$1;
+			}
+			else {
+				span.event("db.transaction.rollback", clock.currentTimeNanosUnsafe());
+				effect = orDie(id > 0 ? options.rollbackSavepoint(conn, id) : options.rollback(conn));
+			}
+			return flatMap(scope !== void 0 ? ensuring(effect, close(scope, exit)) : effect, () => exit);
+		})));
+	})));
+};
+/**
+* Creates a unique context service tag for the active transaction connection of
+* a specific SQL client.
+*
+* @category services
+* @since 4.0.0
+*/
+const TransactionConnection = (clientId) => Service(`effect/sql/SqlClient/TransactionConnection/${clientId}`);
+/**
+* Context reference used by SQL integrations to opt in to safe integer
+* handling; defaults to `false`.
+*
+* @category services
+* @since 4.0.0
+*/
+const SafeIntegers = /*#__PURE__*/ Reference("effect/sql/SqlClient/SafeIntegers", { defaultValue: () => false });
+//#endregion
+export { makeCompilerSqlite as a, getOption as c, make$3 as d, makeWith as f, defaultTransforms as i, invalidate as l, SqlClient as n, layer as o, set as p, make as r, get as s, SafeIntegers as t, keys as u };
+
+//# sourceMappingURL=SqlClient-DcM69ZvI.mjs.map