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

package/dist/_chunks/walkers-BhhwI9TD.js

@@ -1,936 +0,0 @@
-import { n as findSchemaFile, r as parseExistingSchemaKeys } from "./cli-schema-sync-CKgHC2MB.js";
-import { n as classifyUrlSegment, r as effectiveUrlSegment } from "./segment-classify-C539Pa2O.js";
-import { parseAst } from "vite";
-import { join, posix, relative } from "node:path";
-import { existsSync, readFileSync, statSync } from "node:fs";
-//#region src/routing/codegen-shared.ts
-/**
-* Shared codegen helpers — import-path computation, codec chain type
-* builder, and searchParams type formatter.
-*
-* Extracted from `codegen.ts` so `link-codegen.ts` can use the same
-* helpers without a cyclic import.
-*/
-/**
-* Compute a relative import specifier for a codec/page file, stripping
-* the .ts/.tsx extension and resolving against the codegen output dir.
-*/
-function codecImportPath(codecFilePath, importBase) {
-	const absPath = codecFilePath.replace(/\.(ts|tsx)$/, "");
-	if (importBase) return "./" + relative(importBase, absPath).replace(/\\/g, "/");
-	return "./" + posix.basename(absPath);
-}
-/** Name of the shared helper type emitted at the top of the .d.ts. */
-var RESOLVE_SEGMENT_FIELD_TYPE_NAME = "_TimberResolveSegmentField";
-/**
-* Helper type emitted once at the top of the generated `.d.ts` and
-* referenced by every codec-chain conditional. Without this shared
-* helper, the inline expansion would duplicate the fallback branch on
-* every step and grow O(2^N) in chain depth (a single deep nested route
-* could blow up the file size and TS performance). With the helper,
-* each step reuses the named type and growth is O(N).
-*
-* The helper is a 2-arg conditional: given a typeof import expression
-* (`Def`), a key (`K`), and a fallback (`F`), it returns `T[K]` if
-* `Def extends ParamsDefinition<T>` and `K extends keyof T`, otherwise
-* `F`. The codec chain composes calls to this helper.
-*/
-function emitResolveSegmentFieldHelper() {
-	return [
-		`type ${RESOLVE_SEGMENT_FIELD_TYPE_NAME}<Def, K extends string, F> =`,
-		`  Def extends import('@timber-js/app/segment-params').ParamsDefinition<infer T>`,
-		`    ? K extends keyof T ? T[K] : F`,
-		`    : F;`
-	].join("\n");
-}
-/**
-* Build a TypeScript type expression that resolves a single param's
-* codec by walking a chain of params.ts files in priority order.
-*
-* Each entry in the chain emits one application of the shared
-* `_TimberResolveSegmentField` helper type. Composing N applications
-* grows linearly with chain depth (O(N) characters), unlike an inline
-* conditional that would duplicate the fallback in each branch and
-* grow O(2^N).
-*
-* The closest match (position 0 in the chain) is checked first; if its
-* `segmentParams` definition declares the key, its inferred type wins.
-* Otherwise we fall through to the next entry, and finally to the
-* provided fallback. See TIM-834.
-*/
-function buildCodecChainType(p, importBase, fallback) {
-	const files = p.codecFilePaths;
-	if (!files || files.length === 0) return fallback;
-	const key = JSON.stringify(p.name);
-	let inner = fallback;
-	for (let i = files.length - 1; i >= 0; i--) inner = `${RESOLVE_SEGMENT_FIELD_TYPE_NAME}<(typeof import('${codecImportPath(files[i], importBase)}'))['segmentParams'], ${key}, ${inner}>`;
-	return inner;
-}
-/**
-* Build a TypeScript type expression for a single param using the global
-* schema's InferCodecType. Falls back to the param's base type when
-* schema doesn't declare this param (schemas are opt-in per key).
-*
-* Uses `infer` to extract the codec value rather than direct indexing
-* because TypeScript doesn't narrow index validity inside a conditional
-* type's true branch — `typeof schema.segmentParams[K]` produces TS2538
-* even when the condition proves K is a valid key. In .d.ts files that
-* error is suppressed and the type silently becomes `any`.
-*/
-function buildSchemaParamType(p, fallback) {
-	return `typeof schema['segmentParams'] extends Record<${JSON.stringify(p.bracketName)}, infer V> ? InferCodecType<V> : ${fallback ?? p.type}`;
-}
-/**
-* Format the searchParams type for a route entry.
-*
-* When a page.tsx (or params.ts) exports searchParams, we reference its
-* inferred type via an import type. The import path is relative to
-* `importBase` (the directory where the .d.ts will be written). When
-* importBase is undefined, falls back to a bare relative path.
-*/
-function formatSearchParamsType(route, importBase) {
-	if (route.hasSearchParams && route.searchParamsPagePath) return `(typeof import('${codecImportPath(route.searchParamsPagePath, importBase)}'))['searchParams'] extends import('@timber-js/app/search-params').SearchParamsDefinition<infer T> ? T : never`;
-	return "{}";
-}
-//#endregion
-//#region src/routing/file-cache.ts
-var cache = /* @__PURE__ */ new Map();
-/**
-* Read a file's text content, returning a cached copy when the file
-* hasn't been modified since the last read (checked via mtime + size).
-*
-* Falls back to a fresh read on any stat/read error.
-*/
-function readFileCached(filePath) {
-	try {
-		const stat = statSync(filePath);
-		const entry = cache.get(filePath);
-		if (entry && entry.mtimeMs === stat.mtimeMs && entry.size === stat.size) return entry.content;
-		const content = readFileSync(filePath, "utf-8");
-		cache.set(filePath, {
-			mtimeMs: stat.mtimeMs,
-			size: stat.size,
-			content
-		});
-		return content;
-	} catch {
-		cache.delete(filePath);
-		return readFileSync(filePath, "utf-8");
-	}
-}
-//#endregion
-//#region src/routing/export-detect.ts
-/**
-* AST-based export detection for route files.
-*
-* Uses Vite's `parseAst` (backed by oxc) to precisely detect named and
-* default exports, replacing the regex-based approach that was fragile
-* with TypeScript syntax (type exports, `as` aliases, comments, etc.).
-*/
-function tryParse(source) {
-	try {
-		return parseAst(source, { lang: "tsx" });
-	} catch {
-		return null;
-	}
-}
-/**
-* Collect all named export identifiers from a parsed program.
-* Handles: `export function X`, `export const X`, `export { X }`,
-* `export { X } from '...'`, `export { Y as X }`.
-*/
-function collectNamedExports(program) {
-	const names = /* @__PURE__ */ new Set();
-	for (const stmt of program.body) {
-		if (stmt.type !== "ExportNamedDeclaration") continue;
-		if (stmt.exportKind === "type") continue;
-		if (stmt.declaration) {
-			if (stmt.declaration.id?.name) names.add(stmt.declaration.id.name);
-			if (stmt.declaration.declarations) {
-				for (const decl of stmt.declaration.declarations) if (decl.id?.name) names.add(decl.id.name);
-			}
-		}
-		if (stmt.specifiers) for (const spec of stmt.specifiers) {
-			if (spec.exportKind === "type") continue;
-			if (spec.exported?.name && spec.exported.name !== "default") names.add(spec.exported.name);
-		}
-	}
-	return names;
-}
-/**
-* Check whether a program has a default export.
-* Handles: `export default ...`, `export { X as default }`,
-* `export { default } from '...'`.
-*/
-function hasDefaultExport(program) {
-	for (const stmt of program.body) {
-		if (stmt.type === "ExportDefaultDeclaration") return true;
-		if (stmt.type === "ExportNamedDeclaration" && stmt.specifiers) {
-			for (const spec of stmt.specifiers) if (spec.exported?.name === "default") return true;
-		}
-	}
-	return false;
-}
-/**
-* Check whether a program has any bare `export * from '...'` declarations.
-* Excludes `export * as X from '...'` (namespace re-exports) since those
-* create a namespace object, not individual top-level exports.
-*/
-function hasStarExport(program) {
-	return program.body.some((stmt) => stmt.type === "ExportAllDeclaration" && !stmt.exported && stmt.exportKind !== "type");
-}
-/**
-* Check if a file exports a specific named export.
-* Returns false if the file doesn't exist or can't be parsed.
-*/
-function fileHasExport(filePath, exportName) {
-	if (!existsSync(filePath)) return false;
-	try {
-		const program = tryParse(readFileCached(filePath));
-		if (!program) return false;
-		return collectNamedExports(program).has(exportName);
-	} catch {
-		return false;
-	}
-}
-/**
-* Check if a file has any of the given named exports.
-* Returns the set of matching export names.
-*/
-function fileHasAnyExport(filePath, exportNames) {
-	const matches = /* @__PURE__ */ new Set();
-	try {
-		const program = tryParse(readFileCached(filePath));
-		if (!program) return matches;
-		const exports = collectNamedExports(program);
-		for (const name of exportNames) if (exports.has(name)) matches.add(name);
-	} catch {}
-	return matches;
-}
-/**
-* Check if a file has a default export.
-* Returns false if the file doesn't exist or can't be parsed.
-*/
-function fileHasDefaultExport(filePath) {
-	if (!existsSync(filePath)) return false;
-	try {
-		const program = tryParse(readFileCached(filePath));
-		if (!program) return false;
-		return hasDefaultExport(program);
-	} catch {
-		return false;
-	}
-}
-/**
-* Check if a file has any `export * from '...'` declarations.
-* Returns false if the file doesn't exist or can't be parsed.
-*/
-function fileHasStarExport(filePath) {
-	if (!existsSync(filePath)) return false;
-	try {
-		const program = tryParse(readFileCached(filePath));
-		if (!program) return false;
-		return hasStarExport(program);
-	} catch {
-		return false;
-	}
-}
-function extractLiteralValue(node) {
-	if (!node) return void 0;
-	const n = node;
-	if (n.type === "Literal") return n.value;
-	if (n.type === "UnaryExpression" && n.operator === "-" && n.argument?.type === "Literal") return -n.argument.value;
-	if (n.type === "ArrayExpression") {
-		const elements = n.elements;
-		if (!elements) return void 0;
-		const result = [];
-		for (const el of elements) {
-			const v = extractLiteralValue(el);
-			if (v === void 0) return void 0;
-			result.push(v);
-		}
-		return result;
-	}
-}
-function extractObjectLiteral(node) {
-	if (node.type !== "ObjectExpression") return void 0;
-	const props = node.properties;
-	if (!props) return void 0;
-	const result = {};
-	for (const prop of props) {
-		const p = prop;
-		if (p.type === "SpreadElement") return void 0;
-		if (p.type !== "Property" || p.computed) return void 0;
-		const key = p.key?.type === "Identifier" ? p.key.name : p.key?.type === "Literal" ? String(p.key.value) : void 0;
-		if (!key) return void 0;
-		const value = extractLiteralValue(p.value);
-		if (value === void 0) return void 0;
-		result[key] = value;
-	}
-	return result;
-}
-/**
-* Extract the value of `export const prerender` from a file.
-* Returns undefined if the file doesn't export `prerender` or can't be parsed.
-*
-* Supports:
-*   export const prerender = true;
-*   export const prerender = false;
-*   export const prerender = { ttl: 3600, tags: ['docs'] };
-*/
-function getPrerenderExport(filePath) {
-	if (!existsSync(filePath)) return void 0;
-	try {
-		const program = tryParse(readFileCached(filePath));
-		if (!program) return void 0;
-		for (const stmt of program.body) {
-			if (stmt.type !== "ExportNamedDeclaration") continue;
-			if (stmt.exportKind === "type") continue;
-			if (!stmt.declaration) continue;
-			const decl = stmt.declaration;
-			if (decl.type !== "VariableDeclaration") continue;
-			const declarations = decl.declarations;
-			if (!declarations) continue;
-			for (const d of declarations) {
-				if (d.id?.name !== "prerender" || !d.init) continue;
-				const init = d.init;
-				if (init.type === "Literal" && typeof init.value === "boolean") return init.value;
-				if (init.type === "ObjectExpression") {
-					const obj = extractObjectLiteral(init);
-					if (!obj) return void 0;
-					const result = {};
-					if ("ttl" in obj && typeof obj.ttl === "number") result.ttl = obj.ttl;
-					if ("tags" in obj && Array.isArray(obj.tags) && obj.tags.every((t) => typeof t === "string")) result.tags = obj.tags;
-					return result;
-				}
-				return;
-			}
-		}
-		return;
-	} catch {
-		return;
-	}
-}
-/**
-* Check if a file starts with a specific directive (e.g. "use client").
-* Directives are string literal expression statements at the top of the file.
-*/
-function fileHasDirective(filePath, directive) {
-	if (!existsSync(filePath)) return false;
-	try {
-		const program = tryParse(readFileCached(filePath));
-		if (!program) return false;
-		for (const stmt of program.body) {
-			if (stmt.type !== "ExpressionStatement") break;
-			const expr = stmt.expression;
-			if (expr?.type !== "Literal" || typeof expr.value !== "string") break;
-			if (expr.value === directive) return true;
-		}
-		return false;
-	} catch {
-		return false;
-	}
-}
-//#endregion
-//#region src/routing/link-codegen.ts
-/** Shared Link base-props type literal used in every emitted call signature. */
-var LINK_BASE_PROPS_TYPE = "Omit<import('react').AnchorHTMLAttributes<HTMLAnchorElement>, 'href'> & { prefetch?: boolean; scroll?: boolean; preserveSearchParams?: true | string[]; onNavigate?: import('./client/link.js').OnNavigateHandler; children?: import('react').ReactNode }";
-/**
-* Build a TypeScript template literal pattern for a dynamic route.
-* e.g. '/products/[id]'        → '/products/${string}'
-*      '/blog/[...slug]'       → '/blog/${string}'
-*      '/docs/[[...path]]'     → '/docs/${string}' (also matches /docs)
-*      '/[org]/[repo]'         → '/${string}/${string}'
-*/
-function buildResolvedPattern(route) {
-	return route.urlPath.split("/").map((part) => {
-		const seg = classifyUrlSegment(part);
-		switch (seg.kind) {
-			case "catch-all":
-			case "optional-catch-all": return "${string}";
-			case "dynamic": return `${seg.prefix ?? ""}\${string}${seg.suffix ?? ""}`;
-			default: return part;
-		}
-	}).join("/");
-}
-/**
-* Format the segmentParams type for Link overloads.
-*
-* Link params accept `string | number` for single dynamic segments
-* (convenience — values are stringified at runtime). Catch-all and
-* optional catch-all remain `string[]` / `string[] | undefined`.
-*
-* 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, hasSchema) {
-	if (params.length === 0) return "{}";
-	return `{ ${params.map((p) => {
-		const fallback = p.type === "string" ? "string | number" : p.type;
-		const codecType = hasSchema ? buildSchemaParamType(p, fallback) : buildCodecChainType(p, importBase, fallback);
-		return `${p.name}: ${codecType}`;
-	}).join("; ")} }`;
-}
-/**
-* Catch-all call signatures for `<Link>` — external hrefs and computed
-* `string` variables. Emitted from codegen in a SEPARATE
-* `declare module` block (declared AFTER the per-route block) so the TS
-* "later overload set ordered first" rule places these catch-all
-* signatures ahead of per-route in resolution order, leaving per-route
-* as the final overload whose error message is reported on failure.
-*
-* The conditional `string extends H ? ... : never` protection preserves
-* TIM-624's guarantee that unknown internal path literals don't match
-* the catch-all — typos like `<Link href="/typo" />` still error.
-*/
-function formatLinkCatchAllOverloads() {
-	const lines = [];
-	const baseProps = LINK_BASE_PROPS_TYPE;
-	const catchAllSearchParams = "{ definition: SearchParamsDefinition<Record<string, unknown>>; values: Record<string, unknown> } | Record<string, unknown>";
-	const externalHref = "`http://${string}` | `https://${string}` | `mailto:${string}` | `tel:${string}` | `ftp://${string}` | `//${string}` | `#${string}` | `?${string}`";
-	lines.push("  // Typed Link overloads — catch-all (block 2 / emitted second)");
-	lines.push("  interface LinkFunction {");
-	lines.push(`    (props: ${baseProps} & {`);
-	lines.push(`      href: ${externalHref}`);
-	lines.push(`      segmentParams?: Record<string, unknown>`);
-	lines.push(`      searchParams?: ${catchAllSearchParams}`);
-	lines.push(`    }): import('react').JSX.Element`);
-	lines.push(`    <H extends string>(`);
-	lines.push(`      props: ${baseProps} & {`);
-	lines.push(`        href: string extends H ? H : never`);
-	lines.push(`        segmentParams?: Record<string, string | number | string[]>`);
-	lines.push(`        searchParams?: ${catchAllSearchParams}`);
-	lines.push(`      }`);
-	lines.push(`    ): import('react').JSX.Element`);
-	lines.push("  }");
-	return lines;
-}
-/**
-* Generate typed per-route Link call signatures via LinkFunction
-* interface merging.
-*
-* TIM-835: This emits a SINGLE call signature whose props is a
-* discriminated union keyed on `href`. TypeScript narrows the union by
-* the literal `href` at the call site, then checks the rest of the
-* props against the matched variant. When `segmentParams` or
-* `searchParams` is wrong, TS reports the error against the matched
-* variant — naming the user's actual `href` and the offending field.
-*
-* Before TIM-835, this function emitted N separate per-route overloads
-* (one per route, sometimes two for dynamic routes). When ALL overloads
-* failed, TS would pick an arbitrary failed overload (heuristically the
-* "last tried") to render the diagnostic, often pointing at a route
-* completely unrelated to the one the user wrote. The discriminated
-* union sidesteps overload-resolution heuristics entirely.
-*
-* Open property shapes (`Record<string, unknown>` instead of `never`)
-* for `segmentParams` on routes that don't declare them keep generic
-* `LinkProps`-spreading wrappers compiling. (Aligned with TIM-833.)
-*
-* TIM-832: this function still emits the per-route block FIRST and the
-* catch-all block follows, so per-route remains the LAST overload set in
-* resolution order — the one TS reports against on failure. With a
-* discriminated union there is only one call signature in this block,
-* 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, 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, 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} }`);
-		if (hasDynamicParams) {
-			const templatePattern = buildResolvedPattern(route);
-			if (templatePattern) {
-				const resolvedSearchParamsProp = searchParamsType ? `searchParams?: { definition: SearchParamsDefinition<${searchParamsType}>; values: Partial<${searchParamsType}> }` : "searchParams?: Record<string, unknown>";
-				variants.push(`${baseProps} & { href: \`${templatePattern}\`; segmentParams?: Record<string, never>; ${resolvedSearchParamsProp} }`);
-			}
-		}
-	}
-	lines.push("  interface LinkFunction {");
-	if (variants.length === 0) {
-		lines.push("  }");
-		return lines;
-	}
-	lines.push("    (");
-	lines.push("      props:");
-	for (const variant of variants) lines.push(`        | (${variant})`);
-	lines.push(`    ): import('react').JSX.Element`);
-	lines.push("  }");
-	return lines;
-}
-//#endregion
-//#region src/routing/codegen.ts
-/**
-* Route map codegen.
-*
-* Walks the scanned RouteTree and generates a TypeScript declaration file
-* mapping every route to its params and searchParams shapes.
-*
-* This runs at build time and in dev (regenerated on file changes).
-* No runtime overhead — purely static type generation.
-*/
-/**
-* Generate a TypeScript declaration file string from a scanned route tree.
-*
-* The output is a `declare module '@timber-js/app'` block containing the Routes
-* 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, hasSchema, false);
-	routes.sort((a, b) => a.urlPath.localeCompare(b.urlPath));
-	return formatDeclarationFile(routes, options.outputDir ?? options.appDir, hasSchema, options.appDir);
-}
-/** 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.
-*
-* 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, parentTreePath, routes, hasSchema, insideSlot, insideIntercepting = false) {
-	const treePath = node.segmentName ? `${parentTreePath}/${node.segmentName}` : parentTreePath;
-	const ownParamsFile = node.params && fileHasExport(node.params.filePath, "segmentParams") ? node.params.filePath : void 0;
-	const urlSegment = effectiveUrlSegment(node);
-	const params = [...ancestorParams];
-	if (urlSegment.paramName) {
-		const legacyFallback = ownParamsFile ? void 0 : findLegacyParamsExport(node);
-		params.push({
-			name: urlSegment.paramName,
-			bracketName: bracketNameForSegment(urlSegment),
-			type: paramTypeForSegment(urlSegment.segmentType),
-			legacyCodecFilePath: legacyFallback
-		});
-	}
-	const nextAncestorFiles = ownParamsFile ? [...ancestorParamsFiles, ownParamsFile] : ancestorParamsFiles;
-	const isPage = !!node.page;
-	const isApiRoute = !!node.route;
-	if (isPage || isApiRoute) {
-		const leafFirstChain = nextAncestorFiles.length > 0 ? [...nextAncestorFiles].reverse() : [];
-		const resolvedParams = params.map((p) => {
-			const codecFilePaths = leafFirstChain.length > 0 ? leafFirstChain : p.legacyCodecFilePath ? [p.legacyCodecFilePath] : void 0;
-			return {
-				name: p.name,
-				bracketName: p.bracketName,
-				type: p.type,
-				codecFilePaths
-			};
-		});
-		const entry = {
-			urlPath: node.urlPath,
-			segmentPath: treePath || "/",
-			params: resolvedParams,
-			hasSearchParams: false,
-			isApiRoute,
-			isSlotRoute: insideSlot,
-			isInterceptingRoute: insideIntercepting,
-			hasSchema
-		};
-		if (isPage) {
-			if (node.params && fileHasExport(node.params.filePath, "searchParams")) {
-				entry.hasSearchParams = true;
-				entry.searchParamsPagePath = node.params.filePath;
-			} else if (node.page && fileHasExport(node.page.filePath, "searchParams")) {
-				entry.hasSearchParams = true;
-				entry.searchParamsPagePath = node.page.filePath;
-			}
-		}
-		routes.push(entry);
-	}
-	for (const child of node.children) collectRoutes(child, params, nextAncestorFiles, treePath, routes, hasSchema, insideSlot, insideIntercepting || child.segmentType === "intercepting");
-	for (const slot of Object.values(node.slots)) collectRoutes(slot, params, nextAncestorFiles, treePath, routes, hasSchema, true, insideIntercepting);
-}
-/**
-* Dedupe route entries by urlPath for urlPath-keyed emissions (the Routes
-* interface, useQueryStates overloads, and typed Link variants).
-*
-* Parallel-slot pages share their parent's urlPath; emitting one entry per
-* slot page produced duplicate interface keys (TS2300/TS2717 under
-* skipLibCheck:false) and duplicate overloads. The non-slot entry is the
-* canonical one; when only slot entries exist (parent has no page), the
-* lexicographically smallest segmentPath wins so output is independent of
-* slot scan order. A slot's searchParams definition is carried onto the
-* merged entry when the canonical entry has none — never silently dropped.
-*
-* segmentPath-keyed emissions (getSegmentParams, useSegmentParams,
-* TimberSegmentParams) must NOT use this — segmentPaths are already unique
-* and slot entries feed those APIs directly.
-*/
-function dedupeRoutesByUrlPath(routes) {
-	const byPath = /* @__PURE__ */ new Map();
-	for (const route of routes) {
-		const existing = byPath.get(route.urlPath);
-		if (!existing) {
-			byPath.set(route.urlPath, route);
-			continue;
-		}
-		let winner = existing;
-		let loser = route;
-		if (existing.isSlotRoute && !route.isSlotRoute || !!existing.isSlotRoute === !!route.isSlotRoute && route.segmentPath.localeCompare(existing.segmentPath) < 0) {
-			winner = route;
-			loser = existing;
-		}
-		if (!winner.hasSearchParams && loser.hasSearchParams) winner = {
-			...winner,
-			hasSearchParams: true,
-			searchParamsPagePath: loser.searchParamsPagePath
-		};
-		byPath.set(route.urlPath, winner);
-	}
-	return [...byPath.values()];
-}
-/**
-* Determine the TypeScript type for a segment's param.
-*/
-/**
-* Derive the bracket key for schema/codegen lookup.
-* For bare segments like `[id]` this is the segmentName itself.
-* For affixed segments like `img-[id].png` this is `[id]` — the bare bracket form.
-*/
-function bracketNameForSegment(node) {
-	if (node.paramPrefix || node.paramSuffix) return `[${node.paramName}]`;
-	return node.segmentName;
-}
-function paramTypeForSegment(segmentType) {
-	switch (segmentType) {
-		case "catch-all": return "string[]";
-		case "optional-catch-all": return "string[] | undefined";
-		default: return "string";
-	}
-}
-/**
-* Find a legacy `segmentParams` export on layout.tsx or page.tsx.
-*
-* Backward-compat shim: TIM-508 made params.ts the canonical location
-* for `segmentParams`. Layout/page exports are still accepted for the
-* OWN segment only (not inherited by descendants — see TIM-834).
-*/
-function findLegacyParamsExport(node) {
-	if (node.layout && fileHasExport(node.layout.filePath, "segmentParams")) return node.layout.filePath;
-	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 segment path to its accumulated segment params. */");
-	lines.push("export interface TimberSegmentParams {");
-	for (const route of routes) if (route.params.length === 0) lines.push(`  '${route.segmentPath}': {};`);
-	else {
-		lines.push(`  '${route.segmentPath}': {`);
-		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, hasSchema, appDir) {
-	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("");
-	if (hasSchema) {
-		const schemaImport = appDir && importBase ? "./" + relative(importBase, join(appDir, "schema")).replace(/\\/g, "/") : "../app/schema";
-		lines.push(`import type schema from '${schemaImport}';`);
-		lines.push("import type { InferCodecType, SegmentParamCodec } from '@timber-js/app/params';");
-		lines.push("");
-		const allBracketKeys = /* @__PURE__ */ new Set();
-		for (const route of routes) for (const p of route.params) allBracketKeys.add(p.bracketName);
-		if (allBracketKeys.size > 0) {
-			lines.push("declare module '@timber-js/app/params' {");
-			lines.push("  interface ValidDynamicSegmentKeysRegistry {");
-			for (const key of [...allBracketKeys].sort()) lines.push(`    ${JSON.stringify(key)}: true;`);
-			lines.push("  }");
-			lines.push("}");
-			lines.push("");
-		}
-		lines.push("type _AssertSchemaValues = {");
-		lines.push("  [K in keyof typeof schema['segmentParams']]: typeof schema['segmentParams'][K] extends SegmentParamCodec ? true : ['Error: value for', K, 'is not a valid Codec or Standard Schema'];");
-		lines.push("};");
-		lines.push("type _EnforceSchemaValues<_T extends Record<string, true> = _AssertSchemaValues> = true;");
-		lines.push("");
-	}
-	if (!hasSchema) {
-		lines.push(emitResolveSegmentFieldHelper());
-		lines.push("");
-	}
-	const uniqueByUrlPath = dedupeRoutesByUrlPath(routes.filter((r) => !r.isInterceptingRoute));
-	lines.push("declare module '@timber-js/app' {");
-	lines.push("  interface Routes {");
-	for (const route of uniqueByUrlPath) {
-		const paramsType = formatParamsType(route.params, importBase, hasSchema);
-		const searchParamsType = formatSearchParamsType(route, importBase);
-		lines.push(`    '${route.urlPath}': {`);
-		lines.push(`      segmentParams: ${paramsType}`);
-		lines.push(`      searchParams: ${searchParamsType}`);
-		lines.push(`    }`);
-	}
-	lines.push("  }");
-	if (hasSchema) {
-		lines.push("");
-		lines.push(...formatSchemaTypes(routes).map((l) => `  ${l}`));
-	}
-	lines.push("}");
-	lines.push("");
-	const pageRoutes = uniqueByUrlPath.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' {");
-		if (hasSchema) lines.push("  import type { AllSegmentParams } from '@timber-js/app'");
-		for (const route of dynamicRoutes) {
-			const paramsType = formatParamsType(route.params, importBase, hasSchema);
-			lines.push(`  export function getSegmentParams(segmentPath: '${route.segmentPath}'): ${paramsType}`);
-		}
-		lines.push(hasSchema ? "  export function getSegmentParams(): Partial<AllSegmentParams>" : "  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'");
-		if (hasSchema) lines.push("  import type { AllSegmentParams } from '@timber-js/app'");
-		lines.push("");
-		if (dynamicRoutes.length > 0) {
-			for (const route of dynamicRoutes) {
-				const paramsType = formatParamsType(route.params, importBase, hasSchema);
-				lines.push(`  export function useSegmentParams(segmentPath: '${route.segmentPath}'): ${paramsType}`);
-			}
-			lines.push(hasSchema ? "  export function useSegmentParams(): Partial<AllSegmentParams>" : "  export function useSegmentParams(): Record<string, string | string[]>");
-			lines.push("");
-		}
-		if (pageRoutes.length > 0) {
-			lines.push(...formatUseQueryStatesOverloads(pageRoutes, importBase));
-			lines.push("");
-		}
-		if (pageRoutes.length > 0) {
-			lines.push("  // Typed Link overloads — per-route (block 1 / emitted first)");
-			lines.push(...formatTypedLinkOverloads(pageRoutes, importBase, hasSchema));
-			lines.push("");
-		}
-		lines.push("}");
-		lines.push("");
-	}
-	lines.push("declare module '@timber-js/app/client' {");
-	lines.push("  import type { SearchParamsDefinition } from '@timber-js/app/search-params'");
-	lines.push("");
-	lines.push(...formatLinkCatchAllOverloads());
-	lines.push("}");
-	lines.push("");
-	return lines.join("\n");
-}
-/**
-* Format the params type for a route entry.
-*/
-function formatParamsType(params, importBase, hasSchema) {
-	if (params.length === 0) return "{}";
-	return `{ ${params.map((p) => {
-		const codecType = hasSchema ? buildSchemaParamType(p) : buildCodecChainType(p, importBase, p.type);
-		return `${p.name}: ${codecType}`;
-	}).join("; ")} }`;
-}
-/**
-* Generate useQueryStates overloads.
-*
-* For each page route:
-* - Routes with search-params.ts get a typed overload returning the inferred T
-* - Routes without search-params.ts get an overload returning [{}, SetParams<{}>]
-*
-* A fallback overload for standalone codecs (existing API) is emitted last.
-*/
-function formatUseQueryStatesOverloads(routes, importBase) {
-	const lines = [];
-	for (const route of routes) {
-		const searchParamsType = route.hasSearchParams ? formatSearchParamsType(route, importBase) : "{}";
-		lines.push(`  export function useQueryStates<R extends '${route.urlPath}'>(route: R, options?: QueryStatesOptions): [${searchParamsType}, SetParams<${searchParamsType}>]`);
-	}
-	lines.push("  export function useQueryStates<T extends Record<string, unknown>>(codecs: { [K in keyof T]: SearchParamCodec<T[K]> }, options?: QueryStatesOptions): [T, SetParams<T>]");
-	return lines;
-}
-//#endregion
-//#region src/routing/schema-validation.ts
-/**
-* Schema key/value validation against the filesystem route tree.
-*
-* Runs at codegen time (build + dev) to catch mismatches between
-* app/schema.ts keys and the actual dynamic segments on disk.
-*
-* Design doc: design/41-global-params.md
-*/
-/**
-* Collect all unique bracket-keyed dynamic segment names from a route tree.
-* Returns entries like '[artistSlug]', '[...slug]', '[[...topic]]'.
-*/
-function collectDynamicSegmentsFromTree(tree) {
-	const segments = /* @__PURE__ */ new Set();
-	walkTree(tree.root, segments);
-	return segments;
-}
-function walkTree(node, segments) {
-	if (node.paramName && node.segmentName) {
-		const classified = classifyUrlSegment(node.segmentName);
-		if (classified.kind !== "static") if (classified.kind === "dynamic" && (classified.prefix || classified.suffix)) segments.add(`[${classified.name}]`);
-		else segments.add(node.segmentName);
-	}
-	for (const child of node.children) walkTree(child, segments);
-	for (const slot of Object.values(node.slots)) walkTree(slot, segments);
-}
-/**
-* Extract the param name from a bracket key.
-* '[id]' → 'id', '[...slug]' → 'slug', '[[...topic]]' → 'topic'
-*/
-function extractParamName(bracketKey) {
-	const seg = classifyUrlSegment(bracketKey);
-	if (seg.kind === "static") return null;
-	return seg.name;
-}
-/**
-* Validate schema keys against the filesystem route tree.
-*
-* Returns warnings for:
-* - Stale keys: schema keys that don't match any filesystem segment
-* - Bracket form mismatches: same param name, different bracket form
-* - Missing keys: filesystem segments not registered in schema (informational)
-*/
-function validateSchemaAgainstRoutes(tree, appDir) {
-	const schemaPath = findSchemaFile(appDir);
-	if (!schemaPath) return [];
-	const schemaKeys = parseExistingSchemaKeys(readFileCached(schemaPath));
-	if (schemaKeys.length === 0) return [];
-	return validateKeys(schemaKeys, collectDynamicSegmentsFromTree(tree));
-}
-/**
-* Core validation: compare schema keys against filesystem segments.
-* Exported separately for testing without filesystem dependencies.
-*/
-function validateKeys(schemaKeys, filesystemSegments) {
-	const warnings = [];
-	const fsParamToKey = /* @__PURE__ */ new Map();
-	for (const fsKey of filesystemSegments) {
-		const name = extractParamName(fsKey);
-		if (name) fsParamToKey.set(name, fsKey);
-	}
-	const schemaParamNames = /* @__PURE__ */ new Set();
-	for (const schemaKey of schemaKeys) {
-		const schemaParamName = extractParamName(schemaKey);
-		if (!schemaParamName) continue;
-		schemaParamNames.add(schemaParamName);
-		if (filesystemSegments.has(schemaKey)) continue;
-		const fsKey = fsParamToKey.get(schemaParamName);
-		if (fsKey) warnings.push({
-			type: "bracket-mismatch",
-			key: schemaKey,
-			filesystemKey: fsKey,
-			message: `Schema key '${schemaKey}' does not match filesystem bracket form '${fsKey}'. Update the schema key to '${fsKey}'.`
-		});
-		else warnings.push({
-			type: "stale-key",
-			key: schemaKey,
-			message: `Schema key '${schemaKey}' does not match any dynamic segment in the filesystem. Remove it from app/schema.ts or create the corresponding route segment.`
-		});
-	}
-	for (const fsKey of filesystemSegments) {
-		const name = extractParamName(fsKey);
-		if (name && !schemaParamNames.has(name)) warnings.push({
-			type: "missing-key",
-			key: fsKey,
-			message: `Dynamic segment '${fsKey}' has no codec in app/schema.ts (defaults to string). Run: timber schema sync`
-		});
-	}
-	return warnings;
-}
-//#endregion
-//#region src/routing/walkers.ts
-/**
-* Walk a segment tree and collect every leaf with a `page` or `route`
-* handler. Generic over `TFile` so it works on both the build-time
-* scanner output and the runtime manifest tree.
-*
-* - Pages and route handlers at the same URL produce two distinct
-*   entries (the build report deduplicates by URL afterward).
-* - Parallel slots are skipped unless `includeSlots: true` (slots
-*   share their parent's URL and are not addressable on their own).
-* - Intercepting subtrees are skipped unconditionally. They render only
-*   on soft navigation and add no URL depth, so their computed `urlPath`s
-*   are not addresses — listing them would advertise routes (`/[year]`)
-*   that no request can reach. This matches every other consumer of the
-*   tree that produces URLs: the sitemap generator, the static generator,
-*   prerendering and the prebuilt-payload builder all skip them too.
-* - Result is sorted by `urlPath` for deterministic output.
-*/
-function collectLeafRoutes(root, options = {}) {
-	const { includeSlots = false } = options;
-	const result = [];
-	walk(root, [], result, includeSlots);
-	result.sort((a, b) => a.urlPath.localeCompare(b.urlPath));
-	return result;
-}
-function walk(node, chain, result, includeSlots) {
-	if (node.segmentType === "intercepting") return;
-	const currentChain = [...chain, node];
-	const path = node.urlPath || "/";
-	if (node.page) result.push({
-		urlPath: path,
-		segments: currentChain,
-		page: node.page
-	});
-	if (node.route) result.push({
-		urlPath: path,
-		segments: currentChain,
-		route: node.route
-	});
-	for (const child of node.children) walk(child, currentChain, result, includeSlots);
-	if (includeSlots) for (const slotNode of Object.values(node.slots)) walk(slotNode, currentChain, result, includeSlots);
-}
-//#endregion
-export { fileHasAnyExport as a, fileHasExport as c, generateRouteMap as i, fileHasStarExport as l, collectDynamicSegmentsFromTree as n, fileHasDefaultExport as o, validateSchemaAgainstRoutes as r, fileHasDirective as s, collectLeafRoutes as t, getPrerenderExport as u };
-
-//# sourceMappingURL=walkers-BhhwI9TD.js.map