t3code-cli 0.13.0 → 0.14.1

package/dist/src/config/credential/env.d.ts

@@ -1,3 +0,0 @@
-import * as Option from "effect/Option";
-import type { T3CliEnvShape } from "../env/env.ts";
-export declare function credentialTokenFromEnv(t3CliEnv: Pick<T3CliEnvShape, "t3codeToken">): Option.Option<string>;

package/dist/src/config/credential/error.d.ts

@@ -1,8 +0,0 @@
-import * as Schema from "effect/Schema";
-declare const CredentialCipherError_base: Schema.Class<CredentialCipherError, Schema.TaggedStruct<"CredentialCipherError", {
-    readonly operation: Schema.Literals<readonly ["encrypt", "decrypt"]>;
-    readonly cause: Schema.Defect;
-}>, import("effect/Cause").YieldableError>;
-export declare class CredentialCipherError extends CredentialCipherError_base {
-}
-export {};

package/dist/src/config/credential/index.d.ts

@@ -1,6 +0,0 @@
-export * as Service from "./service.ts";
-export * as Cipher from "./cipher.ts";
-export * as CipherNode from "./cipher-node.ts";
-export * as CipherWeb from "./cipher-web.ts";
-export { credentialTokenFromEnv } from "./env.ts";
-export { CredentialCipherError } from "./error.ts";

package/dist/src/config/credential/service.d.ts

@@ -1,34 +0,0 @@
-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 { T3CredentialCipher } from "./cipher.ts";
-import type { EncryptedToken } from "../persist/schema.ts";
-import { ConfigError } from "../error.ts";
-import { T3MasterKeyKeystoreFactory } from "../keystore/service.ts";
-export type CredentialEncryptInput = {
-    readonly environmentName: string;
-    readonly url: string;
-    readonly local: boolean;
-    readonly token: string;
-};
-export type CredentialDecryptInput = {
-    readonly environmentName: string;
-    readonly url: string;
-    readonly local: boolean;
-    readonly token: EncryptedToken;
-};
-declare const T3CredentialCrypto_base: Context.ServiceClass<T3CredentialCrypto, "t3cli/T3CredentialCrypto", {
-    readonly encrypt: (input: CredentialEncryptInput) => Effect.Effect<EncryptedToken, ConfigError>;
-    readonly decrypt: (input: CredentialDecryptInput) => Effect.Effect<string, ConfigError>;
-}>;
-export declare class T3CredentialCrypto extends T3CredentialCrypto_base {
-}
-export declare const make: () => Effect.Effect<{
-    encrypt: (input: CredentialEncryptInput) => Effect.Effect<EncryptedToken, ConfigError>;
-    decrypt: (input: CredentialDecryptInput) => Effect.Effect<string, ConfigError>;
-}, ConfigError, Crypto.Crypto | FileSystem.FileSystem | Path.Path | T3CredentialCipher | T3MasterKeyKeystoreFactory>;
-export declare const layer: Layer.Layer<T3CredentialCrypto, ConfigError, Crypto.Crypto | FileSystem.FileSystem | Path.Path | T3CredentialCipher | T3MasterKeyKeystoreFactory>;
-export {};

package/dist/src/config/env/env.d.ts

