effect-cf 0.40.0 → 0.40.2

package/dist/AnalyticsEngine.mjs

@@ -0,0 +1,275 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { layer as layer$1 } from "./Binding.mjs";
+import { causeMessage, violationsMessage } 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 Layer from "effect/Layer";
+import * as Predicate from "effect/Predicate";
+import * as Config from "effect/Config";
+import * as Option from "effect/Option";
+import * as Result from "effect/Result";
+import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import * as HttpClientRequest from "effect/unstable/http/HttpClientRequest";
+//#region src/AnalyticsEngine.ts
+var AnalyticsEngine_exports = /* @__PURE__ */ __exportAll({
+	AnalyticsEngineDataPointSchema: () => AnalyticsEngineDataPointSchema,
+	AnalyticsEngineFieldValueSchema: () => AnalyticsEngineFieldValueSchema,
+	AnalyticsEngineOperationError: () => AnalyticsEngineOperationError,
+	AnalyticsEngineQueryError: () => AnalyticsEngineQueryError,
+	AnalyticsEngineWriteValidationError: () => AnalyticsEngineWriteValidationError,
+	QueryTag: () => QueryTag,
+	Tag: () => Tag,
+	isAnalyticsEngineDataset: () => isAnalyticsEngineDataset,
+	layer: () => layer,
+	layerFetch: () => layerFetch,
+	layerFetchConfig: () => layerFetchConfig,
+	make: () => make,
+	makeClient: () => makeClient,
+	makeQuery: () => makeQuery,
+	makeQueryClient: () => makeQueryClient,
+	queryConfig: () => queryConfig,
+	queryLayer: () => queryLayer,
+	queryLayerConfig: () => queryLayerConfig,
+	writeLimits: () => writeLimits
+});
+const expectedAnalyticsEngineDataset = "Analytics Engine dataset binding with writeDataPoint()";
+const defaultQueryApiBaseUrl = "https://api.cloudflare.com/client/v4";
+const textEncoder = new TextEncoder();
+const writeLimits = {
+	maxBlobs: 20,
+	maxDoubles: 20,
+	maxIndexes: 1,
+	maxBlobBytes: 16384,
+	maxIndexBytes: 96,
+	maxDataPointsPerInvocation: 250
+};
+const queryColumnSchema = S.Struct({
+	name: S.String,
+	type: S.String
+});
+const queryRowSchema = S.Record(S.String, S.Unknown);
+const queryResponseSchema = S.Struct({
+	meta: S.Array(queryColumnSchema),
+	data: S.Array(queryRowSchema),
+	rows: S.Number
+});
+const AnalyticsEngineFieldValueSchema = S.NullOr(S.Union([S.String, S.instanceOf(ArrayBuffer)]));
+const AnalyticsEngineDataPointSchema = S.Struct({
+	indexes: S.optional(S.Array(AnalyticsEngineFieldValueSchema)),
+	doubles: S.optional(S.Array(S.Finite)),
+	blobs: S.optional(S.Array(AnalyticsEngineFieldValueSchema))
+});
+const decodeQueryResponse = S.decodeUnknownEffect(queryResponseSchema);
+const decodeDataPoint = S.decodeUnknownEffect(AnalyticsEngineDataPointSchema);
+var AnalyticsEngineOperationError = class extends Data.TaggedError("AnalyticsEngineOperationError") {
+	get message() {
+		return `Analytics Engine ${this.operation} failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
+	}
+};
+var AnalyticsEngineWriteValidationError = class extends Data.TaggedError("AnalyticsEngineWriteValidationError") {
+	get message() {
+		return `Analytics Engine ${this.operation} for binding "${this.binding}" failed validation: ${violationsMessage(this.violations)}`;
+	}
+};
+var AnalyticsEngineQueryError = class extends Data.TaggedError("AnalyticsEngineQueryError") {};
+const analyticsEngineError = (binding, operation, cause) => new AnalyticsEngineOperationError({
+	binding,
+	operation,
+	cause
+});
+const analyticsEngineWriteValidationError = (binding, operation, violations, cause) => new AnalyticsEngineWriteValidationError({
+	binding,
+	operation,
+	violations,
+	cause
+});
+const analyticsEngineQueryError = (definition, operation, message, options) => new AnalyticsEngineQueryError({
+	operation,
+	accountId: definition.accountId,
+	message,
+	status: options?.status,
+	body: options?.body,
+	cause: options?.cause
+});
+const tryAnalyticsEngineSync = (binding, operation, evaluate) => Effect.try({
+	try: evaluate,
+	catch: (cause) => analyticsEngineError(binding, operation, cause)
+});
+const resolveWritePolicy = (defaults, options) => ({ onInvalid: options?.onInvalid ?? defaults?.onInvalid ?? "error" });
+const fieldPath = (prefix, field) => prefix === "" ? field : `${prefix}.${field}`;
+const indexedPath = (prefix, field, index) => `${fieldPath(prefix, field)}[${index}]`;
+const byteLength = (value) => {
+	if (value === null) return 0;
+	return Predicate.isString(value) ? textEncoder.encode(value).byteLength : value.byteLength;
+};
+const lengthViolation = (path, label, actual, limit) => ({
+	path,
+	message: `${label} exceeds Cloudflare Analytics Engine limit`,
+	actual,
+	limit
+});
+const validateDataPointLimits = (dataPoint, pathPrefix = "") => {
+	const violations = [];
+	if (dataPoint.blobs !== void 0 && dataPoint.blobs.length > writeLimits.maxBlobs) violations.push(lengthViolation(fieldPath(pathPrefix, "blobs"), "blobs", dataPoint.blobs.length, writeLimits.maxBlobs));
+	if (dataPoint.doubles !== void 0 && dataPoint.doubles.length > writeLimits.maxDoubles) violations.push(lengthViolation(fieldPath(pathPrefix, "doubles"), "doubles", dataPoint.doubles.length, writeLimits.maxDoubles));
+	if (dataPoint.indexes !== void 0 && dataPoint.indexes.length > writeLimits.maxIndexes) violations.push(lengthViolation(fieldPath(pathPrefix, "indexes"), "indexes", dataPoint.indexes.length, writeLimits.maxIndexes));
+	if (dataPoint.blobs !== void 0) {
+		const blobBytes = dataPoint.blobs.reduce((total, value) => total + byteLength(value), 0);
+		if (blobBytes > writeLimits.maxBlobBytes) violations.push(lengthViolation(fieldPath(pathPrefix, "blobs"), "blob bytes", blobBytes, writeLimits.maxBlobBytes));
+	}
+	if (dataPoint.indexes !== void 0) for (let index = 0; index < dataPoint.indexes.length; index++) {
+		const indexBytes = byteLength(dataPoint.indexes[index] ?? null);
+		if (indexBytes > writeLimits.maxIndexBytes) violations.push(lengthViolation(indexedPath(pathPrefix, "indexes", index), "index bytes", indexBytes, writeLimits.maxIndexBytes));
+	}
+	return violations;
+};
+const schemaViolation = (pathPrefix, cause) => ({
+	path: pathPrefix === "" ? "$" : pathPrefix,
+	message: cause.message
+});
+const toAnalyticsEngineDataPoint = (dataPoint) => {
+	const result = {};
+	if (dataPoint.indexes !== void 0) result.indexes = [...dataPoint.indexes];
+	if (dataPoint.doubles !== void 0) result.doubles = [...dataPoint.doubles];
+	if (dataPoint.blobs !== void 0) result.blobs = [...dataPoint.blobs];
+	return result;
+};
+const validateDataPoint = (binding, operation, dataPoint, pathPrefix = "") => Effect.gen(function* () {
+	const decoded = yield* decodeDataPoint(dataPoint).pipe(Effect.mapError((cause) => analyticsEngineWriteValidationError(binding, operation, [schemaViolation(pathPrefix, cause)], cause)));
+	const validated = toAnalyticsEngineDataPoint(decoded);
+	const violations = validateDataPointLimits(validated, pathPrefix);
+	if (violations.length > 0) return yield* Effect.fail(analyticsEngineWriteValidationError(binding, operation, violations));
+	return validated;
+});
+const validateOptionalDataPoint = (binding, operation, dataPoint) => dataPoint === void 0 ? Effect.succeed(void 0) : validateDataPoint(binding, operation, dataPoint);
+const validateDataPoints = (binding, operation, dataPoints, policy) => Effect.gen(function* () {
+	const points = dataPoints.length > writeLimits.maxDataPointsPerInvocation && policy.onInvalid === "drop" ? dataPoints.slice(0, writeLimits.maxDataPointsPerInvocation) : dataPoints;
+	const violations = [];
+	if (dataPoints.length > writeLimits.maxDataPointsPerInvocation && policy.onInvalid === "error") violations.push(lengthViolation("dataPoints", "data points per Worker invocation", dataPoints.length, writeLimits.maxDataPointsPerInvocation));
+	const validPoints = [];
+	for (let index = 0; index < points.length; index++) {
+		const result = yield* Effect.result(validateDataPoint(binding, operation, points[index], `dataPoints[${index}]`));
+		if (Result.isSuccess(result)) validPoints.push(result.success);
+		else if (policy.onInvalid === "error") violations.push(...result.failure.violations);
+	}
+	if (violations.length > 0) return yield* Effect.fail(analyticsEngineWriteValidationError(binding, operation, violations));
+	return validPoints;
+});
+const writeChunks = (binding, operation, dataset, dataPoints) => Effect.gen(function* () {
+	for (const point of dataPoints) yield* tryAnalyticsEngineSync(binding, operation, () => dataset.writeDataPoint(point));
+});
+const queryApiUrl = (definition) => {
+	const baseUrl = new URL(definition.apiBaseUrl ?? defaultQueryApiBaseUrl);
+	baseUrl.pathname = `${baseUrl.pathname.replace(/\/+$/, "")}/accounts/${definition.accountId}/analytics_engine/sql`;
+	return baseUrl.href;
+};
+const queryRequest = (definition, sql, options) => {
+	let request = HttpClientRequest.post(queryApiUrl(definition)).pipe(HttpClientRequest.bodyText(sql, "text/plain;charset=UTF-8"));
+	if (options?.headers !== void 0) request = HttpClientRequest.setHeaders(request, options.headers);
+	return HttpClientRequest.bearerToken(request, definition.apiToken);
+};
+const responseText = (definition, response, operation) => response.text.pipe(Effect.catch((cause) => Effect.fail(analyticsEngineQueryError(definition, operation, "Failed to read Analytics Engine SQL API response body", { cause }))));
+const executeQueryRequest = (definition, httpClient, sql, options) => Effect.gen(function* () {
+	const request = yield* Effect.try({
+		try: () => queryRequest(definition, sql, options),
+		catch: (cause) => analyticsEngineQueryError(definition, "query", "Invalid Analytics Engine SQL API URL", { cause })
+	});
+	const response = yield* httpClient.execute(request).pipe(Effect.mapError((cause) => analyticsEngineQueryError(definition, "query", "Analytics Engine SQL API request failed", { cause })));
+	if (response.status < 200 || response.status >= 300) {
+		const body = yield* responseText(definition, response, "queryErrorBody");
+		return yield* Effect.fail(analyticsEngineQueryError(definition, "query", `Analytics Engine SQL API returned HTTP ${response.status}`, {
+			status: response.status,
+			body
+		}));
+	}
+	return response;
+});
+const makeQueryClientWith = (definition, httpClient) => {
+	const raw = Effect.fn("AnalyticsEngine.raw")((sql, options) => executeQueryRequest(definition, httpClient, sql, options));
+	const query = Effect.fn("AnalyticsEngine.query")(function* (sql, options) {
+		const json = yield* (yield* raw(sql, options)).json.pipe(Effect.catch((cause) => Effect.fail(analyticsEngineQueryError(definition, "json", "Failed to read Analytics Engine SQL API JSON response body", { cause }))));
+		return yield* decodeQueryResponse(json);
+	});
+	const queryResult = (row, sql, options) => Effect.gen(function* () {
+		const result = yield* query(sql, options);
+		const decodeRow = S.decodeUnknownEffect(row);
+		const data = [];
+		for (const value of result.data) data.push(yield* decodeRow(value));
+		return {
+			...result,
+			data,
+			rows: result.rows
+		};
+	}).pipe(Effect.withSpan("AnalyticsEngine.queryResult"));
+	return {
+		definition,
+		raw,
+		query,
+		queryResult,
+		queryRows: (row, sql, options) => queryResult(row, sql, options).pipe(Effect.map((result) => result.data), Effect.withSpan("AnalyticsEngine.queryRows")),
+		queryOne: (row, sql, options) => queryResult(row, sql, options).pipe(Effect.map((result) => result.data[0] === void 0 ? Option.none() : Option.some(result.data[0])), Effect.withSpan("AnalyticsEngine.queryOne")),
+		queryText: Effect.fn("AnalyticsEngine.queryText")((sql, options) => raw(sql, options).pipe(Effect.flatMap((response) => responseText(definition, response, "text"))))
+	};
+};
+const makeQueryClient = (definition) => Effect.map(HttpClient.HttpClient, (httpClient) => makeQueryClientWith(definition, httpClient));
+const isAnalyticsEngineDataset = (value) => Predicate.hasProperty(value, "writeDataPoint") && Predicate.isFunction(value.writeDataPoint);
+const makeClient = (definition, defaults) => (dataset) => {
+	return {
+		definition,
+		writeDataPoint: Effect.fn("AnalyticsEngine.writeDataPoint")((dataPoint, options) => {
+			const policy = resolveWritePolicy(defaults, options);
+			return validateOptionalDataPoint(definition.binding, "writeDataPoint", dataPoint).pipe(Effect.matchEffect({
+				onFailure: (error) => policy.onInvalid === "drop" ? Effect.succeed(void 0) : Effect.fail(error),
+				onSuccess: (point) => tryAnalyticsEngineSync(definition.binding, "writeDataPoint", () => dataset.writeDataPoint(point))
+			}));
+		}),
+		writeDataPoints: Effect.fn("AnalyticsEngine.writeDataPoints")(function* (dataPoints, options) {
+			const policy = resolveWritePolicy(defaults, options);
+			const validPoints = yield* validateDataPoints(definition.binding, "writeDataPoints", dataPoints, policy);
+			yield* writeChunks(definition.binding, "writeDataPoints", dataset, validPoints);
+		}),
+		rawUnsafe: Effect.succeed(dataset)
+	};
+};
+const queryConfig = (options) => Config.all({
+	accountId: options?.accountId ?? Config.string("CLOUDFLARE_ACCOUNT_ID"),
+	apiToken: options?.apiToken ?? Config.redacted("CLOUDFLARE_API_TOKEN"),
+	apiBaseUrl: options?.apiBaseUrl ?? Config.string("CLOUDFLARE_API_BASE_URL").pipe(Config.withDefault(defaultQueryApiBaseUrl))
+});
+const queryLayer = (tag, definition) => Layer.effect(tag, makeQueryClient(definition));
+const layerFetch = (tag, definition) => queryLayer(tag, definition).pipe(Layer.provide(FetchHttpClient.layer));
+const queryLayerConfig = (tag, config = queryConfig()) => Layer.effect(tag, Effect.gen(function* () {
+	const definition = yield* config;
+	return yield* makeQueryClient(definition);
+}));
+const layerFetchConfig = (tag, config = queryConfig()) => queryLayerConfig(tag, config).pipe(Layer.provide(FetchHttpClient.layer));
+const layer = (tag, definition) => layer$1(tag, definition.binding, isAnalyticsEngineDataset, makeClient(definition, definition.write), { expected: expectedAnalyticsEngineDataset });
+const make = (id) => Tag()(id);
+const makeQuery = (id) => QueryTag()(id);
+const Tag = () => (id) => {
+	const tag = Context.Service()(id);
+	const makeLayer = (definition) => layer(tag, definition);
+	return Object.assign(tag, {
+		id,
+		layer: makeLayer
+	});
+};
+const QueryTag = () => (id) => {
+	const tag = Context.Service()(id);
+	const makeLayer = (definition) => queryLayer(tag, definition);
+	const makeLayerFetch = (definition) => layerFetch(tag, definition);
+	const makeLayerConfig = (config) => queryLayerConfig(tag, config);
+	const makeLayerFetchConfig = (config) => layerFetchConfig(tag, config);
+	return Object.assign(tag, {
+		id,
+		layer: makeLayer,
+		layerFetch: makeLayerFetch,
+		layerConfig: makeLayerConfig,
+		layerFetchConfig: makeLayerFetchConfig
+	});
+};
+//#endregion
+export { AnalyticsEngineDataPointSchema, AnalyticsEngineFieldValueSchema, AnalyticsEngineOperationError, AnalyticsEngineQueryError, AnalyticsEngineWriteValidationError, AnalyticsEngine_exports, QueryTag, Tag, isAnalyticsEngineDataset, layer, layerFetch, layerFetchConfig, make, makeClient, makeQuery, makeQueryClient, queryConfig, queryLayer, queryLayerConfig, writeLimits };

package/dist/{Artifacts-B3r3RuTB.d.mts → Artifacts.d.mts}

@@ -1,5 +1,8 @@
-import { c as WorkerEnvironment, r as BindingValidationError, t as BindingNotFoundError } from "./Binding-DKcLrQCM.mjs";
-import { Context, Effect, Layer } from "effect";
+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 { Layer } from "effect";
 declare namespace Artifacts_d_exports {
   export { ArtifactsBinding, ArtifactsClient, ArtifactsCommit, ArtifactsCommitIdentity, ArtifactsCreateOptions, ArtifactsCreateRepoResult, ArtifactsCreateTokenResult, ArtifactsDefinition, ArtifactsErrorCode, ArtifactsForkOptions, ArtifactsImportParams, ArtifactsImportSource, ArtifactsImportTarget, ArtifactsImportTargetOptions, ArtifactsListOptions, ArtifactsLogOptions, ArtifactsLogResult, ArtifactsOperation, ArtifactsOperationError, ArtifactsRepoBinding, ArtifactsRepoClient, ArtifactsRepoInfo, ArtifactsRepoListEntry, ArtifactsRepoListResult, ArtifactsRepoStatus, ArtifactsService, ArtifactsTokenInfo, ArtifactsTokenListResult, ArtifactsTokenScope, ArtifactsTokenState, ArtifactsTree, Cursor, LayerOptions, RepoName, Tag, TagClass, artifactsErrorCodes, artifactsErrorNumericCodes, isArtifactsBinding, isArtifactsRepoBinding, layer, make, makeClient };
 }
@@ -187,15 +190,15 @@ interface ArtifactsService<Id extends string> {
 type LayerOptions = {
   readonly binding: string;
 };
-interface TagClass<Self, Id extends string> extends Context.ServiceClass<Self, Id, ArtifactsClient> {
+interface TagClass<Self, Id extends string> extends Context$1.ServiceClass<Self, Id, ArtifactsClient> {
   readonly id: Id;
   readonly layer: (options: LayerOptions) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 }
 declare const isArtifactsRepoBinding: <Candidate>(value: Candidate) => value is Candidate & ArtifactsRepoBinding;
 declare const isArtifactsBinding: <Candidate>(value: Candidate) => value is Candidate & ArtifactsBinding;
 declare const makeClient: (definition: ArtifactsDefinition) => (artifacts: ArtifactsBinding) => ArtifactsClient;
-declare const layer: <Self>(tag: Context.Service<Self, ArtifactsClient>, definition: ArtifactsDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const layer: <Self>(tag: Context$1.Service<Self, ArtifactsClient>, definition: ArtifactsDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 declare const make: <Id extends string>(id: Id) => TagClass<ArtifactsService<Id>, Id>;
 declare const Tag: <Self>() => <Id extends string>(id: Id) => TagClass<Self, Id>;
 //#endregion
-export { ArtifactsOperationError as a, ArtifactsTokenListResult as c, ArtifactsCreateTokenResult as i, Artifacts_d_exports as l, ArtifactsCreateOptions as n, ArtifactsRepoInfo as o, ArtifactsCreateRepoResult as r, ArtifactsTokenInfo as s, ArtifactsBinding as t, RepoName as u };
+export { ArtifactsBinding, ArtifactsClient, ArtifactsCommit, ArtifactsCommitIdentity, ArtifactsCreateOptions, ArtifactsCreateRepoResult, ArtifactsCreateTokenResult, ArtifactsDefinition, ArtifactsErrorCode, ArtifactsForkOptions, ArtifactsImportParams, ArtifactsImportSource, ArtifactsImportTarget, ArtifactsImportTargetOptions, ArtifactsListOptions, ArtifactsLogOptions, ArtifactsLogResult, ArtifactsOperation, ArtifactsOperationError, ArtifactsRepoBinding, ArtifactsRepoClient, ArtifactsRepoInfo, ArtifactsRepoListEntry, ArtifactsRepoListResult, ArtifactsRepoStatus, ArtifactsService, ArtifactsTokenInfo, ArtifactsTokenListResult, ArtifactsTokenScope, ArtifactsTokenState, ArtifactsTree, Artifacts_d_exports, Cursor, LayerOptions, RepoName, Tag, TagClass, artifactsErrorCodes, artifactsErrorNumericCodes, isArtifactsBinding, isArtifactsRepoBinding, layer, make, makeClient };

package/dist/{Artifacts-CBxWGeZB.mjs → Artifacts.mjs}

@@ -1,7 +1,11 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { t as causeMessage } from "./ErrorMessage-Byx2OgNd.mjs";
-import { r as layer$1 } from "./Binding-C82jRhdr.mjs";
-import { Context, Data, Effect, Predicate, Schema } from "effect";
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { layer as layer$1 } from "./Binding.mjs";
+import { causeMessage } from "./internal/ErrorMessage.mjs";
+import * as Context from "effect/Context";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as Predicate from "effect/Predicate";
 //#region src/Artifacts.ts
 var Artifacts_exports = /* @__PURE__ */ __exportAll({
 	ArtifactsOperationError: () => ArtifactsOperationError,
@@ -125,4 +129,4 @@ const Tag = () => (id) => {
 	});
 };
 //#endregion
-export { Artifacts_exports as n, ArtifactsOperationError as t };
+export { ArtifactsOperationError, Artifacts_exports, Tag, artifactsErrorCodes, artifactsErrorNumericCodes, isArtifactsBinding, isArtifactsRepoBinding, layer, make, makeClient };

package/dist/Binding.d.mts

@@ -0,0 +1,45 @@
+import { WorkerEnvironment } from "./Environment.mjs";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+import * as Predicate from "effect/Predicate";
+declare namespace Binding_d_exports {
+  export { BindingNotFoundError, BindingService, BindingValidationError, Service, TypeId, ValidationOptions, layer };
+}
+declare const TypeId: "~effect-cf/Binding";
+type TypeId = typeof TypeId;
+declare const BindingNotFoundError_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: "BindingNotFoundError";
+} & Readonly<A>;
+/** Error raised when a configured binding does not exist on `env`. */
+declare class BindingNotFoundError extends BindingNotFoundError_base<{
+  readonly binding: string;
+  readonly message: string;
+}> {}
+declare const BindingValidationError_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: "BindingValidationError";
+} & Readonly<A>;
+/** Error raised when a binding exists but does not match the expected shape. */
+declare class BindingValidationError extends BindingValidationError_base<{
+  readonly binding: string;
+  readonly expected: string;
+  readonly actual: string;
+  readonly message: string;
+}> {}
+interface ValidationOptions {
+  readonly expected?: string;
+}
+type BindingCandidate = Parameters<typeof Predicate.isUnknown>[0];
+interface BindingService<Self, Id extends string, Service> extends Context.ServiceClass<Self, `effect-cf/Binding/${Id}`, Service> {
+  readonly [TypeId]: TypeId;
+  readonly id: Id;
+  readonly binding: string;
+  readonly layer: Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+}
+declare function layer<Self, Resource>(tag: Context.Service<Self, Resource>, binding: string, isResource: (value: BindingCandidate) => value is Resource, wrap?: undefined, options?: ValidationOptions): Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare function layer<Self, Resource, Service>(tag: Context.Service<Self, Service>, binding: string, isResource: (value: BindingCandidate) => value is Resource, wrap: (resource: Resource) => Service, options?: ValidationOptions): Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const Service: <Self>() => {
+  <Id extends string, Resource>(id: Id, binding: string, isResource: (value: BindingCandidate) => value is Resource, wrap?: undefined, options?: ValidationOptions): BindingService<Self, Id, Resource>;
+  <Id extends string, Resource, Service>(id: Id, binding: string, isResource: (value: BindingCandidate) => value is Resource, wrap: (resource: Resource) => Service, options?: ValidationOptions): BindingService<Self, Id, Service>;
+};
+//#endregion
+export { BindingNotFoundError, BindingService, BindingValidationError, Binding_d_exports, Service, TypeId, ValidationOptions, layer };

package/dist/{Binding-C82jRhdr.mjs → Binding.mjs}

@@ -1,6 +1,10 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { a as WorkerEnvironment } from "./ErrorMessage-Byx2OgNd.mjs";
-import { Context, Data, Effect, Layer, Predicate } from "effect";
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { WorkerEnvironment } from "./Environment.mjs";
+import * as Context from "effect/Context";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Predicate from "effect/Predicate";
 //#region src/Binding.ts
 var Binding_exports = /* @__PURE__ */ __exportAll({
 	BindingNotFoundError: () => BindingNotFoundError,
@@ -125,4 +129,4 @@ const Service = () => {
 	return makeService;
 };
 //#endregion
-export { Service as n, layer as r, Binding_exports as t };
+export { BindingNotFoundError, BindingValidationError, Binding_exports, Service, TypeId, layer };

package/dist/BrowserRendering.d.mts

@@ -0,0 +1,85 @@
+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 { Layer } from "effect";
+declare namespace BrowserRendering_d_exports {
+  export { BrowserRenderingBinding, BrowserRenderingBrowserClient, BrowserRenderingBrowserLike, BrowserRenderingClient, BrowserRenderingConnect, BrowserRenderingDefinition, BrowserRenderingExternalResult, BrowserRenderingLaunch, BrowserRenderingMethodOptions, BrowserRenderingOperationError, BrowserRenderingPageClient, BrowserRenderingPageFunction, BrowserRenderingPageLike, BrowserRenderingService, LayerOptions, Tag, TagClass, isBrowserRenderingBinding, layer, make, makeClient };
+}
+declare const BrowserRenderingOperationError_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: "BrowserRenderingOperationError";
+} & Readonly<A>;
+declare class BrowserRenderingOperationError extends BrowserRenderingOperationError_base<{
+  readonly binding: string;
+  readonly operation: string;
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
+interface BrowserRenderingDefinition {
+  readonly binding: string;
+}
+type BrowserRenderingBinding = object;
+interface BrowserRenderingMethodOptions {}
+type BrowserRenderingExternalResult = Awaited<ReturnType<Response["json"]>>;
+type BrowserRenderingPageFunction = string | Function;
+type BrowserRenderingLaunch<RawBinding, Browser, LaunchOptions = unknown> = (binding: RawBinding, options?: LaunchOptions) => Promise<Browser>;
+type BrowserRenderingConnect<RawBinding, Browser, ConnectOptions = unknown> = (binding: RawBinding, options?: ConnectOptions) => Promise<Browser>;
+interface BrowserRenderingBrowserLike<Page = BrowserRenderingPageLike> {
+  readonly newPage: () => Promise<Page>;
+  readonly close?: () => Promise<void>;
+  readonly disconnect?: () => void;
+  readonly version?: () => Promise<string>;
+}
+interface BrowserRenderingPageLike {
+  readonly goto?: (url: string, options?: BrowserRenderingMethodOptions) => Promise<BrowserRenderingExternalResult>;
+  readonly setContent?: (html: string, options?: BrowserRenderingMethodOptions) => Promise<void>;
+  readonly content?: () => Promise<string>;
+  readonly screenshot?: (options?: BrowserRenderingMethodOptions) => Promise<Uint8Array | string>;
+  readonly pdf?: (options?: BrowserRenderingMethodOptions) => Promise<Uint8Array>;
+  readonly evaluate?: (pageFunction: BrowserRenderingPageFunction, ...args: ReadonlyArray<unknown>) => Promise<BrowserRenderingExternalResult>;
+  readonly close?: (options?: BrowserRenderingMethodOptions) => Promise<void>;
+}
+interface BrowserRenderingPageClient<Page extends BrowserRenderingPageLike> {
+  readonly raw: Page;
+  readonly goto: (url: string, options?: Parameters<NonNullable<Page["goto"]>>[1]) => Effect.Effect<Awaited<ReturnType<NonNullable<Page["goto"]>>>, BrowserRenderingOperationError>;
+  readonly setContent: (html: string, options?: Parameters<NonNullable<Page["setContent"]>>[1]) => Effect.Effect<void, BrowserRenderingOperationError>;
+  readonly content: Effect.Effect<string, BrowserRenderingOperationError>;
+  readonly screenshot: (options?: Parameters<NonNullable<Page["screenshot"]>>[0]) => Effect.Effect<Awaited<ReturnType<NonNullable<Page["screenshot"]>>>, BrowserRenderingOperationError>;
+  readonly pdf: (options?: Parameters<NonNullable<Page["pdf"]>>[0]) => Effect.Effect<Awaited<ReturnType<NonNullable<Page["pdf"]>>>, BrowserRenderingOperationError>;
+  readonly evaluate: (pageFunction: Parameters<NonNullable<Page["evaluate"]>>[0], ...args: ReadonlyArray<unknown>) => Effect.Effect<Awaited<ReturnType<NonNullable<Page["evaluate"]>>>, BrowserRenderingOperationError>;
+  readonly close: (options?: Parameters<NonNullable<Page["close"]>>[0]) => Effect.Effect<void, BrowserRenderingOperationError>;
+}
+interface BrowserRenderingBrowserClient<Browser extends BrowserRenderingBrowserLike<Page>, Page extends BrowserRenderingPageLike> {
+  readonly raw: Browser;
+  readonly newPage: Effect.Effect<BrowserRenderingPageClient<Page>, BrowserRenderingOperationError>;
+  readonly version: Effect.Effect<string, BrowserRenderingOperationError>;
+  readonly close: Effect.Effect<void, BrowserRenderingOperationError>;
+  readonly disconnect: Effect.Effect<void, BrowserRenderingOperationError>;
+}
+interface BrowserRenderingClient<RawBinding extends BrowserRenderingBinding = BrowserRenderingBinding> {
+  readonly launchWith: <Browser extends BrowserRenderingBrowserLike<Page>, Page extends BrowserRenderingPageLike = BrowserRenderingPageLike, LaunchOptions = unknown>(launch: BrowserRenderingLaunch<RawBinding, Browser, LaunchOptions>, options?: LaunchOptions) => Effect.Effect<BrowserRenderingBrowserClient<Browser, Page>, BrowserRenderingOperationError>;
+  readonly connectWith: <Browser extends BrowserRenderingBrowserLike<Page>, Page extends BrowserRenderingPageLike = BrowserRenderingPageLike, ConnectOptions = unknown>(connect: BrowserRenderingConnect<RawBinding, Browser, ConnectOptions>, options?: ConnectOptions) => Effect.Effect<BrowserRenderingBrowserClient<Browser, Page>, BrowserRenderingOperationError>;
+  readonly rawUnsafe: Effect.Effect<RawBinding>;
+  readonly definition: BrowserRenderingDefinition;
+}
+declare const BrowserRenderingServiceTypeId: unique symbol;
+interface BrowserRenderingService<Id extends string> {
+  readonly [BrowserRenderingServiceTypeId]: {
+    readonly id: Id;
+  };
+}
+type LayerOptions = {
+  readonly binding: string;
+};
+interface TagClass<Self, Id extends string> extends Context$1.ServiceClass<Self, Id, BrowserRenderingClient> {
+  readonly id: Id;
+  readonly layer: (options: LayerOptions) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+}
+declare const isBrowserRenderingBinding: <Candidate>(value: Candidate) => value is Candidate & BrowserRenderingBinding;
+declare const makeClient: <RawBinding extends BrowserRenderingBinding = BrowserRenderingBinding>(definition: BrowserRenderingDefinition) => (binding: RawBinding) => BrowserRenderingClient<RawBinding>;
+declare const layer: <Self>(tag: Context$1.Service<Self, BrowserRenderingClient>, definition: BrowserRenderingDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const make: <Id extends string>(id: Id) => TagClass<BrowserRenderingService<Id>, Id>;
+declare const Tag: <Self>() => <Id extends string>(id: Id) => TagClass<Self, Id>;
+//#endregion
+export { BrowserRenderingBinding, BrowserRenderingBrowserClient, BrowserRenderingBrowserLike, BrowserRenderingClient, BrowserRenderingConnect, BrowserRenderingDefinition, BrowserRenderingExternalResult, BrowserRenderingLaunch, BrowserRenderingMethodOptions, BrowserRenderingOperationError, BrowserRenderingPageClient, BrowserRenderingPageFunction, BrowserRenderingPageLike, BrowserRenderingService, BrowserRendering_d_exports, LayerOptions, Tag, TagClass, isBrowserRenderingBinding, layer, make, makeClient };

package/dist/BrowserRendering.mjs

@@ -0,0 +1,81 @@
+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";
+//#region src/BrowserRendering.ts
+var BrowserRendering_exports = /* @__PURE__ */ __exportAll({
+	BrowserRenderingOperationError: () => BrowserRenderingOperationError,
+	Tag: () => Tag,
+	isBrowserRenderingBinding: () => isBrowserRenderingBinding,
+	layer: () => layer,
+	make: () => make,
+	makeClient: () => makeClient
+});
+const expectedBrowserRenderingBinding = "Browser Rendering binding resource";
+var BrowserRenderingOperationError = class extends Data.TaggedError("BrowserRenderingOperationError") {
+	get message() {
+		return `Browser Rendering ${this.operation} failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
+	}
+};
+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) => {
+		const screenshot = page.screenshot?.bind(page);
+		return screenshot === void 0 ? missingMethod(binding, "screenshot") : tryBrowserRenderingPromise(binding, "screenshot", () => screenshot(options));
+	},
+	pdf: (options) => {
+		const pdf = page.pdf?.bind(page);
+		return pdf === void 0 ? missingMethod(binding, "pdf") : tryBrowserRenderingPromise(binding, "pdf", () => pdf(options));
+	},
+	evaluate: (pageFunction, ...args) => {
+		const evaluate = page.evaluate?.bind(page);
+		return evaluate === void 0 ? missingMethod(binding, "evaluate") : tryBrowserRenderingPromise(binding, "evaluate", () => 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) => Predicate.isObjectOrArray(value) || Predicate.isFunction(value);
+const makeClient = (definition) => (binding) => ({
+	definition,
+	launchWith: (launch, options) => tryBrowserRenderingPromise(definition.binding, "launch", () => launch(binding, options)).pipe(Effect.map((browser) => wrapBrowser(definition.binding, browser)), Effect.withSpan("BrowserRendering.launchWith")),
+	connectWith: (connect, options) => tryBrowserRenderingPromise(definition.binding, "connect", () => connect(binding, options)).pipe(Effect.map((browser) => wrapBrowser(definition.binding, browser)), Effect.withSpan("BrowserRendering.connectWith")),
+	rawUnsafe: Effect.succeed(binding)
+});
+const layer = (tag, definition) => layer$1(tag, definition.binding, isBrowserRenderingBinding, makeClient(definition), { expected: expectedBrowserRenderingBinding });
+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 { BrowserRenderingOperationError, BrowserRendering_exports, Tag, isBrowserRenderingBinding, layer, make, makeClient };

package/dist/Cache.d.mts

@@ -0,0 +1,40 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+declare namespace Cache_d_exports {
+  export { CacheClient, CacheOperation, CacheOperationError, CacheQueryOptions, CacheRequest, CacheStorage, CacheStorageClient, layer, layerFrom, makeCacheClient, makeClient };
+}
+type CacheRequest = CloudflareRequestInfo | URL;
+type CacheQueryOptions = CloudflareCacheQueryOptions;
+type CacheOperation = "open" | "match" | "put" | "delete";
+declare const CacheOperationError_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: "CacheOperationError";
+} & Readonly<A>;
+declare class CacheOperationError extends CacheOperationError_base<{
+  readonly cache: string;
+  readonly operation: CacheOperation;
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
+interface CacheClient {
+  readonly name: string;
+  readonly match: (request: CacheRequest, options?: CacheQueryOptions) => Effect.Effect<Option.Option<Response>, CacheOperationError>;
+  readonly put: (request: CacheRequest, response: Response) => Effect.Effect<void, CacheOperationError>;
+  readonly delete: (request: CacheRequest, options?: CacheQueryOptions) => Effect.Effect<boolean, CacheOperationError>;
+  readonly rawUnsafe: Effect.Effect<CloudflareCache>;
+}
+interface CacheStorageClient {
+  readonly default: CacheClient;
+  readonly open: (name: string) => Effect.Effect<CacheClient, CacheOperationError>;
+  readonly rawUnsafe: Effect.Effect<CloudflareCacheStorage>;
+}
+declare const CacheStorage_base: Context.ServiceClass<CacheStorage, "effect-cf/CacheStorage", CacheStorageClient>;
+declare class CacheStorage extends CacheStorage_base {}
+declare const makeCacheClient: (cache: CloudflareCache, name?: string) => CacheClient;
+declare const makeClient: (storage: CloudflareCacheStorage) => CacheStorageClient;
+declare const layerFrom: (storage: CloudflareCacheStorage) => Layer.Layer<CacheStorage>;
+declare const layer: Layer.Layer<CacheStorage>;
+//#endregion
+export { CacheClient, CacheOperation, CacheOperationError, CacheQueryOptions, CacheRequest, CacheStorage, CacheStorageClient, Cache_d_exports, layer, layerFrom, makeCacheClient, makeClient };