t3code-cli 0.12.0 → 0.14.0

package/dist/cli.d.ts

@@ -0,0 +1,66 @@
+import { Fi as CliRuntime, Ii as layer$1, Un as T3CliEnvScope, Wn as T3CliEnvShape, fr as T3ConfigSelection } from "./shared.js";
+import * as Layer from "effect/Layer";
+import { Flag, GlobalFlag } from "effect/unstable/cli";
+//#region src/cli/flags.d.ts
+declare const projectFlag: Flag.Flag<import("effect/Option").Option<string>>;
+declare const threadFlag: Flag.Flag<import("effect/Option").Option<string>>;
+declare const worktreeFlag: Flag.Flag<import("effect/Option").Option<string>>;
+declare const projectPathFlag: Flag.Flag<string>;
+declare const formatFlag: Flag.Flag<"auto" | "human" | "json">;
+declare const threadFormatFlag: Flag.Flag<"auto" | "human" | "json" | "ndjson">;
+declare const waitFormatFlag: Flag.Flag<"auto" | "human" | "ndjson">;
+declare const modelFlags: {
+  readonly option: Flag.Flag<import("effect/Option").Option<Record<string, string>>>;
+  readonly reasoningEffort: Flag.Flag<import("effect/Option").Option<string>>;
+  readonly effort: Flag.Flag<import("effect/Option").Option<string>>;
+  readonly fastMode: Flag.Flag<import("effect/Option").Option<boolean>>;
+  readonly thinking: Flag.Flag<import("effect/Option").Option<boolean>>;
+};
+//#endregion
+//#region src/cli/env/flag.d.ts
+declare const cliEnvironmentSetting: GlobalFlag.Setting<"environment", import("effect/Option").Option<string>>;
+declare namespace selection_layer_d_exports {
+  export { layer };
+}
+declare const layer: Layer.Layer<T3ConfigSelection, import("effect/Config").ConfigError, never>;
+declare namespace index_d_exports {
+  export { selection_layer_d_exports as Selection, cliEnvironmentSetting };
+}
+declare namespace index_d_exports$1 {
+  export { CliRuntime, layer$1 as layer };
+}
+//#endregion
+//#region src/cli/scope/resolve.d.ts
+declare function resolveProjectRef(input: {
+  readonly value: string | undefined;
+  readonly scope: T3CliEnvScope;
+}): string | undefined;
+declare function resolveCommandProjectRef(input: {
+  readonly value: string | undefined;
+  readonly scope: T3CliEnvScope;
+  readonly cwd: string;
+  readonly isLocal?: boolean;
+}): string | undefined;
+declare function resolveWorktreePath(input: {
+  readonly value: string | undefined;
+  readonly scope: T3CliEnvScope;
+  readonly inferred?: string;
+}): string | undefined;
+declare function resolveThreadId(input: {
+  readonly value: string | undefined;
+  readonly scope: T3CliEnvScope;
+}): string | undefined;
+//#endregion
+//#region src/cli/format/output.d.ts
+declare const humanJsonFormatChoices: readonly ["auto", "human", "json"];
+declare const humanNdjsonFormatChoices: readonly ["auto", "human", "ndjson"];
+declare const humanJsonNdjsonFormatChoices: readonly ["auto", "human", "json", "ndjson"];
+type HumanJsonFormat = (typeof humanJsonFormatChoices)[number];
+type HumanNdjsonFormat = (typeof humanNdjsonFormatChoices)[number];
+type HumanJsonNdjsonFormat = (typeof humanJsonNdjsonFormatChoices)[number];
+declare function resolveOutputFormat<T extends "json" | "ndjson">(format: "auto" | "human" | T, cliRuntime: CliRuntime["Service"], t3CliEnv: T3CliEnvShape, nonHumanFormat: T): "human" | T;
+declare function canRenderLiveTerminal(cliRuntime: CliRuntime["Service"], t3CliEnv: T3CliEnvShape): boolean;
+declare function isInteractiveHumanTerminal(cliRuntime: CliRuntime["Service"], t3CliEnv: T3CliEnvShape): boolean;
+declare function isAgentEnvironment(t3CliEnv: T3CliEnvShape): boolean;
+//#endregion
+export { index_d_exports as Env, type HumanJsonFormat, type HumanJsonNdjsonFormat, type HumanNdjsonFormat, index_d_exports$1 as Runtime, canRenderLiveTerminal, formatFlag, humanJsonFormatChoices, humanJsonNdjsonFormatChoices, humanNdjsonFormatChoices, isAgentEnvironment, isInteractiveHumanTerminal, modelFlags, projectFlag, projectPathFlag, resolveCommandProjectRef, resolveOutputFormat, resolveProjectRef, resolveThreadId, resolveWorktreePath, threadFlag, threadFormatFlag, waitFormatFlag, worktreeFlag };

package/dist/cli.js

@@ -1,5 +1,5 @@
 import { n as __exportAll } from "./rolldown-runtime.js";
