t3code-cli 0.14.2 → 0.15.0

package/dist/client-runtime/state/threads.js

@@ -1,4 +1,4 @@
-import { $k as orElseSucceed, $r as make, AO as fromQueue, Aj as none, An as unsettleThread, Bk as gen, Bo as makeEnvironmentHttpApiClient, Br as buildEnvironmentAuthHeaders, Cj as getOrNull, Ck as catchCause, Cn as setThreadRuntimeMode, Cw as EnvironmentId, Dj as isSome, Dk as catch_, Dn as stopThreadSession, EO as filter$1, Ej as isNone, Ek as catchTags, En as startThreadTurn, FA as squash, Fy as get$1, Gk as map, HO as runHead, IA as effect, IO as never, Ia as EnvironmentSupervisor, Ij as combine, Iy as make$1, La as ConnectionWakeups, Lj as combineAll, Ly as set$1, MO as map$3, Nj as Number$1, Nk as flatMap$1, Nn as updateThreadMetadata, Oj as map$2, On as unarchiveThread, Os as connectionProjectionPhase, PA as pretty, Pj as String, Pk as fn, Py as changes, Qt as parseThreadKey, Ra as shouldResubscribeAfterWakeup, Ry as update, SO as debounce, Sj as getOrElse, Sn as setThreadInteractionMode, Tn as snoozeThread, Tr as followStreamInEnvironment, Uk as logDebug, Uo as environmentEndpointUrl, VO as runForEach, Vb as ORCHESTRATION_WS_METHODS, Vr as withEnvironmentCredentials, Wa as EnvironmentCacheStore, Wk as logWarning, Xr as subscribeDynamic, YO as unwrap, Yj as pipe, Yt as arrayElementsEqual, Zr as family, Zt as parseProjectRefCollectionKey, _k as all, _n as pinThread, ak as offerUnsafe, bA as void_, bT as set, bk as as, bn as respondToThreadUserInput, cA as succeed, ck as sliding, dT as HttpClient, dn as archiveThread, dr as scopeThreadShell, ei as setIdleTTL, ej as append, ek as make$3, en as projectRefCollectionKey, gk as addFinalizer, gn as interruptThreadTurn, hj as Service, hn as deleteThread, ik as offer, jj as some, jn as unsnoozeThread, kj as match, kn as unpinThread, mj as Reference, mr as createEnvironmentCommand, nA as provideService, ni as withLabel, nj as map$1, nn as threadKey, oA as serviceOption, pn as createThread, pr as createAtomCommandScheduler, rj as sort, rn as threadRefsEqual, si as value, tj as filter, to as ManagedRelayDpopSigner, uA as sync, ur as scopeThread, vT as get, vj as flatMap, vk as andThen, vn as reorderPinnedThread, wj as getOrThrow, wn as settleThread, xT as update$1, xn as revertThreadCheckpoint, yT as make$2, yk as annotateLogs, yn as respondToThreadApproval, zj as mapInput, zk as forkScoped, zo as executeEnvironmentHttpRequest } from "../../shared.js";
+import { $A as runHead, AN as Service, Aj as andThen, An as unsettleThread, Ba as shouldResubscribeAfterWakeup, By as changes, CM as sync, Cn as setThreadRuntimeMode, DD as set, Dn as stopThreadSession, Dr as followStreamInEnvironment, ED as make$2, En as startThreadTurn, Fj as catchCause, GN as none, Gj as flatMap$1, HN as isSome, Ho as makeEnvironmentHttpApiClient, Hr as buildEnvironmentAuthHeaders, Hy as make$1, JM as squash, JN as Number$1, KN as some, Ka as EnvironmentCacheStore, Kj as fn, Ko as environmentEndpointUrl, Kr as make, LA as filter$1, LN as getOrElse, ME as EnvironmentId, Mj as as, NA as debounce, NM as void_, NN as flatMap, Nn as updateThreadMetadata, OD as update$1, Oj as addFinalizer, On as unarchiveThread, QA as runForEach, QN as combineAll, Qj as gen, Qt as parseThreadKey, RN as getOrNull, Ra as EnvironmentSupervisor, Rj as catchTags, Sn as setThreadInteractionMode, TD as get, Tn as snoozeThread, UA as map$3, UN as map$2, Ur as withEnvironmentCredentials, Uy as set$1, VA as fromQueue, VN as isNone, Vo as executeEnvironmentHttpRequest, Vy as get$1, WN as match, Wr as family, Wy as update, XS as ORCHESTRATION_WS_METHODS, YM as effect, YN as String, Yr as withLabel, Yt as arrayElementsEqual, ZN as combine, Zj as forkScoped, Zt as parseProjectRefCollectionKey, _j as offerUnsafe, _n as pinThread, bj as sliding, bn as respondToThreadUserInput, dn as archiveThread, dr as scopeThread, eP as mapInput, ei as value, en as projectRefCollectionKey, fM as orElseSucceed, fj as make$3, fr as scopeThreadShell, gN as sort, gj as offer, gn as interruptThreadTurn, hM as provideService, hN as map$1, hn as deleteThread, hr as createEnvironmentCommand, jj as annotateLogs, jn as unsnoozeThread, js as connectionProjectionPhase, kN as Reference, kj as all, kn as unpinThread, li as subscribeDynamic, mN as filter, mr as createAtomCommandScheduler, nM as logWarning, nn as threadKey, pN as append, pn as createThread, qA as never, qM as pretty, qr as setIdleTTL, rM as map, rn as threadRefsEqual, ro as ManagedRelayDpopSigner, sj as unwrap, tM as logDebug, uP as pipe, vD as HttpClient, vn as reorderPinnedThread, wn as settleThread, xM as succeed, xn as revertThreadCheckpoint, yM as serviceOption, yn as respondToThreadApproval, zN as getOrThrow, za as ConnectionWakeups, zj as catch_ } from "../../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/state/threadSnapshotHttp.ts
 const DEFAULT_THREAD_SNAPSHOT_TIMEOUT_MS = 6e3;
 const fetchEnvironmentThreadSnapshot = fn("clientRuntime.state.fetchEnvironmentThreadSnapshot")(function* (input) {

package/dist/client-runtime/state/vcs.d.ts

@@ -1,4 +1,4 @@
-import { Aa as ConnectionPersistenceError, Aw as VcsListRefsResult, CD as EnvironmentId, Cw as TextGenerationError, Da as EnvironmentSupervisor, JC as VcsProcessOutputReadError, KC as VcsProcessMissingExitCodeError, Ly as OrchestrationThreadDetailSnapshot, Na as EnvironmentCacheStore, Nw as VcsRef$1, Oy as OrchestrationShellSnapshot, QC as VcsProcessTimeoutError, Qw as SourceControlProviderError, RD as ThreadId, Rw as VcsStatusResult, Sw as GitStackedAction, Ta as EnvironmentRegistry, UC as VcsProcessExitError, YC as VcsProcessSpawnError, ZC as VcsProcessStdinWriteError, _ as AtomCommandResult, _w as GitRunStackedActionInput, cw as GitCommandError, du as ServerConfig, f as AtomCommand, iD as EnvironmentAuthorizationError, iw as GitActionProgressEvent, kw as VcsListRefsInput, lw as GitManagerError, mn as EnvironmentRpcUnavailableError, pw as GitPullRequestMaterializationError, qC as VcsProcessOutputLimitError, rw as VcsUnsupportedOperationError, tw as VcsRepositoryDetectionError, vw as GitRunStackedActionResult, wa as EnvironmentNotRegisteredError } from "../../shared.js";
+import { $O as EnvironmentAuthorizationError, Aa as EnvironmentSupervisor, Cw as VcsProcessExitError, Da as EnvironmentNotRegisteredError, Dw as VcsProcessOutputLimitError, Ew as VcsProcessMissingExitCodeError, Fw as VcsRepositoryDetectionError, Hw as GitCommandError, Ia as EnvironmentCacheStore, Lw as VcsUnsupportedOperationError, Mw as VcsProcessTimeoutError, Na as ConnectionPersistenceError, Nk as ThreadId, Oa as EnvironmentRegistry, Ow as VcsProcessOutputReadError, Qw as GitRunStackedActionResult, Rw as GitActionProgressEvent, Su as ServerConfig, UD as SourceControlProviderError, Uw as GitManagerError, Zw as GitRunStackedActionInput, _ as AtomCommandResult, ab as OrchestrationShellSnapshot, f as AtomCommand, hn as EnvironmentRpcUnavailableError, jw as VcsProcessStdinWriteError, kw as VcsProcessSpawnError, lT as VcsListRefsInput, mb as OrchestrationThreadDetailSnapshot, nT as GitStackedAction, pT as VcsRef$1, qw as GitPullRequestMaterializationError, rT as TextGenerationError, uT as VcsListRefsResult, vT as VcsStatusResult, vk as EnvironmentId } from "../../shared.js";
 import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";
 import * as Schema from "effect/Schema";

package/dist/client-runtime/state/vcs.js

@@ -1,4 +1,4 @@
-import { $r as make, AA as fail$1, AD as TaggedErrorClass, Aj as none, Ba as safeErrorLogAttributes, Bk as gen, CA as exponential, Cw as EnvironmentId, DD as Number, DO as filterMap, Dk as catch_, ED as NullOr, FA as squash, Fy as get, Ia as EnvironmentSupervisor, Jr as runStream, KO as switchMap, LD as decodeUnknownSync, LO as retry, Ld as GitStackedAction, MA as hasInterruptsOnly, MD as Union, MO as map, NO as mapAccum, Nk as flatMap, OD as String, OO as fromEffect, Pk as fn, Py as changes, Q as applyGitStatusStreamEvent, Qr as keepAlive, St as vcsCommandScheduler, TO as empty, Tr as followStreamInEnvironment, Us as WS_METHODS, VO as runForEach, Wa as EnvironmentCacheStore, Wk as logWarning, YO as unwrap, Yr as subscribe, Zr as family, ai as failure, aj as failVoid, bA as void_, bO as changes$1, bk as as, br as createRuntimeCommand, bt as withVcsRefsPersistenceLock, cA as succeed, dj as min, ei as setIdleTTL, fA as tapError, hr as createEnvironmentRpcCommand, jD as Tuple, jj as some, jk as fail, jr as runStreamInEnvironment, kj as match, kk as ensuring, lA as suspend, lO as nowUnsafe, lj as succeed$1, nA as provideService, ni as withLabel, oi as isSuccess, pj as seconds, qr as request, ri as AtomRegistry, rt as isTemporaryWorktreeBranch, uA as sync, uO as toEpochMillis, vt as invalidateCachedVcsRefs, wA as modifyDelay, wD as Literals, wd as GitActionProgressPhase, xD as Defect, xO as concat, xt as vcsCommandConcurrency, yk as annotateLogs, yr as createEnvironmentSubscriptionAtomFamily, yt as vcsRefsCacheStateAtom } from "../../shared.js";
+import { $r as isSuccess, Bk as Tuple, By as changes, CM as sync, DN as seconds, Dr as followStreamInEnvironment, Fk as NullOr, GM as hasInterruptsOnly, GN as none, Gj as flatMap, Gr as keepAlive, Ha as safeErrorLogAttributes, IA as empty, IM as exponential, Ik as Number, JA as retry, JM as squash, KN as some, Ka as EnvironmentCacheStore, Kj as fn, Kk as decodeUnknownSync, Kr as make, LM as modifyDelay, Lk as String, MA as concat, ME as EnvironmentId, Mj as as, NM as void_, Nk as Literals, Nr as runStreamInEnvironment, Q as applyGitStatusStreamEvent, QA as runForEach, Qj as gen, Qr as failure, RA as filterMap, Ra as EnvironmentSupervisor, SM as suspend, SN as succeed$1, Sr as createRuntimeCommand, St as vcsCommandScheduler, TM as tapError, TN as min, UA as map, UM as fail$1, Uj as fail, Vj as ensuring, Vk as Union, Vy as get, WA as mapAccum, WN as match, Wr as family, Xr as AtomRegistry, Yr as withLabel, _r as createEnvironmentRpcCommand, bA as nowUnsafe, bf as GitStackedAction, bt as withVcsRefsPersistenceLock, ci as subscribe, hM as provideService, jA as changes$1, jj as annotateLogs, kk as Defect, lc as WS_METHODS, nM as logWarning, oi as request, qr as setIdleTTL, rj as switchMap, rt as isTemporaryWorktreeBranch, sf as GitActionProgressPhase, si as runStream, sj as unwrap, vN as failVoid, vt as invalidateCachedVcsRefs, xA as toEpochMillis, xM as succeed, xr as createEnvironmentSubscriptionAtomFamily, xt as vcsCommandConcurrency, yt as vcsRefsCacheStateAtom, zA as fromEffect, zj as catch_, zk as TaggedErrorClass } from "../../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/state/gitActions.ts
 function buildGitActionProgressStages(input) {
 	const branchStages = input.featureBranch ? ["Preparing feature branch..."] : [];

package/dist/config.d.ts

@@ -1,4 +1,4 @@
-import { $i as ConfigServiceError, $n as T3CliEnvShape, Ar as cipher_d_exports, Cr as service_d_exports, Dr as KeystoreUnavailableError, Er as service_d_exports$1, Or as EncryptedToken, Qi as ConfigError, Qn as T3CliEnvScope, Sr as service_d_exports$2, Tr as T3MasterKeyKeystoreFactory, Zi as UrlError, Zn as T3CliEnvConfig, _r as EncryptedConfig, br as UpsertEnvironmentInput, er as loadT3CliEnv, gr as config_d_exports, jr as CredentialCipherError, kr as T3CredentialCipher, vr as EnvironmentSummary, wr as MasterKeyReadResult, yr as ResolvedConfig } from "./shared.js";
+import { $n as T3CliEnvConfig, Ar as EncryptedToken, Dr as T3MasterKeyKeystoreFactory, Er as MasterKeyReadResult, Mr as cipher_d_exports, Nr as CredentialCipherError, Or as service_d_exports$1, Sr as UpsertEnvironmentInput, Tr as service_d_exports, br as EnvironmentSummary, ea as UrlError, er as T3CliEnvScope, jr as T3CredentialCipher, kr as KeystoreUnavailableError, na as ConfigServiceError, nr as loadT3CliEnv, ta as ConfigError, tr as T3CliEnvShape, vr as config_d_exports, wr as service_d_exports$2, xr as ResolvedConfig, yr as EncryptedConfig } from "./shared.js";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import * as Layer from "effect/Layer";

package/dist/config.js

@@ -1,5 +1,5 @@
 import { n as __exportAll } from "./rolldown-runtime.js";
-import { $T as loadT3CliEnv, $w as config_exports, AT as cipher_exports, BA as succeed, Bk as gen, CT as file_exports, DT as service_exports$1, ET as resolveT3cliConfigDir, Fi as resolveT3BaseDir, Fs as cipher_node_exports, Ls as CredentialCipherError, Ms as keyring_node_exports, OT as ConfigError, Ps as KeystoreUnavailableError, QT as T3CliEnvConfig, ST as service_exports, TT as resolveKeyFilePath, aT as validateEnvironmentName, cT as toWebSocketBaseUrl, eT as service_exports$2, hA as tryPromise, iT as slugifyEnvironmentName, jT as credentialTokenFromEnv, jk as fail, kT as T3CredentialCipher, lT as toWebSocketEndpointUrl, nT as defaultEnvironmentNameFromUrl, oT as normalizeHttpBaseUrl, rT as migrateV1EnvironmentName, sT as toHttpEndpointUrl, tT as defaultEnvironmentNameForLocal, uT as UrlError, wT as resolveConfigFilePath } from "./shared.js";
+import { $M as succeed, AD as file_exports, Bs as CredentialCipherError, FD as ConfigError, Fs as keyring_node_exports, ID as T3CredentialCipher, LD as cipher_exports, Li as resolveT3BaseDir, Ls as KeystoreUnavailableError, MD as resolveKeyFilePath, ND as resolveT3cliConfigDir, OM as tryPromise, PD as service_exports$1, Qj as gen, RD as credentialTokenFromEnv, Rs as cipher_node_exports, Uj as fail, _D as UrlError, aO as T3CliEnvConfig, cD as defaultEnvironmentNameForLocal, dD as slugifyEnvironmentName, fD as validateEnvironmentName, gD as toWebSocketEndpointUrl, hD as toWebSocketBaseUrl, jD as resolveConfigFilePath, kD as service_exports, lD as defaultEnvironmentNameFromUrl, mD as toHttpEndpointUrl, oD as config_exports, oO as loadT3CliEnv, pD as normalizeHttpBaseUrl, sD as service_exports$2, uD as migrateV1EnvironmentName } from "./shared.js";
 //#region src/config/credential/cipher-web.ts
 var cipher_web_exports = /* @__PURE__ */ __exportAll({ layerWeb: () => layerWeb });
 const aesGcmAlgorithm = "AES-GCM";

package/dist/connection.d.ts

@@ -1,4 +1,4 @@
-import { Gn as T3CodeConnectionProvider, Jn as T3CodeAuth, Kn as T3CodeConnectionProviderLive, Xi as T3CodeConnectionError, Xn as T3CodeOrigin, Yn as T3CodeConnection, qn as makeT3CodeConnectionProvider, vi as T3Rpc } from "./shared.js";
+import { $i as T3CodeConnectionError, Jn as T3CodeConnectionProviderLive, Qn as T3CodeOrigin, Xn as T3CodeAuth, Yn as makeT3CodeConnectionProvider, Zn as T3CodeConnection, bi as T3Rpc, qn as T3CodeConnectionProvider } from "./shared.js";
 import * as Layer from "effect/Layer";
 //#region src/connection/layer.d.ts
 declare function makeT3CodeRpcLayer(): Layer.Layer<T3Rpc, never, import("effect/unstable/http/HttpClient").HttpClient | T3CodeConnectionProvider | import("effect/unstable/socket/Socket").WebSocketConstructor>;

package/dist/connection.js

@@ -1,2 +1,2 @@
-import { Fn as T3CodeRpcLayer, In as makeT3CodeRpcLayer, ci as T3CodeConnectionProvider, li as T3CodeConnectionProviderLive, na as T3CodeConnectionError, ui as makeT3CodeConnectionProvider } from "./shared.js";
+import { Fn as T3CodeRpcLayer, In as makeT3CodeRpcLayer, di as T3CodeConnectionProviderLive, fi as makeT3CodeConnectionProvider, ia as T3CodeConnectionError, ui as T3CodeConnectionProvider } from "./shared.js";
 export { T3CodeConnectionError, T3CodeConnectionProvider, T3CodeConnectionProviderLive, T3CodeRpcLayer, makeT3CodeConnectionProvider, makeT3CodeRpcLayer };

package/dist/contracts.d.ts

@@ -1,2 +1,2 @@
-import { Gx as PREVIEW_VIEWPORT_PRESET_IDS, Iu as ServerProvider, LE as AuthClientPresentationMetadata, Ny as OrchestrationThread, Oy as OrchestrationShellSnapshot, Sx as PreviewAutomationResponse, Vy as OrchestrationThreadShell, ax as PreviewAutomationHostFocus, bx as PreviewAutomationResizeInput, cS as PreviewViewportPresetId, hy as OrchestrationMessage, ix as PreviewAutomationHost, kx as PreviewAutomationStreamEvent, lS as PreviewViewportSetting, vy as OrchestrationProjectShell } from "./shared.js";
+import { $x as PreviewAutomationResponse, Fx as PreviewAutomationHost, HS as PreviewViewportPresetId, Ix as PreviewAutomationHostFocus, Ky as OrchestrationMessage, MO as AuthClientPresentationMetadata, TS as PREVIEW_VIEWPORT_PRESET_IDS, US as PreviewViewportSetting, Yy as OrchestrationProjectShell, Zx as PreviewAutomationResizeInput, ab as OrchestrationShellSnapshot, oS as PreviewAutomationStreamEvent, qu as ServerProvider, ub as OrchestrationThread, vb as OrchestrationThreadShell } from "./shared.js";
 export { type AuthClientPresentationMetadata, type OrchestrationMessage, type OrchestrationProjectShell, type OrchestrationShellSnapshot, type OrchestrationThread, type OrchestrationThreadShell, PREVIEW_VIEWPORT_PRESET_IDS, type PreviewAutomationHost, type PreviewAutomationHostFocus, type PreviewAutomationResizeInput, type PreviewAutomationResponse, type PreviewAutomationStreamEvent, type PreviewViewportPresetId, PreviewViewportSetting, type ServerProvider };

package/dist/contracts.js

@@ -1,2 +1,2 @@
-import { oy as PREVIEW_VIEWPORT_PRESET_IDS, wy as PreviewViewportSetting } from "./shared.js";
+import { Ay as PreviewViewportSetting, fy as PREVIEW_VIEWPORT_PRESET_IDS } from "./shared.js";
 export { PREVIEW_VIEWPORT_PRESET_IDS, PreviewViewportSetting };

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-import { An as AppLayer, Di as SendThreadInput, Mi as T3Application, Oi as StartThreadInput, jn as AuthAppLayer, ki as StartThreadPolicy, qi as ApplicationError, zi as WaitEvent } from "./shared.js";
+import { Fi as T3Application, Hi as WaitEvent, Ki as ApplicationError, Mi as StartThreadPolicy, Mn as AppLayer, Nn as AuthAppLayer, ji as StartThreadInput, ki as SendThreadInput } from "./shared.js";
 export { AppLayer, type ApplicationError, AuthAppLayer, type SendThreadInput, type StartThreadInput, type StartThreadPolicy, T3Application, type WaitEvent };

package/dist/index.js

@@ -1,2 +1,2 @@
-import { Ln as AppLayer, Rn as AuthAppLayer, tE as T3Application } from "./shared.js";
+import { Ln as AppLayer, Rn as AuthAppLayer, cO as T3Application } from "./shared.js";
 export { AppLayer, AuthAppLayer, T3Application };

package/dist/node.d.ts

@@ -1,4 +1,4 @@
-import { Gn as T3CodeConnectionProvider, vi as T3Rpc } from "./shared.js";
+import { bi as T3Rpc, qn as T3CodeConnectionProvider } from "./shared.js";
 import * as Layer from "effect/Layer";
 //#region src/node/connection.d.ts
 declare const T3CodeNodeRpcLayer: Layer.Layer<T3Rpc, never, T3CodeConnectionProvider>;

package/dist/node.js

@@ -1,4 +1,4 @@
-import { As as layerWebSocketConstructor, Fn as T3CodeRpcLayer, LA as mergeAll, RA as provide, js as layerUndici } from "./shared.js";
+import { Fn as T3CodeRpcLayer, Ns as layerWebSocketConstructor, Ps as layerUndici, XM as mergeAll, ZM as provide } from "./shared.js";
 //#region src/node/connection.ts
 const NodeConnectionPlatformLayer = mergeAll(layerUndici, layerWebSocketConstructor);
 const T3CodeNodeRpcLayer = T3CodeRpcLayer.pipe(provide(NodeConnectionPlatformLayer));

package/dist/orchestration.d.ts

@@ -1,7 +1,8 @@
-import { Hi as Orchestration, Hy as OrchestrationThreadStreamItem, Oy as OrchestrationShellSnapshot, Ui as OrchestrationError, Vi as OpenThread, Wi as T3Orchestration, Yi as RpcError, mi as T3RpcOperations } from "./shared.js";
+import { Ji as Orchestration, Qi as RpcError, Ss as ThreadSnapshotRequestError, Xi as T3Orchestration, Yi as OrchestrationError, ab as OrchestrationShellSnapshot, gi as T3RpcOperations, hb as OrchestrationThreadDetailWindow, jn as T3PreparedConnectionProvider, mb as OrchestrationThreadDetailSnapshot, qi as OpenThread, yb as OrchestrationThreadStreamItem } from "./shared.js";
 import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";
 import * as Layer from "effect/Layer";
+import { HttpClient } from "effect/unstable/http";
 //#region src/orchestration/layer.d.ts
 declare const makeT3Orchestration: () => Effect.Effect<{
   dispatch: (command: {
@@ -333,6 +334,7 @@ declare const makeT3Orchestration: () => Effect.Effect<{
         readonly output: string | null;
       };
     }[];
+    readonly threadSnapshotPagination?: boolean;
   }, RpcError, never>;
   getShellSnapshot: () => Effect.Effect<{
     readonly snapshotSequence: number;
@@ -655,6 +657,10 @@ declare const makeT3Orchestration: () => Effect.Effect<{
       readonly updatedAt: string;
     } | null;
   }, RpcError, never>;
+  getThreadDetailSnapshot: (input: {
+    readonly threadId: string;
+    readonly window?: OrchestrationThreadDetailWindow;
+  }) => Effect.Effect<OrchestrationThreadDetailSnapshot, OrchestrationError>;
   watchShellSnapshots: () => Stream.Stream<OrchestrationShellSnapshot, OrchestrationError, import("effect/Scope").Scope>;
   watchShellSequence: () => Stream.Stream<number, OrchestrationError, import("effect/Scope").Scope>;
   watchThreadItems: (threadId: string) => Stream.Stream<OrchestrationThreadStreamItem, OrchestrationError, import("effect/Scope").Scope>;
@@ -1555,9 +1561,9 @@ declare const makeT3Orchestration: () => Effect.Effect<{
           readonly createdAt: string;
         };
       };
-    }, RpcError, never>;
-  }, RpcError, import("effect/Scope").Scope>;
-}, never, T3RpcOperations>;
-declare const T3OrchestrationLive: Layer.Layer<T3Orchestration, never, T3RpcOperations>;
+    }, OrchestrationError, never>;
+  }, OrchestrationError, import("effect/Scope").Scope>;
+}, never, HttpClient.HttpClient | T3PreparedConnectionProvider | T3RpcOperations>;
+declare const T3OrchestrationLive: Layer.Layer<T3Orchestration, never, HttpClient.HttpClient | T3PreparedConnectionProvider | T3RpcOperations>;
 //#endregion
