@timber-js/app 0.2.0-alpha.186 → 0.2.0-alpha.188

package/dist/index.js

@@ -1,9 +1,11 @@
 import { a as __esmMin, o as __exportAll, s as __toCommonJS } from "./_chunks/dist-BA3u1z3W.js";
+import { t as RSC_CONTENT_TYPE } from "./_chunks/rsc-media-type-DRqE_lD_.js";
 import { a as canonicalize, d as isMetadataRouteServePath, u as isDynamicMetadataExtension } from "./_chunks/segment-keys-BawYuNFO.js";
-import { a as collectInterceptionRewrites, i as scanRoutes, o as matchUrlParts } from "./_chunks/cli-schema-sync-CKgHC2MB.js";
-import { h as swallow } from "./_chunks/logger-N7e5auP0.js";
-import { a as fileHasAnyExport, c as fileHasExport, i as generateRouteMap, l as fileHasStarExport, o as fileHasDefaultExport, r as validateSchemaAgainstRoutes, s as fileHasDirective, t as collectLeafRoutes, u as getPrerenderExport } from "./_chunks/walkers-BhhwI9TD.js";
-import { a as resolveAppDir, c as createNoopTimer, n as loadTimberConfigFile, o as resolveBuildDir, r as mergeFileConfig, s as resolveClientJavascript, t as createPluginContext } from "./_chunks/plugin-context-DEGLSJs3.js";
+import { n as collectInterceptionRewrites, r as matchUrlParts, t as scanRoutes } from "./_chunks/scanner-C8b0Gcw3.js";
+import { h as swallow } from "./_chunks/logger-D8xJZXIN.js";
+import { c as writeRouteCodegen, i as getPrerenderExport, l as buildDirToRouteMap, n as formatConventionWarnings, r as lintConventions, s as flushCodegenWrites, t as checkAppDirExists } from "./_chunks/convention-lint-kXsgc_-7.js";
+import { c as resolveClientJavascript, i as mergeFileConfig, l as createNoopTimer, o as resolveAppDir, r as loadTimberConfigFile, s as resolveBuildDir, t as createPluginContext } from "./_chunks/plugin-context-rCinWLiE.js";
+import { r as validateSchemaAgainstRoutes, t as collectLeafRoutes } from "./_chunks/walkers-RzN6AFjr.js";
 import { i as withBasePath, n as normalizeBasePath, t as isRelativeBase } from "./_chunks/base-path-DaQrzbez.js";
 import { t as rscPayloadPath } from "./_chunks/rsc-payload-path-B_LBodc2.js";
 import { a as REDIRECTS_FILE, n as detectFsIdentity, o as RESERVED_OUTPUT_PATHS, r as fsKey, t as EXACT_FS_IDENTITY } from "./_chunks/fs-identity-D7vb6GdI.js";
