t3code-cli 0.3.0 → 0.4.0

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

@@ -765,12 +765,12 @@ export declare const makeT3Application: () => Effect.Effect<{
             readonly message: string | null;
         };
         readonly updateState?: {
-            readonly status: "idle" | "running" | "queued" | "succeeded" | "failed" | "unchanged";
+            readonly status: "idle" | "running" | "failed" | "queued" | "succeeded" | "unchanged";
             readonly startedAt: string | null;
             readonly finishedAt: string | null;
             readonly message: string | null;
             readonly output: string | null;
         };
     }[], import("../rpc/error.ts").RpcError, never>;
-}, never, import("../environment/service.ts").Environment | import("effect/Path").Path | import("../orchestration/service.ts").T3Orchestration | import("effect/Crypto").Crypto>;
-export declare const T3ApplicationLive: Layer.Layer<T3Application, never, import("../environment/service.ts").Environment | import("effect/Path").Path | import("../orchestration/service.ts").T3Orchestration | import("effect/Crypto").Crypto>;
+}, never, import("../environment/service.ts").Environment | import("effect/Path").Path | import("effect/Crypto").Crypto | import("../orchestration/service.ts").T3Orchestration>;
+export declare const T3ApplicationLive: Layer.Layer<T3Application, never, import("../environment/service.ts").Environment | import("effect/Path").Path | import("effect/Crypto").Crypto | import("../orchestration/service.ts").T3Orchestration>;

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

@@ -83,7 +83,7 @@ export declare const makeModelsApplication: () => Effect.Effect<{
             readonly message: string | null;
         };
         readonly updateState?: {
-            readonly status: "idle" | "running" | "queued" | "succeeded" | "failed" | "unchanged";
+            readonly status: "idle" | "running" | "failed" | "queued" | "succeeded" | "unchanged";
             readonly startedAt: string | null;
             readonly finishedAt: string | null;
             readonly message: string | null;

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

@@ -133,4 +133,4 @@ export declare const makeProjectApplication: () => Effect.Effect<{
             } | null | undefined;
         };
     }, ProjectCreateVisibilityError | import("../rpc/error.ts").RpcError, never>;
-}, never, Environment | Path.Path | T3Orchestration | Crypto.Crypto>;
+}, never, Environment | Path.Path | Crypto.Crypto | T3Orchestration>;

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

@@ -560,4 +560,4 @@ export declare const makeThreadApplication: () => Effect.Effect<{
             readonly providerInstanceId?: (string & import("effect/Brand").Brand<"ProviderInstanceId">) | undefined;
         } | null;
     }, ThreadSessionError | import("../rpc/error.ts").RpcError, never>;
-}, never, Environment | Path.Path | T3Orchestration | Crypto.Crypto>;
+}, never, Environment | Path.Path | Crypto.Crypto | T3Orchestration>;

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

@@ -21,9 +21,28 @@ declare const AuthTransportError_base: Schema.Class<AuthTransportError, Schema.T
 }>, Cause.YieldableError>;
 export declare class AuthTransportError extends AuthTransportError_base {
 }
