effect-cf 0.26.0 → 0.28.0

package/dist/ComputerWorkspace.mjs

@@ -0,0 +1,577 @@
+import { t as DurableObjectState } from "./DurableObjectState-BjkK2kwH.mjs";
+import { fromClient } from "./ComputerArtifacts.mjs";
+import { t as lookup } from "./ComputerWorkspaceHostRegistry-CY5Fv4Ng.mjs";
+import { Context, Effect, Layer, Predicate, Schema, Stream } from "effect";
+//#region src/ComputerWorkspace.ts
+/**
+* Workspace errors use `Schema.TaggedError`, unlike most local binding errors,
+* because workspace operations commonly sit behind Durable Object RPC methods.
+* The schema form preserves the operation-family tags across that boundary.
+*/
+var WorkspaceFsError = class extends Schema.TaggedError()("WorkspaceFsError", {
+	operation: Schema.String,
+	path: Schema.String,
+	message: Schema.String,
+	code: Schema.optionalKey(Schema.String),
+	cause: Schema.optionalKey(Schema.Defect({ includeStack: true }))
+}) {};
+/** Schema-serializable error for a workspace Git operation. */
+var WorkspaceGitError = class extends Schema.TaggedError()("WorkspaceGitError", {
+	operation: Schema.String,
+	message: Schema.String,
+	code: Schema.optionalKey(Schema.String),
+	cause: Schema.optionalKey(Schema.Defect({ includeStack: true }))
+}) {};
+/** Schema-serializable error for a workspace runtime operation. */
+var WorkspaceExecError = class extends Schema.TaggedError()("WorkspaceExecError", {
+	operation: Schema.String,
+	message: Schema.String,
+	code: Schema.optionalKey(Schema.String),
+	cause: Schema.optionalKey(Schema.Defect({ includeStack: true }))
+}) {};
+/** Schema-serializable error for a workspace Assets operation. */
+var WorkspaceAssetsError = class extends Schema.TaggedError()("WorkspaceAssetsError", {
+	operation: Schema.String,
+	path: Schema.String,
+	message: Schema.String,
+	code: Schema.optionalKey(Schema.String),
+	cause: Schema.optionalKey(Schema.Defect({ includeStack: true }))
+}) {};
+const errorMessage = (cause) => cause instanceof Error ? cause.message : String(cause);
+const errorCode = (cause) => {
+	if (Predicate.hasProperty(cause, "code") && Predicate.isString(cause.code)) return cause.code;
+};
+const fsError = (operation, path, cause) => {
+	const properties = {
+		operation,
+		path,
+		message: errorMessage(cause),
+		cause
+	};
+	const code = errorCode(cause);
+	if (code !== void 0) properties.code = code;
+	return WorkspaceFsError.make(properties);
+};
+const gitError = (operation, cause) => {
+	const properties = {
+		operation,
+		message: errorMessage(cause),
+		cause
+	};
+	const code = errorCode(cause);
+	if (code !== void 0) properties.code = code;
+	return WorkspaceGitError.make(properties);
+};
+const execError = (operation, cause) => {
+	const properties = {
+		operation,
+		message: errorMessage(cause),
+		cause
+	};
+	const code = errorCode(cause);
+	if (code !== void 0) properties.code = code;
+	return WorkspaceExecError.make(properties);
+};
+const assetsError = (operation, path, cause) => {
+	const properties = {
+		operation,
+		path,
+		message: errorMessage(cause),
+		cause
+	};
+	const code = errorCode(cause);
+	if (code !== void 0) properties.code = code;
+	return WorkspaceAssetsError.make(properties);
+};
+const tryFs = (operation, path, evaluate) => Effect.tryPromise({
+	try: evaluate,
+	catch: (cause) => fsError(operation, path, cause)
+});
+const isNotFound = (error) => error.code === "ENOENT" || /ENOENT|no such/i.test(error.message);
+const makeFilesystem = (fsClient) => {
+	const readFile = Effect.fn("ComputerWorkspace.fs.readFile", { attributes: {
+		family: "fs",
+		operation: "readFile"
+	} })(function* (path, options = {}) {
+		yield* Effect.annotateCurrentSpan("path", path);
+		const { encoding = "utf8", ...readOptions } = options;
+		if (encoding === "stream") return yield* tryFs("readFile", path, () => fsClient.readFile(path, readOptions));
+		return yield* tryFs("readFile", path, () => fsClient.readFile(path, {
+			...readOptions,
+			encoding: "utf8"
+		}));
+	});
+	const stat = Effect.fn("ComputerWorkspace.fs.stat", { attributes: {
+		family: "fs",
+		operation: "stat"
+	} })(function* (path) {
+		yield* Effect.annotateCurrentSpan("path", path);
+		return yield* tryFs("stat", path, () => fsClient.stat(path));
+	});
+	return {
+		readFile,
+		stat,
+		lstat: Effect.fn("ComputerWorkspace.fs.lstat", { attributes: {
+			family: "fs",
+			operation: "lstat"
+		} })(function* (path) {
+			yield* Effect.annotateCurrentSpan("path", path);
+			return yield* tryFs("lstat", path, () => fsClient.lstat(path));
+		}),
+		exists: Effect.fn("ComputerWorkspace.fs.exists", { attributes: {
+			family: "fs",
+			operation: "exists"
+		} })(function* (path) {
+			yield* Effect.annotateCurrentSpan("path", path);
+			return yield* stat(path).pipe(Effect.as(true), Effect.catch((error) => isNotFound(error) ? Effect.succeed(false) : Effect.fail(error)));
+		}),
+		readlink: Effect.fn("ComputerWorkspace.fs.readlink", { attributes: {
+			family: "fs",
+			operation: "readlink"
+		} })(function* (path) {
+			yield* Effect.annotateCurrentSpan("path", path);
+			return yield* tryFs("readlink", path, () => fsClient.readlink(path));
+		}),
+		readdir: Effect.fn("ComputerWorkspace.fs.readdir", { attributes: {
+			family: "fs",
+			operation: "readdir"
+		} })(function* (path, options) {
+			yield* Effect.annotateCurrentSpan("path", path);
+			return yield* tryFs("readdir", path, () => fsClient.readdir(path, options));
+		}),
+		find: Effect.fn("ComputerWorkspace.fs.find", { attributes: {
+			family: "fs",
+			operation: "find"
+		} })(function* (directory, pattern, options) {
+			yield* Effect.annotateCurrentSpan({
+				path: directory,
+				pattern
+			});
+			return yield* tryFs("find", directory, () => fsClient.find(directory, pattern, options));
+		}),
+		ls: Effect.fn("ComputerWorkspace.fs.ls", { attributes: {
+			family: "fs",
+			operation: "ls"
+		} })(function* (prefix) {
+			yield* Effect.annotateCurrentSpan("path", prefix);
+			return yield* tryFs("ls", prefix, () => fsClient.ls(prefix));
+		}),
+		grep: Effect.fn("ComputerWorkspace.fs.grep", { attributes: {
+			family: "fs",
+			operation: "grep"
+		} })(function* (pattern, path, options) {
+			yield* Effect.annotateCurrentSpan({
+				path,
+				pattern
+			});
+			return yield* tryFs("grep", path, () => fsClient.grep(pattern, path, options));
+		}),
+		writeFile: Effect.fn("ComputerWorkspace.fs.writeFile", { attributes: {
+			family: "fs",
+			operation: "writeFile"
+		} })(function* (path, content, options) {
+			yield* Effect.annotateCurrentSpan("path", path);
+			yield* tryFs("writeFile", path, () => fsClient.writeFile(path, content, options));
+		}),
+		mkdir: Effect.fn("ComputerWorkspace.fs.mkdir", { attributes: {
+			family: "fs",
+			operation: "mkdir"
+		} })(function* (path, options) {
+			yield* Effect.annotateCurrentSpan("path", path);
+			yield* tryFs("mkdir", path, () => fsClient.mkdir(path, options));
+		}),
+		rm: Effect.fn("ComputerWorkspace.fs.rm", { attributes: {
+			family: "fs",
+			operation: "rm"
+		} })(function* (path, options) {
+			yield* Effect.annotateCurrentSpan("path", path);
+			yield* tryFs("rm", path, () => fsClient.rm(path, options));
+		}),
+		chmod: Effect.fn("ComputerWorkspace.fs.chmod", { attributes: {
+			family: "fs",
+			operation: "chmod"
+		} })(function* (path, mode) {
+			yield* Effect.annotateCurrentSpan({
+				path,
+				mode
+			});
+			yield* tryFs("chmod", path, () => fsClient.chmod(path, mode));
+		}),
+		symlink: Effect.fn("ComputerWorkspace.fs.symlink", { attributes: {
+			family: "fs",
+			operation: "symlink"
+		} })(function* (target, path) {
+			yield* Effect.annotateCurrentSpan({
+				path,
+				target
+			});
+			yield* tryFs("symlink", path, () => fsClient.symlink(target, path));
+		})
+	};
+};
+const gitPerson = (person) => ({
+	...person,
+	timestampSeconds: person.timestamp
+});
+const gitCommit = (commit) => ({
+	oid: commit.oid,
+	message: commit.message,
+	tree: commit.tree,
+	parent: commit.parent,
+	parents: commit.parent,
+	author: gitPerson(commit.author),
+	committer: gitPerson(commit.committer)
+});
+const makeGit = (gitClient) => {
+	const method = (operation, evaluate) => Effect.fn(`ComputerWorkspace.git.${operation}`, { attributes: {
+		family: "git",
+		operation
+	} })(function* (...args) {
+		return yield* Effect.tryPromise({
+			try: () => evaluate(...args),
+			catch: (cause) => gitError(operation, cause)
+		});
+	});
+	const log = Effect.fn("ComputerWorkspace.git.log", { attributes: {
+		family: "git",
+		operation: "log"
+	} })(function* (options) {
+		const { maxCount, ...upstreamOptions } = options ?? {};
+		const logOptions = { ...upstreamOptions };
+		if (logOptions.depth === void 0 && maxCount !== void 0) logOptions.depth = maxCount;
+		return (yield* Effect.tryPromise({
+			try: () => gitClient.log(logOptions),
+			catch: (cause) => gitError("log", cause)
+		})).map(gitCommit);
+	});
+	const revParse = Effect.fn("ComputerWorkspace.git.revParse", { attributes: {
+		family: "git",
+		operation: "revParse"
+	} })(function* (input) {
+		const options = Predicate.isString(input) ? { ref: input } : input;
+		return yield* Effect.tryPromise({
+			try: () => gitClient.revParse(options),
+			catch: (cause) => gitError("revParse", cause)
+		});
+	});
+	return {
+		clone: method("clone", (options) => gitClient.clone(options)),
+		diff: method("diff", (options) => gitClient.diff(options)),
+		diffSummary: method("diffSummary", (options) => gitClient.diffSummary(options)),
+		init: method("init", (options) => gitClient.init(options)),
+		status: method("status", (options) => gitClient.status(options)),
+		add: method("add", (options) => gitClient.add(options)),
+		rm: method("rm", (options) => gitClient.rm(options)),
+		commit: method("commit", (options) => gitClient.commit(options)),
+		log,
+		show: method("show", (options) => gitClient.show(options)),
+		revParse,
+		repoRoot: method("repoRoot", (options) => gitClient.repoRoot(options)),
+		currentBranch: method("currentBranch", (options) => gitClient.currentBranch(options)),
+		lsFiles: method("lsFiles", (options) => gitClient.lsFiles(options)),
+		lsTree: method("lsTree", (options) => gitClient.lsTree(options)),
+		branch: method("branch", (options) => gitClient.branch(options)),
+		branchDelete: method("branchDelete", (options) => gitClient.branchDelete(options)),
+		branchList: method("branchList", (options) => gitClient.branchList(options)),
+		tag: method("tag", (options) => gitClient.tag(options)),
+		tagDelete: method("tagDelete", (options) => gitClient.tagDelete(options)),
+		tagList: method("tagList", (options) => gitClient.tagList(options)),
+		checkout: method("checkout", (options) => gitClient.checkout(options)),
+		fetch: method("fetch", (options) => gitClient.fetch(options)),
+		push: method("push", (options) => gitClient.push(options)),
+		pull: method("pull", (options) => gitClient.pull(options)),
+		merge: method("merge", (options) => gitClient.merge(options)),
+		remoteAdd: method("remoteAdd", (options) => gitClient.remoteAdd(options)),
+		remoteRemove: method("remoteRemove", (options) => gitClient.remoteRemove(options)),
+		remoteList: method("remoteList", (options) => gitClient.remoteList(options)),
+		hashObject: method("hashObject", (options) => gitClient.hashObject(options)),
+		catFile: method("catFile", (options) => gitClient.catFile(options)),
+		updateRef: method("updateRef", (options) => gitClient.updateRef(options)),
+		configGet: method("configGet", (options) => gitClient.configGet(options)),
+		configSet: method("configSet", (options) => gitClient.configSet(options)),
+		stashPush: method("stashPush", (options) => gitClient.stashPush(options)),
+		stashList: method("stashList", (options) => gitClient.stashList(options)),
+		stashPop: method("stashPop", (options) => gitClient.stashPop(options)),
+		reset: method("reset", (options) => gitClient.reset(options)),
+		clean: method("clean", (options) => gitClient.clean(options)),
+		cli: method("cli", (input) => gitClient.cli(input))
+	};
+};
+const runtimeExecOptions = (options) => {
+	const { encoding = "utf8", timeoutMillis, timeoutMs, ...rest } = options ?? {};
+	const runtimeOptions = { ...rest };
+	if (encoding === "utf8") runtimeOptions.encoding = "utf8";
+	const selectedTimeout = timeoutMs ?? timeoutMillis;
+	if (selectedTimeout !== void 0) runtimeOptions.timeoutMs = selectedTimeout;
+	return runtimeOptions;
+};
+const runtimeGetOptions = (options) => {
+	const { encoding = "utf8", ...rest } = options ?? {};
+	const runtimeOptions = { ...rest };
+	if (encoding === "utf8") runtimeOptions.encoding = "utf8";
+	return runtimeOptions;
+};
+const wrapRuntimeResult = (result) => {
+	const stdout = result.stdout;
+	const stderr = result.stderr;
+	const wrapped = {
+		status: result.status,
+		exitCode: result.exitCode,
+		stdout,
+		stderr,
+		pushed: result.pushed,
+		pulled: result.pulled,
+		skipped: result.skipped,
+		sync: result.sync
+	};
+	return result.value === void 0 ? wrapped : {
+		...wrapped,
+		value: result.value
+	};
+};
+const wrapRuntimeEvent = (event) => {
+	switch (event.name) {
+		case "stdout": {
+			const chunk = event.value;
+			return Predicate.isString(chunk) ? {
+				_tag: "Stdout",
+				id: event.id,
+				sequence: event.seq,
+				chunk,
+				text: chunk
+			} : {
+				_tag: "Stdout",
+				id: event.id,
+				sequence: event.seq,
+				chunk,
+				bytes: chunk
+			};
+		}
+		case "stderr": {
+			const chunk = event.value;
+			return Predicate.isString(chunk) ? {
+				_tag: "Stderr",
+				id: event.id,
+				sequence: event.seq,
+				chunk,
+				text: chunk
+			} : {
+				_tag: "Stderr",
+				id: event.id,
+				sequence: event.seq,
+				chunk,
+				bytes: chunk
+			};
+		}
+		case "exit":
+			const exitEvent = {
+				_tag: "Exit",
+				id: event.id,
+				sequence: event.seq,
+				exitCode: event.code
+			};
+			return event.result === void 0 ? exitEvent : {
+				...exitEvent,
+				value: event.result
+			};
+	}
+};
+const wrapRun = (handle) => {
+	const mapRuntimeEvent = wrapRuntimeEvent;
+	const events = Stream.fromReadableStream({
+		evaluate: () => handle,
+		onError: (cause) => execError("events", cause)
+	}).pipe(Stream.map(mapRuntimeEvent));
+	const result = Effect.tryPromise({
+		try: () => handle.result(),
+		catch: (cause) => execError("result", cause)
+	}).pipe(Effect.map(wrapRuntimeResult));
+	const kill = Effect.fn("ComputerWorkspace.runtime.run.kill", { attributes: {
+		family: "runtime",
+		operation: "run.kill",
+		runId: handle.id
+	} })(function* (signal) {
+		yield* Effect.tryPromise({
+			try: () => handle.kill(signal),
+			catch: (cause) => execError("run.kill", cause)
+		});
+	});
+	return {
+		id: handle.id,
+		backend: handle.backend,
+		events,
+		result,
+		kill
+	};
+};
+const releaseRun = (handle) => Effect.sync(() => handle[Symbol.dispose]());
+const makeRuntime = (client) => {
+	const execImplementation = Effect.fn("ComputerWorkspace.runtime.exec", { attributes: {
+		family: "runtime",
+		operation: "exec"
+	} })(function* (source, optionsOrValue, ...remainingValues) {
+		const options = Predicate.isString(source) ? optionsOrValue : void 0;
+		yield* Effect.annotateCurrentSpan({
+			backend: options?.backend,
+			runId: options?.id
+		});
+		const handle = yield* Effect.acquireRelease(Effect.tryPromise({
+			try: () => {
+				if (Predicate.isString(source)) return client.runtime.exec(source, runtimeExecOptions(options));
+				const values = optionsOrValue === void 0 ? remainingValues : [optionsOrValue, ...remainingValues];
+				return client.runtime.exec(source, ...values);
+			},
+			catch: (cause) => execError("exec", cause)
+		}), releaseRun);
+		return wrapRun(handle);
+	});
+	const exec = execImplementation;
+	const getExec = Effect.fn("ComputerWorkspace.runtime.getExec", { attributes: {
+		family: "runtime",
+		operation: "getExec"
+	} })(function* (id, options) {
+		yield* Effect.annotateCurrentSpan({
+			backend: options?.backend,
+			runId: id
+		});
+		const handle = yield* Effect.acquireRelease(Effect.tryPromise({
+			try: () => client.runtime.getExec(id, runtimeGetOptions(options)),
+			catch: (cause) => execError("getExec", cause)
+		}), releaseRun);
+		return wrapRun(handle);
+	});
+	const killExec = Effect.fn("ComputerWorkspace.runtime.killExec", { attributes: {
+		family: "runtime",
+		operation: "killExec"
+	} })(function* (id, options) {
+		yield* Effect.annotateCurrentSpan({
+			backend: options?.backend,
+			runId: id
+		});
+		yield* Effect.tryPromise({
+			try: () => client.runtime.killExec(id, options),
+			catch: (cause) => execError("killExec", cause)
+		});
+	});
+	const disposeExec = Effect.fn("ComputerWorkspace.runtime.disposeExec", { attributes: {
+		family: "runtime",
+		operation: "disposeExec"
+	} })(function* (id, options) {
+		yield* Effect.annotateCurrentSpan({
+			backend: options?.backend,
+			runId: id
+		});
+		yield* Effect.tryPromise({
+			try: () => client.runtime.disposeExec(id, options),
+			catch: (cause) => execError("disposeExec", cause)
+		});
+	});
+	return {
+		exec,
+		execCollect: Effect.fn("ComputerWorkspace.runtime.execCollect", { attributes: {
+			family: "runtime",
+			operation: "execCollect"
+		} })(function* (source, optionsOrValue, ...remainingValues) {
+			return yield* Effect.scoped(Effect.gen(function* () {
+				return yield* (yield* execImplementation(source, optionsOrValue, ...remainingValues)).result;
+			}));
+		}),
+		getExec,
+		killExec,
+		disposeExec
+	};
+};
+const makeAssets = (client) => client === void 0 ? void 0 : { share: Effect.fn("ComputerWorkspace.assets.share", { attributes: {
+	family: "assets",
+	operation: "share"
+} })(function* (path, options) {
+	yield* Effect.annotateCurrentSpan("path", path);
+	return yield* Effect.tryPromise({
+		try: () => client.share(path, options),
+		catch: (cause) => assetsError("share", path, cause)
+	});
+}) };
+const makeThink = (client) => {
+	if (client.readFile === void 0 || client.readFileBytes === void 0 || client.writeFile === void 0 || client.readDir === void 0 || client.rm === void 0 || client.glob === void 0 || client.mkdir === void 0 || client.stat === void 0) return;
+	const method = (operation, pathOf, evaluate) => Effect.fn(`ComputerWorkspace.think.${operation}`, { attributes: {
+		family: "think",
+		operation
+	} })(function* (...args) {
+		const path = pathOf(...args);
+		yield* Effect.annotateCurrentSpan("path", path);
+		return yield* tryFs(`think.${operation}`, path, () => evaluate(...args));
+	});
+	const readFile = client.readFile.bind(client);
+	const readFileBytes = client.readFileBytes.bind(client);
+	const writeFile = client.writeFile.bind(client);
+	const readDir = client.readDir.bind(client);
+	const rm = client.rm.bind(client);
+	const glob = client.glob.bind(client);
+	const mkdir = client.mkdir.bind(client);
+	const stat = client.stat.bind(client);
+	return {
+		readFile: method("readFile", (path) => path, (path) => readFile(path)),
+		readFileBytes: method("readFileBytes", (path) => path, (path) => readFileBytes(path)),
+		writeFile: method("writeFile", (path, _content) => path, (path, content) => writeFile(path, content)),
+		readDir: method("readDir", (path, _options) => path, (path, options) => readDir(path, options)),
+		rm: method("rm", (path, _options) => path, (path, options) => rm(path, options)),
+		glob: method("glob", (pattern) => pattern, (pattern) => glob(pattern)),
+		mkdir: method("mkdir", (path, _options) => path, (path, options) => mkdir(path, options)),
+		stat: method("stat", (path) => path, (path) => stat(path))
+	};
+};
+/**
+* Wraps a client whose lifetime is owned by the caller. Prefer
+* {@link ComputerWorkspace.layer} in Durable Objects so the parent client and
+* every runtime handle are disposed by Effect `Scope`.
+*/
+const fromWorkspaceClient = (client) => {
+	const fs = makeFilesystem(client.fs);
+	const git = makeGit(client.git);
+	const runtime = makeRuntime(client);
+	return {
+		fs,
+		git,
+		runtime,
+		artifacts: fromClient(client.artifacts, { binding: "ComputerWorkspace.artifacts" }),
+		assets: makeAssets(client.assets),
+		think: makeThink(client),
+		readFile: fs.readFile,
+		stat: fs.stat,
+		lstat: fs.lstat,
+		exists: fs.exists,
+		readlink: fs.readlink,
+		readdir: fs.readdir,
+		listDirectory: fs.readdir,
+		find: fs.find,
+		ls: fs.ls,
+		grep: fs.grep,
+		writeFile: fs.writeFile,
+		mkdir: fs.mkdir,
+		rm: fs.rm,
+		removePath: fs.rm,
+		chmod: fs.chmod,
+		symlink: fs.symlink,
+		exec: runtime.exec,
+		execCollect: runtime.execCollect,
+		getExec: runtime.getExec,
+		killExec: runtime.killExec,
+		disposeExec: runtime.disposeExec
+	};
+};
+/** Effect service for the workspace owned by the enclosing Durable Object. */
+var ComputerWorkspace = class ComputerWorkspace extends Context.Service()("effect-cf/ComputerWorkspace") {
+	/**
+	* Acquires the single workspace registered by `withComputerWorkspace` and
+	* releases its RPC client when the layer scope closes.
+	*/
+	static layer = Layer.effect(ComputerWorkspace, Effect.gen(function* () {
+		const host = lookup((yield* DurableObjectState).raw);
+		if (host === void 0) return yield* Effect.die("ComputerWorkspace.layer requires a Durable Object class built with withComputerWorkspace");
+		const computer = yield* Effect.promise(() => import("@cloudflare/computer"));
+		const client = yield* Effect.acquireRelease(Effect.promise(() => computer.getWorkspace(host)), (workspace) => Effect.sync(() => workspace[Symbol.dispose]()));
+		return ComputerWorkspace.of(fromWorkspaceClient(client));
+	}));
+};
+//#endregion
+export { ComputerWorkspace, WorkspaceAssetsError, WorkspaceExecError, WorkspaceFsError, WorkspaceGitError, fromWorkspaceClient };

