t3code-cli 0.12.0 → 0.14.0

package/dist/client-runtime/relay.js

@@ -0,0 +1,245 @@
+import { $D as flatMap, An as findErrorTraceId, EO as succeed, GO as currentTimeMillis, Gr as family, Ik as getOrNull, Jr as setIdleTTL, KE as map, KO as TaggedError, Kr as keepAlive, NO as tryPromise, OO as sync, PE as changes, QD as fail, Qr as toStream, RE as drop, WD as callback, Xr as withLabel, Ya as managedRelay_exports, Yr as swr, ZO as squash, aO as gen, ao as decodeRelayJwt, eO as fn, mO as onExit, oa as discovery_exports, qa as ManagedRelayClient, qr as make, ti as value, vy as RelayEnvironmentConnectScope, yy as RelayEnvironmentStatusScope } 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;
+const CLERK_TOKEN_EXPIRY_SKEW_MS = 5e3;
+var ManagedRelaySessionError = class extends TaggedError("ManagedRelaySessionError") {};
+var ManagedRelaySnapshotError = class extends TaggedError("ManagedRelaySnapshotError") {};
+const managedRelaySessionAtom = make(null).pipe(keepAlive, withLabel("managed-relay:session"));
+const managedRelaySessionControls = /* @__PURE__ */ new WeakMap();
+function createManagedRelaySession(input) {
+	let cachedToken = null;
+	let pendingToken = null;
+	let readClerkToken = input.readClerkToken;
+	let tokenProviderGeneration = 0;
+	const readCachedClerkToken = async (nowMillis) => {
+		if (cachedToken && cachedToken.expiresAtMillis > nowMillis + CLERK_TOKEN_EXPIRY_SKEW_MS) return cachedToken.token;
+		if (pendingToken) return await pendingToken;
+		const operationGeneration = tokenProviderGeneration;
+		const operation = readClerkToken().then((token) => {
+			if (operationGeneration !== tokenProviderGeneration) return token;
+			if (!token) {
+				cachedToken = null;
+				return null;
+			}
+			try {
+				const expiresAtSeconds = decodeRelayJwt(token).exp;
+				cachedToken = typeof expiresAtSeconds === "number" ? {
+					token,
+					expiresAtMillis: expiresAtSeconds * 1e3
+				} : null;
+			} catch {
+				cachedToken = null;
+			}
+			return token;
+		});
+		pendingToken = operation;
+		try {
+			return await operation;
+		} finally {
+			if (pendingToken === operation) pendingToken = null;
+		}
+	};
+	const session = {
+		accountId: input.accountId,
+		readClerkToken: fn("clientRuntime.managedRelaySession.readClerkToken")(function* () {
+			const nowMillis = yield* currentTimeMillis;
+			return yield* tryPromise({
+				try: () => readCachedClerkToken(nowMillis),
+				catch: (cause) => new ManagedRelaySessionError({
+					message: "Could not obtain the T3 Connect session token.",
+					cause
+				})
+			});
+		})
+	};
+	managedRelaySessionControls.set(session, { updateReadClerkToken: (nextReadClerkToken) => {
+		readClerkToken = nextReadClerkToken;
+		tokenProviderGeneration += 1;
+		pendingToken = null;
+	} });
+	return session;
+}
+function setManagedRelaySession(registry, input) {
+	const current = registry.get(managedRelaySessionAtom);
+	if (input === null) {
+		if (current !== null) registry.set(managedRelaySessionAtom, null);
+		return;
+	}
+	if (current?.accountId === input.accountId) {
+		const control = managedRelaySessionControls.get(current);
+		if (control) {
+			control.updateReadClerkToken(input.readClerkToken);
+			return;
+		}
+	}
+	registry.set(managedRelaySessionAtom, createManagedRelaySession(input));
+}
+function managedRelayAccountChanges(registry) {
+	return toStream(registry, managedRelaySessionAtom).pipe(map((session) => session?.accountId ?? null), changes, drop(1));
+}
+function readSessionClerkToken(session) {
+	return session.readClerkToken().pipe(flatMap((token) => token ? succeed(token) : fail(new ManagedRelaySessionError({ message: "The T3 Connect session token is unavailable." }))));
+}
+const waitForManagedRelayClerkToken = fn("clientRuntime.managedRelaySession.waitForClerkToken")(function* (registry) {
+	return yield* callback((resume) => {
+		let unsubscribe;
+		let completed = false;
+		const readCurrentSession = () => {
+			if (completed) return true;
+			const session = registry.get(managedRelaySessionAtom);
+			if (!session) return false;
+			completed = true;
+			unsubscribe?.();
+			resume(readSessionClerkToken(session));
+			return true;
+		};
+		if (readCurrentSession()) return;
+		unsubscribe = registry.subscribe(managedRelaySessionAtom, readCurrentSession);
+		readCurrentSession();
+		return sync(() => unsubscribe?.());
+	});
+});
+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." }));
+	return readSessionClerkToken(session);
+}
+function statusKey(input) {
+	return JSON.stringify(input);
+}
+function parseStatusKey(key) {
+	return JSON.parse(key);
+}
+function endpointMatches(left, right) {
+	return left.httpBaseUrl === right.httpBaseUrl && left.wsBaseUrl === right.wsBaseUrl && left.providerKind === right.providerKind;
+}
+function validateEnvironmentStatus(environment, status) {
+	if (status.environmentId !== environment.environmentId) return fail(new ManagedRelaySnapshotError({ message: "Relay returned status for a different environment." }));
+	if (!endpointMatches(status.endpoint, environment.endpoint)) return fail(new ManagedRelaySnapshotError({ message: "Relay returned status for a different endpoint." }));
+	if (status.descriptor && status.descriptor.environmentId !== environment.environmentId) return fail(new ManagedRelaySnapshotError({ message: "Relay returned status descriptor for a different environment." }));
+	return succeed(status);
+}
+function readManagedRelaySnapshotState(result) {
+	let error = null;
+	let errorTraceId = null;
+	if (result._tag === "Failure") {
+		const cause = squash(result.cause);
+		error = cause instanceof Error ? cause.message : "Could not load T3 Connect data.";
+		errorTraceId = findErrorTraceId(cause);
+	}
+	return {
+		data: getOrNull(value(result)),
+		error,
+		errorTraceId,
+		isPending: result.waiting
+	};
+}
+function createManagedRelayQueryManager(runtime, options) {
+	const staleTime = options?.staleTimeMs ?? DEFAULT_STALE_TIME_MS;
+	const idleTtl = options?.idleTtlMs ?? DEFAULT_IDLE_TTL_MS;
+	const observe = (input, effect) => gen(function* () {
+		options?.onQueryEvent?.({
+			...input,
+			phase: "start"
+		});
+		return yield* effect.pipe(onExit((exit) => sync(() => {
+			if (exit._tag === "Success") {
+				options?.onQueryEvent?.({
+					...input,
+					phase: "success"
+				});
+				return;
+			}
+			const error = squash(exit.cause);
+			options?.onQueryEvent?.({
+				...input,
+				phase: "failure",
+				message: error instanceof Error ? error.message : String(error),
+				traceId: findErrorTraceId(error)
+			});
+		})));
+	});
+	const environmentsAtom = family((accountId) => runtime.atom((get) => gen(function* () {
+		const base = {
+			operation: "environments",
+			accountId
+		};
+		const clerkToken = yield* observe({
+			...base,
+			stage: "clerk-token"
+		}, requireClerkToken(get, accountId));
+		const relay = yield* ManagedRelayClient;
+		return yield* observe({
+			...base,
+			stage: "relay-request"
+		}, relay.listEnvironments({ clerkToken }));
+	})).pipe(swr({
+		staleTime,
+		revalidateOnMount: true
+	}), setIdleTTL(idleTtl), withLabel(`managed-relay:environments:${accountId}`)));
+	const devicesAtom = family((accountId) => runtime.atom((get) => gen(function* () {
+		const base = {
+			operation: "devices",
+			accountId
+		};
+		const clerkToken = yield* observe({
+			...base,
+			stage: "clerk-token"
+		}, requireClerkToken(get, accountId));
+		const relay = yield* ManagedRelayClient;
+		return yield* observe({
+			...base,
+			stage: "relay-request"
+		}, relay.listDevices({ clerkToken }));
+	})).pipe(swr({
+		staleTime,
+		revalidateOnMount: true
+	}), setIdleTTL(idleTtl), withLabel(`managed-relay:devices:${accountId}`)));
+	const environmentStatusAtom = family((key) => {
+		const { accountId, environment } = parseStatusKey(key);
+		return runtime.atom((get) => gen(function* () {
+			const base = {
+				operation: "environment-status",
+				accountId,
+				environmentId: environment.environmentId
+			};
+			const clerkToken = yield* observe({
+				...base,
+				stage: "clerk-token"
+			}, requireClerkToken(get, accountId));
+			const relay = yield* ManagedRelayClient;
+			const status = yield* observe({
+				...base,
+				stage: "relay-request"
+			}, relay.getEnvironmentStatus({
+				clerkToken,
+				scopes: [RelayEnvironmentStatusScope, RelayEnvironmentConnectScope],
+				environmentId: environment.environmentId
+			}));
+			return yield* observe({
+				...base,
+				stage: "validation"
+			}, validateEnvironmentStatus(environment, status));
+		})).pipe(swr({
+			staleTime,
+			revalidateOnMount: true
+		}), setIdleTTL(idleTtl), withLabel(`managed-relay:environment-status:${key}`));
+	});
+	return {
+		environmentsAtom,
+		devicesAtom,
+		environmentStatusAtom: (input) => environmentStatusAtom(statusKey(input)),
+		refreshEnvironments(registry, accountId) {
+			registry.refresh(environmentsAtom(accountId));
+		},
+		refreshDevices(registry, accountId) {
+			registry.refresh(devicesAtom(accountId));
+		},
+		refreshEnvironmentStatus(registry, input) {
+			registry.refresh(environmentStatusAtom(statusKey(input)));
+		}
+	};
+}
+//#endregion
+export { discovery_exports as Discovery, managedRelay_exports as ManagedRelay, ManagedRelaySessionError, ManagedRelaySnapshotError, createManagedRelayQueryManager, createManagedRelaySession, managedRelayAccountChanges, managedRelaySessionAtom, readManagedRelaySnapshotState, setManagedRelaySession, waitForManagedRelayClerkToken };

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

