effect-cf 0.39.1 → 0.40.1

package/dist/QueueDefinition.mjs

@@ -0,0 +1,63 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { layer } from "./QueueBinding.mjs";
+import { decodeBatch } from "./Queue.mjs";
+import { make as make$1 } from "./Worker.mjs";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as S from "effect/Schema";
+//#region src/QueueDefinition.ts
+var QueueDefinition_exports = /* @__PURE__ */ __exportAll({
+	Queue: () => Queue,
+	Tag: () => Tag,
+	implement: () => implement,
+	make: () => make
+});
+const makeDefinition = (id, definition) => {
+	const queueDefinition = {
+		id,
+		message: definition.message
+	};
+	return Object.assign(queueDefinition, { make: (layer, options) => make$1(layer, {
+		...options,
+		queue: wrapHandler(queueDefinition, options.queue)
+	}) });
+};
+const make = (id, definition) => Tag()(id, definition);
+const Tag = () => (id, definition) => {
+	const queueDefinition = makeDefinition(id, definition);
+	const tag = Context.Service()(`effect-cf/Queue/${id}`);
+	const layer$1 = (binding) => layer(tag, {
+		...binding,
+		message: definition.message
+	});
+	const send = Effect.fnUntraced(function* (message, options) {
+		yield* (yield* tag).send(message, options);
+	});
+	const sendBatch = Effect.fnUntraced(function* (messages, options) {
+		yield* (yield* tag).sendBatch(messages, options);
+	});
+	const metrics = Effect.fnUntraced(function* () {
+		return yield* (yield* tag).metrics();
+	});
+	const rawUnsafe = Effect.flatMap(tag, (queue) => queue.rawUnsafe);
+	return Object.assign(tag, {
+		id: queueDefinition.id,
+		message: queueDefinition.message,
+		make: queueDefinition.make,
+		layer: layer$1,
+		send,
+		sendBatch,
+		metrics,
+		rawUnsafe
+	});
+};
+const Queue = Tag;
+const wrapHandler = (definition, handler) => {
+	const decodeBody = S.decodeUnknownEffect(definition.message);
+	return Effect.fnUntraced(function* (batch) {
+		yield* handler(yield* decodeBatch(batch.raw, decodeBody));
+	});
+};
+const implement = (_definition, handler) => handler;
+//#endregion
+export { Queue, QueueDefinition_exports, Tag, implement, make };

package/dist/R2.d.mts

