t3code-cli 0.14.0 → 0.14.2

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

@@ -1,4 +1,4 @@
-import { Fk as getOrElse, Gr as family, Xr as withLabel, na as presentEnvironmentConnection, qr as make, ti as value, us as AVAILABLE_CONNECTION_STATE } from "../../shared.js";
+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";
 //#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 { Ab as PreviewSessionLookupError, Hy as PreviewAutomationRemoteUnavailableError, Iy as PreviewAutomationNoAvailableHostError, Jy as PreviewAutomationResultTooLargeError, My as PreviewAutomationInvalidSelectorError, Ny as PreviewAutomationMalformedResponseError, Oy as PreviewAutomationExecutionError, Wy as PreviewAutomationRequestQueueClosedError, bT as EnvironmentAuthorizationError, bb as PreviewInvalidUrlError, f as AtomCommand, ha as EnvironmentRegistry, ib as PreviewAutomationTimeoutError, ma as EnvironmentNotRegisteredError, ob as PreviewAutomationUnavailableError, on as EnvironmentRpcUnavailableError, rb as PreviewAutomationTargetNotEditableError, sb as PreviewAutomationUnsupportedClientError, tb as PreviewAutomationTabNotFoundError, wy as PreviewAutomationControlInterruptedError, yy as PreviewAutomationClientDisconnectedError, zT as EnvironmentId } from "../../shared.js";
