effect-cf 0.39.1 → 0.40.1

package/dist/{ComputerWorkspaceHostRegistry-CY5Fv4Ng.mjs → internal/ComputerWorkspaceHostRegistry.mjs}

@@ -5,4 +5,4 @@ const register = (state, host) => {
 };
 const lookup = (state) => hosts.get(state);
 //#endregion
-export { register as n, lookup as t };
+export { lookup, register };

package/dist/internal/Entrypoint.mjs

@@ -0,0 +1,37 @@
+import { assertNoReservedMethods, encodeWireError } from "../RpcDefinition.mjs";
+import { RpcTraceContext } from "../RpcTracing.mjs";
+import { CurrentInvocation } from "./RpcInvocation.mjs";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as Layer from "effect/Layer";
+//#region src/internal/Entrypoint.ts
+const isRpcTraceContext = Schema.is(RpcTraceContext);
+const invokeEntrypointRpcMethod = (self, method, args, run, onExit, service, key, rpcTracing) => {
+	const last = args.at(-1);
+	const parent = rpcTracing !== void 0 && isRpcTraceContext(last) ? last : void 0;
+	const handlerArgs = parent === void 0 ? args : args.slice(0, -1);
+	const invocation = {
+		service: rpcTracing?.service ?? service,
+		method: key,
+		args: handlerArgs,
+		parent
+	};
+	const handler = Effect.suspend(() => method(...handlerArgs)).pipe(Effect.provideService(CurrentInvocation, invocation), Effect.mapError(encodeWireError));
+	return run(self, onExit === void 0 ? handler : handler.pipe(Effect.onExit(() => onExit(self))), invocation);
+};
+const provideEntrypointServices = (layer, services) => layer.pipe(Layer.provideMerge(services));
+const defineEntrypointRpcMethods = (target, prototype, rpc, reservedMethodNames, run, onExit, rpcTracing) => {
+	const methods = rpc ?? {};
+	assertNoReservedMethods(target, methods, reservedMethodNames);
+	for (const [key, method] of Object.entries(methods)) Object.defineProperty(prototype, key, {
+		enumerable: true,
+		value(...args) {
+			return invokeEntrypointRpcMethod(this, method, args, run, onExit, target, key, rpcTracing);
+		}
+	});
+};
+const assumeEntrypointClass = (entrypoint) => {
+	return entrypoint;
+};
+//#endregion
+export { assumeEntrypointClass, defineEntrypointRpcMethods, provideEntrypointServices };

package/dist/internal/ErrorMessage.mjs

@@ -0,0 +1,17 @@
+import * as Predicate from "effect/Predicate";
+//#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 (Predicate.hasProperty(cause, "message") && Predicate.isString(cause.message) && cause.message.length > 0) return cause.message;
+	try {
+		return String(cause);
+	} catch {
+		return "unknown cause";
+	}
+};
+const violationsMessage = (violations) => violations.map((violation) => `${violation.path}: ${violation.message}`).join("; ");
+//#endregion
+export { causeMessage, violationsMessage };

package/dist/internal/NativeCallback.mjs

@@ -0,0 +1,33 @@
+import * as Effect from "effect/Effect";
+import "effect/Exit";
+import * as FiberSet from "effect/FiberSet";
+//#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
+export { runNativeCallback };

package/dist/internal/RpcInvocation.d.mts

@@ -0,0 +1,13 @@
+import { Result } from "../Rpc.mjs";
+import "../RpcTracing.mjs";
+import "effect/Context";
+import "effect/Effect";
+import "effect/Schema";
+//#region src/internal/RpcInvocation.d.ts
+type AnyArgs = Array<any>;
+type AsyncMethodKey<Api> = { [Key in keyof Api]-?: Key extends string ? Api[Key] extends ((...args: AnyArgs) => Promise<any>) ? Key : never : never; }[keyof Api];
+type AsyncMethodArgs<Api, Method extends keyof Api> = Api[Method] extends ((...args: infer Args) => Promise<any>) ? Args : never;
+type AsyncMethodSuccess<Api, Method extends keyof Api> = Api[Method] extends ((...args: AnyArgs) => Promise<infer A>) ? A : never;
+type AsyncMethodCloudflareReturn<Api, Method extends keyof Api> = Result<AsyncMethodSuccess<Api, Method>>;
+//#endregion
+export { AsyncMethodArgs, AsyncMethodCloudflareReturn, AsyncMethodKey, AsyncMethodSuccess };

