effect-cf 0.33.0 → 0.35.0

package/dist/{ContainerNamespace-CFjiLw8b.d.mts → ContainerNamespace-DbLaeFhN.d.mts}

@@ -1,13 +1,10 @@
-import { c as WorkerEnvironment, r as BindingValidationError, t as BindingNotFoundError } from "./Binding-xJJJPmiD.mjs";
+import { c as WorkerEnvironment, r as BindingValidationError, t as BindingNotFoundError } from "./Binding-DKcLrQCM.mjs";
 import { Context, Effect, Layer, Schema } from "effect";
 declare namespace ContainerNamespace_d_exports {
   export { ContainerInstanceClient, ContainerNamespace, ContainerNamespaceClient, ContainerNamespaceDefinition, ContainerNamespaceResource, ContainerNamespaceService, ContainerNamespaceStaticClient, ContainerOperationError, ContainerReadinessOptions, ContainerSignal, ContainerStartAndWaitForPortsOptions, ContainerStartOptions, ContainerState, ContainerStopSignal, ContainerStub, ContainerStubOf, ContainerWaitOptions, LayerOptions, Tag, TagClass, isContainerNamespaceResource, layer, make, makeClient };
 }
-/** Named signal accepted by Cloudflare Container instances. */
 type ContainerSignal = "SIGKILL" | "SIGINT" | "SIGTERM";
-/** Named or numeric signal accepted by Container `stop()`. */
 type ContainerStopSignal = ContainerSignal | number;
