effect-cf 0.40.0 → 0.40.1

package/dist/RpcTracing.d.mts

@@ -0,0 +1,52 @@
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as Tracer from "effect/Tracer";
+declare namespace RpcTracing_d_exports {
+  export { ReceiverOptions, RpcInvocationInfo, RpcTraceContext, withRpcClientSpan, withRpcServerSpan, withRpcTraceContext };
+}
+/**
+ * Live native RPC metadata. Opted-in receivers reserve a valid trailing value
+ * with this tag for transport context; do not use it as a final domain argument.
+ * Never store this in durable messages or envelopes.
+ */
+declare const RpcTraceContext: Schema.Struct<{
+  readonly _tag: Schema.Literal<"effect-cf/RpcTraceContext/v1">;
+  readonly traceId: Schema.String;
+  readonly spanId: Schema.String;
+  readonly sampled: Schema.Boolean;
+}>;
+type RpcTraceContext = typeof RpcTraceContext.Type;
+interface ReceiverOptions {
+  /** Stable service name, never an instance id or capability URL. */
+  readonly service: string;
+}
+/** Per-invocation metadata passed to Worker and DurableObject RunSymbol overrides. */
+interface RpcInvocationInfo {
+  readonly service: string;
+  readonly method: string;
+  /** Native arguments with valid, opted-in trace metadata removed. Do not log them. */
+  readonly args: ReadonlyArray<unknown>;
+  /**
+   * Set after a definition-backed receiver decodes its arguments, before its
+   * handler runs. Absent before decoding and when decoding fails. Do not log it.
+   */
+  readonly decodedArgs?: ReadonlyArray<unknown>;
+  readonly parent?: RpcTraceContext;
+}
+/**
+ * Appends the current live parent only for a receiver that has opted in.
+ * Call this inside the CLIENT span, immediately before the native invocation.
+ * With no valid propagating parent, the original argument array is returned.
+ */
+declare const withRpcTraceContext: (args: readonly unknown[]) => Effect.Effect<readonly unknown[], never, never>;
+/** Wrap the whole call, including native result resolution and success decoding. */
+declare const withRpcClientSpan: <A, E, R>(effect: Effect.Effect<A, E, R>, binding: string, method: string) => Effect.Effect<A, E, Exclude<R, Tracer.ParentSpan>>;
+/**
+ * Optional application instrumentation for the entire receiver effect.
+ * Use in a RunSymbol override to include argument decode, handler and encode.
+ * Records stable service/method attributes and failure status, not argument or
+ * error payloads. The original typed failure still propagates to the caller.
+ */
+declare const withRpcServerSpan: <A, E, R>(effect: Effect.Effect<A, E, R>, invocation: RpcInvocationInfo) => Effect.Effect<A, E, Exclude<R, Tracer.ParentSpan>>;
+//#endregion
+export { ReceiverOptions, RpcInvocationInfo, RpcTraceContext, RpcTracing_d_exports, withRpcClientSpan, withRpcServerSpan, withRpcTraceContext };

package/dist/RpcTracing.mjs

@@ -0,0 +1,77 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as Option from "effect/Option";
+import * as Cause from "effect/Cause";
+import * as Exit from "effect/Exit";
+import * as Clock from "effect/Clock";
+import * as Tracer from "effect/Tracer";
+import * as References from "effect/References";
+//#region src/RpcTracing.ts
+var RpcTracing_exports = /* @__PURE__ */ __exportAll({
+	RpcTraceContext: () => RpcTraceContext,
+	withRpcClientSpan: () => withRpcClientSpan,
+	withRpcServerSpan: () => withRpcServerSpan,
+	withRpcTraceContext: () => withRpcTraceContext
+});
+/**
+* Live native RPC metadata. Opted-in receivers reserve a valid trailing value
+* with this tag for transport context; do not use it as a final domain argument.
+* Never store this in durable messages or envelopes.
+*/
+const RpcTraceContext = Schema.Struct({
+	_tag: Schema.Literal("effect-cf/RpcTraceContext/v1"),
+	traceId: Schema.String.check(Schema.isPattern(/^(?!0{32}$)[0-9a-f]{32}$/)),
+	spanId: Schema.String.check(Schema.isPattern(/^(?!0{16}$)[0-9a-f]{16}$/)),
+	sampled: Schema.Boolean
+});
+const isRpcTraceContext = Schema.is(RpcTraceContext);
+/**
+* Appends the current live parent only for a receiver that has opted in.
+* Call this inside the CLIENT span, immediately before the native invocation.
+* With no valid propagating parent, the original argument array is returned.
+*/
+const withRpcTraceContext = Effect.fnUntraced(function* (args) {
+	if (yield* Tracer.DisablePropagation) return args;
+	const parent = yield* Effect.serviceOption(Tracer.ParentSpan);
+	if (Option.isNone(parent) || Context.get(parent.value.annotations, Tracer.DisablePropagation)) return args;
+	const context = {
+		_tag: "effect-cf/RpcTraceContext/v1",
+		traceId: parent.value.traceId,
+		spanId: parent.value.spanId,
+		sampled: parent.value.sampled
+	};
+	return isRpcTraceContext(context) ? [...args, context] : args;
+});
+const attributes = (service, method) => ({
+	"sentry.op": "rpc",
+	"rpc.system.name": "cloudflare",
+	"rpc.method": `${service}/${method}`,
+	"server.address": service
+});
+const withRpcSpan = (effect, service, method, options) => Effect.useSpan(`${service}/${method}`, {
+	...options,
+	attributes: attributes(service, method)
+}, (span) => effect.pipe(Effect.withParentSpan(span), Effect.onExit((exit) => {
+	if (Exit.isSuccess(exit) || Cause.hasInterruptsOnly(exit.cause) || span.status._tag === "Ended") return Effect.void;
+	return Effect.gen(function* () {
+		const endTime = (yield* References.TracerTimingEnabled) ? yield* Clock.currentTimeNanos : 0n;
+		span.attribute("error.type", "_OTHER");
+		span.end(endTime, Exit.fail("RPC failed"));
+	});
+})));
+/** Wrap the whole call, including native result resolution and success decoding. */
+const withRpcClientSpan = (effect, binding, method) => withRpcSpan(effect, binding, method, { kind: "client" });
+/**
+* Optional application instrumentation for the entire receiver effect.
+* Use in a RunSymbol override to include argument decode, handler and encode.
+* Records stable service/method attributes and failure status, not argument or
+* error payloads. The original typed failure still propagates to the caller.
+*/
+const withRpcServerSpan = (effect, invocation) => withRpcSpan(effect, invocation.service, invocation.method, {
+	kind: "server",
+	parent: invocation.parent === void 0 ? void 0 : Tracer.externalSpan(invocation.parent)
+});
+//#endregion
+export { RpcTraceContext, RpcTracing_exports, withRpcClientSpan, withRpcServerSpan, withRpcTraceContext };

