effect-cf 0.40.0 → 0.40.2

package/dist/Images.mjs

@@ -0,0 +1,112 @@
+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 Predicate from "effect/Predicate";
+import * as Option from "effect/Option";
+import * as Function from "effect/Function";
+//#region src/Images.ts
+var Images_exports = /* @__PURE__ */ __exportAll({
+	ImagesOperationError: () => ImagesOperationError,
+	Step: () => Step,
+	Tag: () => Tag,
+	draw: () => draw,
+	empty: () => empty,
+	isImagesBinding: () => isImagesBinding,
+	layer: () => layer,
+	make: () => make,
+	makeClient: () => makeClient,
+	transform: () => transform
+});
+const TypeId = "~effect-cf/Images/Steps";
+const expectedImagesBinding = "Images binding with info() and input()";
+var ImagesOperationError = class extends Data.TaggedError("ImagesOperationError") {
+	get message() {
+		return `Images ${this.operation} failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
+	}
+};
+const Step = Data.taggedEnum();
+const makeSteps = (steps) => ({
+	[TypeId]: TypeId,
+	steps
+});
+const empty = makeSteps([]);
+const transform = Function.dual(2, (steps, transformValue) => makeSteps([...steps.steps, Step.Transform({ transform: transformValue })]));
+const draw = Function.dual(2, (steps, drawValue) => makeSteps([...steps.steps, Step.Draw(drawValue)]));
+const imagesError = (binding, operation, cause) => new ImagesOperationError({
+	binding,
+	operation,
+	cause
+});
+const tryImagesPromise = (binding, operation, evaluate) => Effect.tryPromise({
+	try: evaluate,
+	catch: (cause) => imagesError(binding, operation, cause)
+});
+const tryImagesSync = (binding, operation, evaluate) => Effect.try({
+	try: evaluate,
+	catch: (cause) => imagesError(binding, operation, cause)
+});
+const maybe = (value) => value === null ? Option.none() : Option.some(value);
+const hasFunction = (value, key) => Predicate.hasProperty(value, key) && Predicate.isFunction(value[key]);
+const isHostedImagesBinding = (value) => hasFunction(value, "image") && hasFunction(value, "upload") && hasFunction(value, "list") && hasFunction(value, "createDirectUpload");
+const isImagesBinding = (value) => hasFunction(value, "info") && hasFunction(value, "input");
+const wrapResult = (binding, result) => ({
+	raw: result,
+	response: (options) => tryImagesSync(binding, "response", () => result.response(options)),
+	contentType: tryImagesSync(binding, "contentType", () => result.contentType()),
+	image: (options) => tryImagesSync(binding, "image", () => result.image(options))
+});
+const wrapHandle = (binding, handle) => ({
+	raw: handle,
+	details: tryImagesPromise(binding, "details", () => handle.details()).pipe(Effect.map(maybe), Effect.withSpan("Images.details")),
+	bytes: tryImagesPromise(binding, "bytes", () => handle.bytes()).pipe(Effect.map(maybe), Effect.withSpan("Images.bytes")),
+	signedUrl: Effect.fn("Images.signedUrl")((options) => tryImagesPromise(binding, "signedUrl", () => handle.signedUrl(options))),
+	update: Effect.fn("Images.update")((options) => tryImagesPromise(binding, "update", () => handle.update(options))),
+	delete: tryImagesPromise(binding, "delete", () => handle.delete()).pipe(Effect.withSpan("Images.delete"))
+});
+const wrapHosted = (binding, hosted) => ({
+	image: (imageId) => wrapHandle(binding, hosted.image(imageId)),
+	upload: Effect.fn("Images.upload")((image, options) => tryImagesPromise(binding, "upload", () => hosted.upload(image, options))),
+	list: Effect.fn("Images.list")((options) => tryImagesPromise(binding, "list", () => hosted.list(options))),
+	createDirectUpload: Effect.fn("Images.createDirectUpload")((options) => tryImagesPromise(binding, "createDirectUpload", () => hosted.createDirectUpload(options))),
+	rawUnsafe: Effect.succeed(hosted)
+});
+const makeClient = (definition) => (images) => {
+	const input = (image, options) => tryImagesSync(definition.binding, "input", () => images.input(image, options));
+	const text = (content, options) => tryImagesSync(definition.binding, "text", () => {
+		if (!hasFunction(images, "text")) throw new Error("Images binding is missing text()");
+		return images.text(content, options);
+	});
+	const process = Effect.fn("Images.process")(function* (steps, options) {
+		let transformer = "text" in options ? yield* text(options.text, options.textOptions) : yield* input(options.stream, options.inputOptions);
+		for (const step of steps.steps) transformer = yield* Step.$match(step, {
+			Draw: (drawStep) => tryImagesSync(definition.binding, "draw", () => transformer.draw(drawStep.image, drawStep.options)),
+			Transform: (transformStep) => tryImagesSync(definition.binding, "transform", () => transformer.transform(transformStep.transform))
+		});
+		const result = yield* tryImagesPromise(definition.binding, "output", () => transformer.output(options.outputOptions));
+		return wrapResult(definition.binding, result);
+	});
+	return {
+		definition,
+		info: Effect.fn("Images.info")((image, options) => tryImagesPromise(definition.binding, "info", () => images.info(image, options))),
+		input,
+		text,
+		process,
+		hosted: isHostedImagesBinding(images.hosted) ? Option.some(wrapHosted(definition.binding, images.hosted)) : Option.none(),
+		rawUnsafe: Effect.succeed(images)
+	};
+};
+const layer = (tag, definition) => layer$1(tag, definition.binding, isImagesBinding, makeClient(definition), { expected: expectedImagesBinding });
+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 { ImagesOperationError, Images_exports, Step, Tag, draw, empty, isImagesBinding, layer, make, makeClient, transform };

package/dist/Kv.d.mts

@@ -0,0 +1,84 @@
+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 S from "effect/Schema";
+import * as Option from "effect/Option";
+import { Layer } from "effect";
+declare namespace Kv_d_exports {
+  export { Definition, KvClient, KvDefinition, KvListKey, KvListOptions, KvListResult, KvOperation, KvOperationError, KvPutOptions, KvWithMetadata, LayerOptions, Tag, TagClass, isKvNamespace, layer, makeClient };
+}
+type KvOperation = "put" | "get" | "getWithMetadata" | "list" | "delete";
+declare const KvOperationError_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: "KvOperationError";
+} & Readonly<A>;
+declare class KvOperationError extends KvOperationError_base<{
+  readonly binding: string;
+  readonly operation: KvOperation;
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
+type KvPutOptions = CloudflareKVNamespacePutOptions;
+type KvListOptions<Metadata = unknown> = CloudflareKVNamespaceListOptions & {
+  readonly metadataSchema?: S.Codec<Metadata, unknown>;
+};
+interface KvWithMetadata<Value, Metadata> {
+  readonly value: Value;
+  readonly metadata: Option.Option<Metadata>;
+  readonly cacheStatus: Option.Option<string>;
+}
+interface KvListKey<Key, Metadata = unknown> {
+  readonly name: Key;
+  readonly expiration: Option.Option<number>;
+  readonly metadata: Option.Option<Metadata>;
+}
+interface KvListResult<Key, Metadata = unknown> {
+  readonly keys: ReadonlyArray<KvListKey<Key, Metadata>>;
+  readonly listComplete: boolean;
+  readonly cursor: Option.Option<string>;
+  readonly cacheStatus: Option.Option<string>;
+}
+interface KvDefinition<Key, Value, EncodedValue> {
+  readonly binding: string;
+  readonly key: S.Codec<Key, string>;
+  readonly value: S.Codec<Value, EncodedValue>;
+}
+/**
+ * Reusable typed KV resource definition without a concrete Cloudflare binding name.
+ */
+interface Definition<Id extends string = string, Key = unknown, Value = unknown, EncodedValue = unknown> {
+  readonly id: Id;
+  readonly key: S.Codec<Key, string>;
+  readonly value: S.Codec<Value, EncodedValue>;
+}
+declare namespace Definition {
+  type Any = Definition<string, any, any, any>;
+}
+interface KvClient<Key, Value, EncodedValue> {
+  readonly put: (key: Key, value: Value, options?: KvPutOptions) => Effect.Effect<void, KvOperationError | S.SchemaError>;
+  readonly get: (key: Key) => Effect.Effect<Option.Option<Value>, KvOperationError | S.SchemaError>;
+  readonly getWithMetadata: <Metadata>(key: Key, metadataSchema: S.Codec<Metadata, unknown>) => Effect.Effect<Option.Option<KvWithMetadata<Value, Metadata>>, KvOperationError | S.SchemaError>;
+  readonly list: <Metadata = unknown>(options?: KvListOptions<Metadata>) => Effect.Effect<KvListResult<Key, Metadata>, KvOperationError | S.SchemaError>;
+  readonly delete: (key: Key) => Effect.Effect<void, KvOperationError | S.SchemaError>;
+  readonly rawUnsafe: Effect.Effect<KVNamespace>;
+  readonly definition: KvDefinition<Key, Value, EncodedValue>;
+}
+type LayerOptions = {
+  readonly binding: string;
+};
+interface TagClass<Self, Id extends string, Key, Value, EncodedValue> extends Context$1.ServiceClass<Self, Id, KvClient<Key, Value, EncodedValue>> {
+  readonly id: Id;
+  readonly keySchema: S.Codec<Key, string>;
+  readonly valueSchema: S.Codec<Value, EncodedValue>;
+  readonly layer: (options: LayerOptions) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+}
+declare const isKvNamespace: <Candidate>(value: Candidate) => value is Candidate & KVNamespace;
+declare const makeClient: <Key, Value, EncodedValue>(definition: KvDefinition<Key, Value, EncodedValue>) => ((kv: KVNamespace) => KvClient<Key, Value, EncodedValue>);
+declare const layer: <Self, Key, Value, EncodedValue>(tag: Context$1.Service<Self, KvClient<Key, Value, EncodedValue>>, definition: KvDefinition<Key, Value, EncodedValue>) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const Tag: <Self>() => <Id extends string, Key, Value, EncodedValue>(id: Id, definition: {
+  readonly key: S.Codec<Key, string>;
+  readonly value: S.Codec<Value, EncodedValue>;
+}) => TagClass<Self, Id, Key, Value, EncodedValue>;
+//#endregion
+export { Definition, KvClient, KvDefinition, KvListKey, KvListOptions, KvListResult, KvOperation, KvOperationError, KvPutOptions, KvWithMetadata, Kv_d_exports, LayerOptions, Tag, TagClass, isKvNamespace, layer, makeClient };

package/dist/Kv.mjs

@@ -0,0 +1,132 @@
+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 S from "effect/Schema";
+import * as Predicate from "effect/Predicate";
+import * as Option from "effect/Option";
+//#region src/Kv.ts
+var Kv_exports = /* @__PURE__ */ __exportAll({
+	KvOperationError: () => KvOperationError,
+	Tag: () => Tag,
+	isKvNamespace: () => isKvNamespace,
+	layer: () => layer,
+	makeClient: () => makeClient
+});
+const expectedKvNamespace = "KV namespace binding with get(), put(), delete(), getWithMetadata(), and list()";
+var KvOperationError = class extends Data.TaggedError("KvOperationError") {
+	get message() {
+		return `Kv ${this.operation} failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
+	}
+};
+const kvError = (binding, operation, cause) => new KvOperationError({
+	binding,
+	operation,
+	cause
+});
+const tryKvPromise = (binding, operation, evaluate) => Effect.tryPromise({
+	try: evaluate,
+	catch: (cause) => kvError(binding, operation, cause)
+});
+const isKvNamespace = (value) => Predicate.hasProperty(value, "get") && Predicate.isFunction(value.get) && Predicate.hasProperty(value, "put") && Predicate.isFunction(value.put) && Predicate.hasProperty(value, "delete") && Predicate.isFunction(value.delete) && Predicate.hasProperty(value, "getWithMetadata") && Predicate.isFunction(value.getWithMetadata) && Predicate.hasProperty(value, "list") && Predicate.isFunction(value.list);
+const makeClient = (definition) => {
+	const encodeKey = S.encodeEffect(definition.key);
+	const decodeKey = S.decodeUnknownEffect(definition.key);
+	const jsonValue = S.fromJsonString(S.toCodecJson(definition.value));
+	const encodeValue = S.encodeEffect(jsonValue);
+	const decodeValue = S.decodeUnknownEffect(jsonValue);
+	return (kv) => ({
+		definition,
+		put: Effect.fn("Kv.put", { attributes: {
+			binding: definition.binding,
+			operation: "put"
+		} })(function* (key, value, options) {
+			const keyEncoded = yield* encodeKey(key);
+			const valueEncoded = yield* encodeValue(value);
+			yield* tryKvPromise(definition.binding, "put", () => kv.put(keyEncoded, valueEncoded, options));
+		}),
+		get: Effect.fn("Kv.get", { attributes: {
+			binding: definition.binding,
+			operation: "get"
+		} })(function* (key) {
+			const keyEncoded = yield* encodeKey(key);
+			const valueEncoded = yield* tryKvPromise(definition.binding, "get", () => kv.get(keyEncoded));
+			if (valueEncoded === null) return Option.none();
+			return yield* decodeValue(valueEncoded).pipe(Effect.map(Option.some));
+		}),
+		getWithMetadata: Effect.fn("Kv.getWithMetadata", { attributes: {
+			binding: definition.binding,
+			operation: "getWithMetadata"
+		} })(function* (key, metadataSchema) {
+			const keyEncoded = yield* encodeKey(key);
+			const result = yield* tryKvPromise(definition.binding, "getWithMetadata", () => kv.getWithMetadata(keyEncoded));
+			if (result.value === null) return Option.none();
+			const value = yield* decodeValue(result.value);
+			const metadata = result.metadata === null ? Option.none() : Option.some(yield* S.decodeUnknownEffect(metadataSchema)(result.metadata));
+			return Option.some({
+				value,
+				metadata,
+				cacheStatus: Option.fromNullishOr(result.cacheStatus)
+			});
+		}),
+		list: Effect.fn("Kv.list", { attributes: {
+			binding: definition.binding,
+			operation: "list"
+		} })(function* (options) {
+			const { metadataSchema, ...kvOptions } = options ?? {};
+			const result = yield* tryKvPromise(definition.binding, "list", () => kv.list(kvOptions));
+			const keys = [];
+			for (const key of result.keys) {
+				const decodedName = yield* decodeKey(key.name);
+				const decodedMetadata = key.metadata === void 0 ? Option.none() : metadataSchema === void 0 ? Option.some(key.metadata) : Option.some(yield* S.decodeUnknownEffect(metadataSchema)(key.metadata));
+				keys.push({
+					name: decodedName,
+					expiration: Option.fromUndefinedOr(key.expiration),
+					metadata: decodedMetadata
+				});
+			}
+			return {
+				keys,
+				listComplete: result.list_complete,
+				cursor: Option.fromNullishOr("cursor" in result ? result.cursor : void 0),
+				cacheStatus: Option.fromNullishOr(result.cacheStatus)
+			};
+		}),
+		delete: Effect.fn("Kv.delete", { attributes: {
+			binding: definition.binding,
+			operation: "delete"
+		} })(function* (key) {
+			const keyEncoded = yield* encodeKey(key);
+			yield* tryKvPromise(definition.binding, "delete", () => kv.delete(keyEncoded));
+		}),
+		rawUnsafe: Effect.succeed(kv)
+	});
+};
+const layer = (tag, definition) => layer$1(tag, definition.binding, isKvNamespace, makeClient(definition), { expected: expectedKvNamespace });
+const makeDefinition = (id, definition) => {
+	const kvDefinition = {
+		id,
+		key: definition.key,
+		value: definition.value
+	};
+	return Object.assign(kvDefinition, { layer: (tag, binding) => layer(tag, {
+		...binding,
+		key: definition.key,
+		value: definition.value
+	}) });
+};
+const Tag = () => (id, definition) => {
+	const kvDefinition = makeDefinition(id, definition);
+	const tag = Context.Service()(id);
+	const makeLayer = (binding) => kvDefinition.layer(tag, binding);
+	return Object.assign(tag, {
+		id: kvDefinition.id,
+		keySchema: kvDefinition.key,
+		valueSchema: kvDefinition.value,
+		layer: makeLayer
+	});
+};
+//#endregion
+export { KvOperationError, Kv_exports, Tag, isKvNamespace, layer, makeClient };

