effect-cf 0.49.0 → 0.51.0

package/dist/DurableObjectContainer.mjs

@@ -0,0 +1,179 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { causeMessage } from "./internal/ErrorMessage.mjs";
+import { DurableObjectState } from "./DurableObjectState.mjs";
+import * as Context from "effect/Context";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Stream from "effect/Stream";
+import * as Duration from "effect/Duration";
+//#region src/DurableObjectContainer.ts
+var DurableObjectContainer_exports = /* @__PURE__ */ __exportAll({
+	ContainerError: () => ContainerError,
+	ContainerNotConfiguredError: () => ContainerNotConfiguredError,
+	ContainerReadinessTimeoutError: () => ContainerReadinessTimeoutError,
+	DurableObjectContainer: () => DurableObjectContainer,
+	fromContainer: () => fromContainer,
+	layer: () => layer
+});
+var ContainerNotConfiguredError = class extends Data.TaggedError("ContainerNotConfiguredError") {
+	get message() {
+		return `No container is configured for Durable Object "${this.durableObjectId}"`;
+	}
+};
+var ContainerError = class extends Data.TaggedError("ContainerError") {
+	get message() {
+		return `Durable Object container ${this.operation} failed: ${causeMessage(this.cause)}`;
+	}
+};
+var ContainerReadinessTimeoutError = class extends Data.TaggedError("ContainerReadinessTimeoutError") {
+	get message() {
+		return `Container port ${this.port} was not ready within ${Duration.toMillis(this.timeout)}ms`;
+	}
+};
+var DurableObjectContainer = class extends Context.Service()("effect-cf/DurableObjectContainer") {};
+const attempt = (operation, evaluate) => Effect.try({
+	try: evaluate,
+	catch: (cause) => new ContainerError({
+		operation,
+		cause
+	})
+});
+const attemptPromise = (operation, evaluate) => Effect.tryPromise({
+	try: evaluate,
+	catch: (cause) => new ContainerError({
+		operation,
+		cause
+	})
+});
+const processStream = (stream, operation) => stream === null || stream === void 0 ? Stream.empty : Stream.fromReadableStream({
+	evaluate: () => stream,
+	onError: (cause) => new ContainerError({
+		operation,
+		cause
+	})
+});
+const fromProcess = (process) => {
+	let exited = false;
+	const onExit = () => {
+		exited = true;
+	};
+	process.exitCode.then(onExit, onExit);
+	const stdout = processStream(process.stdout, "exec.stdout");
+	const stderr = processStream(process.stderr, "exec.stderr");
+	const output = attemptPromise("exec.output", () => process.output());
+	return {
+		raw: process,
+		pid: process.pid,
+		isPty: process.isPty,
+		stdin: process.stdin ?? null,
+		stdout,
+		stderr,
+		logs: Stream.merge(Stream.map(stdout, (data) => ({
+			stream: "stdout",
+			data
+		})), Stream.map(stderr, (data) => ({
+			stream: "stderr",
+			data
+		}))),
+		exitCode: attemptPromise("exec.exitCode", () => process.exitCode),
+		output,
+		outputText: Effect.map(output, (result) => ({
+			stdout: new TextDecoder().decode(result.stdout),
+			stderr: new TextDecoder().decode(result.stderr),
+			exitCode: result.exitCode
+		})),
+		kill: (signal) => attemptPromise("exec.kill", async () => {
+			await Promise.resolve();
+			if (!exited) process.kill(signal);
+		}),
+		resize: (cols, rows) => attempt("exec.resize", () => process.resize(cols, rows))
+	};
+};
+const fromTcpPort = (port) => {
+	const fetch = (input, init) => attemptPromise("getTcpPort.fetch", (signal) => {
+		const callerSignal = init?.signal !== void 0 ? init.signal : input instanceof Request ? input.signal : void 0;
+		return port.fetch(input, {
+			...init,
+			signal: callerSignal === null || callerSignal === void 0 ? signal : AbortSignal.any([callerSignal, signal])
+		});
+	});
+	return {
+		raw: port,
+		fetch,
+		proxy: (request) => attempt("getTcpPort.proxy", () => {
+			const url = new URL(request.url);
+			url.protocol = "http:";
+			return new Request(url, request);
+		}).pipe(Effect.flatMap((forwarded) => fetch(forwarded))),
+		connect: (...args) => attempt("getTcpPort.connect", () => port.connect(...args))
+	};
+};
+/** Wraps `ctx.container` without starting it or taking ownership of its lifecycle. */
+const fromContainer = (container) => {
+	const exec = (command, options) => attemptPromise("exec", (signal) => container.exec([...command], {
+		...options,
+		signal
+	})).pipe(Effect.map(fromProcess));
+	const waitForHttp = Effect.fnUntraced(function* (portNumber, options = {}) {
+		const timeout = yield* attempt("waitForHttp", () => Duration.fromInputUnsafe(options.timeout ?? "30 seconds"));
+		let lastFailure;
+		const probe = attemptPromise("waitForHttp", async (signal) => {
+			const response = await container.getTcpPort(portNumber).fetch(new URL(options.path ?? "/", "http://container"), { signal });
+			await response.body?.cancel();
+			if (options.status !== void 0 && (response.status < options.status.min || response.status > options.status.max)) throw new Error(`HTTP readiness probe returned status ${response.status}`);
+		});
+		return yield* Effect.gen(function* () {
+			while (true) {
+				if (!(yield* attempt("running", () => container.running))) return yield* new ContainerError({
+					operation: "waitForHttp",
+					cause: /* @__PURE__ */ new Error("Container stopped before the port became ready")
+				});
+				if (yield* probe.pipe(Effect.timeout(options.attemptTimeout ?? "1 second"), Effect.match({
+					onSuccess: () => true,
+					onFailure: (error) => {
+						lastFailure = error;
+						return false;
+					}
+				}))) return;
+				yield* Effect.sleep(options.interval ?? "100 millis");
+			}
+		}).pipe(Effect.timeoutOrElse({
+			duration: timeout,
+			orElse: () => Effect.fail(new ContainerReadinessTimeoutError({
+				port: portNumber,
+				timeout,
+				cause: lastFailure
+			}))
+		}));
+	});
+	return {
+		raw: container,
+		running: attempt("running", () => container.running),
+		images: attempt("images", () => container.images),
+		inspect: attemptPromise("inspect", () => container.inspect()).pipe(Effect.map(Option.fromNullishOr)),
+		start: (options) => attempt("start", () => container.start(options)),
+		monitor: attemptPromise("monitor", () => container.monitor()),
+		destroy: (reason) => attemptPromise("destroy", () => container.destroy(reason)),
+		signal: (signal) => attempt("signal", () => container.signal(signal)),
+		setInactivityTimeout: (duration) => attemptPromise("setInactivityTimeout", () => container.setInactivityTimeout(Duration.toMillis(duration))),
+		getTcpPort: (port) => attempt("getTcpPort", () => fromTcpPort(container.getTcpPort(port))),
+		waitForHttp,
+		exec,
+		execScoped: (command, options) => Effect.acquireRelease(exec(command, options), (process) => process.kill(9).pipe(Effect.orDie), { interruptible: true }),
+		snapshotContainer: (options = {}) => attemptPromise("snapshotContainer", () => container.snapshotContainer(options)),
+		interceptOutboundHttp: (address, binding) => attemptPromise("interceptOutboundHttp", () => container.interceptOutboundHttp(address, binding)),
+		interceptAllOutboundHttp: (binding) => attemptPromise("interceptAllOutboundHttp", () => container.interceptAllOutboundHttp(binding)),
+		interceptOutboundHttps: (address, binding) => attemptPromise("interceptOutboundHttps", () => container.interceptOutboundHttps(address, binding))
+	};
+};
+/** Supplies the container attached to the current Durable Object, without owning it. */
+const layer = Layer.effect(DurableObjectContainer, Effect.gen(function* () {
+	const state = yield* DurableObjectState;
+	const container = state.raw.container;
+	if (container === void 0) return yield* new ContainerNotConfiguredError({ durableObjectId: state.id.toString() });
+	return fromContainer(container);
+}));
+//#endregion
+export { ContainerError, ContainerNotConfiguredError, ContainerReadinessTimeoutError, DurableObjectContainer, DurableObjectContainer_exports, fromContainer, layer };

