effect-cf 0.33.0 → 0.35.0

package/src/DurableObjectStorage.ts

@@ -1,11 +1,22 @@
-import { Clock, Data, Duration, Effect, Exit, Option, Predicate, Schema as S } from "effect";
+import {
+  Cause,
+  Clock,
+  Data,
+  Duration,
+  Effect,
+  Exit,
+  Fiber,
+  Option,
+  Predicate,
+  Result,
+  Schema as S,
+} from "effect";
 
 import * as ErrorMessage from "./internal/ErrorMessage";
+import { runNativeCallback } from "./internal/NativeCallback";
 
-/** Supported primitive value types for Durable Object SQL APIs. */
 export type SqlStorageValue = globalThis.SqlStorageValue;
 
-/** Error type used when a storage operation throws or rejects. */
 export class StorageOperationError extends Data.TaggedError("StorageOperationError")<{
   readonly operation: string;
   readonly cause: unknown;
@@ -17,9 +28,6 @@ export class StorageOperationError extends Data.TaggedError("StorageOperationErr
 
 type StorageEffect<A> = Effect.Effect<A, StorageOperationError>;
 
-/**
- * Effect wrapper for Cloudflare SQL cursor operations.
- */
 export interface SqlCursor<T extends Record<string, SqlStorageValue>> {
   next(): StorageEffect<{ done?: false; value: T } | { done: true; value?: never }>;
   toArray(): StorageEffect<Array<T>>;
@@ -30,11 +38,7 @@ export interface SqlCursor<T extends Record<string, SqlStorageValue>> {
   readonly rowsWritten: StorageEffect<number>;
 }
 
-/**
- * Effect wrapper for Durable Object SQLite APIs.
- */
 export interface SqlStorage {
-  /** Executes a SQL statement and returns a typed cursor. */
   exec<T extends Record<string, SqlStorageValue>>(
     query: string,
     ...bindings: Array<SqlStorageValue>
@@ -42,9 +46,6 @@ export interface SqlStorage {
   readonly databaseSize: number;
 }
 
-/**
- * Schema pair used by `SyncKvStorage.schema(...)`.
- */
 export interface SyncKvDefinition<Key, Value, EncodedValue> {
   readonly key: S.Codec<Key, string>;
   readonly value: S.Codec<Value, EncodedValue>;
@@ -60,9 +61,6 @@ export interface SchemaBackedSyncKvStorage<Key, Value> {
   list(options?: globalThis.SyncKvListOptions): Effect.Effect<Array<[Key, Value]>, unknown>;
 }
 
-/**
- * Effect wrapper for synchronous KV attached to Durable Object SQLite storage.
- */
 export interface SyncKvStorage {
   get<T = unknown>(key: string): StorageEffect<T | undefined>;
   put<T>(key: string, value: T): StorageEffect<void>;
@@ -99,7 +97,6 @@ export interface DurableObjectTransaction {
     scheduledTime: number | Date,
     options?: globalThis.DurableObjectSetAlarmOptions,
   ): StorageEffect<void>;
-  /** Schedules the alarm after a delay measured by the Effect clock. */
   setAlarmAfter(
     delay: Duration.Input,
     options?: globalThis.DurableObjectSetAlarmOptions,
@@ -107,19 +104,6 @@ export interface DurableObjectTransaction {
   deleteAlarm(options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
 }
 
-/**
- * Effect wrapper around Cloudflare Durable Object storage.
- *
- * @example
- * ```ts
- * const program = Effect.gen(function* () {
- *   const state = yield* DurableObjectState;
- *   yield* state.storage.put("counter", 1);
- *   const value = yield* state.storage.get<number>("counter");
- *   return value;
- * });
- * ```
- */
 export interface DurableObjectStorage {
   get<T = unknown>(
     key: string,
@@ -137,7 +121,6 @@ export interface DurableObjectStorage {
     scheduledTime: number | Date,
     options?: globalThis.DurableObjectSetAlarmOptions,
   ): StorageEffect<void>;
-  /** Schedules the alarm after a delay measured by the Effect clock. */
   setAlarmAfter(
     delay: Duration.Input,
     options?: globalThis.DurableObjectSetAlarmOptions,
@@ -161,9 +144,9 @@ export interface DurableObjectStorage {
   ): Effect.Effect<A, E | StorageOperationError, R>;
   /** Flushes pending writes to disk. */
   sync(): StorageEffect<void>;
-  /** SQLite-backed Durable Object storage point-in-time recovery API only. */
+  /** Requires SQLite-backed Durable Object storage. */
   getCurrentBookmark(): StorageEffect<string>;
-  /** SQLite-backed Durable Object storage point-in-time recovery API only. */
+  /** Requires SQLite-backed Durable Object storage. */
   onNextSessionRestoreBookmark(bookmark: string): StorageEffect<string>;
   readonly sql: SqlStorage;
   readonly kv: SyncKvStorage;
@@ -329,9 +312,6 @@ const fromDurableObjectTransaction = (
       tryStoragePromise("transaction.deleteAlarm", () => txn.deleteAlarm(options)),
   }) as DurableObjectTransaction;
 
-/**
- * Wraps native Cloudflare storage APIs as Effect-returning helpers.
- */
 export const fromDurableObjectStorage = (
   storage: globalThis.DurableObjectStorage,
 ): DurableObjectStorage => ({
@@ -364,6 +344,7 @@ export const fromDurableObjectStorage = (
           // failed Exit is thrown to abort it. Keep a typed reference to that
           // Exit rather than recovering its type from the untyped catch binding.
           let aborted: Exit.Exit<A, E> | undefined;
+          let escapedFiber: Fiber.Fiber<unknown, unknown> | undefined;
 
           try {
             return Effect.succeed(
@@ -373,55 +354,59 @@ export const fromDurableObjectStorage = (
                 if (Exit.isSuccess(exit)) {
                   return exit.value;
                 }
+                const defect = Cause.findDefect(exit.cause);
+
+                if (Result.isSuccess(defect) && Cause.isAsyncFiberError(defect.success)) {
+                  escapedFiber = defect.success.fiber;
+                  escapedFiber.interruptUnsafe();
+                }
                 aborted = exit;
 
                 throw exit;
               }),
             );
           } catch (cause) {
-            if (aborted !== undefined && cause === aborted && Exit.isFailure(aborted)) {
-              return Effect.failCause(aborted.cause);
+            const failure: Effect.Effect<never, E | StorageOperationError> =
+              aborted !== undefined && cause === aborted && Exit.isFailure(aborted)
+                ? Effect.failCause(aborted.cause)
+                : Effect.fail(storageError("transactionSync", cause));
+            const fiber = escapedFiber;
+
+            if (fiber !== undefined) {
+              return Fiber.interrupt(fiber).pipe(Effect.andThen(failure));
             }
 
-            return Effect.fail(storageError("transactionSync", cause));
+            return failure;
           }
         }),
       ),
     ),
   transaction: <A, E, R>(closure: (txn: DurableObjectTransaction) => Effect.Effect<A, E, R>) =>
-    Effect.context<R>().pipe(
-      Effect.flatMap((context) =>
-        Effect.callback<A, E | StorageOperationError>((resume) => {
-          // See `transactionSync`: the thrown Exit aborts Cloudflare's
-          // transaction, and holding it here keeps its error type.
-          let aborted: Exit.Exit<A, E> | undefined;
+    Effect.suspend(() => {
+      // See `transactionSync`: the thrown Exit aborts Cloudflare's
+      // transaction, and holding it here keeps its error type.
+      let aborted: Exit.Exit<A, E> | undefined;
 
-          void storage
-            .transaction(async (txn) => {
-              const exit = await Effect.runPromiseExitWith(context)(
-                closure(fromDurableObjectTransaction(txn)),
-              );
-
-              if (Exit.isSuccess(exit)) {
-                return exit.value;
-              }
-              aborted = exit;
-
-              throw exit;
-            })
-            .then(
-              (value) => resume(Effect.succeed(value)),
-              (cause) => {
-                if (aborted !== undefined && cause === aborted && Exit.isFailure(aborted)) {
-                  resume(Effect.failCause(aborted.cause));
-                } else {
-                  resume(Effect.fail(storageError("transaction", cause)));
-                }
-              },
-            );
+      return runNativeCallback<A, E, R, A>((run) =>
+        storage.transaction(async (txn) => {
+          const exit = await run(Effect.suspend(() => closure(fromDurableObjectTransaction(txn))));
+
+          if (Exit.isSuccess(exit)) {
+            return exit.value;
+          }
+          aborted = exit;
+
+          throw exit;
         }),
-      ),
-    ),
+      ).pipe(
+        Effect.catch(
+          (cause): Effect.Effect<never, E | StorageOperationError> =>
+            aborted !== undefined && cause === aborted && Exit.isFailure(aborted)
+              ? Effect.failCause(aborted.cause)
+              : Effect.fail(storageError("transaction", cause)),
+        ),
+      );
+    }),
   sync: () => tryStoragePromise("sync", () => storage.sync()),
   getCurrentBookmark: () =>
     tryStoragePromise("getCurrentBookmark", () => storage.getCurrentBookmark()),

package/src/DurableObjectWebSocket.ts

@@ -3,10 +3,8 @@ import { Data, Effect, Option, Result, Schema as S } from "effect";
 import { DurableObjectState } from "./DurableObjectState";
 import * as ErrorMessage from "./internal/ErrorMessage";
 
-/** Data supported by Cloudflare websocket `send`. */
 export type DurableWebSocketSendData = string | ArrayBuffer | ArrayBufferView;
 
-/** Error raised when sending on a Durable Object websocket fails. */
 export class DurableWebSocketSendError extends Data.TaggedError("DurableWebSocketSendError")<{
   readonly cause: unknown;
 }> {
@@ -15,7 +13,6 @@ export class DurableWebSocketSendError extends Data.TaggedError("DurableWebSocke
   }
 }
 
-/** Error raised when closing a Durable Object websocket fails. */
 export class DurableWebSocketCloseError extends Data.TaggedError("DurableWebSocketCloseError")<{
   readonly cause: unknown;
 }> {
@@ -36,95 +33,55 @@ export class DurableWebSocketAttachmentError extends Data.TaggedError(
   }
 }
 
-/** Effect-native wrapper around a hibernatable Durable Object websocket. */
 export interface DurableWebSocket<Attachment = unknown> {
-  /** Underlying Cloudflare websocket. */
   readonly raw: WebSocket;
-  /** Sends a message through the socket. */
   send(data: DurableWebSocketSendData): Effect.Effect<void, DurableWebSocketSendError>;
-  /** Closes the socket. */
   close(code?: number, reason?: string): Effect.Effect<void, DurableWebSocketCloseError>;
   /** Serializes hibernation attachment metadata onto the socket. */
-  serializeAttachment<A = Attachment>(
+  serializeAttachment<A extends Attachment = Attachment>(
     value: A,
   ): Effect.Effect<void, DurableWebSocketAttachmentError>;
   /** Deserializes hibernation attachment metadata from the socket. */
   readonly deserializeAttachment: Effect.Effect<unknown, DurableWebSocketAttachmentError>;
 }
 
-const wrappers = new WeakMap<WebSocket, DurableWebSocket<unknown>>();
-
-/** Wraps a native Cloudflare websocket in the Effect-native Durable Object API. */
 export const fromWebSocket = <Attachment = unknown>(
   raw: WebSocket,
-): DurableWebSocket<Attachment> => {
-  const existing = wrappers.get(raw);
-
-  if (existing !== undefined) {
-    // SAFETY: Attachment is phantom; a wrapper's runtime behavior is independent of that type.
-    return existing as DurableWebSocket<Attachment>;
-  }
-
-  const socket: DurableWebSocket<unknown> = {
-    raw,
-    send: (data) =>
-      Effect.try({
-        try: () => raw.send(data),
-        catch: (cause) => new DurableWebSocketSendError({ cause }),
-      }),
-    close: (code, reason) =>
-      Effect.try({
-        try: () => raw.close(code, reason),
-        catch: (cause) => new DurableWebSocketCloseError({ cause }),
-      }),
-    serializeAttachment: (value) =>
-      Effect.try({
-        try: () => raw.serializeAttachment(value),
-        catch: (cause) => new DurableWebSocketAttachmentError({ operation: "serialize", cause }),
-      }),
-    deserializeAttachment: Effect.try({
-      try: () => raw.deserializeAttachment(),
-      catch: (cause) => new DurableWebSocketAttachmentError({ operation: "deserialize", cause }),
+): DurableWebSocket<Attachment> => ({
+  raw,
+  send: (data) =>
+    Effect.try({
+      try: () => raw.send(data),
+      catch: (cause) => new DurableWebSocketSendError({ cause }),
     }),
-  };
-
-  wrappers.set(raw, socket);
-
-  // SAFETY: Attachment is phantom; the newly created wrapper supports values through its generic serializer.
-  return socket as DurableWebSocket<Attachment>;
-};
+  close: (code, reason) =>
+    Effect.try({
+      try: () => raw.close(code, reason),
+      catch: (cause) => new DurableWebSocketCloseError({ cause }),
+    }),
+  serializeAttachment: <A extends Attachment = Attachment>(value: A) =>
+    Effect.try({
+      try: () => raw.serializeAttachment(value),
+      catch: (cause) => new DurableWebSocketAttachmentError({ operation: "serialize", cause }),
+    }),
+  deserializeAttachment: Effect.try({
+    try: () => raw.deserializeAttachment(),
+    catch: (cause) => new DurableWebSocketAttachmentError({ operation: "deserialize", cause }),
+  }),
+});
 
-/**
- * Options for accepting an incoming websocket request in a Durable Object.
- */
 export interface AcceptUpgradeOptions<Attachment = unknown> {
-  /** Optional websocket tags for Durable Object hibernation filtering. */
   readonly tags?: ReadonlyArray<string> | undefined;
   /** Optional attachment serialized onto the server socket. */
   readonly attachment?: Attachment | undefined;
 }
 
-/**
- * Result of a websocket upgrade accepted by {@link acceptUpgrade}.
- */
 export interface AcceptedUpgrade<Attachment = unknown> {
   readonly client: WebSocket;
   readonly server: DurableWebSocket<Attachment>;
   readonly response: Response;
 }
 
-/**
- * Accepts a websocket upgrade and registers the server socket on `DurableObjectState`.
- *
- * @example
- * ```ts
- * const response = yield* DurableObjectWebSocket.acceptUpgrade({
- *   tags: ["room:general"],
- * });
- *
- * return response.response;
- * ```
- */
 export const acceptUpgrade = Effect.fn("DurableObjectWebSocket.acceptUpgrade")(function* <
   Attachment = unknown,
 >(
@@ -158,9 +115,7 @@ export const acceptUpgrade = Effect.fn("DurableObjectWebSocket.acceptUpgrade")(f
 export type AttachmentInvalidPolicy = "ignore" | "ignore-and-close" | "fail";
 
 export interface AttachmentRehydrateOptions {
-  /** Optional Durable Object websocket tag filter. */
   readonly tag?: string | undefined;
-  /** Invalid attachment behavior. Defaults to skipping invalid sockets. */
   readonly onInvalid?: AttachmentInvalidPolicy | undefined;
 }
 
@@ -187,7 +142,6 @@ export interface DurableWebSocketAttachment<Attachment, Encoded> {
   readonly schema: S.Codec<Attachment, Encoded, never, never>;
 }
 
-/** Creates typed attachment helpers for accepted and rehydrated sockets. */
 export const attachment = <const AttachmentSchema extends S.Codec<any, any, never, never>>(
   schema: AttachmentSchema,
 ): DurableWebSocketAttachment<
@@ -195,15 +149,13 @@ export const attachment = <const AttachmentSchema extends S.Codec<any, any, neve
   S.Codec.Encoded<AttachmentSchema>
 > => {
   type Attachment = S.Schema.Type<AttachmentSchema>;
-  type Encoded = S.Codec.Encoded<AttachmentSchema>;
 
   const serialize = (socket: DurableWebSocket<unknown>, value: Attachment) =>
     S.encodeEffect(schema)(value).pipe(
       Effect.mapError(
         (cause) => new DurableWebSocketAttachmentError({ operation: "serialize", cause }),
       ),
-      // SAFETY: S.encodeEffect returns this codec's declared Encoded representation.
-      Effect.flatMap((encoded) => socket.serializeAttachment(encoded as Encoded)),
+      Effect.flatMap((encoded) => socket.serializeAttachment(encoded)),
     );
 
   const deserialize = (socket: DurableWebSocket<unknown>) =>
@@ -267,7 +219,6 @@ export interface DurableWebSocketHandlers<R = never, E = unknown> {
   readonly error?: (socket: DurableWebSocket, cause: unknown) => Effect.Effect<void, E, R>;
 }
 
-/** Maps compact websocket lifecycle handler names to `DurableObject.make` options. */
 export const handlers = <R = never, E = unknown>(options: DurableWebSocketHandlers<R, E>) => ({
   webSocketMessage: options.message,
   webSocketClose: options.close,

package/src/Email.ts

@@ -13,17 +13,13 @@ import * as ErrorMessage from "./internal/ErrorMessage";
 const expectedSendEmailBinding = "Send Email binding with send()";
 const textEncoder = new TextEncoder();
 
-/** Documented Cloudflare Email Sending limits. */
 export const sendLimits = {
-  /** Combined `to`, `cc`, and `bcc` addresses per message. */
   maxRecipients: 50,
   maxAttachments: 32,
-  /** Total message size, including attachments. Not enforced client side. */
   maxMessageBytes: 5 * 1024 * 1024,
   maxHeaderNameBytes: 100,
   maxHeaderValueBytes: 2048,
   maxHeadersBytes: 16 * 1024,
-  /** Allowlisted custom headers, excluding `X-` prefixed headers. */
   maxAllowlistHeaders: 20,
 } as const;
 
@@ -58,10 +54,8 @@ export const emailErrorCodes = [
   "E_HEADERS_TOO_MANY",
 ] as const;
 
-/** A documented Cloudflare Email Sending error code. */
 export type EmailErrorCode = (typeof emailErrorCodes)[number];
 
-/** Error raised when a Cloudflare Send Email operation fails. */
 export class EmailOperationError extends Data.TaggedError("EmailOperationError")<{
   readonly binding: string;
   readonly operation: string;
@@ -82,7 +76,6 @@ export class EmailOperationError extends Data.TaggedError("EmailOperationError")
   }
 }
 
-/** A single message field that violates a documented Email Sending limit. */
 export interface EmailViolation {
   readonly path: string;
   readonly message: string;
@@ -90,7 +83,6 @@ export interface EmailViolation {
   readonly actual?: number;
 }
 
-/** Error raised when a message violates documented Cloudflare Email Sending limits. */
 export class EmailValidationError extends Data.TaggedError("EmailValidationError")<{
   readonly binding: string;
   readonly operation: string;
@@ -101,9 +93,7 @@ export class EmailValidationError extends Data.TaggedError("EmailValidationError
   }
 }
 
-/** Typed Cloudflare Send Email binding definition. */
 export interface EmailDefinition {
-  /** Binding name as configured in `wrangler.jsonc`. */
   readonly binding: string;
 }
 
@@ -117,7 +107,6 @@ export type EmailSendError = EmailOperationError | EmailValidationError;
 type EmailFieldCandidate = Parameters<typeof Predicate.isUnknown>[0];
 
 export interface EmailSendOptions {
-  /** Validates builder messages against documented limits. Defaults to `true`. */
   readonly validate?: boolean;
 }
 
@@ -133,7 +122,6 @@ export interface EmailClient {
 
 declare const EmailServiceTypeId: unique symbol;
 
-/** Nominal service marker for Send Email services created with {@link make}. */
 export interface EmailService<Id extends string> {
   readonly [EmailServiceTypeId]: {
     readonly id: Id;

package/src/Environment.ts

@@ -1,6 +1,5 @@
 import { Config, ConfigProvider, Context, Effect, type Layer, Predicate } from "effect";
 
-/** Cloudflare worker environment object (`env`). */
 export type WorkerEnv = Cloudflare.Env;
 
 /**
@@ -23,38 +22,9 @@ type ScalarConfigKey = Extract<
   string
 >;
 
-/**
- * Effect `Config` helpers for scalar Cloudflare vars and secrets declared on
- * `Cloudflare.Env`.
- *
- * Users still author their app config explicitly with Effect `Config`:
- *
- * ```ts
- * import { Config, Effect } from "effect";
- * import { WorkerConfig } from "effect-cf";
- *
- * const AppConfig = Config.all({
- *   databaseUrl: WorkerConfig.redacted("DATABASE_URL"),
- *   port: WorkerConfig.integer("PORT").pipe(Config.withDefault(8787)),
- * });
- *
- * const program = Effect.gen(function* () {
- *   const config = yield* AppConfig;
- *   // ...
- * }).pipe(Effect.provide(WorkerConfig.providerLayer));
- * ```
- *
- * Keys are constrained to scalar `Cloudflare.Env` properties (`string`,
- * `number`, or `boolean`, including optional scalar properties). Binding
- * objects such as `KVNamespace`, `DurableObjectNamespace`, and service
- * bindings are intentionally excluded; keep using the package binding helpers
- * for those live resources.
- */
 export namespace WorkerConfig {
-  /** Scalar env value types supported by the typed config key helpers. */
   export type Scalar = ScalarConfigValue;
 
-  /** Scalar keys available on the current consumer's `Cloudflare.Env`. */
   export type Key = ScalarConfigKey;
 
   /** Read a scalar Cloudflare var or secret as a string. */
@@ -72,7 +42,6 @@ export namespace WorkerConfig {
   /** Read a scalar Cloudflare var or secret as a boolean. */
   export const boolean = <const Name extends Key>(name: Name) => Config.boolean(name);
 
-  /** Options for building a `ConfigProvider` from a Cloudflare worker `env` object. */
   export interface ProviderOptions {
     /**
      * Keep empty-string env values as explicit `""` config values.
@@ -104,14 +73,9 @@ export namespace WorkerConfig {
     return ConfigProvider.fromEnvRecord(record, options);
   };
 
-  /**
-   * Build a `ConfigProvider` from the current `WorkerEnvironment` with a custom
-   * conversion function.
-   */
   export const providerWith = (makeProvider: (env: WorkerEnv) => ConfigProvider.ConfigProvider) =>
     Effect.map(WorkerEnvironment, makeProvider);
 
-  /** Build a `ConfigProvider` from the current `WorkerEnvironment`. */
   export const provider = providerWith(providerFromEnv);
 
   /**
@@ -121,7 +85,6 @@ export namespace WorkerConfig {
   export const providerLayer: Layer.Layer<never, never, WorkerEnvironment> =
     ConfigProvider.layer(provider);
 
-  /** Build a `ConfigProvider` layer with a custom `env` conversion function. */
   export const layerWith = (
     makeProvider: (env: WorkerEnv) => ConfigProvider.ConfigProvider,
   ): Layer.Layer<never, never, WorkerEnvironment> =>

package/src/Hyperdrive.ts

@@ -5,9 +5,7 @@ import type { WorkerEnvironment } from "./Environment";
 
 const expectedHyperdrive = "Hyperdrive binding with connectionString";
 
-/** Typed Hyperdrive binding definition. */
 export interface HyperdriveDefinition {
-  /** Binding name as configured in `wrangler.jsonc`. */
   readonly binding: string;
 }
 
@@ -19,7 +17,6 @@ export interface HyperdriveClient {
 
 declare const HyperdriveServiceTypeId: unique symbol;
 
-/** Nominal service marker for Hyperdrive services created with {@link make}. */
 export interface HyperdriveService<Id extends string> {
   readonly [HyperdriveServiceTypeId]: {
     readonly id: Id;

package/src/HyperdrivePg.ts

@@ -6,20 +6,11 @@ import type * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";
 import type * as Hyperdrive from "./Hyperdrive";
 
-/** Hyperdrive owns database pooling, so app-side pool and connection options are not exposed. */
 export type PgLayerOptions = Omit<
   Parameters<typeof PgClient.makeClient>[0],
   "url" | "host" | "port" | "path" | "ssl" | "database" | "username" | "password" | "stream"
 >;
 
-/**
- * Provides `PgClient` and `SqlClient` backed by a Hyperdrive binding.
- *
- * Note: since Effect `4.0.0-beta.99`, `PgClient.makeClient` connects eagerly,
- * so the TCP connection to Hyperdrive is opened when this layer is built.
- * In per-request Workers runtimes, build the layer within the request
- * lifecycle rather than sharing it across requests.
- */
 export const layer = <Self, Id extends string>(
   tag: Hyperdrive.TagClass<Self, Id>,
   binding: Hyperdrive.LayerOptions,

package/src/Images.ts

@@ -33,7 +33,6 @@ export type TypeId = typeof TypeId;
 
 const expectedImagesBinding = "Images binding with info() and input()";
 
-/** Error raised when a Cloudflare Images operation fails. */
 export class ImagesOperationError extends Data.TaggedError("ImagesOperationError")<{
   readonly binding: string;
   readonly operation: string;
@@ -44,9 +43,7 @@ export class ImagesOperationError extends Data.TaggedError("ImagesOperationError
   }
 }
 
-/** Typed Cloudflare Images binding definition. */
 export interface ImagesDefinition {
-  /** Binding name as configured in `wrangler.jsonc`. */
   readonly binding: string;
 }
 
@@ -175,7 +172,6 @@ export interface ImagesClient {
 
 declare const ImagesServiceTypeId: unique symbol;
 
-/** Nominal service marker for Images services created with {@link make}. */
 export interface ImagesService<Id extends string> {
   readonly [ImagesServiceTypeId]: {
     readonly id: Id;
@@ -206,7 +202,6 @@ const makeSteps = (steps: ReadonlyArray<Step>): Steps => ({
   steps,
 });
 
-/** Empty Images transformation pipeline. */
 export const empty: Steps = makeSteps([]);
 
 export const transform: {