effect-cf 0.29.0 → 0.31.0

package/dist/Sandbox.mjs

@@ -0,0 +1,361 @@
+import { a as WorkerEnvironment, t as causeMessage } from "./ErrorMessage-BM0K-Nik.mjs";
+import { r as layer$1 } from "./Binding-pfilNJmP.mjs";
+import { Context, Data, Effect, Option, Predicate, Stream } from "effect";
+//#region src/Sandbox.ts
+const expectedSandboxNamespace = "Sandbox Durable Object namespace binding with idFromName() and get()";
+/** Failure raised when invoking a sandbox operation. */
+var SandboxOperationError = class extends Data.TaggedError("SandboxOperationError") {
+	get message() {
+		return `Sandbox ${this.operation} failed for binding "${this.binding}" instance "${this.instance}": ${causeMessage(this.cause)}`;
+	}
+};
+const trySandboxPromise = (definition, instance, operation, evaluate) => Effect.tryPromise({
+	try: evaluate,
+	catch: (cause) => new SandboxOperationError({
+		binding: definition.binding,
+		instance,
+		operation,
+		cause
+	})
+});
+const sandboxStream = (definition, instance, operation, acquire) => Stream.unwrap(Effect.map(trySandboxPromise(definition, instance, operation, acquire), (readable) => Stream.fromReadableStream({
+	evaluate: () => readable,
+	onError: (cause) => new SandboxOperationError({
+		binding: definition.binding,
+		instance,
+		operation,
+		cause
+	})
+})));
+const decodeSseData = (payload) => {
+	if (payload === "[DONE]" || payload.trim() === "") return [];
+	try {
+		return [JSON.parse(payload)];
+	} catch {
+		return [];
+	}
+};
+/**
+* Decodes the sandbox runtime's `data:`-framed Server-Sent Events byte stream
+* into JSON event values, mirroring `parseSSEStream` from
+* `@cloudflare/sandbox` without requiring the package at runtime.
+*/
+const decodeSseEvents = (bytes) => bytes.pipe(Stream.decodeText(), Stream.splitLines, Stream.mapAccum(() => [], (pending, line) => {
+	if (line === "") return pending.length > 0 ? [[], decodeSseData(pending.join("\n"))] : [pending, []];
+	if (line.startsWith("data:")) {
+		const value = line.startsWith("data: ") ? line.slice(6) : line.slice(5);
+		return [[...pending, value], []];
+	}
+	return [pending, []];
+}, { onHalt: (pending) => pending.length > 0 ? decodeSseData(pending.join("\n")) : [] }));
+const makeProcessHandle = (definition, instance, process) => {
+	const spanOptions = (operation) => ({ attributes: {
+		binding: definition.binding,
+		instance,
+		processId: process.id,
+		operation
+	} });
+	return {
+		id: process.id,
+		pid: process.pid,
+		rawUnsafe: Effect.succeed(process),
+		status: trySandboxPromise(definition, instance, "process.status", () => process.status()).pipe(Effect.withSpan("Sandbox.process.status", spanOptions("process.status"))),
+		exitCode: trySandboxPromise(definition, instance, "process.exitCode", () => process.exitCode).pipe(Effect.withSpan("Sandbox.process.exitCode", spanOptions("process.exitCode"))),
+		logs: (options) => sandboxStream(definition, instance, "process.logs", (signal) => process.logs({
+			...options,
+			signal
+		})),
+		waitForLog: Effect.fn("Sandbox.process.waitForLog", spanOptions("process.waitForLog"))(function* (pattern, options) {
+			return yield* trySandboxPromise(definition, instance, "process.waitForLog", (signal) => process.waitForLog(pattern, {
+				...options,
+				signal
+			}));
+		}),
+		waitForExit: Effect.fn("Sandbox.process.waitForExit", spanOptions("process.waitForExit"))(function* (options) {
+			return yield* trySandboxPromise(definition, instance, "process.waitForExit", (signal) => process.waitForExit({
+				...options,
+				signal
+			}));
+		}),
+		output: Effect.fn("Sandbox.process.output", spanOptions("process.output"))(function* (options) {
+			return yield* trySandboxPromise(definition, instance, "process.output", (signal) => process.output({
+				...options,
+				signal
+			}));
+		}),
+		outputText: Effect.fn("Sandbox.process.outputText", spanOptions("process.outputText"))(function* (options) {
+			return yield* trySandboxPromise(definition, instance, "process.outputText", (signal) => process.output({
+				...options,
+				encoding: "utf8",
+				signal
+			}));
+		}),
+		waitForPort: Effect.fn("Sandbox.process.waitForPort", spanOptions("process.waitForPort"))(function* (port, options) {
+			return yield* trySandboxPromise(definition, instance, "process.waitForPort", (signal) => process.waitForPort(port, {
+				...options,
+				signal
+			}));
+		}),
+		kill: Effect.fn("Sandbox.process.kill", spanOptions("process.kill"))(function* (signal) {
+			return yield* trySandboxPromise(definition, instance, "process.kill", () => process.kill(signal));
+		})
+	};
+};
+const makeTerminalHandle = (definition, instance, terminal) => {
+	const spanOptions = (operation) => ({ attributes: {
+		binding: definition.binding,
+		instance,
+		terminalId: terminal.id,
+		operation
+	} });
+	return {
+		id: terminal.id,
+		rawUnsafe: Effect.succeed(terminal),
+		snapshot: trySandboxPromise(definition, instance, "terminal.snapshot", () => terminal.getSnapshot()).pipe(Effect.withSpan("Sandbox.terminal.snapshot", spanOptions("terminal.snapshot"))),
+		write: Effect.fn("Sandbox.terminal.write", spanOptions("terminal.write"))(function* (data) {
+			return yield* trySandboxPromise(definition, instance, "terminal.write", () => terminal.write(data));
+		}),
+		resize: Effect.fn("Sandbox.terminal.resize", spanOptions("terminal.resize"))(function* (cols, rows) {
+			return yield* trySandboxPromise(definition, instance, "terminal.resize", () => terminal.resize(cols, rows));
+		}),
+		output: (options) => sandboxStream(definition, instance, "terminal.output", (signal) => terminal.output({
+			...options,
+			signal
+		})),
+		waitForExit: Effect.fn("Sandbox.terminal.waitForExit", spanOptions("terminal.waitForExit"))(function* (options) {
+			return yield* trySandboxPromise(definition, instance, "terminal.waitForExit", (signal) => terminal.waitForExit({
+				...options,
+				signal
+			}));
+		}),
+		interrupt: trySandboxPromise(definition, instance, "terminal.interrupt", () => terminal.interrupt()).pipe(Effect.withSpan("Sandbox.terminal.interrupt", spanOptions("terminal.interrupt"))),
+		terminate: trySandboxPromise(definition, instance, "terminal.terminate", () => terminal.terminate()).pipe(Effect.withSpan("Sandbox.terminal.terminate", spanOptions("terminal.terminate"))),
+		connect: Effect.fn("Sandbox.terminal.connect", spanOptions("terminal.connect"))(function* (request, options) {
+			return yield* trySandboxPromise(definition, instance, "terminal.connect", () => terminal.connect(request, options));
+		})
+	};
+};
+/**
+* Wraps an already-created sandbox client (the value returned by
+* `getSandbox()` from `@cloudflare/sandbox`) into an Effect client.
+*
+* Prefer {@link Tag}/{@link make} with a layer for application code; this
+* entry point exists for advanced composition and testing.
+*/
+const fromSandboxClient = (client, definition, instance) => {
+	const spanOptions = (operation) => ({ attributes: {
+		binding: definition.binding,
+		instance,
+		operation
+	} });
+	return {
+		rawUnsafe: Effect.succeed(client),
+		exec: Effect.fn("Sandbox.exec", spanOptions("exec"))(function* (command, options) {
+			const process = yield* trySandboxPromise(definition, instance, "exec", () => client.exec(command, options));
+			return makeProcessHandle(definition, instance, process);
+		}),
+		getProcess: Effect.fn("Sandbox.getProcess", spanOptions("getProcess"))(function* (id) {
+			const process = yield* trySandboxPromise(definition, instance, "getProcess", () => client.getProcess(id));
+			return Option.map(Option.fromNullishOr(process), (found) => makeProcessHandle(definition, instance, found));
+		}),
+		listProcesses: trySandboxPromise(definition, instance, "listProcesses", () => client.listProcesses()).pipe(Effect.withSpan("Sandbox.listProcesses", spanOptions("listProcesses"))),
+		writeFile: Effect.fn("Sandbox.writeFile", spanOptions("writeFile"))(function* (path, content, options) {
+			yield* Effect.annotateCurrentSpan("path", path);
+			return yield* trySandboxPromise(definition, instance, "writeFile", () => client.writeFile(path, content, options));
+		}),
+		readFile: Effect.fn("Sandbox.readFile", spanOptions("readFile"))(function* (path, options) {
+			yield* Effect.annotateCurrentSpan("path", path);
+			return yield* trySandboxPromise(definition, instance, "readFile", () => client.readFile(path, options));
+		}),
+		readFileStream: (path) => sandboxStream(definition, instance, "readFileStream", () => client.readFileStream(path)),
+		mkdir: Effect.fn("Sandbox.mkdir", spanOptions("mkdir"))(function* (path, options) {
+			yield* Effect.annotateCurrentSpan("path", path);
+			return yield* trySandboxPromise(definition, instance, "mkdir", () => client.mkdir(path, options));
+		}),
+		deleteFile: Effect.fn("Sandbox.deleteFile", spanOptions("deleteFile"))(function* (path) {
+			yield* Effect.annotateCurrentSpan("path", path);
+			return yield* trySandboxPromise(definition, instance, "deleteFile", () => client.deleteFile(path));
+		}),
+		renameFile: Effect.fn("Sandbox.renameFile", spanOptions("renameFile"))(function* (oldPath, newPath) {
+			yield* Effect.annotateCurrentSpan({
+				oldPath,
+				newPath
+			});
+			return yield* trySandboxPromise(definition, instance, "renameFile", () => client.renameFile(oldPath, newPath));
+		}),
+		moveFile: Effect.fn("Sandbox.moveFile", spanOptions("moveFile"))(function* (sourcePath, destinationPath) {
+			yield* Effect.annotateCurrentSpan({
+				sourcePath,
+				destinationPath
+			});
+			return yield* trySandboxPromise(definition, instance, "moveFile", () => client.moveFile(sourcePath, destinationPath));
+		}),
+		listFiles: Effect.fn("Sandbox.listFiles", spanOptions("listFiles"))(function* (path, options) {
+			yield* Effect.annotateCurrentSpan("path", path);
+			return yield* trySandboxPromise(definition, instance, "listFiles", () => client.listFiles(path, options));
+		}),
+		exists: Effect.fn("Sandbox.exists", spanOptions("exists"))(function* (path) {
+			yield* Effect.annotateCurrentSpan("path", path);
+			return yield* trySandboxPromise(definition, instance, "exists", () => client.exists(path));
+		}),
+		watch: (path, options) => decodeSseEvents(sandboxStream(definition, instance, "watch", () => client.watch(path, options))),
+		checkChanges: Effect.fn("Sandbox.checkChanges", spanOptions("checkChanges"))(function* (path, options) {
+			yield* Effect.annotateCurrentSpan("path", path);
+			return yield* trySandboxPromise(definition, instance, "checkChanges", () => client.checkChanges(path, options));
+		}),
+		setEnvVars: Effect.fn("Sandbox.setEnvVars", spanOptions("setEnvVars"))(function* (envVars) {
+			return yield* trySandboxPromise(definition, instance, "setEnvVars", () => client.setEnvVars(envVars));
+		}),
+		exposePort: Effect.fn("Sandbox.exposePort", spanOptions("exposePort"))(function* (port, options) {
+			yield* Effect.annotateCurrentSpan("port", port);
+			return yield* trySandboxPromise(definition, instance, "exposePort", () => client.exposePort(port, options));
+		}),
+		unexposePort: Effect.fn("Sandbox.unexposePort", spanOptions("unexposePort"))(function* (port) {
+			yield* Effect.annotateCurrentSpan("port", port);
+			return yield* trySandboxPromise(definition, instance, "unexposePort", () => client.unexposePort(port));
+		}),
+		getExposedPorts: Effect.fn("Sandbox.getExposedPorts", spanOptions("getExposedPorts"))(function* (hostname) {
+			return yield* trySandboxPromise(definition, instance, "getExposedPorts", () => client.getExposedPorts(hostname));
+		}),
+		isPortExposed: Effect.fn("Sandbox.isPortExposed", spanOptions("isPortExposed"))(function* (port) {
+			yield* Effect.annotateCurrentSpan("port", port);
+			return yield* trySandboxPromise(definition, instance, "isPortExposed", () => client.isPortExposed(port));
+		}),
+		validatePortToken: Effect.fn("Sandbox.validatePortToken", spanOptions("validatePortToken"))(function* (port, token) {
+			yield* Effect.annotateCurrentSpan("port", port);
+			return yield* trySandboxPromise(definition, instance, "validatePortToken", () => client.validatePortToken(port, token));
+		}),
+		containerFetch: Effect.fn("Sandbox.containerFetch", spanOptions("containerFetch"))(function* (requestOrUrl, port) {
+			return yield* trySandboxPromise(definition, instance, "containerFetch", () => client.containerFetch(requestOrUrl, port));
+		}),
+		wsConnect: Effect.fn("Sandbox.wsConnect", spanOptions("wsConnect"))(function* (request, port) {
+			yield* Effect.annotateCurrentSpan("port", port);
+			return yield* trySandboxPromise(definition, instance, "wsConnect", () => client.wsConnect(request, port));
+		}),
+		mountBucket: Effect.fn("Sandbox.mountBucket", spanOptions("mountBucket"))(function* (bucket, mountPath, options) {
+			yield* Effect.annotateCurrentSpan({
+				bucket,
+				mountPath
+			});
+			return yield* trySandboxPromise(definition, instance, "mountBucket", () => client.mountBucket(bucket, mountPath, options));
+		}),
+		unmountBucket: Effect.fn("Sandbox.unmountBucket", spanOptions("unmountBucket"))(function* (mountPath) {
+			yield* Effect.annotateCurrentSpan("mountPath", mountPath);
+			return yield* trySandboxPromise(definition, instance, "unmountBucket", () => client.unmountBucket(mountPath));
+		}),
+		createBackup: Effect.fn("Sandbox.createBackup", spanOptions("createBackup"))(function* (options) {
+			yield* Effect.annotateCurrentSpan("dir", options.dir);
+			return yield* trySandboxPromise(definition, instance, "createBackup", () => client.createBackup(options));
+		}),
+		restoreBackup: Effect.fn("Sandbox.restoreBackup", spanOptions("restoreBackup"))(function* (backup) {
+			yield* Effect.annotateCurrentSpan({
+				backupId: backup.id,
+				dir: backup.dir
+			});
+			return yield* trySandboxPromise(definition, instance, "restoreBackup", () => client.restoreBackup(backup));
+		}),
+		createTerminal: Effect.fn("Sandbox.createTerminal", spanOptions("createTerminal"))(function* (options) {
+			const terminal = yield* trySandboxPromise(definition, instance, "createTerminal", () => client.createTerminal(options));
+			return makeTerminalHandle(definition, instance, terminal);
+		}),
+		getTerminal: Effect.fn("Sandbox.getTerminal", spanOptions("getTerminal"))(function* (id) {
+			const terminal = yield* trySandboxPromise(definition, instance, "getTerminal", () => client.getTerminal(id));
+			return Option.map(Option.fromNullishOr(terminal), (found) => makeTerminalHandle(definition, instance, found));
+		}),
+		listTerminals: trySandboxPromise(definition, instance, "listTerminals", () => client.listTerminals()).pipe(Effect.map((terminals) => terminals.map((terminal) => makeTerminalHandle(definition, instance, terminal))), Effect.withSpan("Sandbox.listTerminals", spanOptions("listTerminals"))),
+		tunnels: {
+			get: Effect.fn("Sandbox.tunnels.get", spanOptions("tunnels.get"))(function* (port, options) {
+				yield* Effect.annotateCurrentSpan("port", port);
+				return yield* trySandboxPromise(definition, instance, "tunnels.get", () => client.tunnels.get(port, options));
+			}),
+			list: trySandboxPromise(definition, instance, "tunnels.list", () => client.tunnels.list()).pipe(Effect.withSpan("Sandbox.tunnels.list", spanOptions("tunnels.list"))),
+			destroy: Effect.fn("Sandbox.tunnels.destroy", spanOptions("tunnels.destroy"))(function* (portOrInfo) {
+				return yield* trySandboxPromise(definition, instance, "tunnels.destroy", () => client.tunnels.destroy(portOrInfo));
+			})
+		},
+		start: Effect.fn("Sandbox.start", spanOptions("start"))(function* (options) {
+			return yield* trySandboxPromise(definition, instance, "start", () => client.start(options));
+		}),
+		stop: Effect.fn("Sandbox.stop", spanOptions("stop"))(function* (signal) {
+			return yield* trySandboxPromise(definition, instance, "stop", () => client.stop(signal));
+		}),
+		destroy: trySandboxPromise(definition, instance, "destroy", () => client.destroy()).pipe(Effect.withSpan("Sandbox.destroy", spanOptions("destroy")))
+	};
+};
+/**
+* Lazily imports `@cloudflare/sandbox`.
+*
+* The package is an optional peer dependency: loading it on first use keeps
+* this module importable (and the rest of `effect-cf` bundleable) in
+* applications that never touch sandboxes.
+*/
+const importSandboxModule = (definition, instance) => Effect.tryPromise({
+	try: () => import("@cloudflare/sandbox"),
+	catch: (cause) => new SandboxOperationError({
+		binding: definition.binding,
+		instance,
+		operation: "import",
+		cause
+	})
+});
+const isSandboxNamespaceResource = (value) => Predicate.hasProperty(value, "idFromName") && Predicate.isFunction(value.idFromName) && Predicate.hasProperty(value, "get") && Predicate.isFunction(value.get);
+const makeClient = (definition) => (namespace) => {
+	return {
+		definition,
+		get: Effect.fn("Sandbox.get", { attributes: {
+			binding: definition.binding,
+			operation: "get"
+		} })(function* (name, options) {
+			yield* Effect.annotateCurrentSpan("instance", name);
+			const sandboxModule = yield* importSandboxModule(definition, name);
+			const nativeNamespace = namespace;
+			const client = yield* Effect.try({
+				try: () => sandboxModule.getSandbox(nativeNamespace, name, options),
+				catch: (cause) => new SandboxOperationError({
+					binding: definition.binding,
+					instance: name,
+					operation: "get",
+					cause
+				})
+			});
+			return fromSandboxClient(client, definition, name);
+		}),
+		rawUnsafe: Effect.succeed(namespace)
+	};
+};
+const layer = (tag, definition) => layer$1(tag, definition.binding, (value) => isSandboxNamespaceResource(value), makeClient(definition), { expected: expectedSandboxNamespace });
+const make = (id) => Tag()(id);
+/** Creates a typed Effect service for a Cloudflare Sandbox namespace. */
+const Tag = () => (id) => {
+	const tag = Context.Service()(`effect-cf/Sandbox/${id}`);
+	const makeLayer = (definition) => layer(tag, definition);
+	const get = Effect.fnUntraced(function* (name, options) {
+		return yield* (yield* tag).get(name, options);
+	});
+	const rawUnsafe = Effect.flatMap(tag, (namespace) => namespace.rawUnsafe);
+	return Object.assign(tag, {
+		id,
+		layer: makeLayer,
+		get,
+		rawUnsafe
+	});
+};
+const Sandbox = Tag;
+/**
+* Routes sandbox preview-URL requests (`https://<port>-<sandbox-id>-<token>.<host>`)
+* to the owning sandbox, mirroring `proxyToSandbox` from `@cloudflare/sandbox`.
+*
+* Call this before any other routing in a Worker `fetch` handler; it resolves
+* to `Option.none()` for requests that are not preview-URL traffic.
+*/
+const proxyToSandbox = Effect.fn("Sandbox.proxyToSandbox")(function* (request, options) {
+	const binding = options?.binding ?? "Sandbox";
+	const definition = { binding };
+	const env = yield* WorkerEnvironment;
+	const resource = Predicate.hasProperty(env, binding) ? env[binding] : void 0;
+	const sandboxModule = yield* importSandboxModule(definition, "preview");
+	const response = yield* trySandboxPromise(definition, "preview", "proxyToSandbox", () => sandboxModule.proxyToSandbox(request, { Sandbox: resource }));
+	return Option.fromNullishOr(response);
+});
+//#endregion
+export { Sandbox, SandboxOperationError, Tag, fromSandboxClient, isSandboxNamespaceResource, layer, make, makeClient, proxyToSandbox };

