fix: routes fetches based on worker routes

Author: edmundhung

packages/wrangler/e2e/create-server.test.ts

@@ -135,6 +135,67 @@ describe("createServer", { sequential: true }, () => {
 		);
 	});
 
+	it("routes fetches based on worker routes", async ({ expect }) => {
+		await helper.seed({
+			"wrangler.primary.jsonc": dedent`
+				{
+					"name": "primary-worker",
+					"main": "src/primary.ts",
+					"compatibility_date": "2026-05-20",
+					"routes": ["primary.example.com/*"]
+				}
+			`,
+			"src/primary.ts": dedent`
+				export default {
+					fetch(request) {
+						return Response.json({ name: "primary", url: request.url });
+					}
+				};
+			`,
+			"src/auxiliary.ts": dedent`
+				export default {
+					fetch(request) {
+						return Response.json({ name: "auxiliary", url: request.url });
+					}
+				};
+			`,
+		});
+
+		const server = createServer({
+			root: helper.tmpPath,
+			workers: [
+				{ configPath: "./wrangler.primary.jsonc" },
+				{
+					config: {
+						name: "auxiliary-worker",
+						main: "src/auxiliary.ts",
+						compatibility_date: "2026-05-20",
+						routes: ["auxiliary.example.com/*"],
+					},
+				},
+			],
+		});
+		onTestFinished(server.close);
+
+		await server.listen();
+
+		const primaryResponse = await server.fetch(
+			"http://primary.example.com/path?value=1"
+		);
+		await expect(primaryResponse.json()).resolves.toEqual({
+			name: "primary",
+			url: "http://primary.example.com/path?value=1",
+		});
+
+		const auxiliaryResponse = await server.fetch(
+			"http://auxiliary.example.com/path?value=2"
+		);
+		await expect(auxiliaryResponse.json()).resolves.toEqual({
+			name: "auxiliary",
+			url: "http://auxiliary.example.com/path?value=2",
+		});
+	});
+
 	it("supports overriding fetch for outbound requests", async ({ expect }) => {
 		await helper.seed({
 			"wrangler.jsonc": dedent`

packages/wrangler/src/api/server.ts

@@ -18,13 +18,12 @@ import type {
 	LogLevel,
 	ServiceFetch,
 	StartDevWorkerInput,
-	StartDevWorkerOptions,
 } from "./startDevWorker/types";
 import type {
 	FetcherScheduledOptions,
 	FetcherScheduledResult,
 } from "@cloudflare/workers-types/experimental";
-import type { Config, RawConfig } from "@cloudflare/workers-utils";
+import type { Config, RawConfig, Trigger } from "@cloudflare/workers-utils";
 import type { DispatchFetch, Json, RequestInfo } from "miniflare";
 
 export type InlineConfig = Omit<RawConfig, "env">;
@@ -131,6 +130,28 @@ function normalizeInlineWorkerConfig(
 	return normalizedConfig;
 }
 
+type ConfigRoute = NonNullable<Config["route"]> | NonNullable<Config["routes"]>[number];
+
+function routeToTrigger(route: ConfigRoute): Extract<Trigger, { type: "route" }> {
+	return typeof route === "string"
+		? { type: "route", pattern: route }
+		: { type: "route", ...route };
+}
+
+function getInlineConfigTriggers(config: Config): Trigger[] {
+	const routes = [
+		...(config.route ? [config.route] : []),
+		...(config.routes ?? []),
+	].map(routeToTrigger);
+	const crons =
+		config.triggers.crons?.map<Extract<Trigger, { type: "cron" }>>((cron) => ({
+			type: "cron",
+			cron,
+		})) ?? [];
+
+	return [...routes, ...crons];
+}
+
 async function resolveFetchInput(
 	input: RequestInfo,
 	session: ServerSession
@@ -195,10 +216,7 @@ function resolveWorkerInputs(
 			bindings,
 			migrations: inlineConfig?.migrations,
 			containers: inlineConfig?.containers,
-			triggers: inlineConfig?.triggers?.crons?.map((cron) => ({
-				type: "cron" as const,
-				cron,
-			})),
+			triggers: inlineConfig ? getInlineConfigTriggers(inlineConfig) : undefined,
 			tailConsumers: inlineConfig?.tail_consumers,
 			streamingTailConsumers: inlineConfig?.streaming_tail_consumers,
 			assets: inlineConfig?.assets?.directory,
@@ -216,7 +234,8 @@ function resolveWorkerInputs(
 					((request) => {
 						return globalThis.fetch(request.url, request);
 					}),
-				multiworkerPrimary: isPrimaryWorker && isMultiworker ? true : undefined,
+				multiworkerPrimary: isMultiworker ? isPrimaryWorker : undefined,
+				inferOriginFromRoutes: false,
 			},
 			build: {
 				nodejsCompatMode: (config) => {
@@ -298,44 +317,6 @@ async function updateConfig(
 	}
 }
 
-// TODO: Do we want this?
-function maybePrintScheduledWorkerWarning(
-	serverSession: ServerSession,
-	url: URL
-): void {
-	const workersWithCronTriggers = serverSession.devEnvs
-		.map((devEnv) => devEnv.config.latestConfig)
-		.filter((config): config is StartDevWorkerOptions => config !== undefined)
-		.filter((config) =>
-			config.triggers?.some((trigger) => trigger.type === "cron")
-		);
-
-	if (workersWithCronTriggers.length === 0) {
-		return;
-	}
-
-	const testScheduled = workersWithCronTriggers.every(
-		(config) => config.dev.testScheduled
-	);
-	if (testScheduled) {
-		return;
-	}
-
-	const host =
-		url.hostname === "0.0.0.0" || url.hostname === "::"
-			? "localhost"
-			: url.hostname.includes(":")
-				? `[${url.hostname}]`
-				: url.hostname;
-
-	logger.once.warn(
-		`Scheduled Workers are not automatically triggered during local development.\n` +
-			`To manually trigger a scheduled event, run:\n` +
-			`  curl "http://${host}:${url.port}/cdn-cgi/handler/scheduled"\n` +
-			`For more details, see https://developers.cloudflare.com/workers/configuration/cron-triggers/#test-cron-triggers-locally`
-	);
-}
-
 /**
  * Creates a worker server with a small, migration-focused API surface.
  *
@@ -415,9 +396,8 @@ export function createServer(options: ServerOptions): WorkerServer {
 		const session = await createSession(currentOptions, serverAuthHook);
 
 		try {
-			const ready = await waitForPrimaryReady(session);
+			await waitForPrimaryReady(session);
 			serverSession = session;
-			maybePrintScheduledWorkerWarning(session, ready.url);
 		} catch (error) {
 			await teardownSession(session);
 			throw error;

packages/wrangler/src/api/startDevWorker/ConfigController.ts

@@ -149,7 +149,11 @@ async function resolveDevConfig(
 		origin: {
 			secure:
 				input.dev?.origin?.secure ?? config.dev.upstream_protocol === "https",
-			hostname: host ?? getInferredHost(routes, config.configPath),
+			hostname:
+				host ??
+				(input.dev?.inferOriginFromRoutes
+					? getInferredHost(routes, config.configPath)
+					: undefined),
 		},
 		watch: input.dev?.watch,
 		liveReload: input.dev?.liveReload || false,
@@ -159,6 +163,7 @@ async function resolveDevConfig(
 		persist: localPersistencePath,
 		registry: input.dev?.registry,
 		multiworkerPrimary: input.dev?.multiworkerPrimary,
+		inferOriginFromRoutes: input.dev?.inferOriginFromRoutes,
 		enableContainers:
 			input.dev?.enableContainers ?? config.dev.enable_containers,
 		dockerPath: input.dev?.dockerPath ?? getDockerPath(),

packages/wrangler/src/api/startDevWorker/LocalRuntimeController.ts

@@ -112,10 +112,13 @@ export async function convertToConfigBundle(
 	const bindings: Record<string, Binding> = { ...event.config.bindings };
 
 	const crons = [];
+	const routes = [];
 	const queueConsumers = [];
 	for (const trigger of event.config.triggers ?? []) {
 		if (trigger.type === "cron") {
 			crons.push(trigger.cron);
+		} else if (trigger.type === "route") {
+			routes.push(trigger.pattern);
 		} else if (trigger.type === "queue-consumer") {
 			const { type: _, ...consumer } = trigger;
 			queueConsumers.push(consumer);
@@ -191,6 +194,7 @@ export async function convertToConfigBundle(
 		localPersistencePath: event.config.dev.persist,
 		liveReload: event.config.dev?.liveReload ?? false,
 		crons,
+		routes,
 		queueConsumers,
 		outboundService: event.config.dev.outboundService,
 		localProtocol: event.config.dev?.server?.secure ? "https" : "http",

packages/wrangler/src/api/startDevWorker/types.ts

@@ -173,6 +173,8 @@ export interface StartDevWorkerInput {
 
 		/** Treat this as the primary worker in a multiworker setup (i.e. the first Worker in Miniflare's options) */
 		multiworkerPrimary?: boolean;
+		/** Whether to infer the local request origin from configured routes. */
+		inferOriginFromRoutes?: boolean;
 
 		containerBuildId?: string;
 		/** Whether to build and connect to containers during local dev. Requires Docker daemon to be running. Defaults to true. */

packages/wrangler/src/dev/miniflare/index.ts

@@ -86,6 +86,7 @@ export interface ConfigBundle {
 	localPersistencePath: string | false;
 	liveReload: boolean;
 	crons: Config["triggers"]["crons"];
+	routes: string[] | undefined;
 	queueConsumers: Config["queues"]["consumers"];
 	localProtocol: "http" | "https";
 	httpsKeyPath: string | undefined;
@@ -1090,6 +1091,7 @@ export async function buildMiniflareOptions(
 				...bindingOptions,
 				...sitesOptions,
 				...assetOptions,
+				routes: config.routes,
 				outboundService: config.outboundService,
 				containerEngine: config.containerEngine,
 				zone: config.zone,

packages/wrangler/src/dev/start-dev.ts

@@ -265,6 +265,7 @@ async function setupDevEnv(
 				logLevel: args.logLevel,
 				registry: args.disableDevRegistry ? undefined : getRegistryPath(),
 				multiworkerPrimary: args.multiworkerPrimary,
+				inferOriginFromRoutes: true,
 				enableContainers: args.enableContainers,
 				dockerPath: args.dockerPath,
 				// initialise with a random id