package/dist/Mcp.d.mts

@@ -1,7 +1,9 @@
-import { n as NativeRequest } from "./Worker-gV4mDqIs.mjs";
-import { Effect, Option } from "effect";
+import { NativeRequest } from "./Worker.mjs";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
 import { CreateMcpHandlerOptions, ServerOptions } from "@modelcontextprotocol/server";
-import { Tool, Toolkit } from "effect/unstable/ai";
+import * as Tool from "effect/unstable/ai/Tool";
+import { Toolkit } from "effect/unstable/ai";
 //#region src/Mcp.d.ts
 /**
  * CORS headers applied to MCP responses.

package/dist/Mcp.mjs

@@ -1,8 +1,17 @@
-import { r as runNativeCallback } from "./WorkerContext-Yobnfw-K.mjs";
-import { n as NativeRequest } from "./Worker-XsGJsCJX.mjs";
-import { Cause, Context, Effect, Exit, Option, Predicate, Schema, Sink, Stream } from "effect";
+import { runNativeCallback } from "./internal/NativeCallback.mjs";
+import { NativeRequest } from "./Worker.mjs";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as Predicate from "effect/Predicate";
+import * as Option from "effect/Option";
+import * as Cause from "effect/Cause";
+import * as Exit from "effect/Exit";
+import * as Stream from "effect/Stream";
 import { McpServer, createMcpHandler, hostHeaderValidationResponse, localhostAllowedHostnames, localhostAllowedOrigins, originValidationResponse } from "@modelcontextprotocol/server";
-import { AiError, Tool } from "effect/unstable/ai";
+import * as Sink from "effect/Sink";
+import * as AiError from "effect/unstable/ai/AiError";
+import * as Tool from "effect/unstable/ai/Tool";
 //#region src/Mcp.ts
 const DEFAULT_CORS_OPTIONS = {
 	origin: "*",

package/dist/Queue.d.mts

@@ -0,0 +1,64 @@
+import { WorkerEnvironment } from "./Environment.mjs";
+import { Definition as Definition$1, Handler as Handler$1, LayerOptions as LayerOptions$1, Options as Options$1, Tag, TagClass as TagClass$1, implement } from "./QueueDefinition.mjs";
+import { ExecutionContext, WorkerContext } from "./Worker.mjs";
+import * as Effect from "effect/Effect";
+import { Scope } from "effect";
+declare namespace Queue_d_exports {
+  export { Definition, Handler, LayerOptions, Options, QueueBatch, QueueHandler, QueueMessage, QueueMessageDecodeError, QueueOptions, Tag, TagClass, decodeBatch, fromMessage, fromMessageBatch, implement };
+}
+interface QueueMessage<Body> {
+  readonly raw: globalThis.Message<unknown>;
+  readonly id: string;
+  readonly timestamp: Date;
+  readonly body: Body;
+  readonly attempts: number;
+  readonly ack: Effect.Effect<void>;
+  readonly retry: (options?: globalThis.QueueRetryOptions) => Effect.Effect<void>;
+}
+interface QueueBatch<Body> {
+  readonly raw: globalThis.MessageBatch<unknown>;
+  readonly messages: ReadonlyArray<QueueMessage<Body>>;
+  readonly queue: string;
+  readonly metadata: globalThis.MessageBatchMetadata;
+  readonly ackAll: Effect.Effect<void>;
+  readonly retryAll: (options?: globalThis.QueueRetryOptions) => Effect.Effect<void>;
+}
+declare const QueueMessageDecodeError_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: "QueueMessageDecodeError";
+} & Readonly<A>;
+declare class QueueMessageDecodeError extends QueueMessageDecodeError_base<{
+  readonly queue: string;
+  readonly messageId: string;
+  readonly index: number;
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
+type RuntimeContext<ROut> = ExecutionContext | WorkerContext | WorkerEnvironment | ROut;
+type QueueHandlerContext<ROut> = RuntimeContext<ROut> | Scope.Scope;
+type EncodedQueueBody = globalThis.Message<unknown>["body"];
+type QueueHandler<ROut, Body = unknown> = (batch: QueueBatch<Body>) => Effect.Effect<void, unknown, QueueHandlerContext<ROut>>;
+interface QueueOptions<ROut, Body = unknown> {
+  readonly queue: QueueHandler<ROut, Body>;
+}
+declare const fromMessage: <Body>(message: globalThis.Message<unknown>, body: Body) => {
+  raw: Message<unknown>;
+  id: string;
+  timestamp: Date;
+  body: Body;
+  attempts: number;
+  ack: Effect.Effect<void, never, never>;
+  retry: (options?: globalThis.QueueRetryOptions) => Effect.Effect<void, never, never>;
+};
+declare const fromMessageBatch: <Body>(batch: globalThis.MessageBatch<unknown>, messages: ReadonlyArray<QueueMessage<Body>>) => QueueBatch<Body>;
+declare const decodeBatch: <Body>(batch: globalThis.MessageBatch<unknown>, decodeBody: (body: EncodedQueueBody) => Effect.Effect<Body, unknown>) => Effect.Effect<QueueBatch<Body>, QueueMessageDecodeError>;
+type Definition<Id extends string = string, Message extends Definition$1.Any["message"] = Definition$1.Any["message"]> = Definition$1<Id, Message>;
+declare namespace Definition {
+  type Any = Definition$1.Any;
+}
+type LayerOptions = LayerOptions$1;
+type TagClass<Self, Id extends string, Message extends Definition$1.Any["message"]> = TagClass$1<Self, Id, Message>;
+type Handler<ROut, Self extends Definition$1.Any> = Handler$1<ROut, Self>;
+type Options<ROut, Self extends Definition$1.Any> = Options$1<ROut, Self>;
+//#endregion
+export { Definition, Handler, LayerOptions, Options, QueueBatch, QueueHandler, QueueMessage, QueueMessageDecodeError, QueueOptions, Queue_d_exports, Tag, TagClass, decodeBatch, fromMessage, fromMessageBatch, implement };

package/dist/Queue.mjs

@@ -0,0 +1,52 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { causeMessage } from "./internal/ErrorMessage.mjs";
+import { Tag, implement } from "./QueueDefinition.mjs";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+//#region src/Queue.ts
+var Queue_exports = /* @__PURE__ */ __exportAll({
+	QueueMessageDecodeError: () => QueueMessageDecodeError,
+	Tag: () => Tag,
+	decodeBatch: () => decodeBatch,
+	fromMessage: () => fromMessage,
+	fromMessageBatch: () => fromMessageBatch,
+	implement: () => implement
+});
+var QueueMessageDecodeError = class extends Data.TaggedError("QueueMessageDecodeError") {
+	get message() {
+		return `Queue "${this.queue}" failed to decode message "${this.messageId}" at index ${this.index}: ${causeMessage(this.cause)}`;
+	}
+};
+const fromMessage = (message, body) => ({
+	raw: message,
+	id: message.id,
+	timestamp: message.timestamp,
+	body,
+	attempts: message.attempts,
+	ack: Effect.sync(() => message.ack()),
+	retry: (options) => Effect.sync(() => message.retry(options))
+});
+const fromMessageBatch = (batch, messages) => ({
+	raw: batch,
+	messages,
+	queue: batch.queue,
+	metadata: batch.metadata,
+	ackAll: Effect.sync(() => batch.ackAll()),
+	retryAll: (options) => Effect.sync(() => batch.retryAll(options))
+});
+const decodeBatch = (batch, decodeBody) => Effect.gen(function* () {
+	const messages = [];
+	for (let index = 0; index < batch.messages.length; index++) {
+		const message = batch.messages[index];
+		const body = yield* decodeBody(message.body).pipe(Effect.mapError((cause) => new QueueMessageDecodeError({
+			queue: batch.queue,
+			messageId: message.id,
+			index,
+			cause
+		})));
+		messages.push(fromMessage(message, body));
+	}
+	return fromMessageBatch(batch, messages);
+});
+//#endregion
+export { QueueMessageDecodeError, Queue_exports, Tag, decodeBatch, fromMessage, fromMessageBatch, implement };

