t3code-cli 0.12.0 → 0.14.0

package/src/auth/remote-error.ts

@@ -0,0 +1,17 @@
+import {
+  RemoteEnvironmentAuthFetchError,
+  type RemoteEnvironmentAuthError,
+  RemoteEnvironmentAuthInvalidJsonError,
+  RemoteEnvironmentAuthTimeoutError,
+  RemoteEnvironmentAuthUndeclaredStatusError,
+} from "@t3tools/client-runtime/authorization";
+import { EnvironmentHttpCommonError } from "@t3tools/contracts";
+import * as Schema from "effect/Schema";
+
+export const RemoteEnvironmentAuthErrorSchema = Schema.Union([
+  EnvironmentHttpCommonError,
+  Schema.instanceOf(RemoteEnvironmentAuthFetchError),
+  Schema.instanceOf(RemoteEnvironmentAuthInvalidJsonError),
+  Schema.instanceOf(RemoteEnvironmentAuthTimeoutError),
+  Schema.instanceOf(RemoteEnvironmentAuthUndeclaredStatusError),
+]) satisfies Schema.Schema<RemoteEnvironmentAuthError>;

package/src/auth/service.ts

@@ -11,6 +11,7 @@ import type {
   AuthUseResult,
   LocalAuthInput,
   LocalAuthResult,
+  AuthPairInput,
   PairResult,
   PersistEnvironmentInput,
 } from "./type.ts";
