alchemy 2.0.0-beta.43 → 2.0.0-beta.45

package/src/Cli/commands/_shared.ts

@@ -9,7 +9,12 @@ import * as Argument from "effect/unstable/cli/Argument";
 import * as CliError from "effect/unstable/cli/CliError";
 import * as Flag from "effect/unstable/cli/Flag";
 
-import { AuthError } from "../../Auth/AuthProvider.ts";
+import {
+  type AuthProvider,
+  AuthError,
+  AuthProviders,
+} from "../../Auth/AuthProvider.ts";
+import type { AlchemyProfile } from "../../Auth/Profile.ts";
 import type * as Stack from "../../Stack.ts";
 import { recordCli } from "../../Telemetry/Metrics.ts";
 import { PromptCancelled } from "../../Util/Clank.ts";
@@ -254,11 +259,49 @@ export const instrumentCommand =
       recordCli(command),
     );
 
+/**
+ * Render a profile's stored credential entries the same way across
+ * `alchemy login` and `alchemy profile show`: one `── Provider ──`
+ * header per entry, then either the provider's own `prettyPrint` block
+ * (preferred) or a JSON-style fallback when the provider isn't
+ * registered in the supplied {@link AuthProviders} registry.
+ */
+export const printProfile = Effect.fn(function* (
+  profile: string,
+  stored: AlchemyProfile,
+  registry: AuthProviders["Service"],
+) {
+  yield* Console.log(`Profile: ${profile}`);
+  const names = Object.keys(stored).sort();
+  if (names.length === 0) {
+    yield* Console.log("(no providers configured)");
+    return;
+  }
+  for (const name of names) {
+    const cfg = stored[name]!;
+    yield* Console.log("");
+    yield* Console.log(`── ${name} ──`);
+    const provider: AuthProvider | undefined = registry[name];
+    if (provider == null) {
+      yield* Console.log(`  method: ${cfg.method}`);
+      const { method: _method, ...rest } = cfg as Record<string, unknown> & {
+        method: string;
+      };
+      for (const [k, v] of Object.entries(rest)) {
+        yield* Console.log(
+          `  ${k}: ${typeof v === "string" ? v : JSON.stringify(v)}`,
+        );
+      }
+      continue;
+    }
+    yield* provider.prettyPrint(profile, cfg);
+  }
+});
+
 export const importStack = Effect.fn(function* (main: string) {
   const path = yield* Path.Path;
-  const module = yield* Effect.promise(
-    () => import(path.resolve(process.cwd(), main)),
-  );
+  const url = import.meta.resolve(path.resolve(main));
+  const module = yield* Effect.promise(() => import(url));
   const stackEffect = module.default as ReturnType<
     ReturnType<typeof Stack.make>
   >;

package/src/Cli/commands/dev.ts

@@ -1,8 +1,11 @@
 import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
 import * as Schema from "effect/Schema";
 import * as Command from "effect/unstable/cli/Command";
 import * as ChildProcess from "effect/unstable/process/ChildProcess";
 import { fileURLToPath } from "node:url";
+import { SPAWNER_URL_ENV_KEY } from "../../Local/RpcProviderProxy.ts";
+import * as RpcSpawner from "../../Local/RpcSpawner.ts";
 import { envFile, force, profile, script, stage } from "./_shared.ts";
 import { ExecStackOptions } from "./deploy.ts";
 
@@ -15,41 +18,64 @@ export const devCommand = Command.make(
     stage,
     profile,
   },
-  Effect.fn(function* (args) {
-    const options = yield* Schema.encodeEffect(ExecStackOptions)({
-      ...args,
-      yes: true,
-      dev: true,
-    });
-    // We no longer force Bun in development because this prevents us from testing in Node.
-    const command =
-      typeof globalThis.Bun !== "undefined"
-        ? [
-            "bun",
-            "run",
-            ...process.execArgv,
-            "--watch",
-            "--no-clear-screen",
-            fileURLToPath(import.meta.resolve("alchemy/bin/exec.ts")),
-          ]
-        : [
-            "node",
-            ...process.execArgv,
-            "--experimental-transform-types",
-            "--watch",
-            "--watch-preserve-output",
-            fileURLToPath(import.meta.resolve("alchemy/bin/exec.js")),
-          ];
-    const child = yield* ChildProcess.make(command[0], command.slice(1), {
-      stdin: "inherit",
-      stdout: "inherit",
-      stderr: "inherit",
-      env: {
-        ALCHEMY_EXEC_OPTIONS: JSON.stringify(options),
-      },
-      extendEnv: true,
-      detached: false,
-    });
-    yield* child.exitCode;
-  }),
+  Effect.fn(
+    function* (args) {
+      const options = yield* Schema.encodeEffect(ExecStackOptions)({
+        ...args,
+        yes: true,
+        dev: true,
+      });
+      const spawner = yield* RpcSpawner.RpcSpawner;
+      // We no longer force Bun in development because this prevents us from testing in Node.
+      const command =
+        typeof globalThis.Bun !== "undefined"
+          ? [
+              "bun",
+              "run",
+              ...process.execArgv,
+              "--watch",
+              "--no-clear-screen",
+              fileURLToPath(import.meta.resolve("alchemy/bin/exec.ts")),
+            ]
+          : [
+              "node",
+              ...process.execArgv,
+              ...(isTransformTypesSupported()
+                ? [
+                    "--experimental-transform-types",
+                    "--no-warnings=ExperimentalWarning",
+                  ]
+                : []),
+              "--watch",
+              "--watch-preserve-output",
+              fileURLToPath(import.meta.resolve("alchemy/bin/exec.js")),
+            ];
+      const child = yield* ChildProcess.make(command[0], command.slice(1), {
+        stdin: "inherit",
+        stdout: "inherit",
+        stderr: "inherit",
+        env: {
+          ALCHEMY_EXEC_OPTIONS: JSON.stringify(options),
+          [SPAWNER_URL_ENV_KEY]: spawner.url,
+        },
+        extendEnv: true,
+        detached: false,
+      });
+      yield* child.exitCode;
+    },
+    (effect, args) =>
+      Effect.provide(
+        RpcSpawner.layerServer({
+          profile: args.profile,
+          envFile: Option.getOrUndefined(args.envFile),
+        }),
+      )(effect),
+  ),
 );
+
+const isTransformTypesSupported = (
+  version = process.versions.node,
+): boolean => {
+  const [major, minor] = version.split(".").map(Number);
+  return (major === 22 && minor >= 7) || (major >= 23 && major < 26);
+};

package/src/Cli/commands/login.ts

@@ -18,6 +18,7 @@ import {
   envFile,
   importStack,
   instrumentCommand,
+  printProfile,
   profile,
   script,
   stage,
@@ -91,10 +92,12 @@ export const loginCommand = Command.make(
           (provider) =>
             Effect.gen(function* () {
               const existing = yield* profiles.getProfile(profile);
-              const stored = existing?.[provider.name];
+              // --configure treats every provider as missing, so configure
+              // runs unconditionally and overwrites the stored entry.
+              const stored = configure ? undefined : existing?.[provider.name];
 
               let cfg: { method: string };
-              if (configure || stored == null) {
+              if (stored == null) {
                 cfg = yield* provider.configure(profile, { ci });
                 yield* profiles.setProfile(profile, {
                   ...existing,
@@ -104,11 +107,24 @@ export const loginCommand = Command.make(
                 cfg = stored;
               }
 
-              yield* provider.login(profile, cfg);
-              yield* provider.prettyPrint(profile, cfg);
+              // `read` succeeds when creds are present and not expired
+              // (refreshing OAuth proactively if near expiry). Any failure
+              // — missing file, dead refresh token, etc. — falls through
+              // to `login`.
+              yield* provider
+                .read(profile, cfg)
+                .pipe(Effect.catch(() => provider.login(profile, cfg)));
             }),
           { discard: true },
         );
+
+        // Print the resulting profile using the same renderer as
+        // `alchemy profile show`.
+        const final = yield* profiles.getProfile(profile);
+        if (final != null) {
+          yield* Console.log("");
+          yield* printProfile(profile, final, authProviders);
+        }
       }).pipe(Effect.provide(services));
     }),
   ),

package/src/Cli/commands/profile.ts

@@ -9,11 +9,20 @@ import { AuthProviders } from "../../Auth/AuthProvider.ts";
 import { CredentialsStore } from "../../Auth/Credentials.ts";
 import { Profile, withProfileOverride } from "../../Auth/Profile.ts";
 import { AwsAuth } from "../../AWS/AuthProvider.ts";
+import { AxiomAuth } from "../../Axiom/AuthProvider.ts";
 import { CloudflareAuth } from "../../Cloudflare/Auth/AuthProvider.ts";
+import { GitHubAuth } from "../../GitHub/AuthProvider.ts";
+import { NeonAuth } from "../../Neon/AuthProvider.ts";
+import { PlanetscaleAuth } from "../../Planetscale/AuthProvider.ts";
 import { loadConfigProvider } from "../../Util/ConfigProvider.ts";
 import { fileLogger } from "../../Util/FileLogger.ts";
 
-import { envFile, instrumentCommand, profile } from "./_shared.ts";
+import {
+  envFile,
+  instrumentCommand,
+  printProfile,
+  profile,
+} from "./_shared.ts";
 
 const showCommand = Command.make(
   "show",
@@ -36,14 +45,6 @@ const showCommand = Command.make(
         return;
       }
 
-      yield* Console.log(`Profile: ${profile}`);
-
-      const providerNames = Object.keys(stored).sort();
-      if (providerNames.length === 0) {
-        yield* Console.log("(no providers configured)");
-        return;
-      }
-
       const authProviders: AuthProviders["Service"] = {};
       const authRegistry = Layer.succeed(AuthProviders, authProviders);
       const services = Layer.mergeAll(
@@ -54,33 +55,22 @@ const showCommand = Command.make(
         Logger.layer([fileLogger("out")], { mergeWithExisting: true }),
         // Building these layers triggers their AuthProviderLayer effect, which
         // registers the provider into the shared `authProviders` registry.
-        Layer.provide(Layer.mergeAll(CloudflareAuth, AwsAuth), authRegistry),
+        Layer.provide(
+          Layer.mergeAll(
+            AwsAuth,
+            AxiomAuth,
+            CloudflareAuth,
+            GitHubAuth,
+            NeonAuth,
+            PlanetscaleAuth,
+          ),
+          authRegistry,
+        ),
       );
 
-      yield* Effect.gen(function* () {
-        for (const name of providerNames) {
-          const cfg = stored[name]!;
-          yield* Console.log("");
-          yield* Console.log(`── ${name} ──`);
-          const provider = authProviders[name];
-          if (provider == null) {
-            // Unknown provider — fall back to a JSON dump so the user can still
-            // see what's stored even if its module isn't bundled into the CLI.
-            yield* Console.log(`method: ${cfg.method}`);
-            const { method: _method, ...rest } = cfg as Record<
-              string,
-              unknown
-            > & { method: string };
-            for (const [k, v] of Object.entries(rest)) {
-              yield* Console.log(
-                `${k}: ${typeof v === "string" ? v : JSON.stringify(v)}`,
-              );
-            }
-            continue;
-          }
-          yield* provider.prettyPrint(profile, cfg);
-        }
-      }).pipe(Effect.provide(services));
+      yield* printProfile(profile, stored, authProviders).pipe(
+        Effect.provide(services),
+      );
     }),
   ),
 );