package/dist/Vitest.d.mts

@@ -1,12 +1,12 @@
 import { c as WorkerEnvironment, s as WorkerEnv } from "./Binding-xJJJPmiD.mjs";
-import { n as DurableObjectStateService, t as DurableObjectState } from "./DurableObjectState-OupNMMUl.mjs";
-import { o as WorkflowInstanceStatusName } from "./WorkflowBinding-DUZtKCVM.mjs";
+import { n as DurableObjectStateService, t as DurableObjectState } from "./DurableObjectState-DVIgf0sA.mjs";
+import { o as WorkflowInstanceStatusName } from "./WorkflowBinding-C9KRmfDU.mjs";
 import { Effect, Layer, Schema } from "effect";
 import { DurableObject } from "cloudflare:workers";
 import { adminSecretsStore as adminSecretsStore$1, getQueueResult, introspectWorkflow as introspectWorkflow$1, introspectWorkflowInstance as introspectWorkflowInstance$1 } from "cloudflare:test";
 //#region src/Vitest.d.ts
 /**
- * Provides the Workers pool environment as both {@link WorkerEnvironment} and
+ * Provides the Workers test environment as both {@link WorkerEnvironment} and
  * the active Effect `ConfigProvider`.
  */
 declare const layer: Layer.Layer<WorkerEnvironment>;
