lopata 0.8.3 → 0.9.0

package/dist/dashboard/{chunk-yxzrcvyh.js → chunk-yq8n0mcf.js}

@@ -930,6 +930,39 @@ var ICONS = {
       }, undefined, false, undefined, this)
     ]
   }, undefined, true, undefined, this),
+  routes: () => /* @__PURE__ */ u3("svg", {
+    width: "16",
+    height: "16",
+    viewBox: "0 0 16 16",
+    fill: "none",
+    stroke: "currentColor",
+    "stroke-width": "1.5",
+    "stroke-linecap": "round",
+    "stroke-linejoin": "round",
+    children: [
+      /* @__PURE__ */ u3("circle", {
+        cx: "4",
+        cy: "4",
+        r: "1.5"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ u3("circle", {
+        cx: "12",
+        cy: "4",
+        r: "1.5"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ u3("circle", {
+        cx: "12",
+        cy: "12",
+        r: "1.5"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ u3("path", {
+        d: "M4 5.5v2c0 1.5 1 2.5 2.5 2.5h4"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ u3("path", {
+        d: "M4 5.5v5c0 1 .5 1.5 1.5 1.5h5"
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this),
   overview: () => /* @__PURE__ */ u3("svg", {
     width: "16",
     height: "16",
@@ -7825,6 +7858,43 @@ function R2ObjectList({ bucket }) {
   }, undefined, true, undefined, this);
 }
 
+// src/dashboard/views/routes.tsx
+var TYPE_COLORS = {
+  route: "bg-emerald-500/15 text-emerald-500",
+  fallback: "bg-panel-active text-text-data"
+};
+function RoutesView() {
+  const { data: routes } = useQuery("routes.list");
+  return /* @__PURE__ */ u3("div", {
+    class: "p-4 sm:p-8",
+    children: [
+      /* @__PURE__ */ u3(PageHeader, {
+        title: "Routes",
+        subtitle: `${routes?.length ?? 0} route(s)`
+      }, undefined, false, undefined, this),
+      !routes?.length ? /* @__PURE__ */ u3(EmptyState, {
+        message: "No routes configured"
+      }, undefined, false, undefined, this) : /* @__PURE__ */ u3(Table, {
+        headers: ["Pattern", "Worker", "Type"],
+        rows: routes.map((r3) => [
+          /* @__PURE__ */ u3("span", {
+            class: "font-mono text-xs font-medium",
+            children: r3.pattern
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ u3("span", {
+            class: "text-text-secondary",
+            children: r3.workerName
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ u3(StatusBadge, {
+            status: r3.isFallback ? "fallback" : "route",
+            colorMap: TYPE_COLORS
+          }, undefined, false, undefined, this)
+        ])
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
 // src/dashboard/views/scheduled.tsx
 function ScheduledView({ route }) {
   return /* @__PURE__ */ u3(ScheduledList, {}, undefined, false, undefined, this);
@@ -8958,7 +9028,7 @@ function DurationBar({ durationMs, maxDuration }) {
 }
 
 // src/dashboard/views/workers.tsx
-var TYPE_COLORS = {
+var TYPE_COLORS2 = {
   kv: "bg-emerald-500/15 text-emerald-500",
   r2: "bg-blue-500/15 text-blue-400",
   d1: "bg-violet-500/15 text-violet-400",
@@ -9014,7 +9084,7 @@ function WorkersView() {
               rows: w3.bindings.map((b) => [
                 /* @__PURE__ */ u3(StatusBadge, {
                   status: b.type,
-                  colorMap: TYPE_COLORS
+                  colorMap: TYPE_COLORS2
                 }, undefined, false, undefined, this),
                 /* @__PURE__ */ u3("span", {
                   class: "font-mono text-xs font-medium",
@@ -9744,6 +9814,7 @@ var NAV_GROUPS = [
     label: "Compute",
     items: [
       { path: "/workers", label: "Workers", icon: "workers" },
+      { path: "/routes", label: "Routes", icon: "routes" },
       { path: "/do", label: "Durable Objects", icon: "do" },
       { path: "/containers", label: "Containers", icon: "containers" },
       { path: "/workflows", label: "Workflows", icon: "workflows" },
@@ -9880,6 +9951,8 @@ function App() {
       }, undefined, false, undefined, this);
     if (route.startsWith("/workers"))
       return /* @__PURE__ */ u3(WorkersView, {}, undefined, false, undefined, this);
+    if (route.startsWith("/routes"))
+      return /* @__PURE__ */ u3(RoutesView, {}, undefined, false, undefined, this);
     if (route.startsWith("/generations"))
       return /* @__PURE__ */ u3(GenerationsView, {}, undefined, false, undefined, this);
     if (route.startsWith("/kv"))

package/dist/dashboard/index.html

@@ -8,7 +8,7 @@
   <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
   <link href="https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@400;500;600&display=swap" rel="stylesheet" />
   
-<link rel="stylesheet" crossorigin href="/__dashboard/assets/chunk-csyd2tq2.css"><script type="module" crossorigin src="/__dashboard/assets/chunk-yxzrcvyh.js"></script></head>
+<link rel="stylesheet" crossorigin href="/__dashboard/assets/chunk-csyd2tq2.css"><script type="module" crossorigin src="/__dashboard/assets/chunk-yq8n0mcf.js"></script></head>
 <body class="h-full bg-surface text-ink" style="font-family: system-ui, -apple-system, sans-serif;">
   <script>
     // Apply saved theme before first paint to prevent flash

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "lopata",
-	"version": "0.8.3",
+	"version": "0.9.0",
 	"type": "module",
 	"license": "MIT",
 	"repository": {

package/src/api/dispatch.ts

@@ -13,6 +13,7 @@ import { handlers as kv } from './handlers/kv'
 import { handlers as overview } from './handlers/overview'
 import { handlers as queue } from './handlers/queue'
 import { handlers as r2 } from './handlers/r2'
+import { handlers as routes } from './handlers/routes'
 import { handlers as scheduled } from './handlers/scheduled'
 import { handlers as traces } from './handlers/traces'
 import { handlers as warnings } from './handlers/warnings'
@@ -40,6 +41,7 @@ const allHandlers = {
 	...ai,
 	...analyticsEngine,
 	...warnings,
+	...routes,
 }
 
 export type Procedures = {

package/src/api/handlers/routes.ts

@@ -0,0 +1,31 @@
+import { extractPathPattern } from '../../route-matcher'
+import type { HandlerContext, RouteInfo } from '../types'
+
+export const handlers = {
+	'routes.list'(_input: {}, ctx: HandlerContext): RouteInfo[] {
+		const routes: RouteInfo[] = []
+
+		if (ctx.routeDispatcher) {
+			for (const r of ctx.routeDispatcher.getRegisteredRoutes()) {
+				routes.push({ pattern: r.pattern, workerName: r.workerName, isFallback: false })
+			}
+		}
+
+		// In single-worker mode, show routes from config
+		if (!ctx.routeDispatcher && ctx.config?.routes) {
+			const workerName = ctx.config.name || 'main'
+			for (const route of ctx.config.routes) {
+				if (typeof route === 'object' && route.custom_domain) continue
+				routes.push({ pattern: extractPathPattern(route), workerName, isFallback: false })
+			}
+		}
+
+		// Add main/fallback worker entry
+		const mainName = ctx.registry
+			? Array.from(ctx.registry.listManagers().keys())[0] ?? 'main'
+			: ctx.config?.name || 'main'
+		routes.push({ pattern: '/*', workerName: mainName, isFallback: true })
+
+		return routes
+	},
+}

package/src/api/index.ts

@@ -1,13 +1,14 @@
 import type { WranglerConfig } from '../config'
 import type { GenerationManager } from '../generation-manager'
 import type { LopataConfig } from '../lopata-config'
+import type { RouteDispatcher } from '../route-matcher'
 import type { WorkerRegistry } from '../worker-registry'
 import { handlePreflight, withCors } from './cors'
 import { dispatch } from './dispatch'
 import { handleR2Download, handleR2Upload } from './r2'
 import type { HandlerContext } from './types'
 
-const ctx: HandlerContext = { config: null, manager: null, registry: null, lopataConfig: null }
+const ctx: HandlerContext = { config: null, manager: null, registry: null, lopataConfig: null, routeDispatcher: null }
 
 export function setDashboardConfig(config: WranglerConfig): void {
 	ctx.config = config
@@ -25,6 +26,10 @@ export function setLopataConfig(config: LopataConfig): void {
 	ctx.lopataConfig = config
 }
 
+export function setRouteDispatcher(dispatcher: RouteDispatcher): void {
+	ctx.routeDispatcher = dispatcher
+}
+
 export function handleApiRequest(request: Request): Response | Promise<Response> {
 	const url = new URL(request.url)
 

package/src/api/types.ts

@@ -379,6 +379,7 @@ export type { SpanData, SpanEventData, TraceDetail, TraceEvent, TraceSummary } f
 import type { WranglerConfig } from '../config'
 import type { GenerationManager } from '../generation-manager'
 import type { LopataConfig } from '../lopata-config'
+import type { RouteDispatcher } from '../route-matcher'
 import type { WorkerRegistry } from '../worker-registry'
 
 export interface HandlerContext {
@@ -386,6 +387,13 @@ export interface HandlerContext {
 	manager: GenerationManager | null
 	registry: WorkerRegistry | null
 	lopataConfig: LopataConfig | null
+	routeDispatcher: RouteDispatcher | null
+}
+
+export interface RouteInfo {
+	pattern: string
+	workerName: string
+	isFallback: boolean
 }
 
 /** Collect configs from all workers (registry) or fall back to single config. */

package/src/cli/dev.ts

@@ -3,7 +3,7 @@ Error.stackTraceLimit = 50
 
 import '../plugin'
 import path from 'node:path'
-import { handleApiRequest, setDashboardConfig, setGenerationManager, setLopataConfig, setWorkerRegistry } from '../api'
+import { handleApiRequest, setDashboardConfig, setGenerationManager, setLopataConfig, setRouteDispatcher, setWorkerRegistry } from '../api'
 import { QueuePullConsumer } from '../bindings/queue'
 import type { AckRequest, PullRequest } from '../bindings/queue'
 import { CFWebSocket } from '../bindings/websocket-pair'
@@ -14,6 +14,7 @@ import { FileWatcher } from '../file-watcher'
 import { GenerationManager } from '../generation-manager'
 import { loadLopataConfig } from '../lopata-config'
 import { addCfProperty } from '../request-cf'
+import { RouteDispatcher } from '../route-matcher'
 import { getTraceStore } from '../tracing/store'
 import type { TraceEvent } from '../tracing/types'
 import { WorkerRegistry } from '../worker-registry'
@@ -32,6 +33,8 @@ export async function run(ctx: CliContext) {
 	const lopataConfig = await loadLopataConfig(baseDir)
 
 	let manager: GenerationManager
+	let routeDispatcher: RouteDispatcher | undefined
+	let registry: WorkerRegistry | undefined
 
 	if (lopataConfig) {
 		// ─── Multi-worker mode ─────────────────────────────────────────
@@ -48,7 +51,7 @@ export async function run(ctx: CliContext) {
 			console.warn(`[lopata] Unknown isolation mode "${lopataConfig.isolation}", using "dev"`)
 		}
 
-		const registry = new WorkerRegistry()
+		registry = new WorkerRegistry()
 
 		// Load main worker config
 		const mainConfig = await loadConfig(lopataConfig.main, envFlag)
@@ -67,9 +70,11 @@ export async function run(ctx: CliContext) {
 		})
 		registry.register(mainConfig.name, mainManager, true)
 
-		// Load auxiliary workers
+		// Load auxiliary workers and collect their configs for route setup
+		const auxConfigs = new Map<string, import('../config').WranglerConfig>()
 		for (const workerDef of lopataConfig.workers ?? []) {
 			const auxConfig = await loadConfig(workerDef.config, envFlag)
+			auxConfigs.set(workerDef.name, auxConfig)
 			const auxBaseDir = path.dirname(workerDef.config)
 			console.log(`[lopata] Auxiliary worker: ${workerDef.name} (${auxConfig.name})`)
 
@@ -94,8 +99,17 @@ export async function run(ctx: CliContext) {
 			// File watcher for aux worker
 			const auxSrcDir = path.dirname(path.resolve(auxBaseDir, auxConfig.main))
 			const auxWatcher = new FileWatcher(auxSrcDir, () => {
-				auxManager.reload().then(gen => {
+				auxManager.reload().then(async gen => {
 					console.log(`[lopata] Auxiliary worker "${workerDef.name}" reloaded → generation ${gen.id}`)
+					// Re-read config and update routes in case routes changed
+					if (routeDispatcher) {
+						try {
+							const freshConfig = await loadConfig(workerDef.config, envFlag)
+							routeDispatcher.addRoutes(freshConfig, auxManager, workerDef.name)
+						} catch (err) {
+							console.warn(`[lopata] Failed to re-read config for "${workerDef.name}" routes:`, err)
+						}
+					}
 				}).catch(err => {
 					console.error(`[lopata] Reload failed for "${workerDef.name}":`, err)
 				})
@@ -109,9 +123,30 @@ export async function run(ctx: CliContext) {
 		const firstGen = await mainManager.reload()
 		console.log(`[lopata] Main worker → generation ${firstGen.id}`)
 
+		// Warn if main worker has routes — they are ignored because main is the fallback
+		if (mainConfig.routes && mainConfig.routes.length > 0) {
+			console.warn(
+				'[lopata] Warning: main worker has "routes" in config — these are ignored in multi-worker mode (main worker is the fallback for unmatched requests)',
+			)
+		}
+
+		// Build route dispatcher for route-based worker selection (aux workers only — main is the fallback)
+		routeDispatcher = new RouteDispatcher(mainManager)
+		for (const workerDef of lopataConfig.workers ?? []) {
+			const auxConfig = auxConfigs.get(workerDef.name)
+			const auxMgr = registry.getManager(workerDef.name)
+			if (auxConfig && auxMgr) routeDispatcher.addRoutes(auxConfig, auxMgr, workerDef.name)
+		}
+		if (routeDispatcher.hasRoutes()) {
+			for (const r of routeDispatcher.getRegisteredRoutes()) {
+				console.log(`[lopata] Route: ${r.pattern} → ${r.workerName}`)
+			}
+		}
+
 		manager = mainManager
 		setGenerationManager(manager)
 		setWorkerRegistry(registry)
+		setRouteDispatcher(routeDispatcher)
 
 		// File watcher for main worker
 		const mainSrcDir = path.dirname(path.resolve(mainBaseDir, mainConfig.main))
@@ -201,9 +236,10 @@ export async function run(ctx: CliContext) {
 				}
 			}
 
-			// Email handler: POST /cdn-cgi/handler/email?from=...&to=...
+			// Email handler: POST /cdn-cgi/handler/email?from=...&to=...&worker=<name>
 			if (url.pathname === '/cdn-cgi/handler/email' && request.method === 'POST') {
-				const gen = manager.active
+				const targetManager = resolveWorkerParam(url, registry, manager)
+				const gen = targetManager.active
 				if (!gen) return new Response('No active generation', { status: 503 })
 				const from = url.searchParams.get('from') ?? ''
 				const to = url.searchParams.get('to') ?? ''
@@ -211,16 +247,18 @@ export async function run(ctx: CliContext) {
 				return gen.callEmail(new Uint8Array(raw), from, to)
 			}
 
-			// Manual trigger: GET /cdn-cgi/handler/scheduled?cron=<expression>
+			// Manual trigger: GET /cdn-cgi/handler/scheduled?cron=<expression>&worker=<name>
 			if (url.pathname === '/cdn-cgi/handler/scheduled') {
-				const gen = manager.active
+				const targetManager = resolveWorkerParam(url, registry, manager)
+				const gen = targetManager.active
 				if (!gen) return new Response('No active generation', { status: 503 })
 				const cronExpr = url.searchParams.get('cron') ?? '* * * * *'
 				return gen.callScheduled(cronExpr)
 			}
 
-			// Delegate to active generation
-			const gen = manager.active
+			// Delegate to active generation (route-based dispatch in multi-worker mode)
+			const targetManager = routeDispatcher ? routeDispatcher.resolve(url.pathname) : manager
+			const gen = targetManager.active
 			if (!gen) {
 				return new Response('No active generation', { status: 503 })
 			}
@@ -402,6 +440,18 @@ export async function run(ctx: CliContext) {
 	await new Promise(() => {})
 }
 
+/** Resolve a ?worker= query param to the target GenerationManager, falling back to the main manager. */
+function resolveWorkerParam(url: URL, registry: WorkerRegistry | undefined, fallback: GenerationManager): GenerationManager {
+	const workerName = url.searchParams.get('worker')
+	if (!workerName || !registry) return fallback
+	const target = registry.getManager(workerName)
+	if (!target) {
+		console.warn(`[lopata] Unknown worker "${workerName}" in ?worker= param, using main worker`)
+		return fallback
+	}
+	return target
+}
+
 function matchGlob(text: string, pattern: string): boolean {
 	// Placeholder approach: protect ** before escaping special chars
 	const regex = pattern

package/src/config.ts

@@ -58,6 +58,7 @@ export interface WranglerConfig {
 		instance_type?: string
 		name?: string
 	}[]
+	routes?: (string | { pattern: string; zone_name?: string; custom_domain?: boolean })[]
 	analytics_engine_datasets?: { binding: string; dataset?: string }[]
 	browser?: { binding: string }
 	version_metadata?: { binding: string }

package/src/route-matcher.ts

@@ -0,0 +1,181 @@
+import type { WranglerConfig } from './config'
+
+/** Minimal interface for the manager stored in route entries — allows both GenerationManager and Vite adapters. */
+export interface RoutableManager {
+	readonly active: { callFetch(request: Request, server: unknown): Promise<Response | undefined> | Response | undefined } | null
+}
+
+/**
+ * Extract the path portion from a Cloudflare route pattern.
+ * Strips the domain prefix: `example.com/api/*` → `/api/*`
+ * Handles patterns that are already path-only: `/api/*` → `/api/*`
+ * Strips query strings and hash fragments from the result.
+ */
+export function extractPathPattern(route: string | { pattern: string }): string {
+	let pattern = typeof route === 'string' ? route : route.pattern
+
+	// Strip protocol if present (e.g. `https://example.com/api/*`)
+	pattern = pattern.replace(/^https?:\/\//, '')
+
+	let path: string
+	if (pattern.startsWith('/')) {
+		path = pattern
+	} else {
+		// Strip domain (and optional port): find the first `/` after the domain
+		const slashIndex = pattern.indexOf('/')
+		if (slashIndex === -1) path = '/*' // Domain-only pattern like `example.com` matches everything
+		else path = pattern.slice(slashIndex)
+	}
+
+	// Strip query string and hash fragment
+	const qIndex = path.indexOf('?')
+	if (qIndex !== -1) path = path.slice(0, qIndex)
+	const hIndex = path.indexOf('#')
+	if (hIndex !== -1) path = path.slice(0, hIndex)
+
+	return path
+}
+
+/**
+ * Match a request pathname against a Cloudflare-style route pattern (path portion only).
+ * Supports trailing `*` as a wildcard that matches any suffix.
+ *
+ * Examples:
+ * - `/api/*` matches `/api/foo`, `/api/foo/bar`
+ * - `/api/users` matches only `/api/users`
+ * - `/*` matches everything
+ */
+export function matchRoute(pathname: string, pattern: string): boolean {
+	if (pattern === '/*' || pattern === '*') return true
+
+	if (pattern.endsWith('/*')) {
+		const prefix = pattern.slice(0, -2)
+		return pathname.startsWith(prefix + '/')
+	}
+
+	if (pattern.endsWith('*')) {
+		const prefix = pattern.slice(0, -1)
+		return pathname.startsWith(prefix)
+	}
+
+	return pathname === pattern
+}
+
+/** Count the number of path segments in a pattern (ignoring trailing wildcard). */
+function segmentCount(pattern: string): number {
+	const clean = pattern.replace(/\/?\*$/, '')
+	if (clean === '' || clean === '/') return 0
+	return clean.split('/').filter(Boolean).length
+}
+
+interface RouteEntry {
+	pattern: string
+	workerName: string
+	manager: RoutableManager
+}
+
+/**
+ * Dispatches requests to workers based on route patterns.
+ * Routes are sorted by specificity (most specific first).
+ *
+ * Only auxiliary workers should be added here — the main worker
+ * is the fallback and handles all unmatched requests.
+ */
+export class RouteDispatcher {
+	private routes: RouteEntry[] = []
+	private sorted = true
+	private fallback: RoutableManager
+
+	constructor(fallback: RoutableManager) {
+		this.fallback = fallback
+	}
+
+	addRoutes(config: WranglerConfig, manager: RoutableManager, workerName: string): void {
+		if (!config.routes) return
+
+		// Clear existing routes for this worker to support re-registration (e.g. config reload)
+		const hadRoutes = this.routes.length > 0
+		this.routes = this.routes.filter(r => r.workerName !== workerName)
+		if (hadRoutes && this.routes.length === 0) this.sorted = true
+
+		for (const route of config.routes) {
+			// Skip custom_domain entries — they are domain ownership claims, not request routing patterns
+			if (typeof route === 'object' && route.custom_domain) continue
+
+			const rawPattern = typeof route === 'string' ? route : route.pattern
+			if (!rawPattern || rawPattern.trim() === '') {
+				console.warn(`[lopata] Warning: empty route pattern in worker "${workerName}" — skipping`)
+				continue
+			}
+
+			const pattern = extractPathPattern(route)
+
+			// Warn about mid-pattern wildcards (CF only supports trailing wildcards)
+			const starIndex = pattern.indexOf('*')
+			if (starIndex !== -1 && starIndex < pattern.length - 1) {
+				console.warn(`[lopata] Warning: route pattern "${pattern}" has a wildcard not at the end — Cloudflare only supports trailing wildcards`)
+			}
+
+			// Skip duplicate patterns from different workers (first registered wins)
+			const existing = this.routes.find(r => r.pattern === pattern)
+			if (existing) {
+				console.warn(
+					`[lopata] Warning: route pattern "${pattern}" is already registered by "${existing.workerName}" — skipping duplicate from "${workerName}"`,
+				)
+				continue
+			}
+
+			this.routes.push({ pattern, workerName, manager })
+			this.sorted = false
+		}
+	}
+
+	removeWorkerRoutes(workerName: string): void {
+		this.routes = this.routes.filter(r => r.workerName !== workerName)
+	}
+
+	private ensureSorted(): void {
+		if (this.sorted) return
+		this.routes.sort((a, b) => {
+			const aHasWild = a.pattern.includes('*')
+			const bHasWild = b.pattern.includes('*')
+			// Non-wildcard patterns are more specific
+			if (aHasWild !== bHasWild) return aHasWild ? 1 : -1
+			// More segments = more specific
+			const segDiff = segmentCount(b.pattern) - segmentCount(a.pattern)
+			if (segDiff !== 0) return segDiff
+			// Slash-star (`/api/*`) is more specific than bare-star (`/api*`)
+			// because it only matches path-separated suffixes
+			const aSlashStar = a.pattern.endsWith('/*')
+			const bSlashStar = b.pattern.endsWith('/*')
+			if (aSlashStar !== bSlashStar) return aSlashStar ? -1 : 1
+			// Longer pattern string as tiebreaker
+			return b.pattern.length - a.pattern.length
+		})
+		this.sorted = true
+	}
+
+	resolve(pathname: string): RoutableManager {
+		this.ensureSorted()
+		for (const entry of this.routes) {
+			if (matchRoute(pathname, entry.pattern)) {
+				return entry.manager
+			}
+		}
+		return this.fallback
+	}
+
+	/** Check whether the given manager is the fallback (main worker). */
+	isFallback(manager: RoutableManager): boolean {
+		return manager === this.fallback
+	}
+
+	hasRoutes(): boolean {
+		return this.routes.length > 0
+	}
+
+	getRegisteredRoutes(): Array<{ pattern: string; workerName: string }> {
+		this.ensureSorted()
+		return this.routes.map(r => ({ pattern: r.pattern, workerName: r.workerName }))
+	}
+}

package/src/vite-plugin/config-plugin.ts

@@ -49,7 +49,7 @@ export function configPlugin(envName: string): Plugin {
 					watch: {
 						usePolling: true,
 						interval: 500,
-						ignored: ['**/.lopata/**', '**/.wrangler/**', '**/.react-router/**'],
+						ignored: ['**/.lopata/**', '**/.wrangler/**', '**/.react-router/**', '**/*.tmp.*'],
 					},
 				},
 				environments: {

package/src/vite-plugin/dev-server-plugin.ts

@@ -2,11 +2,12 @@ import type { IncomingMessage, ServerResponse } from 'node:http'
 import { dirname, resolve } from 'node:path'
 import type { Plugin, ViteDevServer } from 'vite'
 import { FileWatcher } from '../file-watcher.ts'
+import { RouteDispatcher } from '../route-matcher.ts'
 
 interface DevServerPluginOptions {
 	configPath?: string
 	envName: string
-	auxiliaryWorkers?: { configPath: string }[]
+	auxiliaryWorkers?: { configPath: string; name?: string }[]
 }
 
 /**
@@ -49,6 +50,9 @@ export function devServerPlugin(options: DevServerPluginOptions): Plugin {
 	let handleApiRequest: Function
 	let getTraceStore: Function
 
+	// Route dispatcher for multi-worker route-based dispatching
+	let routeDispatcher: RouteDispatcher | undefined
+
 	// Track current module to detect when Vite HMR invalidates it
 	let currentModule: Record<string, unknown> | null = null
 	// Serializes module reload — prevents concurrent wireClassRefs calls
@@ -130,6 +134,75 @@ export function devServerPlugin(options: DevServerPluginOptions): Plugin {
 		return currentModule ?? workerModule
 	}
 
+	/**
+	 * Dispatch a request through the worker's fetch() handler with tracing
+	 * and generation tracking. Throws on HMR race conditions so the caller
+	 * can retry.
+	 */
+	async function handleWorkerFetch(req: IncomingMessage, res: ServerResponse, next: Function): Promise<void> {
+		const activeModule = await ensureWorkerModule()
+		const genId = currentGenerationId
+		genActiveRequests.set(genId, (genActiveRequests.get(genId) ?? 0) + 1)
+
+		try {
+			const request = nodeReqToRequest(req)
+			const parsedUrl = new URL(request.url)
+
+			const handler = activeModule.default as Record<string, unknown>
+			if (!handler || typeof handler.fetch !== 'function') {
+				console.error('[lopata:vite] Worker module default export has no fetch() method')
+				next()
+				return
+			}
+
+			// Capture caller stack before entering the worker (for async stack stitching)
+			const callerStack = new Error()
+
+			const ctx = new ExecutionContext()
+			const response = await (startSpan as Function)({
+				name: `${request.method} ${parsedUrl.pathname}`,
+				kind: 'server',
+				attributes: { 'http.method': request.method, 'http.url': request.url, 'lopata.generation_id': genId },
+			}, () =>
+				runWithExecutionContext(ctx, async () => {
+					try {
+						const resp = await (handler.fetch as Function).call(handler, request, env, ctx) as Response
+						;(setSpanAttribute as Function)('http.status_code', resp.status)
+
+						// Intercept React Router error boundary responses with lopata error page
+						const routeError = (globalThis as any).__lopata_routeError
+						delete (globalThis as any).__lopata_routeError
+						if (routeError) {
+							if (routeError instanceof Error) {
+								stitchAsyncStack(routeError, callerStack)
+							}
+							console.error('[lopata:vite] Route error:\n' + (routeError instanceof Error ? routeError.stack : String(routeError)))
+							return (renderErrorPage as Function)(routeError, request, env, config)
+						}
+
+						ctx._awaitAll().catch(() => {})
+						return resp
+					} catch (err) {
+						if (isHmrRaceError(err)) {
+							currentModule = null
+							throw err
+						}
+						if (err instanceof Error) {
+							stitchAsyncStack(err, callerStack)
+						}
+						console.error('[lopata:vite] Request error:\n' + (err instanceof Error ? err.stack : String(err)))
+						return (renderErrorPage as Function)(err, request, env, config)
+					}
+				})) as Response
+
+			writeResponse(response, res)
+		} finally {
+			const count = genActiveRequests.get(genId) ?? 1
+			if (count <= 1) genActiveRequests.delete(genId)
+			else genActiveRequests.set(genId, count - 1)
+		}
+	}
+
 	return {
 		name: 'lopata:dev-server',
 
@@ -206,11 +279,20 @@ export function devServerPlugin(options: DevServerPluginOptions): Plugin {
 			apiMod.setDashboardConfig(config)
 
 			// 3b. Create generation tracking adapter for dashboard
-			const mainAdapter = {
+			const mainAdapter: import('../route-matcher.ts').RoutableManager & Record<string, unknown> = {
 				config,
 				gracePeriodMs: 0,
 				get active() {
-					return currentModule ? { workerModule: currentModule, env, registry } : null
+					return currentModule
+						? {
+							workerModule: currentModule,
+							env,
+							registry,
+							callFetch(_request: Request, _server: unknown) {
+								throw new Error('Main worker in Vite mode should be dispatched via handleWorkerFetch, not callFetch')
+							},
+						}
+						: null
 				},
 				list() {
 					return Array.from(viteGenerations.values()).map(g => ({
@@ -259,7 +341,7 @@ export function devServerPlugin(options: DevServerPluginOptions): Plugin {
 				},
 				setGracePeriod() {},
 			}
-			apiMod.setGenerationManager(mainAdapter as any)
+			apiMod.setGenerationManager(mainAdapter as any) // Dashboard adapter, not RoutableManager
 
 			// 4. Set up auxiliary workers (if configured)
 			if (options.auxiliaryWorkers && options.auxiliaryWorkers.length > 0) {
@@ -269,42 +351,76 @@ export function devServerPlugin(options: DevServerPluginOptions): Plugin {
 				const { GenerationManager } = await import('../generation-manager.ts')
 
 				workerRegistry = new WorkerRegistry()
-				workerRegistry.register(config.name, mainAdapter as any, true)
+				workerRegistry.register(config.name, mainAdapter as any, true) // Dashboard adapter
 
+				const auxConfigs = new Map<string, { config: any; name: string }>()
 				for (const workerDef of options.auxiliaryWorkers) {
 					const auxConfigPath = resolve(projectRoot, workerDef.configPath)
 					const auxBaseDir = dirname(auxConfigPath)
 					const auxConfig = await configMod.loadConfig(auxConfigPath)
-					console.log(`[lopata:vite] Auxiliary worker: ${auxConfig.name}`)
+					const workerName = workerDef.name ?? auxConfig.name
+					auxConfigs.set(workerDef.configPath, { config: auxConfig, name: workerName })
+					console.log(`[lopata:vite] Auxiliary worker: ${workerName}`)
 
 					const auxManager = new GenerationManager(auxConfig, auxBaseDir, {
-						workerName: auxConfig.name,
+						workerName,
 						workerRegistry,
 						isMain: false,
 					})
-					workerRegistry.register(auxConfig.name, auxManager)
+					workerRegistry.register(workerName, auxManager)
 
 					try {
 						const gen = await auxManager.reload()
-						console.log(`[lopata:vite] Auxiliary worker "${auxConfig.name}" loaded (gen ${gen.id})`)
+						console.log(`[lopata:vite] Auxiliary worker "${workerName}" loaded (gen ${gen.id})`)
 					} catch (err) {
-						console.error(`[lopata:vite] Failed to load auxiliary worker "${auxConfig.name}":`, err)
+						console.error(`[lopata:vite] Failed to load auxiliary worker "${workerName}":`, err)
 					}
 
 					// File watcher for aux worker reload
 					const auxSrcDir = dirname(resolve(auxBaseDir, auxConfig.main))
 					const auxWatcher = new FileWatcher(auxSrcDir, () => {
-						auxManager.reload().then(gen => {
-							console.log(`[lopata:vite] Auxiliary worker "${auxConfig.name}" reloaded → generation ${gen.id}`)
+						auxManager.reload().then(async gen => {
+							console.log(`[lopata:vite] Auxiliary worker "${workerName}" reloaded → generation ${gen.id}`)
+							// Re-read config and update routes in case routes changed
+							if (routeDispatcher) {
+								try {
+									const freshConfig = await configMod.loadConfig(auxConfigPath)
+									routeDispatcher.addRoutes(freshConfig, auxManager, workerName)
+								} catch (err) {
+									console.warn(`[lopata:vite] Failed to re-read config for "${workerName}" routes:`, err)
+								}
+							}
 						}).catch(err => {
-							console.error(`[lopata:vite] Reload failed for "${auxConfig.name}":`, err)
+							console.error(`[lopata:vite] Reload failed for "${workerName}":`, err)
 						})
 					})
 					auxWatcher.start()
-					console.log(`[lopata:vite] Watching ${auxSrcDir} for changes (${auxConfig.name})`)
+					console.log(`[lopata:vite] Watching ${auxSrcDir} for changes (${workerName})`)
 				}
 
 				apiMod.setWorkerRegistry(workerRegistry)
+
+				// Warn if main worker has routes — they are ignored because main is the fallback
+				if (config.routes && config.routes.length > 0) {
+					console.warn(
+						'[lopata:vite] Warning: main worker has "routes" in config — these are ignored (main worker is the fallback for unmatched requests)',
+					)
+				}
+
+				// Build route dispatcher for aux workers with routes (main worker is the fallback)
+				routeDispatcher = new RouteDispatcher(mainAdapter)
+				for (const workerDef of options.auxiliaryWorkers) {
+					const cached = auxConfigs.get(workerDef.configPath)
+					if (!cached) continue
+					const auxMgr = workerRegistry.getManager(cached.name)
+					if (auxMgr) routeDispatcher.addRoutes(cached.config, auxMgr, cached.name)
+				}
+				if (routeDispatcher.hasRoutes()) {
+					for (const r of routeDispatcher.getRegisteredRoutes()) {
+						console.log(`[lopata:vite] Route: ${r.pattern} → ${r.workerName}`)
+					}
+				}
+				apiMod.setRouteDispatcher(routeDispatcher)
 			}
 
 			// 5. Set up WebSocket trace streaming on httpServer
@@ -355,68 +471,52 @@ export function devServerPlugin(options: DevServerPluginOptions): Plugin {
 						return
 					}
 
-					try {
-						const activeModule = await ensureWorkerModule()
-						const genId = currentGenerationId
-						genActiveRequests.set(genId, (genActiveRequests.get(genId) ?? 0) + 1)
-
-						try {
-							const request = nodeReqToRequest(req)
-							const parsedUrl = new URL(request.url)
-
-							const handler = activeModule.default as Record<string, unknown>
-							if (!handler || typeof handler.fetch !== 'function') {
-								console.error('[lopata:vite] Worker module default export has no fetch() method')
-								return next()
+					// Route-based dispatch: if an aux worker matches, use its GenerationManager directly
+					if (routeDispatcher) {
+						const parsedUrl = new URL(url, 'http://localhost')
+						const targetManager = routeDispatcher.resolve(parsedUrl.pathname)
+						// If the resolved manager is not the main adapter, dispatch via aux worker
+						if (!routeDispatcher.isFallback(targetManager)) {
+							const gen = targetManager.active
+							if (!gen) {
+								if (!res.headersSent) {
+									res.writeHead(503, { 'content-type': 'text/plain' })
+									res.end('No active generation for matched route')
+								}
+								return
 							}
-
-							// Capture caller stack before entering the worker (for async stack stitching)
-							const callerStack = new Error()
-
-							const ctx = new ExecutionContext()
-							const response = await (startSpan as Function)({
-								name: `${request.method} ${parsedUrl.pathname}`,
-								kind: 'server',
-								attributes: { 'http.method': request.method, 'http.url': request.url, 'lopata.generation_id': genId },
-							}, () =>
-								runWithExecutionContext(ctx, async () => {
-									try {
-										const resp = await (handler.fetch as Function).call(handler, request, env, ctx) as Response
-										;(setSpanAttribute as Function)('http.status_code', resp.status)
-
-										// Intercept React Router error boundary responses with lopata error page
-										const routeError = (globalThis as any).__lopata_routeError
-										delete (globalThis as any).__lopata_routeError
-										if (routeError) {
-											if (routeError instanceof Error) {
-												stitchAsyncStack(routeError, callerStack)
-											}
-											console.error('[lopata:vite] Route error:\n' + (routeError instanceof Error ? routeError.stack : String(routeError)))
-											return (renderErrorPage as Function)(routeError, request, env, config)
-										}
-
-										ctx._awaitAll().catch(() => {})
-										return resp
-									} catch (err) {
-										if (err instanceof Error) {
-											stitchAsyncStack(err, callerStack)
-										}
-										console.error('[lopata:vite] Request error:\n' + (err instanceof Error ? err.stack : String(err)))
-										return (renderErrorPage as Function)(err, request, env, config)
-									}
-								})) as Response
-
-							writeResponse(response, res)
-						} finally {
-							const count = genActiveRequests.get(genId) ?? 1
-							if (count <= 1) genActiveRequests.delete(genId)
-							else genActiveRequests.set(genId, count - 1)
+							try {
+								const request = nodeReqToRequest(req)
+								const response = await (startSpan as Function)({
+									name: `${request.method} ${parsedUrl.pathname}`,
+									kind: 'server',
+									attributes: { 'http.method': request.method, 'http.url': request.url, 'lopata.worker': (targetManager as any).config?.name ?? 'aux' },
+								}, async () => {
+									const resp = await gen.callFetch(request, null) as Response
+									;(setSpanAttribute as Function)('http.status_code', resp.status)
+									return resp
+								}) as Response
+								writeResponse(response, res)
+							} catch (err) {
+								writeRequestError(res, err)
+							}
+							return
 						}
+					}
+
+					try {
+						await handleWorkerFetch(req, res, next)
 					} catch (err) {
-						console.error('[lopata:vite] Request error:', err)
-						if (!res.headersSent) {
-							res.writeHead(500, { 'content-type': 'text/plain' })
-							res.end(err instanceof Error ? err.stack ?? err.message : String(err))
+						if (!isHmrRaceError(err)) {
+							writeRequestError(res, err)
+							return
+						}
+						// Retry once after a short delay — module graph may be mid-evaluation during HMR
+						await new Promise((resolve) => setTimeout(resolve, 200))
+						try {
+							await handleWorkerFetch(req, res, next)
+						} catch (retryErr) {
+							writeRequestError(res, retryErr)
 						}
 					}
 				})
@@ -552,6 +652,42 @@ export function devServerPlugin(options: DevServerPluginOptions): Plugin {
 		try {
 			const { CFWebSocket } = await import('../bindings/websocket-pair.ts')
 
+			const request = nodeReqToRequest(req)
+			const parsedUrl = new URL(request.url)
+
+			// Route-based dispatch: if an aux worker matches, delegate the WebSocket upgrade to it
+			if (routeDispatcher) {
+				const targetManager = routeDispatcher.resolve(parsedUrl.pathname)
+				if (!routeDispatcher.isFallback(targetManager)) {
+					const gen = targetManager.active
+					if (!gen) {
+						socket.destroy()
+						return
+					}
+					const response = await (startSpan as Function)({
+						name: `WS ${parsedUrl.pathname}`,
+						kind: 'server',
+						attributes: {
+							'http.method': 'GET',
+							'http.url': request.url,
+							'lopata.worker': (targetManager as any).config?.name ?? 'aux',
+							'lopata.websocket': true,
+						},
+					}, async () => {
+						return gen.callFetch(request, null) as Promise<Response & { webSocket?: InstanceType<typeof CFWebSocket> }>
+					}) as Response & { webSocket?: InstanceType<typeof CFWebSocket> }
+					const cfSocket = response.webSocket
+					if (response.status !== 101 || !cfSocket || !(cfSocket instanceof CFWebSocket)) {
+						socket.destroy()
+						return
+					}
+					wss.handleUpgrade(req, socket, head, (ws: any) => {
+						bridgeCfWebSocket(cfSocket, ws)
+					})
+					return
+				}
+			}
+
 			const activeModule = await ensureWorkerModule()
 			const handler = activeModule.default as Record<string, unknown>
 			if (!handler || typeof handler.fetch !== 'function') {
@@ -559,7 +695,6 @@ export function devServerPlugin(options: DevServerPluginOptions): Plugin {
 				return
 			}
 
-			const request = nodeReqToRequest(req)
 			const ctx = new ExecutionContext()
 			const response = await runWithExecutionContext(ctx, async () => {
 				return (handler.fetch as Function).call(handler, request, env, ctx) as Response
@@ -573,47 +708,7 @@ export function devServerPlugin(options: DevServerPluginOptions): Plugin {
 
 			// Complete the upgrade and bridge
 			wss.handleUpgrade(req, socket, head, (ws: any) => {
-				// CF → real WS
-				cfSocket.addEventListener('message', (ev: Event) => {
-					const msgData = (ev as MessageEvent).data
-					try {
-						ws.send(msgData)
-					} catch {}
-				})
-				cfSocket.addEventListener('close', (ev: Event) => {
-					const ce = ev as CloseEvent
-					try {
-						ws.close(ce.code, ce.reason)
-					} catch {}
-				})
-				// Accept the client side so events from server.send() are dispatched
-				cfSocket.accept()
-
-				// Real WS → CF
-				ws.on('message', (data: Buffer, isBinary: boolean) => {
-					const msgData = isBinary
-						? data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength) as ArrayBuffer
-						: data.toString('utf-8')
-					const evt = { type: 'message' as const, data: msgData }
-					if (cfSocket._peer?._accepted) {
-						cfSocket._peer._dispatchWSEvent(evt)
-					} else if (cfSocket._peer) {
-						cfSocket._peer._eventQueue.push(evt)
-					}
-				})
-
-				ws.on('close', (code: number, reason: Buffer) => {
-					if (cfSocket._peer && cfSocket._peer.readyState !== 3) {
-						const evt = { type: 'close' as const, code: code ?? 1000, reason: reason?.toString('utf-8') ?? '', wasClean: true }
-						if (cfSocket._peer._accepted) {
-							cfSocket._peer._dispatchWSEvent(evt)
-						} else {
-							cfSocket._peer._eventQueue.push(evt)
-						}
-						cfSocket._peer.readyState = 3
-					}
-					cfSocket.readyState = 3
-				})
+				bridgeCfWebSocket(cfSocket, ws)
 			})
 		} catch (err) {
 			console.error('[lopata:vite] Worker WebSocket upgrade failed:', err)
@@ -622,6 +717,19 @@ export function devServerPlugin(options: DevServerPluginOptions): Plugin {
 	}
 }
 
+/** Detect transient TypeError from Vite module graph being mid-evaluation during HMR */
+function isHmrRaceError(err: unknown): boolean {
+	return err instanceof TypeError && err.message.includes('not be null or undefined')
+}
+
+function writeRequestError(res: ServerResponse, err: unknown): void {
+	console.error('[lopata:vite] Request error:', err)
+	if (!res.headersSent) {
+		res.writeHead(500, { 'content-type': 'text/plain' })
+		res.end(err instanceof Error ? err.stack ?? err.message : String(err))
+	}
+}
+
 function stitchAsyncStack(err: Error, callerError: Error | null): void {
 	if (!callerError) return
 	if (!err.stack || !callerError.stack) return
@@ -638,6 +746,51 @@ function stitchAsyncStack(err: Error, callerError: Error | null): void {
 	err.stack += '\n    --- async ---\n' + filtered.join('\n')
 }
 
+/** Bridge a CFWebSocket (from worker response) to a real ws WebSocket. */
+function bridgeCfWebSocket(cfSocket: any, ws: any): void {
+	// CF → real WS
+	cfSocket.addEventListener('message', (ev: Event) => {
+		const msgData = (ev as MessageEvent).data
+		try {
+			ws.send(msgData)
+		} catch {}
+	})
+	cfSocket.addEventListener('close', (ev: Event) => {
+		const ce = ev as CloseEvent
+		try {
+			ws.close(ce.code, ce.reason)
+		} catch {}
+	})
+	// Accept the client side so events from server.send() are dispatched
+	cfSocket.accept()
+
+	// Real WS → CF
+	ws.on('message', (data: Buffer, isBinary: boolean) => {
+		const msgData = isBinary
+			? data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength) as ArrayBuffer
+			: data.toString('utf-8')
+		const evt = { type: 'message' as const, data: msgData }
+		if (cfSocket._peer?._accepted) {
+			cfSocket._peer._dispatchWSEvent(evt)
+		} else if (cfSocket._peer) {
+			cfSocket._peer._eventQueue.push(evt)
+		}
+	})
+
+	ws.on('close', (code: number, reason: Buffer) => {
+		if (cfSocket._peer && cfSocket._peer.readyState !== 3) {
+			const evt = { type: 'close' as const, code: code ?? 1000, reason: reason?.toString('utf-8') ?? '', wasClean: true }
+			if (cfSocket._peer._accepted) {
+				cfSocket._peer._dispatchWSEvent(evt)
+			} else {
+				cfSocket._peer._eventQueue.push(evt)
+			}
+			cfSocket._peer.readyState = 3
+		}
+		cfSocket.readyState = 3
+	})
+}
+
 function matchGlob(text: string, pattern: string): boolean {
 	const regex = pattern
 		.replace(/\*\*/g, '\0')

package/src/vite-plugin/index.ts

@@ -11,7 +11,7 @@ export interface LopataPluginConfig {
 	/** Vite environment name for SSR. Default: "ssr" */
 	viteEnvironment?: { name?: string }
 	/** Auxiliary workers loaded via native Bun import (not through Vite). */
-	auxiliaryWorkers?: { configPath: string }[]
+	auxiliaryWorkers?: { configPath: string; name?: string }[]
 }
 
 /**