alchemy 2.0.0-beta.51 → 2.0.0-beta.53

package/src/Cloudflare/Browser/Browser.ts

@@ -32,9 +32,10 @@ type BindEffect = Effect.Effect<BrowserClient, never, BrowserBinding>;
  * Worker and returns the runtime {@link BrowserClient} — no separate
  * `.bind(...)` step required.
  *
- * The divergence is achieved via `[Symbol.iterator]`: the object is not an
- * `Effect` (so `InferEnv` resolves it to the native `Fetcher` in the `env`
- * position), but it is iterable as one when `yield*`-ed.
+ * The divergence is achieved via `[Symbol.iterator]`: the object is
+ * deliberately not an `Effect` (so `InferEnv` and the Worker `env` resolver
+ * keep it as the native `BrowserRun` rather than `yield*`-ing it), but it is
+ * iterable as one when `yield*`-ed.
  */
 export interface Browser {
   kind: BrowserTypeId;
@@ -53,7 +54,73 @@ export const isBrowser = (value: unknown): value is Browser =>
  * @binding
  *
  * @section Effect-style Worker (recommended)
- * @example Render a page title with managed browser cleanup
+ * @example Bind the runtime client and convert a page to Markdown
+ * Yielding the marker attaches the binding to the surrounding Worker and
+ * returns the runtime {@link BrowserClient}. Every `cf.BrowserRun` method is
+ * mirrored as an Effect, so no `Effect.tryPromise` wrapping is needed.
+ * ```typescript
+ * import * as Effect from "effect/Effect";
+ *
+ * Cloudflare.Worker(
+ *   "BrowserWorker",
+ *   { main: import.meta.filename },
+ *   Effect.gen(function* () {
+ *     const browser = yield* Cloudflare.Browser({ name: "BROWSER" });
+ *
+ *     return {
+ *       fetch: Effect.gen(function* () {
+ *         return yield* browser.markdown({ url: "https://example.com" });
+ *       }),
+ *     };
+ *   }).pipe(Effect.provide(Cloudflare.BrowserBindingLive)),
+ * );
+ * ```
+ *
+ * @section Quick Actions
+ * @example Render content, screenshot, PDF, and structured data
+ * JSON quick actions resolve to their parsed payload; binary actions
+ * (`screenshot`, `pdf`) resolve to a `Stream` of bytes. No `Promise` or
+ * `Response.json()` in sight.
+ * ```typescript
+ * import * as Effect from "effect/Effect";
+ * import * as Stream from "effect/Stream";
+ *
+ * const browser = yield* Cloudflare.Browser({ name: "BROWSER" });
+ * const url = "https://example.com";
+ *
+ * // HTML content — parsed payload, title lives in `meta`.
+ * const content = yield* browser.content({ url });
+ * const title = content.meta.title;
+ *
+ * // Scrape elements by CSS selector.
+ * yield* browser.scrape({ url, elements: [{ selector: "h1" }] });
+ *
+ * // Extract all links.
+ * const { result: links } = yield* browser.links({ url });
+ *
+ * // Binary actions stream bytes — collect or pipe them.
+ * const png = yield* browser.screenshot({ url }).pipe(Stream.runCollect);
+ * const pdf = yield* browser.pdf({ url }).pipe(Stream.runCollect);
+ *
+ * // AI-extracted structured data.
+ * yield* browser.json({ url, prompt: "Extract the page heading" });
+ * ```
+ *
+ * @example Call the generic `quickAction` directly
+ * The named methods are thin wrappers over `quickAction`, which mirrors
+ * `cf.BrowserRun["quickAction"]` one-to-one.
+ * ```typescript
+ * const browser = yield* Cloudflare.Browser({ name: "BROWSER" });
+ *
+ * const res = yield* browser.quickAction("snapshot", {
+ *   url: "https://example.com",
+ * });
+ * ```
+ *
+ * @section Driving Puppeteer
+ * @example Use the raw `cf.BrowserRun` binding with `@cloudflare/puppeteer`
+ * `raw` hands you the underlying runtime binding. Puppeteer is promise-based,
+ * so this is the one place you reach for `Effect.tryPromise`.
  * ```typescript
  * import puppeteer from "@cloudflare/puppeteer";
  * import * as Effect from "effect/Effect";
@@ -62,25 +129,30 @@ export const isBrowser = (value: unknown): value is Browser =>
  *   "BrowserWorker",
  *   { main: import.meta.filename },
  *   Effect.gen(function* () {
- *     // Attaches the binding to this Worker AND returns the runtime client.
  *     const browser = yield* Cloudflare.Browser({ name: "BROWSER" });
  *
  *     return {
- *       fetch: browser.withBrowser(puppeteer, (browser) =>
- *         Effect.gen(function* () {
- *           const page = yield* Effect.tryPromise(() => browser.newPage());
+ *       fetch: Effect.gen(function* () {
+ *         const binding = yield* browser.raw;
+ *         const session = yield* Effect.tryPromise(() =>
+ *           puppeteer.launch(binding),
+ *         );
+ *         try {
+ *           const page = yield* Effect.tryPromise(() => session.newPage());
  *           yield* Effect.tryPromise(() => page.goto("https://example.com"));
  *           const title = yield* Effect.tryPromise(() => page.title());
  *           return Response.json({ title });
- *         }),
- *       ),
+ *         } finally {
+ *           yield* Effect.promise(() => session.close());
+ *         }
+ *       }),
  *     };
  *   }).pipe(Effect.provide(Cloudflare.BrowserBindingLive)),
  * );
  * ```
  *
  * @section Worker binding metadata
- * @example
+ * @example Declare the binding on `env`
  * ```typescript
  * export const Worker = Cloudflare.Worker("Worker", {
  *   main: "./src/worker.ts",
@@ -90,7 +162,7 @@ export const isBrowser = (value: unknown): value is Browser =>
  * });
  *
  * export type WorkerEnv = Cloudflare.InferEnv<typeof Worker>;
- * //   { BROWSER: Fetcher }
+ * //   { BROWSER: BrowserRun }
  * ```
  *
  * @example Async-style worker with the raw runtime binding

package/src/Cloudflare/Browser/BrowserBinding.ts

@@ -2,8 +2,10 @@ 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 Stream from "effect/Stream";
 import * as Binding from "../../Binding.ts";
 import type { ResourceLike } from "../../Resource.ts";
+import type { RuntimeContext } from "../../RuntimeContext.ts";
 import { isWorker, WorkerEnvironment } from "../Workers/Worker.ts";
 import type { Browser as BrowserLike } from "./Browser.ts";
 
@@ -12,39 +14,143 @@ export class BrowserError extends Data.TaggedError("BrowserError")<{
   cause: unknown;
 }> {}
 
-export interface BrowserHandle {
-  close(): Promise<void>;
-}
+/** The `Response` type returned by the Cloudflare Browser Rendering binding. */
+type BrowserResponse = Awaited<ReturnType<cf.BrowserRun["fetch"]>>;
 
-export interface BrowserPuppeteer<Browser extends BrowserHandle> {
-  launch(binding: cf.Fetcher): Promise<Browser>;
-}
+/** An Effect produced by a {@link BrowserClient} operation. */
+type BrowserEffect<A> = Effect.Effect<A, BrowserError, RuntimeContext>;
+
+/** A byte stream produced by a binary {@link BrowserClient} action. */
+type BrowserByteStream = Stream.Stream<
+  Uint8Array,
+  BrowserError,
+  RuntimeContext
+>;
+
+// Quick action option types, re-exported so callers don't reach into the
+// `@cloudflare/workers-types` namespace directly.
+export type BrowserScreenshotOptions = cf.BrowserRunScreenshotOptions;
+export type BrowserPDFOptions = cf.BrowserRunPDFOptions;
+export type BrowserContentOptions = cf.BrowserRunContentOptions;
+export type BrowserScrapeOptions = cf.BrowserRunScrapeOptions;
+export type BrowserLinksOptions = cf.BrowserRunLinksOptions;
+export type BrowserSnapshotOptions = cf.BrowserRunSnapshotOptions;
+export type BrowserJsonOptions = cf.BrowserRunJsonOptions;
+export type BrowserMarkdownOptions = cf.BrowserRunMarkdownOptions;
+
+// Quick action success payloads.
+export type BrowserContentResult = cf.BrowserRunContentSuccessResponse;
+export type BrowserScrapeResult = cf.BrowserRunScrapeSuccessResponse;
+export type BrowserLinksResult = cf.BrowserRunLinksSuccessResponse;
+export type BrowserSnapshotResult = cf.BrowserRunSnapshotSuccessResponse;
+export type BrowserJsonResult = cf.BrowserRunJsonSuccessResponse;
+export type BrowserMarkdownResult = cf.BrowserRunMarkdownSuccessResponse;
+export type BrowserErrorResponse = cf.BrowserRunErrorResponse;
 
 /**
  * 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.
+ * Mirrors the runtime {@link cf.BrowserRun} binding, translating its shapes
+ * into Effect-native ones: JSON quick actions resolve to their parsed success
+ * payload, and binary actions (`screenshot`, `pdf`) resolve to a `Stream` of
+ * the response bytes. Non-success responses fail with {@link BrowserError}, so
+ * callers never touch a `Promise` or `Response.json()` themselves. Use
+ * `Cloudflare.Browser.bind(browser)` (or `yield* Cloudflare.Browser(...)`)
+ * inside a Worker's init phase to obtain it.
+ *
+ * The {@link raw} accessor and {@link fetch} are the only promise-shaped
+ * escape hatches — they exist for libraries like `@cloudflare/puppeteer` that
+ * consume the binding directly.
  */
 export interface BrowserClient {
   /**
    * Effect resolving to the raw Cloudflare Browser Rendering runtime binding.
+   *
+   * Pass it to `@cloudflare/puppeteer`'s `puppeteer.launch(binding)` to drive a
+   * full browser session.
+   */
+  raw: Effect.Effect<cf.BrowserRun, never, RuntimeContext>;
+  /**
+   * Send a raw HTTP request to the Browser Run API and resolve to the raw
+   * `Response`. Used by libraries like `@cloudflare/puppeteer` to acquire and
+   * connect to a browser instance.
+   */
+  fetch(
+    ...args: Parameters<cf.BrowserRun["fetch"]>
+  ): BrowserEffect<BrowserResponse>;
+  /**
+   * Run a Browser Run quick action, resolving to the parsed success payload
+   * (or a byte `Stream` for binary actions). Mirrors
+   * `cf.BrowserRun["quickAction"]`; the {@link screenshot}, {@link pdf},
+   * {@link content}, {@link scrape}, {@link links}, {@link snapshot},
+   * {@link json}, and {@link markdown} methods are thin wrappers over the
+   * corresponding action.
+   */
+  quickAction(
+    action: "screenshot",
+    options: BrowserScreenshotOptions,
+  ): BrowserByteStream;
+  quickAction(action: "pdf", options: BrowserPDFOptions): BrowserByteStream;
+  quickAction(
+    action: "content",
+    options: BrowserContentOptions,
+  ): BrowserEffect<BrowserContentResult>;
+  quickAction(
+    action: "scrape",
+    options: BrowserScrapeOptions,
+  ): BrowserEffect<BrowserScrapeResult>;
+  quickAction(
+    action: "links",
+    options: BrowserLinksOptions,
+  ): BrowserEffect<BrowserLinksResult>;
+  quickAction(
+    action: "snapshot",
+    options: BrowserSnapshotOptions,
+  ): BrowserEffect<BrowserSnapshotResult>;
+  quickAction(
+    action: "json",
+    options: BrowserJsonOptions,
+  ): BrowserEffect<BrowserJsonResult>;
+  quickAction(
+    action: "markdown",
+    options: BrowserMarkdownOptions,
+  ): BrowserEffect<BrowserMarkdownResult>;
+  /**
+   * Take a screenshot of a web page, streaming the raw image bytes.
+   */
+  screenshot(options: BrowserScreenshotOptions): BrowserByteStream;
+  /**
+   * Generate a PDF of a web page, streaming the raw PDF bytes.
+   */
+  pdf(options: BrowserPDFOptions): BrowserByteStream;
+  /**
+   * Get the HTML content of a web page.
+   */
+  content(options: BrowserContentOptions): BrowserEffect<BrowserContentResult>;
+  /**
+   * Scrape elements from a web page by CSS selector.
+   */
+  scrape(options: BrowserScrapeOptions): BrowserEffect<BrowserScrapeResult>;
+  /**
+   * Extract all links from a web page.
+   */
+  links(options: BrowserLinksOptions): BrowserEffect<BrowserLinksResult>;
+  /**
+   * Get both the HTML content and a base64-encoded screenshot of a web page.
    */
-  raw: Effect.Effect<cf.Fetcher, never, WorkerEnvironment>;
+  snapshot(
+    options: BrowserSnapshotOptions,
+  ): BrowserEffect<BrowserSnapshotResult>;
   /**
-   * Launch a Browser Rendering session through `@cloudflare/puppeteer`.
+   * Extract structured JSON data from a web page using AI.
    */
-  launch<Browser extends BrowserHandle>(
-    puppeteer: BrowserPuppeteer<Browser>,
-  ): Effect.Effect<Browser, BrowserError, WorkerEnvironment>;
+  json(options: BrowserJsonOptions): BrowserEffect<BrowserJsonResult>;
   /**
-   * Launch a browser, run an Effect with it, and close it afterward.
+   * Convert a web page to Markdown.
    */
-  withBrowser<Browser extends BrowserHandle, A, E, R>(
-    puppeteer: BrowserPuppeteer<Browser>,
-    use: (browser: Browser) => Effect.Effect<A, E, R>,
-  ): Effect.Effect<A, BrowserError | E, WorkerEnvironment | R>;
+  markdown(
+    options: BrowserMarkdownOptions,
+  ): BrowserEffect<BrowserMarkdownResult>;
 }
 
 export class BrowserBinding extends Binding.Service<
@@ -56,14 +162,14 @@ export const BrowserBindingLive = Layer.effect(
   BrowserBinding,
   Effect.gen(function* () {
     const Policy = yield* BrowserBindingPolicy;
+    const env = yield* WorkerEnvironment;
 
     return Effect.fn(function* (browser: BrowserLike) {
       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]!,
-      );
+      const raw: Effect.Effect<cf.BrowserRun, never, RuntimeContext> =
+        Effect.sync(
+          () => (env as Record<string, cf.BrowserRun>)[browser.name]!,
+        );
       return makeBrowserClient(raw);
     });
   }),