+declare const AuthLocalSecretError_base: Schema.Class<AuthLocalSecretError, Schema.TaggedStruct<"AuthLocalSecretError", {
+    readonly message: Schema.String;
+    readonly cause: Schema.optionalKey<Schema.instanceOf<PlatformError, PlatformError>>;
+}>, Cause.YieldableError>;
+export declare class AuthLocalSecretError extends AuthLocalSecretError_base {
+}
+declare const AuthLocalDatabaseError_base: Schema.Class<AuthLocalDatabaseError, Schema.TaggedStruct<"AuthLocalDatabaseError", {
+    readonly operation: Schema.Literals<readonly ["connect", "query", "schema"]>;
+    readonly message: Schema.String;
+}>, Cause.YieldableError>;
+export declare class AuthLocalDatabaseError extends AuthLocalDatabaseError_base {
+}
+declare const AuthLocalSigningError_base: Schema.Class<AuthLocalSigningError, Schema.TaggedStruct<"AuthLocalSigningError", {
+    readonly operation: Schema.Literals<readonly ["sign"]>;
+    readonly message: Schema.String;
+    readonly cause: Schema.optionalKey<Schema.instanceOf<PlatformError, PlatformError>>;
+}>, Cause.YieldableError>;
+export declare class AuthLocalSigningError extends AuthLocalSigningError_base {
+}
 declare const AuthLocalError_base: Schema.Class<AuthLocalError, Schema.TaggedStruct<"AuthLocalError", {
     readonly message: Schema.String;
-    readonly cause: Schema.optionalKey<Schema.Union<readonly [Schema.instanceOf<PlatformError, unknown>, Schema.instanceOf<Schema.SchemaError, unknown>, typeof UrlError]>>;
+    readonly cause: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.instanceOf<PlatformError, unknown>, Schema.instanceOf<Schema.SchemaError, unknown>, typeof UrlError]>, typeof AuthLocalSecretError, typeof AuthLocalDatabaseError, typeof AuthLocalSigningError]>>;
 }>, Cause.YieldableError>;
 export declare class AuthLocalError extends AuthLocalError_base {
 }

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

@@ -1,36 +1,23 @@
 import * as Effect from "effect/Effect";
-import * as FileSystem from "effect/FileSystem";
 import * as Layer from "effect/Layer";
-import * as Path from "effect/Path";
-import * as Scope from "effect/Scope";
-import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
 import { T3Config } from "../config/service.ts";
-import { Environment } from "../environment/service.ts";
 import { AuthConfigError } from "./error.ts";
+import { T3LocalAuth } from "./local.ts";
+import { T3AuthPairing } from "./pairing.ts";
 import { T3Auth } from "./service.ts";
-import type { LocalAuthInput } from "./type.ts";
+import { T3AuthTransport } from "./transport.ts";
 export declare const makeT3Auth: () => Effect.Effect<{
-    pair: (pairingUrl: string) => Effect.Effect<{
-        url: string;
-        role: "client" | "owner";
-        expiresAt: string;
-    }, import("./error.ts").AuthPairingUrlError | AuthConfigError | import("./error.ts").AuthTransportError, never>;
-    local: (input: LocalAuthInput) => Effect.Effect<{
-        url: string;
-        role: "client" | "owner";
-        expiresAt: string;
-        source: "local";
-        baseDir: string;
-    }, AuthConfigError | import("./error.ts").AuthLocalError, never>;
+    pair: (pairingUrl: string) => Effect.Effect<import("./type.ts").PairResult, AuthConfigError | import("./error.ts").AuthPairingUrlError | import("./error.ts").AuthTransportError>;
+    local: (input: import("./type.ts").LocalAuthInput) => Effect.Effect<import("./type.ts").LocalAuthResult, AuthConfigError | import("./error.ts").AuthLocalError>;
     status: () => Effect.Effect<{
         readonly authenticated: boolean;
         readonly role?: "client" | "owner";
         readonly sessionMethod?: string;
         readonly expiresAt?: string;
     }, AuthConfigError | import("./error.ts").AuthTransportError, never>;
-    issueWebSocketToken: () => Effect.Effect<{
-        readonly token: string;
+    issueWebSocketTicket: () => Effect.Effect<{
+        readonly ticket: string;
         readonly expiresAt: string;
     }, AuthConfigError | import("./error.ts").AuthTransportError, never>;
-}, never, Environment | T3Config | Path.Path | ChildProcessSpawner | Scope.Scope | FileSystem.FileSystem | import("effect/unstable/http/HttpClient").HttpClient>;
-export declare const T3AuthLive: Layer.Layer<T3Auth, never, Environment | T3Config | Path.Path | ChildProcessSpawner | FileSystem.FileSystem | import("effect/unstable/http/HttpClient").HttpClient>;
+}, never, T3Config | T3LocalAuth | T3AuthTransport | T3AuthPairing>;
+export declare const T3AuthLive: Layer.Layer<T3Auth, never, T3Config | T3LocalAuth | T3AuthTransport | T3AuthPairing>;

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