@@ -286,8 +288,8 @@ function classifyStack(stack, projectRoot) {
 *
 * Design doc: 21-dev-server.md §"Error Overlay"
 */
-var noValidate$1 = { validateStream: false };
-var style$1 = (fmt, text) => styleText(fmt, text, noValidate$1);
+var noValidate = { validateStream: false };
+var style = (fmt, text) => styleText(fmt, text, noValidate);
 /**
 * Wrap text in an OSC 8 hyperlink escape sequence.
 *
@@ -309,7 +311,7 @@ function hyperlink(text, url) {
 function fileLink(filePath, line, col) {
 	const display = line ? `${filePath}:${line}${col ? `:${col}` : ""}` : filePath;
 	const base = pathToFileURL(filePath).href;
-	return style$1(["cyan", "underline"], hyperlink(display, line ? `${base}:${line}${col ? `:${col}` : ""}` : base));
+	return style(["cyan", "underline"], hyperlink(display, line ? `${base}:${line}${col ? `:${col}` : ""}` : base));
 }
 var BOX = {
 	topLeft: "╭",
@@ -328,9 +330,9 @@ var BOX = {
 function box(lines, borderFormat, width = 80) {
 	const bar = BOX.horizontal.repeat(width - 2);
 	const output = [];
-	output.push(style$1(borderFormat, `${BOX.topLeft}${bar}${BOX.topRight}`));
-	for (const line of lines) output.push(`${style$1(borderFormat, BOX.vertical)} ${line}`);
-	output.push(style$1(borderFormat, `${BOX.bottomLeft}${bar}${BOX.bottomRight}`));
+	output.push(style(borderFormat, `${BOX.topLeft}${bar}${BOX.topRight}`));
+	for (const line of lines) output.push(`${style(borderFormat, BOX.vertical)} ${line}`);
+	output.push(style(borderFormat, `${BOX.bottomLeft}${bar}${BOX.bottomRight}`));
 	return output.join("\n");
 }
 /**
@@ -351,32 +353,32 @@ function formatTerminalError$1(error, phase, projectRoot) {
 	const appFrames = frames.filter((f) => f.type === "app");
 	const internalCount = frames.filter((f) => f.type !== "app").length;
 	const boxLines = [];
-	boxLines.push(style$1(["red", "bold"], `${PHASE_LABELS$1[phase]} Error`));
+	boxLines.push(style(["red", "bold"], `${PHASE_LABELS$1[phase]} Error`));
 	boxLines.push("");
-	for (const msgLine of error.message.split("\n")) boxLines.push(style$1("red", msgLine));
+	for (const msgLine of error.message.split("\n")) boxLines.push(style("red", msgLine));
 	if (loc) {
 		boxLines.push("");
 		const relPath = loc.file.startsWith(projectRoot) ? loc.file.slice(projectRoot.length + 1) : loc.file;
-		boxLines.push(`${style$1("bold", "→")} ${fileLink(loc.file, loc.line, loc.column)} ${style$1("dim", `(${relPath})`)}`);
+		boxLines.push(`${style("bold", "→")} ${fileLink(loc.file, loc.line, loc.column)} ${style("dim", `(${relPath})`)}`);
 	}
 	sections.push(box(boxLines, "red"));
 	if (componentStack) {
 		sections.push("");
-		sections.push(`  ${style$1("bold", "Component Stack:")}`);
-		for (const csLine of componentStack.trim().split("\n")) sections.push(`  ${style$1("dim", csLine.trim())}`);
+		sections.push(`  ${style("bold", "Component Stack:")}`);
+		for (const csLine of componentStack.trim().split("\n")) sections.push(`  ${style("dim", csLine.trim())}`);
 	}
 	if (appFrames.length > 0) {
 		sections.push("");
-		sections.push(`  ${style$1("bold", "Application Frames:")}`);
+		sections.push(`  ${style("bold", "Application Frames:")}`);
 		for (let i = 0; i < appFrames.length; i++) {
 			const f = appFrames[i];
 			if (f.file && f.line) {
-				const prefix = i === 0 ? style$1("bold", "▸") : " ";
-				sections.push(`  ${prefix} ${fileLink(f.file, f.line, f.col)} ${style$1("dim", extractFnName(f.raw))}`);
+				const prefix = i === 0 ? style("bold", "▸") : " ";
+				sections.push(`  ${prefix} ${fileLink(f.file, f.line, f.col)} ${style("dim", extractFnName(f.raw))}`);
 			} else sections.push(`  ${f.raw}`);
 		}
 	}
-	if (internalCount > 0) sections.push(`  ${style$1("dim", `… ${internalCount} internal frame${internalCount !== 1 ? "s" : ""} hidden`)}`);
+	if (internalCount > 0) sections.push(`  ${style("dim", `… ${internalCount} internal frame${internalCount !== 1 ? "s" : ""} hidden`)}`);
 	sections.push("");
 	return sections.join("\n");
 }
@@ -1378,7 +1380,7 @@ var COMPRESSIBLE_TYPES = /* @__PURE__ */ new Set([
 	"text/plain",
 	"text/xml",
 	"text/javascript",
-	"text/x-component",
+	RSC_CONTENT_TYPE,
 	"application/json",
 	"application/javascript",
 	"application/xml",
@@ -2204,69 +2206,10 @@ function timberMdx(ctx) {
 	};
 }
 //#endregion
-//#region src/routing/segment-codegen.ts
-/**
-* $segment type generation and directory-to-route mapping.
-*
-* Generates per-route $segment.d.ts files in .timber/types/ that mirror
-* the app/ directory structure. TypeScript's rootDirs feature makes these
-* importable as './$segment' from route files.
-*
-* Design doc: design/41-global-params.md §The $segment Module
-*/
-/**
-* Build a map of absolute filesystem directory → segment info.
-* Used by resolveId to map a $segment import's importer to the correct route,
-* and by writeSegmentTypes to generate per-route $segment.d.ts files.
-*
-* Walks every segment (not just leaves) so layouts and middleware
-* at any depth can import $segment.
-*/
-function buildDirToRouteMap(tree, appDir) {
-	const map = /* @__PURE__ */ new Map();
-	function walk(node, fsPath, treePath) {
-		map.set(fsPath, {
-			route: node.urlPath || "/",
-			segmentPath: treePath || "/"
-		});
-		for (const child of node.children) walk(child, join(fsPath, child.segmentName), `${treePath}/${child.segmentName}`);
-		for (const [slotName, slotNode] of Object.entries(node.slots)) walk(slotNode, join(fsPath, `@${slotName}`), `${treePath}/@${slotName}`);
-	}
-	walk(tree.root, appDir, "");
-	return map;
-}
-/**
-* Generate the full $segment.d.ts content for a segment.
-*/
-function generateSegmentDts(info) {
-	return [
-		`export const ROUTE: '${info.route}';`,
-		`export const SEGMENT_PATH: '${info.segmentPath}';`,
-		""
-	].join("\n");
-}
-/**
-* Generate per-route $segment.d.ts files in .timber/types/ mirroring
-* the app/ directory structure. These files are importable via TypeScript's
-* rootDirs feature.
-*/
-async function writeSegmentTypes(routeTree, appDir, root) {
-	const typesBase = join(root, ".timber", "types", appDir.slice(root.length + 1));
-	const map = buildDirToRouteMap(routeTree, appDir);
-	const writes = [];
-	for (const [fsDir, info] of map) {
-		const segmentDir = join(typesBase, fsDir.slice(appDir.length));
-		const segmentFile = join(segmentDir, "$segment.d.ts");
-		const content = generateSegmentDts(info);
-		writes.push(mkdir(segmentDir, { recursive: true }).then(() => writeFile(segmentFile, content, "utf-8")));
-	}
-	await Promise.all(writes);
-}
-//#endregion
 //#region src/routing/manifest-codegen.ts
 /**
 * Route manifest codegen — generates virtual module source for the route
-* manifest, search-params registry, and global schema.
+* manifest and the global schema loader.
 *
 * Extracted from plugins/routing.ts to keep it under the 500-line budget.
 * See design/18-build-system.md §"Virtual Modules".
@@ -2281,8 +2224,7 @@ var SINGLE_FILE_KEYS = [
 	"route",
 	"error",
 	"default",
-	"denied",
-	"params"
+	"denied"
 ];
 var RECORD_FILE_KEYS = [
 	"statusFiles",
@@ -2382,50 +2324,6 @@ function generateManifestModule(tree, viteRoot) {
 	].filter((line) => line !== void 0 && line !== "").join("\n");
 }
 /**
-* Walk the route tree and collect every page that exports a
-* `searchParams` definition, then emit a module that statically imports
-* each export and registers it into the shared search-params registry.
-*/
-function generateSearchParamsRegistryModule(tree) {
-	const entries = [];
-	function walk(node) {
-		if (node.page) {
-			if (node.params && fileHasSearchParamsExport(node.params.filePath)) entries.push({
-				urlPath: node.urlPath,
-				filePath: node.params.filePath
-			});
-			else if (fileHasSearchParamsExport(node.page.filePath)) entries.push({
-				urlPath: node.urlPath,
-				filePath: node.page.filePath
-			});
-		}
-		for (const child of node.children) walk(child);
-		for (const slot of Object.values(node.slots)) walk(slot);
-	}
-	walk(tree.root);
-	entries.sort((a, b) => a.urlPath.localeCompare(b.urlPath));
-	const lines = [];
-	lines.push("// Auto-generated search-params registry — do not edit.");
-	lines.push("// Generated by timber-routing plugin (TIM-830).");
-	lines.push("");
-	lines.push("import { registerSearchParams } from '@timber-js/app/search-params';");
-	lines.push("");
-	entries.forEach((entry, i) => {
-		lines.push(`import { searchParams as r${i} } from ${JSON.stringify(entry.filePath)};`);
-	});
-	lines.push("");
-	entries.forEach((entry, i) => {
-		lines.push(`registerSearchParams(${JSON.stringify(entry.urlPath)}, r${i});`);
-	});
-	lines.push("");
-	lines.push("export {};");
-	lines.push("");
-	return lines.join("\n");
-}
-function fileHasSearchParamsExport(filePath) {
-	return fileHasExport(filePath, "searchParams");
-}
-/**
 * Generate the virtual:timber-schema module.
 *
 * When app/schema.{ts,tsx,js,jsx} exists, generates a module that
@@ -2457,348 +2355,34 @@ function generateSchemaModule(appDir) {
 	].join("\n");
 }
 //#endregion
-//#region src/routing/convention-lint.ts
-/**
-* Convention linter — validates common misconfigurations in the route tree.
-*
-* Runs at scan time (build and dev startup). Each check produces a warning
-* with the file path, what's wrong, and what to do about it.
-*
-* These are warnings, not errors — they don't block the build. The goal is
-* to catch issues that would otherwise produce cryptic runtime behavior
-* (silent 404s, empty pages, confusing React errors).
-*
-* Design doc: 07-routing.md, 10-error-handling.md
-*/
-/**
-* Run all convention lint checks on a route tree.
-*
-* Returns an array of warnings. Empty array means everything looks good.
-*/
-function lintConventions(tree, appDir) {
-	const warnings = [];
-	checkEmptyApp(tree.root, appDir, warnings);
-	checkRouteExports(tree.root, warnings);
-	checkRootLayout(tree.root, warnings);
-	checkDefaultExports(tree.root, warnings);
-	checkErrorDirectives(tree.root, warnings);
-	if (tree.globalError && isScriptExtension(tree.globalError.extension)) checkFileUseClientDirective(tree.globalError.filePath, "global-error", warnings);
-	return warnings;
-}
-/**
-* Warn when the app/ directory has no routable files at all.
-*
-* This catches the "I created app/ but didn't add any pages" case where
-* every request silently 404s with no guidance.
-*/
-function checkEmptyApp(root, appDir, warnings) {
-	if (hasAnyRoutable(root)) return;
-	warnings.push({
-		id: "EMPTY_APP",
-		summary: "No pages or route handlers found in app/",
-		details: `  Directory: ${appDir}\n\n  Your app/ directory has no page.tsx or route.ts files.
-  Every request will return 404.
-
-  To fix: Create app/page.tsx with a default export:
-
-    export default function Home() {
-      return <h1>Hello</h1>;
-    }
-`,
-		level: "warn"
-	});
-}
-/**
-* Check if a segment tree has any routable files (page or route) anywhere.
-*/
-function hasAnyRoutable(node) {
-	if (node.page || node.route) return true;
-	for (const child of node.children) if (hasAnyRoutable(child)) return true;
-	for (const slot of Object.values(node.slots)) if (hasAnyRoutable(slot)) return true;
-	return false;
-}
-/**
-* Check if a segment tree has any page files (not just route handlers).
-* Used by checkRootLayout to avoid false positives for API-only apps (TIM-794).
-* API-only apps (just route.ts handlers) don't need a root layout.
-*/
-function hasAnyPage(node) {
-	if (node.page) return true;
-	for (const child of node.children) if (hasAnyPage(child)) return true;
-	for (const slot of Object.values(node.slots)) if (hasAnyPage(slot)) return true;
-	return false;
-}
-/** HTTP methods that route.ts can export. */
-var HTTP_METHODS = [
-	"GET",
-	"POST",
-	"PUT",
-	"PATCH",
-	"DELETE",
-	"HEAD",
-	"OPTIONS"
-];
-/**
-* Warn when a route.ts file doesn't appear to export any recognized HTTP methods.
-*
-* Uses AST-based detection via parseAst for precise matching.
-* Falls back silently when the file can't be parsed (syntax errors produce
-* no spurious warning — the TS compiler will catch those).
-*/
-function checkRouteExports(node, warnings) {
-	if (node.route) {
-		const filePath = node.route.filePath;
-		try {
-			if (fileHasAnyExport(filePath, HTTP_METHODS).size === 0 && !fileHasStarExport(filePath)) {
-				const hint = fileHasDefaultExport(filePath) ? "  It looks like you have a default export. route.ts uses named exports\n  for HTTP methods (GET, POST, etc.), not a default export.\n" : "";
-				warnings.push({
-					id: "ROUTE_NO_METHODS",
-					summary: `route.ts has no HTTP method exports: ${filePath}`,
-					details: `  File: ${filePath}\n\n  route.ts files must export named HTTP method handlers.
-  Without them, the route matches but returns 405 Method Not Allowed.
-
-` + hint + "  Example:\n\n    export function GET(ctx: RouteContext) {\n      return Response.json({ hello: 'world' });\n    }\n",
-					level: "warn"
-				});
-			}
-		} catch (err) {
-			swallow(err, `convention-lint: unreadable route.ts ${filePath}`);
-		}
-	}
-	for (const child of node.children) checkRouteExports(child, warnings);
-	for (const slot of Object.values(node.slots)) checkRouteExports(slot, warnings);
-}
-/**
-* Warn when the root segment has no layout.tsx.
-*
-* Without a root layout, there's no HTML shell (<html>, <body>).
-* The page will render but may have hydration issues or no proper document structure.
-*/
-function checkRootLayout(root, warnings) {
-	if (root.layout) return;
-	if (!hasAnyPage(root)) return;
-	warnings.push({
-		id: "NO_ROOT_LAYOUT",
-		summary: "No root layout.tsx found",
-		details: "  Your app has pages but no root layout.\n  Without app/layout.tsx, pages have no <html> or <body> wrapper.\n\n  To fix: Create app/layout.tsx:\n\n    export default function RootLayout({ children }: { children: React.ReactNode }) {\n      return (\n        <html lang=\"en\">\n          <body>{children}</body>\n        </html>\n      );\n    }\n",
-		level: "warn"
-	});
-}
-/**
-* Warn when page.tsx or layout.tsx files don't have a default export.
-*
-* Without a default export:
-* - page.tsx: the page renders nothing (empty content)
-* - layout.tsx: the layout module loads but has no component to render
-*
-* Uses AST-based detection via parseAst for precise matching. Falls back
-* silently when the file can't be parsed (no spurious warning on syntax errors).
-*/
-function checkDefaultExports(node, warnings) {
-	if (node.page && isScriptExtension(node.page.extension)) checkFileDefaultExport(node.page.filePath, "page", warnings);
-	if (node.layout && isScriptExtension(node.layout.extension)) checkFileDefaultExport(node.layout.filePath, "layout", warnings);
-	for (const child of node.children) checkDefaultExports(child, warnings);
-	for (const slot of Object.values(node.slots)) checkDefaultExports(slot, warnings);
-}
-function isScriptExtension(ext) {
-	return ext === "tsx" || ext === "ts" || ext === "jsx" || ext === "js";
-}
-function checkFileDefaultExport(filePath, fileType, warnings) {
-	try {
-		if (!fileHasDefaultExport(filePath)) warnings.push({
-			id: `NO_DEFAULT_EXPORT:${filePath}`,
-			summary: `${fileType}.tsx has no default export: ${filePath}`,
-			details: `  File: ${filePath}\n\n  ${fileType}.tsx files must export a default React component.\n  Without a default export, the ${fileType === "page" ? "page renders nothing" : "layout has no component to wrap children"}.\n\n  To fix: Add a default export:\n\n    export default function My${fileType === "page" ? "Page" : "Layout"}(${fileType === "layout" ? "{ children }" : ""}) {\n      return ${fileType === "layout" ? "<div>{children}</div>" : "<h1>Hello</h1>"};\n    }\n`,
-			level: "warn"
-		});
-	} catch (err) {
-		swallow(err, `convention-lint: unreadable ${fileType} file ${filePath}`);
-	}
-}
-/**
-* Warn when error.tsx or global-error.tsx is missing 'use client'.
-*
-* React's error boundary API requires client components. Without the directive,
-* the error boundary silently fails — the component renders as a server component
-* with no error catching. Users discover this only via cryptic runtime errors.
-*/
-function checkErrorDirectives(node, warnings) {
-	if (node.error && isScriptExtension(node.error.extension)) checkFileUseClientDirective(node.error.filePath, "error", warnings);
-	for (const child of node.children) checkErrorDirectives(child, warnings);
-	for (const slot of Object.values(node.slots)) checkErrorDirectives(slot, warnings);
-}
-function checkFileUseClientDirective(filePath, fileType, warnings) {
-	try {
-		if (!fileHasDirective(filePath, "use client")) warnings.push({
-			id: `ERROR_NO_USE_CLIENT:${filePath}`,
-			summary: `${fileType}.tsx is missing 'use client': ${filePath}`,
-			details: `  File: ${filePath}\n\n  ${fileType}.tsx must start with 'use client' because React error\n  boundaries require client components. Without it, the error boundary
-  silently fails and errors are uncaught.
-
-  To fix: Add 'use client' as the first line of the file:
-
-    'use client';
-
-    export default function ${fileType === "global-error" ? "GlobalError" : "ErrorBoundary"}({ error, reset }) {\n      return <div><h2>Something went wrong</h2><button onClick={reset}>Try again</button></div>;
-    }
-`,
-			level: "warn"
-		});
-	} catch (err) {
-		swallow(err, `convention-lint: unreadable ${fileType} file ${filePath}`);
-	}
-}
-/**
-* Check if the app/ directory exists. Called before scanning.
-* Returns a warning if missing, or null if the directory exists.
-*/
-function checkAppDirExists(appDir) {
-	if (existsSync(appDir)) return null;
-	return {
-		id: "NO_APP_DIR",
-		summary: "No app/ directory found",
-		details: `  Expected: ${appDir}\n\n  timber.js requires an app/ directory for file-system routing.
-  Every request will return 404 until you create it.
-
-  To fix: Create the app/ directory with a page:
-
-    mkdir -p app
-    # Create app/layout.tsx and app/page.tsx
-`,
-		level: "error"
-	};
-}
-var noValidate = { validateStream: false };
-var style = (fmt, text) => styleText(fmt, text, noValidate);
-/**
-* Format warnings for terminal output.
-*
-* Groups by severity, uses colors, and includes fix suggestions.
-*/
-function formatConventionWarnings(warnings) {
-	if (warnings.length === 0) return "";
-	const errors = warnings.filter((w) => w.level === "error");
-	const warns = warnings.filter((w) => w.level === "warn");
-	const lines = [];
-	if (errors.length > 0) {
-		lines.push(`${style(["red", "bold"], "[timber]")} ${style("red", `${errors.length} configuration error${errors.length !== 1 ? "s" : ""}:`)}`);
-		for (const e of errors) {
-			lines.push("");
-			lines.push(`  ${style("red", "✗")} ${e.summary}`);
-			lines.push(style("dim", e.details));
-		}
-	}
-	if (warns.length > 0) {
-		if (errors.length > 0) lines.push("");
-		lines.push(`${style(["yellow", "bold"], "[timber]")} ${style("yellow", `${warns.length} configuration warning${warns.length !== 1 ? "s" : ""}:`)}`);
-		for (const w of warns) {
-			lines.push("");
-			lines.push(`  ${style("yellow", "⚠")} ${w.summary}`);
-			lines.push(style("dim", w.details));
-		}
-	}
-	return lines.join("\n");
-}
-//#endregion
 //#region src/plugins/routing.ts
 var VIRTUAL_MODULE_ID$1 = "virtual:timber-route-manifest";
 var RESOLVED_VIRTUAL_ID$1 = `\0${VIRTUAL_MODULE_ID$1}`;
-var SEARCH_PARAMS_REGISTRY_ID = "virtual:timber-search-params-registry";
-var RESOLVED_SEARCH_PARAMS_REGISTRY_ID = `\0${SEARCH_PARAMS_REGISTRY_ID}`;
 var SCHEMA_ID = "virtual:timber-schema";
 var RESOLVED_SCHEMA_ID = `\0${SCHEMA_ID}`;
 var SEGMENT_PREFIX = "\0$segment:";
 /**
 * File convention names we track for changes that require manifest regeneration.
 */
-var ROUTE_FILE_PATTERNS = /\/(page|layout|middleware|access|route|error|global-error|default|denied|params|schema|\d{3}|[45]xx|sitemap|robots|manifest|favicon|icon|opengraph-image|apple-icon)\./;
+var ROUTE_FILE_PATTERNS = /\/(page|layout|middleware|access|route|error|global-error|default|denied|schema|\d{3}|[45]xx|sitemap|robots|manifest|favicon|icon|opengraph-image|apple-icon)\./;
 /**
 * Create the timber-routing Vite plugin.
 *
 * Hooks: resolveId, load, buildStart, configureServer
 */
-/** Absolute path to the generated route map declaration file. */
-var CODEGEN_OUTPUT = ".timber/timber-routes.d.ts";
-/**
-* Content of the timber-env.d.ts file written to the project root.
-*
-* Uses a triple-slash reference so TypeScript auto-discovers the generated
-* route map without the user needing to edit tsconfig.json — same pattern
-* as Next.js's next-env.d.ts.
-*
-* Also references `vite/client` so side-effect imports like
-* `import './globals.css'` type-check without ts(2882), and so
-* `import.meta.env`, `import.meta.hot`, `import.meta.glob`, asset
-* imports (`*.png`, `*.svg`, …), CSS modules, and `?url`/`?raw`/
-* `?inline` query variants all resolve without the user editing
-* tsconfig.json themselves. Next.js's next-env.d.ts plays the same
-* role via `next/types/global`.
-*
-* `vite` is a peer dep of `@timber-js/app`, so the reference always
-* resolves in a correctly-installed project.
-*/
-var TIMBER_ENV_DTS = [
-	"// This file is auto-generated by timber.js. Do not edit.",
-	"// It ensures TypeScript picks up the generated route types and",
-	"// Vite-provided ambient types (CSS, assets, import.meta.env, HMR).",
-	"/* eslint-disable @typescript-eslint/triple-slash-reference */",
-	"/// <reference path=\".timber/timber-routes.d.ts\" />",
-	"/// <reference types=\"vite/client\" />",
-	""
-].join("\n");
-/**
-* Codegen writes that have been started but have not yet landed on disk.
-*
-* `writeCodegen` is deliberately unawaited on the hot path, which leaves a
-* caller no way to know the files exist yet. Anything that tears down the
-* project root — a build process exiting, a test removing its temp root —
-* then races the writes: `rmSync` empties a directory that a pending `mkdir`
-* immediately recreates, and the removal fails with ENOTEMPTY.
-*
-* Every started write registers here and deregisters when it settles, so
-* `flushCodegenWrites()` can await them instead of guessing at a delay.
-*/
-var pendingCodegenWrites = /* @__PURE__ */ new Set();
-/**
-* Resolve once every codegen write started so far has landed on disk.
-*
-* Safe to call at any time and from anywhere — writes are tracked per process,
-* not per plugin instance, so a caller does not need a handle on the plugin
-* that started them. Never rejects: individual write failures are already
-* swallowed and logged by `writeCodegen`.
-*/
-async function flushCodegenWrites() {
-	while (pendingCodegenWrites.size > 0) {
-		const inFlight = [...pendingCodegenWrites];
-		await Promise.all(inFlight);
-		for (const write of inFlight) pendingCodegenWrites.delete(write);
-	}
-}
 /**
 * Write the generated route map and the timber-env.d.ts reference file.
 *
-* Not awaited by callers, to avoid blocking the hot path — use
-* `flushCodegenWrites()` to wait for the writes to land.
-* Errors are swallowed; a missing .d.ts is a developer UX issue, not a runtime failure.
+* Not awaited, to avoid blocking the hot path — use `flushCodegenWrites()` to
+* wait for the writes to land. Failures are logged, not thrown: a missing .d.ts
+* is a developer UX issue in dev/build, not a runtime failure. (`timber check`
+* calls `writeRouteCodegen` directly and does treat a failure as fatal.)
 */
 function writeCodegen(ctx) {
 	if (!ctx.routeTree) return;
-	const timberDir = join(ctx.root, ".timber");
-	const content = generateRouteMap(ctx.routeTree, {
-		appDir: ctx.appDir,
-		outputDir: timberDir
-	});
-	const routesPath = join(ctx.root, CODEGEN_OUTPUT);
-	const envPath = join(ctx.root, "timber-env.d.ts");
-	const done = mkdir(timberDir, { recursive: true }).then(() => Promise.all([
-		writeFile(routesPath, content, "utf-8"),
-		writeFile(envPath, TIMBER_ENV_DTS, "utf-8"),
-		writeSegmentTypes(ctx.routeTree, ctx.appDir, ctx.root)
-	])).then(() => void 0).catch((err) => {
+	writeRouteCodegen(ctx.routeTree, ctx.appDir, ctx.root).catch((err) => {
 		console.warn("[timber] Failed to write codegen output:", err);
 	});
-	pendingCodegenWrites.add(done);
-	done.finally(() => pendingCodegenWrites.delete(done));
 }
 function timberRouting(ctx) {
 	/** Track warned files to avoid repeating warnings on rescan. */
@@ -2820,12 +2404,16 @@ function timberRouting(ctx) {
 			return;
 		}
 		ctx.timer.start("route-scan");
-		ctx.routeTree = scanRoutes(ctx.appDir, { pageExtensions: ctx.config.pageExtensions });
+		const tree = scanRoutes(ctx.appDir, { pageExtensions: ctx.config.pageExtensions });
 		ctx.timer.end("route-scan");
+		const conventionWarnings = lintConventions(tree, ctx.appDir);
+		const fatal = conventionWarnings.filter((w) => w.level === "error");
+		if (fatal.length > 0) throw new Error(formatConventionWarnings(fatal, { color: false }));
+		ctx.routeTree = tree;
 		dirToRoute = buildDirToRouteMap(ctx.routeTree, ctx.appDir);
 		writeCodegen(ctx);
 		warnSchemaValidation(ctx);
-		const newConventionWarnings = lintConventions(ctx.routeTree, ctx.appDir).filter((w) => !warnedFiles.has(w.id));
+		const newConventionWarnings = conventionWarnings.filter((w) => !warnedFiles.has(w.id));
 		if (newConventionWarnings.length > 0) {
 			for (const w of newConventionWarnings) warnedFiles.add(w.id);
 			const formatted = formatConventionWarnings(newConventionWarnings);
@@ -2846,7 +2434,6 @@ function timberRouting(ctx) {
 			const cleanId = id.startsWith("\0") ? id.slice(1) : id;
 			if (cleanId === VIRTUAL_MODULE_ID$1) return RESOLVED_VIRTUAL_ID$1;
 			if (cleanId.endsWith(`/${VIRTUAL_MODULE_ID$1}`)) return RESOLVED_VIRTUAL_ID$1;
-			if (cleanId === SEARCH_PARAMS_REGISTRY_ID || cleanId.endsWith(`/${SEARCH_PARAMS_REGISTRY_ID}`)) return RESOLVED_SEARCH_PARAMS_REGISTRY_ID;
 			if (cleanId === SCHEMA_ID || cleanId.endsWith(`/${SCHEMA_ID}`)) return RESOLVED_SCHEMA_ID;
 			if (importer && (cleanId === "./$segment" || cleanId === "./$segment.js" || cleanId === "./$segment.ts")) {
 				const cleanImporter = importer.startsWith("\0") ? importer.slice(1) : importer;
@@ -2867,10 +2454,6 @@ function timberRouting(ctx) {
 				if (!ctx.routeTree) rescan();
 				return generateManifestModule(ctx.routeTree, ctx.root);
 			}
-			if (id === RESOLVED_SEARCH_PARAMS_REGISTRY_ID) {
-				if (!ctx.routeTree) rescan();
-				return generateSearchParamsRegistryModule(ctx.routeTree);
-			}
 			if (id === RESOLVED_SCHEMA_ID) return generateSchemaModule(ctx.appDir);
 			if (id.startsWith(SEGMENT_PREFIX)) {
 				const info = JSON.parse(id.slice(10));
@@ -2917,13 +2500,59 @@ function timberRouting(ctx) {
 			/** Snapshot of the last generated manifest, used to detect structural changes. */
 			let lastManifest = ctx.routeTree ? generateManifestModule(ctx.routeTree, ctx.root) : "";
 			/**
+			* Rescan without letting a rejected route tree kill the dev server.
+			*
+			* `rescan()` throws on hard misconfigurations — duplicate conventions,
+			* route collisions, a status file that is not a client component. Those
+			* throws are correct at startup and in `vite build`, but here they run
+			* inside a chokidar listener, where an exception is an unhandled
+			* rejection that takes the process down mid-edit. Report and keep the
+			* last good tree so the server stays up and the fix is one save away.
+			*
+			* Returns false when the scan failed, so callers skip the manifest
+			* regeneration that would otherwise publish a stale tree as fresh.
+			*/
+			/**
+			* True while the last rescan is still failing.
+			*
+			* Recovery has to force a reload even when the manifest is byte-identical.
+			* Adding a missing `'use client'` back to a status file changes no route
+			* metadata, so the content-change path would send nothing and leave the
+			* error overlay on screen over a page that is now fine.
+			*/
+			let scanFailed = false;
+			const rescanSafely = () => {
+				try {
+					rescan();
+					if (scanFailed) {
+						scanFailed = false;
+						lastManifest = ctx.routeTree ? generateManifestModule(ctx.routeTree, ctx.root) : "";
+						invalidateManifest(devServer);
+					}
+					return true;
+				} catch (err) {
+					const message = err instanceof Error ? err.message : String(err);
+					process.stderr.write(`[timber] Route scan failed — keeping previous routes.\n${message}\n`);
+					scanFailed = true;
+					devServer.hot.send({
+						type: "error",
+						err: {
+							message,
+							stack: "",
+							plugin: "timber-routing"
+						}
+					});
+					return false;
+				}
+			};
+			/**
 			* Handle a route-significant file being added or removed.
 			* Always triggers a full-reload since the route tree structure changed.
 			*/
 			const handleStructuralChange = (filePath) => {
 				if (!filePath.startsWith(ctx.appDir)) return;
 				if (!ROUTE_FILE_PATTERNS.test(filePath)) return;
-				rescan();
+				if (!rescanSafely()) return;
 				lastManifest = ctx.routeTree ? generateManifestModule(ctx.routeTree, ctx.root) : "";
 				invalidateManifest(devServer);
 			};
@@ -2938,7 +2567,7 @@ function timberRouting(ctx) {
 			const handleContentChange = (filePath) => {
 				if (!filePath.startsWith(ctx.appDir)) return;
 				if (!ROUTE_FILE_PATTERNS.test(filePath)) return;
-				rescan();
+				if (!rescanSafely()) return;
 				const newManifest = ctx.routeTree ? generateManifestModule(ctx.routeTree, ctx.root) : "";
 				if (newManifest !== lastManifest) {
 					lastManifest = newManifest;
@@ -2988,11 +2617,7 @@ function invalidateManifest(server) {
 	for (const envName of Object.keys(server.environments)) {
 		const env = server.environments[envName];
 		if (!env?.moduleGraph) continue;
-		for (const virtualId of [
-			RESOLVED_VIRTUAL_ID$1,
-			RESOLVED_SEARCH_PARAMS_REGISTRY_ID,
-			RESOLVED_SCHEMA_ID
-		]) {
+		for (const virtualId of [RESOLVED_VIRTUAL_ID$1, RESOLVED_SCHEMA_ID]) {
 			const mod = env.moduleGraph.getModuleById(virtualId);
 			if (mod) env.moduleGraph.invalidateModule(mod);
 		}
@@ -3030,7 +2655,6 @@ var SUBPATH_SRC_MAP = {
 	"cookies": "cookies/index.ts",
 	"params": "params/index.ts",
 	"search-params": "search-params/index.ts",
-	"segment-params": "segment-params/index.ts",
 	"cache/stores/memory": "cache/stores/memory.ts",
 	"cache/stores/redis": "cache/stores/redis.ts",
 	"cache/stores/cloudflare-kv": "cache/stores/cloudflare-kv.ts",
@@ -6769,6 +6393,45 @@ async function cleanConditionalArtifacts(staticDir) {
 	await rm(join(staticDir, REDIRECTS_FILE), { force: true }).catch(() => {});
 }
 /**
+* Run `fn` with `MessageChannel` instrumented, then stop every channel opened
+* while it ran from holding the process open.
+*
+* Static generation is the only build pass that renders **HTML** in the build
+* process: it imports the built app bundle and drives the full SSR pipeline
+* through it. React's scheduler opens a `MessageChannel` at module scope in
+* that bundle (`scheduler`'s DOM build) and never closes it, and a ref'd
+* `MessagePort` keeps Node's event loop alive on its own — so `timber build`
+* finished the site, printed its summary, and then hung forever. Server-mode
+* builds are unaffected because nothing there renders through react-dom.
+*
+* `unref()` is the whole fix: it leaves the port working and only drops the
+* "keep the process alive" property. It is applied **after** `fn` resolves, so
+* a render in flight can never be cut short by the process exiting under it —
+* an unref'd port would let Node exit while the scheduler still had a
+* continuation queued, which is a silently truncated page rather than a hang.
+*
+* Nothing renders after this pass. If that ever changes, the release has to
+* move to the end of whatever renders last.
+*
+* @internal Exported for testing.
+*/
+async function withSchedulerPortsReleased(fn) {
+	const opened = [];
+	const OriginalMessageChannel = globalThis.MessageChannel;
+	globalThis.MessageChannel = class extends OriginalMessageChannel {
+		constructor() {
+			super();
+			opened.push(this.port1, this.port2);
+		}
+	};
+	try {
+		return await fn();
+	} finally {
+		globalThis.MessageChannel = OriginalMessageChannel;
+		for (const port of opened) port.unref?.();
+	}
+}
+/**
 * Load the built RSC entry and run the static generation pass.
 *
 * Unlike prebuilt capture, this needs the FULL pipeline handler, so
@@ -6783,27 +6446,29 @@ async function runStaticGeneration(ctx) {
 	g.__TIMBER_CAPTURE_MODE__ = false;
 	if (ctx.buildManifest) await mergeRscAssetsManifest(ctx.buildDir, ctx.root, ctx.buildManifest, ctx.routeClientRefKeys);
 	console.log("[timber] Static generation: building site…");
-	let mod;
-	try {
-		mod = await import(
-			/* @vite-ignore */
-			`${pathToFileURL(entryPath).href}?t=${Date.now()}`
-);
-	} catch (error) {
-		throw new Error(`[timber] Static generation: failed to load the built RSC entry (${entryPath}). The full request handler must initialize for static rendering.`, { cause: error });
-	}
-	const generate = mod.__timber_generateStaticSite;
-	if (typeof generate !== "function") throw new Error("[timber] Static generation: built RSC entry does not export __timber_generateStaticSite — rebuild from a clean build directory");
 	const staticDir = join(ctx.buildDir, "static-pages");
 	await cleanConditionalArtifacts(staticDir);
 	await mkdir(staticDir, { recursive: true });
 	const sitemapConfig = ctx.config.sitemap;
 	const autoSitemapEnabled = Boolean(sitemapConfig?.enabled && sitemapConfig?.baseUrl);
 	const writer = new StaticSiteWriter(staticDir, await detectFsIdentity(staticDir));
-	const summary = await generate({
-		autoSitemapEnabled,
-		renderTimeoutMs: ctx.config.renderTimeoutMs,
-		onEntry: (entry) => writer.write(entry)
+	const summary = await withSchedulerPortsReleased(async () => {
+		let mod;
+		try {
+			mod = await import(
+				/* @vite-ignore */
+				`${pathToFileURL(entryPath).href}?t=${Date.now()}`
+);
+		} catch (error) {
+			throw new Error(`[timber] Static generation: failed to load the built RSC entry (${entryPath}). The full request handler must initialize for static rendering.`, { cause: error });
+		}
+		const generate = mod.__timber_generateStaticSite;
+		if (typeof generate !== "function") throw new Error("[timber] Static generation: built RSC entry does not export __timber_generateStaticSite — rebuild from a clean build directory");
+		return generate({
+			autoSitemapEnabled,
+			renderTimeoutMs: ctx.config.renderTimeoutMs,
+			onEntry: (entry) => writer.write(entry)
+		});
 	});
 	const totalUrls = summary.rendered + summary.errors.length;
 	console.log(`[timber] Static generation: rendered ${summary.rendered}/${totalUrls} entries.` + (summary.errors.length > 0 ? ` ${summary.errors.length} failed.` : "") + (summary.redirects.length > 0 ? ` ${summary.redirects.length} redirect(s).` : ""));
@@ -10935,6 +10600,7 @@ function timber(config) {
 	const earlyFileConfig = loadTimberConfigFile(process.cwd());
 	const rootSync = {
 		name: "timber-root-sync",
+		api: { getContext: () => ctx },
 		async config(userConfig, { command, isPreview }) {
 			const viteRoot = resolve(userConfig.root ?? process.cwd());
 			ctx.timer.start("config-load");
@@ -10991,7 +10657,6 @@ function timber(config) {
 				"@timber-js/app/cookies",
 				"@timber-js/app/cache",
 				"@timber-js/app/search-params",
-				"@timber-js/app/segment-params",
 				"@timber-js/app/params",
 				"@timber-js/app/codec"
 			];