effect-cf 0.15.0 → 0.16.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # effect-cf
 
+## 0.16.0
+
+### Minor Changes
+
+- [#51](https://github.com/danieljvdm/effect-cf/pull/51) [`9a6abd2`](https://github.com/danieljvdm/effect-cf/commit/9a6abd27366c71867a420f872459b3d5fc1b2143) Thanks [@owensbla](https://github.com/owensbla)! - Add Effect-native Cloudflare Analytics Engine helpers. `AnalyticsEngine.Tag(...)` now provides validated dataset writes, configurable invalid-write policy, and batch write helpers. `AnalyticsEngine.QueryTag(...)` / `makeQueryClient(...)` provide SQL API querying backed by Effect `HttpClient`, config and redacted API token support, typed result envelopes, and row decoding through Effect schemas.
+
 ## 0.15.0
 
 ### Minor Changes

package/README.md

@@ -1,6 +1,6 @@
 # effect-cf
 
-Effect-native Cloudflare primitives for Workers, Durable Objects, bindings, KV, D1, Queues, Email, Workflows, and Durable Object storage.
+Effect-native Cloudflare primitives for Workers, Durable Objects, bindings, KV, D1, Queues, Email, Analytics Engine, Workflows, and Durable Object storage.
 
 ## Install
 
@@ -36,6 +36,7 @@ Runtime creation belongs at Cloudflare entrypoints, not inside binding helpers.
 - `Hyperdrive` - typed Hyperdrive binding helper for connection strings and optional Postgres SQL integration
 - `Images` - typed Cloudflare Images binding helper with transformation APIs and optional hosted image operations
 - `Email` - typed Cloudflare Send Email binding helper for `send_email` bindings
+- `AnalyticsEngine` - typed Cloudflare Analytics Engine write bindings and SQL API query helpers
 - `Queue` - typed Queue producer/consumer tags plus client and error types
 - `Workflow` - typed Workflow entrypoints, steps, starter clients, and instance types
 - `Rpc` - Cloudflare RPC type helpers and scoped disposal utilities
@@ -233,6 +234,87 @@ export const sendWelcomeEmail = (to: string) =>
   });
 ```
 
+## Analytics Engine Example
+
+Analytics Engine tags expose Cloudflare dataset bindings as Effect-wrapped `writeDataPoint(...)` operations. Writes use Cloudflare's native non-blocking runtime API and are validated against Workers Analytics Engine limits before reaching the binding.
+
+```ts
+import { Effect } from "effect";
+import { AnalyticsEngine } from "effect-cf";
+
+class RequestAnalytics extends AnalyticsEngine.Tag<RequestAnalytics>()("RequestAnalytics") {}
+
+export const RequestAnalyticsLayer = RequestAnalytics.layer({
+  binding: "REQUEST_ANALYTICS",
+  write: {
+    onInvalid: "error",
+    batchSize: 100,
+  },
+});
+
+export const recordPageView = (request: Request) =>
+  Effect.gen(function* () {
+    const analytics = yield* RequestAnalytics;
+    const url = new URL(request.url);
+
+    yield* analytics.writeDataPoint({
+      indexes: [url.hostname],
+      blobs: [url.pathname, request.headers.get("cf-connecting-country") ?? "unknown"],
+      doubles: [1],
+    });
+
+    yield* analytics.writeBatch(
+      [
+        {
+          indexes: [url.hostname],
+          blobs: [url.pathname, "page-view"],
+          doubles: [1],
+        },
+      ],
+      { onInvalid: "drop" },
+    );
+  });
+```
+
+Define the dataset binding in the consuming Worker's `wrangler.jsonc` with `analytics_engine_datasets`, then provide `RequestAnalytics.layer({ binding: "REQUEST_ANALYTICS" })` from the Worker layer. Invalid writes fail with `AnalyticsEngineWriteValidationError` by default. Use `write: { onInvalid: "drop" }` on the layer or `{ onInvalid: "drop" }` per call when dropping invalid points is preferable.
+
+Analytics Engine query tags wrap Cloudflare's HTTP SQL API. Configuration can stay in Effect `Config`, including a redacted API token, the outbound transport is an Effect `HttpClient` dependency, and rows can be decoded with Effect schemas at the query boundary. Use `fetchLayerConfig(...)` as shorthand when the platform fetch-backed client is enough.
+
+```ts
+import { Effect, Layer, Schema as S } from "effect";
+import { FetchHttpClient } from "effect/unstable/http";
+import { AnalyticsEngine, WorkerConfig } from "effect-cf";
+
+class AnalyticsQuery extends AnalyticsEngine.QueryTag<AnalyticsQuery>()("AnalyticsQuery") {}
+
+export const AnalyticsQueryLayer = AnalyticsQuery.layerConfig(
+  AnalyticsEngine.queryConfig({
+    accountId: WorkerConfig.string("CLOUDFLARE_ACCOUNT_ID"),
+    apiToken: WorkerConfig.redacted("CLOUDFLARE_API_TOKEN"),
+  }),
+).pipe(Layer.provide(FetchHttpClient.layer));
+
+const PageView = S.Struct({
+  path: S.String,
+  views: S.Number,
+});
+
+export const topPages = Effect.gen(function* () {
+  const analytics = yield* AnalyticsQuery;
+
+  return yield* analytics.queryRows(
+    PageView,
+    `
+      SELECT blob1 AS path, SUM(_sample_interval) AS views
+      FROM request_metrics
+      GROUP BY path
+      ORDER BY views DESC
+      LIMIT 10
+    `,
+  );
+});
+```
+
 ## Workflow Example
 
 Workflow definitions type the payload and result. Runtime handlers can access `Workflow.WorkflowEvent`, use durable `Workflow.step(...)`, and use normal binding services inside steps.

package/dist/index.d.mts

@@ -1,6 +1,6 @@
 import { a as BindingService, c as WorkerConfig, i as BindingNotFoundError, l as WorkerEnv, o as BindingValidationError, s as Binding_d_exports, t as Hyperdrive_d_exports, u as WorkerEnvironment } from "./Hyperdrive-C0vfrPeG.mjs";
-import { Cause, Context, Data, DateTime, Duration, Effect, Layer, Option, Schema, Scope } from "effect";
-import { Headers as Headers$1, HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
+import { Cause, Config, Context, Data, DateTime, Duration, Effect, Layer, Option, Redacted, Schema, Scope } from "effect";
+import { Headers as Headers$1, HttpClient, HttpClientResponse, HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
 import { D1Client } from "@effect/sql-d1";
 import { DurableObject, RpcStub, RpcTarget, WorkerEntrypoint, WorkflowEntrypoint, WorkflowEvent, WorkflowSleepDuration, WorkflowStep, WorkflowStepConfig, WorkflowStepContext, WorkflowStepEvent, WorkflowTimeoutDuration } from "cloudflare:workers";
 import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
@@ -16,7 +16,7 @@ import * as _$effect_Config0 from "effect/Config";
 
 //#region src/WorkersAi.d.ts
 declare namespace WorkersAi_d_exports {
-  export { LayerOptions$17 as LayerOptions, Tag$16 as Tag, TagClass$15 as TagClass, WorkersAiAsyncBatchResponse, WorkersAiBinding, WorkersAiClient, WorkersAiDefinition, WorkersAiEmbeddingInput, WorkersAiEmbeddingResponse, WorkersAiModelsSearchObject, WorkersAiModelsSearchParams, WorkersAiOperationError, WorkersAiOptions, WorkersAiService, embeddingResponse, isWorkersAiBinding, layer$14 as layer, make$15 as make, makeClient$11 as makeClient };
+  export { LayerOptions$18 as LayerOptions, Tag$17 as Tag, TagClass$16 as TagClass, WorkersAiAsyncBatchResponse, WorkersAiBinding, WorkersAiClient, WorkersAiDefinition, WorkersAiEmbeddingInput, WorkersAiEmbeddingResponse, WorkersAiModelsSearchObject, WorkersAiModelsSearchParams, WorkersAiOperationError, WorkersAiOptions, WorkersAiService, embeddingResponse, isWorkersAiBinding, layer$15 as layer, make$16 as make, makeClient$12 as makeClient };
 }
 declare const WorkersAiOperationError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
   readonly _tag: "WorkersAiOperationError";
@@ -75,24 +75,24 @@ interface WorkersAiService<Id extends string> {
     readonly id: Id;
   };
 }
-type LayerOptions$17 = {
+type LayerOptions$18 = {
   readonly binding: string;
 };
-interface TagClass$15<Self, Id extends string, ModelList extends AiModelListType = AiModels> extends Context.ServiceClass<Self, Id, WorkersAiClient<ModelList>> {
+interface TagClass$16<Self, Id extends string, ModelList extends AiModelListType = AiModels> extends Context.ServiceClass<Self, Id, WorkersAiClient<ModelList>> {
   readonly id: Id;
-  readonly layer: (options: LayerOptions$17) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+  readonly layer: (options: LayerOptions$18) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 }
 declare const isWorkersAiBinding: (value: unknown) => value is WorkersAiBinding;
 declare const embeddingResponse: (value: {
   readonly data?: ReadonlyArray<ReadonlyArray<number>>;
   readonly shape?: ReadonlyArray<number>;
 }) => WorkersAiEmbeddingResponse;
-declare const makeClient$11: <ModelList extends AiModelListType = AiModels>(definition: WorkersAiDefinition) => (ai: WorkersAiBinding<ModelList>) => WorkersAiClient<ModelList>;
-declare const layer$14: <Self, ModelList extends AiModelListType = AiModels>(tag: Context.Service<Self, WorkersAiClient<ModelList>>, definition: WorkersAiDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-declare const make$15: <Id extends string>(id: Id) => TagClass$15<WorkersAiService<Id>, Id, AiModels>;
-declare const Tag$16: <Self>() => <Id extends string, ModelList extends AiModelListType = AiModels>(id: Id) => TagClass$15<Self, Id, ModelList>;
+declare const makeClient$12: <ModelList extends AiModelListType = AiModels>(definition: WorkersAiDefinition) => (ai: WorkersAiBinding<ModelList>) => WorkersAiClient<ModelList>;
+declare const layer$15: <Self, ModelList extends AiModelListType = AiModels>(tag: Context.Service<Self, WorkersAiClient<ModelList>>, definition: WorkersAiDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const make$16: <Id extends string>(id: Id) => TagClass$16<WorkersAiService<Id>, Id, AiModels>;
+declare const Tag$17: <Self>() => <Id extends string, ModelList extends AiModelListType = AiModels>(id: Id) => TagClass$16<Self, Id, ModelList>;
 declare namespace AiGateway_d_exports {
-  export { AiGatewayBinding, AiGatewayClient, AiGatewayDefinition, AiGatewayFetchOptions, AiGatewayHeaders, AiGatewayLog, AiGatewayOperationError, AiGatewayPatchLog, AiGatewayProvider, AiGatewayRunOptions, AiGatewayService, AiGatewayUniversalRequest, LayerOptions$16 as LayerOptions, Tag$15 as Tag, TagClass$14 as TagClass, isAiGatewayBinding, layer$13 as layer, make$14 as make, makeClient$10 as makeClient, makeClientFromAi, makeHttpClient };
+  export { AiGatewayBinding, AiGatewayClient, AiGatewayDefinition, AiGatewayFetchOptions, AiGatewayHeaders, AiGatewayLog, AiGatewayOperationError, AiGatewayPatchLog, AiGatewayProvider, AiGatewayRunOptions, AiGatewayService, AiGatewayUniversalRequest, LayerOptions$17 as LayerOptions, Tag$16 as Tag, TagClass$15 as TagClass, isAiGatewayBinding, layer$14 as layer, make$15 as make, makeClient$11 as makeClient, makeClientFromAi, makeHttpClient };
 }
 declare const AiGatewayOperationError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
   readonly _tag: "AiGatewayOperationError";
@@ -141,17 +141,17 @@ interface AiGatewayService<Id extends string> {
     readonly id: Id;
   };
 }
-type LayerOptions$16 = {
+type LayerOptions$17 = {
   readonly binding: string;
   readonly gatewayId: string;
   readonly accountId?: string;
 };
-interface TagClass$14<Self, Id extends string> extends Context.ServiceClass<Self, Id, AiGatewayClient> {
+interface TagClass$15<Self, Id extends string> extends Context.ServiceClass<Self, Id, AiGatewayClient> {
   readonly id: Id;
-  readonly layer: (options: LayerOptions$16) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError | AiGatewayOperationError, WorkerEnvironment>;
+  readonly layer: (options: LayerOptions$17) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError | AiGatewayOperationError, WorkerEnvironment>;
 }
 declare const isAiGatewayBinding: (value: unknown) => value is WorkersAiBinding;
-declare const makeClient$10: (definition: AiGatewayDefinition, gateway: AiGatewayBinding) => {
+declare const makeClient$11: (definition: AiGatewayDefinition, gateway: AiGatewayBinding) => {
   definition: AiGatewayDefinition;
   run: (data: _$_cloudflare_workers_types0.AIGatewayUniversalRequest | readonly _$_cloudflare_workers_types0.AIGatewayUniversalRequest[], options: {
     gateway?: _$_cloudflare_workers_types0.UniversalGatewayOptions;
@@ -169,9 +169,180 @@ declare const makeHttpClient: (definition: Omit<AiGatewayDefinition, "binding">
   readonly accountId: string;
   readonly binding?: string;
 }, request?: typeof fetch) => AiGatewayClient;
-declare const layer$13: <Self>(tag: Context.Service<Self, AiGatewayClient>, definition: AiGatewayDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-declare const make$14: <Id extends string>(id: Id) => TagClass$14<AiGatewayService<Id>, Id>;
+declare const layer$14: <Self>(tag: Context.Service<Self, AiGatewayClient>, definition: AiGatewayDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const make$15: <Id extends string>(id: Id) => TagClass$15<AiGatewayService<Id>, Id>;
+declare const Tag$16: <Self>() => <Id extends string>(id: Id) => TagClass$15<Self, Id>;
+declare namespace AnalyticsEngine_d_exports {
+  export { AnalyticsEngineBinding, AnalyticsEngineClient, AnalyticsEngineDataPoint, AnalyticsEngineDataPointSchema, AnalyticsEngineDefinition, AnalyticsEngineFieldValue, AnalyticsEngineFieldValueSchema, AnalyticsEngineInvalidWritePolicy, AnalyticsEngineOperationError, AnalyticsEngineQueryClient, AnalyticsEngineQueryColumn, AnalyticsEngineQueryDefinition, AnalyticsEngineQueryError, AnalyticsEngineQueryOptions, AnalyticsEngineQueryResult, AnalyticsEngineQueryRow, AnalyticsEngineQueryService, AnalyticsEngineService, AnalyticsEngineWriteBatchOptions, AnalyticsEngineWriteError, AnalyticsEngineWriteOptions, AnalyticsEngineWritePolicy, AnalyticsEngineWriteValidationError, AnalyticsEngineWriteViolation, LayerOptions$16 as LayerOptions, QueryConfigOptions, QueryTag, QueryTagClass, Tag$15 as Tag, TagClass$14 as TagClass, isAnalyticsEngineDataset, layer$13 as layer, make$14 as make, makeClient$10 as makeClient, makeQuery, makeQueryClient, queryConfig, queryFetchLayer, queryFetchLayerConfig, queryLayer, queryLayerConfig, writeLimits };
+}
+declare const writeLimits: {
+  readonly maxBlobs: 20;
+  readonly maxDoubles: 20;
+  readonly maxIndexes: 1;
+  readonly maxBlobBytes: number;
+  readonly maxIndexBytes: 96;
+  readonly maxDataPointsPerInvocation: 250;
+};
+declare const queryColumnSchema: Schema.Struct<{
+  readonly name: Schema.String;
+  readonly type: Schema.String;
+}>;
+declare const queryRowSchema: Schema.$Record<Schema.String, Schema.Unknown>;
+declare const AnalyticsEngineFieldValueSchema: Schema.NullOr<Schema.Union<readonly [Schema.String, Schema.instanceOf<ArrayBuffer, unknown>]>>;
+declare const AnalyticsEngineDataPointSchema: Schema.Struct<{
+  readonly indexes: Schema.optional<Schema.$Array<Schema.NullOr<Schema.Union<readonly [Schema.String, Schema.instanceOf<ArrayBuffer, unknown>]>>>>;
+  readonly doubles: Schema.optional<Schema.$Array<Schema.Finite>>;
+  readonly blobs: Schema.optional<Schema.$Array<Schema.NullOr<Schema.Union<readonly [Schema.String, Schema.instanceOf<ArrayBuffer, unknown>]>>>>;
+}>;
+declare const AnalyticsEngineOperationError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+  readonly _tag: "AnalyticsEngineOperationError";
+} & Readonly<A>;
+/** Error raised when an Analytics Engine operation fails. */
+declare class AnalyticsEngineOperationError extends AnalyticsEngineOperationError_base<{
+  readonly binding: string;
+  readonly operation: string;
+  readonly cause: unknown;
+}> {}
+interface AnalyticsEngineWriteViolation {
+  readonly path: string;
+  readonly message: string;
+  readonly limit?: number;
+  readonly actual?: number;
+}
+declare const AnalyticsEngineWriteValidationError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+  readonly _tag: "AnalyticsEngineWriteValidationError";
+} & Readonly<A>;
+/** Error raised when an Analytics Engine write input violates Cloudflare limits. */
+declare class AnalyticsEngineWriteValidationError extends AnalyticsEngineWriteValidationError_base<{
+  readonly binding: string;
+  readonly operation: string;
+  readonly violations: ReadonlyArray<AnalyticsEngineWriteViolation>;
+  readonly cause?: unknown;
+}> {}
+declare const AnalyticsEngineQueryError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+  readonly _tag: "AnalyticsEngineQueryError";
+} & Readonly<A>;
+/** Error raised when an Analytics Engine SQL API query fails. */
+declare class AnalyticsEngineQueryError extends AnalyticsEngineQueryError_base<{
+  readonly operation: string;
+  readonly accountId: string;
+  readonly message: string;
+  readonly status?: number;
+  readonly body?: string;
+  readonly cause?: unknown;
+}> {}
+/** Typed Analytics Engine dataset binding definition. */
+interface AnalyticsEngineDefinition {
+  /** Binding name as configured in `wrangler.jsonc`. */
+  readonly binding: string;
+}
+type AnalyticsEngineBinding = CloudflareAnalyticsEngineDataset;
+type AnalyticsEngineDataPoint = CloudflareAnalyticsEngineDataPoint;
+type AnalyticsEngineFieldValue = ArrayBuffer | string | null;
+type AnalyticsEngineWriteError = AnalyticsEngineOperationError | AnalyticsEngineWriteValidationError;
+type AnalyticsEngineInvalidWritePolicy = "error" | "drop";
+type AnalyticsEngineQueryColumn = Schema.Schema.Type<typeof queryColumnSchema>;
+type AnalyticsEngineQueryRow = Schema.Schema.Type<typeof queryRowSchema>;
+interface AnalyticsEngineWriteOptions {
+  /**
+   * Controls invalid write behavior. The default is `"error"`, which fails with
+   * `AnalyticsEngineWriteValidationError`. `"drop"` skips invalid points.
+   */
+  readonly onInvalid?: AnalyticsEngineInvalidWritePolicy;
+}
+interface AnalyticsEngineWriteBatchOptions extends AnalyticsEngineWriteOptions {
+  /**
+   * Maximum points per native batch call. Values are clamped to Cloudflare's
+   * per-invocation limit.
+   */
+  readonly batchSize?: number;
+}
+type AnalyticsEngineWritePolicy = AnalyticsEngineWriteBatchOptions;
+interface AnalyticsEngineQueryResult<Row = AnalyticsEngineQueryRow> {
+  readonly meta: ReadonlyArray<AnalyticsEngineQueryColumn>;
+  readonly data: ReadonlyArray<Row>;
+  readonly rows: number;
+}
+interface AnalyticsEngineQueryDefinition {
+  /** Cloudflare account id that owns the Analytics Engine datasets. */
+  readonly accountId: string;
+  /** API token with Account Analytics Read permission. */
+  readonly apiToken: Redacted.Redacted<string>;
+  /** Base Cloudflare API URL. Defaults to `https://api.cloudflare.com/client/v4`. */
+  readonly apiBaseUrl?: string | URL;
+}
+interface AnalyticsEngineQueryOptions {
+  /** Additional request headers. Authorization is always derived from `apiToken`. */
+  readonly headers?: Headers$1.Input;
+}
+interface AnalyticsEngineClient {
+  readonly writeDataPoint: (dataPoint?: AnalyticsEngineDataPoint, options?: AnalyticsEngineWriteOptions) => Effect.Effect<void, AnalyticsEngineWriteError>;
+  readonly write: (dataPoint?: AnalyticsEngineDataPoint, options?: AnalyticsEngineWriteOptions) => Effect.Effect<void, AnalyticsEngineWriteError>;
+  readonly writeDataPoints: (dataPoints: ReadonlyArray<AnalyticsEngineDataPoint>, options?: AnalyticsEngineWriteBatchOptions) => Effect.Effect<void, AnalyticsEngineWriteError>;
+  readonly writeBatch: (dataPoints: ReadonlyArray<AnalyticsEngineDataPoint>, options?: AnalyticsEngineWriteBatchOptions) => Effect.Effect<void, AnalyticsEngineWriteError>;
+  readonly unsafeRaw: Effect.Effect<AnalyticsEngineBinding>;
+  readonly definition: AnalyticsEngineDefinition;
+}
+interface AnalyticsEngineQueryClient {
+  readonly query: (sql: string, options?: AnalyticsEngineQueryOptions) => Effect.Effect<AnalyticsEngineQueryResult, AnalyticsEngineQueryError | Schema.SchemaError>;
+  readonly queryResult: <Row>(row: Schema.Codec<Row, unknown>, sql: string, options?: AnalyticsEngineQueryOptions) => Effect.Effect<AnalyticsEngineQueryResult<Row>, AnalyticsEngineQueryError | Schema.SchemaError>;
+  readonly queryRows: <Row>(row: Schema.Codec<Row, unknown>, sql: string, options?: AnalyticsEngineQueryOptions) => Effect.Effect<ReadonlyArray<Row>, AnalyticsEngineQueryError | Schema.SchemaError>;
+  readonly queryOne: <Row>(row: Schema.Codec<Row, unknown>, sql: string, options?: AnalyticsEngineQueryOptions) => Effect.Effect<Option.Option<Row>, AnalyticsEngineQueryError | Schema.SchemaError>;
+  readonly queryText: (sql: string, options?: AnalyticsEngineQueryOptions) => Effect.Effect<string, AnalyticsEngineQueryError>;
+  readonly raw: (sql: string, options?: AnalyticsEngineQueryOptions) => Effect.Effect<HttpClientResponse.HttpClientResponse, AnalyticsEngineQueryError>;
+  readonly definition: AnalyticsEngineQueryDefinition;
+}
+declare const AnalyticsEngineServiceTypeId: unique symbol;
+declare const AnalyticsEngineQueryServiceTypeId: unique symbol;
+/** Nominal service marker for Analytics Engine services created with {@link make}. */
+interface AnalyticsEngineService<Id extends string> {
+  readonly [AnalyticsEngineServiceTypeId]: {
+    readonly id: Id;
+  };
+}
+/** Nominal service marker for Analytics Engine query services created with {@link makeQuery}. */
+interface AnalyticsEngineQueryService<Id extends string> {
+  readonly [AnalyticsEngineQueryServiceTypeId]: {
+    readonly id: Id;
+  };
+}
+type LayerOptions$16 = {
+  readonly binding: string;
+  readonly write?: AnalyticsEngineWritePolicy;
+};
+type QueryConfigOptions = {
+  readonly accountId?: Config.Config<string>;
+  readonly apiToken?: Config.Config<Redacted.Redacted<string>>;
+  readonly apiBaseUrl?: Config.Config<string>;
+};
+interface TagClass$14<Self, Id extends string> extends Context.ServiceClass<Self, Id, AnalyticsEngineClient> {
+  readonly id: Id;
+  readonly layer: (options: LayerOptions$16) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+}
+interface QueryTagClass<Self, Id extends string> extends Context.ServiceClass<Self, Id, AnalyticsEngineQueryClient> {
+  readonly id: Id;
+  readonly layer: (definition: AnalyticsEngineQueryDefinition) => Layer.Layer<Self, never, HttpClient.HttpClient>;
+  readonly fetchLayer: (definition: AnalyticsEngineQueryDefinition) => Layer.Layer<Self>;
+  readonly layerConfig: (config?: Config.Config<AnalyticsEngineQueryDefinition>) => Layer.Layer<Self, Config.ConfigError, HttpClient.HttpClient>;
+  readonly fetchLayerConfig: (config?: Config.Config<AnalyticsEngineQueryDefinition>) => Layer.Layer<Self, Config.ConfigError>;
+}
+declare const makeQueryClient: (definition: AnalyticsEngineQueryDefinition) => Effect.Effect<AnalyticsEngineQueryClient, never, HttpClient.HttpClient>;
+declare const isAnalyticsEngineDataset: (value: unknown) => value is AnalyticsEngineBinding;
+declare const makeClient$10: (definition: AnalyticsEngineDefinition, defaults?: AnalyticsEngineWritePolicy) => (dataset: AnalyticsEngineBinding) => AnalyticsEngineClient;
+declare const queryConfig: (options?: QueryConfigOptions) => Config.Config<{
+  accountId: string;
+  apiToken: Redacted.Redacted<string>;
+  apiBaseUrl: string;
+}>;
+declare const queryLayer: <Self>(tag: Context.Service<Self, AnalyticsEngineQueryClient>, definition: AnalyticsEngineQueryDefinition) => Layer.Layer<Self, never, HttpClient.HttpClient>;
+declare const queryFetchLayer: <Self>(tag: Context.Service<Self, AnalyticsEngineQueryClient>, definition: AnalyticsEngineQueryDefinition) => Layer.Layer<Self, never, never>;
+declare const queryLayerConfig: <Self>(tag: Context.Service<Self, AnalyticsEngineQueryClient>, config?: Config.Config<AnalyticsEngineQueryDefinition>) => Layer.Layer<Self, Config.ConfigError, HttpClient.HttpClient>;
+declare const queryFetchLayerConfig: <Self>(tag: Context.Service<Self, AnalyticsEngineQueryClient>, config?: Config.Config<AnalyticsEngineQueryDefinition>) => Layer.Layer<Self, Config.ConfigError, never>;
+declare const layer$13: <Self>(tag: Context.Service<Self, AnalyticsEngineClient>, definition: LayerOptions$16) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const make$14: <Id extends string>(id: Id) => TagClass$14<AnalyticsEngineService<Id>, Id>;
+declare const makeQuery: <Id extends string>(id: Id) => QueryTagClass<AnalyticsEngineQueryService<Id>, Id>;
 declare const Tag$15: <Self>() => <Id extends string>(id: Id) => TagClass$14<Self, Id>;
