wrangler 0.0.0-e3cab74 → 0.0.0-e3e3243

package/src/__tests__/publish.test.ts

@@ -2,14 +2,19 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import * as TOML from "@iarna/toml";
 import { mockAccountId, mockApiToken } from "./helpers/mock-account-id";
-import { setMockResponse, unsetAllMocks } from "./helpers/mock-cfetch";
+import {
+  createFetchResult,
+  setMockRawResponse,
+  setMockResponse,
+  unsetAllMocks,
+  unsetMockFetchKVGetValues,
+} from "./helpers/mock-cfetch";
 import { mockConsoleMethods } from "./helpers/mock-console";
 import { mockKeyListRequest } from "./helpers/mock-kv";
 import { runInTempDir } from "./helpers/run-in-tmp";
 import { runWrangler } from "./helpers/run-wrangler";
 import writeWranglerToml from "./helpers/write-wrangler-toml";
-import type { WorkerMetadata } from "../api/form_data";
-import type { Config } from "../config";
+import type { WorkerMetadata } from "../create-worker-upload-form";
 import type { KVNamespaceInfo } from "../kv";
 import type { FormData, File } from "undici";
 
@@ -27,11 +32,12 @@ describe("publish", () => {
 
   afterEach(() => {
     unsetAllMocks();
+    unsetMockFetchKVGetValues();
   });
 
   describe("environments", () => {
     it("should use legacy environments by default", async () => {
-      writeWranglerToml();
+      writeWranglerToml({ env: { "some-env": {} } });
       writeWorkerSource();
       mockSubDomainRequest();
       mockUploadWorkerRequest({
@@ -40,14 +46,9 @@ describe("publish", () => {
       });
       await runWrangler("publish index.js --env some-env");
       expect(std.out).toMatchInlineSnapshot(`
-        "Uploaded
-        test-name-some-env
-        (TIMINGS)
-        Published
-        test-name-some-env
-        (TIMINGS)
-
-        test-name-some-env.test-sub-domain.workers.dev"
+        "Uploaded test-name-some-env (TIMINGS)
+        Published test-name-some-env (TIMINGS)
+          test-name-some-env.test-sub-domain.workers.dev"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
       expect(std.warn).toMatchInlineSnapshot(`""`);
@@ -63,21 +64,16 @@ describe("publish", () => {
         });
         await runWrangler("publish index.js --legacy-env true");
         expect(std.out).toMatchInlineSnapshot(`
-          "Uploaded
-          test-name
-          (TIMINGS)
-          Published
-          test-name
-          (TIMINGS)
-
-          test-name.test-sub-domain.workers.dev"
+          "Uploaded test-name (TIMINGS)
+          Published test-name (TIMINGS)
+            test-name.test-sub-domain.workers.dev"
         `);
         expect(std.err).toMatchInlineSnapshot(`""`);
         expect(std.warn).toMatchInlineSnapshot(`""`);
       });
 
-      it("appends the environment name when provided", async () => {
-        writeWranglerToml();
+      it("appends the environment name when provided, and there is associated config", async () => {
+        writeWranglerToml({ env: { "some-env": {} } });
         writeWorkerSource();
         mockSubDomainRequest();
         mockUploadWorkerRequest({
@@ -86,18 +82,77 @@ describe("publish", () => {
         });
         await runWrangler("publish index.js --env some-env --legacy-env true");
         expect(std.out).toMatchInlineSnapshot(`
-          "Uploaded
-          test-name-some-env
-          (TIMINGS)
-          Published
-          test-name-some-env
-          (TIMINGS)
-
-          test-name-some-env.test-sub-domain.workers.dev"
+          "Uploaded test-name-some-env (TIMINGS)
+          Published test-name-some-env (TIMINGS)
+            test-name-some-env.test-sub-domain.workers.dev"
         `);
         expect(std.err).toMatchInlineSnapshot(`""`);
         expect(std.warn).toMatchInlineSnapshot(`""`);
       });
+
+      it("appends the environment name when provided (with a warning), if there are no configured environments", async () => {
+        writeWranglerToml({});
+        writeWorkerSource();
+        mockSubDomainRequest();
+        mockUploadWorkerRequest({
+          env: "some-env",
+          legacyEnv: true,
+        });
+        await runWrangler("publish index.js --env some-env --legacy-env true");
+        expect(std.out).toMatchInlineSnapshot(`
+          "Uploaded test-name-some-env (TIMINGS)
+          Published test-name-some-env (TIMINGS)
+            test-name-some-env.test-sub-domain.workers.dev"
+        `);
+        expect(std.err).toMatchInlineSnapshot(`""`);
+        expect(std.warn).toMatchInlineSnapshot(`
+          "Processing wrangler.toml configuration:
+            - No environment found in configuration with name \\"some-env\\".
+              Before using \`--env=some-env\` there should be an equivalent environment section in the configuration.
+
+              Consider adding an environment configuration section to the wrangler.toml file:
+              \`\`\`
+              [env.some-env]
+              \`\`\`
+          "
+        `);
+      });
+
+      it("should throw an error when an environment name when provided, which doesn't match those in the config", async () => {
+        writeWranglerToml({ env: { "other-env": {} } });
+        writeWorkerSource();
+        mockSubDomainRequest();
+        await expect(
+          runWrangler("publish index.js --env some-env --legacy-env true")
+        ).rejects.toThrowErrorMatchingInlineSnapshot(`
+                "Processing wrangler.toml configuration:
+                  - No environment found in configuration with name \\"some-env\\".
+                    Before using \`--env=some-env\` there should be an equivalent environment section in the configuration.
+                    The available configured environment names are: [\\"other-env\\"]
+
+                    Consider adding an environment configuration section to the wrangler.toml file:
+                    \`\`\`
+                    [env.some-env]
+                    \`\`\`
+                "
+              `);
+      });
+
+      it("should throw an error w/ helpful message when using --env --name", async () => {
+        writeWranglerToml({ env: { "some-env": {} } });
+        writeWorkerSource();
+        mockSubDomainRequest();
+        await runWrangler(
+          "publish index.js --name voyager --env some-env --legacy-env true"
+        ).catch((err) =>
+          expect(err).toMatchInlineSnapshot(`
+            [Error: In legacy environment mode you cannot use --name and --env together. If you want to specify a Worker name for a specific environment you can add the following to your wrangler.toml config:
+                [env.some-env]
+                name = "voyager"
+                ]
+          `)
+        );
+      });
     });
 
     describe("services", () => {
@@ -110,21 +165,16 @@ describe("publish", () => {
         });
         await runWrangler("publish index.js");
         expect(std.out).toMatchInlineSnapshot(`
-          "Uploaded
-          test-name
-          (TIMINGS)
-          Published
-          test-name
-          (TIMINGS)
-
-          test-name.test-sub-domain.workers.dev"
+          "Uploaded test-name (TIMINGS)
+          Published test-name (TIMINGS)
+            test-name.test-sub-domain.workers.dev"
         `);
         expect(std.err).toMatchInlineSnapshot(`""`);
         expect(std.warn).toMatchInlineSnapshot(`""`);
       });
 
       it("publishes as an environment when provided", async () => {
-        writeWranglerToml();
+        writeWranglerToml({ env: { "some-env": {} } });
         writeWorkerSource();
         mockSubDomainRequest();
         mockUploadWorkerRequest({
@@ -133,14 +183,9 @@ describe("publish", () => {
         });
         await runWrangler("publish index.js --env some-env --legacy-env false");
         expect(std.out).toMatchInlineSnapshot(`
-          "Uploaded
-          test-name (some-env)
-          (TIMINGS)
-          Published
-          test-name (some-env)
-          (TIMINGS)
-
-          some-env.test-name.test-sub-domain.workers.dev"
+          "Uploaded test-name (some-env) (TIMINGS)
+          Published test-name (some-env) (TIMINGS)
+            some-env.test-name.test-sub-domain.workers.dev"
         `);
         expect(std.err).toMatchInlineSnapshot(`""`);
         expect(std.warn).toMatchInlineSnapshot(`""`);
@@ -168,18 +213,14 @@ describe("publish", () => {
           type: "json",
         },
       ],
+      expectedCompatibilityDate: "2022-01-12",
     });
     mockSubDomainRequest();
     await runWrangler("publish ./some-path/worker/index.js");
     expect(std.out).toMatchInlineSnapshot(`
-      "Uploaded
-      test-name
-      (TIMINGS)
-      Published
-      test-name
-      (TIMINGS)
-
-      test-name.test-sub-domain.workers.dev"
+      "Uploaded test-name (TIMINGS)
+      Published test-name (TIMINGS)
+        test-name.test-sub-domain.workers.dev"
     `);
     expect(std.err).toMatchInlineSnapshot(`""`);
   });
@@ -255,14 +296,9 @@ describe("publish", () => {
       await runWrangler("publish ./index");
 
       expect(std.out).toMatchInlineSnapshot(`
-        "Uploaded
-        test-name
-        (TIMINGS)
-        Published
-        test-name
-        (TIMINGS)
-
-        test-name.test-sub-domain.workers.dev"
+        "Uploaded test-name (TIMINGS)
+        Published test-name (TIMINGS)
+          test-name.test-sub-domain.workers.dev"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
     });
@@ -276,14 +312,9 @@ describe("publish", () => {
       await runWrangler("publish ./index");
 
       expect(std.out).toMatchInlineSnapshot(`
-        "Uploaded
-        test-name
-        (TIMINGS)
-        Published
-        test-name
-        (TIMINGS)
-
-        test-name.test-sub-domain.workers.dev"
+        "Uploaded test-name (TIMINGS)
+        Published test-name (TIMINGS)
+          test-name.test-sub-domain.workers.dev"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
     });
@@ -297,14 +328,9 @@ describe("publish", () => {
       await runWrangler("publish");
 
       expect(std.out).toMatchInlineSnapshot(`
-        "Uploaded
-        test-name
-        (TIMINGS)
-        Published
-        test-name
-        (TIMINGS)
-
-        test-name.test-sub-domain.workers.dev"
+        "Uploaded test-name (TIMINGS)
+        Published test-name (TIMINGS)
+          test-name.test-sub-domain.workers.dev"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
     });
@@ -320,14 +346,9 @@ describe("publish", () => {
       await runWrangler("publish");
 
       expect(std.out).toMatchInlineSnapshot(`
-        "Uploaded
-        test-name
-        (TIMINGS)
-        Published
-        test-name
-        (TIMINGS)
-
-        test-name.test-sub-domain.workers.dev"
+        "Uploaded test-name (TIMINGS)
+        Published test-name (TIMINGS)
+          test-name.test-sub-domain.workers.dev"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
     });
@@ -341,14 +362,9 @@ describe("publish", () => {
       await runWrangler("publish");
 
       expect(std.out).toMatchInlineSnapshot(`
-        "Uploaded
-        test-name
-        (TIMINGS)
-        Published
-        test-name
-        (TIMINGS)
-
-        test-name.test-sub-domain.workers.dev"
+        "Uploaded test-name (TIMINGS)
+        Published test-name (TIMINGS)
+          test-name.test-sub-domain.workers.dev"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
       expect(std.warn).toMatchInlineSnapshot(`
@@ -378,14 +394,9 @@ describe("publish", () => {
       await runWrangler("publish");
 
       expect(std.out).toMatchInlineSnapshot(`
-        "Uploaded
-        test-name
-        (TIMINGS)
-        Published
-        test-name
-        (TIMINGS)
-
-        test-name.test-sub-domain.workers.dev"
+        "Uploaded test-name (TIMINGS)
+        Published test-name (TIMINGS)
+          test-name.test-sub-domain.workers.dev"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
       expect(std.warn).toMatchInlineSnapshot(`
@@ -428,14 +439,9 @@ describe("publish", () => {
       await runWrangler("publish index.ts");
 
       expect(std.out).toMatchInlineSnapshot(`
-        "Uploaded
-        test-name
-        (TIMINGS)
-        Published
-        test-name
-        (TIMINGS)
-
-        test-name.test-sub-domain.workers.dev"
+        "Uploaded test-name (TIMINGS)
+        Published test-name (TIMINGS)
+          test-name.test-sub-domain.workers.dev"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
     });
@@ -451,14 +457,9 @@ describe("publish", () => {
       await runWrangler("publish index.ts");
 
       expect(std.out).toMatchInlineSnapshot(`
-        "Uploaded
-        test-name
-        (TIMINGS)
-        Published
-        test-name
-        (TIMINGS)
-
-        test-name.test-sub-domain.workers.dev"
+        "Uploaded test-name (TIMINGS)
+        Published test-name (TIMINGS)
+          test-name.test-sub-domain.workers.dev"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
     });
@@ -486,14 +487,9 @@ export default{
       mockSubDomainRequest();
       await runWrangler("publish index.js");
       expect(std.out).toMatchInlineSnapshot(`
-        "Uploaded
-        test-name
-        (TIMINGS)
-        Published
-        test-name
-        (TIMINGS)
-
-        test-name.test-sub-domain.workers.dev"
+        "Uploaded test-name (TIMINGS)
+        Published test-name (TIMINGS)
+          test-name.test-sub-domain.workers.dev"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
     });
@@ -507,14 +503,9 @@ export default{
       await runWrangler("publish ./src/index.js");
 
       expect(std.out).toMatchInlineSnapshot(`
-        "Uploaded
-        test-name
-        (TIMINGS)
-        Published
-        test-name
-        (TIMINGS)
-
-        test-name.test-sub-domain.workers.dev"
+        "Uploaded test-name (TIMINGS)
+        Published test-name (TIMINGS)
+          test-name.test-sub-domain.workers.dev"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
     });
@@ -531,23 +522,17 @@ export default{
       await runWrangler("publish ./src/index.js");
 
       expect(std.out).toMatchInlineSnapshot(`
-        "Uploaded
-        test-name
-        (TIMINGS)
-        Published
-        test-name
-        (TIMINGS)
-
-        test-name.test-sub-domain.workers.dev"
+        "Uploaded test-name (TIMINGS)
+        Published test-name (TIMINGS)
+          test-name.test-sub-domain.workers.dev"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
     });
 
     it('should error if a site definition doesn\'t have a "bucket" field', async () => {
       writeWranglerToml({
-        site: {
-          "entry-point": "./index.js",
-        } as Config["site"],
+        // @ts-expect-error we're intentionally setting an invalid config
+        site: {},
       });
       writeWorkerSource();
       mockUploadWorkerRequest();
@@ -556,21 +541,20 @@ export default{
       await expect(runWrangler("publish ./index.js")).rejects
         .toThrowErrorMatchingInlineSnapshot(`
               "Processing wrangler.toml configuration:
-                - ERROR: \\"site.bucket\\" is a required field."
+                - \\"site.bucket\\" is a required field."
             `);
 
       expect(std.out).toMatchInlineSnapshot(`""`);
       expect(std.err).toMatchInlineSnapshot(`
         "Processing wrangler.toml configuration:
-          - ERROR: \\"site.bucket\\" is a required field.
+          - \\"site.bucket\\" is a required field.
 
-        %s
-        If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
+        %s If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
       `);
       expect(std.warn).toMatchInlineSnapshot(`""`);
     });
 
-    it("should warn if there is a `site.entry-point` configuration", async () => {
+    it("should error if there is a `site.entry-point` configuration", async () => {
       const assets = [
         { filePath: "assets/file-1.txt", content: "Content of file-1" },
         { filePath: "assets/file-2.txt", content: "Content of file-2" },
@@ -594,27 +578,26 @@ export default{
       mockKeyListRequest(kvNamespace.id, []);
       mockUploadAssetsToKVRequest(kvNamespace.id, assets);
 
-      await runWrangler("publish ./index.js");
+      await expect(runWrangler("publish ./index.js")).rejects
+        .toThrowErrorMatchingInlineSnapshot(`
+              "Processing wrangler.toml configuration:
+                - DEPRECATION: \\"site.entry-point\\":
+                  The \`site.entry-point\` config field is no longer used.
+                  The entry-point should be specified via the command line or the \`main\` config field."
+            `);
 
-      expect(std.out).toMatchInlineSnapshot(`
-        "reading assets/file-1.txt...
-        uploading as assets/file-1.2ca234f380.txt...
-        reading assets/file-2.txt...
-        uploading as assets/file-2.5938485188.txt...
-        Uploaded
-        test-name
-        (TIMINGS)
-        Published
-        test-name
-        (TIMINGS)
+      expect(std.out).toMatchInlineSnapshot(`""`);
+      expect(std.err).toMatchInlineSnapshot(`
+        "Processing wrangler.toml configuration:
+          - DEPRECATION: \\"site.entry-point\\":
+            The \`site.entry-point\` config field is no longer used.
+            The entry-point should be specified via the command line or the \`main\` config field.
 
-        test-name.test-sub-domain.workers.dev"
+        %s If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
       `);
-      expect(std.err).toMatchInlineSnapshot(`""`);
       expect(std.warn).toMatchInlineSnapshot(`
-        "Deprecation notice: The \`site.entry-point\` config field is no longer used.
-        The entry-point should be specified via the command line (e.g. \`wrangler publish path/to/script\`) or the \`main\` config field.
-        Please remove the \`site.entry-point\` field from the \`wrangler.toml\` file."
+        "Processing wrangler.toml configuration:
+          - Unexpected fields found in site field: \\"entry-point\\""
       `);
     });
 
@@ -633,8 +616,7 @@ export default{
       expect(std.err).toMatchInlineSnapshot(`
         "Missing entry-point: The entry-point should be specified via the command line (e.g. \`wrangler publish path/to/script\`) or the \`main\` config field.
 
-        %s
-        If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
+        %s If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
       `);
     });
   });
@@ -669,14 +651,10 @@ export default{
         uploading as assets/file-1.2ca234f380.txt...
         reading assets/file-2.txt...
         uploading as assets/file-2.5938485188.txt...
-        Uploaded
-        test-name
-        (TIMINGS)
-        Published
-        test-name
-        (TIMINGS)
-
-        test-name.test-sub-domain.workers.dev"
+        ↗️  Done syncing assets
+        Uploaded test-name (TIMINGS)
+        Published test-name (TIMINGS)
+          test-name.test-sub-domain.workers.dev"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
     });
@@ -729,14 +707,10 @@ export default{
         uploading as assets/file-1.2ca234f380.txt...
         reading assets/file-2.txt...
         uploading as assets/file-2.5938485188.txt...
-        Uploaded
-        test-name
-        (TIMINGS)
-        Published
-        test-name
-        (TIMINGS)
-
-        test-name.test-sub-domain.workers.dev"
+        ↗️  Done syncing assets
+        Uploaded test-name (TIMINGS)
+        Published test-name (TIMINGS)
+          test-name.test-sub-domain.workers.dev"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
     });
@@ -783,14 +757,10 @@ export default{
         uploading as assets/file-1.2ca234f380.txt...
         reading assets/file-2.txt...
         uploading as assets/file-2.5938485188.txt...
-        Uploaded
-        test-name
-        (TIMINGS)
-        Published
-        test-name
-        (TIMINGS)
-
-        test-name.test-sub-domain.workers.dev"
+        ↗️  Done syncing assets
+        Uploaded test-name (TIMINGS)
+        Published test-name (TIMINGS)
+          test-name.test-sub-domain.workers.dev"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
     });
@@ -810,6 +780,7 @@ export default{
         site: {
           bucket: "assets",
         },
+        env: { "some-env": {} },
       });
       writeWorkerSource();
       writeAssets(assets);
@@ -834,14 +805,10 @@ export default{
         uploading as assets/file-1.2ca234f380.txt...
         reading assets/file-2.txt...
         uploading as assets/file-2.5938485188.txt...
-        Uploaded
-        test-name (some-env)
-        (TIMINGS)
-        Published
-        test-name (some-env)
-        (TIMINGS)
-
-        some-env.test-name.test-sub-domain.workers.dev"
+        ↗️  Done syncing assets
+        Uploaded test-name (some-env) (TIMINGS)
+        Published test-name (some-env) (TIMINGS)
+          some-env.test-name.test-sub-domain.workers.dev"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
     });
@@ -861,6 +828,7 @@ export default{
         site: {
           bucket: "assets",
         },
+        env: { "some-env": {} },
       });
       writeWorkerSource();
       writeAssets(assets);
@@ -886,14 +854,10 @@ export default{
         uploading as assets/file-1.2ca234f380.txt...
         reading assets/file-2.txt...
         uploading as assets/file-2.5938485188.txt...
-        Uploaded
-        test-name-some-env
-        (TIMINGS)
-        Published
-        test-name-some-env
-        (TIMINGS)
-
-        test-name-some-env.test-sub-domain.workers.dev"
+        ↗️  Done syncing assets
+        Uploaded test-name-some-env (TIMINGS)
+        Published test-name-some-env (TIMINGS)
+          test-name-some-env.test-sub-domain.workers.dev"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
     });
@@ -919,7 +883,9 @@ export default{
       mockSubDomainRequest();
       mockListKVNamespacesRequest(kvNamespace);
       // Put file-1 in the KV namespace
-      mockKeyListRequest(kvNamespace.id, ["assets/file-1.2ca234f380.txt"]);
+      mockKeyListRequest(kvNamespace.id, [
+        { name: "assets/file-1.2ca234f380.txt" },
+      ]);
       // Check we do not upload file-1
       mockUploadAssetsToKVRequest(
         kvNamespace.id,
@@ -932,14 +898,10 @@ export default{
         skipping - already uploaded
         reading assets/file-2.txt...
         uploading as assets/file-2.5938485188.txt...
-        Uploaded
-        test-name
-        (TIMINGS)
-        Published
-        test-name
-        (TIMINGS)
-
-        test-name.test-sub-domain.workers.dev"
+        ↗️  Done syncing assets
+        Uploaded test-name (TIMINGS)
+        Published test-name (TIMINGS)
+          test-name.test-sub-domain.workers.dev"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
     });
@@ -975,14 +937,10 @@ export default{
       expect(std.out).toMatchInlineSnapshot(`
         "reading assets/file-1.txt...
         uploading as assets/file-1.2ca234f380.txt...
-        Uploaded
-        test-name
-        (TIMINGS)
-        Published
-        test-name
-        (TIMINGS)
-
-        test-name.test-sub-domain.workers.dev"
+        ↗️  Done syncing assets
+        Uploaded test-name (TIMINGS)
+        Published test-name (TIMINGS)
+          test-name.test-sub-domain.workers.dev"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
     });
@@ -1018,14 +976,10 @@ export default{
       expect(std.out).toMatchInlineSnapshot(`
         "reading assets/file-1.txt...
         uploading as assets/file-1.2ca234f380.txt...
-        Uploaded
-        test-name
-        (TIMINGS)
-        Published
-        test-name
-        (TIMINGS)
-
-        test-name.test-sub-domain.workers.dev"
+        ↗️  Done syncing assets
+        Uploaded test-name (TIMINGS)
+        Published test-name (TIMINGS)
+          test-name.test-sub-domain.workers.dev"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
     });
@@ -1062,14 +1016,10 @@ export default{
       expect(std.out).toMatchInlineSnapshot(`
         "reading assets/file-1.txt...
         uploading as assets/file-1.2ca234f380.txt...
-        Uploaded
-        test-name
-        (TIMINGS)
-        Published
-        test-name
-        (TIMINGS)
-
-        test-name.test-sub-domain.workers.dev"
+        ↗️  Done syncing assets
+        Uploaded test-name (TIMINGS)
+        Published test-name (TIMINGS)
+          test-name.test-sub-domain.workers.dev"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
     });
@@ -1106,14 +1056,10 @@ export default{
       expect(std.out).toMatchInlineSnapshot(`
         "reading assets/file-1.txt...
         uploading as assets/file-1.2ca234f380.txt...
-        Uploaded
-        test-name
-        (TIMINGS)
-        Published
-        test-name
-        (TIMINGS)
-
-        test-name.test-sub-domain.workers.dev"
+        ↗️  Done syncing assets
+        Uploaded test-name (TIMINGS)
+        Published test-name (TIMINGS)
+          test-name.test-sub-domain.workers.dev"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
     });
@@ -1150,14 +1096,10 @@ export default{
       expect(std.out).toMatchInlineSnapshot(`
         "reading assets/file-1.txt...
         uploading as assets/file-1.2ca234f380.txt...
-        Uploaded
-        test-name
-        (TIMINGS)
-        Published
-        test-name
-        (TIMINGS)
-
-        test-name.test-sub-domain.workers.dev"
+        ↗️  Done syncing assets
+        Uploaded test-name (TIMINGS)
+        Published test-name (TIMINGS)
+          test-name.test-sub-domain.workers.dev"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
     });
@@ -1194,14 +1136,10 @@ export default{
       expect(std.out).toMatchInlineSnapshot(`
         "reading assets/file-1.txt...
         uploading as assets/file-1.2ca234f380.txt...
-        Uploaded
-        test-name
-        (TIMINGS)
-        Published
-        test-name
-        (TIMINGS)
-
-        test-name.test-sub-domain.workers.dev"
+        ↗️  Done syncing assets
+        Uploaded test-name (TIMINGS)
+        Published test-name (TIMINGS)
+          test-name.test-sub-domain.workers.dev"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
     });
@@ -1240,14 +1178,10 @@ export default{
       expect(std.out).toMatchInlineSnapshot(`
         "reading assets/directory-1/file-1.txt...
         uploading as assets/directory-1/file-1.2ca234f380.txt...
-        Uploaded
-        test-name
-        (TIMINGS)
-        Published
-        test-name
-        (TIMINGS)
-
-        test-name.test-sub-domain.workers.dev"
+        ↗️  Done syncing assets
+        Uploaded test-name (TIMINGS)
+        Published test-name (TIMINGS)
+          test-name.test-sub-domain.workers.dev"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
     });
@@ -1290,14 +1224,10 @@ export default{
       expect(std.out).toMatchInlineSnapshot(`
         "reading assets/.well-known/file-2.txt...
         uploading as assets/.well-known/file-2.5938485188.txt...
-        Uploaded
-        test-name
-        (TIMINGS)
-        Published
-        test-name
-        (TIMINGS)
-
-        test-name.test-sub-domain.workers.dev"
+        ↗️  Done syncing assets
+        Uploaded test-name (TIMINGS)
+        Published test-name (TIMINGS)
+          test-name.test-sub-domain.workers.dev"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
     });
@@ -1345,8 +1275,7 @@ export default{
       expect(std.err).toMatchInlineSnapshot(`
         "File assets/too-large-file.txt is too big, it should be under 25 MiB. See https://developers.cloudflare.com/workers/platform/limits#kv-limits
 
-        %s
-        If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
+        %s If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
       `);
     });
 
@@ -1384,9 +1313,64 @@ export default{
       expect(std.err).toMatchInlineSnapshot(`
         "The asset path key \\"assets/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/folder/file.3da0d0cd12.txt\\" exceeds the maximum key size limit of 512. See https://developers.cloudflare.com/workers/platform/limits#kv-limits\\",
 
-        %s
-        If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
+        %s If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
+      `);
+    });
+
+    it("should delete uploaded assets that aren't included anymore", async () => {
+      const assets = [
+        { filePath: "assets/file-1.txt", content: "Content of file-1" },
+        { filePath: "assets/file-2.txt", content: "Content of file-2" },
+      ];
+      const kvNamespace = {
+        title: "__test-name-workers_sites_assets",
+        id: "__test-name-workers_sites_assets-id",
+      };
+      writeWranglerToml({
+        main: "./index.js",
+        site: {
+          bucket: "assets",
+        },
+      });
+      writeWorkerSource();
+      writeAssets(assets);
+      mockUploadWorkerRequest();
+      mockSubDomainRequest();
+      mockListKVNamespacesRequest(kvNamespace);
+      mockKeyListRequest(kvNamespace.id, [
+        // Put file-1 in the KV namespace
+        { name: "assets/file-1.2ca234f380.txt" },
+        // As well as a couple from a previous upload
+        { name: "assets/file-3.somehash.txt" },
+        { name: "assets/file-4.anotherhash.txt" },
+      ]);
+
+      // we upload only file-1.txt
+      mockUploadAssetsToKVRequest(kvNamespace.id, [
+        ...assets.filter((a) => a.filePath !== "assets/file-1.txt"),
+      ]);
+
+      // and mark file-3 and file-4 for deletion
+      mockDeleteUnusedAssetsRequest(kvNamespace.id, [
+        "assets/file-3.somehash.txt",
+        "assets/file-4.anotherhash.txt",
+      ]);
+
+      await runWrangler("publish");
+
+      expect(std.out).toMatchInlineSnapshot(`
+        "reading assets/file-1.txt...
+        skipping - already uploaded
+        reading assets/file-2.txt...
+        uploading as assets/file-2.5938485188.txt...
+        deleting assets/file-3.somehash.txt from the asset store...
+        deleting assets/file-4.anotherhash.txt from the asset store...
+        ↗️  Done syncing assets
+        Uploaded test-name (TIMINGS)
+        Published test-name (TIMINGS)
+          test-name.test-sub-domain.workers.dev"
       `);
+      expect(std.err).toMatchInlineSnapshot(`""`);
     });
   });
 