@@ -1,55 +0,0 @@
-import * as Config from "effect/Config";
-import * as Effect from "effect/Effect";
-import * as Option from "effect/Option";
-import type * as Redacted from "effect/Redacted";
-export type T3CliEnvScope = {
-    readonly t3codeProjectRoot?: string | undefined;
-    readonly t3codeProjectId?: string | undefined;
-    readonly t3codeWorktreePath?: string | undefined;
-    readonly t3codeThreadId?: string | undefined;
-};
-export type T3CliEnvShape = {
-    readonly home: Option.Option<string>;
-    readonly xdgConfigHome: Option.Option<string>;
-    readonly t3cliEnv: Option.Option<string>;
-    readonly t3codeUrl: Option.Option<string>;
-    readonly t3codeToken: Option.Option<Redacted.Redacted>;
-    readonly t3codeHome: Option.Option<string>;
-    readonly term: Option.Option<string>;
-    readonly ci: boolean;
-    readonly codexCi: boolean;
-    readonly codexThreadId: boolean;
-    readonly t3cliAgent: boolean;
-    readonly scope: T3CliEnvScope;
-};
-export declare const T3CliEnvConfig: Config.Config<{
-    home: Option.Option<string>;
-    xdgConfigHome: Option.Option<string>;
-    t3cliEnv: Option.Option<string>;
-    t3codeUrl: Option.Option<string>;
-    t3codeToken: Option.Option<Redacted.Redacted<string>>;
-    t3codeHome: Option.Option<string>;
-    t3codeProjectRoot: Option.Option<string>;
-    t3codeProjectId: Option.Option<string>;
-    t3codeWorktreePath: Option.Option<string>;
-    t3codeThreadId: Option.Option<string>;
-    term: Option.Option<string>;
-    ci: boolean;
-    codexCi: boolean;
-    codexThreadId: boolean;
-    t3cliAgent: boolean;
-}>;
-export declare const loadT3CliEnv: Effect.Effect<{
-    home: Option.Option<string>;
-    xdgConfigHome: Option.Option<string>;
-    t3cliEnv: Option.Option<string>;
-    t3codeUrl: Option.Option<string>;
-    t3codeToken: Option.Option<Redacted.Redacted<string>>;
-    t3codeHome: Option.Option<string>;
-    term: Option.Option<string>;
-    ci: boolean;
-    codexCi: boolean;
-    codexThreadId: boolean;
-    t3cliAgent: boolean;
-    scope: T3CliEnvScope;
-}, Config.ConfigError, never>;

package/dist/src/config/env/index.d.ts

@@ -1,2 +0,0 @@
-export { loadT3CliEnv, T3CliEnvConfig, type T3CliEnvScope, type T3CliEnvShape } from "./env.ts";
-export { resolveT3BaseDir, type T3Layout } from "./layout.ts";

package/dist/src/config/env/layout.d.ts

@@ -1,11 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Path from "effect/Path";
-export type T3Layout = {
-    readonly cwd: string;
-    readonly homeDir: string;
-    readonly t3codeHome?: string | undefined;
-};
-export declare const resolveT3BaseDir: (input: {
-    readonly layout: T3Layout;
-    readonly baseDir?: string | undefined;
-}) => Effect.Effect<string, never, Path.Path>;

package/dist/src/config/environment-name/index.d.ts

@@ -1 +0,0 @@
-export { defaultEnvironmentNameForLocal, defaultEnvironmentNameFromUrl, migrateV1EnvironmentName, slugifyEnvironmentName, validateEnvironmentName, } from "./name.ts";

package/dist/src/config/environment-name/name.d.ts

@@ -1,10 +0,0 @@
-import * as Effect from "effect/Effect";
-import { ConfigError } from "../error.ts";
-export declare function slugifyEnvironmentName(value: string): string;
-export declare function validateEnvironmentName(name: string): Effect.Effect<void, never, never> | Effect.Effect<never, ConfigError, never>;
-export declare function defaultEnvironmentNameFromUrl(url: string): Effect.Effect<string, ConfigError, never>;
-export declare function defaultEnvironmentNameForLocal(): "local";
-export declare function migrateV1EnvironmentName(input: {
-    readonly url?: string;
-    readonly local?: boolean;
-}): Effect.Effect<string, ConfigError, never>;

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

@@ -1,11 +0,0 @@
-import * as Schema from "effect/Schema";
-import { PlatformError } from "effect/PlatformError";
-declare const ConfigError_base: Schema.Class<ConfigError, Schema.TaggedStruct<"ConfigError", {
-    readonly message: Schema.String;
-    readonly cause: Schema.optionalKey<Schema.Union<readonly [Schema.instanceOf<PlatformError, unknown>, Schema.instanceOf<Schema.SchemaError, unknown>, Schema.Defect]>>;
-}>, import("effect/Cause").YieldableError>;
-export declare class ConfigError extends ConfigError_base {
-}
-export type ConfigServiceError = ConfigError;
-export declare function isPlatformNotFoundError(error: PlatformError): boolean;
-export {};

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

