t3code-cli 0.4.0 → 0.5.0

package/dist/bin.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { $ as runLast, $n as isNullish, $t as sync, A as Crypto, An as Service, At as flatMap, B as WatchBackend, Bn as isSome, Bt as map$2, C as decodeUnknownEffect, Cn as succeed$1, Ct as asVoid, D as optionalKey, Dn as fail$2, Dt as catch_, E as optional$3, En as map$3, Et as catchTags, F as TypeId$7, Fn as fromNullishOr, Ft as gen, G as fromIterable, Gn as Prototype, Gt as provideContext, H as callback$1, Hn as match, Ht as matchEffect, I as FileDescriptor, In as fromUndefinedOr, It as ignore, J as mkString, Jn as BaseProto, Jt as runFork, K as isStream, Kn as PipeInspectableProto, Kt as provideService, L as FileSystem, Ln as getOrElse, Lt as interrupt, M as fromReadable, Mn as getUnsafe, Mt as fnUntraced, N as fromWritable, Nn as make$13, Nt as forEach, O as tag, On as succeed$3, Ot as effectify, P as Path$1, Pn as flatMap$1, Pt as forkScoped, Q as runFold, Qn as isNotUndefined, Qt as suspend, R as FileTypeId, Rn as getOrUndefined, Rt as isEffect, S as decodeTo, Sn as isSuccess, St as as, T as is, Tn as sync$1, Tt as catchFilter, U as decodeText, Un as none, Ut as orDie, V as make$10, Vn as map$4, Vt as mapError, W as empty, Wn as some, Wt as provide$1, X as runCollect, Xn as hasProperty, Xt as serviceOption, Y as run$1, Yn as format, Yt as scoped, Z as runDrain, Zn as isNotNull, Zt as succeed, _ as Literals, _n as MinimumLogLevel, _t as nominal, a as latestAssistantMessage, an as uninterruptible, ar as pipeArguments, at as get, b as TaggedErrorClass, bn as isDone, bt as addFinalizer, c as Environment, cn as fail$1, ct as isSink, d as ArraySchema, dn as effect, dt as make$12, en as tapCause, er as isUndefined, et as splitLines, f as Boolean$2, fn as mergeAll, ft as offer, g as Literal, gn as sync$2, gt as systemError, h as Int, hn as succeed$2, ht as badArgument, i as ThreadSessionError, in as try_, ir as pipe, it as unwrap, j as make$9, jn as empty$1, jt as fn, k as toCodecStringTree, kn as Reference, kt as fail, l as T3Config, ln as hasInterruptsOnly, lt as endUnsafe, m as ErrorClass, mn as provideMerge, mt as BadArgument, nn as timeoutOrElse, nr as dual, nt as tap, o as threadStatus, on as void_, or as __commonJSMin, ot as make$11, p as Defect, pn as provide, pt as offerUnsafe, q as merge, qn as withFiber, qt as result, r as NodeEnvironmentLive, rn as tryPromise, rr as identity, rt as transduce, s as T3Application, sn as TaggedError, sr as __require, st as drain, t as AppLayer, tn as tapError, tr as constVoid, tt as succeed$4, u as T3Auth, un as squash, ut as failCauseUnsafe, v as String$1, vn as _await, vt as transform$1, w as fromJsonString, wn as ConsoleRef, wt as callback, x as Union, xn as makeUnsafe, xt as andThen, y as Struct, yn as doneUnsafe, yt as acquireRelease, z as Size, zn as isNone, zt as logError } from "./runtime-Cq64iuZr.js";
+import { $ as is, $n as sync$1, $t as catchFilter, An as timeoutOrElse, Ar as dual, At as tap, B as Boolean$2, Bn as mergeAll, Bt as offer, Cn as scoped, Cr as format, Ct as run$1, Dn as sync, Dr as isNullish, Dt as runLast, En as suspend, Er as isNotUndefined, Et as runFold, F as T3Application, Fn as TaggedError, Fr as __require, Ft as drain, G as Literals, Gn as MinimumLogLevel, Gt as nominal, H as ErrorClass, Hn as provideMerge, Ht as BadArgument, I as Environment, In as fail$1, It as isSink, J as TaggedErrorClass, Jn as isDone, Jt as addFinalizer, K as String$1, Kn as _await, Kt as transform$1, L as T3Config, Ln as hasInterruptsOnly, Lt as endUnsafe, M as ThreadSessionError, Mn as try_, Mr as pipe, Mt as unwrap, N as latestAssistantMessage, Nn as uninterruptible, Nr as pipeArguments, Nt as get, On as tapCause, Or as isUndefined, Ot as splitLines, P as threadStatus, Pn as void_, Pr as __commonJSMin, Pt as make$11, Q as fromJsonString, Qn as ConsoleRef, Qt as callback, R as T3Auth, Rn as squash, Rt as failCauseUnsafe, Sn as runFork, Sr as BaseProto, St as mkString, Tn as succeed, Tr as isNotNull, Tt as runDrain, U as Int, Un as succeed$2, Ut as badArgument, V as Defect, Vn as provide, Vt as offerUnsafe, W as Literal, Wn as sync$2, Wt as systemError, X as decodeTo, Xn as isSuccess, Xt as as, Y as Union, Yn as makeUnsafe, Yt as andThen, Z as decodeUnknownEffect, Zn as succeed$1, Zt as asVoid, _n as orDie, _r as none, _t as decodeText, an as fn, ar as empty$1, at as make$9, bn as provideService, br as PipeInspectableProto, bt as isStream, cn as forkScoped, cr as flatMap$1, ct as Path$1, dn as interrupt, dr as getOrElse, dt as FileSystem, en as catchTags, er as map$3, et as optional$3, fn as isEffect, fr as getOrUndefined, ft as FileTypeId, gn as matchEffect, gr as match, gt as callback$1, hn as mapError, hr as map$4, ht as make$10, in as flatMap, ir as Service, it as Crypto, j as NodeEnvironmentLive, jn as tryPromise, jr as identity, jt as transduce, kn as tapError, kr as constVoid, kt as succeed$4, ln as gen, lr as fromNullishOr, lt as TypeId$7, mn as map$2, mr as isSome, mt as WatchBackend, nn as effectify, nr as succeed$3, nt as tag, on as fnUntraced, or as getUnsafe, ot as fromReadable, pn as logError, pr as isNone, pt as Size, q as Struct, qn as doneUnsafe, qt as acquireRelease, rn as fail, rr as Reference, rt as toCodecStringTree, sn as forEach, sr as make$13, st as fromWritable, t as AppLayer, tn as catch_, tr as fail$2, tt as optionalKey, un as ignore, ur as fromUndefinedOr, ut as FileDescriptor, vn as provide$1, vr as some, vt as empty, wn as serviceOption, wr as hasProperty, wt as runCollect, xn as result, xr as withFiber, xt as merge, yn as provideContext, yr as Prototype, yt as fromIterable, z as ArraySchema, zn as effect, zt as make$12 } from "./runtime-15tR27tv.js";
 import * as NodeChildProcess from "node:child_process";
 import * as NodeCrypto from "node:crypto";
 import * as NFS from "node:fs";
