effect-cf 0.20.1 → 0.22.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-cf",
-  "version": "0.20.1",
+  "version": "0.22.0",
   "description": "Effect-native primitives for Cloudflare Workers and bindings.",
   "license": "MIT",
   "repository": {
@@ -14,6 +14,7 @@
     "src"
   ],
   "type": "module",
+  "sideEffects": [],
   "types": "./dist/index.d.mts",
   "exports": {
     ".": {
@@ -52,12 +53,16 @@
     "vitest": "catalog:"
   },
   "peerDependencies": {
-    "@effect/sql-d1": "^4.0.0-beta.105",
-    "@effect/sql-pg": "^4.0.0-beta.105",
-    "@effect/sql-sqlite-do": "^4.0.0-beta.105",
-    "effect": "^4.0.0-beta.105"
+    "@cloudflare/workers-types": "^4.20260611.1",
+    "@effect/sql-d1": "4.0.0-beta.105",
+    "@effect/sql-pg": "4.0.0-beta.105",
+    "@effect/sql-sqlite-do": "4.0.0-beta.105",
+    "effect": "4.0.0-beta.105"
   },
   "peerDependenciesMeta": {
+    "@cloudflare/workers-types": {
+      "optional": true
+    },
     "@effect/sql-pg": {
       "optional": true
     }

package/src/AiGateway.ts

@@ -4,6 +4,7 @@ import type { AiGateway as CloudflareAiGateway } from "@cloudflare/workers-types
 import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";
 import { isWorkersAiBinding, type WorkersAiBinding } from "./WorkersAi";
+import * as ErrorMessage from "./internal/ErrorMessage";
 
 const expectedAiGatewayBinding = "Workers AI binding with gateway()";
 
@@ -12,7 +13,11 @@ export class AiGatewayOperationError extends Data.TaggedError("AiGatewayOperatio
   readonly binding: string;
   readonly operation: string;
   readonly cause: unknown;
-}> {}
+}> {
+  override get message(): string {
+    return `AI Gateway ${this.operation} failed for binding "${this.binding}": ${ErrorMessage.causeMessage(this.cause)}`;
+  }
+}
 
 /** Typed AI Gateway client definition. */
 export interface AiGatewayDefinition {
@@ -53,7 +58,7 @@ export interface AiGatewayClient {
     data: AiGatewayPatchLog,
   ) => Effect.Effect<void, AiGatewayOperationError>;
   readonly getLog: (logId: string) => Effect.Effect<AiGatewayLog, AiGatewayOperationError>;
-  readonly unsafeRaw: Effect.Effect<AiGatewayBinding, AiGatewayOperationError>;
+  readonly rawUnsafe: Effect.Effect<AiGatewayBinding, AiGatewayOperationError>;
   readonly definition: AiGatewayDefinition;
 }
 
@@ -93,13 +98,19 @@ const aiGatewayError = (binding: string, operation: string, cause: unknown) =>
 const tryAiGatewayPromise = <A>(
   binding: string,
   operation: string,
-  evaluate: () => Promise<A>,
+  evaluate: (signal: AbortSignal) => Promise<A>,
 ): Effect.Effect<A, AiGatewayOperationError> =>
   Effect.tryPromise({
     try: evaluate,
     catch: (cause) => aiGatewayError(binding, operation, cause),
   });
 
+const mergeAbortSignals = (
+  userSignal: AbortSignal | null | undefined,
+  signal: AbortSignal,
+): AbortSignal =>
+  userSignal === null || userSignal === undefined ? signal : AbortSignal.any([userSignal, signal]);
+
 const tryAiGatewaySync = <A>(
   binding: string,
   operation: string,
@@ -126,32 +137,42 @@ export const isAiGatewayBinding = (value: unknown): value is WorkersAiBinding =>
 export const makeClient = (definition: AiGatewayDefinition, gateway: AiGatewayBinding) =>
   ({
     definition,
-    run: (data, options) =>
-      tryAiGatewayPromise(definition.binding, "run", () =>
-        gateway.run(
-          (Array.isArray(data) ? [...data] : data) as
-            | AiGatewayUniversalRequest
-            | Array<AiGatewayUniversalRequest>,
-          options,
+    run: Effect.fn("AiGateway.run")(
+      (
+        data: AiGatewayUniversalRequest | ReadonlyArray<AiGatewayUniversalRequest>,
+        options?: AiGatewayRunOptions,
+      ) =>
+        tryAiGatewayPromise(definition.binding, "run", () =>
+          gateway.run(
+            (Array.isArray(data) ? [...data] : data) as
+              | AiGatewayUniversalRequest
+              | Array<AiGatewayUniversalRequest>,
+            options,
+          ),
         ),
-      ),
-    getUrl: (provider) =>
+    ),
+    getUrl: Effect.fn("AiGateway.getUrl")((provider?: AiGatewayProvider) =>
       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) =>
+    ),
+    fetch: Effect.fn("AiGateway.fetch")(function* (options: AiGatewayFetchOptions) {
+      const baseUrl = yield* tryAiGatewayPromise(definition.binding, "getUrl", () =>
+        gateway.getUrl(options.provider),
+      );
+
+      return yield* tryAiGatewayPromise(definition.binding, "fetch", (signal) =>
+        fetch(providerUrl(baseUrl, options.path).href, {
+          ...options.init,
+          signal: mergeAbortSignals(options.init?.signal, signal),
+        }),
+      );
+    }),
+    patchLog: Effect.fn("AiGateway.patchLog")((logId: string, data: AiGatewayPatchLog) =>
       tryAiGatewayPromise(definition.binding, "patchLog", () => gateway.patchLog(logId, data)),
-    getLog: (logId) =>
+    ),
+    getLog: Effect.fn("AiGateway.getLog")((logId: string) =>
       tryAiGatewayPromise(definition.binding, "getLog", () => gateway.getLog(logId)),
-    unsafeRaw: Effect.succeed(gateway),
+    ),
+    rawUnsafe: Effect.succeed(gateway),
   }) satisfies AiGatewayClient;
 
 export const makeClientFromAi = (
@@ -174,7 +195,7 @@ export const makeClientFromAi = (
     patchLog: (logId, data) =>
       withGateway((raw) => makeClient(definition, raw).patchLog(logId, data)),
     getLog: (logId) => withGateway((raw) => makeClient(definition, raw).getLog(logId)),
-    unsafeRaw: gateway,
+    rawUnsafe: gateway,
   };
 };
 
@@ -214,45 +235,59 @@ export const makeHttpClient = (
 
   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()),
+    run: Effect.fn("AiGateway.run")(
+      (
+        data: AiGatewayUniversalRequest | ReadonlyArray<AiGatewayUniversalRequest>,
+        options?: AiGatewayRunOptions,
+      ) =>
+        tryAiGatewayPromise(binding, "run", (signal) =>
+          request(gatewayUrl(definition), {
+            method: "POST",
+            body: JSON.stringify(data),
+            headers: new Headers({
+              "content-type": "application/json",
+              ...Object.fromEntries(new Headers(extraHeaders(options)).entries()),
+            }),
+            signal: mergeAbortSignals(options?.signal, signal),
           }),
-          signal: options?.signal,
-        }),
-      ),
+        ),
+    ),
     getUrl,