-export { type OpenThread, type Orchestration, type OrchestrationError, T3Orchestration, T3OrchestrationLive, makeT3Orchestration };
+export { type OpenThread, type Orchestration, type OrchestrationError, T3Orchestration, T3OrchestrationLive, ThreadSnapshotRequestError, makeT3Orchestration };

package/dist/orchestration.js

@@ -1,2 +1,2 @@
-import { er as T3OrchestrationLive, ks as T3Orchestration, tr as makeT3Orchestration } from "./shared.js";
-export { T3Orchestration, T3OrchestrationLive, makeT3Orchestration };
+import { Ms as T3Orchestration, er as T3OrchestrationLive, nr as ThreadSnapshotRequestError, tr as makeT3Orchestration } from "./shared.js";
+export { T3Orchestration, T3OrchestrationLive, ThreadSnapshotRequestError, makeT3Orchestration };

package/dist/preview.d.ts

@@ -1,2 +1,2 @@
-import { Hn as T3PreviewAutomation, Sx as PreviewAutomationResponse, Un as T3PreviewAutomationLive, Wn as makeT3PreviewAutomation, ax as PreviewAutomationHostFocus, ix as PreviewAutomationHost, kx as PreviewAutomationStreamEvent } from "./shared.js";
+import { $x as PreviewAutomationResponse, Fx as PreviewAutomationHost, Gn as T3PreviewAutomationLive, Ix as PreviewAutomationHostFocus, Kn as makeT3PreviewAutomation, Wn as T3PreviewAutomation, oS as PreviewAutomationStreamEvent } from "./shared.js";
 export { type PreviewAutomationHost, type PreviewAutomationHostFocus, type PreviewAutomationResponse, type PreviewAutomationStreamEvent, T3PreviewAutomation, T3PreviewAutomationLive, makeT3PreviewAutomation };