package/src/Cli/exec.ts

@@ -7,17 +7,22 @@ import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
 import { AlchemyContextLive } from "../AlchemyContext.ts";
 import { CredentialsStoreLive } from "../Auth/Credentials.ts";
 import { ProfileLive } from "../Auth/Profile.ts";
+import * as RpcProviderProxy from "../Local/RpcProviderProxy.ts";
 import { PlatformServices } from "../Util/PlatformServices.ts";
 import { execStack, ExecStackOptions } from "./commands/deploy.ts";
 import { selectCli } from "./selectCli.ts";
 
-const services = Layer.mergeAll(
-  Layer.provideMerge(AlchemyContextLive, PlatformServices),
-  Layer.provide(ProfileLive, PlatformServices),
-  Layer.provide(CredentialsStoreLive, PlatformServices),
-  FetchHttpClient.layer,
-  ConfigProvider.layer(ConfigProvider.fromEnv()),
-  selectCli(),
+const services = Layer.merge(selectCli(), RpcProviderProxy.fromEnv()).pipe(
+  Layer.provideMerge(
+    Layer.mergeAll(AlchemyContextLive, ProfileLive, CredentialsStoreLive),
+  ),
+  Layer.provideMerge(
+    Layer.mergeAll(
+      PlatformServices,
+      FetchHttpClient.layer,
+      ConfigProvider.layer(ConfigProvider.fromEnv()),
+    ),
+  ),
 );
 
 export const exec = () =>

package/src/Cli/main.ts

@@ -8,12 +8,9 @@ import { AlchemyContextLive } from "alchemy/AlchemyContext";
 import { CredentialsStoreLive } from "alchemy/Auth/Credentials";
 import { ProfileLive } from "alchemy/Auth/Profile";
 import { TelemetryLive } from "alchemy/Telemetry/Layer";
-import { installLocalhostDns } from "alchemy/Util/LocalhostDns";
 import { PlatformServices } from "alchemy/Util/PlatformServices";
 import packageJson from "../../package.json" with { type: "json" };
 
-installLocalhostDns();
-
 import { checkLatestVersion } from "./checkVersion.ts";
 import { handleCancellation } from "./commands/_shared.ts";
 import { awsCommand } from "./commands/aws.ts";

package/src/Cloudflare/AiGateway/AiGateway.ts

@@ -190,8 +190,6 @@ export type AiGateway = Resource<
   {
     gatewayId: string;
     accountId: string;
-    accountTag: string | undefined;
-    internalId: string | undefined;
     cacheInvalidateOnUpdate: boolean;
     cacheTtl: number | null;
     collectLogs: boolean;
@@ -328,8 +326,8 @@ export const AiGatewayProvider = () =>
       ): AiGateway["Attributes"] => ({
         gatewayId: gateway.id,
         accountId,
-        accountTag: gateway.accountTag ?? undefined,
-        internalId: gateway.internalId ?? undefined,
+        // accountTag: gateway.accountTag ?? undefined,
+        // internalId: gateway.internalId ?? undefined,
         cacheInvalidateOnUpdate: gateway.cacheInvalidateOnUpdate,
         cacheTtl: nullIfZero(gateway.cacheTtl),
         collectLogs: gateway.collectLogs,
@@ -387,7 +385,6 @@ export const AiGatewayProvider = () =>
           rateLimitingLimit: next.rateLimitingLimit,
           rateLimitingTechnique: next.rateLimitingTechnique,
           authentication: next.authentication,
-          isDefault: next.isDefault,
           logManagement: next.logManagement,
           logManagementStrategy: next.logManagementStrategy,
           logpush: next.logpush,
@@ -413,7 +410,6 @@ export const AiGatewayProvider = () =>
           rateLimitingTechnique: next.rateLimitingTechnique,
           authentication: next.authentication,
           dlp: next.dlp,
-          isDefault: next.isDefault,
           logManagement: next.logManagement,
           logManagementStrategy: next.logManagementStrategy,
           logpush: next.logpush,

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";