package/dist/DurableObjectRpcWebSocket.d.mts

@@ -64,8 +64,8 @@ interface LayerOptions {
   readonly attachmentKey?: string | undefined;
   /**
    * Heartbeat behavior. `"auto-response"` (the default) installs Cloudflare's
-   * hibernation-safe text Ping/Pong response while an RPC socket exists and no
-   * non-resumable RPC operation is active, then removes it while one is pending.
+   * hibernation-safe text Ping/Pong response for the lifetime of RPC sockets,
+   * including pending operations. Keepalives never dispatch application code.
    * `"passthrough"` leaves the Durable Object's existing auto-response
    * configuration unchanged and makes the application responsible for waking a
    * lost pending operation.

package/dist/DurableObjectRpcWebSocket.mjs

@@ -70,7 +70,6 @@ const layer = (options = {}) => Layer.effectContext(Effect.gen(function* () {
 	const declarationsByTag = /* @__PURE__ */ new Map();
 	const replayRequests = [];
 	let nextClientId = 0;
-	let activeNonResumableRequestCount = 0;
 	let writeRequest;
 	for (const declaration of declarations) {
 		if (declaration.id.length === 0 || declaration.rpcTag.length === 0) return yield* Effect.die(/* @__PURE__ */ new Error("Resumable RPC stream declaration ids and tags must be non-empty"));
@@ -137,7 +136,7 @@ const layer = (options = {}) => Layer.effectContext(Effect.gen(function* () {
 		return connection;
 	};
 	const heartbeat = yield* makeHeartbeatController(durableObjectState, serialization, heartbeatPolicy);
-	const syncHeartbeat = () => heartbeat.setEnabled(connectionsBySocket.size > 0 && activeNonResumableRequestCount === 0);
+	const syncHeartbeat = () => heartbeat.setEnabled(connectionsBySocket.size > 0);
 	const persistConnection = Effect.fn("DurableObjectRpcWebSocket.persistConnection")(function* (connection) {
 		return yield* Effect.try({
 			try: () => {
@@ -171,7 +170,6 @@ const layer = (options = {}) => Layer.effectContext(Effect.gen(function* () {
 		if (connection === void 0) return;
 		connectionsBySocket.delete(socket.raw);
 		connectionsById.delete(connection.id);
-		activeNonResumableRequestCount -= connection.nonResumableRequestIds.size;
 		connection.requestIds.clear();
 		connection.nonResumableRequestIds.clear();
 		connection.subscriptionsByRequestId.clear();
@@ -210,7 +208,6 @@ const layer = (options = {}) => Layer.effectContext(Effect.gen(function* () {
 		} else {
 			connection.requestIds.add(request.id);
 			connection.nonResumableRequestIds.add(request.id);
-			activeNonResumableRequestCount++;
 		}
 		if (!(yield* persistOrReset(connection))) return false;
 		yield* syncHeartbeat();
@@ -218,7 +215,7 @@ const layer = (options = {}) => Layer.effectContext(Effect.gen(function* () {
 	});
 	const completeRequest = Effect.fn("DurableObjectRpcWebSocket.completeRequest")(function* (connection, requestId, preserveAckFilter = false) {
 		if (connection.requestIds.delete(requestId)) {
-			if (connection.nonResumableRequestIds.delete(requestId)) activeNonResumableRequestCount--;
+			connection.nonResumableRequestIds.delete(requestId);
 			const subscription = removeSubscription(connection, requestId);
 			connection.currentPendingRequestIds.delete(requestId);
 			if (preserveAckFilter && subscription !== void 0) connection.suppressedAckRequestIds.add(requestId);
@@ -229,7 +226,6 @@ const layer = (options = {}) => Layer.effectContext(Effect.gen(function* () {
 	});
 	const completeAllRequests = Effect.fn("DurableObjectRpcWebSocket.completeAllRequests")(function* (connection) {
 		const hadRequests = connection.requestIds.size > 0;
-		if (connection.requestIds.size > 0) activeNonResumableRequestCount -= connection.nonResumableRequestIds.size;
 		connection.requestIds.clear();
 		connection.nonResumableRequestIds.clear();
 		connection.subscriptionsByRequestId.clear();

package/dist/DurableObjectStorage.d.mts

@@ -2,7 +2,6 @@ import * as Effect from "effect/Effect";
 import * as S from "effect/Schema";
 import * as Option from "effect/Option";
 import * as Cause from "effect/Cause";
-import * as Duration from "effect/Duration";
 declare namespace DurableObjectStorage_d_exports {
   export { DurableObjectStorage, DurableObjectTransaction, SchemaBackedSyncKvStorage, SqlCursor, SqlStorage, SqlStorageValue, StorageOperationError, SyncKvDefinition, SyncKvStorage, fromDurableObjectStorage };
 }
@@ -69,23 +68,17 @@ interface DurableObjectTransaction {
   delete(keys: Array<string>, options?: globalThis.DurableObjectPutOptions): StorageEffect<number>;
   rollback(): StorageEffect<void>;
   getAlarm(options?: globalThis.DurableObjectGetAlarmOptions): StorageEffect<number | null>;
-  setAlarm(scheduledTime: number | Date, options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
-  setAlarmAfter(delay: Duration.Input, options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
-  deleteAlarm(options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
 }
 interface DurableObjectStorage {
   get<T = unknown>(key: string, options?: globalThis.DurableObjectGetOptions): StorageEffect<T | undefined>;
   put<T>(key: string, value: T, options?: globalThis.DurableObjectPutOptions): StorageEffect<void>;
   delete(key: string, options?: globalThis.DurableObjectPutOptions): StorageEffect<boolean>;
   /**
-   * Deletes all stored data. On compatibility dates before 2026-02-24, Cloudflare
-   * documents that active alarms must be deleted separately with `deleteAlarm()`.
+   * Deletes all stored data, including logical schedules. Use the alarm scheduler
+   * to cancel individual alarms without deleting application data.
    */
   deleteAll(options?: globalThis.DurableObjectPutOptions): StorageEffect<void>;
   getAlarm(options?: globalThis.DurableObjectGetAlarmOptions): StorageEffect<number | null>;
-  setAlarm(scheduledTime: number | Date, options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
-  setAlarmAfter(delay: Duration.Input, options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
-  deleteAlarm(options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
   /**
    * SQLite-backed Durable Object storage only.
    *

package/dist/DurableObjectStorage.mjs

@@ -9,8 +9,6 @@ import * as Option from "effect/Option";
 import * as Result from "effect/Result";
 import * as Cause from "effect/Cause";
 import * as Exit from "effect/Exit";
-import * as Clock from "effect/Clock";
-import * as Duration from "effect/Duration";
 import * as Fiber from "effect/Fiber";
 //#region src/DurableObjectStorage.ts
 var DurableObjectStorage_exports = /* @__PURE__ */ __exportAll({
@@ -34,11 +32,6 @@ 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()),
@@ -98,10 +91,7 @@ const fromDurableObjectTransaction = (txn) => ({
 	put: (keyOrEntries, valueOrOptions, maybeOptions) => tryStoragePromise("transaction.put", () => Predicate.isString(keyOrEntries) ? txn.put(keyOrEntries, valueOrOptions, maybeOptions) : txn.put(keyOrEntries, valueOrOptions)),
 	delete: (keyOrKeys, options) => Array.isArray(keyOrKeys) ? tryStoragePromise("transaction.delete", () => txn.delete(keyOrKeys, options)) : tryStoragePromise("transaction.delete", () => txn.delete(keyOrKeys, options)),
 	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))
+	getAlarm: (options) => tryStoragePromise("transaction.getAlarm", () => txn.getAlarm(options))
 });
 const fromDurableObjectStorage = (storage) => ({
 	get: (key, options) => tryStoragePromise("get", () => storage.get(key, options)),
@@ -109,9 +99,6 @@ const fromDurableObjectStorage = (storage) => ({
 	delete: (key, options) => tryStoragePromise("delete", () => storage.delete(key, options)),
 	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;
 		let escapedFiber;

package/dist/DurableObjectWebSocket.d.mts

@@ -3,8 +3,16 @@ import * as Effect from "effect/Effect";
 import * as S from "effect/Schema";
 import * as Option from "effect/Option";
 declare namespace DurableObjectWebSocket_d_exports {
-  export { AcceptUpgradeOptions, AcceptedUpgrade, AttachmentInvalidPolicy, AttachmentRehydrateOptions, DurableWebSocket, DurableWebSocketAttachment, DurableWebSocketAttachmentError, DurableWebSocketCloseError, DurableWebSocketHandlers, DurableWebSocketSendData, DurableWebSocketSendError, RehydratedDurableWebSocket, acceptUpgrade, attachment, fromWebSocket, handlers };
+  export { AcceptUpgradeOptions, AcceptedUpgrade, AttachmentInvalidPolicy, AttachmentRehydrateOptions, DEFAULT_KEEPALIVE_REQUEST, DEFAULT_KEEPALIVE_RESPONSE, DurableWebSocket, DurableWebSocketAttachment, DurableWebSocketAttachmentError, DurableWebSocketCloseError, DurableWebSocketHandlers, DurableWebSocketSendData, DurableWebSocketSendError, RehydratedDurableWebSocket, acceptUpgrade, attachment, fromWebSocket, handlers, installKeepalive };
 }
+declare const DEFAULT_KEEPALIVE_REQUEST = "effect-cf:ping";
+declare const DEFAULT_KEEPALIVE_RESPONSE = "effect-cf:pong";
+/**
+ * Registers exact text keepalives with Cloudflare so they never invoke the object.
+ * The pair applies to all hibernating sockets on this object; install in its constructor.
+ * Clients send the request text and consume the response outside their application protocol.
+ */
+declare const installKeepalive: (request?: any, response?: any) => Effect.Effect<undefined, never, DurableObjectState>;
 type DurableWebSocketSendData = string | ArrayBuffer | ArrayBufferView;
 declare const DurableWebSocketSendError_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: "DurableWebSocketSendError";
@@ -80,4 +88,4 @@ declare const handlers: <R = never, E = unknown>(options: DurableWebSocketHandle
   webSocketError: ((socket: DurableWebSocket, cause: unknown) => Effect.Effect<void, E, R>) | undefined;
 };
 //#endregion
-export { AcceptUpgradeOptions, AcceptedUpgrade, AttachmentInvalidPolicy, AttachmentRehydrateOptions, DurableObjectWebSocket_d_exports, DurableWebSocket, DurableWebSocketAttachment, DurableWebSocketAttachmentError, DurableWebSocketCloseError, DurableWebSocketHandlers, DurableWebSocketSendData, DurableWebSocketSendError, RehydratedDurableWebSocket, acceptUpgrade, attachment, fromWebSocket, handlers };
+export { AcceptUpgradeOptions, AcceptedUpgrade, AttachmentInvalidPolicy, AttachmentRehydrateOptions, DEFAULT_KEEPALIVE_REQUEST, DEFAULT_KEEPALIVE_RESPONSE, DurableObjectWebSocket_d_exports, DurableWebSocket, DurableWebSocketAttachment, DurableWebSocketAttachmentError, DurableWebSocketCloseError, DurableWebSocketHandlers, DurableWebSocketSendData, DurableWebSocketSendError, RehydratedDurableWebSocket, acceptUpgrade, attachment, fromWebSocket, handlers, installKeepalive };

package/dist/DurableObjectWebSocket.mjs

@@ -8,13 +8,29 @@ import * as Option from "effect/Option";
 import * as Result from "effect/Result";
 //#region src/DurableObjectWebSocket.ts
 var DurableObjectWebSocket_exports = /* @__PURE__ */ __exportAll({
+	DEFAULT_KEEPALIVE_REQUEST: () => DEFAULT_KEEPALIVE_REQUEST,
+	DEFAULT_KEEPALIVE_RESPONSE: () => DEFAULT_KEEPALIVE_RESPONSE,
 	DurableWebSocketAttachmentError: () => DurableWebSocketAttachmentError,
 	DurableWebSocketCloseError: () => DurableWebSocketCloseError,
 	DurableWebSocketSendError: () => DurableWebSocketSendError,
 	acceptUpgrade: () => acceptUpgrade,
 	attachment: () => attachment,
 	fromWebSocket: () => fromWebSocket,
-	handlers: () => handlers
+	handlers: () => handlers,
+	installKeepalive: () => installKeepalive
+});
+const DEFAULT_KEEPALIVE_REQUEST = "effect-cf:ping";
+const DEFAULT_KEEPALIVE_RESPONSE = "effect-cf:pong";
+/**
+* Registers exact text keepalives with Cloudflare so they never invoke the object.
+* The pair applies to all hibernating sockets on this object; install in its constructor.
+* Clients send the request text and consume the response outside their application protocol.
+*/
+const installKeepalive = Effect.fn("DurableObjectWebSocket.installKeepalive")(function* (request = DEFAULT_KEEPALIVE_REQUEST, response = DEFAULT_KEEPALIVE_RESPONSE) {
+	const state = yield* DurableObjectState;
+	const configured = yield* state.getWebSocketAutoResponse;
+	if (configured !== null && (configured.request !== request || configured.response !== response)) return yield* Effect.die(/* @__PURE__ */ new Error("Durable Object already has a different keepalive protocol"));
+	yield* state.setWebSocketAutoResponse(new WebSocketRequestResponsePair(request, response));
 });
 var DurableWebSocketSendError = class extends Data.TaggedError("DurableWebSocketSendError") {
 	get message() {
@@ -117,4 +133,4 @@ const handlers = (options) => ({
 	webSocketError: options.error
 });
 //#endregion
-export { DurableObjectWebSocket_exports, DurableWebSocketAttachmentError, DurableWebSocketCloseError, DurableWebSocketSendError, acceptUpgrade, attachment, fromWebSocket, handlers };
+export { DEFAULT_KEEPALIVE_REQUEST, DEFAULT_KEEPALIVE_RESPONSE, DurableObjectWebSocket_exports, DurableWebSocketAttachmentError, DurableWebSocketCloseError, DurableWebSocketSendError, acceptUpgrade, attachment, fromWebSocket, handlers, installKeepalive };

package/dist/RpcTracing.mjs

@@ -5,9 +5,9 @@ import * as Schema from "effect/Schema";
 import * as Option from "effect/Option";
 import * as Cause from "effect/Cause";
 import * as Exit from "effect/Exit";
-import * as Clock from "effect/Clock";
 import * as Tracer from "effect/Tracer";
 import * as References from "effect/References";
+import * as Clock from "effect/Clock";
 //#region src/RpcTracing.ts
 var RpcTracing_exports = /* @__PURE__ */ __exportAll({
 	RpcTraceContext: () => RpcTraceContext,

package/dist/index.d.mts

@@ -24,6 +24,8 @@ import { BrowserRendering_d_exports } from "./BrowserRendering.mjs";
 import { Cache_d_exports } from "./Cache.mjs";
 import { CloudflareOtlp_d_exports } from "./CloudflareOtlp.mjs";
 import { CloudflareTracer_d_exports } from "./CloudflareTracer.mjs";
+import { DurableObjectContainer_d_exports } from "./DurableObjectContainer.mjs";
+import { ContainerFiles_d_exports } from "./ContainerFiles.mjs";
 import { D1_d_exports } from "./D1.mjs";
 import { DurableObjectAlarm_d_exports } from "./DurableObjectAlarm.mjs";
 import { DurableObjectDefinition_d_exports } from "./DurableObjectDefinition.mjs";
@@ -40,4 +42,4 @@ import { Vectorize_d_exports } from "./Vectorize.mjs";
 import { WebTransport_d_exports } from "./WebTransport.mjs";
 import { WorkflowDefinition_d_exports } from "./WorkflowDefinition.mjs";
 import { Workflow_d_exports } from "./Workflow.mjs";
-export { AiGateway_d_exports as AiGateway, AnalyticsEngine_d_exports as AnalyticsEngine, Artifacts_d_exports as Artifacts, Binding_d_exports as Binding, BrowserRendering_d_exports as BrowserRendering, Cache_d_exports as Cache, CloudflareOtlp_d_exports as CloudflareOtlp, CloudflareTracer_d_exports as CloudflareTracer, ContainerNamespace_d_exports as ContainerNamespace, D1_d_exports as D1, DurableObject_d_exports as DurableObject, DurableObjectAlarm_d_exports as DurableObjectAlarm, DurableObjectDefinition_d_exports as DurableObjectDefinition, DurableObjectNamespace_d_exports as DurableObjectNamespace, DurableObjectRpcWebSocket_d_exports as DurableObjectRpcWebSocket, DurableObjectSqlite_d_exports as DurableObjectSqlite, DurableObjectState_d_exports as DurableObjectState, DurableObjectStorage_d_exports as DurableObjectStorage, DurableObjectWebSocket_d_exports as DurableObjectWebSocket, Email_d_exports as Email, Environment_d_exports as Environment, Hyperdrive_d_exports as Hyperdrive, Images_d_exports as Images, Kv_d_exports as Kv, Queue_d_exports as Queue, QueueBinding_d_exports as QueueBinding, QueueDefinition_d_exports as QueueDefinition, R2_d_exports as R2, Rpc_d_exports as Rpc, RpcDefinition_d_exports as RpcDefinition, RpcTargets_d_exports as RpcTargets, RpcTracing_d_exports as RpcTracing, RpcWebSocketClient_d_exports as RpcWebSocketClient, ServiceBinding_d_exports as ServiceBinding, Vectorize_d_exports as Vectorize, WebTransport_d_exports as WebTransport, Worker_d_exports as Worker, WorkerConfig, WorkerDefinition_d_exports as WorkerDefinition, type WorkerEnv, WorkerEnvironment, WorkersAi_d_exports as WorkersAi, Workflow_d_exports as Workflow, WorkflowBinding_d_exports as WorkflowBinding, WorkflowDefinition_d_exports as WorkflowDefinition };
+export { AiGateway_d_exports as AiGateway, AnalyticsEngine_d_exports as AnalyticsEngine, Artifacts_d_exports as Artifacts, Binding_d_exports as Binding, BrowserRendering_d_exports as BrowserRendering, Cache_d_exports as Cache, CloudflareOtlp_d_exports as CloudflareOtlp, CloudflareTracer_d_exports as CloudflareTracer, ContainerFiles_d_exports as ContainerFiles, ContainerNamespace_d_exports as ContainerNamespace, D1_d_exports as D1, DurableObject_d_exports as DurableObject, DurableObjectAlarm_d_exports as DurableObjectAlarm, DurableObjectContainer_d_exports as DurableObjectContainer, DurableObjectDefinition_d_exports as DurableObjectDefinition, DurableObjectNamespace_d_exports as DurableObjectNamespace, DurableObjectRpcWebSocket_d_exports as DurableObjectRpcWebSocket, DurableObjectSqlite_d_exports as DurableObjectSqlite, DurableObjectState_d_exports as DurableObjectState, DurableObjectStorage_d_exports as DurableObjectStorage, DurableObjectWebSocket_d_exports as DurableObjectWebSocket, Email_d_exports as Email, Environment_d_exports as Environment, Hyperdrive_d_exports as Hyperdrive, Images_d_exports as Images, Kv_d_exports as Kv, Queue_d_exports as Queue, QueueBinding_d_exports as QueueBinding, QueueDefinition_d_exports as QueueDefinition, R2_d_exports as R2, Rpc_d_exports as Rpc, RpcDefinition_d_exports as RpcDefinition, RpcTargets_d_exports as RpcTargets, RpcTracing_d_exports as RpcTracing, RpcWebSocketClient_d_exports as RpcWebSocketClient, ServiceBinding_d_exports as ServiceBinding, Vectorize_d_exports as Vectorize, WebTransport_d_exports as WebTransport, Worker_d_exports as Worker, WorkerConfig, WorkerDefinition_d_exports as WorkerDefinition, type WorkerEnv, WorkerEnvironment, WorkersAi_d_exports as WorkersAi, Workflow_d_exports as Workflow, WorkflowBinding_d_exports as WorkflowBinding, WorkflowDefinition_d_exports as WorkflowDefinition };

package/dist/index.mjs

@@ -11,6 +11,8 @@ import { DurableObjectWebSocket_exports } from "./DurableObjectWebSocket.mjs";
 import { DurableObjectState_exports } from "./DurableObjectState.mjs";
 import { CloudflareOtlp_exports } from "./CloudflareOtlp.mjs";
 import { CloudflareTracer_exports } from "./CloudflareTracer.mjs";
+import { DurableObjectContainer_exports } from "./DurableObjectContainer.mjs";
+import { ContainerFiles_exports } from "./ContainerFiles.mjs";
 import { RpcTargets_exports } from "./RpcTargets.mjs";
 import { ContainerNamespace_exports } from "./ContainerNamespace.mjs";
 import { D1_exports } from "./D1.mjs";
@@ -40,4 +42,4 @@ import { WebTransport_exports } from "./WebTransport.mjs";
 import { WorkflowBinding_exports } from "./WorkflowBinding.mjs";
 import { WorkflowDefinition_exports } from "./WorkflowDefinition.mjs";
 import { Workflow_exports } from "./Workflow.mjs";
-export { AiGateway_exports as AiGateway, AnalyticsEngine_exports as AnalyticsEngine, Artifacts_exports as Artifacts, Binding_exports as Binding, BrowserRendering_exports as BrowserRendering, Cache_exports as Cache, CloudflareOtlp_exports as CloudflareOtlp, CloudflareTracer_exports as CloudflareTracer, ContainerNamespace_exports as ContainerNamespace, D1_exports as D1, DurableObject_exports as DurableObject, DurableObjectAlarm_exports as DurableObjectAlarm, DurableObjectDefinition_exports as DurableObjectDefinition, DurableObjectNamespace_exports as DurableObjectNamespace, DurableObjectRpcWebSocket_exports as DurableObjectRpcWebSocket, DurableObjectSqlite_exports as DurableObjectSqlite, DurableObjectState_exports as DurableObjectState, DurableObjectStorage_exports as DurableObjectStorage, DurableObjectWebSocket_exports as DurableObjectWebSocket, Email_exports as Email, Environment_exports as Environment, Hyperdrive_exports as Hyperdrive, Images_exports as Images, Kv_exports as Kv, Queue_exports as Queue, QueueBinding_exports as QueueBinding, QueueDefinition_exports as QueueDefinition, R2_exports as R2, Rpc_exports as Rpc, RpcDefinition_exports as RpcDefinition, RpcTargets_exports as RpcTargets, RpcTracing_exports as RpcTracing, RpcWebSocketClient_exports as RpcWebSocketClient, ServiceBinding_exports as ServiceBinding, Vectorize_exports as Vectorize, WebTransport_exports as WebTransport, Worker_exports as Worker, WorkerConfig, WorkerDefinition_exports as WorkerDefinition, WorkerEnvironment, WorkersAi_exports as WorkersAi, Workflow_exports as Workflow, WorkflowBinding_exports as WorkflowBinding, WorkflowDefinition_exports as WorkflowDefinition };
+export { AiGateway_exports as AiGateway, AnalyticsEngine_exports as AnalyticsEngine, Artifacts_exports as Artifacts, Binding_exports as Binding, BrowserRendering_exports as BrowserRendering, Cache_exports as Cache, CloudflareOtlp_exports as CloudflareOtlp, CloudflareTracer_exports as CloudflareTracer, ContainerFiles_exports as ContainerFiles, ContainerNamespace_exports as ContainerNamespace, D1_exports as D1, DurableObject_exports as DurableObject, DurableObjectAlarm_exports as DurableObjectAlarm, DurableObjectContainer_exports as DurableObjectContainer, DurableObjectDefinition_exports as DurableObjectDefinition, DurableObjectNamespace_exports as DurableObjectNamespace, DurableObjectRpcWebSocket_exports as DurableObjectRpcWebSocket, DurableObjectSqlite_exports as DurableObjectSqlite, DurableObjectState_exports as DurableObjectState, DurableObjectStorage_exports as DurableObjectStorage, DurableObjectWebSocket_exports as DurableObjectWebSocket, Email_exports as Email, Environment_exports as Environment, Hyperdrive_exports as Hyperdrive, Images_exports as Images, Kv_exports as Kv, Queue_exports as Queue, QueueBinding_exports as QueueBinding, QueueDefinition_exports as QueueDefinition, R2_exports as R2, Rpc_exports as Rpc, RpcDefinition_exports as RpcDefinition, RpcTargets_exports as RpcTargets, RpcTracing_exports as RpcTracing, RpcWebSocketClient_exports as RpcWebSocketClient, ServiceBinding_exports as ServiceBinding, Vectorize_exports as Vectorize, WebTransport_exports as WebTransport, Worker_exports as Worker, WorkerConfig, WorkerDefinition_exports as WorkerDefinition, WorkerEnvironment, WorkersAi_exports as WorkersAi, Workflow_exports as Workflow, WorkflowBinding_exports as WorkflowBinding, WorkflowDefinition_exports as WorkflowDefinition };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-cf",
-  "version": "0.49.0",
+  "version": "0.51.0",
   "description": "Effect-native primitives for Cloudflare Workers and bindings.",
   "license": "MIT",
   "repository": {
@@ -78,6 +78,7 @@
     "@cloudflare/computer": "0.2.0",
     "@cloudflare/containers": "catalog:",
     "@cloudflare/sandbox": "0.13.0-next.738.2",
+    "@cloudflare/sandbox-v1": "npm:@cloudflare/sandbox@1.0.0",
     "@cloudflare/vitest-plugin": "catalog:",
     "@cloudflare/workers-types": "catalog:",
     "@effect/platform-node": "catalog:",
@@ -96,9 +97,9 @@
   },
   "peerDependencies": {
     "@cloudflare/computer": "^0.2.0",
-    "@cloudflare/sandbox": "^0.13.0-next.738.2",
+    "@cloudflare/sandbox": "^0.13.0-next.738.2 || ^1.0.0",
     "@cloudflare/vitest-plugin": "^1.0.0",
-    "@cloudflare/workers-types": "^5.20260825.1",
+    "@cloudflare/workers-types": "^5.20260926.1",
     "@effect/sql-d1": "^4.0.0-rc.115",
     "@effect/sql-pg": "^4.0.0-rc.115",
     "@effect/sql-sqlite-do": "^4.0.0-rc.115",

package/src/ContainerFiles.ts

@@ -0,0 +1,162 @@
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+
+import { ContainerError } from "./DurableObjectContainer";
+
+export type FileContent =
+  | string
+  | ArrayBuffer
+  | ArrayBufferView
+  | Blob
+  | ReadableStream<Uint8Array>;
+export type FileType =
+  | "file"
+  | "directory"
+  | "symlink"
+  | "blockDevice"
+  | "characterDevice"
+  | "fifo"
+  | "socket";
+
+export interface FileOperationOptions {
+  readonly cwd?: string;
+  readonly user?: string;
+}
+
+export interface MkdirOptions extends FileOperationOptions {
+  readonly recursive?: boolean;
+}
+
+export interface RemoveOptions extends FileOperationOptions {
+  readonly recursive?: boolean;
+  readonly force?: boolean;
+}
+
+export interface FileStat {
+  readonly type: FileType;
+  readonly size: bigint;
+  readonly mode: number;
+  readonly uid: number;
+  readonly gid: number;
+  readonly accessedAt: Date;
+  readonly modifiedAt: Date;
+  readonly changedAt: Date;
+}
+
+export interface DirectoryEntry {
+  readonly name: string;
+  readonly type: FileType;
+}
+
+type WithSignal<A> = A & { readonly signal?: AbortSignal };
+
+/** Structural contract of Sandbox SDK 1.x `Files`, without loading an SDK version. */
+export interface FilesResource {
+  readFile(path: string, options?: WithSignal<FileOperationOptions>): Promise<Response>;
+  writeFile(
+    path: string,
+    content: FileContent,
+    options?: WithSignal<FileOperationOptions>,
+  ): Promise<void>;
+  stat(path: string, options?: WithSignal<FileOperationOptions>): Promise<FileStat>;
+  lstat(path: string, options?: WithSignal<FileOperationOptions>): Promise<FileStat>;
+  readDirectory(
+    path: string,
+    options?: WithSignal<FileOperationOptions>,
+  ): Promise<ReadonlyArray<DirectoryEntry>>;
+  mkdir(path: string, options?: WithSignal<MkdirOptions>): Promise<void>;
+  rename(
+    source: string,
+    destination: string,
+    options?: WithSignal<FileOperationOptions>,
+  ): Promise<void>;
+  remove(path: string, options?: WithSignal<RemoveOptions>): Promise<void>;
+}
+
+export interface ContainerFiles {
+  readonly raw: FilesResource;
+  /** The caller consumes or cancels the response body. Late failures retain native SDK errors. */
+  readonly readFile: (
+    path: string,
+    options?: FileOperationOptions,
+  ) => Effect.Effect<Response, ContainerError>;
+  /** Includes failures that arrive while reading the response body. */
+  readonly readFileStream: (
+    path: string,
+    options?: FileOperationOptions,
+  ) => Stream.Stream<Uint8Array, ContainerError>;
+  readonly readFileString: (
+    path: string,
+    options?: FileOperationOptions,
+  ) => Effect.Effect<string, ContainerError>;
+  readonly writeFile: (
+    path: string,
+    content: FileContent,
+    options?: FileOperationOptions,
+  ) => Effect.Effect<void, ContainerError>;
+  readonly stat: (
+    path: string,
+    options?: FileOperationOptions,
+  ) => Effect.Effect<FileStat, ContainerError>;
+  readonly lstat: (
+    path: string,
+    options?: FileOperationOptions,
+  ) => Effect.Effect<FileStat, ContainerError>;
+  readonly readDirectory: (
+    path: string,
+    options?: FileOperationOptions,
+  ) => Effect.Effect<ReadonlyArray<DirectoryEntry>, ContainerError>;
+  readonly mkdir: (path: string, options?: MkdirOptions) => Effect.Effect<void, ContainerError>;
+  readonly rename: (
+    source: string,
+    destination: string,
+    options?: FileOperationOptions,
+  ) => Effect.Effect<void, ContainerError>;
+  readonly remove: (path: string, options?: RemoveOptions) => Effect.Effect<void, ContainerError>;
+}
+
+const attempt = <A>(operation: string, evaluate: (signal: AbortSignal) => Promise<A>) =>
+  Effect.tryPromise({
+    try: evaluate,
+    catch: (cause) => new ContainerError({ operation: `files.${operation}`, cause }),
+  });
+
+/** Pass `new Files(container.raw)` from SDK 1.x. The image must supply its matching sandbox-shim. */
+export const fromFiles = (files: FilesResource): ContainerFiles => {
+  const readFile = (path: string, options?: FileOperationOptions) =>
+    attempt("readFile", (signal) => files.readFile(path, { ...options, signal }));
+  const readFileStream = (path: string, options?: FileOperationOptions) =>
+    Stream.unwrap(
+      Effect.map(readFile(path, options), (response) => {
+        const body = response.body;
+
+        return body === null
+          ? Stream.empty
+          : Stream.fromReadableStream({
+              evaluate: () => body,
+              onError: (cause) => new ContainerError({ operation: "files.readFile", cause }),
+            });
+      }),
+    );
+
+  return {
+    raw: files,
+    readFile,
+    readFileStream,
+    readFileString: (path, options) =>
+      readFileStream(path, options).pipe(Stream.decodeText(), Stream.mkString),
+    writeFile: (path, content, options) =>
+      attempt("writeFile", (signal) => files.writeFile(path, content, { ...options, signal })),
+    stat: (path, options) => attempt("stat", (signal) => files.stat(path, { ...options, signal })),
+    lstat: (path, options) =>
+      attempt("lstat", (signal) => files.lstat(path, { ...options, signal })),
+    readDirectory: (path, options) =>
+      attempt("readDirectory", (signal) => files.readDirectory(path, { ...options, signal })),
+    mkdir: (path, options) =>
+      attempt("mkdir", (signal) => files.mkdir(path, { ...options, signal })),
+    rename: (source, destination, options) =>
+      attempt("rename", (signal) => files.rename(source, destination, { ...options, signal })),
+    remove: (path, options) =>
+      attempt("remove", (signal) => files.remove(path, { ...options, signal })),
+  };
+};

package/src/ContainerNamespace.ts

@@ -60,10 +60,12 @@ export const ContainerState = S.Union([
 export type ContainerState = typeof ContainerState.Type;
 
 /**
- * Native Container stub shape exposed by a Container namespace binding.
+ * RPC stub exposed by the legacy `@cloudflare/containers` Container class.
  *
  * This is structural so using Container bindings does not make
  * `@cloudflare/containers` a runtime dependency of effect-cf.
+ * Use `DurableObjectContainer` inside a Durable Object for the native
+ * `ctx.container` API and the `durable_object` scheduling policy.
  */
 export interface ContainerStub {
   fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;