+declare const QueryTag: <Self>() => <Id extends string>(id: Id) => QueryTagClass<Self, Id>;
 declare namespace BrowserRendering_d_exports {
   export { BrowserRenderingBinding, BrowserRenderingBrowserClient, BrowserRenderingBrowserLike, BrowserRenderingClient, BrowserRenderingConnect, BrowserRenderingDefinition, BrowserRenderingLaunch, BrowserRenderingOperationError, BrowserRenderingPageClient, BrowserRenderingPageLike, BrowserRenderingService, LayerOptions$15 as LayerOptions, Tag$14 as Tag, TagClass$13 as TagClass, isBrowserRenderingBinding, layer$12 as layer, make$13 as make, makeClient$9 as makeClient };
 }
@@ -683,7 +854,7 @@ declare const Service$1: <Self>() => <Id extends string>(id: Id, definition: D1D
   sqlLayer: (options?: D1SqlLayerOptions) => Layer.Layer<D1Client.D1Client | _$effect_unstable_sql_SqlClient0.SqlClient, BindingNotFoundError | BindingValidationError | _$effect_Config0.ConfigError, WorkerEnvironment | Exclude<Exclude<Self, _$effect_Scope0.Scope>, Self>>;
 };
 declare namespace Rpc_d_exports {
-  export { DisposableValue, MethodArgs, MethodKey, MethodReturn, Provider, Result, RpcStub, RpcTarget, Serializable, Stub, Stubable, Stubify, dispose, isDisposable, resolve, scoped };
+  export { DisposableValue, MethodArgs, MethodKey, MethodReturn, Provider, Result$1 as Result, RpcStub, RpcTarget, Serializable, Stub, Stubable, Stubify, dispose, isDisposable, resolve, scoped };
 }
 type Stubable = Rpc.Stubable;
 type Stub<T extends Stubable> = Rpc.Stub<T>;
