t3code-cli 0.5.1 → 0.6.0

package/dist/layer-DIg0RxSO.js

@@ -0,0 +1,1217 @@
+import { An as identity, C as isNone, S as getOrUndefined, T as isSome, an as hasProperty, n as Service } from "./Context-DueQ9iMH.js";
+import { $ as mapError, Fn as succeed$1, It as try_, Mn as mergeAll, Mt as tapError, Nn as provide$1, P as fn, Tt as succeed, U as gen, Vt as void_, X as map, Yt as exponential, Zt as take, b as catchTags, bt as scope, dt as provideService, j as flatMap, k as fail, kn as effect, kt as sync, lt as provide, mt as retry, qt as collectWhile, st as orDie, t as Path, xt as scoped, zn as addFinalizer } from "./Path-D8WPdPwR.js";
+import { $ as optional, $t as tapError$1, At as map$1, Ct as flatMap$1, Et as fromIterableEffect, F as decodeUnknownSync, Ft as peel, Gt as runHead, Kt as runLast, Ln as formatIso, Rn as now, Rt as retry$1, St as filter, T as Union, Tt as fromIterable, Zt as takeUntil, _t as catchTags$1, a as Defect, g as Number, nn as unwrap, qt as scoped$1, sn as head, x as TaggedErrorClass, xt as fail$1, y as String } from "./Schema-DsQxYh6_.js";
+import { n as T3AuthTransportLive } from "./transport-D3zBdZ1h.js";
+import { a as makeT3CodeConnectionProvider, n as T3Rpc, o as layerWebSocketConstructor, r as T3CodeConnectionProvider, s as layerUndici, t as T3RpcLive } from "./layer-DvHnKBYj.js";
+import { S as Crypto, _ as layer, c as T3LocalAuthLive, d as T3LocalAuthTokenLive, g as makeCompilerSqlite, h as defaultTransforms, i as T3AuthPairingLive, m as make, p as SqlClientFactory, t as T3AuthLive, y as T3LocalAuthOriginLive } from "./layer-CfC5qZol.js";
+import { $c as ProviderInstanceId, Gu as MessageId, Vu as CommandId, Yu as ProjectId, is as ORCHESTRATION_WS_METHODS, rs as ModelSelection, t as WS_METHODS, td as ThreadId, ws as OrchestrationMessage } from "./src-KdbHqrex.js";
+import { n as T3Config, t as Environment } from "./service-CLmRO2Dp.js";
+import { t as T3Application } from "./service-ybOWV9pL.js";
+import { i as RpcClientError, n as T3CodeConnectionError, t as RpcError } from "./error-B2t1bAP9.js";
+import { t as T3ConfigLive } from "./layer-DUv99vsS.js";
+import { DatabaseSync } from "node:sqlite";
+//#region src/domain/error.ts
+var ProjectLookupError = class extends TaggedErrorClass()("ProjectLookupError", {
+	message: String,
+	ref: String
+}) {};
+var ModelSelectionError = class extends TaggedErrorClass()("ModelSelectionError", { message: String }) {};
+TaggedErrorClass()("ThreadEventError", { message: String });
+var ThreadSessionError = class extends TaggedErrorClass()("ThreadSessionError", {
+	message: String,
+	threadId: String
+}) {};
+var ProjectCreateVisibilityError = class extends TaggedErrorClass()("ProjectCreateVisibilityError", {
+	message: String,
+	projectId: String
+}) {};
+//#endregion
+//#region src/domain/thread-lifecycle.ts
+function isThreadActive(thread) {
+	return thread.session?.status === "starting" || thread.session?.status === "running" || thread.latestTurn?.state === "running" || isPendingStart(thread);
+}
+function threadStatus(thread) {
+	if (isPendingStart(thread)) return "pending";
+	return thread.session?.status ?? thread.latestTurn?.state ?? "unknown";
+}
+function latestAssistantMessage(thread) {
+	return thread.messages.toReversed().find((message) => message.role === "assistant");
+}
+function isThreadCompleteEnough(thread) {
+	if (thread.session?.status === "error" || thread.session?.status === "interrupted") return true;
+	const lastUserIndex = thread.messages.findLastIndex((message) => message.role === "user");
+	if (lastUserIndex === -1) return true;
+	return thread.messages.slice(lastUserIndex + 1).some((message) => message.role === "assistant");
+}
+function applyThreadEvent(current, event, messages) {
+	const message = messageFromEvent(event, messages);
+	if (message !== null) {
+		messages.set(messageKey(message), message);
+		return {
+			...current,
+			messages: [...messages.values()]
+		};
+	}
+	if (event.type === "thread.session-set") return {
+		...current,
+		session: event.payload.session
+	};
+	return current;
+}
+function messageFromEvent(event, existingMessages = /* @__PURE__ */ new Map()) {
+	if (event.type !== "thread.message-sent") return null;
+	const payload = event.payload;
+	const id = payload.messageId;
+	const previous = existingMessages.get(id);
+	const text = payload.text;
+	return decodeUnknownSync(OrchestrationMessage)({
+		id,
+		role: payload.role,
+		text: text.length > 0 || previous === void 0 ? text : previous.text,
+		turnId: payload.turnId,
+		streaming: payload.streaming,
+		createdAt: payload.createdAt,
+		updatedAt: payload.updatedAt
+	});
+}
+function messageKey(message) {
+	return message.id;
+}
+function isPendingStart(thread) {
+	if (thread.session !== null || thread.latestTurn !== null || !("messages" in thread)) return false;
+	return thread.messages.at(-1)?.role === "user";
+}
+//#endregion
+//#region src/domain/model-config.ts
+function isSelectableProvider(provider) {
+	return provider.status === "ready" && provider.models.length > 0;
+}
+function firstSelectableProvider(providers) {
+	return providers.find(isSelectableProvider);
+}
+function firstSelectableModel(provider) {
+	return provider.models[0];
+}
+function findSelectableProvider(providers, instanceId) {
+	return providers.find((provider) => provider.instanceId === instanceId && isSelectableProvider(provider));
+}
+function filterProvidersForModelListing(input) {
+	return input.providers.filter((provider) => input.provider === void 0 || provider.instanceId === input.provider).flatMap((provider) => {
+		if (input.all) return [provider];
+		if (!isSelectableProvider(provider)) return [];
+		return [provider];
+	});
+}
+//#endregion
+//#region src/orchestration/service.ts
+var T3Orchestration = class extends Service()("t3cli/T3Orchestration") {};
+//#endregion
+//#region src/application/models.ts
+const makeModelsApplication = fn("makeModelsApplication")(function* () {
+	const orchestration = yield* T3Orchestration;
+	return { listModels: fn("T3Application.listModels")(function* (input) {
+		return filterProvidersForModelListing({
+			providers: (yield* orchestration.getServerConfig()).providers,
+			all: input.all === true,
+			...input.provider !== void 0 && input.provider.length > 0 ? { provider: input.provider } : {}
+		});
+	}) };
+});
+//#endregion
+//#region src/domain/helpers.ts
+const resolveProjectScope = fn("resolveProjectScope")(function* (snapshot, input) {
+	const absoluteRef = yield* resolveAbsolutePath(input.ref, input.cwd);
+	const byId = findProjectById(snapshot, input.ref);
+	if (byId !== null) return { project: byId };
+	const byExactPath = yield* findProjectByWorkspaceRoot(snapshot, absoluteRef, input.cwd);
+	if (byExactPath !== void 0) return { project: byExactPath };
+	const byAncestor = yield* findProjectByAncestorPath(snapshot, absoluteRef, input.cwd);
+	if (byAncestor !== void 0) return byAncestor;
+	return yield* findProjectByKnownWorktreePath(snapshot, absoluteRef, input.cwd);
+});
+function findProjectById(snapshot, projectId) {
+	return snapshot.projects.find((project) => project.id === projectId) ?? null;
+}
+const resolveAbsolutePath = fn("resolveAbsolutePath")(function* (ref, cwd) {
+	const path = yield* Path;
+	return path.isAbsolute(ref) ? path.normalize(ref) : path.normalize(path.resolve(cwd, ref));
+});
+const isDescendantPath = fn("isDescendantPath")(function* (parent, child) {
+	const path = yield* Path;
+	if (child === parent) return true;
+	const relative = path.relative(parent, child);
+	return relative.length > 0 && !relative.startsWith("..") && !path.isAbsolute(relative);
+});
+const findProjectByWorkspaceRoot = fn("findProjectByWorkspaceRoot")(function* (snapshot, absolutePath, cwd) {
+	for (const project of snapshot.projects) if ((yield* resolveAbsolutePath(project.workspaceRoot, cwd)) === absolutePath) return project;
+});
+const findProjectByAncestorPath = fn("findProjectByAncestorPath")(function* (snapshot, absolutePath, cwd) {
+	let bestProject;
+	let bestWorkspaceRoot = "";
+	for (const project of snapshot.projects) {
+		const workspaceRoot = yield* resolveAbsolutePath(project.workspaceRoot, cwd);
+		if (!(yield* isDescendantPath(workspaceRoot, absolutePath))) continue;
+		if (workspaceRoot.length > bestWorkspaceRoot.length) {
+			bestProject = project;
+			bestWorkspaceRoot = workspaceRoot;
+		}
+	}
+	if (bestProject === void 0) return;
+	if (absolutePath === bestWorkspaceRoot) return { project: bestProject };
+	return {
+		project: bestProject,
+		inferredWorktreePath: absolutePath
+	};
+});
+const findProjectByKnownWorktreePath = fn("findProjectByKnownWorktreePath")(function* (snapshot, absolutePath, cwd) {
+	const projectsById = new Map(snapshot.projects.map((project) => [project.id, project]));
+	let bestProject;
+	let bestKnownPath = "";
+	for (const thread of snapshot.threads) {
+		if (thread.worktreePath === null) continue;
+		const project = projectsById.get(thread.projectId);
+		if (project === void 0) continue;
+		const knownPath = yield* resolveAbsolutePath(thread.worktreePath, cwd);
+		if (!(yield* isDescendantPath(knownPath, absolutePath))) continue;
+		if (knownPath.length > bestKnownPath.length) {
+			bestProject = project;
+			bestKnownPath = knownPath;
+		}
+	}
+	if (bestProject === void 0) return;
+	const workspaceRoot = yield* resolveAbsolutePath(bestProject.workspaceRoot, cwd);
+	if (absolutePath === workspaceRoot) return { project: bestProject };
+	if (absolutePath === bestKnownPath) return bestKnownPath === workspaceRoot ? { project: bestProject } : {
+		project: bestProject,
+		inferredWorktreePath: bestKnownPath
+	};
+	return {
+		project: bestProject,
+		inferredWorktreePath: absolutePath
+	};
+});
+//#endregion
+//#region src/application/project-commands.ts
+const makeProjectCreateCommand = fn("makeProjectCreateCommand")(function* (input) {
+	const path = yield* Path;
+	const crypto = yield* Crypto;
+	const environment = yield* Environment;
+	const workspaceRoot = path.resolve(environment.cwd, input.path);
+	const projectId = ProjectId.make(yield* crypto.randomUUIDv4.pipe(orDie));
+	const title = input.title?.trim();
+	const createdAt = formatIso(yield* now);
+	return {
+		type: "project.create",
+		commandId: CommandId.make(`t3cli:project-create:${yield* crypto.randomUUIDv4.pipe(orDie)}`),
+		projectId,
+		title: title !== void 0 && title.length > 0 ? title : path.basename(workspaceRoot),
+		workspaceRoot,
+		createdAt
+	};
+});
+//#endregion
+//#region src/application/shell-sequence.ts
+function waitForShellSequence(input) {
+	return gen(function* () {
+		if (isNone(yield* input.orchestration.watchShellSequence().pipe(filter((snapshotSequence) => snapshotSequence >= input.sequence), runHead, scoped))) return yield* fail(new RpcError({
+			message: `shell stream ended before sequence ${input.sequence}`,
+			method: ORCHESTRATION_WS_METHODS.subscribeShell
+		}));
+		return yield* input.orchestration.getShellSnapshot();
+	});
+}
+//#endregion
+//#region src/application/projects.ts
+const makeProjectApplication = fn("makeProjectApplication")(function* () {
+	const orchestration = yield* T3Orchestration;
+	const crypto = yield* Crypto;
+	const path = yield* Path;
+	const environment = yield* Environment;
+	return {
+		loadShell: fn("T3ApplicationLive.loadShell")(function* () {
+			return yield* orchestration.getShellSnapshot();
+		}),
+		addProject: fn("T3ApplicationLive.addProject")(function* (projectInput) {
+			const command = yield* makeProjectCreateCommand(projectInput).pipe(provideService(Path, path), provideService(Crypto, crypto), provideService(Environment, environment));
+			const dispatch = yield* orchestration.dispatch(command);
+			const project = findProjectById(yield* waitForShellSequence({
+				orchestration,
+				sequence: dispatch.sequence
+			}), command.projectId);
+			if (project === null) return yield* fail(new ProjectCreateVisibilityError({
+				message: `project created but not visible in shell snapshot: ${command.projectId}`,
+				projectId: command.projectId
+			}));
+			return {
+				dispatch,
+				project
+			};
+		})
+	};
+});
+//#endregion
+//#region src/application/model-selection.ts
+function resolveModelSelection(input) {
+	return gen(function* () {
+		if (input.start.provider !== void 0 && input.start.model !== void 0) return withModelOptions(input.start, {
+			instanceId: ProviderInstanceId.make(input.start.provider),
+			model: input.start.model
+		});
+		if (input.start.provider !== void 0) {
+			const model = firstSelectableModel(yield* findProvider(input.serverConfig, input.start.provider));
+			if (model === void 0) return yield* failNoAvailableModel();
+			return withModelOptions(input.start, {
+				instanceId: ProviderInstanceId.make(input.start.provider),
+				model: model.slug
+			});
+		}
+		if (input.start.model !== void 0) {
+			const provider = yield* firstAvailableModel(input.serverConfig);
+			return withModelOptions(input.start, {
+				instanceId: provider.instanceId,
+				model: input.start.model
+			});
+		}
+		if (input.project.defaultModelSelection !== null) return withModelOptions(input.start, input.project.defaultModelSelection);
+		const provider = yield* firstAvailableModel(input.serverConfig);
+		const model = firstSelectableModel(provider);
+		if (model === void 0) return yield* failNoAvailableModel();
+		return withModelOptions(input.start, {
+			instanceId: provider.instanceId,
+			model: model.slug
+		});
+	});
+}
+function mergeModelOptions(selection, options) {
+	if (options.length === 0) return selection;
+	const optionsById = new Map((selection.options ?? []).map((option) => [option.id, option]));
+	for (const option of options) optionsById.set(option.id, option);
+	return decodeUnknownSync(ModelSelection)({
+		...selection,
+		options: [...optionsById.values()]
+	});
+}
+function withModelOptions(input, selection) {
+	if (input.options === void 0 || input.options.length === 0) return selection;
+	return mergeModelOptions(selection, input.options);
+}
+function firstAvailableModel(serverConfig) {
+	const providers = serverConfig.providers;
+	const provider = firstSelectableProvider(providers);
+	if (provider === void 0) return failNoAvailableModel();
+	return succeed(provider);
+}
+function findProvider(serverConfig, instanceId) {
+	const provider = findSelectableProvider(serverConfig.providers, instanceId);
+	if (provider === void 0) return failNoAvailableModel();
+	return succeed(provider);
+}
+function failNoAvailableModel() {
+	return fail(new ModelSelectionError({ message: "no available provider model found; pass --provider and --model" }));
+}
+//#endregion
+//#region src/application/thread-commands.ts
+const makeThreadStartCommands = fn("makeThreadStartCommands")(function* (input) {
+	const crypto = yield* Crypto;
+	const threadId = ThreadId.make(yield* crypto.randomUUIDv4.pipe(orDie));
+	const createdAt = formatIso(yield* now);
+	const modelSelection = yield* resolveModelSelection(input);
+	const inputTitle = input.start.title?.trim();
+	const messageTitle = input.start.message.trim().split(/\s+/).slice(0, 8).join(" ");
+	const title = inputTitle !== void 0 && inputTitle.length > 0 ? inputTitle : messageTitle;
+	return {
+		createCommand: {
+			type: "thread.create",
+			commandId: CommandId.make(`t3cli:thread-create:${yield* crypto.randomUUIDv4.pipe(orDie)}`),
+			threadId,
+			projectId: input.project.id,
+			title: title.length > 0 ? title : "New thread",
+			modelSelection,
+			runtimeMode: "full-access",
+			interactionMode: "default",
+			branch: null,
+			worktreePath: input.start.worktreePath ?? null,
+			createdAt
+		},
+		turnCommand: {
+			type: "thread.turn.start",
+			commandId: CommandId.make(`t3cli:thread-start:${yield* crypto.randomUUIDv4.pipe(orDie)}`),
+			threadId,
+			message: {
+				messageId: MessageId.make(yield* crypto.randomUUIDv4.pipe(orDie)),
+				role: "user",
+				text: input.start.message,
+				attachments: []
+			},
+			modelSelection,
+			titleSeed: title,
+			runtimeMode: "full-access",
+			interactionMode: "default",
+			createdAt
+		},
+		threadId
+	};
+});
+const makeThreadTurnContinueCommand = fn("makeThreadTurnContinueCommand")(function* (input) {
+	const crypto = yield* Crypto;
+	const createdAt = formatIso(yield* now);
+	return {
+		type: "thread.turn.start",
+		commandId: CommandId.make(`t3cli:thread-start:${yield* crypto.randomUUIDv4.pipe(orDie)}`),
+		threadId: ThreadId.make(input.threadId),
+		message: {
+			messageId: MessageId.make(yield* crypto.randomUUIDv4.pipe(orDie)),
+			role: "user",
+			text: input.message,
+			attachments: []
+		},
+		runtimeMode: "full-access",
+		interactionMode: "default",
+		...input.modelSelection !== void 0 ? { modelSelection: input.modelSelection } : {},
+		createdAt
+	};
+});
+const makeThreadArchiveCommand = fn("makeThreadArchiveCommand")(function* (threadId) {
+	const crypto = yield* Crypto;
+	return {
+		type: "thread.archive",
+		commandId: CommandId.make(`t3cli:thread-archive:${yield* crypto.randomUUIDv4.pipe(orDie)}`),
+		threadId: ThreadId.make(threadId)
+	};
+});
+//#endregion
+//#region src/application/thread-wait.ts
+function watchThread(input) {
+	let current;
+	let currentMessages;
+	return scoped$1(input.orchestration.watchThreadItems(input.threadId).pipe(flatMap$1((item) => {
+		if (item.kind === "snapshot") {
+			const messages = /* @__PURE__ */ new Map();
+			for (const message of item.snapshot.thread.messages) messages.set(messageKey(message), message);
+			current = item.snapshot.thread;
+			currentMessages = messages;
+			const events = [{
+				type: "thread",
+				thread: current
+			}, {
+				type: "status",
+				status: threadStatus(current),
+				threadId: current.id
+			}];
+			if (!isThreadActive(current) && isThreadCompleteEnough(current)) events.push({
+				type: "done",
+				thread: current
+			});
+			return fromIterable(events);
+		}
+		if (current === void 0 || currentMessages === void 0) return fail$1(new ThreadSessionError({
+			message: `thread stream event received before snapshot: ${input.threadId}`,
+			threadId: input.threadId
+		}));
+		current = applyThreadEvent(current, item.event, currentMessages);
+		const message = messageFromEvent(item.event, currentMessages);
+		const events = message !== null ? [{
+			type: "message",
+			message
+		}] : [];
+		events.push({
+			type: "status",
+			status: threadStatus(current),
+			threadId: current.id
+		});
+		if (!isThreadActive(current) && isThreadCompleteEnough(current)) events.push({
+			type: "done",
+			thread: current
+		});
+		return fromIterable(events);
+	}), takeUntil((event) => event.type === "done")));
+}
+function waitForThread(input) {
+	return watchThread(input).pipe(runLast, flatMap((event) => {
+		if (isSome(event) && event.value.type === "done") return succeed(event.value.thread);
+		return fail(new ThreadSessionError({
+			message: `thread wait ended without done event: ${input.threadId}`,
+			threadId: input.threadId
+		}));
+	}));
+}
+//#endregion
+//#region src/application/threads.ts
+const makeThreadApplication = fn("makeThreadApplication")(function* () {
+	const orchestration = yield* T3Orchestration;
+	const crypto = yield* Crypto;
+	const path = yield* Path;
+	const environment = yield* Environment;
+	const listThreads = fn("T3ApplicationLive.listThreads")(function* (projectRef) {
+		const snapshot = yield* orchestration.getShellSnapshot();
+		const scope = yield* resolveProjectScope(snapshot, {
+			ref: projectRef,
+			cwd: environment.cwd
+		}).pipe(provideService(Path, path));
+		if (scope === void 0) return yield* fail(new ProjectLookupError({
+			message: `project not found: ${projectRef}`,
+			ref: projectRef
+		}));
+		return {
+			project: scope.project,
+			threads: snapshot.threads.filter((thread) => thread.projectId === scope.project.id)
+		};
+	});
+	const getThreadMessages = fn("T3ApplicationLive.getThreadMessages")(function* (threadId) {
+		return yield* orchestration.getThreadSnapshot(threadId);
+	});
+	const archiveThread = fn("T3ApplicationLive.archiveThread")(function* (threadId) {
+		const command = yield* makeThreadArchiveCommand(threadId).pipe(provideService(Crypto, crypto));
+		return yield* orchestration.dispatch(command);
+	});
+	const startThread = fn("T3ApplicationLive.startThread")(function* (startInput, policy) {
+		const snapshot = yield* orchestration.getShellSnapshot();
+		const projectRef = startInput.projectRef;
+		if (projectRef === void 0) return yield* fail(new ProjectLookupError({
+			message: "project is required",
+			ref: environment.cwd
+		}));
+		const scope = yield* resolveProjectScope(snapshot, {
+			ref: projectRef,
+			cwd: environment.cwd
+		}).pipe(provideService(Path, path));
+		if (scope === void 0) return yield* fail(new ProjectLookupError({
+			message: `project not found: ${projectRef}`,
+			ref: projectRef
+		}));
+		const worktreePath = startInput.worktreePath ?? scope.inferredWorktreePath;
+		const serverConfig = yield* orchestration.getServerConfig();
+		const commands = yield* makeThreadStartCommands({
+			start: {
+				...startInput,
+				...worktreePath !== void 0 ? { worktreePath } : {}
+			},
+			project: scope.project,
+			serverConfig
+		}).pipe(provideService(Crypto, crypto));
+		yield* waitForShellSequence({
+			orchestration,
+			sequence: (yield* orchestration.dispatch(commands.createCommand)).sequence
+		});
+		const dispatch = yield* orchestration.dispatch(commands.turnCommand);
+		const threadId = commands.threadId;
+		const until = policy?.until ?? "dispatch";
+		if (until === "dispatch") return {
+			dispatch,
+			project: scope.project,
+			threadId
+		};
+		yield* waitForShellSequence({
+			orchestration,
+			sequence: dispatch.sequence
+		});
+		if (until === "visible") {
+			const thread = yield* scoped(gen(function* () {
+				return (yield* orchestration.openThread(threadId)).snapshot;
+			}));
+			return {
+				dispatch,
+				project: scope.project,
+				threadId,
+				thread
+			};
+		}
+		const thread = yield* waitForThread({
+			orchestration,
+			threadId
+		});
+		yield* failIfThreadError(thread);
+		return {
+			dispatch,
+			project: scope.project,
+			threadId,
+			thread
+		};
+	});
+	const sendThread = fn("T3ApplicationLive.sendThread")(function* (input, policy) {
+		const modelSelection = input.options !== void 0 && input.options.length > 0 ? mergeModelOptions((yield* orchestration.getThreadSnapshot(input.threadId)).modelSelection, input.options) : void 0;
+		const command = yield* makeThreadTurnContinueCommand({
+			...input,
+			...modelSelection !== void 0 ? { modelSelection } : {}
+		}).pipe(provideService(Crypto, crypto));
+		const dispatch = yield* orchestration.dispatch(command);
+		const until = policy?.until ?? "dispatch";
+		if (until === "dispatch") return {
+			dispatch,
+			threadId: input.threadId
+		};
+		yield* waitForShellSequence({
+			orchestration,
+			sequence: dispatch.sequence
+		});
+		if (until === "visible") {
+			const thread = yield* scoped(gen(function* () {
+				return (yield* orchestration.openThread(input.threadId)).snapshot;
+			}));
+			return {
+				dispatch,
+				threadId: input.threadId,
+				thread
+			};
+		}
+		const thread = yield* waitForThread({
+			orchestration,
+			threadId: input.threadId
+		});
+		yield* failIfThreadError(thread);
+		return {
+			dispatch,
+			threadId: input.threadId,
+			thread
+		};
+	});
+	const watchThread$1 = (threadId) => watchThread({
+		orchestration,
+		threadId
+	});
+	return {
+		archiveThread,
+		listThreads,
+		getThreadMessages,
+		sendThread,
+		startThread,
+		watchThread: watchThread$1,
+		waitForThread: fn("T3ApplicationLive.waitForThread")(function* (threadId) {
+			const thread = yield* waitForThread({
+				orchestration,
+				threadId
+			});
+			yield* failIfThreadError(thread);
+			return thread;
+		})
+	};
+});
+function failIfThreadError(thread) {
+	if (thread.session?.status !== "error") return void_;
+	return fail(new ThreadSessionError({
+		threadId: thread.id,
+		message: thread.session.lastError ?? "thread ended with error"
+	}));
+}
+const T3ApplicationLive = effect(T3Application, fn("makeT3Application")(function* () {
+	const models = yield* makeModelsApplication();
+	const projects = yield* makeProjectApplication();
+	const threads = yield* makeThreadApplication();
+	return {
+		...models,
+		...projects,
+		...threads
+	};
+})());
+//#endregion
+//#region src/orchestration/layer.ts
+const rpcRetrySchedule = exponential("100 millis").pipe(take(4), collectWhile((metadata) => metadata.input instanceof RpcClientError));
+function runRpc(rpc, method, f) {
+	return gen(function* () {
+		return yield* f(yield* rpc.getClient);
+	}).pipe(tapError((error) => error instanceof RpcClientError ? rpc.disconnect : void_), retry(rpcRetrySchedule), catchTags({
+		RpcError: (error) => fail(error),
+		EnvironmentAuthorizationError: (error) => fail(toRpcRequestError(error, method)),
+		RpcClientError: (error) => fail(toRpcRequestError(error, method)),
+		KeybindingsConfigParseError: (error) => fail(toRpcRequestError(error, method)),
+		OrchestrationDispatchCommandError: (error) => fail(toRpcRequestError(error, method)),
+		OrchestrationGetSnapshotError: (error) => fail(toRpcRequestError(error, method)),
+		ServerSettingsError: (error) => fail(toRpcRequestError(error, method))
+	}));
+}
+function subscribeRpc(rpc, method, f) {
+	return unwrap(map(rpc.getClient, f)).pipe(tapError$1((error) => error instanceof RpcClientError ? rpc.disconnect : void_), retry$1(rpcRetrySchedule), catchTags$1({
+		RpcError: (error) => fail$1(error),
+		EnvironmentAuthorizationError: (error) => fail$1(toRpcRequestError(error, method)),
+		RpcClientError: (error) => fail$1(toRpcRequestError(error, method)),
+		KeybindingsConfigParseError: (error) => fail$1(toRpcRequestError(error, method)),
+		OrchestrationDispatchCommandError: (error) => fail$1(toRpcRequestError(error, method)),
+		OrchestrationGetSnapshotError: (error) => fail$1(toRpcRequestError(error, method)),
+		ServerSettingsError: (error) => fail$1(toRpcRequestError(error, method))
+	}));
+}
+const T3OrchestrationLive = effect(T3Orchestration, fn("makeT3Orchestration")(function* () {
+	const rpc = yield* T3Rpc;
+	const dispatch = fn("T3OrchestrationLive.dispatch")(function* (command) {
+		return yield* runRpc(rpc, ORCHESTRATION_WS_METHODS.dispatchCommand, (client) => client[ORCHESTRATION_WS_METHODS.dispatchCommand](command));
+	});
+	const getServerConfig = fn("T3OrchestrationLive.getServerConfig")(function* () {
+		return yield* runRpc(rpc, WS_METHODS.serverGetConfig, (client) => client[WS_METHODS.serverGetConfig]({}));
+	});
+	const getShellSnapshot = fn("T3OrchestrationLive.getShellSnapshot")(function* () {
+		const value = getOrUndefined(yield* runHead(subscribeRpc(rpc, ORCHESTRATION_WS_METHODS.subscribeShell, (client) => client[ORCHESTRATION_WS_METHODS.subscribeShell]({}))));
+		if (value === void 0 || value.kind !== "snapshot") return yield* fail(new RpcError({
+			message: "server did not return shell snapshot",
+			method: ORCHESTRATION_WS_METHODS.subscribeShell
+		}));
+		return value.snapshot;
+	});
+	const getThreadSnapshot = fn("T3OrchestrationLive.getThreadSnapshot")(function* (threadId) {
+		const value = getOrUndefined(yield* runHead(subscribeRpc(rpc, ORCHESTRATION_WS_METHODS.subscribeThread, (client) => client[ORCHESTRATION_WS_METHODS.subscribeThread]({ threadId: ThreadId.make(threadId) }))));
+		if (value === void 0 || value.kind !== "snapshot") return yield* fail(new RpcError({
+			message: `thread ${threadId} not found`,
+			method: ORCHESTRATION_WS_METHODS.subscribeThread
+		}));
+		return value.snapshot.thread;
+	});
+	const watchShellSequence = () => subscribeRpc(rpc, ORCHESTRATION_WS_METHODS.subscribeShell, (client) => client[ORCHESTRATION_WS_METHODS.subscribeShell]({})).pipe(map$1((item) => item.kind === "snapshot" ? item.snapshot.snapshotSequence : item.sequence));
+	const watchThreadItems = (threadId) => subscribeRpc(rpc, ORCHESTRATION_WS_METHODS.subscribeThread, (client) => client[ORCHESTRATION_WS_METHODS.subscribeThread]({ threadId: ThreadId.make(threadId) }));
+	return {
+		dispatch,
+		getServerConfig,
+		getShellSnapshot,
+		getThreadSnapshot,
+		watchShellSequence,
+		watchThreadItems,
+		openThread: fn("T3OrchestrationLive.openThread")(function* (threadId) {
+			return yield* watchThreadItems(threadId).pipe(peel(head()), flatMap(([item, rest]) => {
+				const value = getOrUndefined(item);
+				if (value === void 0 || value.kind !== "snapshot") return fail(new RpcError({
+					message: `thread ${threadId} not found`,
+					method: ORCHESTRATION_WS_METHODS.subscribeThread
+				}));
+				return succeed({
+					snapshot: value.snapshot.thread,
+					events: rest.pipe(filter((next) => next.kind === "event"), map$1((next) => next.event))
+				});
+			}));
+		})
+	};
+})());
+function toRpcRequestError(error, method) {
+	return new RpcError({
+		message: error.message,
+		method,
+		cause: error
+	});
+}
+//#endregion
+//#region node_modules/.pnpm/effect@4.0.0-beta.78/node_modules/effect/dist/unstable/sql/SqlError.js
+/**
+* Structured SQL failures for unstable SQL clients and driver integrations.
+*
+* This module provides the top-level `SqlError` wrapper, the concrete
+* `SqlErrorReason` variants used by adapters, schemas for encoding or decoding
+* those errors, guards for recognizing them, and a SQLite classifier for native
+* driver causes. The model keeps query mistakes, authentication and
+* authorization failures, constraint violations, connection failures, lock
+* waits, deadlocks, serialization conflicts, statement timeouts, and unknown
+* failures distinguishable in the Effect error channel.
+*
+* **Mental model**
+*
+* `SqlError` wraps exactly one reason. Its `message`, `cause`, and
+* `isRetryable` values are delegated to that reason, so recovery code can branch
+* on either the reason tag or the retryability flag without losing the original
+* native cause. Reasons are intentionally driver-neutral; adapters translate
+* database-specific error codes into this shared vocabulary.
+*
+* **Common tasks**
+*
+* Construct a reason when adapting a driver failure, wrap it in `SqlError` for
+* client APIs, use `isSqlError` or `isSqlErrorReason` at boundaries that receive
+* unknown failures, and use `classifySqliteError` when mapping SQLite `code` or
+* `errno` values.
+*
+* **Gotchas**
+*
+* Preserve the native `cause` and `operation` metadata when constructing these
+* errors; they are often the only way to diagnose dialect-specific failures.
+* Retryable reasons represent transient infrastructure or concurrency problems,
+* while syntax, credential, permission, and constraint failures generally need a
+* changed query, configuration, or data set. SQLite unique violations include a
+* best-effort constraint name when one can be extracted.
+*
+* @since 4.0.0
+*/
+const TypeId = "~effect/sql/SqlError";
+const ReasonTypeId = "~effect/sql/SqlError/Reason";
+const ReasonFields = {
+	cause: /*#__PURE__*/ Defect(),
+	message: /*#__PURE__*/ optional(String),
+	operation: /*#__PURE__*/ optional(String)
+};
+/**
+* SQL error reason for connection or open failures; marked retryable.
+*
+* @category errors
+* @since 4.0.0
+*/
+var ConnectionError = class extends TaggedErrorClass("effect/sql/SqlError/ConnectionError")("ConnectionError", ReasonFields) {
+	/**
+	* Marks this value as a structured SQL error reason for runtime guards.
+	*
+	* @since 4.0.0
+	*/
+	[ReasonTypeId] = ReasonTypeId;
+	/**
+	* Indicates whether retrying the failed SQL operation may succeed.
+	*
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return true;
+	}
+};
+/**
+* SQL error reason for authentication failures such as invalid credentials; not
+* marked retryable.
+*
+* @category errors
+* @since 4.0.0
+*/
+var AuthenticationError = class extends TaggedErrorClass("effect/sql/SqlError/AuthenticationError")("AuthenticationError", ReasonFields) {
+	/**
+	* Marks this value as a structured SQL error reason for runtime guards.
+	*
+	* @since 4.0.0
+	*/
+	[ReasonTypeId] = ReasonTypeId;
+	/**
+	* Indicates whether retrying the failed SQL operation may succeed.
+	*
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return false;
+	}
+};
+/**
+* SQL error reason for authorization or permission failures; not marked
+* retryable.
+*
+* @category errors
+* @since 4.0.0
+*/
+var AuthorizationError = class extends TaggedErrorClass("effect/sql/SqlError/AuthorizationError")("AuthorizationError", ReasonFields) {
+	/**
+	* Marks this value as a structured SQL error reason for runtime guards.
+	*
+	* @since 4.0.0
+	*/
+	[ReasonTypeId] = ReasonTypeId;
+	/**
+	* Indicates whether retrying the failed SQL operation may succeed.
+	*
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return false;
+	}
+};
+/**
+* SQL error reason for invalid SQL syntax; not marked retryable.
+*
+* @category errors
+* @since 4.0.0
+*/
+var SqlSyntaxError = class extends TaggedErrorClass("effect/sql/SqlError/SqlSyntaxError")("SqlSyntaxError", ReasonFields) {
+	/**
+	* Marks this value as a structured SQL error reason for runtime guards.
+	*
+	* @since 4.0.0
+	*/
+	[ReasonTypeId] = ReasonTypeId;
+	/**
+	* Indicates whether retrying the failed SQL operation may succeed.
+	*
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return false;
+	}
+};
+const UniqueViolationFields = {
+	...ReasonFields,
+	constraint: String
+};
+/**
+* SQL error reason for a unique constraint violation, including the violated
+* constraint identifier; not marked retryable.
+*
+* @category errors
+* @since 4.0.0
+*/
+var UniqueViolation = class extends TaggedErrorClass("effect/sql/SqlError/UniqueViolation")("UniqueViolation", UniqueViolationFields) {
+	/**
+	* Marks this value as a structured SQL error reason for runtime guards.
+	*
+	* @since 4.0.0
+	*/
+	[ReasonTypeId] = ReasonTypeId;
+	/**
+	* Indicates whether retrying the failed SQL operation may succeed.
+	*
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return false;
+	}
+};
+/**
+* SQL error reason for a non-unique constraint violation; not marked retryable.
+*
+* @category errors
+* @since 4.0.0
+*/
+var ConstraintError = class extends TaggedErrorClass("effect/sql/SqlError/ConstraintError")("ConstraintError", ReasonFields) {
+	/**
+	* Marks this value as a structured SQL error reason for runtime guards.
+	*
+	* @since 4.0.0
+	*/
+	[ReasonTypeId] = ReasonTypeId;
+	/**
+	* Indicates whether retrying the failed SQL operation may succeed.
+	*
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return false;
+	}
+};
+/**
+* SQL error reason for a database deadlock; marked retryable.
+*
+* @category errors
+* @since 4.0.0
+*/
+var DeadlockError = class extends TaggedErrorClass("effect/sql/SqlError/DeadlockError")("DeadlockError", ReasonFields) {
+	/**
+	* Marks this value as a structured SQL error reason for runtime guards.
+	*
+	* @since 4.0.0
+	*/
+	[ReasonTypeId] = ReasonTypeId;
+	/**
+	* Indicates whether retrying the failed SQL operation may succeed.
+	*
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return true;
+	}
+};
+/**
+* SQL error reason for a transaction serialization or isolation conflict;
+* marked retryable.
+*
+* @category errors
+* @since 4.0.0
+*/
+var SerializationError = class extends TaggedErrorClass("effect/sql/SqlError/SerializationError")("SerializationError", ReasonFields) {
+	/**
+	* Marks this value as a structured SQL error reason for runtime guards.
+	*
+	* @since 4.0.0
+	*/
+	[ReasonTypeId] = ReasonTypeId;
+	/**
+	* Indicates whether retrying the failed SQL operation may succeed.
+	*
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return true;
+	}
+};
+/**
+* SQL error reason for timing out while waiting on a database lock; marked
+* retryable.
+*
+* @category errors
+* @since 4.0.0
+*/
+var LockTimeoutError = class extends TaggedErrorClass("effect/sql/SqlError/LockTimeoutError")("LockTimeoutError", ReasonFields) {
+	/**
+	* Marks this value as a structured SQL error reason for runtime guards.
+	*
+	* @since 4.0.0
+	*/
+	[ReasonTypeId] = ReasonTypeId;
+	/**
+	* Indicates whether retrying the failed SQL operation may succeed.
+	*
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return true;
+	}
+};
+/**
+* SQL error reason for a statement or query timeout; marked retryable.
+*
+* @category errors
+* @since 4.0.0
+*/
+var StatementTimeoutError = class extends TaggedErrorClass("effect/sql/SqlError/StatementTimeoutError")("StatementTimeoutError", ReasonFields) {
+	/**
+	* Marks this value as a structured SQL error reason for runtime guards.
+	*
+	* @since 4.0.0
+	*/
+	[ReasonTypeId] = ReasonTypeId;
+	/**
+	* Indicates whether retrying the failed SQL operation may succeed.
+	*
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return true;
+	}
+};
+/**
+* SQL error reason for an unclassified database failure; not marked retryable.
+*
+* @category errors
+* @since 4.0.0
+*/
+var UnknownError = class extends TaggedErrorClass("effect/sql/SqlError/UnknownError")("UnknownError", ReasonFields) {
+	/**
+	* Marks this value as a structured SQL error reason for runtime guards.
+	*
+	* @since 4.0.0
+	*/
+	[ReasonTypeId] = ReasonTypeId;
+	/**
+	* Indicates whether retrying the failed SQL operation may succeed.
+	*
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return false;
+	}
+};
+/**
+* Schema for encoding and decoding SQL error reasons.
+*
+* @category schemas
+* @since 4.0.0
+*/
+const SqlErrorReason = /*#__PURE__*/ Union([
+	ConnectionError,
+	AuthenticationError,
+	AuthorizationError,
+	SqlSyntaxError,
+	UniqueViolation,
+	ConstraintError,
+	DeadlockError,
+	SerializationError,
+	LockTimeoutError,
+	StatementTimeoutError,
+	UnknownError
+]);
+/**
+* Error wrapper for SQL failures whose `message`, `cause`, and `isRetryable`
+* values are derived from its `SqlErrorReason`.
+*
+* @category errors
+* @since 4.0.0
+*/
+var SqlError = class extends TaggedErrorClass("effect/sql/SqlError")("SqlError", { reason: SqlErrorReason }) {
+	/**
+	* Marks this value as the top-level SQL error wrapper for runtime guards.
+	*
+	* @since 4.0.0
+	*/
+	[TypeId] = TypeId;
+	/**
+	* Exposes the structured SQL reason as the JavaScript error cause.
+	*
+	* @since 4.0.0
+	*/
+	cause = this.reason;
+	/**
+	* Uses the reason message when present, otherwise falls back to the reason tag.
+	*
+	* @since 4.0.0
+	*/
+	get message() {
+		return this.reason.message || this.reason._tag;
+	}
+	/**
+	* Delegates retryability to the underlying SQL error reason.
+	*
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return this.reason.isRetryable;
+	}
+};
+const sqliteCodeFromCause = (cause) => {
+	if (!hasProperty(cause, "code")) return;
+	const code = cause.code;
+	return typeof code === "string" || typeof code === "number" ? code : void 0;
+};
+const sqliteNumericCodeFromCause = (cause) => {
+	const code = sqliteCodeFromCause(cause);
+	if (typeof code === "number") return code;
+	if (!hasProperty(cause, "errno")) return;
+	const errno = cause.errno;
+	return typeof errno === "number" ? errno : void 0;
+};
+const matchesSqliteNumericCode = (cause, expected) => {
+	if (sqliteCodeFromCause(cause) === expected) return true;
+	if (!hasProperty(cause, "errno")) return false;
+	return cause.errno === expected;
+};
+const matchesSqliteCode = (code, expected) => code === expected || code.startsWith(expected + "_");
+const UNKNOWN_CONSTRAINT = "unknown";
+const SQLITE_CONSTRAINT_UNIQUE = "SQLITE_CONSTRAINT_UNIQUE";
+const SQLITE_CONSTRAINT_UNIQUE_CODE = 2067;
+const normalizeConstraintIdentifier = (identifier) => {
+	if (typeof identifier !== "string") return UNKNOWN_CONSTRAINT;
+	const trimmed = identifier.trim();
+	return trimmed.length === 0 ? UNKNOWN_CONSTRAINT : trimmed;
+};
+const sqliteUniqueConstraintFromCause = (cause) => {
+	if (hasProperty(cause, "constraint")) return normalizeConstraintIdentifier(cause.constraint);
+	if (!hasProperty(cause, "message")) return UNKNOWN_CONSTRAINT;
+	const message = cause.message;
+	if (typeof message !== "string") return UNKNOWN_CONSTRAINT;
+	const index = message.indexOf("UNIQUE constraint failed:");
+	return index === -1 ? UNKNOWN_CONSTRAINT : normalizeConstraintIdentifier(message.slice(index + 25));
+};
+/**
+* Classifies a native SQLite error cause into a `SqlErrorReason` using its
+* `code` or `errno`, with optional message and operation metadata.
+*
+* @category converting
+* @since 4.0.0
+*/
+const classifySqliteError = (cause, { message, operation } = {}) => {
+	const props = {
+		cause,
+		message,
+		operation
+	};
+	const code = sqliteCodeFromCause(cause);
+	const numericCode = sqliteNumericCodeFromCause(cause);
+	if (code === SQLITE_CONSTRAINT_UNIQUE || matchesSqliteNumericCode(cause, SQLITE_CONSTRAINT_UNIQUE_CODE)) return new UniqueViolation({
+		...props,
+		constraint: sqliteUniqueConstraintFromCause(cause)
+	});
+	if (typeof code === "string") {
+		if (matchesSqliteCode(code, "SQLITE_AUTH")) return new AuthenticationError(props);
+		if (matchesSqliteCode(code, "SQLITE_PERM")) return new AuthorizationError(props);
+		if (matchesSqliteCode(code, "SQLITE_CONSTRAINT")) return new ConstraintError(props);
+		if (matchesSqliteCode(code, "SQLITE_BUSY") || matchesSqliteCode(code, "SQLITE_LOCKED")) return new LockTimeoutError(props);
+		if (matchesSqliteCode(code, "SQLITE_CANTOPEN")) return new ConnectionError(props);
+	}
+	if (typeof numericCode === "number") switch (numericCode & 255) {
+		case 23: return new AuthenticationError(props);
+		case 3: return new AuthorizationError(props);
+		case 19: return new ConstraintError(props);
+		case 5:
+		case 6: return new LockTimeoutError(props);
+		case 14: return new ConnectionError(props);
+		default: return new UnknownError(props);
+	}
+	return new UnknownError(props);
+};
+TaggedErrorClass("effect/sql/ResultLengthMismatch")("ResultLengthMismatch", {
+	expected: Number,
+	actual: Number
+});
+//#endregion
+//#region src/sql/node-sqlite-client.ts
+const ATTR_DB_SYSTEM_NAME = "db.system.name";
+const classifyError = (cause, message, operation) => classifySqliteError(cause, {
+	message,
+	operation
+});
+const makeNodeSqliteClient = fn("makeNodeSqliteClient")(function* (config) {
+	const compiler = makeCompilerSqlite(config.transformQueryNames);
+	const transformRows = config.transformResultNames === void 0 ? void 0 : defaultTransforms(config.transformResultNames).array;
+	const scope$1 = yield* scope;
+	const db = yield* try_({
+		try: () => new DatabaseSync(config.filename),
+		catch: (cause) => new SqlError({ reason: classifyError(cause, "Failed to open sqlite database", "connect") })
+	});
+	yield* addFinalizer(scope$1, sync(() => {
+		try {
+			db.close();
+		} catch {}
+	}));
+	const runRows = (sql, params) => try_({
+		try: () => {
+			const statement = db.prepare(sql);
+			const bound = params.map(toSqlInputValue);
+			if (statement.columns().length > 0) return statement.all(...bound);
+			statement.run(...bound);
+			return [];
+		},
+		catch: (cause) => new SqlError({ reason: classifyError(cause, "Failed to execute sqlite statement", "execute") })
+	});
+	const runRaw = (sql, params) => try_({
+		try: () => {
+			const statement = db.prepare(sql);
+			const bound = params.map(toSqlInputValue);
+			return statement.columns().length > 0 ? statement.all(...bound) : statement.run(...bound);
+		},
+		catch: (cause) => new SqlError({ reason: classifyError(cause, "Failed to execute sqlite statement", "execute") })
+	});
+	const runValues = (sql, params) => map(runRows(sql, params), (rows) => rows.map((row) => Object.values(row)));
+	return yield* make({
+		acquirer: succeed(identity({
+			execute(sql, params, rowTransform) {
+				const effect = runRows(sql, params);
+				return rowTransform === void 0 ? effect : map(effect, rowTransform);
+			},
+			executeRaw(sql, params) {
+				return runRaw(sql, params);
+			},
+			executeValues(sql, params) {
+				return runValues(sql, params);
+			},
+			executeUnprepared(sql, params, rowTransform) {
+				const effect = runRows(sql, params);
+				return rowTransform === void 0 ? effect : map(effect, rowTransform);
+			},
+			executeStream(sql, params, rowTransform) {
+				return fromIterableEffect(this.execute(sql, params, rowTransform));
+			}
+		})),
+		compiler,
+		spanAttributes: [[ATTR_DB_SYSTEM_NAME, "sqlite"]],
+		transformRows
+	});
+});
+const NodeSqlClientFactoryLive = succeed$1(SqlClientFactory, { sqliteClient: (config) => makeNodeSqliteClient(config).pipe(provide(layer)) });
+function toSqlInputValue(value) {
+	if (value === void 0 || value === null) return null;
+	if (typeof value === "string" || typeof value === "number" || typeof value === "bigint") return value;
+	if (typeof value === "boolean") return value ? 1 : 0;
+	if (value instanceof Date) return value.toISOString();
+	if (ArrayBuffer.isView(value)) {
+		const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+		const copy = new Uint8Array(bytes.byteLength);
+		copy.set(bytes);
+		return copy;
+	}
+	return JSON.stringify(value) ?? null;
+}
+//#endregion
+//#region src/runtime/layer.ts
+const T3AuthTransportLayer = T3AuthTransportLive.pipe(provide$1(layerUndici));
+const T3LocalAuthOriginLayer = T3LocalAuthOriginLive;
+const T3LocalAuthTokenLayer = T3LocalAuthTokenLive.pipe(provide$1(NodeSqlClientFactoryLive));
+const T3LocalAuthLayer = T3LocalAuthLive.pipe(provide$1(mergeAll(T3LocalAuthOriginLayer, T3LocalAuthTokenLayer)));
+const T3AuthPairingLayer = T3AuthPairingLive.pipe(provide$1(T3AuthTransportLayer));
+const T3AuthLayer = T3AuthLive.pipe(provide$1(mergeAll(T3ConfigLive, T3AuthTransportLayer, T3LocalAuthLayer, T3AuthPairingLayer)));
+const T3ConfigConnectionProviderLayer = effect(T3CodeConnectionProvider, gen(function* () {
+	return makeT3CodeConnectionProvider((yield* T3Config).resolve().pipe(map((resolved) => ({
+		origin: { url: resolved.url },
+		auth: { token: resolved.token }
+	})), mapError((error) => new T3CodeConnectionError({
+		message: "failed to resolve T3 Code connection from CLI config",
+		cause: error
+	}))));
+})).pipe(provide$1(T3ConfigLive));
+const T3RpcLayer = T3RpcLive.pipe(provide$1(mergeAll(T3ConfigConnectionProviderLayer, T3AuthTransportLayer, layerWebSocketConstructor)));
+const T3OrchestrationLayer = T3OrchestrationLive.pipe(provide$1(T3RpcLayer));
+const T3ApplicationLayer = T3ApplicationLive.pipe(provide$1(T3OrchestrationLayer));
+const AuthAppLayer = mergeAll(T3ConfigLive, T3AuthLayer);
+const AppLayer = mergeAll(T3ConfigLive, T3AuthLayer, T3RpcLayer, T3OrchestrationLayer, T3ApplicationLayer);
+//#endregion
+export { T3AuthTransportLayer as a, T3LocalAuthTokenLayer as c, latestAssistantMessage as d, threadStatus as f, T3AuthPairingLayer as i, T3OrchestrationLayer as l, ThreadSessionError as m, AuthAppLayer as n, T3LocalAuthLayer as o, ProjectLookupError as p, T3AuthLayer as r, T3LocalAuthOriginLayer as s, AppLayer as t, T3Orchestration as u };