@junejs/server 1.0.0-dev.42 → 1.0.0-dev.45

package/dist/router.js

@@ -1,3 +1,4 @@
+import { compareSegments, parseSegment } from "./route-rank.js";
 import { existsSync } from "node:fs";
 import { readdir } from "node:fs/promises";
 import { join, relative, sep } from "node:path";
@@ -42,11 +43,11 @@ function isSpecialFile(file) {
 	return SPECIAL_FILES.has(baseName(file));
 }
 const isRouteGroup = (name) => /^\(.+\)$/.test(name);
-const isParamDir = (name) => /^\[([A-Za-z_][A-Za-z0-9_]*)\]$/.test(name);
-const isOptionalDir = (name) => /^\[\[([A-Za-z_][A-Za-z0-9_]*)\]\]$/.test(name);
-const isOptionalCatchAllDir = (name) => /^\[\[\.\.\.([A-Za-z_][A-Za-z0-9_]*)\]\]$/.test(name);
-const isCatchAllDir = (name) => /^\[\.\.\.([A-Za-z_][A-Za-z0-9_]*)\]$/.test(name);
-const paramName = (name) => name.replace(/^\[+(\.\.\.)?|\]+$/g, "");
+const isParamDir = (name) => parseSegment(name).kind === "param";
+const isOptionalDir = (name) => parseSegment(name).kind === "optional";
+const isOptionalCatchAllDir = (name) => parseSegment(name).kind === "optionalCatchAll";
+const isCatchAllDir = (name) => parseSegment(name).kind === "catchAll";
+const paramName = (name) => parseSegment(name).name;
 async function listDir(dir) {
 	return (await readdir(dir, { withFileTypes: true }).catch(() => [])).filter((e) => !e.name.startsWith("_") && !e.name.startsWith(".")).map((e) => ({
 		name: e.name,
@@ -84,63 +85,76 @@ function routePath(appDir, file) {
 }
 async function matchRouteTree(appDir, pathname, options = {}) {
 	const urlSegments = pathname.split("/").filter(Boolean).map(decodeURIComponent);
-	async function descend(dir, rest, params, chain) {
-		const entries = await listDir(dir);
+	async function levelAt(dir, chain) {
+		const entries = (await listDir(dir)).sort((a, b) => compareSegments(a.name, b.name));
 		const segments = [...chain, segmentAt(dir, entries)];
-		if (rest.length === 0) {
-			const page = fileFor(entries, dir, "page") ?? fileFor(entries, dir, "index") ?? fileFor(entries, dir, "route");
-			if (page) return {
-				file: page,
+		const levels = [{
+			dir,
+			entries,
+			segments
+		}];
+		for (const e of entries) if (e.dir && isRouteGroup(e.name)) levels.push(...await levelAt(join(dir, e.name), segments));
+		return levels;
+	}
+	async function descend(nodes, rest, params) {
+		const levels = (await Promise.all(nodes.map((n) => levelAt(n.dir, n.chain)))).flat();
+		if (rest.length === 0) for (const base of [["page", "index"], ["route"]]) for (const { dir: d, entries, segments } of levels) {
+			const file = base.map((b) => fileFor(entries, d, b)).find(Boolean);
+			if (file) return {
+				file,
 				params,
 				segments
 			};
-		} else if (!options.pageConvention) {
-			if (rest.length === 1) {
-				const leaf = fileFor(entries, dir, rest[0]);
-				if (leaf && !isSpecialFile(leaf) && !isPageFile(leaf)) return {
-					file: leaf,
-					params,
-					segments
-				};
-			}
 		}
-		for (const e of entries) {
-			if (!e.dir || !isRouteGroup(e.name)) continue;
-			const hit = await descend(join(dir, e.name), rest, params, segments);
-			if (hit) return hit;
+		else if (!options.pageConvention && rest.length === 1) for (const { dir: d, entries, segments } of levels) {
+			const leaf = fileFor(entries, d, rest[0]);
+			if (leaf && !isSpecialFile(leaf) && !isPageFile(leaf)) return {
+				file: leaf,
+				params,
+				segments
+			};
+		}
+		const children = /* @__PURE__ */ new Map();
+		for (const lv of levels) for (const e of lv.entries) {
+			if (!e.dir || isRouteGroup(e.name)) continue;
+			const node = {
+				dir: join(lv.dir, e.name),
+				chain: lv.segments
+			};
+			const same = children.get(e.name);
+			if (same) same.push(node);
+			else children.set(e.name, [node]);
 		}
+		const names = [...children.keys()].sort(compareSegments);
 		if (rest.length === 0) {
-			for (const e of entries) {
-				if (!e.dir || !(isOptionalDir(e.name) || isOptionalCatchAllDir(e.name))) continue;
-				const hit = await descend(join(dir, e.name), [], params, segments);
+			for (const name of names) {
+				if (!(isOptionalDir(name) || isOptionalCatchAllDir(name))) continue;
+				const hit = await descend(children.get(name), [], params);
 				if (hit) return hit;
 			}
 			return null;
 		}
 		const [head, ...tail] = rest;
-		if (entries.find((e) => e.dir && e.name === head)) {
-			const hit = await descend(join(dir, head), tail, params, segments);
-			if (hit) return hit;
-		}
-		for (const e of entries) {
-			if (!e.dir || !(isParamDir(e.name) || isOptionalDir(e.name))) continue;
-			const hit = await descend(join(dir, e.name), tail, {
+		for (const name of names) {
+			const into = children.get(name);
+			let hit = null;
+			if (isParamDir(name) || isOptionalDir(name)) hit = await descend(into, tail, {
 				...params,
-				[paramName(e.name)]: head
-			}, segments);
-			if (hit) return hit;
-		}
-		for (const e of entries) {
-			if (!e.dir || !(isCatchAllDir(e.name) || isOptionalCatchAllDir(e.name))) continue;
-			const hit = await descend(join(dir, e.name), [], {
+				[paramName(name)]: head
+			});
+			else if (isCatchAllDir(name) || isOptionalCatchAllDir(name)) hit = await descend(into, [], {
 				...params,
-				[paramName(e.name)]: rest.join("/")
-			}, segments);
+				[paramName(name)]: rest.join("/")
+			});
+			else if (name === head) hit = await descend(into, tail, params);
 			if (hit) return hit;
 		}
 		return null;
 	}
-	return descend(appDir, urlSegments, {}, []);
+	return descend([{
+		dir: appDir,
+		chain: []
+	}], urlSegments, {});
 }
 async function resolveNotFound(appDir, pathname) {
 	const urlSegments = pathname.split("/").filter(Boolean).map(decodeURIComponent);

package/dist/{worker-Dv4l6Ybs.d.ts → worker-2qbQjj2c.d.ts}

@@ -20,6 +20,7 @@ type WorkerManifest = {
     pattern: string;
     handler: ResourceHandler;
   }>;
+  generatedRoutes?: string[];
   layoutChains?: Record<string, LayoutComponent[]>;
   layoutBoundaries?: Record<string, {
     index: number;

package/dist/worker.d.ts

@@ -1,2 +1,2 @@
-import { a as withDenoAssets, i as withAssets, n as WorkerManifest, r as createWorker, t as WorkerExecutionContext } from "./worker-Dv4l6Ybs.js";
+import { a as withDenoAssets, i as withAssets, n as WorkerManifest, r as createWorker, t as WorkerExecutionContext } from "./worker-2qbQjj2c.js";
 export { WorkerExecutionContext, WorkerManifest, createWorker, withAssets, withDenoAssets };

package/dist/worker.js

@@ -1,4 +1,5 @@
 import { durableAgentSurface, durableChannelSurface } from "./agent-durable.js";
+import { compareRoutePatterns, parseSegment } from "./route-rank.js";
 import { acceptTarget } from "./negotiate.js";
 import { createPipeline } from "./pipeline.js";
 import { RESERVED_PREFIX, contentTypeFor, safeRelativePath } from "./static-files.js";
@@ -8,34 +9,16 @@ function compilePattern(pattern) {
 	let source = "";
 	let allOptional = true;
 	for (const seg of pattern.split("/").filter(Boolean)) {
-		const oca = seg.match(/^\[\[\.\.\.(\w+)\]\]$/);
-		if (oca) {
-			names.push(oca[1]);
-			source += "(?:/(.+))?";
-			continue;
-		}
-		const ca = seg.match(/^\[\.\.\.(\w+)\]$/);
-		if (ca) {
-			names.push(ca[1]);
-			source += "/(.+)";
-			allOptional = false;
-			continue;
-		}
-		const op = seg.match(/^\[\[(\w+)\]\]$/);
-		if (op) {
-			names.push(op[1]);
-			source += "(?:/([^/]+))?";
-			continue;
-		}
-		const p = seg.match(/^\[(\w+)\]$/);
-		if (p) {
-			names.push(p[1]);
-			source += "/([^/]+)";
+		const { kind, name } = parseSegment(seg);
+		if (name) names.push(name);
+		if (kind === "optionalCatchAll") source += "(?:/(.+))?";
+		else if (kind === "optional") source += "(?:/([^/]+))?";
+		else {
+			if (kind === "catchAll") source += "/(.+)";
+			else if (kind === "param") source += "/([^/]+)";
+			else source += "/" + seg.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 			allOptional = false;
-			continue;
 		}
-		source += "/" + seg.replace(/[.*+?^${}()|\\]/g, "\\$&");
-		allOptional = false;
 	}
 	if (source === "") return {
 		regex: /^\/$/,
@@ -47,20 +30,42 @@ function compilePattern(pattern) {
 	};
 }
 function createWorker(manifest, opts = {}) {
-	const dynamic = (manifest.dynamicRoutes ?? []).map((d) => ({
-		...compilePattern(d.pattern),
-		def: d.def,
-		pattern: d.pattern
-	}));
-	const resources = (manifest.resourceRoutes ?? []).map((r) => ({
-		...compilePattern(r.pattern),
-		handler: r.handler,
-		pattern: r.pattern
-	}));
+	const generated = new Set(manifest.generatedRoutes ?? []);
+	const row = (pattern) => ({
+		...compilePattern(pattern),
+		pattern,
+		generated: generated.has(pattern)
+	});
+	const table = [
+		...Object.entries(manifest.routes).map(([pattern, def]) => ({
+			...row(pattern),
+			def
+		})),
+		...(manifest.dynamicRoutes ?? []).map((d) => ({
+			...row(d.pattern),
+			def: d.def
+		})),
+		...(manifest.resourceRoutes ?? []).map((r) => ({
+			...row(r.pattern),
+			handler: r.handler
+		}))
+	];
+	table.sort((a, b) => Number(a.generated) - Number(b.generated) || compareRoutePatterns(a.pattern, b.pattern) || Number(!!a.handler) - Number(!!b.handler));
 	const routeList = [...Object.keys(manifest.routes), ...(manifest.dynamicRoutes ?? []).map((d) => d.pattern)].sort();
 	const chainFor = (key) => manifest.layoutChains?.[key] ?? [];
 	const loadingFor = (key) => manifest.loadings?.[key];
 	const boundaryFor = (key) => manifest.layoutBoundaries?.[key] ?? null;
+	const resolvedPage = (def, key, params) => {
+		const b = boundaryFor(key);
+		return {
+			def,
+			params,
+			chain: chainFor(key),
+			boundaryIndex: b?.index ?? null,
+			boundaryKey: b?.key ?? null,
+			loading: loadingFor(key)
+		};
+	};
 	let currentEnv;
 	const requestLocals = /* @__PURE__ */ new WeakMap();
 	const provider = manifest.resources;
@@ -102,47 +107,18 @@ function createWorker(manifest, opts = {}) {
 		services: servicesProvider ? () => (servicesCache ??= { v: servicesProvider(currentEnv) }).v : void 0,
 		resolve: async (pathname) => {
 			const staticDef = manifest.routes[pathname];
-			if (staticDef) {
-				const b = boundaryFor(pathname);
-				return {
-					def: staticDef,
-					params: {},
-					chain: chainFor(pathname),
-					boundaryIndex: b?.index ?? null,
-					boundaryKey: b?.key ?? null,
-					loading: loadingFor(pathname)
-				};
-			}
-			for (const d of dynamic) {
-				const m = pathname.match(d.regex);
-				if (m) {
-					const params = Object.fromEntries(d.names.flatMap((n, i) => {
-						const v = m[i + 1];
-						return v === void 0 ? [] : [[n, decodeURIComponent(v)]];
-					}));
-					const b = boundaryFor(d.pattern);
-					return {
-						def: d.def,
-						params,
-						chain: chainFor(d.pattern),
-						boundaryIndex: b?.index ?? null,
-						boundaryKey: b?.key ?? null,
-						loading: loadingFor(d.pattern)
-					};
-				}
-			}
-			for (const r of resources) {
+			if (staticDef && !generated.has(pathname)) return resolvedPage(staticDef, pathname, {});
+			for (const r of table) {
 				const m = pathname.match(r.regex);
-				if (m) {
-					const params = Object.fromEntries(r.names.flatMap((n, i) => {
-						const v = m[i + 1];
-						return v === void 0 ? [] : [[n, decodeURIComponent(v)]];
-					}));
-					return {
-						handler: r.handler,
-						params
-					};
-				}
+				if (!m) continue;
+				const params = Object.fromEntries(r.names.flatMap((n, i) => {
+					const v = m[i + 1];
+					return v === void 0 ? [] : [[n, decodeURIComponent(v)]];
+				}));
+				return r.handler ? {
+					handler: r.handler,
+					params
+				} : resolvedPage(r.def, r.pattern, params);
 			}
 			return null;
 		}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@junejs/server",
-  "version": "1.0.0-dev.42",
+  "version": "1.0.0-dev.45",
   "description": "June host adapters + dev server. Host-coupled; depends on the pure @junejs/core contract layer.",
   "type": "module",
   "license": "MIT",
@@ -136,11 +136,11 @@
     "@momiji-rs/sparkdown": "^0.0.4",
     "@resvg/resvg-wasm": "^2.6.2",
     "lightningcss": "^1.27.0",
-    "oxc-parser": "^0.151.0",
+    "oxc-parser": "^0.152.0",
     "rolldown": "^1.1.0"
   },
   "peerDependencies": {
-    "@junejs/core": ">=0.2.0-dev.63",
+    "@junejs/core": ">=0.2.0-dev.65",
     "react": "^19.2.0",
     "react-dom": "^19.2.0",
     "react-server-dom-webpack": "19.3.0",

package/src/agent-native.ts

@@ -141,6 +141,7 @@ class AnnouncementRetry {
   // Explicit fields (not parameter properties) — keep the shipped source erasable.
   private readonly flush: (agent: string, id: string) => void;
   private readonly state = new Map<string, { failures: number; timer?: ReturnType<typeof setTimeout> }>();
+  private stopped = false;
   constructor(flush: (agent: string, id: string) => void) {
     this.flush = flush;
   }
@@ -150,6 +151,7 @@ class AnnouncementRetry {
     this.state.delete(key);
   }
   failed(key: string, agent: string, id: string) {
+    if (this.stopped) return; // the runtime is closed: nothing retries into it
     const s = this.state.get(key) ?? { failures: 0 };
     this.state.set(key, s);
     if (s.timer) return; // one retry pending at a time
@@ -158,8 +160,20 @@ class AnnouncementRetry {
     s.timer = setTimeout(() => { s.timer = undefined; this.flush(agent, id); }, delay);
     (s.timer as { unref?: () => void }).unref?.();
   }
+  // Cancel every pending retry, for good (#317): unref only keeps a timer from holding the
+  // process open — it still fires while the process lives, into a runtime (and a db) that
+  // is gone.
+  stop() {
+    this.stopped = true;
+    for (const s of this.state.values()) if (s.timer) clearTimeout(s.timer);
+    this.state.clear();
+  }
 }
 
+// SQLite handles a runtime opened itself (createNativeRuntime), so close() closes those and
+// never one a caller passed in.
+const ownedDbs = new WeakSet<SyncSqlite>();
+
 // Install the announcement hook on a freshly built session and deliver what an earlier life
 // of it recorded but never delivered (#260). The flush never rejects; it logs — and a
 // failure schedules a retry.
@@ -223,6 +237,7 @@ export class NativeRuntime implements Runtime {
   // Retries failed announcement deliveries (#260), across actor rebuilds.
   private readonly announceRetry = new AnnouncementRetry((agent, id) => { void this.session(agent, id).flushAnnouncements(); });
   private readonly maxSessions: number;
+  private closing: Promise<void> | undefined; // set by close() (#317)
 
   constructor(agents: Record<string, AgentDef>, db: SyncSqlite, opts: NativeRuntimeOptions = {}) {
     assertCoreRuntimeVersion("NativeRuntime"); // #94: fail power-on, not mid-turn
@@ -244,6 +259,9 @@ export class NativeRuntime implements Runtime {
   session(agent: string, id: string): AgentSession {
     const key = `${agent}:${id}`;
     const hit = this.actors.get(key);
+    // A closing runtime still serves the actors it has (their turns are finishing), but
+    // builds no new one.
+    if (!hit && this.closing) throw new Error(`NativeRuntime is closed: cannot open session "${key}"`);
     if (hit) {
       // most recently used → the tail (Map iteration order is insertion order)
       this.actors.delete(key);
@@ -276,6 +294,29 @@ export class NativeRuntime implements Runtime {
     }
   }
 
+  // Shut the runtime down (#317). Pending announcement retries are cancelled and no new
+  // session opens at once; then it waits until every actor is idle — a running turn or an
+  // announcement delivery in flight still writes the store after its hook or model call
+  // returns — before dropping the actors and closing the SQLite handle createNativeRuntime
+  // opened (a db passed to the constructor stays the caller's). So it resolves only after
+  // in-flight work finishes. Call it before discarding a runtime in a process that keeps
+  // running (a test suite, a host that swaps runtimes), or a retry fires later against a
+  // closed or deleted database. Safe to call twice: both calls resolve together.
+  close(): Promise<void> {
+    this.closing ??= (async () => {
+      this.announceRetry.stop();
+      while ([...this.actors.values()].some((a) => !a.session.idle())) {
+        await new Promise((r) => setTimeout(r, 10));
+      }
+      this.actors.clear();
+      if (ownedDbs.has(this.db)) {
+        ownedDbs.delete(this.db);
+        this.db.close();
+      }
+    })();
+    return this.closing;
+  }
+
   // Drop least recently used idle actors until one more fits under the cap. Runs before
   // the new actor is inserted, so the actor being handed out is never a candidate.
   private evictIdle() {
@@ -295,9 +336,24 @@ export async function createNativeRuntime(
   path = ":memory:",
   opts: NativeRuntimeOptions = {},
 ): Promise<NativeRuntime> {
-  const runtime = new NativeRuntime(agents, await openLocalSqliteSync(path), opts);
-  runtime.recoverAnnouncements(); // #260
-  return runtime;
+  const db = await openLocalSqliteSync(path);
+  ownedDbs.add(db);
+  let runtime: NativeRuntime | undefined;
+  try {
+    runtime = new NativeRuntime(agents, db, opts);
+    runtime.recoverAnnouncements(); // #260
+    return runtime;
+  } catch (err) {
+    // Nobody else holds this handle (a bad maxSessions, unreadable leftovers). A recovery
+    // that failed part-way may already have deliveries in flight, so go through close(),
+    // which waits for them before closing the db.
+    if (runtime) await runtime.close();
+    else {
+      ownedDbs.delete(db);
+      db.close();
+    }
+    throw err;
+  }
 }
 
 // ── memory backend — in-process, ephemeral (no DB, no disk) ───────────────────
@@ -340,6 +396,7 @@ export class MemoryRuntime implements Runtime {
   private stores = new Map<string, MemorySessionStore>();
   private readonly agents: Record<string, AgentDef>;
   private readonly announceRetry = new AnnouncementRetry((agent, id) => { void this.session(agent, id).flushAnnouncements(); }); // #260
+  private closed = false; // set by close() (#317)
   constructor(agents: Record<string, AgentDef>) {
     assertCoreRuntimeVersion("MemoryRuntime"); // #94: fail power-on, not mid-turn
     this.agents = agents;
@@ -349,6 +406,7 @@ export class MemoryRuntime implements Runtime {
     const key = `${agent}:${id}`;
     let a = this.actors.get(key);
     if (!a) {
+      if (this.closed) throw new Error(`MemoryRuntime is closed: cannot open session "${key}"`);
       const def = this.agents[agent];
       if (!def) throw new Error(`unknown agent: ${agent}`);
       const store = new MemorySessionStore();
@@ -360,6 +418,16 @@ export class MemoryRuntime implements Runtime {
     }
     return a;
   }
+  // Shut the runtime down (#317): cancel pending announcement retries and open no new
+  // session. The state is the actors themselves, so they are dropped too; with no store
+  // to close there is nothing to wait for — work still in flight finishes against its own
+  // in-memory store. Safe to call twice.
+  async close(): Promise<void> {
+    this.closed = true;
+    this.announceRetry.stop();
+    this.actors.clear();
+    this.stores.clear();
+  }
 }
 
 // The selectable agent-runtime backends. `native` (SQLite via june/host, durable
@@ -371,10 +439,13 @@ export type AgentBackend = "native" | "memory" | "durable";
 // Build an in-process runtime for the chosen backend. Throws for `durable` (that
 // target is the DO the worker constructs, not an in-process object) — so the
 // choice is explicit and a mis-selection fails loudly.
+// An in-process runtime: a Runtime the host owns, so it can shut it down (#317).
+export type InProcessRuntime = Runtime & { close(): Promise<void> };
+
 export async function createAgentRuntime(
   agents: Record<string, AgentDef>,
   opts: { backend?: AgentBackend; path?: string; maxSessions?: number } = {},
-): Promise<Runtime> {
+): Promise<InProcessRuntime> {
   const backend = opts.backend ?? "native";
   if (backend === "memory") return new MemoryRuntime(agents);
   if (backend === "native") return createNativeRuntime(agents, opts.path, { maxSessions: opts.maxSessions });

package/src/app.ts

@@ -27,9 +27,10 @@ import type { DocumentConfig } from "@junejs/core/document";
 import { runWithTrace, type RequestTrace } from "@junejs/core/instrumentation";
 
 import { findMiddlewareFile, isResourceFile, listRoutes, matchRouteTree, resolveNotFound, routeFiles, type SegmentMatch } from "./router";
+import { routeProblems, scanRoutes } from "./route-scan";
 import { createPipeline, type ExtraHandler, type LayoutComponent, type MiddlewareHandler, type Pipeline, type Resolved, type ResourceHandler } from "./pipeline";
 import { discoverAgent } from "./agent-discover";
-import { createAgentRuntime, mountAgent, toAgentDef } from "./agent-native";
+import { createAgentRuntime, mountAgent, toAgentDef, type InProcessRuntime } from "./agent-native";
 import { anthropic } from "@junejs/core/agent-models";
 import { resolveBoundary } from "./segment";
 import { memoizeResources } from "./resources";
@@ -65,6 +66,10 @@ export type JuneApp = {
   warmup(): Promise<void>;
   routePaths(): Promise<string[]>;
   earlyHints(): string[];
+  // Shut down what the app started (#317): the agent runtime built for an agent/
+  // directory — its pending announcement retries, its in-flight turns, its SQLite
+  // handle. Resolves once they finish. A no-op when no runtime was built.
+  close(): Promise<void>;
 };
 
 // Import a layout file's default export as a layout component (memoized), plus
@@ -226,6 +231,8 @@ export function createApp({ appDir: appDirInput, config = {} }: CreateAppOptions
   // pipeline is built lazily on first fetch, memoized after.
   let pipelinePromise: Promise<Pipeline> | undefined;
   const getPipeline = (): Promise<Pipeline> => (pipelinePromise ??= buildPipeline());
+  // The agent runtime buildPipeline creates, kept so close() can shut it down (#317).
+  let agentRuntime: InProcessRuntime | undefined;
   async function buildPipeline(): Promise<Pipeline> {
     // Wire CSS Modules BEFORE any route import: the runtime interceptor must be
     // active so `import "x.module.css"` in a route resolves to the scoped map,
@@ -264,6 +271,7 @@ export function createApp({ appDir: appDirInput, config = {} }: CreateAppOptions
       // toAgentDef: tools, prompt AND the per-surface policies (#149) from the one
       // definition — channelInstructions was previously dropped on this path (#173).
       const rt = await createAgentRuntime({ [def.name]: toAgentDef(def, model) }, { backend });
+      agentRuntime = rt;
       const mounted = mountAgent(def, rt, { chatPath: agent.runtime.chat.path, channels: agent.runtime.channels });
       agentSurface = (req) => mounted.surface(req);
       await mounted.startAll();
@@ -443,6 +451,13 @@ export function createApp({ appDir: appDirInput, config = {} }: CreateAppOptions
       return toPipeline();
     },
     async warmup() {
+      // What `june build` refuses (same-path files, a segment after an optional
+      // or catch-all), dev reports up front — it still serves what it can.
+      const problems = routeProblems(
+        [await scanRoutes(appDir), hasJuneRoutes ? await scanRoutes(juneRoutesDir) : []],
+        dirname(appDir),
+      );
+      if (problems) console.error(problems);
       const files = await routeFiles(appDir, { pageConvention: true });
       if (hasJuneRoutes) files.push(...(await routeFiles(juneRoutesDir, { pageConvention: true })));
       for (const file of files) {
@@ -453,5 +468,11 @@ export function createApp({ appDir: appDirInput, config = {} }: CreateAppOptions
     },
     routePaths,
     earlyHints: () => config.earlyHints ?? [],
+    async close() {
+      // A pipeline still being built may be about to create the runtime: let it finish
+      // (its failure is the fetch's to report, not close()'s).
+      await pipelinePromise?.catch(() => {});
+      await agentRuntime?.close();
+    },
   };
 }

package/src/build.ts

@@ -300,6 +300,12 @@ export async function juneBuild(
   const resourceRoutesField = resources.length
     ? `\n  resourceRoutes: [\n${resources.join("\n")}\n  ],`
     : "";
+  // .june/routes/ patterns rank after every app/ route (dev falls back to them).
+  // Only emitted when there are some, so bundles without them stay byte-identical.
+  const generatedPaths = routes.filter((r) => r.generated).map((r) => r.path);
+  const generatedRoutesField = generatedPaths.length
+    ? `\n  generatedRoutes: ${JSON.stringify(generatedPaths)},`
+    : "";
   // Only emitted when some route declares a boundary, so boundary-less bundles
   // stay byte-identical (additive manifest field, like resources).
   const layoutBoundariesField = boundaries.length
@@ -435,7 +441,7 @@ ${statics.join("\n")}
   },
   dynamicRoutes: [
 ${dynamics.join("\n")}
-  ],${resourceRoutesField}
+  ],${resourceRoutesField}${generatedRoutesField}
   layoutChains: {
 ${chains.join("\n")}
   },${layoutBoundariesField}