wrangler 0.0.0-e178d6fb → 0.0.0-e1c2f5b9

package/src/__tests__/configuration.test.ts

@@ -25,8 +25,9 @@ describe("normalizeAndValidateConfig()", () => {
 			compatibility_date: undefined,
 			compatibility_flags: [],
 			configPath: undefined,
+			d1_databases: [],
 			dev: {
-				ip: "localhost",
+				ip: "0.0.0.0",
 				local_protocol: "http",
 				port: undefined, // the default of 8787 is set at runtime
 				upstream_protocol: "https",
@@ -40,12 +41,21 @@ describe("normalizeAndValidateConfig()", () => {
 			tsconfig: undefined,
 			kv_namespaces: [],
 			legacy_env: true,
+			logfwdr: {
+				bindings: [],
+				schema: undefined,
+			},
 			send_metrics: undefined,
 			main: undefined,
 			migrations: [],
 			name: undefined,
+			queues: {
+				consumers: [],
+				producers: [],
+			},
 			r2_buckets: [],
 			services: [],
+			analytics_engine_datasets: [],
 			route: undefined,
 			routes: undefined,
 			rules: [],
@@ -57,7 +67,7 @@ describe("normalizeAndValidateConfig()", () => {
 			unsafe: {
 				bindings: [],
 			},
-			worker_namespaces: [],
+			dispatch_namespaces: [],
 			usage_model: undefined,
 			vars: {},
 			define: {},
@@ -68,6 +78,9 @@ describe("normalizeAndValidateConfig()", () => {
 			no_bundle: undefined,
 			minify: undefined,
 			node_compat: undefined,
+			first_party_worker: undefined,
+			keep_vars: undefined,
+			logpush: undefined,
 		});
 		expect(diagnostics.hasErrors()).toBe(false);
 		expect(diagnostics.hasWarnings()).toBe(false);
@@ -101,6 +114,7 @@ describe("normalizeAndValidateConfig()", () => {
 			const expectedConfig = {
 				legacy_env: "FOO",
 				send_metrics: "BAD",
+				keep_vars: "NEVER",
 				dev: {
 					ip: 222,
 					port: "FOO",
@@ -123,6 +137,7 @@ describe("normalizeAndValidateConfig()", () => {
 			"Processing wrangler configuration:
 			  - Expected \\"legacy_env\\" to be of type boolean but got \\"FOO\\".
 			  - Expected \\"send_metrics\\" to be of type boolean but got \\"BAD\\".
+			  - Expected \\"keep_vars\\" to be of type boolean but got \\"NEVER\\".
 			  - 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\\".
@@ -463,6 +478,56 @@ describe("normalizeAndValidateConfig()", () => {
 		});
 
 		describe("[assets]", () => {
+			it("normalizes a string input to an object", () => {
+				const { config, diagnostics } = normalizeAndValidateConfig(
+					{
+						assets: "path/to/assets",
+					} as unknown as RawConfig,
+					undefined,
+					{ env: undefined }
+				);
+
+				expect(config.assets).toMatchInlineSnapshot(`
+			Object {
+			  "browser_TTL": undefined,
+			  "bucket": "path/to/assets",
+			  "exclude": Array [],
+			  "include": Array [],
+			  "serve_single_page_app": false,
+			}
+		`);
+				expect(diagnostics.hasWarnings()).toBe(true);
+				expect(diagnostics.hasErrors()).toBe(false);
+
+				expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
+			"Processing wrangler configuration:
+			  - \\"assets\\" fields are experimental and may change or break at any time."
+		`);
+			});
+
+			it("errors when input is not a string or object", () => {
+				const { config, diagnostics } = normalizeAndValidateConfig(
+					{
+						assets: 123,
+					} as unknown as RawConfig,
+					undefined,
+					{ env: undefined }
+				);
+
+				expect(config.assets).toBeUndefined();
+				expect(diagnostics.hasWarnings()).toBe(true);
+				expect(diagnostics.hasErrors()).toBe(true);
+
+				expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
+			"Processing wrangler configuration:
+			  - \\"assets\\" fields are experimental and may change or break at any time."
+		`);
+				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+			"Processing wrangler configuration:
+			  - Expected the \`assets\` field to be a string or an object, but got number."
+		`);
+			});
+
 			it("should error if `assets` config is missing `bucket`", () => {
 				const expectedConfig: RawConfig = {
 					// @ts-expect-error we're intentionally passing an invalid configuration here
@@ -478,7 +543,9 @@ describe("normalizeAndValidateConfig()", () => {
 					{ env: undefined }
 				);
 
-				expect(config).toEqual(expect.objectContaining(expectedConfig));
+				expect(config.assets).toEqual(
+					expect.objectContaining(expectedConfig.assets)
+				);
 				expect(diagnostics.hasWarnings()).toBe(true);
 				expect(diagnostics.hasErrors()).toBe(true);
 
@@ -498,6 +565,8 @@ describe("normalizeAndValidateConfig()", () => {
 						bucket: "BUCKET",
 						include: [222, 333],
 						exclude: [444, 555],
+						browser_TTL: "not valid",
+						serve_single_page_app: "INVALID",
 					},
 				};
 
@@ -514,12 +583,14 @@ describe("normalizeAndValidateConfig()", () => {
 			            - \\"assets\\" fields are experimental and may change or break at any time."
 		        `);
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
-			          "Processing wrangler configuration:
-			            - Expected \\"assets.include.[0]\\" to be of type string but got 222.
-			            - Expected \\"assets.include.[1]\\" to be of type string but got 333.
-			            - Expected \\"assets.exclude.[0]\\" to be of type string but got 444.
-			            - Expected \\"assets.exclude.[1]\\" to be of type string but got 555."
-		        `);
+			"Processing wrangler configuration:
+			  - Expected \\"assets.include.[0]\\" to be of type string but got 222.
+			  - Expected \\"assets.include.[1]\\" to be of type string but got 333.
+			  - Expected \\"assets.exclude.[0]\\" to be of type string but got 444.
+			  - Expected \\"assets.exclude.[1]\\" to be of type string but got 555.
+			  - Expected \\"assets.browser_TTL\\" to be of type number but got \\"not valid\\".
+			  - Expected \\"assets.serve_single_page_app\\" to be of type boolean but got \\"INVALID\\"."
+		`);
 			});
 		});
 
@@ -845,6 +916,15 @@ describe("normalizeAndValidateConfig()", () => {
 						environment: "SERVICE_BINDING_ENVIRONMENT_1",
 					},
 				],
+				analytics_engine_datasets: [
+					{
+						binding: "AE_BINDING_1",
+						dataset: "DATASET_1",
+					},
+					{
+						binding: "AE_BINDING_2",
+					},
+				],
 				unsafe: {
 					bindings: [
 						{ name: "UNSAFE_BINDING_1", type: "UNSAFE_TYPE_1" },
@@ -858,6 +938,8 @@ describe("normalizeAndValidateConfig()", () => {
 				no_bundle: true,
 				minify: true,
 				node_compat: true,
+				first_party_worker: true,
+				logpush: true,
 			};
 
 			const { config, diagnostics } = normalizeAndValidateConfig(
@@ -931,6 +1013,8 @@ describe("normalizeAndValidateConfig()", () => {
 				no_bundle: "INVALID",
 				minify: "INVALID",
 				node_compat: "INVALID",
+				first_party_worker: "INVALID",
+				logpush: "INVALID",
 			} as unknown as RawEnvironment;
 
 			const { config, diagnostics } = normalizeAndValidateConfig(
@@ -997,7 +1081,9 @@ describe("normalizeAndValidateConfig()", () => {
 			  - The field \\"define.DEF1\\" should be a string but got 1777.
 			  - Expected \\"no_bundle\\" to be of type boolean but got \\"INVALID\\".
 			  - Expected \\"minify\\" to be of type boolean but got \\"INVALID\\".
-			  - Expected \\"node_compat\\" to be of type boolean but got \\"INVALID\\"."
+			  - Expected \\"node_compat\\" to be of type boolean but got \\"INVALID\\".
+			  - Expected \\"first_party_worker\\" to be of type boolean but got \\"INVALID\\".
+			  - Expected \\"logpush\\" to be of type boolean but got \\"INVALID\\"."
 		`);
 		});
 
@@ -1249,15 +1335,12 @@ describe("normalizeAndValidateConfig()", () => {
 
 		describe("[durable_objects]", () => {
 			it("should error if durable_objects is an array", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{ durable_objects: [] } as unknown as RawConfig,
 					undefined,
 					{ env: undefined }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({ durable_objects: expect.anything })
-				);
 				expect(diagnostics.hasWarnings()).toBe(false);
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
 			                  "Processing wrangler configuration:
@@ -1266,15 +1349,12 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if durable_objects is a string", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{ durable_objects: "BAD" } as unknown as RawConfig,
 					undefined,
 					{ env: undefined }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({ durable_objects: expect.anything })
-				);
 				expect(diagnostics.hasWarnings()).toBe(false);
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
 			                  "Processing wrangler configuration:
@@ -1283,15 +1363,12 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if durable_objects is a number", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{ durable_objects: 999 } as unknown as RawConfig,
 					undefined,
 					{ env: undefined }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({ durable_objects: expect.anything })
-				);
 				expect(diagnostics.hasWarnings()).toBe(false);
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
 			                  "Processing wrangler configuration:
@@ -1300,15 +1377,12 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if durable_objects is null", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{ durable_objects: null } as unknown as RawConfig,
 					undefined,
 					{ env: undefined }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({ durable_objects: expect.anything })
-				);
 				expect(diagnostics.hasWarnings()).toBe(false);
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
 			                  "Processing wrangler configuration:
@@ -1317,15 +1391,12 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if durable_objects.bindings is not defined", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{ durable_objects: {} } as unknown as RawConfig,
 					undefined,
 					{ env: undefined }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({ durable_objects: expect.anything })
-				);
 				expect(diagnostics.hasWarnings()).toBe(false);
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
 			                  "Processing wrangler configuration:
@@ -1334,17 +1405,12 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if durable_objects.bindings is an object", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{ durable_objects: { bindings: {} } } as unknown as RawConfig,
 					undefined,
 					{ env: undefined }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({
-						durable_objects: { bindings: expect.anything },
-					})
-				);
 				expect(diagnostics.hasWarnings()).toBe(false);
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
 			                  "Processing wrangler configuration:
@@ -1353,17 +1419,12 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if durable_objects.bindings is a string", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{ durable_objects: { bindings: "BAD" } } as unknown as RawConfig,
 					undefined,
 					{ env: undefined }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({
-						durable_objects: { bindings: expect.anything },
-					})
-				);
 				expect(diagnostics.hasWarnings()).toBe(false);
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
 			                  "Processing wrangler configuration:
@@ -1372,17 +1433,12 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if durable_objects.bindings is a number", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{ durable_objects: { bindings: 999 } } as unknown as RawConfig,
 					undefined,
 					{ env: undefined }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({
-						durable_objects: { bindings: expect.anything },
-					})
-				);
 				expect(diagnostics.hasWarnings()).toBe(false);
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
 			                  "Processing wrangler configuration:
@@ -1391,17 +1447,12 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if durable_objects.bindings is null", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{ durable_objects: { bindings: null } } as unknown as RawConfig,
 					undefined,
 					{ env: undefined }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({
-						durable_objects: { bindings: expect.anything },
-					})
-				);
 				expect(diagnostics.hasWarnings()).toBe(false);
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
 			                  "Processing wrangler configuration:
@@ -1410,7 +1461,7 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if durable_objects.bindings are not valid", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{
 						durable_objects: {
 							bindings: [
@@ -1445,11 +1496,6 @@ describe("normalizeAndValidateConfig()", () => {
 					{ env: undefined }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({
-						durable_objects: { bindings: expect.anything },
-					})
-				);
 				expect(diagnostics.hasWarnings()).toBe(false);
 
 				expect(diagnostics.hasErrors()).toBe(true);
@@ -1492,15 +1538,12 @@ describe("normalizeAndValidateConfig()", () => {
 
 		describe("[kv_namespaces]", () => {
 			it("should error if kv_namespaces is an object", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{ kv_namespaces: {} } as unknown as RawConfig,
 					undefined,
 					{ env: undefined }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({ kv_namespaces: expect.anything })
-				);
 				expect(diagnostics.hasWarnings()).toBe(false);
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
 			                  "Processing wrangler configuration:
@@ -1509,15 +1552,12 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if kv_namespaces is a string", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{ kv_namespaces: "BAD" } as unknown as RawConfig,
 					undefined,
 					{ env: undefined }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({ kv_namespaces: expect.anything })
-				);
 				expect(diagnostics.hasWarnings()).toBe(false);
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
 			                  "Processing wrangler configuration:
@@ -1526,15 +1566,12 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if kv_namespaces is a number", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{ kv_namespaces: 999 } as unknown as RawConfig,
 					undefined,
 					{ env: undefined }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({ kv_namespaces: expect.anything })
-				);
 				expect(diagnostics.hasWarnings()).toBe(false);
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
 			                  "Processing wrangler configuration:
@@ -1543,15 +1580,12 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if kv_namespaces is null", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{ kv_namespaces: null } as unknown as RawConfig,
 					undefined,
 					{ env: undefined }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({ kv_namespaces: expect.anything })
-				);
 				expect(diagnostics.hasWarnings()).toBe(false);
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
 			                  "Processing wrangler configuration:
@@ -1560,7 +1594,7 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if kv_namespaces.bindings are not valid", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{
 						kv_namespaces: [
 							{},
@@ -1571,17 +1605,13 @@ describe("normalizeAndValidateConfig()", () => {
 								id: "KV_ID_2",
 								preview_id: 2222,
 							},
+							{ binding: "VALID", id: "" },
 						],
 					} as unknown as RawConfig,
 					undefined,
 					{ env: undefined }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({
-						kv_namespaces: { bindings: expect.anything },
-					})
-				);
 				expect(diagnostics.hasWarnings()).toBe(false);
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
 			          "Processing wrangler configuration:
@@ -1590,213 +1620,381 @@ describe("normalizeAndValidateConfig()", () => {
 			            - \\"kv_namespaces[1]\\" bindings should have a string \\"id\\" field but got {\\"binding\\":\\"VALID\\"}.
 			            - \\"kv_namespaces[2]\\" bindings should have a string \\"binding\\" field but got {\\"binding\\":2000,\\"id\\":2111}.
 			            - \\"kv_namespaces[2]\\" bindings should have a string \\"id\\" field but got {\\"binding\\":2000,\\"id\\":2111}.
-			            - \\"kv_namespaces[3]\\" bindings should, optionally, have a string \\"preview_id\\" field but got {\\"binding\\":\\"KV_BINDING_2\\",\\"id\\":\\"KV_ID_2\\",\\"preview_id\\":2222}."
+			            - \\"kv_namespaces[3]\\" bindings should, optionally, have a string \\"preview_id\\" field but got {\\"binding\\":\\"KV_BINDING_2\\",\\"id\\":\\"KV_ID_2\\",\\"preview_id\\":2222}.
+			            - \\"kv_namespaces[4]\\" bindings should have a string \\"id\\" field but got {\\"binding\\":\\"VALID\\",\\"id\\":\\"\\"}."
 		        `);
 			});
 		});
 
-		describe("[r2_buckets]", () => {
-			it("should error if r2_buckets is an object", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
-					{ r2_buckets: {} } as unknown as RawConfig,
+		describe("[d1_databases]", () => {
+			it("should error if d1_databases is an object", () => {
+				const { diagnostics } = normalizeAndValidateConfig(
+					{ d1_databases: {} } as unknown as RawConfig,
 					undefined,
 					{ env: undefined }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({ r2_buckets: expect.anything })
-				);
 				expect(diagnostics.hasWarnings()).toBe(false);
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
 			                  "Processing wrangler configuration:
-			                    - The field \\"r2_buckets\\" should be an array but got {}."
+			                    - The field \\"d1_databases\\" should be an array but got {}."
 		              `);
 			});
 
-			it("should error if r2_buckets is a string", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
-					{ r2_buckets: "BAD" } as unknown as RawConfig,
+			it("should error if d1_databases is a string", () => {
+				const { diagnostics } = normalizeAndValidateConfig(
+					{ d1_databases: "BAD" } as unknown as RawConfig,
 					undefined,
 					{ env: undefined }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({ r2_buckets: expect.anything })
-				);
 				expect(diagnostics.hasWarnings()).toBe(false);
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
 			                  "Processing wrangler configuration:
-			                    - The field \\"r2_buckets\\" should be an array but got \\"BAD\\"."
+			                    - The field \\"d1_databases\\" should be an array but got \\"BAD\\"."
 		              `);
 			});
 
-			it("should error if r2_buckets is a number", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
-					{ r2_buckets: 999 } as unknown as RawConfig,
+			it("should error if d1_databases is a number", () => {
+				const { diagnostics } = normalizeAndValidateConfig(
+					{ d1_databases: 999 } as unknown as RawConfig,
 					undefined,
 					{ env: undefined }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({ r2_buckets: expect.anything })
-				);
 				expect(diagnostics.hasWarnings()).toBe(false);
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
 			                  "Processing wrangler configuration:
-			                    - The field \\"r2_buckets\\" should be an array but got 999."
+			                    - The field \\"d1_databases\\" should be an array but got 999."
 		              `);
 			});
 
-			it("should error if r2_buckets is null", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
-					{ r2_buckets: null } as unknown as RawConfig,
+			it("should error if d1_databases is null", () => {
+				const { diagnostics } = normalizeAndValidateConfig(
+					{ d1_databases: null } as unknown as RawConfig,
 					undefined,
 					{ env: undefined }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({ r2_buckets: expect.anything })
-				);
 				expect(diagnostics.hasWarnings()).toBe(false);
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
 			                  "Processing wrangler configuration:
-			                    - The field \\"r2_buckets\\" should be an array but got null."
+			                    - The field \\"d1_databases\\" should be an array but got null."
 		              `);
 			});
 
-			it("should error if r2_buckets.bindings are not valid", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+			it("should error if d1_databases.bindings are not valid", () => {
+				const { diagnostics } = normalizeAndValidateConfig(
 					{
-						r2_buckets: [
+						d1_databases: [
 							{},
-							{ binding: "R2_BINDING_1" },
-							{ binding: 2333, bucket_name: 2444 },
+							{ binding: "VALID" },
+							{ binding: 2000, id: 2111 },
 							{
-								binding: "R2_BINDING_2",
-								bucket_name: "R2_BUCKET_2",
-								preview_bucket_name: 2555,
+								binding: "D1_BINDING_2",
+								id: "my-db",
+								preview_id: 2222,
 							},
+							{ binding: "VALID", id: "" },
 						],
 					} as unknown as RawConfig,
 					undefined,
 					{ env: undefined }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({
-						r2_buckets: { bindings: expect.anything },
-					})
-				);
 				expect(diagnostics.hasWarnings()).toBe(false);
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
-			          "Processing wrangler configuration:
-			            - \\"r2_buckets[0]\\" bindings should have a string \\"binding\\" field but got {}.
-			            - \\"r2_buckets[0]\\" bindings should have a string \\"bucket_name\\" field but got {}.
-			            - \\"r2_buckets[1]\\" bindings should have a string \\"bucket_name\\" field but got {\\"binding\\":\\"R2_BINDING_1\\"}.
-			            - \\"r2_buckets[2]\\" bindings should have a string \\"binding\\" field but got {\\"binding\\":2333,\\"bucket_name\\":2444}.
-			            - \\"r2_buckets[2]\\" bindings should have a string \\"bucket_name\\" field but got {\\"binding\\":2333,\\"bucket_name\\":2444}.
-			            - \\"r2_buckets[3]\\" bindings should, optionally, have a string \\"preview_bucket_name\\" field but got {\\"binding\\":\\"R2_BINDING_2\\",\\"bucket_name\\":\\"R2_BUCKET_2\\",\\"preview_bucket_name\\":2555}."
-		        `);
+			"Processing wrangler configuration:
+			  - \\"d1_databases[0]\\" bindings should have a string \\"binding\\" field but got {}.
+			  - \\"d1_databases[0]\\" bindings must have a \\"database_id\\" field but got {}.
+			  - \\"d1_databases[1]\\" bindings must have a \\"database_id\\" field but got {\\"binding\\":\\"VALID\\"}.
+			  - \\"d1_databases[2]\\" bindings should have a string \\"binding\\" field but got {\\"binding\\":2000,\\"id\\":2111}.
+			  - \\"d1_databases[2]\\" bindings must have a \\"database_id\\" field but got {\\"binding\\":2000,\\"id\\":2111}.
+			  - \\"d1_databases[3]\\" bindings must have a \\"database_id\\" field but got {\\"binding\\":\\"D1_BINDING_2\\",\\"id\\":\\"my-db\\",\\"preview_id\\":2222}.
+			  - \\"d1_databases[4]\\" bindings must have a \\"database_id\\" field but got {\\"binding\\":\\"VALID\\",\\"id\\":\\"\\"}."
+		`);
 			});
 		});
 
-		describe("[services]", () => {
-			it("should error if services is an object", () => {
+		describe("[queues]", () => {
+			it("should error if queues is not an object", () => {
 				const { config, diagnostics } = normalizeAndValidateConfig(
-					{ services: {} } as unknown as RawConfig,
+					{ queues: [] } as unknown as RawConfig,
 					undefined,
 					{ env: undefined }
 				);
 
 				expect(config).toEqual(
-					expect.not.objectContaining({ services: expect.anything })
+					expect.not.objectContaining({ queues: 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.hasWarnings()).toBe(false);
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
-			          "Processing wrangler configuration:
-			            - The field \\"services\\" should be an array but got {}."
-		        `);
+			                  "Processing wrangler configuration:
+			                    - The field \\"queues\\" should be an object but got []."
+		              `);
 			});
 
-			it("should error if services is a string", () => {
+			it("should error if queues producer bindings are not valid", () => {
 				const { config, diagnostics } = normalizeAndValidateConfig(
-					{ services: "BAD" } as unknown as RawConfig,
+					{
+						queues: {
+							invalidField: "madeupValue",
+							producers: [
+								{},
+								{ binding: "QUEUE_BINDING_1" },
+								{ binding: 2333, queue: 2444 },
+								{ binding: "QUEUE_BINDING_3", queue: "" },
+							],
+						},
+					} as unknown as RawConfig,
 					undefined,
 					{ env: undefined }
 				);
 
 				expect(config).toEqual(
-					expect.not.objectContaining({ services: expect.anything })
+					expect.not.objectContaining({
+						queues: { producers: 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."
-		        `);
+					"Processing wrangler configuration:
+					  - Unexpected fields found in queues field: \\"invalidField\\""
+				`);
+
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
-			          "Processing wrangler configuration:
-			            - The field \\"services\\" should be an array but got \\"BAD\\"."
-		        `);
+					"Processing wrangler configuration:
+					  - \\"queues.producers[0]\\" bindings should have a string \\"binding\\" field but got {}.
+					  - \\"queues.producers[0]\\" bindings should have a string \\"queue\\" field but got {}.
+					  - \\"queues.producers[1]\\" bindings should have a string \\"queue\\" field but got {\\"binding\\":\\"QUEUE_BINDING_1\\"}.
+					  - \\"queues.producers[2]\\" bindings should have a string \\"binding\\" field but got {\\"binding\\":2333,\\"queue\\":2444}.
+					  - \\"queues.producers[2]\\" bindings should have a string \\"queue\\" field but got {\\"binding\\":2333,\\"queue\\":2444}.
+					  - \\"queues.producers[3]\\" bindings should have a string \\"queue\\" field but got {\\"binding\\":\\"QUEUE_BINDING_3\\",\\"queue\\":\\"\\"}."
+				`);
 			});
 
-			it("should error if services is a number", () => {
+			it("should error if queues consumers are not valid", () => {
 				const { config, diagnostics } = normalizeAndValidateConfig(
-					{ services: 999 } as unknown as RawConfig,
+					{
+						queues: {
+							invalidField: "madeupValue",
+							consumers: [
+								{},
+								{ queue: 22 },
+								{ queue: "myQueue", invalidField: "madeupValue" },
+								{
+									queue: "myQueue",
+									max_batch_size: "3",
+									max_batch_timeout: null,
+									max_retries: "hello",
+									dead_letter_queue: 5,
+								},
+							],
+						},
+					} as unknown as RawConfig,
 					undefined,
 					{ env: undefined }
 				);
 
 				expect(config).toEqual(
-					expect.not.objectContaining({ services: expect.anything })
+					expect.not.objectContaining({
+						queues: { producers: 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."
-		        `);
+					"Processing wrangler configuration:
+					  - Unexpected fields found in queues field: \\"invalidField\\"
+					  - Unexpected fields found in queues.consumers[2] field: \\"invalidField\\""
+				`);
+
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
-			          "Processing wrangler configuration:
-			            - The field \\"services\\" should be an array but got 999."
-		        `);
+					"Processing wrangler configuration:
+					  - \\"queues.consumers[0]\\" should have a string \\"queue\\" field but got {}.
+					  - \\"queues.consumers[1]\\" should have a string \\"queue\\" field but got {\\"queue\\":22}.
+					  - \\"queues.consumers[3]\\" should, optionally, have a number \\"max_batch_size\\" field but got {\\"queue\\":\\"myQueue\\",\\"max_batch_size\\":\\"3\\",\\"max_batch_timeout\\":null,\\"max_retries\\":\\"hello\\",\\"dead_letter_queue\\":5}.
+					  - \\"queues.consumers[3]\\" should, optionally, have a number \\"max_batch_timeout\\" field but got {\\"queue\\":\\"myQueue\\",\\"max_batch_size\\":\\"3\\",\\"max_batch_timeout\\":null,\\"max_retries\\":\\"hello\\",\\"dead_letter_queue\\":5}.
+					  - \\"queues.consumers[3]\\" should, optionally, have a number \\"max_retries\\" field but got {\\"queue\\":\\"myQueue\\",\\"max_batch_size\\":\\"3\\",\\"max_batch_timeout\\":null,\\"max_retries\\":\\"hello\\",\\"dead_letter_queue\\":5}.
+					  - \\"queues.consumers[3]\\" should, optionally, have a string \\"dead_letter_queue\\" field but got {\\"queue\\":\\"myQueue\\",\\"max_batch_size\\":\\"3\\",\\"max_batch_timeout\\":null,\\"max_retries\\":\\"hello\\",\\"dead_letter_queue\\":5}."
+				`);
 			});
+		});
 
-			it("should error if services is null", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
-					{ services: null } as unknown as RawConfig,
+		describe("[r2_buckets]", () => {
+			it("should error if r2_buckets is an object", () => {
+				const { diagnostics } = normalizeAndValidateConfig(
+					{ r2_buckets: {} } 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.hasWarnings()).toBe(false);
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
-			          "Processing wrangler configuration:
-			            - The field \\"services\\" should be an array but got null."
-		        `);
+			                  "Processing wrangler configuration:
+			                    - The field \\"r2_buckets\\" should be an array but got {}."
+		              `);
 			});
 
-			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 },
+			it("should error if r2_buckets is a string", () => {
+				const { diagnostics } = normalizeAndValidateConfig(
+					{ r2_buckets: "BAD" } as unknown as RawConfig,
+					undefined,
+					{ env: undefined }
+				);
+
+				expect(diagnostics.hasWarnings()).toBe(false);
+				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+			                  "Processing wrangler configuration:
+			                    - The field \\"r2_buckets\\" should be an array but got \\"BAD\\"."
+		              `);
+			});
+
+			it("should error if r2_buckets is a number", () => {
+				const { diagnostics } = normalizeAndValidateConfig(
+					{ r2_buckets: 999 } as unknown as RawConfig,
+					undefined,
+					{ env: undefined }
+				);
+
+				expect(diagnostics.hasWarnings()).toBe(false);
+				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+			                  "Processing wrangler configuration:
+			                    - The field \\"r2_buckets\\" should be an array but got 999."
+		              `);
+			});
+
+			it("should error if r2_buckets is null", () => {
+				const { diagnostics } = normalizeAndValidateConfig(
+					{ r2_buckets: null } as unknown as RawConfig,
+					undefined,
+					{ env: undefined }
+				);
+
+				expect(diagnostics.hasWarnings()).toBe(false);
+				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+			                  "Processing wrangler configuration:
+			                    - The field \\"r2_buckets\\" should be an array but got null."
+		              `);
+			});
+
+			it("should error if r2_buckets.bindings are not valid", () => {
+				const { diagnostics } = normalizeAndValidateConfig(
+					{
+						r2_buckets: [
+							{},
+							{ binding: "R2_BINDING_1" },
+							{ binding: 2333, bucket_name: 2444 },
+							{
+								binding: "R2_BINDING_2",
+								bucket_name: "R2_BUCKET_2",
+								preview_bucket_name: 2555,
+							},
+							{ binding: "R2_BINDING_1", bucket_name: "" },
+						],
+					} as unknown as RawConfig,
+					undefined,
+					{ env: undefined }
+				);
+
+				expect(diagnostics.hasWarnings()).toBe(false);
+				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+			          "Processing wrangler configuration:
+			            - \\"r2_buckets[0]\\" bindings should have a string \\"binding\\" field but got {}.
+			            - \\"r2_buckets[0]\\" bindings should have a string \\"bucket_name\\" field but got {}.
+			            - \\"r2_buckets[1]\\" bindings should have a string \\"bucket_name\\" field but got {\\"binding\\":\\"R2_BINDING_1\\"}.
+			            - \\"r2_buckets[2]\\" bindings should have a string \\"binding\\" field but got {\\"binding\\":2333,\\"bucket_name\\":2444}.
+			            - \\"r2_buckets[2]\\" bindings should have a string \\"bucket_name\\" field but got {\\"binding\\":2333,\\"bucket_name\\":2444}.
+			            - \\"r2_buckets[3]\\" bindings should, optionally, have a string \\"preview_bucket_name\\" field but got {\\"binding\\":\\"R2_BINDING_2\\",\\"bucket_name\\":\\"R2_BUCKET_2\\",\\"preview_bucket_name\\":2555}.
+			            - \\"r2_buckets[4]\\" bindings should have a string \\"bucket_name\\" field but got {\\"binding\\":\\"R2_BINDING_1\\",\\"bucket_name\\":\\"\\"}."
+		        `);
+			});
+		});
+
+		describe("[services]", () => {
+			it("should error if services is an object", () => {
+				const { diagnostics } = normalizeAndValidateConfig(
+					{ services: {} } as unknown as RawConfig,
+					undefined,
+					{ env: undefined }
+				);
+
+				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 { diagnostics } = normalizeAndValidateConfig(
+					{ services: "BAD" } as unknown as RawConfig,
+					undefined,
+					{ env: undefined }
+				);
+
+				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 { diagnostics } = normalizeAndValidateConfig(
+					{ services: 999 } as unknown as RawConfig,
+					undefined,
+					{ env: undefined }
+				);
+
+				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 { diagnostics } = normalizeAndValidateConfig(
+					{ services: null } as unknown as RawConfig,
+					undefined,
+					{ env: undefined }
+				);
+
+				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 { 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,
@@ -1814,11 +2012,6 @@ describe("normalizeAndValidateConfig()", () => {
 					{ 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(`
@@ -1845,59 +2038,114 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 		});
 
-		describe("[worker_namespaces]", () => {
-			it("should log an experimental warning when worker_namespaces is used", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+		describe("[analytics_engine_datasets]", () => {
+			it("should error if analytics_engine_datasets is an object", () => {
+				const { diagnostics } = normalizeAndValidateConfig(
+					{ analytics_engine_datasets: {} } as unknown as RawConfig,
+					undefined,
+					{ env: undefined }
+				);
+
+				expect(diagnostics.hasWarnings()).toBe(false);
+				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+			                  "Processing wrangler configuration:
+			                    - The field \\"analytics_engine_datasets\\" should be an array but got {}."
+		              `);
+			});
+
+			it("should error if analytics_engine_datasets is a string", () => {
+				const { diagnostics } = normalizeAndValidateConfig(
+					{ analytics_engine_datasets: "BAD" } as unknown as RawConfig,
+					undefined,
+					{ env: undefined }
+				);
+
+				expect(diagnostics.hasWarnings()).toBe(false);
+				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+			                  "Processing wrangler configuration:
+			                    - The field \\"analytics_engine_datasets\\" should be an array but got \\"BAD\\"."
+		              `);
+			});
+
+			it("should error if analytics_engine_datasets is a number", () => {
+				const { diagnostics } = normalizeAndValidateConfig(
+					{ analytics_engine_datasets: 999 } as unknown as RawConfig,
+					undefined,
+					{ env: undefined }
+				);
+
+				expect(diagnostics.hasWarnings()).toBe(false);
+				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+			                  "Processing wrangler configuration:
+			                    - The field \\"analytics_engine_datasets\\" should be an array but got 999."
+		              `);
+			});
+
+			it("should error if analytics_engine_datasets is null", () => {
+				const { diagnostics } = normalizeAndValidateConfig(
+					{ analytics_engine_datasets: null } as unknown as RawConfig,
+					undefined,
+					{ env: undefined }
+				);
+
+				expect(diagnostics.hasWarnings()).toBe(false);
+				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+			                  "Processing wrangler configuration:
+			                    - The field \\"analytics_engine_datasets\\" should be an array but got null."
+		              `);
+			});
+
+			it("should error if analytics_engine_datasets.bindings are not valid", () => {
+				const { diagnostics } = normalizeAndValidateConfig(
 					{
-						worker_namespaces: [
+						analytics_engine_datasets: [
+							{},
+							{ binding: 2333, dataset: 2444 },
 							{
-								binding: "BINDING_1",
-								namespace: "NAMESPACE_1",
+								binding: "AE_BINDING_2",
+								dataset: 2555,
 							},
+							{ binding: "AE_BINDING_1", dataset: "" },
 						],
 					} as unknown as RawConfig,
 					undefined,
 					{ env: undefined }
 				);
-				expect(config).toEqual(
-					expect.not.objectContaining({ worker_namespaces: expect.anything })
-				);
-				expect(diagnostics.hasWarnings()).toBe(true);
-				expect(diagnostics.hasErrors()).toBe(false);
-				expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
-			"Processing wrangler configuration:
-			  - \\"worker_namespaces\\" fields are experimental and may change or break at any time."
-		`);
+
+				expect(diagnostics.hasWarnings()).toBe(false);
+				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+			          "Processing wrangler configuration:
+			            - \\"analytics_engine_datasets[0]\\" bindings should have a string \\"binding\\" field but got {}.
+			            - \\"analytics_engine_datasets[1]\\" bindings should have a string \\"binding\\" field but got {\\"binding\\":2333,\\"dataset\\":2444}.
+			            - \\"analytics_engine_datasets[1]\\" bindings should, optionally, have a string \\"dataset\\" field but got {\\"binding\\":2333,\\"dataset\\":2444}.
+			            - \\"analytics_engine_datasets[2]\\" bindings should, optionally, have a string \\"dataset\\" field but got {\\"binding\\":\\"AE_BINDING_2\\",\\"dataset\\":2555}.
+			            - \\"analytics_engine_datasets[3]\\" bindings should, optionally, have a string \\"dataset\\" field but got {\\"binding\\":\\"AE_BINDING_1\\",\\"dataset\\":\\"\\"}."
+		        `);
 			});
+		});
 
-			it("should error if worker_namespaces is not an array", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+		describe("[dispatch_namespaces]", () => {
+			it("should error if dispatch_namespaces is not an array", () => {
+				const { diagnostics } = normalizeAndValidateConfig(
 					{
-						worker_namespaces: "just a string",
+						dispatch_namespaces: "just a string",
 					} as unknown as RawConfig,
 					undefined,
 					{ env: undefined }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({ worker_namespaces: expect.anything })
-				);
-				expect(diagnostics.hasWarnings()).toBe(true);
+				expect(diagnostics.hasWarnings()).toBe(false);
 				expect(diagnostics.hasErrors()).toBe(true);
-				expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
-			          "Processing wrangler configuration:
-			            - \\"worker_namespaces\\" fields are experimental and may change or break at any time."
-		        `);
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
 			"Processing wrangler configuration:
-			  - The field \\"worker_namespaces\\" should be an array but got \\"just a string\\"."
+			  - The field \\"dispatch_namespaces\\" should be an array but got \\"just a string\\"."
 		`);
 			});
 
-			it("should error on non valid worker_namespaces", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+			it("should error on non valid dispatch_namespaces", () => {
+				const { diagnostics } = normalizeAndValidateConfig(
 					{
-						worker_namespaces: [
+						dispatch_namespaces: [
 							"a string",
 							123,
 							{
@@ -1905,17 +2153,17 @@ describe("normalizeAndValidateConfig()", () => {
 								namespace: 456,
 							},
 							{
-								binding: "WORKER_NAMESPACE_BINDING_1",
+								binding: "DISPATCH_NAMESPACE_BINDING_1",
 								namespace: 456,
 							},
 							// this one is valid
 							{
-								binding: "WORKER_NAMESPACE_BINDING_1",
-								namespace: "WORKER_NAMESPACE_BINDING_NAMESPACE_1",
+								binding: "DISPATCH_NAMESPACE_BINDING_1",
+								namespace: "DISPATCH_NAMESPACE_BINDING_NAMESPACE_1",
 							},
 							{
 								binding: 123,
-								namespace: "WORKER_NAMESPACE_BINDING_SERVICE_1",
+								namespace: "DISPATCH_NAMESPACE_BINDING_SERVICE_1",
 							},
 							{
 								binding: 123,
@@ -1926,42 +2174,30 @@ describe("normalizeAndValidateConfig()", () => {
 					undefined,
 					{ env: undefined }
 				);
-				expect(config).toEqual(
-					expect.not.objectContaining({
-						worker_namespaces: expect.anything,
-					})
-				);
-				expect(diagnostics.hasWarnings()).toBe(true);
+				expect(diagnostics.hasWarnings()).toBe(false);
 				expect(diagnostics.hasErrors()).toBe(true);
-				expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
-			"Processing wrangler configuration:
-			  - \\"worker_namespaces\\" fields are experimental and may change or break at any time."
-		`);
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
 			"Processing wrangler configuration:
-			  - \\"worker_namespaces[0]\\" binding should be objects, but got \\"a string\\"
-			  - \\"worker_namespaces[1]\\" binding should be objects, but got 123
-			  - \\"worker_namespaces[2]\\" should have a string \\"binding\\" field but got {\\"binding\\":123,\\"namespace\\":456}.
-			  - \\"worker_namespaces[2]\\" should have a string \\"namespace\\" field but got {\\"binding\\":123,\\"namespace\\":456}.
-			  - \\"worker_namespaces[3]\\" should have a string \\"namespace\\" field but got {\\"binding\\":\\"WORKER_NAMESPACE_BINDING_1\\",\\"namespace\\":456}.
-			  - \\"worker_namespaces[5]\\" should have a string \\"binding\\" field but got {\\"binding\\":123,\\"namespace\\":\\"WORKER_NAMESPACE_BINDING_SERVICE_1\\"}.
-			  - \\"worker_namespaces[6]\\" should have a string \\"binding\\" field but got {\\"binding\\":123,\\"service\\":456}.
-			  - \\"worker_namespaces[6]\\" should have a string \\"namespace\\" field but got {\\"binding\\":123,\\"service\\":456}."
+			  - \\"dispatch_namespaces[0]\\" binding should be objects, but got \\"a string\\"
+			  - \\"dispatch_namespaces[1]\\" binding should be objects, but got 123
+			  - \\"dispatch_namespaces[2]\\" should have a string \\"binding\\" field but got {\\"binding\\":123,\\"namespace\\":456}.
+			  - \\"dispatch_namespaces[2]\\" should have a string \\"namespace\\" field but got {\\"binding\\":123,\\"namespace\\":456}.
+			  - \\"dispatch_namespaces[3]\\" should have a string \\"namespace\\" field but got {\\"binding\\":\\"DISPATCH_NAMESPACE_BINDING_1\\",\\"namespace\\":456}.
+			  - \\"dispatch_namespaces[5]\\" should have a string \\"binding\\" field but got {\\"binding\\":123,\\"namespace\\":\\"DISPATCH_NAMESPACE_BINDING_SERVICE_1\\"}.
+			  - \\"dispatch_namespaces[6]\\" should have a string \\"binding\\" field but got {\\"binding\\":123,\\"service\\":456}.
+			  - \\"dispatch_namespaces[6]\\" should have a string \\"namespace\\" field but got {\\"binding\\":123,\\"service\\":456}."
 		`);
 			});
 		});
 
 		describe("[unsafe.bindings]", () => {
 			it("should error if unsafe is an array", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{ unsafe: [] } as unknown as RawConfig,
 					undefined,
 					{ env: undefined }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({ unsafe: expect.anything })
-				);
 				expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
 			                  "Processing wrangler configuration:
 			                    - \\"unsafe\\" fields are experimental and may change or break at any time."
@@ -1973,15 +2209,12 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if unsafe is a string", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{ unsafe: "BAD" } as unknown as RawConfig,
 					undefined,
 					{ env: undefined }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({ unsafe: expect.anything })
-				);
 				expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
 			                  "Processing wrangler configuration:
 			                    - \\"unsafe\\" fields are experimental and may change or break at any time."
@@ -1993,15 +2226,12 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if unsafe is a number", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{ unsafe: 999 } as unknown as RawConfig,
 					undefined,
 					{ env: undefined }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({ unsafe: expect.anything })
-				);
 				expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
 			                  "Processing wrangler configuration:
 			                    - \\"unsafe\\" fields are experimental and may change or break at any time."
@@ -2013,15 +2243,12 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if unsafe is null", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{ unsafe: null } as unknown as RawConfig,
 					undefined,
 					{ env: undefined }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({ unsafe: expect.anything })
-				);
 				expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
 			                  "Processing wrangler configuration:
 			                    - \\"unsafe\\" fields are experimental and may change or break at any time."
@@ -2033,15 +2260,12 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if unsafe.bindings is not defined", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{ unsafe: {} } as unknown as RawConfig,
 					undefined,
 					{ env: undefined }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({ unsafe: expect.anything })
-				);
 				expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
 			                  "Processing wrangler configuration:
 			                    - \\"unsafe\\" fields are experimental and may change or break at any time."
@@ -2053,17 +2277,12 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if unsafe.bindings is an object", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{ unsafe: { bindings: {} } } as unknown as RawConfig,
 					undefined,
 					{ env: undefined }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({
-						unsafe: { bindings: expect.anything },
-					})
-				);
 				expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
 			                  "Processing wrangler configuration:
 			                    - \\"unsafe\\" fields are experimental and may change or break at any time."
@@ -2075,17 +2294,12 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if unsafe.bindings is a string", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{ unsafe: { bindings: "BAD" } } as unknown as RawConfig,
 					undefined,
 					{ env: undefined }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({
-						unsafe: { bindings: expect.anything },
-					})
-				);
 				expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
 			                  "Processing wrangler configuration:
 			                    - \\"unsafe\\" fields are experimental and may change or break at any time."
@@ -2097,17 +2311,12 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if unsafe.bindings is a number", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{ unsafe: { bindings: 999 } } as unknown as RawConfig,
 					undefined,
 					{ env: undefined }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({
-						unsafe: { bindings: expect.anything },
-					})
-				);
 				expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
 			                  "Processing wrangler configuration:
 			                    - \\"unsafe\\" fields are experimental and may change or break at any time."
@@ -2119,17 +2328,12 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if unsafe.bindings is null", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{ unsafe: { bindings: null } } as unknown as RawConfig,
 					undefined,
 					{ env: undefined }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({
-						unsafe: { bindings: expect.anything },
-					})
-				);
 				expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
 			                  "Processing wrangler configuration:
 			                    - \\"unsafe\\" fields are experimental and may change or break at any time."
@@ -2141,7 +2345,7 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if durable_objects.bindings are not valid", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{
 						unsafe: {
 							bindings: [
@@ -2160,11 +2364,6 @@ describe("normalizeAndValidateConfig()", () => {
 					{ env: undefined }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({
-						durable_objects: { bindings: expect.anything },
-					})
-				);
 				expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
 			                  "Processing wrangler configuration:
 			                    - \\"unsafe\\" fields are experimental and may change or break at any time."
@@ -2311,6 +2510,8 @@ describe("normalizeAndValidateConfig()", () => {
 				no_bundle: true,
 				minify: true,
 				node_compat: true,
+				first_party_worker: true,
+				logpush: true,
 			};
 
 			const { config, diagnostics } = normalizeAndValidateConfig(
@@ -2354,6 +2555,8 @@ describe("normalizeAndValidateConfig()", () => {
 				no_bundle: false,
 				minify: false,
 				node_compat: false,
+				first_party_worker: false,
+				logpush: false,
 			};
 			const rawConfig: RawConfig = {
 				name: "mock-name",
@@ -2376,6 +2579,8 @@ describe("normalizeAndValidateConfig()", () => {
 				no_bundle: true,
 				minify: true,
 				node_compat: true,
+				first_party_worker: true,
+				logpush: true,
 				env: {
 					ENV1: rawEnv,
 				},
@@ -2559,6 +2764,8 @@ describe("normalizeAndValidateConfig()", () => {
 			};
 			const kv_namespaces: RawConfig["kv_namespaces"] = [];
 			const r2_buckets: RawConfig["r2_buckets"] = [];
+			const analytics_engine_datasets: RawConfig["analytics_engine_datasets"] =
+				[];
 			const unsafe: RawConfig["unsafe"] = { bindings: [] };
 			const rawConfig: RawConfig = {
 				define,
@@ -2566,6 +2773,7 @@ describe("normalizeAndValidateConfig()", () => {
 				durable_objects,
 				kv_namespaces,
 				r2_buckets,
+				analytics_engine_datasets,
 				unsafe,
 				env: {
 					ENV1: {},
@@ -2585,33 +2793,37 @@ describe("normalizeAndValidateConfig()", () => {
 					durable_objects,
 					kv_namespaces,
 					r2_buckets,
+					analytics_engine_datasets,
 					unsafe,
 				})
 			);
 			expect(diagnostics.hasErrors()).toBe(false);
 			expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
-			        "Processing wrangler configuration:
-			          - \\"unsafe\\" fields are experimental and may change or break at any time.
-			          - \\"env.ENV1\\" environment configuration
-			            - \\"vars\\" exists at the top level, but not on \\"env.ENV1\\".
-			              This is not what you probably want, since \\"vars\\" is not inherited by environments.
-			              Please add \\"vars\\" to \\"env.ENV1\\".
-			            - \\"define\\" exists at the top level, but not on \\"env.ENV1\\".
-			              This is not what you probably want, since \\"define\\" is not inherited by environments.
-			              Please add \\"define\\" to \\"env.ENV1\\".
-			            - \\"durable_objects\\" exists at the top level, but not on \\"env.ENV1\\".
-			              This is not what you probably want, since \\"durable_objects\\" is not inherited by environments.
-			              Please add \\"durable_objects\\" to \\"env.ENV1\\".
-			            - \\"kv_namespaces\\" exists at the top level, but not on \\"env.ENV1\\".
-			              This is not what you probably want, since \\"kv_namespaces\\" is not inherited by environments.
-			              Please add \\"kv_namespaces\\" to \\"env.ENV1\\".
-			            - \\"r2_buckets\\" exists at the top level, but not on \\"env.ENV1\\".
-			              This is not what you probably want, since \\"r2_buckets\\" is not inherited by environments.
-			              Please add \\"r2_buckets\\" to \\"env.ENV1\\".
-			            - \\"unsafe\\" exists at the top level, but not on \\"env.ENV1\\".
-			              This is not what you probably want, since \\"unsafe\\" is not inherited by environments.
-			              Please add \\"unsafe\\" to \\"env.ENV1\\"."
-		      `);
+			"Processing wrangler configuration:
+			  - \\"unsafe\\" fields are experimental and may change or break at any time.
+			  - \\"env.ENV1\\" environment configuration
+			    - \\"vars\\" exists at the top level, but not on \\"env.ENV1\\".
+			      This is not what you probably want, since \\"vars\\" is not inherited by environments.
+			      Please add \\"vars\\" to \\"env.ENV1\\".
+			    - \\"define\\" exists at the top level, but not on \\"env.ENV1\\".
+			      This is not what you probably want, since \\"define\\" is not inherited by environments.
+			      Please add \\"define\\" to \\"env.ENV1\\".
+			    - \\"durable_objects\\" exists at the top level, but not on \\"env.ENV1\\".
+			      This is not what you probably want, since \\"durable_objects\\" is not inherited by environments.
+			      Please add \\"durable_objects\\" to \\"env.ENV1\\".
+			    - \\"kv_namespaces\\" exists at the top level, but not on \\"env.ENV1\\".
+			      This is not what you probably want, since \\"kv_namespaces\\" is not inherited by environments.
+			      Please add \\"kv_namespaces\\" to \\"env.ENV1\\".
+			    - \\"r2_buckets\\" exists at the top level, but not on \\"env.ENV1\\".
+			      This is not what you probably want, since \\"r2_buckets\\" is not inherited by environments.
+			      Please add \\"r2_buckets\\" to \\"env.ENV1\\".
+			    - \\"analytics_engine_datasets\\" exists at the top level, but not on \\"env.ENV1\\".
+			      This is not what you probably want, since \\"analytics_engine_datasets\\" is not inherited by environments.
+			      Please add \\"analytics_engine_datasets\\" to \\"env.ENV1\\".
+			    - \\"unsafe\\" exists at the top level, but not on \\"env.ENV1\\".
+			      This is not what you probably want, since \\"unsafe\\" is not inherited by environments.
+			      Please add \\"unsafe\\" to \\"env.ENV1\\"."
+		`);
 		});
 
 		it("should error on invalid environment values", () => {
@@ -2637,6 +2849,8 @@ describe("normalizeAndValidateConfig()", () => {
 				no_bundle: "INVALID",
 				minify: "INVALID",
 				node_compat: "INVALID",
+				first_party_worker: "INVALID",
+				logpush: "INVALID",
 			} as unknown as RawEnvironment;
 
 			const { config, diagnostics } = normalizeAndValidateConfig(
@@ -2672,7 +2886,9 @@ describe("normalizeAndValidateConfig()", () => {
 			    - Expected \\"usage_model\\" field to be one of [\\"bundled\\",\\"unbound\\"] but got \\"INVALID\\".
 			    - Expected \\"no_bundle\\" to be of type boolean but got \\"INVALID\\".
 			    - Expected \\"minify\\" to be of type boolean but got \\"INVALID\\".
-			    - Expected \\"node_compat\\" to be of type boolean but got \\"INVALID\\"."
+			    - Expected \\"node_compat\\" to be of type boolean but got \\"INVALID\\".
+			    - Expected \\"first_party_worker\\" to be of type boolean but got \\"INVALID\\".
+			    - Expected \\"logpush\\" to be of type boolean but got \\"INVALID\\"."
 		`);
 		});
 
@@ -2900,15 +3116,12 @@ describe("normalizeAndValidateConfig()", () => {
 
 		describe("[durable_objects]", () => {
 			it("should error if durable_objects is an array", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{ env: { ENV1: { durable_objects: [] } } } as unknown as RawConfig,
 					undefined,
 					{ env: "ENV1" }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({ durable_objects: expect.anything })
-				);
 				expect(diagnostics.hasWarnings()).toBe(false);
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
 			          "Processing wrangler configuration:
@@ -2919,15 +3132,12 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if durable_objects is a string", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{ env: { ENV1: { durable_objects: "BAD" } } } as unknown as RawConfig,
 					undefined,
 					{ env: "ENV1" }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({ durable_objects: expect.anything })
-				);
 				expect(diagnostics.hasWarnings()).toBe(false);
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
 			          "Processing wrangler configuration:
@@ -2938,15 +3148,12 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if durable_objects is a number", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{ env: { ENV1: { durable_objects: 999 } } } as unknown as RawConfig,
 					undefined,
 					{ env: "ENV1" }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({ durable_objects: expect.anything })
-				);
 				expect(diagnostics.hasWarnings()).toBe(false);
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
 			          "Processing wrangler configuration:
@@ -2957,15 +3164,12 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if durable_objects is null", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{ env: { ENV1: { durable_objects: null } } } as unknown as RawConfig,
 					undefined,
 					{ env: "ENV1" }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({ durable_objects: expect.anything })
-				);
 				expect(diagnostics.hasWarnings()).toBe(false);
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
 			          "Processing wrangler configuration:
@@ -2976,15 +3180,12 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if durable_objects.bindings is not defined", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{ env: { ENV1: { durable_objects: {} } } } as unknown as RawConfig,
 					undefined,
 					{ env: "ENV1" }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({ durable_objects: expect.anything })
-				);
 				expect(diagnostics.hasWarnings()).toBe(false);
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
 			          "Processing wrangler configuration:
@@ -2995,7 +3196,7 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if durable_objects.bindings is an object", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{
 						env: { ENV1: { durable_objects: { bindings: {} } } },
 					} as unknown as RawConfig,
@@ -3003,11 +3204,6 @@ describe("normalizeAndValidateConfig()", () => {
 					{ env: "ENV1" }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({
-						durable_objects: { bindings: expect.anything },
-					})
-				);
 				expect(diagnostics.hasWarnings()).toBe(false);
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
 			          "Processing wrangler configuration:
@@ -3018,7 +3214,7 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if durable_objects.bindings is a string", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{
 						env: { ENV1: { durable_objects: { bindings: "BAD" } } },
 					} as unknown as RawConfig,
@@ -3026,11 +3222,6 @@ describe("normalizeAndValidateConfig()", () => {
 					{ env: "ENV1" }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({
-						durable_objects: { bindings: expect.anything },
-					})
-				);
 				expect(diagnostics.hasWarnings()).toBe(false);
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
 			          "Processing wrangler configuration:
@@ -3041,7 +3232,7 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if durable_objects.bindings is a number", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{
 						env: { ENV1: { durable_objects: { bindings: 999 } } },
 					} as unknown as RawConfig,
@@ -3049,11 +3240,6 @@ describe("normalizeAndValidateConfig()", () => {
 					{ env: "ENV1" }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({
-						durable_objects: { bindings: expect.anything },
-					})
-				);
 				expect(diagnostics.hasWarnings()).toBe(false);
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
 			          "Processing wrangler configuration:
@@ -3064,7 +3250,7 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if durable_objects.bindings is null", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{
 						env: { ENV1: { durable_objects: { bindings: null } } },
 					} as unknown as RawConfig,
@@ -3072,11 +3258,6 @@ describe("normalizeAndValidateConfig()", () => {
 					{ env: "ENV1" }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({
-						durable_objects: { bindings: expect.anything },
-					})
-				);
 				expect(diagnostics.hasWarnings()).toBe(false);
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
 			          "Processing wrangler configuration:
@@ -3087,7 +3268,7 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if durable_objects.bindings are not valid", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{
 						env: {
 							ENV1: {
@@ -3110,11 +3291,6 @@ describe("normalizeAndValidateConfig()", () => {
 					{ env: "ENV1" }
 				);
 
-				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(`
@@ -3143,15 +3319,12 @@ describe("normalizeAndValidateConfig()", () => {
 
 		describe("[kv_namespaces]", () => {
 			it("should error if kv_namespaces is an object", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{ env: { ENV1: { kv_namespaces: {} } } } as unknown as RawConfig,
 					undefined,
 					{ env: "ENV1" }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({ kv_namespaces: expect.anything })
-				);
 				expect(diagnostics.hasWarnings()).toBe(false);
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
 			          "Processing wrangler configuration:
@@ -3162,15 +3335,12 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if kv_namespaces is a string", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{ env: { ENV1: { kv_namespaces: "BAD" } } } as unknown as RawConfig,
 					undefined,
 					{ env: "ENV1" }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({ kv_namespaces: expect.anything })
-				);
 				expect(diagnostics.hasWarnings()).toBe(false);
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
 			          "Processing wrangler configuration:
@@ -3181,15 +3351,12 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if kv_namespaces is a number", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{ env: { ENV1: { kv_namespaces: 999 } } } as unknown as RawConfig,
 					undefined,
 					{ env: "ENV1" }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({ kv_namespaces: expect.anything })
-				);
 				expect(diagnostics.hasWarnings()).toBe(false);
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
 			          "Processing wrangler configuration:
@@ -3200,15 +3367,12 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if kv_namespaces is null", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{ env: { ENV1: { kv_namespaces: null } } } as unknown as RawConfig,
 					undefined,
 					{ env: "ENV1" }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({ kv_namespaces: expect.anything })
-				);
 				expect(diagnostics.hasWarnings()).toBe(false);
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
 			          "Processing wrangler configuration:
@@ -3219,7 +3383,7 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if kv_namespaces.bindings are not valid", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{
 						env: {
 							ENV1: {
@@ -3240,11 +3404,6 @@ describe("normalizeAndValidateConfig()", () => {
 					{ env: "ENV1" }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({
-						kv_namespaces: { bindings: expect.anything },
-					})
-				);
 				expect(diagnostics.hasWarnings()).toBe(false);
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
 			          "Processing wrangler configuration:
@@ -3262,15 +3421,12 @@ describe("normalizeAndValidateConfig()", () => {
 
 		describe("[r2_buckets]", () => {
 			it("should error if r2_buckets is an object", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{ env: { ENV1: { r2_buckets: {} } } } as unknown as RawConfig,
 					undefined,
 					{ env: "ENV1" }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({ r2_buckets: expect.anything })
-				);
 				expect(diagnostics.hasWarnings()).toBe(false);
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
 			          "Processing wrangler configuration:
@@ -3281,15 +3437,12 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if r2_buckets is a string", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{ env: { ENV1: { r2_buckets: "BAD" } } } as unknown as RawConfig,
 					undefined,
 					{ env: "ENV1" }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({ r2_buckets: expect.anything })
-				);
 				expect(diagnostics.hasWarnings()).toBe(false);
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
 			          "Processing wrangler configuration:
@@ -3300,15 +3453,12 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if r2_buckets is a number", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{ env: { ENV1: { r2_buckets: 999 } } } as unknown as RawConfig,
 					undefined,
 					{ env: "ENV1" }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({ r2_buckets: expect.anything })
-				);
 				expect(diagnostics.hasWarnings()).toBe(false);
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
 			          "Processing wrangler configuration:
@@ -3319,15 +3469,12 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if r2_buckets is null", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{ env: { ENV1: { r2_buckets: null } } } as unknown as RawConfig,
 					undefined,
 					{ env: "ENV1" }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({ r2_buckets: expect.anything })
-				);
 				expect(diagnostics.hasWarnings()).toBe(false);
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
 			          "Processing wrangler configuration:
@@ -3338,7 +3485,7 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if r2_buckets.bindings are not valid", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{
 						env: {
 							ENV1: {
@@ -3359,11 +3506,6 @@ describe("normalizeAndValidateConfig()", () => {
 					{ env: "ENV1" }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({
-						r2_buckets: { bindings: expect.anything },
-					})
-				);
 				expect(diagnostics.hasWarnings()).toBe(false);
 				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
 			          "Processing wrangler configuration:
@@ -3379,17 +3521,122 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 		});
 
+		describe("[analytics_engine_datasets]", () => {
+			it("should error if analytics_engine_datasets is an object", () => {
+				const { diagnostics } = normalizeAndValidateConfig(
+					{
+						env: { ENV1: { analytics_engine_datasets: {} } },
+					} as unknown as RawConfig,
+					undefined,
+					{ env: "ENV1" }
+				);
+
+				expect(diagnostics.hasWarnings()).toBe(false);
+				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+			          "Processing wrangler configuration:
+
+			            - \\"env.ENV1\\" environment configuration
+			              - The field \\"env.ENV1.analytics_engine_datasets\\" should be an array but got {}."
+		        `);
+			});
+
+			it("should error if analytics_engine_datasets is a string", () => {
+				const { diagnostics } = normalizeAndValidateConfig(
+					{
+						env: { ENV1: { analytics_engine_datasets: "BAD" } },
+					} as unknown as RawConfig,
+					undefined,
+					{ env: "ENV1" }
+				);
+
+				expect(diagnostics.hasWarnings()).toBe(false);
+				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+			          "Processing wrangler configuration:
+
+			            - \\"env.ENV1\\" environment configuration
+			              - The field \\"env.ENV1.analytics_engine_datasets\\" should be an array but got \\"BAD\\"."
+		        `);
+			});
+
+			it("should error if analytics_engine_datasets is a number", () => {
+				const { diagnostics } = normalizeAndValidateConfig(
+					{
+						env: { ENV1: { analytics_engine_datasets: 999 } },
+					} as unknown as RawConfig,
+					undefined,
+					{ env: "ENV1" }
+				);
+
+				expect(diagnostics.hasWarnings()).toBe(false);
+				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+			          "Processing wrangler configuration:
+
+			            - \\"env.ENV1\\" environment configuration
+			              - The field \\"env.ENV1.analytics_engine_datasets\\" should be an array but got 999."
+		        `);
+			});
+
+			it("should error if analytics_engine_datasets is null", () => {
+				const { diagnostics } = normalizeAndValidateConfig(
+					{
+						env: { ENV1: { analytics_engine_datasets: null } },
+					} as unknown as RawConfig,
+					undefined,
+					{ env: "ENV1" }
+				);
+
+				expect(diagnostics.hasWarnings()).toBe(false);
+				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+			          "Processing wrangler configuration:
+
+			            - \\"env.ENV1\\" environment configuration
+			              - The field \\"env.ENV1.analytics_engine_datasets\\" should be an array but got null."
+		        `);
+			});
+
+			it("should error if analytics_engine_datasets.bindings are not valid", () => {
+				const { diagnostics } = normalizeAndValidateConfig(
+					{
+						env: {
+							ENV1: {
+								analytics_engine_datasets: [
+									{},
+									{ binding: 2333, dataset: 2444 },
+									{
+										binding: "AE_BINDING_2",
+										dataset: 2555,
+									},
+									{ binding: "AE_BINDING_1", dataset: "" },
+								],
+							},
+						},
+					} as unknown as RawConfig,
+					undefined,
+					{ env: "ENV1" }
+				);
+
+				expect(diagnostics.hasWarnings()).toBe(false);
+				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+			          "Processing wrangler configuration:
+
+			            - \\"env.ENV1\\" environment configuration
+			              - \\"env.ENV1.analytics_engine_datasets[0]\\" bindings should have a string \\"binding\\" field but got {}.
+			              - \\"env.ENV1.analytics_engine_datasets[1]\\" bindings should have a string \\"binding\\" field but got {\\"binding\\":2333,\\"dataset\\":2444}.
+			              - \\"env.ENV1.analytics_engine_datasets[1]\\" bindings should, optionally, have a string \\"dataset\\" field but got {\\"binding\\":2333,\\"dataset\\":2444}.
+			              - \\"env.ENV1.analytics_engine_datasets[2]\\" bindings should, optionally, have a string \\"dataset\\" field but got {\\"binding\\":\\"AE_BINDING_2\\",\\"dataset\\":2555}.
+			              - \\"env.ENV1.analytics_engine_datasets[3]\\" bindings should, optionally, have a string \\"dataset\\" field but got {\\"binding\\":\\"AE_BINDING_1\\",\\"dataset\\":\\"\\"}."
+		        `);
+			});
+		});
+
 		describe("[unsafe.bindings]", () => {
 			it("should error if unsafe is an array", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{ env: { ENV1: { unsafe: [] } } } as unknown as RawConfig,
 					undefined,
 					{ env: "ENV1" }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({ unsafe: expect.anything })
-				);
 				expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
 			          "Processing wrangler configuration:
 
@@ -3405,15 +3652,12 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if unsafe is a string", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{ env: { ENV1: { unsafe: "BAD" } } } as unknown as RawConfig,
 					undefined,
 					{ env: "ENV1" }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({ unsafe: expect.anything })
-				);
 				expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
 			          "Processing wrangler configuration:
 
@@ -3429,15 +3673,12 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if unsafe is a number", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{ env: { ENV1: { unsafe: 999 } } } as unknown as RawConfig,
 					undefined,
 					{ env: "ENV1" }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({ unsafe: expect.anything })
-				);
 				expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
 			          "Processing wrangler configuration:
 
@@ -3453,15 +3694,12 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if unsafe is null", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{ env: { ENV1: { unsafe: null } } } as unknown as RawConfig,
 					undefined,
 					{ env: "ENV1" }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({ unsafe: expect.anything })
-				);
 				expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
 			          "Processing wrangler configuration:
 
@@ -3477,15 +3715,12 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if unsafe.bindings is not defined", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{ env: { ENV1: { unsafe: {} } } } as unknown as RawConfig,
 					undefined,
 					{ env: "ENV1" }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({ unsafe: expect.anything })
-				);
 				expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
 			          "Processing wrangler configuration:
 
@@ -3501,7 +3736,7 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if unsafe.bindings is an object", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{
 						env: { ENV1: { unsafe: { bindings: {} } } },
 					} as unknown as RawConfig,
@@ -3509,11 +3744,6 @@ describe("normalizeAndValidateConfig()", () => {
 					{ env: "ENV1" }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({
-						unsafe: { bindings: expect.anything },
-					})
-				);
 				expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
 			          "Processing wrangler configuration:
 
@@ -3529,7 +3759,7 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if unsafe.bindings is a string", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{
 						env: { ENV1: { unsafe: { bindings: "BAD" } } },
 					} as unknown as RawConfig,
@@ -3537,11 +3767,6 @@ describe("normalizeAndValidateConfig()", () => {
 					{ env: "ENV1" }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({
-						unsafe: { bindings: expect.anything },
-					})
-				);
 				expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
 			          "Processing wrangler configuration:
 
@@ -3557,7 +3782,7 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if unsafe.bindings is a number", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{
 						env: { ENV1: { unsafe: { bindings: 999 } } },
 					} as unknown as RawConfig,
@@ -3565,11 +3790,6 @@ describe("normalizeAndValidateConfig()", () => {
 					{ env: "ENV1" }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({
-						unsafe: { bindings: expect.anything },
-					})
-				);
 				expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
 			          "Processing wrangler configuration:
 
@@ -3585,7 +3805,7 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if unsafe.bindings is null", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{
 						env: { ENV1: { unsafe: { bindings: null } } },
 					} as unknown as RawConfig,
@@ -3593,11 +3813,6 @@ describe("normalizeAndValidateConfig()", () => {
 					{ env: "ENV1" }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({
-						unsafe: { bindings: expect.anything },
-					})
-				);
 				expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
 			          "Processing wrangler configuration:
 
@@ -3613,7 +3828,7 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 
 			it("should error if unsafe.bindings are not valid", () => {
-				const { config, diagnostics } = normalizeAndValidateConfig(
+				const { diagnostics } = normalizeAndValidateConfig(
 					{
 						env: {
 							ENV1: {
@@ -3636,11 +3851,6 @@ describe("normalizeAndValidateConfig()", () => {
 					{ env: "ENV1" }
 				);
 
-				expect(config).toEqual(
-					expect.not.objectContaining({
-						durable_objects: { bindings: expect.anything },
-					})
-				);
 				expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
 			          "Processing wrangler configuration:
 
@@ -3670,6 +3880,7 @@ describe("normalizeAndValidateConfig()", () => {
 			it("should remove and warn about deprecated properties", () => {
 				const environment: RawEnvironment = {
 					zone_id: "ZONE_ID",
+					"kv-namespaces": "BAD_KV_NAMESPACE",
 					experimental_services: [
 						{
 							name: "mock-name",
@@ -3695,14 +3906,16 @@ describe("normalizeAndValidateConfig()", () => {
 				expect(diagnostics.hasErrors()).toBe(false);
 				expect(diagnostics.hasWarnings()).toBe(true);
 				expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
-			          "Processing wrangler configuration:
+			"Processing wrangler configuration:
 
-			            - \\"env.ENV1\\" environment 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]."
-		        `);
+			  - \\"env.ENV1\\" environment configuration
+			    - Deprecation: \\"kv-namespaces\\":
+			      The \\"kv-namespaces\\" field is no longer supported, please rename to \\"kv_namespaces\\"
+			    - 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]."
+		`);
 			});
 		});