-/** Per-instance Container startup configuration. */
 interface ContainerStartOptions {
   readonly envVars?: Record<string, string>;
   readonly entrypoint?: Array<string>;
@@ -26,7 +23,6 @@ interface ContainerReadinessOptions {
   readonly portReadyTimeoutMS?: number;
   readonly waitInterval?: number;
 }
-/** Options for starting a Container and waiting for its ports. */
 interface ContainerStartAndWaitForPortsOptions {
   readonly startOptions?: ContainerStartOptions;
   readonly ports?: number | Array<number>;
@@ -63,21 +59,16 @@ interface ContainerStub {
   removeAllowedHost(hostname: string): Promise<void>;
   removeDeniedHost(hostname: string): Promise<void>;
 }
-/** Native Container namespace binding shape. */
 interface ContainerNamespaceResource {
   getByName(name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions): ContainerStub;
 }
-/** Exact native stub type produced by a Container namespace binding. */
 type ContainerStubOf<Namespace extends ContainerNamespaceResource> = ReturnType<Namespace["getByName"]>;
-/** Container namespace binding metadata. */
 interface ContainerNamespaceDefinition {
-  /** Binding name as configured in `wrangler.jsonc`. */
   readonly binding: string;
 }
 declare const ContainerOperationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
   readonly _tag: "ContainerOperationError";
 } & Readonly<A>;
-/** Failure raised when invoking a named Container operation. */
 declare class ContainerOperationError extends ContainerOperationError_base<{
   readonly binding: string;
   readonly instance: string;
@@ -86,7 +77,6 @@ declare class ContainerOperationError extends ContainerOperationError_base<{
 }> {
   get message(): string;
 }
-/** Effect-wrapped client for one named Container instance. */
 interface ContainerInstanceClient<Stub extends ContainerStub = ContainerStub> {
   readonly rawUnsafe: Effect.Effect<Stub, ContainerOperationError>;
   readonly state: Effect.Effect<ContainerState, ContainerOperationError>;
@@ -103,7 +93,6 @@ interface ContainerInstanceClient<Stub extends ContainerStub = ContainerStub> {
   readonly removeAllowedHost: (hostname: string) => Effect.Effect<void, ContainerOperationError>;
   readonly removeDeniedHost: (hostname: string) => Effect.Effect<void, ContainerOperationError>;
 }
-/** Effect client for a Container namespace binding. */
 interface ContainerNamespaceClient<Namespace extends ContainerNamespaceResource = ContainerNamespaceResource> {
   readonly definition: ContainerNamespaceDefinition;
   readonly getByName: (name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => Effect.Effect<ContainerInstanceClient<ContainerStubOf<Namespace>>, ContainerOperationError>;
@@ -142,13 +131,11 @@ declare const makeClient: (definition: ContainerNamespaceDefinition) => <Namespa
 declare const layer: <Self, Namespace extends ContainerNamespaceResource>(tag: Context.Service<Self, ContainerNamespaceClient<Namespace>>, definition: ContainerNamespaceDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 declare const make: <Id extends string>(id: Id) => TagClass<ContainerNamespaceService<Id>, Id, ContainerNamespaceResource>;
 declare const ContainerNamespaceServiceTypeId: unique symbol;
-/** Nominal service marker for Container namespaces created with {@link make}. */
 interface ContainerNamespaceService<Id extends string> {
   readonly [ContainerNamespaceServiceTypeId]: {
     readonly id: Id;
   };
 }
-/** Creates a typed Effect service for a Cloudflare Container namespace. */
 declare const Tag: <Self, Namespace extends ContainerNamespaceResource = ContainerNamespaceResource>() => <Id extends string>(id: Id) => TagClass<Self, Id, Namespace>;
 declare const ContainerNamespace: typeof Tag;
 //#endregion

package/dist/{DurableObjectState-CVLLse69.mjs → DurableObjectState-DcqElJ4e.mjs}

@@ -1,12 +1,40 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { t as causeMessage } from "./ErrorMessage-BM0K-Nik.mjs";
-import { Cause, Clock, Context, Data, Duration, Effect, Exit, Option, Predicate, Result, Schema } from "effect";
+import { t as causeMessage } from "./ErrorMessage-Byx2OgNd.mjs";
+import { Cause, Clock, Context, Data, Duration, Effect, Exit, Fiber, FiberSet, Option, Predicate, Result, Schema } from "effect";
+//#region src/internal/NativeCallback.ts
+/**
+* Runs an Effect callback owned by a native Promise operation.
+*
+* The callback keeps the caller's context, while a private scope owns its
+* fiber. Closing that scope interrupts and joins the callback before awaiting
+* the native operation's settlement.
+*/
+const runNativeCallback = Effect.fnUntraced(function* (operation) {
+	const callerContext = yield* Effect.context();
+	return yield* Effect.scoped(Effect.gen(function* () {
+		let nativePromise;
+		yield* Effect.addFinalizer(() => {
+			const promise = nativePromise;
+			return promise === void 0 ? Effect.void : Effect.promise(() => promise.then(() => void 0, () => void 0));
+		});
+		const runPromise = yield* FiberSet.makeRuntimePromise();
+		return yield* Effect.callback((resume) => {
+			try {
+				nativePromise = operation((effect) => runPromise(Effect.provideContext(Effect.exit(effect), callerContext)));
+			} catch (cause) {
+				resume(Effect.fail(cause));
+				return;
+			}
+			nativePromise.then((value) => resume(Effect.succeed(value)), (cause) => resume(Effect.fail(cause)));
+		});
+	}));
+});
+//#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)}`;
@@ -93,9 +121,6 @@ const fromDurableObjectTransaction = (txn) => ({
 	setAlarmAfter: (delay, options) => setAlarmAfter("transaction.setAlarm", (scheduledTime, options) => txn.setAlarm(scheduledTime, options), delay, 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)),
@@ -107,30 +132,35 @@ const fromDurableObjectStorage = (storage) => ({
 	deleteAlarm: (options) => tryStoragePromise("deleteAlarm", () => storage.deleteAlarm(options)),
 	transactionSync: (closure) => Effect.context().pipe(Effect.flatMap((context) => Effect.suspend(() => {
 		let aborted;
+		let escapedFiber;
 		try {
 			return Effect.succeed(storage.transactionSync(() => {
 				const exit = Effect.runSyncExitWith(context)(closure());
 				if (Exit.isSuccess(exit)) return exit.value;
+				const defect = Cause.findDefect(exit.cause);
+				if (Result.isSuccess(defect) && Cause.isAsyncFiberError(defect.success)) {
+					escapedFiber = defect.success.fiber;
+					escapedFiber.interruptUnsafe();
+				}
 				aborted = exit;
 				throw exit;
 			}));
 		} catch (cause) {
-			if (aborted !== void 0 && cause === aborted && Exit.isFailure(aborted)) return Effect.failCause(aborted.cause);
-			return Effect.fail(storageError("transactionSync", cause));
+			const failure = aborted !== void 0 && cause === aborted && Exit.isFailure(aborted) ? Effect.failCause(aborted.cause) : Effect.fail(storageError("transactionSync", cause));
+			const fiber = escapedFiber;
+			if (fiber !== void 0) return Fiber.interrupt(fiber).pipe(Effect.andThen(failure));
+			return failure;
 		}
 	}))),
-	transaction: (closure) => Effect.context().pipe(Effect.flatMap((context) => Effect.callback((resume) => {
+	transaction: (closure) => Effect.suspend(() => {
 		let aborted;
-		storage.transaction(async (txn) => {
-			const exit = await Effect.runPromiseExitWith(context)(closure(fromDurableObjectTransaction(txn)));
+		return runNativeCallback((run) => storage.transaction(async (txn) => {
+			const exit = await run(Effect.suspend(() => closure(fromDurableObjectTransaction(txn))));
 			if (Exit.isSuccess(exit)) return exit.value;
 			aborted = exit;
 			throw exit;
-		}).then((value) => resume(Effect.succeed(value)), (cause) => {
-			if (aborted !== void 0 && cause === aborted && Exit.isFailure(aborted)) resume(Effect.failCause(aborted.cause));
-			else resume(Effect.fail(storageError("transaction", cause)));
-		});
-	}))),
+		})).pipe(Effect.catch((cause) => aborted !== void 0 && cause === aborted && Exit.isFailure(aborted) ? Effect.failCause(aborted.cause) : Effect.fail(storageError("transaction", cause))));
+	}),
 	sync: () => tryStoragePromise("sync", () => storage.sync()),
 	getCurrentBookmark: () => tryStoragePromise("getCurrentBookmark", () => storage.getCurrentBookmark()),
 	onNextSessionRestoreBookmark: (bookmark) => tryStoragePromise("onNextSessionRestoreBookmark", () => storage.onNextSessionRestoreBookmark(bookmark)),
@@ -148,13 +178,11 @@ var DurableObjectWebSocket_exports = /* @__PURE__ */ __exportAll({
 	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)}`;
@@ -166,51 +194,31 @@ var DurableWebSocketAttachmentError = class extends Data.TaggedError("DurableWeb
 		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
-			})
+const fromWebSocket = (raw) => ({
+	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
 		})
-	};
-	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;
-* ```
-*/
+	}),
+	deserializeAttachment: Effect.try({
+		try: () => raw.deserializeAttachment(),
+		catch: (cause) => new DurableWebSocketAttachmentError({
+			operation: "deserialize",
+			cause
+		})
+	})
+});
 const acceptUpgrade = Effect.fn("DurableObjectWebSocket.acceptUpgrade")(function* (options = {}) {
 	const state = yield* DurableObjectState;
 	const pair = new WebSocketPair();
@@ -227,7 +235,6 @@ const acceptUpgrade = Effect.fn("DurableObjectWebSocket.acceptUpgrade")(function
 		})
 	};
 });
-/** 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",
@@ -266,7 +273,6 @@ const attachment = (schema) => {
 		schema
 	};
 };
-/** Maps compact websocket lifecycle handler names to `DurableObject.make` options. */
 const handlers = (options) => ({
 	webSocketMessage: options.message,
 	webSocketClose: options.close,
@@ -278,30 +284,19 @@ 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 failureHandler = (label, cause, options) => Effect.suspend(() => 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))));
 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) => {
+		const runHandler = (cause) => runPromiseExit(Effect.provideContext(Effect.scoped(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) => {
+		register(runPromiseExit(Effect.provideContext(Effect.scoped(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 {
@@ -318,13 +313,7 @@ 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)));
@@ -333,8 +322,12 @@ const fromDurableObjectState = (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))))),
+		blockConcurrencyWhile: (effect) => runNativeCallback((run) => state.blockConcurrencyWhile(() => runExitPreservingTypedFailures(run, effect))).pipe(Effect.orDie, Effect.flatten),
+		blockConcurrencyWhileOrReset: (effect) => runNativeCallback((run) => state.blockConcurrencyWhile(async () => {
+			const exit = await run(effect);
+			if (Exit.isFailure(exit)) throw Cause.squash(exit.cause);
+			return exit.value;
+		})).pipe(Effect.orDie),
 		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)),
@@ -346,10 +339,10 @@ const fromDurableObjectState = (state) => {
 		abort: (reason, options) => Effect.sync(() => state.abort(reason, options))
 	};
 };
-const runPromiseExitPreservingTypedFailures = async (context, effect) => {
-	const exit = await Effect.runPromiseExitWith(context)(effect);
+const runExitPreservingTypedFailures = async (run, effect) => {
+	const exit = await run(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, DurableObjectStorage_exports as c, fromExecutionContext as i, DurableObjectState_exports as n, DurableWebSocketAttachmentError as o, fromDurableObjectState as r, fromWebSocket as s, DurableObjectState as t };
+export { DurableObjectWebSocket_exports as a, DurableObjectStorage_exports as c, fromExecutionContext as i, runNativeCallback as l, DurableObjectState_exports as n, DurableWebSocketAttachmentError as o, fromDurableObjectState as r, fromWebSocket as s, DurableObjectState as t };