alchemy 2.0.0-beta.44 → 2.0.0-beta.45

package/src/Cloudflare/BrowserRendering/BrowserRendering.ts

@@ -0,0 +1,132 @@
+import * as Effect from "effect/Effect";
+import { BrowserRenderingBinding } from "./BrowserRenderingBinding.ts";
+
+type BrowserRenderingTypeId = typeof BrowserRenderingTypeId;
+const BrowserRenderingTypeId = "Cloudflare.BrowserRendering" as const;
+
+export type BrowserRenderingProps = {
+  /**
+   * Binding name used when `Cloudflare.BrowserRendering.bind(browser)` attaches
+   * Browser Rendering from inside a Worker init phase. When Browser Rendering
+   * is passed through `Worker({ bindings: { ... } })`, the object key remains
+   * the binding name.
+   *
+   * @default "BROWSER"
+   */
+  name?: string;
+};
+
+/**
+ * Marker for a Cloudflare Browser Rendering binding.
+ *
+ * Browser Rendering bindings are configured directly on Workers and do not
+ * have a standalone provisioning API. The Worker provider sees this object in
+ * `bindings: { ... }` and emits the corresponding `{ type: "browser" }`
+ * metadata binding to the script.
+ */
+export type BrowserRendering = {
+  kind: BrowserRenderingTypeId;
+  name: string;
+};
+
+export const isBrowserRendering = (value: unknown): value is BrowserRendering =>
+  typeof value === "object" &&
+  (value as BrowserRendering)?.kind === BrowserRenderingTypeId;
+
+/**
+ * A Cloudflare Browser Rendering binding for launching headless browser
+ * sessions from Workers via `@cloudflare/puppeteer`.
+ *
+ * @binding
+ *
+ * @section Effect-style Worker (recommended)
+ * @example Render a page title with managed browser cleanup
+ * ```typescript
+ * import puppeteer from "@cloudflare/puppeteer";
+ * import * as Effect from "effect/Effect";
+ *
+ * const Browser = Cloudflare.BrowserRendering({ name: "BROWSER" });
+ *
+ * Cloudflare.Worker(
+ *   "BrowserWorker",
+ *   { main: import.meta.filename },
+ *   Effect.gen(function* () {
+ *     const browserRendering = yield* Cloudflare.BrowserRendering.bind(
+ *       yield* Browser,
+ *     );
+ *
+ *     return {
+ *       fetch: browserRendering.withBrowser(puppeteer, (browser) =>
+ *         Effect.gen(function* () {
+ *           const page = yield* Effect.tryPromise(() => browser.newPage());
+ *           yield* Effect.tryPromise(() => page.goto("https://example.com"));
+ *           const title = yield* Effect.tryPromise(() => page.title());
+ *           return Response.json({ title });
+ *         }),
+ *       ),
+ *     };
+ *   }).pipe(Effect.provide(Cloudflare.BrowserRenderingBindingLive)),
+ * );
+ * ```
+ *
+ * @section Declaring Browser Rendering
+ * @example
+ * ```typescript
+ * const Browser = yield* Cloudflare.BrowserRendering({ name: "BROWSER" });
+ * ```
+ *
+ * @section Worker binding metadata
+ * @example
+ * ```typescript
+ * export const Worker = Cloudflare.Worker("Worker", {
+ *   main: "./src/worker.ts",
+ *   bindings: {
+ *     BROWSER: Cloudflare.BrowserRendering(),
+ *   },
+ * });
+ *
+ * export type WorkerEnv = Cloudflare.InferEnv<typeof Worker>;
+ * //   { BROWSER: Fetcher }
+ * ```
+ *
+ * @example Async-style worker with the raw runtime binding
+ * ```typescript
+ * import puppeteer from "@cloudflare/puppeteer";
+ * import type { WorkerEnv } from "../alchemy.run.ts";
+ *
+ * export default {
+ *   async fetch(request: Request, env: WorkerEnv) {
+ *     const browser = await puppeteer.launch(env.BROWSER);
+ *     const page = await browser.newPage();
+ *     await page.goto("https://example.com");
+ *     const screenshot = await page.screenshot();
+ *     await browser.close();
+ *
+ *     return new Response(screenshot, {
+ *       headers: { "content-type": "image/png" },
+ *     });
+ *   },
+ * };
+ * ```
+ *
+ * @see https://developers.cloudflare.com/browser-rendering/workers-binding-api/
+ */
+export const BrowserRendering: {
+  (props?: BrowserRenderingProps): Effect.Effect<BrowserRendering>;
+  /**
+   * Bind Browser Rendering to the surrounding Worker, returning a small client
+   * with access to the native Workers runtime binding.
+   */
+  bind: typeof BrowserRenderingBinding.bind;
+} = Object.assign(
+  Effect.fn(function* (props?: BrowserRenderingProps) {
+    return {
+      kind: BrowserRenderingTypeId,
+      name: props?.name ?? "BROWSER",
+    } satisfies BrowserRendering;
+  }),
+  {
+    bind: (...args: Parameters<typeof BrowserRenderingBinding.bind>) =>
+      BrowserRenderingBinding.bind(...args),
+  },
+);