@@ -0,0 +1,2 @@
+import { $a as makeWsRpcProtocolClient, $t as EnvironmentRpcRequestObserver, Ba as RemoteEnvironmentAuthInvalidJsonError, Ga as makeEnvironmentHttpApiClient, Ha as RemoteEnvironmentAuthUndeclaredStatusError, Ka as remoteHttpClientLayer, Qa as WsRpcProtocolClient, Qt as EnvironmentRpcRequestObservation, Ua as RemoteEnvironmentRequestError, Va as RemoteEnvironmentAuthTimeoutError, Wa as executeEnvironmentHttpRequest, Xa as RpcSession, Xt as EnvironmentRpcFailure, Za as RpcSessionFactory, Zt as EnvironmentRpcInput, an as EnvironmentRpcTag, cn as EnvironmentStreamRpcTag, dn as config, en as EnvironmentRpcStreamFailure, fn as request, hn as subscribeDynamic, in as EnvironmentRpcSuccess, ln as EnvironmentSubscriptionRpcTag, mn as subscribe, nn as EnvironmentRpcSubscriptionObservation, on as EnvironmentRpcUnavailableError, pn as runStream, rn as EnvironmentRpcSubscriptionObserver, sn as EnvironmentStreamCommandRpcTag, tn as EnvironmentRpcStreamValue, un as EnvironmentUnaryRpcTag, za as RemoteEnvironmentAuthFetchError } 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, makeEnvironmentHttpApiClient, makeWsRpcProtocolClient, remoteHttpClientLayer, request, runStream, subscribe, subscribeDynamic };

