effect-cf 0.25.3 → 0.27.0

package/dist/ComputerWorkspace.mjs

@@ -0,0 +1,545 @@
+import { t as DurableObjectState } from "./DurableObjectState-Dux8KfjG.mjs";
+import { fromClient } from "./ComputerArtifacts.mjs";
+import { t as lookup } from "./ComputerWorkspaceHostRegistry-CY5Fv4Ng.mjs";
+import { Context, Effect, Layer, 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 (typeof cause !== "object" || cause === null) return;
+	const code = Reflect.get(cause, "code");
+	return typeof code === "string" ? code : void 0;
+};
+const fsError = (operation, path, cause) => WorkspaceFsError.make({
+	operation,
+	path,
+	message: errorMessage(cause),
+	cause,
+	...errorCode(cause) === void 0 ? {} : { code: errorCode(cause) }
+});
+const gitError = (operation, cause) => WorkspaceGitError.make({
+	operation,
+	message: errorMessage(cause),
+	cause,
+	...errorCode(cause) === void 0 ? {} : { code: errorCode(cause) }
+});
+const execError = (operation, cause) => WorkspaceExecError.make({
+	operation,
+	message: errorMessage(cause),
+	cause,
+	...errorCode(cause) === void 0 ? {} : { code: errorCode(cause) }
+});
+const assetsError = (operation, path, cause) => WorkspaceAssetsError.make({
+	operation,
+	path,
+	message: errorMessage(cause),
+	cause,
+	...errorCode(cause) === void 0 ? {} : { code: errorCode(cause) }
+});
+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 ?? {};
+		return (yield* Effect.tryPromise({
+			try: () => gitClient.log({
+				...upstreamOptions,
+				...upstreamOptions.depth === void 0 && maxCount !== void 0 ? { depth: maxCount } : {}
+			}),
+			catch: (cause) => gitError("log", cause)
+		})).map(gitCommit);
+	});
+	const revParse = Effect.fn("ComputerWorkspace.git.revParse", { attributes: {
+		family: "git",
+		operation: "revParse"
+	} })(function* (input) {
+		const options = typeof input === "string" ? { 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 ?? {};
+	return {
+		...rest,
+		...encoding === "utf8" ? { encoding: "utf8" } : {},
+		...timeoutMs === void 0 && timeoutMillis === void 0 ? {} : { timeoutMs: timeoutMs ?? timeoutMillis }
+	};
+};
+const runtimeGetOptions = (options) => {
+	const { encoding = "utf8", ...rest } = options ?? {};
+	return {
+		...rest,
+		...encoding === "utf8" ? { encoding: "utf8" } : {}
+	};
+};
+const wrapRuntimeResult = (result) => ({
+	status: result.status,
+	exitCode: result.exitCode,
+	stdout: result.stdout,
+	stderr: result.stderr,
+	...result.value === void 0 ? {} : { value: result.value },
+	pushed: result.pushed,
+	pulled: result.pulled,
+	skipped: result.skipped,
+	sync: result.sync
+});
+const wrapRuntimeEvent = (event) => {
+	switch (event.name) {
+		case "stdout": {
+			const chunk = event.value;
+			return typeof chunk === "string" ? {
+				_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 typeof chunk === "string" ? {
+				_tag: "Stderr",
+				id: event.id,
+				sequence: event.seq,
+				chunk,
+				text: chunk
+			} : {
+				_tag: "Stderr",
+				id: event.id,
+				sequence: event.seq,
+				chunk,
+				bytes: chunk
+			};
+		}
+		case "exit": return {
+			_tag: "Exit",
+			id: event.id,
+			sequence: event.seq,
+			exitCode: event.code,
+			...event.result === void 0 ? {} : { value: event.result }
+		};
+	}
+};
+const wrapRun = (handle) => {
+	const events = Stream.fromReadableStream({
+		evaluate: () => handle,
+		onError: (cause) => execError("events", cause)
+	}).pipe(Stream.map(wrapRuntimeEvent));
+	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 = typeof source === "string" ? optionsOrValue : void 0;
+		yield* Effect.annotateCurrentSpan({
+			backend: options?.backend,
+			runId: options?.id
+		});
+		const handle = yield* Effect.acquireRelease(Effect.tryPromise({
+			try: () => {
+				if (typeof source === "string") 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));
+	});
+	return {
+		readFile: method("readFile", (path) => path, (path) => client.readFile(path)),
+		readFileBytes: method("readFileBytes", (path) => path, (path) => client.readFileBytes(path)),
+		writeFile: method("writeFile", (path, _content) => path, (path, content) => client.writeFile(path, content)),
+		readDir: method("readDir", (path, _options) => path, (path, options) => client.readDir(path, options)),
+		rm: method("rm", (path, _options) => path, (path, options) => client.rm(path, options)),
+		glob: method("glob", (pattern) => pattern, (pattern) => client.glob(pattern)),
+		mkdir: method("mkdir", (path, _options) => path, (path, options) => client.mkdir(path, options)),
+		stat: method("stat", (path) => path, (path) => client.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

@@ -0,0 +1,71 @@
+import { t as ArtifactsBinding } from "./Artifacts-DcoXcRP5.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";
+//#region src/ComputerWorkspaceHost.d.ts
+/** The value of a `worker_loaders` binding. */
+type DynamicWorkerLoader = WorkerShellLoader;
+/** Default author and committer identity for workspace Git operations. */
+interface ComputerWorkspaceGitIdentity {
+  readonly name: string;
+  readonly email: string;
+}
+/** Session-scoped Artifacts configuration passed through to `Workspace`. */
+interface ComputerWorkspaceArtifactsOptions {
+  readonly binding: ArtifactsBinding;
+  /**
+   * Session prefix for repository names. When omitted, `sessionId` from the
+   * enclosing host configuration is used.
+   */
+  readonly sessionId?: string;
+}
+/**
+ * Worker-shell backend options with the loopback workspace wiring named in
+ * Durable Object terms.
+ */
+interface ComputerWorkspaceShellOptions extends Omit<WorkerShellBackendOptions, "source" | "loader" | "workspace" | "ctx" | "egress"> {
+  readonly loader: DynamicWorkerLoader;
+  /** Durable Object namespace binding that points back to the wrapped class. */
+  readonly hostBinding: string;
+  /** Current Durable Object id, normally `ctx.id.toString()`. */
+  readonly hostId: string;
+  /** Current Durable Object execution context, normally `ctx`. */
+  readonly executionContext: unknown;
+  /** Dynamic Worker egress policy. Defaults to `{ mode: "none" }`. */
+  readonly egress?: WorkspaceEgressPolicy;
+}
+/** Configuration accepted by {@link withComputerWorkspace}. */
+interface ComputerWorkspaceHostConfig {
+  /** Native SQLite-backed Durable Object storage (`ctx.storage`). */
+  readonly storage: globalThis.DurableObjectStorage | DurableObjectStorageLike;
+  /** Stable workspace id used by mounts and as the default Artifacts session. */
+  readonly sessionId?: string;
+  readonly gitIdentity?: ComputerWorkspaceGitIdentity;
+  /** Override the default `createGitClient()` factory. */
+  readonly git?: GitClientFactory;
+  /** Additional container, Worker JavaScript, shell, or custom backends. */
+  readonly backends?: ReadonlyArray<WorkspaceRegisteredBackend>;
+  /** Convenience wiring for one Worker Shell backend. */
+  readonly shell?: ComputerWorkspaceShellOptions;
+  readonly mounts?: WorkspaceOptions["mounts"];
+  readonly observer?: WorkspaceOptions["observer"];
+  readonly retryScheduler?: WorkspaceOptions["retryScheduler"];
+  readonly retry?: WorkspaceOptions["retry"];
+  readonly assets?: WorkspaceOptions["assets"];
+  readonly artifacts?: ComputerWorkspaceArtifactsOptions;
+  readonly now?: WorkspaceOptions["now"];
+  readonly useThink?: WorkspaceOptions["useThink"];
+}
+type DurableObjectConstructor = new (...args: Array<any>) => object;
+/**
+ * Wraps a Durable Object class with one SQLite-backed Cloudflare Computer
+ * workspace and registers that local workspace for {@link ComputerWorkspace}
+ * to acquire through its Effect layer.
+ *
+ * The class must use a `new_sqlite_classes` migration. If `shell` is present,
+ * its Worker must also configure a `worker_loaders` binding, enable the
+ * `experimental` compatibility flag, and export `WorkspaceServiceProxy`.
+ */
+declare const withComputerWorkspace: <TBase extends DurableObjectConstructor>(Base: TBase, config: (self: InstanceType<TBase>, state: globalThis.DurableObjectState, env: ConstructorParameters<TBase>[1]) => ComputerWorkspaceHostConfig) => WithWorkspaceCtor<TBase>;
+//#endregion
+export { ComputerWorkspaceArtifactsOptions, ComputerWorkspaceGitIdentity, ComputerWorkspaceHostConfig, ComputerWorkspaceShellOptions, DynamicWorkerLoader, type ShellModuleGroup, type SyncRetryIntent, type SyncRetryOptions, type SyncRetryScheduler, type WorkspaceAttributeValue, type WorkspaceAttributes, type WorkspaceEgressPolicy, type WorkspaceObserver, type WorkspaceRetryPendingSyncResult, WorkspaceServiceProxy, type WorkspaceSpan, withComputerWorkspace };

package/dist/ComputerWorkspaceHost.mjs

@@ -0,0 +1,74 @@
+import { n as register } from "./ComputerWorkspaceHostRegistry-CY5Fv4Ng.mjs";
+import { createGitClient } from "@cloudflare/computer/git";
+import { WorkspaceServiceProxy, withWorkspace } from "@cloudflare/computer";
+import { WorkerShellBackend } from "@cloudflare/computer/backends/worker-shell";
+//#region src/ComputerWorkspaceHost.ts
+const toWorkspaceOptions = (config) => {
+	const backends = [...config.backends ?? []];
+	if (config.shell !== void 0) {
+		const { egress, executionContext, hostBinding, hostId, loader, ...shellOptions } = config.shell;
+		backends.push(new WorkerShellBackend({
+			...shellOptions,
+			loader,
+			workspace: {
+				binding: hostBinding,
+				id: hostId
+			},
+			ctx: executionContext,
+			egress: egress ?? { mode: "none" }
+		}));
+	}
+	return {
+		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 }
+	};
+};
+const HostArguments = Symbol("effect-cf/ComputerWorkspaceHost/arguments");
+/**
+* Wraps a Durable Object class with one SQLite-backed Cloudflare Computer
+* workspace and registers that local workspace for {@link ComputerWorkspace}
+* to acquire through its Effect layer.
+*
+* The class must use a `new_sqlite_classes` migration. If `shell` is present,
+* its Worker must also configure a `worker_loaders` binding, enable the
+* `experimental` compatibility flag, and export `WorkspaceServiceProxy`.
+*/
+const withComputerWorkspace = (Base, config) => {
+	const CapturedBase = class extends Base {
+		[HostArguments];
+		constructor(...args) {
+			super(...args);
+			this[HostArguments] = {
+				state: args[0],
+				env: args[1]
+			};
+		}
+	};
+	const WithWorkspace = withWorkspace(CapturedBase, (self) => {
+		const { env, state } = self[HostArguments];
+		return toWorkspaceOptions(config(self, state, env));
+	});
+	class WithComputerWorkspace extends WithWorkspace {
+		constructor(...args) {
+			super(...args);
+			register(args[0], this);
+		}
+	}
+	return WithComputerWorkspace;
+};
+//#endregion
+export { WorkspaceServiceProxy, withComputerWorkspace };