package/dist/internal/RpcInvocation.mjs

@@ -0,0 +1,34 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import "effect/Schema";
+import * as Predicate from "effect/Predicate";
+import * as Option from "effect/Option";
+//#region src/internal/RpcInvocation.ts
+/** Scoped to the incoming event effect, never the instance runtime or storage. */
+var CurrentInvocation = class extends Context.Service()("effect-cf/internal/RpcInvocation") {};
+const recordDecodedArgs = (args) => Effect.map(Effect.serviceOption(CurrentInvocation), (invocation) => {
+	if (Option.isSome(invocation)) invocation.value.decodedArgs = args;
+});
+const invokeWithReceiver = (value, receiver, args) => {
+	return Function.prototype.apply.call(value, receiver, args);
+};
+const lookupRpcMethod = (target, method, makeError) => Effect.try({
+	try: () => {
+		if (!Predicate.isObjectKeyword(target)) throw new TypeError(`RPC target is not object-like`);
+		const receiver = target;
+		const value = receiver[method];
+		if (!Predicate.isFunction(value)) throw new TypeError(`RPC method "${String(method)}" is not callable`);
+		const callable = value;
+		return (...args) => invokeWithReceiver(callable, receiver, args);
+	},
+	catch: makeError
+});
+const invokeRpcMethod = Effect.fnUntraced(function* (target, method, args, makeError) {
+	const fn = yield* lookupRpcMethod(target, method, makeError);
+	return yield* Effect.try({
+		try: () => fn(...args),
+		catch: makeError
+	});
+});
+//#endregion
+export { CurrentInvocation, invokeRpcMethod, lookupRpcMethod, recordDecodedArgs };

package/dist/internal/Runtime.mjs

@@ -0,0 +1,31 @@
+import { WorkerConfig, WorkerEnvironment } from "../Environment.mjs";
+import { provideEntrypointServices } from "./Entrypoint.mjs";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as ConfigProvider from "effect/ConfigProvider";
+import * as ManagedRuntime from "effect/ManagedRuntime";
+//#region src/internal/Runtime.ts
+/**
+* Assembles the shared `ManagedRuntime` used by the Cloudflare entrypoint
+* classes (Worker, Durable Object, Workflow).
+*
+* The entrypoint-specific services are merged with the env-backed
+* `ConfigProvider` and `WorkerEnvironment`, then provided to the user-supplied
+* layer so the resulting runtime satisfies both the user services and the
+* platform services.
+*/
+const makeEntrypointRuntime = (layer, env, services) => {
+	const entrypointServices = Layer.mergeAll(services, ConfigProvider.layer(WorkerConfig.providerFromEnv(env)), Layer.succeed(WorkerEnvironment, env));
+	return ManagedRuntime.make(provideEntrypointServices(layer, entrypointServices));
+};
+function runEventPromise(...args) {
+	const [runtime, effect, eventLayer, parent] = args;
+	if (eventLayer === void 0) {
+		const event = Effect.scoped(effect);
+		return runtime.runPromise(parent === void 0 ? event : Effect.withParentSpan(event, parent));
+	}
+	const event = Effect.scoped(effect.pipe(Effect.provide(eventLayer, { local: true })));
+	return runtime.runPromise(parent === void 0 ? event : Effect.withParentSpan(event, parent));
+}
+//#endregion
+export { makeEntrypointRuntime, runEventPromise };

package/dist/internal/Telemetry.mjs