package/dist/Sandbox.d.mts

@@ -1,6 +1,11 @@
-import { c as WorkerEnvironment, r as BindingValidationError, t as BindingNotFoundError } from "./Binding-DKcLrQCM.mjs";
-import { n as ContainerStartOptions, r as ContainerStopSignal } from "./ContainerNamespace-DbLaeFhN.mjs";
-import { Context, Effect, Layer, Option, Stream } from "effect";
+import { WorkerEnvironment } from "./Environment.mjs";
+import { BindingNotFoundError, BindingValidationError } from "./Binding.mjs";
+import { ContainerStartOptions, ContainerStopSignal } from "./ContainerNamespace.mjs";
+import * as Context$1 from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Stream from "effect/Stream";
+import { Layer } from "effect";
 import { BackupOptions, BackupOptions as BackupOptions$1, CheckChangesOptions, CheckChangesOptions as CheckChangesOptions$1, CheckChangesResult, CheckChangesResult as CheckChangesResult$1, CreateTerminalOptions, CreateTerminalOptions as CreateTerminalOptions$1, DirectoryBackup, DirectoryBackup as DirectoryBackup$1, ExecOptions, ExecOptions as ExecOptions$1, FileWatchSSEEvent, FileWatchSSEEvent as FileWatchSSEEvent$1, ISandbox, ISandbox as ISandbox$1, ListFilesOptions, ListFilesOptions as ListFilesOptions$1, MountBucketOptions, MountBucketOptions as MountBucketOptions$1, ProcessExit, ProcessExit as ProcessExit$1, ProcessLogEvent, ProcessLogEvent as ProcessLogEvent$1, ProcessLogsOptions, ProcessLogsOptions as ProcessLogsOptions$1, ProcessOutput, ProcessOutput as ProcessOutput$1, ProcessOutputOptions, ProcessOutputOptions as ProcessOutputOptions$1, ProcessStatus, ProcessStatus as ProcessStatus$1, RestoreBackupResult, RestoreBackupResult as RestoreBackupResult$1, SandboxCommand, SandboxCommand as SandboxCommand$1, SandboxOptions, SandboxOptions as SandboxOptions$1, SandboxProcess, SandboxProcess as SandboxProcess$1, Terminal, Terminal as Terminal$1, TerminalOutputCursor, TerminalOutputCursor as TerminalOutputCursor$1, TerminalOutputEvent, TerminalOutputEvent as TerminalOutputEvent$1, TerminalOutputOptions, TerminalOutputOptions as TerminalOutputOptions$1, TerminalSnapshot, TerminalSnapshot as TerminalSnapshot$1, TunnelInfo, TunnelInfo as TunnelInfo$1, TunnelOptions, TunnelOptions as TunnelOptions$1, WaitForExitOptions, WaitForExitOptions as WaitForExitOptions$1, WaitForLogOptions, WaitForLogOptions as WaitForLogOptions$1, WaitForLogResult, WaitForLogResult as WaitForLogResult$1, WaitForPortOptions, WaitForPortOptions as WaitForPortOptions$1, WatchOptions, WatchOptions as WatchOptions$1 } from "@cloudflare/sandbox";
 //#region src/Sandbox.d.ts
 interface SandboxDefinition {
@@ -159,7 +164,7 @@ interface SandboxNamespaceClient<Namespace extends SandboxNamespaceResource = Sa
 type LayerOptions = {
   readonly binding: string;
 };
-interface TagClass<Self, Id extends string, Namespace extends SandboxNamespaceResource = SandboxNamespaceResource> extends Context.ServiceClass<Self, `effect-cf/Sandbox/${Id}`, SandboxNamespaceClient<Namespace>> {
+interface TagClass<Self, Id extends string, Namespace extends SandboxNamespaceResource = SandboxNamespaceResource> extends Context$1.ServiceClass<Self, `effect-cf/Sandbox/${Id}`, SandboxNamespaceClient<Namespace>> {
   readonly id: Id;
   readonly layer: (options: LayerOptions) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
   readonly get: (name: string, options?: SandboxOptions$1) => Effect.Effect<SandboxInstanceClient, SandboxOperationError, Self>;
@@ -168,7 +173,7 @@ interface TagClass<Self, Id extends string, Namespace extends SandboxNamespaceRe
 declare const fromSandboxClient: (client: SandboxClientResource, definition: SandboxDefinition, instance: string) => SandboxInstanceClient;
 declare const isSandboxNamespaceResource: <Candidate>(value: Candidate) => value is Candidate & SandboxNamespaceResource;
 declare const makeClient: (definition: SandboxDefinition) => <Namespace extends SandboxNamespaceResource>(namespace: Namespace) => SandboxNamespaceClient<Namespace>;
-declare const layer: <Self, Namespace extends SandboxNamespaceResource>(tag: Context.Service<Self, SandboxNamespaceClient<Namespace>>, definition: SandboxDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const layer: <Self, Namespace extends SandboxNamespaceResource>(tag: Context$1.Service<Self, SandboxNamespaceClient<Namespace>>, definition: SandboxDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 declare const make: <Id extends string>(id: Id) => TagClass<SandboxNamespaceService<Id>, Id, SandboxNamespaceResource>;
 declare const SandboxNamespaceServiceTypeId: unique symbol;
 interface SandboxNamespaceService<Id extends string> {

package/dist/Sandbox.mjs

@@ -1,6 +1,12 @@
-import { a as WorkerEnvironment, t as causeMessage } from "./ErrorMessage-Byx2OgNd.mjs";
-import { r as layer$1 } from "./Binding-C82jRhdr.mjs";
-import { Context, Data, Effect, Option, Predicate, Stream } from "effect";
+import { WorkerEnvironment } from "./Environment.mjs";
+import { layer as layer$1 } from "./Binding.mjs";
+import { causeMessage } from "./internal/ErrorMessage.mjs";
+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 Option from "effect/Option";
+import * as Stream from "effect/Stream";
 //#region src/Sandbox.ts
 const expectedSandboxNamespace = "Sandbox Durable Object namespace binding with idFromName() and get()";
 var SandboxOperationError = class extends Data.TaggedError("SandboxOperationError") {

package/dist/ServiceBinding.d.mts

@@ -0,0 +1,112 @@
+import { WorkerEnvironment } from "./Environment.mjs";
+import { BindingNotFoundError, BindingService, BindingValidationError } from "./Binding.mjs";
+import { Provider, Result } from "./Rpc.mjs";
+import { Definition, Method as Method$1 } from "./RpcDefinition.mjs";
+import { AsyncMethodArgs, AsyncMethodCloudflareReturn, AsyncMethodKey, AsyncMethodSuccess } from "./internal/RpcInvocation.mjs";
+import { Definition as Definition$1, ReservedMethodName as ReservedMethodName$1, ServerApi } from "./WorkerDefinition.mjs";
+import * as Effect from "effect/Effect";
+import * as Schema$1 from "effect/Schema";
+import { Context, Scope } from "effect";
+declare namespace ServiceBinding_d_exports {
+  export { Service, ServiceBindingClient, ServiceBindingDefinition, ServiceBindingEffectClient, ServiceBindingFetchError, ServiceBindingRpcError, ServiceBindingStaticClient, ServiceFetcher, isServiceBindingClient, layer, makeClient, makeDirectMethods };
+}
+declare const TypeId: "effect-cf/ServiceBinding";
+interface ServiceFetcher {
+  fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+}
+type RpcClient<Api> = { readonly [Key in keyof Api as Key extends string ? Api[Key] extends ((...args: Array<any>) => any) ? Key : never : never]: Api[Key]; };
+type ReservedMethodName = ReservedMethodName$1 | "fetch";
+type ServiceBindingClient<Api extends object> = ServiceFetcher & RpcClient<Provider<Api, ReservedMethodName>>;
+type ApiFromDefinition<Definition> = Definition extends Definition$1.Any ? ServerApi<Definition> : never;
+type ApiOrDefinition<Api extends object, Definition> = [Api] extends [never] ? ApiFromDefinition<Definition> : Api;
+/**
+ * Binding metadata used to create an Effect service from a Worker binding.
+ */
+interface ServiceBindingDefinition<Definition extends Definition$1.Any | undefined = undefined> {
+  readonly binding: string;
+  readonly definition?: Definition;
+  /** Append live trace context only when the receiver also enables rpcTracing. */
+  readonly rpcTracing?: boolean;
+}
+declare const ServiceBindingFetchError_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: "ServiceBindingFetchError";
+} & Readonly<A>;
+/**
+ * Failure raised when calling `fetch` on a service binding.
+ */
+declare class ServiceBindingFetchError extends ServiceBindingFetchError_base<{
+  readonly binding: string;
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
+declare const ServiceBindingRpcError_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: "ServiceBindingRpcError";
+} & Readonly<A>;
+/**
+ * Failure raised when invoking an RPC method on a service binding.
+ */
+declare class ServiceBindingRpcError extends ServiceBindingRpcError_base<{
+  readonly binding: string;
+  readonly method: string;
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
+type ServiceMethodKey<Api> = AsyncMethodKey<Api>;
+type ServiceMethodArgs<Api, Method extends keyof Api> = AsyncMethodArgs<Api, Method>;
+type ServiceMethodSuccess<Api, Method extends keyof Api> = AsyncMethodSuccess<Api, Method>;
+type ServiceMethodCloudflareReturn<Api, Method extends keyof Api> = AsyncMethodCloudflareReturn<Api, Method>;
+type ServiceCall<R, Api> = <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<ServiceMethodSuccess<Api, Method>, ServiceBindingRpcError, R>;
+type DefinitionDirectMethods<R, Definition$2 extends Definition$1.Any> = { readonly [Method in Definition.MethodNames<Definition$2>]: (...args: Method$1.Args<Definition$2["methods"][Method]>) => Effect.Effect<Method$1.Success<Definition$2["methods"][Method]>, ServiceBindingRpcError, R>; };
+type DirectMethods<R, Definition> = Definition extends Definition$1.Any ? DefinitionDirectMethods<R, Definition> : {};
+type ServiceBindingEffectClient<Api extends object, Definition extends Definition$1.Any | undefined = undefined> = DirectMethods<never, Definition> & {
+  readonly fetch: (input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<globalThis.Response, ServiceBindingFetchError>;
+  /**
+   * Invokes a Worker RPC method and returns Cloudflare's raw RPC result.
+   *
+   * This preserves Cloudflare RPC behavior such as promise-like pipelining and
+   * transferable / disposable result objects. It does not resolve the returned
+   * promise-like value and it does not decode definition-backed success schemas.
+   *
+   * Most application code should use {@link call} instead.
+   */
+  readonly rpc: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<ServiceMethodCloudflareReturn<Api, Method>, ServiceBindingRpcError>;
+  /**
+   * Invokes a Worker RPC method, resolves Cloudflare's RPC result, and decodes
+   * the success value when the binding was created from a definition.
+   *
+   * This is the normal choice when application code wants the final typed value.
+   */
+  readonly call: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<ServiceMethodSuccess<Api, Method>, ServiceBindingRpcError>;
+  /**
+   * Invokes a Worker RPC method in the current `Scope`, resolves Cloudflare's RPC
+   * result, decodes definition-backed success values, and disposes the resolved
+   * result when the scope closes if it implements `Symbol.dispose`.
+   *
+   * Use this for RPC methods that return Cloudflare RPC resources or other
+   * disposable objects whose lifetime should be tied to an Effect scope.
+   */
+  readonly scopedCall: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<Awaited<ServiceMethodSuccess<Api, Method>>, ServiceBindingRpcError, Scope.Scope>;
+};
+type ServiceBindingStaticClient<R, Api extends object, Definition extends Definition$1.Any | undefined = undefined> = DirectMethods<R, Definition> & {
+  readonly fetch: (input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<globalThis.Response, ServiceBindingFetchError, R>;
+  readonly rpc: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<ServiceMethodCloudflareReturn<Api, Method>, ServiceBindingRpcError, R>;
+  readonly call: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<ServiceMethodSuccess<Api, Method>, ServiceBindingRpcError, R>;
+  readonly scopedCall: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<Awaited<ServiceMethodSuccess<Api, Method>>, ServiceBindingRpcError, Scope.Scope | R>;
+};
+type ServiceBindingValue = Schema$1.Schema.Type<typeof Schema$1.Unknown>;
+declare const isServiceBindingClient: <Api extends object>(value: ServiceBindingValue) => value is ServiceBindingClient<Api>;
+declare const makeClient: <Api extends object, const Definition extends Definition$1.Any | undefined = undefined>(definition: ServiceBindingDefinition<Definition>) => ((service: ServiceBindingClient<Api>) => ServiceBindingEffectClient<Api, Definition>);
+declare const layer: <Self, Api extends object, const Definition extends Definition$1.Any | undefined = undefined>(tag: Context.Service<Self, ServiceBindingEffectClient<Api, Definition>>, definition: ServiceBindingDefinition<Definition>) => import("effect/Layer").Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const Service: <Self, Api extends object = never>() => <Id extends string, const Definition extends Definition$1.Any | undefined = undefined>(id: Id, definition: ServiceBindingDefinition<Definition>) => BindingService<Self, Id, ServiceBindingEffectClient<ApiOrDefinition<Api, Definition>, Definition>> & DirectMethods<Self, Definition> & {
+  readonly [TypeId]: typeof TypeId;
+  readonly definition: ServiceBindingDefinition<Definition>;
+  readonly fetch: (input: URL | RequestInfo<unknown, CfProperties<unknown>>, init?: RequestInit<CfProperties<unknown>> | undefined) => Effect.Effect<Response, ServiceBindingFetchError, Self>;
+  readonly rpc: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition>>>(method: Method, ...args: AsyncMethodArgs<ApiOrDefinition<Api, Definition>, Method>) => Effect.Effect<Result<AsyncMethodSuccess<ApiOrDefinition<Api, Definition>, Method>>, ServiceBindingRpcError, Self>;
+  readonly call: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition>>>(method: Method, ...args: AsyncMethodArgs<ApiOrDefinition<Api, Definition>, Method>) => Effect.Effect<AsyncMethodSuccess<ApiOrDefinition<Api, Definition>, Method>, ServiceBindingRpcError, Self>;
+  readonly scopedCall: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition>>>(method: Method, ...args: AsyncMethodArgs<ApiOrDefinition<Api, Definition>, Method>) => Effect.Effect<Awaited<AsyncMethodSuccess<ApiOrDefinition<Api, Definition>, Method>>, ServiceBindingRpcError, Self | Scope.Scope>;
+};
+declare const makeDirectMethods: <R, Api, Definition extends Definition$1.Any | undefined>(rpcDefinition: Definition | undefined, call: ServiceCall<R, Api>) => DirectMethods<R, Definition>;
+//#endregion
+export { Service, ServiceBindingClient, ServiceBindingDefinition, ServiceBindingEffectClient, ServiceBindingFetchError, ServiceBindingRpcError, ServiceBindingStaticClient, ServiceBinding_d_exports, ServiceFetcher, isServiceBindingClient, layer, makeClient, makeDirectMethods };

package/dist/ServiceBinding.mjs

@@ -0,0 +1,145 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { Service as Service$1, layer as layer$1 } from "./Binding.mjs";
+import { causeMessage } from "./internal/ErrorMessage.mjs";
+import { decodeSuccess, encodeArgs } from "./RpcDefinition.mjs";
+import { withRpcClientSpan, withRpcTraceContext } from "./RpcTracing.mjs";
+import { invokeRpcMethod } from "./internal/RpcInvocation.mjs";
+import { resolve, scoped } from "./Rpc.mjs";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as Predicate from "effect/Predicate";
+import * as Option from "effect/Option";
+//#region src/ServiceBinding.ts
+var ServiceBinding_exports = /* @__PURE__ */ __exportAll({
+	Service: () => Service,
+	ServiceBindingFetchError: () => ServiceBindingFetchError,
+	ServiceBindingRpcError: () => ServiceBindingRpcError,
+	isServiceBindingClient: () => isServiceBindingClient,
+	layer: () => layer,
+	makeClient: () => makeClient,
+	makeDirectMethods: () => makeDirectMethods
+});
+const TypeId = "effect-cf/ServiceBinding";
+const expectedServiceBinding = "Worker service binding with fetch()";
+/**
+* Failure raised when calling `fetch` on a service binding.
+*/
+var ServiceBindingFetchError = class extends Data.TaggedError("ServiceBindingFetchError") {
+	get message() {
+		return `Service binding "${this.binding}" fetch failed: ${causeMessage(this.cause)}`;
+	}
+};
+/**
+* Failure raised when invoking an RPC method on a service binding.
+*/
+var ServiceBindingRpcError = class extends Data.TaggedError("ServiceBindingRpcError") {
+	get message() {
+		return `Service binding "${this.binding}" RPC method "${this.method}" failed: ${causeMessage(this.cause)}`;
+	}
+};
+const ServiceBindingSchema = Schema.declare((value) => Predicate.hasProperty(value, "fetch") && Predicate.isFunction(value.fetch));
+const decodeServiceBinding = Schema.decodeUnknownOption(ServiceBindingSchema);
+const isServiceBindingClient = (value) => Option.isSome(decodeServiceBinding(value));
+const makeClient = (definition) => {
+	return (service) => {
+		const fetch = Effect.fn("ServiceBinding.fetch")(function* (input, init) {
+			return yield* Effect.tryPromise({
+				try: (signal) => {
+					const callerSignal = init?.signal !== void 0 ? init.signal : input instanceof Request ? input.signal : void 0;
+					return service.fetch(input, {
+						...init,
+						signal: callerSignal === null || callerSignal === void 0 ? signal : AbortSignal.any([callerSignal, signal])
+					});
+				},
+				catch: (cause) => new ServiceBindingFetchError({
+					binding: definition.binding,
+					cause
+				})
+			});
+		});
+		const rpc = Effect.fnUntraced(function* (method, ...args) {
+			const methodName = String(method);
+			const encodedArgs = definition.definition === void 0 ? args : yield* encodeArgs(definition.definition, methodName, args).pipe(Effect.mapError((cause) => new ServiceBindingRpcError({
+				binding: definition.binding,
+				method: methodName,
+				cause
+			})));
+			const nativeArgs = definition.rpcTracing ? yield* withRpcTraceContext(encodedArgs) : encodedArgs;
+			return yield* invokeRpcMethod(service, method, nativeArgs, (cause) => new ServiceBindingRpcError({
+				binding: definition.binding,
+				method: methodName,
+				cause
+			}));
+		});
+		const decodeSuccess$1 = Effect.fnUntraced(function* (methodName, value) {
+			if (definition.definition === void 0) return value;
+			return yield* decodeSuccess(definition.definition, methodName, value).pipe(Effect.mapError((cause) => new ServiceBindingRpcError({
+				binding: definition.binding,
+				method: methodName,
+				cause
+			})));
+		});
+		const call = Effect.fnUntraced(function* (method, ...args) {
+			const methodName = String(method);
+			const value = yield* resolve(yield* rpc(method, ...args)).pipe(Effect.mapError((cause) => new ServiceBindingRpcError({
+				binding: definition.binding,
+				method: methodName,
+				cause
+			})));
+			return yield* decodeSuccess$1(methodName, value);
+		}, (effect, ...args) => withRpcClientSpan(effect, definition.binding, String(args[0])));
+		const scopedCall = Effect.fnUntraced(function* (method, ...args) {
+			const methodName = String(method);
+			const result = yield* rpc(method, ...args);
+			const value = yield* scoped(result).pipe(Effect.mapError((cause) => new ServiceBindingRpcError({
+				binding: definition.binding,
+				method: methodName,
+				cause
+			})));
+			return yield* decodeSuccess$1(methodName, value);
+		}, (effect, ...args) => withRpcClientSpan(effect, definition.binding, String(args[0])));
+		const directMethods = makeDirectMethods(definition.definition, call);
+		return Object.assign(directMethods, {
+			fetch,
+			rpc,
+			call,
+			scopedCall
+		});
+	};
+};
+const layer = (tag, definition) => layer$1(tag, definition.binding, (value) => isServiceBindingClient(value), makeClient(definition), { expected: expectedServiceBinding });
+const Service = () => (id, definition) => {
+	const tag = Service$1()(id, definition.binding, (value) => isServiceBindingClient(value), makeClient(definition));
+	const fetch = Effect.fnUntraced(function* (input, init) {
+		return yield* (yield* tag).fetch(input, init);
+	});
+	const rpc = Effect.fnUntraced(function* (method, ...args) {
+		return yield* (yield* tag).rpc(method, ...args);
+	});
+	const call = Effect.fnUntraced(function* (method, ...args) {
+		return yield* (yield* tag).call(method, ...args);
+	});
+	const scopedCall = Effect.fnUntraced(function* (method, ...args) {
+		return yield* (yield* tag).scopedCall(method, ...args);
+	});
+	const directMethods = makeDirectMethods(definition.definition, call);
+	return Object.assign(tag, directMethods, {
+		[TypeId]: TypeId,
+		definition,
+		fetch,
+		rpc,
+		call,
+		scopedCall
+	});
+};
+const makeDirectMethods = (rpcDefinition, call) => {
+	const methods = {};
+	if (rpcDefinition !== void 0) {
+		const invoke = call;
+		for (const methodName of Object.keys(rpcDefinition.methods)) methods[methodName] = (...args) => invoke(methodName, ...args);
+	}
+	return methods;
+};
+//#endregion
+export { Service, ServiceBindingFetchError, ServiceBindingRpcError, ServiceBinding_exports, isServiceBindingClient, layer, makeClient, makeDirectMethods };

package/dist/Vectorize.d.mts

@@ -0,0 +1,68 @@
+import { WorkerEnvironment } from "./Environment.mjs";
+import { BindingNotFoundError, BindingValidationError } from "./Binding.mjs";
+import * as Context$1 from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Schema$1 from "effect/Schema";
+import { Layer } from "effect";
+declare namespace Vectorize_d_exports {
+  export { LayerOptions, Tag, TagClass, VectorizeBinding, VectorizeClient, VectorizeDefinition, VectorizeIndexDetails, VectorizeIndexInfo, VectorizeMatch, VectorizeMatches, VectorizeMutation, VectorizeOperation, VectorizeOperationError, VectorizeQueryOptions, VectorizeService, VectorizeValues, VectorizeVector, VectorizeVectorMetadata, VectorizeVectorMetadataFilter, VectorizeVectorMetadataValue, isVectorizeBinding, layer, make, makeClient };
+}
+type VectorizeOperation = "describe" | "query" | "queryById" | "insert" | "upsert" | "deleteByIds" | "getByIds";
+declare const VectorizeOperationError_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: "VectorizeOperationError";
+} & Readonly<A>;
+declare class VectorizeOperationError extends VectorizeOperationError_base<{
+  readonly binding: string;
+  readonly operation: VectorizeOperation;
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
+interface VectorizeDefinition {
+  readonly binding: string;
+}
+type VectorizeBinding = CloudflareVectorize | CloudflareVectorizeIndex;
+type VectorizeVector = CloudflareVectorizeVector;
+type VectorizeVectorMetadata = CloudflareVectorizeVectorMetadata;
+type VectorizeVectorMetadataValue = CloudflareVectorizeVectorMetadataValue;
+type VectorizeVectorMetadataFilter = CloudflareVectorizeVectorMetadataFilter;
+type VectorizeQueryOptions = CloudflareVectorizeQueryOptions;
+type VectorizeMatches = CloudflareVectorizeMatches;
+type VectorizeMatch = CloudflareVectorizeMatch;
+type VectorizeIndexInfo = CloudflareVectorizeIndexInfo;
+type VectorizeIndexDetails = CloudflareVectorizeIndexDetails;
+type VectorizeMutation = CloudflareVectorizeAsyncMutation | CloudflareVectorizeVectorMutation;
+type VectorizeValues = Float32Array | Float64Array | ReadonlyArray<number>;
+interface VectorizeClient {
+  readonly describe: Effect.Effect<VectorizeIndexInfo | VectorizeIndexDetails, VectorizeOperationError>;
+  readonly query: (vector: VectorizeValues, options?: VectorizeQueryOptions) => Effect.Effect<VectorizeMatches, VectorizeOperationError>;
+  readonly queryById: (vectorId: string, options?: VectorizeQueryOptions) => Effect.Effect<VectorizeMatches, VectorizeOperationError>;
+  readonly insert: (vectors: ReadonlyArray<VectorizeVector>) => Effect.Effect<VectorizeMutation, VectorizeOperationError>;
+  readonly upsert: (vectors: ReadonlyArray<VectorizeVector>) => Effect.Effect<VectorizeMutation, VectorizeOperationError>;
+  readonly deleteByIds: (ids: ReadonlyArray<string>) => Effect.Effect<VectorizeMutation, VectorizeOperationError>;
+  readonly delete: (ids: ReadonlyArray<string>) => Effect.Effect<VectorizeMutation, VectorizeOperationError>;
+  readonly getByIds: (ids: ReadonlyArray<string>) => Effect.Effect<ReadonlyArray<VectorizeVector>, VectorizeOperationError>;
+  readonly rawUnsafe: Effect.Effect<VectorizeBinding>;
+  readonly definition: VectorizeDefinition;
+}
+declare const VectorizeServiceTypeId: unique symbol;
+interface VectorizeService<Id extends string> {
+  readonly [VectorizeServiceTypeId]: {
+    readonly id: Id;
+  };
+}
+type LayerOptions = {
+  readonly binding: string;
+};
+interface TagClass<Self, Id extends string> extends Context$1.ServiceClass<Self, Id, VectorizeClient> {
+  readonly id: Id;
+  readonly layer: (options: LayerOptions) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+}
+type VectorizeBindingValue = Schema$1.Schema.Type<typeof Schema$1.Unknown>;
+declare const isVectorizeBinding: (value: VectorizeBindingValue) => value is VectorizeBinding;
+declare const makeClient: (definition: VectorizeDefinition) => (index: VectorizeBinding) => VectorizeClient;
+declare const layer: <Self>(tag: Context$1.Service<Self, VectorizeClient>, definition: VectorizeDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const make: <Id extends string>(id: Id) => TagClass<VectorizeService<Id>, Id>;
+declare const Tag: <Self>() => <Id extends string>(id: Id) => TagClass<Self, Id>;
+//#endregion
+export { LayerOptions, Tag, TagClass, VectorizeBinding, VectorizeClient, VectorizeDefinition, VectorizeIndexDetails, VectorizeIndexInfo, VectorizeMatch, VectorizeMatches, VectorizeMutation, VectorizeOperation, VectorizeOperationError, VectorizeQueryOptions, VectorizeService, VectorizeValues, VectorizeVector, VectorizeVectorMetadata, VectorizeVectorMetadataFilter, VectorizeVectorMetadataValue, Vectorize_d_exports, isVectorizeBinding, layer, make, makeClient };

package/dist/Vectorize.mjs

@@ -0,0 +1,76 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { layer as layer$1 } from "./Binding.mjs";
+import { causeMessage } from "./internal/ErrorMessage.mjs";
+import * as Context from "effect/Context";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as Predicate from "effect/Predicate";
+import * as Option from "effect/Option";
+//#region src/Vectorize.ts
+var Vectorize_exports = /* @__PURE__ */ __exportAll({
+	Tag: () => Tag,
+	VectorizeOperationError: () => VectorizeOperationError,
+	isVectorizeBinding: () => isVectorizeBinding,
+	layer: () => layer,
+	make: () => make,
+	makeClient: () => makeClient
+});
+const expectedVectorizeBinding = "Vectorize index binding with describe(), query(), insert(), upsert(), deleteByIds(), and getByIds()";
+var VectorizeOperationError = class extends Data.TaggedError("VectorizeOperationError") {
+	get message() {
+		return `Vectorize ${this.operation} failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
+	}
+};
+const vectorizeError = (binding, operation, cause) => new VectorizeOperationError({
+	binding,
+	operation,
+	cause
+});
+const tryVectorizePromise = (binding, operation, evaluate) => Effect.tryPromise({
+	try: evaluate,
+	catch: (cause) => vectorizeError(binding, operation, cause)
+});
+const spanOptions = (binding, operation) => ({ attributes: {
+	binding,
+	operation
+} });
+const invokeVectorizeMethod = (method, receiver, args) => {
+	return Function.prototype.apply.call(method, receiver, args);
+};
+const VectorizeBindingSchema = Schema.declare((value) => Predicate.hasProperty(value, "describe") && Predicate.isFunction(value.describe) && Predicate.hasProperty(value, "query") && Predicate.isFunction(value.query) && Predicate.hasProperty(value, "insert") && Predicate.isFunction(value.insert) && Predicate.hasProperty(value, "upsert") && Predicate.isFunction(value.upsert) && Predicate.hasProperty(value, "deleteByIds") && Predicate.isFunction(value.deleteByIds) && Predicate.hasProperty(value, "getByIds") && Predicate.isFunction(value.getByIds));
+const decodeVectorizeBinding = Schema.decodeUnknownOption(VectorizeBindingSchema);
+const isVectorizeBinding = (value) => Option.isSome(decodeVectorizeBinding(value));
+const makeClient = (definition) => (index) => {
+	const runtime = index;
+	const deleteByIds = Effect.fn("Vectorize.deleteByIds", spanOptions(definition.binding, "deleteByIds"))((ids) => tryVectorizePromise(definition.binding, "deleteByIds", () => runtime.deleteByIds([...ids])));
+	return {
+		definition,
+		describe: tryVectorizePromise(definition.binding, "describe", () => runtime.describe()).pipe(Effect.withSpan("Vectorize.describe", spanOptions(definition.binding, "describe"))),
+		query: Effect.fn("Vectorize.query", spanOptions(definition.binding, "query"))((vector, options) => tryVectorizePromise(definition.binding, "query", () => {
+			return runtime.query(vector, options);
+		})),
+		queryById: Effect.fn("Vectorize.queryById", spanOptions(definition.binding, "queryById"))((vectorId, options) => runtime.queryById !== void 0 ? tryVectorizePromise(definition.binding, "queryById", () => {
+			const queryById = runtime.queryById;
+			return queryById === void 0 ? Promise.reject(/* @__PURE__ */ new TypeError("Vectorize binding does not expose queryById()")) : invokeVectorizeMethod(queryById, runtime, [vectorId, options]);
+		}) : Effect.fail(vectorizeError(definition.binding, "queryById", /* @__PURE__ */ new TypeError("Vectorize binding does not expose queryById()")))),
+		insert: Effect.fn("Vectorize.insert", spanOptions(definition.binding, "insert"))((vectors) => tryVectorizePromise(definition.binding, "insert", () => runtime.insert([...vectors]))),
+		upsert: Effect.fn("Vectorize.upsert", spanOptions(definition.binding, "upsert"))((vectors) => tryVectorizePromise(definition.binding, "upsert", () => runtime.upsert([...vectors]))),
+		deleteByIds,
+		delete: deleteByIds,
+		getByIds: Effect.fn("Vectorize.getByIds", spanOptions(definition.binding, "getByIds"))((ids) => tryVectorizePromise(definition.binding, "getByIds", () => runtime.getByIds([...ids]))),
+		rawUnsafe: Effect.succeed(index)
+	};
+};
+const layer = (tag, definition) => layer$1(tag, definition.binding, isVectorizeBinding, makeClient(definition), { expected: expectedVectorizeBinding });
+const make = (id) => Tag()(id);
+const Tag = () => (id) => {
+	const tag = Context.Service()(id);
+	const makeLayer = (definition) => layer(tag, definition);
+	return Object.assign(tag, {
+		id,
+		layer: makeLayer
+	});
+};
+//#endregion
+export { Tag, VectorizeOperationError, Vectorize_exports, isVectorizeBinding, layer, make, makeClient };

package/dist/Vitest.d.mts

@@ -1,7 +1,9 @@
-import { c as WorkerEnvironment, s as WorkerEnv } from "./Binding-DKcLrQCM.mjs";
-import { n as DurableObjectStateService, t as DurableObjectState } from "./DurableObjectState-DJ0K-zyd.mjs";
-import { o as WorkflowInstanceStatusName } from "./WorkflowBinding-DtVykUCz.mjs";
-import { Effect, Layer, Schema } from "effect";
+import { WorkerEnv, WorkerEnvironment } from "./Environment.mjs";
+import { DurableObjectState, DurableObjectStateService } from "./DurableObjectState.mjs";
+import { WorkflowInstanceStatusName } from "./WorkflowBinding.mjs";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as Layer from "effect/Layer";
 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

package/dist/Vitest.mjs

@@ -1,7 +1,11 @@
-import { a as WorkerEnvironment, i as WorkerConfig } from "./ErrorMessage-Byx2OgNd.mjs";
-import { r as runNativeCallback } from "./WorkerContext-Yobnfw-K.mjs";
-import { r as fromDurableObjectState, t as DurableObjectState } from "./DurableObjectState-DLL0YgBd.mjs";
-import { ConfigProvider, Effect, Exit, Layer } from "effect";
+import { WorkerConfig, WorkerEnvironment } from "./Environment.mjs";
+import { runNativeCallback } from "./internal/NativeCallback.mjs";
+import { DurableObjectState, fromDurableObjectState } from "./DurableObjectState.mjs";
+import * as Effect from "effect/Effect";
+import "effect/Schema";
+import * as Layer from "effect/Layer";
+import * as ConfigProvider from "effect/ConfigProvider";
+import * as Exit from "effect/Exit";
 import { env } from "cloudflare:workers";
 import { abortAllDurableObjects as abortAllDurableObjects$1, adminSecretsStore as adminSecretsStore$1, applyD1Migrations as applyD1Migrations$1, createExecutionContext, createMessageBatch, createPagesEventContext, createScheduledController, evictAllDurableObjects as evictAllDurableObjects$1, evictDurableObject as evictDurableObject$1, getQueueResult, introspectWorkflow as introspectWorkflow$1, introspectWorkflowInstance as introspectWorkflowInstance$1, listDurableObjectIds as listDurableObjectIds$1, reset as reset$1, runDurableObjectAlarm as runDurableObjectAlarm$1, runInDurableObject as runInDurableObject$1, waitOnExecutionContext } from "cloudflare:test";
 //#region src/Vitest.ts