package/dist/client-runtime/rpc.js

@@ -0,0 +1,2 @@
+import { Ao as RemoteEnvironmentAuthTimeoutError, Ba as RpcSessionFactory, Br as config, Hr as runStream, Lr as EnvironmentRpcRequestObserver, Mo as executeEnvironmentHttpRequest, No as makeEnvironmentHttpApiClient, Oo as RemoteEnvironmentAuthFetchError, Po as remoteHttpClientLayer, Rr as EnvironmentRpcSubscriptionObserver, Ur as subscribe, Va as makeWsRpcProtocolClient, Vr as request, Wr as subscribeDynamic, jo as RemoteEnvironmentAuthUndeclaredStatusError, ko as RemoteEnvironmentAuthInvalidJsonError, zr as EnvironmentRpcUnavailableError } from "../shared.js";
+export { EnvironmentRpcRequestObserver, EnvironmentRpcSubscriptionObserver, EnvironmentRpcUnavailableError, RemoteEnvironmentAuthFetchError, RemoteEnvironmentAuthInvalidJsonError, RemoteEnvironmentAuthTimeoutError, RemoteEnvironmentAuthUndeclaredStatusError, RpcSessionFactory, config, executeEnvironmentHttpRequest, makeEnvironmentHttpApiClient, makeWsRpcProtocolClient, remoteHttpClientLayer, request, runStream, subscribe, subscribeDynamic };

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

