wrangler 0.0.0-e29a241 → 0.0.0-e2f9bb2

package/src/__tests__/configuration.test.ts

@@ -1,14 +1,18 @@
 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,
-      undefined
-    );
+    const { config, diagnostics } = normalizeAndValidateConfig({}, undefined, {
+      env: undefined,
+    });
 
     expect(config).toEqual({
       account_id: undefined,
@@ -32,6 +36,7 @@ describe("normalizeAndValidateConfig()", () => {
       },
       jsx_factory: "React.createElement",
       jsx_fragment: "React.Fragment",
+      tsconfig: undefined,
       kv_namespaces: [],
       legacy_env: true,
       main: undefined,
@@ -52,7 +57,8 @@ describe("normalizeAndValidateConfig()", () => {
       usage_model: undefined,
       vars: {},
       wasm_modules: undefined,
-      workers_dev: true,
+      data_blobs: undefined,
+      workers_dev: undefined,
       zone_id: undefined,
     });
     expect(diagnostics.hasErrors()).toBe(false);
@@ -61,9 +67,7 @@ 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",
@@ -71,30 +75,21 @@ describe("normalizeAndValidateConfig()", () => {
           local_protocol: "https",
           upstream_protocol: "http",
         },
-        build: {
-          command: "COMMAND",
-          cwd: "CWD",
-          watch_dir: "WATCH_DIR",
-        },
       };
 
       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,
@@ -102,17 +97,12 @@ describe("normalizeAndValidateConfig()", () => {
           local_protocol: "wss",
           upstream_protocol: "ws",
         },
-        build: {
-          command: 555,
-          cwd: 666,
-          watch_dir: 777,
-        },
       };
 
       const { config, diagnostics } = normalizeAndValidateConfig(
         expectedConfig as unknown as RawConfig,
         undefined,
-        undefined
+        { env: undefined }
       );
 
       expect(config).toEqual(
@@ -121,11 +111,7 @@ describe("normalizeAndValidateConfig()", () => {
       expect(diagnostics.hasWarnings()).toBe(false);
       expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
         "Processing wrangler configuration:
-          - Expected \\"build.command\\" to be of type string but got 555.
-          - Expected \\"build.cwd\\" to be of type string but got 666.
-          - Expected \\"build.watch_dir\\" to be of type string but got 777.
           - Expected \\"legacy_env\\" to be of type boolean but got \\"FOO\\".
-          - Expected \\"main\\" to be of type string but got 111.
           - 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\\".
@@ -143,7 +129,7 @@ describe("normalizeAndValidateConfig()", () => {
       const { config, diagnostics } = normalizeAndValidateConfig(
         expectedConfig as unknown as RawConfig,
         undefined,
-        undefined
+        { env: undefined }
       );
 
       expect("unexpected" in config).toBe(false);
@@ -154,7 +140,7 @@ describe("normalizeAndValidateConfig()", () => {
       `);
     });
 
-    it("should ignore `miniflare` top level fields", () => {
+    it("should report a deprecation warning if `miniflare` appears at the top level", () => {
       const expectedConfig = {
         miniflare: {
           host: "localhost",
@@ -164,111 +150,18 @@ describe("normalizeAndValidateConfig()", () => {
       const { config, diagnostics } = normalizeAndValidateConfig(
         expectedConfig as unknown as RawConfig,
         undefined,
-        undefined
+        { env: undefined }
       );
 
       expect("miniflare" in config).toBe(false);
       expect(diagnostics.hasErrors()).toBe(false);
       expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
         "Processing wrangler configuration:
-        "
-      `);
-    });
-
-    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 }],
-          },
-        },
-      };
-
-      const { config, diagnostics } = normalizeAndValidateConfig(
-        expectedConfig,
-        path.resolve("project/wrangler.toml"),
-        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
-            \`\`\`"
+          - 😶 Ignored: \\"miniflare\\":
+            Wrangler does not use configuration in the \`miniflare\` section. Unless you are using Miniflare directly you can remove this section."
       `);
     });
 