@@ -1,19 +1,27 @@
+import * as Context from "effect/Context";
+import * as Crypto from "effect/Crypto";
 import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
 import * as Path from "effect/Path";
-import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
+import { T3Config } from "../config/service.ts";
 import { Environment } from "../environment/service.ts";
-import { AuthLocalError } from "./error.ts";
-import type { LocalAuthInput } from "./type.ts";
-export declare const issueLocalSession: (input: Pick<LocalAuthInput, "label" | "subject" | "role" | "baseDir" | "t3Command">) => Effect.Effect<{
-    readonly baseDir: string;
-    readonly session: {
-        readonly token: string;
-        readonly role: "client" | "owner";
-        readonly expiresAt: string;
-    };
-}, AuthLocalError, Environment | Path.Path | ChildProcessSpawner | import("effect/Scope").Scope | FileSystem.FileSystem>;
-export declare const resolveLocalOrigin: (input: {
-    readonly baseDir: string;
-    readonly origin?: string;
-}) => Effect.Effect<string, AuthLocalError, Path.Path | FileSystem.FileSystem>;
+import { SqlClientFactory } from "../sql/service.ts";
+import { AuthConfigError, AuthLocalError } from "./error.ts";
+import type { LocalAuthInput, LocalAuthResult } from "./type.ts";
+declare const T3LocalAuth_base: Context.ServiceClass<T3LocalAuth, "t3cli/T3LocalAuth", {
+    readonly local: (input: LocalAuthInput) => Effect.Effect<LocalAuthResult, AuthConfigError | AuthLocalError>;
+}>;
+export declare class T3LocalAuth extends T3LocalAuth_base {
+}
+export declare const makeT3LocalAuth: () => Effect.Effect<{
+    local: (input: LocalAuthInput) => Effect.Effect<{
+        url: string;
+        role: "client" | "owner";
+        expiresAt: string;
+        source: "local";
+        baseDir: string;
+    }, AuthConfigError | AuthLocalError, never>;
+}, never, Environment | T3Config | SqlClientFactory | Path.Path | FileSystem.FileSystem | Crypto.Crypto>;
+export declare const T3LocalAuthLive: Layer.Layer<T3LocalAuth, never, Environment | T3Config | SqlClientFactory | Path.Path | FileSystem.FileSystem | Crypto.Crypto>;
+export {};

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

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

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

@@ -1,12 +1,19 @@
 import * as Schema from "effect/Schema";