@@ -0,0 +1,40 @@
+import { Ax as AssetProjectFaviconNotFoundError, Bx as AssetWorkspaceRootNormalizationError, Fx as AssetWorkspaceAssetNotFoundError, Ix as AssetWorkspaceContextNotFoundError, Lx as AssetWorkspaceContextResolutionError, Mx as AssetResource, Nx as AssetSigningKeyLoadError, Ox as AssetPreviewTypeValidationError, Px as AssetWorkspaceAssetInspectionError, Rx as AssetWorkspacePathValidationError, Tx as AssetAttachmentNotFoundError, bT as EnvironmentAuthorizationError, ha as EnvironmentRegistry, jx as AssetProjectFaviconResolutionError, kx as AssetProjectFaviconInspectionError, on as EnvironmentRpcUnavailableError, zT as EnvironmentId, zx as AssetWorkspaceResolutionError } 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
+declare const InvalidAssetCollectionKeyError_base: Schema.Class<InvalidAssetCollectionKeyError, Schema.TaggedStruct<"InvalidAssetCollectionKeyError", {
+  readonly key: Schema.String;
+  readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+declare class InvalidAssetCollectionKeyError extends InvalidAssetCollectionKeyError_base {
+  get message(): string;
+}
+declare function parseAssetCollectionKey(key: string): readonly [EnvironmentId, ReadonlyArray<AssetResource>];
+declare function resolveAssetUrl(httpBaseUrl: string, relativeUrl: string): string | null;
+declare function createAssetEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<EnvironmentRegistry | R, E>): {
+  createUrl: (target: {
+    readonly environmentId: EnvironmentId;
+    readonly input: Schema.Struct.ReadonlyMakeIn<{
+      readonly resource: Schema.Union<readonly [Schema.TaggedStruct<"workspace-file", {
+        readonly threadId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ThreadId">;
+        readonly path: Schema.decodeTo<Schema.String, Schema.String, never, never>;
+      }>, Schema.TaggedStruct<"attachment", {
+        readonly attachmentId: Schema.decodeTo<Schema.String, Schema.String, never, never>;
+      }>, Schema.TaggedStruct<"project-favicon", {
+        readonly cwd: Schema.decodeTo<Schema.String, Schema.String, never, never>;
+      }>]>;
+    }>;
+  }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
+    readonly relativeUrl: string;
+    readonly expiresAt: number;
+  }, E | AssetAttachmentNotFoundError | AssetPreviewTypeValidationError | AssetProjectFaviconInspectionError | AssetProjectFaviconNotFoundError | AssetProjectFaviconResolutionError | AssetSigningKeyLoadError | AssetWorkspaceAssetInspectionError | AssetWorkspaceAssetNotFoundError | AssetWorkspaceContextNotFoundError | AssetWorkspaceContextResolutionError | AssetWorkspacePathValidationError | AssetWorkspaceResolutionError | AssetWorkspaceRootNormalizationError | EnvironmentAuthorizationError | EnvironmentRpcUnavailableError | Error | import("effect/unstable/rpc/RpcClientError").RpcClientError>>;
+  createUrls: (target: {
+    readonly environmentId: EnvironmentId;
+    readonly resources: ReadonlyArray<AssetResource>;
+  }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
+    readonly relativeUrl: string;
+    readonly expiresAt: number;
+  }, E | AssetAttachmentNotFoundError | AssetPreviewTypeValidationError | AssetProjectFaviconInspectionError | AssetProjectFaviconNotFoundError | AssetProjectFaviconResolutionError | AssetSigningKeyLoadError | AssetWorkspaceAssetInspectionError | AssetWorkspaceAssetNotFoundError | AssetWorkspaceContextNotFoundError | AssetWorkspaceContextResolutionError | AssetWorkspacePathValidationError | AssetWorkspaceResolutionError | AssetWorkspaceRootNormalizationError | EnvironmentAuthorizationError | EnvironmentRpcUnavailableError | Error | import("effect/unstable/rpc/RpcClientError").RpcClientError>[]>;
+};
+//#endregion
+export { InvalidAssetCollectionKeyError, createAssetEnvironmentAtoms, parseAssetCollectionKey, resolveAssetUrl };

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

