Commit 845ddd9354538d42db1cc7dc30143c6bb8f0d40f | the-knife

apps/mobile/src/features/threads/NewTaskContextPickerScreens.tsx+14-19

 @@ -2,8 +2,6 @@ import { MaterialListRow } from "../../components/MaterialListRow";
 import type { EnvironmentProject } from "@t3tools/client-runtime/state/shell";
 import type { VcsRef } from "@t3tools/client-runtime/state/vcs";
 import { type EnvironmentId, resolveEnvironmentMachineKind } from "@t3tools/contracts";
-import * as Cause from "effect/Cause";
-import { AsyncResult } from "effect/unstable/reactivity";
 import { LegendList } from "@legendapp/list/react-native";
 import {
   isAtomCommandInterrupted,
 @@ -31,7 +29,7 @@ import { EnvironmentMachineSymbol } from "../../components/EnvironmentMachineSym
 import { ThemedSwitch } from "../../components/ThemedSwitch";
 import { cn } from "../../lib/cn";
 import { NativeHeaderToolbar, NativeStackScreenOptions } from "../../native/StackHeader";
-import { useServerConfigs, waitForProject } from "../../state/entities";
+import { useServerConfigs } from "../../state/entities";
 import { projectEnvironment } from "../../state/projects";
 import { useAtomCommand } from "../../state/use-atom-command";
 import { vcsEnvironment } from "../../state/vcs";
 @@ -208,7 +206,7 @@ export function NewTaskEnvironmentPickerRouteScreen() {
   const navigation = useNavigation();
   const insets = useSafeAreaInsets();
   const serverConfigs = useServerConfigs();
-  const ensureScratch = useAtomCommand(projectEnvironment.ensureScratch, {
+  const openScratch = useAtomCommand(projectEnvironment.openScratch, {
     reportFailure: false,
   });
   const [movingToEnvironmentId, setMovingToEnvironmentId] = useState<EnvironmentId | null>(null);
 @@ -218,23 +216,20 @@ export function NewTaskEnvironmentPickerRouteScreen() {
   async function moveScratchDraft(environmentId: EnvironmentId): Promise<void> {
     setMovingToEnvironmentId(environmentId);
     try {
-      const result = await ensureScratch({ environmentId, input: {} });
+      const result = await openScratch({ environmentId, input: {} });
-      if (AsyncResult.isFailure(result)) {
+      if (result._tag === "Failure") {
-        const error = Cause.squash(result.cause);
+        if (!isAtomCommandInterrupted(result)) {
-        Alert.alert(
+          const error = squashAtomCommandFailure(result);
-          "Could not switch machine",
+          Alert.alert(
-          error instanceof Error
+            "Could not switch machine",
-            ? error.message
+            error instanceof Error
-            : "The folder for threads without a project could not be created.",
+              ? error.message
-        );
+              : "The folder for threads without a project could not be created.",
-        return;
+          );
-      }
+        }
-      const project = await waitForProject({ environmentId, projectId: result.value.projectId });
-      if (project === null) {
-        Alert.alert("Could not switch machine", "It has not reached this device yet. Try again.");
         return;
       }
-      flow.setProject(project);
+      flow.setProject(result.value);
       navigation.goBack();
     } finally {
       setMovingToEnvironmentId(null);

apps/mobile/src/features/threads/NewTaskRouteScreen.tsx+23-25

 @@ -7,11 +7,13 @@ import {
   type StaticScreenProps,
 } from "@react-navigation/native";
 import { SymbolView } from "../../components/AppSymbol";
-import { canCreateProjectInEnvironment } from "@t3tools/client-runtime/operations/projects";
+import { availableScratchWorkspaceRoot } from "@t3tools/client-runtime/operations/projects";
 import { isScratchProject } from "@t3tools/client-runtime/state/projects";
+import {
+  isAtomCommandInterrupted,
+  squashAtomCommandFailure,
+} from "@t3tools/client-runtime/state/runtime";
 import type { EnvironmentProject } from "@t3tools/client-runtime/state/shell";
-import * as Cause from "effect/Cause";
-import { AsyncResult } from "effect/unstable/reactivity";
 import { useEffect, useRef, useState } from "react";
 import { ActivityIndicator, Alert, Platform, Pressable, View } from "react-native";
 import { useSafeAreaInsets } from "react-native-safe-area-context";
 @@ -21,7 +23,7 @@ import { MaterialButton } from "../../components/MaterialButton";
 import { ScreenScrollView as ScrollView } from "../../components/ScreenScrollView";
 import { AppText as Text } from "../../components/AppText";
 import { ProjectFavicon } from "../../components/ProjectFavicon";
-import { useProjects, useServerConfigs, waitForProject } from "../../state/entities";
+import { useProjects, useServerConfigs } from "../../state/entities";
 import { projectEnvironment } from "../../state/projects";
 import { useAtomCommand } from "../../state/use-atom-command";
 import { useRemoteConnectionStatus } from "../../state/use-remote-environment-registry";
 @@ -173,7 +175,7 @@ export function NewTaskRouteScreen({ route }: StaticScreenProps<NewTaskRoutePara
       ) ?? null)
     : null;
   const { connectedEnvironments } = useRemoteConnectionStatus();
-  const ensureScratch = useAtomCommand(projectEnvironment.ensureScratch, {
+  const openScratch = useAtomCommand(projectEnvironment.openScratch, {
     reportFailure: false,
   });
   // Threads without a project need a connected environment that offers them.
 @@ -181,8 +183,10 @@ export function NewTaskRouteScreen({ route }: StaticScreenProps<NewTaskRoutePara
   // first that does; the draft page's machine picker moves it from there.
   const scratchEnvironments = connectedEnvironments.filter(
     (environment) =>
-      canCreateProjectInEnvironment(environment.connectionState) &&
+      availableScratchWorkspaceRoot(
-      serverConfigs.get(environment.environmentId)?.scratchWorkspaceRoot !== undefined,
+        environment.connectionState,
+        serverConfigs.get(environment.environmentId),
+      ) !== null,
   );
   const scratchEnvironment =
     scratchEnvironments.find(
 @@ -230,26 +234,20 @@ export function NewTaskRouteScreen({ route }: StaticScreenProps<NewTaskRoutePara
     const environmentId = scratchEnvironment.environmentId;
     scratchStartInFlightRef.current = true;
     try {
-      const result = await ensureScratch({ environmentId, input: {} });
+      const result = await openScratch({ environmentId, input: {} });
-      if (AsyncResult.isFailure(result)) {
+      if (result._tag === "Failure") {
-        const error = Cause.squash(result.cause);
+        if (!isAtomCommandInterrupted(result)) {
-        Alert.alert(
+          const error = squashAtomCommandFailure(result);
-          "Could not start without a project",
+          Alert.alert(
-          error instanceof Error
+            "Could not start without a project",
-            ? error.message
+            error instanceof Error
-            : "The folder for threads without a project could not be created.",
+              ? error.message
-        );
+              : "The folder for threads without a project could not be created.",
-        return;
+          );
-      }
+        }
-      const project = await waitForProject({ environmentId, projectId: result.value.projectId });
-      if (project === null) {
-        Alert.alert(
-          "Could not start without a project",
-          "It has not reached this device yet. Pick No project from the list once it appears.",
-        );
         return;
       }
-      await selectProject(project);
+      await selectProject(result.value);
     } finally {
       scratchStartInFlightRef.current = false;
     }

apps/mobile/src/features/threads/new-task-flow-provider.tsx+5-3

...	@@ -89,7 +89,7 @@ import {	...	@@ -89,7 +89,7 @@ import {
89	useRemoteConnectionStatus,	89	useRemoteConnectionStatus,
90	useSavedRemoteConnections,	90	useSavedRemoteConnections,
91	} from "../../state/use-remote-environment-registry";	91	} from "../../state/use-remote-environment-registry";
92	import { canCreateProjectInEnvironment } from "@t3tools/client-runtime/operations/projects";	92	import { availableScratchWorkspaceRoot } from "@t3tools/client-runtime/operations/projects";
93	import { isScratchProject } from "@t3tools/client-runtime/state/projects";	93	import { isScratchProject } from "@t3tools/client-runtime/state/projects";
94	import { EnvironmentProject } from "@t3tools/client-runtime/state/shell";	94	import { EnvironmentProject } from "@t3tools/client-runtime/state/shell";
95	import { type VcsRef } from "@t3tools/client-runtime/state/vcs";	95	import { type VcsRef } from "@t3tools/client-runtime/state/vcs";
...	@@ -367,8 +367,10 @@ export function NewTaskFlowProvider(props: React.PropsWithChildren) {	...	@@ -367,8 +367,10 @@ export function NewTaskFlowProvider(props: React.PropsWithChildren) {
367	() =>	367	() =>
368	connectedEnvironments.filter(	368	connectedEnvironments.filter(
369	(environment) =>	369	(environment) =>
370	canCreateProjectInEnvironment(environment.connectionState) &&	370	availableScratchWorkspaceRoot(
371	serverConfigs.get(environment.environmentId)?.scratchWorkspaceRoot !== undefined,	371	environment.connectionState,
		372	serverConfigs.get(environment.environmentId),
		373	) !== null,
372	),	374	),
373	[connectedEnvironments, serverConfigs],	375	[connectedEnvironments, serverConfigs],
374	);	376	);

apps/mobile/src/state/projects.ts+3-1

 @@ -5,8 +5,10 @@ import { environmentCatalog } from "../connection/catalog";
 import { connectionAtomRuntime } from "../connection/runtime";
 import { environmentSnapshotAtom } from "./shell";
-export const projectEnvironment = createProjectEnvironmentAtoms(connectionAtomRuntime);
 export const environmentProjects = createEnvironmentProjectAtoms({
   catalogValueAtom: environmentCatalog.catalogValueAtom,
   snapshotAtom: environmentSnapshotAtom,
 });
+export const projectEnvironment = createProjectEnvironmentAtoms(connectionAtomRuntime, {
+  projectAtom: environmentProjects.projectAtom,
+});

apps/web/src/components/ChatView.tsx+1-1

...	@@ -4396,7 +4396,7 @@ export default function ChatView(props: ChatViewProps) {	...	@@ -4396,7 +4396,7 @@ export default function ChatView(props: ChatViewProps) {
4396	}	4396	}
4397	// Keep send disabled until the destination Scratch project is ready.	4397	// Keep send disabled until the destination Scratch project is ready.
4398	setIsEnvironmentChanging(true);	4398	setIsEnvironmentChanging(true);
4399	void openScratchProject(target.environmentId)	4399	void openScratchProject(target.environmentId, "Could not switch machine")
4400	.then((project) => {	4400	.then((project) => {
4401	if (project) retarget(project);	4401	if (project) retarget(project);
4402	})	4402	})

apps/web/src/hooks/useScratchProject.ts+19-24

 @@ -1,4 +1,5 @@
 import { scopeProjectRef } from "@t3tools/client-runtime/environment";
+import { availableScratchWorkspaceRoot } from "@t3tools/client-runtime/operations/projects";
 import {
   isAtomCommandInterrupted,
   squashAtomCommandFailure,
 @@ -8,17 +9,16 @@ import type { EnvironmentId } from "@t3tools/contracts";
 import { useCallback } from "react";
 import { stackedThreadToast, toastManager } from "~/components/ui/toast";
-import { waitForProject } from "~/state/entities";
 import { useEnvironments } from "~/state/environments";
 import { projectEnvironment } from "~/state/projects";
 import { useAtomCommand } from "~/state/use-atom-command";
 import { useNewThreadHandler } from "./useHandleNewThread";
-function reportScratchFailure(error: unknown) {
+function reportScratchFailure(title: string, error: unknown) {
   toastManager.add(
     stackedThreadToast({
       type: "error",
-      title: "Could not start without a project",
+      title,
       description: error instanceof Error ? error.message : "An error occurred.",
     }),
   );
 @@ -32,16 +32,17 @@ function reportScratchFailure(error: unknown) {
  */
 export function useScratchProject() {
   const { environments } = useEnvironments();
-  const ensureScratch = useAtomCommand(projectEnvironment.ensureScratch, { reportFailure: false });
+  const openScratch = useAtomCommand(projectEnvironment.openScratch, { reportFailure: false });
   const handleNewThread = useNewThreadHandler();
   /** The scratch folder of a connected environment, or null when it offers none. */
   const scratchWorkspaceRootFor = useCallback(
     (environmentId: EnvironmentId | null): string | null => {
       const environment = environments.find((entry) => entry.environmentId === environmentId);
-      return environment?.connection.phase === "connected"
+      return availableScratchWorkspaceRoot(
-        ? (environment.serverConfig?.scratchWorkspaceRoot ?? null)
+        environment?.connection.phase,
-        : null;
+        environment?.serverConfig,
+      );
     },
     [environments],
   );
 @@ -62,24 +63,18 @@ export function useScratchProject() {
   /** Resolves to the scratch project once it is in this client's store. */
   const openScratchProject = useCallback(
-    async (environmentId: EnvironmentId): Promise<EnvironmentProject | null> => {
+    async (
-      const result = await ensureScratch({ environmentId, input: {} });
+      environmentId: EnvironmentId,
-      if (result._tag === "Failure") {
+      failureTitle = "Could not start without a project",
-        if (!isAtomCommandInterrupted(result)) {
+    ): Promise<EnvironmentProject | null> => {
-          reportScratchFailure(squashAtomCommandFailure(result));
+      const result = await openScratch({ environmentId, input: {} });
-        }
+      if (result._tag === "Success") return result.value;
-        return null;
+      if (!isAtomCommandInterrupted(result)) {
+        reportScratchFailure(failureTitle, squashAtomCommandFailure(result));
       }
-      // Drafts key off the project's stored path and settings, so wait for
+      return null;
-      // the create event to reach the store before targeting one.
-      return waitForProject(scopeProjectRef(environmentId, result.value.projectId)).catch(
-        (error: unknown) => {
-          reportScratchFailure(error);
-          return null;
-        },
-      );
     },
-    [ensureScratch],
+    [openScratch],
   );
   const startScratchThread = useCallback(
 @@ -87,7 +82,7 @@ export function useScratchProject() {
       const project = await openScratchProject(environmentId);
       if (project) {
         await handleNewThread(scopeProjectRef(project.environmentId, project.id)).catch(
-          reportScratchFailure,
+          (error: unknown) => reportScratchFailure("Could not start without a project", error),
         );
       }
     },

apps/web/src/state/projects.ts+7-5

 @@ -7,7 +7,13 @@ import { environmentCatalog } from "../connection/catalog";
 import { connectionAtomRuntime } from "../connection/runtime";
 import { environmentSnapshotAtom } from "./shell";
-export const projectEnvironment = createProjectEnvironmentAtoms(connectionAtomRuntime);
+export const environmentProjects = createEnvironmentProjectAtoms({
+  catalogValueAtom: environmentCatalog.catalogValueAtom,
+  snapshotAtom: environmentSnapshotAtom,
+});
+export const projectEnvironment = createProjectEnvironmentAtoms(connectionAtomRuntime, {
+  projectAtom: environmentProjects.projectAtom,
+});
 /**
  * Web-only: project content search backs the ⇧⌘F dialog, which has no mobile
  * surface, so the atom family lives here instead of the shared client-runtime
 @@ -19,7 +25,3 @@ export const projectContentSearch = createEnvironmentRpcQueryAtomFamily(connecti
   staleTimeMs: 5_000,
   idleTtlMs: 60_000,
 });
-export const environmentProjects = createEnvironmentProjectAtoms({
-  catalogValueAtom: environmentCatalog.catalogValueAtom,
-  snapshotAtom: environmentSnapshotAtom,
-});

docs/user/thread-sidebar.md+3-1

 @@ -19,7 +19,9 @@ A thread does not need a project. To start one without a project, click **or
 start without a project** under a new thread's heading, pick **No project** from
 the project menu in that heading or from **New thread in...** in the command
 palette, or press `mod+alt+n`. On mobile, pick **No project** from the project
-list. To move a draft into a project, pick the project in the heading.
+list. It starts on your current machine; before sending, pick another machine
+from the machine menu to move it there. To move a draft into a project, pick the
+project in the heading.
 Each thread without a project works in its own folder under `~/.t3/scratch` (the
 `scratch` folder of your T3 data directory), named after its date, the first words

packages/client-runtime/src/operations/projects.ts+14

...	@@ -4,6 +4,7 @@ import type {	...	@@ -4,6 +4,7 @@ import type {
4	EnvironmentId,	4	EnvironmentId,
5	ProjectMutation,	5	ProjectMutation,
6	ProjectId,	6	ProjectId,
		7	ServerConfig,
7	SourceControlDiscoveryResult,	8	SourceControlDiscoveryResult,
8	SourceControlProviderKind,	9	SourceControlProviderKind,
9	SourceControlRepositoryInfo,	10	SourceControlRepositoryInfo,
...	@@ -36,6 +37,19 @@ export function canCreateProjectInEnvironment(	...	@@ -36,6 +37,19 @@ export function canCreateProjectInEnvironment(
36	return connectionPhase === "connected";	37	return connectionPhase === "connected";
37	}	38	}
38		39
		40	/**
		41	* The Scratch folder an environment offers threads without a project right
		42	* now, or null while it is not connected or has none.
		43	*/
		44	export function availableScratchWorkspaceRoot(
		45	connectionPhase: EnvironmentConnectionPhase \| null \| undefined,
		46	serverConfig: Pick<ServerConfig, "scratchWorkspaceRoot"> \| null \| undefined,
		47	): string \| null {
		48	return canCreateProjectInEnvironment(connectionPhase)
		49	? (serverConfig?.scratchWorkspaceRoot ?? null)
		50	: null;
		51	}
		52
39	export type AddProjectRemoteSourceReadiness = Record<	53	export type AddProjectRemoteSourceReadiness = Record<
40	AddProjectRemoteSource,	54	AddProjectRemoteSource,
41	{ readonly ready: boolean; readonly hint: string \| null }	55	{ readonly ready: boolean; readonly hint: string \| null }

packages/client-runtime/src/state/projectCommands.test.ts created+77

...	@@ -0,0 +1,77 @@
1	import { describe, expect, it } from "@effect/vitest";
2	import { EnvironmentId, ProjectId, type ScopedProjectRef, WS_METHODS } from "@t3tools/contracts";
3	import * as Crypto from "effect/Crypto";
4	import * as Effect from "effect/Effect";
5	import * as Fiber from "effect/Fiber";
6	import * as Layer from "effect/Layer";
7	import * as Option from "effect/Option";
8	import * as SubscriptionRef from "effect/SubscriptionRef";
9	import { Atom, AtomRegistry } from "effect/unstable/reactivity";
10
11	import * as EnvironmentRegistry from "../connection/registry.ts";
12	import * as EnvironmentSupervisor from "../connection/supervisor.ts";
13	import type { RpcSession } from "../rpc/session.ts";
14	import type { EnvironmentProject } from "./models.ts";
15	import { createProjectEnvironmentAtoms } from "./projectCommands.ts";
16
17	const ENVIRONMENT_ID = EnvironmentId.make("environment-1");
18	const PROJECT_ID = ProjectId.make("scratch");
19	const PROJECT = {
20	id: PROJECT_ID,
21	environmentId: ENVIRONMENT_ID,
22	workspaceRoot: "/scratch",
23	} as EnvironmentProject;
24
25	const makeHarness = Effect.fn("TestProjectCommands.makeHarness")(function* () {
26	const supervisor = EnvironmentSupervisor.EnvironmentSupervisor.of({
27	target: { environmentId: ENVIRONMENT_ID },
28	session: yield* SubscriptionRef.make(
29	Option.some({
30	client: {
31	[WS_METHODS.projectsEnsureScratch]: () => Effect.succeed({ projectId: PROJECT_ID }),
32	},
33	} as unknown as RpcSession),
34	),
35	} as EnvironmentSupervisor.EnvironmentSupervisor["Service"]);
36	const runtime = Atom.runtime(
37	Layer.mergeAll(
38	Layer.succeed(EnvironmentRegistry.EnvironmentRegistry, {
39	run: (_environmentId, effect) =>
40	Effect.provideService(effect, EnvironmentSupervisor.EnvironmentSupervisor, supervisor),
41	} as EnvironmentRegistry.EnvironmentRegistry["Service"]),
42	Layer.succeed(
43	Crypto.Crypto,
44	Crypto.make({
45	randomBytes: (size) => new Uint8Array(size),
46	digest: (_algorithm, data) => Effect.succeed(data),
47	}),
48	),
49	),
50	);
51	const storedProject = Atom.make<EnvironmentProject \| null>(null);
52	const commands = createProjectEnvironmentAtoms(runtime, {
53	projectAtom: (ref: ScopedProjectRef) =>
54	ref.environmentId === ENVIRONMENT_ID && ref.projectId === PROJECT_ID
55	? storedProject
56	: Atom.make(null),
57	});
58	const registry = AtomRegistry.make();
59	yield* Effect.addFinalizer(() => Effect.sync(() => registry.dispose()));
60	const openScratch = Effect.promise(() =>
61	commands.openScratch.run(registry, { environmentId: ENVIRONMENT_ID, input: {} }),
62	);
63	return { registry, storedProject, openScratch };
64	});
65
66	describe("openScratch", () => {
67	it.effect("resolves once the created project reaches the client store", () =>
68	Effect.gen(function* () {
69	const { registry, storedProject, openScratch } = yield* makeHarness();
70	const opening = yield* Effect.forkChild(openScratch);
71	yield* Effect.yieldNow;
72	registry.set(storedProject, PROJECT);
73	const result = yield* Fiber.join(opening);
74	expect(result).toMatchObject({ _tag: "Success", value: PROJECT });
75	}).pipe(Effect.scoped),
76	);
77	});

packages/client-runtime/src/state/projectCommands.ts+54-6

...	@@ -1,7 +1,20 @@	...	@@ -1,7 +1,20 @@
1	import { type EnvironmentId, type ProjectReadFileResult, WS_METHODS } from "@t3tools/contracts";	1	import {
		2	type EnvironmentId,
		3	ProjectId,
		4	type ProjectReadFileResult,
		5	type ScopedProjectRef,
		6	WS_METHODS,
		7	} from "@t3tools/contracts";
2	import * as Crypto from "effect/Crypto";	8	import * as Crypto from "effect/Crypto";
3	import { Atom } from "effect/unstable/reactivity";	9	import * as Effect from "effect/Effect";
		10	import * as Option from "effect/Option";
		11	import * as Predicate from "effect/Predicate";
		12	import * as Schema from "effect/Schema";
		13	import * as Stream from "effect/Stream";
		14	import { Atom, AtomRegistry } from "effect/unstable/reactivity";
4		15
		16	import { type EnvironmentRpcInput, request } from "../rpc/client.ts";
		17	import type { EnvironmentProject } from "./models.ts";
5	import {	18	import {
6	createAtomCommandScheduler,	19	createAtomCommandScheduler,
7	createEnvironmentCommand,	20	createEnvironmentCommand,
...	@@ -39,8 +52,22 @@ function optimisticProjectFileKey(target: OptimisticProjectFileTarget): string {	...	@@ -39,8 +52,22 @@ function optimisticProjectFileKey(target: OptimisticProjectFileTarget): string {
39	return JSON.stringify([target.environmentId, target.cwd, target.relativePath]);	52	return JSON.stringify([target.environmentId, target.cwd, target.relativePath]);
40	}	53	}
41		54
		55	/** The Scratch project was created, but its event never reached this client. */
		56	export class ScratchProjectNotLoadedError extends Schema.TaggedError<ScratchProjectNotLoadedError>()(
		57	"ScratchProjectNotLoadedError",
		58	{ projectId: ProjectId },
		59	) {
		60	override get message(): string {
		61	return "The folder for threads without a project has not reached this device yet. Try again.";
		62	}
		63	}
		64
42	export function createProjectEnvironmentAtoms<R, E>(	65	export function createProjectEnvironmentAtoms<R, E>(
43	runtime: Atom.AtomRuntime<EnvironmentRegistry \| Crypto.Crypto \| R, E>,	66	runtime: Atom.AtomRuntime<EnvironmentRegistry \| Crypto.Crypto \| R, E>,
		67	options: {
		68	/** The client store's project; openScratch waits here for the created project. */
		69	readonly projectAtom: (ref: ScopedProjectRef) => Atom.Atom<EnvironmentProject \| null>;
		70	},
44	) {	71	) {
45	const projectScheduler = createAtomCommandScheduler();	72	const projectScheduler = createAtomCommandScheduler();
46	const fileScheduler = createAtomCommandScheduler();	73	const fileScheduler = createAtomCommandScheduler();
...	@@ -92,10 +119,31 @@ export function createProjectEnvironmentAtoms<R, E>(	...	@@ -92,10 +119,31 @@ export function createProjectEnvironmentAtoms<R, E>(
92	scheduler: projectScheduler,	119	scheduler: projectScheduler,
93	concurrency: projectConcurrency,	120	concurrency: projectConcurrency,
94	}),	121	}),
95	// Finds or creates the environment's Scratch project and returns its id.	122	// Finds or creates the environment's Scratch project and resolves once the
96	ensureScratch: createEnvironmentRpcCommand(runtime, {	123	// project is in the client store, since drafts key off its stored path.
97	label: "environment-data:projects:ensure-scratch",	124	openScratch: createEnvironmentCommand(runtime, {
98	tag: WS_METHODS.projectsEnsureScratch,	125	label: "environment-data:projects:open-scratch",
		126	execute: (
		127	input: EnvironmentRpcInput<typeof WS_METHODS.projectsEnsureScratch>,
		128	registry,
		129	environmentId,
		130	) =>
		131	request(WS_METHODS.projectsEnsureScratch, input).pipe(
		132	Effect.flatMap(({ projectId }) =>
		133	AtomRegistry.toStream(registry, options.projectAtom({ environmentId, projectId })).pipe(
		134	Stream.filter(Predicate.isNotNull),
		135	Stream.runHead,
		136	Effect.timeoutOption("10 seconds"),
		137	Effect.map(Option.flatten),
		138	Effect.flatMap(
		139	Option.match({
		140	onSome: Effect.succeed,
		141	onNone: () => Effect.fail(new ScratchProjectNotLoadedError({ projectId })),
		142	}),
		143	),
		144	),
		145	),
		146	),
99	scheduler: projectScheduler,	147	scheduler: projectScheduler,
100	concurrency: { mode: "serial", key: ({ environmentId }) => environmentId },	148	concurrency: { mode: "serial", key: ({ environmentId }) => environmentId },
101	}),	149	}),

author	Ben Davis <45952064+bmdavis419@users.noreply.github.com> 2026-10-03 21:38:09-07:00
committer	GitHub <noreply@github.com> 2026-10-03 21:38:09-07:00
log	845ddd9354538d42db1cc7dc30143c6bb8f0d40f
tree	743789899195f84aa97f053c612efb0a381b1c8a
parent	60a56f11e73dfc9c26e74f8f8e93e391191fc3f8
signature	Signed by PGP key B5690EEEBB952194

refactor(clients): share opening a machine's No project folder (#14759)