@@ -1400,14 +1384,9 @@ export default{
       await runWrangler("publish ./index");
 
       expect(std.out).toMatchInlineSnapshot(`
-        "Uploaded
-        test-name
-        (TIMINGS)
-        Published
-        test-name
-        (TIMINGS)
-
-        test-name.test-sub-domain.workers.dev"
+        "Uploaded test-name (TIMINGS)
+        Published test-name (TIMINGS)
+          test-name.test-sub-domain.workers.dev"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
     });
@@ -1423,14 +1402,9 @@ export default{
       await runWrangler("publish ./index");
 
       expect(std.out).toMatchInlineSnapshot(`
-        "Uploaded
-        test-name
-        (TIMINGS)
-        Published
-        test-name
-        (TIMINGS)
-
-        test-name.test-sub-domain.workers.dev"
+        "Uploaded test-name (TIMINGS)
+        Published test-name (TIMINGS)
+          test-name.test-sub-domain.workers.dev"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
     });
@@ -1441,534 +1415,1522 @@ export default{
       });
       writeWorkerSource();
       mockUploadWorkerRequest();
-      mockSubDomainRequest();
       mockUpdateWorkerRequest({ enabled: false });
 
       await runWrangler("publish ./index");
 
       expect(std.out).toMatchInlineSnapshot(`
-        "Uploaded
-        test-name
-        (TIMINGS)
-        No publish targets for
-        test-name
-        (TIMINGS)"
+        "Uploaded test-name (TIMINGS)
+        No publish targets for test-name (TIMINGS)"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
     });
 
-    it("should enable the workers.dev domain if workers_dev is undefined and subdomain is not already available", async () => {
-      writeWranglerToml();
+    it("should disable the workers.dev domain if workers_dev is undefined but overwritten to `false` in environment", async () => {
+      writeWranglerToml({
+        env: {
+          dev: {
+            workers_dev: false,
+          },
+        },
+      });
       writeWorkerSource();
-      mockUploadWorkerRequest({ available_on_subdomain: false });
-      mockSubDomainRequest();
-      mockUpdateWorkerRequest({ enabled: true });
+      mockUploadWorkerRequest({
+        env: "dev",
+      });
+      mockUpdateWorkerRequest({ enabled: false, env: "dev" });
 
-      await runWrangler("publish ./index");
+      await runWrangler("publish ./index --env dev --legacy-env false");
 
       expect(std.out).toMatchInlineSnapshot(`
-        "Uploaded
-        test-name
-        (TIMINGS)
-        Published
-        test-name
-        (TIMINGS)
-
-        test-name.test-sub-domain.workers.dev"
+        "Uploaded test-name (dev) (TIMINGS)
+        No publish targets for test-name (dev) (TIMINGS)"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
     });
 