@@ -0,0 +1,89 @@
+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 * as Option from "effect/Option";
+import { Layer } from "effect";
+declare namespace R2_d_exports {
+  export { LayerOptions, R2Client, R2Definition, R2GetOptions, R2ListOptions, R2MultipartOptions, R2MultipartUploadClient, R2ObjectBodyClient, R2Operation, R2OperationError, R2PutOptions, R2PutValue, R2Service, R2UploadPartOptions, R2UploadPartValue, Tag, TagClass, isR2Bucket, layer, make, makeClient };
+}
+type R2Operation = "head" | "get" | "put" | "delete" | "list" | "createMultipartUpload" | "resumeMultipartUpload" | "uploadPart" | "abortMultipartUpload" | "completeMultipartUpload" | "arrayBuffer" | "bytes" | "text" | "json" | "blob";
+declare const R2OperationError_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: "R2OperationError";
+} & Readonly<A>;
+declare class R2OperationError extends R2OperationError_base<{
+  readonly binding: string;
+  readonly operation: R2Operation;
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
+interface R2Definition {
+  readonly binding: string;
+}
+type R2GetOptions = CloudflareR2GetOptions;
+type R2PutOptions = CloudflareR2PutOptions;
+type R2ListOptions = CloudflareR2ListOptions;
+type R2MultipartOptions = CloudflareR2MultipartOptions;
+type R2UploadPartOptions = CloudflareR2UploadPartOptions;
+type R2PutValue = ReadableStream | ArrayBuffer | ArrayBufferView | string | null | Blob;
+type R2UploadPartValue = ReadableStream | ArrayBuffer | ArrayBufferView | string | Blob;
+interface R2ObjectBodyClient extends Omit<CloudflareR2ObjectBody, "arrayBuffer" | "blob" | "bytes" | "json" | "text"> {
+  readonly raw: CloudflareR2ObjectBody;
+  readonly arrayBuffer: Effect.Effect<ArrayBuffer, R2OperationError>;
+  readonly bytes: Effect.Effect<Uint8Array, R2OperationError>;
+  readonly text: Effect.Effect<string, R2OperationError>;
+  readonly json: <T = unknown>() => Effect.Effect<T, R2OperationError>;
+  readonly blob: Effect.Effect<Blob, R2OperationError>;
+}
+interface R2MultipartUploadClient {
+  readonly raw: CloudflareR2MultipartUpload;
+  readonly key: string;
+  readonly uploadId: string;
+  readonly uploadPart: (partNumber: number, value: R2UploadPartValue, options?: R2UploadPartOptions) => Effect.Effect<CloudflareR2UploadedPart, R2OperationError>;
+  readonly abort: Effect.Effect<void, R2OperationError>;
+  readonly complete: (uploadedParts: ReadonlyArray<CloudflareR2UploadedPart>) => Effect.Effect<CloudflareR2Object, R2OperationError>;
+}
+interface R2Client {
+  readonly head: (key: string) => Effect.Effect<Option.Option<CloudflareR2Object>, R2OperationError>;
+  readonly get: {
+    (key: string, options: R2GetOptions & {
+      readonly onlyIf: CloudflareR2Conditional | Headers;
+    }): Effect.Effect<Option.Option<R2ObjectBodyClient | CloudflareR2Object>, R2OperationError>;
+    (key: string, options?: R2GetOptions): Effect.Effect<Option.Option<R2ObjectBodyClient>, R2OperationError>;
+  };
+  readonly put: {
+    (key: string, value: R2PutValue, options: R2PutOptions & {
+      readonly onlyIf: CloudflareR2Conditional | Headers;
+    }): Effect.Effect<Option.Option<CloudflareR2Object>, R2OperationError>;
+    (key: string, value: R2PutValue, options?: R2PutOptions): Effect.Effect<CloudflareR2Object, R2OperationError>;
+  };
+  readonly createMultipartUpload: (key: string, options?: R2MultipartOptions) => Effect.Effect<R2MultipartUploadClient, R2OperationError>;
+  readonly resumeMultipartUpload: (key: string, uploadId: string) => Effect.Effect<R2MultipartUploadClient, R2OperationError>;
+  readonly delete: (keys: string | ReadonlyArray<string>) => Effect.Effect<void, R2OperationError>;
+  readonly list: (options?: R2ListOptions) => Effect.Effect<CloudflareR2Objects, R2OperationError>;
+  readonly rawUnsafe: Effect.Effect<CloudflareR2Bucket>;
+  readonly definition: R2Definition;
+}
+declare const R2ServiceTypeId: unique symbol;
+interface R2Service<Id extends string> {
+  readonly [R2ServiceTypeId]: {
+    readonly id: Id;
+  };
+}
+type LayerOptions = {
+  readonly binding: string;
+};
+interface TagClass<Self, Id extends string> extends Context$1.ServiceClass<Self, Id, R2Client> {
+  readonly id: Id;
+  readonly layer: (options: LayerOptions) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+}
+type R2BindingValue = Schema$1.Schema.Type<typeof Schema$1.Unknown>;
+declare const isR2Bucket: (value: R2BindingValue) => value is CloudflareR2Bucket;
+declare const makeClient: (definition: R2Definition) => ((bucket: CloudflareR2Bucket) => R2Client);
+declare const layer: <Self>(tag: Context$1.Service<Self, R2Client>, definition: R2Definition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const make: <Id extends string>(id: Id) => TagClass<R2Service<Id>, Id>;
+declare const Tag: <Self>() => <Id extends string>(id: Id) => TagClass<Self, Id>;
+//#endregion
+export { LayerOptions, R2Client, R2Definition, R2GetOptions, R2ListOptions, R2MultipartOptions, R2MultipartUploadClient, R2ObjectBodyClient, R2Operation, R2OperationError, R2PutOptions, R2PutValue, R2Service, R2UploadPartOptions, R2UploadPartValue, R2_d_exports, Tag, TagClass, isR2Bucket, layer, make, makeClient };

package/dist/R2.mjs

@@ -0,0 +1,117 @@
+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/R2.ts
+var R2_exports = /* @__PURE__ */ __exportAll({
+	R2OperationError: () => R2OperationError,
+	Tag: () => Tag,
+	isR2Bucket: () => isR2Bucket,
+	layer: () => layer,
+	make: () => make,
+	makeClient: () => makeClient
+});
+const expectedR2Bucket = "R2 bucket binding with head(), get(), put(), createMultipartUpload(), resumeMultipartUpload(), delete(), and list()";
+var R2OperationError = class extends Data.TaggedError("R2OperationError") {
+	get message() {
+		return `R2 ${this.operation} failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
+	}
+};
+const r2Error = (binding, operation, cause) => new R2OperationError({
+	binding,
+	operation,
+	cause
+});
+const tryR2Promise = (binding, operation, evaluate) => Effect.tryPromise({
+	try: evaluate,
+	catch: (cause) => r2Error(binding, operation, cause)
+});
+const tryR2Sync = (binding, operation, evaluate) => Effect.try({
+	try: evaluate,
+	catch: (cause) => r2Error(binding, operation, cause)
+});
+const spanOptions = (binding, operation) => ({ attributes: {
+	binding,
+	operation
+} });
+const isR2ObjectBody = (value) => "body" in value && Predicate.isFunction(value.arrayBuffer) && Predicate.isFunction(value.bytes) && Predicate.isFunction(value.text) && Predicate.isFunction(value.json) && Predicate.isFunction(value.blob);
+const wrapObjectBody = (binding, object) => ({
+	key: object.key,
+	version: object.version,
+	size: object.size,
+	etag: object.etag,
+	httpEtag: object.httpEtag,
+	checksums: object.checksums,
+	uploaded: object.uploaded,
+	httpMetadata: object.httpMetadata,
+	customMetadata: object.customMetadata,
+	range: object.range,
+	storageClass: object.storageClass,
+	ssecKeyMd5: object.ssecKeyMd5,
+	writeHttpMetadata: (headers) => object.writeHttpMetadata(headers),
+	raw: object,
+	body: object.body,
+	get bodyUsed() {
+		return object.bodyUsed;
+	},
+	arrayBuffer: tryR2Promise(binding, "arrayBuffer", () => object.arrayBuffer()).pipe(Effect.withSpan("R2.arrayBuffer", spanOptions(binding, "arrayBuffer"))),
+	bytes: tryR2Promise(binding, "bytes", () => object.bytes()).pipe(Effect.withSpan("R2.bytes", spanOptions(binding, "bytes"))),
+	text: tryR2Promise(binding, "text", () => object.text()).pipe(Effect.withSpan("R2.text", spanOptions(binding, "text"))),
+	json: () => tryR2Promise(binding, "json", () => object.json()).pipe(Effect.withSpan("R2.json", spanOptions(binding, "json"))),
+	blob: tryR2Promise(binding, "blob", () => object.blob()).pipe(Effect.withSpan("R2.blob", spanOptions(binding, "blob")))
+});
+const wrapGetResult = (binding, object) => {
+	if (object === null || !isR2ObjectBody(object)) return object;
+	return wrapObjectBody(binding, object);
+};
+const R2BucketSchema = Schema.declare((value) => Predicate.hasProperty(value, "head") && Predicate.isFunction(value.head) && Predicate.hasProperty(value, "get") && Predicate.isFunction(value.get) && Predicate.hasProperty(value, "put") && Predicate.isFunction(value.put) && Predicate.hasProperty(value, "createMultipartUpload") && Predicate.isFunction(value.createMultipartUpload) && Predicate.hasProperty(value, "resumeMultipartUpload") && Predicate.isFunction(value.resumeMultipartUpload) && Predicate.hasProperty(value, "delete") && Predicate.isFunction(value.delete) && Predicate.hasProperty(value, "list") && Predicate.isFunction(value.list));
+const decodeR2Bucket = Schema.decodeUnknownOption(R2BucketSchema);
+const isR2Bucket = (value) => Option.isSome(decodeR2Bucket(value));
+const makeClient = (definition) => {
+	const wrapUpload = (upload) => ({
+		raw: upload,
+		key: upload.key,
+		uploadId: upload.uploadId,
+		uploadPart: Effect.fn("R2.uploadPart", spanOptions(definition.binding, "uploadPart"))((partNumber, value, options) => tryR2Promise(definition.binding, "uploadPart", () => upload.uploadPart(partNumber, value, options))),
+		abort: tryR2Promise(definition.binding, "abortMultipartUpload", () => upload.abort()).pipe(Effect.withSpan("R2.abortMultipartUpload", spanOptions(definition.binding, "abortMultipartUpload"))),
+		complete: Effect.fn("R2.completeMultipartUpload", spanOptions(definition.binding, "completeMultipartUpload"))((uploadedParts) => tryR2Promise(definition.binding, "completeMultipartUpload", () => upload.complete([...uploadedParts])))
+	});
+	return (bucket) => {
+		const get = Effect.fn("R2.get", spanOptions(definition.binding, "get"))((key, options) => tryR2Promise(definition.binding, "get", () => bucket.get(key, options)).pipe(Effect.map((object) => Option.fromNullOr(wrapGetResult(definition.binding, object)))));
+		return {
+			definition,
+			head: Effect.fn("R2.head", spanOptions(definition.binding, "head"))((key) => tryR2Promise(definition.binding, "head", () => bucket.head(key)).pipe(Effect.map(Option.fromNullOr))),
+			get,
+			put: Effect.fn("R2.put", spanOptions(definition.binding, "put"))((key, value, options) => tryR2Promise(definition.binding, "put", () => bucket.put(key, value, options)).pipe(Effect.map((object) => {
+				if (object === null) return Option.none();
+				if (options !== void 0 && "onlyIf" in options) return Option.some(object);
+				return object;
+			}))),
+			createMultipartUpload: Effect.fn("R2.createMultipartUpload", spanOptions(definition.binding, "createMultipartUpload"))((key, options) => tryR2Promise(definition.binding, "createMultipartUpload", () => bucket.createMultipartUpload(key, options)).pipe(Effect.map(wrapUpload))),
+			resumeMultipartUpload: Effect.fn("R2.resumeMultipartUpload", spanOptions(definition.binding, "resumeMultipartUpload"))((key, uploadId) => tryR2Sync(definition.binding, "resumeMultipartUpload", () => wrapUpload(bucket.resumeMultipartUpload(key, uploadId)))),
+			delete: Effect.fn("R2.delete", spanOptions(definition.binding, "delete"))((keys) => {
+				const nativeKeys = Predicate.isString(keys) ? keys : [...keys];
+				return tryR2Promise(definition.binding, "delete", () => bucket.delete(nativeKeys));
+			}),
+			list: Effect.fn("R2.list", spanOptions(definition.binding, "list"))((options) => tryR2Promise(definition.binding, "list", () => bucket.list(options))),
+			rawUnsafe: Effect.succeed(bucket)
+		};
+	};
+};
+const layer = (tag, definition) => layer$1(tag, definition.binding, isR2Bucket, makeClient(definition), { expected: expectedR2Bucket });
+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 { R2OperationError, R2_exports, Tag, isR2Bucket, layer, make, makeClient };

package/dist/Rpc.d.mts

@@ -0,0 +1,29 @@
+import * as Effect from "effect/Effect";
+import * as Schema$1 from "effect/Schema";
+import { RpcStub, RpcTarget } from "cloudflare:workers";
+import { Scope } from "effect";
+declare namespace Rpc_d_exports {
+  export { DisposableValue, MethodArgs, MethodKey, MethodReturn, Provider, Result, RpcStub, RpcTarget, Serializable, Stub, Stubable, Stubify, dispose, isDisposable, resolve, scoped };
+}
+type Stubable = Rpc.Stubable;
+type Stub<T extends Stubable> = Rpc.Stub<T>;
+type Provider<T extends object, Reserved extends string = never> = Rpc.Provider<T, Reserved>;
+type BaseType = void | undefined | null | boolean | number | bigint | string | TypedArray | ArrayBuffer | DataView | Date | Error | RegExp | ReadableStream<Uint8Array> | WritableStream<Uint8Array> | Request | Response | Headers;
+type Serializable<T> = BaseType | Map<T extends Map<infer Key, unknown> ? Serializable<Key> : never, T extends Map<unknown, infer Value> ? Serializable<Value> : never> | Set<T extends Set<infer Value> ? Serializable<Value> : never> | ReadonlyArray<T extends ReadonlyArray<infer Value> ? Serializable<Value> : never> | { [Key in keyof T]: Key extends number | string ? Serializable<T[Key]> : never; } | Stub<Stubable> | Stubable;
+type Stubify<T> = T extends Stubable ? Stub<T> : T extends Map<infer Key, infer Value> ? Map<Stubify<Key>, Stubify<Value>> : T extends Set<infer Value> ? Set<Stubify<Value>> : T extends Array<infer Value> ? Array<Stubify<Value>> : T extends ReadonlyArray<infer Value> ? ReadonlyArray<Stubify<Value>> : T extends BaseType ? T : T extends Record<string | number, infer _Value> ? { [Key in keyof T]: Stubify<T[Key]>; } : T;
+type MaybeProvider<T> = T extends object ? Provider<T> : unknown;
+type MaybeDisposable<T> = T extends object ? Disposable : unknown;
+type Result<T> = T extends Stubable ? Promise<Stub<T>> & Provider<T> : T extends Serializable<T> ? Promise<Stubify<T> & MaybeDisposable<T>> & MaybeProvider<T> : never;
+type MethodKey<Api> = { [Key in keyof Api]-?: Key extends string ? Api[Key] extends ((...args: Array<any>) => any) ? Key : never : never; }[keyof Api];
+type MethodArgs<Api, Method extends keyof Api> = Api[Method] extends ((...args: infer Args) => any) ? Args : never;
+type MethodReturn<Api, Method extends keyof Api> = Api[Method] extends ((...args: Array<any>) => infer Return) ? Return : never;
+type DisposableValue = {
+  [Symbol.dispose](): void;
+};
+type RpcBoundaryValue = Schema$1.Schema.Type<typeof Schema$1.Unknown>;
+declare const isDisposable: (value: RpcBoundaryValue) => value is DisposableValue;
+declare const dispose: (value: RpcBoundaryValue) => Effect.Effect<void>;
+declare const resolve: <A>(value: A) => Effect.Effect<Awaited<A>, unknown>;
+declare const scoped: <A>(value: A) => Effect.Effect<Awaited<A>, unknown, Scope.Scope>;
+//#endregion
+export { DisposableValue, MethodArgs, MethodKey, MethodReturn, Provider, Result, RpcStub, RpcTarget, Rpc_d_exports, Serializable, Stub, Stubable, Stubify, dispose, isDisposable, resolve, scoped };

package/dist/Rpc.mjs

@@ -0,0 +1,28 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { decodeWireError } from "./RpcDefinition.mjs";
+import * as Effect from "effect/Effect";
+import "effect/Schema";
+import * as Predicate from "effect/Predicate";
+import { RpcStub, RpcTarget } from "cloudflare:workers";
+//#region src/Rpc.ts
+var Rpc_exports = /* @__PURE__ */ __exportAll({
+	RpcStub: () => RpcStub,
+	RpcTarget: () => RpcTarget,
+	dispose: () => dispose,
+	isDisposable: () => isDisposable,
+	resolve: () => resolve,
+	scoped: () => scoped
+});
+const isDisposable = (value) => Predicate.hasProperty(value, Symbol.dispose) && Predicate.isFunction(value[Symbol.dispose]);
+const dispose = (value) => Effect.sync(() => {
+	if (isDisposable(value)) value[Symbol.dispose]();
+});
+const resolve = (value) => Predicate.isPromiseLike(value) ? Effect.tryPromise({
+	try: () => Promise.resolve(value),
+	catch: (cause) => decodeWireError(cause)
+}) : Effect.sync(() => {
+	return value;
+});
+const scoped = (value) => Effect.acquireRelease(resolve(value), (resolved) => dispose(resolved));
+//#endregion
+export { RpcStub, RpcTarget, Rpc_exports, dispose, isDisposable, resolve, scoped };

package/dist/RpcDefinition.d.mts

@@ -0,0 +1,116 @@
+import { Provider } from "./Rpc.mjs";
+import * as Effect from "effect/Effect";
+import * as S from "effect/Schema";
+declare namespace RpcDefinition_d_exports {
+  export { Definition, Method, Methods, NoReservedMethods, ReservedMethodName, RpcArgumentCountError, RpcArgumentDecodeError, RpcArgumentEncodeError, RpcReservedMethodNameError, RpcSuccessDecodeError, RpcSuccessEncodeError, ServiceFreeSchema, WireError, assertNoReservedMethods, decodeArgs, decodeSuccess, decodeWireError, encodeArgs, encodeSuccess, encodeWireError, isWireError, make, method, reservedMethodNames };
+}
+declare const RpcReservedMethodNameError_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: "RpcReservedMethodNameError";
+} & Readonly<A>;
+declare class RpcReservedMethodNameError extends RpcReservedMethodNameError_base<{
+  readonly definition: string;
+  readonly method: string;
+}> {
+  get message(): string;
+}
+declare const RpcArgumentCountError_base: S.Class<RpcArgumentCountError, S.TaggedStruct<"RpcArgumentCountError", {
+  readonly definition: S.String;
+  readonly method: S.String;
+  readonly expected: S.Number;
+  readonly actual: S.Number;
+}>, import("effect/Cause").YieldableError>;
+declare class RpcArgumentCountError extends RpcArgumentCountError_base {
+  get message(): string;
+}
+declare const RpcArgumentDecodeError_base: S.Class<RpcArgumentDecodeError, S.TaggedStruct<"RpcArgumentDecodeError", {
+  readonly definition: S.String;
+  readonly method: S.String;
+  readonly cause: S.Defect;
+}>, import("effect/Cause").YieldableError>;
+declare class RpcArgumentDecodeError extends RpcArgumentDecodeError_base {
+  get message(): string;
+}
+declare const RpcArgumentEncodeError_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: "RpcArgumentEncodeError";
+} & Readonly<A>;
+declare class RpcArgumentEncodeError extends RpcArgumentEncodeError_base<{
+  readonly definition: string;
+  readonly method: string;
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
+declare const RpcSuccessDecodeError_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: "RpcSuccessDecodeError";
+} & Readonly<A>;
+declare class RpcSuccessDecodeError extends RpcSuccessDecodeError_base<{
+  readonly definition: string;
+  readonly method: string;
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
+declare const RpcSuccessEncodeError_base: S.Class<RpcSuccessEncodeError, S.TaggedStruct<"RpcSuccessEncodeError", {
+  readonly definition: S.String;
+  readonly method: S.String;
+  readonly cause: S.Defect;
+}>, import("effect/Cause").YieldableError>;
+declare class RpcSuccessEncodeError extends RpcSuccessEncodeError_base {
+  get message(): string;
+}
+/** Errors raised server-side that must survive the Cloudflare RPC wire. */
+type WireError = RpcArgumentCountError | RpcArgumentDecodeError | RpcSuccessEncodeError;
+type WireValue = S.Schema.Type<typeof S.Unknown>;
+declare const isWireError: (error: WireValue) => error is WireError;
+/**
+ * Encodes package RPC errors into a plain `Error` envelope so their tags
+ * survive Cloudflare RPC serialization, which drops custom error properties.
+ */
+declare const encodeWireError: (error: WireValue) => WireValue;
+declare const decodeWireError: (cause: WireValue) => WireValue;
+declare const reservedMethodNameValues: readonly ["constructor", "fetch", "connect", "alarm", "webSocketMessage", "webSocketClose", "webSocketError", "then", "dup", "dispose", "serialize", "deserialize"];
+declare const reservedMethodNames: Set<string>;
+type ReservedMethodName = (typeof reservedMethodNameValues)[number];
+type ServiceFreeSchema = S.Codec<any, any, never, never>;
+interface Method<Args extends ReadonlyArray<ServiceFreeSchema> = ReadonlyArray<ServiceFreeSchema>, Success extends ServiceFreeSchema = ServiceFreeSchema> {
+  readonly args: Args;
+  readonly success: Success;
+}
+declare namespace Method {
+  export type Any = Method<ReadonlyArray<ServiceFreeSchema>, ServiceFreeSchema>;
+  type ArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends ReadonlyArray<ServiceFreeSchema>] ? [S.Schema.Type<Head>, ...ArgsFromSchemas<Tail>] : Array<S.Schema.Type<Args[number]>>;
+  type EncodedArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema>> = { [Index in keyof Args]: S.Json; };
+  export type Args<Self extends Any> = ArgsFromSchemas<Self["args"]>;
+  export type EncodedArgs<Self extends Any> = EncodedArgsFromSchemas<Self["args"]>;
+  export type Success<Self extends Any> = S.Schema.Type<Self["success"]>;
+  export type EncodedSuccess<_Self extends Any> = S.Json;
+  export {};
+}
+type Methods = Record<string, Method.Any>;
+type NoReservedMethods<MethodDefinitions extends Methods, Reserved extends string = ReservedMethodName> = Extract<keyof MethodDefinitions, Reserved> extends never ? MethodDefinitions : never;
+interface Definition<Id extends string = string, MethodDefinitions extends Methods = Methods> {
+  readonly id: Id;
+  readonly methods: MethodDefinitions;
+}
+declare namespace Definition {
+  type Any = Definition<string, Methods>;
+  type ServerApi<Self extends Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method.Args<Self["methods"][Key]>) => Promise<Method.Success<Self["methods"][Key]>>; };
+  type Api<Self extends Any, Reserved extends string = never> = Provider<ServerApi<Self>, Reserved>;
+  type MethodNames<Self extends Any> = Extract<keyof Self["methods"], string>;
+}
+type ReservedMethodValue = S.Schema.Type<typeof S.Unknown>;
+declare const assertNoReservedMethods: <MethodDefinitions extends Readonly<Record<string, ReservedMethodValue>>>(target: string, methods: MethodDefinitions, reserved: ReadonlySet<string>) => void;
+declare function method<Success extends ServiceFreeSchema>(definition: {
+  readonly success: Success;
+}): Method<readonly [], Success>;
+declare function method<const Args extends ReadonlyArray<ServiceFreeSchema>, Success extends ServiceFreeSchema>(definition: {
+  readonly args: Args;
+  readonly success: Success;
+}): Method<Args, Success>;
+declare const decodeArgs: <const Self extends Definition.Any, MethodName extends Definition.MethodNames<Self>>(definition: Self, methodName: MethodName, args: readonly unknown[]) => Effect.Effect<Self["methods"][MethodName]["args"] extends (infer T) ? T extends Self["methods"][MethodName]["args"] ? T extends readonly [] ? [] : T extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ... /*elided*/ any] : S.Schema.Type<Tail[number]>[]] : S.Schema.Type<Tail[number]>[]] : S.Schema.Type<Tail[number]>[]] : S.Schema.Type<Tail[number]>[]] : S.Schema.Type<Tail[number]>[]] : S.Schema.Type<Tail[number]>[]] : S.Schema.Type<Tail[number]>[]] : S.Schema.Type<Tail[number]>[]] : S.Schema.Type<Tail[number]>[]] : S.Schema.Type<Tail[number]>[]] : S.Schema.Type<T[number]>[] : never : never, RpcArgumentCountError | RpcArgumentDecodeError, never>;
+declare const encodeArgs: <const Self extends Definition.Any, MethodName extends Definition.MethodNames<Self>>(definition: Self, methodName: MethodName, args: Self["methods"][MethodName]["args"] extends (infer T) ? T extends Self["methods"][MethodName]["args"] ? T extends readonly [] ? [] : T extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ... /*elided*/ any] : S.Schema.Type<Tail[number]>[]] : S.Schema.Type<Tail[number]>[]] : S.Schema.Type<Tail[number]>[]] : S.Schema.Type<Tail[number]>[]] : S.Schema.Type<Tail[number]>[]] : S.Schema.Type<Tail[number]>[]] : S.Schema.Type<Tail[number]>[]] : S.Schema.Type<Tail[number]>[]] : S.Schema.Type<Tail[number]>[]] : S.Schema.Type<Tail[number]>[]] : S.Schema.Type<T[number]>[] : never : never) => Effect.Effect<Self["methods"][MethodName]["args"] extends (infer T_1 extends readonly ServiceFreeSchema[]) ? { [Index in keyof T_1]: S.Json; } : never, RpcArgumentCountError | RpcArgumentEncodeError, never>;
+declare const encodeSuccess: <const Self extends Definition.Any, MethodName extends Definition.MethodNames<Self>>(definition: Self, methodName: MethodName, value: Method.Success<Self["methods"][MethodName]>) => Effect.Effect<Method.EncodedSuccess<Self["methods"][MethodName]>, RpcSuccessEncodeError>;
+declare const decodeSuccess: <const Self extends Definition.Any, MethodName extends Definition.MethodNames<Self>>(definition: Self, methodName: MethodName, value: WireValue) => Effect.Effect<Method.Success<Self["methods"][MethodName]>, RpcSuccessDecodeError>;
+declare const make: <Id extends string, const MethodDefinitions extends Methods>(id: Id, methods: MethodDefinitions) => Definition<Id, MethodDefinitions>;
+//#endregion
+export { Definition, Method, Methods, NoReservedMethods, ReservedMethodName, RpcArgumentCountError, RpcArgumentDecodeError, RpcArgumentEncodeError, RpcDefinition_d_exports, RpcReservedMethodNameError, RpcSuccessDecodeError, RpcSuccessEncodeError, ServiceFreeSchema, WireError, assertNoReservedMethods, decodeArgs, decodeSuccess, decodeWireError, encodeArgs, encodeSuccess, encodeWireError, isWireError, make, method, reservedMethodNames };

package/dist/RpcDefinition.mjs

@@ -0,0 +1,184 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { causeMessage } from "./internal/ErrorMessage.mjs";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as S from "effect/Schema";
+import * as Predicate from "effect/Predicate";
+//#region src/RpcDefinition.ts
+var RpcDefinition_exports = /* @__PURE__ */ __exportAll({
+	RpcArgumentCountError: () => RpcArgumentCountError,
+	RpcArgumentDecodeError: () => RpcArgumentDecodeError,
+	RpcArgumentEncodeError: () => RpcArgumentEncodeError,
+	RpcReservedMethodNameError: () => RpcReservedMethodNameError,
+	RpcSuccessDecodeError: () => RpcSuccessDecodeError,
+	RpcSuccessEncodeError: () => RpcSuccessEncodeError,
+	assertNoReservedMethods: () => assertNoReservedMethods,
+	decodeArgs: () => decodeArgs,
+	decodeSuccess: () => decodeSuccess,
+	decodeWireError: () => decodeWireError,
+	encodeArgs: () => encodeArgs,
+	encodeSuccess: () => encodeSuccess,
+	encodeWireError: () => encodeWireError,
+	isWireError: () => isWireError,
+	make: () => make,
+	method: () => method,
+	reservedMethodNames: () => reservedMethodNames
+});
+var RpcReservedMethodNameError = class extends Data.TaggedError("RpcReservedMethodNameError") {
+	get message() {
+		return `${this.definition} RPC method "${this.method}" is reserved by Cloudflare Workers RPC`;
+	}
+};
+var RpcArgumentCountError = class extends S.TaggedError()("RpcArgumentCountError", {
+	definition: S.String,
+	method: S.String,
+	expected: S.Number,
+	actual: S.Number
+}) {
+	get message() {
+		return `${this.definition} RPC method "${this.method}" expected ${this.expected} arguments but received ${this.actual}`;
+	}
+};
+var RpcArgumentDecodeError = class extends S.TaggedError()("RpcArgumentDecodeError", {
+	definition: S.String,
+	method: S.String,
+	cause: S.Defect()
+}) {
+	get message() {
+		return `${this.definition} RPC method "${this.method}" argument decode failed: ${causeMessage(this.cause)}`;
+	}
+};
+var RpcArgumentEncodeError = class extends Data.TaggedError("RpcArgumentEncodeError") {
+	get message() {
+		return `${this.definition} RPC method "${this.method}" argument encode failed: ${causeMessage(this.cause)}`;
+	}
+};
+var RpcSuccessDecodeError = class extends Data.TaggedError("RpcSuccessDecodeError") {
+	get message() {
+		return `${this.definition} RPC method "${this.method}" success decode failed: ${causeMessage(this.cause)}`;
+	}
+};
+var RpcSuccessEncodeError = class extends S.TaggedError()("RpcSuccessEncodeError", {
+	definition: S.String,
+	method: S.String,
+	cause: S.Defect()
+}) {
+	get message() {
+		return `${this.definition} RPC method "${this.method}" success encode failed: ${causeMessage(this.cause)}`;
+	}
+};
+const WireErrorSchema = S.Union([
+	RpcArgumentCountError,
+	RpcArgumentDecodeError,
+	RpcSuccessEncodeError
+]);
+const wireErrorKey = "effect-cf/RpcDefinition/wireError";
+const isWireError = (error) => error instanceof RpcArgumentCountError || error instanceof RpcArgumentDecodeError || error instanceof RpcSuccessEncodeError;
+/**
+* Encodes package RPC errors into a plain `Error` envelope so their tags
+* survive Cloudflare RPC serialization, which drops custom error properties.
+*/
+const encodeWireError = (error) => {
+	if (!isWireError(error)) return error;
+	try {
+		return new Error(JSON.stringify({ [wireErrorKey]: S.encodeSync(WireErrorSchema)(error) }));
+	} catch {
+		return error;
+	}
+};
+const decodeWireError = (cause) => {
+	if (!(cause instanceof Error)) return cause;
+	try {
+		const parsed = S.decodeUnknownSync(S.Unknown)(JSON.parse(cause.message));
+		if (!Predicate.hasProperty(parsed, wireErrorKey)) return cause;
+		return S.decodeUnknownSync(WireErrorSchema)(parsed[wireErrorKey]);
+	} catch {
+		return cause;
+	}
+};
+const reservedMethodNames = /* @__PURE__ */ new Set([
+	"constructor",
+	"fetch",
+	"connect",
+	"alarm",
+	"webSocketMessage",
+	"webSocketClose",
+	"webSocketError",
+	"then",
+	"dup",
+	"dispose",
+	"serialize",
+	"deserialize"
+]);
+/**
+* Workers RPC structured-clones every value that crosses an isolate boundary
+* and rejects class instances. Declaration schemas such as `Schema.Result`
+* keep their container instance in their `Encoded` form, so the declared
+* schemas are lowered to their canonical JSON codec before touching the wire.
+*/
+const wireCodec = (schema) => S.toCodecJson(schema);
+const assertNoReservedMethods = (target, methods, reserved) => {
+	for (const method of Object.keys(methods)) if (reserved.has(method)) throw new RpcReservedMethodNameError({
+		definition: target,
+		method
+	});
+};
+function method(definition) {
+	return {
+		args: definition.args ?? [],
+		success: definition.success
+	};
+}
+const decodeArgs = Effect.fnUntraced(function* (definition, methodName, args) {
+	const methodDefinition = definition.methods[methodName];
+	if (args.length !== methodDefinition.args.length) return yield* new RpcArgumentCountError({
+		definition: definition.id,
+		method: methodName,
+		expected: methodDefinition.args.length,
+		actual: args.length
+	});
+	return yield* S.decodeUnknownEffect(wireCodec(S.Tuple(methodDefinition.args)))(args).pipe(Effect.mapError((cause) => new RpcArgumentDecodeError({
+		definition: definition.id,
+		method: methodName,
+		cause
+	})));
+});
+const encodeArgs = Effect.fnUntraced(function* (definition, methodName, args) {
+	const methodDefinition = definition.methods[methodName];
+	if (args.length !== methodDefinition.args.length) return yield* new RpcArgumentCountError({
+		definition: definition.id,
+		method: methodName,
+		expected: methodDefinition.args.length,
+		actual: args.length
+	});
+	return yield* S.encodeUnknownEffect(wireCodec(S.Tuple(methodDefinition.args)))(args).pipe(Effect.mapError((cause) => new RpcArgumentEncodeError({
+		definition: definition.id,
+		method: methodName,
+		cause
+	})));
+});
+const encodeSuccess = (definition, methodName, value) => {
+	const methodDefinition = definition.methods[methodName];
+	return S.encodeUnknownEffect(wireCodec(methodDefinition.success))(value).pipe(Effect.mapError((cause) => new RpcSuccessEncodeError({
+		definition: definition.id,
+		method: methodName,
+		cause
+	})));
+};
+const decodeSuccess = (definition, methodName, value) => {
+	const methodDefinition = definition.methods[methodName];
+	return S.decodeUnknownEffect(wireCodec(methodDefinition.success))(value).pipe(Effect.mapError((cause) => new RpcSuccessDecodeError({
+		definition: definition.id,
+		method: methodName,
+		cause
+	})));
+};
+const make = (id, methods) => {
+	assertNoReservedMethods(id, methods, reservedMethodNames);
+	return {
+		id,
+		methods
+	};
+};
+//#endregion
+export { RpcArgumentCountError, RpcArgumentDecodeError, RpcArgumentEncodeError, RpcDefinition_exports, RpcReservedMethodNameError, RpcSuccessDecodeError, RpcSuccessEncodeError, assertNoReservedMethods, decodeArgs, decodeSuccess, decodeWireError, encodeArgs, encodeSuccess, encodeWireError, isWireError, make, method, reservedMethodNames };