-    fetch: (options) =>
+    fetch: Effect.fn("AiGateway.fetch")((options: AiGatewayFetchOptions) =>
       getUrl(options.provider).pipe(
         Effect.flatMap((baseUrl) =>
-          tryAiGatewayPromise(binding, "fetch", () =>
-            request(providerUrl(baseUrl, options.path).href, options.init),
+          tryAiGatewayPromise(binding, "fetch", (signal) =>
+            request(providerUrl(baseUrl, options.path).href, {
+              ...options.init,
+              signal: mergeAbortSignals(options.init?.signal, signal),
+            }),
           ),
         ),
       ),
-    patchLog: (logId, data) =>
-      tryAiGatewayPromise(binding, "patchLog", () =>
+    ),
+    patchLog: Effect.fn("AiGateway.patchLog")((logId: string, data: AiGatewayPatchLog) =>
+      tryAiGatewayPromise(binding, "patchLog", (signal) =>
         request(providerUrl(gatewayUrl(definition), `logs/${logId}`).href, {
           method: "PATCH",
           body: JSON.stringify(data),
           headers: { "content-type": "application/json" },
+          signal,
         }).then(() => undefined),
       ),
-    getLog: (logId) =>
-      tryAiGatewayPromise(binding, "getLog", async () => {
-        const response = await request(providerUrl(gatewayUrl(definition), `logs/${logId}`).href);
+    ),
+    getLog: Effect.fn("AiGateway.getLog")((logId: string) =>
+      tryAiGatewayPromise(binding, "getLog", async (signal) => {
+        const response = await request(providerUrl(gatewayUrl(definition), `logs/${logId}`).href, {
+          signal,
+        });
 
         return (await response.json()) as AiGatewayLog;
       }),
-    unsafeRaw: Effect.fail(
+    ),
+    rawUnsafe: Effect.fail(
       aiGatewayError(
         binding,
-        "unsafeRaw",
+        "rawUnsafe",
         new TypeError("HTTP AI Gateway clients have no raw binding"),
       ),
     ),

package/src/AnalyticsEngine.ts

@@ -23,6 +23,7 @@ import {
 
 import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";
+import * as ErrorMessage from "./internal/ErrorMessage";
 
 const expectedAnalyticsEngineDataset = "Analytics Engine dataset binding with writeDataPoint()";
 const defaultQueryApiBaseUrl = "https://api.cloudflare.com/client/v4";
@@ -70,7 +71,11 @@ export class AnalyticsEngineOperationError extends Data.TaggedError(
   readonly binding: string;
   readonly operation: string;
   readonly cause: unknown;
-}> {}
+}> {
+  override get message(): string {
+    return `Analytics Engine ${this.operation} failed for binding "${this.binding}": ${ErrorMessage.causeMessage(this.cause)}`;
+  }
+}
 
 export interface AnalyticsEngineWriteViolation {
   readonly path: string;
@@ -87,7 +92,11 @@ export class AnalyticsEngineWriteValidationError extends Data.TaggedError(
   readonly operation: string;
   readonly violations: ReadonlyArray<AnalyticsEngineWriteViolation>;
   readonly cause?: unknown;
-}> {}
+}> {
+  override get message(): string {
+    return `Analytics Engine ${this.operation} for binding "${this.binding}" failed validation: ${ErrorMessage.violationsMessage(this.violations)}`;
+  }
+}
 
 /** Error raised when an Analytics Engine SQL API query fails. */
 export class AnalyticsEngineQueryError extends Data.TaggedError("AnalyticsEngineQueryError")<{
@@ -170,7 +179,7 @@ export interface AnalyticsEngineClient {
     dataPoints: ReadonlyArray<AnalyticsEngineDataPoint>,
     options?: AnalyticsEngineWriteBatchOptions,
   ) => Effect.Effect<void, AnalyticsEngineWriteError>;
-  readonly unsafeRaw: Effect.Effect<AnalyticsEngineBinding>;
+  readonly rawUnsafe: Effect.Effect<AnalyticsEngineBinding>;
   readonly definition: AnalyticsEngineDefinition;
 }
 
@@ -257,11 +266,11 @@ export interface QueryTagClass<Self, Id extends string> extends Context.ServiceC
   readonly layer: (
     definition: AnalyticsEngineQueryDefinition,
   ) => Layer.Layer<Self, never, HttpClient.HttpClient>;
-  readonly fetchLayer: (definition: AnalyticsEngineQueryDefinition) => Layer.Layer<Self>;
+  readonly layerFetch: (definition: AnalyticsEngineQueryDefinition) => Layer.Layer<Self>;
   readonly layerConfig: (
     config?: Config.Config<AnalyticsEngineQueryDefinition>,
   ) => Layer.Layer<Self, Config.ConfigError, HttpClient.HttpClient>;
-  readonly fetchLayerConfig: (
+  readonly layerFetchConfig: (
     config?: Config.Config<AnalyticsEngineQueryDefinition>,
   ) => Layer.Layer<Self, Config.ConfigError>;
 }
@@ -633,26 +642,30 @@ const makeQueryClientWith = (
   definition: AnalyticsEngineQueryDefinition,
   httpClient: HttpClient.HttpClient,
 ): AnalyticsEngineQueryClient => {
-  const raw = (sql: string, options?: AnalyticsEngineQueryOptions) =>
-    executeQueryRequest(definition, httpClient, sql, options);
-  const query = (sql: string, options?: AnalyticsEngineQueryOptions) =>
-    Effect.gen(function* () {
-      const response = yield* raw(sql, options);
-      const json = yield* response.json.pipe(
-        Effect.catch((cause) =>
-          Effect.fail(
-            analyticsEngineQueryError(
-              definition,
-              "json",
-              "Failed to read Analytics Engine SQL API JSON response body",
-              { cause },
-            ),
+  const raw = Effect.fn("AnalyticsEngine.raw")(
+    (sql: string, options?: AnalyticsEngineQueryOptions) =>
+      executeQueryRequest(definition, httpClient, sql, options),
+  );
+  const query = Effect.fn("AnalyticsEngine.query")(function* (
+    sql: string,
+    options?: AnalyticsEngineQueryOptions,
+  ) {
+    const response = yield* raw(sql, options);
+    const json = yield* response.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);
-    });
+    return yield* decodeQueryResponse(json);
+  });
   const queryResult = <Row>(
     row: S.Codec<Row, unknown>,
     sql: string,
@@ -672,7 +685,7 @@ const makeQueryClientWith = (
         data,
         rows: result.rows,
       } satisfies AnalyticsEngineQueryResult<Row>;
-    });
+    }).pipe(Effect.withSpan("AnalyticsEngine.queryResult"));
 
   return {
     definition,
@@ -680,17 +693,23 @@ const makeQueryClientWith = (
     query,
     queryResult,
     queryRows: (row, sql, options) =>
-      queryResult(row, sql, options).pipe(Effect.map((result) => result.data)),
+      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] === undefined ? Option.none() : Option.some(result.data[0]),
         ),
+        Effect.withSpan("AnalyticsEngine.queryOne"),
       ),
-    queryText: (sql, options) =>
-      raw(sql, options).pipe(
-        Effect.flatMap((response) => responseText(definition, response, "text")),
-      ),
+    queryText: Effect.fn("AnalyticsEngine.queryText")(
+      (sql: string, options?: AnalyticsEngineQueryOptions) =>
+        raw(sql, options).pipe(
+          Effect.flatMap((response) => responseText(definition, response, "text")),
+        ),
+    ),
   };
 };
 
@@ -708,7 +727,7 @@ export const isAnalyticsEngineDataset = (value: unknown): value is AnalyticsEngi
 export const makeClient =
   (definition: AnalyticsEngineDefinition, defaults?: AnalyticsEngineWritePolicy) =>
   (dataset: AnalyticsEngineBinding): AnalyticsEngineClient => {
-    const writeDataPoint = (
+    const writeDataPoint = Effect.fn("AnalyticsEngine.writeDataPoint")((
       dataPoint?: AnalyticsEngineDataPoint,
       options?: AnalyticsEngineWriteOptions,
     ) => {
@@ -724,31 +743,28 @@ export const makeClient =
             ),
         }),
       );
-    };
+    });
 
