wrangler 0.0.0-e3cab74 → 0.0.0-e3ce82b

package/src/__tests__/configuration.test.ts

@@ -1,39 +1,49 @@
 import path from "node:path";
 import { normalizeAndValidateConfig } from "../config/validation";
-import type { RawConfig, RawEnvironment } from "../config";
+import { normalizeSlashes } from "./helpers/mock-console";
+import type {
+  ConfigFields,
+  RawDevConfig,
+  RawConfig,
+  RawEnvironment,
+} from "../config";
 
 describe("normalizeAndValidateConfig()", () => {
   it("should use defaults for empty configuration", () => {
-    const { config, diagnostics } = normalizeAndValidateConfig({}, undefined);
+    const { config, diagnostics } = normalizeAndValidateConfig({}, undefined, {
+      env: undefined,
+    });
 
     expect(config).toEqual({
       account_id: undefined,
       build: {
         command: undefined,
         cwd: undefined,
-        watch_dir: undefined,
+        watch_dir: "./src",
       },
       compatibility_date: undefined,
       compatibility_flags: [],
       configPath: undefined,
       dev: {
-        ip: "127.0.0.1",
+        ip: "localhost",
         local_protocol: "http",
-        port: 8787,
+        port: undefined, // the default of 8787 is set at runtime
         upstream_protocol: "https",
+        host: undefined,
       },
       durable_objects: {
         bindings: [],
       },
-      env: {},
       jsx_factory: "React.createElement",
       jsx_fragment: "React.Fragment",
+      tsconfig: undefined,
       kv_namespaces: [],
       legacy_env: true,
       main: undefined,
       migrations: [],
       name: undefined,
       r2_buckets: [],
+      services: [],
       route: undefined,
       routes: undefined,
       rules: [],
@@ -48,8 +58,11 @@ describe("normalizeAndValidateConfig()", () => {
       usage_model: undefined,
       vars: {},
       wasm_modules: undefined,
-      workers_dev: true,
+      data_blobs: undefined,
+      workers_dev: undefined,
       zone_id: undefined,
+      minify: undefined,
+      node_compat: undefined,
     });
     expect(diagnostics.hasErrors()).toBe(false);
     expect(diagnostics.hasWarnings()).toBe(false);
@@ -57,56 +70,42 @@ describe("normalizeAndValidateConfig()", () => {
 
   describe("top-level non-environment configuration", () => {
     it("should override config defaults with provided values", () => {
-      const main = "src/index.ts";
-      const expectedConfig: RawConfig = {
-        main,
+      const expectedConfig: Partial<ConfigFields<RawDevConfig>> = {
         legacy_env: true,
         dev: {
           ip: "255.255.255.255",
           port: 9999,
-          local_protocol: "HTTPS",
-          upstream_protocol: "HTTP",
-        },
-        build: {
-          command: "COMMAND",
-          cwd: "CWD",
-          watch_dir: "WATCH_DIR",
+          local_protocol: "https",
+          upstream_protocol: "http",
         },
       };
 
       const { config, diagnostics } = normalizeAndValidateConfig(
         expectedConfig,
-        undefined
+        undefined,
+        { env: undefined }
       );
 
-      const resolvedMain = path.resolve(process.cwd(), main);
-      expect(config).toEqual(
-        expect.objectContaining({ ...expectedConfig, main: resolvedMain })
-      );
+      expect(config).toEqual(expect.objectContaining(expectedConfig));
       expect(diagnostics.hasErrors()).toBe(false);
       expect(diagnostics.hasWarnings()).toBe(false);
     });
 
     it("should error on invalid top level fields", () => {
       const expectedConfig = {
-        main: 111,
         legacy_env: "FOO",
         dev: {
           ip: 222,
           port: "FOO",
-          local_protocol: 333,
-          upstream_protocol: 444,
-        },
-        build: {
-          command: 555,
-          cwd: 666,
-          watch_dir: 777,
+          local_protocol: "wss",
+          upstream_protocol: "ws",
         },
       };
 
       const { config, diagnostics } = normalizeAndValidateConfig(
         expectedConfig as unknown as RawConfig,
-        undefined
+        undefined,
+        { env: undefined }
       );
 
       expect(config).toEqual(
@@ -114,233 +113,411 @@ describe("normalizeAndValidateConfig()", () => {
       );
       expect(diagnostics.hasWarnings()).toBe(false);
       expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
-          "Processing wrangler configuration:
-            - ERROR: \\"build.command\\" should be of type string but got 555.
-            - ERROR: \\"build.cwd\\" should be of type string but got 666.
-            - ERROR: \\"build.watch_dir\\" should be of type string but got 777.
-            - ERROR: \\"legacy_env\\" should be of type boolean but got \\"FOO\\".
-            - ERROR: \\"main\\" should be a string but got 111
-            - ERROR: \\"dev.ip\\" should be of type string but got 222.
-            - ERROR: \\"dev.port\\" should be of type number but got \\"FOO\\".
-            - ERROR: \\"dev.local_protocol\\" should be of type string but got 333.
-            - ERROR: \\"dev.upstream_protocol\\" should be of type string but got 444."
-        `);
+        "Processing wrangler configuration:
+          - Expected \\"legacy_env\\" to be of type boolean but got \\"FOO\\".
+          - Expected \\"dev.ip\\" to be of type string but got 222.
+          - Expected \\"dev.port\\" to be of type number but got \\"FOO\\".
+          - Expected \\"dev.local_protocol\\" field to be one of [\\"http\\",\\"https\\"] but got \\"wss\\".
+          - Expected \\"dev.upstream_protocol\\" field to be one of [\\"http\\",\\"https\\"] but got \\"ws\\"."
+      `);
     });
 
     it("should warn on and remove unexpected top level fields", () => {
       const expectedConfig = {
-        miniflare: {
-          host: "127.0.0.1",
+        unexpected: {
+          subkey: "some-value",
         },
       };
 
       const { config, diagnostics } = normalizeAndValidateConfig(
         expectedConfig as unknown as RawConfig,
-        undefined
+        undefined,
+        { env: undefined }
       );
 
-      expect("miniflare" in config).toBe(false);
+      expect("unexpected" in config).toBe(false);
       expect(diagnostics.hasErrors()).toBe(false);
       expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
         "Processing wrangler configuration:
-          - Unexpected fields found in top-level field: \\"miniflare\\""
+          - Unexpected fields found in top-level field: \\"unexpected\\""
       `);
     });
 
-    it("should override build.upload config defaults with provided values and warn about deprecations", () => {
-      const expectedConfig: RawConfig = {
-        build: {
-          upload: {
-            dir: "src",
-            format: "modules",
-            main: "index.ts",
-            rules: [{ type: "Text", globs: ["GLOB"], fallthrough: true }],
-          },
+    it("should report a deprecation warning if `miniflare` appears at the top level", () => {
+      const expectedConfig = {
+        miniflare: {
+          host: "localhost",
         },
       };
 
       const { config, diagnostics } = normalizeAndValidateConfig(
-        expectedConfig,
-        path.resolve("project/wrangler.toml")
+        expectedConfig as unknown as RawConfig,
+        undefined,
+        { env: undefined }
       );
 
-      expect(config.main).toEqual(path.resolve("project/src/index.ts"));
-      expect(config.build.upload).toBeUndefined();
+      expect("miniflare" in config).toBe(false);
       expect(diagnostics.hasErrors()).toBe(false);
-      expect(diagnostics.hasWarnings()).toBe(true);
-      expect(normalizePath(diagnostics.renderWarnings()))
-        .toMatchInlineSnapshot(`
-        "Processing project/wrangler.toml configuration:
-          - DEPRECATION: \\"build.upload.format\\":
-            The format is inferred automatically from the code.
-          - DEPRECATION: \\"build.upload.main\\":
-            Delete the \`build.upload.main\` and \`build.upload.dir\` fields.
-            Then add the top level \`main\` field to your configuration file:
-            \`\`\`
-            main = \\"src/index.ts\\"
-            \`\`\`
-          - DEPRECATION: \\"build.upload.dir\\":
-            Use the top level \\"main\\" field or a command-line argument to specify the entry-point for the Worker.
-          - DEPRECATION: The \`build.upload.rules\` config field is no longer used, the rules should be specified via the \`rules\` config field. Delete the \`build.upload\` field from the configuration file, and add this:
-            \`\`\`
-            [[rules]]
-            type = \\"Text\\"
-            globs = [ \\"GLOB\\" ]
-            fallthrough = true
-            \`\`\`"
+      expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
+        "Processing wrangler configuration:
+          - 😶 Ignored: \\"miniflare\\":
+            Wrangler does not use configuration in the \`miniflare\` section. Unless you are using Miniflare directly you can remove this section."
       `);
     });
 
-    it("should override `migrations` config defaults with provided values", () => {
-      const expectedConfig: RawConfig = {
-        migrations: [
-          {
-            tag: "TAG",
-            new_classes: ["CLASS_1", "CLASS_2"],
-            renamed_classes: [
-              {
-                from: "FROM_CLASS",
-                to: "TO_CLASS",
-              },
-            ],
-            deleted_classes: ["CLASS_3", "CLASS_4"],
-          },
-        ],
-      };
+    describe("migrations", () => {
+      it("should override `migrations` config defaults with provided values", () => {
+        const expectedConfig: RawConfig = {
+          migrations: [
+            {
+              tag: "TAG",
+              new_classes: ["CLASS_1", "CLASS_2"],
+              renamed_classes: [
+                {
+                  from: "FROM_CLASS",
+                  to: "TO_CLASS",
+                },
+              ],
+              deleted_classes: ["CLASS_3", "CLASS_4"],
+            },
+          ],
+        };
 
-      const { config, diagnostics } = normalizeAndValidateConfig(
-        expectedConfig,
-        undefined
-      );
+        const { config, diagnostics } = normalizeAndValidateConfig(
+          expectedConfig,
+          undefined,
+          { env: undefined }
+        );
 
-      expect(config).toEqual(expect.objectContaining(expectedConfig));
-      expect(diagnostics.hasErrors()).toBe(false);
-      expect(diagnostics.hasWarnings()).toBe(false);
+        expect(config).toEqual(expect.objectContaining(expectedConfig));
+        expect(diagnostics.hasErrors()).toBe(false);
+        expect(diagnostics.hasWarnings()).toBe(false);
+      });
+
+      it("should error on invalid `migrations` values", () => {
+        const expectedConfig = {
+          migrations: [
+            {
+              tag: 111,
+              new_classes: [222, 333],
+              renamed_classes: [
+                {
+                  from: 444,
+                  to: 555,
+                },
+              ],
+              deleted_classes: [666, 777],
+            },
+          ],
+        };
+
+        const { config, diagnostics } = normalizeAndValidateConfig(
+          expectedConfig as unknown as RawConfig,
+          undefined,
+          { env: undefined }
+        );
+
+        expect(config).toEqual(expect.objectContaining(expectedConfig));
+        expect(diagnostics.hasWarnings()).toBe(false);
+        expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+          "Processing wrangler configuration:
+            - Expected \\"migrations[0].tag\\" to be of type string but got 111.
+            - Expected \\"migrations[0].new_classes.[0]\\" to be of type string but got 222.
+            - Expected \\"migrations[0].new_classes.[1]\\" to be of type string but got 333.
+            - Expected \\"migrations[0].renamed_classes\\" to be an array of \\"{from: string, to: string}\\" objects but got [{\\"from\\":444,\\"to\\":555}].
+            - Expected \\"migrations[0].deleted_classes.[0]\\" to be of type string but got 666.
+            - Expected \\"migrations[0].deleted_classes.[1]\\" to be of type string but got 777."
+        `);
+      });
+
+      it("should warn/error on unexpected fields on `migrations`", async () => {
+        const expectedConfig = {
+          migrations: [
+            {
+              tag: "TAG",
+              new_classes: ["CLASS_1", "CLASS_2"],
+              renamed_classes: [
+                {
+                  from: "FROM_CLASS",
+                  to: "TO_CLASS",
+                },
+                {
+                  a: "something",
+                  b: "someone",
+                },
+              ],
+              deleted_classes: ["CLASS_3", "CLASS_4"],
+              unrecognized_field: "FOO",
+            },
+          ],
+        };
+
+        const { config, diagnostics } = normalizeAndValidateConfig(
+          expectedConfig as unknown as RawConfig,
+          undefined,
+          { env: undefined }
+        );
+
+        expect(config).toEqual(expect.objectContaining(expectedConfig));
+        expect(diagnostics.hasErrors()).toBe(true);
+        expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
+          "Processing wrangler configuration:
+            - Unexpected fields found in migrations field: \\"unrecognized_field\\""
+        `);
+        expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+          "Processing wrangler configuration:
+            - Expected \\"migrations[0].renamed_classes\\" to be an array of \\"{from: string, to: string}\\" objects but got [{\\"from\\":\\"FROM_CLASS\\",\\"to\\":\\"TO_CLASS\\"},{\\"a\\":\\"something\\",\\"b\\":\\"someone\\"}]."
+        `);
+      });
     });
 
-    it("should error on invalid `migrations` values", () => {
-      const expectedConfig = {
-        migrations: [
-          {
-            tag: 111,
-            new_classes: [222, 333],
-            renamed_classes: [
-              {
-                from: 444,
-                to: 555,
-              },
-            ],
-            deleted_classes: [666, 777],
+    describe("site", () => {
+      it("should override `site` config defaults with provided values", () => {
+        const expectedConfig: RawConfig = {
+          site: {
+            bucket: "BUCKET",
+            "entry-point": "my-site",
+            exclude: ["EXCLUDE_1", "EXCLUDE_2"],
+            include: ["INCLUDE_1", "INCLUDE_2"],
           },
-        ],
-      };
+        };
 
-      const { config, diagnostics } = normalizeAndValidateConfig(
-        expectedConfig as unknown as RawConfig,
-        undefined
-      );
+        const { config, diagnostics } = normalizeAndValidateConfig(
+          expectedConfig,
+          undefined,
+          { env: undefined }
+        );
 
-      expect(config).toEqual(expect.objectContaining(expectedConfig));
-      expect(diagnostics.hasWarnings()).toBe(false);
-      expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+        expect(config).toEqual(expect.objectContaining(expectedConfig));
+        expect(diagnostics.hasErrors()).toBe(false);
+        expect(diagnostics.hasWarnings()).toBe(true);
+
+        expect(normalizeSlashes(diagnostics.renderWarnings()))
+          .toMatchInlineSnapshot(`
           "Processing wrangler configuration:
-            - ERROR: \\"migrations[0].tag\\" should be of type string but got 111.
-            - ERROR: \\"migrations[0].new_classes.[0]\\" should be of type string but got 222.
-            - ERROR: \\"migrations[0].new_classes.[1]\\" should be of type string but got 333.
-            - \\"migrations[0].renamed_classes\\" should be an array of \\"{from: string, to: string}\\" objects but got [{\\"from\\":444,\\"to\\":555}].
-            - ERROR: \\"migrations[0].deleted_classes.[0]\\" should be of type string but got 666.
-            - ERROR: \\"migrations[0].deleted_classes.[1]\\" should be of type string but got 777."
+            - Deprecation: \\"site.entry-point\\":
+              Delete the \`site.entry-point\` field, then add the top level \`main\` field to your configuration file:
+              \`\`\`
+              main = \\"my-site/index.js\\"
+              \`\`\`"
         `);
+      });
+
+      it("should error if `site` config is missing `bucket`", () => {
+        const expectedConfig: RawConfig = {
+          // @ts-expect-error we're intentionally passing an invalid configuration here
+          site: {
+            "entry-point": "workers-site",
+            include: ["INCLUDE_1", "INCLUDE_2"],
+            exclude: ["EXCLUDE_1", "EXCLUDE_2"],
+          },
+        };
+
+        const { config, diagnostics } = normalizeAndValidateConfig(
+          expectedConfig,
+          undefined,
+          { env: undefined }
+        );
+
+        expect(config).toEqual(expect.objectContaining(expectedConfig));
+        expect(diagnostics.hasWarnings()).toBe(true);
+        expect(diagnostics.hasErrors()).toBe(true);
+
+        expect(normalizeSlashes(diagnostics.renderWarnings()))
+          .toMatchInlineSnapshot(`
+          "Processing wrangler configuration:
+            - Deprecation: \\"site.entry-point\\":
+              Delete the \`site.entry-point\` field, then add the top level \`main\` field to your configuration file:
+              \`\`\`
+              main = \\"workers-site/index.js\\"
+              \`\`\`"
+        `);
+
+        expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+          "Processing wrangler configuration:
+            - \\"site.bucket\\" is a required field."
+        `);
+      });
+
+      it("should error on invalid `site` values", () => {
+        const expectedConfig = {
+          site: {
+            bucket: "BUCKET",
+            "entry-point": 111,
+            include: [222, 333],
+            exclude: [444, 555],
+          },
+        };
+
+        const { config, diagnostics } = normalizeAndValidateConfig(
+          expectedConfig as unknown as RawConfig,
+          undefined,
+          { env: undefined }
+        );
+
+        expect(config).toEqual(expect.objectContaining(expectedConfig));
+        expect(diagnostics.hasWarnings()).toBe(true);
+        expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+          "Processing wrangler configuration:
+            - Expected \\"sites.include.[0]\\" to be of type string but got 222.
+            - Expected \\"sites.include.[1]\\" to be of type string but got 333.
+            - Expected \\"sites.exclude.[0]\\" to be of type string but got 444.
+            - Expected \\"sites.exclude.[1]\\" to be of type string but got 555.
+            - Expected \\"site.entry-point\\" to be of type string but got 111."
+        `);
+
+        expect(normalizeSlashes(diagnostics.renderWarnings()))
+          .toMatchInlineSnapshot(`
+          "Processing wrangler configuration:
+            - Deprecation: \\"site.entry-point\\":
+              Delete the \`site.entry-point\` field, then add the top level \`main\` field to your configuration file:
+              \`\`\`
+              main = \\"111/index.js\\"
+              \`\`\`"
+        `);
+      });
+
+      it("should log a deprecation warning if entry-point is defined", async () => {
+        const { config, diagnostics } = normalizeAndValidateConfig(
+          {
+            site: {
+              bucket: "some/path",
+              "entry-point": "some/other/script.js",
+            },
+          } as unknown as RawConfig,
+          undefined,
+          { env: undefined }
+        );
+
+        expect(config.site).toMatchInlineSnapshot(`
+          Object {
+            "bucket": "some/path",
+            "entry-point": "some/other/script.js",
+            "exclude": Array [],
+            "include": Array [],
+          }
+        `);
+        expect(diagnostics.hasWarnings()).toBe(true);
+        expect(diagnostics.hasErrors()).toBe(false);
+
+        expect(normalizeSlashes(diagnostics.renderWarnings()))
+          .toMatchInlineSnapshot(`
+          "Processing wrangler configuration:
+            - Deprecation: \\"site.entry-point\\":
+              Delete the \`site.entry-point\` field, then add the top level \`main\` field to your configuration file:
+              \`\`\`
+              main = \\"some/other/script.js\\"
+              \`\`\`"
+        `);
+      });
     });
 
-    it("should override `site` config defaults with provided values", () => {
+    it("should map `wasm_module` paths from relative to the config path to relative to the cwd", () => {
       const expectedConfig: RawConfig = {
-        site: {
-          bucket: "BUCKET",
-          "entry-point": "ENTRY_POINT",
-          include: ["INCLUDE_1", "INCLUDE_2"],
-          exclude: ["EXCLUDE_1", "EXCLUDE_2"],
+        wasm_modules: {
+          MODULE_1: "path/to/module_1.mjs",
+          MODULE_2: "module_2.mjs",
         },
       };
 
       const { config, diagnostics } = normalizeAndValidateConfig(
         expectedConfig,
-        undefined
+        "project/wrangler.toml",
+        { env: undefined }
       );
 
-      expect(config).toEqual(expect.objectContaining(expectedConfig));
+      expect(config).toEqual(
+        expect.objectContaining({
+          wasm_modules: {
+            MODULE_1: path.normalize("project/path/to/module_1.mjs"),
+            MODULE_2: path.normalize("project/module_2.mjs"),
+          },
+        })
+      );
       expect(diagnostics.hasErrors()).toBe(false);
       expect(diagnostics.hasWarnings()).toBe(false);
     });
 
-    it("should error if `site` config is missing `bucket`", () => {
+    it("should warn on unexpected fields on `triggers`", async () => {
       const expectedConfig: RawConfig = {
-        site: {
-          "entry-point": "ENTRY_POINT",
-          include: ["INCLUDE_1", "INCLUDE_2"],
-          exclude: ["EXCLUDE_1", "EXCLUDE_2"],
+        triggers: {
+          crons: ["1 * * * *"],
+          // @ts-expect-error we're purposely adding a field
+          // that doesn't belong here
+          someOtherfield: 123,
         },
-      } as RawConfig;
+      };
 
       const { config, diagnostics } = normalizeAndValidateConfig(
         expectedConfig,
-        undefined
+        "project/wrangler.toml",
+        { env: undefined }
       );
 
-      expect(config).toEqual(expect.objectContaining(expectedConfig));
-      expect(diagnostics.hasErrors()).toBe(true);
-      expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
-                "Processing wrangler configuration:
-                  - ERROR: \\"site.bucket\\" is a required field."
-            `);
-      expect(diagnostics.hasWarnings()).toBe(false);
+      expect(config).toEqual(
+        expect.objectContaining({
+          triggers: {
+            crons: ["1 * * * *"],
+            someOtherfield: 123,
+          },
+        })
+      );
+      expect(diagnostics.hasErrors()).toBe(false);
+      expect(diagnostics.hasWarnings()).toBe(true);
+
+      expect(normalizePath(diagnostics.renderWarnings()))
+        .toMatchInlineSnapshot(`
+        "Processing project/wrangler.toml configuration:
+          - Unexpected fields found in triggers field: \\"someOtherfield\\""
+      `);
     });
 
-    it("should error on invalid `site` values", () => {
+    it("should error on invalid `wasm_modules` paths", () => {
       const expectedConfig = {
-        site: {
-          bucket: "BUCKET",
-          "entry-point": 111,
-          include: [222, 333],
-          exclude: [444, 555],
+        wasm_modules: {
+          MODULE_1: 111,
+          MODULE_2: 222,
         },
       };
 
       const { config, diagnostics } = normalizeAndValidateConfig(
         expectedConfig as unknown as RawConfig,
-        undefined
+        "project/wrangler.toml",
+        { env: undefined }
       );
 
-      expect(config).toEqual(expect.objectContaining(expectedConfig));
+      expect(config).toEqual(
+        expect.objectContaining({
+          wasm_modules: {},
+        })
+      );
       expect(diagnostics.hasWarnings()).toBe(false);
-      expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
-          "Processing wrangler configuration:
-            - ERROR: \\"site.entry_point\\" should be of type string but got 111.
-            - ERROR: \\"sites.include.[0]\\" should be of type string but got 222.
-            - ERROR: \\"sites.include.[1]\\" should be of type string but got 333.
-            - ERROR: \\"sites.exclude.[0]\\" should be of type string but got 444.
-            - ERROR: \\"sites.exclude.[1]\\" should be of type string but got 555."
-        `);
+      expect(normalizePath(diagnostics.renderErrors())).toMatchInlineSnapshot(`
+        "Processing project/wrangler.toml configuration:
+          - Expected \\"wasm_modules['MODULE_1']\\" to be of type string but got 111.
+          - Expected \\"wasm_modules['MODULE_2']\\" to be of type string but got 222."
+      `);
     });
 
-    it("should map `wasm_module` paths from relative to the config path to relative to the cwd", () => {
+    it("should map `text_blobs` paths from relative to the config path to relative to the cwd", () => {
       const expectedConfig: RawConfig = {
-        wasm_modules: {
-          MODULE_1: "path/to/module_1.mjs",
-          MODULE_2: "module_2.mjs",
+        text_blobs: {
+          BLOB_1: "path/to/text1.txt",
+          BLOB_2: "text2.md",
         },
       };
 
       const { config, diagnostics } = normalizeAndValidateConfig(
         expectedConfig,
-        "project/wrangler.toml"
+        "project/wrangler.toml",
+        { env: undefined }
       );
 
       expect(config).toEqual(
         expect.objectContaining({
-          wasm_modules: {
-            MODULE_1: path.normalize("project/path/to/module_1.mjs"),
-            MODULE_2: path.normalize("project/module_2.mjs"),
+          text_blobs: {
+            BLOB_1: path.normalize("project/path/to/text1.txt"),
+            BLOB_2: path.normalize("project/text2.md"),
           },
         })
       );
@@ -348,9 +525,9 @@ describe("normalizeAndValidateConfig()", () => {
       expect(diagnostics.hasWarnings()).toBe(false);
     });
 
-    it("should error on invalid `wasm_module` paths", () => {
+    it("should error on invalid `text_blob` paths", () => {
       const expectedConfig = {
-        wasm_modules: {
+        text_blobs: {
           MODULE_1: 111,
           MODULE_2: 222,
         },
@@ -358,40 +535,42 @@ describe("normalizeAndValidateConfig()", () => {
 
       const { config, diagnostics } = normalizeAndValidateConfig(
         expectedConfig as unknown as RawConfig,
-        "project/wrangler.toml"
+        "project/wrangler.toml",
+        { env: undefined }
       );
 
       expect(config).toEqual(
         expect.objectContaining({
-          wasm_modules: {},
+          text_blobs: {},
         })
       );
       expect(diagnostics.hasWarnings()).toBe(false);
       expect(normalizePath(diagnostics.renderErrors())).toMatchInlineSnapshot(`
-          "Processing project/wrangler.toml configuration:
-            - Expected \\"wasm_modules['MODULE_1']\\" field to be a string but got 111.
-            - Expected \\"wasm_modules['MODULE_2']\\" field to be a string but got 222."
-        `);
+        "Processing project/wrangler.toml configuration:
+          - Expected \\"text_blobs['MODULE_1']\\" to be of type string but got 111.
+          - Expected \\"text_blobs['MODULE_2']\\" to be of type string but got 222."
+      `);
     });
 
-    it("should map `text_blobs` paths from relative to the config path to relative to the cwd", () => {
+    it("should map `data_blobs` paths from relative to the config path to relative to the cwd", () => {
       const expectedConfig: RawConfig = {
-        text_blobs: {
-          BLOB_1: "path/to/text1.txt",
-          BLOB_2: "text2.md",
+        data_blobs: {
+          BLOB_1: "path/to/data1.bin",
+          BLOB_2: "data2.bin",
         },
       };
 
       const { config, diagnostics } = normalizeAndValidateConfig(
         expectedConfig,
-        "project/wrangler.toml"
+        "project/wrangler.toml",
+        { env: undefined }
       );
 
       expect(config).toEqual(
         expect.objectContaining({
-          text_blobs: {
-            BLOB_1: path.normalize("project/path/to/text1.txt"),
-            BLOB_2: path.normalize("project/text2.md"),
+          data_blobs: {
+            BLOB_1: path.normalize("project/path/to/data1.bin"),
+            BLOB_2: path.normalize("project/data2.bin"),
           },
         })
       );
@@ -399,9 +578,9 @@ describe("normalizeAndValidateConfig()", () => {
       expect(diagnostics.hasWarnings()).toBe(false);
     });
 
-    it("should error on invalid `text_blob` paths", () => {
+    it("should error on invalid `data_blob` paths", () => {
       const expectedConfig = {
-        text_blobs: {
+        data_blobs: {
           MODULE_1: 111,
           MODULE_2: 222,
         },
@@ -409,20 +588,42 @@ describe("normalizeAndValidateConfig()", () => {
 
       const { config, diagnostics } = normalizeAndValidateConfig(
         expectedConfig as unknown as RawConfig,
-        "project/wrangler.toml"
+        "project/wrangler.toml",
+        { env: undefined }
       );
 
       expect(config).toEqual(
         expect.objectContaining({
-          text_blobs: {},
+          data_blobs: {},
         })
       );
       expect(diagnostics.hasWarnings()).toBe(false);
       expect(normalizePath(diagnostics.renderErrors())).toMatchInlineSnapshot(`
-          "Processing project/wrangler.toml configuration:
-            - Expected \\"text_blobs['MODULE_1']\\" field to be a string but got 111.
-            - Expected \\"text_blobs['MODULE_2']\\" field to be a string but got 222."
-        `);
+        "Processing project/wrangler.toml configuration:
+          - Expected \\"data_blobs['MODULE_1']\\" to be of type string but got 111.
+          - Expected \\"data_blobs['MODULE_2']\\" to be of type string but got 222."
+      `);
+    });
+
+    it("should resolve tsconfig relative to wrangler.toml", async () => {
+      const expectedConfig: RawEnvironment = {
+        tsconfig: "path/to/some-tsconfig.json",
+      };
+
+      const { config, diagnostics } = normalizeAndValidateConfig(
+        expectedConfig,
+        "project/wrangler.toml",
+        { env: undefined }
+      );
+
+      expect(config).toEqual(
+        expect.objectContaining({
+          tsconfig: path.normalize("project/path/to/some-tsconfig.json"),
+        })
+      );
+
+      expect(diagnostics.hasErrors()).toBe(false);
+      expect(diagnostics.hasWarnings()).toBe(false);
     });
 
     describe("(deprecated)", () => {
@@ -434,7 +635,8 @@ describe("normalizeAndValidateConfig()", () => {
 
         const { config, diagnostics } = normalizeAndValidateConfig(
           rawConfig,
-          undefined
+          undefined,
+          { env: undefined }
         );
 
         // Note the `.not.` here...
@@ -447,30 +649,44 @@ describe("normalizeAndValidateConfig()", () => {
         expect(diagnostics.hasErrors()).toBe(false);
         expect(diagnostics.hasWarnings()).toBe(true);
         expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
-            "Processing wrangler configuration:
-              - DEPRECATION: \\"type\\":
-                DO NOT USE THIS. Most common features now work out of the box with wrangler, including modules, jsx, typescript, etc. If you need anything more, use a custom build.
-              - DEPRECATION: \\"webpack_config\\":
-                DO NOT USE THIS. Most common features now work out of the box with wrangler, including modules, jsx, typescript, etc. If you need anything more, use a custom build."
-          `);
+          "Processing wrangler configuration:
+            - 😶 Ignored: \\"type\\":
+              Most common features now work out of the box with wrangler, including modules, jsx, typescript, etc. If you need anything more, use a custom build.
+            - 😶 Ignored: \\"webpack_config\\":
+              Most common features now work out of the box with wrangler, including modules, jsx, typescript, etc. If you need anything more, use a custom build."
+        `);
       });
     });
   });
 
-  describe("top-level environment configuration", () => {
-    it("should override config defaults with provided values", () => {
-      const expectedConfig: RawConfig = {
-        name: "NAME",
+  describe("top-level environment configuration", () => {
+    it("should override config defaults with provided values", () => {
+      const main = "src/index.ts";
+      const resolvedMain = path.resolve(process.cwd(), main);
+
+      const expectedConfig: RawEnvironment = {
+        name: "mock-name",
         account_id: "ACCOUNT_ID",
         compatibility_date: "2022-01-01",
         compatibility_flags: ["FLAG1", "FLAG2"],
         workers_dev: false,
-        routes: ["ROUTE_1", "ROUTE_2"],
-        route: "ROUTE_3",
+        routes: [
+          "ROUTE_1",
+          "ROUTE_2",
+          { pattern: "ROUTE3", zone_id: "ZONE_ID_3" },
+          "ROUTE_4",
+        ],
         jsx_factory: "JSX_FACTORY",
         jsx_fragment: "JSX_FRAGMENT",
+        tsconfig: "path/to/tsconfig",
         triggers: { crons: ["CRON_1", "CRON_2"] },
         usage_model: "bundled",
+        main,
+        build: {
+          command: "COMMAND",
+          cwd: "CWD",
+          watch_dir: "WATCH_DIR",
+        },
         vars: {
           VAR1: "VALUE_1",
           VAR2: "VALUE_2",
@@ -483,6 +699,12 @@ describe("normalizeAndValidateConfig()", () => {
               class_name: "CLASS2",
               script_name: "SCRIPT2",
             },
+            {
+              name: "DO_BINDING_3",
+              class_name: "CLASS3",
+              script_name: "SCRIPT3",
+              environment: "ENV3",
+            },
           ],
         },
         kv_namespaces: [
@@ -501,6 +723,13 @@ describe("normalizeAndValidateConfig()", () => {
             preview_bucket_name: "R2_PREVIEW_2",
           },
         ],
+        services: [
+          {
+            binding: "SERVICE_BINDING_1",
+            service: "SERVICE_TYPE_1",
+            environment: "SERVICE_BINDING_ENVIRONMENT_1",
+          },
+        ],
         unsafe: {
           bindings: [
             { name: "UNSAFE_BINDING_1", type: "UNSAFE_TYPE_1" },
@@ -511,63 +740,397 @@ describe("normalizeAndValidateConfig()", () => {
             },
           ],
         },
+        minify: true,
+        node_compat: true,
       };
 
       const { config, diagnostics } = normalizeAndValidateConfig(
         expectedConfig,
-        undefined
+        undefined,
+        { env: undefined }
       );
 
-      expect(config).toEqual(expect.objectContaining(expectedConfig));
+      expect(config).toEqual(
+        expect.objectContaining({ ...expectedConfig, main: resolvedMain })
+      );
       expect(diagnostics.hasErrors()).toBe(false);
       expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
-          "Processing wrangler configuration:
-            - \\"unsafe\\" fields are experimental and may change or break at any time."
-        `);
+        "Processing wrangler configuration:
+          - \\"unsafe\\" fields are experimental and may change or break at any time.
+          - \\"services\\" fields are experimental and may change or break at any time.
+          - In wrangler.toml, you have configured [durable_objects] exported by this Worker (CLASS1), but no [migrations] for them. This may not work as expected until you add a [migrations] section to your wrangler.toml. Add this configuration to your wrangler.toml:
+
+              \`\`\`
+              [[migrations]]
+              tag = \\"v1\\" # Should be unique for each entry
+              new_classes = [\\"CLASS1\\"]
+              \`\`\`
+
+            Refer to https://developers.cloudflare.com/workers/learning/using-durable-objects/#durable-object-migrations-in-wranglertoml for more details."
+      `);
     });
 
     it("should error on invalid environment values", () => {
-      const expectedConfig: RawConfig = {
+      const expectedConfig: RawEnvironment = {
         name: 111,
         account_id: 222,
         compatibility_date: 333,
         compatibility_flags: [444, 555],
         workers_dev: "BAD",
-        routes: [666, 777],
+        routes: [
+          666,
+          777,
+          // this one's valid, but we add it here to make sure
+          // it doesn't get included in the error message
+          "example.com/*",
+          { pattern: 123, zone_id: "zone_id_1" },
+          { pattern: "route_2", zone_id: 123 },
+          { pattern: "route_2", zone_name: 123 },
+          { pattern: "route_3" },
+          { zone_id: "zone_id_4" },
+          { zone_name: "zone_name_4" },
+          { pattern: undefined },
+          { pattern: "route_5", zone_id: "zone_id_5", some_other_key: 123 },
+          { pattern: "route_5", zone_name: "zone_name_5", some_other_key: 123 },
+          // this one's valid too
+          { pattern: "route_6", zone_id: "zone_id_6" },
+          // as well as this one
+          { pattern: "route_6", zone_name: "zone_name_6" },
+        ],
         route: 888,
         jsx_factory: 999,
         jsx_fragment: 1000,
+        tsconfig: true,
         triggers: { crons: [1111, 1222] },
         usage_model: "INVALID",
-      } as unknown as RawConfig;
+        main: 1333,
+        build: {
+          command: 1444,
+          cwd: 1555,
+          watch_dir: 1666,
+        },
+        minify: "INVALID",
+        node_compat: "INVALID",
+      } as unknown as RawEnvironment;
 
       const { config, diagnostics } = normalizeAndValidateConfig(
         expectedConfig,
-        undefined
+        undefined,
+        { env: undefined }
       );
 
       expect(config).toEqual(expect.objectContaining(expectedConfig));
       expect(diagnostics.hasWarnings()).toBe(false);
       expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
         "Processing wrangler configuration:
-          - Expected \\"route\\" field to be a string but got 888.
-          - Expected \\"routes\\" field to be an array of strings but got [666,777].
-          - Expected \\"workers_dev\\" field to be a boolean but got \\"BAD\\".
-          - Expected \\"account_id\\" field to be a string but got 222.
-          - Expected \\"compatibility_date\\" field to be a string but got 333.
-          - Expected \\"compatibility_flags\\" field to be an array of strings but got [444,555].
-          - Expected \\"jsx_factory\\" field to be a string but got 999.
-          - Expected \\"jsx_fragment\\" field to be a string but got 1000.
-          - Expected \\"name\\" field to be a string but got 111.
-          - Expected \\"usage_model\\" field to be on of bundled,unbound but got \\"INVALID\\"."
+          - Expected \\"route\\" to be either a string, or an object with shape { pattern, custom_domain, zone_id | zone_name }, but got 888.
+          - Expected \\"routes\\" to be an array of either strings or objects with the shape { pattern, custom_domain, zone_id | zone_name }, but these weren't valid: [
+              666,
+              777,
+              {
+                \\"pattern\\": 123,
+                \\"zone_id\\": \\"zone_id_1\\"
+              },
+              {
+                \\"pattern\\": \\"route_2\\",
+                \\"zone_id\\": 123
+              },
+              {
+                \\"pattern\\": \\"route_2\\",
+                \\"zone_name\\": 123
+              },
+              {
+                \\"pattern\\": \\"route_3\\"
+              },
+              {
+                \\"zone_id\\": \\"zone_id_4\\"
+              },
+              {
+                \\"zone_name\\": \\"zone_name_4\\"
+              },
+              {},
+              {
+                \\"pattern\\": \\"route_5\\",
+                \\"zone_id\\": \\"zone_id_5\\",
+                \\"some_other_key\\": 123
+              },
+              {
+                \\"pattern\\": \\"route_5\\",
+                \\"zone_name\\": \\"zone_name_5\\",
+                \\"some_other_key\\": 123
+              }
+            ].
+          - Expected exactly one of the following fields [\\"routes\\",\\"route\\"].
+          - Expected \\"workers_dev\\" to be of type boolean but got \\"BAD\\".
+          - Expected \\"build.command\\" to be of type string but got 1444.
+          - Expected \\"build.cwd\\" to be of type string but got 1555.
+          - Expected \\"build.watch_dir\\" to be of type string but got 1666.
+          - Expected \\"account_id\\" to be of type string but got 222.
+          - Expected \\"compatibility_date\\" to be of type string but got 333.
+          - Expected \\"compatibility_flags\\" to be of type string array but got [444,555].
+          - Expected \\"jsx_factory\\" to be of type string but got 999.
+          - Expected \\"jsx_fragment\\" to be of type string but got 1000.
+          - Expected \\"tsconfig\\" to be of type string but got true.
+          - Expected \\"name\\" to be of type string, alphanumeric and lowercase with dashes only but got 111.
+          - Expected \\"main\\" to be of type string but got 1333.
+          - Expected \\"usage_model\\" field to be one of [\\"bundled\\",\\"unbound\\"] but got \\"INVALID\\".
+          - Expected \\"minify\\" to be of type boolean but got \\"INVALID\\".
+          - Expected \\"node_compat\\" to be of type boolean but got \\"INVALID\\"."
       `);
     });
 
+    describe("name", () => {
+      it("should error on invalid `name` value with spaces", () => {
+        const expectedConfig: RawEnvironment = {
+          name: "NCC 1701 D",
+        } as unknown as RawEnvironment;
+
+        const { config, diagnostics } = normalizeAndValidateConfig(
+          expectedConfig,
+          undefined,
+          { env: undefined }
+        );
+
+        expect(config).toEqual(expect.objectContaining(expectedConfig));
+        expect(diagnostics.hasWarnings()).toBe(false);
+        expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+          "Processing wrangler configuration:
+            - Expected \\"name\\" to be of type string, alphanumeric and lowercase with dashes only but got \\"NCC 1701 D\\"."
+        `);
+      });
+
+      it("should be valid `name` with underscores", () => {
+        const expectedConfig: RawEnvironment = {
+          name: "enterprise_nx_01",
+        } as unknown as RawEnvironment;
+
+        const { config, diagnostics } = normalizeAndValidateConfig(
+          expectedConfig,
+          undefined,
+          { env: undefined }
+        );
+
+        expect(config).toEqual(expect.objectContaining(expectedConfig));
+        expect(diagnostics.hasWarnings()).toBe(false);
+        expect(diagnostics.hasErrors()).toBe(false);
+      });
+
+      it("should error on invalid `name` value with special characters", () => {
+        const expectedConfig: RawEnvironment = {
+          name: "Thy'lek-Shran",
+        } as unknown as RawEnvironment;
+
+        const { config, diagnostics } = normalizeAndValidateConfig(
+          expectedConfig,
+          undefined,
+          { env: undefined }
+        );
+
+        expect(config).toEqual(expect.objectContaining(expectedConfig));
+        expect(diagnostics.hasWarnings()).toBe(false);
+        expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+          "Processing wrangler configuration:
+            - Expected \\"name\\" to be of type string, alphanumeric and lowercase with dashes only but got \\"Thy'lek-Shran\\"."
+        `);
+      });
+
+      it("should error on invalid `name` value with only special characters", () => {
+        const expectedConfig: RawEnvironment = {
+          name: "!@#$%^&*(()",
+        } as unknown as RawEnvironment;
+
+        const { config, diagnostics } = normalizeAndValidateConfig(
+          expectedConfig,
+          undefined,
+          { env: undefined }
+        );
+
+        expect(config).toEqual(expect.objectContaining(expectedConfig));
+        expect(diagnostics.hasWarnings()).toBe(false);
+        expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+          "Processing wrangler configuration:
+            - Expected \\"name\\" to be of type string, alphanumeric and lowercase with dashes only but got \\"!@#$%^&*(()\\"."
+        `);
+      });
+    });
+
+    describe("build", () => {
+      it("should override build.upload config defaults with provided values and warn about deprecations", () => {
+        const expectedConfig: RawEnvironment = {
+          build: {
+            upload: {
+              dir: "src",
+              format: "modules",
+              main: "index.ts",
+              rules: [{ type: "Text", globs: ["GLOB"], fallthrough: true }],
+            },
+          },
+        };
+
+        const { config, diagnostics } = normalizeAndValidateConfig(
+          expectedConfig,
+          path.resolve("project/wrangler.toml"),
+          { env: undefined }
+        );
+
+        expect(config.main).toEqual(path.resolve("project/src/index.ts"));
+        expect(config.build.upload).toBeUndefined();
+        expect(diagnostics.hasErrors()).toBe(false);
+        expect(diagnostics.hasWarnings()).toBe(true);
+        expect(normalizePath(diagnostics.renderWarnings()))
+          .toMatchInlineSnapshot(`
+          "Processing project/wrangler.toml configuration:
+            - Deprecation: \\"build.upload.format\\":
+              The format is inferred automatically from the code.
+            - Deprecation: \\"build.upload.main\\":
+              Delete the \`build.upload.main\` and \`build.upload.dir\` fields.
+              Then add the top level \`main\` field to your configuration file:
+              \`\`\`
+              main = \\"src/index.ts\\"
+              \`\`\`
+            - Deprecation: \\"build.upload.dir\\":
+              Use the top level \\"main\\" field or a command-line argument to specify the entry-point for the Worker.
+            - Deprecation: The \`build.upload.rules\` config field is no longer used, the rules should be specified via the \`rules\` config field. Delete the \`build.upload\` field from the configuration file, and add this:
+              \`\`\`
+              [[rules]]
+              type = \\"Text\\"
+              globs = [ \\"GLOB\\" ]
+              fallthrough = true
+              \`\`\`"
+        `);
+      });
+
+      it("should default custom build watch directories to src", () => {
+        const expectedConfig: RawEnvironment = {
+          build: {
+            command: "execute some --build",
+          },
+        };
+
+        const { config, diagnostics } = normalizeAndValidateConfig(
+          expectedConfig,
+          undefined,
+          { env: undefined }
+        );
+
+        expect(config.build).toEqual(
+          expect.objectContaining({
+            command: "execute some --build",
+            watch_dir: "./src",
+          })
+        );
+
+        expect(diagnostics.hasErrors()).toBe(false);
+        expect(diagnostics.hasWarnings()).toBe(false);
+      });
+
+      it("should resolve custom build watch directories relative to wrangler.toml", async () => {
+        const expectedConfig: RawEnvironment = {
+          build: {
+            command: "execute some --build",
+            watch_dir: "some/path",
+          },
+        };
+
+        const { config, diagnostics } = normalizeAndValidateConfig(
+          expectedConfig,
+          "project/wrangler.toml",
+          { env: undefined }
+        );
+
+        expect(config.build).toEqual(
+          expect.objectContaining({
+            command: "execute some --build",
+            watch_dir: path.normalize("project/some/path"),
+          })
+        );
+
+        expect(diagnostics.hasErrors()).toBe(false);
+        expect(diagnostics.hasWarnings()).toBe(false);
+      });
+
+      it("should allow watch_dir to be an array of paths", () => {
+        const expectedConfig: RawEnvironment = {
+          build: {
+            command: "execute some --build",
+            watch_dir: ["some/path/a", "some/path/b", "some/path/c"],
+          },
+        };
+
+        const { config, diagnostics } = normalizeAndValidateConfig(
+          expectedConfig,
+          "project/wrangler.toml",
+          { env: undefined }
+        );
+
+        expect(config.build).toEqual(
+          expect.objectContaining({
+            command: "execute some --build",
+            watch_dir: [
+              path.normalize("project/some/path/a"),
+              path.normalize("project/some/path/b"),
+              path.normalize("project/some/path/c"),
+            ],
+          })
+        );
+
+        expect(diagnostics.hasErrors()).toBe(false);
+        expect(diagnostics.hasWarnings()).toBe(false);
+      });
+
+      it("should error when the watch_dir array isn't an array of strings", () => {
+        const expectedConfig: RawEnvironment = {
+          build: {
+            command: "execute some --build",
+            watch_dir: [
+              "some/path/a",
+              "some/path/b",
+              // @ts-expect-error intentionally bad "paths"
+              123,
+              "some/path/c",
+              // @ts-expect-error intentionally bad "paths"
+              false,
+            ],
+          },
+        };
+
+        const { config, diagnostics } = normalizeAndValidateConfig(
+          expectedConfig,
+          "project/wrangler.toml",
+          { env: undefined }
+        );
+
+        expect(config.build).toEqual(
+          expect.objectContaining({
+            command: "execute some --build",
+            watch_dir: [
+              path.normalize("project/some/path/a"),
+              path.normalize("project/some/path/b"),
+              path.normalize("project/123"),
+              path.normalize("project/some/path/c"),
+              path.normalize("project/false"),
+            ],
+          })
+        );
+
+        expect(diagnostics.hasWarnings()).toBe(false);
+        expect(diagnostics.hasErrors()).toBe(true);
+
+        expect(normalizePath(diagnostics.renderErrors()))
+          .toMatchInlineSnapshot(`
+          "Processing project/wrangler.toml configuration:
+            - Expected \\"build.watch_dir.[2]\\" to be of type string but got 123.
+            - Expected \\"build.watch_dir.[4]\\" to be of type string but got false."
+        `);
+      });
+    });
+
     describe("durable_objects field", () => {
       it("should error if durable_objects is an array", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { durable_objects: [] } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -583,7 +1146,8 @@ describe("normalizeAndValidateConfig()", () => {
       it("should error if durable_objects is a string", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { durable_objects: "BAD" } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -599,7 +1163,8 @@ describe("normalizeAndValidateConfig()", () => {
       it("should error if durable_objects is a number", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { durable_objects: 999 } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -615,7 +1180,8 @@ describe("normalizeAndValidateConfig()", () => {
       it("should error if durable_objects is null", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { durable_objects: null } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -631,7 +1197,8 @@ describe("normalizeAndValidateConfig()", () => {
       it("should error if durable_objects.bindings is not defined", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { durable_objects: {} } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -647,7 +1214,8 @@ describe("normalizeAndValidateConfig()", () => {
       it("should error if durable_objects.bindings is an object", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { durable_objects: { bindings: {} } } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -665,7 +1233,8 @@ describe("normalizeAndValidateConfig()", () => {
       it("should error if durable_objects.bindings is a string", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { durable_objects: { bindings: "BAD" } } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -683,7 +1252,8 @@ describe("normalizeAndValidateConfig()", () => {
       it("should error if durable_objects.bindings is a number", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { durable_objects: { bindings: 999 } } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -701,7 +1271,8 @@ describe("normalizeAndValidateConfig()", () => {
       it("should error if durable_objects.bindings is null", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { durable_objects: { bindings: null } } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -722,17 +1293,34 @@ describe("normalizeAndValidateConfig()", () => {
             durable_objects: {
               bindings: [
                 {},
-                { name: "VALID" },
+                { name: "MISSING_CLASS" },
                 { name: 1555, class_name: 1666 },
                 {
                   name: 1777,
                   class_name: 1888,
                   script_name: 1999,
                 },
+                {
+                  name: "SOMENAME",
+                  class_name: "SomeClass",
+                  environment: "staging",
+                },
+                {
+                  name: 1778,
+                  class_name: 1889,
+                  script_name: 1992,
+                  environment: 2111,
+                },
+                {
+                  name: 1772,
+                  class_name: 1883,
+                  environment: 2112,
+                },
               ],
             },
           } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -741,24 +1329,41 @@ describe("normalizeAndValidateConfig()", () => {
           })
         );
         expect(diagnostics.hasWarnings()).toBe(false);
+
+        expect(diagnostics.hasErrors()).toBe(true);
         expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
           "Processing wrangler configuration:
 
             - \\"durable_objects.bindings[0]\\": {}
-              - ERROR: bindings should have a string \\"name\\" field.
-              - ERROR: should have a string \\"class_name\\" field.
+              - binding should have a string \\"name\\" field.
+              - binding should have a string \\"class_name\\" field.
 
-            - \\"durable_objects.bindings[1]\\": {\\"name\\":\\"VALID\\"}
-              - ERROR: should have a string \\"class_name\\" field.
+            - \\"durable_objects.bindings[1]\\": {\\"name\\":\\"MISSING_CLASS\\"}
+              - binding should have a string \\"class_name\\" field.
 
             - \\"durable_objects.bindings[2]\\": {\\"name\\":1555,\\"class_name\\":1666}
-              - ERROR: bindings should have a string \\"name\\" field.
-              - ERROR: should have a string \\"class_name\\" field.
+              - binding should have a string \\"name\\" field.
+              - binding should have a string \\"class_name\\" field.
 
             - \\"durable_objects.bindings[3]\\": {\\"name\\":1777,\\"class_name\\":1888,\\"script_name\\":1999}
-              - ERROR: bindings should have a string \\"name\\" field.
-              - ERROR: should have a string \\"class_name\\" field.
-              - ERROR: should, optionally, have a string \\"script_name\\" field."
+              - binding should have a string \\"name\\" field.
+              - binding should have a string \\"class_name\\" field.
+              - the field \\"script_name\\", when present, should be a string.
+
+            - \\"durable_objects.bindings[4]\\": {\\"name\\":\\"SOMENAME\\",\\"class_name\\":\\"SomeClass\\",\\"environment\\":\\"staging\\"}
+              - binding should have a \\"script_name\\" field if \\"environment\\" is present.
+
+            - \\"durable_objects.bindings[5]\\": {\\"name\\":1778,\\"class_name\\":1889,\\"script_name\\":1992,\\"environment\\":2111}
+              - binding should have a string \\"name\\" field.
+              - binding should have a string \\"class_name\\" field.
+              - the field \\"script_name\\", when present, should be a string.
+              - the field \\"environment\\", when present, should be a string.
+
+            - \\"durable_objects.bindings[6]\\": {\\"name\\":1772,\\"class_name\\":1883,\\"environment\\":2112}
+              - binding should have a string \\"name\\" field.
+              - binding should have a string \\"class_name\\" field.
+              - the field \\"environment\\", when present, should be a string.
+              - binding should have a \\"script_name\\" field if \\"environment\\" is present."
         `);
       });
     });
@@ -767,7 +1372,8 @@ describe("normalizeAndValidateConfig()", () => {
       it("should error if kv_namespaces is an object", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { kv_namespaces: {} } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -783,7 +1389,8 @@ describe("normalizeAndValidateConfig()", () => {
       it("should error if kv_namespaces is a string", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { kv_namespaces: "BAD" } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -799,7 +1406,8 @@ describe("normalizeAndValidateConfig()", () => {
       it("should error if kv_namespaces is a number", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { kv_namespaces: 999 } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -815,7 +1423,8 @@ describe("normalizeAndValidateConfig()", () => {
       it("should error if kv_namespaces is null", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { kv_namespaces: null } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -842,7 +1451,8 @@ describe("normalizeAndValidateConfig()", () => {
               },
             ],
           } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -867,7 +1477,8 @@ describe("normalizeAndValidateConfig()", () => {
       it("should error if r2_buckets is an object", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { r2_buckets: {} } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -883,7 +1494,8 @@ describe("normalizeAndValidateConfig()", () => {
       it("should error if r2_buckets is a string", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { r2_buckets: "BAD" } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -899,7 +1511,8 @@ describe("normalizeAndValidateConfig()", () => {
       it("should error if r2_buckets is a number", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { r2_buckets: 999 } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -915,7 +1528,8 @@ describe("normalizeAndValidateConfig()", () => {
       it("should error if r2_buckets is null", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { r2_buckets: null } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -942,7 +1556,8 @@ describe("normalizeAndValidateConfig()", () => {
               },
             ],
           } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -963,11 +1578,157 @@ describe("normalizeAndValidateConfig()", () => {
       });
     });
 
+    describe("services field", () => {
+      it("should error if services is an object", () => {
+        const { config, diagnostics } = normalizeAndValidateConfig(
+          { services: {} } as unknown as RawConfig,
+          undefined,
+          { env: undefined }
+        );
+
+        expect(config).toEqual(
+          expect.not.objectContaining({ services: expect.anything })
+        );
+        expect(diagnostics.hasWarnings()).toBe(true);
+        expect(diagnostics.hasErrors()).toBe(true);
+        expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
+          "Processing wrangler configuration:
+            - \\"services\\" fields are experimental and may change or break at any time."
+        `);
+        expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+          "Processing wrangler configuration:
+            - The field \\"services\\" should be an array but got {}."
+        `);
+      });
+
+      it("should error if services is a string", () => {
+        const { config, diagnostics } = normalizeAndValidateConfig(
+          { services: "BAD" } as unknown as RawConfig,
+          undefined,
+          { env: undefined }
+        );
+
+        expect(config).toEqual(
+          expect.not.objectContaining({ services: expect.anything })
+        );
+        expect(diagnostics.hasWarnings()).toBe(true);
+        expect(diagnostics.hasErrors()).toBe(true);
+        expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
+          "Processing wrangler configuration:
+            - \\"services\\" fields are experimental and may change or break at any time."
+        `);
+        expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+          "Processing wrangler configuration:
+            - The field \\"services\\" should be an array but got \\"BAD\\"."
+        `);
+      });
+
+      it("should error if services is a number", () => {
+        const { config, diagnostics } = normalizeAndValidateConfig(
+          { services: 999 } as unknown as RawConfig,
+          undefined,
+          { env: undefined }
+        );
+
+        expect(config).toEqual(
+          expect.not.objectContaining({ services: expect.anything })
+        );
+        expect(diagnostics.hasWarnings()).toBe(true);
+        expect(diagnostics.hasErrors()).toBe(true);
+        expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
+          "Processing wrangler configuration:
+            - \\"services\\" fields are experimental and may change or break at any time."
+        `);
+        expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+          "Processing wrangler configuration:
+            - The field \\"services\\" should be an array but got 999."
+        `);
+      });
+
+      it("should error if services is null", () => {
+        const { config, diagnostics } = normalizeAndValidateConfig(
+          { services: null } as unknown as RawConfig,
+          undefined,
+          { env: undefined }
+        );
+
+        expect(config).toEqual(
+          expect.not.objectContaining({ services: expect.anything })
+        );
+        expect(diagnostics.hasWarnings()).toBe(true);
+        expect(diagnostics.hasErrors()).toBe(true);
+        expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
+          "Processing wrangler configuration:
+            - \\"services\\" fields are experimental and may change or break at any time."
+        `);
+        expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+          "Processing wrangler configuration:
+            - The field \\"services\\" should be an array but got null."
+        `);
+      });
+
+      it("should error if services bindings are not valid", () => {
+        const { config, diagnostics } = normalizeAndValidateConfig(
+          {
+            services: [
+              {},
+              { binding: "SERVICE_BINDING_1" },
+              { binding: 123, service: 456 },
+              { binding: 123, service: 456, environment: 789 },
+              { binding: "SERVICE_BINDING_1", service: 456, environment: 789 },
+              {
+                binding: 123,
+                service: "SERVICE_BINDING_SERVICE_1",
+                environment: 789,
+              },
+              {
+                binding: 123,
+                service: 456,
+                environment: "SERVICE_BINDING_ENVIRONMENT_1",
+              },
+            ],
+          } as unknown as RawConfig,
+          undefined,
+          { env: undefined }
+        );
+
+        expect(config).toEqual(
+          expect.not.objectContaining({
+            services: { bindings: expect.anything },
+          })
+        );
+        expect(diagnostics.hasWarnings()).toBe(true);
+        expect(diagnostics.hasErrors()).toBe(true);
+        expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
+          "Processing wrangler configuration:
+            - \\"services\\" fields are experimental and may change or break at any time."
+        `);
+        expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+          "Processing wrangler configuration:
+            - \\"services[0]\\" bindings should have a string \\"binding\\" field but got {}.
+            - \\"services[0]\\" bindings should have a string \\"service\\" field but got {}.
+            - \\"services[1]\\" bindings should have a string \\"service\\" field but got {\\"binding\\":\\"SERVICE_BINDING_1\\"}.
+            - \\"services[2]\\" bindings should have a string \\"binding\\" field but got {\\"binding\\":123,\\"service\\":456}.
+            - \\"services[2]\\" bindings should have a string \\"service\\" field but got {\\"binding\\":123,\\"service\\":456}.
+            - \\"services[3]\\" bindings should have a string \\"binding\\" field but got {\\"binding\\":123,\\"service\\":456,\\"environment\\":789}.
+            - \\"services[3]\\" bindings should have a string \\"service\\" field but got {\\"binding\\":123,\\"service\\":456,\\"environment\\":789}.
+            - \\"services[3]\\" bindings should have a string \\"environment\\" field but got {\\"binding\\":123,\\"service\\":456,\\"environment\\":789}.
+            - \\"services[4]\\" bindings should have a string \\"service\\" field but got {\\"binding\\":\\"SERVICE_BINDING_1\\",\\"service\\":456,\\"environment\\":789}.
+            - \\"services[4]\\" bindings should have a string \\"environment\\" field but got {\\"binding\\":\\"SERVICE_BINDING_1\\",\\"service\\":456,\\"environment\\":789}.
+            - \\"services[5]\\" bindings should have a string \\"binding\\" field but got {\\"binding\\":123,\\"service\\":\\"SERVICE_BINDING_SERVICE_1\\",\\"environment\\":789}.
+            - \\"services[5]\\" bindings should have a string \\"environment\\" field but got {\\"binding\\":123,\\"service\\":\\"SERVICE_BINDING_SERVICE_1\\",\\"environment\\":789}.
+            - \\"services[6]\\" bindings should have a string \\"binding\\" field but got {\\"binding\\":123,\\"service\\":456,\\"environment\\":\\"SERVICE_BINDING_ENVIRONMENT_1\\"}.
+            - \\"services[6]\\" bindings should have a string \\"service\\" field but got {\\"binding\\":123,\\"service\\":456,\\"environment\\":\\"SERVICE_BINDING_ENVIRONMENT_1\\"}."
+        `);
+      });
+    });
+
     describe("unsafe field", () => {
       it("should error if unsafe is an array", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { unsafe: [] } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -986,7 +1747,8 @@ describe("normalizeAndValidateConfig()", () => {
       it("should error if unsafe is a string", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { unsafe: "BAD" } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -1005,7 +1767,8 @@ describe("normalizeAndValidateConfig()", () => {
       it("should error if unsafe is a number", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { unsafe: 999 } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -1024,7 +1787,8 @@ describe("normalizeAndValidateConfig()", () => {
       it("should error if unsafe is null", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { unsafe: null } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -1043,7 +1807,8 @@ describe("normalizeAndValidateConfig()", () => {
       it("should error if unsafe.bindings is not defined", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { unsafe: {} } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -1062,7 +1827,8 @@ describe("normalizeAndValidateConfig()", () => {
       it("should error if unsafe.bindings is an object", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { unsafe: { bindings: {} } } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -1083,7 +1849,8 @@ describe("normalizeAndValidateConfig()", () => {
       it("should error if unsafe.bindings is a string", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { unsafe: { bindings: "BAD" } } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -1104,7 +1871,8 @@ describe("normalizeAndValidateConfig()", () => {
       it("should error if unsafe.bindings is a number", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { unsafe: { bindings: 999 } } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -1125,7 +1893,8 @@ describe("normalizeAndValidateConfig()", () => {
       it("should error if unsafe.bindings is null", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { unsafe: { bindings: null } } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -1159,7 +1928,8 @@ describe("normalizeAndValidateConfig()", () => {
               ],
             },
           } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -1175,15 +1945,15 @@ describe("normalizeAndValidateConfig()", () => {
           "Processing wrangler configuration:
 
             - \\"unsafe.bindings[0]\\": {}
-              - ERROR: should have a string \\"name\\" field.
-              - ERROR: should have a string \\"type\\" field.
+              - binding should have a string \\"name\\" field.
+              - binding should have a string \\"type\\" field.
 
             - \\"unsafe.bindings[1]\\": {\\"name\\":\\"UNSAFE_BINDING_1\\"}
-              - ERROR: should have a string \\"type\\" field.
+              - binding should have a string \\"type\\" field.
 
             - \\"unsafe.bindings[2]\\": {\\"name\\":2666,\\"type\\":2777}
-              - ERROR: should have a string \\"name\\" field.
-              - ERROR: should have a string \\"type\\" field."
+              - binding should have a string \\"name\\" field.
+              - binding should have a string \\"type\\" field."
         `);
       });
     });
@@ -1194,7 +1964,7 @@ describe("normalizeAndValidateConfig()", () => {
           zone_id: "ZONE_ID",
           experimental_services: [
             {
-              name: "NAME",
+              name: "mock-name",
               service: "SERVICE",
               environment: "ENV",
             },
@@ -1203,7 +1973,8 @@ describe("normalizeAndValidateConfig()", () => {
 
         const { config, diagnostics } = normalizeAndValidateConfig(
           rawConfig,
-          undefined
+          undefined,
+          { env: undefined }
         );
 
         expect("experimental_services" in config).toBe(false);
@@ -1212,90 +1983,339 @@ describe("normalizeAndValidateConfig()", () => {
         expect(diagnostics.hasErrors()).toBe(false);
         expect(diagnostics.hasWarnings()).toBe(true);
         expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
-            "Processing wrangler configuration:
-              - DEPRECATION: \\"zone_id\\":
-                This is unnecessary since we can deduce this from routes directly.
-              - DEPRECATION: \\"experimental_services\\":
-                The \\"experimental_services\\" field is no longer supported. Instead, use [[unsafe.bindings]] to enable experimental features. Add this to your wrangler.toml:
-                \`\`\`
-                [[unsafe.bindings]]
-                name = \\"NAME\\"
-                type = \\"service\\"
-                service = \\"SERVICE\\"
-                environment = \\"ENV\\"
-                \`\`\`"
-          `);
+          "Processing wrangler configuration:
+            - Deprecation: \\"zone_id\\":
+              This is unnecessary since we can deduce this from routes directly.
+            - Deprecation: \\"experimental_services\\":
+              The \\"experimental_services\\" field is no longer supported. Simply rename the [experimental_services] field to [services]."
+        `);
+      });
+    });
+
+    describe("route & routes fields", () => {
+      it("should error if both route and routes are specified", () => {
+        const rawConfig: RawConfig = {
+          route: "route1",
+          routes: ["route2", "route3"],
+        };
+
+        const { diagnostics } = normalizeAndValidateConfig(
+          rawConfig,
+          undefined,
+          { env: undefined }
+        );
+
+        expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+          "Processing wrangler configuration:
+            - Expected exactly one of the following fields [\\"routes\\",\\"route\\"]."
+        `);
       });
     });
   });
 
   describe("named environments", () => {
+    it("should warn if we specify an environment but there are no named environments", () => {
+      const rawConfig: RawConfig = {};
+      const { diagnostics } = normalizeAndValidateConfig(rawConfig, undefined, {
+        env: "DEV",
+      });
+      expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+        "Processing wrangler configuration:
+        "
+      `);
+      expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
+        "Processing wrangler configuration:
+          - No environment found in configuration with name \\"DEV\\".
+            Before using \`--env=DEV\` there should be an equivalent environment section in the configuration.
+
+            Consider adding an environment configuration section to the wrangler.toml file:
+            \`\`\`
+            [env.DEV]
+            \`\`\`
+        "
+      `);
+    });
+
+    it("should error if we specify an environment that does not match the named environments", () => {
+      const rawConfig: RawConfig = { env: { ENV1: {} } };
+      const { diagnostics } = normalizeAndValidateConfig(rawConfig, undefined, {
+        env: "DEV",
+      });
+      expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+        "Processing wrangler configuration:
+          - No environment found in configuration with name \\"DEV\\".
+            Before using \`--env=DEV\` there should be an equivalent environment section in the configuration.
+            The available configured environment names are: [\\"ENV1\\"]
+
+            Consider adding an environment configuration section to the wrangler.toml file:
+            \`\`\`
+            [env.DEV]
+            \`\`\`
+        "
+      `);
+      expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
+        "Processing wrangler configuration:
+        "
+      `);
+    });
+
     it("should use top-level values for inheritable config fields", () => {
-      const expectedConfig: RawConfig = {
-        name: "NAME",
+      const main = "src/index.ts";
+      const resolvedMain = path.resolve(process.cwd(), main);
+      const rawConfig: RawConfig = {
+        name: "mock-name",
         account_id: "ACCOUNT_ID",
         compatibility_date: "2022-01-01",
         compatibility_flags: ["FLAG1", "FLAG2"],
         workers_dev: false,
         routes: ["ROUTE_1", "ROUTE_2"],
-        route: "ROUTE_3",
         jsx_factory: "JSX_FACTORY",
         jsx_fragment: "JSX_FRAGMENT",
+        tsconfig: "path/to/tsconfig.json",
         triggers: { crons: ["CRON_1", "CRON_2"] },
         usage_model: "bundled",
+        main,
+        build: {
+          command: "COMMAND",
+          cwd: "CWD",
+          watch_dir: "WATCH_DIR",
+        },
+        minify: true,
+        node_compat: true,
       };
 
       const { config, diagnostics } = normalizeAndValidateConfig(
-        { ...expectedConfig, env: { DEV: {} } },
-        undefined
+        { ...rawConfig, env: { dev: {} } },
+        undefined,
+        { env: "dev" }
       );
 
-      expect(config.env.DEV).toEqual(expect.objectContaining(expectedConfig));
+      expect(config).toEqual(
+        expect.objectContaining({
+          ...rawConfig,
+          main: resolvedMain,
+          name: "mock-name-dev",
+        })
+      );
       expect(diagnostics.hasErrors()).toBe(false);
       expect(diagnostics.hasWarnings()).toBe(false);
     });
 
     it("should override top-level values for inheritable config fields", () => {
-      const environment: RawEnvironment = {
-        name: "ENV_NAME",
+      const main = "src/index.ts";
+      const resolvedMain = path.resolve(process.cwd(), main);
+      const rawEnv: RawEnvironment = {
+        name: "mock-env-name",
         account_id: "ENV_ACCOUNT_ID",
         compatibility_date: "2022-02-02",
         compatibility_flags: ["ENV_FLAG1", "ENV_FLAG2"],
         workers_dev: true,
         routes: ["ENV_ROUTE_1", "ENV_ROUTE_2"],
-        route: "ENV_ROUTE_3",
         jsx_factory: "ENV_JSX_FACTORY",
         jsx_fragment: "ENV_JSX_FRAGMENT",
+        tsconfig: "ENV_path/to/tsconfig.json",
         triggers: { crons: ["ENV_CRON_1", "ENV_CRON_2"] },
         usage_model: "unbound",
+        main,
+        build: {
+          command: "ENV_COMMAND",
+          cwd: "ENV_CWD",
+          watch_dir: "ENV_WATCH_DIR",
+        },
+        minify: false,
+        node_compat: false,
       };
-      const expectedConfig: RawConfig = {
-        name: "NAME",
+      const rawConfig: RawConfig = {
+        name: "mock-name",
         account_id: "ACCOUNT_ID",
         compatibility_date: "2022-01-01",
         compatibility_flags: ["FLAG1", "FLAG2"],
         workers_dev: false,
         routes: ["ROUTE_1", "ROUTE_2"],
-        route: "ROUTE_3",
         jsx_factory: "JSX_FACTORY",
         jsx_fragment: "JSX_FRAGMENT",
+        tsconfig: "path/to/tsconfig.json",
         triggers: { crons: ["CRON_1", "CRON_2"] },
         usage_model: "bundled",
+        main: "top-level.js",
+        build: {
+          command: "COMMAND",
+          cwd: "CWD",
+          watch_dir: "WATCH_DIR",
+        },
+        minify: true,
+        node_compat: true,
         env: {
-          ENV1: environment,
+          ENV1: rawEnv,
         },
       };
 
       const { config, diagnostics } = normalizeAndValidateConfig(
-        expectedConfig,
-        undefined
+        rawConfig,
+        undefined,
+        { env: "ENV1" }
       );
 
-      expect(config.env.ENV1).toEqual(expect.objectContaining(environment));
+      expect(config).toEqual(
+        expect.objectContaining({ ...rawEnv, main: resolvedMain })
+      );
       expect(diagnostics.hasErrors()).toBe(false);
       expect(diagnostics.hasWarnings()).toBe(false);
     });
 
+    describe("non-legacy", () => {
+      it("should use top-level `name` field", () => {
+        const rawConfig: RawConfig = {
+          name: "mock-name",
+          legacy_env: false,
+          env: { DEV: {} },
+        };
+
+        const { config, diagnostics } = normalizeAndValidateConfig(
+          rawConfig,
+          undefined,
+          { env: "DEV" }
+        );
+
+        expect(config.name).toEqual("mock-name");
+        expect(diagnostics.hasErrors()).toBe(false);
+        expect(diagnostics.hasWarnings()).toBe(true);
+        expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
+          "Processing wrangler configuration:
+            - Experimental: Service environments are in beta, and their behaviour is guaranteed to change in the future. DO NOT USE IN PRODUCTION."
+        `);
+      });
+
+      it("should error if named environment contains a `name` field, even if there is no top-level name", () => {
+        const rawConfig: RawConfig = {
+          legacy_env: false,
+          env: {
+            DEV: {
+              name: "mock-env-name",
+            },
+          },
+        };
+
+        const { config, diagnostics } = normalizeAndValidateConfig(
+          rawConfig,
+          undefined,
+          { env: "DEV" }
+        );
+
+        expect(config.name).toBeUndefined();
+        expect(diagnostics.hasWarnings()).toBe(true);
+        expect(diagnostics.hasErrors()).toBe(true);
+        expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
+          "Processing wrangler configuration:
+            - Experimental: Service environments are in beta, and their behaviour is guaranteed to change in the future. DO NOT USE IN PRODUCTION."
+        `);
+        expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+          "Processing wrangler configuration:
+
+            - \\"env.DEV\\" environment configuration
+              - The \\"name\\" field is not allowed in named service environments.
+                Please remove the field from this environment."
+        `);
+      });
+
+      it("should error if top-level config and a named environment both contain a `name` field", () => {
+        const rawConfig: RawConfig = {
+          name: "mock-name",
+          legacy_env: false,
+          env: {
+            DEV: {
+              name: "mock-env-name",
+            },
+          },
+        };
+
+        const { config, diagnostics } = normalizeAndValidateConfig(
+          rawConfig,
+          undefined,
+          { env: "DEV" }
+        );
+
+        expect(config.name).toEqual("mock-name");
+        expect(diagnostics.hasWarnings()).toBe(true);
+        expect(diagnostics.hasErrors()).toBe(true);
+        expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
+          "Processing wrangler configuration:
+            - Experimental: Service environments are in beta, and their behaviour is guaranteed to change in the future. DO NOT USE IN PRODUCTION."
+        `);
+        expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+          "Processing wrangler configuration:
+
+            - \\"env.DEV\\" environment configuration
+              - The \\"name\\" field is not allowed in named service environments.
+                Please remove the field from this environment."
+        `);
+      });
+    });
+
+    it("should error if named environment contains a `account_id` field, even if there is no top-level name", () => {
+      const rawConfig: RawConfig = {
+        legacy_env: false,
+        env: {
+          DEV: {
+            account_id: "some_account_id",
+          },
+        },
+      };
+
+      const { config, diagnostics } = normalizeAndValidateConfig(
+        rawConfig,
+        undefined,
+        { env: "DEV" }
+      );
+
+      expect(diagnostics.hasWarnings()).toBe(true);
+      expect(config.account_id).toBeUndefined();
+      expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
+        "Processing wrangler configuration:
+          - Experimental: Service environments are in beta, and their behaviour is guaranteed to change in the future. DO NOT USE IN PRODUCTION."
+      `);
+      expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+        "Processing wrangler configuration:
+
+          - \\"env.DEV\\" environment configuration
+            - The \\"account_id\\" field is not allowed in named service environments.
+              Please remove the field from this environment."
+      `);
+    });
+
+    it("should error if top-level config and a named environment both contain a `account_id` field", () => {
+      const rawConfig: RawConfig = {
+        account_id: "ACCOUNT_ID",
+        legacy_env: false,
+        env: {
+          DEV: {
+            account_id: "ENV_ACCOUNT_ID",
+          },
+        },
+      };
+
+      const { config, diagnostics } = normalizeAndValidateConfig(
+        rawConfig,
+        undefined,
+        { env: "DEV" }
+      );
+
+      expect(config.account_id).toEqual("ACCOUNT_ID");
+      expect(diagnostics.hasErrors()).toBe(true);
+      expect(diagnostics.hasWarnings()).toBe(true);
+      expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
+        "Processing wrangler configuration:
+          - Experimental: Service environments are in beta, and their behaviour is guaranteed to change in the future. DO NOT USE IN PRODUCTION."
+      `);
+      expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+        "Processing wrangler configuration:
+
+          - \\"env.DEV\\" environment configuration
+            - The \\"account_id\\" field is not allowed in named service environments.
+              Please remove the field from this environment."
+      `);
+    });
+
     it("should warn for non-inherited fields that are missing in environments", () => {
       const vars: RawConfig["vars"] = {
         FOO: "foo",
@@ -1319,10 +2339,11 @@ describe("normalizeAndValidateConfig()", () => {
 
       const { config, diagnostics } = normalizeAndValidateConfig(
         rawConfig,
-        undefined
+        undefined,
+        { env: "ENV1" }
       );
 
-      expect(config.env.ENV1).toEqual(
+      expect(config).toEqual(
         expect.not.objectContaining({
           vars,
           durable_objects,
@@ -1365,31 +2386,52 @@ describe("normalizeAndValidateConfig()", () => {
         route: 888,
         jsx_factory: 999,
         jsx_fragment: 1000,
+        tsconfig: 123,
         triggers: { crons: [1111, 1222] },
         usage_model: "INVALID",
+        main: 1333,
+        build: {
+          command: 1444,
+          cwd: 1555,
+          watch_dir: 1666,
+        },
+        minify: "INVALID",
+        node_compat: "INVALID",
       } as unknown as RawEnvironment;
 
       const { config, diagnostics } = normalizeAndValidateConfig(
         { env: { ENV1: expectedConfig } },
-        undefined
+        undefined,
+        { env: "ENV1" }
       );
 
-      expect(config.env.ENV1).toEqual(expect.objectContaining(expectedConfig));
+      expect(config).toEqual(expect.objectContaining(expectedConfig));
       expect(diagnostics.hasWarnings()).toBe(false);
       expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
         "Processing wrangler configuration:
 
           - \\"env.ENV1\\" environment configuration
-            - Expected \\"route\\" field to be a string but got 888.
-            - Expected \\"routes\\" field to be an array of strings but got [666,777].
-            - Expected \\"workers_dev\\" field to be a boolean but got \\"BAD\\".
-            - Expected \\"account_id\\" field to be a string but got 222.
-            - Expected \\"compatibility_date\\" field to be a string but got 333.
-            - Expected \\"compatibility_flags\\" field to be an array of strings but got [444,555].
-            - Expected \\"jsx_factory\\" field to be a string but got 999.
-            - Expected \\"jsx_fragment\\" field to be a string but got 1000.
-            - Expected \\"name\\" field to be a string but got 111.
-            - Expected \\"usage_model\\" field to be on of bundled,unbound but got \\"INVALID\\"."
+            - Expected \\"route\\" to be either a string, or an object with shape { pattern, custom_domain, zone_id | zone_name }, but got 888.
+            - Expected \\"routes\\" to be an array of either strings or objects with the shape { pattern, custom_domain, zone_id | zone_name }, but these weren't valid: [
+                666,
+                777
+              ].
+            - Expected exactly one of the following fields [\\"routes\\",\\"route\\"].
+            - Expected \\"workers_dev\\" to be of type boolean but got \\"BAD\\".
+            - Expected \\"build.command\\" to be of type string but got 1444.
+            - Expected \\"build.cwd\\" to be of type string but got 1555.
+            - Expected \\"build.watch_dir\\" to be of type string but got 1666.
+            - Expected \\"account_id\\" to be of type string but got 222.
+            - Expected \\"compatibility_date\\" to be of type string but got 333.
+            - Expected \\"compatibility_flags\\" to be of type string array but got [444,555].
+            - Expected \\"jsx_factory\\" to be of type string but got 999.
+            - Expected \\"jsx_fragment\\" to be of type string but got 1000.
+            - Expected \\"tsconfig\\" to be of type string but got 123.
+            - Expected \\"name\\" to be of type string, alphanumeric and lowercase with dashes only but got 111.
+            - Expected \\"main\\" to be of type string but got 1333.
+            - Expected \\"usage_model\\" field to be one of [\\"bundled\\",\\"unbound\\"] but got \\"INVALID\\".
+            - Expected \\"minify\\" to be of type boolean but got \\"INVALID\\".
+            - Expected \\"node_compat\\" to be of type boolean but got \\"INVALID\\"."
       `);
     });
 
@@ -1397,10 +2439,11 @@ describe("normalizeAndValidateConfig()", () => {
       it("should error if durable_objects is an array", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { env: { ENV1: { durable_objects: [] } } } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: "ENV1" }
         );
 
-        expect(config.env.ENV1).toEqual(
+        expect(config).toEqual(
           expect.not.objectContaining({ durable_objects: expect.anything })
         );
         expect(diagnostics.hasWarnings()).toBe(false);
@@ -1415,10 +2458,11 @@ describe("normalizeAndValidateConfig()", () => {
       it("should error if durable_objects is a string", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { env: { ENV1: { durable_objects: "BAD" } } } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: "ENV1" }
         );
 
-        expect(config.env.ENV1).toEqual(
+        expect(config).toEqual(
           expect.not.objectContaining({ durable_objects: expect.anything })
         );
         expect(diagnostics.hasWarnings()).toBe(false);
@@ -1433,10 +2477,11 @@ describe("normalizeAndValidateConfig()", () => {
       it("should error if durable_objects is a number", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { env: { ENV1: { durable_objects: 999 } } } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: "ENV1" }
         );
 
-        expect(config.env.ENV1).toEqual(
+        expect(config).toEqual(
           expect.not.objectContaining({ durable_objects: expect.anything })
         );
         expect(diagnostics.hasWarnings()).toBe(false);
@@ -1451,10 +2496,11 @@ describe("normalizeAndValidateConfig()", () => {
       it("should error if durable_objects is null", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { env: { ENV1: { durable_objects: null } } } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: "ENV1" }
         );
 
-        expect(config.env.ENV1).toEqual(
+        expect(config).toEqual(
           expect.not.objectContaining({ durable_objects: expect.anything })
         );
         expect(diagnostics.hasWarnings()).toBe(false);
@@ -1469,10 +2515,11 @@ describe("normalizeAndValidateConfig()", () => {
       it("should error if durable_objects.bindings is not defined", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { env: { ENV1: { durable_objects: {} } } } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: "ENV1" }
         );
 
-        expect(config.env.ENV1).toEqual(
+        expect(config).toEqual(
           expect.not.objectContaining({ durable_objects: expect.anything })
         );
         expect(diagnostics.hasWarnings()).toBe(false);
@@ -1489,10 +2536,11 @@ describe("normalizeAndValidateConfig()", () => {
           {
             env: { ENV1: { durable_objects: { bindings: {} } } },
           } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: "ENV1" }
         );
 
-        expect(config.env.ENV1).toEqual(
+        expect(config).toEqual(
           expect.not.objectContaining({
             durable_objects: { bindings: expect.anything },
           })
@@ -1511,10 +2559,11 @@ describe("normalizeAndValidateConfig()", () => {
           {
             env: { ENV1: { durable_objects: { bindings: "BAD" } } },
           } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: "ENV1" }
         );
 
-        expect(config.env.ENV1).toEqual(
+        expect(config).toEqual(
           expect.not.objectContaining({
             durable_objects: { bindings: expect.anything },
           })
@@ -1533,10 +2582,11 @@ describe("normalizeAndValidateConfig()", () => {
           {
             env: { ENV1: { durable_objects: { bindings: 999 } } },
           } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: "ENV1" }
         );
 
-        expect(config.env.ENV1).toEqual(
+        expect(config).toEqual(
           expect.not.objectContaining({
             durable_objects: { bindings: expect.anything },
           })
@@ -1555,10 +2605,11 @@ describe("normalizeAndValidateConfig()", () => {
           {
             env: { ENV1: { durable_objects: { bindings: null } } },
           } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: "ENV1" }
         );
 
-        expect(config.env.ENV1).toEqual(
+        expect(config).toEqual(
           expect.not.objectContaining({
             durable_objects: { bindings: expect.anything },
           })
@@ -1592,35 +2643,37 @@ describe("normalizeAndValidateConfig()", () => {
               },
             },
           } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: "ENV1" }
         );
 
-        expect(config.env.ENV1).toEqual(
+        expect(config).toEqual(
           expect.not.objectContaining({
             durable_objects: { bindings: expect.anything },
           })
         );
         expect(diagnostics.hasWarnings()).toBe(false);
+        expect(diagnostics.hasErrors()).toBe(true);
         expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
           "Processing wrangler configuration:
 
             - \\"env.ENV1\\" environment configuration
 
               - \\"env.ENV1.durable_objects.bindings[0]\\": {}
-                - ERROR: bindings should have a string \\"name\\" field.
-                - ERROR: should have a string \\"class_name\\" field.
+                - binding should have a string \\"name\\" field.
+                - binding should have a string \\"class_name\\" field.
 
               - \\"env.ENV1.durable_objects.bindings[1]\\": {\\"name\\":\\"VALID\\"}
-                - ERROR: should have a string \\"class_name\\" field.
+                - binding should have a string \\"class_name\\" field.
 
               - \\"env.ENV1.durable_objects.bindings[2]\\": {\\"name\\":1555,\\"class_name\\":1666}
-                - ERROR: bindings should have a string \\"name\\" field.
-                - ERROR: should have a string \\"class_name\\" field.
+                - binding should have a string \\"name\\" field.
+                - binding should have a string \\"class_name\\" field.
 
               - \\"env.ENV1.durable_objects.bindings[3]\\": {\\"name\\":1777,\\"class_name\\":1888,\\"script_name\\":1999}
-                - ERROR: bindings should have a string \\"name\\" field.
-                - ERROR: should have a string \\"class_name\\" field.
-                - ERROR: should, optionally, have a string \\"script_name\\" field."
+                - binding should have a string \\"name\\" field.
+                - binding should have a string \\"class_name\\" field.
+                - the field \\"script_name\\", when present, should be a string."
         `);
       });
     });
@@ -1629,10 +2682,11 @@ describe("normalizeAndValidateConfig()", () => {
       it("should error if kv_namespaces is an object", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { env: { ENV1: { kv_namespaces: {} } } } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: "ENV1" }
         );
 
-        expect(config.env.ENV1).toEqual(
+        expect(config).toEqual(
           expect.not.objectContaining({ kv_namespaces: expect.anything })
         );
         expect(diagnostics.hasWarnings()).toBe(false);
@@ -1647,10 +2701,11 @@ describe("normalizeAndValidateConfig()", () => {
       it("should error if kv_namespaces is a string", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { env: { ENV1: { kv_namespaces: "BAD" } } } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: "ENV1" }
         );
 
-        expect(config.env.ENV1).toEqual(
+        expect(config).toEqual(
           expect.not.objectContaining({ kv_namespaces: expect.anything })
         );
         expect(diagnostics.hasWarnings()).toBe(false);
@@ -1665,10 +2720,11 @@ describe("normalizeAndValidateConfig()", () => {
       it("should error if kv_namespaces is a number", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { env: { ENV1: { kv_namespaces: 999 } } } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: "ENV1" }
         );
 
-        expect(config.env.ENV1).toEqual(
+        expect(config).toEqual(
           expect.not.objectContaining({ kv_namespaces: expect.anything })
         );
         expect(diagnostics.hasWarnings()).toBe(false);
@@ -1683,10 +2739,11 @@ describe("normalizeAndValidateConfig()", () => {
       it("should error if kv_namespaces is null", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { env: { ENV1: { kv_namespaces: null } } } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: "ENV1" }
         );
 
-        expect(config.env.ENV1).toEqual(
+        expect(config).toEqual(
           expect.not.objectContaining({ kv_namespaces: expect.anything })
         );
         expect(diagnostics.hasWarnings()).toBe(false);
@@ -1716,10 +2773,11 @@ describe("normalizeAndValidateConfig()", () => {
               },
             },
           } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: "ENV1" }
         );
 
-        expect(config.env.ENV1).toEqual(
+        expect(config).toEqual(
           expect.not.objectContaining({
             kv_namespaces: { bindings: expect.anything },
           })
@@ -1743,10 +2801,11 @@ describe("normalizeAndValidateConfig()", () => {
       it("should error if r2_buckets is an object", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { env: { ENV1: { r2_buckets: {} } } } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: "ENV1" }
         );
 
-        expect(config.env.ENV1).toEqual(
+        expect(config).toEqual(
           expect.not.objectContaining({ r2_buckets: expect.anything })
         );
         expect(diagnostics.hasWarnings()).toBe(false);
@@ -1761,10 +2820,11 @@ describe("normalizeAndValidateConfig()", () => {
       it("should error if r2_buckets is a string", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { env: { ENV1: { r2_buckets: "BAD" } } } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: "ENV1" }
         );
 
-        expect(config.env.ENV1).toEqual(
+        expect(config).toEqual(
           expect.not.objectContaining({ r2_buckets: expect.anything })
         );
         expect(diagnostics.hasWarnings()).toBe(false);
@@ -1779,10 +2839,11 @@ describe("normalizeAndValidateConfig()", () => {
       it("should error if r2_buckets is a number", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { env: { ENV1: { r2_buckets: 999 } } } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: "ENV1" }
         );
 
-        expect(config.env.ENV1).toEqual(
+        expect(config).toEqual(
           expect.not.objectContaining({ r2_buckets: expect.anything })
         );
         expect(diagnostics.hasWarnings()).toBe(false);
@@ -1797,10 +2858,11 @@ describe("normalizeAndValidateConfig()", () => {
       it("should error if r2_buckets is null", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { env: { ENV1: { r2_buckets: null } } } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: "ENV1" }
         );
 
-        expect(config.env.ENV1).toEqual(
+        expect(config).toEqual(
           expect.not.objectContaining({ r2_buckets: expect.anything })
         );
         expect(diagnostics.hasWarnings()).toBe(false);
@@ -1830,10 +2892,11 @@ describe("normalizeAndValidateConfig()", () => {
               },
             },
           } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: "ENV1" }
         );
 
-        expect(config.env.ENV1).toEqual(
+        expect(config).toEqual(
           expect.not.objectContaining({
             r2_buckets: { bindings: expect.anything },
           })
@@ -1857,10 +2920,11 @@ describe("normalizeAndValidateConfig()", () => {
       it("should error if unsafe is an array", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { env: { ENV1: { unsafe: [] } } } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: "ENV1" }
         );
 
-        expect(config.env.ENV1).toEqual(
+        expect(config).toEqual(
           expect.not.objectContaining({ unsafe: expect.anything })
         );
         expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
@@ -1880,10 +2944,11 @@ describe("normalizeAndValidateConfig()", () => {
       it("should error if unsafe is a string", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { env: { ENV1: { unsafe: "BAD" } } } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: "ENV1" }
         );
 
-        expect(config.env.ENV1).toEqual(
+        expect(config).toEqual(
           expect.not.objectContaining({ unsafe: expect.anything })
         );
         expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
@@ -1903,10 +2968,11 @@ describe("normalizeAndValidateConfig()", () => {
       it("should error if unsafe is a number", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { env: { ENV1: { unsafe: 999 } } } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: "ENV1" }
         );
 
-        expect(config.env.ENV1).toEqual(
+        expect(config).toEqual(
           expect.not.objectContaining({ unsafe: expect.anything })
         );
         expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
@@ -1926,10 +2992,11 @@ describe("normalizeAndValidateConfig()", () => {
       it("should error if unsafe is null", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { env: { ENV1: { unsafe: null } } } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: "ENV1" }
         );
 
-        expect(config.env.ENV1).toEqual(
+        expect(config).toEqual(
           expect.not.objectContaining({ unsafe: expect.anything })
         );
         expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
@@ -1949,10 +3016,11 @@ describe("normalizeAndValidateConfig()", () => {
       it("should error if unsafe.bindings is not defined", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { env: { ENV1: { unsafe: {} } } } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: "ENV1" }
         );
 
-        expect(config.env.ENV1).toEqual(
+        expect(config).toEqual(
           expect.not.objectContaining({ unsafe: expect.anything })
         );
         expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
@@ -1974,10 +3042,11 @@ describe("normalizeAndValidateConfig()", () => {
           {
             env: { ENV1: { unsafe: { bindings: {} } } },
           } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: "ENV1" }
         );
 
-        expect(config.env.ENV1).toEqual(
+        expect(config).toEqual(
           expect.not.objectContaining({
             unsafe: { bindings: expect.anything },
           })
@@ -2001,10 +3070,11 @@ describe("normalizeAndValidateConfig()", () => {
           {
             env: { ENV1: { unsafe: { bindings: "BAD" } } },
           } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: "ENV1" }
         );
 
-        expect(config.env.ENV1).toEqual(
+        expect(config).toEqual(
           expect.not.objectContaining({
             unsafe: { bindings: expect.anything },
           })
@@ -2028,10 +3098,11 @@ describe("normalizeAndValidateConfig()", () => {
           {
             env: { ENV1: { unsafe: { bindings: 999 } } },
           } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: "ENV1" }
         );
 
-        expect(config.env.ENV1).toEqual(
+        expect(config).toEqual(
           expect.not.objectContaining({
             unsafe: { bindings: expect.anything },
           })
@@ -2055,10 +3126,11 @@ describe("normalizeAndValidateConfig()", () => {
           {
             env: { ENV1: { unsafe: { bindings: null } } },
           } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: "ENV1" }
         );
 
-        expect(config.env.ENV1).toEqual(
+        expect(config).toEqual(
           expect.not.objectContaining({
             unsafe: { bindings: expect.anything },
           })
@@ -2097,10 +3169,11 @@ describe("normalizeAndValidateConfig()", () => {
               },
             },
           } as unknown as RawConfig,
-          undefined
+          undefined,
+          { env: "ENV1" }
         );
 
-        expect(config.env.ENV1).toEqual(
+        expect(config).toEqual(
           expect.not.objectContaining({
             durable_objects: { bindings: expect.anything },
           })
@@ -2117,15 +3190,15 @@ describe("normalizeAndValidateConfig()", () => {
             - \\"env.ENV1\\" environment configuration
 
               - \\"env.ENV1.unsafe.bindings[0]\\": {}
-                - ERROR: should have a string \\"name\\" field.
-                - ERROR: should have a string \\"type\\" field.
+                - binding should have a string \\"name\\" field.
+                - binding should have a string \\"type\\" field.
 
               - \\"env.ENV1.unsafe.bindings[1]\\": {\\"name\\":\\"UNSAFE_BINDING_1\\"}
-                - ERROR: should have a string \\"type\\" field.
+                - binding should have a string \\"type\\" field.
 
               - \\"env.ENV1.unsafe.bindings[2]\\": {\\"name\\":2666,\\"type\\":2777}
-                - ERROR: should have a string \\"name\\" field.
-                - ERROR: should have a string \\"type\\" field."
+                - binding should have a string \\"name\\" field.
+                - binding should have a string \\"type\\" field."
         `);
       });
     });
@@ -2136,7 +3209,7 @@ describe("normalizeAndValidateConfig()", () => {
           zone_id: "ZONE_ID",
           experimental_services: [
             {
-              name: "NAME",
+              name: "mock-name",
               service: "SERVICE",
               environment: "ENV",
             },
@@ -2149,31 +3222,260 @@ describe("normalizeAndValidateConfig()", () => {
               ENV1: environment,
             },
           },
-          undefined
+          undefined,
+          { env: "ENV1" }
         );
 
-        expect("experimental_services" in config.env.ENV1).toBe(false);
+        expect("experimental_services" in config).toBe(false);
         // Zone is not removed yet, since `route` commands might use it
-        expect(config.env.ENV1.zone_id).toEqual("ZONE_ID");
+        expect(config.zone_id).toEqual("ZONE_ID");
         expect(diagnostics.hasErrors()).toBe(false);
         expect(diagnostics.hasWarnings()).toBe(true);
         expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
           "Processing wrangler configuration:
 
             - \\"env.ENV1\\" environment configuration
-              - DEPRECATION: \\"zone_id\\":
+              - Deprecation: \\"zone_id\\":
                 This is unnecessary since we can deduce this from routes directly.
-              - DEPRECATION: \\"experimental_services\\":
-                The \\"experimental_services\\" field is no longer supported. Instead, use [[unsafe.bindings]] to enable experimental features. Add this to your wrangler.toml:
-                \`\`\`
-                [[unsafe.bindings]]
-                name = \\"NAME\\"
-                type = \\"service\\"
-                service = \\"SERVICE\\"
-                environment = \\"ENV\\"
-                \`\`\`"
+              - Deprecation: \\"experimental_services\\":
+                The \\"experimental_services\\" field is no longer supported. Simply rename the [experimental_services] field to [services]."
+        `);
+      });
+    });
+
+    describe("route & routes fields", () => {
+      it("should error if both route and routes are specified in the same environment", () => {
+        const environment: RawEnvironment = {
+          name: "mock-env-name",
+          account_id: "ENV_ACCOUNT_ID",
+          compatibility_date: "2022-02-02",
+          compatibility_flags: ["ENV_FLAG1", "ENV_FLAG2"],
+          workers_dev: true,
+          route: "ENV_ROUTE_1",
+          routes: ["ENV_ROUTE_2", "ENV_ROUTE_3"],
+          jsx_factory: "ENV_JSX_FACTORY",
+          jsx_fragment: "ENV_JSX_FRAGMENT",
+          triggers: { crons: ["ENV_CRON_1", "ENV_CRON_2"] },
+          usage_model: "unbound",
+        };
+        const expectedConfig: RawConfig = {
+          name: "mock-name",
+          account_id: "ACCOUNT_ID",
+          compatibility_date: "2022-01-01",
+          compatibility_flags: ["FLAG1", "FLAG2"],
+          workers_dev: false,
+          routes: ["ROUTE_1", "ROUTE_2"],
+          jsx_factory: "JSX_FACTORY",
+          jsx_fragment: "JSX_FRAGMENT",
+          triggers: { crons: ["CRON_1", "CRON_2"] },
+          usage_model: "bundled",
+          env: {
+            ENV1: environment,
+          },
+        };
+
+        const { config, diagnostics } = normalizeAndValidateConfig(
+          expectedConfig,
+          undefined,
+          { env: "ENV1" }
+        );
+
+        expect(config).toEqual(expect.objectContaining(environment));
+        expect(diagnostics.hasErrors()).toBe(true);
+        expect(diagnostics.hasWarnings()).toBe(false);
+
+        expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+          "Processing wrangler configuration:
+
+            - \\"env.ENV1\\" environment configuration
+              - Expected exactly one of the following fields [\\"routes\\",\\"route\\"]."
+        `);
+      });
+
+      it("should error if both route and routes are specified in the top-level environment", () => {
+        const environment: RawEnvironment = {
+          name: "mock-env-name",
+          account_id: "ENV_ACCOUNT_ID",
+          compatibility_date: "2022-02-02",
+          compatibility_flags: ["ENV_FLAG1", "ENV_FLAG2"],
+          workers_dev: true,
+          routes: ["ENV_ROUTE_1", "ENV_ROUTE_2"],
+          jsx_factory: "ENV_JSX_FACTORY",
+          jsx_fragment: "ENV_JSX_FRAGMENT",
+          triggers: { crons: ["ENV_CRON_1", "ENV_CRON_2"] },
+          usage_model: "unbound",
+        };
+        const expectedConfig: RawConfig = {
+          name: "mock-name",
+          account_id: "ACCOUNT_ID",
+          compatibility_date: "2022-01-01",
+          compatibility_flags: ["FLAG1", "FLAG2"],
+          workers_dev: false,
+          route: "ROUTE_1",
+          routes: ["ROUTE_2", "ROUTE_3"],
+          jsx_factory: "JSX_FACTORY",
+          jsx_fragment: "JSX_FRAGMENT",
+          triggers: { crons: ["CRON_1", "CRON_2"] },
+          usage_model: "bundled",
+          env: {
+            ENV1: environment,
+          },
+        };
+
+        const { config, diagnostics } = normalizeAndValidateConfig(
+          expectedConfig,
+          undefined,
+          { env: "ENV1" }
+        );
+
+        expect(config).toEqual(expect.objectContaining(environment));
+        expect(diagnostics.hasErrors()).toBe(true);
+        expect(diagnostics.hasWarnings()).toBe(false);
+
+        expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+          "Processing wrangler configuration:
+            - Expected exactly one of the following fields [\\"routes\\",\\"route\\"]."
         `);
       });
+
+      it("should not error if <env>.route and <top-level>.routes are specified", () => {
+        const environment: RawEnvironment = {
+          name: "mock-env-name",
+          account_id: "ENV_ACCOUNT_ID",
+          compatibility_date: "2022-02-02",
+          compatibility_flags: ["ENV_FLAG1", "ENV_FLAG2"],
+          workers_dev: true,
+          route: "ENV_ROUTE_1",
+          jsx_factory: "ENV_JSX_FACTORY",
+          jsx_fragment: "ENV_JSX_FRAGMENT",
+          triggers: { crons: ["ENV_CRON_1", "ENV_CRON_2"] },
+          usage_model: "unbound",
+        };
+        const expectedConfig: RawConfig = {
+          name: "mock-name",
+          account_id: "ACCOUNT_ID",
+          compatibility_date: "2022-01-01",
+          compatibility_flags: ["FLAG1", "FLAG2"],
+          workers_dev: false,
+          routes: ["ROUTE_1", "ROUTE_2"],
+          jsx_factory: "JSX_FACTORY",
+          jsx_fragment: "JSX_FRAGMENT",
+          triggers: { crons: ["CRON_1", "CRON_2"] },
+          usage_model: "bundled",
+          env: {
+            ENV1: environment,
+          },
+        };
+
+        const { config, diagnostics } = normalizeAndValidateConfig(
+          expectedConfig,
+          undefined,
+          { env: "ENV1" }
+        );
+
+        expect(config).toEqual(expect.objectContaining(environment));
+        expect(diagnostics.hasErrors()).toBe(false);
+        expect(diagnostics.hasWarnings()).toBe(false);
+      });
+
+      it("should not error if <env>.routes and <top-level>.route are specified", () => {
+        const environment: RawEnvironment = {
+          name: "mock-env-name",
+          account_id: "ENV_ACCOUNT_ID",
+          compatibility_date: "2022-02-02",
+          compatibility_flags: ["ENV_FLAG1", "ENV_FLAG2"],
+          workers_dev: true,
+          routes: ["ENV_ROUTE_1", "ENV_ROUTE_2"],
+          jsx_factory: "ENV_JSX_FACTORY",
+          jsx_fragment: "ENV_JSX_FRAGMENT",
+          triggers: { crons: ["ENV_CRON_1", "ENV_CRON_2"] },
+          usage_model: "unbound",
+        };
+        const expectedConfig: RawConfig = {
+          name: "mock-name",
+          account_id: "ACCOUNT_ID",
+          compatibility_date: "2022-01-01",
+          compatibility_flags: ["FLAG1", "FLAG2"],
+          workers_dev: false,
+          route: "ROUTE_1",
+          jsx_factory: "JSX_FACTORY",
+          jsx_fragment: "JSX_FRAGMENT",
+          triggers: { crons: ["CRON_1", "CRON_2"] },
+          usage_model: "bundled",
+          env: {
+            ENV1: environment,
+          },
+        };
+
+        const { config, diagnostics } = normalizeAndValidateConfig(
+          expectedConfig,
+          undefined,
+          { env: "ENV1" }
+        );
+
+        expect(config).toEqual(expect.objectContaining(environment));
+        expect(diagnostics.hasErrors()).toBe(false);
+        expect(diagnostics.hasWarnings()).toBe(false);
+      });
+
+      it("should not error if <env1>.route and <env2>.routes are specified", () => {
+        const environment1: RawEnvironment = {
+          name: "mock-env-name",
+          account_id: "ENV_ACCOUNT_ID",
+          compatibility_date: "2022-02-02",
+          compatibility_flags: ["ENV_FLAG1", "ENV_FLAG2"],
+          workers_dev: true,
+          routes: ["ENV1_ROUTE_1", "ENV2_ROUTE_2"],
+          jsx_factory: "ENV_JSX_FACTORY",
+          jsx_fragment: "ENV_JSX_FRAGMENT",
+          triggers: { crons: ["ENV_CRON_1", "ENV_CRON_2"] },
+          usage_model: "unbound",
+        };
+        const environment2: RawEnvironment = {
+          name: "mock-env-name",
+          account_id: "ENV_ACCOUNT_ID",
+          compatibility_date: "2022-02-02",
+          compatibility_flags: ["ENV_FLAG1", "ENV_FLAG2"],
+          workers_dev: true,
+          route: "ENV2_ROUTE_1",
+          jsx_factory: "ENV_JSX_FACTORY",
+          jsx_fragment: "ENV_JSX_FRAGMENT",
+          triggers: { crons: ["ENV_CRON_1", "ENV_CRON_2"] },
+          usage_model: "unbound",
+        };
+        const expectedConfig: RawConfig = {
+          name: "mock-name",
+          account_id: "ACCOUNT_ID",
+          compatibility_date: "2022-01-01",
+          compatibility_flags: ["FLAG1", "FLAG2"],
+          workers_dev: false,
+          route: "ROUTE_1",
+          jsx_factory: "JSX_FACTORY",
+          jsx_fragment: "JSX_FRAGMENT",
+          triggers: { crons: ["CRON_1", "CRON_2"] },
+          usage_model: "bundled",
+          env: {
+            ENV1: environment1,
+            ENV2: environment2,
+          },
+        };
+
+        const result1 = normalizeAndValidateConfig(expectedConfig, undefined, {
+          env: "ENV1",
+        });
+
+        expect(result1.config).toEqual(expect.objectContaining(environment1));
+        expect(result1.diagnostics.hasErrors()).toBe(false);
+        expect(result1.diagnostics.hasWarnings()).toBe(false);
+
+        const result2 = normalizeAndValidateConfig(expectedConfig, undefined, {
+          env: "ENV2",
+        });
+
+        expect(result2.config).toEqual(expect.objectContaining(environment2));
+        expect(result2.diagnostics.hasErrors()).toBe(false);
+        expect(result2.diagnostics.hasWarnings()).toBe(false);
+      });
     });
   });
 });