package/src/Cloudflare/BrowserRendering/BrowserRenderingBinding.ts

@@ -0,0 +1,137 @@
+import type * as cf from "@cloudflare/workers-types";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Binding from "../../Binding.ts";
+import type { ResourceLike } from "../../Resource.ts";
+import { isWorker, WorkerEnvironment } from "../Workers/Worker.ts";
+import type { BrowserRendering as BrowserRenderingLike } from "./BrowserRendering.ts";
+
+export class BrowserRenderingError extends Data.TaggedError(
+  "BrowserRenderingError",
+)<{
+  message: string;
+  cause: unknown;
+}> {}
+
+export interface BrowserRenderingBrowser {
+  close(): Promise<void>;
+}
+
+export interface BrowserRenderingPuppeteer<
+  Browser extends BrowserRenderingBrowser,
+> {
+  launch(binding: cf.Fetcher): Promise<Browser>;
+}
+
+/**
+ * Effect-native client for a Cloudflare Browser Rendering binding.
+ *
+ * Browser Rendering's Workers binding is consumed by `@cloudflare/puppeteer`.
+ * Alchemy keeps Puppeteer as a caller-provided dependency while wrapping
+ * launch and cleanup in Effects.
+ */
+export interface BrowserRenderingClient {
+  /**
+   * Effect resolving to the raw Cloudflare Browser Rendering runtime binding.
+   */
+  raw: Effect.Effect<cf.Fetcher, never, WorkerEnvironment>;
+  /**
+   * Launch a Browser Rendering session through `@cloudflare/puppeteer`.
+   */
+  launch<Browser extends BrowserRenderingBrowser>(
+    puppeteer: BrowserRenderingPuppeteer<Browser>,
+  ): Effect.Effect<Browser, BrowserRenderingError, WorkerEnvironment>;
+  /**
+   * Launch a browser, run an Effect with it, and close it afterward.
+   */
+  withBrowser<Browser extends BrowserRenderingBrowser, A, E, R>(
+    puppeteer: BrowserRenderingPuppeteer<Browser>,
+    use: (browser: Browser) => Effect.Effect<A, E, R>,
+  ): Effect.Effect<A, BrowserRenderingError | E, WorkerEnvironment | R>;
+}
+
+export class BrowserRenderingBinding extends Binding.Service<
+  BrowserRenderingBinding,
+  (browser: BrowserRenderingLike) => Effect.Effect<BrowserRenderingClient>
+>()("Cloudflare.BrowserRendering.Binding") {}
+
+export const BrowserRenderingBindingLive = Layer.effect(
+  BrowserRenderingBinding,
+  Effect.gen(function* () {
+    const Policy = yield* BrowserRenderingBindingPolicy;
+
+    return Effect.fn(function* (browser: BrowserRenderingLike) {
+      yield* Policy(browser);
+      // Cloudflare exposes Browser Rendering as a service-style binding for
+      // @cloudflare/puppeteer; workers-types has no narrower interface.
+      const raw = WorkerEnvironment.useSync(
+        (env) => (env as Record<string, cf.Fetcher>)[browser.name]!,
+      );
+      return makeBrowserRenderingClient(raw);
+    });
+  }),
+);
+
+export class BrowserRenderingBindingPolicy extends Binding.Policy<
+  BrowserRenderingBindingPolicy,
+  (browser: BrowserRenderingLike) => Effect.Effect<void>
+>()("Cloudflare.BrowserRendering.Binding") {}
+
+export const BrowserRenderingBindingPolicyLive =
+  BrowserRenderingBindingPolicy.layer.succeed(
+    Effect.fn(function* (host: ResourceLike, browser: BrowserRenderingLike) {
+      if (isWorker(host)) {
+        yield* host.bind(browser.name, {
+          bindings: [
+            {
+              type: "browser",
+              name: browser.name,
+            },
+          ],
+        });
+      } else {
+        return yield* Effect.die(
+          new Error(
+            `BrowserRenderingBinding does not support runtime '${host.Type}'`,
+          ),
+        );
+      }
+    }),
+  );
+
+const tryPromise = <T>(
+  fn: () => Promise<T>,
+): Effect.Effect<T, BrowserRenderingError> =>
+  Effect.tryPromise({
+    try: fn,
+    catch: (error) =>
+      new BrowserRenderingError({
+        message:
+          error instanceof Error
+            ? error.message
+            : "Unknown Browser Rendering error",
+        cause: error,
+      }),
+  });
+
+/** @internal */
+export const makeBrowserRenderingClient = (
+  raw: Effect.Effect<cf.Fetcher, never, WorkerEnvironment>,
+): BrowserRenderingClient => {
+  const launch = <Browser extends BrowserRenderingBrowser>(
+    puppeteer: BrowserRenderingPuppeteer<Browser>,
+  ) =>
+    raw.pipe(
+      Effect.flatMap((binding) => tryPromise(() => puppeteer.launch(binding))),
+    );
+
+  return {
+    raw,
+    launch,
+    withBrowser: (puppeteer, use) =>
+      Effect.acquireUseRelease(launch(puppeteer), use, (browser) =>
+        tryPromise(() => browser.close()),
+      ),
+  } satisfies BrowserRenderingClient;
+};