-    const writeDataPoints = (
+    const writeDataPoints = Effect.fn("AnalyticsEngine.writeDataPoints")(function* (
       dataPoints: ReadonlyArray<AnalyticsEngineDataPoint>,
       options?: AnalyticsEngineWriteBatchOptions,
-    ) => {
+    ) {
       const policy = resolveWritePolicy(defaults, options);
+      const validPoints = yield* validateDataPoints(
+        definition.binding,
+        "writeDataPoints",
+        dataPoints,
+        policy,
+      );
 
-      return Effect.gen(function* () {
-        const validPoints = yield* validateDataPoints(
-          definition.binding,
-          "writeDataPoints",
-          dataPoints,
-          policy,
-        );
-
-        yield* writeChunks(
-          definition.binding,
-          "writeDataPoints",
-          dataset,
-          validPoints,
-          policy.batchSize,
-        );
-      });
-    };
+      yield* writeChunks(
+        definition.binding,
+        "writeDataPoints",
+        dataset,
+        validPoints,
+        policy.batchSize,
+      );
+    });
 
     return {
       definition,
@@ -756,7 +772,7 @@ export const makeClient =
       write: writeDataPoint,
       writeDataPoints,
       writeBatch: writeDataPoints,
-      unsafeRaw: Effect.succeed(dataset),
+      rawUnsafe: Effect.succeed(dataset),
     };
   };
 