@@ -1,10 +0,0 @@
-export * as Config from "./config.ts";
-export type { EncryptedConfig, EncryptedToken, EnvironmentSummary, ResolvedConfig, UpsertEnvironmentInput, } from "./types.ts";
-export { ConfigError, type ConfigServiceError } from "./error.ts";
-export * as Credential from "./credential/index.ts";
-export * as Keystore from "./keystore/index.ts";
-export * as Selection from "./selection/index.ts";
-export * as Env from "./env/index.ts";
-export * as Paths from "./paths/index.ts";
-export * as Url from "./url/index.ts";
-export * as EnvironmentName from "./environment-name/index.ts";

package/dist/src/config/keystore/error.d.ts

@@ -1,8 +0,0 @@
-import * as Schema from "effect/Schema";
-declare const KeystoreUnavailableError_base: Schema.Class<KeystoreUnavailableError, Schema.TaggedStruct<"KeystoreUnavailableError", {
-    readonly reason: Schema.Literals<readonly ["module-not-found", "backend-unavailable"]>;
-    readonly cause: Schema.Defect;
-}>, import("effect/Cause").YieldableError>;
-export declare class KeystoreUnavailableError extends KeystoreUnavailableError_base {
-}
-export {};

package/dist/src/config/keystore/file.d.ts

@@ -1,9 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as FileSystem from "effect/FileSystem";
-import * as Path from "effect/Path";
-import { ConfigError } from "../error.ts";
-import { type MasterKeyReadResult } from "./service.ts";
-export declare const makeFileKeystore: () => Effect.Effect<{
-    read: () => Effect.Effect<MasterKeyReadResult, ConfigError>;
-    write: (key: Uint8Array) => Effect.Effect<void, ConfigError>;
-}, ConfigError, FileSystem.FileSystem | Path.Path>;

package/dist/src/config/keystore/index.d.ts

@@ -1,4 +0,0 @@
-export * as Service from "./service.ts";
-export { KeystoreUnavailableError } from "./error.ts";
-export * as KeyringNode from "./keyring-node.ts";
-export * as File from "./file.ts";

package/dist/src/config/keystore/keyring-node.d.ts

@@ -1,4 +0,0 @@
-import * as Layer from "effect/Layer";
-import { T3MasterKeyKeystoreFactory, type MasterKeyReadResult } from "./service.ts";
-export declare function parseKeyringPassword(password: string | null): MasterKeyReadResult;
-export declare const layerNode: Layer.Layer<T3MasterKeyKeystoreFactory, never, never>;

package/dist/src/config/keystore/service.d.ts

@@ -1,33 +0,0 @@
-import * as Context from "effect/Context";
-import type * as Effect from "effect/Effect";
-import type { ConfigError } from "../error.ts";
-import type { KeystoreUnavailableError } from "./error.ts";
-export declare const masterKeyByteLength = 32;
-export type MasterKeyReadResult = {
-    readonly kind: "missing";
-} | {
-    readonly kind: "present";
-    readonly key: Uint8Array;
-} | {
-    readonly kind: "corrupt";
-    readonly message: string;
-} | {
-    readonly kind: "unavailable";
-    readonly message: string;
-};
-export type MasterKeyKeystore = {
-    readonly read: () => Effect.Effect<MasterKeyReadResult, ConfigError>;
-    readonly write: (key: Uint8Array) => Effect.Effect<void, ConfigError | KeystoreUnavailableError>;
-};
-declare const T3MasterKeyKeystoreFactory_base: Context.ServiceClass<T3MasterKeyKeystoreFactory, "t3cli/T3MasterKeyKeystoreFactory", {
-    readonly make: () => Effect.Effect<MasterKeyKeystore, KeystoreUnavailableError>;
-}>;
-export declare class T3MasterKeyKeystoreFactory extends T3MasterKeyKeystoreFactory_base {
-}
-export declare function shouldUseFileKeystoreForRead(result: MasterKeyReadResult): result is {
-    readonly kind: "missing";
-} | {
-    readonly kind: "unavailable";
-    readonly message: string;
-};
-export {};

package/dist/src/config/paths/index.d.ts

@@ -1 +0,0 @@
-export { resolveConfigFilePath, resolveKeyFilePath, resolveT3cliConfigDir } from "./paths.ts";

package/dist/src/config/paths/paths.d.ts