package/dist/rpc.d.ts

@@ -1,16 +1,9 @@
-import { $b as PreviewAutomationControlInterruptedError, $o as ConnectionAttemptError, $v as OrchestrationDispatchCommandError, AS as TerminalSessionLookupError, Ax as PreviewAutomationTabNotFoundError, Cx as PreviewAutomationResultTooLargeError, Cy as OrchestrationSearchThreadsError, Dd as KeybindingsConfigError, ES as TerminalResizeError, FS as TerminalWriteError, Fx as PreviewAutomationUnavailableError, Ix as PreviewAutomationUnsupportedClientError, Jb as PreviewAutomationClientDisconnectedError, Ji as OrchestrationError, Mx as PreviewAutomationTargetNotEditableError, Nx as PreviewAutomationTimeoutError, SS as TerminalHistoryError, Xi as T3CodeConnectionError, Yi as RpcError, _S as TerminalCwdNotDirectoryError, _i as makeT3RpcOperations, _x as PreviewAutomationRemoteUnavailableError, bi as WsClient, cx as PreviewAutomationMalformedResponseError, dx as PreviewAutomationNoAvailableHostError, gi as T3RpcOperationsService, hi as T3RpcOperationsLive, iD as EnvironmentAuthorizationError, mi as T3RpcOperations, os as ConnectionTransientError, oy as OrchestrationGetSnapshotError, rx as PreviewAutomationExecutionError, sx as PreviewAutomationInvalidSelectorError, us as PreparedConnection, vS as TerminalCwdNotFoundError, vi as T3Rpc, wS as TerminalNotRunningError, xi as CliServerConfig, yS as TerminalCwdStatError, yi as T3RpcService, yv as ServerSettingsError, yx as PreviewAutomationRequestQueueClosedError } from "./shared.js";
+import { $O as EnvironmentAuthorizationError, $S as TerminalCwdStatError, Ax as PreviewAutomationControlInterruptedError, Ay as OrchestrationDispatchCommandError, Ci as CliServerConfig, Hx as PreviewAutomationNoAvailableHostError, Jx as PreviewAutomationRemoteUnavailableError, Ly as OrchestrationGetSnapshotError, Px as PreviewAutomationExecutionError, QS as TerminalCwdNotFoundError, Qi as RpcError, Rd as KeybindingsConfigError, Rx as PreviewAutomationInvalidSelectorError, Si as WsClient, Tx as PreviewAutomationClientDisconnectedError, Xv as ServerSettingsError, Xx as PreviewAutomationRequestQueueClosedError, ZS as TerminalCwdNotDirectoryError, Zi as OrchestrationError, _i as T3RpcOperationsLive, bi as T3Rpc, eS as PreviewAutomationResultTooLargeError, eb as OrchestrationSearchThreadsError, fS as PreviewAutomationUnavailableError, gi as T3RpcOperations, hC as TerminalWriteError, iC as TerminalNotRunningError, jn as T3PreparedConnectionProvider, lS as PreviewAutomationTargetNotEditableError, ms as PreparedConnection, nC as TerminalHistoryError, oC as TerminalResizeError, pS as PreviewAutomationUnsupportedClientError, rs as ConnectionAttemptError, sS as PreviewAutomationTabNotFoundError, uC as TerminalSessionLookupError, uS as PreviewAutomationTimeoutError, us as ConnectionTransientError, vi as T3RpcOperationsService, xi as T3RpcService, yi as makeT3RpcOperations, zx as PreviewAutomationMalformedResponseError } from "./shared.js";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
 import * as Scope from "effect/Scope";
