t3code-cli 0.4.0 → 0.5.1

package/src/auth/pairing.ts

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

package/src/auth/service.ts

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

package/src/auth/transport.ts

@@ -9,7 +9,6 @@ import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import { HttpClient, HttpClientError, HttpClientRequest } from "effect/unstable/http";
 
-import type { ResolvedConfig } from "../config/service.ts";
 import { toHttpEndpointUrl } from "../config/url.ts";
 import { AuthTransportError } from "./error.ts";
 import {
@@ -21,6 +20,11 @@ import {
   decodeAuthWebSocketTicketResult,
 } from "./schema.ts";
 
+export type AuthTransportConnection = {
+  readonly url: string;
+  readonly token: string;
+};
+
 export class T3AuthTransport extends Context.Service<
   T3AuthTransport,
   {
@@ -29,10 +33,10 @@ export class T3AuthTransport extends Context.Service<
       readonly credential: string;
     }) => Effect.Effect<AuthBearerBootstrapResult, AuthTransportError>;
     readonly getSession: (
-      config: ResolvedConfig,
+      connection: AuthTransportConnection,
     ) => Effect.Effect<AuthSessionState, AuthTransportError>;
     readonly issueWebSocketTicket: (
-      config: ResolvedConfig,
+      connection: AuthTransportConnection,
     ) => Effect.Effect<AuthWebSocketTicketResult, AuthTransportError>;
   }
 >()("t3cli/T3AuthTransport") {}
@@ -91,9 +95,11 @@ const makeT3AuthTransport = Effect.fn("makeT3AuthTransport")(function* () {
     } satisfies AuthBearerBootstrapResult;
   });
 
