t3code-cli 0.14.2 → 0.15.0

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

@@ -0,0 +1,478 @@
+import { $O as EnvironmentAuthorizationError, Da as EnvironmentNotRegisteredError, LE as PullRequestDiffInput, Oa as EnvironmentRegistry, RE as PullRequestDiffResult, TD as PullRequestUnavailableError, f as AtomCommand, hn as EnvironmentRpcUnavailableError, iD as PullRequestOperationError, ms as PreparedConnection, no as RemoteEnvironmentRequestError, vk as EnvironmentId } from "../../shared.js";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import "effect/Option";
+import * as Layer from "effect/Layer";
+import { HttpClient } from "effect/unstable/http";
+import { Atom } from "effect/unstable/reactivity";
+//#region upstream-t3code/packages/client-runtime/src/state/pullRequestDiffHttp.d.ts
+declare const PullRequestDiffLoader_base: Context.ServiceClass<PullRequestDiffLoader, "@t3tools/client-runtime/state/pullRequestDiffHttp/PullRequestDiffLoader", {
+  readonly load: (prepared: PreparedConnection, input: PullRequestDiffInput) => Effect.Effect<PullRequestDiffResult, RemoteEnvironmentRequestError>;
+}>;
+declare class PullRequestDiffLoader extends PullRequestDiffLoader_base {}
+declare const pullRequestDiffLoaderLayer: Layer.Layer<PullRequestDiffLoader, never, HttpClient.HttpClient>;
+//#endregion
+//#region upstream-t3code/packages/client-runtime/src/state/pullRequests.d.ts
+declare const EnvironmentHttpConnectionNotReadyError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "EnvironmentHttpConnectionNotReadyError";
+} & Readonly<A>;
+declare class EnvironmentHttpConnectionNotReadyError extends EnvironmentHttpConnectionNotReadyError_base<{
+  readonly message: string;
+}> {}
+/**
+ * Every read shells out to the GitHub CLI, so results are reused for a short while and
+ * refreshed explicitly. Mutations run serially per environment: `gh` actions on the same
+ * pull request are order-sensitive, and the detail view refetches after each one.
+ */
+declare function createPullRequestEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<EnvironmentRegistry | PullRequestDiffLoader | R, E>): {
+  list: (target: {
+    readonly environmentId: EnvironmentId;
+    readonly input: {
+      readonly state: "all" | "closed" | "merged" | "open";
+      readonly involvement?: "all" | "authored" | "reviewing" | undefined;
+      readonly filters?: {
+        readonly draft?: "hide" | "only" | undefined;
+        readonly review?: "approved" | "changes-requested" | "none" | "review-required" | undefined;
+        readonly checks?: "failing" | "passing" | undefined;
+        readonly labels?: readonly (readonly string[])[] | undefined;
+        readonly excludedLabels?: readonly string[] | undefined;
+        readonly author?: string | undefined;
+      } | undefined;
+      readonly projectId?: (string & import("effect/Brand").Brand<"ProjectId">) | undefined;
+      readonly projectIds?: readonly (string & import("effect/Brand").Brand<"ProjectId">)[] | undefined;
+      readonly host?: string | undefined;
+      readonly limit?: number | undefined;
+      readonly cursors?: {
+        readonly [x: string]: string;
+      } | undefined;
+      readonly query?: string | undefined;
+    };
+  }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
+    readonly viewers: {
+      readonly [x: string]: string;
+    };
+    readonly providers: readonly {
+      readonly host: string;
+      readonly kind: "azure-devops" | "bitbucket" | "github" | "gitlab" | "unknown";
+      readonly searchesOnHost: boolean;
+      readonly projectCount: number;
+      readonly configured: boolean;
+      readonly detail: string | null;
+    }[];
+    readonly entries: readonly {
+      readonly provider: "azure-devops" | "bitbucket" | "github" | "gitlab" | "unknown";
+      readonly host: string;
+      readonly projectId: string & import("effect/Brand").Brand<"ProjectId">;
+      readonly projectTitle: string;
+      readonly repository: string;
+      readonly number: number;
+      readonly title: string;
+      readonly url: string;
+      readonly author: {
+        readonly login: string;
+        readonly name: string | null;
+        readonly avatarUrl: string | null;
+      } | null;
+      readonly headBranch: string;
+      readonly baseBranch: string;
+      readonly state: "closed" | "merged" | "open";
+      readonly isDraft: boolean;
+      readonly mergeability: "conflicting" | "mergeable" | "unknown";
+      readonly additions: number;
+      readonly deletions: number;
+      readonly createdAt: string;
+      readonly updatedAt: string;
+      readonly viewerReviewRequested: boolean;
+      readonly labels: readonly {
+        readonly name: string;
+        readonly color: string | null;
+      }[];
+      readonly reviewDecision?: "approved" | "changes-requested" | "review-required" | undefined;
+      readonly checksState?: "failing" | "passing" | "pending" | undefined;
+    }[];
+    readonly errors: readonly {
+      readonly projectId: string & import("effect/Brand").Brand<"ProjectId">;
+      readonly projectTitle: string;
+      readonly message: string;
+    }[];
+    readonly truncated: boolean;
+    readonly nextCursors: {
+      readonly [x: string]: string;
+    };
+  }, E | EnvironmentAuthorizationError | EnvironmentRpcUnavailableError | Error | PullRequestOperationError | PullRequestUnavailableError | import("effect/unstable/rpc/RpcClientError").RpcClientError>>;
+  /**
+   * The line counts for rows the listing has already handed over. Its own query because the
+   * listing is quicker without them — measured over twelve repositories, ~4.0s against ~7.1s —
+   * so the rows arrive first and their stats a moment later. Kept longer than the listing:
+   * a change request's size only moves when somebody pushes to it.
+   */
+  listStats: (target: {
+    readonly environmentId: EnvironmentId;
+    readonly input: {
+      readonly refs: readonly {
+        readonly projectId: string & import("effect/Brand").Brand<"ProjectId">;
+        readonly repository: string;
+        readonly number: number;
+      }[];
+    };
+  }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
+    readonly stats: readonly {
+      readonly projectId: string & import("effect/Brand").Brand<"ProjectId">;
+      readonly repository: string;
+      readonly number: number;
+      readonly additions: number;
+      readonly deletions: number;
+    }[];
+  }, E | EnvironmentAuthorizationError | EnvironmentRpcUnavailableError | Error | PullRequestOperationError | PullRequestUnavailableError | import("effect/unstable/rpc/RpcClientError").RpcClientError>>;
+  detail: (target: {
+    readonly environmentId: EnvironmentId;
+    readonly input: {
+      readonly projectId: string & import("effect/Brand").Brand<"ProjectId">;
+      readonly repository: string;
+      readonly number: number;
+    };
+  }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
+    readonly provider: "azure-devops" | "bitbucket" | "github" | "gitlab" | "unknown";
+    readonly capabilities: {
+      readonly diff: boolean;
+      readonly comment: boolean;
+      readonly actions: readonly ("close" | "disable-auto-merge" | "draft" | "enable-auto-merge" | "merge" | "ready" | "reopen" | "update-branch")[];
+      readonly mergeMethods: readonly ("merge" | "rebase" | "squash")[];
+      readonly updateMethods?: readonly ("merge" | "rebase")[] | undefined;
+      readonly search: boolean;
+      readonly reactions?: boolean | undefined;
+      readonly review: {
+        readonly inlineComment: boolean;
+        readonly reply: boolean;
+        readonly resolve: boolean;
+        readonly verdicts: readonly ("approve" | "comment" | "request-changes")[];
+      };
+      readonly reviewers: {
+        readonly request: boolean;
+        readonly listCandidates: boolean;
+      };
+      readonly edit?: {
+        readonly changeRequest: boolean;
+        readonly comment: boolean;
+      } | undefined;
+    };
+    readonly viewerPermissions: {
+      readonly actions: readonly ("close" | "disable-auto-merge" | "draft" | "enable-auto-merge" | "merge" | "ready" | "reopen" | "update-branch")[];
+      readonly comment: boolean;
+      readonly resolve: boolean;
+      readonly verdicts: readonly ("approve" | "comment" | "request-changes")[];
+      readonly requestReviewers: boolean;
+      readonly updateMethods?: readonly ("merge" | "rebase")[] | undefined;
+    };
+    readonly projectId: string & import("effect/Brand").Brand<"ProjectId">;
+    readonly projectTitle: string;
+    readonly workspaceRoot: string;
+    readonly repository: string;
+    readonly number: number;
+    readonly title: string;
+    readonly body: string;
+    readonly url: string;
+    readonly author: {
+      readonly login: string;
+      readonly name: string | null;
+      readonly avatarUrl: string | null;
+    } | null;
+    readonly state: "closed" | "merged" | "open";
+    readonly isDraft: boolean;
+    readonly mergeability: "conflicting" | "mergeable" | "unknown";
+    readonly additions: number;
+    readonly deletions: number;
+    readonly changedFiles: number;
+    readonly headBranch: string;
+    readonly baseBranch: string;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly mergedAt: string | null;
+    readonly closedAt: string | null;
+    readonly reviewers: readonly {
+      readonly login: string;
+      readonly name: string | null;
+      readonly avatarUrl: string | null;
+    }[];
+    readonly labels: readonly {
+      readonly name: string;
+      readonly color: string | null;
+    }[];
+    readonly checks: readonly {
+      readonly name: string;
+      readonly status: "cancelled" | "failure" | "neutral" | "pending" | "skipped" | "success";
+      readonly description: string | null;
+      readonly url: string | null;
+    }[];
+    readonly mergeCapabilities: {
+      readonly merge: boolean;
+      readonly squash: boolean;
+      readonly rebase: boolean;
+    };
+    readonly viewer?: string | undefined;
+    readonly baseComparison?: "behind" | "unknown" | "up-to-date" | undefined;
+    readonly behindBy?: number | undefined;
+    readonly autoMergeEnabled?: boolean | undefined;
+  }, E | EnvironmentAuthorizationError | EnvironmentRpcUnavailableError | Error | PullRequestOperationError | PullRequestUnavailableError | import("effect/unstable/rpc/RpcClientError").RpcClientError>>;
+  activity: (target: {
+    readonly environmentId: EnvironmentId;
+    readonly input: {
+      readonly projectId: string & import("effect/Brand").Brand<"ProjectId">;
+      readonly repository: string;
+      readonly number: number;
+    };
+  }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
+    readonly author?: {
+      readonly login: string;
+      readonly name: string | null;
+      readonly avatarUrl: string | null;
+    } | null | undefined;
+    readonly reviewers?: readonly {
+      readonly login: string;
+      readonly name: string | null;
+      readonly avatarUrl: string | null;
+    }[] | undefined;
+    readonly comments: readonly {
+      readonly id: string;
+      readonly kind: "issue-comment" | "review" | "review-comment";
+      readonly author: {
+        readonly login: string;
+        readonly name: string | null;
+        readonly avatarUrl: string | null;
+      } | null;
+      readonly body: string;
+      readonly createdAt: string;
+      readonly url: string | null;
+      readonly path: string | null;
+      readonly reviewState: string | null;
+      readonly reactions?: readonly {
+        readonly content: "confused" | "eyes" | "heart" | "hooray" | "laugh" | "rocket" | "thumbs-down" | "thumbs-up";
+        readonly count: number;
+        readonly actors: readonly string[];
+        readonly viewerHasReacted: boolean;
+      }[] | undefined;
+    }[];
+    readonly commentCount: number;
+    readonly commentsTruncated: boolean;
+    readonly reviewThreads: readonly {
+      readonly id: string;
+      readonly path: string;
+      readonly line: number | null;
+      readonly side: "left" | "right";
+      readonly isResolved: boolean;
+      readonly isOutdated: boolean;
+      readonly comments: readonly {
+        readonly id: string;
+        readonly author: {
+          readonly login: string;
+          readonly name: string | null;
+          readonly avatarUrl: string | null;
+        } | null;
+        readonly body: string;
+        readonly createdAt: string;
+        readonly url: string | null;
+        readonly reactions?: readonly {
+          readonly content: "confused" | "eyes" | "heart" | "hooray" | "laugh" | "rocket" | "thumbs-down" | "thumbs-up";
+          readonly count: number;
+          readonly actors: readonly string[];
+          readonly viewerHasReacted: boolean;
+        }[] | undefined;
+      }[];
+    }[];
+    readonly commits: readonly {
+      readonly oid: string;
+      readonly messageHeadline: string;
+      readonly committedDate: string;
+      readonly additions?: number | undefined;
+      readonly deletions?: number | undefined;
+      readonly authors?: readonly {
+        readonly login: string;
+        readonly name: string | null;
+        readonly avatarUrl: string | null;
+      }[] | undefined;
+    }[];
+    readonly reactions?: readonly {
+      readonly content: "confused" | "eyes" | "heart" | "hooray" | "laugh" | "rocket" | "thumbs-down" | "thumbs-up";
+      readonly count: number;
+      readonly actors: readonly string[];
+      readonly viewerHasReacted: boolean;
+    }[] | undefined;
+  }, E | EnvironmentAuthorizationError | EnvironmentRpcUnavailableError | Error | PullRequestOperationError | PullRequestUnavailableError | import("effect/unstable/rpc/RpcClientError").RpcClientError>>;
+  diff: (target: {
+    readonly environmentId: EnvironmentId;
+    readonly input: {
+      readonly projectId: string & import("effect/Brand").Brand<"ProjectId">;
+      readonly repository: string;
+      readonly number: number;
+      readonly cursor?: string | undefined;
+      readonly commit?: string | undefined;
+    };
+  }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
+    readonly patch: string;
+    readonly truncated: boolean;
+    readonly nextCursor: string | null;
+    readonly omittedFileStats?: readonly {
+      readonly path: string;
+      readonly additions: number;
+      readonly deletions: number;
+    }[] | undefined;
+  }, E | EnvironmentHttpConnectionNotReadyError | Error | RemoteEnvironmentRequestError>>;
+  diffFileContents: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: {
+      readonly projectId: string & import("effect/Brand").Brand<"ProjectId">;
+      readonly repository: string;
+      readonly number: number;
+      readonly commit?: string | undefined;
+      readonly changeType: "change" | "deleted" | "new" | "rename-changed" | "rename-pure";
+      readonly oldPath: string;
+      readonly newPath: string;
+    };
+  }, {
+    readonly oldContents: string;
+    readonly newContents: string;
+  }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | PullRequestOperationError | PullRequestUnavailableError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
+  runAction: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: {
+      readonly projectId: string & import("effect/Brand").Brand<"ProjectId">;
+      readonly repository: string;
+      readonly number: number;
+      readonly action: "close" | "disable-auto-merge" | "draft" | "enable-auto-merge" | "merge" | "ready" | "reopen" | "update-branch";
+      readonly mergeMethod?: "merge" | "rebase" | "squash" | undefined;
+      readonly updateMethod?: "merge" | "rebase" | undefined;
+    };
+  }, void, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | PullRequestOperationError | PullRequestUnavailableError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
+  update: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: {
+      readonly projectId: string & import("effect/Brand").Brand<"ProjectId">;
+      readonly repository: string;
+      readonly number: number;
+      readonly title?: string | undefined;
+      readonly body?: string | undefined;
+    };
+  }, void, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | PullRequestOperationError | PullRequestUnavailableError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
+  comment: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: {
+      readonly projectId: string & import("effect/Brand").Brand<"ProjectId">;
+      readonly repository: string;
+      readonly number: number;
+      readonly body: string;
+    };
+  }, void, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | PullRequestOperationError | PullRequestUnavailableError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
+  updateComment: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: {
+      readonly projectId: string & import("effect/Brand").Brand<"ProjectId">;
+      readonly repository: string;
+      readonly number: number;
+      readonly commentId: string;
+      readonly kind: "issue-comment" | "review-comment";
+      readonly body: string;
+    };
+  }, void, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | PullRequestOperationError | PullRequestUnavailableError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
+  submitReview: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: {
+      readonly projectId: string & import("effect/Brand").Brand<"ProjectId">;
+      readonly repository: string;
+      readonly number: number;
+      readonly verdict: "approve" | "comment" | "request-changes";
+      readonly body: string;
+      readonly comments: readonly {
+        readonly path: string;
+        readonly oldPath?: string | undefined;
+        readonly line: number;
+        readonly side: "left" | "right";
+        readonly body: string;
+      }[];
+    };
+  }, void, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | PullRequestOperationError | PullRequestUnavailableError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
+  replyToThread: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: {
+      readonly projectId: string & import("effect/Brand").Brand<"ProjectId">;
+      readonly repository: string;
+      readonly number: number;
+      readonly threadId: string;
+      readonly body: string;
+    };
+  }, void, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | PullRequestOperationError | PullRequestUnavailableError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
+  /**
+   * Its own query rather than part of the detail: the people who may be asked are only wanted
+   * once somebody opens the reviewer menu, so this atom is read then and not before. Kept fresh
+   * for a minute, because who has access to a repository changes far more slowly than the
+   * change request it is being read for.
+   */
+  reviewerCandidates: (target: {
+    readonly environmentId: EnvironmentId;
+    readonly input: {
+      readonly projectId: string & import("effect/Brand").Brand<"ProjectId">;
+      readonly repository: string;
+      readonly number: number;
+    };
+  }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
+    readonly candidates: readonly {
+      readonly login: string;
+      readonly name: string | null;
+      readonly avatarUrl: string | null;
+      readonly id: string;
+      readonly kind: "team" | "user";
+      readonly isRequested: boolean;
+    }[];
+    readonly truncated: boolean;
+  }, E | EnvironmentAuthorizationError | EnvironmentRpcUnavailableError | Error | PullRequestOperationError | PullRequestUnavailableError | import("effect/unstable/rpc/RpcClientError").RpcClientError>>;
+  requestReviewers: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: {
+      readonly projectId: string & import("effect/Brand").Brand<"ProjectId">;
+      readonly repository: string;
+      readonly number: number;
+      readonly reviewers: readonly {
+        readonly id: string;
+        readonly kind: "team" | "user";
+      }[];
+      readonly requested: boolean;
+    };
+  }, void, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | PullRequestOperationError | PullRequestUnavailableError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
+  setThreadResolution: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: {
+      readonly projectId: string & import("effect/Brand").Brand<"ProjectId">;
+      readonly repository: string;
+      readonly number: number;
+      readonly threadId: string;
+      readonly resolved: boolean;
+    };
+  }, void, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | PullRequestOperationError | PullRequestUnavailableError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
+  setReaction: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: {
+      readonly projectId: string & import("effect/Brand").Brand<"ProjectId">;
+      readonly repository: string;
+      readonly number: number;
+      readonly subjectId?: string | undefined;
+      readonly content: "confused" | "eyes" | "heart" | "hooray" | "laugh" | "rocket" | "thumbs-down" | "thumbs-up";
+      readonly reacted: boolean;
+    };
+  }, void, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | PullRequestOperationError | PullRequestUnavailableError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
+  /**
+   * Explicit refresh: forget the server's cached answers, then re-run the reads. A separate
+   * request rather than a flag on a read, so only a person's refresh spends host requests
+   * while every silent re-read shares the cache.
+   */
+  invalidate: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: {
+      readonly reference?: {
+        readonly projectId: string & import("effect/Brand").Brand<"ProjectId">;
+        readonly repository: string;
+        readonly number: number;
+      } | undefined;
+    };
+  }, void, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | PullRequestOperationError | PullRequestUnavailableError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
+};
+//#endregion
+export { EnvironmentHttpConnectionNotReadyError, PullRequestDiffLoader, createPullRequestEnvironmentAtoms, pullRequestDiffLoaderLayer };

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

