effect-cf 0.13.0 → 0.14.0

package/dist/index.mjs

@@ -1,14 +1,236 @@
 import { t as __exportAll } from "./chunk-CfYAbeIz.mjs";
-import { a as WorkerConfig, i as layer$10, n as Binding_exports, o as WorkerEnvironment, r as Service$2, t as Hyperdrive_exports } from "./Hyperdrive-89hg_Fck.mjs";
-import { Cause, Clock, Config, ConfigProvider, Context, Data, DateTime, Duration, Effect, Exit, Layer, ManagedRuntime, Option, Queue, Schema } from "effect";
+import { a as WorkerConfig, i as layer$15, n as Binding_exports, o as WorkerEnvironment, r as Service$2, t as Hyperdrive_exports } from "./Hyperdrive-89hg_Fck.mjs";
+import { Cause, Clock, ConfigProvider, Context, Data, DateTime, Duration, Effect, Exit, Layer, ManagedRuntime, Option, Queue, Schema } from "effect";
 import { FetchHttpClient, HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
-import { Otlp, OtlpLogger, OtlpMetrics, OtlpSerialization, OtlpTracer } from "effect/unstable/observability";
+import { OtlpLogger, OtlpMetrics, OtlpSerialization, OtlpTracer } from "effect/unstable/observability";
 import { D1Client } from "@effect/sql-d1";
 import { DurableObject, RpcStub, RpcTarget, WorkerEntrypoint, WorkflowEntrypoint } from "cloudflare:workers";
 import * as RpcMessage from "effect/unstable/rpc/RpcMessage";
 import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
 import * as RpcServer from "effect/unstable/rpc/RpcServer";
 import { SqliteClient } from "@effect/sql-sqlite-do";
+//#region src/WorkersAi.ts
+var WorkersAi_exports = /* @__PURE__ */ __exportAll({
+	Tag: () => Tag$14,
+	WorkersAiOperationError: () => WorkersAiOperationError,
+	embeddingResponse: () => embeddingResponse,
+	isWorkersAiBinding: () => isWorkersAiBinding,
+	layer: () => layer$14,
+	make: () => make$14,
+	makeClient: () => makeClient$10
+});
+const expectedWorkersAiBinding = "Workers AI binding with run(), gateway(), and models()";
+/** Error raised when a Workers AI operation fails. */
+var WorkersAiOperationError = class extends Data.TaggedError("WorkersAiOperationError") {};
+const workersAiError = (binding, operation, cause) => new WorkersAiOperationError({
+	binding,
+	operation,
+	cause
+});
+const tryWorkersAiPromise = (binding, operation, evaluate) => Effect.tryPromise({
+	try: evaluate,
+	catch: (cause) => workersAiError(binding, operation, cause)
+});
+const tryWorkersAiSync = (binding, operation, evaluate) => Effect.try({
+	try: evaluate,
+	catch: (cause) => workersAiError(binding, operation, cause)
+});
+const hasFunction$3 = (value, key) => typeof Reflect.get(value, key) === "function";
+const isWorkersAiBinding = (value) => typeof value === "object" && value !== null && hasFunction$3(value, "run") && hasFunction$3(value, "gateway") && hasFunction$3(value, "models");
+const embeddingResponse = (value) => ({
+	data: value.data ?? [],
+	shape: value.shape ?? []
+});
+const makeClient$10 = (definition) => (ai) => {
+	const run = ((model, input, options) => tryWorkersAiPromise(definition.binding, "run", () => ai.run(model, input, options)));
+	return {
+		definition,
+		aiGatewayLogId: tryWorkersAiSync(definition.binding, "aiGatewayLogId", () => ai.aiGatewayLogId),
+		run,
+		runEmbedding: (model, input, options) => run(model, input, options).pipe(Effect.map((response) => embeddingResponse(response))),
+		models: (params) => tryWorkersAiPromise(definition.binding, "models", () => ai.models(params)),
+		gateway: (gatewayId) => tryWorkersAiSync(definition.binding, "gateway", () => ai.gateway(gatewayId)),
+		unsafeRaw: Effect.succeed(ai)
+	};
+};
+const layer$14 = (tag, definition) => layer$15(tag, definition.binding, (value) => isWorkersAiBinding(value), makeClient$10(definition), { expected: expectedWorkersAiBinding });
+const make$14 = (id) => Tag$14()(id);
+const Tag$14 = () => (id) => {
+	const tag = Context.Service()(id);
+	const makeLayer = (definition) => layer$14(tag, definition);
+	return Object.assign(tag, {
+		id,
+		layer: makeLayer
+	});
+};
+//#endregion
+//#region src/AiGateway.ts
+var AiGateway_exports = /* @__PURE__ */ __exportAll({
+	AiGatewayOperationError: () => AiGatewayOperationError,
+	Tag: () => Tag$13,
+	isAiGatewayBinding: () => isAiGatewayBinding,
+	layer: () => layer$13,
+	make: () => make$13,
+	makeClient: () => makeClient$9,
+	makeClientFromAi: () => makeClientFromAi,
+	makeHttpClient: () => makeHttpClient
+});
+const expectedAiGatewayBinding = "Workers AI binding with gateway()";
+/** Error raised when an AI Gateway operation fails. */
+var AiGatewayOperationError = class extends Data.TaggedError("AiGatewayOperationError") {};
+const aiGatewayError = (binding, operation, cause) => new AiGatewayOperationError({
+	binding,
+	operation,
+	cause
+});
+const tryAiGatewayPromise = (binding, operation, evaluate) => Effect.tryPromise({
+	try: evaluate,
+	catch: (cause) => aiGatewayError(binding, operation, cause)
+});
+const tryAiGatewaySync = (binding, operation, evaluate) => Effect.try({
+	try: evaluate,
+	catch: (cause) => aiGatewayError(binding, operation, cause)
+});
+const providerUrl = (baseUrl, path = "") => {
+	const url = new URL(baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`);
+	const normalizedPath = path.replace(/^\/+/, "");
+	return normalizedPath === "" ? url : new URL(normalizedPath, url);
+};
+const gatewayUrl = (definition) => `https://gateway.ai.cloudflare.com/v1/${definition.accountId}/${definition.gatewayId}/`;
+const isAiGatewayBinding = (value) => isWorkersAiBinding(value);
+const makeClient$9 = (definition, gateway) => ({
+	definition,
+	run: (data, options) => tryAiGatewayPromise(definition.binding, "run", () => gateway.run(Array.isArray(data) ? [...data] : data, options)),
+	getUrl: (provider) => tryAiGatewayPromise(definition.binding, "getUrl", () => gateway.getUrl(provider)),
+	fetch: (options) => Effect.gen(function* () {
+		const baseUrl = yield* tryAiGatewayPromise(definition.binding, "getUrl", () => gateway.getUrl(options.provider));
+		return yield* tryAiGatewayPromise(definition.binding, "fetch", () => fetch(providerUrl(baseUrl, options.path).href, options.init));
+	}),
+	patchLog: (logId, data) => tryAiGatewayPromise(definition.binding, "patchLog", () => gateway.patchLog(logId, data)),
+	getLog: (logId) => tryAiGatewayPromise(definition.binding, "getLog", () => gateway.getLog(logId)),
+	unsafeRaw: Effect.succeed(gateway)
+});
+const makeClientFromAi = (definition, ai) => {
+	const gateway = tryAiGatewaySync(definition.binding, "gateway", () => ai.gateway(definition.gatewayId));
+	const withGateway = (operation) => gateway.pipe(Effect.flatMap(operation));
+	return {
+		definition,
+		run: (data, options) => withGateway((raw) => makeClient$9(definition, raw).run(data, options)),
+		getUrl: (provider) => withGateway((raw) => makeClient$9(definition, raw).getUrl(provider)),
+		fetch: (options) => withGateway((raw) => makeClient$9(definition, raw).fetch(options)),
+		patchLog: (logId, data) => withGateway((raw) => makeClient$9(definition, raw).patchLog(logId, data)),
+		getLog: (logId) => withGateway((raw) => makeClient$9(definition, raw).getLog(logId)),
+		unsafeRaw: gateway
+	};
+};
+const makeHttpClient = (definition, request = fetch) => {
+	const binding = definition.binding ?? "AI_GATEWAY";
+	const clientDefinition = {
+		binding,
+		gatewayId: definition.gatewayId,
+		accountId: definition.accountId
+	};
+	const getUrl = (provider) => Effect.succeed(provider === void 0 ? gatewayUrl(definition) : providerUrl(gatewayUrl(definition), provider).href.replace(/\/$/, ""));
+	const extraHeaders = (options) => {
+		if (options?.extraHeaders === void 0 || Array.isArray(options.extraHeaders) || options.extraHeaders instanceof Headers) return options?.extraHeaders;
+		return Object.fromEntries(Object.entries(options.extraHeaders).map(([key, value]) => [key, String(value)]));
+	};
+	return {
+		definition: clientDefinition,
+		run: (data, options) => tryAiGatewayPromise(binding, "run", () => request(gatewayUrl(definition), {
+			method: "POST",
+			body: JSON.stringify(data),
+			headers: new Headers({
+				"content-type": "application/json",
+				...Object.fromEntries(new Headers(extraHeaders(options)).entries())
+			}),
+			signal: options?.signal
+		})),
+		getUrl,
+		fetch: (options) => getUrl(options.provider).pipe(Effect.flatMap((baseUrl) => tryAiGatewayPromise(binding, "fetch", () => request(providerUrl(baseUrl, options.path).href, options.init)))),
+		patchLog: (logId, data) => tryAiGatewayPromise(binding, "patchLog", () => request(providerUrl(gatewayUrl(definition), `logs/${logId}`).href, {
+			method: "PATCH",
+			body: JSON.stringify(data),
+			headers: { "content-type": "application/json" }
+		}).then(() => void 0)),
+		getLog: (logId) => tryAiGatewayPromise(binding, "getLog", async () => {
+			return await (await request(providerUrl(gatewayUrl(definition), `logs/${logId}`).href)).json();
+		}),
+		unsafeRaw: Effect.fail(aiGatewayError(binding, "unsafeRaw", /* @__PURE__ */ new TypeError("HTTP AI Gateway clients have no raw binding")))
+	};
+};
+const layer$13 = (tag, definition) => layer$15(tag, definition.binding, isAiGatewayBinding, (ai) => makeClientFromAi(definition, ai), { expected: expectedAiGatewayBinding });
+const make$13 = (id) => Tag$13()(id);
+const Tag$13 = () => (id) => {
+	const tag = Context.Service()(id);
+	const makeLayer = (definition) => layer$13(tag, definition);
+	return Object.assign(tag, {
+		id,
+		layer: makeLayer
+	});
+};
+//#endregion
+//#region src/BrowserRendering.ts
+var BrowserRendering_exports = /* @__PURE__ */ __exportAll({
+	BrowserRenderingOperationError: () => BrowserRenderingOperationError,
+	Tag: () => Tag$12,
+	isBrowserRenderingBinding: () => isBrowserRenderingBinding,
+	layer: () => layer$12,
+	make: () => make$12,
+	makeClient: () => makeClient$8
+});
+const expectedBrowserRenderingBinding = "Browser Rendering binding resource";
+/** Error raised when a Browser Rendering operation fails. */
+var BrowserRenderingOperationError = class extends Data.TaggedError("BrowserRenderingOperationError") {};
+const browserRenderingError = (binding, operation, cause) => new BrowserRenderingOperationError({
+	binding,
+	operation,
+	cause
+});
+const tryBrowserRenderingPromise = (binding, operation, evaluate) => Effect.tryPromise({
+	try: evaluate,
+	catch: (cause) => browserRenderingError(binding, operation, cause)
+});
+const tryBrowserRenderingSync = (binding, operation, evaluate) => Effect.try({
+	try: evaluate,
+	catch: (cause) => browserRenderingError(binding, operation, cause)
+});
+const missingMethod = (binding, operation) => Effect.fail(browserRenderingError(binding, operation, /* @__PURE__ */ new TypeError(`Browser Rendering object does not expose ${operation}()`)));
+const wrapPage = (binding, page) => ({
+	raw: page,
+	goto: (url, options) => page.goto === void 0 ? missingMethod(binding, "goto") : tryBrowserRenderingPromise(binding, "goto", () => page.goto(url, options)),
+	setContent: (html, options) => page.setContent === void 0 ? missingMethod(binding, "setContent") : tryBrowserRenderingPromise(binding, "setContent", () => page.setContent(html, options)),
+	content: page.content === void 0 ? missingMethod(binding, "content") : tryBrowserRenderingPromise(binding, "content", () => page.content()),
+	screenshot: (options) => page.screenshot === void 0 ? missingMethod(binding, "screenshot") : tryBrowserRenderingPromise(binding, "screenshot", () => page.screenshot(options)),
+	pdf: (options) => page.pdf === void 0 ? missingMethod(binding, "pdf") : tryBrowserRenderingPromise(binding, "pdf", () => page.pdf(options)),
+	evaluate: (pageFunction, ...args) => page.evaluate === void 0 ? missingMethod(binding, "evaluate") : tryBrowserRenderingPromise(binding, "evaluate", () => page.evaluate(pageFunction, ...args)),
+	close: (options) => page.close === void 0 ? Effect.void : tryBrowserRenderingPromise(binding, "closePage", () => page.close(options))
+});
+const wrapBrowser = (binding, browser) => ({
+	raw: browser,
+	newPage: tryBrowserRenderingPromise(binding, "newPage", () => browser.newPage()).pipe(Effect.map((page) => wrapPage(binding, page))),
+	version: browser.version === void 0 ? missingMethod(binding, "version") : tryBrowserRenderingPromise(binding, "version", () => browser.version()),
+	close: browser.close === void 0 ? Effect.void : tryBrowserRenderingPromise(binding, "closeBrowser", () => browser.close()),
+	disconnect: browser.disconnect === void 0 ? Effect.void : tryBrowserRenderingSync(binding, "disconnect", () => browser.disconnect())
+});
+const isBrowserRenderingBinding = (value) => (typeof value === "object" || typeof value === "function") && value !== null;
+const makeClient$8 = (definition) => (binding) => ({
+	definition,
+	launchWith: (launch, options) => tryBrowserRenderingPromise(definition.binding, "launch", () => launch(binding, options)).pipe(Effect.map((browser) => wrapBrowser(definition.binding, browser))),
+	connectWith: (connect, options) => tryBrowserRenderingPromise(definition.binding, "connect", () => connect(binding, options)).pipe(Effect.map((browser) => wrapBrowser(definition.binding, browser))),
+	unsafeRaw: Effect.succeed(binding)
+});
+const layer$12 = (tag, definition) => layer$15(tag, definition.binding, isBrowserRenderingBinding, makeClient$8(definition), { expected: expectedBrowserRenderingBinding });
+const make$12 = (id) => Tag$12()(id);
+const Tag$12 = () => (id) => {
+	const tag = Context.Service()(id);
+	const makeLayer = (definition) => layer$12(tag, definition);
+	return Object.assign(tag, {
+		id,
+		layer: makeLayer
+	});
+};
+//#endregion
 //#region src/DurableObjectStorage.ts
 var DurableObjectStorage_exports = /* @__PURE__ */ __exportAll({
 	StorageOperationError: () => StorageOperationError,
@@ -300,251 +522,77 @@ const runPromiseExitPreservingTypedFailures = async (effect) => {
 //#endregion
 //#region src/CloudflareOtlp.ts
 var CloudflareOtlp_exports = /* @__PURE__ */ __exportAll({
-	CloudflareOtlpSettings: () => CloudflareOtlpSettings,
 	durableObjectLayer: () => durableObjectLayer,
-	layer: () => layer$9,
+	layer: () => layer$11,
 	layerJson: () => layerJson,
 	layerProtobuf: () => layerProtobuf,
-	settingsConfig: () => settingsConfig,
-	settingsLayer: () => settingsLayer,
 	workerLayer: () => workerLayer
 });
-/**
-* Supported OpenTelemetry environment configuration for Cloudflare OTLP export.
-*
-* This config intentionally uses the conventional `OTEL_*` variable names so
-* deployments can share the same settings used by other OpenTelemetry SDKs.
-* It covers the OTLP HTTP settings supported by the Effect OTLP layers:
-*
-* - `OTEL_EXPORTER_OTLP_ENDPOINT`
-* - `OTEL_EXPORTER_OTLP_LOGS_ENDPOINT`
-* - `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT`
-* - `OTEL_EXPORTER_OTLP_METRICS_ENDPOINT`
-* - `OTEL_EXPORTER_OTLP_HEADERS`
-* - `OTEL_EXPORTER_OTLP_LOGS_HEADERS`
-* - `OTEL_EXPORTER_OTLP_TRACES_HEADERS`
-* - `OTEL_EXPORTER_OTLP_METRICS_HEADERS`
-* - `OTEL_SERVICE_NAME`
-* - `OTEL_RESOURCE_ATTRIBUTES`
-*
-* `OTEL_SERVICE_VERSION` is also accepted as an effect-cf convenience alias.
-* The standard OpenTelemetry way to configure service version is
-* `OTEL_RESOURCE_ATTRIBUTES=service.version=...`.
-*
-* Consumers with non-standard binding names should map those names into
-* {@link CloudflareOtlpSettings} rather than changing this config globally.
-*/
-const settingsConfig = Config.all({
-	endpoint: Config.string("OTEL_EXPORTER_OTLP_ENDPOINT").pipe(Config.option),
-	logsEndpoint: Config.string("OTEL_EXPORTER_OTLP_LOGS_ENDPOINT").pipe(Config.option),
-	tracesEndpoint: Config.string("OTEL_EXPORTER_OTLP_TRACES_ENDPOINT").pipe(Config.option),
-	metricsEndpoint: Config.string("OTEL_EXPORTER_OTLP_METRICS_ENDPOINT").pipe(Config.option),
-	headers: Config.string("OTEL_EXPORTER_OTLP_HEADERS").pipe(Config.option),
-	logsHeaders: Config.string("OTEL_EXPORTER_OTLP_LOGS_HEADERS").pipe(Config.option),
-	tracesHeaders: Config.string("OTEL_EXPORTER_OTLP_TRACES_HEADERS").pipe(Config.option),
-	metricsHeaders: Config.string("OTEL_EXPORTER_OTLP_METRICS_HEADERS").pipe(Config.option),
-	serviceName: Config.string("OTEL_SERVICE_NAME").pipe(Config.option),
-	serviceVersion: Config.string("OTEL_SERVICE_VERSION").pipe(Config.option),
-	resourceAttributes: Config.schema(Config.Record(Schema.String, Schema.String), "OTEL_RESOURCE_ATTRIBUTES").pipe(Config.option)
-});
-/**
-* Service carrying already-resolved Cloudflare OTLP settings.
-*
-* Provide this service directly when an application needs to map custom
-* Cloudflare binding names, compute settings dynamically, or override settings
-* in tests. When this service is present, the OTLP layers use it instead of
-* reading {@link settingsConfig}.
-*
-* @example
-* ```ts
-* const CustomOtlpSettings = Layer.effect(
-*   CloudflareOtlp.CloudflareOtlpSettings,
-*   Config.all({
-*     ...CloudflareOtlp.settingsConfig,
-*     endpoint: Config.string("MY_OTLP_ENDPOINT").pipe(Config.option),
-*   }),
-* ).pipe(Layer.provide(WorkerConfig.layer));
-* ```
-*/
-var CloudflareOtlpSettings = class extends Context.Service()("effect-cf/CloudflareOtlpSettings") {};
 const allSignals = [
 	"logs",
 	"traces",
 	"metrics"
 ];
-const optionToUndefined = (option) => Option.isSome(option) ? option.value : void 0;
-const nonEmptyStringOption = (option) => Option.flatMap(option, (value) => {
-	const trimmed = value.trim();
-	return trimmed === "" ? Option.none() : Option.some(trimmed);
-});
-const nonEmptyRecordOption = (option) => Option.filter(option, (value) => Object.keys(value).length > 0);
-const normalizeSettings = (settings) => ({
-	endpoint: nonEmptyStringOption(settings.endpoint),
-	logsEndpoint: nonEmptyStringOption(settings.logsEndpoint),
-	tracesEndpoint: nonEmptyStringOption(settings.tracesEndpoint),
-	metricsEndpoint: nonEmptyStringOption(settings.metricsEndpoint),
-	headers: nonEmptyStringOption(settings.headers),
-	logsHeaders: nonEmptyStringOption(settings.logsHeaders),
-	tracesHeaders: nonEmptyStringOption(settings.tracesHeaders),
-	metricsHeaders: nonEmptyStringOption(settings.metricsHeaders),
-	serviceName: nonEmptyStringOption(settings.serviceName),
-	serviceVersion: nonEmptyStringOption(settings.serviceVersion),
-	resourceAttributes: nonEmptyRecordOption(settings.resourceAttributes)
-});
-/**
-* Layer that reads standard OpenTelemetry settings from the current Cloudflare
-* `env` object.
-*
-* The layer depends on {@link WorkerEnvironment} and installs a
-* Cloudflare-backed Effect `ConfigProvider`, so `settingsConfig` reads from
-* Worker vars/secrets instead of Node process environment variables.
-*/
-const settingsLayer = Layer.effect(CloudflareOtlpSettings, settingsConfig.pipe(Config.map(normalizeSettings))).pipe(Layer.provide(WorkerConfig.layer));
+const emptyConfigProvider = ConfigProvider.fromUnknown({});
+const cloudflareConfigProviderLayer = ConfigProvider.layerAdd(Effect.map(Effect.serviceOption(WorkerEnvironment), (env) => Option.isSome(env) ? WorkerConfig.providerFromEnv(env.value) : emptyConfigProvider), { asPrimary: true });
 const selectedSignals = (signals) => new Set(signals ?? allSignals);
 const withDefinedAttributes = (attributes) => {
 	const out = {};
 	for (const [key, value] of Object.entries(attributes)) if (value !== void 0) out[key] = value;
 	return out;
 };
-const parseHeaders = (input) => {
-	if (Option.isNone(input) || input.value.trim() === "") return;
-	const headers = {};
-	for (const part of input.value.split(",")) {
-		const index = part.indexOf("=");
-		if (index <= 0) continue;
-		const key = part.slice(0, index).trim();
-		const value = part.slice(index + 1).trim();
-		if (key !== "") headers[decodeHeaderComponent(key)] = decodeHeaderComponent(value);
-	}
-	return headers;
-};
-const mergeHeaders = (common, signalSpecific) => {
-	const commonHeaders = parseHeaders(common);
-	const signalHeaders = parseHeaders(signalSpecific);
-	if (commonHeaders === void 0 && signalHeaders === void 0) return;
-	return {
-		...commonHeaders,
-		...signalHeaders
-	};
-};
-const decodeHeaderComponent = (value) => {
-	try {
-		return decodeURIComponent(value);
-	} catch {
-		return value;
-	}
-};
-const appendOtlpPath = (baseUrl, path) => `${baseUrl.replace(/\/+$/, "")}${path}`;
-const makeResource = (settings, options, runtimeAttributes) => ({
-	serviceName: options.serviceName ?? optionToUndefined(settings.serviceName),
-	serviceVersion: options.serviceVersion ?? optionToUndefined(settings.serviceVersion),
+const makeResource = (options, runtimeAttributes) => ({
+	serviceName: options.resource?.serviceName,
+	serviceVersion: options.resource?.serviceVersion,
 	attributes: {
-		...optionToUndefined(settings.resourceAttributes),
 		...withDefinedAttributes(runtimeAttributes),
-		...options.attributes
+		...options.resource?.attributes
 	}
 });
-const commonOtlpOptions = (settings, options, runtimeAttributes) => ({
-	resource: makeResource(settings, options, runtimeAttributes),
-	maxBatchSize: options.maxBatchSize,
-	loggerExportInterval: options.loggerExportInterval,
-	loggerExcludeLogSpans: options.loggerExcludeLogSpans,
-	loggerMergeWithExisting: options.loggerMergeWithExisting,
-	tracerExportInterval: options.tracerExportInterval,
-	tracerContext: options.tracerContext,
-	metricsExportInterval: options.metricsExportInterval,
-	metricsTemporality: options.metricsTemporality,
-	shutdownTimeout: options.shutdownTimeout
-});
 const serializationLayer = (serialization) => serialization === "json" ? OtlpSerialization.layerJson : OtlpSerialization.layerProtobuf;
-const resolveSettings = Effect.gen(function* () {
-	const settings = yield* Effect.serviceOption(CloudflareOtlpSettings);
-	if (Option.isSome(settings)) return normalizeSettings(settings.value);
-	const env = yield* Effect.serviceOption(WorkerEnvironment);
-	if (Option.isSome(env)) return normalizeSettings(yield* settingsConfig.pipe(Effect.provide(ConfigProvider.layer(Effect.succeed(WorkerConfig.providerFromEnv(env.value))))));
-	return normalizeSettings(yield* settingsConfig);
-});
 const mergeSignalLayers = (layers) => {
 	if (layers.length === 0) return Layer.empty;
 	let merged = layers[0];
 	for (let index = 1; index < layers.length; index++) merged = Layer.mergeAll(merged, layers[index]);
 	return merged;
 };
-const emptyLayer = Layer.empty;
-const makeLayerFromSettings = (options = {}, runtimeAttributes = {}) => Layer.unwrap(Effect.map(resolveSettings, (settings) => {
+const makeLayer = (options = {}, runtimeAttributes = {}) => {
 	const signals = selectedSignals(options.signals);
-	const endpoint = optionToUndefined(settings.endpoint);
-	const logsEndpoint = optionToUndefined(settings.logsEndpoint);
-	const tracesEndpoint = optionToUndefined(settings.tracesEndpoint);
-	const metricsEndpoint = optionToUndefined(settings.metricsEndpoint);
-	const hasSpecificEndpoint = logsEndpoint !== void 0 || tracesEndpoint !== void 0 || metricsEndpoint !== void 0;
-	const hasSpecificHeaders = Option.isSome(settings.logsHeaders) || Option.isSome(settings.tracesHeaders) || Option.isSome(settings.metricsHeaders);
-	const common = commonOtlpOptions(settings, options, runtimeAttributes);
-	if (endpoint !== void 0 && !hasSpecificEndpoint && !hasSpecificHeaders && signals.size === 3) return Otlp.layer({
-		baseUrl: endpoint,
-		headers: parseHeaders(settings.headers),
-		...common
-	}).pipe(Layer.provide(serializationLayer(options.serialization)), Layer.provide(FetchHttpClient.layer));
+	const resource = makeResource(options, runtimeAttributes);
 	const layers = [];
-	if (signals.has("logs")) {
-		const url = logsEndpoint ?? (endpoint === void 0 ? void 0 : appendOtlpPath(endpoint, "/v1/logs"));
-		if (url !== void 0) layers.push(OtlpLogger.layer({
-			url,
-			resource: common.resource,
-			headers: mergeHeaders(settings.headers, settings.logsHeaders),
-			exportInterval: common.loggerExportInterval,
-			maxBatchSize: common.maxBatchSize,
-			shutdownTimeout: common.shutdownTimeout,
-			excludeLogSpans: common.loggerExcludeLogSpans,
-			mergeWithExisting: common.loggerMergeWithExisting
-		}).pipe(Layer.provide(serializationLayer(options.serialization)), Layer.provide(FetchHttpClient.layer)));
-	}
-	if (signals.has("traces")) {
-		const url = tracesEndpoint ?? (endpoint === void 0 ? void 0 : appendOtlpPath(endpoint, "/v1/traces"));
-		if (url !== void 0) layers.push(OtlpTracer.layer({
-			url,
-			resource: common.resource,
-			headers: mergeHeaders(settings.headers, settings.tracesHeaders),
-			exportInterval: common.tracerExportInterval,
-			maxBatchSize: common.maxBatchSize,
-			context: common.tracerContext,
-			shutdownTimeout: common.shutdownTimeout
-		}).pipe(Layer.provide(serializationLayer(options.serialization)), Layer.provide(FetchHttpClient.layer)));
-	}
-	if (signals.has("metrics")) {
-		const url = metricsEndpoint ?? (endpoint === void 0 ? void 0 : appendOtlpPath(endpoint, "/v1/metrics"));
-		if (url !== void 0) layers.push(OtlpMetrics.layer({
-			url,
-			resource: common.resource,
-			headers: mergeHeaders(settings.headers, settings.metricsHeaders),
-			exportInterval: common.metricsExportInterval,
-			shutdownTimeout: common.shutdownTimeout,
-			temporality: common.metricsTemporality
-		}).pipe(Layer.provide(serializationLayer(options.serialization)), Layer.provide(FetchHttpClient.layer)));
-	}
-	return mergeSignalLayers(layers);
-}).pipe(Effect.catch((error) => Effect.logWarning("CloudflareOtlp disabled because OTLP configuration is invalid", { error: String(error) }).pipe(Effect.as(emptyLayer)))));
-const makeLayer = (options = {}, runtimeAttributes = {}) => makeLayerFromSettings(options, runtimeAttributes);
+	if (signals.has("logs")) layers.push(OtlpLogger.layerFromConfig({
+		resource,
+		headers: options.headers,
+		excludeLogSpans: options.loggerExcludeLogSpans,
+		mergeWithExisting: options.loggerMergeWithExisting
+	}));
+	if (signals.has("traces")) layers.push(OtlpTracer.layerFromConfig({
+		resource,
+		headers: options.headers,
+		context: options.tracerContext
+	}));
+	if (signals.has("metrics")) layers.push(OtlpMetrics.layerFromConfig({
+		resource,
+		headers: options.headers
+	}));
+	return mergeSignalLayers(layers).pipe(Layer.provide(cloudflareConfigProviderLayer), Layer.provide(serializationLayer(options.serialization)), Layer.provide(FetchHttpClient.layer));
+};
 /**
 * Base OTLP telemetry layer for Cloudflare-compatible runtimes.
 *
-* The layer reads {@link CloudflareOtlpSettings} when provided. Otherwise it
-* reads standard OpenTelemetry config from `WorkerEnvironment` when available,
-* then falls back to the ambient Effect `ConfigProvider`.
-*
-* When only `OTEL_EXPORTER_OTLP_ENDPOINT` is configured, per-signal paths are
-* derived by appending `/v1/logs`, `/v1/traces`, and `/v1/metrics`. Signal
-* specific endpoints are used as-is, matching the OpenTelemetry OTLP exporter
-* convention.
+* Standard OpenTelemetry environment variables are resolved by Effect's OTLP
+* layers. In Cloudflare Workers and Durable Objects, the current `env` object is
+* installed as the primary `ConfigProvider`; outside Cloudflare, the ambient
+* Effect `ConfigProvider` remains the fallback.
 */
-const layer$9 = (options = {}) => makeLayer(options);
+const layer$11 = (options = {}) => makeLayer(options);
 /** Base OTLP telemetry layer forced to JSON serialization. */
-const layerJson = (options = {}) => layer$9({
+const layerJson = (options = {}) => layer$11({
 	...options,
 	serialization: "json"
 });
 /** Base OTLP telemetry layer forced to protobuf serialization. */
-const layerProtobuf = (options = {}) => layer$9({
+const layerProtobuf = (options = {}) => layer$11({
 	...options,
 	serialization: "protobuf"
 });
@@ -574,7 +622,7 @@ const durableObjectLayer = (options = {}) => Layer.unwrap(Effect.map(DurableObje
 //#region src/D1.ts
 var D1_exports = /* @__PURE__ */ __exportAll({
 	Service: () => Service$1,
-	make: () => make$10
+	make: () => make$11
 });
 const TypeId$2 = "effect-cf/D1";
 const expectedD1Database = "D1 database binding with prepare(), batch(), and exec()";
@@ -586,7 +634,7 @@ const isD1Database = (value) => {
 /**
 * Creates a typed D1 service tag plus Effect helpers.
 */
-const make$10 = (id, definition) => Service$1()(id, definition);
+const make$11 = (id, definition) => Service$1()(id, definition);
 /**
 * Builds a D1 service around a Cloudflare D1 database binding.
 *
@@ -622,8 +670,8 @@ const Service$1 = () => (id, definition) => {
 var QueueBinding_exports = /* @__PURE__ */ __exportAll({
 	QueueOperationError: () => QueueOperationError,
 	isQueue: () => isQueue,
-	layer: () => layer$8,
-	makeClient: () => makeClient$6
+	layer: () => layer$10,
+	makeClient: () => makeClient$7
 });
 const expectedQueueProducer = "Queue producer binding with send(); optional sendBatch()/metrics()";
 var QueueOperationError = class extends Data.TaggedError("QueueOperationError") {};
@@ -640,7 +688,7 @@ const isQueue = (value) => {
 	if (typeof value !== "object" || value === null) return false;
 	return typeof value.send === "function";
 };
-const makeClient$6 = (definition) => {
+const makeClient$7 = (definition) => {
 	const encodeMessage = Schema.encodeEffect(definition.message);
 	return (queue) => ({
 		send: Effect.fnUntraced(function* (message, options) {
@@ -678,30 +726,30 @@ const makeClient$6 = (definition) => {
 		unsafeRaw: Effect.succeed(queue)
 	});
 };
-const layer$8 = (tag, definition) => layer$10(tag, definition.binding, (value) => isQueue(value), makeClient$6(definition), { expected: expectedQueueProducer });
+const layer$10 = (tag, definition) => layer$15(tag, definition.binding, (value) => isQueue(value), makeClient$7(definition), { expected: expectedQueueProducer });
 //#endregion
 //#region src/QueueDefinition.ts
 var QueueDefinition_exports = /* @__PURE__ */ __exportAll({
 	Queue: () => Queue$1,
-	Tag: () => Tag$10,
+	Tag: () => Tag$11,
 	implement: () => implement$7,
-	make: () => make$9
+	make: () => make$10
 });
 const makeDefinition$4 = (id, definition) => {
 	const queueDefinition = {
 		id,
 		message: definition.message
 	};
-	return Object.assign(queueDefinition, { make: (layer, options) => make$6(layer, {
+	return Object.assign(queueDefinition, { make: (layer, options) => make$7(layer, {
 		...options,
 		queue: wrapHandler$1(queueDefinition, options.queue)
 	}) });
 };
-const make$9 = (id, definition) => Tag$10()(id, definition);
-const Tag$10 = () => (id, definition) => {
+const make$10 = (id, definition) => Tag$11()(id, definition);
+const Tag$11 = () => (id, definition) => {
 	const queueDefinition = makeDefinition$4(id, definition);
 	const tag = Context.Service()(id);
-	const layer = (binding) => layer$8(tag, {
+	const layer = (binding) => layer$10(tag, {
 		...binding,
 		message: definition.message
 	});
@@ -728,7 +776,7 @@ const Tag$10 = () => (id, definition) => {
 		unsafeRaw
 	});
 };
-const Queue$1 = Tag$10;
+const Queue$1 = Tag$11;
 const wrapHandler$1 = (definition, handler) => {
 	const decodeBody = Schema.decodeUnknownEffect(definition.message);
 	return (batch) => Effect.gen(function* () {
@@ -740,7 +788,7 @@ const implement$7 = (_definition, handler) => handler;
 //#region src/Queue.ts
 var Queue_exports = /* @__PURE__ */ __exportAll({
 	QueueMessageDecodeError: () => QueueMessageDecodeError,
-	Tag: () => Tag$9,
+	Tag: () => Tag$10,
 	decodeBatch: () => decodeBatch,
 	fromMessage: () => fromMessage,
 	fromMessageBatch: () => fromMessageBatch,
@@ -778,7 +826,7 @@ const decodeBatch = (batch, decodeBody) => Effect.gen(function* () {
 	}
 	return fromMessageBatch(batch, messages);
 });
-const Tag$9 = Tag$10;
+const Tag$10 = Tag$11;
 const implement$6 = implement$7;
 //#endregion
 //#region src/RpcDefinition.ts
@@ -796,7 +844,7 @@ var RpcDefinition_exports = /* @__PURE__ */ __exportAll({
 	decodeSuccess: () => decodeSuccess,
 	encodeArgs: () => encodeArgs,
 	encodeSuccess: () => encodeSuccess,
-	make: () => make$8,
+	make: () => make$9,
 	method: () => method$4,
 	reservedMethodNames: () => reservedMethodNames$4
 });
@@ -899,7 +947,7 @@ const decodeSuccess = (definition, methodName, value) => {
 		cause
 	})));
 };
-const make$8 = (id, methods) => {
+const make$9 = (id, methods) => {
 	const definition = {
 		id,
 		methods
@@ -957,8 +1005,8 @@ var ServiceBinding_exports = /* @__PURE__ */ __exportAll({
 	ServiceBindingFetchError: () => ServiceBindingFetchError,
 	ServiceBindingRpcError: () => ServiceBindingRpcError,
 	isServiceBindingClient: () => isServiceBindingClient,
-	layer: () => layer$7,
-	makeClient: () => makeClient$5,
+	layer: () => layer$9,
+	makeClient: () => makeClient$6,
 	makeDirectMethods: () => makeDirectMethods$1
 });
 const TypeId$1 = "effect-cf/ServiceBinding";
@@ -972,7 +1020,7 @@ var ServiceBindingFetchError = class extends Data.TaggedError("ServiceBindingFet
 */
 var ServiceBindingRpcError = class extends Data.TaggedError("ServiceBindingRpcError") {};
 const isServiceBindingClient = (value) => typeof value === "object" && value !== null && typeof Reflect.get(value, "fetch") === "function";
-const makeClient$5 = (definition) => {
+const makeClient$6 = (definition) => {
 	return (service) => {
 		const fetch = (input, init) => Effect.tryPromise({
 			try: () => service.fetch(input, init),
@@ -1021,7 +1069,7 @@ const makeClient$5 = (definition) => {
 		});
 	};
 };
-const layer$7 = (tag, definition) => layer$10(tag, definition.binding, (value) => isServiceBindingClient(value), makeClient$5(definition), { expected: expectedServiceBinding });
+const layer$9 = (tag, definition) => layer$15(tag, definition.binding, (value) => isServiceBindingClient(value), makeClient$6(definition), { expected: expectedServiceBinding });
 /**
 * Creates a typed Effect service for a Worker service binding.
 *
@@ -1052,7 +1100,7 @@ const layer$7 = (tag, definition) => layer$10(tag, definition.binding, (value) =
 * ```
 */
 const Service = () => (id, definition) => {
-	const tag = Service$2()(id, definition.binding, (value) => isServiceBindingClient(value), makeClient$5(definition));
+	const tag = Service$2()(id, definition.binding, (value) => isServiceBindingClient(value), makeClient$6(definition));
 	const fetch = (input, init) => Effect.gen(function* () {
 		return yield* (yield* tag).fetch(input, init);
 	});
@@ -1083,10 +1131,10 @@ const makeDirectMethods$1 = (rpcDefinition, call) => {
 //#endregion
 //#region src/WorkerDefinition.ts
 var WorkerDefinition_exports = /* @__PURE__ */ __exportAll({
-	Tag: () => Tag$8,
+	Tag: () => Tag$9,
 	Worker: () => Worker,
 	implement: () => implement$5,
-	make: () => make$7,
+	make: () => make$8,
 	method: () => method$3
 });
 const reservedMethodNames$3 = new Set([
@@ -1124,21 +1172,21 @@ const method$3 = method$4;
 */
 const makeDefinition$3 = (id, methods) => {
 	assertNoReservedMethods("Worker", methods, reservedMethodNames$3);
-	const definition = make$8(id, methods);
-	return Object.assign(definition, { make: (layer, options) => make$6(layer, {
+	const definition = make$9(id, methods);
+	return Object.assign(definition, { make: (layer, options) => make$7(layer, {
 		...options,
 		rpc: wrapHandlers$1(definition, options.rpc)
 	}) });
 };
-const make$7 = (id, methods) => Tag$8()(id, methods);
-const Tag$8 = () => (id, methods) => {
+const make$8 = (id, methods) => Tag$9()(id, methods);
+const Tag$9 = () => (id, methods) => {
 	const definition = makeDefinition$3(id, methods);
 	const tag = Context.Service()(id);
 	const bindingDefinition = (binding) => ({
 		...binding,
 		definition
 	});
-	const layer = (binding) => layer$7(tag, bindingDefinition(binding));
+	const layer = (binding) => layer$9(tag, bindingDefinition(binding));
 	const fetch = (input, init) => Effect.gen(function* () {
 		return yield* (yield* tag).fetch(input, init);
 	});
@@ -1163,7 +1211,7 @@ const Tag$8 = () => (id, methods) => {
 		scopedCall
 	});
 };
-const Worker = Tag$8;
+const Worker = Tag$9;
 const wrapHandlers$1 = (definition, handlers) => {
 	const wrapped = {};
 	for (const key of Object.keys(definition.methods)) {
@@ -1179,6 +1227,26 @@ const wrapHandlers$1 = (definition, handlers) => {
 */
 const implement$5 = (_definition, handlers) => handlers;
 //#endregion
+//#region src/internal/Clock.ts
+const maxTimerMillis = 2 ** 31 - 1;
+const nanosPerMilli = BigInt(1e6);
+const clock = {
+	currentTimeMillisUnsafe: () => Date.now(),
+	currentTimeMillis: Effect.sync(() => clock.currentTimeMillisUnsafe()),
+	currentTimeNanosUnsafe: () => BigInt(Date.now()) * nanosPerMilli,
+	currentTimeNanos: Effect.sync(() => clock.currentTimeNanosUnsafe()),
+	sleep: (duration) => {
+		const millis = Duration.toMillis(duration);
+		if (millis <= 0) return Effect.yieldNow;
+		return Effect.callback((resume) => {
+			if (millis > maxTimerMillis) return;
+			const handle = setTimeout(() => resume(Effect.void), millis);
+			return Effect.sync(() => clearTimeout(handle));
+		});
+	}
+};
+const layer$8 = Layer.effect(Clock.Clock, Effect.succeed(clock));
+//#endregion
 //#region src/internal/Entrypoint.ts
 const provideEntrypointServices = (layer, services) => layer.pipe(Layer.provideMerge(services));
 const defineEntrypointRpcMethods = (target, prototype, rpc, reservedMethodNames, run) => {
@@ -1219,11 +1287,11 @@ const fromExecutionContext = (ctx, runPromiseExit) => {
 var Worker_exports = /* @__PURE__ */ __exportAll({
 	ExecutionContext: () => ExecutionContext,
 	NativeRequest: () => NativeRequest,
-	Tag: () => Tag$7,
+	Tag: () => Tag$8,
 	WorkerContext: () => WorkerContext,
 	implement: () => implement$4,
 	isWebSocketUpgrade: () => isWebSocketUpgrade,
-	make: () => make$6,
+	make: () => make$7,
 	makeFetchHandler: () => makeFetchHandler,
 	method: () => method$2,
 	renderHttpResponse: () => renderHttpResponse
@@ -1252,14 +1320,14 @@ const RunSymbol$1 = Symbol.for("effect-cf/Worker/run");
 const renderHttpResponse = (effect) => Effect.flatMap(effect, (response) => Effect.map(Effect.context(), (context) => HttpServerResponse.toWeb(response, { context })));
 const renderFetchSuccess = (effect) => Effect.flatMap(effect, (response) => response instanceof Response ? Effect.succeed(response) : Effect.map(Effect.context(), (context) => HttpServerResponse.toWeb(response, { context })));
 const isWorkerOptions = (options) => typeof options === "object" && options !== null && ("eventLayer" in options || "fetch" in options || "queue" in options || "rpc" in options);
-function make$6(layer, optionsOrFetch) {
+function make$7(layer, optionsOrFetch) {
 	const options = isWorkerOptions(optionsOrFetch) ? optionsOrFetch : { fetch: optionsOrFetch };
 	class EffectWorker extends WorkerEntrypoint {
 		runtime;
 		constructor(ctx, env) {
 			super(ctx, env);
 			let runWaitUntilEffect = () => Promise.reject(/* @__PURE__ */ new Error("WorkerContext runtime is not initialized"));
-			const runtimeLayer = provideEntrypointServices(layer, Layer.mergeAll(Layer.succeed(ExecutionContext, ctx), ConfigProvider.layer(Effect.succeed(WorkerConfig.providerFromEnv(env))), Layer.succeed(WorkerContext, fromExecutionContext(ctx, (effect) => runWaitUntilEffect(effect))), Layer.succeed(WorkerEnvironment, env)));
+			const runtimeLayer = provideEntrypointServices(layer, Layer.mergeAll(layer$8, Layer.succeed(ExecutionContext, ctx), ConfigProvider.layer(Effect.succeed(WorkerConfig.providerFromEnv(env))), Layer.succeed(WorkerContext, fromExecutionContext(ctx, (effect) => runWaitUntilEffect(effect))), Layer.succeed(WorkerEnvironment, env)));
 			this.runtime = ManagedRuntime.make(runtimeLayer);
 			runWaitUntilEffect = (effect) => this.runtime.runPromiseExit(effect);
 		}
@@ -1284,10 +1352,10 @@ function make$6(layer, optionsOrFetch) {
 	return assumeEntrypointClass(EffectWorker);
 }
 const makeFetchHandler = (layer, options) => {
-	const WorkerClass = make$6(layer, options);
+	const WorkerClass = make$7(layer, options);
 	return { fetch: (request, env, ctx) => Promise.resolve(new WorkerClass(ctx, env).fetch(request)) };
 };
-const Tag$7 = Tag$8;
+const Tag$8 = Tag$9;
 const method$2 = method$3;
 const implement$4 = implement$5;
 //#endregion
@@ -1296,8 +1364,8 @@ var DurableObjectNamespace_exports = /* @__PURE__ */ __exportAll({
 	DurableObjectFetchError: () => DurableObjectFetchError,
 	DurableObjectRpcError: () => DurableObjectRpcError,
 	isDurableObjectNamespaceClient: () => isDurableObjectNamespaceClient,
-	layer: () => layer$6,
-	makeClient: () => makeClient$4,
+	layer: () => layer$7,
+	makeClient: () => makeClient$5,
 	makeDirectMethods: () => makeDirectMethods
 });
 const expectedDurableObjectNamespace = "Durable Object namespace binding with getByName(), get(), idFromName(), idFromString(), newUniqueId(), and jurisdiction()";
@@ -1309,9 +1377,9 @@ var DurableObjectRpcError = class extends Data.TaggedError("DurableObjectRpcErro
 * Failure raised when forwarding a request to a Durable Object stub.
 */
 var DurableObjectFetchError = class extends Data.TaggedError("DurableObjectFetchError") {};
-const hasFunction$1 = (value, key) => typeof Reflect.get(value, key) === "function";
-const isDurableObjectNamespaceClient = (value) => typeof value === "object" && value !== null && hasFunction$1(value, "getByName") && hasFunction$1(value, "get") && hasFunction$1(value, "idFromName") && hasFunction$1(value, "idFromString") && hasFunction$1(value, "newUniqueId") && hasFunction$1(value, "jurisdiction");
-const makeClient$4 = (definition) => {
+const hasFunction$2 = (value, key) => typeof Reflect.get(value, key) === "function";
+const isDurableObjectNamespaceClient = (value) => typeof value === "object" && value !== null && hasFunction$2(value, "getByName") && hasFunction$2(value, "get") && hasFunction$2(value, "idFromName") && hasFunction$2(value, "idFromString") && hasFunction$2(value, "newUniqueId") && hasFunction$2(value, "jurisdiction");
+const makeClient$5 = (definition) => {
 	return (namespace) => {
 		const newUniqueId = (options) => Effect.sync(() => namespace.newUniqueId(options));
 		const idFromName = (name) => Effect.sync(() => namespace.idFromName(name));
@@ -1378,7 +1446,7 @@ const makeClient$4 = (definition) => {
 		});
 	};
 };
-const layer$6 = (tag, definition) => layer$10(tag, definition.binding, (value) => isDurableObjectNamespaceClient(value), makeClient$4(definition), { expected: expectedDurableObjectNamespace });
+const layer$7 = (tag, definition) => layer$15(tag, definition.binding, (value) => isDurableObjectNamespaceClient(value), makeClient$5(definition), { expected: expectedDurableObjectNamespace });
 const makeDirectMethods = (rpcDefinition, helpers) => {
 	const methods = {};
 	if (rpcDefinition !== void 0) {
@@ -1403,9 +1471,9 @@ const makeDirectMethods = (rpcDefinition, helpers) => {
 //#region src/DurableObjectDefinition.ts
 var DurableObjectDefinition_exports = /* @__PURE__ */ __exportAll({
 	DurableObject: () => DurableObject$1,
-	Tag: () => Tag$6,
+	Tag: () => Tag$7,
 	implement: () => implement$3,
-	make: () => make$5,
+	make: () => make$6,
 	method: () => method$1
 });
 const reservedMethodNames$1 = new Set([
@@ -1436,21 +1504,21 @@ const method$1 = method$4;
 */
 const makeDefinition$2 = (id, methods) => {
 	assertNoReservedMethods("Durable Object", methods, reservedMethodNames$1);
-	const definition = make$8(id, methods);
-	return Object.assign(definition, { make: (layer, options) => make$4(layer, {
+	const definition = make$9(id, methods);
+	return Object.assign(definition, { make: (layer, options) => make$5(layer, {
 		...options,
 		rpc: wrapHandlers(definition, options.rpc)
 	}) });
 };
-const make$5 = (id, methods) => Tag$6()(id, methods);
-const Tag$6 = () => (id, methods) => {
+const make$6 = (id, methods) => Tag$7()(id, methods);
+const Tag$7 = () => (id, methods) => {
 	const definition = makeDefinition$2(id, methods);
 	const tag = Context.Service()(id);
 	const bindingDefinition = (binding) => ({
 		...binding,
 		definition
 	});
-	const layer = (binding) => layer$6(tag, bindingDefinition(binding));
+	const layer = (binding) => layer$7(tag, bindingDefinition(binding));
 	const newUniqueId = Effect.fnUntraced(function* (options) {
 		return yield* (yield* tag).newUniqueId(options);
 	});
@@ -1508,7 +1576,7 @@ const Tag$6 = () => (id, methods) => {
 		unsafeRaw
 	});
 };
-const DurableObject$1 = Tag$6;
+const DurableObject$1 = Tag$7;
 const wrapHandlers = (definition, handlers) => {
 	const wrapped = {};
 	for (const key of Object.keys(definition.methods)) {
@@ -1526,9 +1594,9 @@ const implement$3 = (_definition, handlers) => handlers;
 //#endregion
 //#region src/DurableObject.ts
 var DurableObject_exports = /* @__PURE__ */ __exportAll({
-	Tag: () => Tag$5,
+	Tag: () => Tag$6,
 	implement: () => implement$2,
-	make: () => make$4,
+	make: () => make$5,
 	method: () => method
 });
 const reservedMethodNames = new Set([
@@ -1544,12 +1612,12 @@ const RunSymbol = Symbol.for("effect-cf/DurableObject/run");
 /**
 * Creates a Durable Object class backed by a single managed Effect runtime.
 */
-const make$4 = (layer, options = {}) => {
+const make$5 = (layer, options = {}) => {
 	class EffectDurableObject extends DurableObject {
 		runtime;
 		constructor(state, env) {
 			super(state, env);
-			const runtimeLayer = provideEntrypointServices(layer, Layer.mergeAll(Layer.succeed(DurableObjectState, fromDurableObjectState(state)), Layer.succeed(WorkerEnvironment, env)));
+			const runtimeLayer = provideEntrypointServices(layer, Layer.mergeAll(layer$8, ConfigProvider.layer(Effect.succeed(WorkerConfig.providerFromEnv(env))), Layer.succeed(DurableObjectState, fromDurableObjectState(state)), Layer.succeed(WorkerEnvironment, env)));
 			this.runtime = ManagedRuntime.make(runtimeLayer);
 			const initialize = options.initialize;
 			if (initialize !== void 0) state.waitUntil(this[RunSymbol](initialize, { eventLayer: false }));
@@ -1586,7 +1654,7 @@ const make$4 = (layer, options = {}) => {
 	defineEntrypointRpcMethods("Durable Object", EffectDurableObject.prototype, options.rpc, reservedMethodNames, (self, effect) => self[RunSymbol](effect));
 	return assumeEntrypointClass(EffectDurableObject);
 };
-const Tag$5 = Tag$6;
+const Tag$6 = Tag$7;
 const method = method$1;
 const implement$2 = implement$3;
 //#endregion
@@ -1915,7 +1983,7 @@ var DurableObjectAlarm = class DurableObjectAlarm extends Context.Service()("eff
 //#region src/DurableObjectRpcWebSocket.ts
 var DurableObjectRpcWebSocket_exports = /* @__PURE__ */ __exportAll({
 	DurableObjectRpcWebSocket: () => DurableObjectRpcWebSocket,
-	layer: () => layer$5
+	layer: () => layer$6
 });
 const defaultAttachmentKey = "effectCloudflareRpcClientId";
 const defaultTag = "effect-cf-rpc";
@@ -1926,7 +1994,7 @@ var DurableObjectRpcWebSocket = class extends Context.Service()("effect-cf/Durab
 /**
 * Builds a layer that bridges Durable Object websocket events to `RpcServer.Protocol`.
 */
-const layer$5 = (options = {}) => Layer.effectContext(Effect.gen(function* () {
+const layer$6 = (options = {}) => Layer.effectContext(Effect.gen(function* () {
 	const tag = options.tag ?? defaultTag;
 	const attachmentKey = options.attachmentKey ?? defaultAttachmentKey;
 	const durableObjectState = yield* DurableObjectState;
@@ -2039,7 +2107,7 @@ const writeAttachment = (socket, key, clientId) => {
 };
 //#endregion
 //#region src/DurableObjectSqlite.ts
-var DurableObjectSqlite_exports = /* @__PURE__ */ __exportAll({ layer: () => layer$4 });
+var DurableObjectSqlite_exports = /* @__PURE__ */ __exportAll({ layer: () => layer$5 });
 /**
 * Provides `effect/unstable/sql` from the current Durable Object SQLite storage.
 *
@@ -2051,7 +2119,7 @@ var DurableObjectSqlite_exports = /* @__PURE__ */ __exportAll({ layer: () => lay
 * );
 * ```
 */
-const layer$4 = (options) => Layer.unwrap(Effect.gen(function* () {
+const layer$5 = (options) => Layer.unwrap(Effect.gen(function* () {
 	const state = yield* DurableObjectState;
 	return SqliteClient.layer({
 		...options,
@@ -2062,13 +2130,13 @@ const layer$4 = (options) => Layer.unwrap(Effect.gen(function* () {
 //#region src/Images.ts
 var Images_exports = /* @__PURE__ */ __exportAll({
 	ImagesOperationError: () => ImagesOperationError,
-	Tag: () => Tag$4,
+	Tag: () => Tag$5,
 	draw: () => draw,
 	empty: () => empty,
 	isImagesBinding: () => isImagesBinding,
-	layer: () => layer$3,
-	make: () => make$3,
-	makeClient: () => makeClient$3,
+	layer: () => layer$4,
+	make: () => make$4,
+	makeClient: () => makeClient$4,
 	transform: () => transform
 });
 const TypeId = "effect-cf/Images/Steps";
@@ -2109,9 +2177,9 @@ const tryImagesSync = (binding, operation, evaluate) => Effect.try({
 	catch: (cause) => imagesError(binding, operation, cause)
 });
 const maybe$1 = (value) => value === null ? Option.none() : Option.some(value);
-const hasFunction = (value, key) => typeof Reflect.get(value, key) === "function";
-const isHostedImagesBinding = (value) => typeof value === "object" && value !== null && hasFunction(value, "image") && hasFunction(value, "upload") && hasFunction(value, "list");
-const isImagesBinding = (value) => typeof value === "object" && value !== null && hasFunction(value, "info") && hasFunction(value, "input");
+const hasFunction$1 = (value, key) => typeof Reflect.get(value, key) === "function";
+const isHostedImagesBinding = (value) => typeof value === "object" && value !== null && hasFunction$1(value, "image") && hasFunction$1(value, "upload") && hasFunction$1(value, "list");
+const isImagesBinding = (value) => typeof value === "object" && value !== null && hasFunction$1(value, "info") && hasFunction$1(value, "input");
 const wrapResult = (binding, result) => ({
 	raw: result,
 	response: tryImagesSync(binding, "response", () => result.response()),
@@ -2131,7 +2199,7 @@ const wrapHosted = (binding, hosted) => ({
 	list: (options) => tryImagesPromise(binding, "list", () => hosted.list(options)),
 	unsafeRaw: Effect.succeed(hosted)
 });
-const makeClient$3 = (definition) => (images) => {
+const makeClient$4 = (definition) => (images) => {
 	const input = (image, options) => tryImagesSync(definition.binding, "input", () => images.input(image, options));
 	const process = (steps, options) => Effect.gen(function* () {
 		let transformer = yield* input(options.stream, options.inputOptions);
@@ -2155,11 +2223,11 @@ const makeClient$3 = (definition) => (images) => {
 		unsafeRaw: Effect.succeed(images)
 	};
 };
-const layer$3 = (tag, definition) => layer$10(tag, definition.binding, isImagesBinding, makeClient$3(definition), { expected: expectedImagesBinding });
-const make$3 = (id) => Tag$4()(id);
-const Tag$4 = () => (id) => {
+const layer$4 = (tag, definition) => layer$15(tag, definition.binding, isImagesBinding, makeClient$4(definition), { expected: expectedImagesBinding });
+const make$4 = (id) => Tag$5()(id);
+const Tag$5 = () => (id) => {
 	const tag = Context.Service()(id);
-	const makeLayer = (definition) => layer$3(tag, definition);
+	const makeLayer = (definition) => layer$4(tag, definition);
 	return Object.assign(tag, {
 		id,
 		layer: makeLayer
@@ -2169,10 +2237,10 @@ const Tag$4 = () => (id) => {
 //#region src/Kv.ts
 var Kv_exports = /* @__PURE__ */ __exportAll({
 	KvOperationError: () => KvOperationError,
-	Tag: () => Tag$3,
+	Tag: () => Tag$4,
 	isKvNamespace: () => isKvNamespace,
-	layer: () => layer$2,
-	makeClient: () => makeClient$2
+	layer: () => layer$3,
+	makeClient: () => makeClient$3
 });
 const expectedKvNamespace = "KV namespace binding with get(), put(), delete(), getWithMetadata(), and list()";
 /** Error raised when a KV operation fails. */
@@ -2193,7 +2261,7 @@ const isKvNamespace = (value) => {
 	const resource = value;
 	return typeof resource.get === "function" && typeof resource.put === "function" && typeof resource.delete === "function" && typeof resource.getWithMetadata === "function" && typeof resource.list === "function";
 };
-const makeClient$2 = (definition) => {
+const makeClient$3 = (definition) => {
 	const encodeKey = Schema.encodeEffect(definition.key);
 	const decodeKey = Schema.decodeUnknownEffect(definition.key);
 	const encodeValue = Schema.encodeEffect(Schema.fromJsonString(Schema.toCodecJson(definition.value)));
@@ -2250,20 +2318,20 @@ const makeClient$2 = (definition) => {
 		unsafeRaw: Effect.succeed(kv)
 	});
 };
-const layer$2 = (tag, definition) => layer$10(tag, definition.binding, isKvNamespace, makeClient$2(definition), { expected: expectedKvNamespace });
+const layer$3 = (tag, definition) => layer$15(tag, definition.binding, isKvNamespace, makeClient$3(definition), { expected: expectedKvNamespace });
 const makeDefinition$1 = (id, definition) => {
 	const kvDefinition = {
 		id,
 		key: definition.key,
 		value: definition.value
 	};
-	return Object.assign(kvDefinition, { layer: (tag, binding) => layer$2(tag, {
+	return Object.assign(kvDefinition, { layer: (tag, binding) => layer$3(tag, {
 		...binding,
 		key: definition.key,
 		value: definition.value
 	}) });
 };
-const Tag$3 = () => (id, definition) => {
+const Tag$4 = () => (id, definition) => {
 	const kvDefinition = makeDefinition$1(id, definition);
 	const tag = Context.Service()(id);
 	const makeLayer = (binding) => kvDefinition.layer(tag, binding);
@@ -2278,11 +2346,11 @@ const Tag$3 = () => (id, definition) => {
 //#region src/R2.ts
 var R2_exports = /* @__PURE__ */ __exportAll({
 	R2OperationError: () => R2OperationError,
-	Tag: () => Tag$2,
+	Tag: () => Tag$3,
 	isR2Bucket: () => isR2Bucket,
-	layer: () => layer$1,
-	make: () => make$2,
-	makeClient: () => makeClient$1
+	layer: () => layer$2,
+	make: () => make$3,
+	makeClient: () => makeClient$2
 });
 const expectedR2Bucket = "R2 bucket binding with head(), get(), put(), createMultipartUpload(), resumeMultipartUpload(), delete(), and list()";
 /** Error raised when an R2 operation fails. */
@@ -2336,7 +2404,7 @@ const isR2Bucket = (value) => {
 	const resource = value;
 	return typeof resource.head === "function" && typeof resource.get === "function" && typeof resource.put === "function" && typeof resource.createMultipartUpload === "function" && typeof resource.resumeMultipartUpload === "function" && typeof resource.delete === "function" && typeof resource.list === "function";
 };
-const makeClient$1 = (definition) => {
+const makeClient$2 = (definition) => {
 	const wrapUpload = (upload) => ({
 		raw: upload,
 		key: upload.key,
@@ -2367,11 +2435,11 @@ const makeClient$1 = (definition) => {
 		};
 	};
 };
-const layer$1 = (tag, definition) => layer$10(tag, definition.binding, isR2Bucket, makeClient$1(definition), { expected: expectedR2Bucket });
-const make$2 = (id) => Tag$2()(id);
-const Tag$2 = () => (id) => {
+const layer$2 = (tag, definition) => layer$15(tag, definition.binding, isR2Bucket, makeClient$2(definition), { expected: expectedR2Bucket });
+const make$3 = (id) => Tag$3()(id);
+const Tag$3 = () => (id) => {
 	const tag = Context.Service()(id);
-	const makeLayer = (definition) => layer$1(tag, definition);
+	const makeLayer = (definition) => layer$2(tag, definition);
 	return Object.assign(tag, {
 		id,
 		layer: makeLayer
@@ -2383,8 +2451,8 @@ var WorkflowBinding_exports = /* @__PURE__ */ __exportAll({
 	WorkflowOperationError: () => WorkflowOperationError,
 	WorkflowResultDecodeError: () => WorkflowResultDecodeError,
 	isWorkflow: () => isWorkflow,
-	layer: () => layer,
-	makeClient: () => makeClient
+	layer: () => layer$1,
+	makeClient: () => makeClient$1
 });
 const expectedWorkflow = "Workflow binding with create(), createBatch(), and get()";
 var WorkflowOperationError = class extends Data.TaggedError("WorkflowOperationError") {};
@@ -2403,7 +2471,7 @@ const isWorkflow = (value) => {
 	const resource = value;
 	return typeof resource.create === "function" && typeof resource.createBatch === "function" && typeof resource.get === "function";
 };
-const makeClient = (definition) => {
+const makeClient$1 = (definition) => {
 	const encodePayload = Schema.encodeEffect(definition.payload);
 	const decodeResult = Schema.decodeUnknownEffect(definition.result);
 	const wrapInstance = (raw) => {
@@ -2453,14 +2521,14 @@ const makeClient = (definition) => {
 		unsafeRaw: Effect.succeed(workflow)
 	});
 };
-const layer = (tag, definition) => layer$10(tag, definition.binding, (value) => isWorkflow(value), makeClient(definition), { expected: expectedWorkflow });
+const layer$1 = (tag, definition) => layer$15(tag, definition.binding, (value) => isWorkflow(value), makeClient$1(definition), { expected: expectedWorkflow });
 //#endregion
 //#region src/WorkflowDefinition.ts
 var WorkflowDefinition_exports = /* @__PURE__ */ __exportAll({
-	Tag: () => Tag$1,
+	Tag: () => Tag$2,
 	Workflow: () => Workflow,
 	implement: () => implement$1,
-	make: () => make$1
+	make: () => make$2
 });
 const makeDefinition = (id, definition) => {
 	const workflowDefinition = {
@@ -2468,13 +2536,13 @@ const makeDefinition = (id, definition) => {
 		payload: definition.payload,
 		result: definition.result
 	};
-	return Object.assign(workflowDefinition, { make: (layer, options) => make(layer, { run: wrapHandler(workflowDefinition, options.run) }) });
+	return Object.assign(workflowDefinition, { make: (layer, options) => make$1(layer, { run: wrapHandler(workflowDefinition, options.run) }) });
 };
-const make$1 = (id, definition) => Tag$1()(id, definition);
-const Tag$1 = () => (id, definition) => {
+const make$2 = (id, definition) => Tag$2()(id, definition);
+const Tag$2 = () => (id, definition) => {
 	const workflowDefinition = makeDefinition(id, definition);
 	const tag = Context.Service()(id);
-	const layer$11 = (binding) => layer(tag, {
+	const layer = (binding) => layer$1(tag, {
 		...binding,
 		payload: definition.payload,
 		result: definition.result
@@ -2496,14 +2564,14 @@ const Tag$1 = () => (id, definition) => {
 		payload: workflowDefinition.payload,
 		result: workflowDefinition.result,
 		make: workflowDefinition.make,
-		layer: layer$11,
+		layer,
 		create,
 		createBatch,
 		get,
 		unsafeRaw
 	});
 };
-const Workflow = Tag$1;
+const Workflow = Tag$2;
 const wrapHandler = (definition, handler) => {
 	const decodePayload = Schema.decodeUnknownEffect(definition.payload);
 	const encodeResult = Schema.encodeEffect(definition.result);
@@ -2520,12 +2588,12 @@ const implement$1 = (_definition, handler) => handler;
 //#endregion
 //#region src/Workflow.ts
 var Workflow_exports = /* @__PURE__ */ __exportAll({
-	Tag: () => Tag,
+	Tag: () => Tag$1,
 	WorkflowEvent: () => WorkflowEvent$1,
 	WorkflowStep: () => WorkflowStep$1,
 	WorkflowStepContext: () => WorkflowStepContext$1,
 	implement: () => implement,
-	make: () => make,
+	make: () => make$1,
 	sleep: () => sleep,
 	sleepUntil: () => sleepUntil,
 	step: () => step,
@@ -2538,7 +2606,8 @@ const fromWorkflowEvent = (event) => ({
 	raw: event,
 	payload: event.payload,
 	timestamp: event.timestamp,
-	instanceId: event.instanceId
+	instanceId: event.instanceId,
+	workflowName: event.workflowName
 });
 const fromWorkflowStep = (step, runPromise) => ({
 	raw: step,
@@ -2563,7 +2632,7 @@ const fromWorkflowStep = (step, runPromise) => ({
 		catch: (cause) => cause
 	})
 });
-const make = (layer, options) => {
+const make$1 = (layer, options) => {
 	class EffectWorkflow extends WorkflowEntrypoint {
 		runtime;
 		constructor(ctx, env) {
@@ -2584,7 +2653,57 @@ const step = (name, effect, config) => Effect.flatMap(WorkflowStep$1, (workflowS
 const sleep = (name, duration) => Effect.flatMap(WorkflowStep$1, (workflowStep) => workflowStep.sleep(name, duration));
 const sleepUntil = (name, timestamp) => Effect.flatMap(WorkflowStep$1, (workflowStep) => workflowStep.sleepUntil(name, timestamp));
 const waitForEvent = (name, options) => Effect.flatMap(WorkflowStep$1, (workflowStep) => workflowStep.waitForEvent(name, options));
-const Tag = Tag$1;
+const Tag$1 = Tag$2;
 const implement = implement$1;
 //#endregion
-export { Binding_exports as Binding, CloudflareOtlp_exports as CloudflareOtlp, D1_exports as D1, DurableObject_exports as DurableObject, DurableObjectAlarm_exports as DurableObjectAlarm, DurableObjectDefinition_exports as DurableObjectDefinition, DurableObjectNamespace_exports as DurableObjectNamespace, DurableObjectRpcWebSocket_exports as DurableObjectRpcWebSocket, DurableObjectSqlite_exports as DurableObjectSqlite, DurableObjectState_exports as DurableObjectState, DurableObjectStorage_exports as DurableObjectStorage, DurableObjectWebSocket_exports as DurableObjectWebSocket, Hyperdrive_exports as Hyperdrive, Images_exports as Images, Kv_exports as Kv, Queue_exports as Queue, QueueBinding_exports as QueueBinding, QueueDefinition_exports as QueueDefinition, R2_exports as R2, Rpc_exports as Rpc, RpcDefinition_exports as RpcDefinition, ServiceBinding_exports as ServiceBinding, Worker_exports as Worker, WorkerConfig, WorkerDefinition_exports as WorkerDefinition, WorkerEnvironment, Workflow_exports as Workflow, WorkflowBinding_exports as WorkflowBinding, WorkflowDefinition_exports as WorkflowDefinition };
+//#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()";
+/** Error raised when a Vectorize operation fails. */
+var VectorizeOperationError = class extends Data.TaggedError("VectorizeOperationError") {};
+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 hasFunction = (value, key) => typeof Reflect.get(value, key) === "function";
+const isVectorizeBinding = (value) => typeof value === "object" && value !== null && hasFunction(value, "describe") && hasFunction(value, "query") && hasFunction(value, "insert") && hasFunction(value, "upsert") && hasFunction(value, "deleteByIds") && hasFunction(value, "getByIds");
+const makeClient = (definition) => (index) => {
+	const runtime = index;
+	const deleteByIds = (ids) => tryVectorizePromise(definition.binding, "deleteByIds", () => runtime.deleteByIds([...ids]));
+	return {
+		definition,
+		describe: tryVectorizePromise(definition.binding, "describe", () => runtime.describe()),
+		query: (vector, options) => tryVectorizePromise(definition.binding, "query", () => runtime.query(vector, options)),
+		queryById: (vectorId, options) => runtime.queryById !== void 0 ? tryVectorizePromise(definition.binding, "queryById", () => runtime.queryById(vectorId, options)) : Effect.fail(vectorizeError(definition.binding, "queryById", /* @__PURE__ */ new TypeError("Vectorize binding does not expose queryById()"))),
+		insert: (vectors) => tryVectorizePromise(definition.binding, "insert", () => runtime.insert([...vectors])),
+		upsert: (vectors) => tryVectorizePromise(definition.binding, "upsert", () => runtime.upsert([...vectors])),
+		deleteByIds,
+		delete: deleteByIds,
+		getByIds: (ids) => tryVectorizePromise(definition.binding, "getByIds", () => runtime.getByIds([...ids])),
+		unsafeRaw: Effect.succeed(index)
+	};
+};
+const layer = (tag, definition) => layer$15(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 { AiGateway_exports as AiGateway, Binding_exports as Binding, BrowserRendering_exports as BrowserRendering, CloudflareOtlp_exports as CloudflareOtlp, D1_exports as D1, DurableObject_exports as DurableObject, DurableObjectAlarm_exports as DurableObjectAlarm, DurableObjectDefinition_exports as DurableObjectDefinition, DurableObjectNamespace_exports as DurableObjectNamespace, DurableObjectRpcWebSocket_exports as DurableObjectRpcWebSocket, DurableObjectSqlite_exports as DurableObjectSqlite, DurableObjectState_exports as DurableObjectState, DurableObjectStorage_exports as DurableObjectStorage, DurableObjectWebSocket_exports as DurableObjectWebSocket, Hyperdrive_exports as Hyperdrive, Images_exports as Images, Kv_exports as Kv, Queue_exports as Queue, QueueBinding_exports as QueueBinding, QueueDefinition_exports as QueueDefinition, R2_exports as R2, Rpc_exports as Rpc, RpcDefinition_exports as RpcDefinition, ServiceBinding_exports as ServiceBinding, Vectorize_exports as Vectorize, Worker_exports as Worker, WorkerConfig, WorkerDefinition_exports as WorkerDefinition, WorkerEnvironment, WorkersAi_exports as WorkersAi, Workflow_exports as Workflow, WorkflowBinding_exports as WorkflowBinding, WorkflowDefinition_exports as WorkflowDefinition };