effect-cf 0.23.1 → 0.25.0

package/dist/index.mjs

@@ -1,5 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { Cause, Clock, Config, ConfigProvider, Context, Data, DateTime, Duration, Effect, Exit, Function as Function$1, Layer, ManagedRuntime, Option, Predicate, Queue, Result, Schema } from "effect";
+import { a as DurableObjectWebSocket_exports, c as causeMessage, d as WorkerConfig, f as WorkerEnvironment, i as fromExecutionContext, l as violationsMessage, n as DurableObjectState_exports, o as fromWebSocket, r as fromDurableObjectState, s as DurableObjectStorage_exports, t as DurableObjectState, u as Environment_exports } from "./DurableObjectState-B5RCFnRy.mjs";
+import { Clock, Config, ConfigProvider, Context, Data, DateTime, Duration, Effect, Exit, Function as Function$1, Layer, ManagedRuntime, Option, Predicate, Queue, Result, Schema } from "effect";
 import { FetchHttpClient, HttpClient, HttpClientRequest, HttpEffect, HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
 import { OtlpExporter, OtlpLogger, OtlpMetrics, OtlpSerialization, OtlpTracer } from "effect/unstable/observability";
 import { D1Client } from "@effect/sql-d1";
@@ -8,29 +9,6 @@ import * as RpcMessage from "effect/unstable/rpc/RpcMessage";
 import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
 import * as RpcServer from "effect/unstable/rpc/RpcServer";
 import { SqliteClient } from "@effect/sql-sqlite-do";
-//#region src/Environment.ts
-var Environment_exports = /* @__PURE__ */ __exportAll({
-	WorkerConfig: () => WorkerConfig,
-	WorkerEnvironment: () => WorkerEnvironment
-});
-/**
-* Context service for reading worker bindings from the current `env` object.
-*/
-var WorkerEnvironment = class extends Context.Service()("effect-cf/WorkerEnvironment") {};
-let WorkerConfig;
-(function(_WorkerConfig) {
-	_WorkerConfig.string = (name) => Config.string(name);
-	_WorkerConfig.redacted = (name) => Config.redacted(name);
-	_WorkerConfig.number = (name) => Config.number(name);
-	_WorkerConfig.integer = (name) => Config.int(name);
-	_WorkerConfig.boolean = (name) => Config.boolean(name);
-	const providerFromEnv = _WorkerConfig.providerFromEnv = (env, options) => ConfigProvider.fromUnknown(env, options);
-	const providerWith = _WorkerConfig.providerWith = (makeProvider) => Effect.map(WorkerEnvironment, makeProvider);
-	const provider = _WorkerConfig.provider = providerWith(providerFromEnv);
-	_WorkerConfig.layer = _WorkerConfig.providerLayer = ConfigProvider.layer(provider);
-	_WorkerConfig.layerWith = (makeProvider) => ConfigProvider.layer(providerWith(makeProvider));
-})(WorkerConfig || (WorkerConfig = {}));
-//#endregion
 //#region src/Binding.ts
 var Binding_exports = /* @__PURE__ */ __exportAll({
 	BindingNotFoundError: () => BindingNotFoundError,
@@ -149,25 +127,6 @@ const Service$2 = () => {
 	return makeService;
 };
 //#endregion
-//#region src/internal/ErrorMessage.ts
-/**
-* Renders the most useful human-readable description of an unknown `cause`
-* for use in tagged error `message` getters.
-*/
-const causeMessage = (cause) => {
-	if (typeof cause === "object" && cause !== null) {
-		const message = Reflect.get(cause, "message");
-		if (typeof message === "string" && message.length > 0) return message;
-	}
-	try {
-		return String(cause);
-	} catch {
-		return "unknown cause";
-	}
-};
-/** Renders a violation list as a single `path: message; ...` line. */
-const violationsMessage = (violations) => violations.map((violation) => `${violation.path}: ${violation.message}`).join("; ");
-//#endregion
 //#region src/WorkersAi.ts
 var WorkersAi_exports = /* @__PURE__ */ __exportAll({
 	Tag: () => Tag$16,
@@ -433,14 +392,7 @@ const tryAnalyticsEngineSync = (binding, operation, evaluate) => Effect.try({
 	try: evaluate,
 	catch: (cause) => analyticsEngineError(binding, operation, cause)
 });
-const normalizeBatchSize = (batchSize) => {
-	if (batchSize === void 0 || !Number.isFinite(batchSize) || batchSize <= 0) return writeLimits.maxDataPointsPerInvocation;
-	return Math.min(Math.floor(batchSize), writeLimits.maxDataPointsPerInvocation);
-};
-const resolveWritePolicy = (defaults, options) => ({
-	onInvalid: options?.onInvalid ?? defaults?.onInvalid ?? "error",
-	batchSize: normalizeBatchSize(options?.batchSize ?? defaults?.batchSize)
-});
+const resolveWritePolicy = (defaults, options) => ({ onInvalid: options?.onInvalid ?? defaults?.onInvalid ?? "error" });
 const fieldPath = (prefix, field) => prefix === "" ? field : `${prefix}.${field}`;
 const indexedPath = (prefix, field, index) => `${fieldPath(prefix, field)}[${index}]`;
 const byteLength$1 = (value) => {
@@ -498,13 +450,8 @@ const validateDataPoints = (binding, operation, dataPoints, policy) => Effect.ge
 	if (violations.length > 0) return yield* Effect.fail(analyticsEngineWriteValidationError(binding, operation, violations));
 	return validPoints;
 });
-const writeChunks = (binding, operation, dataset, dataPoints, batchSize) => Effect.gen(function* () {
-	const writeDataPoints = Reflect.get(dataset, "writeDataPoints");
-	for (let index = 0; index < dataPoints.length; index += batchSize) {
-		const chunk = dataPoints.slice(index, index + batchSize);
-		if (typeof writeDataPoints === "function") yield* tryAnalyticsEngineSync(binding, operation, () => writeDataPoints.call(dataset, chunk));
-		else for (const point of chunk) yield* tryAnalyticsEngineSync(binding, operation, () => dataset.writeDataPoint(point));
-	}
+const writeChunks = (binding, operation, dataset, dataPoints) => Effect.gen(function* () {
+	for (const point of dataPoints) yield* tryAnalyticsEngineSync(binding, operation, () => dataset.writeDataPoint(point));
 });
 const queryApiUrl = (definition) => {
 	const baseUrl = new URL(definition.apiBaseUrl ?? defaultQueryApiBaseUrl);
@@ -561,24 +508,20 @@ const isAnalyticsEngineDataset = (value) => {
 	return typeof Reflect.get(value, "writeDataPoint") === "function";
 };
 const makeClient$13 = (definition, defaults) => (dataset) => {
-	const writeDataPoint = Effect.fn("AnalyticsEngine.writeDataPoint")((dataPoint, options) => {
-		const policy = resolveWritePolicy(defaults, options);
-		return validateOptionalDataPoint(definition.binding, "writeDataPoint", dataPoint).pipe(Effect.matchEffect({
-			onFailure: (error) => policy.onInvalid === "drop" ? Effect.succeed(void 0) : Effect.fail(error),
-			onSuccess: (point) => tryAnalyticsEngineSync(definition.binding, "writeDataPoint", () => dataset.writeDataPoint(point))
-		}));
-	});
-	const writeDataPoints = Effect.fn("AnalyticsEngine.writeDataPoints")(function* (dataPoints, options) {
-		const policy = resolveWritePolicy(defaults, options);
-		const validPoints = yield* validateDataPoints(definition.binding, "writeDataPoints", dataPoints, policy);
-		yield* writeChunks(definition.binding, "writeDataPoints", dataset, validPoints, policy.batchSize);
-	});
 	return {
 		definition,
-		writeDataPoint,
-		write: writeDataPoint,
-		writeDataPoints,
-		writeBatch: writeDataPoints,
+		writeDataPoint: Effect.fn("AnalyticsEngine.writeDataPoint")((dataPoint, options) => {
+			const policy = resolveWritePolicy(defaults, options);
+			return validateOptionalDataPoint(definition.binding, "writeDataPoint", dataPoint).pipe(Effect.matchEffect({
+				onFailure: (error) => policy.onInvalid === "drop" ? Effect.succeed(void 0) : Effect.fail(error),
+				onSuccess: (point) => tryAnalyticsEngineSync(definition.binding, "writeDataPoint", () => dataset.writeDataPoint(point))
+			}));
+		}),
+		writeDataPoints: Effect.fn("AnalyticsEngine.writeDataPoints")(function* (dataPoints, options) {
+			const policy = resolveWritePolicy(defaults, options);
+			const validPoints = yield* validateDataPoints(definition.binding, "writeDataPoints", dataPoints, policy);
+			yield* writeChunks(definition.binding, "writeDataPoints", dataset, validPoints);
+		}),
 		rawUnsafe: Effect.succeed(dataset)
 	};
 };
@@ -734,345 +677,6 @@ const layerFrom = (storage) => Layer.succeed(CacheStorage, makeClient$11(storage
 /** Provides Cache API services from Cloudflare's global `caches` object. */
 const layer$14 = Layer.sync(CacheStorage, () => makeClient$11(caches));
 //#endregion
-//#region src/DurableObjectStorage.ts
-var DurableObjectStorage_exports = /* @__PURE__ */ __exportAll({
-	StorageOperationError: () => StorageOperationError,
-	fromDurableObjectStorage: () => fromDurableObjectStorage
-});
-/** Error type used when a storage operation throws or rejects. */
-var StorageOperationError = class extends Data.TaggedError("StorageOperationError") {
-	get message() {
-		return `Durable Object storage ${this.operation} failed: ${causeMessage(this.cause)}`;
-	}
-};
-const storageError = (operation, cause) => new StorageOperationError({
-	operation,
-	cause
-});
-const tryStorageSync = (operation, evaluate) => Effect.try({
-	try: evaluate,
-	catch: (cause) => storageError(operation, cause)
-});
-const tryStoragePromise = (operation, evaluate) => Effect.tryPromise({
-	try: evaluate,
-	catch: (cause) => storageError(operation, cause)
-});
-const fromSqlCursor = (cursor) => ({
-	next: () => tryStorageSync("sql.next", () => cursor.next()),
-	toArray: () => tryStorageSync("sql.toArray", () => cursor.toArray()),
-	one: () => tryStorageSync("sql.one", () => cursor.one()),
-	raw: () => tryStorageSync("sql.raw", () => cursor.raw()),
-	get columnNames() {
-		return cursor.columnNames;
-	},
-	rowsRead: tryStorageSync("sql.rowsRead", () => cursor.rowsRead),
-	rowsWritten: tryStorageSync("sql.rowsWritten", () => cursor.rowsWritten)
-});
-const fromSqlStorage = (sql) => ({
-	exec: (query, ...bindings) => tryStorageSync("sql.exec", () => fromSqlCursor(sql.exec(query, ...bindings))),
-	get databaseSize() {
-		return sql.databaseSize;
-	}
-});
-const schemaBackedSyncKvStorage = (kv, definition) => {
-	const encodeKey = Schema.encodeEffect(definition.key);
-	const decodeKey = Schema.decodeUnknownEffect(definition.key);
-	const encodeValue = Schema.encodeEffect(definition.value);
-	const decodeValue = Schema.decodeUnknownEffect(definition.value);
-	return {
-		get: (key) => Effect.gen(function* () {
-			const encodedKey = yield* encodeKey(key);
-			const encodedValue = yield* tryStorageSync("kv.get", () => kv.get(encodedKey));
-			if (encodedValue === void 0) return Option.none();
-			return yield* decodeValue(encodedValue).pipe(Effect.map(Option.some));
-		}),
-		put: (key, value) => Effect.gen(function* () {
-			const encodedKey = yield* encodeKey(key);
-			const encodedValue = yield* encodeValue(value);
-			yield* tryStorageSync("kv.put", () => kv.put(encodedKey, encodedValue));
-		}),
-		delete: (key) => Effect.gen(function* () {
-			const encodedKey = yield* encodeKey(key);
-			return yield* tryStorageSync("kv.delete", () => kv.delete(encodedKey));
-		}),
-		list: (options) => Effect.gen(function* () {
-			const entries = Array.from(yield* tryStorageSync("kv.list", () => kv.list(options)));
-			const decoded = [];
-			for (const [key, value] of entries) decoded.push([yield* decodeKey(key), yield* decodeValue(value)]);
-			return decoded;
-		})
-	};
-};
-const fromSyncKvStorage = (kv) => ({
-	get: (key) => tryStorageSync("kv.get", () => kv.get(key)),
-	put: (key, value) => tryStorageSync("kv.put", () => kv.put(key, value)),
-	delete: (key) => tryStorageSync("kv.delete", () => kv.delete(key)),
-	list: (options) => tryStorageSync("kv.list", () => Array.from(kv.list(options))),
-	schema: (definition) => schemaBackedSyncKvStorage(kv, definition)
-});
-const fromDurableObjectTransaction = (txn) => ({
-	get: (keyOrKeys, options) => Array.isArray(keyOrKeys) ? tryStoragePromise("transaction.get", () => txn.get(keyOrKeys, options)) : tryStoragePromise("transaction.get", () => txn.get(keyOrKeys, options)),
-	list: (options) => tryStoragePromise("transaction.list", () => txn.list(options)),
-	put: (keyOrEntries, valueOrOptions, maybeOptions) => tryStoragePromise("transaction.put", () => typeof keyOrEntries === "string" ? 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)),
-	deleteAlarm: (options) => tryStoragePromise("transaction.deleteAlarm", () => txn.deleteAlarm(options))
-});
-/**
-* Wraps native Cloudflare storage APIs as Effect-returning helpers.
-*/
-const fromDurableObjectStorage = (storage) => ({
-	get: (key, options) => tryStoragePromise("get", () => storage.get(key, options)),
-	put: (key, value, options) => tryStoragePromise("put", () => storage.put(key, value, options)),
-	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)),
-	deleteAlarm: (options) => tryStoragePromise("deleteAlarm", () => storage.deleteAlarm(options)),
-	transactionSync: (closure) => Effect.context().pipe(Effect.flatMap((context) => Effect.suspend(() => {
-		try {
-			return Effect.succeed(storage.transactionSync(() => {
-				const exit = Effect.runSyncExitWith(context)(closure());
-				if (Exit.isSuccess(exit)) return exit.value;
-				throw exit;
-			}));
-		} catch (cause) {
-			if (Exit.isExit(cause) && Exit.isFailure(cause)) return Effect.failCause(cause.cause);
-			return Effect.fail(storageError("transactionSync", cause));
-		}
-	}))),
-	transaction: (closure) => Effect.context().pipe(Effect.flatMap((context) => Effect.callback((resume) => {
-		storage.transaction(async (txn) => {
-			const exit = await Effect.runPromiseExitWith(context)(closure(fromDurableObjectTransaction(txn)));
-			if (Exit.isSuccess(exit)) return exit.value;
-			throw exit;
-		}).then((value) => resume(Effect.succeed(value)), (cause) => {
-			if (Exit.isExit(cause) && Exit.isFailure(cause)) resume(Effect.failCause(cause.cause));
-			else resume(Effect.fail(storageError("transaction", cause)));
-		});
-	}))),
-	sync: () => tryStoragePromise("sync", () => storage.sync()),
-	getCurrentBookmark: () => tryStoragePromise("getCurrentBookmark", () => storage.getCurrentBookmark()),
-	onNextSessionRestoreBookmark: (bookmark) => tryStoragePromise("onNextSessionRestoreBookmark", () => storage.onNextSessionRestoreBookmark(bookmark)),
-	sql: fromSqlStorage(storage.sql),
-	kv: fromSyncKvStorage(storage.kv)
-});
-//#endregion
-//#region src/DurableObjectWebSocket.ts
-var DurableObjectWebSocket_exports = /* @__PURE__ */ __exportAll({
-	DurableWebSocketAttachmentError: () => DurableWebSocketAttachmentError,
-	DurableWebSocketCloseError: () => DurableWebSocketCloseError,
-	DurableWebSocketSendError: () => DurableWebSocketSendError,
-	acceptUpgrade: () => acceptUpgrade,
-	attachment: () => attachment,
-	fromWebSocket: () => fromWebSocket,
-	handlers: () => handlers
-});
-/** Error raised when sending on a Durable Object websocket fails. */
-var DurableWebSocketSendError = class extends Data.TaggedError("DurableWebSocketSendError") {
-	get message() {
-		return `Durable Object websocket send failed: ${causeMessage(this.cause)}`;
-	}
-};
-/** Error raised when closing a Durable Object websocket fails. */
-var DurableWebSocketCloseError = class extends Data.TaggedError("DurableWebSocketCloseError") {
-	get message() {
-		return `Durable Object websocket close failed: ${causeMessage(this.cause)}`;
-	}
-};
-/** Error raised when serializing or deserializing a websocket attachment fails. */
-var DurableWebSocketAttachmentError = class extends Data.TaggedError("DurableWebSocketAttachmentError") {
-	get message() {
-		return `Durable Object websocket attachment ${this.operation} failed: ${causeMessage(this.cause)}`;
-	}
-};
-const wrappers = /* @__PURE__ */ new WeakMap();
-/** Wraps a native Cloudflare websocket in the Effect-native Durable Object API. */
-const fromWebSocket = (raw) => {
-	const existing = wrappers.get(raw);
-	if (existing !== void 0) return existing;
-	const socket = {
-		raw,
-		send: (data) => Effect.try({
-			try: () => raw.send(data),
-			catch: (cause) => new DurableWebSocketSendError({ cause })
-		}),
-		close: (code, reason) => Effect.try({
-			try: () => raw.close(code, reason),
-			catch: (cause) => new DurableWebSocketCloseError({ cause })
-		}),
-		serializeAttachment: (value) => Effect.try({
-			try: () => raw.serializeAttachment(value),
-			catch: (cause) => new DurableWebSocketAttachmentError({
-				operation: "serialize",
-				cause
-			})
-		}),
-		deserializeAttachment: Effect.try({
-			try: () => raw.deserializeAttachment(),
-			catch: (cause) => new DurableWebSocketAttachmentError({
-				operation: "deserialize",
-				cause
-			})
-		})
-	};
-	wrappers.set(raw, socket);
-	return socket;
-};
-/**
-* Accepts a websocket upgrade and registers the server socket on `DurableObjectState`.
-*
-* @example
-* ```ts
-* const response = yield* DurableObjectWebSocket.acceptUpgrade({
-*   tags: ["room:general"],
-* });
-*
-* return response.response;
-* ```
-*/
-const acceptUpgrade = Effect.fn("DurableObjectWebSocket.acceptUpgrade")(function* (options = {}) {
-	const state = yield* DurableObjectState;
-	const pair = new WebSocketPair();
-	const client = pair[0];
-	const server = fromWebSocket(pair[1]);
-	if (options.attachment !== void 0) yield* server.serializeAttachment(options.attachment);
-	yield* state.acceptWebSocket(server, options.tags === void 0 ? void 0 : [...options.tags]);
-	return {
-		client,
-		server,
-		response: new Response(null, {
-			status: 101,
-			webSocket: client
-		})
-	};
-});
-/** Creates typed attachment helpers for accepted and rehydrated sockets. */
-const attachment = (schema) => {
-	const serialize = (socket, value) => Schema.encodeEffect(schema)(value).pipe(Effect.mapError((cause) => new DurableWebSocketAttachmentError({
-		operation: "serialize",
-		cause
-	})), Effect.flatMap((encoded) => socket.serializeAttachment(encoded)));
-	const deserialize = (socket) => Effect.gen(function* () {
-		const value = yield* socket.deserializeAttachment;
-		if (value === null || value === void 0) return Option.none();
-		return Option.some(yield* Schema.decodeUnknownEffect(schema)(value).pipe(Effect.mapError((cause) => new DurableWebSocketAttachmentError({
-			operation: "deserialize",
-			cause
-		}))));
-	});
-	const rehydrate = (options = {}) => Effect.gen(function* () {
-		const sockets = yield* (yield* DurableObjectState).getWebSockets(options.tag);
-		const restored = [];
-		const onInvalid = options.onInvalid ?? "ignore";
-		for (const socket of sockets) {
-			const decoded = yield* Effect.result(deserialize(socket));
-			if (Result.isSuccess(decoded) && Option.isSome(decoded.success)) {
-				restored.push({
-					socket,
-					attachment: decoded.success.value
-				});
-				continue;
-			}
-			if (Result.isFailure(decoded) && onInvalid === "fail") return yield* Effect.fail(decoded.failure);
-			if (Result.isFailure(decoded) && onInvalid === "ignore-and-close") yield* socket.close(1008, "invalid websocket attachment").pipe(Effect.ignore);
-		}
-		return restored;
-	});
-	return {
-		serialize,
-		deserialize,
-		rehydrate,
-		schema
-	};
-};
-/** Maps compact websocket lifecycle handler names to `DurableObject.make` options. */
-const handlers = (options) => ({
-	webSocketMessage: options.message,
-	webSocketClose: options.close,
-	webSocketError: options.error
-});
-//#endregion
-//#region src/internal/WorkerContext.ts
-const causeError = (cause) => {
-	const squashed = Cause.squash(cause);
-	return squashed instanceof Error ? squashed : new Error(Cause.pretty(cause), { cause: squashed });
-};
-const failureHandler = (label, cause, options) => (options?.onFailure?.(cause) ?? Effect.logError(`${label} failed`, Cause.pretty(cause))).pipe(Effect.catchCause((handlerCause) => Effect.logError(`${label} failure handler failed`, Cause.pretty(cause), Cause.pretty(handlerCause))));
-/**
-* Builds a `waitUntil` scheduler for any Cloudflare lifecycle that accepts
-* background promises (`ExecutionContext`, `DurableObjectState`).
-*
-* Background effects capture the calling fiber's context via `Effect.context`
-* before being registered, so the default module-level `Effect.runPromiseExit`
-* runner is sufficient; entrypoints may still pass a runtime-bound runner.
-*/
-const makeWaitUntilScheduler = (label, register, runPromiseExit = (effect) => Effect.runPromiseExit(effect)) => {
-	return (effect, options, mode) => Effect.context().pipe(Effect.flatMap((context) => Effect.sync(() => {
-		const runHandler = (cause) => runPromiseExit(Effect.scoped(Effect.provideContext(failureHandler(label, cause, options), context))).then((exit) => {
-			if (Exit.isFailure(exit)) console.error(`${label} failure handler failed`, Cause.pretty(exit.cause));
-		});
-		register(runPromiseExit(Effect.scoped(Effect.provideContext(effect, context))).then(async (exit) => {
-			if (Exit.isSuccess(exit)) return;
-			await runHandler(exit.cause);
-			if (mode === "propagate") throw causeError(exit.cause);
-		}));
-	})));
-};
-/**
-* Builds the `WorkerContext` service from a native `ExecutionContext`.
-*/
-const fromExecutionContext = (ctx, runPromiseExit = (effect) => Effect.runPromiseExit(effect)) => {
-	const schedule = makeWaitUntilScheduler("WorkerContext.waitUntil", (promise) => ctx.waitUntil(promise), runPromiseExit);
-	return {
-		raw: ctx,
-		waitUntil: (effect, options) => schedule(effect, options, options?.mode ?? "observe"),
-		waitUntilPropagating: (effect, options) => schedule(effect, options, "propagate"),
-		passThroughOnException: Effect.sync(() => ctx.passThroughOnException())
-	};
-};
-//#endregion
-//#region src/DurableObjectState.ts
-var DurableObjectState_exports = /* @__PURE__ */ __exportAll({
-	DurableObjectState: () => DurableObjectState,
-	fromDurableObjectState: () => fromDurableObjectState
-});
-/**
-* Context tag for accessing the current Durable Object state service.
-*/
-var DurableObjectState = class extends Context.Service()("effect-cf/DurableObjectState") {};
-/**
-* Wraps a native Cloudflare `DurableObjectState` as a {@link DurableObjectStateService}.
-*/
-const fromDurableObjectState = (state) => {
-	const scheduleWaitUntil = makeWaitUntilScheduler("DurableObjectState.waitUntil", (promise) => state.waitUntil(promise));
-	const waitUntil = ((input, options) => Effect.isEffect(input) ? scheduleWaitUntil(input, options, options?.mode ?? "observe") : Effect.sync(() => state.waitUntil(input)));
-	return {
-		raw: state,
-		id: state.id,
-		storage: fromDurableObjectStorage(state.storage),
-		waitUntil,
-		blockConcurrencyWhile: (effect) => Effect.context().pipe(Effect.flatMap((context) => Effect.promise(() => state.blockConcurrencyWhile(() => runPromiseExitPreservingTypedFailures(context, effect)))), Effect.flatten),
-		blockConcurrencyWhileOrReset: (effect) => Effect.context().pipe(Effect.flatMap((context) => Effect.promise(() => state.blockConcurrencyWhile(() => Effect.runPromiseWith(context)(effect))))),
-		acceptWebSocket: (ws, tags) => Effect.sync(() => state.acceptWebSocket(ws.raw, tags)),
-		getWebSockets: (tag) => Effect.sync(() => state.getWebSockets(tag).map((socket) => fromWebSocket(socket))),
-		setWebSocketAutoResponse: (pair) => Effect.sync(() => state.setWebSocketAutoResponse(pair)),
-		getWebSocketAutoResponse: Effect.sync(() => state.getWebSocketAutoResponse()),
-		getWebSocketAutoResponseTimestamp: (ws) => Effect.sync(() => state.getWebSocketAutoResponseTimestamp(ws.raw)),
-		setHibernatableWebSocketEventTimeout: (timeoutMs) => Effect.sync(() => state.setHibernatableWebSocketEventTimeout(timeoutMs)),
-		getHibernatableWebSocketEventTimeout: Effect.sync(() => state.getHibernatableWebSocketEventTimeout()),
-		getTags: (ws) => Effect.sync(() => state.getTags(ws.raw)),
-		abort: (reason) => Effect.sync(() => state.abort(reason))
-	};
-};
-const runPromiseExitPreservingTypedFailures = async (context, effect) => {
-	const exit = await Effect.runPromiseExitWith(context)(effect);
-	if (Exit.isFailure(exit) && (Cause.hasDies(exit.cause) || Cause.hasInterrupts(exit.cause))) throw Cause.squash(exit.cause);
-	return exit;
-};
-//#endregion
 //#region src/CloudflareOtlp.ts
 /**
 * OTLP telemetry layers for Cloudflare Workers and Durable Objects.
@@ -2530,7 +2134,6 @@ var DurableObjectAlarm_exports = /* @__PURE__ */ __exportAll({
 	InvalidRepeatEveryError: () => InvalidRepeatEveryError,
 	StoredAlarmDecodeError: () => StoredAlarmDecodeError,
 	define: () => define,
-	process: () => process,
 	processDue: () => processDue
 });
 const INIT_TABLE_SQL = `
@@ -2655,7 +2258,6 @@ const getFailureActionRetryDelay = (action) => typeof action === "string" || act
 const processDue = (handle, options = {}) => Effect.gen(function* () {
 	return yield* (yield* DurableObjectAlarm).processDueAlarms(handle, options);
 });
-const process = processDue;
 const isAlarmDefinitionConfig = (definition) => typeof definition === "object" && definition !== null && "payload" in definition;
 const getAlarmDefinitionSchema = (definition) => isAlarmDefinitionConfig(definition) ? definition.payload : definition;
 const getAlarmDefinitionFailureAction = (definition) => {
@@ -3018,7 +2620,6 @@ var Email_exports = /* @__PURE__ */ __exportAll({
 	Tag: () => Tag$7,
 	emailErrorCodes: () => emailErrorCodes,
 	isEmailBinding: () => isEmailBinding,
-	isEmailMessageBuilder: () => isEmailMessageBuilder,
 	layer: () => layer$6,
 	make: () => make$6,
 	makeClient: () => makeClient$6,
@@ -3109,24 +2710,6 @@ const tryEmailPromise = (binding, operation, evaluate) => Effect.tryPromise({
 	try: evaluate,
 	catch: (cause) => emailError(binding, operation, cause)
 });
-const builderFields = [
-	"subject",
-	"html",
-	"text",
-	"cc",
-	"bcc",
-	"replyTo",
-	"attachments",
-	"headers"
-];
-/**
-* Distinguishes structured Email Sending messages from raw MIME `EmailMessage`
-* values, which only carry envelope `from` and `to` addresses.
-*/
-const isEmailMessageBuilder = (message) => {
-	if (typeof message !== "object" || message === null) return false;
-	return builderFields.some((field) => Reflect.get(message, field) !== void 0);
-};
 const byteLength = (value) => textEncoder.encode(value).byteLength;
 const limitViolation = (path, label, actual, limit) => ({
 	path,
@@ -3261,7 +2844,7 @@ const makeClient$6 = (definition, options) => (email) => {
 	return {
 		definition,
 		send: Effect.fn("Email.send")(function* (message) {
-			if (validate && isEmailMessageBuilder(message)) yield* validateSendInput(definition.binding, "send", message);
+			if (validate) yield* validateSendInput(definition.binding, "send", message);
 			return yield* tryEmailPromise(definition.binding, "send", () => runtime.send(message));
 		}),
 		rawUnsafe: Effect.succeed(email)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-cf",
-  "version": "0.23.1",
+  "version": "0.25.0",
   "description": "Effect-native primitives for Cloudflare Workers and bindings.",
   "license": "MIT",
   "repository": {
@@ -27,6 +27,11 @@
       "import": "./dist/HyperdrivePg.mjs",
       "default": "./dist/HyperdrivePg.mjs"
     },
+    "./vitest": {
+      "types": "./dist/Vitest.d.mts",
+      "import": "./dist/Vitest.mjs",
+      "default": "./dist/Vitest.mjs"
+    },
     "./package.json": "./package.json"
   },
   "publishConfig": {
@@ -43,7 +48,7 @@
     "@cloudflare/containers": "catalog:",
     "@cloudflare/vitest-pool-workers": "catalog:",
     "@cloudflare/workers-types": "catalog:",
-    "@effect/platform-node": "4.0.0-beta.105",
+    "@effect/platform-node": "^4.0.0-beta.105",
     "@effect/sql-d1": "catalog:",
     "@effect/sql-pg": "catalog:",
     "@effect/sql-sqlite-do": "catalog:",
@@ -53,13 +58,17 @@
     "vitest": "catalog:"
   },
   "peerDependencies": {
+    "@cloudflare/vitest-pool-workers": "^0.21.3",
     "@cloudflare/workers-types": "^4.20260611.1",
-    "@effect/sql-d1": "4.0.0-beta.105",
-    "@effect/sql-pg": "4.0.0-beta.105",
-    "@effect/sql-sqlite-do": "4.0.0-beta.105",
-    "effect": "4.0.0-beta.105"
+    "@effect/sql-d1": "^4.0.0-beta.105",
+    "@effect/sql-pg": "^4.0.0-beta.105",
+    "@effect/sql-sqlite-do": "^4.0.0-beta.105",
+    "effect": "^4.0.0-beta.105"
   },
   "peerDependenciesMeta": {
+    "@cloudflare/vitest-pool-workers": {
+      "optional": true
+    },
     "@cloudflare/workers-types": {
       "optional": true
     },