effect-cf 0.29.0 → 0.30.0

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # effect-cf
 
+## 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

@@ -33,6 +33,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 +62,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
@@ -322,6 +331,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.

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-D3k-WRnd.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-CepagPkX.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 };

package/dist/{DurableObjectState-DnnLoHV-.mjs → DurableObjectState-CepagPkX.mjs}

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
 import { t as causeMessage } from "./ErrorMessage-BM0K-Nik.mjs";
-import { Cause, Context, Data, Effect, Exit, Option, Predicate, Result, Schema } from "effect";
+import { Cause, Clock, Context, Data, Duration, Effect, Exit, Option, Predicate, Result, Schema } from "effect";
 //#region src/DurableObjectStorage.ts
 var DurableObjectStorage_exports = /* @__PURE__ */ __exportAll({
 	StorageOperationError: () => StorageOperationError,
@@ -24,6 +24,11 @@ const tryStoragePromise = (operation, evaluate) => Effect.tryPromise({
 	try: evaluate,
 	catch: (cause) => storageError(operation, cause)
 });
+const setAlarmAfter = Effect.fn("DurableObjectStorage.setAlarmAfter")(function* (operation, setAlarm, delay, options) {
+	const now = yield* Clock.currentTimeMillis;
+	const delayMillis = Math.ceil(Duration.toMillis(delay));
+	yield* tryStoragePromise(operation, () => setAlarm(now + delayMillis, options));
+});
 const fromSqlCursor = (cursor) => ({
 	next: () => tryStorageSync("sql.next", () => cursor.next()),
 	toArray: () => tryStorageSync("sql.toArray", () => cursor.toArray()),
@@ -85,6 +90,7 @@ const fromDurableObjectTransaction = (txn) => ({
 	rollback: () => tryStorageSync("transaction.rollback", () => txn.rollback()),
 	getAlarm: (options) => tryStoragePromise("transaction.getAlarm", () => txn.getAlarm(options)),
 	setAlarm: (scheduledTime, options) => tryStoragePromise("transaction.setAlarm", () => txn.setAlarm(scheduledTime, options)),
+	setAlarmAfter: (delay, options) => setAlarmAfter("transaction.setAlarm", (scheduledTime, options) => txn.setAlarm(scheduledTime, options), delay, options),
 	deleteAlarm: (options) => tryStoragePromise("transaction.deleteAlarm", () => txn.deleteAlarm(options))
 });
 /**
@@ -97,6 +103,7 @@ const fromDurableObjectStorage = (storage) => ({
 	deleteAll: (options) => tryStoragePromise("deleteAll", () => storage.deleteAll(options)),
 	getAlarm: (options) => tryStoragePromise("getAlarm", () => storage.getAlarm(options)),
 	setAlarm: (scheduledTime, options) => tryStoragePromise("setAlarm", () => storage.setAlarm(scheduledTime, options)),
+	setAlarmAfter: (delay, options) => setAlarmAfter("setAlarm", (scheduledTime, options) => storage.setAlarm(scheduledTime, options), delay, options),
 	deleteAlarm: (options) => tryStoragePromise("deleteAlarm", () => storage.deleteAlarm(options)),
 	transactionSync: (closure) => Effect.context().pipe(Effect.flatMap((context) => Effect.suspend(() => {
 		let aborted;

package/dist/{DurableObjectState-OupNMMUl.d.mts → DurableObjectState-D3k-WRnd.d.mts}

@@ -1,5 +1,5 @@
 import { c as WorkerEnvironment, n as BindingService, r as BindingValidationError, s as WorkerEnv, t as BindingNotFoundError } from "./Binding-xJJJPmiD.mjs";
-import { Cause, Context, Effect, Layer, Option, Predicate, Schema, Scope } from "effect";
+import { Cause, Context, Duration, Effect, Layer, Option, Predicate, Schema, Scope } from "effect";
 import { HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
 import { RpcStub, RpcTarget, WorkerEntrypoint } from "cloudflare:workers";
 declare namespace DurableObjectStorage_d_exports {
@@ -84,6 +84,8 @@ interface DurableObjectTransaction {
   rollback(): StorageEffect<void>;
   getAlarm(options?: globalThis.DurableObjectGetAlarmOptions): StorageEffect<number | null>;
   setAlarm(scheduledTime: number | Date, options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
+  /** Schedules the alarm after a delay measured by the Effect clock. */
+  setAlarmAfter(delay: Duration.Input, options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
   deleteAlarm(options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
 }
 /**
@@ -110,6 +112,8 @@ interface DurableObjectStorage {
   deleteAll(options?: globalThis.DurableObjectPutOptions): StorageEffect<void>;
   getAlarm(options?: globalThis.DurableObjectGetAlarmOptions): StorageEffect<number | null>;
   setAlarm(scheduledTime: number | Date, options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
+  /** Schedules the alarm after a delay measured by the Effect clock. */
+  setAlarmAfter(delay: Duration.Input, options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
   deleteAlarm(options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
   /**
    * SQLite-backed Durable Object storage only.