@@ -695,7 +866,7 @@ type Stubify<T> = T extends Stubable ? Stub<T> : T extends Map<infer Key, infer
 } ? { [Key in keyof T]: Stubify<T[Key]> } : T;
 type MaybeProvider<T> = T extends object ? Provider<T> : unknown;
 type MaybeDisposable<T> = T extends object ? Disposable : unknown;
-type Result<T> = T extends Stubable ? Promise<Stub<T>> & Provider<T> : T extends Serializable<T> ? Promise<Stubify<T> & MaybeDisposable<T>> & MaybeProvider<T> : never;
+type Result$1<T> = T extends Stubable ? Promise<Stub<T>> & Provider<T> : T extends Serializable<T> ? Promise<Stubify<T> & MaybeDisposable<T>> & MaybeProvider<T> : never;
 type MethodKey<Api> = { [Key in keyof Api]-?: Key extends string ? Api[Key] extends ((...args: Array<any>) => unknown) ? Key : never : never }[keyof Api];
 type MethodArgs<Api, Method extends keyof Api> = Api[Method] extends ((...args: infer Args) => unknown) ? Args : never;
 type MethodReturn<Api, Method extends keyof Api> = Api[Method] extends ((...args: Array<any>) => infer Return) ? Return : never;
@@ -1024,7 +1195,7 @@ type AnyArgs = Array<any>;
 type AsyncMethodKey<Api> = { [Key in keyof Api]-?: Key extends string ? Api[Key] extends ((...args: AnyArgs) => Promise<unknown>) ? Key : never : never }[keyof Api];
 type AsyncMethodArgs<Api, Method extends keyof Api> = Api[Method] extends ((...args: infer Args) => Promise<unknown>) ? Args : never;
 type AsyncMethodSuccess<Api, Method extends keyof Api> = Api[Method] extends ((...args: AnyArgs) => Promise<infer A>) ? A : never;