@@ -0,0 +1,53 @@
+import { Fs as WS_METHODS, GT as Defect, Gr as family, JS as EnvironmentId, Jr as setIdleTTL, QT as String, WT as ArraySchema, Xr as withLabel, eE as TaggedErrorClass, fr as createEnvironmentRpcQueryAtomFamily, oE as decodeUnknownSync, ou as AssetResource, qr as make, tE as Tuple } 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;
+const ASSET_URL_IDLE_TTL_MS = 60 * 6e4;
+var InvalidAssetCollectionKeyError = class extends TaggedErrorClass()("InvalidAssetCollectionKeyError", {
+	key: String,
+	cause: Defect()
+}) {
+	get message() {
+		return `Invalid asset collection atom key: ${JSON.stringify(this.key)}.`;
+	}
+};
+const decodeAssetCollectionKey = decodeUnknownSync(Tuple([EnvironmentId, ArraySchema(AssetResource)]));
+function parseAssetCollectionKey(key) {
+	try {
+		return decodeAssetCollectionKey(JSON.parse(key));
+	} catch (cause) {
+		throw new InvalidAssetCollectionKeyError({
+			key,
+			cause
+		});
+	}
+}
+function resolveAssetUrl(httpBaseUrl, relativeUrl) {
+	try {
+		return new URL(relativeUrl, httpBaseUrl).toString();
+	} catch {
+		return null;
+	}
+}
+function createAssetEnvironmentAtoms(runtime) {
+	const createUrl = createEnvironmentRpcQueryAtomFamily(runtime, {
+		label: "environment-data:assets:create-url",
+		tag: WS_METHODS.assetsCreateUrl,
+		staleTimeMs: ASSET_URL_STALE_TIME_MS,
+		idleTtlMs: ASSET_URL_IDLE_TTL_MS,
+		refreshIntervalMs: ASSET_URL_REFRESH_INTERVAL_MS
+	});
+	const createUrlsFamily = family((key) => {
+		const [environmentId, resources] = parseAssetCollectionKey(key);
+		return make((get) => resources.map((resource) => get(createUrl({
+			environmentId,
+			input: { resource }
+		})))).pipe(setIdleTTL(ASSET_URL_IDLE_TTL_MS), withLabel(`environment-data:assets:create-urls:${key}`));
+	});
+	return {
+		createUrl,
+		createUrls: (target) => createUrlsFamily(JSON.stringify([target.environmentId, target.resources]))
+	};
+}
+//#endregion
+export { InvalidAssetCollectionKeyError, createAssetEnvironmentAtoms, parseAssetCollectionKey, resolveAssetUrl };

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

@@ -0,0 +1,98 @@
+import { Bw as AuthAccessStreamError, Lw as AuthAccessSnapshot, Vw as AuthAccessStreamEvent, bT as EnvironmentAuthorizationError, ha as EnvironmentRegistry, zT as EnvironmentId } 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;
+declare function applyAuthAccessStreamEvent(current: AuthAccessSnapshot, event: AuthAccessStreamEvent): AuthAccessSnapshot;
+declare function projectAuthAccessSnapshot(current: AuthAccessSnapshot, event: AuthAccessStreamEvent): readonly [AuthAccessSnapshot, ReadonlyArray<AuthAccessStreamEvent>];
+declare function createAuthEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<EnvironmentRegistry | R, E>): {
+  accessChanges: (target: {
+    readonly environmentId: EnvironmentId;
+    readonly input: null;
+  }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
+    readonly version: 1;
+    readonly revision: number;
+    readonly type: "snapshot";
+    readonly payload: {
+      readonly pairingLinks: readonly {
+        readonly id: string;
+        readonly credential: string;
+        readonly scopes: readonly ("access:read" | "access:write" | "orchestration:operate" | "orchestration:read" | "relay:read" | "relay:write" | "review:write" | "terminal:operate")[];
+        readonly subject: string;
+        readonly label?: string;
+        readonly createdAt: import("effect/DateTime").Utc;
+        readonly expiresAt: import("effect/DateTime").Utc;
+      }[];
+      readonly clientSessions: readonly {
+        readonly sessionId: string & import("effect/Brand").Brand<"AuthSessionId">;
+        readonly subject: string;
+        readonly scopes: readonly ("access:read" | "access:write" | "orchestration:operate" | "orchestration:read" | "relay:read" | "relay:write" | "review:write" | "terminal:operate")[];
+        readonly method: "bearer-access-token" | "browser-session-cookie" | "dpop-access-token";
+        readonly client: {
+          readonly label?: string;
+          readonly ipAddress?: string;
+          readonly userAgent?: string;
+          readonly deviceType: "bot" | "desktop" | "mobile" | "tablet" | "unknown";
+          readonly os?: string;
+          readonly browser?: string;
+        };
+        readonly issuedAt: import("effect/DateTime").Utc;
+        readonly expiresAt: import("effect/DateTime").Utc;
+        readonly lastConnectedAt: import("effect/DateTime").Utc | null;
+        readonly connected: boolean;
+        readonly current: boolean;
+      }[];
+    };
+  } | {
+    readonly version: 1;
+    readonly revision: number;
+    readonly type: "pairingLinkUpserted";
+    readonly payload: {
+      readonly id: string;
+      readonly credential: string;
+      readonly scopes: readonly ("access:read" | "access:write" | "orchestration:operate" | "orchestration:read" | "relay:read" | "relay:write" | "review:write" | "terminal:operate")[];
+      readonly subject: string;
+      readonly label?: string;
+      readonly createdAt: import("effect/DateTime").Utc;
+      readonly expiresAt: import("effect/DateTime").Utc;
+    };
+  } | {
+    readonly version: 1;
+    readonly revision: number;
+    readonly type: "pairingLinkRemoved";
+    readonly payload: {
+      readonly id: string;
+    };
+  } | {
+    readonly version: 1;
+    readonly revision: number;
+    readonly type: "clientUpserted";
+    readonly payload: {
+      readonly sessionId: string & import("effect/Brand").Brand<"AuthSessionId">;
+      readonly subject: string;
+      readonly scopes: readonly ("access:read" | "access:write" | "orchestration:operate" | "orchestration:read" | "relay:read" | "relay:write" | "review:write" | "terminal:operate")[];
+      readonly method: "bearer-access-token" | "browser-session-cookie" | "dpop-access-token";
+      readonly client: {
+        readonly label?: string;
+        readonly ipAddress?: string;
+        readonly userAgent?: string;
+        readonly deviceType: "bot" | "desktop" | "mobile" | "tablet" | "unknown";
+        readonly os?: string;
+        readonly browser?: string;
+      };
+      readonly issuedAt: import("effect/DateTime").Utc;
+      readonly expiresAt: import("effect/DateTime").Utc;
+      readonly lastConnectedAt: import("effect/DateTime").Utc | null;
+      readonly connected: boolean;
+      readonly current: boolean;
+    };
+  } | {
+    readonly version: 1;
+    readonly revision: number;
+    readonly type: "clientRemoved";
+    readonly payload: {
+      readonly sessionId: string & import("effect/Brand").Brand<"AuthSessionId">;
+    };
+  }, E | AuthAccessStreamError | EnvironmentAuthorizationError | import("effect/Cause").NoSuchElementError | import("effect/unstable/rpc/RpcClientError").RpcClientError>>;
+};
+//#endregion
+export { EMPTY_AUTH_ACCESS_SNAPSHOT, applyAuthAccessStreamEvent, createAuthEnvironmentAtoms, projectAuthAccessSnapshot };

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

