alchemy 0.76.0 → 0.77.0

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

@@ -1,32 +1,20 @@
 import type { PluginConfig } from "@cloudflare/vite-plugin";
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { dirname } from "pathe";
-import { getDefaultConfigPath } from "../miniflare/paths.ts";
+import type { PluginOption } from "vite";
 import alchemyVite from "../vite/plugin.ts";
 
-const alchemy = (config?: PluginConfig) => {
-  const configPath = config?.configPath ?? getDefaultConfigPath();
-  // react-router type generation requries a wrangler.json and creates a chicken and egg problem
-  // we create a dummy wrangler.json file so that clean builds can be performed
-  if (!existsSync(configPath)) {
-    mkdirSync(dirname(configPath), { recursive: true });
-    writeFileSync(
-      configPath,
-      JSON.stringify(
-        {
-          name: "dummy",
-          compatibility_date: "2025-09-23",
-        },
-        null,
-        2,
-      ),
-    );
+const alchemy = (config: PluginConfig = {}): PluginOption => {
+  // plugin is not required for react-router typegen, so return a no-op to avoid errors
+  if (
+    process.argv.some((arg) => arg.includes("react-router")) &&
+    process.argv.includes("typegen")
+  ) {
+    return null;
   }
   return alchemyVite({
-    ...config,
     viteEnvironment: {
       name: "ssr",
     },
+    ...config,
   });
 };
 

package/src/cloudflare/vite/plugin.ts

@@ -26,9 +26,6 @@ const alchemy = (config?: PluginConfig): PluginOption => {
         config?.configPath ?? getDefaultConfigPath(),
       ),
       persistState,
-      experimental: config?.experimental ?? {
-        remoteBindings: true,
-      },
     }),
     {
       name: "alchemy-supress-watch",

package/src/cloudflare/worker-bundle.ts

@@ -308,8 +308,14 @@ export namespace WorkerBundleSource {
 
       for await (const result of hotReload.iterator) {
         count++;
+        if (result.errors.length > 0 || result.metafile == null) {
+          logger.error(
+            `Error bundling worker \`${this.props.id}\`, see detailed logs above.`,
+          );
+          continue;
+        }
         const { entrypoint, root, modules } = await this.formatBuildOutput(
-          result.metafile!,
+          result.metafile,
         );
         yield {
           entrypoint,
@@ -416,12 +422,16 @@ export namespace WorkerBundleSource {
       );
       const paths: string[] = [];
       let entrypoint: string | undefined;
+      let sourcemap: string | undefined;
       for (const [key, value] of Object.entries(metafile.outputs)) {
         const name = path.relative(outdir, path.resolve(this.props.cwd, key));
         paths.push(name);
         if (value.entryPoint === this.props.entrypoint) {
           entrypoint = name;
         }
+        if (name.endsWith(".map")) {
+          sourcemap = name;
+        }
       }
       if (!entrypoint) {
         throw new Error(
@@ -433,6 +443,23 @@ export namespace WorkerBundleSource {
             .join(", ")}`,
         );
       }
+      if (sourcemap != null) {
+        const map = JSON.parse(
+          await fs.readFile(path.join(outdir, sourcemap), "utf-8"),
+        ) as { sources: Array<string> };
+        map.sources = map.sources.map((source) => {
+          const originalPath = path.join(outdir, source);
+          const entrypointDir = path.dirname(
+            path.resolve(this.props.cwd, this.props.entrypoint),
+          );
+          return path.relative(entrypointDir, originalPath);
+        });
+        await fs.writeFile(
+          path.join(outdir, sourcemap),
+          JSON.stringify(map),
+          "utf-8",
+        );
+      }
       return {
         entrypoint,
         root: outdir,

package/src/cloudflare/worker-metadata.ts

@@ -312,7 +312,10 @@ export async function prepareWorkerMetadata(
         // let's now apply a herusitic based on binding name (assume binding name is consistent)
         // TODO(sam): this has a chance of being wrong, is that OK? Users should be encouraged to upgrade alchemy version and re-deploy
         const object = props.bindings?.[oldBinding.name];
-        if (object && isDurableObjectNamespace(object)) {
+        if (
+          object &&
+          (isDurableObjectNamespace(object) || isContainer(object))
+        ) {
           if (object.className === oldBinding.class_name) {
             // this is relatively safe to assume is the right match, do not delete
             return [];
@@ -683,10 +686,11 @@ export async function prepareWorkerMetadata(
 
 export function bumpMigrationTagVersion(tag?: string) {
   if (tag) {
-    if (!tag.match(/^v\d+$/)) {
-      throw new Error(`Invalid tag format: ${tag}. Expected format: v<number>`);
+    const version = tag.match(/^(alchemy:)?v(\d+)$/)?.[2];
+    if (!version) {
+      return "alchemy:v1";
     }
-    return `v${Number.parseInt(tag.slice(1), 10) + 1}`;
+    return `alchemy:v${Number.parseInt(version, 10) + 1}`;
   }
   return undefined;
 }

package/src/cloudflare/worker-subdomain.ts

@@ -126,7 +126,6 @@ export async function getWorkerSubdomain(
       `/accounts/${api.accountId}/workers/scripts/${scriptName}/subdomain`,
     ),
   ).catch((error): SubdomainResponse => {
-    console.log("error", error);
     if (error.status === 404) {
       return { enabled: false, previews_enabled: false };
     }

package/src/cloudflare/worker.ts

@@ -61,6 +61,7 @@ import { Workflow, isWorkflow, upsertWorkflow } from "./workflow.ts";
 // This import is here to avoid errors when destroying the `Bundle` resource.
 import "../esbuild/bundle.ts";
 import { Scope } from "../scope.ts";
+import { extractCloudflareResult } from "./api-response.ts";
 import type { WorkerRef } from "./worker-ref.ts";
 import { createEmptyWorker, exists } from "./worker-stub.ts";
 
@@ -1586,54 +1587,40 @@ export async function putWorker(
   return withExponentialBackoff(
     async () => {
       const { body, endpoint, method } = await prepareWorkerUpload(api, props);
-      const uploadResponse = await api.fetch(endpoint, {
-        method,
-        headers: {
-          "Content-Type": "multipart/form-data",
-        },
-        body,
-      });
-
-      // Check if the upload was successful
-      if (!uploadResponse.ok) {
-        try {
-          return await handleApiError(
-            uploadResponse,
-            version ? "uploading worker version" : "uploading worker script",
-            "worker",
-            workerName,
-          );
-        } catch (error) {
-          if (error instanceof CloudflareApiError && error.status === 412) {
-            // this happens when adopting a Worker managed with Wrangler
-            // because wrangler includes a migration tag and we do not
-            // currently, the only way to discover the old_tag is through the error message
-            // Get Worker Script Settings is meant to return it (according to the docs)
-            // but it doesn't work at runtime
-            //
-            // so, we catch the error and parse out the tag and then retry
-            if (error.message.includes("when expected tag is")) {
-              const newTag = error.message.match(
-                /when expected tag is ['"]?(v\d+)['"]?/,
-              )?.[1];
-              if (newTag) {
-                return await putWorker(api, {
-                  ...props,
-                  migrationTag: newTag,
-                });
-              }
-            } else {
-              throw error;
-            }
-          } else {
-            throw error;
+      try {
+        return await extractCloudflareResult<PutWorkerResult>(
+          version
+            ? `upload version for worker "${workerName}"`
+            : `upload worker script "${workerName}"`,
+          api.fetch(endpoint, {
+            method,
+            headers: {
+              "Content-Type": "multipart/form-data",
+            },
+            body,
+          }),
+        );
+      } catch (error) {
+        if (error instanceof CloudflareApiError && error.status === 412) {
+          // this happens when adopting a Worker managed with Wrangler
+          // because wrangler includes a migration tag and we do not
+          // currently, the only way to discover the old_tag is through the error message
+          // Get Worker Script Settings is meant to return it (according to the docs)
+          // but it doesn't work at runtime
+          //
+          // so, we catch the error and parse out the tag and then retry
+          const newTag = error.message.match(
+            /when expected tag is ['"]?([^'"]+)['"]?/,
+          )?.[1];
+          if (newTag) {
+            return await putWorker(api, {
+              ...props,
+              migrationTag: newTag,
+            });
           }
         }
+        throw error;
       }
-      const responseData = (await uploadResponse.json()) as {
-        result: PutWorkerResult;
-      };
-      return responseData.result;
     },
     (err) =>
       err.status === 404 ||