t3code-cli 0.5.1 → 0.7.0

package/dist/layer-CfC5qZol.js

@@ -0,0 +1,1508 @@
+import { $t as hash, Tn as constUndefined, X as Prototype, a as get, an as hasProperty, bn as isTagged, h as mutate, k as match, kn as flow, n as Service, o as getOption, r as add, t as Reference } from "./Context-DueQ9iMH.js";
+import { $ as mapError, Ar as makeSpanUnsafe, At as tap, Br as ParentSpan, Bt as useSpan, C as context, Ct as serviceOption, D as ensuring, F as fnUntraced, H as fromResult, Jn as TracerTimingEnabled, Kn as provide, O as exit, Ot as suspend, P as fn, Rn as Scope, Rt as uninterruptibleMask, S as clockWith, Tt as succeed, U as gen, Ur as reason, Ut as withFiber, Vn as close, Vt as void_, Wn as make$4, X as map, Y as makeSpanScoped, _r as endSpan, a as badArgument, at as onExit, b as catchTags, dt as provideService, gt as runForkWith, j as flatMap, k as fail, kn as effect, kt as sync, sr as isSuccess, st as orDie, t as Path, ut as provideContext, v as catchFilter, w as contextWith, xt as scoped, y as catchTag, zn as addFinalizer } from "./Path-D8WPdPwR.js";
+import { Bn as Clock, Dn as runIn, Dt as fromQueue, Fn as encodeBase64Url, In as add$1, Ln as formatIso, Rn as now, Sn as offerUnsafe, dt as FileSystem, nn as unwrap, vn as failCauseUnsafe, yn as make$5, zn as toEpochMillis } from "./Schema-DsQxYh6_.js";
+import { r as decodeAuthLocalRuntimeStateFromJson, t as T3AuthTransport } from "./transport-D3zBdZ1h.js";
+import { ou as AuthAdministrativeScopes, zu as AuthSessionId } from "./src-KdbHqrex.js";
+import { n as T3Config, t as Environment } from "./service-CLmRO2Dp.js";
+import { a as mutate$1, i as fromString, t as normalizeHttpBaseUrl } from "./url-SlsaG8nY.js";
+import { a as AuthLocalSigningError, i as AuthLocalSecretError, n as AuthLocalDatabaseError, o as AuthPairingUrlError, r as AuthLocalError, t as AuthConfigError } from "./error-jwMt3VoW.js";
+import { n as resolveT3BaseDir } from "./base-dir-R12OMDso.js";
+//#region node_modules/.pnpm/effect@4.0.0-beta.78/node_modules/effect/dist/Crypto.js
+/**
+* The `Crypto` module provides a platform-agnostic service for cryptographic
+* operations. Runtime packages such as `@effect/platform-node`,
+* `@effect/platform-bun`, and `@effect/platform-browser` provide concrete
+* implementations backed by the host platform's cryptography APIs.
+*
+* Use `Crypto` for cryptographic randomness, UUID generation, random values,
+* and message digests. The base `Random` service is not cryptographically
+* secure unless you replace it with a cryptographically secure implementation.
+*
+* **Example** (Providing a test Crypto service)
+*
+* ```ts
+* import { Console, Crypto, Effect, Layer } from "effect"
+*
+* const TestCrypto = Layer.succeed(
+*   Crypto.Crypto,
+*   Crypto.make({
+*     randomBytes: (size) => new Uint8Array(size),
+*     digest: (_algorithm, data) => Effect.succeed(data)
+*   })
+* )
+*
+* const program = Effect.gen(function*() {
+*   const crypto = yield* Crypto.Crypto
+*   const id = yield* crypto.randomUUIDv4
+*   yield* Console.log(`Created id: ${id}`)
+* })
+*
+* Effect.runPromise(Effect.provide(program, TestCrypto))
+* ```
+*
+* **Example** (Generating random bytes)
+*
+* ```ts
+* import { Crypto, Effect, Layer } from "effect"
+*
+* const TestCrypto = Layer.succeed(
+*   Crypto.Crypto,
+*   Crypto.make({
+*     randomBytes: (size) => new Uint8Array(size),
+*     digest: (_algorithm, data) => Effect.succeed(data)
+*   })
+* )
+*
+* const program = Effect.gen(function*() {
+*   const crypto = yield* Crypto.Crypto
+*   return yield* crypto.randomBytes(32)
+* })
+*
+* Effect.runPromise(Effect.provide(program, TestCrypto))
+* ```
+*
+* @since 4.0.0
+*/
+const TypeId$1 = "~effect/platform/Crypto";
+/**
+* Service tag for platform cryptography.
+*
+* **When to use**
+*
+* Use when you need to provide or retrieve the full platform cryptography
+* service from an effect's context.
+*
+* **Details**
+*
+* Providing this service supplies platform-agnostic cryptographic operations
+* such as hashing, UUID generation, and secure random values.
+*
+* @see {@link make} for constructing a Crypto service from primitive operations
+*
+* @category services
+* @since 4.0.0
+*/
+const Crypto = /*#__PURE__*/ Service("effect/Crypto");
+/**
+* Creates a `Crypto` service from the primitive implementation, deriving the
+* random generator helpers and UUID generation from those primitives.
+*
+* **When to use**
+*
+* Use to build a Crypto service for a platform integration, test layer, or
+* custom runtime from primitive random-byte and digest operations.
+*
+* **Details**
+*
+* The constructor derives random numbers, booleans, integer ranges, shuffling,
+* and UUID generation from `impl.randomBytes`. Digest operations delegate to
+* `impl.digest`.
+*
+* **Gotchas**
+*
+* `impl.randomBytes` must return cryptographically secure bytes of the
+* requested length. UUID formatting mutates the byte array returned for UUID
+* generation, so the implementation should return a fresh array for each call.
+*
+* **Example** (Creating a Crypto service)
+*
+* ```ts
+* import { Crypto, Effect, Layer } from "effect"
+*
+* const TestCrypto = Layer.succeed(
+*   Crypto.Crypto,
+*   Crypto.make({
+*     randomBytes: (size) => new Uint8Array(size),
+*     digest: (_algorithm, data) => Effect.succeed(data)
+*   })
+* )
+* ```
+*
+* @category constructors
+* @since 4.0.0
+*/
+const make$3 = (impl) => {
+	const randomBytesUnsafe = impl.randomBytes;
+	const randomBytes = (size) => map(validateSize("randomBytes", size), randomBytesUnsafe);
+	const nextDoubleUnsafe = () => {
+		const bytes = randomBytesUnsafe(7);
+		return ((bytes[0] & 31) * 2 ** 48 + bytes[1] * 2 ** 40 + bytes[2] * 2 ** 32 + bytes[3] * 2 ** 24 + bytes[4] * 2 ** 16 + bytes[5] * 2 ** 8 + bytes[6]) / 2 ** 53;
+	};
+	const nextIntUnsafe = () => Math.floor(nextDoubleUnsafe() * (Number.MAX_SAFE_INTEGER - Number.MIN_SAFE_INTEGER + 1)) + Number.MIN_SAFE_INTEGER;
+	return Crypto.of({
+		[TypeId$1]: TypeId$1,
+		randomBytes,
+		nextDoubleUnsafe,
+		nextIntUnsafe,
+		digest: impl.digest,
+		random: sync(() => nextDoubleUnsafe()),
+		randomBoolean: sync(() => nextDoubleUnsafe() > .5),
+		randomInt: sync(() => nextIntUnsafe()),
+		randomBetween: (min, max) => sync(() => nextDoubleUnsafe() * (max - min) + min),
+		randomIntBetween(min, max, options) {
+			const extra = options?.halfOpen === true ? 0 : 1;
+			return sync(() => {
+				const minInt = Math.ceil(min);
+				const maxInt = Math.floor(max);
+				return Math.floor(nextDoubleUnsafe() * (maxInt - minInt + extra)) + minInt;
+			});
+		},
+		randomShuffle: (elements) => sync(() => {
+			const buffer = Array.from(elements);
+			for (let i = buffer.length - 1; i >= 1; i = i - 1) {
+				const index = Math.min(i, Math.floor(nextDoubleUnsafe() * (i + 1)));
+				const value = buffer[i];
+				buffer[i] = buffer[index];
+				buffer[index] = value;
+			}
+			return buffer;
+		}),
+		randomUUIDv4: sync(() => formatUUIDv4(randomBytesUnsafe(16))),
+		randomUUIDv7: clockWith((clock) => succeed(formatUUIDv7(clock.currentTimeMillisUnsafe(), randomBytesUnsafe(16))))
+	});
+};
+const validateSize = (method, size) => Number.isSafeInteger(size) && size >= 0 ? succeed(size) : fail(badArgument({
+	module: "Crypto",
+	method,
+	description: "size must be a non-negative safe integer"
+}));
+const hex = (byte) => byte.toString(16).padStart(2, "0");
+const formatUUID = (bytes) => {
+	return [
+		bytes.subarray(0, 4),
+		bytes.subarray(4, 6),
+		bytes.subarray(6, 8),
+		bytes.subarray(8, 10),
+		bytes.subarray(10, 16)
+	].map((segment) => Array.from(segment, hex).join("")).join("-");
+};
+const formatUUIDv4 = (bytes) => {
+	bytes[6] = bytes[6] & 15 | 64;
+	bytes[8] = bytes[8] & 63 | 128;
+	return formatUUID(bytes);
+};
+const maxUUIDv7Timestamp = 2 ** 48 - 1;
+const formatUUIDv7 = (timestampMillis, bytes) => {
+	const timestamp = Math.min(Math.max(0, Math.trunc(timestampMillis)), maxUUIDv7Timestamp);
+	bytes[0] = Math.floor(timestamp / 2 ** 40);
+	bytes[1] = Math.floor(timestamp / 2 ** 32) & 255;
+	bytes[2] = Math.floor(timestamp / 2 ** 24) & 255;
+	bytes[3] = Math.floor(timestamp / 2 ** 16) & 255;
+	bytes[4] = Math.floor(timestamp / 2 ** 8) & 255;
+	bytes[5] = timestamp & 255;
+	bytes[6] = bytes[6] & 15 | 112;
+	bytes[8] = bytes[8] & 63 | 128;
+	return formatUUID(bytes);
+};
+//#endregion
+//#region src/auth/service.ts
+var T3Auth = class extends Service()("t3cli/T3Auth") {};
+//#endregion
+//#region src/auth/local-base-dir.ts
+const resolveLocalBaseDir = fn("resolveLocalBaseDir")(function* (input) {
+	const environment = yield* Environment;
+	return yield* resolveT3BaseDir({
+		layout: {
+			cwd: environment.cwd,
+			homeDir: environment.homeDir,
+			t3codeHome: environment.env["T3CODE_HOME"]
+		},
+		baseDir: input.baseDir
+	});
+});
+//#endregion
+//#region src/auth/local-origin.ts
+var T3LocalAuthOrigin = class extends Service()("t3cli/T3LocalAuthOrigin") {};
+const makeT3LocalAuthOrigin = fn("makeT3LocalAuthOrigin")(function* () {
+	const fs = yield* FileSystem;
+	const path = yield* Path;
+	const environment = yield* Environment;
+	return { resolve: fn("T3LocalAuthOriginLive.resolve")(function* (input) {
+		const baseDir = yield* resolveLocalBaseDir({ baseDir: input?.baseDir }).pipe(provideService(Environment, environment), provideService(Path, path));
+		if (input?.origin !== void 0) return yield* normalizeLocalOrigin(input.origin);
+		const runtimeStatePath = path.join(baseDir, "userdata", "server-runtime.json");
+		return yield* normalizeLocalOrigin((yield* decodeAuthLocalRuntimeStateFromJson(yield* fs.readFileString(runtimeStatePath).pipe(mapError((error) => new AuthLocalError({
+			message: `local runtime state not found: ${runtimeStatePath}. Make sure T3 Code is running with Network access enabled, or pass --origin manually.`,
+			cause: error
+		})))).pipe(mapError((error) => new AuthLocalError({
+			message: "local runtime state has invalid shape",
+			cause: error
+		})))).origin);
+	}) };
+});
+const T3LocalAuthOriginLive = effect(T3LocalAuthOrigin, makeT3LocalAuthOrigin());
+function normalizeLocalOrigin(origin) {
+	return normalizeHttpBaseUrl(origin).pipe(mapError((error) => new AuthLocalError({
+		message: error.message,
+		cause: error
+	})));
+}
+//#endregion
+//#region node_modules/.pnpm/effect@4.0.0-beta.78/node_modules/effect/dist/unstable/reactivity/Reactivity.js
+/**
+* The `Reactivity` module provides process-local invalidation for connecting
+* writes to dependent reads. It does not cache values itself; it tracks keys,
+* registers query handlers, and reruns effects when matching keys are
+* invalidated so queues, streams, UI subscriptions, and read models can stay
+* fresh after successful writes.
+*
+* **Mental model**
+*
+* A query registers one or more keys, runs once immediately, and publishes each
+* result to a queue or stream. Invalidating any registered key schedules the
+* query to rerun. Mutations wrap an effect and invalidate keys only after it
+* succeeds. Keys can be a flat array, or a record whose property names act as
+* broad namespaces and whose ids address individual records.
+*
+* **Common tasks**
+*
+* - Provide the default in-memory service with {@link layer}.
+* - Use {@link query} when callers need a queue of rerun results.
+* - Use {@link stream} when downstream code should consume reruns as a stream.
+* - Wrap writes with {@link mutation}, or call {@link invalidate} directly when
+*   invalidation is already part of the workflow.
+* - Use the {@link Reactivity} service directly when many invalidations should
+*   be coalesced until a batch exits.
+*
+* **Gotchas**
+*
+* - The default layer is process-local; it does not coordinate invalidations
+*   across processes or cluster runners.
+* - Non-primitive keys are matched by their `Hash.hash` value, so prefer stable
+*   key values over mutable objects.
+* - If a query fails, its queue or stream fails with the same cause.
+* - Invalidations that arrive while a query is already running coalesce into one
+*   follow-up run.
+*
+* **See also**
+*
+* - {@link query}, {@link stream}, {@link mutation}, and {@link invalidate}
+* - {@link layer} and {@link Reactivity}
+*
+* @since 4.0.0
+*/
+/**
+* Service for key-based reactive invalidation.
+*
+* **When to use**
+*
+* Use to provide the invalidation service that refreshes queries, streams, and
+* atoms when application keys change.
+*
+* **Details**
+*
+* The service can register handlers for keys, invalidate those keys, wrap
+* mutations so successful effects invalidate keys, and turn query effects into
+* queues or streams that rerun when keys are invalidated.
+*
+* @category services
+* @since 4.0.0
+*/
+var Reactivity = class extends Service()("effect/reactivity/Reactivity") {};
+/**
+* Creates an in-memory `Reactivity` service.
+*
+* **Details**
+*
+* The service tracks handlers by hashed keys and runs the registered handlers when
+* matching keys are invalidated.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const make$2 = /*#__PURE__*/ sync(() => {
+	const handlers = /* @__PURE__ */ new Map();
+	const invalidateUnsafe = (keys) => {
+		keysToHashes(keys, (hash) => {
+			const set = handlers.get(hash);
+			if (set === void 0) return;
+			set.forEach((run) => run());
+		});
+	};
+	const invalidate = (keys) => contextWith((services) => {
+		const pending = services.mapUnsafe.get(PendingInvalidation.key);
+		if (pending) keysToHashes(keys, (hash) => {
+			pending.add(hash);
+		});
+		else invalidateUnsafe(keys);
+		return void_;
+	});
+	const mutation = (keys, effect) => tap(effect, invalidate(keys));
+	const registerUnsafe = (keys, handler) => {
+		const resolvedKeys = [];
+		keysToHashes(keys, (hash) => {
+			resolvedKeys.push(hash);
+			let set = handlers.get(hash);
+			if (set === void 0) {
+				set = /* @__PURE__ */ new Set();
+				handlers.set(hash, set);
+			}
+			set.add(handler);
+		});
+		return () => {
+			for (let i = 0; i < resolvedKeys.length; i++) {
+				const set = handlers.get(resolvedKeys[i]);
+				set.delete(handler);
+				if (set.size === 0) handlers.delete(resolvedKeys[i]);
+			}
+		};
+	};
+	const query = (keys, effect) => gen(function* () {
+		const services = yield* context();
+		const scope = get(services, Scope);
+		const results = yield* make$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(registerUnsafe(keys, run)));
+		run();
+		return results;
+	});
+	const stream = (tables, effect) => query(tables, effect).pipe(map(fromQueue), unwrap);
+	const withBatch = (effect) => suspend(() => {
+		const pending = /* @__PURE__ */ new Set();
+		return effect.pipe(provideService(PendingInvalidation, pending), onExit((_) => sync(() => {
+			pending.forEach((hash) => {
+				const set = handlers.get(hash);
+				if (set === void 0) return;
+				set.forEach((run) => run());
+			});
+		})));
+	});
+	return Reactivity.of({
+		mutation,
+		query,
+		stream,
+		invalidateUnsafe,
+		invalidate,
+		registerUnsafe,
+		withBatch
+	});
+});
+var PendingInvalidation = class extends Service()("effect/reactivity/Reactivity/PendingInvalidation") {};
+/**
+* The default layer that provides an in-memory `Reactivity` service.
+*
+* @category layers
+* @since 4.0.0
+*/
+const layer = /*#__PURE__*/ effect(Reactivity)(make$2);
+function stringOrHash(u) {
+	switch (typeof u) {
+		case "string":
+		case "number":
+		case "bigint":
+		case "boolean": return String(u);
+		default: return hash(u);
+	}
+}
+const keysToHashes = (keys, f) => {
+	if (Array.isArray(keys)) {
+		for (let i = 0; i < keys.length; i++) f(stringOrHash(keys[i]));
+		return;
+	}
+	for (const key in keys) {
+		f(key);
+		const ids = keys[key];
+		for (let i = 0; i < ids.length; i++) f(`${key}:${stringOrHash(ids[i])}`);
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/effect@4.0.0-beta.78/node_modules/effect/dist/unstable/sql/Statement.js
+/**
+* Low-level SQL statement and fragment primitives.
+*
+* This module is the foundation used by SQL clients to build executable,
+* parameterized SQL. It defines the {@link Statement} and {@link Fragment}
+* models, the tagged-template {@link Constructor}, segment constructors for
+* identifiers, parameters, literals, arrays, records, and custom dialect data,
+* plus compilers that render those segments into dialect-specific SQL text and
+* bind parameters.
+*
+* **Mental model**
+*
+* A statement is a sequence of {@link Segment} values. In a tagged template,
+* nested fragments and known segments are spliced into that sequence, while
+* ordinary interpolated values become bound parameters. A {@link Compiler}
+* turns the sequence into SQL for one dialect, escaping identifiers and
+* formatting placeholders for that dialect. Executing a {@link Statement} uses
+* the connection acquirer captured by {@link make} and can return rows, raw
+* results, streams, values, or unprepared execution paths.
+*
+* **Common tasks**
+*
+* - Build statements with a {@link Constructor} tagged template
+* - Use {@link identifier} for table and column names rather than interpolating
+*   plain strings
+* - Compose optional clauses with {@link and}, {@link or}, {@link csv}, and
+*   {@link join}
+* - Create insert and update fragments with record helpers
+* - Add custom segment handling with {@link custom} and {@link makeCompiler}
+*
+* **Gotchas**
+*
+* Bound parameters protect values, not SQL syntax. Use `literal` and `unsafe`
+* only for trusted SQL text, and use identifiers for names that need escaping.
+* Compiled SQL is dialect-specific and cached on the statement;
+* `withoutTransform` intentionally bypasses identifier or row transforms, so
+* its output can differ from normal execution.
+*
+* @since 4.0.0
+*/
+const FragmentTypeId = "~effect/sql/Fragment";
+/**
+* Constructs a SQL `Fragment` from low-level statement segments.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const fragment = (segments) => ({
+	[FragmentTypeId]: FragmentTypeId,
+	segments
+});
+/**
+* Context reference for an optional current SQL statement transformer applied
+* before statement execution.
+*
+* @category transformer
+* @since 4.0.0
+*/
+const CurrentTransformer = /*#__PURE__*/ Reference("effect/sql/CurrentTransformer", { defaultValue: constUndefined });
+/**
+* Returns `true` when a value is a SQL `Fragment`.
+*
+* @category guards
+* @since 4.0.0
+*/
+const isFragment = (u) => hasProperty(u, FragmentTypeId);
+/**
+* Constructs a raw SQL literal segment. The literal text is not escaped, so use
+* bound parameters for untrusted values.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const literal = (value, params) => ({
+	_tag: "Literal",
+	value,
+	params
+});
+/**
+* Constructs a SQL identifier segment that will be escaped by the active
+* compiler.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const identifier = (value) => ({
+	_tag: "Identifier",
+	value
+});
+/**
+* Constructs a bound parameter segment for a statement value.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const parameter = (value) => ({
+	_tag: "Parameter",
+	value
+});
+/**
+* Constructs an `ArrayHelper` segment for an array of values or fragments.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const arrayHelper = (value) => ({
+	_tag: "ArrayHelper",
+	value
+});
+const RecordInsertHelperProto = {
+	_tag: "RecordInsertHelper",
+	returning(sql) {
+		const self = Object.create(Object.getPrototypeOf(this));
+		Object.assign(self, this, { returningIdentifier: sql });
+		return self;
+	}
+};
+/**
+* Constructs a `RecordInsertHelper` from one or more row objects.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const recordInsertHelper = (value) => Object.assign(Object.create(RecordInsertHelperProto), {
+	value,
+	returningIdentifier: void 0
+});
+const RecordUpdateHelperProto = {
+	...RecordInsertHelperProto,
+	_tag: "RecordUpdateHelper"
+};
+/**
+* Constructs a `RecordUpdateHelper` for multi-row update compilation using the
+* provided alias.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const recordUpdateHelper = (value, alias) => Object.assign(Object.create(RecordUpdateHelperProto), {
+	value,
+	alias,
+	returningIdentifier: void 0
+});
+const RecordUpdateHelperSingleProto = {
+	...RecordInsertHelperProto,
+	_tag: "RecordUpdateHelperSingle"
+};
+/**
+* Constructs a `RecordUpdateHelperSingle` from a record and a list of columns
+* to omit from the update.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const recordUpdateHelperSingle = (value, omit) => Object.assign(Object.create(RecordUpdateHelperSingleProto), {
+	value,
+	omit,
+	returningIdentifier: void 0
+});
+/**
+* Creates a cached SQL statement constructor from a connection acquirer,
+* compiler, tracing attributes, and optional row transformation function.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const make$1 = (acquirer, compiler, spanAttributes, transformRows) => {
+	const cache = transformRows === void 0 ? constructorCache.noTransforms : constructorCache.transforms;
+	if (cache.has(acquirer)) return cache.get(acquirer);
+	const self = Object.assign(function sql(strings, ...args) {
+		if (typeof strings === "string") return identifier(strings);
+		else if (Array.isArray(strings) && "raw" in strings) return statement(acquirer, compiler, strings, args, spanAttributes, transformRows);
+		throw "absurd";
+	}, {
+		unsafe(sql, params) {
+			return makeUnsafe([literal(sql, params)], acquirer, compiler, spanAttributes, transformRows);
+		},
+		literal(sql) {
+			return fragment([literal(sql)]);
+		},
+		in: in_,
+		insert(value) {
+			return recordInsertHelper(Array.isArray(value) ? value : [value]);
+		},
+		update(value, omit) {
+			return recordUpdateHelperSingle(value, omit ?? []);
+		},
+		updateValues(value, alias) {
+			return recordUpdateHelper(value, alias);
+		},
+		and,
+		or,
+		csv,
+		join,
+		onDialect(options) {
+			return options[compiler.dialect]();
+		},
+		onDialectOrElse(options) {
+			return options[compiler.dialect] !== void 0 ? options[compiler.dialect]() : options.orElse();
+		}
+	});
+	cache.set(acquirer, self);
+	return self;
+};
+const constructorCache = {
+	transforms: /*#__PURE__*/ new WeakMap(),
+	noTransforms: /*#__PURE__*/ new WeakMap()
+};
+/**
+* Builds a `Statement` from template strings and arguments, preserving
+* fragments and helper segments while converting ordinary interpolated values
+* into bound parameters.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const statement = (acquirer, compiler, strings, args, spanAttributes, transformRows) => {
+	const segments = strings[0].length > 0 ? [literal(strings[0])] : [];
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (isFragment(arg)) segments.push(...arg.segments);
+		else if (isSegment(arg)) segments.push(arg);
+		else segments.push(parameter(arg));
+		if (strings[i + 1].length > 0) segments.push(literal(strings[i + 1]));
+	}
+	return makeUnsafe(segments, acquirer, compiler, spanAttributes, transformRows);
+};
+/**
+* Creates a helper that joins SQL clauses with a literal separator, optionally
+* wrapping multiple clauses in parentheses and using a fallback for an empty
+* list.
+*
+* @category constructors
+* @since 4.0.0
+*/
+function join(lit, addParens = true, fallback = "") {
+	const literalStatement = literal(lit);
+	const fallbackFragment = fragment([literal(fallback)]);
+	return (clauses) => {
+		if (clauses.length === 0) return fallbackFragment;
+		else if (clauses.length === 1) return fragment(convertLiteralOrFragment(clauses[0]));
+		const segments = [];
+		if (addParens) segments.push(literal("("));
+		segments.push.apply(segments, convertLiteralOrFragment(clauses[0]));
+		for (let i = 1; i < clauses.length; i++) {
+			segments.push(literalStatement);
+			segments.push.apply(segments, convertLiteralOrFragment(clauses[i]));
+		}
+		if (addParens) segments.push(literal(")"));
+		return fragment(segments);
+	};
+}
+/**
+* Combines clauses with `AND`, parenthesizing multiple clauses and returning
+* `1=1` when the list is empty.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const and = /*#__PURE__*/ join(" AND ", true, "1=1");
+/**
+* Combines clauses with `OR`, parenthesizing multiple clauses and returning
+* `1=1` when the list is empty.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const or = /*#__PURE__*/ join(" OR ", true, "1=1");
+/**
+* Creates a comma-separated SQL fragment from values, optionally adding a
+* prefix, and returns an empty fragment when no values are provided.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const csv = function(...args) {
+	if (args[args.length - 1].length === 0) return emptyFragment;
+	if (args.length === 1) return csvRaw(args[0]);
+	return fragment([literal(`${args[0]} `), ...csvRaw(args[1]).segments]);
+};
+const csvRaw = /*#__PURE__*/ join(",", false);
+const emptyFragment = /*#__PURE__*/ fragment([/*#__PURE__*/ literal("")]);
+/**
+* Creates a dialect-specific SQL `Compiler` from rendering callbacks.
+*
+* @category compiler
+* @since 4.0.0
+*/
+const makeCompiler = (options) => {
+	const self = Object.create(CompilerProto);
+	self.options = options;
+	self.dialect = options.dialect;
+	self.disableTransforms = false;
+	return self;
+};
+const statementCacheSymbol = /*#__PURE__*/ Symbol.for("effect/unstable/sql/Statement/statementCache");
+const statementCacheNoTransformSymbol = /*#__PURE__*/ Symbol.for("effect/unstable/sql/Statement/statementCacheNoTransform");
+const CompilerProto = {
+	compile(statement, withoutTransform = false, placeholderOverride) {
+		const opts = this.options;
+		withoutTransform = withoutTransform || this.disableTransforms;
+		const cacheSymbol = withoutTransform ? statementCacheNoTransformSymbol : statementCacheSymbol;
+		if (cacheSymbol in statement) return statement[cacheSymbol];
+		const segments = statement.segments;
+		const len = segments.length;
+		let sql = "";
+		const binds = [];
+		let placeholderCount = 0;
+		const placeholder = placeholderOverride ?? ((u) => opts.placeholder(++placeholderCount, u));
+		const placeholderNoIncrement = (u) => opts.placeholder(placeholderCount, u);
+		const placeholders = makePlaceholdersArray(placeholder);
+		for (let i = 0; i < len; i++) {
+			const segment = segments[i];
+			switch (segment._tag) {
+				case "Literal":
+					sql += segment.value;
+					if (segment.params) binds.push.apply(binds, segment.params);
+					break;
+				case "Identifier":
+					sql += opts.onIdentifier(segment.value, withoutTransform);
+					break;
+				case "Parameter":
+					sql += placeholder(segment.value);
+					binds.push(segment.value);
+					break;
+				case "ArrayHelper":
+					sql += `(${placeholders(segment.value)})`;
+					binds.push.apply(binds, segment.value);
+					break;
+				case "RecordInsertHelper": {
+					const keys = Object.keys(segment.value[0]);
+					if (opts.onInsert) {
+						const values = new Array(segment.value.length);
+						let placeholders = "";
+						for (let i = 0; i < segment.value.length; i++) {
+							const row = new Array(keys.length);
+							values[i] = row;
+							placeholders += i === 0 ? "(" : ",(";
+							for (let j = 0; j < keys.length; j++) {
+								const key = keys[j];
+								const value = segment.value[i][key];
+								row[j] = extractPrimitive(value, opts.onCustom, placeholderNoIncrement, withoutTransform);
+								placeholders += j === 0 ? placeholder(value) : `,${placeholder(value)}`;
+							}
+							placeholders += ")";
+						}
+						const [s, b] = opts.onInsert(keys.map((_) => opts.onIdentifier(_, withoutTransform)), placeholders, values, typeof segment.returningIdentifier === "string" ? [segment.returningIdentifier, []] : segment.returningIdentifier ? this.compile(segment.returningIdentifier, withoutTransform, placeholder) : void 0);
+						sql += s;
+						binds.push.apply(binds, b);
+					} else {
+						let placeholders = "";
+						for (let i = 0; i < segment.value.length; i++) {
+							placeholders += i === 0 ? "(" : ",(";
+							for (let j = 0; j < keys.length; j++) {
+								const value = segment.value[i][keys[j]];
+								const primitive = extractPrimitive(value, opts.onCustom, placeholderNoIncrement, withoutTransform);
+								binds.push(primitive);
+								placeholders += j === 0 ? placeholder(value) : `,${placeholder(value)}`;
+							}
+							placeholders += ")";
+						}
+						sql += `${generateColumns(keys, opts.onIdentifier, withoutTransform)} VALUES ${placeholders}`;
+						if (typeof segment.returningIdentifier === "string") sql += ` RETURNING ${segment.returningIdentifier}`;
+						else if (segment.returningIdentifier) {
+							sql += " RETURNING ";
+							const [s, b] = this.compile(segment.returningIdentifier, withoutTransform, placeholder);
+							sql += s;
+							binds.push.apply(binds, b);
+						}
+					}
+					break;
+				}
+				case "RecordUpdateHelperSingle": {
+					let keys = Object.keys(segment.value);
+					if (segment.omit.length > 0) keys = keys.filter((key) => !segment.omit.includes(key));
+					if (opts.onRecordUpdateSingle) {
+						const [s, b] = opts.onRecordUpdateSingle(keys.map((_) => opts.onIdentifier(_, withoutTransform)), keys.map((key) => extractPrimitive(segment.value[key], opts.onCustom, placeholderNoIncrement, withoutTransform)), typeof segment.returningIdentifier === "string" ? [segment.returningIdentifier, []] : segment.returningIdentifier ? this.compile(segment.returningIdentifier, withoutTransform, placeholder) : void 0);
+						sql += s;
+						binds.push.apply(binds, b);
+					} else {
+						for (let i = 0, len = keys.length; i < len; i++) {
+							const column = opts.onIdentifier(keys[i], withoutTransform);
+							if (i === 0) sql += `${column} = ${placeholder(segment.value[keys[i]])}`;
+							else sql += `, ${column} = ${placeholder(segment.value[keys[i]])}`;
+							binds.push(extractPrimitive(segment.value[keys[i]], opts.onCustom, placeholderNoIncrement, withoutTransform));
+						}
+						if (typeof segment.returningIdentifier === "string") if (this.dialect === "mssql") sql += ` OUTPUT ${segment.returningIdentifier === "*" ? "INSERTED.*" : segment.returningIdentifier}`;
+						else sql += ` RETURNING ${segment.returningIdentifier}`;
+						else if (segment.returningIdentifier) {
+							sql += this.dialect === "mssql" ? " OUTPUT " : " RETURNING ";
+							const [s, b] = this.compile(segment.returningIdentifier, withoutTransform, placeholder);
+							sql += s;
+							binds.push.apply(binds, b);
+						}
+					}
+					break;
+				}
+				case "RecordUpdateHelper": {
+					const keys = Object.keys(segment.value[0]);
+					const values = new Array(segment.value.length);
+					let placeholders = "";
+					for (let i = 0; i < segment.value.length; i++) {
+						const row = new Array(keys.length);
+						values[i] = row;
+						placeholders += i === 0 ? "(" : ",(";
+						for (let j = 0; j < keys.length; j++) {
+							const key = keys[j];
+							const value = segment.value[i][key];
+							row[j] = extractPrimitive(value, opts.onCustom, placeholderNoIncrement, withoutTransform);
+							placeholders += j === 0 ? placeholder(value) : `,${placeholder(value)}`;
+						}
+						placeholders += ")";
+					}
+					const [s, b] = opts.onRecordUpdate(placeholders, segment.alias, generateColumns(keys, opts.onIdentifier, withoutTransform), values, typeof segment.returningIdentifier === "string" ? [segment.returningIdentifier, []] : segment.returningIdentifier ? this.compile(segment.returningIdentifier, withoutTransform, placeholder) : void 0);
+					sql += s;
+					binds.push.apply(binds, b);
+					break;
+				}
+				case "Custom": {
+					const [s, b] = opts.onCustom(segment, placeholder, withoutTransform);
+					sql += s;
+					binds.push.apply(binds, b);
+					break;
+				}
+			}
+		}
+		const result = [sql, binds];
+		if (placeholderOverride !== void 0) return result;
+		return statement[cacheSymbol] = result;
+	},
+	get withoutTransform() {
+		const self = Object.create(CompilerProto);
+		Object.assign(self, this, { disableTransforms: true });
+		return self;
+	}
+};
+/**
+* Creates a SQLite compiler that uses `?` placeholders and quoted identifiers,
+* optionally transforming identifier names before escaping.
+*
+* @category compiler
+* @since 4.0.0
+*/
+const makeCompilerSqlite = (transform) => makeCompiler({
+	dialect: "sqlite",
+	placeholder(_) {
+		return "?";
+	},
+	onIdentifier: transform ? function(value, withoutTransform) {
+		return withoutTransform ? escapeSqlite(value) : escapeSqlite(transform(value));
+	} : escapeSqlite,
+	onRecordUpdate() {
+		return ["", []];
+	},
+	onCustom() {
+		return ["", []];
+	}
+});
+/**
+* Creates an identifier escaping function that wraps names in the given
+* delimiter, doubles delimiter characters, and escapes dots between identifier
+* parts.
+*
+* @category constructors
+* @since 4.0.0
+*/
+function defaultEscape(c) {
+	const re = new RegExp(c, "g");
+	const double = c + c;
+	const dot = c + "." + c;
+	return function(str) {
+		return c + str.replace(re, double).replace(/\./g, dot) + c;
+	};
+}
+/**
+* Builds value, object, and row-array transformers that rename object keys with
+* the supplied function and optionally recurse into nested object arrays.
+*
+* @category transforming
+* @since 4.0.0
+*/
+const defaultTransforms = (transformer, nested = true) => {
+	const transformValue = (value) => {
+		if (Array.isArray(value)) {
+			if (value.length === 0 || value[0].constructor !== Object) return value;
+			return array(value);
+		} else if (value?.constructor === Object) return transformObject(value);
+		return value;
+	};
+	const transformObject = (obj) => {
+		const newObj = {};
+		for (const key in obj) 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 in row) obj[transformer(key)] = transformValue(row[key]);
+				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 in row) obj[transformer(key)] = row[key];
+				newRows[i] = obj;
+			}
+		}
+		return newRows;
+	};
+	const array = nested ? transformArrayNested : transformArray;
+	return {
+		value: transformValue,
+		object: transformObject,
+		array
+	};
+};
+const ATTR_DB_OPERATION_NAME = "db.operation.name";
+const ATTR_DB_QUERY_TEXT = "db.query.text";
+const makeUnsafe = (segments, acquirer, compiler, spanAttributes, transformRows) => {
+	const self = Object.create(StatementProto);
+	self.segments = segments;
+	self.acquirer = acquirer;
+	self.compiler = compiler;
+	self.spanAttributes = spanAttributes;
+	self.transformRows = transformRows;
+	return self;
+};
+const StatementProto = {
+	.../*#__PURE__*/ Prototype({
+		label: "Statement",
+		evaluate(fiber) {
+			const span = makeSpanUnsafe(fiber, "sql.execute", { kind: "client" });
+			const clock = fiber.getRef(Clock);
+			const timingEnabled = fiber.getRef(TracerTimingEnabled);
+			return onExit(this.withConnectionSpan("execute", (connection, sql, params) => connection.execute(sql, params, this.transformRows), false, span), (exit) => endSpan(span, exit, clock, timingEnabled));
+		}
+	}),
+	[FragmentTypeId]: FragmentTypeId,
+	withConnection(operation, f, withoutTransform = false) {
+		return useSpan("sql.execute", { kind: "client" }, (span) => this.withConnectionSpan(operation, f, withoutTransform, span));
+	},
+	withConnectionSpan(operation, f, withoutTransform, span) {
+		return withStatement(this, span, (statement) => {
+			const [sql, params] = statement.compile(withoutTransform);
+			for (const [key, value] of this.spanAttributes) span.attribute(key, value);
+			span.attribute(ATTR_DB_OPERATION_NAME, operation);
+			span.attribute(ATTR_DB_QUERY_TEXT, sql);
+			return scoped(flatMap(this.acquirer, (_) => f(_, sql, params)));
+		});
+	},
+	get withoutTransform() {
+		return this.withConnection("executeWithoutTransform", (connection, sql, params) => connection.execute(sql, params, void 0), true);
+	},
+	get raw() {
+		return this.withConnection("executeRaw", (connection, sql, params) => connection.executeRaw(sql, params), true);
+	},
+	get stream() {
+		const self = this;
+		return unwrap(flatMap(makeSpanScoped("sql.execute", { kind: "client" }), (span) => withStatement(self, span, (statement) => {
+			const [sql, params] = statement.compile();
+			for (const [key, value] of self.spanAttributes) span.attribute(key, value);
+			span.attribute(ATTR_DB_OPERATION_NAME, "executeStream");
+			span.attribute(ATTR_DB_QUERY_TEXT, sql);
+			return map(self.acquirer, (_) => _.executeStream(sql, params, self.transformRows));
+		})));
+	},
+	get values() {
+		return this.withConnection("executeValues", (connection, sql, params) => connection.executeValues(sql, params));
+	},
+	get unprepared() {
+		const self = this;
+		return self.withConnection("executeUnprepared", (connection, sql, params) => connection.executeUnprepared(sql, params, self.transformRows));
+	},
+	compile(withoutTransform) {
+		return this.compiler.compile(this, withoutTransform ?? false);
+	},
+	toJSON() {
+		const [sql, params] = this.compile();
+		return {
+			_id: "Statement",
+			segments: this.segments,
+			sql,
+			params
+		};
+	}
+};
+const withStatement = (self, span, f) => withFiber((fiber) => {
+	const transform = fiber.getRef(CurrentTransformer);
+	if (transform === void 0) return f(self);
+	return flatMap(transform(self, make$1(self.acquirer, self.compiler, self.spanAttributes, self.transformRows), fiber, span), f);
+});
+const isSegment = (u) => {
+	if (!hasProperty(u, "_tag")) return false;
+	switch (u._tag) {
+		case "Literal":
+		case "Parameter":
+		case "ArrayHelper":
+		case "RecordInsertHelper":
+		case "RecordUpdateHelper":
+		case "RecordUpdateHelperSingle":
+		case "Identifier":
+		case "Custom": return true;
+		default: return false;
+	}
+};
+function convertLiteralOrFragment(clause) {
+	if (typeof clause === "string") return [literal(clause)];
+	return clause.segments;
+}
+const makePlaceholdersArray = (evaluate) => (values) => {
+	if (values.length === 0) return "";
+	let result = evaluate(values[0]);
+	for (let i = 1; i < values.length; i++) result += `,${evaluate(values[i])}`;
+	return result;
+};
+const generateColumns = (keys, escape, withoutTransform) => {
+	if (keys.length === 0) return "()";
+	let str = `(${escape(keys[0], withoutTransform)}`;
+	for (let i = 1; i < keys.length; i++) str += `,${escape(keys[i], withoutTransform)}`;
+	return str + ")";
+};
+const extractPrimitive = (value, onCustom, placeholder, withoutTransform) => {
+	if (value === void 0) return null;
+	else if (isFragment(value)) {
+		const head = value.segments[0];
+		if (head._tag === "Custom") return onCustom(head, placeholder, withoutTransform)[1][0] ?? null;
+		else if (head._tag === "Parameter") return head.value;
+		return null;
+	}
+	return value;
+};
+const escapeSqlite = /*#__PURE__*/ defaultEscape("\"");
+function in_() {
+	if (arguments.length === 1) return arrayHelper(arguments[0]);
+	const column = arguments[0];
+	const values = arguments[1];
+	return values.length === 0 ? neverFragment : fragment([
+		identifier(column),
+		literal(" IN "),
+		arrayHelper(values)
+	]);
+}
+const neverFragment = /*#__PURE__*/ fragment([/*#__PURE__*/ literal("1=0")]);
+//#endregion
+//#region node_modules/.pnpm/effect@4.0.0-beta.78/node_modules/effect/dist/unstable/sql/SqlClient.js
+/**
+* Defines the `SqlClient` service, the central runtime entry point for Effect's
+* unstable SQL support.
+*
+* A `SqlClient` combines the tagged-template statement constructor with a
+* scoped connection acquirer, dialect compiler, tracing attributes, optional row
+* transforms, reactive query helpers, and transaction management. Applications
+* typically consume it from `Context` to build parameterized queries, stream
+* rows, run raw driver operations, reserve a connection for lower-level work, or
+* wrap several query effects in `withTransaction`.
+*
+* Transactions are tracked through a per-client context service. Top-level
+* transactions acquire the configured transaction connection and issue the
+* dialect's begin/commit/rollback SQL; nested transactions reuse that
+* connection and rely on dialect-provided savepoint SQL. A query only joins a
+* transaction when it is run with the same client service, so avoid mixing
+* clients or manually reserved connections when atomicity matters. Dialect
+* integrations are also responsible for the compiler and transaction
+* statements, which means placeholder syntax, identifier escaping, row
+* transforms, savepoint support, and unprepared/raw statement behavior can
+* differ by database.
+*
+* @since 4.0.0
+*/
+const TypeId = "~effect/sql/SqlClient";
+/**
+* Service tag for the active SQL client service.
+*
+* **When to use**
+*
+* Use to access or provide the SQL client used to build statements, stream
+* rows, reserve connections, and run transactions.
+*
+* @category services
+* @since 4.0.0
+*/
+const SqlClient = /*#__PURE__*/ Service("effect/sql/SqlClient");
+let clientIdCounter = 0;
+/**
+* Constructs a `SqlClient` from connection acquirers, a compiler, transaction
+* commands, tracing attributes, optional row transforms, and reactive query
+* integration.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const make = /*#__PURE__*/ fnUntraced(function* (options) {
+	const transactionService = options.transactionService ?? TransactionConnection(clientIdCounter++);
+	const getConnection = flatMap(serviceOption(transactionService), match({
+		onNone: () => options.acquirer,
+		onSome: ([conn]) => succeed(conn)
+	}));
+	const beginTransaction = options.beginTransaction ?? "BEGIN";
+	const commit = options.commit ?? "COMMIT";
+	const savepoint = options.savepoint ?? ((name) => `SAVEPOINT ${name}`);
+	const rollback = options.rollback ?? "ROLLBACK";
+	const rollbackSavepoint = options.rollbackSavepoint ?? ((name) => `ROLLBACK TO SAVEPOINT ${name}`);
+	const transactionAcquirer = options.transactionAcquirer ?? options.acquirer;
+	const withTransaction = makeWithTransaction({
+		transactionService,
+		spanAttributes: options.spanAttributes,
+		acquireConnection: flatMap(make$4(), (scope) => map(provide(transactionAcquirer, scope), (conn) => [scope, conn])),
+		begin: (conn) => conn.executeUnprepared(beginTransaction, [], void 0),
+		savepoint: (conn, id) => conn.executeUnprepared(savepoint(`effect_sql_${id}`), [], void 0),
+		commit: (conn) => conn.executeUnprepared(commit, [], void 0),
+		rollback: (conn) => conn.executeUnprepared(rollback, [], void 0),
+		rollbackSavepoint: (conn, id) => conn.executeUnprepared(rollbackSavepoint(`effect_sql_${id}`), [], void 0)
+	});
+	const reactivity = yield* Reactivity;
+	const client = Object.assign(make$1(getConnection, options.compiler, options.spanAttributes, options.transformRows), {
+		[TypeId]: TypeId,
+		safe: void 0,
+		withTransaction,
+		transactionService,
+		reserve: transactionAcquirer,
+		withoutTransforms() {
+			if (options.transformRows === void 0) return this;
+			const statement = make$1(getConnection, options.compiler.withoutTransform, options.spanAttributes, void 0);
+			const client = Object.assign(statement, {
+				...this,
+				...statement
+			});
+			client.safe = client;
+			client.withoutTransforms = () => client;
+			return client;
+		},
+		reactive: options.reactiveQueue ? (keys, effect) => options.reactiveQueue(keys, effect).pipe(map(fromQueue), unwrap) : reactivity.stream,
+		reactiveMailbox: options.reactiveQueue ?? reactivity.query
+	});
+	client.safe = client;
+	return client;
+});
+/**
+* Builds a transaction wrapper that begins top-level transactions, uses
+* savepoints for nested transactions, commits on success, and rolls back on
+* failure or interruption.
+*
+* @category transactions
+* @since 4.0.0
+*/
+const makeWithTransaction = (options) => (effect) => {
+	return uninterruptibleMask((restore) => useSpan("sql.transaction", { kind: "client" }, (span) => withFiber((fiber) => {
+		for (const [key, value] of options.spanAttributes) span.attribute(key, value);
+		const services = fiber.context;
+		const clock = fiber.getRef(Clock);
+		const connOption = getOption(services, options.transactionService);
+		const conn = connOption._tag === "Some" ? succeed([void 0, connOption.value[0]]) : options.acquireConnection;
+		const id = connOption._tag === "Some" ? connOption.value[1] + 1 : 0;
+		return flatMap(conn, ([scope, conn]) => (id === 0 ? options.begin(conn) : options.savepoint(conn, id)).pipe(flatMap(() => provideContext(restore(effect), mutate(services, (services) => services.pipe(add(options.transactionService, [conn, id]), add(ParentSpan, span))))), exit, flatMap((exit) => {
+			let effect;
+			if (isSuccess(exit)) if (id === 0) {
+				span.event("db.transaction.commit", clock.currentTimeNanosUnsafe());
+				effect = orDie(options.commit(conn));
+			} else {
+				span.event("db.transaction.savepoint", clock.currentTimeNanosUnsafe());
+				effect = void_;
+			}
+			else {
+				span.event("db.transaction.rollback", clock.currentTimeNanosUnsafe());
+				effect = orDie(id > 0 ? options.rollbackSavepoint(conn, id) : options.rollback(conn));
+			}
+			return flatMap(scope !== void 0 ? ensuring(effect, close(scope, exit)) : effect, () => exit);
+		})));
+	})));
+};
+/**
+* Creates a unique context service tag for the active transaction connection of
+* a specific SQL client.
+*
+* @category services
+* @since 4.0.0
+*/
+const TransactionConnection = (clientId) => Service(`effect/sql/SqlClient/TransactionConnection/${clientId}`);
+//#endregion
+//#region src/sql/service.ts
+var SqlClientFactory = class extends Service()("t3cli/SqlClientFactory") {};
+//#endregion
+//#region src/auth/local-token.ts
+var T3LocalAuthToken = class extends Service()("t3cli/T3LocalAuthToken") {};
+const makeT3LocalAuthToken = fn("makeT3LocalAuthToken")(function* () {
+	const fs = yield* FileSystem;
+	const path = yield* Path;
+	const environment = yield* Environment;
+	const crypto = yield* Crypto;
+	const sqlClientFactory = yield* SqlClientFactory;
+	function readSigningSecret(secretPath) {
+		return fs.readFile(secretPath).pipe(map((bytes) => Uint8Array.from(bytes)), catchFilter(reason("PlatformError", "NotFound"), () => succeed(void 0)), mapError((error) => new AuthLocalSecretError({
+			message: `failed to read signing secret: ${secretPath}`,
+			cause: error
+		})));
+	}
+	const readRequiredSigningSecret = fn("readRequiredSigningSecret")(function* (secretsDir) {
+		const secretPath = path.join(secretsDir, `${signingSecretName}.bin`);
+		const secret = yield* readSigningSecret(secretPath);
+		if (secret === void 0) return yield* fail(new AuthLocalSecretError({ message: `local signing secret not found: ${secretPath}` }));
+		return secret;
+	});
+	const hmacSha256 = (secret, payload) => gen(function* () {
+		const key = secret.byteLength > sha256BlockSize ? yield* crypto.digest("SHA-256", secret) : secret;
+		const block = new Uint8Array(sha256BlockSize);
+		block.set(key);
+		const outerPad = block.map((byte) => byte ^ 92);
+		const innerPad = block.map((byte) => byte ^ 54);
+		const innerHash = yield* crypto.digest("SHA-256", concatBytes(innerPad, payload));
+		return yield* crypto.digest("SHA-256", concatBytes(outerPad, innerHash));
+	});
+	const signPayload = (payload, secret) => hmacSha256(secret, new TextEncoder().encode(payload)).pipe(map(encodeBase64Url), mapError((error) => new AuthLocalSigningError({
+		operation: "sign",
+		message: "failed to sign local auth payload",
+		cause: error
+	})));
+	function openAuthDatabase(dbPath) {
+		return sqlClientFactory.sqliteClient({ filename: dbPath }).pipe(catchTag("SqlError", (error) => fail(new AuthLocalDatabaseError({
+			operation: "connect",
+			message: error.message
+		}))));
+	}
+	const provideAuthDatabase = (dbPath) => (effect) => gen(function* () {
+		const sql = yield* openAuthDatabase(dbPath);
+		return yield* effect.pipe(provideService(SqlClient, sql));
+	}).pipe(scoped);
+	const issueLocalDatabaseSession = fn("issueLocalDatabaseSession")(function* (input) {
+		const secret = yield* readRequiredSigningSecret(input.secretsDir);
+		const issuedAt = yield* now;
+		const expiresAt = add$1(issuedAt, { milliseconds: defaultSessionTtlMs });
+		const sessionId = yield* crypto.randomUUIDv4.pipe(map((id) => AuthSessionId.make(id)), mapError((error) => new AuthLocalSecretError({
+			message: "failed to generate auth session id",
+			cause: error
+		})));
+		const scopes = [...AuthAdministrativeScopes];
+		const claims = {
+			v: 1,
+			kind: "session",
+			sid: sessionId,
+			sub: input.subject,
+			scopes,
+			method: "bearer-access-token",
+			iat: toEpochMillis(issuedAt),
+			exp: toEpochMillis(expiresAt)
+		};
+		const encodedPayload = encodeBase64Url(JSON.stringify(claims));
+		const token = `${encodedPayload}.${yield* signPayload(encodedPayload, secret)}`;
+		yield* insertAuthSession({
+			sessionId,
+			subject: input.subject,
+			scopes,
+			label: input.label,
+			issuedAt: formatIso(issuedAt),
+			expiresAt: formatIso(expiresAt)
+		}).pipe(provideAuthDatabase(input.dbPath), catchTag("SqlError", (error) => fail(new AuthLocalDatabaseError({
+			operation: isTagged(error.reason, "ConnectionError") ? "connect" : "query",
+			message: error.message
+		}))));
+		return {
+			token,
+			role: input.role,
+			expiresAt: formatIso(expiresAt)
+		};
+	});
+	return { create: fn("T3LocalAuthTokenLive.create")(function* (input) {
+		if (input.label.length === 0) return yield* fail(new AuthLocalError({ message: "local auth label cannot be empty" }));
+		if (input.subject.length === 0) return yield* fail(new AuthLocalError({ message: "local auth subject cannot be empty" }));
+		const baseDir = yield* resolveLocalBaseDir({ baseDir: input.baseDir }).pipe(provideService(Environment, environment), provideService(Path, path));
+		const session = yield* issueLocalDatabaseSession({
+			dbPath: path.join(baseDir, "userdata", "state.sqlite"),
+			secretsDir: path.join(baseDir, "userdata", "secrets"),
+			role: input.role,
+			label: input.label,
+			subject: input.subject
+		}).pipe(mapError((error) => new AuthLocalError({
+			message: `local auth failed: ${error.message}`,
+			cause: error
+		})));
+		return {
+			token: session.token,
+			role: session.role,
+			expiresAt: session.expiresAt,
+			source: "local",
+			baseDir
+		};
+	}) };
+});
+const T3LocalAuthTokenLive = effect(T3LocalAuthToken, makeT3LocalAuthToken());
+function insertAuthSession(input) {
+	return gen(function* () {
+		const sql = yield* SqlClient;
+		yield* sql`PRAGMA busy_timeout = 5000;`;
+		yield* sql`PRAGMA foreign_keys = ON;`;
+		if (!(yield* sql`PRAGMA table_info(auth_sessions)`).some((column) => column.name === "scopes")) return yield* fail(new AuthLocalDatabaseError({
+			operation: "schema",
+			message: "local auth database is missing scoped auth_sessions schema"
+		}));
+		yield* sql`
+      INSERT INTO auth_sessions (
+        session_id,
+        subject,
+        scopes,
+        method,
+        client_label,
+        client_ip_address,
+        client_user_agent,
+        client_device_type,
+        client_os,
+        client_browser,
+        issued_at,
+        expires_at,
+        revoked_at
+      )
+      VALUES (
+        ${input.sessionId},
+        ${input.subject},
+        ${JSON.stringify(input.scopes)},
+        ${"bearer-access-token"},
+        ${input.label},
+        NULL,
+        NULL,
+        ${"bot"},
+        NULL,
+        NULL,
+        ${input.issuedAt},
+        ${input.expiresAt},
+        NULL
+      )
+    `;
+	});
+}
+const defaultSessionTtlMs = 720 * 60 * 60 * 1e3;
+const signingSecretName = "server-signing-key";
+const sha256BlockSize = 64;
+function concatBytes(first, second) {
+	const bytes = new Uint8Array(first.byteLength + second.byteLength);
+	bytes.set(first);
+	bytes.set(second, first.byteLength);
+	return bytes;
+}
+//#endregion
+//#region src/auth/local.ts
+var T3LocalAuth = class extends Service()("t3cli/T3LocalAuth") {};
+const makeT3LocalAuth = fn("makeT3LocalAuth")(function* () {
+	const origin = yield* T3LocalAuthOrigin;
+	const token = yield* T3LocalAuthToken;
+	return { local: fn("T3LocalAuthLive.local")(function* (input) {
+		const created = yield* token.create(input);
+		return {
+			url: yield* origin.resolve({
+				baseDir: created.baseDir,
+				...input.origin !== void 0 ? { origin: input.origin } : {}
+			}),
+			token: created.token,
+			role: created.role,
+			expiresAt: created.expiresAt,
+			source: "local",
+			baseDir: created.baseDir
+		};
+	}) };
+});
+const T3LocalAuthLive = effect(T3LocalAuth, makeT3LocalAuth());
+//#endregion
+//#region src/auth/pairing.ts
+var T3AuthPairing = class extends Service()("t3cli/T3AuthPairing") {};
+const makeT3AuthPairing = fn("makeT3AuthPairing")(function* () {
+	const transport = yield* T3AuthTransport;
+	return { pair: fn("T3AuthPairingLive.pair")(function* (pairingUrl) {
+		const parsed = yield* parsePairingUrl(pairingUrl);
+		const result = yield* transport.bootstrapBearer(parsed);
+		return {
+			url: parsed.baseUrl,
+			token: result.sessionToken,
+			role: result.role,
+			expiresAt: result.expiresAt
+		};
+	}) };
+});
+const T3AuthPairingLive = effect(T3AuthPairing, makeT3AuthPairing());
+function parsePairingUrl(value) {
+	return gen(function* () {
+		const url = yield* parseUrl(value);
+		const token = yield* readPairingToken(url);
+		if (token.length === 0) return yield* fail(new AuthPairingUrlError({ message: "pairing url missing token" }));
+		const hostedHost = url.searchParams.get("host")?.trim();
+		return {
+			baseUrl: normalizeBaseUrl(yield* parseUrl(hostedHost !== void 0 && hostedHost.length > 0 ? hostedHost : new URL(".", url).toString())),
+			credential: token
+		};
+	});
+}
+function parseUrl(value) {
+	return fromResult(fromString(value)).pipe(catchTags({ IllegalArgumentError: (error) => fail(new AuthPairingUrlError({
+		message: "invalid pairing url",
+		cause: error
+	})) }));
+}
+function normalizeBaseUrl(url) {
+	return mutate$1(url, (current) => {
+		current.hash = "";
+		current.search = "";
+		current.pathname = current.pathname === "/" ? "" : current.pathname.replace(/\/+$/u, "");
+	}).toString().replace(/\/$/, "");
+}
+function readPairingToken(url) {
+	return gen(function* () {
+		const hashToken = (yield* parseUrl(`http://t3.local/?${url.hash.startsWith("#") ? url.hash.slice(1) : url.hash}`)).searchParams.get("token")?.trim();
+		const token = url.searchParams.get("token")?.trim();
+		return hashToken !== void 0 && hashToken.length > 0 ? hashToken : token !== void 0 && token.length > 0 ? token : "";
+	});
+}
+//#endregion
+//#region src/auth/layer.ts
+const makeT3Auth = fn("makeT3Auth")(function* () {
+	const config = yield* T3Config;
+	const transport = yield* T3AuthTransport;
+	const localAuth = yield* T3LocalAuth;
+	const pairing = yield* T3AuthPairing;
+	const status = fn("T3AuthLive.status")(function* () {
+		const resolved = yield* config.resolve().pipe(catchTags({
+			ConfigError: (error) => fail(new AuthConfigError({
+				message: "auth config failed",
+				cause: error
+			})),
+			UrlError: (error) => fail(new AuthConfigError({
+				message: "auth config failed",
+				cause: error
+			}))
+		}));
+		return yield* transport.getSession(resolved);
+	});
+	const issueWebSocketTicket = fn("T3AuthLive.issueWebSocketTicket")(function* () {
+		const resolved = yield* config.resolve().pipe(catchTags({
+			ConfigError: (error) => fail(new AuthConfigError({
+				message: "auth config failed",
+				cause: error
+			})),
+			UrlError: (error) => fail(new AuthConfigError({
+				message: "auth config failed",
+				cause: error
+			}))
+		}));
+		return yield* transport.issueWebSocketTicket(resolved);
+	});
+	const writeConfig = fn("T3AuthLive.writeConfig")(function* (input) {
+		const existing = yield* config.readStored().pipe(catchTags({ ConfigError: (error) => fail(new AuthConfigError({
+			message: "auth config failed",
+			cause: error
+		})) }));
+		yield* config.writeStored({
+			...existing,
+			url: input.url,
+			token: input.token,
+			...input.local !== void 0 ? { local: input.local } : {}
+		}).pipe(catchTags({ ConfigError: (error) => fail(new AuthConfigError({
+			message: "auth config failed",
+			cause: error
+		})) }));
+	});
+	return {
+		pair: pairing.pair,
+		local: localAuth.local,
+		writeConfig,
+		status,
+		issueWebSocketTicket
+	};
+});
+const T3AuthLive = effect(T3Auth, makeT3Auth());
+//#endregion
+export { make$3 as C, Crypto as S, layer as _, makeT3AuthPairing as a, makeT3LocalAuthOrigin as b, T3LocalAuthLive as c, T3LocalAuthTokenLive as d, makeT3LocalAuthToken as f, makeCompilerSqlite as g, defaultTransforms as h, T3AuthPairingLive as i, makeT3LocalAuth as l, make as m, makeT3Auth as n, parsePairingUrl as o, SqlClientFactory as p, T3AuthPairing as r, T3LocalAuth as s, T3AuthLive as t, T3LocalAuthToken as u, T3LocalAuthOrigin as v, T3Auth as x, T3LocalAuthOriginLive as y };