@@ -774,7 +790,7 @@ export const queryLayer = <Self>(
   definition: AnalyticsEngineQueryDefinition,
 ) => Layer.effect(tag, makeQueryClient(definition));
 
-export const queryFetchLayer = <Self>(
+export const layerFetch = <Self>(
   tag: Context.Service<Self, AnalyticsEngineQueryClient>,
   definition: AnalyticsEngineQueryDefinition,
 ) => queryLayer(tag, definition).pipe(Layer.provide(FetchHttpClient.layer));
@@ -792,7 +808,7 @@ export const queryLayerConfig = <Self>(
     }),
   );
 
-export const queryFetchLayerConfig = <Self>(
+export const layerFetchConfig = <Self>(
   tag: Context.Service<Self, AnalyticsEngineQueryClient>,
   config: Config.Config<AnalyticsEngineQueryDefinition> = queryConfig(),
 ) => queryLayerConfig(tag, config).pipe(Layer.provide(FetchHttpClient.layer));
@@ -834,18 +850,18 @@ export const QueryTag =
   <Id extends string>(id: Id) => {
     const tag = Context.Service<Self, AnalyticsEngineQueryClient>()(id);
     const makeLayer = (definition: AnalyticsEngineQueryDefinition) => queryLayer(tag, definition);
-    const makeFetchLayer = (definition: AnalyticsEngineQueryDefinition) =>
-      queryFetchLayer(tag, definition);
+    const makeLayerFetch = (definition: AnalyticsEngineQueryDefinition) =>
+      layerFetch(tag, definition);
     const makeLayerConfig = (config?: Config.Config<AnalyticsEngineQueryDefinition>) =>
       queryLayerConfig(tag, config);
-    const makeFetchLayerConfig = (config?: Config.Config<AnalyticsEngineQueryDefinition>) =>
-      queryFetchLayerConfig(tag, config);
+    const makeLayerFetchConfig = (config?: Config.Config<AnalyticsEngineQueryDefinition>) =>
+      layerFetchConfig(tag, config);
 
     return Object.assign(tag, {
       id,
       layer: makeLayer,
-      fetchLayer: makeFetchLayer,
+      layerFetch: makeLayerFetch,
       layerConfig: makeLayerConfig,
-      fetchLayerConfig: makeFetchLayerConfig,
+      layerFetchConfig: makeLayerFetchConfig,
     }) as QueryTagClass<Self, Id>;
   };

package/src/Binding.ts

@@ -3,7 +3,10 @@ import { Context, Data, Effect, Layer } from "effect";
 import { WorkerEnvironment, type WorkerEnv } from "./Environment";
 
 /** Internal type id marker used by binding helper services. */
-export const TypeId = "effect-cf/Binding" as const;
+export const TypeId = "~effect-cf/Binding" as const;
+
+/** Internal type id marker used by binding helper services. */
+export type TypeId = typeof TypeId;
 
 /** Error raised when a configured binding does not exist on `env`. */
 export class BindingNotFoundError extends Data.TaggedError("BindingNotFoundError")<{
@@ -161,13 +164,17 @@ const getBinding = <Resource>(
 
 /**
  * Creates a Context tag + layer for reading and validating a Cloudflare binding.
+ *
+ * The Context key is namespaced as `effect-cf/Binding/<id>`; `id` stays the
+ * bare user-supplied identifier.
  */
 export interface BindingService<Self, Id extends string, Service> extends Context.ServiceClass<
   Self,
-  Id,
+  `effect-cf/Binding/${Id}`,
   Service
 > {
-  readonly [TypeId]: typeof TypeId;
+  readonly [TypeId]: TypeId;
+  readonly id: Id;
   readonly binding: string;
   readonly layer: Layer.Layer<
     Self,
@@ -176,12 +183,17 @@ export interface BindingService<Self, Id extends string, Service> extends Contex
   >;
 }
 
-export const layer = <Self, Resource, Service = Resource>(
+/**
+ * The overloads on {@link layer} and {@link Service} guarantee that
+ * `Service = Resource` whenever `wrap` is absent, making the fallback cast
+ * safe.
+ */
+const makeBindingLayer = <Self, Resource, Service>(
   tag: Context.Service<Self, Service>,
   binding: string,
   isResource: (value: unknown) => value is Resource,
-  wrap?: (resource: Resource) => Service,
-  options?: ValidationOptions,
+  wrap: ((resource: Resource) => Service) | undefined,
+  options: ValidationOptions | undefined,
 ): Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment> =>
   Layer.effect(
     tag,
@@ -193,21 +205,62 @@ export const layer = <Self, Resource, Service = Resource>(
     }),
   );
 
-export const Service =
-  <Self>() =>
-  <Id extends string, Resource, Service = Resource>(
+export function layer<Self, Resource>(
+  tag: Context.Service<Self, Resource>,
+  binding: string,
+  isResource: (value: unknown) => value is Resource,
+  wrap?: undefined,
+  options?: ValidationOptions,
+): Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+export function layer<Self, Resource, Service>(
+  tag: Context.Service<Self, Service>,
+  binding: string,
+  isResource: (value: unknown) => value is Resource,
+  wrap: (resource: Resource) => Service,
+  options?: ValidationOptions,
+): Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+export function layer<Self, Resource, Service = Resource>(
+  tag: Context.Service<Self, Service>,
+  binding: string,
+  isResource: (value: unknown) => value is Resource,
+  wrap?: (resource: Resource) => Service,
+  options?: ValidationOptions,
+): Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment> {
+  return makeBindingLayer(tag, binding, isResource, wrap, options);
+}
+
+export const Service = <Self>() => {
+  function makeService<Id extends string, Resource>(
+    id: Id,
+    binding: string,
+    isResource: (value: unknown) => value is Resource,
+    wrap?: undefined,
+    options?: ValidationOptions,
+  ): BindingService<Self, Id, Resource>;
+  function makeService<Id extends string, Resource, Service>(
+    id: Id,
+    binding: string,
+    isResource: (value: unknown) => value is Resource,
+    wrap: (resource: Resource) => Service,
+    options?: ValidationOptions,
+  ): BindingService<Self, Id, Service>;
+  function makeService<Id extends string, Resource, Service = Resource>(
     id: Id,
     binding: string,
     isResource: (value: unknown) => value is Resource,
     wrap?: (resource: Resource) => Service,
     options?: ValidationOptions,
-  ): BindingService<Self, Id, Service> => {
-    const tag = Context.Service<Self, Service>()(id);
-    const serviceLayer = layer(tag, binding, isResource, wrap, options);
+  ): BindingService<Self, Id, Service> {
+    const tag = Context.Service<Self, Service>()(`effect-cf/Binding/${id}` as const);
+    const serviceLayer = makeBindingLayer(tag, binding, isResource, wrap, options);
 
     return Object.assign(tag, {
       [TypeId]: TypeId,
+      id,
       binding,
       layer: serviceLayer,
     }) as BindingService<Self, Id, Service>;
-  };
+  }
+
+  return makeService;
+};