@@ -17584,6 +17584,7 @@ const pairCommand = make("pair", {
 	const output = yield* T3Output;
 	const resolvedFormat = resolveOutputFormat(format, environment, "json");
 	const result = yield* auth.pair(url);
+	yield* auth.writeConfig(result);
 	if (resolvedFormat === "json") yield* output.printJson(result);
 	else yield* output.printInfo(formatAuthPaired(result));
 })).pipe(withDescription("pair with t3code server"));
@@ -17606,6 +17607,7 @@ const localCommand = make("local", {
 		...isSome(baseDir) ? { baseDir: baseDir.value } : {},
 		...isSome(origin) ? { origin: origin.value } : {}
 	});
+	yield* auth.writeConfig(result);
 	if (resolvedFormat === "json") yield* output.printJson(formatAuthLocalJson(result));
 	else yield* output.printInfo(formatAuthLocalHuman(result));
 })).pipe(withDescription("authenticate with local t3code installation"));
@@ -18147,7 +18149,7 @@ var T3Version = class extends Service()("t3cli/T3Version") {};
 //#endregion
 //#region src/version/layer.ts
 const PackageJsonSchema = fromJsonString(Struct({ version: String$1 }));
-const T3VersionBundledLive = sync$2(T3Version, () => ({ version: "0.4.0" }));
+const T3VersionBundledLive = sync$2(T3Version, () => ({ version: "0.5.0" }));
 effect(T3Version, gen(function* () {
 	const packageJson = yield* (yield* FileSystem).readFileString(fileURLToPath(new URL("../../package.json", import.meta.url)));
 	return { version: (yield* decodeUnknownEffect(PackageJsonSchema)(packageJson)).version };

package/dist/index.js

@@ -1,2 +1,2 @@
-import { n as AuthAppLayer, r as NodeEnvironmentLive, s as T3Application, t as AppLayer } from "./runtime-Cq64iuZr.js";
-export { AppLayer, AuthAppLayer, NodeEnvironmentLive, T3Application };
+import { A as UrlError, C as AuthLocalDatabaseError, D as AuthPairingUrlError, E as AuthLocalSigningError, F as T3Application, I as Environment, L as T3Config, O as AuthTransportError, R as T3Auth, S as AuthConfigError, T as AuthLocalSecretError, _ as parsePairingUrl, a as T3AuthTransportLayer, b as makeT3LocalAuth, c as NodeSqliteClientLive, d as makeT3Config, f as T3AuthLive, g as makeT3AuthPairing, h as T3AuthPairingLive, i as T3AuthPairingLayer, j as NodeEnvironmentLive, k as ConfigError, l as makeNodeSqliteClient, m as T3AuthPairing, n as AuthAppLayer, o as T3LocalAuthLayer, p as makeT3Auth, r as T3AuthLayer, s as NodeSqlClientFactoryLive, t as AppLayer, u as T3ConfigLive, v as T3LocalAuth, w as AuthLocalError, x as SqlClientFactory, y as T3LocalAuthLive } from "./runtime-15tR27tv.js";
+export { AppLayer, AuthAppLayer, AuthConfigError, AuthLocalDatabaseError, AuthLocalError, AuthLocalSecretError, AuthLocalSigningError, AuthPairingUrlError, AuthTransportError, ConfigError, Environment, NodeEnvironmentLive, NodeSqlClientFactoryLive, NodeSqliteClientLive, SqlClientFactory, T3Application, T3Auth, T3AuthLayer, T3AuthLive, T3AuthPairing, T3AuthPairingLayer, T3AuthPairingLive, T3AuthTransportLayer, T3Config, T3ConfigLive, T3LocalAuth, T3LocalAuthLayer, T3LocalAuthLive, UrlError, makeNodeSqliteClient, makeT3Auth, makeT3AuthPairing, makeT3Config, makeT3LocalAuth, parsePairingUrl };

package/dist/{runtime-Cq64iuZr.js → runtime-15tR27tv.js}

@@ -66566,8 +66566,7 @@ const decodeAuthLocalRuntimeStateFromJson = decodeUnknownEffect(fromJsonString(A
 //#endregion
 //#region src/auth/local.ts
 var T3LocalAuth = class extends Service$1()("t3cli/T3LocalAuth") {};
-const T3LocalAuthLive = effect(T3LocalAuth, fn("makeT3LocalAuth")(function* () {
-	const config = yield* T3Config;
+const makeT3LocalAuth = fn("makeT3LocalAuth")(function* () {
 	const fs = yield* FileSystem;
 	const path = yield* Path;
 	const environment = yield* Environment;
@@ -66668,22 +66667,6 @@ const T3LocalAuthLive = effect(T3LocalAuth, fn("makeT3LocalAuth")(function* () {
 			expiresAt: formatIso(expiresAt)
 		};
 	});
-	function writeLocalConfig(input) {
-		return gen(function* () {
-			const existing = yield* config.readStored().pipe(catchTags$1({ ConfigError: (error) => fail$2(new AuthConfigError({
-				message: "auth config failed",
-				cause: error
-			})) }));
-			yield* config.writeStored({
-				...existing,
-				url: input.url,
-				token: input.token
-			}).pipe(catchTags$1({ ConfigError: (error) => fail$2(new AuthConfigError({
-				message: "auth config failed",
-				cause: error
-			})) }));
-		});
-	}
 	return { local: fn("T3LocalAuthLive.local")(function* (input) {
 		if (input.label.length === 0) return yield* fail$2(new AuthLocalError({ message: "local auth label cannot be empty" }));
 		if (input.subject.length === 0) return yield* fail$2(new AuthLocalError({ message: "local auth subject cannot be empty" }));
@@ -66698,23 +66681,20 @@ const T3LocalAuthLive = effect(T3LocalAuth, fn("makeT3LocalAuth")(function* () {
 			message: `local auth failed: ${error.message}`,
 			cause: error
 		})));
-		const url = yield* resolveLocalOrigin({
-			baseDir,
-			...input.origin !== void 0 ? { origin: input.origin } : {}
-		});
-		yield* writeLocalConfig({
-			url,
-			token: session.token
-		});
 		return {
-			url,
+			url: yield* resolveLocalOrigin({
+				baseDir,
+				...input.origin !== void 0 ? { origin: input.origin } : {}
+			}),
+			token: session.token,
 			role: session.role,
 			expiresAt: session.expiresAt,
 			source: "local",
 			baseDir
 		};
 	}) };
-})());
+});
+const T3LocalAuthLive = effect(T3LocalAuth, makeT3LocalAuth());
 function insertAuthSession(input) {
 	return gen(function* () {
 		const sql = yield* SqlClient;
@@ -66852,31 +66832,20 @@ function makeHttpEndpointUrl(baseUrl, path) {
 //#endregion
 //#region src/auth/pairing.ts
 var T3AuthPairing = class extends Service$1()("t3cli/T3AuthPairing") {};
-const T3AuthPairingLive = effect(T3AuthPairing, fn("makeT3AuthPairing")(function* () {
-	const config = yield* T3Config;
+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);
-		const existing = yield* config.readStored().pipe(catchTags$1({ ConfigError: (error) => fail$2(new AuthConfigError({
-			message: "auth config failed",
-			cause: error
-		})) }));
-		yield* config.writeStored({
-			...existing,
-			url: parsed.baseUrl,
-			token: result.sessionToken
-		}).pipe(catchTags$1({ ConfigError: (error) => fail$2(new AuthConfigError({
-			message: "auth config failed",
-			cause: error
-		})) }));
 		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);
@@ -66909,7 +66878,9 @@ function readPairingToken(url) {
 		return hashToken !== void 0 && hashToken.length > 0 ? hashToken : token !== void 0 && token.length > 0 ? token : "";
 	});
 }
-const T3AuthLive = effect(T3Auth, fn("makeT3Auth")(function* () {
+//#endregion
+//#region src/auth/layer.ts
+const makeT3Auth = fn("makeT3Auth")(function* () {
 	const config = yield* T3Config;
 	const transport = yield* T3AuthTransport;
 	const localAuth = yield* T3LocalAuth;
@@ -66940,14 +66911,32 @@ const T3AuthLive = effect(T3Auth, fn("makeT3Auth")(function* () {
 		}));
 		return yield* transport.issueWebSocketTicket(resolved);
 	});
+	const writeConfig = fn("T3AuthLive.writeConfig")(function* (input) {
+		const existing = yield* config.readStored().pipe(catchTags$1({ ConfigError: (error) => fail$2(new AuthConfigError({
+			message: "auth config failed",
+			cause: error
+		})) }));
+		yield* config.writeStored({
+			...existing,
+			url: input.url,
+			token: input.token
+		}).pipe(catchTags$1({ ConfigError: (error) => fail$2(new AuthConfigError({
+			message: "auth config failed",
+			cause: error
+		})) }));
+	});
 	return {
 		pair: pairing.pair,
 		local: localAuth.local,
+		writeConfig,
 		status,
 		issueWebSocketTicket
 	};
-})());
-const T3ConfigLive = effect(T3Config, fn("makeT3Config")(function* () {
+});
+const T3AuthLive = effect(T3Auth, makeT3Auth());
+//#endregion
+//#region src/config/layer.ts
+const makeT3Config = fn("makeT3Config")(function* () {
 	const fs = yield* FileSystem;
 	const path = yield* Path;
 	const environment = yield* Environment;
@@ -66992,7 +66981,8 @@ const T3ConfigLive = effect(T3Config, fn("makeT3Config")(function* () {
 			};
 		})
 	};
-})());
+});
+const T3ConfigLive = effect(T3Config, makeT3Config());
 const StoredConfigSchema = Struct({
 	url: optionalKey(String$1),
 	token: optionalKey(String$1)
@@ -71415,6 +71405,7 @@ const makeNodeSqliteClient = fn("makeNodeSqliteClient")(function* (config) {
 		transformRows
 	});
 });
+const NodeSqliteClientLive = (config) => effectContext(map$3(makeNodeSqliteClient(config), (client) => make$40(SqlClient, client))).pipe(provide$2(layer));
 const NodeSqlClientFactoryLive = succeed$3(SqlClientFactory, { sqliteClient: (config) => makeNodeSqliteClient(config).pipe(provide(layer)) });
 function toSqlInputValue(value) {
 	if (value === void 0 || value === null) return null;
@@ -71432,8 +71423,8 @@ function toSqlInputValue(value) {
 //#endregion
 //#region src/runtime.ts
 const T3AuthTransportLayer = T3AuthTransportLive.pipe(provide$2(layerUndici));
-const T3LocalAuthLayer = T3LocalAuthLive.pipe(provide$2(mergeAll$1(T3ConfigLive, NodeSqlClientFactoryLive)));
-const T3AuthPairingLayer = T3AuthPairingLive.pipe(provide$2(mergeAll$1(T3ConfigLive, T3AuthTransportLayer)));
+const T3LocalAuthLayer = T3LocalAuthLive.pipe(provide$2(NodeSqlClientFactoryLive));
+const T3AuthPairingLayer = T3AuthPairingLive.pipe(provide$2(T3AuthTransportLayer));
 const T3AuthLayer = T3AuthLive.pipe(provide$2(mergeAll$1(T3ConfigLive, T3AuthTransportLayer, T3LocalAuthLayer, T3AuthPairingLayer)));
 const T3RpcLayer = T3RpcLive.pipe(provide$2(mergeAll$1(T3ConfigLive, T3AuthLayer, layerWebSocketConstructor)));
 const T3OrchestrationLayer = T3OrchestrationLive.pipe(provide$2(T3RpcLayer));
@@ -71441,4 +71432,4 @@ const T3ApplicationLayer = T3ApplicationLive.pipe(provide$2(T3OrchestrationLayer
 const AuthAppLayer = mergeAll$1(T3ConfigLive, T3AuthLayer);
 const AppLayer = mergeAll$1(T3ConfigLive, T3AuthLayer, T3RpcLayer, T3OrchestrationLayer, T3ApplicationLayer);
 //#endregion
-export { runLast as $, isNullish as $n, sync as $t, Crypto as A, Service$1 as An, flatMap$2 as At, WatchBackend as B, isSome as Bn, map$3 as Bt, decodeUnknownEffect as C, succeed$4 as Cn, asVoid as Ct, optionalKey as D, fail$6 as Dn, catch_$1 as Dt, optional as E, map$5 as En, catchTags$1 as Et, TypeId$29 as F, fromNullishOr as Fn, gen as Ft, fromIterable$1 as G, Prototype as Gn, provideContext$2 as Gt, callback as H, match$3 as Hn, matchEffect as Ht, FileDescriptor as I, fromUndefinedOr as In, ignore$1 as It, mkString as J, BaseProto as Jn, runFork as Jt, isStream as K, PipeInspectableProto as Kn, provideService$1 as Kt, FileSystem as L, getOrElse$1 as Ln, interrupt$1 as Lt, fromReadable as M, getUnsafe$2 as Mn, fnUntraced as Mt, fromWritable as N, make$40 as Nn, forEach$1 as Nt, tag as O, succeed$6 as On, effectify as Ot, Path as P, flatMap$4 as Pn, forkScoped as Pt, runFold as Q, isNotUndefined as Qn, suspend$3 as Qt, FileTypeId as R, getOrUndefined as Rn, isEffect as Rt, decodeTo as S, isSuccess as Sn, as as St, is as T, sync$2 as Tn, catchFilter$2 as Tt, decodeText as U, none as Un, orDie as Ut, make$24 as V, map$7 as Vn, mapError$2 as Vt, empty$6 as W, some as Wn, provide as Wt, runCollect as X, hasProperty as Xn, serviceOption as Xt, run$1 as Y, format$1 as Yn, scoped$2 as Yt, runDrain as Z, isNotNull as Zn, succeed$2 as Zt, Literals as _, MinimumLogLevel as _n, nominal as _t, latestAssistantMessage as a, uninterruptible as an, pipeArguments as ar, get$2 as at, TaggedErrorClass as b, isDone$1 as bn, addFinalizer as bt, Environment as c, fail$3 as cn, __toESM as cr, isSink as ct, ArraySchema as d, effect as dn, make$27 as dt, tapCause as en, isUndefined as er, splitLines as et, Boolean$1 as f, mergeAll$1 as fn, offer as ft, Literal as g, sync$1 as gn, systemError as gt, Int as h, succeed$3 as hn, badArgument as ht, ThreadSessionError as i, try_ as in, pipe as ir, unwrap as it, make$23 as j, empty$11 as jn, fn as jt, toCodecStringTree as k, Reference as kn, fail$2 as kt, T3Config as l, hasInterruptsOnly as ln, endUnsafe as lt, ErrorClass as m, provideMerge as mn, BadArgument as mt, AuthAppLayer as n, timeoutOrElse as nn, dual as nr, tap as nt, threadStatus as o, void_$1 as on, __commonJSMin as or, make$25 as ot, Defect as p, provide$2 as pn, offerUnsafe as pt, merge$1 as q, withFiber$1 as qn, result as qt, NodeEnvironmentLive as r, tryPromise as rn, identity as rr, transduce as rt, T3Application as s, TaggedError as sn, __require as sr, drain as st, AppLayer as t, tapError$2 as tn, constVoid as tr, succeed as tt, T3Auth as u, squash as un, failCauseUnsafe as ut, String$1 as v, _await as vn, transform as vt, fromJsonString as w, ConsoleRef as wn, callback$1 as wt, Union as x, makeUnsafe$8 as xn, andThen as xt, Struct as y, doneUnsafe as yn, acquireRelease as yt, Size as z, isNone as zn, logError as zt };
+export { is as $, sync$2 as $n, catchFilter$2 as $t, UrlError as A, timeoutOrElse as An, dual as Ar, tap as At, Boolean$1 as B, mergeAll$1 as Bn, offer as Bt, AuthLocalDatabaseError as C, scoped$2 as Cn, format$1 as Cr, run$1 as Ct, AuthPairingUrlError as D, sync as Dn, isNullish as Dr, runLast as Dt, AuthLocalSigningError as E, suspend$3 as En, isNotUndefined as Er, runFold as Et, T3Application as F, TaggedError as Fn, __require as Fr, drain as Ft, Literals as G, MinimumLogLevel as Gn, nominal as Gt, ErrorClass as H, provideMerge as Hn, BadArgument as Ht, Environment as I, fail$3 as In, __toESM as Ir, isSink as It, TaggedErrorClass as J, isDone$1 as Jn, addFinalizer as Jt, String$1 as K, _await as Kn, transform as Kt, T3Config as L, hasInterruptsOnly as Ln, endUnsafe as Lt, ThreadSessionError as M, try_ as Mn, pipe as Mr, unwrap as Mt, latestAssistantMessage as N, uninterruptible as Nn, pipeArguments as Nr, get$2 as Nt, AuthTransportError as O, tapCause as On, isUndefined as Or, splitLines as Ot, threadStatus as P, void_$1 as Pn, __commonJSMin as Pr, make$25 as Pt, fromJsonString as Q, ConsoleRef as Qn, callback$1 as Qt, T3Auth as R, squash as Rn, failCauseUnsafe as Rt, AuthConfigError as S, runFork as Sn, BaseProto as Sr, mkString as St, AuthLocalSecretError as T, succeed$2 as Tn, isNotNull as Tr, runDrain as Tt, Int as U, succeed$3 as Un, badArgument as Ut, Defect as V, provide$2 as Vn, offerUnsafe as Vt, Literal as W, sync$1 as Wn, systemError as Wt, decodeTo as X, isSuccess as Xn, as as Xt, Union as Y, makeUnsafe$8 as Yn, andThen as Yt, decodeUnknownEffect as Z, succeed$4 as Zn, asVoid as Zt, parsePairingUrl as _, orDie as _n, none as _r, decodeText as _t, T3AuthTransportLayer as a, fn as an, empty$11 as ar, make$23 as at, makeT3LocalAuth as b, provideService$1 as bn, PipeInspectableProto as br, isStream as bt, NodeSqliteClientLive as c, forkScoped as cn, flatMap$4 as cr, Path as ct, makeT3Config as d, interrupt$1 as dn, getOrElse$1 as dr, FileSystem as dt, catchTags$1 as en, map$5 as er, optional as et, T3AuthLive as f, isEffect as fn, getOrUndefined as fr, FileTypeId as ft, makeT3AuthPairing as g, matchEffect as gn, match$3 as gr, callback as gt, T3AuthPairingLive as h, mapError$2 as hn, map$7 as hr, make$24 as ht, T3AuthPairingLayer as i, flatMap$2 as in, Service$1 as ir, Crypto as it, NodeEnvironmentLive as j, tryPromise as jn, identity as jr, transduce as jt, ConfigError as k, tapError$2 as kn, constVoid as kr, succeed as kt, makeNodeSqliteClient as l, gen as ln, fromNullishOr as lr, TypeId$29 as lt, T3AuthPairing as m, map$3 as mn, isSome as mr, WatchBackend as mt, AuthAppLayer as n, effectify as nn, succeed$6 as nr, tag as nt, T3LocalAuthLayer as o, fnUntraced as on, getUnsafe$2 as or, fromReadable as ot, makeT3Auth as p, logError as pn, isNone as pr, Size as pt, Struct as q, doneUnsafe as qn, acquireRelease as qt, T3AuthLayer as r, fail$2 as rn, Reference as rr, toCodecStringTree as rt, NodeSqlClientFactoryLive as s, forEach$1 as sn, make$40 as sr, fromWritable as st, AppLayer as t, catch_$1 as tn, fail$6 as tr, optionalKey as tt, T3ConfigLive as u, ignore$1 as un, fromUndefinedOr as ur, FileDescriptor as ut, T3LocalAuth as v, provide as vn, some as vr, empty$6 as vt, AuthLocalError as w, serviceOption as wn, hasProperty as wr, runCollect as wt, SqlClientFactory as x, result as xn, withFiber$1 as xr, merge$1 as xt, T3LocalAuthLive as y, provideContext$2 as yn, Prototype as yr, fromIterable$1 as yt, ArraySchema as z, effect as zn, make$27 as zt };

package/dist/src/application/layer.d.ts

@@ -772,5 +772,5 @@ export declare const makeT3Application: () => Effect.Effect<{
             readonly output: string | null;
         };
     }[], import("../rpc/error.ts").RpcError, never>;
-}, never, import("../environment/service.ts").Environment | import("effect/Path").Path | import("effect/Crypto").Crypto | import("../orchestration/service.ts").T3Orchestration>;
-export declare const T3ApplicationLive: Layer.Layer<T3Application, never, import("../environment/service.ts").Environment | import("effect/Path").Path | import("effect/Crypto").Crypto | import("../orchestration/service.ts").T3Orchestration>;
+}, never, import("../index.ts").Environment | import("effect/Path").Path | import("effect/Crypto").Crypto | import("../orchestration/service.ts").T3Orchestration>;
+export declare const T3ApplicationLive: Layer.Layer<T3Application, never, import("../index.ts").Environment | import("effect/Path").Path | import("effect/Crypto").Crypto | import("../orchestration/service.ts").T3Orchestration>;

package/dist/src/auth/layer.d.ts

@@ -6,9 +6,11 @@ import { T3LocalAuth } from "./local.ts";
 import { T3AuthPairing } from "./pairing.ts";
 import { T3Auth } from "./service.ts";
 import { T3AuthTransport } from "./transport.ts";
+import type { AuthConfigInput } from "./type.ts";
 export declare const makeT3Auth: () => Effect.Effect<{
-    pair: (pairingUrl: string) => Effect.Effect<import("./type.ts").PairResult, AuthConfigError | import("./error.ts").AuthPairingUrlError | import("./error.ts").AuthTransportError>;
-    local: (input: import("./type.ts").LocalAuthInput) => Effect.Effect<import("./type.ts").LocalAuthResult, AuthConfigError | import("./error.ts").AuthLocalError>;
+    pair: (pairingUrl: string) => Effect.Effect<import("./type.ts").PairResult, import("./error.ts").AuthPairingUrlError | import("./error.ts").AuthTransportError>;
+    local: (input: import("./type.ts").LocalAuthInput) => Effect.Effect<import("./type.ts").LocalAuthResult, import("./error.ts").AuthLocalError>;
+    writeConfig: (input: AuthConfigInput) => Effect.Effect<void, AuthConfigError, never>;
     status: () => Effect.Effect<{
         readonly authenticated: boolean;
         readonly role?: "client" | "owner";

package/dist/src/auth/local.d.ts

@@ -4,24 +4,24 @@ import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Layer from "effect/Layer";
 import * as Path from "effect/Path";
-import { T3Config } from "../config/service.ts";
 import { Environment } from "../environment/service.ts";
 import { SqlClientFactory } from "../sql/service.ts";
-import { AuthConfigError, AuthLocalError } from "./error.ts";
+import { AuthLocalError } from "./error.ts";
 import type { LocalAuthInput, LocalAuthResult } from "./type.ts";
 declare const T3LocalAuth_base: Context.ServiceClass<T3LocalAuth, "t3cli/T3LocalAuth", {
-    readonly local: (input: LocalAuthInput) => Effect.Effect<LocalAuthResult, AuthConfigError | AuthLocalError>;
+    readonly local: (input: LocalAuthInput) => Effect.Effect<LocalAuthResult, AuthLocalError>;
 }>;
 export declare class T3LocalAuth extends T3LocalAuth_base {
 }
 export declare const makeT3LocalAuth: () => Effect.Effect<{
     local: (input: LocalAuthInput) => Effect.Effect<{
         url: string;
+        token: string;
         role: "client" | "owner";
         expiresAt: string;
         source: "local";
         baseDir: string;
-    }, AuthConfigError | AuthLocalError, never>;
-}, never, Environment | T3Config | SqlClientFactory | Path.Path | FileSystem.FileSystem | Crypto.Crypto>;
-export declare const T3LocalAuthLive: Layer.Layer<T3LocalAuth, never, Environment | T3Config | SqlClientFactory | Path.Path | FileSystem.FileSystem | Crypto.Crypto>;
+    }, AuthLocalError, never>;
+}, never, Environment | SqlClientFactory | Path.Path | FileSystem.FileSystem | Crypto.Crypto>;
+export declare const T3LocalAuthLive: Layer.Layer<T3LocalAuth, never, Environment | SqlClientFactory | Path.Path | FileSystem.FileSystem | Crypto.Crypto>;
 export {};

package/dist/src/auth/pairing.d.ts

@@ -1,22 +1,22 @@
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
-import { T3Config } from "../config/service.ts";
-import { AuthConfigError, AuthPairingUrlError, AuthTransportError } from "./error.ts";
+import { AuthPairingUrlError, AuthTransportError } from "./error.ts";
 import { T3AuthTransport } from "./transport.ts";
 import type { PairingUrl, PairResult } from "./type.ts";
 declare const T3AuthPairing_base: Context.ServiceClass<T3AuthPairing, "t3cli/T3AuthPairing", {
-    readonly pair: (pairingUrl: string) => Effect.Effect<PairResult, AuthConfigError | AuthPairingUrlError | AuthTransportError>;
+    readonly pair: (pairingUrl: string) => Effect.Effect<PairResult, AuthPairingUrlError | AuthTransportError>;
 }>;
 export declare class T3AuthPairing extends T3AuthPairing_base {
 }
 export declare const makeT3AuthPairing: () => Effect.Effect<{
     pair: (pairingUrl: string) => Effect.Effect<{
         url: string;
+        token: string;
         role: "client" | "owner";
         expiresAt: string;
-    }, AuthPairingUrlError | AuthConfigError | AuthTransportError, never>;
-}, never, T3Config | T3AuthTransport>;
-export declare const T3AuthPairingLive: Layer.Layer<T3AuthPairing, never, T3Config | T3AuthTransport>;
+    }, AuthPairingUrlError | AuthTransportError, never>;
+}, never, T3AuthTransport>;
+export declare const T3AuthPairingLive: Layer.Layer<T3AuthPairing, never, T3AuthTransport>;
 export declare function parsePairingUrl(value: string): Effect.Effect<PairingUrl, AuthPairingUrlError>;
 export {};

package/dist/src/auth/service.d.ts

@@ -2,10 +2,11 @@ import * as Context from "effect/Context";
 import type * as Effect from "effect/Effect";
 import type { AuthSessionState, AuthWebSocketTicketResult } from "./schema.ts";
 import type { AuthError } from "./error.ts";
-import type { LocalAuthInput, LocalAuthResult, PairResult } from "./type.ts";
+import type { AuthConfigInput, LocalAuthInput, LocalAuthResult, PairResult } from "./type.ts";
 declare const T3Auth_base: Context.ServiceClass<T3Auth, "t3cli/T3Auth", {
     readonly pair: (value: string) => Effect.Effect<PairResult, AuthError>;
     readonly local: (input: LocalAuthInput) => Effect.Effect<LocalAuthResult, AuthError>;
+    readonly writeConfig: (input: AuthConfigInput) => Effect.Effect<void, AuthError>;
     readonly status: () => Effect.Effect<AuthSessionState, AuthError>;
     readonly issueWebSocketTicket: () => Effect.Effect<AuthWebSocketTicketResult, AuthError>;
 }>;

package/dist/src/auth/type.d.ts

@@ -4,8 +4,13 @@ export type PairingUrl = {
     readonly baseUrl: string;
     readonly credential: string;
 };
+export type AuthConfigInput = {
+    readonly url: string;
+    readonly token: string;
+};
 export type PairResult = {
     readonly url: string;
+    readonly token: string;
     readonly role: AuthBearerBootstrapResult["role"];
     readonly expiresAt: string;
 };
@@ -18,6 +23,7 @@ export type LocalAuthInput = {
 };
 export type LocalAuthResult = {
     readonly url: string;
+    readonly token: string;
     readonly role: AuthSessionRole;
     readonly expiresAt: string;
     readonly source: "local";

package/dist/src/index.d.ts

@@ -1,6 +1,24 @@
 export { T3Application } from "./application/service.ts";
 export type { SendThreadInput, StartThreadInput, StartThreadPolicy, WaitEvent, } from "./application/service.ts";
 export type { ApplicationError } from "./application/error.ts";
+export { T3Auth } from "./auth/service.ts";
+export { T3AuthLive, makeT3Auth } from "./auth/layer.ts";
+export { T3LocalAuth, T3LocalAuthLive, makeT3LocalAuth } from "./auth/local.ts";
+export { T3AuthPairing, T3AuthPairingLive, makeT3AuthPairing, parsePairingUrl, } from "./auth/pairing.ts";
+export { AuthConfigError, AuthLocalDatabaseError, AuthLocalError, AuthLocalSecretError, AuthLocalSigningError, AuthPairingUrlError, AuthTransportError, } from "./auth/error.ts";
+export type { AuthError } from "./auth/error.ts";
+export type { AuthSessionState, AuthWebSocketTicketResult } from "./auth/schema.ts";
+export type { AuthConfigInput, AuthSessionRole, LocalAuthInput, LocalAuthResult, PairingUrl, PairResult, } from "./auth/type.ts";
+export { T3Config } from "./config/service.ts";
+export type { ResolvedConfig, StoredConfig } from "./config/service.ts";
+export { T3ConfigLive, makeT3Config } from "./config/layer.ts";
+export { ConfigError, UrlError } from "./config/error.ts";
+export type { ConfigServiceError } from "./config/error.ts";
+export { Environment } from "./environment/service.ts";
+export type { EnvironmentShape } from "./environment/service.ts";
 export { NodeEnvironmentLive } from "./environment/layer.ts";
-export { AppLayer, AuthAppLayer } from "./runtime.ts";
+export { AppLayer, AuthAppLayer, T3AuthLayer, T3AuthPairingLayer, T3AuthTransportLayer, T3LocalAuthLayer, } from "./runtime.ts";
+export { SqlClientFactory } from "./sql/service.ts";
+export type { SqlClientFactoryShape, SqliteClientConfig } from "./sql/service.ts";
+export { NodeSqlClientFactoryLive, NodeSqliteClientLive, makeNodeSqliteClient, } from "./sql/node-sqlite-client.ts";
 export type { OrchestrationMessage, OrchestrationProjectShell, OrchestrationShellSnapshot, OrchestrationThread, OrchestrationThreadShell, ServerProvider, } from "#t3tools/contracts";

package/dist/src/rpc/layer.d.ts

@@ -4674,5 +4674,5 @@ export declare const makeT3RpcLayer: () => Effect.Effect<{
             }[];
         }, import("effect/unstable/rpc/RpcClientError").RpcClientError | (Discard extends true ? never : import("#t3tools/contracts").EnvironmentAuthorizationError | import("#t3tools/contracts").KeybindingsConfigError | import("#t3tools/contracts").ServerSettingsError), never>;
     }, RpcError, never>;
-}, never, T3Config | Scope.Scope | T3Auth>;
-export declare const T3RpcLive: Layer.Layer<T3Rpc, never, T3Config | T3Auth>;
+}, never, T3Auth | T3Config | Scope.Scope>;
+export declare const T3RpcLive: Layer.Layer<T3Rpc, never, T3Auth | T3Config>;

