effect-cf 0.26.0 → 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/{DurableObjectState-CEh0DVw7.mjs → DurableObjectState-Dux8KfjG.mjs}

@@ -1,51 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { Cause, Config, ConfigProvider, Context, Data, Effect, Exit, Option, Predicate, Result, Schema } from "effect";
-//#region src/Environment.ts
-var Environment_exports = /* @__PURE__ */ __exportAll({
-	WorkerConfig: () => WorkerConfig,
-	WorkerEnvironment: () => WorkerEnvironment
-});
-/**
-* Context service for reading worker bindings from the current `env` object.
-*/
-var WorkerEnvironment = class extends Context.Service()("effect-cf/WorkerEnvironment") {};
-let WorkerConfig;
-(function(_WorkerConfig) {
-	_WorkerConfig.string = (name) => Config.string(name);
-	_WorkerConfig.redacted = (name) => Config.redacted(name);
-	_WorkerConfig.number = (name) => Config.number(name);
-	_WorkerConfig.integer = (name) => Config.int(name);
-	_WorkerConfig.boolean = (name) => Config.boolean(name);
-	const providerFromEnv = _WorkerConfig.providerFromEnv = (env, options) => {
-		const record = {};
-		for (const [key, value] of Object.entries(env)) if (Predicate.isString(value) || Predicate.isNumber(value) || Predicate.isBoolean(value)) record[key] = String(value);
-		return ConfigProvider.fromEnvRecord(record, options);
-	};
-	const providerWith = _WorkerConfig.providerWith = (makeProvider) => Effect.map(WorkerEnvironment, makeProvider);
-	const provider = _WorkerConfig.provider = providerWith(providerFromEnv);
-	_WorkerConfig.providerLayer = ConfigProvider.layer(provider);
-	_WorkerConfig.layerWith = (makeProvider) => ConfigProvider.layer(providerWith(makeProvider));
-})(WorkerConfig || (WorkerConfig = {}));
-//#endregion
-//#region src/internal/ErrorMessage.ts
-/**
-* Renders the most useful human-readable description of an unknown `cause`
-* for use in tagged error `message` getters.
-*/
-const causeMessage = (cause) => {
-	if (typeof cause === "object" && cause !== null) {
-		const message = Reflect.get(cause, "message");
-		if (typeof message === "string" && message.length > 0) return message;
-	}
-	try {
-		return String(cause);
-	} catch {
-		return "unknown cause";
-	}
-};
-/** Renders a violation list as a single `path: message; ...` line. */
-const violationsMessage = (violations) => violations.map((violation) => `${violation.path}: ${violation.message}`).join("; ");
-//#endregion
+import { t as causeMessage } from "./ErrorMessage-_lg53p3W.mjs";
+import { Cause, Context, Data, Effect, Exit, Option, Result, Schema } from "effect";
 //#region src/DurableObjectStorage.ts
 var DurableObjectStorage_exports = /* @__PURE__ */ __exportAll({
 	StorageOperationError: () => StorageOperationError,
@@ -385,4 +340,4 @@ const runPromiseExitPreservingTypedFailures = async (context, effect) => {
 	return exit;
 };
 //#endregion
-export { DurableObjectWebSocket_exports as a, causeMessage as c, WorkerConfig as d, WorkerEnvironment as f, fromExecutionContext as i, violationsMessage as l, DurableObjectState_exports as n, fromWebSocket as o, fromDurableObjectState as r, DurableObjectStorage_exports as s, DurableObjectState as t, Environment_exports as u };
+export { DurableObjectWebSocket_exports as a, fromExecutionContext as i, DurableObjectState_exports as n, fromWebSocket as o, fromDurableObjectState as r, DurableObjectStorage_exports as s, DurableObjectState as t };