package/dist/QueueBinding.d.mts

@@ -0,0 +1,42 @@
+import { WorkerEnvironment } from "./Environment.mjs";
+import { BindingNotFoundError, BindingValidationError } from "./Binding.mjs";
+import { ServiceFreeSchema } from "./RpcDefinition.mjs";
+import * as Effect from "effect/Effect";
+import * as S from "effect/Schema";
+import * as Predicate from "effect/Predicate";
+import { Context } from "effect";
+declare namespace QueueBinding_d_exports {
+  export { MessageSendRequest, QueueBindingClient, QueueBindingDefinition, QueueMetrics, QueueOperationError, QueueProducer, QueueSendBatchOptions, QueueSendBatchResponse, QueueSendOptions, QueueSendResponse, isQueue, layer, makeClient };
+}
+type QueueSendOptions = CloudflareQueueSendOptions;
+type QueueSendResponse = CloudflareQueueSendResponse;
+type QueueSendBatchOptions = CloudflareQueueSendBatchOptions;
+type QueueSendBatchResponse = CloudflareQueueSendBatchResponse;
+type QueueMetrics = CloudflareQueueMetrics;
+type MessageSendRequest<Body> = CloudflareMessageSendRequest<Body>;
+type QueueProducer<Body> = Pick<CloudflareQueue<Body>, "send"> & Partial<Pick<CloudflareQueue<Body>, "sendBatch" | "metrics">>;
+type QueueCandidate = Parameters<typeof Predicate.isUnknown>[0];
+interface QueueBindingDefinition<Message extends ServiceFreeSchema> {
+  readonly binding: string;
+  readonly message: Message;
+}
+interface QueueBindingClient<Message extends ServiceFreeSchema> {
+  readonly send: (message: S.Schema.Type<Message>, options?: QueueSendOptions) => Effect.Effect<void, QueueOperationError | S.SchemaError>;
+  readonly sendBatch: (messages: Iterable<MessageSendRequest<S.Schema.Type<Message>>>, options?: QueueSendBatchOptions) => Effect.Effect<void, QueueOperationError | S.SchemaError>;
+  readonly metrics: () => Effect.Effect<QueueMetrics, QueueOperationError>;
+  readonly rawUnsafe: Effect.Effect<QueueProducer<S.Codec.Encoded<Message>>>;
+}
+declare const QueueOperationError_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: "QueueOperationError";
+} & Readonly<A>;
+declare class QueueOperationError extends QueueOperationError_base<{
+  readonly binding: string;
+  readonly operation: string;
+  readonly cause: unknown;
+  readonly message: string;
+}> {}
+declare const isQueue: <Body>(value: QueueCandidate) => value is QueueProducer<Body>;
+declare const makeClient: <Message extends ServiceFreeSchema>(definition: QueueBindingDefinition<Message>) => ((queue: QueueProducer<S.Codec.Encoded<Message>>) => QueueBindingClient<Message>);
+declare const layer: <Self, Message extends ServiceFreeSchema>(tag: Context.Service<Self, QueueBindingClient<Message>>, definition: QueueBindingDefinition<Message>) => import("effect/Layer").Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+//#endregion
+export { MessageSendRequest, QueueBindingClient, QueueBindingDefinition, QueueBinding_d_exports, QueueMetrics, QueueOperationError, QueueProducer, QueueSendBatchOptions, QueueSendBatchResponse, QueueSendOptions, QueueSendResponse, isQueue, layer, makeClient };