@@ -0,0 +1,48 @@
+import { Fs as WS_METHODS, Ur as subscribe, hr as createEnvironmentSubscriptionAtomFamily, qE as mapAccum } from "../../shared.js";
+//#region upstream-t3code/packages/client-runtime/src/state/auth.ts
+const EMPTY_AUTH_ACCESS_SNAPSHOT = {
+	pairingLinks: [],
+	clientSessions: []
+};
+function upsertByKey(values, next, key) {
+	const nextKey = key(next);
+	return [...values.filter((value) => key(value) !== nextKey), next];
+}
+function applyAuthAccessStreamEvent(current, event) {
+	switch (event.type) {
+		case "snapshot": return event.payload;
+		case "pairingLinkUpserted": return {
+			...current,
+			pairingLinks: upsertByKey(current.pairingLinks, event.payload, (value) => value.id)
+		};
+		case "pairingLinkRemoved": return {
+			...current,
+			pairingLinks: current.pairingLinks.filter((value) => value.id !== event.payload.id)
+		};
+		case "clientUpserted": return {
+			...current,
+			clientSessions: upsertByKey(current.clientSessions, event.payload, (value) => value.sessionId)
+		};
+		case "clientRemoved": return {
+			...current,
+			clientSessions: current.clientSessions.filter((value) => value.sessionId !== event.payload.sessionId)
+		};
+	}
+}
+function projectAuthAccessSnapshot(current, event) {
+	const snapshot = applyAuthAccessStreamEvent(current, event);
+	return [snapshot, [{
+		version: 1,
+		revision: event.revision,
+		type: "snapshot",
+		payload: snapshot
+	}]];
+}
+function createAuthEnvironmentAtoms(runtime) {
+	return { accessChanges: createEnvironmentSubscriptionAtomFamily(runtime, {
+		label: "environment-data:server:auth-access-changes",
+		subscribe: (_input) => subscribe(WS_METHODS.subscribeAuthAccess, {}).pipe(mapAccum(() => EMPTY_AUTH_ACCESS_SNAPSHOT, projectAuthAccessSnapshot))
+	}) };
+}
+//#endregion
+export { EMPTY_AUTH_ACCESS_SNAPSHOT, applyAuthAccessStreamEvent, createAuthEnvironmentAtoms, projectAuthAccessSnapshot };

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