@@ -0,0 +1,172 @@
+import { AN as Service, HM as TaggedError, Ho as makeEnvironmentHttpApiClient, Hr as buildEnvironmentAuthHeaders, Kj as fn, Qj as gen, Ra as EnvironmentSupervisor, Uo as makeEnvironmentHttpApiUrlBuilder, Ur as withEnvironmentCredentials, VN as isNone, Vo as executeEnvironmentHttpRequest, Vy as get, YM as effect, _r as createEnvironmentRpcCommand, gr as createEnvironmentQueryAtomFamily, hM as provideService, lc as WS_METHODS, mr as createAtomCommandScheduler, ro as ManagedRelayDpopSigner, vD as HttpClient, vr as createEnvironmentRpcQueryAtomFamily, yM as serviceOption } from "../../shared.js";
+//#region upstream-t3code/packages/client-runtime/src/state/pullRequestDiffHttp.ts
+const DEFAULT_PULL_REQUEST_DIFF_TIMEOUT_MS = 6e4;
+const fetchEnvironmentPullRequestDiff = fn("clientRuntime.state.fetchEnvironmentPullRequestDiff")(function* (input) {
+	const requestUrl = makeEnvironmentHttpApiUrlBuilder(input.prepared.httpBaseUrl).pullRequests.diff();
+	const client = yield* makeEnvironmentHttpApiClient(input.prepared.httpBaseUrl);
+	const headers = yield* buildEnvironmentAuthHeaders(input.prepared.httpAuthorization, "POST", requestUrl, input.signer);
+	return yield* executeEnvironmentHttpRequest(requestUrl, input.timeoutMs ?? DEFAULT_PULL_REQUEST_DIFF_TIMEOUT_MS, withEnvironmentCredentials(input.prepared.httpAuthorization, client.pullRequests.diff({
+		payload: input.diff,
+		headers
+	})));
+});
+var PullRequestDiffLoader = class extends Service()("@t3tools/client-runtime/state/pullRequestDiffHttp/PullRequestDiffLoader") {};
+const pullRequestDiffLoaderLayer = effect(PullRequestDiffLoader, gen(function* () {
+	const httpClient = yield* HttpClient;
+	const signer = yield* serviceOption(ManagedRelayDpopSigner);
+	return PullRequestDiffLoader.of({ load: (prepared, input) => fetchEnvironmentPullRequestDiff({
+		prepared,
+		diff: input,
+		signer
+	}).pipe(provideService(HttpClient, httpClient)) });
+}));
+//#endregion
+//#region upstream-t3code/packages/client-runtime/src/state/pullRequests.ts
+var EnvironmentHttpConnectionNotReadyError = class extends TaggedError("EnvironmentHttpConnectionNotReadyError") {};
+/**
+* Every read shells out to the GitHub CLI, so results are reused for a short while and
+* refreshed explicitly. Mutations run serially per environment: `gh` actions on the same
+* pull request are order-sensitive, and the detail view refetches after each one.
+*/
+function createPullRequestEnvironmentAtoms(runtime) {
+	const commandScheduler = createAtomCommandScheduler();
+	const serialPerEnvironment = {
+		mode: "serial",
+		key: ({ environmentId }) => environmentId
+	};
+	return {
+		list: createEnvironmentRpcQueryAtomFamily(runtime, {
+			label: "environment-data:pull-requests:list",
+			tag: WS_METHODS.pullRequestsList,
+			staleTimeMs: 3e4
+		}),
+		/**
+		* The line counts for rows the listing has already handed over. Its own query because the
+		* listing is quicker without them — measured over twelve repositories, ~4.0s against ~7.1s —
+		* so the rows arrive first and their stats a moment later. Kept longer than the listing:
+		* a change request's size only moves when somebody pushes to it.
+		*/
+		listStats: createEnvironmentRpcQueryAtomFamily(runtime, {
+			label: "environment-data:pull-requests:list-stats",
+			tag: WS_METHODS.pullRequestsListStats,
+			staleTimeMs: 6e4
+		}),
+		detail: createEnvironmentRpcQueryAtomFamily(runtime, {
+			label: "environment-data:pull-requests:detail",
+			tag: WS_METHODS.pullRequestsDetail,
+			staleTimeMs: 15e3
+		}),
+		activity: createEnvironmentRpcQueryAtomFamily(runtime, {
+			label: "environment-data:pull-requests:activity",
+			tag: WS_METHODS.pullRequestsActivity,
+			staleTimeMs: 15e3
+		}),
+		diff: createEnvironmentQueryAtomFamily(runtime, {
+			label: "environment-data:pull-requests:diff",
+			staleTimeMs: 6e4,
+			execute: (input) => gen(function* () {
+				const supervisor = yield* EnvironmentSupervisor;
+				const loader = yield* PullRequestDiffLoader;
+				const prepared = yield* get(supervisor.prepared);
+				if (isNone(prepared)) return yield* new EnvironmentHttpConnectionNotReadyError({ message: "The environment HTTP connection is not ready." });
+				return yield* loader.load(prepared.value, input);
+			})
+		}),
+		diffFileContents: createEnvironmentRpcCommand(runtime, {
+			label: "environment-data:pull-requests:diff-file-contents",
+			tag: WS_METHODS.pullRequestsDiffFileContents,
+			scheduler: commandScheduler,
+			concurrency: {
+				mode: "singleFlight",
+				key: ({ environmentId, input }) => JSON.stringify([
+					environmentId,
+					input.projectId,
+					input.repository,
+					input.number,
+					input.commit ?? null,
+					input.changeType,
+					input.oldPath,
+					input.newPath
+				])
+			}
+		}),
+		runAction: createEnvironmentRpcCommand(runtime, {
+			label: "environment-data:pull-requests:run-action",
+			tag: WS_METHODS.pullRequestsRunAction,
+			scheduler: commandScheduler,
+			concurrency: serialPerEnvironment
+		}),
+		update: createEnvironmentRpcCommand(runtime, {
+			label: "environment-data:pull-requests:update",
+			tag: WS_METHODS.pullRequestsUpdate,
+			scheduler: commandScheduler,
+			concurrency: serialPerEnvironment
+		}),
+		comment: createEnvironmentRpcCommand(runtime, {
+			label: "environment-data:pull-requests:comment",
+			tag: WS_METHODS.pullRequestsComment,
+			scheduler: commandScheduler,
+			concurrency: serialPerEnvironment
+		}),
+		updateComment: createEnvironmentRpcCommand(runtime, {
+			label: "environment-data:pull-requests:update-comment",
+			tag: WS_METHODS.pullRequestsUpdateComment,
+			scheduler: commandScheduler,
+			concurrency: serialPerEnvironment
+		}),
+		submitReview: createEnvironmentRpcCommand(runtime, {
+			label: "environment-data:pull-requests:submit-review",
+			tag: WS_METHODS.pullRequestsSubmitReview,
+			scheduler: commandScheduler,
+			concurrency: serialPerEnvironment
+		}),
+		replyToThread: createEnvironmentRpcCommand(runtime, {
+			label: "environment-data:pull-requests:reply-to-thread",
+			tag: WS_METHODS.pullRequestsReplyToThread,
+			scheduler: commandScheduler,
+			concurrency: serialPerEnvironment
+		}),
+		/**
+		* Its own query rather than part of the detail: the people who may be asked are only wanted
+		* once somebody opens the reviewer menu, so this atom is read then and not before. Kept fresh
+		* for a minute, because who has access to a repository changes far more slowly than the
+		* change request it is being read for.
+		*/
+		reviewerCandidates: createEnvironmentRpcQueryAtomFamily(runtime, {
+			label: "environment-data:pull-requests:reviewer-candidates",
+			tag: WS_METHODS.pullRequestsReviewerCandidates,
+			staleTimeMs: 6e4
+		}),
+		requestReviewers: createEnvironmentRpcCommand(runtime, {
+			label: "environment-data:pull-requests:request-reviewers",
+			tag: WS_METHODS.pullRequestsRequestReviewers,
+			scheduler: commandScheduler,
+			concurrency: serialPerEnvironment
+		}),
+		setThreadResolution: createEnvironmentRpcCommand(runtime, {
+			label: "environment-data:pull-requests:set-thread-resolution",
+			tag: WS_METHODS.pullRequestsSetThreadResolution,
+			scheduler: commandScheduler,
+			concurrency: serialPerEnvironment
+		}),
+		setReaction: createEnvironmentRpcCommand(runtime, {
+			label: "environment-data:pull-requests:set-reaction",
+			tag: WS_METHODS.pullRequestsSetReaction,
+			scheduler: commandScheduler,
+			concurrency: serialPerEnvironment
+		}),
+		/**
+		* Explicit refresh: forget the server's cached answers, then re-run the reads. A separate
+		* request rather than a flag on a read, so only a person's refresh spends host requests
+		* while every silent re-read shares the cache.
+		*/
+		invalidate: createEnvironmentRpcCommand(runtime, {
+			label: "environment-data:pull-requests:invalidate",
+			tag: WS_METHODS.pullRequestsInvalidate,
+			scheduler: commandScheduler,
+			concurrency: serialPerEnvironment
+		})
+	};
+}
+//#endregion
+export { EnvironmentHttpConnectionNotReadyError, PullRequestDiffLoader, createPullRequestEnvironmentAtoms, pullRequestDiffLoaderLayer };

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

@@ -1,4 +1,4 @@
-import { da as RelayEnvironmentDiscoveryState, f as AtomCommand, ua as RelayEnvironmentDiscovery } from "../../shared.js";
+import { f as AtomCommand, ma as RelayEnvironmentDiscoveryState, pa 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 { $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";
+import { By as changes, Gj as flatMap, Kr as make, LN as getOrElse, Sr as createRuntimeCommand, Yr as withLabel, ei as value, fa as EMPTY_RELAY_ENVIRONMENT_DISCOVERY_STATE, pa as RelayEnvironmentDiscovery, rM as map, sj as unwrap } 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 });