-type AsyncMethodCloudflareReturn<Api, Method extends keyof Api> = Result<AsyncMethodSuccess<Api, Method>>;
+type AsyncMethodCloudflareReturn<Api, Method extends keyof Api> = Result$1<AsyncMethodSuccess<Api, Method>>;
 declare namespace ServiceBinding_d_exports {
   export { Service, ServiceBindingClient, ServiceBindingDefinition, ServiceBindingEffectClient, ServiceBindingFetchError, ServiceBindingRpcError, ServiceBindingStaticClient, ServiceFetcher, isServiceBindingClient, layer$9 as layer, makeClient$7 as makeClient, makeDirectMethods$1 as makeDirectMethods };
 }
@@ -1207,7 +1378,7 @@ declare const Service: <Self, Api extends object = never>() => <Id extends strin
   readonly [TypeId$1]: typeof TypeId$1;
   readonly definition: ServiceBindingDefinition<Definition>;
   readonly fetch: (input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<Response, ServiceBindingFetchError, Self>;
-  readonly rpc: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition>>>(method: Method, ...args: ServiceMethodArgs<ApiOrDefinition<Api, Definition>, Method>) => Effect.Effect<Result<AsyncMethodSuccess<ApiOrDefinition<Api, Definition>, Method>>, ServiceBindingRpcError, Self>;
+  readonly rpc: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition>>>(method: Method, ...args: ServiceMethodArgs<ApiOrDefinition<Api, Definition>, Method>) => Effect.Effect<Result$1<AsyncMethodSuccess<ApiOrDefinition<Api, Definition>, Method>>, ServiceBindingRpcError, Self>;
   readonly call: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition>>>(method: Method, ...args: ServiceMethodArgs<ApiOrDefinition<Api, Definition>, Method>) => Effect.Effect<AsyncMethodSuccess<ApiOrDefinition<Api, Definition>, Method>, ServiceBindingRpcError, Self>;
   readonly scopedCall: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition>>>(method: Method, ...args: ServiceMethodArgs<ApiOrDefinition<Api, Definition>, Method>) => Effect.Effect<Awaited<AsyncMethodSuccess<ApiOrDefinition<Api, Definition>, Method>>, unknown, Self | Scope.Scope>;
 };