@@ -0,0 +1,2 @@
+import { d as createEnvironmentCatalogAtoms, l as EMPTY_ENVIRONMENT_CATALOG_STATE, u as EnvironmentCatalogState } from "../../shared.js";
+export { EMPTY_ENVIRONMENT_CATALOG_STATE, EnvironmentCatalogState, createEnvironmentCatalogAtoms };

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

@@ -0,0 +1,52 @@
+import { $D as flatMap, Aa as EnvironmentSupervisor, Fk as getOrElse, Gr as family, KE as map$1, Oa as EnvironmentRegistry, Sv as changes, Xr as withLabel, gr as createRuntimeCommand, lD as unwrap, lr as createAtomCommandScheduler, qr as make, ti as value, uO as map, us as AVAILABLE_CONNECTION_STATE, xr as followStreamInEnvironment } from "../../shared.js";
+//#region upstream-t3code/packages/client-runtime/src/state/connections.ts
+const EMPTY_ENVIRONMENT_CATALOG_STATE = Object.freeze({
+	isReady: false,
+	entries: /* @__PURE__ */ new Map()
+});
+function createEnvironmentCatalogAtoms(runtime) {
+	const commandScheduler = createAtomCommandScheduler();
+	const serial = {
+		mode: "serial",
+		key: () => "environment-catalog"
+	};
+	const catalogAtom = runtime.atom(unwrap(EnvironmentRegistry.pipe(map((registry) => changes(registry.entries).pipe(map$1((entries) => ({
+		isReady: true,
+		entries
+	})))))), { initialValue: EMPTY_ENVIRONMENT_CATALOG_STATE });
+	const catalogValueAtom = make((get) => getOrElse(value(get(catalogAtom)), () => EMPTY_ENVIRONMENT_CATALOG_STATE)).pipe(withLabel("environment-catalog-value"));
+	const networkStatusAtom = runtime.atom(unwrap(EnvironmentRegistry.pipe(map((registry) => changes(registry.networkStatus)))), { initialValue: "unknown" });
+	return {
+		catalogAtom,
+		catalogValueAtom,
+		networkStatusAtom,
+		networkStatusValueAtom: make((get) => getOrElse(value(get(networkStatusAtom)), () => "unknown")).pipe(withLabel("environment-network-status-value")),
+		stateAtom: family((environmentId) => runtime.atom(followStreamInEnvironment(environmentId, unwrap(EnvironmentSupervisor.pipe(map((supervisor) => changes(supervisor.state))))), { initialValue: AVAILABLE_CONNECTION_STATE })),
+		register: createRuntimeCommand(runtime, {
+			label: "environment-catalog:register",
+			scheduler: commandScheduler,
+			concurrency: serial,
+			execute: (target) => EnvironmentRegistry.pipe(flatMap((registry) => registry.register(target)))
+		}),
+		remove: createRuntimeCommand(runtime, {
+			label: "environment-catalog:remove",
+			scheduler: commandScheduler,
+			concurrency: serial,
+			execute: (environmentId) => EnvironmentRegistry.pipe(flatMap((registry) => registry.remove(environmentId)))
+		}),
+		removeRelayEnvironments: createRuntimeCommand(runtime, {
+			label: "environment-catalog:remove-relay-environments",
+			scheduler: commandScheduler,
+			concurrency: serial,
+			execute: (_input) => EnvironmentRegistry.pipe(flatMap((registry) => registry.removeRelayEnvironments()))
+		}),
+		retryNow: createRuntimeCommand(runtime, {
+			label: "environment-catalog:retry-now",
+			scheduler: commandScheduler,
+			concurrency: serial,
+			execute: (environmentId) => EnvironmentRegistry.pipe(flatMap((registry) => registry.retryNow(environmentId)))
+		})
+	};
+}
+//#endregion
+export { EMPTY_ENVIRONMENT_CATALOG_STATE, createEnvironmentCatalogAtoms };

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

