@timber-js/app 0.2.0-alpha.110 → 0.2.0-alpha.111

package/dist/_chunks/{walkers-DQn5NNrf.js → walkers-DGTmJT0f.js}

@@ -1,336 +1,5 @@
-import { r as DEFAULT_PAGE_EXTENSIONS, t as classifySegment } from "./segment-classify-CnfLLvir.js";
-import { a as isDynamicMetadataExtension, n as classifyMetadataRoute } from "./metadata-routes-Cjmvi3rQ.js";
-import { h as swallow } from "./logger-DDmK5skc.js";
-import { basename, extname, join, posix, relative } from "node:path";
-import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
-//#region src/routing/scanner.ts
-/**
-* Route discovery scanner.
-*
-* Pure function: (appDir, config) → RouteTree
-*
-* Scans the app/ directory and builds a segment tree recognizing all
-* timber.js file conventions. Does NOT handle request matching — this
-* is discovery only.
-*/
-/**
-* Pattern matching encoded path delimiters that must be rejected during route discovery.
-* %2F / %2f (forward slash) and %5C / %5c (backslash) can cause route collisions
-* when decoded. See design/13-security.md §"Encoded separators rejected".
-*/
-var ENCODED_SEPARATOR_PATTERN = /%(?:2[fF]|5[cC])/;
-/**
-* Pattern matching encoded null bytes (%00) that must be rejected.
-* See design/13-security.md §"Null bytes rejected".
-*/
-var ENCODED_NULL_PATTERN = /%00/;
-/**
-* File convention names that use pageExtensions (can be .tsx, .ts, .jsx, .js, .mdx, etc.)
-*/
-var PAGE_EXT_CONVENTIONS = new Set([
-	"page",
-	"layout",
-	"error",
-	"default",
-	"denied"
-]);
-/**
-* Legacy compat status-code files.
-* Maps legacy file name → HTTP status code for the fallback chain.
-* See design/10-error-handling.md §"Fallback Chain".
-*/
-var LEGACY_STATUS_FILES = {
-	"not-found": 404,
-	"forbidden": 403,
-	"unauthorized": 401
-};
-/**
-* File convention names that are always .ts/.tsx (never .mdx etc.)
-*/
-var FIXED_CONVENTIONS = new Set([
-	"middleware",
-	"access",
-	"route",
-	"params"
-]);
-/**
-* Status-code file patterns:
-* - Exact 3-digit codes: 401.tsx, 429.tsx, 503.tsx
-* - Category catch-alls: 4xx.tsx, 5xx.tsx
-*/
-var STATUS_CODE_PATTERN = /^(\d{3}|[45]xx)$/;
-/**
-* Scan the app/ directory and build the route tree.
-*
-* @param appDir - Absolute path to the app/ directory
-* @param config - Scanner configuration
-* @returns The complete route tree
-*/
-function scanRoutes(appDir, config = {}) {
-	const pageExtensions = config.pageExtensions ?? DEFAULT_PAGE_EXTENSIONS;
-	const extSet = new Set(pageExtensions);
-	const tree = { root: createSegmentNode("", "static", "/") };
-	const proxyFile = findFixedFile(appDir, "proxy");
-	if (proxyFile) tree.proxy = proxyFile;
-	const globalErrorFile = findPageExtFile(appDir, "global-error", extSet);
-	if (globalErrorFile) tree.globalError = globalErrorFile;
-	scanSegmentFiles(appDir, tree.root, extSet);
-	scanChildren(appDir, tree.root, extSet);
-	validateRouteGroupCollisions(tree.root);
-	validateDuplicateParamNames(tree.root);
-	return tree;
-}
-/**
-* Create an empty segment node.
-*/
-function createSegmentNode(segmentName, segmentType, urlPath, paramName, interceptionMarker, interceptedSegmentName) {
-	return {
-		segmentName,
-		segmentType,
-		urlPath,
-		paramName,
-		interceptionMarker,
-		interceptedSegmentName,
-		children: [],
-		slots: {}
-	};
-}
-/**
-* Compute the URL path for a child segment given its parent's URL path.
-* Route groups, slots, and intercepting routes do NOT add URL depth.
-*/
-function computeUrlPath(parentUrlPath, dirName, segmentType) {
-	if (segmentType === "group" || segmentType === "slot" || segmentType === "intercepting") return parentUrlPath;
-	return `${parentUrlPath === "/" ? "" : parentUrlPath}/${dirName}`;
-}
-/**
-* Scan a directory for file conventions and populate the segment node.
-*/
-function scanSegmentFiles(dirPath, node, extSet) {
-	let entries;
-	try {
-		entries = readdirSync(dirPath);
-	} catch (err) {
-		swallow(err, `scanSegmentFiles: unreadable directory ${dirPath}`, { level: "warn" });
-		return;
-	}
-	for (const entry of entries) {
-		const fullPath = join(dirPath, entry);
-		try {
-			if (statSync(fullPath).isDirectory()) continue;
-		} catch {
-			continue;
-		}
-		const ext = extname(entry).slice(1);
-		const name = basename(entry, `.${ext}`);
-		if (PAGE_EXT_CONVENTIONS.has(name) && extSet.has(ext)) {
-			const file = {
-				filePath: fullPath,
-				extension: ext
-			};
-			switch (name) {
-				case "page":
-					node.page = file;
-					break;
-				case "layout":
-					node.layout = file;
-					break;
-				case "error":
-					node.error = file;
-					break;
-				case "default":
-					node.default = file;
-					break;
-				case "denied":
-					node.denied = file;
-					break;
-			}
-			continue;
-		}
-		if (FIXED_CONVENTIONS.has(name) && /\.?[jt]sx?$/.test(ext)) {
-			const file = {
-				filePath: fullPath,
-				extension: ext
-			};
-			switch (name) {
-				case "middleware":
-					node.middleware = file;
-					break;
-				case "access":
-					node.access = file;
-					break;
-				case "route":
-					node.route = file;
-					break;
-				case "params":
-					node.params = file;
-					break;
-			}
-			continue;
-		}
-		if (STATUS_CODE_PATTERN.test(name) && ext === "json") {
-			if (!node.jsonStatusFiles) node.jsonStatusFiles = {};
-			node.jsonStatusFiles[name] = {
-				filePath: fullPath,
-				extension: ext
-			};
-			continue;
-		}
-		if (STATUS_CODE_PATTERN.test(name) && extSet.has(ext)) {
-			if (!node.statusFiles) node.statusFiles = {};
-			node.statusFiles[name] = {
-				filePath: fullPath,
-				extension: ext
-			};
-			continue;
-		}
-		if (name in LEGACY_STATUS_FILES && extSet.has(ext)) {
-			if (!node.legacyStatusFiles) node.legacyStatusFiles = {};
-			node.legacyStatusFiles[name] = {
-				filePath: fullPath,
-				extension: ext
-			};
-			continue;
-		}
-		if (classifyMetadataRoute(entry)) {
-			if (!node.metadataRoutes) node.metadataRoutes = {};
-			const existing = node.metadataRoutes[name];
-			if (existing) {
-				const existingIsDynamic = isDynamicMetadataExtension(name, existing.extension);
-				if (isDynamicMetadataExtension(name, ext) || !existingIsDynamic) node.metadataRoutes[name] = {
-					filePath: fullPath,
-					extension: ext
-				};
-			} else node.metadataRoutes[name] = {
-				filePath: fullPath,
-				extension: ext
-			};
-		}
-	}
-	if (node.route && node.page) throw new Error(`Build error: route.ts and page.* cannot coexist in the same segment.\n  route.ts: ${node.route.filePath}\n  page:     ${node.page.filePath}\nA URL is either an API endpoint or a rendered page, not both.`);
-}
-/**
-* Recursively scan child directories and build the segment tree.
-*/
-function scanChildren(dirPath, parentNode, extSet) {
-	let entries;
-	try {
-		entries = readdirSync(dirPath);
-	} catch (err) {
-		swallow(err, `scanChildren: unreadable directory ${dirPath}`, { level: "warn" });
-		return;
-	}
-	for (const entry of entries) {
-		const fullPath = join(dirPath, entry);
-		try {
-			if (!statSync(fullPath).isDirectory()) continue;
-		} catch {
-			continue;
-		}
-		if (ENCODED_SEPARATOR_PATTERN.test(entry)) throw new Error(`Build error: directory name contains an encoded path delimiter (%%2F or %%5C).\n  Directory: ${fullPath}\nEncoded separators in directory names cause route collisions when decoded. Rename the directory to remove the encoded delimiter.`);
-		if (ENCODED_NULL_PATTERN.test(entry)) throw new Error(`Build error: directory name contains an encoded null byte (%%00).\n  Directory: ${fullPath}\nEncoded null bytes in directory names are not allowed. Rename the directory to remove the null byte encoding.`);
-		const { type, paramName, interceptionMarker, interceptedSegmentName } = classifySegment(entry);
-		if (type === "private") continue;
-		const childNode = createSegmentNode(entry, type, computeUrlPath(parentNode.urlPath, entry, type), paramName, interceptionMarker, interceptedSegmentName);
-		scanSegmentFiles(fullPath, childNode, extSet);
-		scanChildren(fullPath, childNode, extSet);
-		if (type === "slot") {
-			const slotName = entry.slice(1);
-			parentNode.slots[slotName] = childNode;
-		} else parentNode.children.push(childNode);
-	}
-}
-/**
-* Validate that route groups don't produce conflicting pages/routes at the same URL path.
-*
-* Two route groups like (auth)/login/page.tsx and (marketing)/login/page.tsx both claim
-* /login — the scanner must detect and reject this at build time.
-*
-* Parallel slots are excluded from collision detection — they intentionally coexist at
-* the same URL path as their parent (that's the whole point of parallel routes).
-*/
-function validateRouteGroupCollisions(root) {
-	collectRoutableLeaves(root, /* @__PURE__ */ new Map(), "", false);
-}
-/**
-* Walk the segment tree and collect all routable leaves (page or route files),
-* throwing on collision. Slots are tracked in their own collision space since
-* they are parallel routes that intentionally share URL paths with their parent.
-*/
-function collectRoutableLeaves(node, seen, segmentPath, insideSlot) {
-	const currentPath = segmentPath ? `${segmentPath}/${node.segmentName}` : node.segmentName || "(root)";
-	if (!insideSlot) {
-		const routableFile = node.page ?? node.route;
-		if (routableFile) {
-			const existing = seen.get(node.urlPath);
-			if (existing) throw new Error(`Build error: route collision — multiple route groups produce a page/route at the same URL path.\n  URL path: ${node.urlPath}\n  File 1:   ${existing.filePath} (via ${existing.segmentPath})\n  File 2:   ${routableFile.filePath} (via ${currentPath})\nEach URL path must map to exactly one page or route handler. Rename or move one of the conflicting files.`);
-			seen.set(node.urlPath, {
-				filePath: routableFile.filePath,
-				segmentPath: currentPath
-			});
-		}
-	}
-	for (const child of node.children) collectRoutableLeaves(child, seen, currentPath, insideSlot);
-	for (const slotNode of Object.values(node.slots)) collectRoutableLeaves(slotNode, seen, currentPath, true);
-}
-/**
-* Validate that no route chain contains duplicate dynamic param names.
-*
-* Example violation:
-*   app/[id]/items/[id]/page.tsx — 'id' appears twice in the ancestor chain.
-*
-* Route groups are transparent — params accumulate through them.
-* Slots are independent — duplicate detection does NOT cross slot boundaries.
-*
-* See design/07-routing.md §"Duplicate Param Name Detection"
-*/
-function validateDuplicateParamNames(root) {
-	walkForDuplicateParams(root, /* @__PURE__ */ new Map());
-}
-/**
-* Recursively walk the segment tree, tracking seen param names → segment paths.
-* Throws on the first duplicate found.
-*/
-function walkForDuplicateParams(node, seen) {
-	if (node.paramName) {
-		const existing = seen.get(node.paramName);
-		if (existing) throw new Error(`[timber] Duplicate param name '${node.paramName}' in route chain.\n  First defined at: ${existing}\n  Duplicate at: ${node.urlPath || "/"}\n  Rename one of the segments to avoid ambiguity.`);
-		seen = new Map(seen);
-		seen.set(node.paramName, node.urlPath || "/");
-	}
-	for (const child of node.children) walkForDuplicateParams(child, seen);
-	for (const slotNode of Object.values(node.slots)) walkForDuplicateParams(slotNode, new Map(seen));
-}
-/**
-* Find a fixed-extension file (proxy.ts) in a directory.
-*/
-function findFixedFile(dirPath, name) {
-	for (const ext of ["ts", "tsx"]) {
-		const fullPath = join(dirPath, `${name}.${ext}`);
-		try {
-			if (statSync(fullPath).isFile()) return {
-				filePath: fullPath,
-				extension: ext
-			};
-		} catch {}
-	}
-}
-/**
-* Find a file using the configured page extensions (tsx, ts, jsx, js, mdx, etc.).
-* Used for app-root conventions like global-error that aren't per-segment.
-*/
-function findPageExtFile(dirPath, name, extSet) {
-	for (const ext of extSet) {
-		const fullPath = join(dirPath, `${name}.${ext}`);
-		try {
-			if (statSync(fullPath).isFile()) return {
-				filePath: fullPath,
-				extension: ext
-			};
-		} catch {}
-	}
-}
-//#endregion
+import { join, posix, relative } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
 //#region src/routing/codegen-shared.ts
 /**
 * Shared codegen helpers — import-path computation, codec chain type
@@ -395,6 +64,16 @@ function buildCodecChainType(p, importBase, fallback) {
 	return inner;
 }
 /**
+* Build a TypeScript type expression for a single param using the global
+* schema's InferCodecType. Falls back to `fallback` when schema doesn't
+* declare this param.
+*
+* Generates: `InferCodecType<typeof schema.segmentParams['[paramName]']>`
+*/
+function buildSchemaParamType(p) {
+	return `InferCodecType<typeof schema.segmentParams[${JSON.stringify(p.bracketName)}]>`;
+}
+/**
 * Format the searchParams type for a route entry.
 *
 * When a page.tsx (or params.ts) exports searchParams, we reference its
@@ -435,10 +114,11 @@ function buildResolvedPattern(route) {
 * When the segment's params chain (TIM-834) declares a typed codec, the
 * inferred type from the codec wins via a nested conditional.
 */