-  const getSession = Effect.fn("AuthTransport.getSession")(function* (config: ResolvedConfig) {
-    const url = yield* makeHttpEndpointUrl(config.url, "/api/auth/session");
-    const request = HttpClientRequest.get(url).pipe(authenticatedRequest(config));
+  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) =>
@@ -124,10 +130,10 @@ const makeT3AuthTransport = Effect.fn("makeT3AuthTransport")(function* () {
   });
 
   const issueWebSocketTicket = Effect.fn("AuthTransport.issueWebSocketTicket")(function* (
-    config: ResolvedConfig,
+    connection: AuthTransportConnection,
   ) {
-    const url = yield* makeHttpEndpointUrl(config.url, "/api/auth/websocket-ticket");
-    const request = HttpClientRequest.post(url).pipe(authenticatedRequest(config));
+    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) =>
@@ -167,8 +173,8 @@ const makeT3AuthTransport = Effect.fn("makeT3AuthTransport")(function* () {
 export const T3AuthTransportLive = Layer.effect(T3AuthTransport, makeT3AuthTransport());
 
 const authenticatedRequest =
-  (config: ResolvedConfig) => (request: HttpClientRequest.HttpClientRequest) =>
-    request.pipe(HttpClientRequest.acceptJson, HttpClientRequest.bearerToken(config.token));
+  (connection: AuthTransportConnection) => (request: HttpClientRequest.HttpClientRequest) =>
+    request.pipe(HttpClientRequest.acceptJson, HttpClientRequest.bearerToken(connection.token));
 
 function makeHttpEndpointUrl(baseUrl: string, path: string) {
   return toHttpEndpointUrl(baseUrl, path).pipe(

package/src/auth/type.ts

@@ -7,8 +7,14 @@ export type PairingUrl = {
   readonly credential: string;
 };
 
+export type AuthConfigInput = {
+  readonly url: string;
+  readonly token: string;
+};
+
 export type PairResult = {
   readonly url: string;
+  readonly token: string;
   readonly role: AuthBearerBootstrapResult["role"];
   readonly expiresAt: string;
 };
@@ -21,8 +27,24 @@ export type LocalAuthInput = {
   readonly subject: string;
 };
 
+export type LocalAuthTokenInput = Omit<LocalAuthInput, "origin">;
+
+export type LocalAuthOriginInput = {
+  readonly baseDir?: string;
+  readonly origin?: string;
+};
+
+export type LocalAuthTokenResult = {
+  readonly token: string;
+  readonly role: AuthSessionRole;
+  readonly expiresAt: string;
+  readonly source: "local";
+  readonly baseDir: string;
+};
+
 export type LocalAuthResult = {
   readonly url: string;
+  readonly token: string;
   readonly role: AuthSessionRole;
   readonly expiresAt: string;
   readonly source: "local";

package/src/cli/auth.ts

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

package/src/connection/error.ts

@@ -0,0 +1,9 @@
+import * as Schema from "effect/Schema";
+
+export class T3CodeConnectionError extends Schema.TaggedErrorClass<T3CodeConnectionError>()(
+  "T3CodeConnectionError",
+  {
+    message: Schema.String,
+    cause: Schema.optionalKey(Schema.Unknown),
+  },
+) {}

package/src/connection/layer.ts

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

package/src/connection/node.ts

@@ -0,0 +1,12 @@
+import * as Layer from "effect/Layer";
+import * as NodeHttpClient from "@effect/platform-node/NodeHttpClient";
+import * as NodeSocket from "@effect/platform-node/NodeSocket";
+
+import { T3CodeRpcLayer } from "./layer.ts";
+
+const NodeConnectionPlatformLayer = Layer.mergeAll(
+  NodeHttpClient.layerUndici,
+  NodeSocket.layerWebSocketConstructor,
+);
+
+export const T3CodeNodeRpcLayer = T3CodeRpcLayer.pipe(Layer.provide(NodeConnectionPlatformLayer));

package/src/connection/service.ts

@@ -0,0 +1,26 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+
+import type { T3CodeConnectionError } from "./error.ts";
+import type { T3CodeConnection } from "./type.ts";
+
+export class T3CodeConnectionProvider extends Context.Service<
+  T3CodeConnectionProvider,
+  {
+    readonly get: Effect.Effect<T3CodeConnection, T3CodeConnectionError>;
+  }
+>()("t3cli/T3CodeConnectionProvider") {}
+
+export function makeT3CodeConnectionProvider(
+  get: Effect.Effect<T3CodeConnection, T3CodeConnectionError>,
+): T3CodeConnectionProvider["Service"] {
+  return { get };
+}
+
+export function T3CodeConnectionProviderLive(connection: T3CodeConnection) {
+  return Layer.succeed(
+    T3CodeConnectionProvider,
+    makeT3CodeConnectionProvider(Effect.succeed(connection)),
+  );
+}

package/src/connection/type.ts

@@ -0,0 +1,12 @@
+export type T3CodeOrigin = {
+  readonly url: string;
+};
+
+export type T3CodeAuth = {
+  readonly token: string;
+};
+
+export type T3CodeConnection = {
+  readonly origin: T3CodeOrigin;
+  readonly auth: T3CodeAuth;
+};

package/src/connection.ts

@@ -0,0 +1,9 @@
+export { T3CodeConnectionError } from "./connection/error.ts";
+export { T3CodeRpcLayer, makeT3CodeRpcLayer } from "./connection/layer.ts";
+export { T3CodeNodeRpcLayer } from "./connection/node.ts";
+export {
+  T3CodeConnectionProvider,
+  T3CodeConnectionProviderLive,
+  makeT3CodeConnectionProvider,
+} from "./connection/service.ts";
+export type { T3CodeAuth, T3CodeConnection, T3CodeOrigin } from "./connection/type.ts";

package/src/index.ts

@@ -6,8 +6,82 @@ export type {
   WaitEvent,
 } from "./application/service.ts";
 export type { ApplicationError } from "./application/error.ts";
+export { T3Auth } from "./auth/service.ts";
+export { T3AuthLive, makeT3Auth } from "./auth/layer.ts";
+export { T3LocalAuth, T3LocalAuthLive, makeT3LocalAuth } from "./auth/local.ts";
+export {
+  T3LocalAuthOrigin,
+  T3LocalAuthOriginLive,
+  makeT3LocalAuthOrigin,
+} from "./auth/local-origin.ts";
+export {
+  T3LocalAuthToken,
+  T3LocalAuthTokenLive,
+  makeT3LocalAuthToken,
+} from "./auth/local-token.ts";
+export {
+  T3AuthPairing,
+  T3AuthPairingLive,
+  makeT3AuthPairing,
+  parsePairingUrl,
+} from "./auth/pairing.ts";
+export {
+  AuthConfigError,
+  AuthLocalDatabaseError,
+  AuthLocalError,
+  AuthLocalSecretError,
+  AuthLocalSigningError,
+  AuthPairingUrlError,
+  AuthTransportError,
+} from "./auth/error.ts";
+export type { AuthError } from "./auth/error.ts";
+export type { AuthSessionState, AuthWebSocketTicketResult } from "./auth/schema.ts";
+export type {
+  AuthConfigInput,
+  AuthSessionRole,
+  LocalAuthInput,
+  LocalAuthOriginInput,
+  LocalAuthResult,
+  LocalAuthTokenInput,
+  LocalAuthTokenResult,
+  PairingUrl,
+  PairResult,
+} from "./auth/type.ts";
+export { T3Config } from "./config/service.ts";
+export type { ResolvedConfig, StoredConfig } from "./config/service.ts";
+export { T3ConfigLive, makeT3Config } from "./config/layer.ts";
+export { ConfigError, UrlError } from "./config/error.ts";
+export type { ConfigServiceError } from "./config/error.ts";
+export {
+  makeT3CodeConnectionProvider,
+  makeT3CodeRpcLayer,
+  T3CodeConnectionProvider,
+  T3CodeConnectionProviderLive,
+  T3CodeNodeRpcLayer,
+  T3CodeRpcLayer,
+  T3CodeConnectionError,
+} from "./connection.ts";
+export type { T3CodeAuth, T3CodeConnection, T3CodeOrigin } from "./connection.ts";
+export { Environment } from "./environment/service.ts";
+export type { EnvironmentShape } from "./environment/service.ts";
 export { NodeEnvironmentLive } from "./environment/layer.ts";
-export { AppLayer, AuthAppLayer } from "./runtime.ts";
+export {
+  AppLayer,
+  AuthAppLayer,
+  T3AuthLayer,
+  T3AuthPairingLayer,
+  T3AuthTransportLayer,
+  T3LocalAuthLayer,
+  T3LocalAuthOriginLayer,
+  T3LocalAuthTokenLayer,
+} from "./runtime.ts";
+export { SqlClientFactory } from "./sql/service.ts";
+export type { SqlClientFactoryShape, SqliteClientConfig } from "./sql/service.ts";
+export {
+  NodeSqlClientFactoryLive,
+  NodeSqliteClientLive,
+  makeNodeSqliteClient,
+} from "./sql/node-sqlite-client.ts";
 export type {
   OrchestrationMessage,
   OrchestrationProjectShell,

package/src/rpc/error.ts

@@ -9,13 +9,9 @@ import {
 import { HttpClientError } from "effect/unstable/http";
 import { RpcClientError } from "effect/unstable/rpc";
 
-import {
-  AuthConfigError,
-  AuthLocalError,
-  AuthPairingUrlError,
-  AuthTransportError,
-} from "../auth/error.ts";
-import { ConfigError, UrlError } from "../config/error.ts";
+import { AuthTransportError } from "../auth/error.ts";
+import { T3CodeConnectionError } from "../connection/error.ts";
+import { UrlError } from "../config/error.ts";
 
 const RpcErrorCauseSchema = Schema.Union([
   RpcClientError.RpcClientError,
@@ -24,11 +20,8 @@ const RpcErrorCauseSchema = Schema.Union([
   OrchestrationDispatchCommandError,
   OrchestrationGetSnapshotError,
   ServerSettingsError,
-  AuthConfigError,
-  AuthLocalError,
-  AuthPairingUrlError,
   AuthTransportError,
-  ConfigError,
+  T3CodeConnectionError,
   HttpClientError.HttpClientErrorSchema,
   UrlError,
   Schema.instanceOf(Schema.SchemaError),

package/src/rpc/layer.ts

@@ -6,14 +6,13 @@ import * as Option from "effect/Option";
 import * as Schedule from "effect/Schedule";
 import * as Scope from "effect/Scope";
 import * as SynchronizedRef from "effect/SynchronizedRef";
-import * as NodeSocket from "@effect/platform-node/NodeSocket";
 import { HttpClientRequest } from "effect/unstable/http";
 import { RpcClient, RpcSerialization } from "effect/unstable/rpc";
 import * as Socket from "effect/unstable/socket/Socket";
 
-import { T3Auth } from "../auth/service.ts";
-import { T3Config } from "../config/service.ts";
-import { toWebSocketEndpointUrl } from "../config/url.ts";
+import { T3AuthTransport } from "../auth/transport.ts";
+import { T3CodeConnectionProvider } from "../connection/service.ts";
+import { normalizeHttpBaseUrl, toWebSocketEndpointUrl } from "../config/url.ts";
 import { CliWsRpcGroup } from "./ws-group.ts";
 import { RpcError } from "./error.ts";
 import { T3Rpc, type WsClient } from "./service.ts";
@@ -27,15 +26,19 @@ type Connection = {
 };
 
 export const makeT3RpcLayer = Effect.fn("makeT3RpcLayer")(function* () {
-  const config = yield* T3Config;
-  const auth = yield* T3Auth;
+  const connectionProvider = yield* T3CodeConnectionProvider;
+  const authTransport = yield* T3AuthTransport;
+  const webSocketConstructor = yield* Socket.WebSocketConstructor;
   const parentScope = yield* Scope.Scope;
   const connection = yield* SynchronizedRef.make(Option.none<Connection>());
   const openConnection = Effect.fn("T3RpcLive.openConnection")(function* () {
     const scope = yield* Scope.fork(parentScope);
     return yield* Effect.gen(function* () {
-      const url = yield* makeWsUrl({ auth, config });
-      const protocol = yield* Layer.buildWithScope(makeProtocolLayer(url), scope);
+      const url = yield* makeWsUrl({ authTransport, connectionProvider });
+      const protocol = yield* Layer.buildWithScope(
+        makeProtocolLayer(url, webSocketConstructor),
+        scope,
+      );
       const client = yield* makeClient.pipe(
         Effect.provide(protocol),
         Effect.provideService(Scope.Scope, scope),
@@ -72,21 +75,28 @@ export const makeT3RpcLayer = Effect.fn("makeT3RpcLayer")(function* () {
 });
 
 const makeWsUrl = Effect.fn("makeWsUrl")(function* (input: {
-  readonly config: T3Config["Service"];
-  readonly auth: T3Auth["Service"];
+  readonly authTransport: T3AuthTransport["Service"];
+  readonly connectionProvider: T3CodeConnectionProvider["Service"];
 }) {
-  const resolved = yield* input.config.resolve();
-  const wsTicket = yield* input.auth.issueWebSocketTicket();
-  const wsUrl = yield* toWebSocketEndpointUrl(resolved.url, "/ws");
+  const connection = yield* input.connectionProvider.get;
+  const origin = yield* normalizeHttpBaseUrl(connection.origin.url);
+  const wsTicket = yield* input.authTransport.issueWebSocketTicket({
+    url: origin,
+    token: connection.auth.token,
+  });
+  const wsUrl = yield* toWebSocketEndpointUrl(origin, "/ws");
   const request = HttpClientRequest.get(wsUrl).pipe(
     HttpClientRequest.setUrlParam("wsTicket", wsTicket.ticket),
   );
   return Option.getOrThrow(HttpClientRequest.toUrl(request)).toString();
 });
 
-function makeProtocolLayer(url: string) {
+function makeProtocolLayer(
+  url: string,
+  webSocketConstructor: Socket.WebSocketConstructor["Service"],
+) {
   const socketLayer = Socket.layerWebSocket(url).pipe(
-    Layer.provide(NodeSocket.layerWebSocketConstructor),
+    Layer.provide(Layer.succeed(Socket.WebSocketConstructor, webSocketConstructor)),
   );
   return RpcClient.layerProtocolSocket({ retryTransientErrors: true }).pipe(
     Layer.provide(socketLayer),

package/src/runtime.ts

@@ -1,31 +1,69 @@
+import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as NodeHttpClient from "@effect/platform-node/NodeHttpClient";
 import * as NodeSocket from "@effect/platform-node/NodeSocket";
 
 import { T3AuthLive } from "./auth/layer.ts";
 import { T3LocalAuthLive } from "./auth/local.ts";
+import { T3LocalAuthOriginLive } from "./auth/local-origin.ts";
+import { T3LocalAuthTokenLive } from "./auth/local-token.ts";
 import { T3AuthPairingLive } from "./auth/pairing.ts";
 import { T3AuthTransportLive } from "./auth/transport.ts";
+import { T3CodeConnectionError } from "./connection/error.ts";
+import { T3CodeConnectionProvider, makeT3CodeConnectionProvider } from "./connection/service.ts";
 import { T3ConfigLive } from "./config/layer.ts";
+import { T3Config } from "./config/service.ts";
 import { T3ApplicationLive } from "./application/layer.ts";
 import { T3OrchestrationLive } from "./orchestration/layer.ts";
 import { T3RpcLive } from "./rpc/layer.ts";
 import { NodeSqlClientFactoryLive } from "./sql/node-sqlite-client.ts";
 
-const T3AuthTransportLayer = T3AuthTransportLive.pipe(Layer.provide(NodeHttpClient.layerUndici));
-const T3LocalAuthLayer = T3LocalAuthLive.pipe(
-  Layer.provide(Layer.mergeAll(T3ConfigLive, NodeSqlClientFactoryLive)),
+export const T3AuthTransportLayer = T3AuthTransportLive.pipe(
+  Layer.provide(NodeHttpClient.layerUndici),
 );
-const T3AuthPairingLayer = T3AuthPairingLive.pipe(
-  Layer.provide(Layer.mergeAll(T3ConfigLive, T3AuthTransportLayer)),
+export const T3LocalAuthOriginLayer = T3LocalAuthOriginLive;
+export const T3LocalAuthTokenLayer = T3LocalAuthTokenLive.pipe(
+  Layer.provide(NodeSqlClientFactoryLive),
 );
-const T3AuthLayer = T3AuthLive.pipe(
+export const T3LocalAuthLayer = T3LocalAuthLive.pipe(
+  Layer.provide(Layer.mergeAll(T3LocalAuthOriginLayer, T3LocalAuthTokenLayer)),
+);
+export const T3AuthPairingLayer = T3AuthPairingLive.pipe(Layer.provide(T3AuthTransportLayer));
+export const T3AuthLayer = T3AuthLive.pipe(
   Layer.provide(
     Layer.mergeAll(T3ConfigLive, T3AuthTransportLayer, T3LocalAuthLayer, T3AuthPairingLayer),
   ),
 );
+const T3ConfigConnectionProviderLayer = Layer.effect(
+  T3CodeConnectionProvider,
+  Effect.gen(function* () {
+    const config = yield* T3Config;
+    return makeT3CodeConnectionProvider(
+      config.resolve().pipe(
+        Effect.map((resolved) => ({
+          origin: { url: resolved.url },
+          auth: { token: resolved.token },
+        })),
+        Effect.mapError(
+          (error) =>
+            new T3CodeConnectionError({
+              message: "failed to resolve T3 Code connection from CLI config",
+              cause: error,
+            }),
+        ),
+      ),
+    );
+  }),
+).pipe(Layer.provide(T3ConfigLive));
+
 const T3RpcLayer = T3RpcLive.pipe(
-  Layer.provide(Layer.mergeAll(T3ConfigLive, T3AuthLayer, NodeSocket.layerWebSocketConstructor)),
+  Layer.provide(
+    Layer.mergeAll(
+      T3ConfigConnectionProviderLayer,
+      T3AuthTransportLayer,
+      NodeSocket.layerWebSocketConstructor,
+    ),
+  ),
 );
 const T3OrchestrationLayer = T3OrchestrationLive.pipe(Layer.provide(T3RpcLayer));
 const T3ApplicationLayer = T3ApplicationLive.pipe(Layer.provide(T3OrchestrationLayer));