package/dist/QueueBinding.mjs

@@ -0,0 +1,69 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { layer as layer$1 } from "./Binding.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/QueueBinding.ts
+var QueueBinding_exports = /* @__PURE__ */ __exportAll({
+	QueueOperationError: () => QueueOperationError,
+	isQueue: () => isQueue,
+	layer: () => layer,
+	makeClient: () => makeClient
+});
+const expectedQueueProducer = "Queue producer binding with send(); optional sendBatch()/metrics()";
+var QueueOperationError = class extends Data.TaggedError("QueueOperationError") {};
+const tryQueuePromise = (binding, operation, evaluate) => Effect.tryPromise({
+	try: evaluate,
+	catch: (cause) => new QueueOperationError({
+		binding,
+		operation,
+		cause,
+		message: `Cloudflare queue binding "${binding}" operation "${operation}" failed`
+	})
+});
+const isQueue = (value) => Predicate.hasProperty(value, "send") && Predicate.isFunction(value.send);
+const makeClient = (definition) => {
+	const encodeMessage = S.encodeEffect(definition.message);
+	return (queue) => ({
+		send: Effect.fn("QueueBinding.send", { attributes: {
+			binding: definition.binding,
+			operation: "send"
+		} })(function* (message, options) {
+			const encoded = yield* encodeMessage(message);
+			yield* tryQueuePromise(definition.binding, "send", () => queue.send(encoded, options));
+		}),
+		sendBatch: Effect.fn("QueueBinding.sendBatch", { attributes: {
+			binding: definition.binding,
+			operation: "sendBatch"
+		} })(function* (messages, options) {
+			const encodedMessages = [];
+			for (const message of messages) encodedMessages.push({
+				...message,
+				body: yield* encodeMessage(message.body)
+			});
+			const sendBatch = queue.sendBatch;
+			if (sendBatch === void 0) return yield* new QueueOperationError({
+				binding: definition.binding,
+				operation: "sendBatch",
+				cause: /* @__PURE__ */ new Error(`Queue binding "${definition.binding}" does not provide sendBatch()`),
+				message: `Cloudflare queue binding "${definition.binding}" does not provide sendBatch()`
+			});
+			yield* tryQueuePromise(definition.binding, "sendBatch", () => sendBatch.call(queue, encodedMessages, options));
+		}),
+		metrics: () => {
+			const metrics = queue.metrics;
+			if (metrics === void 0) return Effect.fail(new QueueOperationError({
+				binding: definition.binding,
+				operation: "metrics",
+				cause: /* @__PURE__ */ new Error(`Queue binding "${definition.binding}" does not provide metrics()`),
+				message: `Cloudflare queue binding "${definition.binding}" does not provide metrics()`
+			}));
+			return tryQueuePromise(definition.binding, "metrics", () => metrics.call(queue));
+		},
+		rawUnsafe: Effect.succeed(queue)
+	});
+};
+const layer = (tag, definition) => layer$1(tag, definition.binding, (value) => isQueue(value), makeClient(definition), { expected: expectedQueueProducer });
+//#endregion
+export { QueueBinding_exports, QueueOperationError, isQueue, layer, makeClient };