@@ -0,0 +1,20 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { Flusher } from "effect/unstable/observability/OtlpExporter";
+//#region src/internal/Telemetry.ts
+/** Maximum event lifetime spent on an internally scheduled telemetry flush. */
+const scheduledFlushTimeout = "2 seconds";
+/**
+* Schedules a configured OTLP flusher through the current Cloudflare event.
+*
+* The handed-off effect is best-effort: it settles within two seconds and
+* silently absorbs every failure cause so telemetry cannot extend or fail the
+* user event, or recursively log through an unhealthy exporter.
+*/
+const scheduleTelemetryFlush = (waitUntil) => Effect.gen(function* () {
+	const flusher = yield* Effect.serviceOption(Flusher);
+	if (Option.isNone(flusher)) return;
+	yield* waitUntil(flusher.value.flush.pipe(Effect.timeoutOption(scheduledFlushTimeout), Effect.ignoreCause, Effect.asVoid));
+}).pipe(Effect.ignoreCause);
+//#endregion
+export { scheduleTelemetryFlush };

package/dist/{WorkerContext-Yobnfw-K.mjs → internal/WorkerContext.mjs}

@@ -1,33 +1,6 @@
-import { Cause, Effect, Exit, FiberSet } 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
+import * as Effect from "effect/Effect";
+import * as Cause from "effect/Cause";
+import * as Exit from "effect/Exit";
 //#region src/internal/WorkerContext.ts
 const causeError = (cause) => {
 	const squashed = Cause.squash(cause);
@@ -57,4 +30,4 @@ const fromExecutionContext = (ctx, runPromiseExit = (effect) => Effect.runPromis
 	};
 };
 //#endregion