@@ -1,6 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Path from "effect/Path";
-import { ConfigError } from "../error.ts";
-export declare const resolveT3cliConfigDir: () => Effect.Effect<string, ConfigError, Path.Path>;
-export declare const resolveConfigFilePath: () => Effect.Effect<string, ConfigError, Path.Path>;
-export declare const resolveKeyFilePath: () => Effect.Effect<string, ConfigError, Path.Path>;

package/dist/src/config/persist/file-mode.d.ts

@@ -1,4 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as FileSystem from "effect/FileSystem";
-import { ConfigError } from "../error.ts";
-export declare const hardenPrivateFileMode: (filePath: string, label: "config" | "credential key") => Effect.Effect<void, ConfigError, FileSystem.FileSystem>;

package/dist/src/config/persist/migration.d.ts

@@ -1,68 +0,0 @@
-import * as Effect from "effect/Effect";
-import { T3CredentialCrypto } from "../credential/service.ts";
-import { ConfigError } from "../error.ts";
-import type { EncryptedConfig } from "../types.ts";
-export declare const emptyEncryptedConfig: () => EncryptedConfig;
-export declare const readEncryptedConfigFromValue: (value: unknown) => Effect.Effect<{
-    config: {
-        readonly version: 2;
-        readonly default?: string;
-        readonly environments: {
-            readonly [x: string]: {
-                readonly url: string;
-                readonly local: boolean;
-                readonly token: {
-                    readonly kind: "encrypted";
-                    readonly alg: "aes-256-gcm";
-                    readonly key: "default";
-                    readonly nonce: string;
-                    readonly ciphertext: string;
-                    readonly tag: string;
-                };
-            };
-        };
-    };
-    migratedFromV1: false;
-} | {
-    config: {
-        readonly version: 2;
-        readonly default?: string;
-        readonly environments: {
-            readonly [x: string]: {
-                readonly url: string;
-                readonly local: boolean;
-                readonly token: {
-                    readonly kind: "encrypted";
-                    readonly alg: "aes-256-gcm";
-                    readonly key: "default";
-                    readonly nonce: string;
-                    readonly ciphertext: string;
-                    readonly tag: string;
-                };
-            };
-        };
-    };
-    migratedFromV1: true;
-}, ConfigError, T3CredentialCrypto>;
-export declare const migrateV1FileToEncrypted: (config: {
-    readonly url?: string;
-    readonly token?: string;
-    readonly local?: boolean;
-}) => Effect.Effect<{
-    readonly version: 2;
-    readonly default?: string;
-    readonly environments: {
-        readonly [x: string]: {
-            readonly url: string;
-            readonly local: boolean;
-            readonly token: {
-                readonly kind: "encrypted";
-                readonly alg: "aes-256-gcm";
-                readonly key: "default";
-                readonly nonce: string;
-                readonly ciphertext: string;
-                readonly tag: string;
-            };
-        };
-    };
-}, ConfigError, T3CredentialCrypto>;

package/dist/src/config/persist/persist.d.ts

@@ -1,40 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as FileSystem from "effect/FileSystem";
-import * as Path from "effect/Path";
-import { ConfigError } from "../error.ts";
-export declare const readEncryptedConfigFile: () => Effect.Effect<{
-    readonly version: 2;
-    readonly default?: string;
-    readonly environments: {
-        readonly [x: string]: {
-            readonly url: string;
-            readonly local: boolean;
-            readonly token: {
-                readonly kind: "encrypted";
-                readonly alg: "aes-256-gcm";
-                readonly key: "default";
-                readonly nonce: string;
-                readonly ciphertext: string;
-                readonly tag: string;
-            };
-        };
-    };
-}, ConfigError, FileSystem.FileSystem | Path.Path | import("../credential/service.ts").T3CredentialCrypto>;
-export declare const writeEncryptedConfigFile: (config: {
-    readonly version: 2;
-    readonly default?: string;
-    readonly environments: {
-        readonly [x: string]: {
-            readonly url: string;
-            readonly local: boolean;
-            readonly token: {
-                readonly kind: "encrypted";
-                readonly alg: "aes-256-gcm";
-                readonly key: "default";
-                readonly nonce: string;
-                readonly ciphertext: string;
-                readonly tag: string;
-            };
-        };
-    };
-}) => Effect.Effect<void, ConfigError, FileSystem.FileSystem | Path.Path>;