package/dist/QueueDefinition.d.mts

@@ -0,0 +1,48 @@
+import { WorkerEnvironment } from "./Environment.mjs";
+import { BindingNotFoundError, BindingValidationError } from "./Binding.mjs";
+import { ServiceFreeSchema } from "./RpcDefinition.mjs";
+import { MessageSendRequest, QueueBindingClient, QueueMetrics, QueueOperationError, QueueProducer, QueueSendBatchOptions, QueueSendOptions } from "./QueueBinding.mjs";
+import { QueueBatch } from "./Queue.mjs";
+import { ExecutionContext, WorkerClass, WorkerContext, WorkerOptions } from "./Worker.mjs";
+import * as Context$1 from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as S from "effect/Schema";
+import { Layer, Scope } from "effect";
+declare namespace QueueDefinition_d_exports {
+  export { Definition, Handler, LayerOptions, Options, Queue, Tag, TagClass, implement, make };
+}
+interface Definition<Id extends string = string, Message extends ServiceFreeSchema = ServiceFreeSchema> {
+  readonly id: Id;
+  readonly message: Message;
+}
+declare namespace Definition {
+  type Any = Definition<string, ServiceFreeSchema>;
+}
+type Handler<ROut, Self extends Definition.Any> = (batch: QueueBatch<S.Schema.Type<Self["message"]>>) => Effect.Effect<void, unknown, ExecutionContext | WorkerContext | WorkerEnvironment | Scope.Scope | ROut>;
+interface Options<ROut, Self extends Definition.Any> extends Omit<WorkerOptions<ROut, never, never, Record<never, never>>, "queue" | "rpc"> {
+  readonly queue: Handler<ROut, Self>;
+  readonly rpc?: never;
+}
+type LayerOptions = {
+  readonly binding: string;
+};
+interface TagClass<Self, Id extends string, Message extends ServiceFreeSchema> extends Context$1.ServiceClass<Self, `effect-cf/Queue/${Id}`, QueueBindingClient<Message>> {
+  readonly id: Id;
+  readonly message: Message;
+  readonly make: <ROut, LayerError>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options<ROut, Definition<Id, Message>>) => WorkerClass<Record<never, never>, ROut>;
+  readonly layer: (options: LayerOptions) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+  readonly send: (message: S.Schema.Type<Message>, options?: QueueSendOptions) => Effect.Effect<void, QueueOperationError | S.SchemaError, Self>;
+  readonly sendBatch: (messages: Iterable<MessageSendRequest<S.Schema.Type<Message>>>, options?: QueueSendBatchOptions) => Effect.Effect<void, QueueOperationError | S.SchemaError, Self>;
+  readonly metrics: () => Effect.Effect<QueueMetrics, QueueOperationError, Self>;
+  readonly rawUnsafe: Effect.Effect<QueueProducer<S.Codec.Encoded<Message>>, never, Self>;
+}
+declare const make: <Id extends string, Message extends ServiceFreeSchema>(id: Id, definition: {
+  readonly message: Message;
+}) => TagClass<Definition<Id, Message>, Id, Message>;
+declare const Tag: <Self>() => <Id extends string, Message extends ServiceFreeSchema>(id: Id, definition: {
+  readonly message: Message;
+}) => TagClass<Self, Id, Message>;
+declare const Queue: typeof Tag;
+declare const implement: <ROut, const Self extends Definition.Any>(_definition: Self, handler: Handler<ROut, Self>) => Handler<ROut, Self>;
+//#endregion
+export { Definition, Handler, LayerOptions, Options, Queue, QueueDefinition_d_exports, Tag, TagClass, implement, make };