@@ -0,0 +1,33 @@
+import { Mw as ScopedThreadRef, jw as ScopedProjectRef } 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", {
+  readonly key: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class InvalidScopedProjectKeyError extends InvalidScopedProjectKeyError_base {
+  get message(): string;
+}
+declare const InvalidScopedThreadKeyError_base: Schema.Class<InvalidScopedThreadKeyError, Schema.TaggedStruct<"InvalidScopedThreadKeyError", {
+  readonly key: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class InvalidScopedThreadKeyError extends InvalidScopedThreadKeyError_base {
+  get message(): string;
+}
+declare const InvalidScopedProjectRefCollectionKeyError_base: Schema.Class<InvalidScopedProjectRefCollectionKeyError, Schema.TaggedStruct<"InvalidScopedProjectRefCollectionKeyError", {
+  readonly key: Schema.String;
+  readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+declare class InvalidScopedProjectRefCollectionKeyError extends InvalidScopedProjectRefCollectionKeyError_base {
+  get message(): string;
+}
+declare function projectKey(ref: ScopedProjectRef): string;
+declare function threadKey(ref: ScopedThreadRef): string;
+declare function projectRefCollectionKey(refs: ReadonlyArray<ScopedProjectRef>): string;
+declare function parseProjectKey(key: string): ScopedProjectRef;
+declare function parseProjectRefCollectionKey(key: string): ReadonlyArray<ScopedProjectRef>;
+declare function parseThreadKey(key: string): ScopedThreadRef;
+declare function projectRefsEqual(left: ReadonlyArray<ScopedProjectRef>, right: ReadonlyArray<ScopedProjectRef>): boolean;
+declare function threadRefsEqual(left: ReadonlyArray<ScopedThreadRef>, right: ReadonlyArray<ScopedThreadRef>): boolean;
+declare function arrayElementsEqual<A>(left: ReadonlyArray<A>, right: ReadonlyArray<A>): boolean;
+//#endregion
+export { InvalidScopedProjectKeyError, InvalidScopedProjectRefCollectionKeyError, InvalidScopedThreadKeyError, arrayElementsEqual, parseProjectKey, parseProjectRefCollectionKey, parseThreadKey, projectKey, projectRefCollectionKey, projectRefsEqual, threadKey, threadRefsEqual };

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

@@ -0,0 +1,2 @@
+import { $t as projectRefCollectionKey, Gt as InvalidScopedProjectKeyError, Jt as arrayElementsEqual, Kt as InvalidScopedProjectRefCollectionKeyError, Qt as projectKey, Xt as parseProjectRefCollectionKey, Yt as parseProjectKey, Zt as parseThreadKey, en as projectRefsEqual, nn as threadRefsEqual, qt as InvalidScopedThreadKeyError, tn as threadKey } from "../../shared.js";
+export { InvalidScopedProjectKeyError, InvalidScopedProjectRefCollectionKeyError, InvalidScopedThreadKeyError, arrayElementsEqual, parseProjectKey, parseProjectRefCollectionKey, parseThreadKey, projectKey, projectRefCollectionKey, projectRefsEqual, threadKey, threadRefsEqual };

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

@@ -0,0 +1,42 @@
+import { Hx as FilesystemBrowseError, Vx as FilesystemBrowseEntry, Wi as EnvironmentConnectionPhase, bT as EnvironmentAuthorizationError, ha as EnvironmentRegistry, on as EnvironmentRpcUnavailableError, zT 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): {
+  isBrowsing: boolean;
+  directoryPath: string;
+  filterQuery: string;
+  parentPath: string | null;
+  canBrowseUp: boolean;
+};
+declare function filterFilesystemBrowseEntries(entries: ReadonlyArray<FilesystemBrowseEntry>, query: string): {
+  visibleEntries: {
+    readonly name: string;
+    readonly fullPath: string;
+  }[];
+  exactEntry: {
+    readonly name: string;
+    readonly fullPath: string;
+  } | null;
+};
+declare function createBrowseNavigationCoordinator(): {
+  invalidate: () => void;
+  run: (load: () => Promise<void>, commit: () => void) => Promise<boolean>;
+};
+declare function canPreloadBrowsePath(connectionPhase: EnvironmentConnectionPhase | null | undefined): boolean;
+declare function createFilesystemEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<EnvironmentRegistry | R, E>): {
+  browse: (target: {
+    readonly environmentId: EnvironmentId;
+    readonly input: {
+      readonly partialPath: string;
+      readonly cwd?: string | undefined;
+    };
+  }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
+    readonly parentPath: string;
+    readonly entries: readonly {
+      readonly name: string;
+      readonly fullPath: string;
+    }[];
+  }, E | EnvironmentAuthorizationError | EnvironmentRpcUnavailableError | Error | FilesystemBrowseError | import("effect/unstable/rpc/RpcClientError").RpcClientError>>;
+};
+//#endregion
+export { canPreloadBrowsePath, createBrowseNavigationCoordinator, createFilesystemEnvironmentAtoms, filterFilesystemBrowseEntries, getFilesystemBrowsePath };