effect-cf 0.29.0 → 0.31.0

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # effect-cf
 
+## 0.31.0
+
+### Minor Changes
+
+- [#116](https://github.com/danieljvdm/effect-cf/pull/116) [`98d343b`](https://github.com/danieljvdm/effect-cf/commit/98d343ba7d5a427789ec8e7fc030668987eab1ea) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Move the optional `effect-cf/vitest` peer from `@cloudflare/vitest-pool-workers` to `@cloudflare/vitest-plugin` `^1.0.0`. The package API is unchanged: keep using `cloudflareTest()` and `cloudflare:test`.
+
+- [#118](https://github.com/danieljvdm/effect-cf/pull/118) [`80730a8`](https://github.com/danieljvdm/effect-cf/commit/80730a82b26728e824ba6e4ed8bdbe290428baa6) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Pin the Cloudflare Workers runtime stack to workerd `1.20260820.1` (`@cloudflare/workers-types@^5.20260820.1`, wrangler `4.125.0`, recommended `compatibility_date` `2026-08-20`).
+
+  Images gains text rasterization (`text` / `process` text input), hosted `createDirectUpload` and `signedUrl`, and `response(options?)` for extra headers. Workflow instances gain `delete`, optional `terminate({ rollback })`, and `create`/`createBatch` `locationHint` via the updated types. `Worker.WorkerContext` now wraps the non-experimental `ExecutionContext.abort`.
+
+## 0.30.0
+
+### Minor Changes
+
+- [#110](https://github.com/danieljvdm/effect-cf/pull/110) [`9037864`](https://github.com/danieljvdm/effect-cf/commit/9037864c1acbd15e03b6a71733d49fa123244046) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Add `setAlarmAfter` to Durable Object storage and transaction wrappers for scheduling alarms with Effect `Duration.Input` values.
+
+- [#112](https://github.com/danieljvdm/effect-cf/pull/112) [`cbe0206`](https://github.com/danieljvdm/effect-cf/commit/cbe0206557b101c7bb4050e53366e53af9aa8e5f) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Add `effect-cf/sandbox`: an Effect-native client for the Cloudflare Sandbox SDK 1.0 API (`@cloudflare/sandbox@next`, an optional peer dependency loaded lazily on first use).
+
+  `Sandbox.Tag`/`Sandbox.make` create a typed service for a Sandbox Durable Object namespace binding, and `layer({ binding })` validates the binding from `WorkerEnvironment`. The instance client covers the complete `ISandbox` contract plus lifecycle, preview-port, tunnel, bucket-mount, and backup operations: `exec` returns a process handle with typed log `Stream`s and interruption-aware waits, `watch` decodes file-watch Server-Sent Events into an Effect `Stream`, `readFileStream` streams raw bytes, and terminals are wrapped as Effect handles. Failures are reported as a typed `SandboxOperationError` that preserves the SDK's error classes as `cause`, and `Sandbox.proxyToSandbox` routes preview-URL traffic as an `Option<Response>` Effect.
+
 ## 0.29.0
 
 ### Minor Changes

package/README.md

@@ -4,7 +4,8 @@ Effect-native Cloudflare primitives for Workers, Durable Objects, Containers, bi
 
 ## Install
 
-`effect-cf` targets Effect `^4.0.0-beta.105`.
+`effect-cf` targets Effect `^4.0.0-beta.105` and Cloudflare workerd `1.20260820.1`
+(`@cloudflare/workers-types@5.20260820.1`, recommended `compatibility_date` `2026-08-20`).
 
 ```bash
 bun add effect-cf "effect@^4.0.0-beta.105"
@@ -33,6 +34,14 @@ Workspace Git operations additionally require `@platformatic/vfs`,
 bun add "@platformatic/vfs@^0.4.0"
 ```
 
+The Sandbox integration is an optional peer. Install the `@next` release line
+of `@cloudflare/sandbox` (the Sandbox SDK 1.0 API) only in applications that
+import `effect-cf/sandbox`:
+
+```bash
+bun add "@cloudflare/sandbox@next"
+```
+
 ## Goal
 
 Cloudflare APIs return promises and expose platform-specific bindings. `effect-cf` wraps those boundaries as `Context`, `Layer`, and `Effect` values so application code stays inside one managed Effect runtime.
@@ -54,6 +63,7 @@ Runtime creation belongs at Cloudflare entrypoints, not inside binding helpers.
 - `effect-cf/computer-workspace` - scoped Effect wrappers for the complete Cloudflare Computer filesystem, Git, runtime, Assets, Artifacts, and Think-compatible client surfaces
 - `effect-cf/computer-artifacts` - session-isolated Artifacts repositories backed by `@cloudflare/computer/artifacts`
 - `effect-cf/computer-workspace-host` - optional Durable Object host mixin, worker-shell backend wiring, and `WorkspaceServiceProxy`
+- `effect-cf/sandbox` - Effect-native client for Cloudflare Sandbox containers: processes with log streams, files and watches, preview URLs, tunnels, terminals, bucket mounts, and backups
 - `Hyperdrive` - typed Hyperdrive binding helper for connection strings and optional Postgres SQL integration
 - `Images` - typed Cloudflare Images binding helper with transformation APIs and optional hosted image operations
 - `Email` - typed Cloudflare Email Service binding helper for `send_email` bindings, with limit validation and typed error codes
@@ -63,12 +73,12 @@ Runtime creation belongs at Cloudflare entrypoints, not inside binding helpers.
 - `Rpc` - Cloudflare RPC type helpers and scoped disposal utilities
 - `WebTransport` - truthful WebTransport/HTTP-3 boundary: typed runtime capabilities and decoded inbound protocol metadata
 - `WorkerConfig` - Effect `Config` helpers backed by Cloudflare `env`
-- `effect-cf/vitest` - Effect-native runners and scoped test helpers for Cloudflare's Vitest Workers pool
+- `effect-cf/vitest` - Effect-native runners and scoped test helpers for Cloudflare's Workers Vitest plugin
 
-## Vitest Workers Pool
+## Vitest Workers Plugin
 
-Install and configure a `^0.21.3` release of
-[`@cloudflare/vitest-pool-workers`](https://github.com/cloudflare/workers-sdk/tree/main/packages/vitest-pool-workers#readme),
+Install and configure a `^1.0.0` release of
+[`@cloudflare/vitest-plugin`](https://github.com/cloudflare/workers-sdk/tree/main/packages/vitest-plugin#readme),
 then import the test-only helpers from `effect-cf/vitest`. The `fetch` runner
 constructs the Worker with the current test environment and waits for all
 `waitUntil` work before completing the Effect.
@@ -100,7 +110,7 @@ it.effect("reads Wrangler vars", () =>
 ```
 
 Queue consumers can be invoked with typed message bodies while retaining the
-pool's acknowledgement and retry result:
+plugin's acknowledgement and retry result:
 
 ```ts
 it.effect("acknowledges a job", () =>
@@ -121,7 +131,7 @@ it.effect("acknowledges a job", () =>
 
 Scheduled handlers and Pages Functions use the same lifecycle behavior: their
 Effects complete only after the event's `waitUntil` work has settled. Pages
-tests must configure the `ASSETS` binding required by Pool Workers.
+tests must configure the `ASSETS` binding required by the Workers Vitest plugin.
 
 ```ts
 it.effect("runs the cron handler", () =>
@@ -322,6 +332,75 @@ const stub = Sandboxes.byName("codex").rawUnsafe;
 See [`examples/containers/README.md`](../../examples/containers/README.md) for
 the corresponding Wrangler configuration and entrypoint responsibilities.
 
+## Sandbox Example
+
+`effect-cf/sandbox` wraps the [Cloudflare Sandbox SDK](https://github.com/cloudflare/sandbox-sdk)
+1.0 API (`@cloudflare/sandbox@next`). The Sandbox Durable Object class remains
+owned by `@cloudflare/sandbox`; `effect-cf` wraps the namespace binding used by
+a calling Worker and loads the SDK lazily, so applications without the optional
+peer are unaffected.
+
+```ts
+import { Effect, Option } from "effect";
+import { Worker } from "effect-cf";
+import * as Sandbox from "effect-cf/sandbox";
+
+export { Sandbox as SandboxDurableObject } from "@cloudflare/sandbox";
+
+class Sandboxes extends Sandbox.Tag<Sandboxes>()("Sandboxes") {}
+
+const SandboxesLive = Sandboxes.layer({ binding: "Sandbox" });
+
+export default Worker.make(SandboxesLive, {
+  fetch: Effect.gen(function* () {
+    const request = yield* Worker.NativeRequest;
+
+    // Route preview-URL traffic before any other routing.
+    const proxied = yield* Sandbox.proxyToSandbox(request);
+    if (Option.isSome(proxied)) {
+      return proxied.value;
+    }
+
+    const sandbox = yield* Sandboxes.get("my-sandbox");
+    const handle = yield* sandbox.exec(["python3", "-c", "print(2 + 2)"]);
+    const output = yield* handle.outputText();
+
+    return new Response(output.stdout);
+  }),
+});
+```
+
+The instance client mirrors the complete `ISandbox` client contract plus the
+lifecycle, port, tunnel, and backup operations the SDK client proxies to the
+Sandbox Durable Object. `exec` returns a process handle whose `logs` is an
+Effect `Stream` of typed log events; `watch` decodes the SDK's Server-Sent
+Events into a `Stream` of file-watch events; `readFileStream` streams raw
+bytes. Interruptible waits (`waitForExit`, `waitForLog`, `output`,
+`waitForPort`) abort the underlying SDK call when the Effect is interrupted.
+Failures carry a typed `SandboxOperationError` whose `cause` preserves the
+SDK's rich error classes (`ProcessNotFoundError`, `PortNotExposedError`, and
+friends) for inspection.
+
+The corresponding `wrangler.jsonc` declares the container image and Durable
+Object binding; note the SDK requires the exported Durable Object class to be
+reachable under the configured `class_name`:
+
+```jsonc
+{
+  "containers": [
+    {
+      "class_name": "SandboxDurableObject",
+      "image": "./Dockerfile",
+      "instance_type": "lite",
+    },
+  ],
+  "durable_objects": {
+    "bindings": [{ "class_name": "SandboxDurableObject", "name": "Sandbox" }],
+  },
+  "migrations": [{ "tag": "v1", "new_sqlite_classes": ["SandboxDurableObject"] }],
+}
+```
+
 ## Queue Example
 
 Queues define the message contract once. The same class is the producer service tag and the consumer Worker definition: use `YourQueue.layer({ binding })` to provide a Cloudflare producer binding from `WorkerEnvironment`, and use `.make(...)` for the consumer Worker entrypoint.
@@ -641,10 +720,26 @@ export const resizeAvatar = (image: Images.ImageInputValue) =>
       },
     );
 
-    return yield* result.response;
+    return yield* result.response();
   });
 ```
 
+## Cloudflare runtime pin
+
+`effect-cf` develops and tests against a fixed Cloudflare Workers runtime stack. Keep consumer
+`compatibility_date` and optional `@cloudflare/workers-types` peers at or above this pin:
+
+| Pin                                         | Version        |
+| ------------------------------------------- | -------------- |
+| workerd                                     | `1.20260820.1` |
+| `@cloudflare/workers-types` (optional peer) | `5.20260820.1` |
+| wrangler (repo catalog / examples)          | `4.125.0`      |
+| Recommended `compatibility_date`            | `2026-08-20`   |
+
+The date in the `workerd` / `@cloudflare/workers-types` version is the API surface this package wraps.
+Repo catalog pins live in the root `package.json` `catalog` field (`@cloudflare/workers-types`, `wrangler`).
+`wrangler@4.125.0` pulls `workerd@1.20260820.1` and peers `@cloudflare/workers-types@^5.20260820.1`.
+
 ## Email Example
 
 Email tags expose Cloudflare Email Service `send_email` bindings as Effect-wrapped `send(...)` operations. Structured messages are validated against documented Email Sending limits before reaching the binding, and Cloudflare's `E_*` error codes are surfaced on `EmailOperationError.code`.

package/dist/{Artifacts-rq3hUKQE.mjs → Artifacts-CSIk1Oml.mjs}

@@ -1,131 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { a as WorkerEnvironment, t as causeMessage } from "./ErrorMessage-BM0K-Nik.mjs";
-import { Context, Data, Effect, Layer, Predicate, Schema } from "effect";
-//#region src/Binding.ts
-var Binding_exports = /* @__PURE__ */ __exportAll({
-	BindingNotFoundError: () => BindingNotFoundError,
-	BindingValidationError: () => BindingValidationError,
-	Service: () => Service,
-	TypeId: () => TypeId,
-	layer: () => layer$1
-});
-/** Internal type id marker used by binding helper services. */
-const TypeId = "~effect-cf/Binding";
-/** Error raised when a configured binding does not exist on `env`. */
-var BindingNotFoundError = class extends Data.TaggedError("BindingNotFoundError") {};
-/** Error raised when a binding exists but does not match the expected shape. */
-var BindingValidationError = class extends Data.TaggedError("BindingValidationError") {};
-const defaultExpected = "Cloudflare binding resource";
-const isPropertyTarget = (value) => Predicate.isObjectOrArray(value) || Predicate.isFunction(value);
-const getObjectName = (value) => {
-	const tag = (() => {
-		try {
-			return Object.prototype.toString.call(value).slice(8, -1);
-		} catch {
-			return Predicate.isFunction(value) ? "function" : "object";
-		}
-	})();
-	const constructorName = (() => {
-		try {
-			return "constructor" in value && Predicate.isFunction(value.constructor) && Predicate.isString(value.constructor.name) ? value.constructor.name : void 0;
-		} catch {
-			return;
-		}
-	})();
-	if (tag !== "Object") return tag;
-	if (constructorName !== void 0 && constructorName !== "" && constructorName !== "Object") return constructorName;
-	return tag;
-};
-const propertyNames = (value) => {
-	const names = /* @__PURE__ */ new Set();
-	for (const target of [value, Object.getPrototypeOf(value)]) {
-		if (target === null || target === Object.prototype || target === Function.prototype) continue;
-		try {
-			for (const name of Object.getOwnPropertyNames(target)) names.add(name);
-		} catch {
-			continue;
-		}
-	}
-	return [...names].filter((name) => name !== "constructor").sort();
-};
-const isMethod = (value, name) => {
-	try {
-		return Predicate.hasProperty(value, name) && Predicate.isFunction(value[name]);
-	} catch {
-		return false;
-	}
-};
-const describeActual = (value) => {
-	if (value === null) return "null";
-	if (!isPropertyTarget(value)) {
-		if (Predicate.isString(value)) return "string";
-		if (Predicate.isNumber(value)) return "number";
-		if (Predicate.isBoolean(value)) return "boolean";
-		if (Predicate.isBigInt(value)) return "bigint";
-		if (Predicate.isSymbol(value)) return "symbol";
-		return "undefined";
-	}
-	const names = propertyNames(value);
-	const methods = names.filter((name) => isMethod(value, name));
-	const properties = names.filter((name) => !methods.includes(name));
-	const details = [methods.length > 0 ? `methods ${methods.join(", ")}` : void 0, properties.length > 0 ? `properties ${properties.join(", ")}` : void 0].filter((detail) => detail !== void 0);
-	if (details.length === 0) return getObjectName(value);
-	return `${getObjectName(value)} with ${details.join("; ")}`;
-};
-const getBinding = (env, binding, isResource, options) => Effect.gen(function* () {
-	if (!isPropertyTarget(env)) {
-		const actual = describeActual(env);
-		return yield* Effect.fail(new BindingValidationError({
-			binding,
-			expected: "WorkerEnvironment object",
-			actual,
-			message: `Cloudflare binding "${binding}" failed validation. Expected WorkerEnvironment object; got ${actual}`
-		}));
-	}
-	const resource = Predicate.hasProperty(env, binding) ? env[binding] : void 0;
-	if (resource === void 0) return yield* Effect.fail(new BindingNotFoundError({
-		binding,
-		message: `Cloudflare binding "${binding}" was not found in WorkerEnvironment`
-	}));
-	if (!isResource(resource)) {
-		const expected = options?.expected ?? defaultExpected;
-		const actual = describeActual(resource);
-		return yield* Effect.fail(new BindingValidationError({
-			binding,
-			expected,
-			actual,
-			message: `Cloudflare binding "${binding}" failed validation. Expected ${expected}; got ${actual}`
-		}));
-	}
-	return resource;
-});
-/**
-* The overloads on {@link layer} and {@link Service} guarantee that
-* `Service = Resource` whenever `wrap` is absent, making the fallback cast
-* safe.
-*/
-const makeBindingLayer = (tag, binding, isResource, wrap, options) => Layer.effect(tag, Effect.gen(function* () {
-	const env = yield* WorkerEnvironment;
-	const resource = yield* getBinding(env, binding, isResource, options);
-	return wrap === void 0 ? resource : wrap(resource);
-}));
-function layer$1(tag, binding, isResource, wrap, options) {
-	return makeBindingLayer(tag, binding, isResource, wrap, options);
-}
-const Service = () => {
-	function makeService(id, binding, isResource, wrap, options) {
-		const tag = Context.Service()(`effect-cf/Binding/${id}`);
-		const serviceLayer = makeBindingLayer(tag, binding, isResource, wrap, options);
-		return Object.assign(tag, {
-			[TypeId]: TypeId,
-			id,
-			binding,
-			layer: serviceLayer
-		});
-	}
-	return makeService;
-};
-//#endregion
+import { t as causeMessage } from "./ErrorMessage-BM0K-Nik.mjs";
+import { r as layer$1 } from "./Binding-pfilNJmP.mjs";
+import { Context, Data, Effect, Predicate, Schema } from "effect";
 //#region src/Artifacts.ts
 var Artifacts_exports = /* @__PURE__ */ __exportAll({
 	ArtifactsOperationError: () => ArtifactsOperationError,
@@ -254,4 +130,4 @@ const Tag = () => (id) => {
 	});
 };
 //#endregion
-export { layer$1 as a, Service as i, Artifacts_exports as n, Binding_exports as r, ArtifactsOperationError as t };
+export { Artifacts_exports as n, ArtifactsOperationError as t };

package/dist/Binding-pfilNJmP.mjs

@@ -0,0 +1,129 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { a as WorkerEnvironment } from "./ErrorMessage-BM0K-Nik.mjs";
+import { Context, Data, Effect, Layer, Predicate } from "effect";
+//#region src/Binding.ts
+var Binding_exports = /* @__PURE__ */ __exportAll({
+	BindingNotFoundError: () => BindingNotFoundError,
+	BindingValidationError: () => BindingValidationError,
+	Service: () => Service,
+	TypeId: () => TypeId,
+	layer: () => layer
+});
+/** Internal type id marker used by binding helper services. */
+const TypeId = "~effect-cf/Binding";
+/** Error raised when a configured binding does not exist on `env`. */
+var BindingNotFoundError = class extends Data.TaggedError("BindingNotFoundError") {};
+/** Error raised when a binding exists but does not match the expected shape. */
+var BindingValidationError = class extends Data.TaggedError("BindingValidationError") {};
+const defaultExpected = "Cloudflare binding resource";
+const isPropertyTarget = (value) => Predicate.isObjectOrArray(value) || Predicate.isFunction(value);
+const getObjectName = (value) => {
+	const tag = (() => {
+		try {
+			return Object.prototype.toString.call(value).slice(8, -1);
+		} catch {
+			return Predicate.isFunction(value) ? "function" : "object";
+		}
+	})();
+	const constructorName = (() => {
+		try {
+			return "constructor" in value && Predicate.isFunction(value.constructor) && Predicate.isString(value.constructor.name) ? value.constructor.name : void 0;
+		} catch {
+			return;
+		}
+	})();
+	if (tag !== "Object") return tag;
+	if (constructorName !== void 0 && constructorName !== "" && constructorName !== "Object") return constructorName;
+	return tag;
+};
+const propertyNames = (value) => {
+	const names = /* @__PURE__ */ new Set();
+	for (const target of [value, Object.getPrototypeOf(value)]) {
+		if (target === null || target === Object.prototype || target === Function.prototype) continue;
+		try {
+			for (const name of Object.getOwnPropertyNames(target)) names.add(name);
+		} catch {
+			continue;
+		}
+	}
+	return [...names].filter((name) => name !== "constructor").sort();
+};
+const isMethod = (value, name) => {
+	try {
+		return Predicate.hasProperty(value, name) && Predicate.isFunction(value[name]);
+	} catch {
+		return false;
+	}
+};
+const describeActual = (value) => {
+	if (value === null) return "null";
+	if (!isPropertyTarget(value)) {
+		if (Predicate.isString(value)) return "string";
+		if (Predicate.isNumber(value)) return "number";
+		if (Predicate.isBoolean(value)) return "boolean";
+		if (Predicate.isBigInt(value)) return "bigint";
+		if (Predicate.isSymbol(value)) return "symbol";
+		return "undefined";
+	}
+	const names = propertyNames(value);
+	const methods = names.filter((name) => isMethod(value, name));
+	const properties = names.filter((name) => !methods.includes(name));
+	const details = [methods.length > 0 ? `methods ${methods.join(", ")}` : void 0, properties.length > 0 ? `properties ${properties.join(", ")}` : void 0].filter((detail) => detail !== void 0);
+	if (details.length === 0) return getObjectName(value);
+	return `${getObjectName(value)} with ${details.join("; ")}`;
+};
+const getBinding = (env, binding, isResource, options) => Effect.gen(function* () {
+	if (!isPropertyTarget(env)) {
+		const actual = describeActual(env);
+		return yield* Effect.fail(new BindingValidationError({
+			binding,
+			expected: "WorkerEnvironment object",
+			actual,
+			message: `Cloudflare binding "${binding}" failed validation. Expected WorkerEnvironment object; got ${actual}`
+		}));
+	}
+	const resource = Predicate.hasProperty(env, binding) ? env[binding] : void 0;
+	if (resource === void 0) return yield* Effect.fail(new BindingNotFoundError({
+		binding,
+		message: `Cloudflare binding "${binding}" was not found in WorkerEnvironment`
+	}));
+	if (!isResource(resource)) {
+		const expected = options?.expected ?? defaultExpected;
+		const actual = describeActual(resource);
+		return yield* Effect.fail(new BindingValidationError({
+			binding,
+			expected,
+			actual,
+			message: `Cloudflare binding "${binding}" failed validation. Expected ${expected}; got ${actual}`
+		}));
+	}
+	return resource;
+});
+/**
+* The overloads on {@link layer} and {@link Service} guarantee that
+* `Service = Resource` whenever `wrap` is absent, making the fallback cast
+* safe.
+*/
+const makeBindingLayer = (tag, binding, isResource, wrap, options) => Layer.effect(tag, Effect.gen(function* () {
+	const env = yield* WorkerEnvironment;
+	const resource = yield* getBinding(env, binding, isResource, options);
+	return wrap === void 0 ? resource : wrap(resource);
+}));
+function layer(tag, binding, isResource, wrap, options) {
+	return makeBindingLayer(tag, binding, isResource, wrap, options);
+}
+const Service = () => {
+	function makeService(id, binding, isResource, wrap, options) {
+		const tag = Context.Service()(`effect-cf/Binding/${id}`);
+		const serviceLayer = makeBindingLayer(tag, binding, isResource, wrap, options);
+		return Object.assign(tag, {
+			[TypeId]: TypeId,
+			id,
+			binding,
+			layer: serviceLayer
+		});
+	}
+	return makeService;
+};
+//#endregion
+export { Service as n, layer as r, Binding_exports as t };

package/dist/ComputerArtifacts.mjs

@@ -1,4 +1,4 @@
-import { t as ArtifactsOperationError } from "./Artifacts-rq3hUKQE.mjs";
+import { t as ArtifactsOperationError } from "./Artifacts-CSIk1Oml.mjs";
 import { Effect, Predicate } from "effect";
 //#region src/ComputerArtifacts.ts
 const artifactsErrorDetails = (cause) => {

package/dist/ComputerWorkspace.d.mts

@@ -1,5 +1,5 @@
 import { ComputerArtifactsClient } from "./ComputerArtifacts.mjs";
-import { t as DurableObjectState } from "./DurableObjectState-OupNMMUl.mjs";
+import { t as DurableObjectState } from "./DurableObjectState-DVIgf0sA.mjs";
 import { Context, Effect, Layer, Schema, Scope, Stream } from "effect";
 import { CommitView, GitClient, GitCloneOptions, GitCommitOptions, GitDiffOptions, GitFetchOptions, GitLogOptions, GitUpdateRefOptions } from "@cloudflare/computer/git";
 import { ExecSyncResult, RuntimeExecOptions, RuntimeGetOptions, RuntimeKillOptions, ShellValue, SkippedEntry, ThinkWorkspaceCompatibility, WorkspaceClient, WorkspaceRuntimeResult, WorkspaceRuntimeValue as WorkspaceRuntimeValue$1 } from "@cloudflare/computer";

package/dist/ComputerWorkspace.mjs

@@ -1,4 +1,4 @@
-import { t as DurableObjectState } from "./DurableObjectState-DnnLoHV-.mjs";
+import { t as DurableObjectState } from "./DurableObjectState-CxS5Y2hf.mjs";
 import { fromClient } from "./ComputerArtifacts.mjs";
 import { t as lookup } from "./ComputerWorkspaceHostRegistry-CY5Fv4Ng.mjs";
 import { Context, Effect, Layer, Predicate, Schema, Stream } from "effect";

package/dist/ContainerNamespace-CFjiLw8b.d.mts

@@ -0,0 +1,155 @@
+import { c as WorkerEnvironment, r as BindingValidationError, t as BindingNotFoundError } from "./Binding-xJJJPmiD.mjs";
+import { Context, Effect, Layer, Schema } from "effect";
+declare namespace ContainerNamespace_d_exports {
+  export { ContainerInstanceClient, ContainerNamespace, ContainerNamespaceClient, ContainerNamespaceDefinition, ContainerNamespaceResource, ContainerNamespaceService, ContainerNamespaceStaticClient, ContainerOperationError, ContainerReadinessOptions, ContainerSignal, ContainerStartAndWaitForPortsOptions, ContainerStartOptions, ContainerState, ContainerStopSignal, ContainerStub, ContainerStubOf, ContainerWaitOptions, LayerOptions, Tag, TagClass, isContainerNamespaceResource, layer, make, makeClient };
+}
+/** Named signal accepted by Cloudflare Container instances. */
+type ContainerSignal = "SIGKILL" | "SIGINT" | "SIGTERM";
+/** Named or numeric signal accepted by Container `stop()`. */
+type ContainerStopSignal = ContainerSignal | number;
+/** Per-instance Container startup configuration. */
+interface ContainerStartOptions {
+  readonly envVars?: Record<string, string>;
+  readonly entrypoint?: Array<string>;
+  readonly enableInternet?: boolean;
+  readonly labels?: Record<string, string>;
+}
+/** Serializable retry settings used while starting a Container. */
+interface ContainerWaitOptions {
+  readonly portToCheck: number;
+  readonly retries?: number;
+  readonly waitInterval?: number;
+}
+/** Serializable timeout settings used while waiting for Container ports. */
+interface ContainerReadinessOptions {
+  readonly instanceGetTimeoutMS?: number;
+  readonly portReadyTimeoutMS?: number;
+  readonly waitInterval?: number;
+}
+/** Options for starting a Container and waiting for its ports. */
+interface ContainerStartAndWaitForPortsOptions {
+  readonly startOptions?: ContainerStartOptions;
+  readonly ports?: number | Array<number>;
+  readonly cancellationOptions?: ContainerReadinessOptions;
+}
+/** Serializable state reported by a Cloudflare Container instance. */
+declare const ContainerState: Schema.Union<readonly [Schema.Struct<{
+  readonly lastChange: Schema.Finite;
+  readonly status: Schema.Literals<readonly ["running", "stopping", "stopped", "healthy"]>;
+}>, Schema.Struct<{
+  readonly lastChange: Schema.Finite;
+  readonly status: Schema.Literal<"stopped_with_code">;
+  readonly exitCode: Schema.optionalKey<Schema.Int>;
+}>]>;
+type ContainerState = typeof ContainerState.Type;
+/**
+ * Native Container stub shape exposed by a Container namespace binding.
+ *
+ * This is structural so using Container bindings does not make
+ * `@cloudflare/containers` a runtime dependency of effect-cf.
+ */
+interface ContainerStub {
+  fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+  getState(): Promise<ContainerState>;
+  start(options?: ContainerStartOptions, waitOptions?: ContainerWaitOptions): Promise<void>;
+  startAndWaitForPorts(options?: ContainerStartAndWaitForPortsOptions): Promise<void>;
+  waitForPort(options: ContainerWaitOptions): Promise<number>;
+  stop(signal?: ContainerStopSignal): Promise<void>;
+  destroy(): Promise<void>;
+  setAllowedHosts(hosts: Array<string>): Promise<void>;
+  setDeniedHosts(hosts: Array<string>): Promise<void>;
+  allowHost(hostname: string): Promise<void>;
+  denyHost(hostname: string): Promise<void>;
+  removeAllowedHost(hostname: string): Promise<void>;
+  removeDeniedHost(hostname: string): Promise<void>;
+}
+/** Native Container namespace binding shape. */
+interface ContainerNamespaceResource {
+  getByName(name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions): ContainerStub;
+}
+/** Exact native stub type produced by a Container namespace binding. */
+type ContainerStubOf<Namespace extends ContainerNamespaceResource> = ReturnType<Namespace["getByName"]>;
+/** Container namespace binding metadata. */
+interface ContainerNamespaceDefinition {
+  /** Binding name as configured in `wrangler.jsonc`. */
+  readonly binding: string;
+}
+declare const ContainerOperationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "ContainerOperationError";
+} & Readonly<A>;
+/** Failure raised when invoking a named Container operation. */
+declare class ContainerOperationError extends ContainerOperationError_base<{
+  readonly binding: string;
+  readonly instance: string;
+  readonly operation: string;
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
+/** Effect-wrapped client for one named Container instance. */
+interface ContainerInstanceClient<Stub extends ContainerStub = ContainerStub> {
+  readonly rawUnsafe: Effect.Effect<Stub, ContainerOperationError>;
+  readonly state: Effect.Effect<ContainerState, ContainerOperationError>;
+  readonly fetch: (input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<Response, ContainerOperationError>;
+  readonly start: (options?: ContainerStartOptions, waitOptions?: ContainerWaitOptions) => Effect.Effect<void, ContainerOperationError>;
+  readonly startAndWaitForPorts: (options?: ContainerStartAndWaitForPortsOptions) => Effect.Effect<void, ContainerOperationError>;
+  readonly waitForPort: (options: ContainerWaitOptions) => Effect.Effect<number, ContainerOperationError>;
+  readonly stop: (signal?: ContainerStopSignal) => Effect.Effect<void, ContainerOperationError>;
+  readonly destroy: Effect.Effect<void, ContainerOperationError>;
+  readonly setAllowedHosts: (hosts: ReadonlyArray<string>) => Effect.Effect<void, ContainerOperationError>;
+  readonly setDeniedHosts: (hosts: ReadonlyArray<string>) => Effect.Effect<void, ContainerOperationError>;
+  readonly allowHost: (hostname: string) => Effect.Effect<void, ContainerOperationError>;
+  readonly denyHost: (hostname: string) => Effect.Effect<void, ContainerOperationError>;
+  readonly removeAllowedHost: (hostname: string) => Effect.Effect<void, ContainerOperationError>;
+  readonly removeDeniedHost: (hostname: string) => Effect.Effect<void, ContainerOperationError>;
+}
+/** Effect client for a Container namespace binding. */
+interface ContainerNamespaceClient<Namespace extends ContainerNamespaceResource = ContainerNamespaceResource> {
+  readonly definition: ContainerNamespaceDefinition;
+  readonly getByName: (name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => Effect.Effect<ContainerInstanceClient<ContainerStubOf<Namespace>>, ContainerOperationError>;
+  readonly byName: (name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => ContainerInstanceClient<ContainerStubOf<Namespace>>;
+  readonly rawUnsafe: Effect.Effect<Namespace>;
+}
+type ContainerNamespaceStaticClient<R, Namespace extends ContainerNamespaceResource = ContainerNamespaceResource> = {
+  readonly getByName: (name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => Effect.Effect<ContainerInstanceClient<ContainerStubOf<Namespace>>, ContainerOperationError, R>;
+  readonly byName: (name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => {
+    readonly state: Effect.Effect<ContainerState, ContainerOperationError, R>;
+    readonly fetch: (input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<Response, ContainerOperationError, R>;
+    readonly start: (options?: ContainerStartOptions, waitOptions?: ContainerWaitOptions) => Effect.Effect<void, ContainerOperationError, R>;
+    readonly startAndWaitForPorts: (options?: ContainerStartAndWaitForPortsOptions) => Effect.Effect<void, ContainerOperationError, R>;
+    readonly waitForPort: (options: ContainerWaitOptions) => Effect.Effect<number, ContainerOperationError, R>;
+    readonly stop: (signal?: ContainerStopSignal) => Effect.Effect<void, ContainerOperationError, R>;
+    readonly destroy: Effect.Effect<void, ContainerOperationError, R>;
+    readonly setAllowedHosts: (hosts: ReadonlyArray<string>) => Effect.Effect<void, ContainerOperationError, R>;
+    readonly setDeniedHosts: (hosts: ReadonlyArray<string>) => Effect.Effect<void, ContainerOperationError, R>;
+    readonly allowHost: (hostname: string) => Effect.Effect<void, ContainerOperationError, R>;
+    readonly denyHost: (hostname: string) => Effect.Effect<void, ContainerOperationError, R>;
+    readonly removeAllowedHost: (hostname: string) => Effect.Effect<void, ContainerOperationError, R>;
+    readonly removeDeniedHost: (hostname: string) => Effect.Effect<void, ContainerOperationError, R>;
+    readonly rawUnsafe: Effect.Effect<ContainerStubOf<Namespace>, ContainerOperationError, R>;
+  };
+  readonly rawUnsafe: Effect.Effect<Namespace, never, R>;
+};
+type LayerOptions = {
+  readonly binding: string;
+};
+interface TagClass<Self, Id extends string, Namespace extends ContainerNamespaceResource = ContainerNamespaceResource> extends Context.ServiceClass<Self, `effect-cf/Container/${Id}`, ContainerNamespaceClient<Namespace>>, ContainerNamespaceStaticClient<Self, Namespace> {
+  readonly id: Id;
+  readonly layer: (options: LayerOptions) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+}
+declare const isContainerNamespaceResource: <Candidate>(value: Candidate) => value is Candidate & ContainerNamespaceResource;
+declare const makeClient: (definition: ContainerNamespaceDefinition) => <Namespace extends ContainerNamespaceResource>(namespace: Namespace) => ContainerNamespaceClient<Namespace>;
+declare const layer: <Self, Namespace extends ContainerNamespaceResource>(tag: Context.Service<Self, ContainerNamespaceClient<Namespace>>, definition: ContainerNamespaceDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const make: <Id extends string>(id: Id) => TagClass<ContainerNamespaceService<Id>, Id, ContainerNamespaceResource>;
+declare const ContainerNamespaceServiceTypeId: unique symbol;
+/** Nominal service marker for Container namespaces created with {@link make}. */
+interface ContainerNamespaceService<Id extends string> {
+  readonly [ContainerNamespaceServiceTypeId]: {
+    readonly id: Id;
+  };
+}
+/** Creates a typed Effect service for a Cloudflare Container namespace. */
+declare const Tag: <Self, Namespace extends ContainerNamespaceResource = ContainerNamespaceResource>() => <Id extends string>(id: Id) => TagClass<Self, Id, Namespace>;
+declare const ContainerNamespace: typeof Tag;
+//#endregion
+export { ContainerStartOptions as n, ContainerStopSignal as r, ContainerNamespace_d_exports as t };