effect-cf 0.23.1 → 0.25.0

package/dist/DurableObjectState-B5RCFnRy.mjs

@@ -0,0 +1,384 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { Cause, Config, ConfigProvider, Context, Data, Effect, Exit, Option, Result, Schema } from "effect";
+//#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.providerLayer = ConfigProvider.layer(provider);
+	_WorkerConfig.layerWith = (makeProvider) => ConfigProvider.layer(providerWith(makeProvider));
+})(WorkerConfig || (WorkerConfig = {}));
+//#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/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
+export { DurableObjectWebSocket_exports as a, causeMessage as c, WorkerConfig as d, WorkerEnvironment as f, fromExecutionContext as i, violationsMessage as l, DurableObjectState_exports as n, fromWebSocket as o, fromDurableObjectState as r, DurableObjectStorage_exports as s, DurableObjectState as t, Environment_exports as u };

package/dist/Hyperdrive-BwYp8Rsz.d.mts

@@ -0,0 +1,36 @@
+import { c as WorkerEnvironment, r as BindingValidationError, t as BindingNotFoundError } from "./Binding-DI7u3fEY.mjs";
+import { Context, Effect, Layer } from "effect";
+declare namespace Hyperdrive_d_exports {
+  export { HyperdriveClient, HyperdriveDefinition, HyperdriveService, LayerOptions, Tag, TagClass, isHyperdrive, layer, make, makeClient };
+}
+/** Typed Hyperdrive binding definition. */
+interface HyperdriveDefinition {
+  /** Binding name as configured in `wrangler.jsonc`. */
+  readonly binding: string;
+}
+interface HyperdriveClient {
+  readonly connectionString: string;
+  readonly rawUnsafe: Effect.Effect<Hyperdrive>;
+  readonly definition: HyperdriveDefinition;
+}
+declare const HyperdriveServiceTypeId: unique symbol;
+/** Nominal service marker for Hyperdrive services created with {@link make}. */
+interface HyperdriveService<Id extends string> {
+  readonly [HyperdriveServiceTypeId]: {
+    readonly id: Id;
+  };
+}
+type LayerOptions = {
+  readonly binding: string;
+};
+interface TagClass<Self, Id extends string> extends Context.ServiceClass<Self, Id, HyperdriveClient> {
+  readonly id: Id;
+  readonly layer: (options: LayerOptions) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+}
+declare const isHyperdrive: (value: unknown) => value is Hyperdrive;
+declare const makeClient: (definition: HyperdriveDefinition) => (hyperdrive: Hyperdrive) => HyperdriveClient;
+declare const layer: <Self>(tag: Context.Service<Self, HyperdriveClient>, definition: HyperdriveDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const make: <Id extends string>(id: Id) => TagClass<HyperdriveService<Id>, Id>;
+declare const Tag: <Self>() => <Id extends string>(id: Id) => TagClass<Self, Id>;
+//#endregion
+export { LayerOptions as n, TagClass as r, Hyperdrive_d_exports as t };

package/dist/HyperdrivePg.d.mts

@@ -1,4 +1,5 @@
-import { d as WorkerEnvironment, i as BindingNotFoundError, n as LayerOptions, o as BindingValidationError, r as TagClass } from "./Hyperdrive-COyg7R26.mjs";
+import { c as WorkerEnvironment, r as BindingValidationError, t as BindingNotFoundError } from "./Binding-DI7u3fEY.mjs";
+import { n as LayerOptions, r as TagClass } from "./Hyperdrive-BwYp8Rsz.mjs";
 import { Layer } from "effect";
 import { PgClient } from "@effect/sql-pg";
 import { SqlClient, SqlError } from "effect/unstable/sql";

package/dist/Vitest.d.mts

@@ -0,0 +1,192 @@
+import { c as WorkerEnvironment, s as WorkerEnv } from "./Binding-DI7u3fEY.mjs";
+import { c as DurableObjectState, l as DurableObjectStateService, o as WorkflowInstanceStatusName } from "./WorkflowBinding--eMVaixT.mjs";
+import { Effect, Layer } from "effect";
+import { DurableObject } from "cloudflare:workers";
+import { adminSecretsStore as adminSecretsStore$1, getQueueResult, introspectWorkflow as introspectWorkflow$1, introspectWorkflowInstance as introspectWorkflowInstance$1 } from "cloudflare:test";
+//#region src/Vitest.d.ts
+/**
+ * Provides the Workers pool environment as both {@link WorkerEnvironment} and
+ * the active Effect `ConfigProvider`.
+ */
+declare const layer: Layer.Layer<WorkerEnvironment>;
+/** Constructor shape shared by Effect-backed Worker entrypoints. */
+interface WorkerConstructor<Instance> {
+  new (context: globalThis.ExecutionContext, env: WorkerEnv): Instance;
+}
+/**
+ * Creates an `ExecutionContext` and drains all `waitUntil` work before the
+ * returned effect completes, including when `use` fails or is interrupted.
+ */
+declare const withExecutionContext: <A, E, R>(use: (context: globalThis.ExecutionContext) => Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+interface FetchWorker {
+  fetch(request: Request): Promise<Response>;
+}
+/**
+ * Invokes an Effect-backed Worker fetch handler and drains its `waitUntil`
+ * work before returning the response.
+ */
+declare const fetch: <Instance extends FetchWorker>(Worker: WorkerConstructor<Instance>, request: Request<unknown, CfProperties<unknown>>, workerEnv?: Cloudflare.Env | undefined) => Effect.Effect<Response, never, never>;
+/** Modules-format scheduled handler accepted by {@link scheduled}. */
+type ScheduledHandler = NonNullable<globalThis.ExportedHandler<WorkerEnv>["scheduled"]>;
+/** Options used to construct a scheduled event controller. */
+interface ScheduledOptions {
+  readonly scheduledTime?: number | Date;
+  readonly cron?: string;
+}
+/**
+ * Invokes a modules-format scheduled handler and drains its `waitUntil` work.
+ */
+declare const scheduled: (handler: ExportedHandlerScheduledHandler<Cloudflare.Env, unknown>, options?: ScheduledOptions | undefined, workerEnv?: Cloudflare.Env | undefined) => Effect.Effect<ScheduledController, never, never>;
+type AnyPagesFunction = globalThis.PagesFunction<WorkerEnv, string, any>;
+interface PagesEventContextInitBase {
+  readonly request: Request<unknown, IncomingRequestCfProperties>;
+  readonly functionPath?: string;
+  readonly next?: (request: Request) => Response | Promise<Response>;
+}
+type PagesEventContextInitParams<Context> = Context extends globalThis.EventContext<unknown, infer Params, unknown> ? [Params] extends [never] ? {
+  readonly params?: Record<string, never>;
+} : {
+  readonly params: Record<Params, string | Array<string>>;
+} : never;
+type PagesEventContextInitData<Context> = Context extends globalThis.EventContext<unknown, string, infer Data> ? Data extends Record<string, never> ? {
+  readonly data?: Data;
+} : {
+  readonly data: Data;
+} : never;
+/** Initialization accepted by Pool Workers for a Pages Function. */
+type PagesEventContextInit<Function extends AnyPagesFunction> = PagesEventContextInitBase & PagesEventContextInitParams<Parameters<Function>[0]> & PagesEventContextInitData<Parameters<Function>[0]>;
+/**
+ * Invokes a Pages Function with a typed event context and drains its
+ * `waitUntil` work, including when the function fails.
+ */
+declare const pages: <Function extends AnyPagesFunction>(handler: Function, init: PagesEventContextInit<Function>) => Effect.Effect<Response, never, never>;
+interface QueueWorker {
+  queue(batch: globalThis.MessageBatch): Promise<void>;
+}
+/** Input message accepted by Pool Workers' `createMessageBatch` helper. */
+type QueueMessage<Body> = {
+  readonly id: string;
+  readonly timestamp: Date;
+  readonly attempts: number;
+} & ({
+  readonly body: Body;
+} | {
+  readonly serializedBody: ArrayBuffer | ArrayBufferView;
+});
+/** Acknowledgement and retry result returned by Pool Workers. */
+type QueueResult = Awaited<ReturnType<typeof getQueueResult>>;
+/** Result of invoking a queue consumer through {@link queue}. */
+interface QueueRunResult<Body> {
+  readonly batch: globalThis.MessageBatch<Body>;
+  readonly result: QueueResult;
+}
+/**
+ * Invokes an Effect-backed queue consumer, drains its `waitUntil` work, and
+ * returns Pool Workers' acknowledgement and retry result.
+ */
+declare const queue: <Body, Instance extends QueueWorker>(Worker: WorkerConstructor<Instance>, queueName: string, messages: readonly QueueMessage<Body>[], workerEnv?: Cloudflare.Env | undefined) => Effect.Effect<QueueRunResult<Body>, never, never>;
+/**
+ * Runs an Effect inside the I/O context of a Durable Object instance.
+ *
+ * The caller's Effect context is preserved, and the instance's native state is
+ * provided as {@link DurableObjectState}. A wrapped state service is also
+ * passed to `use` for direct access.
+ */
+declare const runInDurableObject: <Object extends DurableObject, A, E, R>(stub: DurableObjectStub<Object>, use: (instance: Object, state: DurableObjectStateService) => Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, DurableObjectState>>;
+/** Immediately runs and removes a scheduled Durable Object alarm. */
+declare const runDurableObjectAlarm: (stub: DurableObjectStub<DurableObject<Cloudflare.Env, {}>>) => Effect.Effect<boolean, never, never>;
+/** Options controlling how Durable Object eviction handles WebSockets. */
+interface DurableObjectEvictionOptions {
+  readonly webSockets?: "close" | "hibernate";
+}
+/** Gracefully evicts one running Durable Object while preserving durable storage. */
+declare const evictDurableObject: (stub: DurableObjectStub<DurableObject<Cloudflare.Env, {}>>, options?: DurableObjectEvictionOptions | undefined) => Effect.Effect<void, never, never>;
+/** Lists all IDs created in a Durable Object namespace. */
+declare const listDurableObjectIds: <Object extends DurableObject | undefined>(namespace: DurableObjectNamespace<Object>) => Effect.Effect<DurableObjectId[], never, never>;
+/** Deletes data from all bindings attached to the current test Worker. */
+declare const reset: () => Effect.Effect<void, never, never>;
+/** Aborts all Durable Object instances without deleting their persisted data. */
+declare const abortAllDurableObjects: () => Effect.Effect<void, never, never>;
+/** Gracefully evicts all running Durable Objects while preserving durable storage. */
+declare const evictAllDurableObjects: (options?: DurableObjectEvictionOptions | undefined) => Effect.Effect<void, never, never>;
+/** A D1 migration accepted by Pool Workers. */
+interface D1Migration {
+  readonly name: string;
+  readonly queries: ReadonlyArray<string>;
+}
+/** Applies all D1 migrations that have not already been recorded. */
+declare const applyD1Migrations: (database: D1Database, migrations: readonly D1Migration[], migrationsTableName?: string | undefined) => Effect.Effect<void, never, never>;
+type NativeSecretsStoreAdmin = ReturnType<typeof adminSecretsStore$1>;
+/** Secret metadata returned by {@link SecretsStoreAdmin.list}. */
+interface SecretsStoreSecret {
+  readonly name: string;
+  readonly metadata?: {
+    readonly uuid: string;
+  };
+}
+/** Effect-native wrapper around Pool Workers' Secrets Store admin API. */
+interface SecretsStoreAdmin {
+  readonly raw: NativeSecretsStoreAdmin;
+  readonly create: (value: string) => Effect.Effect<string>;
+  readonly update: (value: string, id: string) => Effect.Effect<string>;
+  readonly duplicate: (id: string, newName: string) => Effect.Effect<string>;
+  readonly delete: (id: string) => Effect.Effect<void>;
+  readonly list: Effect.Effect<Array<SecretsStoreSecret>>;
+  readonly get: (id: string) => Effect.Effect<string>;
+}
+/** Acquires an Effect-native admin client for a Secrets Store binding. */
+declare const adminSecretsStore: (binding: {
+  get(): Promise<string>;
+}) => Effect.Effect<SecretsStoreAdmin, never, never>;
+type NativeWorkflowIntrospector = Awaited<ReturnType<typeof introspectWorkflow$1>>;
+type NativeWorkflowInstanceIntrospector = Awaited<ReturnType<typeof introspectWorkflowInstance$1>>;
+/** Identifies one occurrence of a Workflow step or sleep. */
+interface WorkflowStepTarget {
+  readonly name: string;
+  readonly index?: number;
+}
+/** Event delivered to a mocked Workflow `waitForEvent` operation. */
+interface WorkflowMockEvent {
+  readonly type: string;
+  readonly payload: unknown;
+}
+/** Effect-native Workflow behavior modifier. */
+interface WorkflowInstanceModifier {
+  readonly disableSleeps: (steps?: ReadonlyArray<WorkflowStepTarget>) => Effect.Effect<void>;
+  readonly disableRetryDelays: (steps?: ReadonlyArray<WorkflowStepTarget>) => Effect.Effect<void>;
+  readonly mockStepResult: (step: WorkflowStepTarget, result: unknown) => Effect.Effect<void>;
+  readonly mockStepError: (step: WorkflowStepTarget, error: Error, times?: number) => Effect.Effect<void>;
+  readonly forceStepTimeout: (step: WorkflowStepTarget, times?: number) => Effect.Effect<void>;
+  readonly mockEvent: (event: WorkflowMockEvent) => Effect.Effect<void>;
+  readonly forceEventTimeout: (step: WorkflowStepTarget) => Effect.Effect<void>;
+}
+/** Effect-native introspector for one Workflow instance. */
+interface WorkflowInstanceIntrospector {
+  readonly raw: NativeWorkflowInstanceIntrospector;
+  readonly modify: <A, E, R>(use: (modifier: WorkflowInstanceModifier) => Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+  readonly waitForStepResult: (step: WorkflowStepTarget) => Effect.Effect<unknown>;
+  readonly waitForStatus: (status: WorkflowInstanceStatusName) => Effect.Effect<void>;
+  readonly getOutput: Effect.Effect<unknown>;
+  readonly getError: Effect.Effect<{
+    readonly name: string;
+    readonly message: string;
+  }>;
+}
+/** Effect-native introspector for subsequently created Workflow instances. */
+interface WorkflowIntrospector {
+  readonly raw: NativeWorkflowIntrospector;
+  readonly modifyAll: <A, E, R>(use: (modifier: WorkflowInstanceModifier) => Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+  readonly get: Effect.Effect<ReadonlyArray<WorkflowInstanceIntrospector>>;
+}
+/**
+ * Acquires an Effect-native Workflow introspector that is disposed when the
+ * surrounding Effect scope closes.
+ */
+declare const introspectWorkflow: (workflow: Workflow<unknown>) => Effect.Effect<WorkflowIntrospector, never, import("effect/Scope").Scope>;
+/**
+ * Acquires an Effect-native Workflow instance introspector that is disposed
+ * when the surrounding Effect scope closes.
+ */
+declare const introspectWorkflowInstance: (workflow: Workflow<unknown>, instanceId: string) => Effect.Effect<WorkflowInstanceIntrospector, never, import("effect/Scope").Scope>;
+//#endregion
+export { D1Migration, DurableObjectEvictionOptions, PagesEventContextInit, QueueMessage, QueueResult, QueueRunResult, ScheduledHandler, ScheduledOptions, SecretsStoreAdmin, SecretsStoreSecret, WorkerConstructor, WorkflowInstanceIntrospector, WorkflowInstanceModifier, WorkflowIntrospector, WorkflowMockEvent, WorkflowStepTarget, abortAllDurableObjects, adminSecretsStore, applyD1Migrations, evictAllDurableObjects, evictDurableObject, fetch, introspectWorkflow, introspectWorkflowInstance, layer, listDurableObjectIds, pages, queue, reset, runDurableObjectAlarm, runInDurableObject, scheduled, withExecutionContext };