t3code-cli 0.13.0 → 0.14.1

package/src/bin.ts

@@ -54,14 +54,17 @@ const program = Effect.gen(function* () {
       process.exitCode = error.errors.length > 0 ? 1 : 0;
     }),
   ),
-  Effect.tapError((error) =>
-    Effect.gen(function* () {
-      const output = yield* T3Output;
-      yield* output.writeStderr(`${error instanceof Error ? error.message : String(error)}\n`);
-    }),
-  ),
+  Effect.matchEffect({
+    onFailure: (error) =>
+      Effect.gen(function* () {
+        const output = yield* T3Output;
+        yield* output.writeStderr(`${error instanceof Error ? error.message : String(error)}\n`);
+        process.exitCode = 1;
+      }),
+    onSuccess: (value) => Effect.succeed(value),
+  }),
   Effect.scoped,
   Effect.provide(CliLayer),
 );
 
-NodeRuntime.runMain(program, { disableErrorReporting: true });
+NodeRuntime.runMain(program);

package/src/cli/auth.ts

@@ -75,7 +75,13 @@ const pairCommand = Command.make(
       const t3CliEnv = yield* loadT3CliEnv;
       const output = yield* T3Output;
       const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
-      const result = yield* auth.pair(url);
+      const result = yield* auth.pair({
+        pairingUrl: url,
+        clientMetadata: {
+          label: "t3cli",
+          deviceType: "bot",
+        },
+      });
       const fallbackName = yield* auth.defaultNameFromUrl(result.url);
       const environmentName = yield* persistAuthEnvironment({
         explicitName: name,

package/src/contracts/index.ts

@@ -1,8 +1,16 @@
 export type {
+  AuthClientPresentationMetadata,
   OrchestrationMessage,
   OrchestrationProjectShell,
   OrchestrationShellSnapshot,
   OrchestrationThread,
   OrchestrationThreadShell,
+  PreviewAutomationHost,
+  PreviewAutomationHostFocus,
+  PreviewAutomationResizeInput,
+  PreviewAutomationResponse,
+  PreviewAutomationStreamEvent,
+  PreviewViewportPresetId,
   ServerProvider,
 } from "@t3tools/contracts";
+export { PREVIEW_VIEWPORT_PRESET_IDS, PreviewViewportSetting } from "@t3tools/contracts";

package/src/orchestration/layer.ts

@@ -8,9 +8,11 @@ import {
   ThreadId,
   WS_METHODS,
   type ClientOrchestrationCommand,
+  type OrchestrationShellSnapshot,
   type OrchestrationShellStreamItem,
   type OrchestrationThreadStreamItem,
 } from "@t3tools/contracts";
+import { applyShellStreamEvent } from "@t3tools/client-runtime/state/shell";
 
 import { RpcError } from "../rpc/error.ts";
 import { T3RpcOperations } from "../rpc/operation.ts";
@@ -19,6 +21,39 @@ import { T3Orchestration, type OpenThread, type Orchestration } from "./service.
 export const makeT3Orchestration = Effect.fn("makeT3Orchestration")(function* () {
   const rpc = yield* T3RpcOperations;
 
+  const watchShellSnapshots: Orchestration["watchShellSnapshots"] = () =>
+    rpc
+      .subscribe(ORCHESTRATION_WS_METHODS.subscribeShell, (client) =>
+        client[ORCHESTRATION_WS_METHODS.subscribeShell]({}),
+      )
+      .pipe(
+        Stream.filter(
+          (
+            item,
+          ): item is Exclude<OrchestrationShellStreamItem, { readonly kind: "synchronized" }> =>
+            item.kind !== "synchronized",
+        ),
+        Stream.mapAccum(
+          () => Option.none<OrchestrationShellSnapshot>(),
+          (
+            current,
+            item,
+          ): readonly [
+            Option.Option<OrchestrationShellSnapshot>,
+            ReadonlyArray<OrchestrationShellSnapshot>,
+          ] => {
+            if (item.kind === "snapshot") {
+              return [Option.some(item.snapshot), [item.snapshot]];
+            }
+            if (Option.isNone(current)) {
+              return [current, []];
+            }
+            const next = applyShellStreamEvent(current.value, item);
+            return [Option.some(next), [next]];
+          },
+        ),
+      );
+
   const watchShellSequence: Orchestration["watchShellSequence"] = () =>
     rpc
       .subscribe(ORCHESTRATION_WS_METHODS.subscribeShell, (client) =>
@@ -126,6 +161,7 @@ export const makeT3Orchestration = Effect.fn("makeT3Orchestration")(function* ()
     getShellSnapshot,
     getArchivedShellSnapshot,
     getThreadSnapshot,
+    watchShellSnapshots,
     watchShellSequence,
     watchThreadItems,
     openThread,

package/src/orchestration/service.ts

@@ -38,6 +38,11 @@ export type Orchestration = {
   readonly getThreadSnapshot: (
     threadId: string,
   ) => Effect.Effect<OrchestrationThread, OrchestrationError>;
+  readonly watchShellSnapshots: () => Stream.Stream<
+    OrchestrationShellSnapshot,
+    OrchestrationError,
+    Scope.Scope
+  >;
   readonly watchShellSequence: () => Stream.Stream<number, OrchestrationError, Scope.Scope>;
   readonly watchThreadItems: (
     threadId: string,

package/src/preview/index.ts

@@ -0,0 +1,11 @@
+export {
+  T3PreviewAutomation,
+  T3PreviewAutomationLive,
+  makeT3PreviewAutomation,
+} from "./service.ts";
+export type {
+  PreviewAutomationHost,
+  PreviewAutomationHostFocus,
+  PreviewAutomationResponse,
+  PreviewAutomationStreamEvent,
+} from "../contracts/index.ts";

package/src/preview/service.ts

@@ -0,0 +1,52 @@
+import { WS_METHODS } from "@t3tools/contracts";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import type * as Stream from "effect/Stream";
+
+import type {
+  PreviewAutomationHost,
+  PreviewAutomationHostFocus,
+  PreviewAutomationResponse,
+  PreviewAutomationStreamEvent,
+} from "../contracts/index.ts";
+import type { RpcError } from "../rpc/error.ts";
+import { T3RpcOperations } from "../rpc/operation.ts";
+
+export class T3PreviewAutomation extends Context.Service<
+  T3PreviewAutomation,
+  {
+    readonly connect: (
+      host: PreviewAutomationHost,
+    ) => Stream.Stream<PreviewAutomationStreamEvent, RpcError>;
+    readonly respond: (response: PreviewAutomationResponse) => Effect.Effect<void, RpcError>;
+    readonly focusHost: (input: PreviewAutomationHostFocus) => Effect.Effect<void, RpcError>;
+  }
+>()("t3cli/T3PreviewAutomation") {}
+
+export const makeT3PreviewAutomation = Effect.fn("makeT3PreviewAutomation")(function* () {
+  const rpc = yield* T3RpcOperations;
+
+  const connect: T3PreviewAutomation["Service"]["connect"] = (host) =>
+    rpc.subscribe(WS_METHODS.previewAutomationConnect, (client) =>
+      client[WS_METHODS.previewAutomationConnect](host),
+    );
+  const respond = Effect.fn("T3PreviewAutomation.respond")(function* (
+    response: PreviewAutomationResponse,
+  ) {
+    return yield* rpc.run(WS_METHODS.previewAutomationRespond, (client) =>
+      client[WS_METHODS.previewAutomationRespond](response),
+    );
+  });
+  const focusHost = Effect.fn("T3PreviewAutomation.focusHost")(function* (
+    input: PreviewAutomationHostFocus,
+  ) {
+    return yield* rpc.run(WS_METHODS.previewAutomationFocusHost, (client) =>
+      client[WS_METHODS.previewAutomationFocusHost](input),
+    );
+  });
+
+  return T3PreviewAutomation.of({ connect, respond, focusHost });
+});
+
+export const T3PreviewAutomationLive = Layer.effect(T3PreviewAutomation, makeT3PreviewAutomation());

package/src/rpc/error.ts

@@ -7,6 +7,7 @@ import {
   KeybindingsConfigError,
   OrchestrationDispatchCommandError,
   OrchestrationGetSnapshotError,
+  PreviewAutomationError,
   ServerSettingsError,
   TerminalError,
 } from "@t3tools/contracts";
@@ -21,6 +22,7 @@ const RpcErrorCauseSchema = Schema.Union([
   KeybindingsConfigError,
   OrchestrationDispatchCommandError,
   OrchestrationGetSnapshotError,
+  PreviewAutomationError,
   ServerSettingsError,
   TerminalError,
   ConnectionBlockedError,

package/src/rpc/layer.ts

@@ -1,3 +1,4 @@
+import type { ConnectionAttemptError } from "@t3tools/client-runtime/connection";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
@@ -8,16 +9,16 @@ import * as Schedule from "effect/Schedule";
 import * as Scope from "effect/Scope";
 import * as SynchronizedRef from "effect/SynchronizedRef";
 
+import { T3CodeConnectionError } from "../connection/error.ts";
 import { T3PreparedConnectionProvider } from "../connection/prepared.ts";
 import { RpcError } from "./error.ts";
 import { T3RpcSessionFactory } from "./session.ts";
 import { T3Rpc, type WsClient } from "./service.ts";
 
 const connectionRetrySchedule = Schedule.exponential("100 millis").pipe(
-  Schedule.take(4),
-  Schedule.collectWhile((metadata: Schedule.Metadata) =>
-    Predicate.isTagged(metadata.input, "ConnectionTransientError"),
-  ),
+  Schedule.setInputType<ConnectionAttemptError | T3CodeConnectionError>(),
+  Schedule.upTo({ times: 4 }),
+  Schedule.while((metadata) => Predicate.isTagged(metadata.input, "ConnectionTransientError")),
 );
 
 type Connection = {

package/src/rpc/operation.ts

@@ -3,6 +3,7 @@ import type {
   KeybindingsConfigError,
   OrchestrationDispatchCommandError,
   OrchestrationGetSnapshotError,
+  PreviewAutomationError,
   ServerSettingsError,
   TerminalError,
 } from "@t3tools/contracts";
@@ -22,15 +23,15 @@ export type CliRpcOperationError =
   | KeybindingsConfigError
   | OrchestrationDispatchCommandError
   | OrchestrationGetSnapshotError
+  | PreviewAutomationError
   | RpcClientError.RpcClientError
   | ServerSettingsError
   | TerminalError;
 
 export const rpcRetrySchedule = Schedule.exponential("100 millis").pipe(
-  Schedule.take(4),
-  Schedule.collectWhile((metadata: Schedule.Metadata) =>
-    Predicate.isTagged(metadata.input, "RpcClientError"),
-  ),
+  Schedule.setInputType<CliRpcOperationError | RpcError>(),
+  Schedule.upTo({ times: 4 }),
+  Schedule.while((metadata) => Predicate.isTagged(metadata.input, "RpcClientError")),
 );
 
 export type T3RpcOperationsService = {

package/src/rpc/ws-group.ts

@@ -8,6 +8,9 @@ import {
   WsOrchestrationGetArchivedShellSnapshotRpc,
   WsOrchestrationSubscribeShellRpc,
   WsOrchestrationSubscribeThreadRpc,
+  WsPreviewAutomationConnectRpc,
+  WsPreviewAutomationFocusHostRpc,
+  WsPreviewAutomationRespondRpc,
   WsServerProbeRpc,
   WsSubscribeTerminalEventsRpc,
   WsSubscribeTerminalMetadataRpc,
@@ -48,6 +51,9 @@ export const CliWsRpcGroup = RpcGroup.make(
   WsOrchestrationGetArchivedShellSnapshotRpc,
   WsOrchestrationSubscribeShellRpc,
   WsOrchestrationSubscribeThreadRpc,
+  WsPreviewAutomationConnectRpc,
+  WsPreviewAutomationRespondRpc,
+  WsPreviewAutomationFocusHostRpc,
   WsServerProbeRpc,
   WsServerGetConfigRpc,
 );

package/src/runtime/index.ts

@@ -10,4 +10,5 @@ export {
   T3LocalAuthOriginLayer,
   T3LocalAuthTokenLayer,
   T3OrchestrationLayer,
+  T3PreviewAutomationLayer,
 } from "./layer.ts";

package/src/runtime/layer.ts

@@ -17,6 +17,7 @@ import { T3CodeConnectionError } from "../connection/error.ts";
 import { T3PreparedConnectionProviderLive } from "../connection/prepared.ts";
 import { T3CodeConnectionProvider, makeT3CodeConnectionProvider } from "../connection/service.ts";
 import { T3OrchestrationLive } from "../orchestration/layer.ts";
+import { T3PreviewAutomationLive } from "../preview/service.ts";
 import { T3RpcLive } from "../rpc/layer.ts";
 import { T3RpcOperationsLive } from "../rpc/operation.ts";
 import { T3RpcSessionFactoryLive } from "../rpc/session.ts";
@@ -74,6 +75,9 @@ const T3RpcLayer = T3RpcLive.pipe(
 );
 const T3RpcOperationsLayer = T3RpcOperationsLive.pipe(Layer.provide(T3RpcLayer));
 export const T3OrchestrationLayer = T3OrchestrationLive.pipe(Layer.provide(T3RpcOperationsLayer));
+export const T3PreviewAutomationLayer = T3PreviewAutomationLive.pipe(
+  Layer.provide(T3RpcOperationsLayer),
+);
 const T3ApplicationLayer = T3ApplicationLive.pipe(
   Layer.provide(Layer.mergeAll(T3RpcOperationsLayer, T3OrchestrationLayer)),
 );
@@ -84,6 +88,7 @@ export const BaseAppLayer = Layer.mergeAll(
   T3RpcLayer,
   T3RpcOperationsLayer,
   T3OrchestrationLayer,
+  T3PreviewAutomationLayer,
   T3ApplicationLayer,
   NodeCliPathLayer,
 );

package/src/sql/node-sqlite-client.ts

@@ -91,6 +91,9 @@ export const makeNodeSqliteClient = Effect.fn("makeNodeSqliteClient")(function*
     executeValues(sql, params) {
       return runValues(sql, params);
     },
+    executeValuesUnprepared(sql, params) {
+      return runValues(sql, params);
+    },
     executeUnprepared(sql, params, rowTransform) {
       const effect = runRows(sql, params);
       return rowTransform === undefined ? effect : Effect.map(effect, rowTransform);

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

@@ -1,25 +0,0 @@
-import * as Crypto from "effect/Crypto";
-import * as Effect from "effect/Effect";
-import * as Path from "effect/Path";
-import { type OrchestrationProjectShell, type ProjectScript } from "@t3tools/contracts";
-import { T3Orchestration } from "../orchestration/service.ts";
-import { T3TerminalApplication, type AddProjectActionInput, type ProjectActionSelector, type UpdateProjectActionInput } from "./service.ts";
-export declare const makeActionApplication: () => Effect.Effect<{
-    addAction: (input: AddProjectActionInput) => Effect.Effect<import("./service.ts").ProjectActionMutationResult, import("./error.ts").ApplicationError>;
-    deleteAction: (input: {
-        readonly projectRef: string;
-        readonly selector: ProjectActionSelector;
-    }) => Effect.Effect<import("./service.ts").ProjectActionDeleteResult, import("./error.ts").ApplicationError>;
-    listActions: (projectRef: string) => Effect.Effect<{
-        readonly project: OrchestrationProjectShell;
-        readonly actions: ReadonlyArray<ProjectScript>;
-    }, import("./error.ts").ApplicationError>;
-    runAction: (input: {
-        readonly threadId: string;
-        readonly selector: ProjectActionSelector;
-        readonly terminalId?: string;
-    }) => Effect.Effect<import("./service.ts").ProjectActionRunResult, import("./error.ts").ApplicationError>;
-    updateAction: (input: UpdateProjectActionInput) => Effect.Effect<import("./service.ts").ProjectActionMutationResult, import("./error.ts").ApplicationError>;
-}, never, Crypto.Crypto | Path.Path | T3Orchestration | T3TerminalApplication>;
-export declare function nextProjectScriptId(name: string, existingIds: Iterable<string>): string;
-export declare function resolveActionBySelector(scripts: ReadonlyArray<ProjectScript>, selector: ProjectActionSelector, projectId: string): ProjectScript;

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

@@ -1,3 +0,0 @@
-import type { DomainError } from "../domain/error.ts";
-import type { RpcError } from "../rpc/error.ts";
-export type ApplicationError = DomainError | RpcError;

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

@@ -1,4 +0,0 @@
-export { T3ActionApplication, T3Application, T3ModelApplication, T3ProjectApplication, T3TerminalApplication, T3ThreadApplication, } from "./service.ts";
-export { makeT3Application, T3ActionApplicationLive, T3ApplicationLive, T3ApplicationSlicesLive, T3ModelApplicationLive, T3ProjectApplicationLive, T3TerminalApplicationLive, T3ThreadApplicationLive, } from "./layer.ts";
-export type { AddProjectActionInput, ProjectActionDeleteResult, ProjectActionMutationResult, ProjectActionRunResult, ProjectActionSelector, SendThreadInput, StartThreadInput, StartThreadPolicy, T3ActionApplicationService, UpdateProjectActionInput, UpdateThreadInput, WaitEvent, } from "./service.ts";
-export type { ApplicationError } from "./error.ts";

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

@@ -1,117 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import { T3ActionApplication, T3Application, T3ModelApplication, T3ProjectApplication, T3TerminalApplication, T3ThreadApplication } from "./service.ts";
-export declare const makeT3Application: () => Effect.Effect<{
-    listActions: (projectRef: string) => Effect.Effect<{
-        readonly project: import("@t3tools/contracts").OrchestrationProjectShell;
-        readonly actions: ReadonlyArray<import("@t3tools/contracts").ProjectScript>;
-    }, import("./error.ts").ApplicationError>;
-    addAction: (input: import("./service.ts").AddProjectActionInput) => Effect.Effect<import("./service.ts").ProjectActionMutationResult, import("./error.ts").ApplicationError>;
-    updateAction: (input: import("./service.ts").UpdateProjectActionInput) => Effect.Effect<import("./service.ts").ProjectActionMutationResult, import("./error.ts").ApplicationError>;
-    deleteAction: (input: {
-        readonly projectRef: string;
-        readonly selector: import("./service.ts").ProjectActionSelector;
-    }) => Effect.Effect<import("./service.ts").ProjectActionDeleteResult, import("./error.ts").ApplicationError>;
-    runAction: (input: {
-        readonly threadId: string;
-        readonly selector: import("./service.ts").ProjectActionSelector;
-        readonly terminalId?: string;
-    }) => Effect.Effect<import("./service.ts").ProjectActionRunResult, import("./error.ts").ApplicationError>;
-    listModels: (input: {
-        readonly all?: boolean;
-        readonly provider?: string;
-    }) => Effect.Effect<ReadonlyArray<import("@t3tools/contracts").ServerProvider>, import("./error.ts").ApplicationError>;
-    loadShell: () => Effect.Effect<import("@t3tools/contracts").OrchestrationShellSnapshot, import("./error.ts").ApplicationError>;
-    addProject: (input: {
-        readonly path: string;
-        readonly title?: string;
-    }) => Effect.Effect<{
-        readonly dispatch: import("@t3tools/contracts").DispatchResult;
-        readonly project: import("@t3tools/contracts").OrchestrationProjectShell;
-    }, import("./error.ts").ApplicationError>;
-    resolveProject: (projectRef: string) => Effect.Effect<import("@t3tools/contracts").OrchestrationProjectShell, import("./error.ts").ApplicationError>;
-    deleteProject: (input: {
-        readonly projectId: string;
-        readonly force?: boolean;
-    }) => Effect.Effect<{
-        readonly projectId: string;
-        readonly dispatch: import("@t3tools/contracts").DispatchResult;
-    }, import("./error.ts").ApplicationError>;
-    listThreads: (projectRef: string, options?: {
-        readonly include?: import("./service.ts").ListThreadsInclude;
-    }) => Effect.Effect<{
-        readonly project: import("@t3tools/contracts").OrchestrationProjectShell;
-        readonly threads: ReadonlyArray<import("@t3tools/contracts").OrchestrationThreadShell>;
-    }, import("./error.ts").ApplicationError>;
-    getThreadMessages: (threadId: string) => Effect.Effect<import("@t3tools/contracts").OrchestrationThread, import("./error.ts").ApplicationError>;
-    showThread: (threadId: string) => Effect.Effect<import("./threads.ts").ThreadShow, import("./error.ts").ApplicationError>;
-    approveThread: (input: {
-        readonly threadId: string;
-        readonly requestId: string;
-        readonly decision: "accept" | "decline" | "cancel";
-    }) => Effect.Effect<{
-        readonly threadId: string;
-        readonly requestId: string;
-        readonly dispatch: import("@t3tools/contracts").DispatchResult;
-    }, import("./error.ts").ApplicationError>;
-    respondToThread: (input: {
-        readonly threadId: string;
-        readonly requestId: string;
-        readonly answers: import("@t3tools/contracts").ProviderUserInputAnswers;
-    }) => Effect.Effect<{
-        readonly threadId: string;
-        readonly requestId: string;
-        readonly dispatch: import("@t3tools/contracts").DispatchResult;
-    }, import("./error.ts").ApplicationError>;
-    archiveThread: (threadId: string) => Effect.Effect<import("@t3tools/contracts").DispatchResult, import("./error.ts").ApplicationError>;
-    interruptThread: (threadId: string) => Effect.Effect<import("@t3tools/contracts").DispatchResult, import("./error.ts").ApplicationError>;
-    unarchiveThread: (threadId: string) => Effect.Effect<import("@t3tools/contracts").DispatchResult, import("./error.ts").ApplicationError>;
-    deleteThread: (threadId: string) => Effect.Effect<{
-        readonly threadId: string;
-        readonly dispatch: import("@t3tools/contracts").DispatchResult;
-    }, import("./error.ts").ApplicationError>;
-    updateThread: (input: import("./service.ts").UpdateThreadInput) => Effect.Effect<import("@t3tools/contracts").DispatchResult, import("./error.ts").ApplicationError>;
-    startThread: (input: import("./service.ts").StartThreadInput, policy?: import("./service.ts").StartThreadPolicy) => Effect.Effect<{
-        readonly dispatch: import("@t3tools/contracts").DispatchResult;
-        readonly project: import("@t3tools/contracts").OrchestrationProjectShell;
-        readonly threadId: string;
-        readonly thread?: import("@t3tools/contracts").OrchestrationThread;
-    }, import("./error.ts").ApplicationError>;
-    sendThread: (input: import("./service.ts").SendThreadInput, policy?: import("./service.ts").StartThreadPolicy) => Effect.Effect<{
-        readonly dispatch: import("@t3tools/contracts").DispatchResult;
-        readonly threadId: string;
-        readonly thread?: import("@t3tools/contracts").OrchestrationThread;
-    }, import("./error.ts").ApplicationError>;
-    watchThread: (threadId: string) => import("effect/Stream").Stream<import("./service.ts").WaitEvent, import("./error.ts").ApplicationError>;
-    waitForThread: (threadId: string) => Effect.Effect<import("@t3tools/contracts").OrchestrationThread, import("./error.ts").ApplicationError>;
-    callbackThread: (input: import("./service.ts").CallbackThreadInput) => Effect.Effect<{
-        readonly dispatch: import("@t3tools/contracts").DispatchResult;
-        readonly targetThreadId: string;
-    }, import("./error.ts").ApplicationError>;
-    listTerminals: (threadId: string) => Effect.Effect<ReadonlyArray<import("@t3tools/contracts").TerminalSummary>, import("./error.ts").ApplicationError>;
-    getTerminal: (terminal: import("./service.ts").TerminalRef) => Effect.Effect<import("@t3tools/contracts").TerminalSummary, import("./error.ts").ApplicationError>;
-    createTerminal: (input: import("./service.ts").CreateTerminalInput) => Effect.Effect<import("@t3tools/contracts").TerminalSessionSnapshot, import("./error.ts").ApplicationError>;
-    attachTerminal: (input: {
-        readonly terminal: import("./service.ts").TerminalAttachTarget;
-        readonly cols?: number;
-        readonly rows?: number;
-    }) => import("effect/Stream").Stream<import("@t3tools/contracts").TerminalAttachStreamEvent, import("./error.ts").ApplicationError>;
-    watchTerminalMetadata: () => import("effect/Stream").Stream<import("@t3tools/contracts").TerminalMetadataStreamEvent, import("./error.ts").ApplicationError>;
-    writeTerminal: (input: {
-        readonly terminal: import("./service.ts").TerminalRef;
-        readonly data: string;
-    }) => Effect.Effect<void, import("./error.ts").ApplicationError>;
-    resizeTerminal: (input: {
-        readonly terminal: import("./service.ts").TerminalRef;
-        readonly cols: number;
-        readonly rows: number;
-    }) => Effect.Effect<void, import("./error.ts").ApplicationError>;
-    destroyTerminal: (terminal: import("./service.ts").TerminalRef) => Effect.Effect<void, import("./error.ts").ApplicationError>;
-}, never, T3ActionApplication | T3ModelApplication | T3ProjectApplication | T3TerminalApplication | T3ThreadApplication>;
-export declare const T3ModelApplicationLive: Layer.Layer<T3ModelApplication, never, import("../orchestration/service.ts").T3Orchestration>;
-export declare const T3ProjectApplicationLive: Layer.Layer<T3ProjectApplication, never, import("../cli/runtime/service.ts").CliRuntime | import("effect/Crypto").Crypto | import("effect/Path").Path | import("../orchestration/service.ts").T3Orchestration>;
-export declare const T3TerminalApplicationLive: Layer.Layer<T3TerminalApplication, never, import("effect/Crypto").Crypto | import("../orchestration/service.ts").T3Orchestration | import("../rpc/operation.ts").T3RpcOperations>;
-export declare const T3ActionApplicationLive: Layer.Layer<T3ActionApplication, never, import("effect/Crypto").Crypto | import("effect/Path").Path | import("../orchestration/service.ts").T3Orchestration | import("../rpc/operation.ts").T3RpcOperations>;
-export declare const T3ThreadApplicationLive: Layer.Layer<T3ThreadApplication, never, import("../cli/runtime/service.ts").CliRuntime | import("effect/Crypto").Crypto | import("effect/Path").Path | import("../orchestration/service.ts").T3Orchestration>;
-export declare const T3ApplicationSlicesLive: Layer.Layer<T3ActionApplication | T3ModelApplication | T3ProjectApplication | T3TerminalApplication | T3ThreadApplication, never, import("../cli/runtime/service.ts").CliRuntime | import("effect/Crypto").Crypto | import("effect/Path").Path | import("../orchestration/service.ts").T3Orchestration | import("../rpc/operation.ts").T3RpcOperations>;
-export declare const T3ApplicationLive: Layer.Layer<T3Application, never, import("../cli/runtime/service.ts").CliRuntime | import("effect/Crypto").Crypto | import("effect/Path").Path | import("../orchestration/service.ts").T3Orchestration | import("../rpc/operation.ts").T3RpcOperations>;

package/dist/src/application/model-selection.d.ts

@@ -1,34 +0,0 @@
-import * as Effect from "effect/Effect";
-import { ModelSelection } from "@t3tools/contracts";
-import type { OrchestrationProjectShell } from "@t3tools/contracts";
-import { ModelSelectionError } from "../domain/error.ts";
-import type { ServerConfigForCli } from "../orchestration/service.ts";
-import type { StartThreadInput } from "./service.ts";
-export declare function resolveModelSelection(input: {
-    readonly start: StartThreadInput;
-    readonly project: OrchestrationProjectShell;
-    readonly serverConfig: ServerConfigForCli;
-}): Effect.Effect<{
-    readonly instanceId: string & import("effect/Brand").Brand<"ProviderInstanceId">;
-    readonly model: string;
-    readonly options?: readonly {
-        readonly id: string;
-        readonly value: string | boolean;
-    }[];
-}, ModelSelectionError, never>;
-export declare function mergeModelOptions(selection: ModelSelection, options: NonNullable<ModelSelection["options"]>): ModelSelection;
-export declare function resolveUpdateModelSelection(input: {
-    readonly current: ModelSelection;
-    readonly provider?: string;
-    readonly model?: string;
-    readonly options?: NonNullable<ModelSelection["options"]>;
-    readonly project: OrchestrationProjectShell;
-    readonly serverConfig: ServerConfigForCli;
-}): Effect.Effect<{
-    readonly instanceId: string & import("effect/Brand").Brand<"ProviderInstanceId">;
-    readonly model: string;
-    readonly options?: readonly {
-        readonly id: string;
-        readonly value: string | boolean;
-    }[];
-}, ModelSelectionError, never>;

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

@@ -1,8 +0,0 @@
-import * as Effect from "effect/Effect";
-import { T3Orchestration } from "../orchestration/service.ts";
-export declare const makeModelsApplication: () => Effect.Effect<{
-    listModels: (input: {
-        readonly all?: boolean;
-        readonly provider?: string;
-    }) => Effect.Effect<ReadonlyArray<import("@t3tools/contracts").ServerProvider>, import("./error.ts").ApplicationError>;
-}, never, T3Orchestration>;

package/dist/src/application/project-commands.d.ts

@@ -1,44 +0,0 @@
-import * as Crypto from "effect/Crypto";
-import * as Effect from "effect/Effect";
-import * as Path from "effect/Path";
-import { type ClientOrchestrationCommand } from "@t3tools/contracts";
-export declare const makeProjectCreateCommand: (input: {
-    readonly path: string;
-    readonly title?: string;
-    readonly cwd: string;
-}) => Effect.Effect<{
-    type: "project.create";
-    commandId: string & import("effect/Brand").Brand<"CommandId">;
-    projectId: string & import("effect/Brand").Brand<"ProjectId">;
-    title: string;
-    workspaceRoot: string;
-    createdAt: string;
-}, never, Crypto.Crypto | Path.Path>;
-export declare const makeProjectDeleteCommand: (input: {
-    readonly projectId: string;
-    readonly force?: boolean;
-}) => Effect.Effect<{
-    type: "project.delete";
-    commandId: string & import("effect/Brand").Brand<"CommandId">;
-    projectId: string & import("effect/Brand").Brand<"ProjectId">;
-    force?: true;
-}, never, Crypto.Crypto>;
-export declare const makeProjectMetaUpdateCommand: (input: {
-    readonly projectId: string;
-    readonly scripts: Extract<ClientOrchestrationCommand, {
-        readonly type: "project.meta.update";
-    }>["scripts"];
-}) => Effect.Effect<{
-    type: "project.meta.update";
-    commandId: string & import("effect/Brand").Brand<"CommandId">;
-    projectId: string & import("effect/Brand").Brand<"ProjectId">;
-    scripts: readonly {
-        readonly id: string;
-        readonly name: string;
-        readonly command: string;
-        readonly icon: "build" | "configure" | "debug" | "lint" | "play" | "test";
-        readonly runOnWorktreeCreate: boolean;
-        readonly previewUrl?: string | undefined;
-        readonly autoOpenPreview?: boolean | undefined;
-    }[] | undefined;
-}, never, Crypto.Crypto>;

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

@@ -1,23 +0,0 @@
-import * as Crypto from "effect/Crypto";
-import * as Effect from "effect/Effect";
-import * as Path from "effect/Path";
-import { CliRuntime } from "../cli/runtime/service.ts";
-import { T3Orchestration } from "../orchestration/service.ts";
-export declare const makeProjectApplication: () => Effect.Effect<{
-    loadShell: () => Effect.Effect<import("@t3tools/contracts").OrchestrationShellSnapshot, import("./error.ts").ApplicationError>;
-    addProject: (input: {
-        readonly path: string;
-        readonly title?: string;
-    }) => Effect.Effect<{
-        readonly dispatch: import("@t3tools/contracts").DispatchResult;
-        readonly project: import("@t3tools/contracts").OrchestrationProjectShell;
-    }, import("./error.ts").ApplicationError>;
-    resolveProject: (projectRef: string) => Effect.Effect<import("@t3tools/contracts").OrchestrationProjectShell, import("./error.ts").ApplicationError>;
-    deleteProject: (input: {
-        readonly projectId: string;
-        readonly force?: boolean;
-    }) => Effect.Effect<{
-        readonly projectId: string;
-        readonly dispatch: import("@t3tools/contracts").DispatchResult;
-    }, import("./error.ts").ApplicationError>;
-}, never, CliRuntime | Crypto.Crypto | Path.Path | T3Orchestration>;