@@ -1309,7 +1480,7 @@ declare const method$2: {
   <Success extends ServiceFreeSchema$2>(definition: {
     readonly success: Success;
   }): Method$3<readonly [], Success>;
-  <const Args extends readonly ServiceFreeSchema$2[], Success extends ServiceFreeSchema$2>(definition: {
+  <const Args extends ReadonlyArray<ServiceFreeSchema$2>, Success extends ServiceFreeSchema$2>(definition: {
     readonly args: Args;
     readonly success: Success;
   }): Method$3<Args, Success>;
@@ -2638,4 +2809,4 @@ declare const layer: <Self>(tag: Context.Service<Self, VectorizeClient>, definit
 declare const make: <Id extends string>(id: Id) => TagClass<VectorizeService<Id>, Id>;
 declare const Tag$1: <Self>() => <Id extends string>(id: Id) => TagClass<Self, Id>;
 //#endregion
-export { AiGateway_d_exports as AiGateway, Binding_d_exports as Binding, BrowserRendering_d_exports as BrowserRendering, CloudflareOtlp_d_exports as CloudflareOtlp, D1_d_exports as D1, DurableObject_d_exports as DurableObject, DurableObjectAlarm_d_exports as DurableObjectAlarm, DurableObjectDefinition_d_exports as DurableObjectDefinition, DurableObjectNamespace_d_exports as DurableObjectNamespace, DurableObjectRpcWebSocket_d_exports as DurableObjectRpcWebSocket, DurableObjectSqlite_d_exports as DurableObjectSqlite, DurableObjectState_d_exports as DurableObjectState, DurableObjectStorage_d_exports as DurableObjectStorage, DurableObjectWebSocket_d_exports as DurableObjectWebSocket, Email_d_exports as Email, Hyperdrive_d_exports as Hyperdrive, Images_d_exports as Images, Kv_d_exports as Kv, Queue_d_exports as Queue, QueueBinding_d_exports as QueueBinding, QueueDefinition_d_exports as QueueDefinition, R2_d_exports as R2, Rpc_d_exports as Rpc, RpcDefinition_d_exports as RpcDefinition, ServiceBinding_d_exports as ServiceBinding, Vectorize_d_exports as Vectorize, Worker_d_exports as Worker, WorkerConfig, WorkerDefinition_d_exports as WorkerDefinition, type WorkerEnv, WorkerEnvironment, WorkersAi_d_exports as WorkersAi, Workflow_d_exports as Workflow, WorkflowBinding_d_exports as WorkflowBinding, WorkflowDefinition_d_exports as WorkflowDefinition };
+export { AiGateway_d_exports as AiGateway, AnalyticsEngine_d_exports as AnalyticsEngine, Binding_d_exports as Binding, BrowserRendering_d_exports as BrowserRendering, CloudflareOtlp_d_exports as CloudflareOtlp, D1_d_exports as D1, DurableObject_d_exports as DurableObject, DurableObjectAlarm_d_exports as DurableObjectAlarm, DurableObjectDefinition_d_exports as DurableObjectDefinition, DurableObjectNamespace_d_exports as DurableObjectNamespace, DurableObjectRpcWebSocket_d_exports as DurableObjectRpcWebSocket, DurableObjectSqlite_d_exports as DurableObjectSqlite, DurableObjectState_d_exports as DurableObjectState, DurableObjectStorage_d_exports as DurableObjectStorage, DurableObjectWebSocket_d_exports as DurableObjectWebSocket, Email_d_exports as Email, Hyperdrive_d_exports as Hyperdrive, Images_d_exports as Images, Kv_d_exports as Kv, Queue_d_exports as Queue, QueueBinding_d_exports as QueueBinding, QueueDefinition_d_exports as QueueDefinition, R2_d_exports as R2, Rpc_d_exports as Rpc, RpcDefinition_d_exports as RpcDefinition, ServiceBinding_d_exports as ServiceBinding, Vectorize_d_exports as Vectorize, Worker_d_exports as Worker, WorkerConfig, WorkerDefinition_d_exports as WorkerDefinition, type WorkerEnv, WorkerEnvironment, WorkersAi_d_exports as WorkersAi, Workflow_d_exports as Workflow, WorkflowBinding_d_exports as WorkflowBinding, WorkflowDefinition_d_exports as WorkflowDefinition };