-import { $p as layer, Bm as isAgentEnvironment, Dm as projectFlag, Em as modelFlags, Hm as resolveOutputFormat, Im as canRenderLiveTerminal, Jp as resolveThreadId, Kp as resolveCommandProjectRef, Lm as humanJsonFormatChoices, Mm as threadFormatFlag, Nm as waitFormatFlag, Om as projectPathFlag, Pm as worktreeFlag, Qp as CliRuntime, Rm as humanJsonNdjsonFormatChoices, Tm as formatFlag, Vm as isInteractiveHumanTerminal, Wp as cliEnvironmentSetting, Yp as resolveWorktreePath, jm as threadFlag, mt as selection_layer_exports, qp as resolveProjectRef, zm as humanNdjsonFormatChoices } from "./shared.js";
+import { Ms as selection_layer_exports, SC as layer, Sw as resolveOutputFormat, _C as resolveThreadId, _w as humanJsonFormatChoices, aw as formatFlag, bw as isAgentEnvironment, cw as projectPathFlag, dw as threadFlag, fw as threadFormatFlag, gC as resolveProjectRef, gw as canRenderLiveTerminal, hC as resolveCommandProjectRef, mw as worktreeFlag, ow as modelFlags, pC as cliEnvironmentSetting, pw as waitFormatFlag, sw as projectFlag, vC as resolveWorktreePath, vw as humanJsonNdjsonFormatChoices, xC as CliRuntime, xw as isInteractiveHumanTerminal, yw as humanNdjsonFormatChoices } from "./shared.js";
 //#region src/cli/env/index.ts
 var env_exports = /* @__PURE__ */ __exportAll({
 	Selection: () => selection_layer_exports,

package/dist/client-runtime/authorization.d.ts

@@ -0,0 +1,2 @@
+import { Aa as RemoteEnvironmentAuthError, Ba as RemoteEnvironmentAuthInvalidJsonError, Fa as issueRemoteDpopWebSocketTicket, Ha as RemoteEnvironmentAuthUndeclaredStatusError, Ia as issueRemoteWebSocketTicket, La as resolveRemoteDpopWebSocketConnectionUrl, Ma as exchangeRemoteDpopAccessToken, Na as fetchRemoteDpopSessionState, Pa as fetchRemoteSessionState, Ra as resolveRemoteWebSocketConnectionUrl, Va as RemoteEnvironmentAuthTimeoutError, io as RemoteEnvironmentAuthorization, ja as bootstrapRemoteBearerSession, no as AuthorizedRemoteEnvironment, oo as tokenStore_d_exports, ro as RelayEnvironmentAuthorization, za as RemoteEnvironmentAuthFetchError } from "../shared.js";
+export { type AuthorizedRemoteEnvironment, type RelayEnvironmentAuthorization, RemoteEnvironmentAuthError, RemoteEnvironmentAuthFetchError, RemoteEnvironmentAuthInvalidJsonError, RemoteEnvironmentAuthTimeoutError, RemoteEnvironmentAuthUndeclaredStatusError, RemoteEnvironmentAuthorization, tokenStore_d_exports as TokenStore, bootstrapRemoteBearerSession, exchangeRemoteDpopAccessToken, fetchRemoteDpopSessionState, fetchRemoteSessionState, issueRemoteDpopWebSocketTicket, issueRemoteWebSocketTicket, resolveRemoteDpopWebSocketConnectionUrl, resolveRemoteWebSocketConnectionUrl };

package/dist/client-runtime/authorization.js

@@ -0,0 +1,2 @@
+import { Ao as RemoteEnvironmentAuthTimeoutError, Co as fetchRemoteSessionState, Do as resolveRemoteWebSocketConnectionUrl, Eo as resolveRemoteDpopWebSocketConnectionUrl, Ka as tokenStore_exports, Oo as RemoteEnvironmentAuthFetchError, So as fetchRemoteDpopSessionState, To as issueRemoteWebSocketTicket, Wa as RemoteEnvironmentAuthorization, bo as bootstrapRemoteBearerSession, jo as RemoteEnvironmentAuthUndeclaredStatusError, ko as RemoteEnvironmentAuthInvalidJsonError, wo as issueRemoteDpopWebSocketTicket, xo as exchangeRemoteDpopAccessToken } from "../shared.js";
+export { RemoteEnvironmentAuthFetchError, RemoteEnvironmentAuthInvalidJsonError, RemoteEnvironmentAuthTimeoutError, RemoteEnvironmentAuthUndeclaredStatusError, RemoteEnvironmentAuthorization, tokenStore_exports as TokenStore, bootstrapRemoteBearerSession, exchangeRemoteDpopAccessToken, fetchRemoteDpopSessionState, fetchRemoteSessionState, issueRemoteDpopWebSocketTicket, issueRemoteWebSocketTicket, resolveRemoteDpopWebSocketConnectionUrl, resolveRemoteWebSocketConnectionUrl };

package/dist/client-runtime/connection.d.ts

@@ -0,0 +1,2 @@
+import { $i as layer_d_exports, $o as PersistedConnectionTarget, Ao as ConnectionCatalogEntry, Bo as connectionRegistrationTarget, Da as mapManagedRelayError, Do as BearerConnectionCredential, Ea as environmentMismatchError, Eo as connectivity_d_exports, Fo as PrimaryConnectionRegistration, Gi as EnvironmentConnectionPresentation, Go as ConnectionBlockedError, Ho as BearerConnectionTarget, Io as RelayConnectionRegistration, Ja as ConnectionDriverProgress, Ji as connectionPhaseMessage, Jo as ConnectionTarget, Ki as EnvironmentPresentation, Ko as ConnectionBlockedReason, Lo as SshConnectionProfile, Mo as ConnectionProfile, No as ConnectionRegistration, Oa as mapRemoteEnvironmentError, Oo as BearerConnectionProfile, Po as PlatformConnectionRegistration, Qi as presentEnvironmentConnection, Qo as NetworkStatus, Ro as SshConnectionRegistration, Ta as credentialMissingError, To as credentialStore_d_exports, Uo as ConnectionAttemptError, Vo as AVAILABLE_CONNECTION_STATE, Wi as EnvironmentConnectionPhase, Wo as ConnectionAttemptStage, Xi as connectionStatusTitle, Xo as ConnectionTransientError, Ya as EnvironmentConnectionLease, Yi as connectionStatusText, Yo as ConnectionTargetKind, Zi as presentConnectionState, Zo as ConnectionTransientReason, _a as EnvironmentSupervisor, aa as ConnectionOnboarding, as as SupervisorConnectionPhase, ca as prepareBearerConnectionUpdate, da as registerPairingConnection, eo as ConnectionResolver, es as PreparedConnection, fa as registerSshConnection, ga as PlatformEnvironmentRemovalError, ha as EnvironmentRegistry, ia as BearerConnectionUpdateInput, is as SshConnectionTarget, jo as ConnectionCredential, ka as profileMissingError, ko as BearerConnectionRegistration, la as preparePairingRegistration, ma as EnvironmentNotRegisteredError, ns as PrimaryConnectionTarget, oa as PairingConnectionInput, os as SupervisorConnectionState, pa as updateBearerConnection, qa as ConnectionDriver, qi as connectionCatalogDisplayUrl, qo as ConnectionProjectionPhase, rs as RelayConnectionTarget, sa as SshConnectionInput, ss as connectionProjectionPhase, to as profileStore_d_exports, ts as PreparedHttpAuthorization, ua as prepareSshRegistration, va as EnvironmentSupervisorOptions, ya as wakeups_d_exports, zo as connectionRegistrationCatalogEntry } from "../shared.js";
+export { AVAILABLE_CONNECTION_STATE, BearerConnectionCredential, BearerConnectionProfile, BearerConnectionRegistration, BearerConnectionTarget, type BearerConnectionUpdateInput, layer_d_exports as Connection, ConnectionAttemptError, ConnectionAttemptStage, ConnectionBlockedError, ConnectionBlockedReason, ConnectionCatalogEntry, ConnectionCredential, ConnectionDriver, type ConnectionDriverProgress, ConnectionOnboarding, ConnectionProfile, ConnectionProjectionPhase, ConnectionRegistration, ConnectionResolver, ConnectionTarget, ConnectionTargetKind, ConnectionTransientError, ConnectionTransientReason, connectivity_d_exports as Connectivity, credentialStore_d_exports as CredentialStore, type EnvironmentConnectionLease, EnvironmentConnectionPhase, EnvironmentConnectionPresentation, EnvironmentNotRegisteredError, EnvironmentPresentation, EnvironmentRegistry, EnvironmentSupervisor, type EnvironmentSupervisorOptions, NetworkStatus, type PairingConnectionInput, PersistedConnectionTarget, PlatformConnectionRegistration, PlatformEnvironmentRemovalError, PreparedConnection, PreparedHttpAuthorization, PrimaryConnectionRegistration, PrimaryConnectionTarget, profileStore_d_exports as ProfileStore, RelayConnectionRegistration, RelayConnectionTarget, type SshConnectionInput, SshConnectionProfile, SshConnectionRegistration, SshConnectionTarget, SupervisorConnectionPhase, SupervisorConnectionState, wakeups_d_exports as Wakeups, connectionCatalogDisplayUrl, connectionPhaseMessage, connectionProjectionPhase, connectionRegistrationCatalogEntry, connectionRegistrationTarget, connectionStatusText, connectionStatusTitle, credentialMissingError, environmentMismatchError, mapManagedRelayError, mapRemoteEnvironmentError, prepareBearerConnectionUpdate, preparePairingRegistration, prepareSshRegistration, presentConnectionState, presentEnvironmentConnection, profileMissingError, registerPairingConnection, registerSshConnection, updateBearerConnection };

package/dist/client-runtime/connection.js

@@ -0,0 +1,2 @@
+import { $i as connectionStatusText, $o as BearerConnectionRegistration, Aa as EnvironmentSupervisor, Da as EnvironmentNotRegisteredError, Ha as ConnectionResolver, Ma as wakeups_exports, Oa as EnvironmentRegistry, Qi as connectionPhaseMessage, Qo as BearerConnectionProfile, Ua as profileStore_exports, Xo as connectivity_exports, Yo as credentialStore_exports, Zi as connectionCatalogDisplayUrl, Zo as BearerConnectionCredential, _o as mapManagedRelayError, _s as PersistedConnectionTarget, as as RelayConnectionRegistration, bs as SshConnectionTarget, ca as ConnectionOnboarding, cs as connectionRegistrationCatalogEntry, da as prepareSshRegistration, ds as BearerConnectionTarget, ea as connectionStatusTitle, es as ConnectionCredential, fa as registerPairingConnection, fs as ConnectionBlockedError, go as environmentMismatchError, gs as ConnectionTransientReason, ho as credentialMissingError, hs as ConnectionTransientError, is as PrimaryConnectionRegistration, ka as PlatformEnvironmentRemovalError, la as prepareBearerConnectionUpdate, ls as connectionRegistrationTarget, ma as updateBearerConnection, ms as ConnectionTarget, na as presentEnvironmentConnection, ns as ConnectionRegistration, os as SshConnectionProfile, pa as registerSshConnection, ps as ConnectionBlockedReason, ra as layer_exports, rs as PlatformConnectionRegistration, ss as SshConnectionRegistration, ta as presentConnectionState, ts as ConnectionProfile, ua as preparePairingRegistration, us as AVAILABLE_CONNECTION_STATE, vo as mapRemoteEnvironmentError, vs as PrimaryConnectionTarget, xs as connectionProjectionPhase, yo as profileMissingError, ys as RelayConnectionTarget, za as ConnectionDriver } from "../shared.js";
+export { AVAILABLE_CONNECTION_STATE, BearerConnectionCredential, BearerConnectionProfile, BearerConnectionRegistration, BearerConnectionTarget, layer_exports as Connection, ConnectionBlockedError, ConnectionBlockedReason, ConnectionCredential, ConnectionDriver, ConnectionOnboarding, ConnectionProfile, ConnectionRegistration, ConnectionResolver, ConnectionTarget, ConnectionTransientError, ConnectionTransientReason, connectivity_exports as Connectivity, credentialStore_exports as CredentialStore, EnvironmentNotRegisteredError, EnvironmentRegistry, EnvironmentSupervisor, PersistedConnectionTarget, PlatformConnectionRegistration, PlatformEnvironmentRemovalError, PrimaryConnectionRegistration, PrimaryConnectionTarget, profileStore_exports as ProfileStore, RelayConnectionRegistration, RelayConnectionTarget, SshConnectionProfile, SshConnectionRegistration, SshConnectionTarget, wakeups_exports as Wakeups, connectionCatalogDisplayUrl, connectionPhaseMessage, connectionProjectionPhase, connectionRegistrationCatalogEntry, connectionRegistrationTarget, connectionStatusText, connectionStatusTitle, credentialMissingError, environmentMismatchError, mapManagedRelayError, mapRemoteEnvironmentError, prepareBearerConnectionUpdate, preparePairingRegistration, prepareSshRegistration, presentConnectionState, presentEnvironmentConnection, profileMissingError, registerPairingConnection, registerSshConnection, updateBearerConnection };

package/dist/client-runtime/environment.d.ts

@@ -0,0 +1,57 @@
+import { $T as ThreadId, KT as ProjectId, Mw as ScopedThreadRef, Tw as ExecutionEnvironmentDescriptor, Ua as RemoteEnvironmentRequestError, _n as classifyHostedHttpsCompatibility, bn as normalizeHttpBaseUrl, gn as CreateAdvertisedEndpointInput, jw as ScopedProjectRef, vn as createAdvertisedEndpoint, yn as deriveWsBaseUrl, zT as EnvironmentId } from "../shared.js";
+import * as Effect from "effect/Effect";
+//#region upstream-t3code/packages/client-runtime/src/environment/descriptor.d.ts
+declare const fetchRemoteEnvironmentDescriptor: (input: {
+  readonly httpBaseUrl: string;
+  readonly timeoutMs?: number;
+}) => Effect.Effect<{
+  readonly environmentId: string & import("effect/Brand").Brand<"EnvironmentId">;
+  readonly label: string;
+  readonly platform: {
+    readonly os: "darwin" | "linux" | "unknown" | "windows";
+    readonly arch: "arm64" | "other" | "x64";
+  };
+  readonly serverVersion: string;
+  readonly capabilities: {
+    readonly repositoryIdentity: boolean;
+    readonly connectionProbe?: boolean;
+    readonly threadSettlement?: boolean;
+    readonly threadSnooze?: boolean;
+    readonly serverSelfUpdate?: "boot-service" | "desktop-managed" | "respawn";
+  };
+}, RemoteEnvironmentRequestError, import("effect/unstable/http/HttpClient").HttpClient>;
+//#endregion
+//#region upstream-t3code/packages/client-runtime/src/environment/endpoint.d.ts
+declare const environmentEndpointUrl: (httpBaseUrl: string, pathname: string) => string;
+//#endregion
+//#region upstream-t3code/packages/client-runtime/src/environment/knownEnvironment.d.ts
+interface KnownEnvironmentConnectionTarget {
+  readonly httpBaseUrl: string;
+  readonly wsBaseUrl: string;
+}
+type KnownEnvironmentSource = "configured" | "desktop-managed" | "manual" | "window-origin";
+interface KnownEnvironment {
+  readonly id: string;
+  readonly label: string;
+  readonly source: KnownEnvironmentSource;
+  readonly environmentId?: EnvironmentId;
+  readonly target: KnownEnvironmentConnectionTarget;
+}
+declare function createKnownEnvironment(input: {
+  readonly id?: string;
+  readonly label: string;
+  readonly source?: KnownEnvironmentSource;
+  readonly target: KnownEnvironmentConnectionTarget;
+}): KnownEnvironment;
+declare function attachEnvironmentDescriptor(environment: KnownEnvironment, descriptor: ExecutionEnvironmentDescriptor): KnownEnvironment;
+//#endregion
+//#region upstream-t3code/packages/client-runtime/src/environment/scoped.d.ts
+declare function scopeProjectRef(environmentId: EnvironmentId, projectId: ProjectId): ScopedProjectRef;
+declare function scopeThreadRef(environmentId: EnvironmentId, threadId: ThreadId): ScopedThreadRef;
+declare function scopedRefKey(ref: ScopedProjectRef | ScopedThreadRef): string;
+declare function scopedProjectKey(ref: ScopedProjectRef): string;
+declare function scopedThreadKey(ref: ScopedThreadRef): string;
+declare function parseScopedProjectKey(key: string): ScopedProjectRef | null;
+declare function parseScopedThreadKey(key: string): ScopedThreadRef | null;
+//#endregion
+export { CreateAdvertisedEndpointInput, KnownEnvironment, KnownEnvironmentConnectionTarget, KnownEnvironmentSource, attachEnvironmentDescriptor, classifyHostedHttpsCompatibility, createAdvertisedEndpoint, createKnownEnvironment, deriveWsBaseUrl, environmentEndpointUrl, fetchRemoteEnvironmentDescriptor, normalizeHttpBaseUrl, parseScopedProjectKey, parseScopedThreadKey, scopeProjectRef, scopeThreadRef, scopedProjectKey, scopedRefKey, scopedThreadKey };

package/dist/client-runtime/environment.js

@@ -0,0 +1,2 @@
+import { Bo as normalizeHttpBaseUrl, Io as environmentEndpointUrl, Lo as classifyHostedHttpsCompatibility, Ro as createAdvertisedEndpoint, ai as parseScopedProjectKey, ci as scopeThreadRef, di as scopedThreadKey, fi as attachEnvironmentDescriptor, li as scopedProjectKey, mo as fetchRemoteEnvironmentDescriptor, oi as parseScopedThreadKey, pi as createKnownEnvironment, si as scopeProjectRef, ui as scopedRefKey, zo as deriveWsBaseUrl } from "../shared.js";
+export { attachEnvironmentDescriptor, classifyHostedHttpsCompatibility, createAdvertisedEndpoint, createKnownEnvironment, deriveWsBaseUrl, environmentEndpointUrl, fetchRemoteEnvironmentDescriptor, normalizeHttpBaseUrl, parseScopedProjectKey, parseScopedThreadKey, scopeProjectRef, scopeThreadRef, scopedProjectKey, scopedRefKey, scopedThreadKey };

package/dist/client-runtime/errors.d.ts

@@ -0,0 +1,28 @@
+//#region upstream-t3code/packages/client-runtime/src/errors/errorTrace.d.ts
+declare function findErrorTraceId(error: unknown): string | null;
+//#endregion
+//#region upstream-t3code/packages/client-runtime/src/errors/safeLog.d.ts
+interface SafeErrorLogAttributes {
+  readonly errorType: "error" | "array" | "null" | "object" | "primitive";
+  readonly errorName?: string;
+  readonly errorTag?: string;
+  readonly traceId?: string;
+  readonly stack?: string;
+}
+declare function safeErrorLogAttributes(error: unknown): SafeErrorLogAttributes;
+//#endregion
+//#region upstream-t3code/packages/client-runtime/src/errors/transport.d.ts
+/**
+ * Check whether an error message originates from a transport-level connection
+ * failure (socket close, socket open, ping timeout, etc.) rather than a
+ * business-logic error.
+ */
+declare function isTransportConnectionErrorMessage(message: string | null | undefined): boolean;
+/**
+ * Strip transport connection errors from user-facing error messages.
+ * Returns `null` for transport errors so the UI can distinguish between
+ * real errors and transient connection issues.
+ */
+declare function sanitizeThreadErrorMessage(message: string | null | undefined): string | null;
+//#endregion
+export { SafeErrorLogAttributes, findErrorTraceId, isTransportConnectionErrorMessage, safeErrorLogAttributes, sanitizeThreadErrorMessage };

package/dist/client-runtime/errors.js

@@ -0,0 +1,35 @@
+import { An as findErrorTraceId, Na as safeErrorLogAttributes } from "../shared.js";
+//#region upstream-t3code/packages/client-runtime/src/errors/transport.ts
+const TRANSPORT_ERROR_PATTERNS = [
+	/\bSocketCloseError\b/i,
+	/\bSocketOpenError\b/i,
+	/\bSocket is not connected\b/i,
+	/Unable to connect to the T3 server WebSocket\./i,
+	/\bis not connected\.$/i,
+	/\bdisconnected\.$/i,
+	/\bcould not establish a WebSocket connection\.$/i,
+	/\bClientProtocolError\b/i,
+	/\bRpcClientError\b/i,
+	/\bping timeout\b/i
+];
+/**
+* Check whether an error message originates from a transport-level connection
+* failure (socket close, socket open, ping timeout, etc.) rather than a
+* business-logic error.
+*/
+function isTransportConnectionErrorMessage(message) {
+	if (typeof message !== "string") return false;
+	const normalizedMessage = message.trim();
+	if (normalizedMessage.length === 0) return false;
+	return TRANSPORT_ERROR_PATTERNS.some((pattern) => pattern.test(normalizedMessage));
+}
+/**
+* Strip transport connection errors from user-facing error messages.
+* Returns `null` for transport errors so the UI can distinguish between
+* real errors and transient connection issues.
+*/
+function sanitizeThreadErrorMessage(message) {
+	return isTransportConnectionErrorMessage(message) ? null : message ?? null;
+}
+//#endregion
+export { findErrorTraceId, isTransportConnectionErrorMessage, safeErrorLogAttributes, sanitizeThreadErrorMessage };

package/dist/client-runtime/operations/projects.d.ts

@@ -0,0 +1,2 @@
+import { $ as getAddProjectInitialQuery, G as AddProjectRemoteSource, J as addProjectRemoteSourcePathHint, K as AddProjectRemoteSourceReadiness, Q as findExistingAddProject, U as AddProjectCloneFlow, W as AddProjectRemoteProviderKind, X as buildAddProjectRemoteSourceReadiness, Y as addProjectRemoteSourceProvider, Z as buildProjectCreateCommand, et as resolveAddProjectPath, q as addProjectRemoteSourceLabel, tt as sortAddProjectProviderSources } from "../../shared.js";
+export { AddProjectCloneFlow, AddProjectRemoteProviderKind, AddProjectRemoteSource, AddProjectRemoteSourceReadiness, addProjectRemoteSourceLabel, addProjectRemoteSourcePathHint, addProjectRemoteSourceProvider, buildAddProjectRemoteSourceReadiness, buildProjectCreateCommand, findExistingAddProject, getAddProjectInitialQuery, resolveAddProjectPath, sortAddProjectProviderSources };

package/dist/client-runtime/operations/projects.js

@@ -0,0 +1,2 @@
+import { At as resolveAddProjectPath, Ct as addProjectRemoteSourceLabel, Dt as buildProjectCreateCommand, Et as buildAddProjectRemoteSourceReadiness, Ot as findExistingAddProject, Tt as addProjectRemoteSourceProvider, jt as sortAddProjectProviderSources, kt as getAddProjectInitialQuery, wt as addProjectRemoteSourcePathHint } from "../../shared.js";
+export { addProjectRemoteSourceLabel, addProjectRemoteSourcePathHint, addProjectRemoteSourceProvider, buildAddProjectRemoteSourceReadiness, buildProjectCreateCommand, findExistingAddProject, getAddProjectInitialQuery, resolveAddProjectPath, sortAddProjectProviderSources };

package/dist/client-runtime/operations.d.ts

@@ -0,0 +1,2 @@
+import { $ as getAddProjectInitialQuery, At as archiveThread, Bt as setThreadRuntimeMode, Ct as StartThreadTurnInput, Dt as UnsnoozeThreadInput, Et as UnsettleThreadInput, Ft as interruptThreadTurn, G as AddProjectRemoteSource, Gt as unarchiveThread, Ht as snoozeThread, It as respondToThreadApproval, J as addProjectRemoteSourcePathHint, Jt as updateProject, K as AddProjectRemoteSourceReadiness, Kt as unsettleThread, Lt as respondToThreadUserInput, Mt as createThread, Nt as deleteProject, Ot as UpdateProjectInput, Pt as deleteThread, Q as findExistingAddProject, Rt as revertThreadCheckpoint, St as SnoozeThreadInput, Tt as UnarchiveThreadInput, U as AddProjectCloneFlow, Ut as startThreadTurn, Vt as settleThread, W as AddProjectRemoteProviderKind, Wt as stopThreadSession, X as buildAddProjectRemoteSourceReadiness, Y as addProjectRemoteSourceProvider, Yt as updateThreadMetadata, Z as buildProjectCreateCommand, _t as RespondToThreadUserInputInput, bt as SetThreadRuntimeModeInput, dt as CreateProjectInput, et as resolveAddProjectPath, ft as CreateThreadInput, gt as RespondToThreadApprovalInput, ht as InterruptThreadTurnInput, jt as createProject, kt as UpdateThreadMetadataInput, mt as DeleteThreadInput, pt as DeleteProjectInput, q as addProjectRemoteSourceLabel, qt as unsnoozeThread, tt as sortAddProjectProviderSources, ut as ArchiveThreadInput, vt as RevertThreadCheckpointInput, wt as StopThreadSessionInput, xt as SettleThreadInput, yt as SetThreadInteractionModeInput, zt as setThreadInteractionMode } from "../shared.js";
+export { AddProjectCloneFlow, AddProjectRemoteProviderKind, AddProjectRemoteSource, AddProjectRemoteSourceReadiness, ArchiveThreadInput, CreateProjectInput, CreateThreadInput, DeleteProjectInput, DeleteThreadInput, InterruptThreadTurnInput, RespondToThreadApprovalInput, RespondToThreadUserInputInput, RevertThreadCheckpointInput, SetThreadInteractionModeInput, SetThreadRuntimeModeInput, SettleThreadInput, SnoozeThreadInput, StartThreadTurnInput, StopThreadSessionInput, UnarchiveThreadInput, UnsettleThreadInput, UnsnoozeThreadInput, UpdateProjectInput, UpdateThreadMetadataInput, addProjectRemoteSourceLabel, addProjectRemoteSourcePathHint, addProjectRemoteSourceProvider, archiveThread, buildAddProjectRemoteSourceReadiness, buildProjectCreateCommand, createProject, createThread, deleteProject, deleteThread, findExistingAddProject, getAddProjectInitialQuery, interruptThreadTurn, resolveAddProjectPath, respondToThreadApproval, respondToThreadUserInput, revertThreadCheckpoint, setThreadInteractionMode, setThreadRuntimeMode, settleThread, snoozeThread, sortAddProjectProviderSources, startThreadTurn, stopThreadSession, unarchiveThread, unsettleThread, unsnoozeThread, updateProject, updateThreadMetadata };

package/dist/client-runtime/operations.js

@@ -0,0 +1,2 @@
+import { At as resolveAddProjectPath, Cn as startThreadTurn, Ct as addProjectRemoteSourceLabel, Dn as unsnoozeThread, Dt as buildProjectCreateCommand, En as unsettleThread, Et as buildAddProjectRemoteSourceReadiness, On as updateProject, Ot as findExistingAddProject, Sn as snoozeThread, Tn as unarchiveThread, Tt as addProjectRemoteSourceProvider, _n as respondToThreadUserInput, bn as setThreadRuntimeMode, dn as createProject, fn as createThread, gn as respondToThreadApproval, hn as interruptThreadTurn, jt as sortAddProjectProviderSources, kn as updateThreadMetadata, kt as getAddProjectInitialQuery, mn as deleteThread, pn as deleteProject, un as archiveThread, vn as revertThreadCheckpoint, wn as stopThreadSession, wt as addProjectRemoteSourcePathHint, xn as settleThread, yn as setThreadInteractionMode } from "../shared.js";
+export { addProjectRemoteSourceLabel, addProjectRemoteSourcePathHint, addProjectRemoteSourceProvider, archiveThread, buildAddProjectRemoteSourceReadiness, buildProjectCreateCommand, createProject, createThread, deleteProject, deleteThread, findExistingAddProject, getAddProjectInitialQuery, interruptThreadTurn, resolveAddProjectPath, respondToThreadApproval, respondToThreadUserInput, revertThreadCheckpoint, setThreadInteractionMode, setThreadRuntimeMode, settleThread, snoozeThread, sortAddProjectProviderSources, startThreadTurn, stopThreadSession, unarchiveThread, unsettleThread, unsnoozeThread, updateProject, updateThreadMetadata };

package/dist/client-runtime/platform.d.ts

@@ -0,0 +1,26 @@
+import { Ca as EnvironmentCacheStore, Co as SshEnvironmentGateway, Do as BearerConnectionCredential, Ho as BearerConnectionTarget, Jo as ConnectionTarget, Lo as SshConnectionProfile, No as ConnectionRegistration, Oo as BearerConnectionProfile, Sa as ConnectionTargetStore, So as RelayDeviceIdentity, _o as ClientPresentation, ao as RemoteDpopAccessToken, ba as ConnectionPersistenceError, bo as PrimaryEnvironmentAuth, is as SshConnectionTarget, ra as PlatformConnectionSource, rs as RelayConnectionTarget, vo as CloudSession, wa as EnvironmentOwnedDataCleanup, xa as ConnectionRegistrationStore, xo as ProvisionedSshEnvironment, yo as PreparedSshEnvironment } from "../shared.js";
+import * as Schema from "effect/Schema";
+//#region upstream-t3code/packages/client-runtime/src/platform/storageDocument.d.ts
+declare const StoredConnectionCredential: Schema.Struct<{
+  readonly connectionId: Schema.String;
+  readonly credential: Schema.Union<readonly [typeof BearerConnectionCredential]>;
+}>;
+type StoredConnectionCredential = typeof StoredConnectionCredential.Type;
+declare const ConnectionCatalogDocument: Schema.Struct<{
+  readonly schemaVersion: Schema.Literal<1>;
+  readonly targets: Schema.$Array<Schema.Union<readonly [typeof BearerConnectionTarget, typeof RelayConnectionTarget, typeof SshConnectionTarget]>>;
+  readonly profiles: Schema.$Array<Schema.Union<readonly [typeof BearerConnectionProfile, typeof SshConnectionProfile]>>;
+  readonly credentials: Schema.$Array<Schema.Struct<{
+    readonly connectionId: Schema.String;
+    readonly credential: Schema.Union<readonly [typeof BearerConnectionCredential]>;
+  }>>;
+  readonly remoteDpopTokens: Schema.$Array<typeof RemoteDpopAccessToken>;
+}>;
+type ConnectionCatalogDocument = typeof ConnectionCatalogDocument.Type;
+declare const EMPTY_CONNECTION_CATALOG_DOCUMENT: ConnectionCatalogDocument;
+declare function replaceCatalogValue<A>(values: ReadonlyArray<A>, key: (value: A) => string, next: A): ReadonlyArray<A>;
+declare function removeCatalogValue<A>(values: ReadonlyArray<A>, key: (value: A) => string, removedKey: string): ReadonlyArray<A>;
+declare function registerConnectionInCatalog(document: ConnectionCatalogDocument, registration: ConnectionRegistration): ConnectionCatalogDocument;
+declare function removeConnectionFromCatalog(document: ConnectionCatalogDocument, target: ConnectionTarget): ConnectionCatalogDocument;
+//#endregion
+export { ClientPresentation, CloudSession, ConnectionCatalogDocument, ConnectionPersistenceError, ConnectionRegistrationStore, ConnectionTargetStore, EMPTY_CONNECTION_CATALOG_DOCUMENT, EnvironmentCacheStore, EnvironmentOwnedDataCleanup, PlatformConnectionSource, PreparedSshEnvironment, PrimaryEnvironmentAuth, ProvisionedSshEnvironment, RelayDeviceIdentity, SshEnvironmentGateway, StoredConnectionCredential, registerConnectionInCatalog, removeCatalogValue, removeConnectionFromCatalog, replaceCatalogValue };

package/dist/client-runtime/platform.js

@@ -0,0 +1,74 @@
+import { $T as Struct, Fa as ConnectionRegistrationStore, Ga as RemoteDpopAccessToken, Ia as ConnectionTargetStore, La as EnvironmentCacheStore, Pa as ConnectionPersistenceError, QT as String, Ra as EnvironmentOwnedDataCleanup, WT as ArraySchema, _s as PersistedConnectionTarget, do as PrimaryEnvironmentAuth, es as ConnectionCredential, fo as RelayDeviceIdentity, lo as ClientPresentation, po as SshEnvironmentGateway, qT as Literal, sa as PlatformConnectionSource, ts as ConnectionProfile, uo as CloudSession } from "../shared.js";
+//#region upstream-t3code/packages/client-runtime/src/platform/storageDocument.ts
+const StoredConnectionCredential = Struct({
+	connectionId: String,
+	credential: ConnectionCredential
+});
+const ConnectionCatalogDocument = Struct({
+	schemaVersion: Literal(1),
+	targets: ArraySchema(PersistedConnectionTarget),
+	profiles: ArraySchema(ConnectionProfile),
+	credentials: ArraySchema(StoredConnectionCredential),
+	remoteDpopTokens: ArraySchema(RemoteDpopAccessToken)
+});
+const EMPTY_CONNECTION_CATALOG_DOCUMENT = Object.freeze({
+	schemaVersion: 1,
+	targets: [],
+	profiles: [],
+	credentials: [],
+	remoteDpopTokens: []
+});
+function replaceCatalogValue(values, key, next) {
+	const nextKey = key(next);
+	return [...values.filter((value) => key(value) !== nextKey), next];
+}
+function removeCatalogValue(values, key, removedKey) {
+	return values.filter((value) => key(value) !== removedKey);
+}
+function connectionIdOf(target) {
+	switch (target._tag) {
+		case "PrimaryConnectionTarget":
+		case "RelayConnectionTarget": return null;
+		case "BearerConnectionTarget":
+		case "SshConnectionTarget": return target.connectionId;
+	}
+}
+function removeConnectionMetadata(document, target, removeRemoteToken) {
+	const connectionId = connectionIdOf(target);
+	return {
+		...document,
+		targets: removeCatalogValue(document.targets, (value) => value.environmentId, target.environmentId),
+		profiles: connectionId === null ? document.profiles : removeCatalogValue(document.profiles, (value) => value.connectionId, connectionId),
+		credentials: connectionId === null ? document.credentials : removeCatalogValue(document.credentials, (value) => value.connectionId, connectionId),
+		remoteDpopTokens: removeRemoteToken ? removeCatalogValue(document.remoteDpopTokens, (value) => value.environmentId, target.environmentId) : document.remoteDpopTokens
+	};
+}
+function registerConnectionInCatalog(document, registration) {
+	const target = registration.target;
+	const previous = document.targets.find((candidate) => candidate.environmentId === target.environmentId);
+	const cleaned = previous === void 0 ? document : removeConnectionMetadata(document, previous, false);
+	const next = {
+		...cleaned,
+		targets: replaceCatalogValue(cleaned.targets, (value) => value.environmentId, target)
+	};
+	switch (registration._tag) {
+		case "RelayConnectionRegistration": return next;
+		case "BearerConnectionRegistration": return {
+			...next,
+			profiles: replaceCatalogValue(next.profiles, (value) => value.connectionId, registration.profile),
+			credentials: replaceCatalogValue(next.credentials, (value) => value.connectionId, {
+				connectionId: registration.target.connectionId,
+				credential: registration.credential
+			})
+		};
+		case "SshConnectionRegistration": return {
+			...next,
+			profiles: replaceCatalogValue(next.profiles, (value) => value.connectionId, registration.profile)
+		};
+	}
+}
+function removeConnectionFromCatalog(document, target) {
+	return removeConnectionMetadata(document, target, true);
+}
+//#endregion
+export { ClientPresentation, CloudSession, ConnectionCatalogDocument, ConnectionPersistenceError, ConnectionRegistrationStore, ConnectionTargetStore, EMPTY_CONNECTION_CATALOG_DOCUMENT, EnvironmentCacheStore, EnvironmentOwnedDataCleanup, PlatformConnectionSource, PrimaryEnvironmentAuth, RelayDeviceIdentity, SshEnvironmentGateway, StoredConnectionCredential, registerConnectionInCatalog, removeCatalogValue, removeConnectionFromCatalog, replaceCatalogValue };

package/dist/client-runtime/relay.d.ts

@@ -0,0 +1,121 @@
+import { co as ManagedRelayClient, do as ManagedRelayRequestFailedError, fo as ManagedRelayRequestProofCreationError, go as managedRelay_d_exports, ho as ManagedRelayUrlInvalidError, lo as ManagedRelayDpopKeyLoadError, mo as ManagedRelayTokenProofCreationError, na as discovery_d_exports, po as ManagedRelayRequestTimeoutError, so as ManagedRelayAccessTokenScopesUnexpectedError, wo as RelayClientEnvironmentRecord } from "../shared.js";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as Cause from "effect/Cause";
+import { AsyncResult, Atom, AtomRegistry } from "effect/unstable/reactivity";
+//#region upstream-t3code/packages/client-runtime/src/relay/managedRelayState.d.ts
+interface ManagedRelaySession {
+  readonly accountId: string;
+  readonly readClerkToken: () => Effect.Effect<string | null, ManagedRelaySessionError>;
+}
+interface ManagedRelaySessionInput {
+  readonly accountId: string;
+  readonly readClerkToken: () => Promise<string | null>;
+}
+interface ManagedRelaySnapshotState<A> {
+  readonly data: A | null;
+  readonly error: string | null;
+  readonly errorTraceId: string | null;
+  readonly isPending: boolean;
+}
+interface ManagedRelayQueryEvent {
+  readonly operation: "environments" | "devices" | "environment-status";
+  readonly stage: "clerk-token" | "relay-request" | "validation";
+  readonly phase: "start" | "success" | "failure";
+  readonly accountId: string;
+  readonly environmentId?: string;
+  readonly message?: string;
+  readonly traceId?: string | null;
+}
+declare const ManagedRelaySessionError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Cause.YieldableError & {
+  readonly _tag: "ManagedRelaySessionError";
+} & Readonly<A>;
+declare class ManagedRelaySessionError extends ManagedRelaySessionError_base<{
+  readonly message: string;
+  readonly cause?: unknown;
+}> {}
+declare const ManagedRelaySnapshotError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Cause.YieldableError & {
+  readonly _tag: "ManagedRelaySnapshotError";
+} & Readonly<A>;
+declare class ManagedRelaySnapshotError extends ManagedRelaySnapshotError_base<{
+  readonly message: string;
+}> {}
+declare const managedRelaySessionAtom: Atom.Writable<ManagedRelaySession | null, ManagedRelaySession | null>;
+declare function createManagedRelaySession(input: ManagedRelaySessionInput): ManagedRelaySession;
+declare function setManagedRelaySession(registry: AtomRegistry.AtomRegistry, input: ManagedRelaySessionInput | null): void;
+declare function managedRelayAccountChanges(registry: AtomRegistry.AtomRegistry): Stream.Stream<string | null>;
+declare const waitForManagedRelayClerkToken: (registry: AtomRegistry.AtomRegistry) => Effect.Effect<string, ManagedRelaySessionError, never>;
+declare function readManagedRelaySnapshotState<A>(result: AsyncResult.AsyncResult<A, unknown>): ManagedRelaySnapshotState<A>;
+declare function createManagedRelayQueryManager(runtime: Atom.AtomRuntime<ManagedRelayClient>, options?: {
+  readonly staleTimeMs?: number;
+  readonly idleTtlMs?: number;
+  readonly onQueryEvent?: (event: ManagedRelayQueryEvent) => void;
+}): {
+  environmentsAtom: (arg: string) => Atom.Atom<AsyncResult.AsyncResult<readonly {
+    readonly environmentId: string & import("effect/Brand").Brand<"EnvironmentId">;
+    readonly label: string;
+    readonly endpoint: {
+      readonly httpBaseUrl: string;
+      readonly wsBaseUrl: string;
+      readonly providerKind: "cloudflare_tunnel" | "manual" | "t3_relay";
+    };
+    readonly linkedAt: string;
+  }[], ManagedRelayAccessTokenScopesUnexpectedError | ManagedRelayDpopKeyLoadError | ManagedRelayRequestFailedError | ManagedRelayRequestProofCreationError | ManagedRelayRequestTimeoutError | ManagedRelaySessionError | ManagedRelayTokenProofCreationError | ManagedRelayUrlInvalidError>>;
+  devicesAtom: (arg: string) => Atom.Atom<AsyncResult.AsyncResult<readonly {
+    readonly deviceId: string;
+    readonly label: string;
+    readonly platform: "ios";
+    readonly iosMajorVersion: number;
+    readonly appVersion: string | null;
+    readonly notifications: {
+      readonly enabled: boolean;
+      readonly notifyOnApproval: boolean;
+      readonly notifyOnInput: boolean;
+      readonly notifyOnCompletion: boolean;
+      readonly notifyOnFailure: boolean;
+    };
+    readonly liveActivities: {
+      readonly enabled: boolean;
+    };
+    readonly updatedAt: string;
+  }[], ManagedRelayAccessTokenScopesUnexpectedError | ManagedRelayDpopKeyLoadError | ManagedRelayRequestFailedError | ManagedRelayRequestProofCreationError | ManagedRelayRequestTimeoutError | ManagedRelaySessionError | ManagedRelayTokenProofCreationError | ManagedRelayUrlInvalidError>>;
+  environmentStatusAtom: (input: {
+    readonly accountId: string;
+    readonly environment: RelayClientEnvironmentRecord;
+  }) => Atom.Atom<AsyncResult.AsyncResult<{
+    readonly environmentId: string & import("effect/Brand").Brand<"EnvironmentId">;
+    readonly endpoint: {
+      readonly httpBaseUrl: string;
+      readonly wsBaseUrl: string;
+      readonly providerKind: "cloudflare_tunnel" | "manual" | "t3_relay";
+    };
+    readonly status: "offline" | "online";
+    readonly checkedAt: string;
+    readonly descriptor?: {
+      readonly environmentId: string & import("effect/Brand").Brand<"EnvironmentId">;
+      readonly label: string;
+      readonly platform: {
+        readonly os: "darwin" | "linux" | "unknown" | "windows";
+        readonly arch: "arm64" | "other" | "x64";
+      };
+      readonly serverVersion: string;
+      readonly capabilities: {
+        readonly repositoryIdentity: boolean;
+        readonly connectionProbe?: boolean;
+        readonly threadSettlement?: boolean;
+        readonly threadSnooze?: boolean;
+        readonly serverSelfUpdate?: "boot-service" | "desktop-managed" | "respawn";
+      };
+    } | undefined;
+    readonly error?: string | undefined;
+    readonly traceId?: string | undefined;
+  }, ManagedRelayAccessTokenScopesUnexpectedError | ManagedRelayDpopKeyLoadError | ManagedRelayRequestFailedError | ManagedRelayRequestProofCreationError | ManagedRelayRequestTimeoutError | ManagedRelaySessionError | ManagedRelaySnapshotError | ManagedRelayTokenProofCreationError | ManagedRelayUrlInvalidError>>;
+  refreshEnvironments(registry: AtomRegistry.AtomRegistry, accountId: string): void;
+  refreshDevices(registry: AtomRegistry.AtomRegistry, accountId: string): void;
+  refreshEnvironmentStatus(registry: AtomRegistry.AtomRegistry, input: {
+    readonly accountId: string;
+    readonly environment: RelayClientEnvironmentRecord;
+  }): void;
+};
+//#endregion
+export { discovery_d_exports as Discovery, managedRelay_d_exports as ManagedRelay, ManagedRelayQueryEvent, ManagedRelaySession, ManagedRelaySessionError, ManagedRelaySessionInput, ManagedRelaySnapshotError, ManagedRelaySnapshotState, createManagedRelayQueryManager, createManagedRelaySession, managedRelayAccountChanges, managedRelaySessionAtom, readManagedRelaySnapshotState, setManagedRelaySession, waitForManagedRelayClerkToken };