@@ -106,23 +212,89 @@ const tryPromise = <T>(fn: () => Promise<T>): Effect.Effect<T, BrowserError> =>
       }),
   });
 
+/** Actions whose successful response is raw binary rather than JSON. */
+const BINARY_ACTIONS = new Set(["screenshot", "pdf"]);
+
+/** Build a {@link BrowserError} from a non-success Browser Run response. */
+const failResponse = (
+  action: string,
+  response: BrowserResponse,
+): Effect.Effect<never, BrowserError> =>
+  tryPromise(() => response.text()).pipe(
+    Effect.flatMap((body) => {
+      let cause: unknown = body;
+      try {
+        cause = JSON.parse(body);
+      } catch {
+        // keep the raw text as the cause
+      }
+      const message =
+        (cause as cf.BrowserRunErrorResponse | undefined)?.errors?.[0]
+          ?.message ??
+        `Browser Rendering '${action}' failed with status ${response.status}`;
+      return Effect.fail(new BrowserError({ message, cause }));
+    }),
+  );
+
 /** @internal */
 export const makeBrowserClient = (
-  raw: Effect.Effect<cf.Fetcher, never, WorkerEnvironment>,
+  raw: Effect.Effect<cf.BrowserRun, never, RuntimeContext>,
 ): BrowserClient => {
-  const launch = <Browser extends BrowserHandle>(
-    puppeteer: BrowserPuppeteer<Browser>,
-  ) =>
+  const respond = (
+    action: string,
+    options: unknown,
+  ): Effect.Effect<BrowserResponse, BrowserError, RuntimeContext> =>
     raw.pipe(
-      Effect.flatMap((binding) => tryPromise(() => puppeteer.launch(binding))),
+      Effect.flatMap((binding) =>
+        tryPromise(() => binding.quickAction(action as any, options as any)),
+      ),
+      Effect.flatMap((response) =>
+        response.ok ? Effect.succeed(response) : failResponse(action, response),
+      ),
+    );
+
+  const jsonAction = <T>(action: string, options: unknown): BrowserEffect<T> =>
+    respond(action, options).pipe(
+      Effect.flatMap((response) =>
+        tryPromise(() => response.json() as Promise<T>),
+      ),
     );
 
+  const streamAction = (action: string, options: unknown): BrowserByteStream =>
+    respond(action, options).pipe(
+      Effect.map((response) =>
+        Stream.fromReadableStream({
+          evaluate: () =>
+            response.body as any as ReadableStream<Uint8Array<ArrayBufferLike>>,
+          onError: (cause) =>
+            new BrowserError({
+              message: `Browser Rendering '${action}' stream failed`,
+              cause,
+            }),
+        }),
+      ),
+      Stream.unwrap,
+    );
+
+  const quickAction = ((action: string, options: unknown) =>
+    BINARY_ACTIONS.has(action)
+      ? streamAction(action, options)
+      : jsonAction(action, options)) as BrowserClient["quickAction"];
+
   return {
     raw,
-    launch,
-    withBrowser: (puppeteer, use) =>
-      Effect.acquireUseRelease(launch(puppeteer), use, (browser) =>
-        tryPromise(() => browser.close()),
+    fetch: (...args) =>
+      raw.pipe(
+        Effect.flatMap((binding) => tryPromise(() => binding.fetch(...args))),
       ),
+    quickAction,
+    screenshot: (options) => streamAction("screenshot", options),
+    pdf: (options) => streamAction("pdf", options),
+    content: (options) => jsonAction("content", options),
+    scrape: (options) => jsonAction("scrape", options),
+    links: (options) => jsonAction("links", options),
+    snapshot: (options) => jsonAction("snapshot", options),
+    json: (options) => jsonAction("json", options),
+    markdown: (options) => jsonAction("markdown", options),
   } satisfies BrowserClient;
 };

package/src/Cloudflare/Browser/index.ts

@@ -6,6 +6,19 @@ export {
   BrowserBindingPolicyLive,
   BrowserError,
   type BrowserClient,
-  type BrowserHandle,
-  type BrowserPuppeteer,
+  type BrowserScreenshotOptions,
+  type BrowserPDFOptions,
+  type BrowserContentOptions,
+  type BrowserScrapeOptions,
+  type BrowserLinksOptions,
+  type BrowserSnapshotOptions,
+  type BrowserJsonOptions,
+  type BrowserMarkdownOptions,
+  type BrowserContentResult,
+  type BrowserScrapeResult,
+  type BrowserLinksResult,
+  type BrowserSnapshotResult,
+  type BrowserJsonResult,
+  type BrowserMarkdownResult,
+  type BrowserErrorResponse,
 } from "./BrowserBinding.ts";

package/src/Cloudflare/CloudflareEnvironment.ts

@@ -4,7 +4,7 @@ import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import { getAuthProvider } from "../Auth/AuthProvider.ts";
-import { ALCHEMY_PROFILE, Profile } from "../Auth/Profile.ts";
+import { ALCHEMY_PROFILE, AlchemyProfile } from "../Auth/Profile.ts";
 import {
   CLOUDFLARE_AUTH_PROVIDER_NAME,
   type CloudflareAuthConfig,
@@ -13,7 +13,7 @@ import {
 
 export class CloudflareEnvironment extends Context.Service<
   CloudflareEnvironment,
-  CloudflareResolvedCredentials
+  Effect.Effect<CloudflareResolvedCredentials>
 >()("Cloudflare::CloudflareEnvironment") {}
 
 const CLOUDFLARE_ACCOUNT_ID = Config.string("CLOUDFLARE_ACCOUNT_ID");
@@ -34,7 +34,7 @@ export const fromProfile = () =>
   Layer.effect(
     CloudflareEnvironment,
     Effect.gen(function* () {
-      const profile = yield* Profile;
+      const profile = yield* AlchemyProfile;
       const auth = yield* getAuthProvider<
         CloudflareAuthConfig,
         CloudflareResolvedCredentials
@@ -44,7 +44,12 @@ export const fromProfile = () =>
       // `loadOrConfigure` reads the persisted config under the canonical
       // provider name (`Cloudflare`); only runs `configure` (and persists the
       // result) if no stored config exists.
-      const config = yield* profile.loadOrConfigure(auth, profileName, { ci });
-      return yield* auth.read(profileName, config as CloudflareAuthConfig);
+      return yield* profile.loadOrConfigure(auth, profileName, { ci }).pipe(
+        Effect.flatMap((config) =>
+          auth.read(profileName, config as CloudflareAuthConfig),
+        ),
+        Effect.orDie,
+        Effect.cached,
+      );
     }),
   );

package/src/Cloudflare/Container/ContainerApplication.ts

@@ -354,23 +354,10 @@ export const ContainerProvider = () =>
     Container,
     Effect.gen(function* () {
       const stack = yield* Stack;
-      const { accountId } = yield* CloudflareEnvironment;
       const { dotAlchemy } = yield* AlchemyContext;
       const fs = yield* FileSystem.FileSystem;
       const virtualEntryPlugin = yield* Bundle.virtualEntryPlugin;
-      const createContainerApplication =
-        yield* Containers.createContainerApplication;
-      const updateContainerApplication =
-        yield* Containers.updateContainerApplication;
-      const deleteContainerApplication =
-        yield* Containers.deleteContainerApplication;
-      const getContainerApplication = yield* Containers.getContainerApplication;
-      const listContainerApplications =
-        yield* Containers.listContainerApplications;
-      const createContainerRegistryCredentials =
-        yield* Containers.createContainerRegistryCredentials;
-      const createContainerApplicationRollout =
-        yield* Containers.createContainerApplicationRollout;
+
       const telemetry = yield* CloudflareLogs;
 
       const createApplicationName = (id: string, name: string | undefined) =>
@@ -385,7 +372,9 @@ export const ContainerProvider = () =>
         });
 
       const findApplicationByName = Effect.fnUntraced(function* (name: string) {
-        return yield* listContainerApplications({ accountId }).pipe(
+        const { accountId } = yield* yield* CloudflareEnvironment;
+
+        return yield* Containers.listContainerApplications({ accountId }).pipe(
           Effect.map((apps) => apps.find((app) => app.name === name)),
         );
       });
@@ -393,7 +382,9 @@ export const ContainerProvider = () =>
       const findApplicationByNamespace = Effect.fnUntraced(function* (
         namespaceId: string,
       ) {
-        return yield* listContainerApplications({ accountId }).pipe(
+        const { accountId } = yield* yield* CloudflareEnvironment;
+
+        return yield* Containers.listContainerApplications({ accountId }).pipe(
           Effect.map((apps) =>
             apps.find((app) => app.durableObjects?.namespaceId === namespaceId),
           ),
@@ -433,6 +424,8 @@ export const ContainerProvider = () =>
             new Error("Container requires a `main` entrypoint."),
           );
         }
+        const { accountId } = yield* yield* CloudflareEnvironment;
+
         const runtime = props.runtime ?? "bun";
         const { files, hash: bundleHash } = yield* bundleProgram({
           id,
@@ -641,6 +634,8 @@ await Effect.runPromise(serverEffect).catch((err) => {
         imageRef: string,
         session?: { note: (message: string) => Effect.Effect<void> },
       ) {
+        const { accountId } = yield* yield* CloudflareEnvironment;
+
         const runtime = props.runtime ?? "bun";
 
         yield* Effect.logInfo(
@@ -687,12 +682,13 @@ await Effect.runPromise(serverEffect).catch((err) => {
         }
 
         const registryId = props.registryId ?? "registry.cloudflare.com";
-        const credentials = yield* createContainerRegistryCredentials({
-          accountId,
-          registryId,
-          permissions: ["pull", "push"],
-          expirationMinutes: 60,
-        });
+        const credentials =
+          yield* Containers.createContainerRegistryCredentials({
+            accountId,
+            registryId,
+            permissions: ["pull", "push"],
+            expirationMinutes: 60,
+          });
         const username = credentials.username ?? (credentials as any).user;
         if (!username) {
           return yield* Effect.fail(
@@ -718,6 +714,8 @@ await Effect.runPromise(serverEffect).catch((err) => {
         configuration: ContainerApplication.Configuration;
         rollout: ContainerApplication.Rollout | undefined;
       }) {
+        const { accountId } = yield* yield* CloudflareEnvironment;
+
         const strategy = rollout?.strategy ?? "immediate";
         const stepPercentage =
           strategy === "immediate" ? 100 : (rollout?.stepPercentage ?? 25);
@@ -725,7 +723,7 @@ await Effect.runPromise(serverEffect).catch((err) => {
         yield* retryForContainerApplicationReadiness(
           "rollout",
           applicationId,
-          createContainerApplicationRollout({
+          Containers.createContainerApplicationRollout({
             accountId,
             applicationId,
             description:
@@ -759,6 +757,8 @@ await Effect.runPromise(serverEffect).catch((err) => {
           | undefined;
         session: { note: (message: string) => Effect.Effect<void> };
       }) {
+        const { accountId } = yield* yield* CloudflareEnvironment;
+
         const describeError = (error: unknown) => {
           if (error instanceof Error) {
             return JSON.stringify(
@@ -816,7 +816,7 @@ await Effect.runPromise(serverEffect).catch((err) => {
           });
         });
 
-        const application = yield* createContainerApplication({
+        const application = yield* Containers.createContainerApplication({
           accountId,
           name,
           instances: news.instances ?? 1,
@@ -890,6 +890,8 @@ await Effect.runPromise(serverEffect).catch((err) => {
         existing: ContainerApplication["Attributes"];
         session: { note: (message: string) => Effect.Effect<void> };
       }) {
+        const { accountId } = yield* yield* CloudflareEnvironment;
+
         yield* Effect.logInfo(
           `Cloudflare Container update: preparing ${existing.applicationName}`,
         );
@@ -909,7 +911,7 @@ await Effect.runPromise(serverEffect).catch((err) => {
         const application = yield* retryForContainerApplicationReadiness(
           "update",
           existing.applicationId,
-          updateContainerApplication({
+          Containers.updateContainerApplication({
             accountId,
             applicationId: existing.applicationId,
             instances: news.instances ?? 1,
@@ -972,6 +974,7 @@ await Effect.runPromise(serverEffect).catch((err) => {
           if (!isResolved(news) || !isResolved(newBindings)) {
             return undefined;
           }
+          const { accountId } = yield* yield* CloudflareEnvironment;
 
           const name = yield* createApplicationName(id, news.name);
           const oldName = output?.applicationName
@@ -1061,7 +1064,7 @@ await Effect.runPromise(serverEffect).catch((err) => {
           // persistence failures.
           let existing: ContainerApplication["Attributes"] | undefined;
           if (output?.applicationId) {
-            existing = yield* getContainerApplication({
+            existing = yield* Containers.getContainerApplication({
               accountId: output.accountId,
               applicationId: output.applicationId,
             }).pipe(
@@ -1121,7 +1124,7 @@ await Effect.runPromise(serverEffect).catch((err) => {
             yield* session.note(
               `Recreating container application ${name} with durable object binding...`,
             );
-            yield* deleteContainerApplication({
+            yield* Containers.deleteContainerApplication({
               accountId: existing.accountId,
               applicationId: existing.applicationId,
             }).pipe(
@@ -1183,7 +1186,7 @@ await Effect.runPromise(serverEffect).catch((err) => {
           yield* Effect.logInfo(
             `Cloudflare Container delete: deleting ${output.applicationName}`,
           );
-          yield* deleteContainerApplication({
+          yield* Containers.deleteContainerApplication({
             accountId: output.accountId,
             applicationId: output.applicationId,
           }).pipe(
@@ -1214,7 +1217,7 @@ await Effect.runPromise(serverEffect).catch((err) => {
             yield* Effect.logInfo(
               `Cloudflare Container read: checking ${output.applicationName}`,
             );
-            attrs = yield* getContainerApplication({
+            attrs = yield* Containers.getContainerApplication({
               accountId: output.accountId,
               applicationId: output.applicationId,
             }).pipe(