package/dist/src/config/persist/schema.d.ts

@@ -1,68 +0,0 @@
-import * as Schema from "effect/Schema";
-export declare const EncryptedTokenSchema: Schema.Struct<{
-    readonly kind: Schema.Literal<"encrypted">;
-    readonly alg: Schema.Literal<"aes-256-gcm">;
-    readonly key: Schema.Literal<"default">;
-    readonly nonce: Schema.String;
-    readonly ciphertext: Schema.String;
-    readonly tag: Schema.String;
-}>;
-export declare const StoredEnvironmentFileSchema: Schema.Struct<{
-    readonly url: Schema.String;
-    readonly local: Schema.Boolean;
-    readonly token: Schema.Struct<{
-        readonly kind: Schema.Literal<"encrypted">;
-        readonly alg: Schema.Literal<"aes-256-gcm">;
-        readonly key: Schema.Literal<"default">;
-        readonly nonce: Schema.String;
-        readonly ciphertext: Schema.String;
-        readonly tag: Schema.String;
-    }>;
-}>;
-export declare const StoredConfigV2FileSchema: Schema.Struct<{
-    readonly version: Schema.Literal<2>;
-    readonly default: Schema.optionalKey<Schema.String>;
-    readonly environments: Schema.$Record<Schema.String, Schema.Struct<{
-        readonly url: Schema.String;
-        readonly local: Schema.Boolean;
-        readonly token: Schema.Struct<{
-            readonly kind: Schema.Literal<"encrypted">;
-            readonly alg: Schema.Literal<"aes-256-gcm">;
-            readonly key: Schema.Literal<"default">;
-            readonly nonce: Schema.String;
-            readonly ciphertext: Schema.String;
-            readonly tag: Schema.String;
-        }>;
-    }>>;
-}>;
-export declare const StoredConfigV1FileSchema: Schema.Struct<{
-    readonly url: Schema.optionalKey<Schema.String>;
-    readonly token: Schema.optionalKey<Schema.String>;
-    readonly local: Schema.optionalKey<Schema.Boolean>;
-}>;
-export type EncryptedToken = Schema.Schema.Type<typeof EncryptedTokenSchema>;
-export type StoredEnvironmentFile = Schema.Schema.Type<typeof StoredEnvironmentFileSchema>;
-export type StoredConfigV2File = Schema.Schema.Type<typeof StoredConfigV2FileSchema>;
-export type StoredConfigV1File = Schema.Schema.Type<typeof StoredConfigV1FileSchema>;
-export declare const StoredConfigV1FileJson: Schema.fromJsonString<Schema.Struct<{
-    readonly url: Schema.optionalKey<Schema.String>;
-    readonly token: Schema.optionalKey<Schema.String>;
-    readonly local: Schema.optionalKey<Schema.Boolean>;
-}>>;
-export declare const StoredConfigV2FileJson: Schema.fromJsonString<Schema.Struct<{
-    readonly version: Schema.Literal<2>;
-    readonly default: Schema.optionalKey<Schema.String>;
-    readonly environments: Schema.$Record<Schema.String, Schema.Struct<{
-        readonly url: Schema.String;
-        readonly local: Schema.Boolean;
-        readonly token: Schema.Struct<{
-            readonly kind: Schema.Literal<"encrypted">;
-            readonly alg: Schema.Literal<"aes-256-gcm">;
-            readonly key: Schema.Literal<"default">;
-            readonly nonce: Schema.String;
-            readonly ciphertext: Schema.String;
-            readonly tag: Schema.String;
-        }>;
-    }>>;
-}>>;
-export declare const UnknownConfigFileJson: Schema.UnknownFromJsonString;

package/dist/src/config/resolve/resolve.d.ts