package/src/Cloudflare/BrowserRendering/index.ts

@@ -0,0 +1,11 @@
+export * from "./BrowserRendering.ts";
+export {
+  BrowserRenderingBinding,
+  BrowserRenderingBindingLive,
+  BrowserRenderingBindingPolicy,
+  BrowserRenderingBindingPolicyLive,
+  BrowserRenderingError,
+  type BrowserRenderingBrowser,
+  type BrowserRenderingClient,
+  type BrowserRenderingPuppeteer,
+} from "./BrowserRenderingBinding.ts";

package/src/Cloudflare/Container/Container.ts

@@ -176,7 +176,7 @@ export type Container = {
  *
  *     return Effect.gen(function* () {
  *       // INNER (per-instance): start the container and expose RPC.
- *       const container = yield* Cloudflare.start(sandbox);
+ *       const container = yield* Cloudflare.start(sandbox, { enableInternet: true });
  *
  *       return {
  *         exec: (cmd: string) => container.exec(cmd),
@@ -200,7 +200,7 @@ export type Container = {
  *
  * // per-instance (inner Effect)
  * return Effect.gen(function* () {
- *   const container = yield* Cloudflare.start(sandbox);
+ *   const container = yield* Cloudflare.start(sandbox, { enableInternet: true });
  *
  *   return {
  *     exec: (cmd: string) => container.exec(cmd),
@@ -215,7 +215,7 @@ export type Container = {
  *
  * @example Fetching from a container port
  * ```typescript
- * const container = yield* Cloudflare.start(sandbox);
+ * const container = yield* Cloudflare.start(sandbox, { enableInternet: true });
  * const { fetch } = yield* container.getTcpPort(3000);
  *
  * const response = yield* fetch(

package/src/Cloudflare/Container/StartContainer.ts

@@ -9,10 +9,9 @@ import { type Fetcher } from "../Fetcher.ts";
 import { DurableObjectState } from "../Workers/DurableObjectState.ts";
 import {
   type Container,
-  type ContainerStartupOptions,
   ContainerError,
+  type ContainerStartupOptions,
 } from "./Container.ts";
-
 /**
  * Runs the Container in a Durable Object and monitors it, providing a durable fetch and RPC interface to it.
  */

package/src/Cloudflare/D1/D1Database.ts

@@ -5,12 +5,15 @@ import { isResolved } from "../../Diff.ts";
 import { createPhysicalName } from "../../PhysicalName.ts";
 import * as Provider from "../../Provider.ts";
 import { Resource } from "../../Resource.ts";
+import { listSqlFiles, readSqlFile } from "../../Sql/SqlFile.ts";
 import { CloudflareEnvironment } from "../CloudflareEnvironment.ts";
 import type { Providers } from "../Providers.ts";
 import { cloneD1Database } from "./D1Clone.ts";
 import { importD1Database } from "./D1Import.ts";
 import { applyMigrations } from "./D1Migrations.ts";
-import { listSqlFiles, readSqlFile } from "../../Sql/SqlFile.ts";
+
+export const isD1Database = (value: unknown): value is D1Database =>
+  typeof value === "object" && (value as any)?.Type === "Cloudflare.D1Database";
 
 export type Jurisdiction = "default" | "eu" | "fedramp";
 export type PrimaryLocationHint =

package/src/Cloudflare/D1/D1DatabaseBinding.ts

@@ -13,7 +13,7 @@ export const DatabaseBinding = Effect.fn(function* (
         {
           type: "d1",
           name: database.LogicalId,
-          id: database.databaseId,
+          databaseId: database.databaseId,
         },
       ],
     });

package/src/Cloudflare/Fetcher.ts

@@ -133,10 +133,8 @@ export const toHttpClient = (fetcher: {
   ) => Effect.Effect<HttpServerResponse.HttpServerResponse, HttpServerError>;
 }) =>
   HttpClient.make((request) => {
-    console.log("toHttpClient: request", request.url);
     return fetcher.fetch(HttpServerRequest.fromClientRequest(request)).pipe(
       Effect.map((response) => {
-        console.log("toHttpClient: response", response);
         return HttpClientResponse.fromWeb(
           request,
           HttpServerResponse.toWeb(response),

package/src/Cloudflare/Hyperdrive/Hyperdrive.ts

@@ -1,5 +1,6 @@
 import * as hyperdrive from "@distilled.cloud/cloudflare/hyperdrive";
 import * as Effect from "effect/Effect";
+import * as Predicate from "effect/Predicate";
 import * as Redacted from "effect/Redacted";
 
 import { AlchemyContext } from "../../AlchemyContext.ts";
@@ -157,6 +158,10 @@ export const Hyperdrive = Resource<Hyperdrive>("Cloudflare.Hyperdrive")({
   bind: HyperdriveBinding.bind,
 });
 
+export const isHyperdrive = (value: unknown): value is Hyperdrive =>
+  Predicate.hasProperty(value, "Type") &&
+  value.Type === "Cloudflare.Hyperdrive";
+
 export const HyperdriveProvider = () =>
   Provider.effect(
     Hyperdrive,

package/src/Cloudflare/Hyperdrive/HyperdriveBinding.ts

@@ -2,7 +2,6 @@ import type * as runtime from "@cloudflare/workers-types";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Redacted from "effect/Redacted";
-import { AlchemyContext } from "../../AlchemyContext.ts";
 import * as Binding from "../../Binding.ts";
 import * as Output from "../../Output.ts";
 import type { ResourceLike } from "../../Resource.ts";
@@ -102,8 +101,6 @@ export class HyperdriveBindingPolicy extends Binding.Policy<
 
 export const HyperdriveBindingPolicyLive = HyperdriveBindingPolicy.layer.effect(
   Effect.gen(function* () {
-    const ctx = yield* AlchemyContext;
-
     return Effect.fn(function* (host: ResourceLike, hyperdrive: Hyperdrive) {
       if (!isWorker(host)) {
         return yield* Effect.die(
@@ -113,38 +110,6 @@ export const HyperdriveBindingPolicyLive = HyperdriveBindingPolicy.layer.effect(
         );
       }
 
-      const origin = Output.map(
-        Output.all(hyperdrive.dev, hyperdrive.origin, hyperdrive.mtls),
-        ([dev, origin, mtls]): Required<HyperdriveDevOrigin> => {
-          if (dev) {
-            return {
-              scheme: dev.scheme,
-              host: dev.host,
-              port: dev.port ?? defaultPort(dev.scheme),
-              user: dev.user,
-              database: dev.database,
-              password: dev.password,
-              sslmode: dev.sslmode ?? "prefer",
-            };
-          }
-          if ("accessClientId" in origin) {
-            throw new Error(
-              `Hyperdrive instance ${hyperdrive.LogicalId} has an origin that requires Cloudflare Access. This is not supported in development mode. ` +
-                "Select a different origin or set the `dev` property to an origin that does not require Cloudflare Access.",
-            );
-          }
-          return {
-            scheme: origin.scheme,
-            host: origin.host,
-            port: origin.port ?? defaultPort(origin.scheme),
-            user: origin.user,
-            database: origin.database,
-            password: origin.password,
-            sslmode: mtls?.sslmode ?? "require",
-          };
-        },
-      );
-
       yield* host.bind`${hyperdrive}`({
         bindings: [
           {
@@ -153,15 +118,48 @@ export const HyperdriveBindingPolicyLive = HyperdriveBindingPolicy.layer.effect(
             id: hyperdrive.hyperdriveId as unknown as string,
           },
         ],
-        hyperdrives: ctx.dev
-          ? (Output.map(
-              Output.all(hyperdrive.hyperdriveId, Output.asOutput(origin)),
-              ([id, origin]) => ({
-                [id]: origin,
-              }),
-            ) as unknown as Record<string, Required<HyperdriveDevOrigin>>)
-          : undefined,
+        hyperdrives: getHyperdriveDevOrigin(hyperdrive),
       });
     });
   }),
 );
+
+export const getHyperdriveDevOrigin = (hyperdrive: Hyperdrive) => {
+  const origin = Output.map(
+    Output.all(hyperdrive.dev, hyperdrive.origin, hyperdrive.mtls),
+    ([dev, origin, mtls]): Required<HyperdriveDevOrigin> => {
+      if (dev) {
+        return {
+          scheme: dev.scheme,
+          host: dev.host,
+          port: dev.port ?? defaultPort(dev.scheme),
+          user: dev.user,
+          database: dev.database,
+          password: dev.password,
+          sslmode: dev.sslmode ?? "prefer",
+        };
+      }
+      if ("accessClientId" in origin) {
+        throw new Error(
+          `Hyperdrive instance ${hyperdrive.LogicalId} has an origin that requires Cloudflare Access. This is not supported in development mode. ` +
+            "Select a different origin or set the `dev` property to an origin that does not require Cloudflare Access.",
+        );
+      }
+      return {
+        scheme: origin.scheme,
+        host: origin.host,
+        port: origin.port ?? defaultPort(origin.scheme),
+        user: origin.user,
+        database: origin.database,
+        password: origin.password,
+        sslmode: mtls?.sslmode ?? "require",
+      };
+    },
+  );
+  return Output.map(
+    Output.all(hyperdrive.hyperdriveId, Output.asOutput(origin)),
+    ([id, origin]) => ({
+      [id]: origin,
+    }),
+  ) as unknown as Record<string, Required<HyperdriveDevOrigin>>;
+};

package/src/Cloudflare/KV/KVNamespace.ts

@@ -10,6 +10,10 @@ import { CloudflareEnvironment } from "../CloudflareEnvironment.ts";
 import type { Providers } from "../Providers.ts";
 import { KVNamespaceBinding } from "./KVNamespaceBinding.ts";
 
+export const isKVNamespace = (value: unknown): value is KVNamespace =>
+  typeof value === "object" &&
+  (value as any)?.Type === "Cloudflare.KVNamespace";
+
 export type KVNamespaceProps = {
   /**
    * A human-readable string name for the namespace.

package/src/Cloudflare/Local.ts

@@ -17,7 +17,7 @@ const cloudflareServices = Layer.provide(
 );
 
 LocalWorkerProvider().pipe(
-  Layer.provide(localRuntimeServices({ port: 1337 })),
+  Layer.provide(localRuntimeServices()),
   Layer.provide(cloudflareServices),
   RpcServer.launch,
 );

package/src/Cloudflare/Providers.ts

@@ -5,11 +5,12 @@ import { pipe } from "effect/Function";
 import * as Layer from "effect/Layer";
 import * as Ref from "effect/Ref";
 import * as Schedule from "effect/Schedule";
+import { CredentialsStoreLive } from "../Auth/Credentials.ts";
+import { ProfileLive } from "../Auth/Profile.ts";
 import { Command } from "../Build/Command.ts";
 import * as Build from "../Build/index.ts";
+import { KeyPair, KeyPairProvider } from "../KeyPair.ts";
 import * as Provider from "../Provider.ts";
-import { CredentialsStoreLive } from "../Auth/Credentials.ts";
-import { ProfileLive } from "../Auth/Profile.ts";
 import { Random, RandomProvider } from "../Random.ts";
 import * as Access from "./Access.ts";
 import * as AiGateway from "./AiGateway/index.ts";
@@ -17,6 +18,7 @@ import * as AnalyticsEngine from "./AnalyticsEngine/index.ts";
 import * as ApiToken from "./ApiToken/index.ts";
 import * as Artifacts from "./Artifacts/index.ts";
 import { CloudflareAuth } from "./Auth/AuthProvider.ts";
+import * as BrowserRendering from "./BrowserRendering/index.ts";
 import * as CloudflareEnvironment from "./CloudflareEnvironment.ts";
 import * as Containers from "./Container/index.ts";
 import * as Credentials from "./Credentials.ts";
@@ -55,6 +57,7 @@ export const providers = () =>
       AiGateway.AiGatewayBindingPolicy,
       AnalyticsEngine.AnalyticsEngineDatasetBindingPolicy,
       Artifacts.ArtifactsBindingPolicy,
+      BrowserRendering.BrowserRenderingBindingPolicy,
       Command,
       Containers.Container,
       D1.D1ConnectionPolicy,
@@ -79,6 +82,7 @@ export const providers = () =>
       SecretsStore.Secret,
       Tunnel.Tunnel,
       VpcService.VpcService,
+      KeyPair,
       Random,
       Workers.BindWorkerPolicy,
       Workers.CronEventSourcePolicy,
@@ -96,6 +100,7 @@ export const providers = () =>
         AiGateway.AiGatewayBindingPolicyLive,
         AnalyticsEngine.AnalyticsEngineDatasetBindingPolicyLive,
         Artifacts.ArtifactsBindingPolicyLive,
+        BrowserRendering.BrowserRenderingBindingPolicyLive,
         Containers.ContainerProvider(),
         D1.D1ConnectionPolicyLive,
         D1.DatabaseProvider(),
@@ -128,7 +133,11 @@ export const providers = () =>
       ),
     ),
     Layer.provideMerge(
-      Layer.mergeAll(Build.CommandProvider(), RandomProvider()),
+      Layer.mergeAll(
+        Build.CommandProvider(),
+        KeyPairProvider(),
+        RandomProvider(),
+      ),
     ),
     Layer.provideMerge(Credentials.fromAuthProvider()),
     Layer.provideMerge(CloudflareEnvironment.fromProfile()),
@@ -157,19 +166,6 @@ export const providers = () =>
     Layer.orDie,
   );
 
-const isMisleadinglyTaggedTransient = (error: unknown): boolean => {
-  if (!error || typeof error !== "object") return false;
-  const tag = (error as { _tag?: unknown })._tag;
-  const message = ((error as { message?: unknown }).message ?? "") as string;
-  // CF code 10001: "Method not allowed for token" is a real permission
-  // failure (NOT retryable), but the same code is also returned with
-  // message "internal error" during Cloudflare-side hiccups. The two
-  // messages are unambiguously distinct, so we can safely retry only
-  // the internal-error variant.
-  if (tag === "Forbidden" && /internal error/i.test(message)) return true;
-  return false;
-};
-
 const cloudflareRetryFactory: Retry.Factory = (lastError) => {
   const defaults = Retry.makeDefault(lastError);
   return {
@@ -196,3 +192,16 @@ const cloudflareRetryFactory: Retry.Factory = (lastError) => {
     ),
   };
 };
+
+const isMisleadinglyTaggedTransient = (error: unknown): boolean => {
+  if (!error || typeof error !== "object") return false;
+  const tag = (error as { _tag?: unknown })._tag;
+  const message = ((error as { message?: unknown }).message ?? "") as string;
+  // CF code 10001: "Method not allowed for token" is a real permission
+  // failure (NOT retryable), but the same code is also returned with
+  // message "internal error" during Cloudflare-side hiccups. The two
+  // messages are unambiguously distinct, so we can safely retry only
+  // the internal-error variant.
+  if (tag === "Forbidden" && /internal error/i.test(message)) return true;
+  return false;
+};

package/src/Cloudflare/Queue/Queue.ts

@@ -10,6 +10,9 @@ import { CloudflareEnvironment } from "../CloudflareEnvironment.ts";
 import type { Providers } from "../Providers.ts";
 import { QueueBinding } from "./QueueBinding.ts";
 
+export const isQueue = (value: unknown): value is Queue =>
+  typeof value === "object" && (value as any)?.Type === "Cloudflare.Queue";
+
 export type QueueProps = {
   /**
    * Name of the queue. If omitted, a unique name will be generated.