alchemy 0.90.0 → 0.91.2

package/src/cloudflare/bun-spa/bun-spa.ts

@@ -14,7 +14,10 @@ import {
   type WebsiteProps,
 } from "../website.ts";
 
-export interface BunSPAProps<B extends Bindings> extends WebsiteProps<B> {
+export interface BunSPAProps<
+  B extends Bindings,
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+> extends WebsiteProps<B, RPC> {
   /**
    * The path to the frontend entrypoints that bun should bundle for deployment & serve in dev mode.
    * These are usually html files. Glob patterns are supported.
@@ -24,12 +27,18 @@ export interface BunSPAProps<B extends Bindings> extends WebsiteProps<B> {
   outDir?: string;
 }
 
-export type BunSPA<B extends Bindings> = Website<B> & { apiUrl: string };
+export type BunSPA<
+  B extends Bindings,
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+> = Website<B, RPC> & { apiUrl: string };
 
-export async function BunSPA<B extends Bindings>(
+export async function BunSPA<
+  B extends Bindings,
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+>(
   id: string,
-  props: BunSPAProps<B>,
-): Promise<BunSPA<B> & { apiUrl: string }> {
+  props: BunSPAProps<B, RPC>,
+): Promise<BunSPA<B, RPC> & { apiUrl: string }> {
   const frontendPaths = Array.isArray(props.frontend)
     ? props.frontend.map((p) => path.resolve(p))
     : [path.resolve(props.frontend)];
@@ -132,7 +141,7 @@ export async function BunSPA<B extends Bindings>(
       },
     });
   }
-  return { ...website, apiUrl } as BunSPA<B>;
+  return { ...website, apiUrl } as BunSPA<B, RPC>;
 }
 
 async function validateBunfigToml(cwd: string): Promise<void> {

package/src/cloudflare/bundle/plugin-wasm.ts

@@ -2,6 +2,7 @@ import type esbuild from "esbuild";
 import assert from "node:assert";
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
+import { createRequire } from "node:module";
 import path from "pathe";
 import type { WorkerBundle } from "../worker-bundle.ts";
 
@@ -22,9 +23,27 @@ export function createWasmPlugin() {
           return { path: resolved.path, external: true };
         }
 
-        // Resolve path to source file, excluding the `?module` suffix (uses path.resolve in case args.path is already absolute)
+        // Resolve path to source file, excluding the `?module` suffix
         const normalizedPath = path.normalize(args.path).replace(/\?.*$/, "");
-        const copyFrom = path.resolve(args.resolveDir, normalizedPath);
+
+        // Determine the source file: use Node module resolution for bare specifiers (npm packages),
+        // otherwise resolve relative to the importing file's directory
+        let copyFrom: string;
+        if (/^[./]/.test(normalizedPath)) {
+          copyFrom = path.resolve(args.resolveDir, normalizedPath);
+        } else {
+          try {
+            // createRequire needs a file path to anchor node_modules resolution from.
+            // The filename is a dummy — only the directory matters.
+            const esmRequire = createRequire(
+              path.join(args.resolveDir, "noop.js"),
+            );
+            copyFrom = esmRequire.resolve(normalizedPath);
+          } catch {
+            // Fall back to the original behavior if require.resolve fails
+            copyFrom = path.resolve(args.resolveDir, normalizedPath);
+          }
+        }
 
         // Resolve path to outdir (required for monorepos if the workdir is not the same as process.cwd())
         assert(

package/src/cloudflare/container.ts

@@ -410,6 +410,14 @@ export interface ContainerApplicationProps extends CloudflareApiOptions {
    */
   adopt?: boolean;
 
+  /**
+   * Whether to delete the container application when removed from Alchemy.
+   * If set to false, the container application will remain but the resource will be removed from state.
+   *
+   * @default true
+   */
+  delete?: boolean;
+
   /**
    * If true, the container application will not be created, but will be retained if it already exists.
    * This is used for local development.
@@ -557,7 +565,7 @@ export const ContainerApplication = Resource(
 
     const api = await createCloudflareApi(props);
     if (this.phase === "delete") {
-      if (this.output?.id) {
+      if (props.delete !== false && this.output?.id) {
         // Delete the container application
         await deleteContainerApplication(api, this.output.id);
       }

package/src/cloudflare/custom-domain.ts

@@ -44,6 +44,14 @@ export interface CustomDomainProps extends CloudflareApiOptions {
    */
   adopt?: boolean;
 
+  /**
+   * Whether to delete the custom domain when removed from Alchemy.
+   * If set to false, the custom domain will remain but the resource will be removed from state.
+   *
+   * @default true
+   */
+  delete?: boolean;
+
   /**
    * If true, the custom domain will not be created, but will be retained if it already exists.
    * This is used for local development.
@@ -137,7 +145,9 @@ export const CustomDomain = Resource(
     const api = await createCloudflareApi(props);
 
     if (this.phase === "delete") {
-      await deleteCustomDomain(this, api, logicalId, props);
+      if (props.delete !== false) {
+        await deleteCustomDomain(this, api, logicalId, props);
+      }
       return this.destroy();
     }
 

package/src/cloudflare/nuxt/nuxt.ts

@@ -14,16 +14,20 @@ import type { Worker } from "../worker.ts";
  * Properties for creating a Nuxt resource.
  * Extends WebsiteProps, allowing customization of the underlying Website.
  */
-export interface NuxtProps<B extends Bindings> extends WebsiteProps<B> {}
+export interface NuxtProps<
+  B extends Bindings,
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+> extends WebsiteProps<B, RPC> {}
 
 /**
  * Represents the output of a Nuxt resource deployment.
  * It resolves to the underlying Cloudflare Worker type, ensuring type safety.
  * Prevents overriding the internal ASSETS binding.
  */
-export type Nuxt<B extends Bindings> = B extends { ASSETS: any }
-  ? never
-  : Worker<B & { ASSETS: Assets }>;
+export type Nuxt<
+  B extends Bindings,
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+> = B extends { ASSETS: any } ? never : Worker<B & { ASSETS: Assets }, RPC>;
 
 /**
  * Creates and deploys a Nuxt application using the Cloudflare Workers preset.
@@ -52,10 +56,10 @@ export type Nuxt<B extends Bindings> = B extends { ASSETS: any }
  *   },
  * });
  */
-export async function Nuxt<B extends Bindings>(
-  id: string,
-  props?: Partial<NuxtProps<B>>,
-): Promise<Nuxt<B>> {
+export async function Nuxt<
+  B extends Bindings,
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+>(id: string, props?: Partial<NuxtProps<B, RPC>>): Promise<Nuxt<B, RPC>> {
   const runner = await getPackageManagerRunner();
   return await Website(id, {
     ...props,

package/src/cloudflare/react-router/react-router.ts

@@ -5,7 +5,10 @@ import type { Bindings } from "../bindings.ts";
 import { Vite, type ViteProps } from "../vite/vite.ts";
 import type { Worker } from "../worker.ts";
 
-export interface ReactRouterProps<B extends Bindings> extends ViteProps<B> {
+export interface ReactRouterProps<
+  B extends Bindings,
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+> extends ViteProps<B, RPC> {
   /**
    * @default workers/app.ts
    */
@@ -13,14 +16,18 @@ export interface ReactRouterProps<B extends Bindings> extends ViteProps<B> {
 }
 
 // don't allow the ASSETS to be overriden
-export type ReactRouter<B extends Bindings> = B extends { ASSETS: any }
-  ? never
-  : Worker<B & { ASSETS: Assets }>;
+export type ReactRouter<
+  B extends Bindings,
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+> = B extends { ASSETS: any } ? never : Worker<B & { ASSETS: Assets }, RPC>;
 
-export async function ReactRouter<B extends Bindings>(
+export async function ReactRouter<
+  B extends Bindings,
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+>(
   id: string,
-  props: ReactRouterProps<B> = {},
-): Promise<ReactRouter<B>> {
+  props: ReactRouterProps<B, RPC> = {},
+): Promise<ReactRouter<B, RPC>> {
   const runner = await getPackageManagerRunner();
   const cwd = path.resolve(props.cwd ?? process.cwd());
   const ssr = await detectSSREnabled(cwd);

package/src/cloudflare/redwood/redwood.ts

@@ -4,12 +4,16 @@ import type { Bindings } from "../bindings.ts";
 import { Vite, type ViteProps } from "../vite/vite.ts";
 import type { Worker } from "../worker.ts";
 
-export interface RedwoodProps<B extends Bindings> extends ViteProps<B> {}
+export interface RedwoodProps<
+  B extends Bindings,
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+> extends ViteProps<B, RPC> {}
 
 // don't allow the ASSETS to be overridden
-export type Redwood<B extends Bindings> = B extends { ASSETS: any }
-  ? never
-  : Worker<B & { ASSETS: Assets }>;
+export type Redwood<
+  B extends Bindings,
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+> = B extends { ASSETS: any } ? never : Worker<B & { ASSETS: Assets }, RPC>;
 
 /**
  * Deploy a RedwoodJS application to Cloudflare Workers with automatically configured defaults.
@@ -37,10 +41,10 @@ export type Redwood<B extends Bindings> = B extends { ASSETS: any }
  * @param props - Configuration properties for the RedwoodJS deployment
  * @returns A Cloudflare Worker resource representing the deployed RedwoodJS application
  */
-export async function Redwood<B extends Bindings>(
-  id: string,
-  props?: Partial<RedwoodProps<B>>,
-): Promise<Redwood<B>> {
+export async function Redwood<
+  B extends Bindings,
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+>(id: string, props?: Partial<RedwoodProps<B, RPC>>): Promise<Redwood<B, RPC>> {
   return await Vite(id, {
     ...props,
     build: props?.build ?? {

package/src/cloudflare/route.ts

@@ -49,6 +49,14 @@ export interface RouteProps extends CloudflareApiOptions {
    */
   adopt?: boolean;
 
+  /**
+   * Whether to delete the route when removed from Alchemy.
+   * If set to false, the route will remain but the resource will be removed from state.
+   *
+   * @default true
+   */
+  delete?: boolean;
+
   /**
    * If true, the route will not be created, but will be retained if it already exists.
    * This is used for local development.
@@ -151,7 +159,7 @@ export const Route = Resource(
 
       // Only delete if we have complete output data (both ID and zoneId)
       // If creation failed, we won't have proper output, so just skip deletion
-      if (this.output?.id && this.output?.zoneId) {
+      if (props.delete !== false && this.output?.id && this.output?.zoneId) {
         await deleteRoute(api, this.output.zoneId, this.output.id);
       }
 

package/src/cloudflare/sveltekit/sveltekit.ts

@@ -4,12 +4,16 @@ import type { Bindings } from "../bindings.ts";
 import { Vite, type ViteProps } from "../vite/vite.ts";
 import type { Worker } from "../worker.ts";
 
-export interface SvelteKitProps<B extends Bindings> extends ViteProps<B> {}
+export interface SvelteKitProps<
+  B extends Bindings,
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+> extends ViteProps<B, RPC> {}
 
 // don't allow the ASSETS to be overriden
-export type SvelteKit<B extends Bindings> = B extends { ASSETS: any }
-  ? never
-  : Worker<B & { ASSETS: Assets }>;
+export type SvelteKit<
+  B extends Bindings,
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+> = B extends { ASSETS: any } ? never : Worker<B & { ASSETS: Assets }, RPC>;
 
 /**
  * Deploy a SvelteKit application to Cloudflare Workers with automatically configured defaults.
@@ -47,10 +51,13 @@ export type SvelteKit<B extends Bindings> = B extends { ASSETS: any }
  * @param props - Configuration properties for the SvelteKit deployment
  * @returns A Cloudflare Worker resource representing the deployed SvelteKit application
  */
-export async function SvelteKit<B extends Bindings>(
+export async function SvelteKit<
+  B extends Bindings,
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+>(
   id: string,
-  props?: Partial<SvelteKitProps<B>>,
-): Promise<SvelteKit<B>> {
+  props?: Partial<SvelteKitProps<B, RPC>>,
+): Promise<SvelteKit<B, RPC>> {
   if (props?.compatibilityDate) {
     const providedDate = new Date(props.compatibilityDate);
     const minDate = new Date("2024-09-23");

package/src/cloudflare/tanstack-start/tanstack-start.ts

@@ -5,17 +5,24 @@ import type { Bindings } from "../bindings.ts";
 import { Vite, type ViteProps } from "../vite/vite.ts";
 import type { Worker } from "../worker.ts";
 
-export interface TanStackStartProps<B extends Bindings> extends ViteProps<B> {}
+export interface TanStackStartProps<
+  B extends Bindings,
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+> extends ViteProps<B, RPC> {}
 
 // don't allow the ASSETS to be overriden
-export type TanStackStart<B extends Bindings> = B extends { ASSETS: any }
-  ? never
-  : Worker<B & { ASSETS: Assets }>;
+export type TanStackStart<
+  B extends Bindings,
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+> = B extends { ASSETS: any } ? never : Worker<B & { ASSETS: Assets }, RPC>;
 
-export async function TanStackStart<B extends Bindings>(
+export async function TanStackStart<
+  B extends Bindings,
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+>(
   id: string,
-  props?: Partial<TanStackStartProps<B>>,
-): Promise<TanStackStart<B>> {
+  props?: Partial<TanStackStartProps<B, RPC>>,
+): Promise<TanStackStart<B, RPC>> {
   const main =
     props?.wrangler?.main ??
     ((await exists(path.resolve(props?.cwd ?? process.cwd(), "src/server.ts")))

package/src/cloudflare/vite/vite.ts

@@ -11,16 +11,20 @@ import {
 } from "../website.ts";
 import type { Worker } from "../worker.ts";
 
-export interface ViteProps<B extends Bindings> extends WebsiteProps<B> {}
+export interface ViteProps<
+  B extends Bindings,
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+> extends WebsiteProps<B, RPC> {}
 
-export type Vite<B extends Bindings> = B extends { ASSETS: any }
-  ? never
-  : Worker<B & { ASSETS: Assets }>;
+export type Vite<
+  B extends Bindings,
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+> = B extends { ASSETS: any } ? never : Worker<B & { ASSETS: Assets }, RPC>;
 
-export async function Vite<B extends Bindings>(
-  id: string,
-  props: ViteProps<B>,
-): Promise<Vite<B>> {
+export async function Vite<
+  B extends Bindings,
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+>(id: string, props: ViteProps<B, RPC>): Promise<Vite<B, RPC>> {
   const runner = await getPackageManagerRunner();
   let dev = spreadDevProps(props, `${runner} vite dev`);
   let domain = typeof dev === "object" ? dev.domain : undefined;

package/src/cloudflare/website.ts

@@ -18,10 +18,10 @@ import { computeWorkerDevDomain } from "./worker-subdomain.ts";
 import { type AssetsConfig, Worker, type WorkerProps } from "./worker.ts";
 import { WranglerJson, type WranglerJsonSpec } from "./wrangler.json.ts";
 
-export interface WebsiteProps<B extends Bindings> extends Omit<
-  WorkerProps<B>,
-  "assets" | "dev"
-> {
+export interface WebsiteProps<
+  B extends Bindings,
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+> extends Omit<WorkerProps<B, RPC>, "assets" | "dev"> {
   /**
    * Configuration for the build command
    *
@@ -149,14 +149,15 @@ export interface WebsiteProps<B extends Bindings> extends Omit<
   memoize?: boolean | { patterns: string[] };
 }
 
-export type Website<B extends Bindings> = B extends { ASSETS: any }
-  ? never
-  : Worker<B & { ASSETS: Assets }>;
+export type Website<
+  B extends Bindings,
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+> = B extends { ASSETS: any } ? never : Worker<B & { ASSETS: Assets }, RPC>;
 
-export async function Website<B extends Bindings>(
-  id: string,
-  props: WebsiteProps<B>,
-) {
+export async function Website<
+  B extends Bindings,
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+>(id: string, props: WebsiteProps<B, RPC>) {
   const {
     name = Scope.current.createPhysicalName(id).toLowerCase(),
     build: buildProps,
@@ -377,7 +378,7 @@ export async function Website<B extends Bindings>(
         : {}),
     },
     dev: url ? { url } : undefined,
-  })) as Website<B>;
+  })) as Website<B, RPC>;
 }
 
 export const spreadBuildProps = (

package/src/cloudflare/worker.ts

@@ -6,7 +6,11 @@ import type { type } from "../type.ts";
 import { DeferredPromise } from "../util/deferred-promise.ts";
 import { logger } from "../util/logger.ts";
 import { withExponentialBackoff } from "../util/retry.ts";
-import { CloudflareApiError, handleApiError } from "./api-error.ts";
+import {
+  CloudflareApiError,
+  handleApiError,
+  isCloudflareApiError,
+} from "./api-error.ts";
 import {
   type CloudflareApi,
   type CloudflareApiOptions,
@@ -207,6 +211,14 @@ export interface BaseWorkerProps<
    */
   logpush?: boolean;
 
+  /**
+   * Whether to delete the worker when removed from Alchemy.
+   * If set to false, the worker will remain but the resource will be removed from state.
+   *
+   * @default true
+   */
+  delete?: boolean;
+
   /**
    * Whether to adopt the Worker if it already exists when creating
    */
@@ -939,6 +951,14 @@ export type Worker<
  * // The worker will have a preview URL for testing:
  * console.log(`Preview URL: ${previewWorker.url}`);
  * // Output: Preview URL: https://pr-123-my-worker.subdomain.workers.dev
+ *
+ * @example
+ * // Prevent deletion of the worker when removed from Alchemy:
+ * const worker = await Worker("critical-api", {
+ *   name: "critical-api",
+ *   entrypoint: "./src/api.ts",
+ *   delete: false
+ * });
  */
 export function Worker<
   const B extends Bindings,
@@ -1104,7 +1124,7 @@ const _Worker = Resource(
         durableObjects: options.durableObjects,
         workflows: options.workflows,
       });
-      if (this.output?.dev?.hasRemote !== false) {
+      if (props.delete !== false && this.output?.dev?.hasRemote !== false) {
         const api = await createCloudflareApi(props);
         if (props.version) {
           //* if the worker exists we deploy an empty version so we can destroy
@@ -1250,45 +1270,49 @@ const _Worker = Resource(
 
     let result: PutWorkerResult;
 
+    // cloudflare has awkward sequencing requirements for modifying subdomains
+    // because conflicts with Durable Objects and preview_enabled is stateful
+    // to solve this, we try and do both in parallel and push them through
+    const bruteForce = <T>(operation: () => Promise<T>) =>
+      withExponentialBackoff(
+        operation,
+        (error) => {
+          operation;
+          return (
+            error instanceof CloudflareApiError &&
+            error.status === 400 &&
+            error.message.includes(
+              "Cannot use Durable Objects with Preview URLs",
+            )
+          );
+        },
+        10,
+        100,
+        1000,
+      );
+
     if (this.scope.watch) {
       const controller = new AbortController();
-      result = await watchWorker(api, props, {
-        id,
-        name: options.name,
-        dispatchNamespace: options.dispatchNamespace,
-        bundle,
-        compatibilityDate: options.compatibilityDate,
-        compatibilityFlags: options.compatibilityFlags,
-        version: props.version,
-        assets,
-        controller,
-      });
+      [result] = await Promise.all([
+        watchWorker(api, props, {
+          id,
+          name: options.name,
+          dispatchNamespace: options.dispatchNamespace,
+          bundle,
+          compatibilityDate: options.compatibilityDate,
+          compatibilityFlags: options.compatibilityFlags,
+          version: props.version,
+          assets,
+          controller,
+        }),
+        bruteForce(updateSubdomain),
+      ]);
       this.onCleanup(() => controller.abort());
       const tail = await createTail(api, id, options.name).catch((error) => {
         logger.error(`Failed to create tail for ${options.name}`, error);
       });
       this.onCleanup(() => tail?.close());
     } else {
-      // cloudflare has awkward sequencing requirements for modifying subdomains
-      // because conflicts with Durable Objects and preview_enabled is stateful
-      // to solve this, we try and do both in parallel and push them through
-      const bruteForce = <T>(operation: () => Promise<T>) =>
-        withExponentialBackoff(
-          operation,
-          (error) => {
-            operation;
-            return (
-              error instanceof CloudflareApiError &&
-              error.status === 400 &&
-              error.message.includes(
-                "Cannot use Durable Objects with Preview URLs",
-              )
-            );
-          },
-          10,
-          100,
-          1000,
-        );
       const scriptBundle = await bundle.create();
       const [_, _result] = await Promise.all([
         bruteForce(updateSubdomain),
@@ -1540,6 +1564,7 @@ async function provisionResources<B extends Bindings>(
               durableObjects: {
                 namespaceId: await getContainerNamespaceId(container),
               },
+              delete: props.delete,
               dev: options.local,
               ...input.api,
             });
@@ -1553,6 +1578,7 @@ async function provisionResources<B extends Bindings>(
               name: domain.name,
               zoneId: domain.zoneId,
               adopt: domain.adopt,
+              delete: props.delete,
               workerName: options.name,
               dev: options.local,
               ...input.api,
@@ -1575,6 +1601,7 @@ async function provisionResources<B extends Bindings>(
               scriptName: options.name,
               settings: eventSource.settings,
               adopt: props.adopt,
+              delete: props.delete,
               dev: options.local,
               ...input.api,
             });
@@ -1589,6 +1616,7 @@ async function provisionResources<B extends Bindings>(
               script: options.name,
               zoneId: route.zoneId,
               adopt: route.adopt,
+              delete: props.delete,
               dev: options.local,
               ...input.api,
             });
@@ -1839,6 +1867,16 @@ export async function putWorker(
             });
           }
         }
+        if (
+          isCloudflareApiError(error, { code: 11001 }) &&
+          !props.eventSources?.length
+        ) {
+          // Error code 11001 means that the worker has event sources, but no `queue` handler is defined.
+          // Normally, queue consumers are removed automatically since we're using the `QueueConsumer` resource,
+          // but if no `queue` handler is defined, we need to remove them for Cloudflare to let us deploy.
+          await deleteQueueConsumers(api, workerName);
+          return await putWorker(api, props);
+        }
         throw error;
       }
     },

package/workers/tunnel-proxy.js

@@ -83,7 +83,7 @@ const renderErrorHtml = (props) => `
             Alchemy</a>.</p>
       </div>
       <div class="bg-slate-200 px-5 py-3 flex flex-col w-full max-w-lg">
-        <p class="text-sm text-slate-500">Alchemy 0.90.0</p>
+        <p class="text-sm text-slate-500">Alchemy 0.91.2</p>
       </div>
     </div>
   </body>