-    it("should default custom build watch directories to src", () => {
-      const expectedConfig: RawConfig = {
-        build: {
-          command: "execute some --build",
-        },
-      };
-
-      const { config, diagnostics } = normalizeAndValidateConfig(
-        expectedConfig,
-        undefined,
-        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: RawConfig = {
-        build: {
-          command: "execute some --build",
-          watch_dir: "some/path",
-        },
-      };
-
-      const { config, diagnostics } = normalizeAndValidateConfig(
-        expectedConfig,
-        "project/wrangler.toml",
-        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 override `migrations` config defaults with provided values", () => {
       const expectedConfig: RawConfig = {
         migrations: [
@@ -289,7 +182,7 @@ describe("normalizeAndValidateConfig()", () => {
       const { config, diagnostics } = normalizeAndValidateConfig(
         expectedConfig,
         undefined,
-        undefined
+        { env: undefined }
       );
 
       expect(config).toEqual(expect.objectContaining(expectedConfig));
@@ -317,7 +210,7 @@ describe("normalizeAndValidateConfig()", () => {
       const { config, diagnostics } = normalizeAndValidateConfig(
         expectedConfig as unknown as RawConfig,
         undefined,
-        undefined
+        { env: undefined }
       );
 
       expect(config).toEqual(expect.objectContaining(expectedConfig));
@@ -338,26 +231,38 @@ describe("normalizeAndValidateConfig()", () => {
         const expectedConfig: RawConfig = {
           site: {
             bucket: "BUCKET",
-            include: ["INCLUDE_1", "INCLUDE_2"],
+            "entry-point": "my-site",
             exclude: ["EXCLUDE_1", "EXCLUDE_2"],
+            include: ["INCLUDE_1", "INCLUDE_2"],
           },
         };
 
         const { config, diagnostics } = normalizeAndValidateConfig(
           expectedConfig,
           undefined,
-          undefined
+          { env: undefined }
         );
 
         expect(config).toEqual(expect.objectContaining(expectedConfig));
         expect(diagnostics.hasErrors()).toBe(false);
-        expect(diagnostics.hasWarnings()).toBe(false);
+        expect(diagnostics.hasWarnings()).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 = \\"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"],
           },
@@ -366,22 +271,34 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           expectedConfig,
           undefined,
-          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."
         `);
-        expect(diagnostics.hasWarnings()).toBe(false);
       });
 
       it("should error on invalid `site` values", () => {
         const expectedConfig = {
           site: {
             bucket: "BUCKET",
+            "entry-point": 111,
             include: [222, 333],
             exclude: [444, 555],
           },
@@ -390,21 +307,32 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           expectedConfig as unknown as RawConfig,
           undefined,
-          undefined
+          { env: undefined }
         );
 
         expect(config).toEqual(expect.objectContaining(expectedConfig));
-        expect(diagnostics.hasWarnings()).toBe(false);
+        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 \\"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 error with a deprecation warning if entry-point is defined", async () => {
+      it("should log a deprecation warning if entry-point is defined", async () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           {
             site: {
@@ -413,27 +341,28 @@ describe("normalizeAndValidateConfig()", () => {
             },
           } as unknown as RawConfig,
           undefined,
-          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(true);
-        expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
-          "Processing wrangler configuration:
-            - Unexpected fields found in site field: \\"entry-point\\""
-        `);
-        expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+        expect(diagnostics.hasErrors()).toBe(false);
+
+        expect(normalizeSlashes(diagnostics.renderWarnings()))
+          .toMatchInlineSnapshot(`
           "Processing wrangler configuration:
-            - DEPRECATION: \\"site.entry-point\\":
-              The \`site.entry-point\` config field is no longer used.
-              The entry-point should be specified via the command line or the \`main\` config field."
+            - 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\\"
+              \`\`\`"
         `);
       });
     });
@@ -449,7 +378,7 @@ describe("normalizeAndValidateConfig()", () => {
       const { config, diagnostics } = normalizeAndValidateConfig(
         expectedConfig,
         "project/wrangler.toml",
-        undefined
+        { env: undefined }
       );
 
       expect(config).toEqual(
@@ -464,7 +393,7 @@ describe("normalizeAndValidateConfig()", () => {
       expect(diagnostics.hasWarnings()).toBe(false);
     });
 
-    it("should error on invalid `wasm_module` paths", () => {
+    it("should error on invalid `wasm_modules` paths", () => {
       const expectedConfig = {
         wasm_modules: {
           MODULE_1: 111,
@@ -475,7 +404,7 @@ describe("normalizeAndValidateConfig()", () => {
       const { config, diagnostics } = normalizeAndValidateConfig(
         expectedConfig as unknown as RawConfig,
         "project/wrangler.toml",
-        undefined
+        { env: undefined }
       );
 
       expect(config).toEqual(
@@ -502,7 +431,7 @@ describe("normalizeAndValidateConfig()", () => {
       const { config, diagnostics } = normalizeAndValidateConfig(
         expectedConfig,
         "project/wrangler.toml",
-        undefined
+        { env: undefined }
       );
 
       expect(config).toEqual(
@@ -528,7 +457,7 @@ describe("normalizeAndValidateConfig()", () => {
       const { config, diagnostics } = normalizeAndValidateConfig(
         expectedConfig as unknown as RawConfig,
         "project/wrangler.toml",
-        undefined
+        { env: undefined }
       );
 
       expect(config).toEqual(
@@ -544,6 +473,80 @@ describe("normalizeAndValidateConfig()", () => {
       `);
     });
 
+    it("should map `data_blobs` paths from relative to the config path to relative to the cwd", () => {
+      const expectedConfig: RawConfig = {
+        data_blobs: {
+          BLOB_1: "path/to/data1.bin",
+          BLOB_2: "data2.bin",
+        },
+      };
+
+      const { config, diagnostics } = normalizeAndValidateConfig(
+        expectedConfig,
+        "project/wrangler.toml",
+        { env: undefined }
+      );
+
+      expect(config).toEqual(
+        expect.objectContaining({
+          data_blobs: {
+            BLOB_1: path.normalize("project/path/to/data1.bin"),
+            BLOB_2: path.normalize("project/data2.bin"),
+          },
+        })
+      );
+      expect(diagnostics.hasErrors()).toBe(false);
+      expect(diagnostics.hasWarnings()).toBe(false);
+    });
+
+    it("should error on invalid `data_blob` paths", () => {
+      const expectedConfig = {
+        data_blobs: {
+          MODULE_1: 111,
+          MODULE_2: 222,
+        },
+      };
+
+      const { config, diagnostics } = normalizeAndValidateConfig(
+        expectedConfig as unknown as RawConfig,
+        "project/wrangler.toml",
+        { env: undefined }
+      );
+
+      expect(config).toEqual(
+        expect.objectContaining({
+          data_blobs: {},
+        })
+      );
+      expect(diagnostics.hasWarnings()).toBe(false);
+      expect(normalizePath(diagnostics.renderErrors())).toMatchInlineSnapshot(`
+        "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)", () => {
       it("should remove and warn about deprecated properties", () => {
         const rawConfig: RawConfig = {
@@ -554,7 +557,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           rawConfig,
           undefined,
-          undefined
+          { env: undefined }
         );
 
         // Note the `.not.` here...
@@ -567,29 +570,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",
+      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"],
+        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",
@@ -635,10 +653,12 @@ describe("normalizeAndValidateConfig()", () => {
       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:
@@ -647,50 +667,283 @@ describe("normalizeAndValidateConfig()", () => {
     });
 
     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,
+        },
+      } 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\\" to be of type string but got 888.
-          - Expected \\"routes\\" to be of type string array but got [666,777].
+          - Expected \\"route\\" to be either a string, or an object with shape { pattern, zone_id | zone_name }, but got 888.
+          - Expected \\"routes\\" to be an array of either strings or objects with the shape { pattern, 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 \\"name\\" to be of type string but got 111.
+          - 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\\"."
       `);
     });
 
+    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 \\"!@#$%^&*(()\\"."
+      `);
+    });
+
+    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);
+    });
+
     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(
@@ -707,7 +960,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { durable_objects: "BAD" } as unknown as RawConfig,
           undefined,
-          undefined
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -724,7 +977,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { durable_objects: 999 } as unknown as RawConfig,
           undefined,
-          undefined
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -741,7 +994,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { durable_objects: null } as unknown as RawConfig,
           undefined,
-          undefined
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -758,7 +1011,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { durable_objects: {} } as unknown as RawConfig,
           undefined,
-          undefined
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -775,7 +1028,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { durable_objects: { bindings: {} } } as unknown as RawConfig,
           undefined,
-          undefined
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -794,7 +1047,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { durable_objects: { bindings: "BAD" } } as unknown as RawConfig,
           undefined,
-          undefined
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -813,7 +1066,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { durable_objects: { bindings: 999 } } as unknown as RawConfig,
           undefined,
-          undefined
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -832,7 +1085,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { durable_objects: { bindings: null } } as unknown as RawConfig,
           undefined,
-          undefined
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -864,7 +1117,7 @@ describe("normalizeAndValidateConfig()", () => {
             },
           } as unknown as RawConfig,
           undefined,
-          undefined
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -900,7 +1153,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { kv_namespaces: {} } as unknown as RawConfig,
           undefined,
-          undefined
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -917,7 +1170,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { kv_namespaces: "BAD" } as unknown as RawConfig,
           undefined,
-          undefined
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -934,7 +1187,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { kv_namespaces: 999 } as unknown as RawConfig,
           undefined,
-          undefined
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -951,7 +1204,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { kv_namespaces: null } as unknown as RawConfig,
           undefined,
-          undefined
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -979,7 +1232,7 @@ describe("normalizeAndValidateConfig()", () => {
             ],
           } as unknown as RawConfig,
           undefined,
-          undefined
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -1005,7 +1258,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { r2_buckets: {} } as unknown as RawConfig,
           undefined,
-          undefined
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -1022,7 +1275,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { r2_buckets: "BAD" } as unknown as RawConfig,
           undefined,
-          undefined
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -1039,7 +1292,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { r2_buckets: 999 } as unknown as RawConfig,
           undefined,
-          undefined
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -1056,7 +1309,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { r2_buckets: null } as unknown as RawConfig,
           undefined,
-          undefined
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -1084,7 +1337,7 @@ describe("normalizeAndValidateConfig()", () => {
             ],
           } as unknown as RawConfig,
           undefined,
-          undefined
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -1110,7 +1363,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { unsafe: [] } as unknown as RawConfig,
           undefined,
-          undefined
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -1130,7 +1383,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { unsafe: "BAD" } as unknown as RawConfig,
           undefined,
-          undefined
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -1150,7 +1403,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { unsafe: 999 } as unknown as RawConfig,
           undefined,
-          undefined
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -1170,7 +1423,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { unsafe: null } as unknown as RawConfig,
           undefined,
-          undefined
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -1190,7 +1443,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { unsafe: {} } as unknown as RawConfig,
           undefined,
-          undefined
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -1210,7 +1463,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { unsafe: { bindings: {} } } as unknown as RawConfig,
           undefined,
-          undefined
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -1232,7 +1485,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { unsafe: { bindings: "BAD" } } as unknown as RawConfig,
           undefined,
-          undefined
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -1254,7 +1507,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { unsafe: { bindings: 999 } } as unknown as RawConfig,
           undefined,
-          undefined
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -1276,7 +1529,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { unsafe: { bindings: null } } as unknown as RawConfig,
           undefined,
-          undefined
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -1311,7 +1564,7 @@ describe("normalizeAndValidateConfig()", () => {
             },
           } as unknown as RawConfig,
           undefined,
-          undefined
+          { env: undefined }
         );
 
         expect(config).toEqual(
@@ -1346,7 +1599,7 @@ describe("normalizeAndValidateConfig()", () => {
           zone_id: "ZONE_ID",
           experimental_services: [
             {
-              name: "NAME",
+              name: "mock-name",
               service: "SERVICE",
               environment: "ENV",
             },
@@ -1356,7 +1609,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           rawConfig,
           undefined,
-          undefined
+          { env: undefined }
         );
 
         expect("experimental_services" in config).toBe(false);
@@ -1365,19 +1618,19 @@ 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. Instead, use [[unsafe.bindings]] to enable experimental features. Add this to your wrangler.toml:
+              \`\`\`
+              [[unsafe.bindings]]
+              name = \\"mock-name\\"
+              type = \\"service\\"
+              service = \\"SERVICE\\"
+              environment = \\"ENV\\"
+              \`\`\`"
+        `);
       });
     });
 
@@ -1391,7 +1644,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { diagnostics } = normalizeAndValidateConfig(
           rawConfig,
           undefined,
-          undefined
+          { env: undefined }
         );
 
         expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
@@ -1405,11 +1658,9 @@ describe("normalizeAndValidateConfig()", () => {
   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,
-        "DEV"
-      );
+      const { diagnostics } = normalizeAndValidateConfig(rawConfig, undefined, {
+        env: "DEV",
+      });
       expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
         "Processing wrangler configuration:
         "
@@ -1427,13 +1678,11 @@ describe("normalizeAndValidateConfig()", () => {
       `);
     });
 
-    it("should warn if we specify an environment that does not match the named environments", () => {
+    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,
-        "DEV"
-      );
+      const { diagnostics } = normalizeAndValidateConfig(rawConfig, undefined, {
+        env: "DEV",
+      });
       expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
         "Processing wrangler configuration:
           - No environment found in configuration with name \\"DEV\\".
@@ -1453,8 +1702,10 @@ describe("normalizeAndValidateConfig()", () => {
     });
 
     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"],
@@ -1462,24 +1713,39 @@ describe("normalizeAndValidateConfig()", () => {
         routes: ["ROUTE_1", "ROUTE_2"],
         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",
+        },
       };
 
       const { config, diagnostics } = normalizeAndValidateConfig(
-        { ...expectedConfig, env: { DEV: {} } },
+        { ...rawConfig, env: { dev: {} } },
         undefined,
-        "DEV"
+        { env: "dev" }
       );
 
-      expect(config).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"],
@@ -1487,11 +1753,18 @@ describe("normalizeAndValidateConfig()", () => {
         routes: ["ENV_ROUTE_1", "ENV_ROUTE_2"],
         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",
+        },
       };
-      const expectedConfig: RawConfig = {
-        name: "NAME",
+      const rawConfig: RawConfig = {
+        name: "mock-name",
         account_id: "ACCOUNT_ID",
         compatibility_date: "2022-01-01",
         compatibility_flags: ["FLAG1", "FLAG2"],
@@ -1499,20 +1772,29 @@ describe("normalizeAndValidateConfig()", () => {
         routes: ["ROUTE_1", "ROUTE_2"],
         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",
+        },
         env: {
-          ENV1: environment,
+          ENV1: rawEnv,
         },
       };
 
       const { config, diagnostics } = normalizeAndValidateConfig(
-        expectedConfig,
+        rawConfig,
         undefined,
-        "ENV1"
+        { env: "ENV1" }
       );
 
-      expect(config).toEqual(expect.objectContaining(environment));
+      expect(config).toEqual(
+        expect.objectContaining({ ...rawEnv, main: resolvedMain })
+      );
       expect(diagnostics.hasErrors()).toBe(false);
       expect(diagnostics.hasWarnings()).toBe(false);
     });
@@ -1520,7 +1802,7 @@ describe("normalizeAndValidateConfig()", () => {
     describe("non-legacy", () => {
       it("should use top-level `name` field", () => {
         const rawConfig: RawConfig = {
-          name: "NAME",
+          name: "mock-name",
           legacy_env: false,
           env: { DEV: {} },
         };
@@ -1528,12 +1810,16 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           rawConfig,
           undefined,
-          "DEV"
+          { env: "DEV" }
         );
 
-        expect(config.name).toEqual("NAME");
+        expect(config.name).toEqual("mock-name");
         expect(diagnostics.hasErrors()).toBe(false);
-        expect(diagnostics.hasWarnings()).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", () => {
@@ -1541,7 +1827,7 @@ describe("normalizeAndValidateConfig()", () => {
           legacy_env: false,
           env: {
             DEV: {
-              name: "ENV_NAME",
+              name: "mock-env-name",
             },
           },
         };
@@ -1549,10 +1835,16 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           rawConfig,
           undefined,
-          "DEV"
+          { 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:
 
@@ -1560,16 +1852,15 @@ describe("normalizeAndValidateConfig()", () => {
               - The \\"name\\" field is not allowed in named service environments.
                 Please remove the field from this environment."
         `);
-        expect(diagnostics.hasWarnings()).toBe(false);
       });
 
       it("should error if top-level config and a named environment both contain a `name` field", () => {
         const rawConfig: RawConfig = {
-          name: "NAME",
+          name: "mock-name",
           legacy_env: false,
           env: {
             DEV: {
-              name: "ENV_NAME",
+              name: "mock-env-name",
             },
           },
         };
@@ -1577,10 +1868,16 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           rawConfig,
           undefined,
-          "DEV"
+          { env: "DEV" }
         );
 
-        expect(config.name).toEqual("NAME");
+        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:
 
@@ -1588,10 +1885,73 @@ describe("normalizeAndValidateConfig()", () => {
               - The \\"name\\" field is not allowed in named service environments.
                 Please remove the field from this environment."
         `);
-        expect(diagnostics.hasWarnings()).toBe(false);
       });
     });
 
+    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",
@@ -1616,7 +1976,7 @@ describe("normalizeAndValidateConfig()", () => {
       const { config, diagnostics } = normalizeAndValidateConfig(
         rawConfig,
         undefined,
-        "ENV1"
+        { env: "ENV1" }
       );
 
       expect(config).toEqual(
@@ -1662,14 +2022,21 @@ 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,
+        },
       } as unknown as RawEnvironment;
 
       const { config, diagnostics } = normalizeAndValidateConfig(
         { env: { ENV1: expectedConfig } },
         undefined,
-        "ENV1"
+        { env: "ENV1" }
       );
 
       expect(config).toEqual(expect.objectContaining(expectedConfig));
@@ -1678,16 +2045,24 @@ describe("normalizeAndValidateConfig()", () => {
         "Processing wrangler configuration:
 
           - \\"env.ENV1\\" environment configuration
-            - Expected \\"route\\" to be of type string but got 888.
-            - Expected \\"routes\\" to be of type string array but got [666,777].
+            - Expected \\"route\\" to be either a string, or an object with shape { pattern, zone_id | zone_name }, but got 888.
+            - Expected \\"routes\\" to be an array of either strings or objects with the shape { pattern, 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 \\"name\\" to be of type string but got 111.
+            - 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\\"."
       `);
     });
@@ -1697,7 +2072,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { env: { ENV1: { durable_objects: [] } } } as unknown as RawConfig,
           undefined,
-          "ENV1"
+          { env: "ENV1" }
         );
 
         expect(config).toEqual(
@@ -1716,7 +2091,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { env: { ENV1: { durable_objects: "BAD" } } } as unknown as RawConfig,
           undefined,
-          "ENV1"
+          { env: "ENV1" }
         );
 
         expect(config).toEqual(
@@ -1735,7 +2110,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { env: { ENV1: { durable_objects: 999 } } } as unknown as RawConfig,
           undefined,
-          "ENV1"
+          { env: "ENV1" }
         );
 
         expect(config).toEqual(
@@ -1754,7 +2129,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { env: { ENV1: { durable_objects: null } } } as unknown as RawConfig,
           undefined,
-          "ENV1"
+          { env: "ENV1" }
         );
 
         expect(config).toEqual(
@@ -1773,7 +2148,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { env: { ENV1: { durable_objects: {} } } } as unknown as RawConfig,
           undefined,
-          "ENV1"
+          { env: "ENV1" }
         );
 
         expect(config).toEqual(
@@ -1794,7 +2169,7 @@ describe("normalizeAndValidateConfig()", () => {
             env: { ENV1: { durable_objects: { bindings: {} } } },
           } as unknown as RawConfig,
           undefined,
-          "ENV1"
+          { env: "ENV1" }
         );
 
         expect(config).toEqual(
@@ -1817,7 +2192,7 @@ describe("normalizeAndValidateConfig()", () => {
             env: { ENV1: { durable_objects: { bindings: "BAD" } } },
           } as unknown as RawConfig,
           undefined,
-          "ENV1"
+          { env: "ENV1" }
         );
 
         expect(config).toEqual(
@@ -1840,7 +2215,7 @@ describe("normalizeAndValidateConfig()", () => {
             env: { ENV1: { durable_objects: { bindings: 999 } } },
           } as unknown as RawConfig,
           undefined,
-          "ENV1"
+          { env: "ENV1" }
         );
 
         expect(config).toEqual(
@@ -1863,7 +2238,7 @@ describe("normalizeAndValidateConfig()", () => {
             env: { ENV1: { durable_objects: { bindings: null } } },
           } as unknown as RawConfig,
           undefined,
-          "ENV1"
+          { env: "ENV1" }
         );
 
         expect(config).toEqual(
@@ -1901,7 +2276,7 @@ describe("normalizeAndValidateConfig()", () => {
             },
           } as unknown as RawConfig,
           undefined,
-          "ENV1"
+          { env: "ENV1" }
         );
 
         expect(config).toEqual(
@@ -1939,7 +2314,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { env: { ENV1: { kv_namespaces: {} } } } as unknown as RawConfig,
           undefined,
-          "ENV1"
+          { env: "ENV1" }
         );
 
         expect(config).toEqual(
@@ -1958,7 +2333,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { env: { ENV1: { kv_namespaces: "BAD" } } } as unknown as RawConfig,
           undefined,
-          "ENV1"
+          { env: "ENV1" }
         );
 
         expect(config).toEqual(
@@ -1977,7 +2352,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { env: { ENV1: { kv_namespaces: 999 } } } as unknown as RawConfig,
           undefined,
-          "ENV1"
+          { env: "ENV1" }
         );
 
         expect(config).toEqual(
@@ -1996,7 +2371,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { env: { ENV1: { kv_namespaces: null } } } as unknown as RawConfig,
           undefined,
-          "ENV1"
+          { env: "ENV1" }
         );
 
         expect(config).toEqual(
@@ -2030,7 +2405,7 @@ describe("normalizeAndValidateConfig()", () => {
             },
           } as unknown as RawConfig,
           undefined,
-          "ENV1"
+          { env: "ENV1" }
         );
 
         expect(config).toEqual(
@@ -2058,7 +2433,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { env: { ENV1: { r2_buckets: {} } } } as unknown as RawConfig,
           undefined,
-          "ENV1"
+          { env: "ENV1" }
         );
 
         expect(config).toEqual(
@@ -2077,7 +2452,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { env: { ENV1: { r2_buckets: "BAD" } } } as unknown as RawConfig,
           undefined,
-          "ENV1"
+          { env: "ENV1" }
         );
 
         expect(config).toEqual(
@@ -2096,7 +2471,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { env: { ENV1: { r2_buckets: 999 } } } as unknown as RawConfig,
           undefined,
-          "ENV1"
+          { env: "ENV1" }
         );
 
         expect(config).toEqual(
@@ -2115,7 +2490,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { env: { ENV1: { r2_buckets: null } } } as unknown as RawConfig,
           undefined,
-          "ENV1"
+          { env: "ENV1" }
         );
 
         expect(config).toEqual(
@@ -2149,7 +2524,7 @@ describe("normalizeAndValidateConfig()", () => {
             },
           } as unknown as RawConfig,
           undefined,
-          "ENV1"
+          { env: "ENV1" }
         );
 
         expect(config).toEqual(
@@ -2177,7 +2552,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { env: { ENV1: { unsafe: [] } } } as unknown as RawConfig,
           undefined,
-          "ENV1"
+          { env: "ENV1" }
         );
 
         expect(config).toEqual(
@@ -2201,7 +2576,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { env: { ENV1: { unsafe: "BAD" } } } as unknown as RawConfig,
           undefined,
-          "ENV1"
+          { env: "ENV1" }
         );
 
         expect(config).toEqual(
@@ -2225,7 +2600,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { env: { ENV1: { unsafe: 999 } } } as unknown as RawConfig,
           undefined,
-          "ENV1"
+          { env: "ENV1" }
         );
 
         expect(config).toEqual(
@@ -2249,7 +2624,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { env: { ENV1: { unsafe: null } } } as unknown as RawConfig,
           undefined,
-          "ENV1"
+          { env: "ENV1" }
         );
 
         expect(config).toEqual(
@@ -2273,7 +2648,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           { env: { ENV1: { unsafe: {} } } } as unknown as RawConfig,
           undefined,
-          "ENV1"
+          { env: "ENV1" }
         );
 
         expect(config).toEqual(
@@ -2299,7 +2674,7 @@ describe("normalizeAndValidateConfig()", () => {
             env: { ENV1: { unsafe: { bindings: {} } } },
           } as unknown as RawConfig,
           undefined,
-          "ENV1"
+          { env: "ENV1" }
         );
 
         expect(config).toEqual(
@@ -2327,7 +2702,7 @@ describe("normalizeAndValidateConfig()", () => {
             env: { ENV1: { unsafe: { bindings: "BAD" } } },
           } as unknown as RawConfig,
           undefined,
-          "ENV1"
+          { env: "ENV1" }
         );
 
         expect(config).toEqual(
@@ -2355,7 +2730,7 @@ describe("normalizeAndValidateConfig()", () => {
             env: { ENV1: { unsafe: { bindings: 999 } } },
           } as unknown as RawConfig,
           undefined,
-          "ENV1"
+          { env: "ENV1" }
         );
 
         expect(config).toEqual(
@@ -2383,7 +2758,7 @@ describe("normalizeAndValidateConfig()", () => {
             env: { ENV1: { unsafe: { bindings: null } } },
           } as unknown as RawConfig,
           undefined,
-          "ENV1"
+          { env: "ENV1" }
         );
 
         expect(config).toEqual(
@@ -2426,7 +2801,7 @@ describe("normalizeAndValidateConfig()", () => {
             },
           } as unknown as RawConfig,
           undefined,
-          "ENV1"
+          { env: "ENV1" }
         );
 
         expect(config).toEqual(
@@ -2465,7 +2840,7 @@ describe("normalizeAndValidateConfig()", () => {
           zone_id: "ZONE_ID",
           experimental_services: [
             {
-              name: "NAME",
+              name: "mock-name",
               service: "SERVICE",
               environment: "ENV",
             },
@@ -2479,7 +2854,7 @@ describe("normalizeAndValidateConfig()", () => {
             },
           },
           undefined,
-          "ENV1"
+          { env: "ENV1" }
         );
 
         expect("experimental_services" in config).toBe(false);
@@ -2491,13 +2866,13 @@ describe("normalizeAndValidateConfig()", () => {
           "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\\":
+              - 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\\"
+                name = \\"mock-name\\"
                 type = \\"service\\"
                 service = \\"SERVICE\\"
                 environment = \\"ENV\\"
@@ -2509,7 +2884,7 @@ describe("normalizeAndValidateConfig()", () => {
     describe("route & routes fields", () => {
       it("should error if both route and routes are specified in the same environment", () => {
         const environment: RawEnvironment = {
-          name: "ENV_NAME",
+          name: "mock-env-name",
           account_id: "ENV_ACCOUNT_ID",
           compatibility_date: "2022-02-02",
           compatibility_flags: ["ENV_FLAG1", "ENV_FLAG2"],
@@ -2522,7 +2897,7 @@ describe("normalizeAndValidateConfig()", () => {
           usage_model: "unbound",
         };
         const expectedConfig: RawConfig = {
-          name: "NAME",
+          name: "mock-name",
           account_id: "ACCOUNT_ID",
           compatibility_date: "2022-01-01",
           compatibility_flags: ["FLAG1", "FLAG2"],
@@ -2540,7 +2915,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           expectedConfig,
           undefined,
-          "ENV1"
+          { env: "ENV1" }
         );
 
         expect(config).toEqual(expect.objectContaining(environment));
@@ -2557,7 +2932,7 @@ describe("normalizeAndValidateConfig()", () => {
 
       it("should error if both route and routes are specified in the top-level environment", () => {
         const environment: RawEnvironment = {
-          name: "ENV_NAME",
+          name: "mock-env-name",
           account_id: "ENV_ACCOUNT_ID",
           compatibility_date: "2022-02-02",
           compatibility_flags: ["ENV_FLAG1", "ENV_FLAG2"],
@@ -2569,7 +2944,7 @@ describe("normalizeAndValidateConfig()", () => {
           usage_model: "unbound",
         };
         const expectedConfig: RawConfig = {
-          name: "NAME",
+          name: "mock-name",
           account_id: "ACCOUNT_ID",
           compatibility_date: "2022-01-01",
           compatibility_flags: ["FLAG1", "FLAG2"],
@@ -2588,7 +2963,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           expectedConfig,
           undefined,
-          "ENV1"
+          { env: "ENV1" }
         );
 
         expect(config).toEqual(expect.objectContaining(environment));
@@ -2603,7 +2978,7 @@ describe("normalizeAndValidateConfig()", () => {
 
       it("should not error if <env>.route and <top-level>.routes are specified", () => {
         const environment: RawEnvironment = {
-          name: "ENV_NAME",
+          name: "mock-env-name",
           account_id: "ENV_ACCOUNT_ID",
           compatibility_date: "2022-02-02",
           compatibility_flags: ["ENV_FLAG1", "ENV_FLAG2"],
@@ -2615,7 +2990,7 @@ describe("normalizeAndValidateConfig()", () => {
           usage_model: "unbound",
         };
         const expectedConfig: RawConfig = {
-          name: "NAME",
+          name: "mock-name",
           account_id: "ACCOUNT_ID",
           compatibility_date: "2022-01-01",
           compatibility_flags: ["FLAG1", "FLAG2"],
@@ -2633,7 +3008,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           expectedConfig,
           undefined,
-          "ENV1"
+          { env: "ENV1" }
         );
 
         expect(config).toEqual(expect.objectContaining(environment));
@@ -2643,7 +3018,7 @@ describe("normalizeAndValidateConfig()", () => {
 
       it("should not error if <env>.routes and <top-level>.route are specified", () => {
         const environment: RawEnvironment = {
-          name: "ENV_NAME",
+          name: "mock-env-name",
           account_id: "ENV_ACCOUNT_ID",
           compatibility_date: "2022-02-02",
           compatibility_flags: ["ENV_FLAG1", "ENV_FLAG2"],
@@ -2655,7 +3030,7 @@ describe("normalizeAndValidateConfig()", () => {
           usage_model: "unbound",
         };
         const expectedConfig: RawConfig = {
-          name: "NAME",
+          name: "mock-name",
           account_id: "ACCOUNT_ID",
           compatibility_date: "2022-01-01",
           compatibility_flags: ["FLAG1", "FLAG2"],
@@ -2673,7 +3048,7 @@ describe("normalizeAndValidateConfig()", () => {
         const { config, diagnostics } = normalizeAndValidateConfig(
           expectedConfig,
           undefined,
-          "ENV1"
+          { env: "ENV1" }
         );
 
         expect(config).toEqual(expect.objectContaining(environment));
@@ -2683,7 +3058,7 @@ describe("normalizeAndValidateConfig()", () => {
 
       it("should not error if <env1>.route and <env2>.routes are specified", () => {
         const environment1: RawEnvironment = {
-          name: "ENV_NAME",
+          name: "mock-env-name",
           account_id: "ENV_ACCOUNT_ID",
           compatibility_date: "2022-02-02",
           compatibility_flags: ["ENV_FLAG1", "ENV_FLAG2"],
@@ -2695,7 +3070,7 @@ describe("normalizeAndValidateConfig()", () => {
           usage_model: "unbound",
         };
         const environment2: RawEnvironment = {
-          name: "ENV_NAME",
+          name: "mock-env-name",
           account_id: "ENV_ACCOUNT_ID",
           compatibility_date: "2022-02-02",
           compatibility_flags: ["ENV_FLAG1", "ENV_FLAG2"],
@@ -2707,7 +3082,7 @@ describe("normalizeAndValidateConfig()", () => {
           usage_model: "unbound",
         };
         const expectedConfig: RawConfig = {
-          name: "NAME",
+          name: "mock-name",
           account_id: "ACCOUNT_ID",
           compatibility_date: "2022-01-01",
           compatibility_flags: ["FLAG1", "FLAG2"],
@@ -2723,21 +3098,17 @@ describe("normalizeAndValidateConfig()", () => {
           },
         };
 
-        const result1 = normalizeAndValidateConfig(
-          expectedConfig,
-          undefined,
-          "ENV1"
-        );
+        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,
-          "ENV2"
-        );
+        const result2 = normalizeAndValidateConfig(expectedConfig, undefined, {
+          env: "ENV2",
+        });
 
         expect(result2.config).toEqual(expect.objectContaining(environment2));
         expect(result2.diagnostics.hasErrors()).toBe(false);