-    it("should enable the workers.dev domain if workers_dev is true and subdomain is not already available", async () => {
-      writeWranglerToml({ workers_dev: true });
+    it("should disable the workers.dev domain if workers_dev is `true` but overwritten to `false` in environment", async () => {
+      writeWranglerToml({
+        workers_dev: true,
+        env: {
+          dev: {
+            workers_dev: false,
+          },
+        },
+      });
       writeWorkerSource();
-      mockUploadWorkerRequest({ available_on_subdomain: false });
-      mockSubDomainRequest();
-      mockUpdateWorkerRequest({ enabled: true });
+      mockUploadWorkerRequest({
+        env: "dev",
+      });
+      mockUpdateWorkerRequest({ enabled: false, env: "dev" });
 
-      await runWrangler("publish ./index");
+      await runWrangler("publish ./index --env dev --legacy-env false");
 
       expect(std.out).toMatchInlineSnapshot(`
-        "Uploaded
-        test-name
-        (TIMINGS)
-        Published
-        test-name
-        (TIMINGS)
-
-        test-name.test-sub-domain.workers.dev"
+        "Uploaded test-name (dev) (TIMINGS)
+        No publish targets for test-name (dev) (TIMINGS)"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
     });
-  });
 
-  describe("custom builds", () => {
-    beforeEach(() => {
-      // @ts-expect-error disable the mock we'd setup earlier
-      // or else custom builds will timeout immediately
-      global.setTimeout.mockRestore();
-    });
-    it("should run a custom build before publishing", async () => {
+    it("should publish to a workers.dev domain if workers_dev is undefined but overwritten to `true` in environment", async () => {
       writeWranglerToml({
-        build: {
-          command: `node -e "console.log('custom build'); require('fs').writeFileSync('index.js', 'export default { fetch(){ return new Response(123) } }')"`,
+        env: {
+          dev: {
+            workers_dev: true,
+          },
         },
       });
-
+      writeWorkerSource();
       mockUploadWorkerRequest({
-        expectedEntry: "return new Response(123)",
+        env: "dev",
       });
       mockSubDomainRequest();
+      mockUpdateWorkerRequest({ enabled: true, env: "dev" });
 
-      await runWrangler("publish index.js");
-      expect(std.out).toMatchInlineSnapshot(`
-        "running:
-        node -e \\"console.log('custom build'); require('fs').writeFileSync('index.js', 'export default { fetch(){ return new Response(123) } }')\\"
-        Uploaded
-        test-name
-        (TIMINGS)
-        Published
-        test-name
-        (TIMINGS)
+      await runWrangler("publish ./index --env dev --legacy-env false");
 
-        test-name.test-sub-domain.workers.dev"
+      expect(std.out).toMatchInlineSnapshot(`
+        "Uploaded test-name (dev) (TIMINGS)
+        Published test-name (dev) (TIMINGS)
+          dev.test-name.test-sub-domain.workers.dev"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
-      expect(std.warn).toMatchInlineSnapshot(`""`);
     });
 
-    if (process.platform !== "win32") {
-      it("should run a custom build of multiple steps combined by && before publishing", async () => {
-        writeWranglerToml({
-          build: {
-            command: `echo "custom build" && echo "export default { fetch(){ return new Response(123) } }" > index.js`,
-          },
-        });
-
-        mockUploadWorkerRequest({
-          expectedEntry: "return new Response(123)",
-        });
-        mockSubDomainRequest();
-
-        await runWrangler("publish index.js");
-        expect(std.out).toMatchInlineSnapshot(`
-          "running:
-          echo \\"custom build\\" && echo \\"export default { fetch(){ return new Response(123) } }\\" > index.js
-          Uploaded
-          test-name
-          (TIMINGS)
-          Published
-          test-name
-          (TIMINGS)
-
-          test-name.test-sub-domain.workers.dev"
-        `);
-        expect(std.err).toMatchInlineSnapshot(`""`);
-        expect(std.warn).toMatchInlineSnapshot(`""`);
-      });
-    }
-  });
-
-  describe("[wasm_modules]", () => {
-    it("should be able to define wasm modules for service-worker format workers", async () => {
+    it("should publish to a workers.dev domain if workers_dev is `false` but overwritten to `true` in environment", async () => {
       writeWranglerToml({
-        wasm_modules: {
-          TESTWASMNAME: "./path/to/test.wasm",
+        workers_dev: false,
+        env: {
+          dev: {
+            workers_dev: true,
+          },
         },
       });
-      writeWorkerSource({ type: "sw" });
-      fs.mkdirSync("./path/to", { recursive: true });
-      fs.writeFileSync("./path/to/test.wasm", "SOME WASM CONTENT");
+      writeWorkerSource();
       mockUploadWorkerRequest({
-        expectedType: "sw",
-        expectedModules: { TESTWASMNAME: "SOME WASM CONTENT" },
-        expectedBindings: [
-          { name: "TESTWASMNAME", part: "TESTWASMNAME", type: "wasm_module" },
-        ],
+        env: "dev",
       });
       mockSubDomainRequest();
-      await runWrangler("publish index.js");
-      expect(std.out).toMatchInlineSnapshot(`
-        "Uploaded
-        test-name
-        (TIMINGS)
-        Published
-        test-name
-        (TIMINGS)
+      mockUpdateWorkerRequest({ enabled: true, env: "dev" });
 
-        test-name.test-sub-domain.workers.dev"
+      await runWrangler("publish ./index --env dev --legacy-env false");
+
+      expect(std.out).toMatchInlineSnapshot(`
+        "Uploaded test-name (dev) (TIMINGS)
+        Published test-name (dev) (TIMINGS)
+          dev.test-name.test-sub-domain.workers.dev"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
-      expect(std.warn).toMatchInlineSnapshot(`""`);
     });
 
-    it("should error when defining wasm modules for modules format workers", async () => {
+    it("should use the global compatibility_date and compatibility_flags if they are not overwritten by the environment", async () => {
       writeWranglerToml({
-        wasm_modules: {
-          TESTWASMNAME: "./path/to/test.wasm",
+        compatibility_date: "2022-01-12",
+        compatibility_flags: ["no_global_navigator"],
+        env: {
+          dev: {},
         },
       });
-      writeWorkerSource({ type: "esm" });
-      fs.mkdirSync("./path/to", { recursive: true });
-      fs.writeFileSync("./path/to/test.wasm", "SOME WASM CONTENT");
+      writeWorkerSource();
+      mockUploadWorkerRequest({
+        env: "dev",
+        expectedCompatibilityDate: "2022-01-12",
+        expectedCompatibilityFlags: ["no_global_navigator"],
+      });
+      mockSubDomainRequest();
+      mockUpdateWorkerRequest({ enabled: true, env: "dev" });
 
-      await expect(
-        runWrangler("publish index.js")
-      ).rejects.toThrowErrorMatchingInlineSnapshot(
-        `"You cannot configure [wasm_modules] with an ES module worker. Instead, import the .wasm module directly in your code"`
-      );
-      expect(std.out).toMatchInlineSnapshot(`""`);
-      expect(std.err).toMatchInlineSnapshot(`
-        "You cannot configure [wasm_modules] with an ES module worker. Instead, import the .wasm module directly in your code
+      await runWrangler("publish ./index --env dev --legacy-env false");
 
-        %s
-        If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
+      expect(std.out).toMatchInlineSnapshot(`
+        "Uploaded test-name (dev) (TIMINGS)
+        Published test-name (dev) (TIMINGS)
+          dev.test-name.test-sub-domain.workers.dev"
       `);
-      expect(std.warn).toMatchInlineSnapshot(`""`);
+      expect(std.err).toMatchInlineSnapshot(`""`);
     });
 
-    it("should resolve wasm modules relative to the wrangler.toml file", async () => {
-      fs.mkdirSync("./path/to/and/the/path/to/", { recursive: true });
-      fs.writeFileSync(
-        "./path/to/wrangler.toml",
-        TOML.stringify({
-          compatibility_date: "2022-01-12",
-          name: "test-name",
-          wasm_modules: {
-            TESTWASMNAME: "./and/the/path/to/test.wasm",
+    it("should use the environment specific compatibility_date and compatibility_flags", async () => {
+      writeWranglerToml({
+        compatibility_date: "2022-01-12",
+        compatibility_flags: ["no_global_navigator"],
+        env: {
+          dev: {
+            compatibility_date: "2022-01-13",
+            compatibility_flags: ["global_navigator"],
           },
-        }),
+        },
+      });
+      writeWorkerSource();
+      mockUploadWorkerRequest({
+        env: "dev",
+        expectedCompatibilityDate: "2022-01-13",
+        expectedCompatibilityFlags: ["global_navigator"],
+      });
+      mockSubDomainRequest();
+      mockUpdateWorkerRequest({ enabled: true, env: "dev" });
 
-        "utf-8"
-      );
+      await runWrangler("publish ./index --env dev --legacy-env false");
 
-      writeWorkerSource({ type: "sw" });
-      fs.writeFileSync(
-        "./path/to/and/the/path/to/test.wasm",
-        "SOME WASM CONTENT"
-      );
+      expect(std.out).toMatchInlineSnapshot(`
+        "Uploaded test-name (dev) (TIMINGS)
+        Published test-name (dev) (TIMINGS)
+          dev.test-name.test-sub-domain.workers.dev"
+      `);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+    });
+
+    it("should use the command line --compatibility-date and --compatibility-flags if they are specified", async () => {
+      writeWranglerToml({
+        compatibility_date: "2022-01-12",
+        compatibility_flags: ["no_global_navigator"],
+        env: {
+          dev: {
+            compatibility_date: "2022-01-13",
+            compatibility_flags: ["global_navigator"],
+          },
+        },
+      });
+      writeWorkerSource();
       mockUploadWorkerRequest({
-        expectedType: "sw",
-        expectedModules: { TESTWASMNAME: "SOME WASM CONTENT" },
-        expectedBindings: [
-          { name: "TESTWASMNAME", part: "TESTWASMNAME", type: "wasm_module" },
-        ],
+        env: "dev",
+        expectedCompatibilityDate: "2022-01-14",
+        expectedCompatibilityFlags: ["url_standard"],
       });
       mockSubDomainRequest();
-      await runWrangler("publish index.js --config ./path/to/wrangler.toml");
-      expect(std.out).toMatchInlineSnapshot(`
-        "Uploaded
-        test-name
-        (TIMINGS)
-        Published
-        test-name
-        (TIMINGS)
+      mockUpdateWorkerRequest({ enabled: true, env: "dev" });
 
-        test-name.test-sub-domain.workers.dev"
+      await runWrangler(
+        "publish ./index --env dev --legacy-env false --compatibility-date 2022-01-14 --compatibility-flags url_standard"
+      );
+
+      expect(std.out).toMatchInlineSnapshot(`
+        "Uploaded test-name (dev) (TIMINGS)
+        Published test-name (dev) (TIMINGS)
+          dev.test-name.test-sub-domain.workers.dev"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
-      expect(std.warn).toMatchInlineSnapshot(`""`);
     });
 
-    it("should be able to import .wasm modules from service-worker format workers", async () => {
+    it("should enable the workers.dev domain if workers_dev is undefined and subdomain is not already available", async () => {
       writeWranglerToml();
-      fs.writeFileSync("./index.js", "import TESTWASMNAME from './test.wasm';");
-      fs.writeFileSync("./test.wasm", "SOME WASM CONTENT");
-      mockUploadWorkerRequest({
-        expectedType: "sw",
-        expectedModules: {
-          __94b240d0d692281e6467aa42043986e5c7eea034_test_wasm:
-            "SOME WASM CONTENT",
-        },
-        expectedBindings: [
-          {
-            name: "__94b240d0d692281e6467aa42043986e5c7eea034_test_wasm",
-            part: "__94b240d0d692281e6467aa42043986e5c7eea034_test_wasm",
-            type: "wasm_module",
-          },
-        ],
+      writeWorkerSource();
+      mockUploadWorkerRequest({ available_on_subdomain: false });
+      mockSubDomainRequest();
+      mockUpdateWorkerRequest({ enabled: true });
+
+      await runWrangler("publish ./index");
+
+      expect(std.out).toMatchInlineSnapshot(`
+        "Uploaded test-name (TIMINGS)
+        Published test-name (TIMINGS)
+          test-name.test-sub-domain.workers.dev"
+      `);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+    });
+
+    it("should enable the workers.dev domain if workers_dev is true and subdomain is not already available", async () => {
+      writeWranglerToml({ workers_dev: true });
+      writeWorkerSource();
+      mockUploadWorkerRequest({ available_on_subdomain: false });
+      mockSubDomainRequest();
+      mockUpdateWorkerRequest({ enabled: true });
+
+      await runWrangler("publish ./index");
+
+      expect(std.out).toMatchInlineSnapshot(`
+        "Uploaded test-name (TIMINGS)
+        Published test-name (TIMINGS)
+          test-name.test-sub-domain.workers.dev"
+      `);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+    });
+
+    it("should error politely when publishing to workers_dev when there is no workers.dev subdomain", async () => {
+      writeWranglerToml({
+        workers_dev: true,
+      });
+      writeWorkerSource();
+      mockUploadWorkerRequest();
+      mockSubDomainRequest("does-not-exist", false);
+
+      await expect(runWrangler("publish ./index")).rejects
+        .toThrowErrorMatchingInlineSnapshot(`
+              "Error: You need to register a workers.dev subdomain before publishing to workers.dev
+              You can either publish your worker to one or more routes by specifying them in wrangler.toml, or register a workers.dev subdomain here:
+              https://dash.cloudflare.com/some-account-id/workers/onboarding"
+            `);
+    });
+
+    it("should not deploy to workers.dev if there are any routes defined", async () => {
+      writeWranglerToml({
+        routes: ["http://example.com/*"],
       });
+      writeWorkerSource();
       mockSubDomainRequest();
+      mockUploadWorkerRequest();
+      mockUpdateWorkerRequest({
+        enabled: false,
+      });
+      mockPublishRoutesRequest({ routes: ["http://example.com/*"] });
       await runWrangler("publish index.js");
-      expect(std.out).toMatchInlineSnapshot(`
-        "Uploaded
-        test-name
-        (TIMINGS)
-        Published
-        test-name
-        (TIMINGS)
 
-        test-name.test-sub-domain.workers.dev"
+      expect(std.out).toMatchInlineSnapshot(`
+        "Uploaded test-name (TIMINGS)
+        Published test-name (TIMINGS)
+          http://example.com/*"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
       expect(std.warn).toMatchInlineSnapshot(`""`);
     });
-  });
 
-  describe("[text_blobs]", () => {
-    it("should be able to define text blobs for service-worker format workers", async () => {
+    it("should not deploy to workers.dev if there are any routes defined (environments)", async () => {
       writeWranglerToml({
-        text_blobs: {
-          TESTTEXTBLOBNAME: "./path/to/text.file",
+        routes: ["http://example.com/*"],
+        env: {
+          production: {
+            routes: ["http://production.example.com/*"],
+          },
         },
       });
-      writeWorkerSource({ type: "sw" });
-      fs.mkdirSync("./path/to", { recursive: true });
-      fs.writeFileSync("./path/to/text.file", "SOME TEXT CONTENT");
-      mockUploadWorkerRequest({
-        expectedType: "sw",
-        expectedModules: { TESTTEXTBLOBNAME: "SOME TEXT CONTENT" },
-        expectedBindings: [
-          {
-            name: "TESTTEXTBLOBNAME",
-            part: "TESTTEXTBLOBNAME",
-            type: "text_blob",
+      writeWorkerSource();
+      mockSubDomainRequest();
+      mockUploadWorkerRequest({ env: "production", legacyEnv: true });
+      mockUpdateWorkerRequest({
+        enabled: false,
+        env: "production",
+        legacyEnv: true,
+      });
+      mockPublishRoutesRequest({
+        routes: ["http://production.example.com/*"],
+        env: "production",
+        legacyEnv: true,
+      });
+      await runWrangler("publish index.js --env production");
+
+      expect(std.out).toMatchInlineSnapshot(`
+        "Uploaded test-name-production (TIMINGS)
+        Published test-name-production (TIMINGS)
+          http://production.example.com/*"
+      `);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+      expect(std.warn).toMatchInlineSnapshot(`""`);
+    });
+
+    it("should not deploy to workers.dev if there are any routes defined (only in environments)", async () => {
+      writeWranglerToml({
+        env: {
+          production: {
+            routes: ["http://production.example.com/*"],
           },
-        ],
+        },
       });
+      writeWorkerSource();
       mockSubDomainRequest();
-      await runWrangler("publish index.js");
+      mockUploadWorkerRequest({ env: "production", legacyEnv: true });
+      mockUpdateWorkerRequest({
+        enabled: false,
+        env: "production",
+        legacyEnv: true,
+      });
+      mockPublishRoutesRequest({
+        routes: ["http://production.example.com/*"],
+        env: "production",
+        legacyEnv: true,
+      });
+      await runWrangler("publish index.js --env production");
+
       expect(std.out).toMatchInlineSnapshot(`
-        "Uploaded
-        test-name
-        (TIMINGS)
-        Published
-        test-name
-        (TIMINGS)
+        "Uploaded test-name-production (TIMINGS)
+        Published test-name-production (TIMINGS)
+          http://production.example.com/*"
+      `);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+      expect(std.warn).toMatchInlineSnapshot(`""`);
+    });
 
-        test-name.test-sub-domain.workers.dev"
+    it("can deploy to both workers.dev and routes if both defined ", async () => {
+      writeWranglerToml({
+        workers_dev: true,
+        routes: ["http://example.com/*"],
+      });
+      writeWorkerSource();
+      mockSubDomainRequest();
+      mockUploadWorkerRequest();
+      mockUpdateWorkerRequest({
+        enabled: false,
+      });
+      mockPublishRoutesRequest({
+        routes: ["http://example.com/*"],
+      });
+      await runWrangler("publish index.js");
+
+      expect(std.out).toMatchInlineSnapshot(`
+        "Uploaded test-name (TIMINGS)
+        Published test-name (TIMINGS)
+          test-name.test-sub-domain.workers.dev
+          http://example.com/*"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
       expect(std.warn).toMatchInlineSnapshot(`""`);
     });
 
-    it("should error when defining text blobs for modules format workers", async () => {
+    it("can deploy to both workers.dev and routes if both defined (environments: 1)", async () => {
       writeWranglerToml({
-        text_blobs: {
-          TESTTEXTBLOBNAME: "./path/to/text.file",
+        workers_dev: true,
+        env: {
+          production: {
+            routes: ["http://production.example.com/*"],
+          },
         },
       });
-      writeWorkerSource({ type: "esm" });
-      fs.mkdirSync("./path/to", { recursive: true });
-      fs.writeFileSync("./path/to/text.file", "SOME TEXT CONTENT");
-
-      await expect(
-        runWrangler("publish index.js")
-      ).rejects.toThrowErrorMatchingInlineSnapshot(
-        `"You cannot configure [text_blobs] with an ES module worker. Instead, import the file directly in your code, and optionally configure \`[build.upload.rules]\` in your wrangler.toml"`
-      );
-      expect(std.out).toMatchInlineSnapshot(`""`);
-      expect(std.err).toMatchInlineSnapshot(`
-        "You cannot configure [text_blobs] with an ES module worker. Instead, import the file directly in your code, and optionally configure \`[build.upload.rules]\` in your wrangler.toml
+      writeWorkerSource();
+      mockSubDomainRequest();
+      mockUploadWorkerRequest({ env: "production", legacyEnv: true });
+      mockUpdateWorkerRequest({
+        enabled: false,
+        env: "production",
+        legacyEnv: true,
+      });
+      mockPublishRoutesRequest({
+        routes: ["http://production.example.com/*"],
+        env: "production",
+        legacyEnv: true,
+      });
+      await runWrangler("publish index.js --env production");
 
-        %s
-        If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
+      expect(std.out).toMatchInlineSnapshot(`
+        "Uploaded test-name-production (TIMINGS)
+        Published test-name-production (TIMINGS)
+          test-name-production.test-sub-domain.workers.dev
+          http://production.example.com/*"
       `);
+      expect(std.err).toMatchInlineSnapshot(`""`);
       expect(std.warn).toMatchInlineSnapshot(`""`);
     });
 
-    it("should resolve text blobs relative to the wrangler.toml file", async () => {
-      fs.mkdirSync("./path/to/and/the/path/to/", { recursive: true });
-      fs.writeFileSync(
-        "./path/to/wrangler.toml",
-        TOML.stringify({
-          compatibility_date: "2022-01-12",
-          name: "test-name",
-          text_blobs: {
-            TESTTEXTBLOBNAME: "./and/the/path/to/text.file",
+    it("can deploy to both workers.dev and routes if both defined (environments: 2)", async () => {
+      writeWranglerToml({
+        env: {
+          production: {
+            workers_dev: true,
+            routes: ["http://production.example.com/*"],
           },
-        }),
+        },
+      });
+      writeWorkerSource();
+      mockSubDomainRequest();
+      mockUploadWorkerRequest({ env: "production", legacyEnv: true });
+      mockUpdateWorkerRequest({
+        enabled: false,
+        env: "production",
+        legacyEnv: true,
+      });
+      mockPublishRoutesRequest({
+        routes: ["http://production.example.com/*"],
+        env: "production",
+        legacyEnv: true,
+      });
+      await runWrangler("publish index.js --env production");
 
-        "utf-8"
-      );
+      expect(std.out).toMatchInlineSnapshot(`
+        "Uploaded test-name-production (TIMINGS)
+        Published test-name-production (TIMINGS)
+          test-name-production.test-sub-domain.workers.dev
+          http://production.example.com/*"
+      `);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+      expect(std.warn).toMatchInlineSnapshot(`""`);
+    });
 
-      writeWorkerSource({ type: "sw" });
-      fs.writeFileSync(
-        "./path/to/and/the/path/to/text.file",
-        "SOME TEXT CONTENT"
-      );
-      mockUploadWorkerRequest({
-        expectedType: "sw",
-        expectedModules: { TESTTEXTBLOBNAME: "SOME TEXT CONTENT" },
-        expectedBindings: [
-          {
-            name: "TESTTEXTBLOBNAME",
-            part: "TESTTEXTBLOBNAME",
-            type: "text_blob",
+    it("will deploy only to routes when workers_dev is false (environments 1) ", async () => {
+      writeWranglerToml({
+        workers_dev: false,
+        env: {
+          production: {
+            routes: ["http://production.example.com/*"],
           },
-        ],
+        },
       });
+      writeWorkerSource();
       mockSubDomainRequest();
-      await runWrangler("publish index.js --config ./path/to/wrangler.toml");
-      expect(std.out).toMatchInlineSnapshot(`
-        "Uploaded
-        test-name
-        (TIMINGS)
-        Published
-        test-name
-        (TIMINGS)
+      mockUploadWorkerRequest({ env: "production", legacyEnv: true });
+      mockUpdateWorkerRequest({
+        enabled: false,
+        env: "production",
+        legacyEnv: true,
+      });
+      mockPublishRoutesRequest({
+        routes: ["http://production.example.com/*"],
+        env: "production",
+        legacyEnv: true,
+      });
+      await runWrangler("publish index.js --env production");
 
-        test-name.test-sub-domain.workers.dev"
+      expect(std.out).toMatchInlineSnapshot(`
+        "Uploaded test-name-production (TIMINGS)
+        Published test-name-production (TIMINGS)
+          http://production.example.com/*"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
       expect(std.warn).toMatchInlineSnapshot(`""`);
     });
-  });
 
-  describe("vars bindings", () => {
-    it("should support json bindings", async () => {
-      writeWranglerToml({
-        vars: {
-          text: "plain ol' string",
-          count: 1,
-          complex: { enabled: true, id: 123 },
-        },
+    it("will deploy only to routes when workers_dev is false (environments 2) ", async () => {
+      writeWranglerToml({
+        env: {
+          production: {
+            workers_dev: false,
+            routes: ["http://production.example.com/*"],
+          },
+        },
+      });
+      writeWorkerSource();
+      mockSubDomainRequest();
+      mockUploadWorkerRequest({ env: "production", legacyEnv: true });
+      mockUpdateWorkerRequest({
+        enabled: false,
+        env: "production",
+        legacyEnv: true,
+      });
+      mockPublishRoutesRequest({
+        routes: ["http://production.example.com/*"],
+        env: "production",
+        legacyEnv: true,
+      });
+      await runWrangler("publish index.js --env production");
+
+      expect(std.out).toMatchInlineSnapshot(`
+        "Uploaded test-name-production (TIMINGS)
+        Published test-name-production (TIMINGS)
+          http://production.example.com/*"
+      `);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+      expect(std.warn).toMatchInlineSnapshot(`""`);
+    });
+  });
+
+  describe("custom builds", () => {
+    beforeEach(() => {
+      // @ts-expect-error disable the mock we'd setup earlier
+      // or else custom builds will timeout immediately
+      global.setTimeout.mockRestore();
+    });
+    it("should run a custom build before publishing", async () => {
+      writeWranglerToml({
+        build: {
+          command: `node -e "console.log('custom build'); require('fs').writeFileSync('index.js', 'export default { fetch(){ return new Response(123) } }')"`,
+        },
+      });
+
+      mockUploadWorkerRequest({
+        expectedEntry: "return new Response(123)",
+      });
+      mockSubDomainRequest();
+
+      await runWrangler("publish index.js");
+      expect(std.out).toMatchInlineSnapshot(`
+        "running: node -e \\"console.log('custom build'); require('fs').writeFileSync('index.js', 'export default { fetch(){ return new Response(123) } }')\\"
+        Uploaded test-name (TIMINGS)
+        Published test-name (TIMINGS)
+          test-name.test-sub-domain.workers.dev"
+      `);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+      expect(std.warn).toMatchInlineSnapshot(`""`);
+    });
+
+    if (process.platform !== "win32") {
+      it("should run a custom build of multiple steps combined by && before publishing", async () => {
+        writeWranglerToml({
+          build: {
+            command: `echo "custom build" && echo "export default { fetch(){ return new Response(123) } }" > index.js`,
+          },
+        });
+
+        mockUploadWorkerRequest({
+          expectedEntry: "return new Response(123)",
+        });
+        mockSubDomainRequest();
+
+        await runWrangler("publish index.js");
+        expect(std.out).toMatchInlineSnapshot(`
+          "running: echo \\"custom build\\" && echo \\"export default { fetch(){ return new Response(123) } }\\" > index.js
+          Uploaded test-name (TIMINGS)
+          Published test-name (TIMINGS)
+            test-name.test-sub-domain.workers.dev"
+        `);
+        expect(std.err).toMatchInlineSnapshot(`""`);
+        expect(std.warn).toMatchInlineSnapshot(`""`);
+      });
+    }
+
+    it("should throw an error if the entry doesn't exist after the build finishes", async () => {
+      writeWranglerToml({
+        main: "index.js",
+        build: {
+          command: `node -e "console.log('custom build');"`,
+        },
+      });
+
+      await expect(
+        runWrangler("publish index.js")
+      ).rejects.toThrowErrorMatchingInlineSnapshot(
+        `"Could not resolve \\"index.js\\" after running custom build: node -e \\"console.log('custom build');\\""`
+      );
+      expect(std.out).toMatchInlineSnapshot(
+        `"running: node -e \\"console.log('custom build');\\""`
+      );
+      expect(std.err).toMatchInlineSnapshot(`
+        "Could not resolve \\"index.js\\" after running custom build: node -e \\"console.log('custom build');\\"
+
+        %s If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
+      `);
+      expect(std.warn).toMatchInlineSnapshot(`""`);
+    });
+  });
+
+  describe("bindings", () => {
+    it("should allow bindings with different names", async () => {
+      writeWranglerToml({
+        durable_objects: {
+          bindings: [
+            {
+              name: "DURABLE_OBJECT_ONE",
+              class_name: "SomeDurableObject",
+              script_name: "some-durable-object-worker",
+            },
+            {
+              name: "DURABLE_OBJECT_TWO",
+              class_name: "AnotherDurableObject",
+              script_name: "another-durable-object-worker",
+            },
+          ],
+        },
+        kv_namespaces: [
+          { binding: "KV_NAMESPACE_ONE", id: "kv-ns-one-id" },
+          { binding: "KV_NAMESPACE_TWO", id: "kv-ns-two-id" },
+        ],
+        r2_buckets: [
+          { binding: "R2_BUCKET_ONE", bucket_name: "r2-bucket-one-name" },
+          { binding: "R2_BUCKET_TWO", bucket_name: "r2-bucket-two-name" },
+        ],
+        text_blobs: {
+          TEXT_BLOB_ONE: "./my-entire-app-depends-on-this.cfg",
+          TEXT_BLOB_TWO: "./the-entirety-of-human-knowledge.txt",
+        },
+        unsafe: {
+          bindings: [
+            {
+              name: "UNSAFE_BINDING_ONE",
+              type: "some unsafe thing",
+              data: { some: { unsafe: "thing" } },
+            },
+            {
+              name: "UNSAFE_BINDING_TWO",
+              type: "another unsafe thing",
+              data: 1337,
+            },
+          ],
+        },
+        vars: {
+          ENV_VAR_ONE: 123,
+          ENV_VAR_TWO: "Hello, I'm an environment variable",
+        },
+        wasm_modules: {
+          WASM_MODULE_ONE: "./some_wasm.wasm",
+          WASM_MODULE_TWO: "./more_wasm.wasm",
+        },
+      });
+
+      writeWorkerSource({ type: "sw" });
+      fs.writeFileSync("./my-entire-app-depends-on-this.cfg", "config = value");
+      fs.writeFileSync(
+        "./the-entirety-of-human-knowledge.txt",
+        "Everything's bigger in Texas"
+      );
+      fs.writeFileSync("./some_wasm.wasm", "some wasm");
+      fs.writeFileSync("./more_wasm.wasm", "more wasm");
+
+      mockUploadWorkerRequest({
+        expectedType: "sw",
+        expectedBindings: [
+          {
+            name: "KV_NAMESPACE_ONE",
+            namespace_id: "kv-ns-one-id",
+            type: "kv_namespace",
+          },
+          {
+            name: "KV_NAMESPACE_TWO",
+            namespace_id: "kv-ns-two-id",
+            type: "kv_namespace",
+          },
+          {
+            class_name: "SomeDurableObject",
+            name: "DURABLE_OBJECT_ONE",
+            script_name: "some-durable-object-worker",
+            type: "durable_object_namespace",
+          },
+          {
+            class_name: "AnotherDurableObject",
+            name: "DURABLE_OBJECT_TWO",
+            script_name: "another-durable-object-worker",
+            type: "durable_object_namespace",
+          },
+          {
+            bucket_name: "r2-bucket-one-name",
+            name: "R2_BUCKET_ONE",
+            type: "r2_bucket",
+          },
+          {
+            bucket_name: "r2-bucket-two-name",
+            name: "R2_BUCKET_TWO",
+            type: "r2_bucket",
+          },
+          { json: 123, name: "ENV_VAR_ONE", type: "json" },
+          {
+            name: "ENV_VAR_TWO",
+            text: "Hello, I'm an environment variable",
+            type: "plain_text",
+          },
+          {
+            name: "WASM_MODULE_ONE",
+            part: "WASM_MODULE_ONE",
+            type: "wasm_module",
+          },
+          {
+            name: "WASM_MODULE_TWO",
+            part: "WASM_MODULE_TWO",
+            type: "wasm_module",
+          },
+          { name: "TEXT_BLOB_ONE", part: "TEXT_BLOB_ONE", type: "text_blob" },
+          { name: "TEXT_BLOB_TWO", part: "TEXT_BLOB_TWO", type: "text_blob" },
+          {
+            data: { some: { unsafe: "thing" } },
+            name: "UNSAFE_BINDING_ONE",
+            type: "some unsafe thing",
+          },
+          {
+            data: 1337,
+            name: "UNSAFE_BINDING_TWO",
+            type: "another unsafe thing",
+          },
+        ],
+      });
+      mockSubDomainRequest();
+
+      await expect(runWrangler("publish index.js")).resolves.toBeUndefined();
+      expect(std.out).toMatchInlineSnapshot(`
+        "Uploaded test-name (TIMINGS)
+        Published test-name (TIMINGS)
+          test-name.test-sub-domain.workers.dev"
+      `);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+      expect(std.warn).toMatchInlineSnapshot(`
+        "Processing wrangler.toml configuration:
+          - \\"unsafe\\" fields are experimental and may change or break at any time."
+      `);
+    });
+
+    it("should error when bindings of different types have the same name", async () => {
+      writeWranglerToml({
+        durable_objects: {
+          bindings: [
+            {
+              name: "CONFLICTING_NAME_ONE",
+              class_name: "SomeDurableObject",
+              script_name: "some-durable-object-worker",
+            },
+            {
+              name: "CONFLICTING_NAME_TWO",
+              class_name: "AnotherDurableObject",
+              script_name: "another-durable-object-worker",
+            },
+          ],
+        },
+        kv_namespaces: [
+          { binding: "CONFLICTING_NAME_ONE", id: "kv-ns-one-id" },
+          { binding: "CONFLICTING_NAME_TWO", id: "kv-ns-two-id" },
+        ],
+        r2_buckets: [
+          {
+            binding: "CONFLICTING_NAME_ONE",
+            bucket_name: "r2-bucket-one-name",
+          },
+          {
+            binding: "CONFLICTING_NAME_THREE",
+            bucket_name: "r2-bucket-two-name",
+          },
+        ],
+        text_blobs: {
+          CONFLICTING_NAME_THREE: "./my-entire-app-depends-on-this.cfg",
+          CONFLICTING_NAME_FOUR: "./the-entirety-of-human-knowledge.txt",
+        },
+        unsafe: {
+          bindings: [
+            {
+              name: "CONFLICTING_NAME_THREE",
+              type: "some unsafe thing",
+              data: { some: { unsafe: "thing" } },
+            },
+            {
+              name: "CONFLICTING_NAME_FOUR",
+              type: "another unsafe thing",
+              data: 1337,
+            },
+          ],
+        },
+        vars: {
+          ENV_VAR_ONE: 123,
+          CONFLICTING_NAME_THREE: "Hello, I'm an environment variable",
+        },
+        wasm_modules: {
+          WASM_MODULE_ONE: "./some_wasm.wasm",
+          CONFLICTING_NAME_THREE: "./more_wasm.wasm",
+        },
+      });
+
+      writeWorkerSource({ type: "sw" });
+      fs.writeFileSync("./my-entire-app-depends-on-this.cfg", "config = value");
+      fs.writeFileSync(
+        "./the-entirety-of-human-knowledge.txt",
+        "Everything's bigger in Texas"
+      );
+      fs.writeFileSync("./some_wasm.wasm", "some wasm");
+      fs.writeFileSync("./more_wasm.wasm", "more wasm");
+
+      await expect(runWrangler("publish index.js")).rejects
+        .toMatchInlineSnapshot(`
+              [Error: Processing wrangler.toml configuration:
+                - CONFLICTING_NAME_ONE assigned to Durable Object, KV Namespace, and R2 Bucket bindings.
+                - CONFLICTING_NAME_TWO assigned to Durable Object and KV Namespace bindings.
+                - CONFLICTING_NAME_THREE assigned to R2 Bucket, Text Blob, Unsafe, Environment Variable, and WASM Module bindings.
+                - CONFLICTING_NAME_FOUR assigned to Text Blob and Unsafe bindings.
+                - Bindings must have unique names, so that they can all be referenced in the worker.
+                  Please change your bindings to have unique names.]
+            `);
+      expect(std.out).toMatchInlineSnapshot(`""`);
+      expect(std.err).toMatchInlineSnapshot(`
+        "Processing wrangler.toml configuration:
+          - CONFLICTING_NAME_ONE assigned to Durable Object, KV Namespace, and R2 Bucket bindings.
+          - CONFLICTING_NAME_TWO assigned to Durable Object and KV Namespace bindings.
+          - CONFLICTING_NAME_THREE assigned to R2 Bucket, Text Blob, Unsafe, Environment Variable, and WASM Module bindings.
+          - CONFLICTING_NAME_FOUR assigned to Text Blob and Unsafe bindings.
+          - Bindings must have unique names, so that they can all be referenced in the worker.
+            Please change your bindings to have unique names.
+
+        %s If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
+      `);
+      expect(std.warn).toMatchInlineSnapshot(`
+        "Processing wrangler.toml configuration:
+          - \\"unsafe\\" fields are experimental and may change or break at any time."
+      `);
+    });
+
+    it("should error when bindings of the same type have the same name", async () => {
+      writeWranglerToml({
+        durable_objects: {
+          bindings: [
+            {
+              name: "CONFLICTING_DURABLE_OBJECT_NAME",
+              class_name: "SomeDurableObject",
+              script_name: "some-durable-object-worker",
+            },
+            {
+              name: "CONFLICTING_DURABLE_OBJECT_NAME",
+              class_name: "AnotherDurableObject",
+              script_name: "another-durable-object-worker",
+            },
+          ],
+        },
+        kv_namespaces: [
+          { binding: "CONFLICTING_KV_NAMESPACE_NAME", id: "kv-ns-one-id" },
+          { binding: "CONFLICTING_KV_NAMESPACE_NAME", id: "kv-ns-two-id" },
+        ],
+        r2_buckets: [
+          {
+            binding: "CONFLICTING_R2_BUCKET_NAME",
+            bucket_name: "r2-bucket-one-name",
+          },
+          {
+            binding: "CONFLICTING_R2_BUCKET_NAME",
+            bucket_name: "r2-bucket-two-name",
+          },
+        ],
+        unsafe: {
+          bindings: [
+            {
+              name: "CONFLICTING_UNSAFE_NAME",
+              type: "some unsafe thing",
+              data: { some: { unsafe: "thing" } },
+            },
+            {
+              name: "CONFLICTING_UNSAFE_NAME",
+              type: "another unsafe thing",
+              data: 1337,
+            },
+          ],
+        },
+        // text_blobs, vars, and wasm_modules are fine because they're object literals,
+        // and by definition cannot have two keys of the same name
+        //
+        // text_blobs: {
+        //   CONFLICTING_TEXT_BLOB_NAME: "./my-entire-app-depends-on-this.cfg",
+        //   CONFLICTING_TEXT_BLOB_NAME: "./the-entirety-of-human-knowledge.txt",
+        // },
+        // vars: {
+        //   CONFLICTING_VARS_NAME: 123,
+        //   CONFLICTING_VARS_NAME: "Hello, I'm an environment variable",
+        // },
+        // wasm_modules: {
+        //   CONFLICTING_WASM_MODULE_NAME: "./some_wasm.wasm",
+        //   CONFLICTING_WASM_MODULE_NAME: "./more_wasm.wasm",
+        // },
+      });
+
+      writeWorkerSource({ type: "sw" });
+
+      await expect(runWrangler("publish index.js")).rejects
+        .toMatchInlineSnapshot(`
+              [Error: Processing wrangler.toml configuration:
+                - CONFLICTING_DURABLE_OBJECT_NAME assigned to multiple Durable Object bindings.
+                - CONFLICTING_KV_NAMESPACE_NAME assigned to multiple KV Namespace bindings.
+                - CONFLICTING_R2_BUCKET_NAME assigned to multiple R2 Bucket bindings.
+                - CONFLICTING_UNSAFE_NAME assigned to multiple Unsafe bindings.
+                - Bindings must have unique names, so that they can all be referenced in the worker.
+                  Please change your bindings to have unique names.]
+            `);
+      expect(std.out).toMatchInlineSnapshot(`""`);
+      expect(std.err).toMatchInlineSnapshot(`
+        "Processing wrangler.toml configuration:
+          - CONFLICTING_DURABLE_OBJECT_NAME assigned to multiple Durable Object bindings.
+          - CONFLICTING_KV_NAMESPACE_NAME assigned to multiple KV Namespace bindings.
+          - CONFLICTING_R2_BUCKET_NAME assigned to multiple R2 Bucket bindings.
+          - CONFLICTING_UNSAFE_NAME assigned to multiple Unsafe bindings.
+          - Bindings must have unique names, so that they can all be referenced in the worker.
+            Please change your bindings to have unique names.
+
+        %s If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
+      `);
+      expect(std.warn).toMatchInlineSnapshot(`
+        "Processing wrangler.toml configuration:
+          - \\"unsafe\\" fields are experimental and may change or break at any time."
+      `);
+    });
+
+    it("should error correctly when bindings of the same and different types use the same name", async () => {
+      writeWranglerToml({
+        durable_objects: {
+          bindings: [
+            {
+              name: "CONFLICTING_DURABLE_OBJECT_NAME",
+              class_name: "SomeDurableObject",
+              script_name: "some-durable-object-worker",
+            },
+            {
+              name: "CONFLICTING_DURABLE_OBJECT_NAME",
+              class_name: "AnotherDurableObject",
+              script_name: "another-durable-object-worker",
+            },
+          ],
+        },
+        kv_namespaces: [
+          {
+            binding: "CONFLICTING_KV_NAMESPACE_NAME",
+            id: "kv-ns-one-id",
+          },
+          {
+            binding: "CONFLICTING_KV_NAMESPACE_NAME",
+            id: "kv-ns-two-id",
+          },
+          { binding: "CONFLICTING_NAME_ONE", id: "kv-ns-three-id" },
+          { binding: "CONFLICTING_NAME_TWO", id: "kv-ns-four-id" },
+        ],
+        r2_buckets: [
+          {
+            binding: "CONFLICTING_R2_BUCKET_NAME",
+            bucket_name: "r2-bucket-one-name",
+          },
+          {
+            binding: "CONFLICTING_R2_BUCKET_NAME",
+            bucket_name: "r2-bucket-two-name",
+          },
+          {
+            binding: "CONFLICTING_NAME_THREE",
+            bucket_name: "r2-bucket-three-name",
+          },
+          {
+            binding: "CONFLICTING_NAME_FOUR",
+            bucket_name: "r2-bucket-four-name",
+          },
+        ],
+        text_blobs: {
+          CONFLICTING_NAME_THREE: "./my-entire-app-depends-on-this.cfg",
+          CONFLICTING_NAME_FOUR: "./the-entirety-of-human-knowledge.txt",
+        },
+        unsafe: {
+          bindings: [
+            {
+              name: "CONFLICTING_UNSAFE_NAME",
+              type: "some unsafe thing",
+              data: { some: { unsafe: "thing" } },
+            },
+            {
+              name: "CONFLICTING_UNSAFE_NAME",
+              type: "another unsafe thing",
+              data: 1337,
+            },
+            {
+              name: "CONFLICTING_NAME_THREE",
+              type: "yet another unsafe thing",
+              data: "how is a string unsafe?",
+            },
+            {
+              name: "CONFLICTING_NAME_FOUR",
+              type: "a fourth unsafe thing",
+              data: null,
+            },
+          ],
+        },
+        vars: {
+          ENV_VAR_ONE: 123,
+          CONFLICTING_NAME_THREE: "Hello, I'm an environment variable",
+        },
+        wasm_modules: {
+          WASM_MODULE_ONE: "./some_wasm.wasm",
+          CONFLICTING_NAME_THREE: "./more_wasm.wasm",
+        },
+      });
+
+      writeWorkerSource({ type: "sw" });
+      fs.writeFileSync("./my-entire-app-depends-on-this.cfg", "config = value");
+      fs.writeFileSync(
+        "./the-entirety-of-human-knowledge.txt",
+        "Everything's bigger in Texas"
+      );
+      fs.writeFileSync("./some_wasm.wasm", "some wasm");
+      fs.writeFileSync("./more_wasm.wasm", "more wasm");
+
+      await expect(runWrangler("publish index.js")).rejects
+        .toMatchInlineSnapshot(`
+              [Error: Processing wrangler.toml configuration:
+                - CONFLICTING_DURABLE_OBJECT_NAME assigned to multiple Durable Object bindings.
+                - CONFLICTING_KV_NAMESPACE_NAME assigned to multiple KV Namespace bindings.
+                - CONFLICTING_R2_BUCKET_NAME assigned to multiple R2 Bucket bindings.
+                - CONFLICTING_NAME_THREE assigned to R2 Bucket, Text Blob, Unsafe, Environment Variable, and WASM Module bindings.
+                - CONFLICTING_NAME_FOUR assigned to R2 Bucket, Text Blob, and Unsafe bindings.
+                - CONFLICTING_UNSAFE_NAME assigned to multiple Unsafe bindings.
+                - Bindings must have unique names, so that they can all be referenced in the worker.
+                  Please change your bindings to have unique names.]
+            `);
+      expect(std.out).toMatchInlineSnapshot(`""`);
+      expect(std.err).toMatchInlineSnapshot(`
+        "Processing wrangler.toml configuration:
+          - CONFLICTING_DURABLE_OBJECT_NAME assigned to multiple Durable Object bindings.
+          - CONFLICTING_KV_NAMESPACE_NAME assigned to multiple KV Namespace bindings.
+          - CONFLICTING_R2_BUCKET_NAME assigned to multiple R2 Bucket bindings.
+          - CONFLICTING_NAME_THREE assigned to R2 Bucket, Text Blob, Unsafe, Environment Variable, and WASM Module bindings.
+          - CONFLICTING_NAME_FOUR assigned to R2 Bucket, Text Blob, and Unsafe bindings.
+          - CONFLICTING_UNSAFE_NAME assigned to multiple Unsafe bindings.
+          - Bindings must have unique names, so that they can all be referenced in the worker.
+            Please change your bindings to have unique names.
+
+        %s If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
+      `);
+      expect(std.warn).toMatchInlineSnapshot(`
+        "Processing wrangler.toml configuration:
+          - \\"unsafe\\" fields are experimental and may change or break at any time."
+      `);
+    });
+
+    describe("[wasm_modules]", () => {
+      it("should be able to define wasm modules for service-worker format workers", async () => {
+        writeWranglerToml({
+          wasm_modules: {
+            TESTWASMNAME: "./path/to/test.wasm",
+          },
+        });
+        writeWorkerSource({ type: "sw" });
+        fs.mkdirSync("./path/to", { recursive: true });
+        fs.writeFileSync("./path/to/test.wasm", "SOME WASM CONTENT");
+        mockUploadWorkerRequest({
+          expectedType: "sw",
+          expectedModules: { TESTWASMNAME: "SOME WASM CONTENT" },
+          expectedBindings: [
+            { name: "TESTWASMNAME", part: "TESTWASMNAME", type: "wasm_module" },
+          ],
+        });
+        mockSubDomainRequest();
+        await runWrangler("publish index.js");
+        expect(std.out).toMatchInlineSnapshot(`
+                  "Uploaded test-name (TIMINGS)
+                  Published test-name (TIMINGS)
+                    test-name.test-sub-domain.workers.dev"
+              `);
+        expect(std.err).toMatchInlineSnapshot(`""`);
+        expect(std.warn).toMatchInlineSnapshot(`""`);
+      });
+
+      it("should error when defining wasm modules for modules format workers", async () => {
+        writeWranglerToml({
+          wasm_modules: {
+            TESTWASMNAME: "./path/to/test.wasm",
+          },
+        });
+        writeWorkerSource({ type: "esm" });
+        fs.mkdirSync("./path/to", { recursive: true });
+        fs.writeFileSync("./path/to/test.wasm", "SOME WASM CONTENT");
+
+        await expect(
+          runWrangler("publish index.js")
+        ).rejects.toThrowErrorMatchingInlineSnapshot(
+          `"You cannot configure [wasm_modules] with an ES module worker. Instead, import the .wasm module directly in your code"`
+        );
+        expect(std.out).toMatchInlineSnapshot(`""`);
+        expect(std.err).toMatchInlineSnapshot(`
+                  "You cannot configure [wasm_modules] with an ES module worker. Instead, import the .wasm module directly in your code
+
+                  %s If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
+              `);
+        expect(std.warn).toMatchInlineSnapshot(`""`);
+      });
+
+      it("should resolve wasm modules relative to the wrangler.toml file", async () => {
+        fs.mkdirSync("./path/to/and/the/path/to/", { recursive: true });
+        fs.writeFileSync(
+          "./path/to/wrangler.toml",
+          TOML.stringify({
+            compatibility_date: "2022-01-12",
+            name: "test-name",
+            wasm_modules: {
+              TESTWASMNAME: "./and/the/path/to/test.wasm",
+            },
+          }),
+
+          "utf-8"
+        );
+
+        writeWorkerSource({ type: "sw" });
+        fs.writeFileSync(
+          "./path/to/and/the/path/to/test.wasm",
+          "SOME WASM CONTENT"
+        );
+        mockUploadWorkerRequest({
+          expectedType: "sw",
+          expectedModules: { TESTWASMNAME: "SOME WASM CONTENT" },
+          expectedBindings: [
+            { name: "TESTWASMNAME", part: "TESTWASMNAME", type: "wasm_module" },
+          ],
+          expectedCompatibilityDate: "2022-01-12",
+        });
+        mockSubDomainRequest();
+        await runWrangler("publish index.js --config ./path/to/wrangler.toml");
+        expect(std.out).toMatchInlineSnapshot(`
+                  "Uploaded test-name (TIMINGS)
+                  Published test-name (TIMINGS)
+                    test-name.test-sub-domain.workers.dev"
+              `);
+        expect(std.err).toMatchInlineSnapshot(`""`);
+        expect(std.warn).toMatchInlineSnapshot(`""`);
+      });
+
+      it("should be able to import .wasm modules from service-worker format workers", async () => {
+        writeWranglerToml();
+        fs.writeFileSync(
+          "./index.js",
+          "import TESTWASMNAME from './test.wasm';"
+        );
+        fs.writeFileSync("./test.wasm", "SOME WASM CONTENT");
+        mockUploadWorkerRequest({
+          expectedType: "sw",
+          expectedModules: {
+            __94b240d0d692281e6467aa42043986e5c7eea034_test_wasm:
+              "SOME WASM CONTENT",
+          },
+          expectedBindings: [
+            {
+              name: "__94b240d0d692281e6467aa42043986e5c7eea034_test_wasm",
+              part: "__94b240d0d692281e6467aa42043986e5c7eea034_test_wasm",
+              type: "wasm_module",
+            },
+          ],
+        });
+        mockSubDomainRequest();
+        await runWrangler("publish index.js");
+        expect(std.out).toMatchInlineSnapshot(`
+                  "Uploaded test-name (TIMINGS)
+                  Published test-name (TIMINGS)
+                    test-name.test-sub-domain.workers.dev"
+              `);
+        expect(std.err).toMatchInlineSnapshot(`""`);
+        expect(std.warn).toMatchInlineSnapshot(`""`);
+      });
+    });
+
+    describe("[text_blobs]", () => {
+      it("should be able to define text blobs for service-worker format workers", async () => {
+        writeWranglerToml({
+          text_blobs: {
+            TESTTEXTBLOBNAME: "./path/to/text.file",
+          },
+        });
+        writeWorkerSource({ type: "sw" });
+        fs.mkdirSync("./path/to", { recursive: true });
+        fs.writeFileSync("./path/to/text.file", "SOME TEXT CONTENT");
+        mockUploadWorkerRequest({
+          expectedType: "sw",
+          expectedModules: { TESTTEXTBLOBNAME: "SOME TEXT CONTENT" },
+          expectedBindings: [
+            {
+              name: "TESTTEXTBLOBNAME",
+              part: "TESTTEXTBLOBNAME",
+              type: "text_blob",
+            },
+          ],
+        });
+        mockSubDomainRequest();
+        await runWrangler("publish index.js");
+        expect(std.out).toMatchInlineSnapshot(`
+                  "Uploaded test-name (TIMINGS)
+                  Published test-name (TIMINGS)
+                    test-name.test-sub-domain.workers.dev"
+              `);
+        expect(std.err).toMatchInlineSnapshot(`""`);
+        expect(std.warn).toMatchInlineSnapshot(`""`);
+      });
+
+      it("should error when defining text blobs for modules format workers", async () => {
+        writeWranglerToml({
+          text_blobs: {
+            TESTTEXTBLOBNAME: "./path/to/text.file",
+          },
+        });
+        writeWorkerSource({ type: "esm" });
+        fs.mkdirSync("./path/to", { recursive: true });
+        fs.writeFileSync("./path/to/text.file", "SOME TEXT CONTENT");
+
+        await expect(
+          runWrangler("publish index.js")
+        ).rejects.toThrowErrorMatchingInlineSnapshot(
+          `"You cannot configure [text_blobs] with an ES module worker. Instead, import the file directly in your code, and optionally configure \`[build.upload.rules]\` in your wrangler.toml"`
+        );
+        expect(std.out).toMatchInlineSnapshot(`""`);
+        expect(std.err).toMatchInlineSnapshot(`
+                  "You cannot configure [text_blobs] with an ES module worker. Instead, import the file directly in your code, and optionally configure \`[build.upload.rules]\` in your wrangler.toml
+
+                  %s If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
+              `);
+        expect(std.warn).toMatchInlineSnapshot(`""`);
+      });
+
+      it("should resolve text blobs relative to the wrangler.toml file", async () => {
+        fs.mkdirSync("./path/to/and/the/path/to/", { recursive: true });
+        fs.writeFileSync(
+          "./path/to/wrangler.toml",
+          TOML.stringify({
+            compatibility_date: "2022-01-12",
+            name: "test-name",
+            text_blobs: {
+              TESTTEXTBLOBNAME: "./and/the/path/to/text.file",
+            },
+          }),
+
+          "utf-8"
+        );
+
+        writeWorkerSource({ type: "sw" });
+        fs.writeFileSync(
+          "./path/to/and/the/path/to/text.file",
+          "SOME TEXT CONTENT"
+        );
+        mockUploadWorkerRequest({
+          expectedType: "sw",
+          expectedModules: { TESTTEXTBLOBNAME: "SOME TEXT CONTENT" },
+          expectedBindings: [
+            {
+              name: "TESTTEXTBLOBNAME",
+              part: "TESTTEXTBLOBNAME",
+              type: "text_blob",
+            },
+          ],
+          expectedCompatibilityDate: "2022-01-12",
+        });
+        mockSubDomainRequest();
+        await runWrangler("publish index.js --config ./path/to/wrangler.toml");
+        expect(std.out).toMatchInlineSnapshot(`
+                  "Uploaded test-name (TIMINGS)
+                  Published test-name (TIMINGS)
+                    test-name.test-sub-domain.workers.dev"
+              `);
+        expect(std.err).toMatchInlineSnapshot(`""`);
+        expect(std.warn).toMatchInlineSnapshot(`""`);
+      });
+    });
+
+    describe("[vars]", () => {
+      it("should support json bindings", async () => {
+        writeWranglerToml({
+          vars: {
+            text: "plain ol' string",
+            count: 1,
+            complex: { enabled: true, id: 123 },
+          },
+        });
+        writeWorkerSource();
+        mockSubDomainRequest();
+        mockUploadWorkerRequest({
+          expectedBindings: [
+            { name: "text", type: "plain_text", text: "plain ol' string" },
+            { name: "count", type: "json", json: 1 },
+            {
+              name: "complex",
+              type: "json",
+              json: { enabled: true, id: 123 },
+            },
+          ],
+        });
+
+        await runWrangler("publish index.js");
+        expect(std.out).toMatchInlineSnapshot(`
+                  "Uploaded test-name (TIMINGS)
+                  Published test-name (TIMINGS)
+                    test-name.test-sub-domain.workers.dev"
+              `);
+        expect(std.err).toMatchInlineSnapshot(`""`);
+        expect(std.warn).toMatchInlineSnapshot(`""`);
+      });
+    });
+
+    describe("[r2_buckets]", () => {
+      it("should support r2 bucket bindings", async () => {
+        writeWranglerToml({
+          r2_buckets: [{ binding: "FOO", bucket_name: "foo-bucket" }],
+        });
+        writeWorkerSource();
+        mockSubDomainRequest();
+        mockUploadWorkerRequest({
+          expectedBindings: [
+            { bucket_name: "foo-bucket", name: "FOO", type: "r2_bucket" },
+          ],
+        });
+
+        await runWrangler("publish index.js");
+        expect(std.out).toMatchInlineSnapshot(`
+                  "Uploaded test-name (TIMINGS)
+                  Published test-name (TIMINGS)
+                    test-name.test-sub-domain.workers.dev"
+              `);
+        expect(std.err).toMatchInlineSnapshot(`""`);
+        expect(std.warn).toMatchInlineSnapshot(`""`);
       });
-      writeWorkerSource();
-      mockSubDomainRequest();
-      mockUploadWorkerRequest({
-        expectedBindings: [
-          { name: "text", type: "plain_text", text: "plain ol' string" },
-          { name: "count", type: "json", json: 1 },
-          {
-            name: "complex",
-            type: "json",
-            json: { enabled: true, id: 123 },
+    });
+
+    describe("[durable_objects]", () => {
+      it("should support durable object bindings", async () => {
+        writeWranglerToml({
+          durable_objects: {
+            bindings: [
+              {
+                name: "EXAMPLE_DO_BINDING",
+                class_name: "ExampleDurableObject",
+              },
+            ],
           },
-        ],
-      });
+        });
+        writeWorkerSource({ type: "esm" });
+        mockSubDomainRequest();
+        mockUploadWorkerRequest({
+          expectedBindings: [
+            {
+              class_name: "ExampleDurableObject",
+              name: "EXAMPLE_DO_BINDING",
+              type: "durable_object_namespace",
+            },
+          ],
+        });
 
-      await runWrangler("publish index.js");
-      expect(std.out).toMatchInlineSnapshot(`
-        "Uploaded
-        test-name
-        (TIMINGS)
-        Published
-        test-name
-        (TIMINGS)
+        await runWrangler("publish index.js");
+        expect(std.out).toMatchInlineSnapshot(`
+                  "Uploaded test-name (TIMINGS)
+                  Published test-name (TIMINGS)
+                    test-name.test-sub-domain.workers.dev"
+              `);
+        expect(std.err).toMatchInlineSnapshot(`""`);
+        expect(std.warn).toMatchInlineSnapshot(`""`);
+      });
 
-        test-name.test-sub-domain.workers.dev"
-      `);
-      expect(std.err).toMatchInlineSnapshot(`""`);
-      expect(std.warn).toMatchInlineSnapshot(`""`);
-    });
-  });
+      it("should support service-workers binding to external durable objects", async () => {
+        writeWranglerToml({
+          durable_objects: {
+            bindings: [
+              {
+                name: "EXAMPLE_DO_BINDING",
+                class_name: "ExampleDurableObject",
+                script_name: "example-do-binding-worker",
+              },
+            ],
+          },
+        });
+        writeWorkerSource({ type: "sw" });
+        mockSubDomainRequest();
+        mockUploadWorkerRequest({
+          expectedType: "sw",
+          expectedBindings: [
+            {
+              name: "EXAMPLE_DO_BINDING",
+              class_name: "ExampleDurableObject",
+              script_name: "example-do-binding-worker",
+              type: "durable_object_namespace",
+            },
+          ],
+        });
 
-  describe("r2 bucket bindings", () => {
-    it("should support r2 bucket bindings", async () => {
-      writeWranglerToml({
-        r2_buckets: [{ binding: "FOO", bucket_name: "foo-bucket" }],
+        await runWrangler("publish index.js");
+        expect(std.out).toMatchInlineSnapshot(`
+                  "Uploaded test-name (TIMINGS)
+                  Published test-name (TIMINGS)
+                    test-name.test-sub-domain.workers.dev"
+              `);
+        expect(std.err).toMatchInlineSnapshot(`""`);
+        expect(std.warn).toMatchInlineSnapshot(`""`);
       });
-      writeWorkerSource();
-      mockSubDomainRequest();
-      mockUploadWorkerRequest({
-        expectedBindings: [
-          { bucket_name: "foo-bucket", name: "FOO", type: "r2_bucket" },
-        ],
+
+      it("should support module workers implementing durable objects", async () => {
+        writeWranglerToml({
+          durable_objects: {
+            bindings: [
+              {
+                name: "EXAMPLE_DO_BINDING",
+                class_name: "ExampleDurableObject",
+              },
+            ],
+          },
+        });
+        writeWorkerSource({ type: "esm" });
+        mockSubDomainRequest();
+        mockUploadWorkerRequest({
+          expectedType: "esm",
+          expectedBindings: [
+            {
+              name: "EXAMPLE_DO_BINDING",
+              class_name: "ExampleDurableObject",
+              type: "durable_object_namespace",
+            },
+          ],
+        });
+
+        await runWrangler("publish index.js");
+        expect(std.out).toMatchInlineSnapshot(`
+                  "Uploaded test-name (TIMINGS)
+                  Published test-name (TIMINGS)
+                    test-name.test-sub-domain.workers.dev"
+              `);
+        expect(std.err).toMatchInlineSnapshot(`""`);
+        expect(std.warn).toMatchInlineSnapshot(`""`);
       });
 
-      await runWrangler("publish index.js");
-      expect(std.out).toMatchInlineSnapshot(`
-        "Uploaded
-        test-name
-        (TIMINGS)
-        Published
-        test-name
-        (TIMINGS)
+      it("should error when detecting service workers implementing  durable objects", async () => {
+        writeWranglerToml({
+          durable_objects: {
+            bindings: [
+              {
+                name: "EXAMPLE_DO_BINDING",
+                class_name: "ExampleDurableObject",
+              },
+            ],
+          },
+        });
+        writeWorkerSource({ type: "sw" });
+        mockSubDomainRequest();
 
-        test-name.test-sub-domain.workers.dev"
-      `);
-      expect(std.err).toMatchInlineSnapshot(`""`);
-      expect(std.warn).toMatchInlineSnapshot(`""`);
+        await expect(runWrangler("publish index.js")).rejects
+          .toThrowErrorMatchingInlineSnapshot(`
+                              "You seem to be trying to use Durable Objects in a Worker written with Service Worker syntax.
+                              You can use Durable Objects defined in other Workers by specifying a \`script_name\` in your wrangler.toml, where \`script_name\` is the name of the Worker that implements that Durable Object. For example:
+                              { name = EXAMPLE_DO_BINDING, class_name = ExampleDurableObject } ==> { name = EXAMPLE_DO_BINDING, class_name = ExampleDurableObject, script_name = example-do-binding-worker }
+                              Alternatively, migrate your worker to ES Module syntax to implement a Durable Object in this Worker:
+                              https://developers.cloudflare.com/workers/learning/migrating-to-module-workers/"
+                          `);
+      });
     });
-  });
 
-  describe("unsafe bindings", () => {
-    it("should warn if using unsafe bindings", async () => {
-      writeWranglerToml({
-        unsafe: {
-          bindings: [
+    describe("[unsafe]", () => {
+      it("should warn if using unsafe bindings", async () => {
+        writeWranglerToml({
+          unsafe: {
+            bindings: [
+              {
+                name: "my-binding",
+                type: "binding-type",
+                param: "binding-param",
+              },
+            ],
+          },
+        });
+        writeWorkerSource();
+        mockSubDomainRequest();
+        mockUploadWorkerRequest({
+          expectedBindings: [
             {
               name: "my-binding",
               type: "binding-type",
               param: "binding-param",
             },
           ],
-        },
+        });
+
+        await runWrangler("publish index.js");
+        expect(std.out).toMatchInlineSnapshot(`
+                  "Uploaded test-name (TIMINGS)
+                  Published test-name (TIMINGS)
+                    test-name.test-sub-domain.workers.dev"
+              `);
+        expect(std.err).toMatchInlineSnapshot(`""`);
+        expect(std.warn).toMatchInlineSnapshot(`
+                  "Processing wrangler.toml configuration:
+                    - \\"unsafe\\" fields are experimental and may change or break at any time."
+              `);
       });
-      writeWorkerSource();
-      mockSubDomainRequest();
-      mockUploadWorkerRequest({
-        expectedBindings: [
-          {
-            name: "my-binding",
-            type: "binding-type",
-            param: "binding-param",
+      it("should warn if using unsafe bindings already handled by wrangler", async () => {
+        writeWranglerToml({
+          unsafe: {
+            bindings: [
+              {
+                name: "my-binding",
+                type: "plain_text",
+                text: "text",
+              },
+            ],
           },
-        ],
-      });
-
-      await runWrangler("publish index.js");
-      expect(std.out).toMatchInlineSnapshot(`
-        "Uploaded
-        test-name
-        (TIMINGS)
-        Published
-        test-name
-        (TIMINGS)
-
-        test-name.test-sub-domain.workers.dev"
-      `);
-      expect(std.err).toMatchInlineSnapshot(`""`);
-      expect(std.warn).toMatchInlineSnapshot(`
-        "Processing wrangler.toml configuration:
-          - \\"unsafe\\" fields are experimental and may change or break at any time."
-      `);
-    });
-    it("should warn if using unsafe bindings already handled by wrangler", async () => {
-      writeWranglerToml({
-        unsafe: {
-          bindings: [
+        });
+        writeWorkerSource();
+        mockSubDomainRequest();
+        mockUploadWorkerRequest({
+          expectedBindings: [
             {
               name: "my-binding",
               type: "plain_text",
               text: "text",
             },
           ],
-        },
-      });
-      writeWorkerSource();
-      mockSubDomainRequest();
-      mockUploadWorkerRequest({
-        expectedBindings: [
-          {
-            name: "my-binding",
-            type: "plain_text",
-            text: "text",
-          },
-        ],
-      });
-
-      await runWrangler("publish index.js");
-      expect(std.out).toMatchInlineSnapshot(`
-        "Uploaded
-        test-name
-        (TIMINGS)
-        Published
-        test-name
-        (TIMINGS)
+        });
 
-        test-name.test-sub-domain.workers.dev"
-      `);
-      expect(std.err).toMatchInlineSnapshot(`""`);
-      expect(std.warn).toMatchInlineSnapshot(`
-        "Processing wrangler.toml configuration:
-          - \\"unsafe\\" fields are experimental and may change or break at any time.
-          - \\"unsafe.bindings[0]\\": {\\"name\\":\\"my-binding\\",\\"type\\":\\"plain_text\\",\\"text\\":\\"text\\"}
-            - The binding type \\"plain_text\\" is directly supported by wrangler.
-              Consider migrating this unsafe binding to a format for 'plain_text' bindings that is supported by wrangler for optimal support.
-              For more details, see https://developers.cloudflare.com/workers/cli-wrangler/configuration"
-      `);
+        await runWrangler("publish index.js");
+        expect(std.out).toMatchInlineSnapshot(`
+                  "Uploaded test-name (TIMINGS)
+                  Published test-name (TIMINGS)
+                    test-name.test-sub-domain.workers.dev"
+              `);
+        expect(std.err).toMatchInlineSnapshot(`""`);
+        expect(std.warn).toMatchInlineSnapshot(`
+                  "Processing wrangler.toml configuration:
+                    - \\"unsafe\\" fields are experimental and may change or break at any time.
+                    - \\"unsafe.bindings[0]\\": {\\"name\\":\\"my-binding\\",\\"type\\":\\"plain_text\\",\\"text\\":\\"text\\"}
+                      - The binding type \\"plain_text\\" is directly supported by wrangler.
+                        Consider migrating this unsafe binding to a format for 'plain_text' bindings that is supported by wrangler for optimal support.
+                        For more details, see https://developers.cloudflare.com/workers/cli-wrangler/configuration"
+              `);
+      });
     });
   });
 
@@ -1996,14 +2958,9 @@ export default{
       });
       await runWrangler("publish index.js");
       expect(std.out).toMatchInlineSnapshot(`
-        "Uploaded
-        test-name
-        (TIMINGS)
-        Published
-        test-name
-        (TIMINGS)
-
-        test-name.test-sub-domain.workers.dev"
+        "Uploaded test-name (TIMINGS)
+        Published test-name (TIMINGS)
+          test-name.test-sub-domain.workers.dev"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
       expect(std.warn).toMatchInlineSnapshot(`""`);
@@ -2029,14 +2986,9 @@ export default{
       });
       await runWrangler("publish index.js");
       expect(std.out).toMatchInlineSnapshot(`
-        "Uploaded
-        test-name
-        (TIMINGS)
-        Published
-        test-name
-        (TIMINGS)
-
-        test-name.test-sub-domain.workers.dev"
+        "Uploaded test-name (TIMINGS)
+        Published test-name (TIMINGS)
+          test-name.test-sub-domain.workers.dev"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
       expect(std.warn).toMatchInlineSnapshot(`""`);
@@ -2066,14 +3018,9 @@ export default{
       });
       await runWrangler("publish index.js");
       expect(std.out).toMatchInlineSnapshot(`
-        "Uploaded
-        test-name
-        (TIMINGS)
-        Published
-        test-name
-        (TIMINGS)
-
-        test-name.test-sub-domain.workers.dev"
+        "Uploaded test-name (TIMINGS)
+        Published test-name (TIMINGS)
+          test-name.test-sub-domain.workers.dev"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
       expect(std.warn).toMatchInlineSnapshot(`
@@ -2114,14 +3061,9 @@ export default{
       });
       await runWrangler("publish index.js");
       expect(std.out).toMatchInlineSnapshot(`
-        "Uploaded
-        test-name
-        (TIMINGS)
-        Published
-        test-name
-        (TIMINGS)
-
-        test-name.test-sub-domain.workers.dev"
+        "Uploaded test-name (TIMINGS)
+        Published test-name (TIMINGS)
+          test-name.test-sub-domain.workers.dev"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
       expect(std.warn).toMatchInlineSnapshot(`""`);
@@ -2185,6 +3127,120 @@ export default{
         The default module rule {\\"type\\":\\"Text\\",\\"globs\\":[\\"**/*.txt\\",\\"**/*.html\\"]} has the same type as a previous rule (at position 0, {\\"type\\":\\"Text\\",\\"globs\\":[\\"**/*.file\\"]}). This rule will be ignored. To the previous rule, add \`fallthrough = true\` to allow the default one to also be used, or \`fallthrough = false\` to silence this warning."
       `);
     });
+
+    describe("inject process.env.NODE_ENV", () => {
+      let actualProcessEnvNodeEnv: string | undefined;
+      beforeEach(() => {
+        actualProcessEnvNodeEnv = process.env.NODE_ENV;
+        process.env.NODE_ENV = "some-node-env";
+      });
+      afterEach(() => {
+        process.env.NODE_ENV = actualProcessEnvNodeEnv;
+      });
+      it("should replace `process.env.NODE_ENV` in scripts", async () => {
+        writeWranglerToml();
+        fs.writeFileSync(
+          "./index.js",
+          `export default {
+            fetch(){
+              return new Response(process.env.NODE_ENV);
+            }
+          }`
+        );
+        mockSubDomainRequest();
+        mockUploadWorkerRequest({
+          expectedEntry: `return new Response("some-node-env");`,
+        });
+        await runWrangler("publish index.js");
+        expect(std.out).toMatchInlineSnapshot(`
+          "Uploaded test-name (TIMINGS)
+          Published test-name (TIMINGS)
+            test-name.test-sub-domain.workers.dev"
+        `);
+        expect(std.err).toMatchInlineSnapshot(`""`);
+        expect(std.warn).toMatchInlineSnapshot(`""`);
+      });
+    });
+  });
+
+  describe("legacy module specifiers", () => {
+    it("should work with legacy module specifiers, with a deprecation warning (1)", async () => {
+      writeWranglerToml({
+        rules: [{ type: "Text", globs: ["**/*.file"], fallthrough: false }],
+      });
+      fs.writeFileSync(
+        "./index.js",
+        `import TEXT from 'text.file'; export default {};`
+      );
+      fs.writeFileSync("./text.file", "SOME TEXT CONTENT");
+      mockSubDomainRequest();
+      mockUploadWorkerRequest({
+        expectedModules: {
+          "./2d91d1c4dd6e57d4f5432187ab7c25f45a8973f0-text.file":
+            "SOME TEXT CONTENT",
+        },
+      });
+      await runWrangler("publish index.js");
+      expect(std.out).toMatchInlineSnapshot(`
+        "Uploaded test-name (TIMINGS)
+        Published test-name (TIMINGS)
+          test-name.test-sub-domain.workers.dev"
+      `);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+      expect(std.warn).toMatchInlineSnapshot(
+        `"Deprecation warning: detected a legacy module import in \\"./index.js\\". This will stop working in the future. Replace references to \\"text.file\\" with \\"./text.file\\";"`
+      );
+    });
+  });
+
+  it("should work with legacy module specifiers, with a deprecation warning (2)", async () => {
+    writeWranglerToml();
+    fs.writeFileSync(
+      "./index.js",
+      `import WASM from 'index.wasm'; export default {};`
+    );
+    fs.writeFileSync("./index.wasm", "SOME WASM CONTENT");
+    mockSubDomainRequest();
+    mockUploadWorkerRequest({
+      expectedModules: {
+        "./94b240d0d692281e6467aa42043986e5c7eea034-index.wasm":
+          "SOME WASM CONTENT",
+      },
+    });
+    await runWrangler("publish index.js");
+    expect(std.out).toMatchInlineSnapshot(`
+      "Uploaded test-name (TIMINGS)
+      Published test-name (TIMINGS)
+        test-name.test-sub-domain.workers.dev"
+    `);
+    expect(std.err).toMatchInlineSnapshot(`""`);
+    expect(std.warn).toMatchInlineSnapshot(
+      `"Deprecation warning: detected a legacy module import in \\"./index.js\\". This will stop working in the future. Replace references to \\"index.wasm\\" with \\"./index.wasm\\";"`
+    );
+  });
+
+  it("should not match regular module specifiers when there aren't any possible legacy module matches", async () => {
+    // see https://github.com/cloudflare/wrangler2/issues/655 for bug details
+
+    fs.writeFileSync(
+      "./index.js",
+      `import inner from './inner/index.js'; export default {};`
+    );
+    fs.mkdirSync("./inner", { recursive: true });
+    fs.writeFileSync("./inner/index.js", `export default 123`);
+    mockSubDomainRequest();
+    mockUploadWorkerRequest();
+
+    await runWrangler(
+      "publish index.js --compatibility-date 2022-03-17 --name test-name"
+    );
+    expect(std.out).toMatchInlineSnapshot(`
+      "Uploaded test-name (TIMINGS)
+      Published test-name (TIMINGS)
+        test-name.test-sub-domain.workers.dev"
+    `);
+    expect(std.err).toMatchInlineSnapshot(`""`);
+    expect(std.warn).toMatchInlineSnapshot(`""`);
   });
 });
 
@@ -2233,6 +3289,8 @@ function mockUploadWorkerRequest({
   expectedType = "esm",
   expectedBindings,
   expectedModules = {},
+  expectedCompatibilityDate,
+  expectedCompatibilityFlags,
   env = undefined,
   legacyEnv = false,
 }: {
@@ -2241,8 +3299,10 @@ function mockUploadWorkerRequest({
   expectedType?: "esm" | "sw";
   expectedBindings?: unknown;
   expectedModules?: Record<string, string>;
-  env?: string | undefined;
-  legacyEnv?: boolean | undefined;
+  expectedCompatibilityDate?: string;
+  expectedCompatibilityFlags?: string[];
+  env?: string;
+  legacyEnv?: boolean;
 } = {}) {
   setMockResponse(
     env && !legacyEnv
@@ -2264,7 +3324,6 @@ function mockUploadWorkerRequest({
           expectedEntry
         );
       }
-
       const metadata = JSON.parse(
         formBody.get("metadata") as string
       ) as WorkerMetadata;
@@ -2276,6 +3335,14 @@ function mockUploadWorkerRequest({
       if (expectedBindings !== undefined) {
         expect(metadata.bindings).toEqual(expectedBindings);
       }
+      if (expectedCompatibilityDate !== undefined) {
+        expect(metadata.compatibility_date).toEqual(expectedCompatibilityDate);
+      }
+      if (expectedCompatibilityFlags !== undefined) {
+        expect(metadata.compatibility_flags).toEqual(
+          expectedCompatibilityFlags
+        );
+      }
       for (const [name, content] of Object.entries(expectedModules)) {
         expect(await (formBody.get(name) as File).text()).toEqual(content);
       }
@@ -2286,10 +3353,21 @@ function mockUploadWorkerRequest({
 }
 
 /** Create a mock handler for the request to get the account's subdomain. */
-function mockSubDomainRequest(subdomain = "test-sub-domain") {
-  setMockResponse("/accounts/:accountId/workers/subdomain", "GET", () => {
-    return { subdomain };
-  });
+function mockSubDomainRequest(
+  subdomain = "test-sub-domain",
+  registeredWorkersDev = true
+) {
+  if (registeredWorkersDev) {
+    setMockResponse("/accounts/:accountId/workers/subdomain", "GET", () => {
+      return { subdomain };
+    });
+  } else {
+    setMockRawResponse("/accounts/:accountId/workers/subdomain", "GET", () => {
+      return createFetchResult(null, false, [
+        { code: 10007, message: "haven't registered workers.dev" },
+      ]);
+    });
+  }
 }
 
 /** Create a mock handler to toggle a <script>.<user>.workers.dev subdomain */
@@ -2370,7 +3448,12 @@ function mockListKVNamespacesRequest(...namespaces: KVNamespaceInfo[]) {
 /** Create a mock handler for the request that tries to do a bulk upload of assets to a KV namespace. */
 function mockUploadAssetsToKVRequest(
   expectedNamespaceId: string,
-  assets: { filePath: string; content: string }[]
+  assets: {
+    filePath: string;
+    content: string;
+    expiration?: number;
+    expiration_ttl?: number;
+  }[]
 ) {
   setMockResponse(
     "/accounts/:accountId/storage/kv/namespaces/:namespaceId/bulk",
@@ -2399,8 +3482,28 @@ function mockUploadAssetsToKVRequest(
         expect(Buffer.from(upload.value, "base64").toString()).toEqual(
           asset.content
         );
+        expect(upload.expiration).toEqual(asset.expiration);
+        expect(upload.expiration_ttl).toEqual(asset.expiration_ttl);
       }
       return null;
     }
   );
 }
+
+/** Create a mock handler for thr request that does a bulk delete of unused assets */
+function mockDeleteUnusedAssetsRequest(
+  expectedNamespaceId: string,
+  assets: string[]
+) {
+  setMockResponse(
+    "/accounts/:accountId/storage/kv/namespaces/:namespaceId/bulk",
+    "DELETE",
+    ([_url, accountId, namespaceId], { body }) => {
+      expect(accountId).toEqual("some-account-id");
+      expect(namespaceId).toEqual(expectedNamespaceId);
+      const deletes = JSON.parse(body as string);
+      expect(assets).toEqual(deletes);
+      return null;
+    }
+  );
+}