+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 { Atom } from "effect/unstable/reactivity";
 //#region upstream-t3code/packages/client-runtime/src/state/preview.d.ts
 declare const previewAutomationHostFocusConcurrencyKey: (value: {
@@ -11,9 +11,9 @@ declare const previewAutomationHostFocusConcurrencyKey: (value: {
 declare function createPreviewEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<EnvironmentRegistry | R, E>): {
   list: (target: {
     readonly environmentId: EnvironmentId;
-    readonly input: import("effect/Schema").Struct.ReadonlyMakeIn<{
-      readonly threadId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "ThreadId">;
-    }>;
+    readonly input: {
+      readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
+    };
   }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
     readonly sessions: readonly {
       readonly threadId: string;
@@ -56,7 +56,7 @@ declare function createPreviewEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<E
   }, E | EnvironmentAuthorizationError | EnvironmentRpcUnavailableError | Error | import("effect/unstable/rpc/RpcClientError").RpcClientError>>;
   events: (target: {
     readonly environmentId: EnvironmentId;
-    readonly input: import("effect/Schema").Struct.ReadonlyMakeIn<{}>;
+    readonly input: {};
   }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
     readonly threadId: string;
     readonly tabId: string;
@@ -207,7 +207,7 @@ 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: import("effect/Schema").Struct.ReadonlyMakeIn<{}>;
+    readonly input: {};
   }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
     readonly servers: readonly {
       readonly host: string;
@@ -333,20 +333,22 @@ declare function createPreviewEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<E
   }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | PreviewInvalidUrlError | PreviewSessionLookupError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
   resize: AtomCommand<{
     readonly environmentId: EnvironmentId;
-    readonly input: import("effect/Schema").Struct.ReadonlyMakeIn<{
-      readonly threadId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "ThreadId">;
-      readonly tabId: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
-      readonly viewport: import("effect/Schema").Union<readonly [import("effect/Schema").TaggedStruct<"fill", {}>, import("effect/Schema").Struct<{
-        readonly _tag: import("effect/Schema").tag<"freeform">;
-        readonly width: import("effect/Schema").Int;
-        readonly height: import("effect/Schema").Int;
-      }>, import("effect/Schema").Struct<{
-        readonly _tag: import("effect/Schema").tag<"preset">;
-        readonly width: import("effect/Schema").Int;
-        readonly height: import("effect/Schema").Int;
-        readonly presetId: import("effect/Schema").Literals<readonly ["iphone-se", "iphone-xr", "iphone-12-pro", "iphone-14-pro-max", "pixel-7", "samsung-galaxy-s8-plus", "samsung-galaxy-s20-ultra", "ipad-mini", "ipad-air", "ipad-pro", "surface-pro-7", "surface-duo", "galaxy-z-fold-5", "asus-zenbook-fold", "samsung-galaxy-a51-71", "nest-hub", "nest-hub-max", "desktop-1920x1080", "desktop-1440x900", "laptop-1366x768", "laptop-1280x800", "ipad-pro-11", "iphone-15-pro", "pixel-8", "galaxy-s24"]>;
-      }>]>;
-    }>;
+    readonly input: {
+      readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
+      readonly tabId: string;
+      readonly viewport: {
+        readonly _tag?: "fill";
+      } | {
+        readonly _tag?: "freeform";
+        readonly width: number;
+        readonly height: number;
+      } | {
+        readonly _tag?: "preset";
+        readonly width: number;
+        readonly height: number;
+        readonly presetId: "asus-zenbook-fold" | "desktop-1440x900" | "desktop-1920x1080" | "galaxy-s24" | "galaxy-z-fold-5" | "ipad-air" | "ipad-mini" | "ipad-pro" | "ipad-pro-11" | "iphone-12-pro" | "iphone-14-pro-max" | "iphone-15-pro" | "iphone-se" | "iphone-xr" | "laptop-1280x800" | "laptop-1366x768" | "nest-hub" | "nest-hub-max" | "pixel-7" | "pixel-8" | "samsung-galaxy-a51-71" | "samsung-galaxy-s20-ultra" | "samsung-galaxy-s8-plus" | "surface-duo" | "surface-pro-7";
+      };
+    };
   }, {
     readonly threadId: string;
     readonly tabId: string;
@@ -385,10 +387,10 @@ declare function createPreviewEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<E
   }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | PreviewInvalidUrlError | PreviewSessionLookupError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
   refresh: AtomCommand<{
     readonly environmentId: EnvironmentId;
-    readonly input: import("effect/Schema").Struct.ReadonlyMakeIn<{
-      readonly threadId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "ThreadId">;
-      readonly tabId: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
-    }>;
+    readonly input: {
+      readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
+      readonly tabId: string;
+    };
   }, void, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | PreviewInvalidUrlError | PreviewSessionLookupError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
   close: AtomCommand<{
     readonly environmentId: EnvironmentId;
@@ -399,24 +401,29 @@ declare function createPreviewEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<E
   }, void, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | PreviewInvalidUrlError | PreviewSessionLookupError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
   reportStatus: AtomCommand<{
     readonly environmentId: EnvironmentId;
-    readonly input: import("effect/Schema").Struct.ReadonlyMakeIn<{
-      readonly threadId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "ThreadId">;
-      readonly tabId: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
-      readonly navStatus: import("effect/Schema").Union<readonly [import("effect/Schema").TaggedStruct<"Idle", {}>, import("effect/Schema").TaggedStruct<"Loading", {
-        readonly url: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
-        readonly title: import("effect/Schema").String;
-      }>, import("effect/Schema").TaggedStruct<"Success", {
-        readonly url: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
-        readonly title: import("effect/Schema").String;
-      }>, import("effect/Schema").TaggedStruct<"LoadFailed", {
-        readonly url: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
-        readonly title: import("effect/Schema").String;
-        readonly code: import("effect/Schema").Int;
-        readonly description: import("effect/Schema").String;
-      }>]>;
-      readonly canGoBack: import("effect/Schema").Boolean;
-      readonly canGoForward: import("effect/Schema").Boolean;
-    }>;
+    readonly input: {
+      readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
+      readonly tabId: string;
+      readonly navStatus: {
+        readonly _tag?: "Idle";
+      } | {
+        readonly _tag?: "Loading";
+        readonly url: string;
+        readonly title: string;
+      } | {
+        readonly _tag?: "Success";
+        readonly url: string;
+        readonly title: string;
+      } | {
+        readonly _tag?: "LoadFailed";
+        readonly url: string;
+        readonly title: string;
+        readonly code: number;
+        readonly description: string;
+      };
+      readonly canGoBack: boolean;
+      readonly canGoForward: boolean;
+    };
   }, void, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | PreviewInvalidUrlError | PreviewSessionLookupError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
   respondToAutomation: AtomCommand<{
     readonly environmentId: EnvironmentId;
@@ -435,12 +442,12 @@ declare function createPreviewEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<E
   }, void, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | PreviewAutomationClientDisconnectedError | PreviewAutomationControlInterruptedError | PreviewAutomationExecutionError | PreviewAutomationInvalidSelectorError | PreviewAutomationMalformedResponseError | PreviewAutomationNoAvailableHostError | PreviewAutomationRemoteUnavailableError | PreviewAutomationRequestQueueClosedError | PreviewAutomationResultTooLargeError | PreviewAutomationTabNotFoundError | PreviewAutomationTargetNotEditableError | PreviewAutomationTimeoutError | PreviewAutomationUnavailableError | PreviewAutomationUnsupportedClientError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
   focusAutomationHost: AtomCommand<{
     readonly environmentId: EnvironmentId;
-    readonly input: import("effect/Schema").Struct.ReadonlyMakeIn<{
-      readonly clientId: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
-      readonly environmentId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "EnvironmentId">;
-      readonly connectionId: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
-      readonly focused: import("effect/Schema").Boolean;
-    }>;
+    readonly input: {
+      readonly clientId: string;
+      readonly environmentId: string & import("effect/Brand").Brand<"EnvironmentId">;
+      readonly connectionId: string;
+      readonly focused: boolean;
+    };
   }, void, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
 };
 //#endregion

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

@@ -1,4 +1,4 @@
-import { Fs as WS_METHODS, dr as createEnvironmentRpcCommand, fr as createEnvironmentRpcQueryAtomFamily, lr as createAtomCommandScheduler, mr as createEnvironmentRpcSubscriptionAtomFamily } from "../../shared.js";
+import { Us as WS_METHODS, gr as createEnvironmentRpcQueryAtomFamily, hr as createEnvironmentRpcCommand, pr as createAtomCommandScheduler, vr as createEnvironmentRpcSubscriptionAtomFamily } from "../../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/state/preview.ts
 const previewAutomationHostFocusConcurrencyKey = (value) => JSON.stringify([
 	value.environmentId,

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

@@ -1,4 +1,4 @@
-import { jw as ScopedProjectRef, l_ as SidebarProjectGroupingMode, rt as EnvironmentProject, wg as ClientSettings } from "../../shared.js";
+import { CD as EnvironmentId, Cv as SidebarProjectGroupingMode, S_ as ClientSettings, at as EnvironmentProject, mE as ScopedProjectRef } from "../../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/state/projectGrouping.d.ts
 interface ProjectGroupingSettings {
   readonly sidebarProjectGroupingMode: SidebarProjectGroupingMode;
@@ -22,5 +22,29 @@ declare function deriveProjectGroupLabel(input: {
   readonly representative: Pick<EnvironmentProject, "title" | "repositoryIdentity">;
   readonly members: ReadonlyArray<Pick<EnvironmentProject, "title" | "repositoryIdentity">>;
 }): string;
+interface ProjectGroupMember<TProject extends EnvironmentProject = EnvironmentProject> {
+  readonly physicalProjectKey: string;
+  readonly project: TProject;
+}
+interface ProjectGroup<TProject extends EnvironmentProject = EnvironmentProject> {
+  readonly key: string;
+  readonly label: string;
+  readonly representative: TProject;
+  readonly members: ReadonlyArray<ProjectGroupMember<TProject>>;
+  readonly memberProjectRefs: ReadonlyArray<ScopedProjectRef>;
+}
+/**
+ * Builds logical project groups without losing the physical projects that
+ * remain the actual navigation and task-creation targets.
+ *
+ * Presentation-specific metadata, filtering, and activity sorting stay in
+ * each client. Grouping modes, overrides, physical deduplication, labels, and
+ * member preservation live here so web and mobile cannot drift.
+ */
+declare function buildProjectGroups<TProject extends EnvironmentProject>(input: {
+  readonly projects: ReadonlyArray<TProject>;
+  readonly settings: ProjectGroupingSettings;
+  readonly preferredEnvironmentId?: EnvironmentId | null;
+}): ReadonlyArray<ProjectGroup<TProject>>;
 //#endregion
-export { ProjectGroupingMode, ProjectGroupingSettings, deriveLogicalProjectKey, deriveLogicalProjectKeyFromRef, deriveLogicalProjectKeyFromSettings, derivePhysicalProjectKey, derivePhysicalProjectKeyFromPath, deriveProjectGroupLabel, deriveProjectGroupingOverrideKey, getProjectOrderKey, resolveProjectGroupingMode, selectProjectGroupingSettings };
+export { ProjectGroup, ProjectGroupMember, ProjectGroupingMode, ProjectGroupingSettings, buildProjectGroups, deriveLogicalProjectKey, deriveLogicalProjectKeyFromRef, deriveLogicalProjectKeyFromSettings, derivePhysicalProjectKey, derivePhysicalProjectKeyFromPath, deriveProjectGroupLabel, deriveProjectGroupingOverrideKey, getProjectOrderKey, resolveProjectGroupingMode, selectProjectGroupingSettings };

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

@@ -1,4 +1,4 @@
-import { cn as normalizeProjectPathForComparison, li as scopedProjectKey, si as scopeProjectRef } from "../../shared.js";
+import { hi as scopedProjectKey, ln as normalizeProjectPathForComparison, pi as scopeProjectRef } from "../../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/state/projectGrouping.ts
 function selectProjectGroupingSettings(settings) {
 	return {
@@ -63,11 +63,91 @@ function deriveLogicalProjectKeyFromRef(projectRef, project, options) {
 	return project ? deriveLogicalProjectKey(project, options) : scopedProjectKey(projectRef);
 }
 function deriveProjectGroupLabel(input) {
+	const sharedTitles = uniqueNonEmptyValues(input.members.map((member) => member.title));
 	const sharedDisplayNames = uniqueNonEmptyValues(input.members.map((member) => member.repositoryIdentity?.displayName));
-	if (sharedDisplayNames.length === 1) return sharedDisplayNames[0];
 	const sharedRepositoryNames = uniqueNonEmptyValues(input.members.map((member) => member.repositoryIdentity?.name));
+	const sharedTitle = sharedTitles[0];
+	if (sharedTitles.length === 1 && sharedTitle !== void 0 && !sharedDisplayNames.includes(sharedTitle) && !sharedRepositoryNames.includes(sharedTitle)) return sharedTitle;
+	if (sharedDisplayNames.length === 1) return sharedDisplayNames[0];
 	if (sharedRepositoryNames.length === 1) return sharedRepositoryNames[0];
 	return input.representative.title;
 }
+function projectFreshnessTime(project) {
+	const updatedAtTime = Date.parse(project.updatedAt);
+	if (Number.isFinite(updatedAtTime)) return updatedAtTime;
+	const createdAtTime = Date.parse(project.createdAt);
+	return Number.isFinite(createdAtTime) ? createdAtTime : 0;
+}
+function shouldReplacePhysicalProjectWinner(existing, candidate) {
+	const freshnessDelta = projectFreshnessTime(candidate) - projectFreshnessTime(existing);
+	return freshnessDelta > 0 || freshnessDelta === 0 && candidate.id > existing.id;
+}
+function selectProjectIdentitySource(projects, winner) {
+	if (winner.repositoryIdentity !== null) return winner;
+	let freshestIdentifiedProject = null;
+	for (const project of projects) {
+		if (project.repositoryIdentity === null) continue;
+		if (freshestIdentifiedProject === null || shouldReplacePhysicalProjectWinner(freshestIdentifiedProject, project)) freshestIdentifiedProject = project;
+	}
+	return freshestIdentifiedProject ?? winner;
+}
+/**
+* Builds logical project groups without losing the physical projects that
+* remain the actual navigation and task-creation targets.
+*
+* Presentation-specific metadata, filtering, and activity sorting stay in
+* each client. Grouping modes, overrides, physical deduplication, labels, and
+* member preservation live here so web and mobile cannot drift.
+*/
+function buildProjectGroups(input) {
+	const projectsByPhysicalKey = /* @__PURE__ */ new Map();
+	for (const project of input.projects) {
+		const physicalProjectKey = derivePhysicalProjectKey(project);
+		const existing = projectsByPhysicalKey.get(physicalProjectKey);
+		if (existing) existing.push(project);
+		else projectsByPhysicalKey.set(physicalProjectKey, [project]);
+	}
+	const logicalKeyByPhysicalKey = /* @__PURE__ */ new Map();
+	const groupedMembers = /* @__PURE__ */ new Map();
+	for (const [physicalProjectKey, physicalProjects] of projectsByPhysicalKey) {
+		const winner = physicalProjects.reduce((current, candidate) => shouldReplacePhysicalProjectWinner(current, candidate) ? candidate : current);
+		const logicalKey = deriveLogicalProjectKey(selectProjectIdentitySource(physicalProjects, winner), { groupingMode: resolveProjectGroupingMode(winner, input.settings) });
+		logicalKeyByPhysicalKey.set(physicalProjectKey, logicalKey);
+		const member = {
+			physicalProjectKey,
+			project: winner
+		};
+		const existing = groupedMembers.get(logicalKey);
+		if (existing) existing.push(member);
+		else groupedMembers.set(logicalKey, [member]);
+	}
+	const projectRefsByLogicalKey = /* @__PURE__ */ new Map();
+	const seenProjectRefs = /* @__PURE__ */ new Set();
+	for (const project of input.projects) {
+		const physicalProjectKey = derivePhysicalProjectKey(project);
+		const logicalKey = logicalKeyByPhysicalKey.get(physicalProjectKey) ?? deriveLogicalProjectKeyFromSettings(project, input.settings);
+		const projectRefKey = scopedProjectKey(scopeProjectRef(project.environmentId, project.id));
+		if (seenProjectRefs.has(projectRefKey)) continue;
+		seenProjectRefs.add(projectRefKey);
+		const projectRef = scopeProjectRef(project.environmentId, project.id);
+		const existing = projectRefsByLogicalKey.get(logicalKey);
+		if (existing) existing.push(projectRef);
+		else projectRefsByLogicalKey.set(logicalKey, [projectRef]);
+	}
+	const preferredEnvironmentId = input.preferredEnvironmentId ?? null;
+	return Array.from(groupedMembers, ([key, members]) => {
+		const representative = (preferredEnvironmentId ? members.find((member) => member.project.environmentId === preferredEnvironmentId)?.project : null) ?? members[0].project;
+		return {
+			key,
+			label: members.length > 1 ? deriveProjectGroupLabel({
+				representative,
+				members: members.map((member) => member.project)
+			}) : representative.title,
+			representative,
+			members,
+			memberProjectRefs: projectRefsByLogicalKey.get(key) ?? []
+		};
+	});
+}
 //#endregion
-export { deriveLogicalProjectKey, deriveLogicalProjectKeyFromRef, deriveLogicalProjectKeyFromSettings, derivePhysicalProjectKey, derivePhysicalProjectKeyFromPath, deriveProjectGroupLabel, deriveProjectGroupingOverrideKey, getProjectOrderKey, resolveProjectGroupingMode, selectProjectGroupingSettings };
+export { buildProjectGroups, deriveLogicalProjectKey, deriveLogicalProjectKeyFromRef, deriveLogicalProjectKeyFromSettings, derivePhysicalProjectKey, derivePhysicalProjectKeyFromPath, deriveProjectGroupLabel, deriveProjectGroupingOverrideKey, getProjectOrderKey, resolveProjectGroupingMode, selectProjectGroupingSettings };

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

@@ -1,4 +1,4 @@
-import { Ot as UpdateProjectInput, _x as ProjectReadFileResult, bT as EnvironmentAuthorizationError, c as normalizeProjectPathForDispatch, cv as OrchestrationShellSnapshot, dt as CreateProjectInput, f as AtomCommand, fx as ProjectListEntriesError, ha as EnvironmentRegistry, hx as ProjectReadFileError, jw as ScopedProjectRef, ma as EnvironmentNotRegisteredError, on as EnvironmentRpcUnavailableError, pt as DeleteProjectInput, r as isExplicitRelativePath, rt as EnvironmentProject, s as normalizeProjectPathForComparison, u as EnvironmentCatalogState, vx as ProjectSearchEntriesError, xx as ProjectWriteFileError, zT as EnvironmentId, z_ as OrchestrationDispatchCommandError } from "../../shared.js";
+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 * as Crypto from "effect/Crypto";
 import { Atom } from "effect/unstable/reactivity";
 //#region upstream-t3code/packages/client-runtime/src/state/projectCommands.d.ts
@@ -14,11 +14,13 @@ interface OptimisticProjectFileTarget {
 declare function createProjectEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<EnvironmentRegistry | Crypto.Crypto | R, E>): {
   searchEntries: (target: {
     readonly environmentId: EnvironmentId;
-    readonly input: import("effect/Schema").Struct.ReadonlyMakeIn<{
-      readonly cwd: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
-      readonly query: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
-      readonly limit: import("effect/Schema").Int;
-    }>;
+    readonly input: {
+      readonly cwd: string;
+      readonly query: string;
+      readonly limit: number;
+      readonly kind?: "directory" | "file" | undefined;
+      readonly imageOnly?: boolean | undefined;
+    };
   }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
     readonly entries: readonly {
       readonly path: string;
@@ -28,9 +30,9 @@ declare function createProjectEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<E
   }, E | EnvironmentAuthorizationError | EnvironmentRpcUnavailableError | Error | ProjectSearchEntriesError | import("effect/unstable/rpc/RpcClientError").RpcClientError>>;
   listEntries: (target: {
     readonly environmentId: EnvironmentId;
-    readonly input: import("effect/Schema").Struct.ReadonlyMakeIn<{
-      readonly cwd: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
-    }>;
+    readonly input: {
+      readonly cwd: string;
+    };
   }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
     readonly entries: readonly {
       readonly path: string;
@@ -40,10 +42,10 @@ declare function createProjectEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<E
   }, E | EnvironmentAuthorizationError | EnvironmentRpcUnavailableError | Error | ProjectListEntriesError | import("effect/unstable/rpc/RpcClientError").RpcClientError>>;
   readFile: (target: {
     readonly environmentId: EnvironmentId;
-    readonly input: import("effect/Schema").Struct.ReadonlyMakeIn<{
-      readonly cwd: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
-      readonly relativePath: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
-    }>;
+    readonly input: {
+      readonly cwd: string;
+      readonly relativePath: string;
+    };
   }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
     readonly relativePath: string;
     readonly contents: string;
@@ -71,11 +73,11 @@ declare function createProjectEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<E
   }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | OrchestrationDispatchCommandError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
   writeFile: AtomCommand<{
     readonly environmentId: EnvironmentId;
-    readonly input: import("effect/Schema").Struct.ReadonlyMakeIn<{
-      readonly cwd: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
-      readonly relativePath: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
-      readonly contents: import("effect/Schema").String;
-    }>;
+    readonly input: {
+      readonly cwd: string;
+      readonly relativePath: string;
+      readonly contents: string;
+    };
   }, {
     readonly relativePath: string;
   }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | ProjectWriteFileError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
@@ -111,6 +113,8 @@ declare function createEnvironmentProjectAtoms(input: {
         readonly value: string | boolean;
       }[];
     } | null;
+    readonly defaultThreadEnvMode?: "local" | "worktree" | null | undefined;
+    readonly faviconPath?: string | null | undefined;
     readonly scripts: readonly {
       readonly id: string;
       readonly name: string;
@@ -148,6 +152,8 @@ declare function createEnvironmentProjectAtoms(input: {
         readonly value: string | boolean;
       }[];
     } | null;
+    readonly defaultThreadEnvMode?: "local" | "worktree" | null | undefined;
+    readonly faviconPath?: string | null | undefined;
     readonly scripts: readonly {
       readonly id: string;
       readonly name: string;

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

@@ -1,2 +1,2 @@
-import { Bt as inferProjectTitleFromPath, Ft as findProjectByPath, Ht as isUnsupportedWindowsProjectPath, It as getBrowseDirectoryPath, Lt as getBrowseLeafPathSegment, Mt as appendBrowsePathSegment, Nt as canNavigateUp, Pt as ensureBrowseDirectoryPath, Rt as getBrowseParentPath, Ut as resolveProjectPathForDispatch, Vt as isFilesystemBrowseQuery, Wt as createEnvironmentProjectAtoms, cn as normalizeProjectPathForComparison, in as isExplicitRelativePath, ln as normalizeProjectPathForDispatch, rn as createProjectEnvironmentAtoms, zt as hasTrailingPathSeparator } from "../../shared.js";
+import { Bt as hasTrailingPathSeparator, Ft as ensureBrowseDirectoryPath, Gt as createEnvironmentProjectAtoms, Ht as isFilesystemBrowseQuery, It as findProjectByPath, Lt as getBrowseDirectoryPath, Nt as appendBrowsePathSegment, Pt as canNavigateUp, Rt as getBrowseLeafPathSegment, Ut as isUnsupportedWindowsProjectPath, Vt as inferProjectTitleFromPath, Wt as resolveProjectPathForDispatch, an as isExplicitRelativePath, in as createProjectEnvironmentAtoms, ln as normalizeProjectPathForComparison, un as normalizeProjectPathForDispatch, zt as getBrowseParentPath } from "../../shared.js";
 export { appendBrowsePathSegment, canNavigateUp, createEnvironmentProjectAtoms, createProjectEnvironmentAtoms, ensureBrowseDirectoryPath, findProjectByPath, getBrowseDirectoryPath, getBrowseLeafPathSegment, getBrowseParentPath, hasTrailingPathSeparator, inferProjectTitleFromPath, isExplicitRelativePath as isExplicitRelativeProjectPath, isFilesystemBrowseQuery, isUnsupportedWindowsProjectPath, normalizeProjectPathForComparison, normalizeProjectPathForDispatch, resolveProjectPathForDispatch };

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

@@ -1,4 +1,4 @@
-import { ea as RelayEnvironmentDiscovery, f as AtomCommand, ta as RelayEnvironmentDiscoveryState } from "../../shared.js";
+import { da as RelayEnvironmentDiscoveryState, f as AtomCommand, ua as RelayEnvironmentDiscovery } from "../../shared.js";
 import { AsyncResult, Atom } from "effect/unstable/reactivity";
 //#region upstream-t3code/packages/client-runtime/src/state/relayDiscovery.d.ts
 declare function createRelayEnvironmentDiscoveryAtoms<R, E>(runtime: Atom.AtomRuntime<RelayEnvironmentDiscovery | R, E>): {

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

@@ -1,4 +1,4 @@
-import { $D as flatMap, Fk as getOrElse, Sv as changes, Xr as withLabel, aa as RelayEnvironmentDiscovery, gr as createRuntimeCommand, ia as EMPTY_RELAY_ENVIRONMENT_DISCOVERY_STATE, lD as unwrap, qr as make, ti as value, uO as map } from "../../shared.js";
+import { $r as make, Gk as map, Nk as flatMap, Py as changes, Sj as getOrElse, YO as unwrap, br as createRuntimeCommand, da as RelayEnvironmentDiscovery, ni as withLabel, si as value, ua as EMPTY_RELAY_ENVIRONMENT_DISCOVERY_STATE } from "../../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/state/relayDiscovery.ts
 function createRelayEnvironmentDiscoveryAtoms(runtime) {
 	const stateAtom = runtime.atom(unwrap(RelayEnvironmentDiscovery.pipe(map((discovery) => changes(discovery.state)))), { initialValue: EMPTY_RELAY_ENVIRONMENT_DISCOVERY_STATE });

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

@@ -1,4 +1,4 @@
-import { TS as GitCommandError, bS as VcsUnsupportedOperationError, bT as EnvironmentAuthorizationError, dS as VcsProcessOutputReadError, fS as VcsProcessSpawnError, hS as VcsProcessTimeoutError, ha as EnvironmentRegistry, lS as VcsProcessMissingExitCodeError, mS as VcsProcessStdinWriteError, oS as VcsProcessExitError, on as EnvironmentRpcUnavailableError, uS as VcsProcessOutputLimitError, vS as VcsRepositoryDetectionError, zT as EnvironmentId } from "../../shared.js";
+import { CD as EnvironmentId, JC as VcsProcessOutputReadError, KC as VcsProcessMissingExitCodeError, QC as VcsProcessTimeoutError, Ta as EnvironmentRegistry, UC as VcsProcessExitError, YC as VcsProcessSpawnError, ZC as VcsProcessStdinWriteError, cw as GitCommandError, f as AtomCommand, iD as EnvironmentAuthorizationError, mn as EnvironmentRpcUnavailableError, qC as VcsProcessOutputLimitError, rw as VcsUnsupportedOperationError, tw as VcsRepositoryDetectionError, wa as EnvironmentNotRegisteredError } from "../../shared.js";
 import { Atom } from "effect/unstable/reactivity";
 //#region upstream-t3code/packages/client-runtime/src/state/review.d.ts
 declare function createReviewEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<EnvironmentRegistry | R, E>): {
@@ -23,6 +23,21 @@ declare function createReviewEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<En
       readonly truncated: boolean;
     }[];
   }, E | EnvironmentAuthorizationError | EnvironmentRpcUnavailableError | Error | GitCommandError | import("effect/unstable/rpc/RpcClientError").RpcClientError | VcsProcessExitError | VcsProcessMissingExitCodeError | VcsProcessOutputLimitError | VcsProcessOutputReadError | VcsProcessSpawnError | VcsProcessStdinWriteError | VcsProcessTimeoutError | VcsRepositoryDetectionError | VcsUnsupportedOperationError>>;
+  diffFileContents: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: {
+      readonly cwd: string;
+      readonly sourceKind: "branch-range" | "working-tree";
+      readonly changeType: "change" | "deleted" | "new" | "rename-changed" | "rename-pure";
+      readonly baseRef: string | null;
+      readonly headRef: string | null;
+      readonly oldPath: string;
+      readonly newPath: string;
+    };
+  }, {
+    readonly oldContents: string;
+    readonly newContents: string;
+  }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | GitCommandError | import("effect/unstable/rpc/RpcClientError").RpcClientError | VcsProcessExitError | VcsProcessMissingExitCodeError | VcsProcessOutputLimitError | VcsProcessOutputReadError | VcsProcessSpawnError | VcsProcessStdinWriteError | VcsProcessTimeoutError | VcsRepositoryDetectionError | VcsUnsupportedOperationError>;
 };
 //#endregion
 export { createReviewEnvironmentAtoms };

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

@@ -1,11 +1,32 @@
-import { Fs as WS_METHODS, fr as createEnvironmentRpcQueryAtomFamily } from "../../shared.js";
+import { Us as WS_METHODS, gr as createEnvironmentRpcQueryAtomFamily, hr as createEnvironmentRpcCommand, pr as createAtomCommandScheduler } from "../../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/state/review.ts
 function createReviewEnvironmentAtoms(runtime) {
-	return { diffPreview: createEnvironmentRpcQueryAtomFamily(runtime, {
-		label: "environment-data:review:diff-preview",
-		tag: WS_METHODS.reviewGetDiffPreview,
-		staleTimeMs: 5e3
-	}) };
+	const diffFileScheduler = createAtomCommandScheduler();
+	return {
+		diffPreview: createEnvironmentRpcQueryAtomFamily(runtime, {
+			label: "environment-data:review:diff-preview",
+			tag: WS_METHODS.reviewGetDiffPreview,
+			staleTimeMs: 5e3
+		}),
+		diffFileContents: createEnvironmentRpcCommand(runtime, {
+			label: "environment-data:review:diff-file-contents",
+			tag: WS_METHODS.reviewGetDiffFileContents,
+			scheduler: diffFileScheduler,
+			concurrency: {
+				mode: "singleFlight",
+				key: ({ environmentId, input }) => JSON.stringify([
+					environmentId,
+					input.cwd,
+					input.sourceKind,
+					input.baseRef,
+					input.headRef,
+					input.oldPath,
+					input.newPath,
+					input.changeType
+				])
+			}
+		})
+	};
 }
 //#endregion
 export { createReviewEnvironmentAtoms };

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

@@ -1,2 +1,2 @@
-import { A as environmentRpcKey, B as settleAsyncResult, C as createEnvironmentRpcCommand, D as createEnvironmentSubscriptionAtomFamily, E as createEnvironmentRpcSubscriptionAtomFamily, F as mapAtomCommandResult, H as squashAtomCommandFailure, I as reportAtomCommandResult, L as runAtomCommand, M as executeAtomQuery, N as followStreamInEnvironment, O as createRuntimeCommand, P as isAtomCommandInterrupted, R as runInEnvironment, S as createEnvironmentCommand, T as createEnvironmentRpcStreamCommand, V as settlePromise, _ as AtomCommandResult, b as SettledAsyncResult, f as AtomCommand, g as AtomCommandReporter, h as AtomCommandOptions, j as executeAtomCommand, k as createRuntimeStreamCommand, m as AtomCommandFailure, p as AtomCommandConcurrency, v as AtomCommandScheduler, w as createEnvironmentRpcQueryAtomFamily, x as createAtomCommandScheduler, y as AtomCommandSuccess, z as runStreamInEnvironment } from "../../shared.js";
-export { AtomCommand, AtomCommandConcurrency, AtomCommandFailure, AtomCommandOptions, AtomCommandReporter, AtomCommandResult, AtomCommandScheduler, AtomCommandSuccess, SettledAsyncResult, createAtomCommandScheduler, createEnvironmentCommand, createEnvironmentRpcCommand, createEnvironmentRpcQueryAtomFamily, createEnvironmentRpcStreamCommand, createEnvironmentRpcSubscriptionAtomFamily, createEnvironmentSubscriptionAtomFamily, createRuntimeCommand, createRuntimeStreamCommand, environmentRpcKey, executeAtomCommand, executeAtomQuery, followStreamInEnvironment, isAtomCommandInterrupted, mapAtomCommandResult, reportAtomCommandResult, runAtomCommand, runInEnvironment, runStreamInEnvironment, settleAsyncResult, settlePromise, squashAtomCommandFailure };
+import { A as environmentRpcKey, B as scheduleAtomCommandEffect, C as createEnvironmentRpcCommand, D as createEnvironmentSubscriptionAtomFamily, E as createEnvironmentRpcSubscriptionAtomFamily, F as mapAtomCommandResult, H as settlePromise, I as reportAtomCommandResult, L as runAtomCommand, M as executeAtomQuery, N as followStreamInEnvironment, O as createRuntimeCommand, P as isAtomCommandInterrupted, R as runInEnvironment, S as createEnvironmentCommand, T as createEnvironmentRpcStreamCommand, U as squashAtomCommandFailure, V as settleAsyncResult, _ as AtomCommandResult, b as SettledAsyncResult, f as AtomCommand, g as AtomCommandReporter, h as AtomCommandOptions, j as executeAtomCommand, k as createRuntimeStreamCommand, m as AtomCommandFailure, p as AtomCommandConcurrency, v as AtomCommandScheduler, w as createEnvironmentRpcQueryAtomFamily, x as createAtomCommandScheduler, y as AtomCommandSuccess, z as runStreamInEnvironment } from "../../shared.js";
+export { AtomCommand, AtomCommandConcurrency, AtomCommandFailure, AtomCommandOptions, AtomCommandReporter, AtomCommandResult, AtomCommandScheduler, AtomCommandSuccess, SettledAsyncResult, createAtomCommandScheduler, createEnvironmentCommand, createEnvironmentRpcCommand, createEnvironmentRpcQueryAtomFamily, createEnvironmentRpcStreamCommand, createEnvironmentRpcSubscriptionAtomFamily, createEnvironmentSubscriptionAtomFamily, createRuntimeCommand, createRuntimeStreamCommand, environmentRpcKey, executeAtomCommand, executeAtomQuery, followStreamInEnvironment, isAtomCommandInterrupted, mapAtomCommandResult, reportAtomCommandResult, runAtomCommand, runInEnvironment, runStreamInEnvironment, scheduleAtomCommandEffect, settleAsyncResult, settlePromise, squashAtomCommandFailure };

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

@@ -1,2 +1,2 @@
-import { Ar as squashAtomCommandFailure, Cr as mapAtomCommandResult, Dr as runStreamInEnvironment, Er as runInEnvironment, Or as settleAsyncResult, Sr as isAtomCommandInterrupted, Tr as runAtomCommand, _r as createRuntimeStreamCommand, br as executeAtomQuery, dr as createEnvironmentRpcCommand, fr as createEnvironmentRpcQueryAtomFamily, gr as createRuntimeCommand, hr as createEnvironmentSubscriptionAtomFamily, kr as settlePromise, lr as createAtomCommandScheduler, mr as createEnvironmentRpcSubscriptionAtomFamily, pr as createEnvironmentRpcStreamCommand, ur as createEnvironmentCommand, vr as environmentRpcKey, wr as reportAtomCommandResult, xr as followStreamInEnvironment, yr as executeAtomCommand } from "../../shared.js";
-export { createAtomCommandScheduler, createEnvironmentCommand, createEnvironmentRpcCommand, createEnvironmentRpcQueryAtomFamily, createEnvironmentRpcStreamCommand, createEnvironmentRpcSubscriptionAtomFamily, createEnvironmentSubscriptionAtomFamily, createRuntimeCommand, createRuntimeStreamCommand, environmentRpcKey, executeAtomCommand, executeAtomQuery, followStreamInEnvironment, isAtomCommandInterrupted, mapAtomCommandResult, reportAtomCommandResult, runAtomCommand, runInEnvironment, runStreamInEnvironment, settleAsyncResult, settlePromise, squashAtomCommandFailure };
+import { Ar as runInEnvironment, Cr as executeAtomCommand, Dr as mapAtomCommandResult, Er as isAtomCommandInterrupted, Fr as squashAtomCommandFailure, Mr as scheduleAtomCommandEffect, Nr as settleAsyncResult, Or as reportAtomCommandResult, Pr as settlePromise, Sr as environmentRpcKey, Tr as followStreamInEnvironment, _r as createEnvironmentRpcStreamCommand, br as createRuntimeCommand, gr as createEnvironmentRpcQueryAtomFamily, hr as createEnvironmentRpcCommand, jr as runStreamInEnvironment, kr as runAtomCommand, mr as createEnvironmentCommand, pr as createAtomCommandScheduler, vr as createEnvironmentRpcSubscriptionAtomFamily, wr as executeAtomQuery, xr as createRuntimeStreamCommand, yr as createEnvironmentSubscriptionAtomFamily } from "../../shared.js";
+export { createAtomCommandScheduler, createEnvironmentCommand, createEnvironmentRpcCommand, createEnvironmentRpcQueryAtomFamily, createEnvironmentRpcStreamCommand, createEnvironmentRpcSubscriptionAtomFamily, createEnvironmentSubscriptionAtomFamily, createRuntimeCommand, createRuntimeStreamCommand, environmentRpcKey, executeAtomCommand, executeAtomQuery, followStreamInEnvironment, isAtomCommandInterrupted, mapAtomCommandResult, reportAtomCommandResult, runAtomCommand, runInEnvironment, runStreamInEnvironment, scheduleAtomCommandEffect, settleAsyncResult, settlePromise, squashAtomCommandFailure };