@@ -1,40 +0,0 @@
-import * as Effect from "effect/Effect";
-import { ConfigError } from "../error.ts";
-import type { EncryptedConfig } from "../types.ts";
-export type ResolveSelectionInput = {
-    readonly selectedEnvironment?: string | undefined;
-    readonly defaultEnvironment?: string | undefined;
-};
-export declare function selectEnvironmentName(input: ResolveSelectionInput): string | undefined;
-export type ResolveCredentialInput = {
-    readonly envUrl?: string | undefined;
-    readonly envToken?: string | undefined;
-};
-export declare function validateCredentialEnvVars(input: ResolveCredentialInput): Effect.Effect<void, never, never> | Effect.Effect<never, ConfigError, never>;
-export declare function resolveDefaultForUpsert(encrypted: EncryptedConfig, environmentName: string, makeDefault?: boolean): string | undefined;
-export declare function summarizeEnvironments(encrypted: EncryptedConfig): {
-    name: string;
-    url: string;
-    local: boolean;
-    default: boolean;
-}[];
-export declare function buildResolvedConfigFromEnv(input: {
-    readonly envUrl: string;
-    readonly envToken: string;
-}): Effect.Effect<{
-    url: string;
-    token: string;
-    source: "env";
-    local: false;
-}, ConfigError, never>;
-export declare function buildResolvedConfigFromStored(input: {
-    readonly selectedName: string;
-    readonly token: string;
-    readonly encrypted: EncryptedConfig;
-}): Effect.Effect<{
-    url: string;
-    token: string;
-    source: "config";
-    local: boolean;
-    environment: string;
-}, ConfigError, never>;

package/dist/src/config/selection/index.d.ts

@@ -1 +0,0 @@
-export * as Service from "./service.ts";

package/dist/src/config/selection/resolve.d.ts

@@ -1,4 +0,0 @@
-export declare function resolveConfiguredEnvironment(input: {
-    readonly cliFlag?: string | undefined;
-    readonly t3cliEnv?: string | undefined;
-}): string | undefined;

package/dist/src/config/selection/service.d.ts

@@ -1,10 +0,0 @@
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-declare const T3ConfigSelection_base: Context.ServiceClass<T3ConfigSelection, "t3cli/T3ConfigSelection", {
-    readonly getSelectedEnvironment: () => Effect.Effect<string | undefined>;
-}>;
-export declare class T3ConfigSelection extends T3ConfigSelection_base {
-}
-export declare const layer: Layer.Layer<T3ConfigSelection, import("effect/Config").ConfigError, never>;
-export {};

package/dist/src/config/types.d.ts

@@ -1,36 +0,0 @@
-import type { EncryptedToken, StoredConfigV2File, StoredEnvironmentFile } from "./persist/schema.ts";
-export type EncryptedEnvironment = StoredEnvironmentFile;
-export type EncryptedConfig = StoredConfigV2File;
-export type DecryptedEnvironment = {
-    readonly url: string;
-    readonly local: boolean;
-    readonly token: string;
-};
-export type DecryptedConfig = {
-    readonly version: 2;
-    readonly default?: string;
-    readonly environments: Readonly<Record<string, DecryptedEnvironment>>;
-};
-export type EnvironmentSummary = {
-    readonly name: string;
-    readonly url: string;
-    readonly local: boolean;
-    readonly default: boolean;
-};
-export type ResolvedConfig = {
-    readonly url: string;
-    readonly token: string;
-    readonly source: "env" | "config";
-    readonly local: boolean;
-    readonly environment?: string;
-};
-export type UpsertEnvironmentInput = {
-    readonly name: string;
-    readonly url: string;
-    readonly token: string;
-    readonly local: boolean;
-    readonly makeDefault?: boolean;
-};
-export type StoredConfig = DecryptedConfig;
-export type StoredEnvironment = DecryptedEnvironment;
-export type { EncryptedToken };

package/dist/src/config/url/error.d.ts

@@ -1,10 +0,0 @@
-import * as Cause from "effect/Cause";
-import * as Schema from "effect/Schema";
-declare const UrlError_base: Schema.Class<UrlError, Schema.TaggedStruct<"UrlError", {
-    readonly message: Schema.String;
-    readonly protocol: Schema.optionalKey<Schema.String>;
-    readonly cause: Schema.optionalKey<Schema.instanceOf<Cause.IllegalArgumentError, Cause.IllegalArgumentError>>;
-}>, Cause.YieldableError>;
-export declare class UrlError extends UrlError_base {
-}
-export {};