package/dist/ComputerWorkspaceHost.d.mts

@@ -1,4 +1,4 @@
-import { t as ArtifactsBinding } from "./Artifacts-DcoXcRP5.mjs";
+import { t as ArtifactsBinding } from "./Artifacts-DnHQA-Ax.mjs";
 import { GitClientFactory } from "@cloudflare/computer/git";
 import { DurableObjectStorageLike, SyncRetryIntent, SyncRetryOptions, SyncRetryScheduler, WithWorkspaceCtor, WorkspaceAttributeValue, WorkspaceAttributes, WorkspaceObserver, WorkspaceOptions, WorkspaceRegisteredBackend, WorkspaceRetryPendingSyncResult, WorkspaceServiceProxy, WorkspaceSpan } from "@cloudflare/computer";
 import { ShellModuleGroup, WorkerShellBackendOptions, WorkerShellLoader, WorkspaceEgressPolicy } from "@cloudflare/computer/backends/worker-shell";

package/dist/ComputerWorkspaceHost.mjs

@@ -18,24 +18,26 @@ const toWorkspaceOptions = (config) => {
 			egress: egress ?? { mode: "none" }
 		}));
 	}
-	return {
+	const options = {
 		storage: config.storage,
-		git: config.git ?? createGitClient(),
-		...config.gitIdentity === void 0 ? {} : { defaultGitIdentity: config.gitIdentity },
-		...backends.length === 0 ? {} : { backends },
-		...config.sessionId === void 0 ? {} : { sessionId: config.sessionId },
-		...config.mounts === void 0 ? {} : { mounts: config.mounts },
-		...config.observer === void 0 ? {} : { observer: config.observer },
-		...config.retryScheduler === void 0 ? {} : { retryScheduler: config.retryScheduler },
-		...config.retry === void 0 ? {} : { retry: config.retry },
-		...config.assets === void 0 ? {} : { assets: config.assets },
-		...config.artifacts === void 0 ? {} : { artifacts: {
-			binding: config.artifacts.binding,
-			...config.artifacts.sessionId === void 0 ? {} : { sessionId: config.artifacts.sessionId }
-		} },
-		...config.now === void 0 ? {} : { now: config.now },
-		...config.useThink === void 0 ? {} : { useThink: config.useThink }
+		git: config.git ?? createGitClient()
 	};
+	if (config.gitIdentity !== void 0) options.defaultGitIdentity = config.gitIdentity;
+	if (backends.length !== 0) options.backends = backends;
+	if (config.sessionId !== void 0) options.sessionId = config.sessionId;
+	if (config.mounts !== void 0) options.mounts = config.mounts;
+	if (config.observer !== void 0) options.observer = config.observer;
+	if (config.retryScheduler !== void 0) options.retryScheduler = config.retryScheduler;
+	if (config.retry !== void 0) options.retry = config.retry;
+	if (config.assets !== void 0) options.assets = config.assets;
+	if (config.artifacts !== void 0) {
+		const artifacts = { binding: config.artifacts.binding };
+		if (config.artifacts.sessionId !== void 0) artifacts.sessionId = config.artifacts.sessionId;
+		options.artifacts = artifacts;
+	}
+	if (config.now !== void 0) options.now = config.now;
+	if (config.useThink !== void 0) options.useThink = config.useThink;
+	return options;
 };
 const HostArguments = Symbol("effect-cf/ComputerWorkspaceHost/arguments");
 /**