package/dist/src/runtime.d.ts

@@ -1,3 +1,7 @@
 import * as Layer from "effect/Layer";
-export declare const AuthAppLayer: Layer.Layer<import("./config/service.ts").T3Config | import("./auth/service.ts").T3Auth, never, import("./environment/service.ts").Environment | import("effect/Path").Path | import("effect/FileSystem").FileSystem | import("effect/Crypto").Crypto>;
-export declare const AppLayer: Layer.Layer<import("./index.ts").T3Application | import("./config/service.ts").T3Config | import("./auth/service.ts").T3Auth | import("./orchestration/service.ts").T3Orchestration | import("./rpc/service.ts").T3Rpc, never, import("./environment/service.ts").Environment | import("effect/Path").Path | import("effect/FileSystem").FileSystem | import("effect/Crypto").Crypto>;
+export declare const T3AuthTransportLayer: Layer.Layer<import("./auth/transport.ts").T3AuthTransport, never, never>;
+export declare const T3LocalAuthLayer: Layer.Layer<import("./auth/local.ts").T3LocalAuth, never, import("./index.ts").Environment | import("effect/Path").Path | import("effect/FileSystem").FileSystem | import("effect/Crypto").Crypto>;
+export declare const T3AuthPairingLayer: Layer.Layer<import("./auth/pairing.ts").T3AuthPairing, never, never>;
+export declare const T3AuthLayer: Layer.Layer<import("./index.ts").T3Auth, never, import("./index.ts").Environment | import("effect/Path").Path | import("effect/FileSystem").FileSystem | import("effect/Crypto").Crypto>;
+export declare const AuthAppLayer: Layer.Layer<import("./index.ts").T3Auth | import("./index.ts").T3Config, never, import("./index.ts").Environment | import("effect/Path").Path | import("effect/FileSystem").FileSystem | import("effect/Crypto").Crypto>;
+export declare const AppLayer: Layer.Layer<import("./index.ts").T3Application | import("./index.ts").T3Auth | import("./index.ts").T3Config | import("./orchestration/service.ts").T3Orchestration | import("./rpc/service.ts").T3Rpc, never, import("./index.ts").Environment | import("effect/Path").Path | import("effect/FileSystem").FileSystem | import("effect/Crypto").Crypto>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "t3code-cli",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "CLI for t3code",
   "keywords": [
     "claude",

package/src/auth/layer.ts

@@ -7,6 +7,7 @@ import { T3LocalAuth } from "./local.ts";
 import { T3AuthPairing } from "./pairing.ts";
 import { T3Auth } from "./service.ts";
 import { T3AuthTransport } from "./transport.ts";
+import type { AuthConfigInput } from "./type.ts";
 
 export const makeT3Auth = Effect.fn("makeT3Auth")(function* () {
   const config = yield* T3Config;
@@ -38,9 +39,25 @@ export const makeT3Auth = Effect.fn("makeT3Auth")(function* () {
     return yield* transport.issueWebSocketTicket(resolved);
   });
 
+  const writeConfig = Effect.fn("T3AuthLive.writeConfig")(function* (input: AuthConfigInput) {
+    const existing = yield* config.readStored().pipe(
+      Effect.catchTags({
+        ConfigError: (error) =>
+          Effect.fail(new AuthConfigError({ message: "auth config failed", cause: error })),
+      }),
+    );
+    yield* config.writeStored({ ...existing, url: input.url, token: input.token }).pipe(
+      Effect.catchTags({
+        ConfigError: (error) =>
+          Effect.fail(new AuthConfigError({ message: "auth config failed", cause: error })),
+      }),
+    );
+  });
+
   return {
     pair: pairing.pair,
     local: localAuth.local,
+    writeConfig,
     status,
     issueWebSocketTicket,
   };

package/src/auth/local.ts

@@ -15,12 +15,10 @@ import * as Path from "effect/Path";
 import * as Predicate from "effect/Predicate";
 import * as SqlClient from "effect/unstable/sql/SqlClient";
 
-import { T3Config } from "../config/service.ts";
 import { normalizeHttpBaseUrl } from "../config/url.ts";
 import { Environment } from "../environment/service.ts";
 import { SqlClientFactory } from "../sql/service.ts";
 import {
-  AuthConfigError,
   AuthLocalDatabaseError,
   AuthLocalError,
   AuthLocalSecretError,
@@ -32,14 +30,11 @@ import type { LocalAuthInput, LocalAuthResult } from "./type.ts";
 export class T3LocalAuth extends Context.Service<
   T3LocalAuth,
   {
-    readonly local: (
-      input: LocalAuthInput,
-    ) => Effect.Effect<LocalAuthResult, AuthConfigError | AuthLocalError>;
+    readonly local: (input: LocalAuthInput) => Effect.Effect<LocalAuthResult, AuthLocalError>;
   }
 >()("t3cli/T3LocalAuth") {}
 
 export const makeT3LocalAuth = Effect.fn("makeT3LocalAuth")(function* () {
-  const config = yield* T3Config;
   const fs = yield* FileSystem.FileSystem;
   const path = yield* Path.Path;
   const environment = yield* Environment;
@@ -218,23 +213,6 @@ export const makeT3LocalAuth = Effect.fn("makeT3LocalAuth")(function* () {
     };
   });
 
-  function writeLocalConfig(input: { readonly url: string; readonly token: string }) {
-    return Effect.gen(function* () {
-      const existing = yield* config.readStored().pipe(
-        Effect.catchTags({
-          ConfigError: (error) =>
-            Effect.fail(new AuthConfigError({ message: "auth config failed", cause: error })),
-        }),
-      );
-      yield* config.writeStored({ ...existing, url: input.url, token: input.token }).pipe(
-        Effect.catchTags({
-          ConfigError: (error) =>
-            Effect.fail(new AuthConfigError({ message: "auth config failed", cause: error })),
-        }),
-      );
-    });
-  }
-
   const local = Effect.fn("T3LocalAuthLive.local")(function* (input: LocalAuthInput) {
     if (input.label.length === 0) {
       return yield* Effect.fail(
@@ -264,9 +242,9 @@ export const makeT3LocalAuth = Effect.fn("makeT3LocalAuth")(function* () {
       baseDir,
       ...(input.origin !== undefined ? { origin: input.origin } : {}),
     });
-    yield* writeLocalConfig({ url, token: session.token });
     return {
       url,
+      token: session.token,
       role: session.role,
       expiresAt: session.expiresAt,
       source: "local" as const,

package/src/auth/pairing.ts

@@ -3,8 +3,7 @@ import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import { Url } from "effect/unstable/http";
 
-import { T3Config } from "../config/service.ts";
-import { AuthConfigError, AuthPairingUrlError, AuthTransportError } from "./error.ts";
+import { AuthPairingUrlError, AuthTransportError } from "./error.ts";
 import { T3AuthTransport } from "./transport.ts";
 import type { PairingUrl, PairResult } from "./type.ts";
 
@@ -13,32 +12,22 @@ export class T3AuthPairing extends Context.Service<
   {
     readonly pair: (
       pairingUrl: string,
-    ) => Effect.Effect<PairResult, AuthConfigError | AuthPairingUrlError | AuthTransportError>;
+    ) => Effect.Effect<PairResult, AuthPairingUrlError | AuthTransportError>;
   }
 >()("t3cli/T3AuthPairing") {}
 
 export const makeT3AuthPairing = Effect.fn("makeT3AuthPairing")(function* () {
-  const config = yield* T3Config;
   const transport = yield* T3AuthTransport;
 
   const pair = Effect.fn("T3AuthPairingLive.pair")(function* (pairingUrl: string) {
     const parsed = yield* parsePairingUrl(pairingUrl);
     const result = yield* transport.bootstrapBearer(parsed);
-    const existing = yield* config.readStored().pipe(
-      Effect.catchTags({
-        ConfigError: (error) =>
-          Effect.fail(new AuthConfigError({ message: "auth config failed", cause: error })),
-      }),
-    );
-    yield* config
-      .writeStored({ ...existing, url: parsed.baseUrl, token: result.sessionToken })
-      .pipe(
-        Effect.catchTags({
-          ConfigError: (error) =>
-            Effect.fail(new AuthConfigError({ message: "auth config failed", cause: error })),
-        }),
-      );
-    return { url: parsed.baseUrl, role: result.role, expiresAt: result.expiresAt };
+    return {
+      url: parsed.baseUrl,
+      token: result.sessionToken,
+      role: result.role,
+      expiresAt: result.expiresAt,
+    };
   });
 
   return { pair };

package/src/auth/service.ts

@@ -3,13 +3,14 @@ import type * as Effect from "effect/Effect";
 
 import type { AuthSessionState, AuthWebSocketTicketResult } from "./schema.ts";
 import type { AuthError } from "./error.ts";
-import type { LocalAuthInput, LocalAuthResult, PairResult } from "./type.ts";
+import type { AuthConfigInput, LocalAuthInput, LocalAuthResult, PairResult } from "./type.ts";
 
 export class T3Auth extends Context.Service<
   T3Auth,
   {
     readonly pair: (value: string) => Effect.Effect<PairResult, AuthError>;
     readonly local: (input: LocalAuthInput) => Effect.Effect<LocalAuthResult, AuthError>;
+    readonly writeConfig: (input: AuthConfigInput) => Effect.Effect<void, AuthError>;
     readonly status: () => Effect.Effect<AuthSessionState, AuthError>;
     readonly issueWebSocketTicket: () => Effect.Effect<AuthWebSocketTicketResult, AuthError>;
   }

package/src/auth/type.ts

@@ -7,8 +7,14 @@ export type PairingUrl = {
   readonly credential: string;
 };
 
+export type AuthConfigInput = {
+  readonly url: string;
+  readonly token: string;
+};
+
 export type PairResult = {
   readonly url: string;
+  readonly token: string;
   readonly role: AuthBearerBootstrapResult["role"];
   readonly expiresAt: string;
 };
@@ -23,6 +29,7 @@ export type LocalAuthInput = {
 
 export type LocalAuthResult = {
   readonly url: string;
+  readonly token: string;
   readonly role: AuthSessionRole;
   readonly expiresAt: string;
   readonly source: "local";

package/src/cli/auth.ts

@@ -35,6 +35,7 @@ const pairCommand = Command.make(
       const output = yield* T3Output;
       const resolvedFormat = resolveOutputFormat(format, environment, "json");
       const result = yield* auth.pair(url);
+      yield* auth.writeConfig(result);
       if (resolvedFormat === "json") {
         yield* output.printJson(result);
       } else {
@@ -66,6 +67,7 @@ const localCommand = Command.make(
         ...(Option.isSome(baseDir) ? { baseDir: baseDir.value } : {}),
         ...(Option.isSome(origin) ? { origin: origin.value } : {}),
       });
+      yield* auth.writeConfig(result);
       if (resolvedFormat === "json") {
         yield* output.printJson(formatAuthLocalJson(result));
       } else {

package/src/index.ts

@@ -6,8 +6,57 @@ export type {
   WaitEvent,
 } from "./application/service.ts";
 export type { ApplicationError } from "./application/error.ts";
+export { T3Auth } from "./auth/service.ts";
+export { T3AuthLive, makeT3Auth } from "./auth/layer.ts";
+export { T3LocalAuth, T3LocalAuthLive, makeT3LocalAuth } from "./auth/local.ts";
+export {
+  T3AuthPairing,
+  T3AuthPairingLive,
+  makeT3AuthPairing,
+  parsePairingUrl,
+} from "./auth/pairing.ts";
+export {
+  AuthConfigError,
+  AuthLocalDatabaseError,
+  AuthLocalError,
+  AuthLocalSecretError,
+  AuthLocalSigningError,
+  AuthPairingUrlError,
+  AuthTransportError,
+} from "./auth/error.ts";
+export type { AuthError } from "./auth/error.ts";
+export type { AuthSessionState, AuthWebSocketTicketResult } from "./auth/schema.ts";
+export type {
+  AuthConfigInput,
+  AuthSessionRole,
+  LocalAuthInput,
+  LocalAuthResult,
+  PairingUrl,
+  PairResult,
+} from "./auth/type.ts";
+export { T3Config } from "./config/service.ts";
+export type { ResolvedConfig, StoredConfig } from "./config/service.ts";
+export { T3ConfigLive, makeT3Config } from "./config/layer.ts";
+export { ConfigError, UrlError } from "./config/error.ts";
+export type { ConfigServiceError } from "./config/error.ts";
+export { Environment } from "./environment/service.ts";
+export type { EnvironmentShape } from "./environment/service.ts";
 export { NodeEnvironmentLive } from "./environment/layer.ts";
-export { AppLayer, AuthAppLayer } from "./runtime.ts";
+export {
+  AppLayer,
+  AuthAppLayer,
+  T3AuthLayer,
+  T3AuthPairingLayer,
+  T3AuthTransportLayer,
+  T3LocalAuthLayer,
+} from "./runtime.ts";
+export { SqlClientFactory } from "./sql/service.ts";
+export type { SqlClientFactoryShape, SqliteClientConfig } from "./sql/service.ts";
+export {
+  NodeSqlClientFactoryLive,
+  NodeSqliteClientLive,
+  makeNodeSqliteClient,
+} from "./sql/node-sqlite-client.ts";
 export type {
   OrchestrationMessage,
   OrchestrationProjectShell,

package/src/runtime.ts

@@ -12,14 +12,12 @@ import { T3OrchestrationLive } from "./orchestration/layer.ts";
 import { T3RpcLive } from "./rpc/layer.ts";
 import { NodeSqlClientFactoryLive } from "./sql/node-sqlite-client.ts";
 
-const T3AuthTransportLayer = T3AuthTransportLive.pipe(Layer.provide(NodeHttpClient.layerUndici));
-const T3LocalAuthLayer = T3LocalAuthLive.pipe(
-  Layer.provide(Layer.mergeAll(T3ConfigLive, NodeSqlClientFactoryLive)),
+export const T3AuthTransportLayer = T3AuthTransportLive.pipe(
+  Layer.provide(NodeHttpClient.layerUndici),
 );
-const T3AuthPairingLayer = T3AuthPairingLive.pipe(
-  Layer.provide(Layer.mergeAll(T3ConfigLive, T3AuthTransportLayer)),
-);
-const T3AuthLayer = T3AuthLive.pipe(
+export const T3LocalAuthLayer = T3LocalAuthLive.pipe(Layer.provide(NodeSqlClientFactoryLive));
+export const T3AuthPairingLayer = T3AuthPairingLive.pipe(Layer.provide(T3AuthTransportLayer));
+export const T3AuthLayer = T3AuthLive.pipe(
   Layer.provide(
     Layer.mergeAll(T3ConfigLive, T3AuthTransportLayer, T3LocalAuthLayer, T3AuthPairingLayer),
   ),