t3code-cli 0.14.2 → 0.15.0

package/dist/cli.d.ts

@@ -1,4 +1,4 @@
-import { $n as T3CliEnvShape, Gi as CliRuntime, Ki as layer$1, Qn as T3CliEnvScope, xr as T3ConfigSelection } from "./shared.js";
+import { Cr as T3ConfigSelection, Gi as layer$1, Wi as CliRuntime, er as T3CliEnvScope, tr as T3CliEnvShape } from "./shared.js";
 import * as Layer from "effect/Layer";
 import { Flag, GlobalFlag } from "effect/unstable/cli";
 //#region src/cli/flags.d.ts

package/dist/cli.js

@@ -1,5 +1,5 @@
 import { n as __exportAll } from "./rolldown-runtime.js";
-import { BT as threadFlag, FT as modelFlags, GT as canRenderLiveTerminal, Gw as resolveProjectRef, HT as waitFormatFlag, Hw as cliEnvironmentSetting, IT as projectFlag, JT as humanNdjsonFormatChoices, KT as humanJsonFormatChoices, Kw as resolveThreadId, LT as projectPathFlag, PT as formatFlag, UT as worktreeFlag, VT as threadFormatFlag, Ww as resolveCommandProjectRef, XT as isInteractiveHumanTerminal, Xw as CliRuntime, YT as isAgentEnvironment, ZT as resolveOutputFormat, Zw as layer, qT as humanJsonNdjsonFormatChoices, qw as resolveWorktreePath, zs as selection_layer_exports } from "./shared.js";
+import { $D as humanJsonFormatChoices, $E as resolveThreadId, HD as modelFlags, Hs as selection_layer_exports, JD as threadFormatFlag, QD as canRenderLiveTerminal, QE as resolveProjectRef, UD as projectFlag, VD as formatFlag, WD as projectPathFlag, XD as worktreeFlag, YD as waitFormatFlag, ZE as resolveCommandProjectRef, eD as resolveWorktreePath, eO as humanJsonNdjsonFormatChoices, iD as layer, iO as resolveOutputFormat, nO as isAgentEnvironment, nc as cliEnvironmentSetting, qD as threadFlag, rD as CliRuntime, rO as isInteractiveHumanTerminal, tO 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

@@ -1,2 +1,2 @@
-import { Ba as RemoteEnvironmentAuthError, Ga as issueRemoteDpopWebSocketTicket, Ha as exchangeRemoteDpopAccessToken, Ja as resolveRemoteWebSocketConnectionUrl, Ka as issueRemoteWebSocketTicket, Qa as RemoteEnvironmentAuthUndeclaredStatusError, Ua as fetchRemoteDpopSessionState, Va as bootstrapRemoteBearerSession, Wa as fetchRemoteSessionState, Xa as RemoteEnvironmentAuthInvalidJsonError, Ya as RemoteEnvironmentAuthFetchError, Za as RemoteEnvironmentAuthTimeoutError, fo as AuthorizedRemoteEnvironment, go as tokenStore_d_exports, mo as RemoteEnvironmentAuthorization, po as RelayEnvironmentAuthorization, qa as resolveRemoteDpopWebSocketConnectionUrl } from "../shared.js";
+import { $a as RemoteEnvironmentAuthInvalidJsonError, Ga as exchangeRemoteDpopAccessToken, Ja as issueRemoteDpopWebSocketTicket, Ka as fetchRemoteDpopSessionState, Qa as RemoteEnvironmentAuthFetchError, Ua as RemoteEnvironmentAuthError, Wa as bootstrapRemoteBearerSession, Xa as resolveRemoteDpopWebSocketConnectionUrl, Ya as issueRemoteWebSocketTicket, Za as resolveRemoteWebSocketConnectionUrl, _o as RelayEnvironmentAuthorization, bo as tokenStore_d_exports, eo as RemoteEnvironmentAuthTimeoutError, go as AuthorizedRemoteEnvironment, qa as fetchRemoteSessionState, to as RemoteEnvironmentAuthUndeclaredStatusError, vo as RemoteEnvironmentAuthorization } 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

@@ -1,2 +1,2 @@
-import { $a as tokenStore_exports, Ao as fetchRemoteSessionState, Do as bootstrapRemoteBearerSession, Fo as RemoteEnvironmentAuthFetchError, Io as RemoteEnvironmentAuthInvalidJsonError, Lo as RemoteEnvironmentAuthTimeoutError, Mo as issueRemoteWebSocketTicket, No as resolveRemoteDpopWebSocketConnectionUrl, Oo as exchangeRemoteDpopAccessToken, Po as resolveRemoteWebSocketConnectionUrl, Ro as RemoteEnvironmentAuthUndeclaredStatusError, Za as RemoteEnvironmentAuthorization, jo as issueRemoteDpopWebSocketTicket, ko as fetchRemoteDpopSessionState } from "../shared.js";
+import { $a as RemoteEnvironmentAuthorization, Ao as exchangeRemoteDpopAccessToken, Bo as RemoteEnvironmentAuthUndeclaredStatusError, Fo as resolveRemoteDpopWebSocketConnectionUrl, Io as resolveRemoteWebSocketConnectionUrl, Lo as RemoteEnvironmentAuthFetchError, Mo as fetchRemoteSessionState, No as issueRemoteDpopWebSocketTicket, Po as issueRemoteWebSocketTicket, Ro as RemoteEnvironmentAuthInvalidJsonError, jo as fetchRemoteDpopSessionState, ko as bootstrapRemoteBearerSession, to as tokenStore_exports, zo as RemoteEnvironmentAuthTimeoutError } 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

@@ -1,2 +1,2 @@
-import { $o as ConnectionAttemptError, Bo as ConnectionCatalogEntry, Ca as updateBearerConnection, Da as EnvironmentSupervisor, Ea as PlatformEnvironmentRemovalError, Fa as credentialMissingError, Fo as credentialStore_d_exports, Go as PrimaryConnectionRegistration, Ho as ConnectionProfile, Ia as environmentMismatchError, Io as connectivity_d_exports, Jo as SshConnectionRegistration, Ko as RelayConnectionRegistration, La as mapManagedRelayError, Lo as BearerConnectionCredential, Oa as EnvironmentSupervisorOptions, Qo as BearerConnectionTarget, Ra as mapRemoteEnvironmentError, Ro as BearerConnectionProfile, Sa as registerSshConnection, Ta as EnvironmentRegistry, Uo as ConnectionRegistration, Vo as ConnectionCredential, Wo as PlatformConnectionRegistration, Xo as connectionRegistrationTarget, Yo as connectionRegistrationCatalogEntry, Zo as AVAILABLE_CONNECTION_STATE, _a as SshConnectionInput, _s as connectionProjectionPhase, aa as connectionStatusText, ao as EnvironmentConnectionLease, as as ConnectionTargetKind, ba as prepareSshRegistration, ca as presentEnvironmentConnection, cs as NetworkStatus, do as profileStore_d_exports, ds as PreparedHttpAuthorization, ea as EnvironmentConnectionPhase, es as ConnectionAttemptStage, fs as PrimaryConnectionTarget, ga as PairingConnectionInput, gs as SupervisorConnectionState, ha as ConnectionOnboarding, hs as SupervisorConnectionPhase, ia as connectionPhaseMessage, io as ConnectionDriverProgress, is as ConnectionTarget, ka as wakeups_d_exports, la as layer_d_exports, ls as PersistedConnectionTarget, ma as BearerConnectionUpdateInput, ms as SshConnectionTarget, na as EnvironmentPresentation, ns as ConnectionBlockedReason, oa as connectionStatusTitle, os as ConnectionTransientError, ps as RelayConnectionTarget, qo as SshConnectionProfile, ra as connectionCatalogDisplayUrl, ro as ConnectionDriver, rs as ConnectionProjectionPhase, sa as presentConnectionState, ss as ConnectionTransientReason, ta as EnvironmentConnectionPresentation, ts as ConnectionBlockedError, uo as ConnectionResolver, us as PreparedConnection, va as prepareBearerConnectionUpdate, wa as EnvironmentNotRegisteredError, xa as registerPairingConnection, ya as preparePairingRegistration, za as profileMissingError, zo as BearerConnectionRegistration } from "../shared.js";
+import { $o as connectionRegistrationCatalogEntry, Aa as EnvironmentSupervisor, Ba as mapManagedRelayError, Bo as connectivity_d_exports, Ca as prepareSshRegistration, Da as EnvironmentNotRegisteredError, Ea as updateBearerConnection, Go as ConnectionCredential, Ha as profileMissingError, Ho as BearerConnectionProfile, Jo as PlatformConnectionRegistration, Ko as ConnectionProfile, Ma as wakeups_d_exports, Oa as EnvironmentRegistry, Qo as SshConnectionRegistration, Ra as credentialMissingError, Sa as preparePairingRegistration, Ta as registerSshConnection, Uo as BearerConnectionRegistration, Va as mapRemoteEnvironmentError, Vo as BearerConnectionCredential, Wo as ConnectionCatalogEntry, Xo as RelayConnectionRegistration, Yo as PrimaryConnectionRegistration, Zo as SshConnectionProfile, _a as BearerConnectionUpdateInput, _s as RelayConnectionTarget, aa as EnvironmentPresentation, as as ConnectionBlockedError, ba as SshConnectionInput, bs as SupervisorConnectionState, ca as connectionStatusText, co as ConnectionDriverProgress, cs as ConnectionTarget, da as presentEnvironmentConnection, ds as ConnectionTransientReason, es as connectionRegistrationTarget, fa as layer_d_exports, fs as NetworkStatus, gs as PrimaryConnectionTarget, ho as profileStore_d_exports, hs as PreparedHttpAuthorization, ia as EnvironmentConnectionPresentation, is as ConnectionAttemptStage, ja as EnvironmentSupervisorOptions, ka as PlatformEnvironmentRemovalError, la as connectionStatusTitle, lo as EnvironmentConnectionLease, ls as ConnectionTargetKind, mo as ConnectionResolver, ms as PreparedConnection, ns as BearerConnectionTarget, oa as connectionCatalogDisplayUrl, os as ConnectionBlockedReason, ps as PersistedConnectionTarget, qo as ConnectionRegistration, ra as EnvironmentConnectionPhase, rs as ConnectionAttemptError, sa as connectionPhaseMessage, so as ConnectionDriver, ss as ConnectionProjectionPhase, ts as AVAILABLE_CONNECTION_STATE, ua as presentConnectionState, us as ConnectionTransientError, va as ConnectionOnboarding, vs as SshConnectionTarget, wa as registerPairingConnection, xa as prepareBearerConnectionUpdate, xs as connectionProjectionPhase, ya as PairingConnectionInput, ys as SupervisorConnectionPhase, za as environmentMismatchError, zo as credentialStore_d_exports } 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

@@ -1,2 +1,2 @@
-import { Co as environmentMismatchError, Cs as ConnectionTransientReason, Ds as SshConnectionTarget, Eo as profileMissingError, Es as RelayConnectionTarget, Fa as PlatformEnvironmentRemovalError, Ia as EnvironmentSupervisor, Ka as ConnectionDriver, Na as EnvironmentNotRegisteredError, Os as connectionProjectionPhase, Pa as EnvironmentRegistry, So as credentialMissingError, Ss as ConnectionTransientError, To as mapRemoteEnvironmentError, Ts as PrimaryConnectionTarget, Xa as profileStore_exports, Ya as ConnectionResolver, _a as prepareSshRegistration, _s as AVAILABLE_CONNECTION_STATE, aa as connectionStatusText, as as BearerConnectionProfile, ba as updateBearerConnection, bs as ConnectionBlockedReason, ca as presentEnvironmentConnection, cs as ConnectionProfile, ds as PrimaryConnectionRegistration, fs as RelayConnectionRegistration, ga as preparePairingRegistration, gs as connectionRegistrationTarget, ha as prepareBearerConnectionUpdate, hs as connectionRegistrationCatalogEntry, ia as connectionPhaseMessage, is as BearerConnectionCredential, la as layer_exports, ls as ConnectionRegistration, ma as ConnectionOnboarding, ms as SshConnectionRegistration, ns as credentialStore_exports, oa as connectionStatusTitle, os as BearerConnectionRegistration, ps as SshConnectionProfile, ra as connectionCatalogDisplayUrl, rs as connectivity_exports, sa as presentConnectionState, ss as ConnectionCredential, us as PlatformConnectionRegistration, va as registerPairingConnection, vs as BearerConnectionTarget, wo as mapManagedRelayError, ws as PersistedConnectionTarget, xs as ConnectionTarget, ya as registerSshConnection, ys as ConnectionBlockedError, za as wakeups_exports } from "../shared.js";
+import { As as SshConnectionTarget, Cs as ConnectionBlockedReason, Do as mapRemoteEnvironmentError, Ds as PersistedConnectionTarget, Eo as mapManagedRelayError, Es as ConnectionTransientReason, Fa as EnvironmentNotRegisteredError, Ia as EnvironmentRegistry, Ja as ConnectionDriver, La as PlatformEnvironmentRemovalError, Oo as profileMissingError, Os as PrimaryConnectionTarget, Qa as profileStore_exports, Ra as EnvironmentSupervisor, Sa as updateBearerConnection, Ss as ConnectionBlockedError, To as environmentMismatchError, Ts as ConnectionTransientError, Va as wakeups_exports, Za as ConnectionResolver, _a as prepareBearerConnectionUpdate, _s as SshConnectionRegistration, aa as connectionCatalogDisplayUrl, as as credentialStore_exports, ba as registerPairingConnection, bs as AVAILABLE_CONNECTION_STATE, ca as connectionStatusTitle, cs as BearerConnectionProfile, da as layer_exports, ds as ConnectionProfile, fs as ConnectionRegistration, ga as ConnectionOnboarding, gs as SshConnectionProfile, hs as RelayConnectionRegistration, js as connectionProjectionPhase, ks as RelayConnectionTarget, la as presentConnectionState, ls as BearerConnectionRegistration, ms as PrimaryConnectionRegistration, oa as connectionPhaseMessage, os as connectivity_exports, ps as PlatformConnectionRegistration, sa as connectionStatusText, ss as BearerConnectionCredential, ua as presentEnvironmentConnection, us as ConnectionCredential, va as preparePairingRegistration, vs as connectionRegistrationCatalogEntry, wo as credentialMissingError, ws as ConnectionTarget, xa as registerSshConnection, xs as BearerConnectionTarget, ya as prepareSshRegistration, ys as connectionRegistrationTarget } 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

@@ -1,4 +1,4 @@
-import { $a as RemoteEnvironmentRequestError, CD as EnvironmentId, Dn as createAdvertisedEndpoint, En as classifyHostedHttpsCompatibility, On as deriveWsBaseUrl, RD as ThreadId, Tn as CreateAdvertisedEndpointInput, cE as ExecutionEnvironmentDescriptor, hE as ScopedThreadRef, jD as ProjectId, kn as normalizeHttpBaseUrl, mE as ScopedProjectRef } from "../shared.js";
+import { An as normalizeHttpBaseUrl, Dn as classifyHostedHttpsCompatibility, Ek as ProjectId, En as CreateAdvertisedEndpointInput, Nk as ThreadId, On as createAdvertisedEndpoint, kn as deriveWsBaseUrl, lO as ScopedProjectRef, no as RemoteEnvironmentRequestError, rO as ExecutionEnvironmentDescriptor, uO as ScopedThreadRef, vk 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: {
@@ -15,6 +15,7 @@ declare const fetchRemoteEnvironmentDescriptor: (input: {
   readonly capabilities: {
     readonly repositoryIdentity: boolean;
     readonly connectionProbe?: boolean;
+    readonly pullRequests?: boolean;
     readonly threadSettlement?: boolean;
     readonly threadSnooze?: boolean;
     readonly threadPinning?: boolean;
@@ -22,6 +23,7 @@ declare const fetchRemoteEnvironmentDescriptor: (input: {
     readonly threadTitleRegeneration?: boolean;
     readonly serverSelfUpdate?: "boot-service" | "desktop-managed" | "respawn";
     readonly serverSelfUpdateProgress?: boolean;
+    readonly agentActivityPublishing?: boolean;
   };
 }, RemoteEnvironmentRequestError, import("effect/unstable/http/HttpClient").HttpClient>;
 //#endregion

package/dist/client-runtime/environment.js

@@ -1,2 +1,2 @@
-import { Go as createAdvertisedEndpoint, Ko as deriveWsBaseUrl, Uo as environmentEndpointUrl, Wo as classifyHostedHttpsCompatibility, _i as scopedThreadKey, di as parseScopedProjectKey, fi as parseScopedThreadKey, gi as scopedRefKey, hi as scopedProjectKey, mi as scopeThreadRef, pi as scopeProjectRef, qo as normalizeHttpBaseUrl, vi as attachEnvironmentDescriptor, xo as fetchRemoteEnvironmentDescriptor, yi as createKnownEnvironment } from "../shared.js";
+import { Co as fetchRemoteEnvironmentDescriptor, Jo as createAdvertisedEndpoint, Ko as environmentEndpointUrl, Xo as normalizeHttpBaseUrl, Yo as deriveWsBaseUrl, _i as scopedProjectKey, bi as attachEnvironmentDescriptor, gi as scopeThreadRef, hi as scopeProjectRef, mi as parseScopedThreadKey, pi as parseScopedProjectKey, qo as classifyHostedHttpsCompatibility, vi as scopedRefKey, xi as createKnownEnvironment, yi as scopedThreadKey } from "../shared.js";
 export { attachEnvironmentDescriptor, classifyHostedHttpsCompatibility, createAdvertisedEndpoint, createKnownEnvironment, deriveWsBaseUrl, environmentEndpointUrl, fetchRemoteEnvironmentDescriptor, normalizeHttpBaseUrl, parseScopedProjectKey, parseScopedThreadKey, scopeProjectRef, scopeThreadRef, scopedProjectKey, scopedRefKey, scopedThreadKey };

package/dist/client-runtime/errors.js

@@ -1,4 +1,4 @@
-import { Ba as safeErrorLogAttributes, Pn as findErrorTraceId } from "../shared.js";
+import { Ha as safeErrorLogAttributes, Pn as findErrorTraceId } from "../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/errors/transport.ts
 const TRANSPORT_ERROR_PATTERNS = [
 	/\bSocketCloseError\b/i,

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

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

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

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

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

@@ -1,4 +1,4 @@
-import { Aa as ConnectionPersistenceError, Ao as PrimaryEnvironmentAuth, Do as ClientPresentation, Lo as BearerConnectionCredential, Ma as ConnectionTargetStore, Mo as RelayDeviceIdentity, Na as EnvironmentCacheStore, No as SshEnvironmentGateway, Oo as CloudSession, Pa as EnvironmentOwnedDataCleanup, Qo as BearerConnectionTarget, Ro as BearerConnectionProfile, Uo as ConnectionRegistration, ho as RemoteDpopAccessToken, is as ConnectionTarget, ja as ConnectionRegistrationStore, jo as ProvisionedSshEnvironment, ko as PreparedSshEnvironment, ms as SshConnectionTarget, pa as PlatformConnectionSource, ps as RelayConnectionTarget, qo as SshConnectionProfile } from "../shared.js";
+import { Fa as ConnectionTargetStore, Fo as ProvisionedSshEnvironment, Ho as BearerConnectionProfile, Ia as EnvironmentCacheStore, Io as RelayDeviceIdentity, La as EnvironmentOwnedDataCleanup, Lo as SshEnvironmentGateway, Mo as CloudSession, Na as ConnectionPersistenceError, No as PreparedSshEnvironment, Pa as ConnectionRegistrationStore, Po as PrimaryEnvironmentAuth, Vo as BearerConnectionCredential, Zo as SshConnectionProfile, _s as RelayConnectionTarget, cs as ConnectionTarget, ga as PlatformConnectionSource, jo as ClientPresentation, ns as BearerConnectionTarget, qo as ConnectionRegistration, vs as SshConnectionTarget, yo as RemoteDpopAccessToken } 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<{

package/dist/client-runtime/platform.js

@@ -1,4 +1,4 @@
-import { CD as Literal, Ga as EnvironmentOwnedDataCleanup, Ha as ConnectionRegistrationStore, OD as String, Qa as RemoteDpopAccessToken, Ua as ConnectionTargetStore, Va as ConnectionPersistenceError, Wa as EnvironmentCacheStore, _o as CloudSession, bD as ArraySchema, bo as SshEnvironmentGateway, cs as ConnectionProfile, go as ClientPresentation, kD as Struct, pa as PlatformConnectionSource, ss as ConnectionCredential, vo as PrimaryEnvironmentAuth, ws as PersistedConnectionTarget, yo as RelayDeviceIdentity } from "../shared.js";
+import { Dk as ArraySchema, Ds as PersistedConnectionTarget, Ga as ConnectionTargetStore, Ka as EnvironmentCacheStore, Lk as String, Mk as Literal, Rk as Struct, So as SshEnvironmentGateway, Ua as ConnectionPersistenceError, Wa as ConnectionRegistrationStore, bo as PrimaryEnvironmentAuth, ds as ConnectionProfile, eo as RemoteDpopAccessToken, ha as PlatformConnectionSource, qa as EnvironmentOwnedDataCleanup, us as ConnectionCredential, vo as ClientPresentation, xo as RelayDeviceIdentity, yo as CloudSession } from "../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/platform/storageDocument.ts
 const StoredConnectionCredential = Struct({
 	connectionId: String,

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

@@ -1,4 +1,4 @@
-import { Co as ManagedRelayRequestTimeoutError, Eo as managedRelay_d_exports, Po as RelayClientEnvironmentRecord, So as ManagedRelayRequestProofCreationError, To as ManagedRelayUrlInvalidError, _o as ManagedRelayAccessTokenScopesUnexpectedError, fa as discovery_d_exports, vo as ManagedRelayClient, wo as ManagedRelayTokenProofCreationError, xo as ManagedRelayRequestFailedError, yo as ManagedRelayDpopKeyLoadError } from "../shared.js";
+import { Ao as managedRelay_d_exports, Co as ManagedRelayDpopKeyLoadError, Do as ManagedRelayRequestTimeoutError, Eo as ManagedRelayRequestProofCreationError, Oo as ManagedRelayTokenProofCreationError, Ro as RelayClientEnvironmentRecord, So as ManagedRelayClient, To as ManagedRelayRequestFailedError, ha as discovery_d_exports, ko as ManagedRelayUrlInvalidError, vk as EnvironmentId, xo as ManagedRelayAccessTokenScopesUnexpectedError } from "../shared.js";
 import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";
 import * as Cause from "effect/Cause";
@@ -45,6 +45,11 @@ declare function createManagedRelaySession(input: ManagedRelaySessionInput): Man
 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>;
+/** Removes an environment from the signed-in account without contacting that environment. */
+declare const deregisterManagedRelayEnvironment: (registry: AtomRegistry.AtomRegistry, input: {
+  readonly accountId: string;
+  readonly environmentId: EnvironmentId;
+}) => Effect.Effect<undefined, ManagedRelayAccessTokenScopesUnexpectedError | ManagedRelayDpopKeyLoadError | ManagedRelayRequestFailedError | ManagedRelayRequestProofCreationError | ManagedRelayRequestTimeoutError | ManagedRelaySessionError | ManagedRelayTokenProofCreationError | ManagedRelayUrlInvalidError, ManagedRelayClient>;
 declare function readManagedRelaySnapshotState<A>(result: AsyncResult.AsyncResult<A, unknown>): ManagedRelaySnapshotState<A>;
 declare function createManagedRelayQueryManager(runtime: Atom.AtomRuntime<ManagedRelayClient>, options?: {
   readonly staleTimeMs?: number;
@@ -102,6 +107,7 @@ declare function createManagedRelayQueryManager(runtime: Atom.AtomRuntime<Manage
       readonly capabilities: {
         readonly repositoryIdentity: boolean;
         readonly connectionProbe?: boolean;
+        readonly pullRequests?: boolean;
         readonly threadSettlement?: boolean;
         readonly threadSnooze?: boolean;
         readonly threadPinning?: boolean;
@@ -109,6 +115,7 @@ declare function createManagedRelayQueryManager(runtime: Atom.AtomRuntime<Manage
         readonly threadTitleRegeneration?: boolean;
         readonly serverSelfUpdate?: "boot-service" | "desktop-managed" | "respawn";
         readonly serverSelfUpdateProgress?: boolean;
+        readonly agentActivityPublishing?: boolean;
       };
     } | undefined;
     readonly error?: string | undefined;
@@ -122,4 +129,4 @@ declare function createManagedRelayQueryManager(runtime: Atom.AtomRuntime<Manage
   }): 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 };
+export { discovery_d_exports as Discovery, managedRelay_d_exports as ManagedRelay, ManagedRelayQueryEvent, ManagedRelaySession, ManagedRelaySessionError, ManagedRelaySessionInput, ManagedRelaySnapshotError, ManagedRelaySnapshotState, createManagedRelayQueryManager, createManagedRelaySession, deregisterManagedRelayEnvironment, managedRelayAccountChanges, managedRelaySessionAtom, readManagedRelaySnapshotState, setManagedRelaySession, waitForManagedRelayClerkToken };

package/dist/client-runtime/relay.js

@@ -1,4 +1,4 @@
-import { $r as make, Ab as RelayEnvironmentConnectScope, Bk as gen, Cj as getOrNull, DA as currentTimeMillis, FA as squash, MO as map, Nk as flatMap, Pk as fn, Pn as findErrorTraceId, Qr as keepAlive, Sk as callback, Xk as onExit, Zr as family, bO as changes, cA as succeed, ei as setIdleTTL, eo as ManagedRelayClient, fa as discovery_exports, fo as decodeRelayJwt, hA as tryPromise, ii as toStream, jb as RelayEnvironmentStatusScope, jk as fail, kA as TaggedError, ni as withLabel, no as managedRelay_exports, si as value, ti as swr, uA as sync, wO as drop } from "../shared.js";
+import { BM as currentTimeMillis, CM as sync, FA as drop, Gj as flatMap, Gr as keepAlive, HM as TaggedError, JM as squash, Jr as swr, Kj as fn, Kr as make, Lb as RelayEnvironmentConnectScope, OM as tryPromise, Pj as callback, Pn as findErrorTraceId, Qj as gen, RN as getOrNull, Rb as RelayEnvironmentStatusScope, UA as map, Uj as fail, Wr as family, Yr as withLabel, Zr as toStream, cM as onExit, ei as value, io as managedRelay_exports, jA as changes, ma as discovery_exports, mo as decodeRelayJwt, no as ManagedRelayClient, qr as setIdleTTL, xM as succeed } from "../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/relay/managedRelayState.ts
 const DEFAULT_STALE_TIME_MS = 15e3;
 const DEFAULT_IDLE_TTL_MS = 5 * 6e4;
@@ -100,6 +100,16 @@ const waitForManagedRelayClerkToken = fn("clientRuntime.managedRelaySession.wait
 		return sync(() => unsubscribe?.());
 	});
 });
+/** Removes an environment from the signed-in account without contacting that environment. */
+const deregisterManagedRelayEnvironment = fn("clientRuntime.managedRelaySession.deregisterEnvironment")(function* (registry, input) {
+	const session = registry.get(managedRelaySessionAtom);
+	if (!session || session.accountId !== input.accountId) return yield* new ManagedRelaySessionError({ message: "Sign in to T3 Connect before deregistering an environment." });
+	const clerkToken = yield* readSessionClerkToken(session);
+	yield* (yield* ManagedRelayClient).unlinkEnvironment({
+		clerkToken,
+		environmentId: input.environmentId
+	});
+});
 function requireClerkToken(get, accountId) {
 	const session = get(managedRelaySessionAtom);
 	if (!session || session.accountId !== accountId) return fail(new ManagedRelaySessionError({ message: "Sign in to T3 Connect before loading relay data." }));
@@ -242,4 +252,4 @@ function createManagedRelayQueryManager(runtime, options) {
 	};
 }
 //#endregion
-export { discovery_exports as Discovery, managedRelay_exports as ManagedRelay, ManagedRelaySessionError, ManagedRelaySnapshotError, createManagedRelayQueryManager, createManagedRelaySession, managedRelayAccountChanges, managedRelaySessionAtom, readManagedRelaySnapshotState, setManagedRelaySession, waitForManagedRelayClerkToken };
+export { discovery_exports as Discovery, managedRelay_exports as ManagedRelay, ManagedRelaySessionError, ManagedRelaySnapshotError, createManagedRelayQueryManager, createManagedRelaySession, deregisterManagedRelayEnvironment, managedRelayAccountChanges, managedRelaySessionAtom, readManagedRelaySnapshotState, setManagedRelaySession, waitForManagedRelayClerkToken };

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

@@ -1,2 +1,2 @@
-import { $a as RemoteEnvironmentRequestError, Cn as subscribe, Qa as RemoteEnvironmentAuthUndeclaredStatusError, Sn as runStream, Xa as RemoteEnvironmentAuthInvalidJsonError, Ya as RemoteEnvironmentAuthFetchError, Za as RemoteEnvironmentAuthTimeoutError, _n as EnvironmentSubscriptionRpcTag, an as EnvironmentRpcInput, bn as isRpcClientError, cn as EnvironmentRpcStreamFailure, co as WsRpcProtocolClient, dn as EnvironmentRpcSubscriptionObserver, eo as executeEnvironmentHttpRequest, fn as EnvironmentRpcSuccess, gn as EnvironmentStreamRpcTag, hn as EnvironmentStreamCommandRpcTag, in as EnvironmentRpcFailure, ln as EnvironmentRpcStreamValue, lo as makeWsRpcProtocolClient, mn as EnvironmentRpcUnavailableError, no as remoteHttpClientLayer, on as EnvironmentRpcRequestObservation, oo as RpcSession, pn as EnvironmentRpcTag, sn as EnvironmentRpcRequestObserver, so as RpcSessionFactory, to as makeEnvironmentHttpApiClient, un as EnvironmentRpcSubscriptionObservation, vn as EnvironmentUnaryRpcTag, wn as subscribeDynamic, xn as request, yn as config } from "../shared.js";
-export { EnvironmentRpcFailure, EnvironmentRpcInput, EnvironmentRpcRequestObservation, EnvironmentRpcRequestObserver, EnvironmentRpcStreamFailure, EnvironmentRpcStreamValue, EnvironmentRpcSubscriptionObservation, EnvironmentRpcSubscriptionObserver, EnvironmentRpcSuccess, EnvironmentRpcTag, EnvironmentRpcUnavailableError, EnvironmentStreamCommandRpcTag, EnvironmentStreamRpcTag, EnvironmentSubscriptionRpcTag, EnvironmentUnaryRpcTag, RemoteEnvironmentAuthFetchError, RemoteEnvironmentAuthInvalidJsonError, RemoteEnvironmentAuthTimeoutError, RemoteEnvironmentAuthUndeclaredStatusError, RemoteEnvironmentRequestError, type RpcSession, RpcSessionFactory, WsRpcProtocolClient, config, executeEnvironmentHttpRequest, isRpcClientError, makeEnvironmentHttpApiClient, makeWsRpcProtocolClient, remoteHttpClientLayer, request, runStream, subscribe, subscribeDynamic };
+import { $a as RemoteEnvironmentAuthInvalidJsonError, Cn as runStream, Qa as RemoteEnvironmentAuthFetchError, Sn as request, Tn as subscribeDynamic, _n as EnvironmentStreamRpcTag, an as EnvironmentRpcFailure, ao as makeEnvironmentHttpApiUrlBuilder, bn as config, cn as EnvironmentRpcRequestObserver, dn as EnvironmentRpcSubscriptionObservation, do as RpcSessionFactory, eo as RemoteEnvironmentAuthTimeoutError, fn as EnvironmentRpcSubscriptionObserver, fo as WsRpcProtocolClient, gn as EnvironmentStreamCommandRpcTag, hn as EnvironmentRpcUnavailableError, io as makeEnvironmentHttpApiClient, ln as EnvironmentRpcStreamFailure, mn as EnvironmentRpcTag, no as RemoteEnvironmentRequestError, on as EnvironmentRpcInput, oo as remoteHttpClientLayer, pn as EnvironmentRpcSuccess, po as makeWsRpcProtocolClient, ro as executeEnvironmentHttpRequest, sn as EnvironmentRpcRequestObservation, to as RemoteEnvironmentAuthUndeclaredStatusError, un as EnvironmentRpcStreamValue, uo as RpcSession, vn as EnvironmentSubscriptionRpcTag, wn as subscribe, xn as isRpcClientError, yn as EnvironmentUnaryRpcTag } from "../shared.js";
+export { EnvironmentRpcFailure, EnvironmentRpcInput, EnvironmentRpcRequestObservation, EnvironmentRpcRequestObserver, EnvironmentRpcStreamFailure, EnvironmentRpcStreamValue, EnvironmentRpcSubscriptionObservation, EnvironmentRpcSubscriptionObserver, EnvironmentRpcSuccess, EnvironmentRpcTag, EnvironmentRpcUnavailableError, EnvironmentStreamCommandRpcTag, EnvironmentStreamRpcTag, EnvironmentSubscriptionRpcTag, EnvironmentUnaryRpcTag, RemoteEnvironmentAuthFetchError, RemoteEnvironmentAuthInvalidJsonError, RemoteEnvironmentAuthTimeoutError, RemoteEnvironmentAuthUndeclaredStatusError, RemoteEnvironmentRequestError, type RpcSession, RpcSessionFactory, WsRpcProtocolClient, config, executeEnvironmentHttpRequest, isRpcClientError, makeEnvironmentHttpApiClient, makeEnvironmentHttpApiUrlBuilder, makeWsRpcProtocolClient, remoteHttpClientLayer, request, runStream, subscribe, subscribeDynamic };

package/dist/client-runtime/rpc.js

@@ -1,2 +1,2 @@
-import { Bo as makeEnvironmentHttpApiClient, Fo as RemoteEnvironmentAuthFetchError, Gr as config, Hr as EnvironmentRpcRequestObserver, Io as RemoteEnvironmentAuthInvalidJsonError, Ja as makeWsRpcProtocolClient, Jr as runStream, Kr as isRpcClientError, Lo as RemoteEnvironmentAuthTimeoutError, Ro as RemoteEnvironmentAuthUndeclaredStatusError, Ur as EnvironmentRpcSubscriptionObserver, Vo as remoteHttpClientLayer, Wr as EnvironmentRpcUnavailableError, Xr as subscribeDynamic, Yr as subscribe, qa as RpcSessionFactory, qr as request, zo as executeEnvironmentHttpRequest } from "../shared.js";
-export { EnvironmentRpcRequestObserver, EnvironmentRpcSubscriptionObserver, EnvironmentRpcUnavailableError, RemoteEnvironmentAuthFetchError, RemoteEnvironmentAuthInvalidJsonError, RemoteEnvironmentAuthTimeoutError, RemoteEnvironmentAuthUndeclaredStatusError, RpcSessionFactory, config, executeEnvironmentHttpRequest, isRpcClientError, makeEnvironmentHttpApiClient, makeWsRpcProtocolClient, remoteHttpClientLayer, request, runStream, subscribe, subscribeDynamic };
+import { Bo as RemoteEnvironmentAuthUndeclaredStatusError, Ho as makeEnvironmentHttpApiClient, Lo as RemoteEnvironmentAuthFetchError, Ro as RemoteEnvironmentAuthInvalidJsonError, Uo as makeEnvironmentHttpApiUrlBuilder, Vo as executeEnvironmentHttpRequest, Wo as remoteHttpClientLayer, Xa as makeWsRpcProtocolClient, Ya as RpcSessionFactory, ai as isRpcClientError, ci as subscribe, ii as config, li as subscribeDynamic, ni as EnvironmentRpcSubscriptionObserver, oi as request, ri as EnvironmentRpcUnavailableError, si as runStream, ti as EnvironmentRpcRequestObserver, zo as RemoteEnvironmentAuthTimeoutError } from "../shared.js";
+export { EnvironmentRpcRequestObserver, EnvironmentRpcSubscriptionObserver, EnvironmentRpcUnavailableError, RemoteEnvironmentAuthFetchError, RemoteEnvironmentAuthInvalidJsonError, RemoteEnvironmentAuthTimeoutError, RemoteEnvironmentAuthUndeclaredStatusError, RpcSessionFactory, config, executeEnvironmentHttpRequest, isRpcClientError, makeEnvironmentHttpApiClient, makeEnvironmentHttpApiUrlBuilder, makeWsRpcProtocolClient, remoteHttpClientLayer, request, runStream, subscribe, subscribeDynamic };

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

@@ -1,4 +1,4 @@
-import { CD as EnvironmentId, Ta as EnvironmentRegistry, _C as AssetWorkspaceContextNotFoundError, bC as AssetWorkspaceResolutionError, dC as AssetProjectFaviconNotFoundError, fC as AssetProjectFaviconResolutionError, gC as AssetWorkspaceAssetNotFoundError, hC as AssetWorkspaceAssetInspectionError, iD as EnvironmentAuthorizationError, lC as AssetPreviewTypeValidationError, mC as AssetSigningKeyLoadError, mn as EnvironmentRpcUnavailableError, oC as AssetAttachmentNotFoundError, pC as AssetResource, uC as AssetProjectFaviconInspectionError, vC as AssetWorkspaceContextResolutionError, xC as AssetWorkspaceRootNormalizationError, yC as AssetWorkspacePathValidationError } from "../../shared.js";
+import { $C as AssetWorkspacePathValidationError, $O as EnvironmentAuthorizationError, BC as AssetAttachmentNotFoundError, GC as AssetProjectFaviconNotFoundError, JC as AssetSigningKeyLoadError, KC as AssetProjectFaviconResolutionError, Oa as EnvironmentRegistry, QC as AssetWorkspaceContextResolutionError, UC as AssetPreviewTypeValidationError, WC as AssetProjectFaviconInspectionError, XC as AssetWorkspaceAssetNotFoundError, YC as AssetWorkspaceAssetInspectionError, ZC as AssetWorkspaceContextNotFoundError, ew as AssetWorkspaceResolutionError, hn as EnvironmentRpcUnavailableError, qC as AssetResource, tw as AssetWorkspaceRootNormalizationError, vk as EnvironmentId } from "../../shared.js";
 import * as Schema from "effect/Schema";
 import { Atom } from "effect/unstable/reactivity";
 //#region upstream-t3code/packages/client-runtime/src/state/assets.d.ts

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

@@ -1,4 +1,4 @@
-import { $r as make, AD as TaggedErrorClass, Cw as EnvironmentId, Iu as AssetResource, LD as decodeUnknownSync, OD as String, Us as WS_METHODS, Zr as family, bD as ArraySchema, ei as setIdleTTL, gr as createEnvironmentRpcQueryAtomFamily, jD as Tuple, ni as withLabel, xD as Defect } from "../../shared.js";
+import { Bk as Tuple, Dk as ArraySchema, Kk as decodeUnknownSync, Kr as make, Lk as String, ME as EnvironmentId, Wr as family, Yr as withLabel, kk as Defect, lc as WS_METHODS, qr as setIdleTTL, vr as createEnvironmentRpcQueryAtomFamily, yd as AssetResource, zk as TaggedErrorClass } from "../../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/state/assets.ts
 const ASSET_URL_REFRESH_INTERVAL_MS = 30 * 6e4;
 const ASSET_URL_STALE_TIME_MS = 5 * 6e4;

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

@@ -1,4 +1,4 @@
-import { CD as EnvironmentId, TE as AuthAccessStreamEvent, Ta as EnvironmentRegistry, iD as EnvironmentAuthorizationError, wE as AuthAccessStreamError, xE as AuthAccessSnapshot } from "../../shared.js";
+import { $O as EnvironmentAuthorizationError, Oa as EnvironmentRegistry, bO as AuthAccessStreamEvent, gO as AuthAccessSnapshot, vk as EnvironmentId, yO as AuthAccessStreamError } from "../../shared.js";
 import { Atom } from "effect/unstable/reactivity";
 //#region upstream-t3code/packages/client-runtime/src/state/auth.d.ts
 declare const EMPTY_AUTH_ACCESS_SNAPSHOT: AuthAccessSnapshot;

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

@@ -1,4 +1,4 @@
-import { NO as mapAccum, Us as WS_METHODS, Yr as subscribe, yr as createEnvironmentSubscriptionAtomFamily } from "../../shared.js";
+import { WA as mapAccum, ci as subscribe, lc as WS_METHODS, xr as createEnvironmentSubscriptionAtomFamily } from "../../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/state/auth.ts
 const EMPTY_AUTH_ACCESS_SNAPSHOT = {
 	pairingLinks: [],

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

@@ -1,4 +1,4 @@
-import { $r as make, Gk as map, Ia as EnvironmentSupervisor, MO as map$1, Nk as flatMap, Pa as EnvironmentRegistry, Py as changes, Sj as getOrElse, Tr as followStreamInEnvironment, YO as unwrap, Zr as family, _s as AVAILABLE_CONNECTION_STATE, br as createRuntimeCommand, ni as withLabel, pr as createAtomCommandScheduler, si as value } from "../../shared.js";
+import { By as changes, Dr as followStreamInEnvironment, Gj as flatMap, Ia as EnvironmentRegistry, Kr as make, LN as getOrElse, Ra as EnvironmentSupervisor, Sr as createRuntimeCommand, UA as map$1, Wr as family, Yr as withLabel, bs as AVAILABLE_CONNECTION_STATE, ei as value, mr as createAtomCommandScheduler, rM as map, sj as unwrap } from "../../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/state/connections.ts
 const EMPTY_ENVIRONMENT_CATALOG_STATE = Object.freeze({
 	isReady: false,

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

@@ -1,4 +1,4 @@
-import { hE as ScopedThreadRef, mE as ScopedProjectRef } from "../../shared.js";
+import { lO as ScopedProjectRef, uO as ScopedThreadRef } from "../../shared.js";
 import * as Schema from "effect/Schema";
 //#region upstream-t3code/packages/client-runtime/src/state/entities.d.ts
 declare const InvalidScopedProjectKeyError_base: Schema.Class<InvalidScopedProjectKeyError, Schema.TaggedStruct<"InvalidScopedProjectKeyError", {

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

@@ -1,4 +1,4 @@
-import { CC as FilesystemBrowseError, CD as EnvironmentId, SC as FilesystemBrowseEntry, Ta as EnvironmentRegistry, ea as EnvironmentConnectionPhase, iD as EnvironmentAuthorizationError, mn as EnvironmentRpcUnavailableError } from "../../shared.js";
+import { $O as EnvironmentAuthorizationError, Oa as EnvironmentRegistry, hn as EnvironmentRpcUnavailableError, nw as FilesystemBrowseEntry, ra as EnvironmentConnectionPhase, rw as FilesystemBrowseError, vk as EnvironmentId } from "../../shared.js";
 import { Atom } from "effect/unstable/reactivity";
 //#region upstream-t3code/packages/client-runtime/src/state/filesystem.d.ts
 declare function getFilesystemBrowsePath(query: string, platform?: string, enabled?: boolean): {

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

@@ -1,4 +1,4 @@
-import { Bt as hasTrailingPathSeparator, Ht as isFilesystemBrowseQuery, Lt as getBrowseDirectoryPath, Pt as canNavigateUp, Rt as getBrowseLeafPathSegment, Us as WS_METHODS, gr as createEnvironmentRpcQueryAtomFamily, zt as getBrowseParentPath } from "../../shared.js";
+import { Bt as hasTrailingPathSeparator, Ht as isFilesystemBrowseQuery, Lt as getBrowseDirectoryPath, Pt as canNavigateUp, Rt as getBrowseLeafPathSegment, lc as WS_METHODS, vr as createEnvironmentRpcQueryAtomFamily, zt as getBrowseParentPath } from "../../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/state/filesystem.ts
 function getFilesystemBrowsePath(query, platform = "", enabled = true) {
 	const isBrowsing = enabled && isFilesystemBrowseQuery(query, platform);

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

@@ -1,4 +1,4 @@
-import { CD as EnvironmentId, Cw as TextGenerationError, Qw as SourceControlProviderError, Ta as EnvironmentRegistry, cw as GitCommandError, f as AtomCommand, iD as EnvironmentAuthorizationError, lw as GitManagerError, mn as EnvironmentRpcUnavailableError, pw as GitPullRequestMaterializationError, wa as EnvironmentNotRegisteredError } from "../../shared.js";
+import { $O as EnvironmentAuthorizationError, Da as EnvironmentNotRegisteredError, Hw as GitCommandError, Oa as EnvironmentRegistry, UD as SourceControlProviderError, Uw as GitManagerError, f as AtomCommand, hn as EnvironmentRpcUnavailableError, qw as GitPullRequestMaterializationError, rT as TextGenerationError, vk as EnvironmentId } from "../../shared.js";
 import { Atom } from "effect/unstable/reactivity";
 //#region upstream-t3code/packages/client-runtime/src/state/git.d.ts
 declare function createGitEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<EnvironmentRegistry | R, E>): {
@@ -37,6 +37,7 @@ declare function createGitEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<Envir
     };
     readonly branch: string;
     readonly worktreePath: string | null;
+    readonly isOnPullRequestHead: boolean;
   }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | GitCommandError | GitManagerError | GitPullRequestMaterializationError | import("effect/unstable/rpc/RpcClientError").RpcClientError | SourceControlProviderError | TextGenerationError>;
 };
 //#endregion

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

@@ -1,4 +1,4 @@
-import { St as vcsCommandScheduler, Us as WS_METHODS, gr as createEnvironmentRpcQueryAtomFamily, hr as createEnvironmentRpcCommand, xt as vcsCommandConcurrency } from "../../shared.js";
+import { St as vcsCommandScheduler, _r as createEnvironmentRpcCommand, lc as WS_METHODS, vr as createEnvironmentRpcQueryAtomFamily, xt as vcsCommandConcurrency } from "../../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/state/git.ts
 function createGitEnvironmentAtoms(runtime) {
 	return {

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

@@ -1,2 +1,2 @@
-import { at as EnvironmentProject, ct as scopeProject, dt as selectEnvironmentThreadShell, it as EnvironmentMessage, lt as scopeThread, ot as EnvironmentThread, st as EnvironmentThreadShell, ut as scopeThreadShell } from "../../shared.js";
+import { at as EnvironmentMessage, ct as EnvironmentThreadShell, dt as scopeThreadShell, ft as selectEnvironmentThreadShell, lt as scopeProject, ot as EnvironmentProject, st as EnvironmentThread, ut as scopeThread } from "../../shared.js";
 export { EnvironmentMessage, EnvironmentProject, EnvironmentThread, EnvironmentThreadShell, scopeProject, scopeThread, scopeThreadShell, selectEnvironmentThreadShell };

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

@@ -1,2 +1,2 @@
-import { dr as scopeThreadShell, fr as selectEnvironmentThreadShell, lr as scopeProject, ur as scopeThread } from "../../shared.js";
+import { dr as scopeThread, fr as scopeThreadShell, pr as selectEnvironmentThreadShell, ur as scopeProject } from "../../shared.js";
 export { scopeProject, scopeThread, scopeThreadShell, selectEnvironmentThreadShell };

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

@@ -1,4 +1,4 @@
-import { CD as EnvironmentId, Cy as OrchestrationSearchThreadsError, Ta as EnvironmentRegistry, iD as EnvironmentAuthorizationError, mn as EnvironmentRpcUnavailableError, oy as OrchestrationGetSnapshotError, ry as OrchestrationGetFullThreadDiffError, sy as OrchestrationGetTurnDiffError, uy as OrchestrationGetWorkflowScriptError } from "../../shared.js";
+import { $O as EnvironmentAuthorizationError, Ly as OrchestrationGetSnapshotError, Oa as EnvironmentRegistry, Py as OrchestrationGetFullThreadDiffError, Ry as OrchestrationGetTurnDiffError, Vy as OrchestrationGetWorkflowScriptError, eb as OrchestrationSearchThreadsError, hn as EnvironmentRpcUnavailableError, vk as EnvironmentId } from "../../shared.js";
 import { Atom } from "effect/unstable/reactivity";
 //#region upstream-t3code/packages/client-runtime/src/state/orchestration.d.ts
 declare function createOrchestrationEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<EnvironmentRegistry | R, E>): {

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

@@ -1,4 +1,4 @@
-import { Vb as ORCHESTRATION_WS_METHODS, gr as createEnvironmentRpcQueryAtomFamily } from "../../shared.js";
+import { XS as ORCHESTRATION_WS_METHODS, vr as createEnvironmentRpcQueryAtomFamily } from "../../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/state/orchestration.ts
 function createOrchestrationEnvironmentAtoms(runtime) {
 	return {

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

@@ -1,4 +1,4 @@
-import { Bo as ConnectionCatalogEntry, CD as EnvironmentId, Td as KeybindingWhenNode, du as ServerConfig, gs as SupervisorConnectionState, na as EnvironmentPresentation, ta as EnvironmentConnectionPresentation, u as EnvironmentCatalogState } from "../../shared.js";
+import { Id as KeybindingWhenNode, Su as ServerConfig, Wo as ConnectionCatalogEntry, aa as EnvironmentPresentation, bs as SupervisorConnectionState, ia as EnvironmentConnectionPresentation, u as EnvironmentCatalogState, vk as EnvironmentId } from "../../shared.js";
 import { AsyncResult, Atom } from "effect/unstable/reactivity";
 //#region upstream-t3code/packages/client-runtime/src/state/presentation.d.ts
 declare function createEnvironmentPresentationAtoms<E>(input: {
@@ -22,6 +22,7 @@ declare function createEnvironmentPresentationAtoms<E>(input: {
         readonly capabilities: {
           readonly repositoryIdentity: boolean;
           readonly connectionProbe?: boolean;
+          readonly pullRequests?: boolean;
           readonly threadSettlement?: boolean;
           readonly threadSnooze?: boolean;
           readonly threadPinning?: boolean;
@@ -29,6 +30,7 @@ declare function createEnvironmentPresentationAtoms<E>(input: {
           readonly threadTitleRegeneration?: boolean;
           readonly serverSelfUpdate?: "boot-service" | "desktop-managed" | "respawn";
           readonly serverSelfUpdateProgress?: boolean;
+          readonly agentActivityPublishing?: boolean;
         };
       };
       readonly auth: {
@@ -163,6 +165,10 @@ declare function createEnvironmentPresentationAtoms<E>(input: {
         };
       }[];
       readonly availableEditors: readonly ("antigravity" | "aqua" | "clion" | "cursor" | "datagrip" | "dataspell" | "file-manager" | "goland" | "idea" | "kiro" | "phpstorm" | "pycharm" | "rider" | "rubymine" | "rustrover" | "trae" | "vscode" | "vscode-insiders" | "vscodium" | "webstorm" | "zed")[];
+      readonly remoteOpenTargets?: readonly {
+        readonly kind: "mdns" | "tailscale";
+        readonly host: string;
+      }[];
       readonly observability: {
         readonly logsDirectoryPath: string;
         readonly localTracingEnabled: boolean;

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

@@ -1,4 +1,4 @@
-import { $r as make, Sj as getOrElse, Zr as family, _s as AVAILABLE_CONNECTION_STATE, ca as presentEnvironmentConnection, ni as withLabel, si as value } from "../../shared.js";
+import { Kr as make, LN as getOrElse, Wr as family, Yr as withLabel, bs as AVAILABLE_CONNECTION_STATE, ei as value, ua as presentEnvironmentConnection } from "../../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/state/presentation.ts
 function mapsEqual(left, right) {
 	if (left.size !== right.size) return false;

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

@@ -1,4 +1,4 @@
-import { $b as PreviewAutomationControlInterruptedError, Ax as PreviewAutomationTabNotFoundError, CD as EnvironmentId, Cx as PreviewAutomationResultTooLargeError, Fx as PreviewAutomationUnavailableError, Ix as PreviewAutomationUnsupportedClientError, Jb as PreviewAutomationClientDisconnectedError, Mx as PreviewAutomationTargetNotEditableError, Nx as PreviewAutomationTimeoutError, Ta as EnvironmentRegistry, Yx as PreviewInvalidUrlError, _x as PreviewAutomationRemoteUnavailableError, aS as PreviewSessionLookupError, cx as PreviewAutomationMalformedResponseError, dx as PreviewAutomationNoAvailableHostError, f as AtomCommand, iD as EnvironmentAuthorizationError, mn as EnvironmentRpcUnavailableError, rx as PreviewAutomationExecutionError, sx as PreviewAutomationInvalidSelectorError, wa as EnvironmentNotRegisteredError, yx as PreviewAutomationRequestQueueClosedError } from "../../shared.js";
+import { $O as EnvironmentAuthorizationError, Ax as PreviewAutomationControlInterruptedError, Da as EnvironmentNotRegisteredError, Hx as PreviewAutomationNoAvailableHostError, Jx as PreviewAutomationRemoteUnavailableError, Oa as EnvironmentRegistry, Px as PreviewAutomationExecutionError, Rx as PreviewAutomationInvalidSelectorError, Tx as PreviewAutomationClientDisconnectedError, Xx as PreviewAutomationRequestQueueClosedError, eS as PreviewAutomationResultTooLargeError, f as AtomCommand, fS as PreviewAutomationUnavailableError, hn as EnvironmentRpcUnavailableError, kS as PreviewInvalidUrlError, lS as PreviewAutomationTargetNotEditableError, pS as PreviewAutomationUnsupportedClientError, sS as PreviewAutomationTabNotFoundError, uS as PreviewAutomationTimeoutError, vk as EnvironmentId, zS as PreviewSessionLookupError, zx as PreviewAutomationMalformedResponseError } from "../../shared.js";
 import { Atom } from "effect/unstable/reactivity";
 //#region upstream-t3code/packages/client-runtime/src/state/preview.d.ts
 declare const previewAutomationHostFocusConcurrencyKey: (value: {
@@ -207,7 +207,9 @@ declare function createPreviewEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<E
   }, E | EnvironmentAuthorizationError | import("effect/Cause").NoSuchElementError | import("effect/unstable/rpc/RpcClientError").RpcClientError>>;
   discoveredServers: (target: {
     readonly environmentId: EnvironmentId;
-    readonly input: {};
+    readonly input: {
+      readonly configuredUrls?: readonly string[] | undefined;
+    };
   }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
     readonly servers: readonly {
       readonly host: string;
@@ -221,6 +223,7 @@ declare function createPreviewEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<E
       } | null;
     }[];
     readonly scannedAt: string;
+    readonly configuredUrlProbing?: true | undefined;
   }, E | EnvironmentAuthorizationError | import("effect/Cause").NoSuchElementError | import("effect/unstable/rpc/RpcClientError").RpcClientError>>;
   automationRequests: (target: {
     readonly environmentId: EnvironmentId;

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

@@ -1,4 +1,4 @@
-import { Us as WS_METHODS, gr as createEnvironmentRpcQueryAtomFamily, hr as createEnvironmentRpcCommand, pr as createAtomCommandScheduler, vr as createEnvironmentRpcSubscriptionAtomFamily } from "../../shared.js";
+import { _r as createEnvironmentRpcCommand, br as createEnvironmentRpcSubscriptionAtomFamily, lc as WS_METHODS, mr as createAtomCommandScheduler, vr as createEnvironmentRpcQueryAtomFamily } from "../../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/state/preview.ts
 const previewAutomationHostFocusConcurrencyKey = (value) => JSON.stringify([
 	value.environmentId,
@@ -25,7 +25,8 @@ function createPreviewEnvironmentAtoms(runtime) {
 		}),
 		discoveredServers: createEnvironmentRpcSubscriptionAtomFamily(runtime, {
 			label: "environment-data:preview:discovered-servers",
-			tag: WS_METHODS.subscribeDiscoveredLocalServers
+			tag: WS_METHODS.subscribeDiscoveredLocalServers,
+			idleTtlMs: 0
 		}),
 		automationRequests: createEnvironmentRpcSubscriptionAtomFamily(runtime, {
 			label: "environment-data:preview:automation-requests",

package/dist/client-runtime/state/project-grouping.d.ts

@@ -1,4 +1,4 @@
-import { CD as EnvironmentId, Cv as SidebarProjectGroupingMode, S_ as ClientSettings, at as EnvironmentProject, mE as ScopedProjectRef } from "../../shared.js";
+import { $_ as ClientSettings, ey as SidebarProjectGroupingMode, lO as ScopedProjectRef, ot as EnvironmentProject, vk as EnvironmentId } from "../../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/state/projectGrouping.d.ts
 interface ProjectGroupingSettings {
   readonly sidebarProjectGroupingMode: SidebarProjectGroupingMode;

package/dist/client-runtime/state/project-grouping.js

@@ -1,4 +1,4 @@
-import { hi as scopedProjectKey, ln as normalizeProjectPathForComparison, pi as scopeProjectRef } from "../../shared.js";
+import { _i as scopedProjectKey, hi as scopeProjectRef, ln as normalizeProjectPathForComparison } from "../../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/state/projectGrouping.ts
 function selectProjectGroupingSettings(settings) {
 	return {

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

@@ -1,4 +1,4 @@
-import { $S as ProjectSearchEntriesError, $v as OrchestrationDispatchCommandError, CD as EnvironmentId, Nt as UpdateProjectInput, Oy as OrchestrationShellSnapshot, Ta as EnvironmentRegistry, WS as ProjectListEntriesError, YS as ProjectReadFileResult, at as EnvironmentProject, c as normalizeProjectPathForDispatch, f as AtomCommand, ht as DeleteProjectInput, iD as EnvironmentAuthorizationError, mE as ScopedProjectRef, mn as EnvironmentRpcUnavailableError, nC as ProjectWriteFileError, pt as CreateProjectInput, qS as ProjectReadFileError, r as isExplicitRelativePath, s as normalizeProjectPathForComparison, u as EnvironmentCatalogState, wa as EnvironmentNotRegisteredError } from "../../shared.js";
+import { $O as EnvironmentAuthorizationError, Ay as OrchestrationDispatchCommandError, DC as ProjectReadFileError, Da as EnvironmentNotRegisteredError, IC as ProjectWriteFileError, NC as ProjectSearchEntriesError, Oa as EnvironmentRegistry, Pt as UpdateProjectInput, ab as OrchestrationShellSnapshot, c as normalizeProjectPathForDispatch, f as AtomCommand, gt as DeleteProjectInput, hn as EnvironmentRpcUnavailableError, kC as ProjectReadFileResult, lO as ScopedProjectRef, mt as CreateProjectInput, ot as EnvironmentProject, r as isExplicitRelativePath, s as normalizeProjectPathForComparison, u as EnvironmentCatalogState, vk as EnvironmentId, wC as ProjectListEntriesError } from "../../shared.js";
 import * as Crypto from "effect/Crypto";
 import { Atom } from "effect/unstable/reactivity";
 //#region upstream-t3code/packages/client-runtime/src/state/projectCommands.d.ts