-export declare const AuthBearerBootstrapResultSchema: Schema.Struct<{
-    readonly authenticated: Schema.Literal<true>;
-    readonly role: Schema.Literals<readonly ["owner", "client"]>;
-    readonly sessionMethod: Schema.Literal<"bearer-session-token">;
-    readonly expiresAt: Schema.String;
-    readonly sessionToken: Schema.String;
+export declare const AuthAccessTokenResultSchema: Schema.Struct<{
+    readonly access_token: Schema.String;
+    readonly issued_token_type: Schema.String;
+    readonly token_type: Schema.Literal<"Bearer">;
+    readonly expires_in: Schema.Number;
+    readonly scope: Schema.String;
 }>;
-export type AuthBearerBootstrapResult = typeof AuthBearerBootstrapResultSchema.Type;
+export type AuthAccessTokenResult = typeof AuthAccessTokenResultSchema.Type;
+export type AuthBearerBootstrapResult = {
+    readonly authenticated: true;
+    readonly role: "owner" | "client";
+    readonly sessionMethod: "bearer-access-token";
+    readonly expiresAt: string;
+    readonly sessionToken: string;
+};
 export declare const AuthSessionStateSchema: Schema.Struct<{
     readonly authenticated: Schema.Boolean;
     readonly role: Schema.optionalKey<Schema.Literals<readonly ["owner", "client"]>>;
@@ -14,28 +21,22 @@ export declare const AuthSessionStateSchema: Schema.Struct<{
     readonly expiresAt: Schema.optionalKey<Schema.String>;
 }>;
 export type AuthSessionState = typeof AuthSessionStateSchema.Type;
-export declare const AuthWebSocketTokenResultSchema: Schema.Struct<{
-    readonly token: Schema.String;
+export declare const AuthWebSocketTicketResultSchema: Schema.Struct<{
+    readonly ticket: Schema.String;
     readonly expiresAt: Schema.String;
 }>;
-export type AuthWebSocketTokenResult = typeof AuthWebSocketTokenResultSchema.Type;
-export declare const AuthLocalSessionIssueResultSchema: Schema.Struct<{
-    readonly token: Schema.String;
-    readonly role: Schema.Literals<readonly ["owner", "client"]>;
-    readonly expiresAt: Schema.String;
-}>;
-export type AuthLocalSessionIssueResult = typeof AuthLocalSessionIssueResultSchema.Type;
+export type AuthWebSocketTicketResult = typeof AuthWebSocketTicketResultSchema.Type;
 export declare const AuthLocalRuntimeStateSchema: Schema.Struct<{
     readonly version: Schema.Literal<1>;
     readonly origin: Schema.String;
 }>;
 export type AuthLocalRuntimeState = typeof AuthLocalRuntimeStateSchema.Type;
-export declare const decodeAuthBearerBootstrapResult: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<{
-    readonly authenticated: true;
-    readonly role: "client" | "owner";
-    readonly sessionMethod: "bearer-session-token";
-    readonly expiresAt: string;
-    readonly sessionToken: string;
+export declare const decodeAuthAccessTokenResult: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<{
+    readonly access_token: string;
+    readonly issued_token_type: string;
+    readonly token_type: "Bearer";
+    readonly expires_in: number;
+    readonly scope: string;
 }, Schema.SchemaError, never>;
 export declare const decodeAuthSessionState: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<{
     readonly authenticated: boolean;
@@ -43,24 +44,14 @@ export declare const decodeAuthSessionState: (input: unknown, options?: import("
     readonly sessionMethod?: string;
     readonly expiresAt?: string;
 }, Schema.SchemaError, never>;
-export declare const decodeAuthWebSocketTokenResult: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<{
-    readonly token: string;
-    readonly expiresAt: string;
-}, Schema.SchemaError, never>;
-export declare const decodeAuthLocalSessionIssueResult: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<{
-    readonly token: string;
-    readonly role: "client" | "owner";
+export declare const decodeAuthWebSocketTicketResult: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<{
+    readonly ticket: string;
     readonly expiresAt: string;
 }, Schema.SchemaError, never>;
 export declare const decodeAuthLocalRuntimeState: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<{
     readonly version: 1;
     readonly origin: string;
 }, Schema.SchemaError, never>;
-export declare const decodeAuthLocalSessionIssueResultFromJson: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<{
-    readonly token: string;
-    readonly role: "client" | "owner";
-    readonly expiresAt: string;
-}, Schema.SchemaError, never>;
 export declare const decodeAuthLocalRuntimeStateFromJson: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<{
     readonly version: 1;
     readonly origin: string;

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

@@ -1,13 +1,13 @@
 import * as Context from "effect/Context";
 import type * as Effect from "effect/Effect";
-import type { AuthSessionState, AuthWebSocketTokenResult } from "./schema.ts";
+import type { AuthSessionState, AuthWebSocketTicketResult } from "./schema.ts";
 import type { AuthError } from "./error.ts";
 import type { LocalAuthInput, LocalAuthResult, PairResult } from "./type.ts";
 declare const T3Auth_base: Context.ServiceClass<T3Auth, "t3cli/T3Auth", {
     readonly pair: (value: string) => Effect.Effect<PairResult, AuthError>;
     readonly local: (input: LocalAuthInput) => Effect.Effect<LocalAuthResult, AuthError>;
     readonly status: () => Effect.Effect<AuthSessionState, AuthError>;
-    readonly issueWebSocketToken: () => Effect.Effect<AuthWebSocketTokenResult, AuthError>;
+    readonly issueWebSocketTicket: () => Effect.Effect<AuthWebSocketTicketResult, AuthError>;
 }>;
 export declare class T3Auth extends T3Auth_base {
 }

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

@@ -1,26 +1,19 @@
+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 type { ResolvedConfig } from "../config/service.ts";
 import { AuthTransportError } from "./error.ts";
-export declare const makeAuthTransport: () => Effect.Effect<{
-    bootstrapBearer: (input: {
+import { type AuthBearerBootstrapResult, type AuthSessionState, type AuthWebSocketTicketResult } from "./schema.ts";
+declare const T3AuthTransport_base: Context.ServiceClass<T3AuthTransport, "t3cli/T3AuthTransport", {
+    readonly bootstrapBearer: (input: {
         readonly baseUrl: string;
         readonly credential: string;
-    }) => Effect.Effect<{
-        readonly authenticated: true;
-        readonly role: "client" | "owner";
-        readonly sessionMethod: "bearer-session-token";
-        readonly expiresAt: string;
-        readonly sessionToken: string;
-    }, AuthTransportError, never>;
-    getSession: (config: ResolvedConfig) => Effect.Effect<{
-        readonly authenticated: boolean;
-        readonly role?: "client" | "owner";
-        readonly sessionMethod?: string;
-        readonly expiresAt?: string;
-    }, AuthTransportError, never>;
-    issueWebSocketToken: (config: ResolvedConfig) => Effect.Effect<{
-        readonly token: string;
-        readonly expiresAt: string;
-    }, AuthTransportError, never>;
-}, never, HttpClient.HttpClient>;
+    }) => Effect.Effect<AuthBearerBootstrapResult, AuthTransportError>;
+    readonly getSession: (config: ResolvedConfig) => Effect.Effect<AuthSessionState, AuthTransportError>;
+    readonly issueWebSocketTicket: (config: ResolvedConfig) => Effect.Effect<AuthWebSocketTicketResult, AuthTransportError>;
+}>;
+export declare class T3AuthTransport extends T3AuthTransport_base {
+}
+export declare const T3AuthTransportLive: Layer.Layer<T3AuthTransport, never, HttpClient.HttpClient>;
+export {};

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

@@ -11,7 +11,6 @@ export type PairResult = {
 };
 export type LocalAuthInput = {
     readonly baseDir?: string;
-    readonly t3Command?: string;
     readonly origin?: string;
     readonly role: AuthSessionRole;
     readonly label: string;

package/dist/src/domain/model-config.d.ts

@@ -79,7 +79,7 @@ export declare function firstSelectableProvider(providers: ReadonlyArray<ServerP
         readonly message: string | null;
     };
     readonly updateState?: {
-        readonly status: "idle" | "running" | "queued" | "succeeded" | "failed" | "unchanged";
+        readonly status: "idle" | "running" | "failed" | "queued" | "succeeded" | "unchanged";
         readonly startedAt: string | null;
         readonly finishedAt: string | null;
         readonly message: string | null;
@@ -194,7 +194,7 @@ export declare function findSelectableProvider(providers: ReadonlyArray<ServerPr
         readonly message: string | null;
     };
     readonly updateState?: {
-        readonly status: "idle" | "running" | "queued" | "succeeded" | "failed" | "unchanged";
+        readonly status: "idle" | "running" | "failed" | "queued" | "succeeded" | "unchanged";
         readonly startedAt: string | null;
         readonly finishedAt: string | null;
         readonly message: string | null;
@@ -284,7 +284,7 @@ export declare function filterProvidersForModelListing(input: {
         readonly message: string | null;
     };
     readonly updateState?: {
-        readonly status: "idle" | "running" | "queued" | "succeeded" | "failed" | "unchanged";
+        readonly status: "idle" | "running" | "failed" | "queued" | "succeeded" | "unchanged";
         readonly startedAt: string | null;
         readonly finishedAt: string | null;
         readonly message: string | null;

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

@@ -214,7 +214,7 @@ export declare const makeT3Orchestration: () => Effect.Effect<{
         readonly auth: {
             readonly policy: "desktop-managed-local" | "loopback-browser" | "remote-reachable" | "unsafe-no-auth";
             readonly bootstrapMethods: readonly ("desktop-bootstrap" | "one-time-token")[];
-            readonly sessionMethods: readonly ("browser-session-cookie" | "bearer-access-token")[];
+            readonly sessionMethods: readonly ("browser-session-cookie" | "bearer-access-token" | "dpop-access-token")[];
             readonly sessionCookieName: string;
         };
         readonly cwd: string;
@@ -332,7 +332,7 @@ export declare const makeT3Orchestration: () => Effect.Effect<{
                 readonly message: string | null;
             };
             readonly updateState?: {
-                readonly status: "idle" | "running" | "queued" | "succeeded" | "failed" | "unchanged";
+                readonly status: "idle" | "running" | "failed" | "queued" | "succeeded" | "unchanged";
                 readonly startedAt: string | null;
                 readonly finishedAt: string | null;
                 readonly message: string | null;
@@ -490,7 +490,7 @@ export declare const makeT3Orchestration: () => Effect.Effect<{
                 readonly message: string | null;
             };
             readonly updateState?: {
-                readonly status: "idle" | "running" | "queued" | "succeeded" | "failed" | "unchanged";
+                readonly status: "idle" | "running" | "failed" | "queued" | "succeeded" | "unchanged";
                 readonly startedAt: string | null;
                 readonly finishedAt: string | null;
                 readonly message: string | null;

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

@@ -2055,7 +2055,7 @@ export declare const makeT3RpcLayer: () => Effect.Effect<{
             readonly auth: {
                 readonly policy: "desktop-managed-local" | "loopback-browser" | "remote-reachable" | "unsafe-no-auth";
                 readonly bootstrapMethods: readonly ("desktop-bootstrap" | "one-time-token")[];
-                readonly sessionMethods: readonly ("browser-session-cookie" | "bearer-access-token")[];
+                readonly sessionMethods: readonly ("browser-session-cookie" | "bearer-access-token" | "dpop-access-token")[];
                 readonly sessionCookieName: string;
             };
             readonly cwd: string;
@@ -2173,7 +2173,7 @@ export declare const makeT3RpcLayer: () => Effect.Effect<{
                     readonly message: string | null;
                 };
                 readonly updateState?: {
-                    readonly status: "idle" | "running" | "queued" | "succeeded" | "failed" | "unchanged";
+                    readonly status: "idle" | "running" | "failed" | "queued" | "succeeded" | "unchanged";
                     readonly startedAt: string | null;
                     readonly finishedAt: string | null;
                     readonly message: string | null;
@@ -2331,7 +2331,7 @@ export declare const makeT3RpcLayer: () => Effect.Effect<{
                     readonly message: string | null;
                 };
                 readonly updateState?: {
-                    readonly status: "idle" | "running" | "queued" | "succeeded" | "failed" | "unchanged";
+                    readonly status: "idle" | "running" | "failed" | "queued" | "succeeded" | "unchanged";
                     readonly startedAt: string | null;
                     readonly finishedAt: string | null;
                     readonly message: string | null;
@@ -4389,7 +4389,7 @@ export declare const makeT3RpcLayer: () => Effect.Effect<{
             readonly auth: {
                 readonly policy: "desktop-managed-local" | "loopback-browser" | "remote-reachable" | "unsafe-no-auth";
                 readonly bootstrapMethods: readonly ("desktop-bootstrap" | "one-time-token")[];
-                readonly sessionMethods: readonly ("browser-session-cookie" | "bearer-access-token")[];
+                readonly sessionMethods: readonly ("browser-session-cookie" | "bearer-access-token" | "dpop-access-token")[];
                 readonly sessionCookieName: string;
             };
             readonly cwd: string;
@@ -4507,7 +4507,7 @@ export declare const makeT3RpcLayer: () => Effect.Effect<{
                     readonly message: string | null;
                 };
                 readonly updateState?: {
-                    readonly status: "idle" | "running" | "queued" | "succeeded" | "failed" | "unchanged";
+                    readonly status: "idle" | "running" | "failed" | "queued" | "succeeded" | "unchanged";
                     readonly startedAt: string | null;
                     readonly finishedAt: string | null;
                     readonly message: string | null;
@@ -4665,7 +4665,7 @@ export declare const makeT3RpcLayer: () => Effect.Effect<{
                     readonly message: string | null;
                 };
                 readonly updateState?: {
-                    readonly status: "idle" | "running" | "queued" | "succeeded" | "failed" | "unchanged";
+                    readonly status: "idle" | "running" | "failed" | "queued" | "succeeded" | "unchanged";
                     readonly startedAt: string | null;
                     readonly finishedAt: string | null;
                     readonly message: string | null;

package/dist/src/rpc/ws-group.d.ts

@@ -106,7 +106,7 @@ export declare const CliServerConfig: Schema.Union<readonly [Schema.Struct<{
     readonly auth: Schema.Struct<{
         readonly policy: Schema.Literals<readonly ["desktop-managed-local", "loopback-browser", "remote-reachable", "unsafe-no-auth"]>;
         readonly bootstrapMethods: Schema.$Array<Schema.Literals<readonly ["desktop-bootstrap", "one-time-token"]>>;
-        readonly sessionMethods: Schema.$Array<Schema.Literals<readonly ["browser-session-cookie", "bearer-access-token"]>>;
+        readonly sessionMethods: Schema.$Array<Schema.Literals<readonly ["browser-session-cookie", "bearer-access-token", "dpop-access-token"]>>;
         readonly sessionCookieName: Schema.decodeTo<Schema.String, Schema.String, never, never>;
     }>;
     readonly cwd: Schema.decodeTo<Schema.String, Schema.String, never, never>;
@@ -413,7 +413,7 @@ export declare const WsServerGetConfigRpc: Rpc.Rpc<"server.getConfig", Schema.St
     readonly auth: Schema.Struct<{
         readonly policy: Schema.Literals<readonly ["desktop-managed-local", "loopback-browser", "remote-reachable", "unsafe-no-auth"]>;
         readonly bootstrapMethods: Schema.$Array<Schema.Literals<readonly ["desktop-bootstrap", "one-time-token"]>>;
-        readonly sessionMethods: Schema.$Array<Schema.Literals<readonly ["browser-session-cookie", "bearer-access-token"]>>;
+        readonly sessionMethods: Schema.$Array<Schema.Literals<readonly ["browser-session-cookie", "bearer-access-token", "dpop-access-token"]>>;
         readonly sessionCookieName: Schema.decodeTo<Schema.String, Schema.String, never, never>;
     }>;
     readonly cwd: Schema.decodeTo<Schema.String, Schema.String, never, never>;
@@ -1945,7 +1945,7 @@ export declare const CliWsRpcGroup: RpcGroup.RpcGroup<Rpc.Rpc<"orchestration.dis
     readonly auth: Schema.Struct<{
         readonly policy: Schema.Literals<readonly ["desktop-managed-local", "loopback-browser", "remote-reachable", "unsafe-no-auth"]>;
         readonly bootstrapMethods: Schema.$Array<Schema.Literals<readonly ["desktop-bootstrap", "one-time-token"]>>;
-        readonly sessionMethods: Schema.$Array<Schema.Literals<readonly ["browser-session-cookie", "bearer-access-token"]>>;
+        readonly sessionMethods: Schema.$Array<Schema.Literals<readonly ["browser-session-cookie", "bearer-access-token", "dpop-access-token"]>>;
         readonly sessionCookieName: Schema.decodeTo<Schema.String, Schema.String, never, never>;
     }>;
     readonly cwd: Schema.decodeTo<Schema.String, Schema.String, never, never>;

package/dist/src/runtime.d.ts

@@ -1,3 +1,3 @@
 import * as Layer from "effect/Layer";
-export declare const AuthAppLayer: Layer.Layer<import("./config/service.ts").T3Config | import("./auth/service.ts").T3Auth, never, import("./environment/service.ts").Environment | import("effect/Path").Path | import("effect/unstable/process/ChildProcessSpawner").ChildProcessSpawner | import("effect/FileSystem").FileSystem>;
-export declare const AppLayer: Layer.Layer<import("./index.ts").T3Application | import("./config/service.ts").T3Config | import("./auth/service.ts").T3Auth | import("./orchestration/service.ts").T3Orchestration | import("./rpc/service.ts").T3Rpc, never, import("./environment/service.ts").Environment | import("effect/Path").Path | import("effect/unstable/process/ChildProcessSpawner").ChildProcessSpawner | import("effect/FileSystem").FileSystem | import("effect/Crypto").Crypto>;
+export declare const AuthAppLayer: Layer.Layer<import("./config/service.ts").T3Config | import("./auth/service.ts").T3Auth, never, import("./environment/service.ts").Environment | import("effect/Path").Path | import("effect/FileSystem").FileSystem | import("effect/Crypto").Crypto>;
+export declare const AppLayer: Layer.Layer<import("./index.ts").T3Application | import("./config/service.ts").T3Config | import("./auth/service.ts").T3Auth | import("./orchestration/service.ts").T3Orchestration | import("./rpc/service.ts").T3Rpc, never, import("./environment/service.ts").Environment | import("effect/Path").Path | import("effect/FileSystem").FileSystem | import("effect/Crypto").Crypto>;

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

@@ -0,0 +1,10 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Scope from "effect/Scope";
+import * as Reactivity from "effect/unstable/reactivity/Reactivity";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+import { SqlError } from "effect/unstable/sql/SqlError";
+import { SqlClientFactory, type SqliteClientConfig } from "./service.ts";
+export declare const makeNodeSqliteClient: (config: SqliteClientConfig) => Effect.Effect<SqlClient.SqlClient, SqlError, Scope.Scope | Reactivity.Reactivity>;
+export declare const NodeSqliteClientLive: (config: SqliteClientConfig) => Layer.Layer<SqlClient.SqlClient, SqlError, never>;
+export declare const NodeSqlClientFactoryLive: Layer.Layer<SqlClientFactory, never, never>;

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

@@ -0,0 +1,17 @@
+import type * as Effect from "effect/Effect";
+import * as Context from "effect/Context";
+import type * as Scope from "effect/Scope";
+import type * as SqlClient from "effect/unstable/sql/SqlClient";
+import type { SqlError } from "effect/unstable/sql/SqlError";
+export type SqliteClientConfig = {
+    readonly filename: string;
+    readonly transformResultNames?: ((str: string) => string) | undefined;
+    readonly transformQueryNames?: ((str: string) => string) | undefined;
+};
+export type SqlClientFactoryShape = {
+    readonly sqliteClient: (config: SqliteClientConfig) => Effect.Effect<SqlClient.SqlClient, SqlError, Scope.Scope>;
+};
+declare const SqlClientFactory_base: Context.ServiceClass<SqlClientFactory, "t3cli/SqlClientFactory", SqlClientFactoryShape>;
+export declare class SqlClientFactory extends SqlClientFactory_base {
+}
+export {};