package/dist/src/config/url/index.d.ts

@@ -1,2 +0,0 @@
-export { normalizeHttpBaseUrl, toWebSocketBaseUrl, toHttpEndpointUrl, toWebSocketEndpointUrl, } from "./url.ts";
-export { UrlError } from "./error.ts";

package/dist/src/config/url/url.d.ts

@@ -1,6 +0,0 @@
-import * as Effect from "effect/Effect";
-import { UrlError } from "./error.ts";
-export declare function normalizeHttpBaseUrl(value: string): Effect.Effect<string, UrlError, never>;
-export declare function toWebSocketBaseUrl(httpBaseUrl: string): Effect.Effect<string, UrlError, never>;
-export declare function toHttpEndpointUrl(httpBaseUrl: string, pathname: string): Effect.Effect<string, UrlError, never>;
-export declare function toWebSocketEndpointUrl(httpBaseUrl: string, pathname: string): Effect.Effect<string, UrlError, never>;

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

@@ -1,10 +0,0 @@
-import * as Schema from "effect/Schema";
-import { ConfigError } from "../config/error.ts";
-import { UrlError } from "../config/url/error.ts";
-declare const T3CodeConnectionError_base: Schema.Class<T3CodeConnectionError, Schema.TaggedStruct<"T3CodeConnectionError", {
-    readonly message: Schema.String;
-    readonly cause: Schema.Union<readonly [typeof ConfigError, typeof UrlError]>;
-}>, import("effect/Cause").YieldableError>;
-export declare class T3CodeConnectionError extends T3CodeConnectionError_base {
-}
-export {};

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

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

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

@@ -1,3 +0,0 @@
-import * as Layer from "effect/Layer";
-export declare function makeT3CodeRpcLayer(): Layer.Layer<import("../rpc/service.ts").T3Rpc, never, import("effect/unstable/http/HttpClient").HttpClient | import("./service.ts").T3CodeConnectionProvider | import("effect/unstable/socket/Socket").WebSocketConstructor>;
-export declare const T3CodeRpcLayer: Layer.Layer<import("../rpc/service.ts").T3Rpc, never, import("effect/unstable/http/HttpClient").HttpClient | import("./service.ts").T3CodeConnectionProvider | import("effect/unstable/socket/Socket").WebSocketConstructor>;

package/dist/src/connection/prepared.d.ts

@@ -1,14 +0,0 @@
-import { type ConnectionAttemptError, type PreparedConnection } from "@t3tools/client-runtime/connection";
-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 { T3CodeConnectionError } from "./error.ts";
-import { T3CodeConnectionProvider } from "./service.ts";
-declare const T3PreparedConnectionProvider_base: Context.ServiceClass<T3PreparedConnectionProvider, "t3cli/T3PreparedConnectionProvider", {
-    readonly get: Effect.Effect<PreparedConnection, ConnectionAttemptError | T3CodeConnectionError>;
-}>;
-export declare class T3PreparedConnectionProvider extends T3PreparedConnectionProvider_base {
-}
-export declare const T3PreparedConnectionProviderLive: Layer.Layer<T3PreparedConnectionProvider, never, HttpClient.HttpClient | T3CodeConnectionProvider>;
-export {};

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

@@ -1,13 +0,0 @@
-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";
-declare const T3CodeConnectionProvider_base: Context.ServiceClass<T3CodeConnectionProvider, "t3cli/T3CodeConnectionProvider", {
-    readonly get: Effect.Effect<T3CodeConnection, T3CodeConnectionError>;
-}>;
-export declare class T3CodeConnectionProvider extends T3CodeConnectionProvider_base {
-}
-export declare function makeT3CodeConnectionProvider(get: Effect.Effect<T3CodeConnection, T3CodeConnectionError>): T3CodeConnectionProvider["Service"];
-export declare function T3CodeConnectionProviderLive(connection: T3CodeConnection): Layer.Layer<T3CodeConnectionProvider, never, never>;
-export {};

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

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

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

@@ -1 +0,0 @@
-export type { OrchestrationMessage, OrchestrationProjectShell, OrchestrationShellSnapshot, OrchestrationThread, OrchestrationThreadShell, ServerProvider, } from "@t3tools/contracts";