+import * as Layer from "effect/Layer";
 import "effect/unstable/socket/Socket";
-import { HttpClient } from "effect/unstable/http";
-//#region src/connection/prepared.d.ts
-declare const T3PreparedConnectionProvider_base: Context.ServiceClass<T3PreparedConnectionProvider, "t3cli/T3PreparedConnectionProvider", {
-  readonly get: Effect.Effect<PreparedConnection, ConnectionAttemptError | T3CodeConnectionError>;
-}>;
-declare class T3PreparedConnectionProvider extends T3PreparedConnectionProvider_base {}
-//#endregion
 //#region src/rpc/session.d.ts
 interface T3RpcSession {
   readonly client: WsClient;
@@ -2847,6 +2840,7 @@ declare const makeT3RpcLayer: () => Effect.Effect<{
           readonly output: string | null;
         };
       }[];
+      readonly threadSnapshotPagination?: boolean;
     }, import("effect/unstable/rpc/RpcClientError").RpcClientError | (Discard extends true ? never : EnvironmentAuthorizationError | KeybindingsConfigError | ServerSettingsError), never>;
     readonly "server.probe": <const AsQueue extends boolean = false, const Discard = false>(input: {}, options?: {
       readonly headers?: import("effect/unstable/http/Headers").Input | undefined;
@@ -6119,6 +6113,7 @@ declare const makeT3RpcLayer: () => Effect.Effect<{
           readonly output: string | null;
         };
       }[];
+      readonly threadSnapshotPagination?: boolean;
     }, import("effect/unstable/rpc/RpcClientError").RpcClientError | (Discard extends true ? never : EnvironmentAuthorizationError | KeybindingsConfigError | ServerSettingsError), never>;
     readonly "server.probe": <const AsQueue extends boolean = false, const Discard = false>(input: {}, options?: {
       readonly headers?: import("effect/unstable/http/Headers").Input | undefined;

package/dist/rpc.js

@@ -1,2 +1,2 @@
-import { $i as makeT3RpcOperations, Qi as T3RpcOperationsLive, Xn as makeT3RpcLayer, Yn as T3RpcLive, Zi as T3RpcOperations, ea as T3Rpc, ta as RpcError } from "./shared.js";
+import { $i as T3RpcOperations, Xn as makeT3RpcLayer, Yn as T3RpcLive, ea as T3RpcOperationsLive, na as T3Rpc, ra as RpcError, ta as makeT3RpcOperations } from "./shared.js";
 export { RpcError, T3Rpc, T3RpcLive, T3RpcOperations, T3RpcOperationsLive, makeT3RpcLayer, makeT3RpcOperations };

package/dist/runtime.d.ts

@@ -1,2 +1,2 @@
-import { An as AppLayer, Bn as T3OrchestrationLayer, Fn as T3AuthPairingLayer, In as T3AuthTransportLayer, Ln as T3LocalAuthLayer, Mn as BaseAppLayer, Nn as BaseAuthAppLayer, Pn as T3AuthLayer, Rn as T3LocalAuthOriginLayer, Vn as T3PreviewAutomationLayer, jn as AuthAppLayer, zn as T3LocalAuthTokenLayer } from "./shared.js";
+import { Bn as T3LocalAuthOriginLayer, Fn as BaseAuthAppLayer, Hn as T3OrchestrationLayer, In as T3AuthLayer, Ln as T3AuthPairingLayer, Mn as AppLayer, Nn as AuthAppLayer, Pn as BaseAppLayer, Rn as T3AuthTransportLayer, Un as T3PreviewAutomationLayer, Vn as T3LocalAuthTokenLayer, zn as T3LocalAuthLayer } from "./shared.js";
 export { AppLayer, AuthAppLayer, BaseAppLayer, BaseAuthAppLayer, T3AuthLayer, T3AuthPairingLayer, T3AuthTransportLayer, T3LocalAuthLayer, T3LocalAuthOriginLayer, T3LocalAuthTokenLayer, T3OrchestrationLayer, T3PreviewAutomationLayer };

package/dist/shared/DrainableWorker.js

@@ -1,4 +1,4 @@
-import { Ay as get, Bk as gen, Dy as shutdown, Ey as offer, Lk as forever, Ny as update, Oy as take, _A as tx, bA as void_, dA as tap, hk as acquireRelease, jy as make, kk as ensuring, ky as unbounded, vA as txRetry, zk as forkScoped } from "../shared.js";
+import { AM as tx, Dj as acquireRelease, Fy as unbounded, Iy as get, Ly as make, My as offer, NM as void_, Ny as shutdown, Py as take, Qj as gen, Vj as ensuring, Yj as forever, Zj as forkScoped, jM as txRetry, wM as tap, zy as update } from "../shared.js";
 //#region upstream-t3code/packages/shared/src/DrainableWorker.ts
 /**
 * Create a drainable worker that processes items from an unbounded queue.

package/dist/shared/KeyedCoalescingWorker.js

@@ -1,4 +1,4 @@
-import { Ay as get, Bk as gen, Ck as catchCause, Dy as shutdown, Ey as offer, Lk as forever, My as modify, Nk as flatMap, Oy as take, _A as tx, bA as void_, dA as tap, hk as acquireRelease, jy as make, ky as unbounded, vA as txRetry, xk as asVoid, zk as forkScoped } from "../shared.js";
+import { AM as tx, Dj as acquireRelease, Fj as catchCause, Fy as unbounded, Gj as flatMap, Iy as get, Ly as make, My as offer, NM as void_, Nj as asVoid, Ny as shutdown, Py as take, Qj as gen, Ry as modify, Yj as forever, Zj as forkScoped, jM as txRetry, wM as tap } from "../shared.js";
 //#region upstream-t3code/packages/shared/src/KeyedCoalescingWorker.ts
 const makeKeyedCoalescingWorker = (options) => gen(function* () {
 	const queue = yield* acquireRelease(unbounded(), shutdown);

package/dist/shared/Net.d.ts

@@ -18,6 +18,11 @@ interface NetServiceShape {
    * Checks loopback availability on both IPv4 and IPv6 localhost addresses.
    */
   readonly isPortAvailableOnLoopback: (port: number) => Effect.Effect<boolean>;
+  /**
+   * Returns true when something accepts TCP connections on {host, port}.
+   * Unlike the bind-side checks this works for privileged ports (<1024).
+   */
+  readonly hasListenerOnHost: (port: number, host: string) => Effect.Effect<boolean>;
   /**
    * Reserve an ephemeral loopback port and release it immediately.
    */
@@ -35,6 +40,7 @@ declare class NetService extends NetService_base {}
 declare const make: () => {
   canListenOnHost: (port: number, host: string) => Effect.Effect<boolean>;
   isPortAvailableOnLoopback: (port: number) => Effect.Effect<boolean>;
+  hasListenerOnHost: (port: number, host: string) => Effect.Effect<boolean>;
   reserveLoopbackPort: (host?: string) => Effect.Effect<number, NetError>;
   findAvailablePort: (preferred: number) => Effect.Effect<number, NetError, never>;
 };

package/dist/shared/Net.js

@@ -1,4 +1,4 @@
-import { Bj as hasProperty, Bk as gen, Gj as isString, SA as zipWith, Sk as callback, VA as sync$1, Wj as isObject, cA as succeed, hj as Service, jk as fail, kA as TaggedError, uA as sync } from "../shared.js";
+import { AN as Service, CM as sync, FM as zipWith, HM as TaggedError, Pj as callback, Qj as gen, Uj as fail, aP as isObject, eN as sync$1, oP as isString, tP as hasProperty, xM as succeed } from "../shared.js";
 import * as NodeNet from "node:net";
 //#region upstream-t3code/packages/shared/src/Net.ts
 var NetError = class extends TaggedError("NetError") {};
@@ -114,6 +114,7 @@ const make = () => {
 	return {
 		canListenOnHost,
 		isPortAvailableOnLoopback,
+		hasListenerOnHost,
 		reserveLoopbackPort,
 		findAvailablePort: (preferred) => gen(function* () {
 			if (preferred > 0 && (yield* isPortAvailableOnLoopback(preferred))) return preferred;

package/dist/shared/advertisedEndpoint.d.ts

@@ -1,2 +1,2 @@
-import { Dn as createAdvertisedEndpoint, En as classifyHostedHttpsCompatibility, On as deriveWsBaseUrl, Tn as CreateAdvertisedEndpointInput, kn as normalizeHttpBaseUrl } from "../shared.js";
+import { An as normalizeHttpBaseUrl, Dn as classifyHostedHttpsCompatibility, En as CreateAdvertisedEndpointInput, On as createAdvertisedEndpoint, kn as deriveWsBaseUrl } from "../shared.js";
 export { CreateAdvertisedEndpointInput, classifyHostedHttpsCompatibility, createAdvertisedEndpoint, deriveWsBaseUrl, normalizeHttpBaseUrl };

package/dist/shared/advertisedEndpoint.js

@@ -1,2 +1,2 @@
-import { Go as createAdvertisedEndpoint, Ko as deriveWsBaseUrl, Wo as classifyHostedHttpsCompatibility, qo as normalizeHttpBaseUrl } from "../shared.js";
+import { Jo as createAdvertisedEndpoint, Xo as normalizeHttpBaseUrl, Yo as deriveWsBaseUrl, qo as classifyHostedHttpsCompatibility } from "../shared.js";
 export { classifyHostedHttpsCompatibility, createAdvertisedEndpoint, deriveWsBaseUrl, normalizeHttpBaseUrl };

package/dist/shared/agentAwareness.d.ts

@@ -1,4 +1,4 @@
-import { CD as EnvironmentId, RD as ThreadId, Vy as OrchestrationThreadShell, vy as OrchestrationProjectShell } from "../shared.js";
+import { Nk as ThreadId, Yy as OrchestrationProjectShell, vb as OrchestrationThreadShell, vk as EnvironmentId } from "../shared.js";
 //#region upstream-t3code/packages/shared/src/agentAwareness.d.ts
 type AgentAwarenessPhase = "starting" | "running" | "waiting_for_approval" | "waiting_for_input" | "completed" | "failed" | "stale";
 interface AgentAwarenessState {

package/dist/shared/backgroundActivitySettings.d.ts

@@ -1,4 +1,4 @@
-import { b_ as BackgroundActivitySettings, v_ as BackgroundActivityProfile, vv as ServerSettings } from "../shared.js";
+import { Y_ as BackgroundActivityProfile, Yv as ServerSettings, Z_ as BackgroundActivitySettings } from "../shared.js";
 import * as Duration from "effect/Duration";
 //#region upstream-t3code/packages/shared/src/backgroundActivitySettings.d.ts
 interface ResolvedBackgroundActivitySettings {

package/dist/shared/connectAuth.d.ts

@@ -13,18 +13,37 @@ declare const CONNECT_OAUTH_SCOPES: readonly ["openid", "profile", "email"];
 interface ConnectAuthorizeRequest {
   readonly state: string;
   readonly challenge: string;
+  /**
+   * Present when a loopback CLI initiated the request: the hosted /connect
+   * page then asks Clerk to redirect the authorization code straight to
+   * `http://127.0.0.1:<port>/callback` instead of the hosted callback page.
+   */
+  readonly loopbackPort?: number;
 }
 /**
- * The URL a headless CLI prints for the user to open on a machine with a
- * browser. `state` and `code_challenge` ride the fragment so they never reach
- * the hosted app's server or CDN logs; neither is a secret.
+ * The URL the CLI prints for the user to open in a browser. `state` and
+ * `code_challenge` ride the fragment so they never reach the hosted app's
+ * server or CDN logs; neither is a secret.
+ *
+ * Both CLI flows route through the hosted /connect page rather than hitting
+ * Clerk's /oauth/authorize directly: a signed-out browser sent straight to
+ * /oauth/authorize goes through Clerk's sign-in redirect, which does not
+ * reliably preserve the authorize query parameters (state, response_type,
+ * code_challenge). The hosted page waits for a Clerk session first, then
+ * forwards the request with the parameters intact.
  */
 declare function buildConnectAuthorizeRequestUrl(input: {
   readonly hostedAppUrl: string;
   readonly state: string;
   readonly challenge: string;
+  readonly loopbackPort?: number;
 }): string;
 declare function readConnectAuthorizeRequest(url: URL): ConnectAuthorizeRequest | null;
+/**
+ * Redirect URI for the CLI's local callback listener. Must stay in sync with
+ * the redirect URI registered on the Clerk CLI OAuth application.
+ */
+declare function connectLoopbackRedirectUri(port: number): string;
 declare function connectCallbackUrl(hostedAppUrl: string): string;
 declare function buildConnectClerkAuthorizeUrl(input: {
   readonly authorizationEndpoint: string;
@@ -55,4 +74,4 @@ declare function encodeConnectAuthCode(input: ConnectAuthCode): string;
 declare function checkConnectAuthCode(blob: string, expectedState: string): ConnectAuthCode | string;
 declare function parseConnectAuthCode(blob: string): ConnectAuthCode | null;
 //#endregion
-export { CONNECT_OAUTH_SCOPES, ConnectAuthCode, ConnectAuthorizeRequest, DEFAULT_HOSTED_APP_URL, buildConnectAuthorizeRequestUrl, buildConnectClerkAuthorizeUrl, checkConnectAuthCode, connectCallbackUrl, encodeConnectAuthCode, parseConnectAuthCode, readConnectAuthorizeRequest };
+export { CONNECT_OAUTH_SCOPES, ConnectAuthCode, ConnectAuthorizeRequest, DEFAULT_HOSTED_APP_URL, buildConnectAuthorizeRequestUrl, buildConnectClerkAuthorizeUrl, checkConnectAuthCode, connectCallbackUrl, connectLoopbackRedirectUri, encodeConnectAuthCode, parseConnectAuthCode, readConnectAuthorizeRequest };

package/dist/shared/connectAuth.js

@@ -1,8 +1,10 @@
-import { Oa as readHashParams } from "../shared.js";
+import { Aa as readHashParams } from "../shared.js";
 //#region upstream-t3code/packages/shared/src/connectAuth.ts
 const CONNECT_AUTH_STATE_PARAM = "state";
 const CONNECT_AUTH_CHALLENGE_PARAM = "challenge";
+const CONNECT_AUTH_PORT_PARAM = "port";
 const CONNECT_AUTH_CODE_SEPARATOR = ".";
+const CONNECT_LOOPBACK_CALLBACK_PATH = "/callback";
 const CONNECT_AUTHORIZE_PATH = "/connect";
 const CONNECT_CALLBACK_PATH = "/connect/callback";
 /**
@@ -21,13 +23,24 @@ const CONNECT_OAUTH_SCOPES = [
 	"email"
 ];
 /**
-* The URL a headless CLI prints for the user to open on a machine with a
-* browser. `state` and `code_challenge` ride the fragment so they never reach
-* the hosted app's server or CDN logs; neither is a secret.
+* The URL the CLI prints for the user to open in a browser. `state` and
+* `code_challenge` ride the fragment so they never reach the hosted app's
+* server or CDN logs; neither is a secret.
+*
+* Both CLI flows route through the hosted /connect page rather than hitting
+* Clerk's /oauth/authorize directly: a signed-out browser sent straight to
+* /oauth/authorize goes through Clerk's sign-in redirect, which does not
+* reliably preserve the authorize query parameters (state, response_type,
+* code_challenge). The hosted page waits for a Clerk session first, then
+* forwards the request with the parameters intact.
 */
 function buildConnectAuthorizeRequestUrl(input) {
 	const url = new URL(CONNECT_AUTHORIZE_PATH, input.hostedAppUrl);
-	url.hash = new URLSearchParams([[CONNECT_AUTH_STATE_PARAM, input.state], [CONNECT_AUTH_CHALLENGE_PARAM, input.challenge]]).toString();
+	url.hash = new URLSearchParams([
+		[CONNECT_AUTH_STATE_PARAM, input.state],
+		[CONNECT_AUTH_CHALLENGE_PARAM, input.challenge],
+		...input.loopbackPort === void 0 ? [] : [[CONNECT_AUTH_PORT_PARAM, String(input.loopbackPort)]]
+	]).toString();
 	return url.toString();
 }
 function readConnectAuthorizeRequest(url) {
@@ -35,10 +48,30 @@ function readConnectAuthorizeRequest(url) {
 	const state = params.get(CONNECT_AUTH_STATE_PARAM)?.trim() ?? "";
 	const challenge = params.get(CONNECT_AUTH_CHALLENGE_PARAM)?.trim() ?? "";
 	if (!state || !challenge) return null;
-	return {
+	const port = params.get(CONNECT_AUTH_PORT_PARAM);
+	if (port === null) return {
 		state,
 		challenge
 	};
+	const loopbackPort = parseLoopbackPort(port.trim());
+	if (loopbackPort === null) return null;
+	return {
+		state,
+		challenge,
+		loopbackPort
+	};
+}
+function parseLoopbackPort(value) {
+	if (!/^\d{1,5}$/.test(value)) return null;
+	const port = Number(value);
+	return port >= 1 && port <= 65535 ? port : null;
+}
+/**
+* Redirect URI for the CLI's local callback listener. Must stay in sync with
+* the redirect URI registered on the Clerk CLI OAuth application.
+*/
+function connectLoopbackRedirectUri(port) {
+	return `http://127.0.0.1:${port}${CONNECT_LOOPBACK_CALLBACK_PATH}`;
 }
 function connectCallbackUrl(hostedAppUrl) {
 	return new URL(CONNECT_CALLBACK_PATH, hostedAppUrl).toString();
@@ -86,4 +119,4 @@ function parseConnectAuthCode(blob) {
 	};
 }
 //#endregion
-export { CONNECT_OAUTH_SCOPES, DEFAULT_HOSTED_APP_URL, buildConnectAuthorizeRequestUrl, buildConnectClerkAuthorizeUrl, checkConnectAuthCode, connectCallbackUrl, encodeConnectAuthCode, parseConnectAuthCode, readConnectAuthorizeRequest };
+export { CONNECT_OAUTH_SCOPES, DEFAULT_HOSTED_APP_URL, buildConnectAuthorizeRequestUrl, buildConnectClerkAuthorizeUrl, checkConnectAuthCode, connectCallbackUrl, connectLoopbackRedirectUri, encodeConnectAuthCode, parseConnectAuthCode, readConnectAuthorizeRequest };

package/dist/shared/devHome.js

@@ -1,4 +1,4 @@
-import { $k as orElseSucceed, Bk as gen, Dj as isSome, Zk as option, fO as Path, mO as FileSystem } from "../shared.js";
+import { CA as Path, HN as isSome, Qj as gen, TA as FileSystem, fM as orElseSucceed, uM as option } from "../shared.js";
 //#region upstream-t3code/packages/shared/src/devHome.ts
 /**
 * Where development state lives, and how to keep it away from the shared

package/dist/shared/dpop.js

@@ -1,4 +1,4 @@
-import { BD as isNonEmpty, CD as Literal, Ej as isNone, HD as optionalKey, ID as decodeUnknownOption, OD as String$1, RD as fromJsonString, SD as Int, TD as Never, aO as decodeBase64Url, kD as Struct, n as normalizeDpopHtu, oO as decodeBase64UrlString, oj as getOrThrow, r as stableStringify, sO as encodeBase64Url, t as DpopPublicJwk$1 } from "../shared.js";
+import { Gk as decodeUnknownOption, Lk as String$1, Mk as Literal, Pk as Never, Rk as Struct, VN as isNone, Yk as isNonEmpty, Zk as optionalKey, gA as encodeBase64Url, hA as decodeBase64UrlString, jk as Int, mA as decodeBase64Url, n as normalizeDpopHtu, qk as fromJsonString, r as stableStringify, t as DpopPublicJwk$1, yN as getOrThrow } from "../shared.js";
 import * as nc from "node:crypto";
 //#region node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/cryptoNode.js
 /**

package/dist/shared/git.d.ts

@@ -1,4 +1,4 @@
-import { $w as SourceControlProviderInfo, Iw as VcsStatusLocalResult, Lw as VcsStatusRemoteResult, Nw as VcsRef, Rw as VcsStatusResult, zw as VcsStatusStreamEvent } from "../shared.js";
+import { WD as SourceControlProviderInfo, _T as VcsStatusRemoteResult, gT as VcsStatusLocalResult, pT as VcsRef, vT as VcsStatusResult, yT as VcsStatusStreamEvent } from "../shared.js";
 //#region upstream-t3code/packages/shared/src/git.d.ts
 declare const WORKTREE_BRANCH_PREFIX = "t3code";
 /**

package/dist/shared/httpObservability.js

@@ -1,2 +1,2 @@
-import { Ho as httpHeaderRedactionLayer } from "../shared.js";
+import { Go as httpHeaderRedactionLayer } from "../shared.js";
 export { httpHeaderRedactionLayer };

package/dist/shared/httpReadiness.js

@@ -1,4 +1,4 @@
-import { Bk as gen, EA as upTo, Kk as mapError, Pk as fn, TA as spaced, Uk as logDebug, Vk as ignore, Wk as logWarning, _T as get, bT as set, cA as succeed, dT as HttpClient, fA as tapError, fT as filterStatusOk, hT as transform, jk as fail, kj as match, mT as tap, pA as timeoutOption, pT as retry, uj as millis, vT as get$1, yT as make } from "../shared.js";
+import { $j as ignore, DD as set, ED as make, EM as timeoutOption, Kj as fn, Qj as gen, RM as spaced, SD as transform, TD as get$1, TM as tapError, Uj as fail, WN as match, bD as retry, iM as mapError, nM as logWarning, tM as logDebug, vD as HttpClient, wD as get, wN as millis, xD as tap, xM as succeed, yD as filterStatusOk, zM as upTo } from "../shared.js";
 //#region upstream-t3code/packages/shared/src/httpReadiness.ts
 const DEFAULT_HTTP_READY_PROBE_TIMEOUT_MS = 1e3;
 /**

package/dist/shared/keybindings.d.ts

@@ -1,4 +1,4 @@
-import { Ld as ResolvedKeybindingRule, Rd as ResolvedKeybindingsConfig, Sd as KeybindingShortcut, Td as KeybindingWhenNode, xd as KeybindingRule } from "../shared.js";
+import { Id as KeybindingWhenNode, Jd as ResolvedKeybindingRule, Md as KeybindingRule, Nd as KeybindingShortcut, Yd as ResolvedKeybindingsConfig } from "../shared.js";
 //#region upstream-t3code/packages/shared/src/keybindings.d.ts
 declare const DEFAULT_KEYBINDINGS: ReadonlyArray<KeybindingRule>;
 declare function parseKeybindingShortcut(value: string): KeybindingShortcut | null;

package/dist/shared/model.d.ts

@@ -1,4 +1,4 @@
-import { Hm as ProviderInstanceId, Im as ProviderDriverKind, Wv as ModelSelection, Zd as ModelCapabilities, rf as ProviderOptionSelection, tf as ProviderOptionDescriptor } from "../shared.js";
+import { $m as ProviderInstanceId, cf as ModelCapabilities, ff as ProviderOptionDescriptor, mf as ProviderOptionSelection, qm as ProviderDriverKind, xy as ModelSelection } from "../shared.js";
 //#region upstream-t3code/packages/shared/src/model.d.ts
 interface SelectableModelOption {
   slug: string;

package/dist/shared/oauthScope.js

@@ -1,2 +1,2 @@
-import { Jo as OAuthScopeEncodingError, Qo as parseOAuthScope, Xo as oauthScopeSetEquals, Yo as encodeOAuthScope, Zo as parseAllowedOAuthScope } from "../shared.js";
+import { $o as oauthScopeSetEquals, Qo as encodeOAuthScope, Zo as OAuthScopeEncodingError, es as parseAllowedOAuthScope, ts as parseOAuthScope } from "../shared.js";
 export { OAuthScopeEncodingError, encodeOAuthScope, oauthScopeSetEquals, parseAllowedOAuthScope, parseOAuthScope };

package/dist/shared/observability.js

@@ -1,4 +1,4 @@
-import { $A as make, D as RotatingFileSink, Dj as isSome, Lk as forever, MA as hasInterruptsOnly, Nk as flatMap, PA as pretty, Pk as fn, QA as NativeSpan, Tj as getOrUndefined, Vk as ignore, XA as isSuccess, bA as void_, gk as addFinalizer, jA as findErrorOption, sA as sleep, uA as sync, vk as andThen, xA as withTracerEnabled, zk as forkScoped } from "../shared.js";
+import { $j as ignore, Aj as andThen, BN as getOrUndefined, CM as sync, D as RotatingFileSink, GM as hasInterruptsOnly, Gj as flatMap, HN as isSome, Kj as fn, NM as void_, Oj as addFinalizer, PM as withTracerEnabled, WM as findErrorOption, Yj as forever, Zj as forkScoped, bM as sleep, dN as NativeSpan, fN as make, lN as isSuccess, qM as pretty } from "../shared.js";
 //#region upstream-t3code/packages/shared/src/observability.ts
 const FLUSH_BUFFER_THRESHOLD = 256;
 const textEncoder = new TextEncoder();

package/dist/shared/preview.js

@@ -1,4 +1,4 @@
-import { AD as TaggedErrorClass, DD as Number, OD as String, VD as optional, wD as Literals, xD as Defect, zD as is } from "../shared.js";
+import { Ik as Number, Jk as is, Lk as String, Nk as Literals, Xk as optional, kk as Defect, zk as TaggedErrorClass } from "../shared.js";
 //#region upstream-t3code/packages/shared/src/preview.ts
 /**
 * Pure URL helpers shared between the preview server, desktop main process,

package/dist/shared/previewViewport.d.ts

@@ -1,4 +1,4 @@
-import { bx as PreviewAutomationResizeInput, cS as PreviewViewportPresetId, lS as PreviewViewportSetting } from "../shared.js";
+import { HS as PreviewViewportPresetId, US as PreviewViewportSetting, Zx as PreviewAutomationResizeInput } from "../shared.js";
 //#region upstream-t3code/packages/shared/src/previewViewport.d.ts
 interface PreviewViewportPreset {
   readonly id: PreviewViewportPresetId;

package/dist/shared/previewViewport.js

@@ -1,4 +1,4 @@
-import { oy as PREVIEW_VIEWPORT_PRESET_IDS } from "../shared.js";
+import { fy as PREVIEW_VIEWPORT_PRESET_IDS } from "../shared.js";
 //#region upstream-t3code/packages/shared/src/previewViewport.ts
 const PREVIEW_VIEWPORT_PRESET_DEFINITIONS = {
 	"iphone-se": {

package/dist/shared/projectScripts.d.ts

@@ -1,4 +1,4 @@
-import { Zy as ProjectScript } from "../shared.js";
+import { Ob as ProjectScript } from "../shared.js";
 //#region upstream-t3code/packages/shared/src/projectScripts.d.ts
 interface ProjectScriptRuntimeEnvInput {
   project: {

package/dist/shared/relayAuth.js

@@ -1,4 +1,4 @@
-import { AD as TaggedErrorClass, OD as String, VD as optional, wD as Literals, xD as Defect } from "../shared.js";
+import { Lk as String, Nk as Literals, Xk as optional, kk as Defect, zk as TaggedErrorClass } from "../shared.js";
 //#region upstream-t3code/packages/shared/src/relayAuth.ts
 const ClerkPublishableKeyPrefix = Literals([
 	"pk_test",

package/dist/shared/relayClient.d.ts

@@ -1,4 +1,4 @@
-import { ST as RelayClientInstallProgressEvent } from "../shared.js";
+import { PT as RelayClientInstallProgressEvent } from "../shared.js";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";