@@ -54,7 +54,7 @@ type PagesEventContextInitData<Context> = Context extends globalThis.EventContex
 } : {
   readonly data: Data;
 } : never;
-/** Initialization accepted by Pool Workers for a Pages Function. */
+/** Initialization accepted by the Workers Vitest plugin for a Pages Function. */
 type PagesEventContextInit<Function extends AnyPagesFunction> = PagesEventContextInitBase & PagesEventContextInitParams<Parameters<Function>[0]> & PagesEventContextInitData<Parameters<Function>[0]>;
 /**
  * Invokes a Pages Function with a typed event context and drains its
@@ -64,7 +64,7 @@ declare const pages: <Function extends AnyPagesFunction>(handler: Function, init
 interface QueueWorker {
   queue(batch: globalThis.MessageBatch): Promise<void>;
 }
-/** Input message accepted by Pool Workers' `createMessageBatch` helper. */
+/** Input message accepted by the Workers Vitest plugin's `createMessageBatch` helper. */
 type QueueMessage<Body> = {
   readonly id: string;
   readonly timestamp: Date;
@@ -74,7 +74,7 @@ type QueueMessage<Body> = {
 } | {
   readonly serializedBody: ArrayBuffer | ArrayBufferView;
 });
-/** Acknowledgement and retry result returned by Pool Workers. */
+/** Acknowledgement and retry result returned by the Workers Vitest plugin. */
 type QueueResult = Awaited<ReturnType<typeof getQueueResult>>;
 /** Result of invoking a queue consumer through {@link queue}. */
 interface QueueRunResult<Body> {
@@ -83,7 +83,7 @@ interface QueueRunResult<Body> {
 }
 /**
  * Invokes an Effect-backed queue consumer, drains its `waitUntil` work, and
- * returns Pool Workers' acknowledgement and retry result.
+ * returns the Workers Vitest plugin's acknowledgement and retry result.
  */
 declare const queue: <Body, Instance extends QueueWorker>(Worker: WorkerConstructor<Instance>, queueName: string, messages: readonly QueueMessage<Body>[], workerEnv?: Cloudflare.Env | undefined) => Effect.Effect<QueueRunResult<Body>, never, never>;
 /**
@@ -110,7 +110,7 @@ declare const reset: () => Effect.Effect<void, never, never>;
 declare const abortAllDurableObjects: () => Effect.Effect<void, never, never>;
 /** Gracefully evicts all running Durable Objects while preserving durable storage. */
 declare const evictAllDurableObjects: (options?: DurableObjectEvictionOptions | undefined) => Effect.Effect<void, never, never>;
-/** A D1 migration accepted by Pool Workers. */
+/** A D1 migration accepted by the Workers Vitest plugin. */
 interface D1Migration {
   readonly name: string;
   readonly queries: ReadonlyArray<string>;
@@ -125,7 +125,7 @@ interface SecretsStoreSecret {
     readonly uuid: string;
   };
 }
-/** Effect-native wrapper around Pool Workers' Secrets Store admin API. */
+/** Effect-native wrapper around the Workers Vitest plugin's Secrets Store admin API. */
 interface SecretsStoreAdmin {
   readonly raw: NativeSecretsStoreAdmin;
   readonly create: (value: string) => Effect.Effect<string>;

package/dist/Vitest.mjs

@@ -1,18 +1,18 @@
 import { a as WorkerEnvironment, i as WorkerConfig } from "./ErrorMessage-BM0K-Nik.mjs";
-import { r as fromDurableObjectState, t as DurableObjectState } from "./DurableObjectState-DnnLoHV-.mjs";
+import { r as fromDurableObjectState, t as DurableObjectState } from "./DurableObjectState-CxS5Y2hf.mjs";
 import { ConfigProvider, Effect, Exit, Layer } from "effect";
 import { env } from "cloudflare:workers";
 import { abortAllDurableObjects as abortAllDurableObjects$1, adminSecretsStore as adminSecretsStore$1, applyD1Migrations as applyD1Migrations$1, createExecutionContext, createMessageBatch, createPagesEventContext, createScheduledController, evictAllDurableObjects as evictAllDurableObjects$1, evictDurableObject as evictDurableObject$1, getQueueResult, introspectWorkflow as introspectWorkflow$1, introspectWorkflowInstance as introspectWorkflowInstance$1, listDurableObjectIds as listDurableObjectIds$1, reset as reset$1, runDurableObjectAlarm as runDurableObjectAlarm$1, runInDurableObject as runInDurableObject$1, waitOnExecutionContext } from "cloudflare:test";
 //#region src/Vitest.ts
 /**
-* Effect-native helpers for tests running in Cloudflare's Vitest Workers pool.
+* Effect-native helpers for tests running in Cloudflare's Workers Vitest plugin.
 *
 * Import this module through the `effect-cf/vitest` subpath. It is intended to
 * run inside the Workers test runtime, where `cloudflare:test` is available.
 */
 const currentEnv = env;
 /**
-* Provides the Workers pool environment as both {@link WorkerEnvironment} and
+* Provides the Workers test environment as both {@link WorkerEnvironment} and
 * the active Effect `ConfigProvider`.
 */
 const layer = Layer.mergeAll(Layer.succeed(WorkerEnvironment, currentEnv), ConfigProvider.layer(WorkerConfig.providerFromEnv(currentEnv)));
@@ -50,7 +50,7 @@ const pages = Effect.fn("effect-cf/vitest/pages")(function* (handler, init) {
 });
 /**
 * Invokes an Effect-backed queue consumer, drains its `waitUntil` work, and
-* returns Pool Workers' acknowledgement and retry result.
+* returns the Workers Vitest plugin's acknowledgement and retry result.
 */
 const queue = Effect.fn("effect-cf/vitest/queue")(function* (Worker, queueName, messages, workerEnv = currentEnv) {
 	return yield* withExecutionContext(Effect.fnUntraced(function* (context) {
@@ -146,7 +146,7 @@ const runWorkflowModifier = Effect.fnUntraced(function* (register, use) {
 			if (callbackExit !== void 0 && Exit.isFailure(callbackExit)) return callbackExit;
 			throw cause;
 		}
-		if (callbackExit === void 0) throw new Error("Pool Workers did not invoke the Workflow modifier callback");
+		if (callbackExit === void 0) throw new Error("The Workers Vitest plugin did not invoke the Workflow modifier callback");
 		return callbackExit;
 	});
 });

package/dist/{WorkflowBinding-DUZtKCVM.d.mts → WorkflowBinding-C9KRmfDU.d.mts}

@@ -1,14 +1,16 @@
 import { c as WorkerEnvironment, r as BindingValidationError, t as BindingNotFoundError } from "./Binding-xJJJPmiD.mjs";
-import { x as ServiceFreeSchema } from "./DurableObjectState-OupNMMUl.mjs";
+import { x as ServiceFreeSchema } from "./DurableObjectState-DVIgf0sA.mjs";
 import { Context, Effect, Option, Schema } from "effect";
 declare namespace WorkflowBinding_d_exports {
-  export { WorkflowBindingClient, WorkflowBindingDefinition, WorkflowInstance, WorkflowInstanceCreateBatchOptions, WorkflowInstanceCreateOptions, WorkflowInstanceEvent, WorkflowInstanceRestartOptions, WorkflowInstanceStatus, WorkflowInstanceStatusName, WorkflowOperationError, WorkflowResultDecodeError, isWorkflow, layer, makeClient };
+  export { WorkflowBindingClient, WorkflowBindingDefinition, WorkflowInstance, WorkflowInstanceCreateBatchOptions, WorkflowInstanceCreateOptions, WorkflowInstanceEvent, WorkflowInstanceLocationHint, WorkflowInstanceRestartOptions, WorkflowInstanceStatus, WorkflowInstanceStatusName, WorkflowInstanceTerminateOptions, WorkflowOperationError, WorkflowResultDecodeError, isWorkflow, layer, makeClient };
 }
 type WorkflowInstanceCreateOptions<Payload> = Omit<CloudflareWorkflowInstanceCreateOptions<Payload>, "params">;
 type WorkflowInstanceCreateBatchOptions<Payload, EncodedPayload = unknown> = ReadonlyArray<{
   readonly payload: Payload;
 } & WorkflowInstanceCreateOptions<EncodedPayload>>;
 type WorkflowInstanceRestartOptions = CloudflareWorkflowInstanceRestartOptions;
+type WorkflowInstanceTerminateOptions = CloudflareWorkflowInstanceTerminateOptions;
+type WorkflowInstanceLocationHint = CloudflareWorkflowInstanceLocationHint;
 type WorkflowInstanceStatusName = CloudflareInstanceStatus["status"];
 interface WorkflowInstanceStatus<Result> {
   readonly status: WorkflowInstanceStatusName;
@@ -23,8 +25,9 @@ interface WorkflowInstance<Result> {
   readonly id: string;
   readonly pause: Effect.Effect<void, WorkflowOperationError>;
   readonly resume: Effect.Effect<void, WorkflowOperationError>;
-  readonly terminate: Effect.Effect<void, WorkflowOperationError>;
+  readonly terminate: (options?: WorkflowInstanceTerminateOptions) => Effect.Effect<void, WorkflowOperationError>;
   readonly restart: (options?: WorkflowInstanceRestartOptions) => Effect.Effect<void, WorkflowOperationError>;
+  readonly delete: Effect.Effect<void, WorkflowOperationError>;
   readonly status: Effect.Effect<WorkflowInstanceStatus<Result>, WorkflowOperationError | WorkflowResultDecodeError>;
   readonly sendEvent: (event: WorkflowInstanceEvent) => Effect.Effect<void, WorkflowOperationError>;
 }