-function formatLinkParamsType(params, importBase) {
+function formatLinkParamsType(params, importBase, hasSchema) {
 	if (params.length === 0) return "{}";
 	return `{ ${params.map((p) => {
-		const codecType = buildCodecChainType(p, importBase, p.type === "string" ? "string | number" : p.type);
+		const fallback = p.type === "string" ? "string | number" : p.type;
+		const codecType = hasSchema ? buildSchemaParamType(p) : buildCodecChainType(p, importBase, fallback);
 		return `${p.name}: ${codecType}`;
 	}).join("; ")} }`;
 }
@@ -505,13 +185,13 @@ function formatLinkCatchAllOverloads() {
 * so the resolved-template-vs-pattern ordering reduces to placing the
 * pattern variant before the resolved-template variant inside the union.
 */
-function formatTypedLinkOverloads(routes, importBase) {
+function formatTypedLinkOverloads(routes, importBase, hasSchema) {
 	const lines = [];
 	const baseProps = LINK_BASE_PROPS_TYPE;
 	const variants = [];
 	for (const route of routes) {
 		const hasDynamicParams = route.params.length > 0;
-		const paramsProp = hasDynamicParams ? `segmentParams: ${formatLinkParamsType(route.params, importBase)}` : "segmentParams?: Record<string, unknown>";
+		const paramsProp = hasDynamicParams ? `segmentParams: ${formatLinkParamsType(route.params, importBase, hasSchema)}` : "segmentParams?: Record<string, unknown>";
 		const searchParamsType = route.hasSearchParams ? formatSearchParamsType(route, importBase) : null;
 		const patternSearchParamsProp = searchParamsType ? `searchParams?: Partial<${searchParamsType}>` : "searchParams?: Record<string, unknown>";
 		variants.push(`${baseProps} & { href: '${route.urlPath}'; ${paramsProp}; ${patternSearchParamsProp} }`);
@@ -553,10 +233,25 @@ function formatTypedLinkOverloads(routes, importBase) {
 * interface that maps every route path to its params and searchParams shape.
 */
 function generateRouteMap(tree, options = {}) {
+	const hasSchema = options.hasSchema ?? detectSchema(options.appDir);
 	const routes = [];
-	collectRoutes(tree.root, [], [], routes);
+	collectRoutes(tree.root, [], [], routes, hasSchema);
 	routes.sort((a, b) => a.urlPath.localeCompare(b.urlPath));
-	return formatDeclarationFile(routes, options.outputDir ?? options.appDir);
+	return formatDeclarationFile(routes, options.outputDir ?? options.appDir, hasSchema);
+}
+/** Schema file extensions to check, in priority order. */
+var SCHEMA_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".js",
+	".jsx"
+];
+/**
+* Detect whether app/schema.{ts,tsx,js,jsx} exists.
+*/
+function detectSchema(appDir) {
+	if (!appDir) return false;
+	return SCHEMA_EXTENSIONS.some((ext) => existsSync(join(appDir, `schema${ext}`)));
 }
 /**
 * Recursively walk the segment tree and collect route entries.
@@ -564,13 +259,14 @@ function generateRouteMap(tree, options = {}) {
 * A route entry is created for any segment that has a `page` or `route` file.
 * Params accumulate from ancestor dynamic segments.
 */
-function collectRoutes(node, ancestorParams, ancestorParamsFiles, routes) {
+function collectRoutes(node, ancestorParams, ancestorParamsFiles, routes, hasSchema) {
 	const ownParamsFile = node.params && fileHasExport(node.params.filePath, "segmentParams") ? node.params.filePath : void 0;
 	const params = [...ancestorParams];
 	if (node.paramName) {
 		const legacyFallback = ownParamsFile ? void 0 : findLegacyParamsExport(node);
 		params.push({
 			name: node.paramName,
+			bracketName: node.segmentName,
 			type: paramTypeForSegment(node.segmentType),
 			legacyCodecFilePath: legacyFallback
 		});
@@ -584,6 +280,7 @@ function collectRoutes(node, ancestorParams, ancestorParamsFiles, routes) {
 			const codecFilePaths = leafFirstChain.length > 0 ? leafFirstChain : p.legacyCodecFilePath ? [p.legacyCodecFilePath] : void 0;
 			return {
 				name: p.name,
+				bracketName: p.bracketName,
 				type: p.type,
 				codecFilePaths
 			};
@@ -592,7 +289,8 @@ function collectRoutes(node, ancestorParams, ancestorParamsFiles, routes) {
 			urlPath: node.urlPath,
 			params: resolvedParams,
 			hasSearchParams: false,
-			isApiRoute
+			isApiRoute,
+			hasSchema
 		};
 		if (isPage) {
 			if (node.params && fileHasExport(node.params.filePath, "searchParams")) {
@@ -605,8 +303,8 @@ function collectRoutes(node, ancestorParams, ancestorParamsFiles, routes) {
 		}
 		routes.push(entry);
 	}
-	for (const child of node.children) collectRoutes(child, params, nextAncestorFiles, routes);
-	for (const slot of Object.values(node.slots)) collectRoutes(slot, params, nextAncestorFiles, routes);
+	for (const child of node.children) collectRoutes(child, params, nextAncestorFiles, routes, hasSchema);
+	for (const slot of Object.values(node.slots)) collectRoutes(slot, params, nextAncestorFiles, routes, hasSchema);
 }
 /**
 * Determine the TypeScript type for a segment's param.
@@ -646,21 +344,69 @@ function findLegacyParamsExport(node) {
 	if (node.page && fileHasExport(node.page.filePath, "segmentParams")) return node.page.filePath;
 }
 /**
+* Emit the schema-based type exports: TimberSegmentParams, TimberRoute,
+* AllSegmentParams, RoutesWithParams.
+*
+* These types use InferCodecType references so they stay in sync with
+* the schema without hardcoding resolved types.
+*
+* Design doc: design/41-global-params.md §Codegen Output
+*/
+function formatSchemaTypes(routes) {
+	const lines = [];
+	lines.push("/** Union of all valid route patterns. */");
+	lines.push("export type TimberRoute = keyof TimberSegmentParams;");
+	lines.push("");
+	lines.push("/** Maps each route pattern to its accumulated segment params. */");
+	lines.push("export interface TimberSegmentParams {");
+	for (const route of routes) if (route.params.length === 0) lines.push(`  '${route.urlPath}': {};`);
+	else {
+		lines.push(`  '${route.urlPath}': {`);
+		for (const p of route.params) lines.push(`    ${p.name}: ${buildSchemaParamType(p)};`);
+		lines.push("  };");
+	}
+	lines.push("}");
+	lines.push("");
+	lines.push("/** All segment params (union of all route params). */");
+	lines.push("export type AllSegmentParams = {");
+	lines.push("  [K in keyof TimberSegmentParams as TimberSegmentParams[K] extends Record<string, never>");
+	lines.push("    ? never");
+	lines.push("    : K]: TimberSegmentParams[K];");
+	lines.push("} extends infer U");
+	lines.push("  ? { [K in keyof U[keyof U]]: U[keyof U][K] }");
+	lines.push("  : never;");
+	lines.push("");
+	lines.push("/** Filters TimberRoute to routes whose accumulated params include all listed keys. */");
+	lines.push("export type RoutesWithParams<K extends keyof AllSegmentParams> = {");
+	lines.push("  [R in TimberRoute]: K extends keyof TimberSegmentParams[R] ? R : never;");
+	lines.push("}[TimberRoute];");
+	return lines;
+}
+/**
 * Format the collected routes into a TypeScript declaration file.
 */
-function formatDeclarationFile(routes, importBase) {
+function formatDeclarationFile(routes, importBase, hasSchema) {
 	const lines = [];
 	lines.push("// This file is auto-generated by timber.js route map codegen.");
 	lines.push("// Do not edit manually. Regenerated on build and in dev mode.");
 	lines.push("");
 	lines.push("export {};");
 	lines.push("");
-	lines.push(emitResolveSegmentFieldHelper());
-	lines.push("");
+	if (hasSchema) {
+		lines.push("import type schema from '../app/schema';");
+		lines.push("import type { InferCodecType } from '@timber-js/app/params';");
+		lines.push("");
+		lines.push(...formatSchemaTypes(routes));
+		lines.push("");
+	}
+	if (!hasSchema) {
+		lines.push(emitResolveSegmentFieldHelper());
+		lines.push("");
+	}
 	lines.push("declare module '@timber-js/app' {");
 	lines.push("  interface Routes {");
 	for (const route of routes) {
-		const paramsType = formatParamsType(route.params, importBase);
+		const paramsType = formatParamsType(route.params, importBase, hasSchema);
 		const searchParamsType = formatSearchParamsType(route, importBase);
 		lines.push(`    '${route.urlPath}': {`);
 		lines.push(`      segmentParams: ${paramsType}`);
@@ -672,13 +418,23 @@ function formatDeclarationFile(routes, importBase) {
 	lines.push("");
 	const pageRoutes = routes.filter((r) => !r.isApiRoute);
 	const dynamicRoutes = routes.filter((r) => r.params.length > 0);
+	if (dynamicRoutes.length > 0) {
+		lines.push("declare module '@timber-js/app/server' {");
+		for (const route of dynamicRoutes) {
+			const paramsType = formatParamsType(route.params, importBase, hasSchema);
+			lines.push(`  export function getSegmentParams(route: '${route.urlPath}'): ${paramsType}`);
+		}
+		lines.push("  export function getSegmentParams(): Record<string, string | string[]>");
+		lines.push("}");
+		lines.push("");
+	}
 	if (dynamicRoutes.length > 0 || pageRoutes.length > 0) {
 		lines.push("declare module '@timber-js/app/client' {");
 		lines.push("  import type { SearchParamsDefinition, SetParams, QueryStatesOptions, SearchParamCodec } from '@timber-js/app/search-params'");
 		lines.push("");
 		if (dynamicRoutes.length > 0) {
 			for (const route of dynamicRoutes) {
-				const paramsType = formatParamsType(route.params, importBase);
+				const paramsType = formatParamsType(route.params, importBase, hasSchema);
 				lines.push(`  export function useSegmentParams(route: '${route.urlPath}'): ${paramsType}`);
 			}
 			lines.push("  export function useSegmentParams(): Record<string, string | string[]>");
@@ -690,7 +446,7 @@ function formatDeclarationFile(routes, importBase) {
 		}
 		if (pageRoutes.length > 0) {
 			lines.push("  // Typed Link overloads — per-route (block 1 / emitted first)");
-			lines.push(...formatTypedLinkOverloads(pageRoutes, importBase));
+			lines.push(...formatTypedLinkOverloads(pageRoutes, importBase, hasSchema));
 			lines.push("");
 		}
 		lines.push("}");
@@ -707,10 +463,10 @@ function formatDeclarationFile(routes, importBase) {
 /**
 * Format the params type for a route entry.
 */
-function formatParamsType(params, importBase) {
+function formatParamsType(params, importBase, hasSchema) {
 	if (params.length === 0) return "{}";
 	return `{ ${params.map((p) => {
-		const codecType = buildCodecChainType(p, importBase, p.type);
+		const codecType = hasSchema ? buildSchemaParamType(p) : buildCodecChainType(p, importBase, p.type);
 		return `${p.name}: ${codecType}`;
 	}).join("; ")} }`;
 }
@@ -845,6 +601,6 @@ function walk(node, chain, result, includeSlots) {
 	if (includeSlots) for (const slotNode of Object.values(node.slots)) walk(slotNode, currentChain, result, includeSlots);
 }
 //#endregion
-export { scanRoutes as i, collectInterceptionRewrites as n, generateRouteMap as r, collectLeafRoutes as t };
+export { collectInterceptionRewrites as n, generateRouteMap as r, collectLeafRoutes as t };
 
-//# sourceMappingURL=walkers-DQn5NNrf.js.map
+//# sourceMappingURL=walkers-DGTmJT0f.js.map