-export { makeWaitUntilScheduler as n, runNativeCallback as r, fromExecutionContext as t };
+export { fromExecutionContext, makeWaitUntilScheduler };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-cf",
-  "version": "0.39.1",
+  "version": "0.40.1",
   "description": "Effect-native primitives for Cloudflare Workers and bindings.",
   "license": "MIT",
   "repository": {

package/src/AiGateway.ts

@@ -1,4 +1,8 @@
-import { Context, Data, Effect, type Layer, Schema as S } from "effect";
+import * as Context from "effect/Context";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as S from "effect/Schema";
+import type { Layer } from "effect";
 import type { AiGateway as CloudflareAiGateway } from "@cloudflare/workers-types";
 
 import * as Binding from "./Binding";

package/src/AnalyticsEngine.ts

@@ -2,25 +2,20 @@ import type {
   AnalyticsEngineDataPoint as CloudflareAnalyticsEngineDataPoint,
   AnalyticsEngineDataset as CloudflareAnalyticsEngineDataset,
 } from "@cloudflare/workers-types";
-import {
-  type Redacted,
-  Config,
-  Context,
-  Data,
-  Effect,
-  Layer,
-  Option,
-  Predicate,
-  Result,
-  Schema as S,
-} from "effect";
-import {
-  FetchHttpClient,
-  type Headers,
-  HttpClient,
-  type HttpClientResponse,
-  HttpClientRequest,
-} from "effect/unstable/http";
+import * as Config from "effect/Config";
+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 Predicate from "effect/Predicate";
+import * as Result from "effect/Result";
+import * as S from "effect/Schema";
+import type { Redacted } from "effect";
+import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import * as HttpClientRequest from "effect/unstable/http/HttpClientRequest";
+import type { Headers, HttpClientResponse } from "effect/unstable/http";
 
 import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";

package/src/Artifacts.ts

@@ -6,7 +6,12 @@ import type {
   ArtifactsTokenInfo as CloudflareArtifactsTokenInfo,
   ArtifactsTokenListResult as CloudflareArtifactsTokenListResult,
 } from "@cloudflare/workers-types";
-import { Context, Data, Effect, type Layer, Predicate, Schema } from "effect";
+import * as Context from "effect/Context";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Predicate from "effect/Predicate";
+import * as Schema from "effect/Schema";
+import type { Layer } from "effect";
 
 import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";

package/src/Binding.ts

@@ -1,4 +1,8 @@
-import { Context, Data, Effect, Layer, Predicate } from "effect";
+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 Predicate from "effect/Predicate";
 
 import { WorkerEnvironment, type WorkerEnv } from "./Environment";
 

package/src/BrowserRendering.ts

@@ -1,4 +1,8 @@
-import { Context, Data, Effect, type Layer, Predicate } from "effect";
+import * as Context from "effect/Context";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Predicate from "effect/Predicate";
+import type { Layer } from "effect";
 
 import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";

package/src/Cache.ts

@@ -4,7 +4,11 @@ import type {
   CacheStorage as CloudflareCacheStorage,
   RequestInfo as CloudflareRequestInfo,
 } from "@cloudflare/workers-types";
-import { Context, Data, Effect, Layer, Option } from "effect";
+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 ErrorMessage from "./internal/ErrorMessage";
 

package/src/CloudflareOtlp.ts

@@ -4,17 +4,19 @@
  * flush explicitly. Scheduled flush failures cannot fail user events. Exporter
  * layer finalizers run separately and follow their configured shutdown timeout.
  */
-import { ConfigProvider, Effect, Layer, Option } from "effect";
+import * as ConfigProvider from "effect/ConfigProvider";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
 import type * as Tracer from "effect/Tracer";
-import { FetchHttpClient, type Headers } from "effect/unstable/http";
-import {
-  OtlpExporter,
-  OtlpLogger,
-  OtlpMetrics,
-  OtlpResource,
-  OtlpSerialization,
-  OtlpTracer,
-} from "effect/unstable/observability";
+import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+import type { Headers } from "effect/unstable/http";
+import * as OtlpExporter from "effect/unstable/observability/OtlpExporter";
+import * as OtlpLogger from "effect/unstable/observability/OtlpLogger";
+import * as OtlpMetrics from "effect/unstable/observability/OtlpMetrics";
+import * as OtlpResource from "effect/unstable/observability/OtlpResource";
+import * as OtlpSerialization from "effect/unstable/observability/OtlpSerialization";
+import * as OtlpTracer from "effect/unstable/observability/OtlpTracer";
 
 import { DurableObjectState } from "./DurableObjectState";
 import { WorkerConfig, WorkerEnvironment } from "./Environment";

package/src/CloudflareTracer.ts

@@ -1,6 +1,12 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { tracing } from "cloudflare:workers";
-import { Cause, Effect, Exit, Layer, Option, Predicate, Tracer } from "effect";
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as Tracer from "effect/Tracer";
 
 type SpanOptions = Parameters<Tracer.Tracer["span"]>[0];
 type RunInContext = ReturnType<typeof AsyncLocalStorage.snapshot>;

package/src/ComputerArtifacts.ts

@@ -8,7 +8,8 @@ import type {
   ArtifactsCLIResult as CloudflareComputerArtifactsCliResult,
   RemoteAddFn as CloudflareComputerRemoteAdd,
 } from "@cloudflare/computer/artifacts";
-import { Effect, Predicate } from "effect";
+import * as Effect from "effect/Effect";
+import * as Predicate from "effect/Predicate";
 
 import * as Artifacts from "./Artifacts";
 

package/src/ComputerWorkspace.ts

@@ -27,7 +27,13 @@ import type {
   GitLogOptions as CloudflareGitLogOptions,
   GitUpdateRefOptions as CloudflareGitUpdateRefOptions,
 } from "@cloudflare/computer/git";
-import { Context, Effect, Layer, Predicate, Schema, type Scope, Stream } from "effect";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Predicate from "effect/Predicate";
+import * as Schema from "effect/Schema";
+import * as Stream from "effect/Stream";
+import type { Scope } from "effect";
 
 import * as ComputerArtifacts from "./ComputerArtifacts";
 import { DurableObjectState } from "./DurableObjectState";

package/src/ContainerNamespace.ts

@@ -1,4 +1,9 @@
-import { Context, Data, Effect, Predicate, Schema as S, type Layer } from "effect";
+import * as Context from "effect/Context";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Predicate from "effect/Predicate";
+import * as S from "effect/Schema";
+import type { Layer } from "effect";
 
 import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";

package/src/D1.ts

@@ -1,5 +1,8 @@
 import { D1Client } from "@effect/sql-d1";
-import { Effect, Layer, Predicate, type Config } from "effect";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Predicate from "effect/Predicate";
+import type { Config } from "effect";
 import type { SqlClient } from "effect/unstable/sql";
 
 import * as Binding from "./Binding";