@@ -18,7 +19,7 @@ import type {
 export class T3Auth extends Context.Service<
   T3Auth,
   {
-    readonly pair: (value: string) => Effect.Effect<PairResult, AuthError>;
+    readonly pair: (input: AuthPairInput) => Effect.Effect<PairResult, AuthError>;
     readonly local: (input: LocalAuthInput) => Effect.Effect<LocalAuthResult, AuthError>;
     readonly writeConfig: (input: AuthConfigInput) => Effect.Effect<void, AuthError>;
     readonly persistEnvironment: (

package/src/auth/transport.ts

@@ -1,23 +1,20 @@
 import {
-  AuthAccessTokenType,
-  AuthEnvironmentBootstrapTokenType,
-  AuthTokenExchangeGrantType,
-} from "@t3tools/contracts";
+  bootstrapRemoteBearerSession,
+  fetchRemoteSessionState,
+  issueRemoteWebSocketTicket,
+} from "@t3tools/client-runtime/authorization";
 import * as Context from "effect/Context";
 import * as DateTime from "effect/DateTime";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
-import { HttpClient, HttpClientError, HttpClientRequest } from "effect/unstable/http";
+import { HttpClient } from "effect/unstable/http";
 
-import { toHttpEndpointUrl } from "../config/url/url.ts";
+import type { AuthClientPresentationMetadata } from "../contracts/index.ts";
 import { AuthTransportError } from "./error.ts";
 import {
   type AuthBearerBootstrapResult,
-  decodeAuthAccessTokenResult,
   type AuthSessionState,
-  decodeAuthSessionState,
   type AuthWebSocketTicketResult,
-  decodeAuthWebSocketTicketResult,
 } from "./schema.ts";
 
 export type AuthTransportConnection = {
@@ -31,6 +28,7 @@ export class T3AuthTransport extends Context.Service<
     readonly bootstrapBearer: (input: {
       readonly baseUrl: string;
       readonly credential: string;
+      readonly clientMetadata?: AuthClientPresentationMetadata;
     }) => Effect.Effect<AuthBearerBootstrapResult, AuthTransportError>;
     readonly getSession: (
       connection: AuthTransportConnection,
@@ -42,53 +40,27 @@ export class T3AuthTransport extends Context.Service<
 >()("t3cli/T3AuthTransport") {}
 
 const makeT3AuthTransport = Effect.fn("makeT3AuthTransport")(function* () {
-  const client = HttpClient.filterStatusOk(yield* HttpClient.HttpClient);
+  const httpClient = yield* HttpClient.HttpClient;
 
   const bootstrapBearer = Effect.fn("AuthTransport.bootstrapBearer")(function* (input: {
     readonly baseUrl: string;
     readonly credential: string;
+    readonly clientMetadata?: AuthClientPresentationMetadata;
   }) {
-    const url = yield* makeHttpEndpointUrl(input.baseUrl, "/oauth/token");
-    const request = HttpClientRequest.post(url).pipe(
-      HttpClientRequest.acceptJson,
-      HttpClientRequest.bodyUrlParams({
-        grant_type: AuthTokenExchangeGrantType,
-        subject_token: input.credential,
-        subject_token_type: AuthEnvironmentBootstrapTokenType,
-        requested_token_type: AuthAccessTokenType,
-      }),
-    );
-    const response = yield* client.execute(request).pipe(
-      Effect.catchTags({
-        HttpClientError: (error) =>
-          Effect.fail(
-            new AuthTransportError({
-              message: "auth request failed",
-              cause: HttpClientError.HttpClientErrorSchema.fromHttpClientError(error),
-            }),
-          ),
-      }),
-    );
-    const result = yield* response.json.pipe(
-      Effect.flatMap(decodeAuthAccessTokenResult),
-      Effect.catchTags({
-        HttpClientError: (error) =>
-          Effect.fail(
-            new AuthTransportError({
-              message: "auth request failed",
-              cause: HttpClientError.HttpClientErrorSchema.fromHttpClientError(error),
-            }),
-          ),
-        SchemaError: (error) =>
-          Effect.fail(
-            new AuthTransportError({ message: "auth response decode failed", cause: error }),
-          ),
-      }),
+    const result = yield* bootstrapRemoteBearerSession({
+      httpBaseUrl: input.baseUrl,
+      credential: input.credential,
+      ...(input.clientMetadata !== undefined ? { clientMetadata: input.clientMetadata } : {}),
+    }).pipe(
+      Effect.provideService(HttpClient.HttpClient, httpClient),
+      Effect.mapError(
+        (error) => new AuthTransportError({ message: "auth request failed", cause: error }),
+      ),
     );
     const now = yield* DateTime.now;
     return {
       authenticated: true,
-      role: result.scope.split(/\s+/u).includes("access:write") ? "owner" : "client",
+      role: inferRole(result.scope),
       sessionMethod: "bearer-access-token",
       expiresAt: DateTime.formatIso(DateTime.add(now, { seconds: result.expires_in })),
       sessionToken: result.access_token,
@@ -98,69 +70,41 @@ const makeT3AuthTransport = Effect.fn("makeT3AuthTransport")(function* () {
   const getSession = Effect.fn("AuthTransport.getSession")(function* (
     connection: AuthTransportConnection,
   ) {
-    const url = yield* makeHttpEndpointUrl(connection.url, "/api/auth/session");
-    const request = HttpClientRequest.get(url).pipe(authenticatedRequest(connection));
-    const response = yield* client.execute(request).pipe(
-      Effect.catchTags({
-        HttpClientError: (error) =>
-          Effect.fail(
-            new AuthTransportError({
-              message: "auth request failed",
-              cause: HttpClientError.HttpClientErrorSchema.fromHttpClientError(error),
-            }),
-          ),
-      }),
-    );
-    return yield* response.json.pipe(
-      Effect.flatMap(decodeAuthSessionState),
-      Effect.catchTags({
-        HttpClientError: (error) =>
-          Effect.fail(
-            new AuthTransportError({
-              message: "auth request failed",
-              cause: HttpClientError.HttpClientErrorSchema.fromHttpClientError(error),
-            }),
-          ),
-        SchemaError: (error) =>
-          Effect.fail(
-            new AuthTransportError({ message: "auth response decode failed", cause: error }),
-          ),
-      }),
+    const result = yield* fetchRemoteSessionState({
+      httpBaseUrl: connection.url,
+      bearerToken: connection.token,
+    }).pipe(
+      Effect.provideService(HttpClient.HttpClient, httpClient),
+      Effect.mapError(
+        (error) => new AuthTransportError({ message: "auth request failed", cause: error }),
+      ),
     );
+    return {
+      authenticated: result.authenticated,
+      ...(result.scopes !== undefined ? { role: inferRole(result.scopes.join(" ")) } : {}),
+      ...(result.sessionMethod !== undefined ? { sessionMethod: result.sessionMethod } : {}),
+      ...(result.expiresAt !== undefined
+        ? { expiresAt: DateTime.formatIso(result.expiresAt) }
+        : {}),
+    } satisfies AuthSessionState;
   });
 
   const issueWebSocketTicket = Effect.fn("AuthTransport.issueWebSocketTicket")(function* (
     connection: AuthTransportConnection,
   ) {
-    const url = yield* makeHttpEndpointUrl(connection.url, "/api/auth/websocket-ticket");
-    const request = HttpClientRequest.post(url).pipe(authenticatedRequest(connection));
-    const response = yield* client.execute(request).pipe(
-      Effect.catchTags({
-        HttpClientError: (error) =>
-          Effect.fail(
-            new AuthTransportError({
-              message: "auth request failed",
-              cause: HttpClientError.HttpClientErrorSchema.fromHttpClientError(error),
-            }),
-          ),
-      }),
-    );
-    return yield* response.json.pipe(
-      Effect.flatMap(decodeAuthWebSocketTicketResult),
-      Effect.catchTags({
-        HttpClientError: (error) =>
-          Effect.fail(
-            new AuthTransportError({
-              message: "auth request failed",
-              cause: HttpClientError.HttpClientErrorSchema.fromHttpClientError(error),
-            }),
-          ),
-        SchemaError: (error) =>
-          Effect.fail(
-            new AuthTransportError({ message: "auth response decode failed", cause: error }),
-          ),
-      }),
+    const result = yield* issueRemoteWebSocketTicket({
+      httpBaseUrl: connection.url,
+      bearerToken: connection.token,
+    }).pipe(
+      Effect.provideService(HttpClient.HttpClient, httpClient),
+      Effect.mapError(
+        (error) => new AuthTransportError({ message: "auth request failed", cause: error }),
+      ),
     );
+    return {
+      ticket: result.ticket,
+      expiresAt: DateTime.formatIso(result.expiresAt),
+    } satisfies AuthWebSocketTicketResult;
   });
 
   return {
@@ -172,15 +116,6 @@ const makeT3AuthTransport = Effect.fn("makeT3AuthTransport")(function* () {
 
 export const T3AuthTransportLive = Layer.effect(T3AuthTransport, makeT3AuthTransport());
 
-const authenticatedRequest =
-  (connection: AuthTransportConnection) => (request: HttpClientRequest.HttpClientRequest) =>
-    request.pipe(HttpClientRequest.acceptJson, HttpClientRequest.bearerToken(connection.token));
-
-function makeHttpEndpointUrl(baseUrl: string, path: string) {
-  return toHttpEndpointUrl(baseUrl, path).pipe(
-    Effect.catchTags({
-      UrlError: (error) =>
-        Effect.fail(new AuthTransportError({ message: "auth request failed", cause: error })),
-    }),
-  );
+function inferRole(scope: string): AuthBearerBootstrapResult["role"] {
+  return scope.split(/\s+/u).includes("access:write") ? "owner" : "client";
 }

package/src/auth/type.ts

@@ -1,3 +1,4 @@
+import type { AuthClientPresentationMetadata } from "../contracts/index.ts";
 import type { AuthBearerBootstrapResult } from "./schema.ts";
 import type { AuthSessionState } from "./schema.ts";
 
@@ -8,6 +9,11 @@ export type PairingUrl = {
   readonly credential: string;
 };
 
+export interface AuthPairInput {
+  readonly pairingUrl: string;
+  readonly clientMetadata?: AuthClientPresentationMetadata;
+}
+
 export type AuthConfigInput = {
   readonly name: string;
   readonly url: string;

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/connection/error.ts

@@ -1,9 +1,12 @@
 import * as Schema from "effect/Schema";
 
+import { ConfigError } from "../config/error.ts";
+import { UrlError } from "../config/url/error.ts";
+
 export class T3CodeConnectionError extends Schema.TaggedErrorClass<T3CodeConnectionError>()(
   "T3CodeConnectionError",
   {
     message: Schema.String,
-    cause: Schema.optionalKey(Schema.Unknown),
+    cause: Schema.Union([ConfigError, UrlError]),
   },
 ) {}

package/src/connection/layer.ts

@@ -1,10 +1,13 @@
 import * as Layer from "effect/Layer";
 
-import { T3AuthTransportLive } from "../auth/transport.ts";
+import { T3PreparedConnectionProviderLive } from "./prepared.ts";
 import { T3RpcLive } from "../rpc/layer.ts";
+import { T3RpcSessionFactoryLive } from "../rpc/session.ts";
 
 export function makeT3CodeRpcLayer() {
-  return T3RpcLive.pipe(Layer.provide(T3AuthTransportLive));
+  return T3RpcLive.pipe(
+    Layer.provide(Layer.mergeAll(T3PreparedConnectionProviderLive, T3RpcSessionFactoryLive)),
+  );
 }
 
 export const T3CodeRpcLayer = makeT3CodeRpcLayer();

package/src/connection/prepared.ts

@@ -0,0 +1,83 @@
+import { resolveRemoteWebSocketConnectionUrl } from "@t3tools/client-runtime/authorization";
+import {
+  BearerConnectionTarget,
+  type ConnectionAttemptError,
+  mapRemoteEnvironmentError,
+  type PreparedConnection,
+} from "@t3tools/client-runtime/connection";
+import { fetchRemoteEnvironmentDescriptor } from "@t3tools/client-runtime/environment";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { HttpClient } from "effect/unstable/http";
+
+import { toWebSocketEndpointUrl } from "../config/url/url.ts";
+import { T3CodeConnectionError } from "./error.ts";
+import { T3CodeConnectionProvider } from "./service.ts";
+import type { T3CodeConnection } from "./type.ts";
+
+export class T3PreparedConnectionProvider extends Context.Service<
+  T3PreparedConnectionProvider,
+  {
+    readonly get: Effect.Effect<PreparedConnection, ConnectionAttemptError | T3CodeConnectionError>;
+  }
+>()("t3cli/T3PreparedConnectionProvider") {}
+
+const makePreparedConnection = Effect.fn("makePreparedConnection")(function* (
+  connection: T3CodeConnection,
+) {
+  const httpBaseUrl = connection.origin.url;
+  const wsBaseUrl = yield* toWebSocketEndpointUrl(httpBaseUrl, "/ws").pipe(
+    Effect.mapError(
+      (error) =>
+        new T3CodeConnectionError({
+          message: "failed to resolve websocket endpoint",
+          cause: error,
+        }),
+    ),
+  );
+  const descriptor = yield* fetchRemoteEnvironmentDescriptor({ httpBaseUrl }).pipe(
+    Effect.mapError(mapRemoteEnvironmentError),
+  );
+  const socketUrl = yield* resolveRemoteWebSocketConnectionUrl({
+    httpBaseUrl,
+    wsBaseUrl,
+    bearerToken: connection.auth.token,
+  }).pipe(Effect.mapError(mapRemoteEnvironmentError));
+
+  return {
+    environmentId: descriptor.environmentId,
+    label: descriptor.label,
+    httpBaseUrl,
+    socketUrl,
+    httpAuthorization: {
+      _tag: "Bearer",
+      token: connection.auth.token,
+    },
+    target: new BearerConnectionTarget({
+      environmentId: descriptor.environmentId,
+      label: descriptor.label,
+      connectionId: descriptor.environmentId,
+    }),
+  } satisfies PreparedConnection;
+});
+
+const makeT3PreparedConnectionProvider = Effect.fn("makeT3PreparedConnectionProvider")(
+  function* () {
+    const connectionProvider = yield* T3CodeConnectionProvider;
+    const httpClient = yield* HttpClient.HttpClient;
+    const get = connectionProvider.get.pipe(
+      Effect.flatMap((connection) =>
+        makePreparedConnection(connection).pipe(
+          Effect.provideService(HttpClient.HttpClient, httpClient),
+        ),
+      ),
+    );
+    return T3PreparedConnectionProvider.of({ get });
+  },
+);
+
+export const T3PreparedConnectionProviderLive = Layer.effect(
+  T3PreparedConnectionProvider,
+  makeT3PreparedConnectionProvider(),
+);

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,13 +21,47 @@ 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) =>
         client[ORCHESTRATION_WS_METHODS.subscribeShell]({}),
       )
       .pipe(
-        Stream.map((item: OrchestrationShellStreamItem) =>
+        Stream.filter((item: OrchestrationShellStreamItem) => item.kind !== "synchronized"),
+        Stream.map((item) =>
           item.kind === "snapshot" ? item.snapshot.snapshotSequence : item.sequence,
         ),
       );
@@ -125,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

@@ -1,21 +1,20 @@
-import * as Schema from "effect/Schema";
+import {
+  ConnectionBlockedError,
+  ConnectionTransientError,
+} from "@t3tools/client-runtime/connection";
 import {
   EnvironmentAuthorizationError,
   KeybindingsConfigError,
   OrchestrationDispatchCommandError,
   OrchestrationGetSnapshotError,
+  PreviewAutomationError,
   ServerSettingsError,
-  TerminalCwdError,
-  TerminalHistoryError,
-  TerminalNotRunningError,
-  TerminalSessionLookupError,
+  TerminalError,
 } from "@t3tools/contracts";
-import { HttpClientError } from "effect/unstable/http";
+import * as Schema from "effect/Schema";
 import { RpcClientError } from "effect/unstable/rpc";
 
-import { AuthTransportError } from "../auth/error.ts";
 import { T3CodeConnectionError } from "../connection/error.ts";
-import { UrlError } from "../config/url/error.ts";
 
 const RpcErrorCauseSchema = Schema.Union([
   RpcClientError.RpcClientError,
@@ -23,16 +22,12 @@ const RpcErrorCauseSchema = Schema.Union([
   KeybindingsConfigError,
   OrchestrationDispatchCommandError,
   OrchestrationGetSnapshotError,
+  PreviewAutomationError,
   ServerSettingsError,
-  TerminalCwdError,
-  TerminalHistoryError,
-  TerminalNotRunningError,
-  TerminalSessionLookupError,
-  AuthTransportError,
+  TerminalError,
+  ConnectionBlockedError,
+  ConnectionTransientError,
   T3CodeConnectionError,
-  HttpClientError.HttpClientErrorSchema,
-  UrlError,
-  Schema.instanceOf(Schema.SchemaError),
 ]);
 
 export type RpcKnownCause = Schema.Schema.Type<typeof RpcErrorCauseSchema>;

package/src/rpc/index.ts

@@ -1,5 +1,6 @@
-export { RpcError } from "./error.ts";
+export { RpcError, type OrchestrationError } from "./error.ts";
 export { makeT3RpcLayer, T3RpcLive } from "./layer.ts";
 export { T3RpcOperations, T3RpcOperationsLive, makeT3RpcOperations } from "./operation.ts";
+export type { T3RpcOperationsService } from "./operation.ts";
 export { T3Rpc } from "./service.ts";
-export type { WsClient } from "./service.ts";
+export type { T3RpcService, WsClient } from "./service.ts";