@timber-js/app 0.2.0-alpha.20 → 0.2.0-alpha.201

package/dist/routing/codegen-types.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Shared types for route codegen modules.
+ *
+ * Lives in its own file so `link-codegen.ts` and `codegen.ts` can import
+ * the same `RouteEntry` / `ParamEntry` shapes without a cyclic
+ * dependency between the two.
+ */
+/** A single route entry extracted from the segment tree. */
+export interface RouteEntry {
+    /** URL path pattern (e.g. "/products/[id]") */
+    urlPath: string;
+    /** Full tree path including groups and slots (e.g. "/(browse)/[artistSlug]/@shows/[year]").
+     *  Uniquely identifies a segment — unlike urlPath which strips groups/slots. */
+    segmentPath: string;
+    /** Accumulated params from all ancestor dynamic segments */
+    params: ParamEntry[];
+    /** Whether this is an API route (route.ts) vs page route */
+    isApiRoute: boolean;
+    /**
+     * Whether a request can reach this segment — it has a `page` or `route`.
+     *
+     * False for a segment that only hosts a layout/middleware/access above the
+     * leaf. Those still need typed `getSegmentParams(SEGMENT_PATH)` overloads
+     * (they have a `$segment` module), but must NOT appear in urlPath-keyed
+     * emissions — the `Routes` interface and `<Link>` — because their urlPath
+     * is not an addressable route. See TIM-1342.
+     */
+    isRoutable: boolean;
+    /** Whether this entry lives inside a parallel slot (@name). Slot entries
+     *  share their parent's urlPath — urlPath-keyed emissions dedupe them,
+     *  preferring the non-slot entry. segmentPath-keyed emissions keep all. */
+    isSlotRoute?: boolean;
+    /**
+     * Whether this entry lives inside an intercepting subtree.
+     *
+     * Such an entry has **no URL of its own**. Interception adds no URL depth,
+     * so the scanner's `urlPath` for the subtree is the owner's path with the
+     * descendants' names appended — `(browse)/(...)[artistSlug]/[year]` computes
+     * `/[year]`, which is not the route it renders at (that is
+     * `/[artistSlug]/[year]`) and is not reachable by any request. It is also
+     * soft-navigation-only.
+     *
+     * So these entries are dropped from every urlPath-keyed emission (`Routes`,
+     * `useQueryStates`, typed `<Link>`) rather than deduped against the
+     * canonical route: dedupe only helps where the paths happen to collide, and
+     * a non-colliding computed path would be published as a real route.
+     * segmentPath-keyed emissions keep them, so the intercepting page's own
+     * params stay typed.
+     */
+    isInterceptingRoute?: boolean;
+    /** Whether a global schema (app/schema.ts) exists for this app */
+    hasSchema?: boolean;
+}
+export interface ParamEntry {
+    name: string;
+    /** Bracket-wrapped segment name as it appears in the filesystem and schema.
+     *  e.g. '[id]', '[...slug]', '[[...slug]]' */
+    bracketName: string;
+    type: 'string' | 'string[]' | 'string[] | undefined';
+}
+//# sourceMappingURL=codegen-types.d.ts.map

package/dist/routing/codegen-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codegen-types.d.ts","sourceRoot":"","sources":["../../src/routing/codegen-types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,4DAA4D;AAC5D,MAAM,WAAW,UAAU;IACzB,+CAA+C;IAC/C,OAAO,EAAE,MAAM,CAAC;IAChB;oFACgF;IAChF,WAAW,EAAE,MAAM,CAAC;IACpB,4DAA4D;IAC5D,MAAM,EAAE,UAAU,EAAE,CAAC;IACrB,4DAA4D;IAC5D,UAAU,EAAE,OAAO,CAAC;IACpB;;;;;;;;OAQG;IACH,UAAU,EAAE,OAAO,CAAC;IACpB;;+EAE2E;IAC3E,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;;;;;;;;;;;;;;OAgBG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,kEAAkE;IAClE,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb;kDAC8C;IAC9C,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,QAAQ,GAAG,UAAU,GAAG,sBAAsB,CAAC;CACtD"}

package/dist/routing/codegen-write.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Route-map codegen writer.
+ *
+ * Materializes the generated route types on disk: `.timber/timber-routes.d.ts`,
+ * `.timber/segment-types.d.ts` (via `writeSegmentTypes`), and the root
+ * `timber-env.d.ts` that references them.
+ *
+ * Lives outside `plugins/routing.ts` because it has two callers with two
+ * different failure policies: the dev/build plugin starts the write off the hot
+ * path and logs failures, while `timber check` awaits it and treats a failure as
+ * fatal — a type check run against absent or stale route types reports errors
+ * about code that is fine. One implementation, two policies, so the bytes on
+ * disk cannot drift between the two commands.
+ *
+ * Design docs: 09-typescript.md §"Typed Routes", 18-build-system.md
+ */
+import type { RouteTree } from './types.ts';
+/**
+ * Path (relative to the project root) of the generated route map declaration
+ * file, and the name of the root file that `/// <reference>`s it.
+ *
+ * Exported because `timber check` has to answer whether the user's tsconfig
+ * pulls these into the program — a question about these exact paths. It derives
+ * them from here rather than restating them, so a rename cannot leave the check
+ * looking for a file nothing writes.
+ */
+export declare const CODEGEN_OUTPUT = ".timber/timber-routes.d.ts";
+/** Root-level file that references the generated declarations. */
+export declare const ENV_DTS_FILENAME = "timber-env.d.ts";
+/**
+ * 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: the tracked copy of each write has its
+ * rejection swallowed, so a failing write cannot turn a teardown barrier into
+ * an unhandled rejection. Callers that care about failure await the promise
+ * `writeRouteCodegen` returned instead.
+ */
+export declare function flushCodegenWrites(): Promise<void>;
+/**
+ * Write the generated route map, segment types, and the timber-env.d.ts
+ * reference file for `tree`.
+ *
+ * Returns a promise that **rejects** if any write fails. The dev/build plugin
+ * does not await it (types are a developer convenience there, not a runtime
+ * dependency) and logs instead; `timber check` awaits it and fails the command.
+ * Either way the write is registered with `flushCodegenWrites()`.
+ */
+export declare function writeRouteCodegen(tree: RouteTree, appDir: string, root: string): Promise<void>;
+//# sourceMappingURL=codegen-write.d.ts.map

package/dist/routing/codegen-write.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codegen-write.d.ts","sourceRoot":"","sources":["../../src/routing/codegen-write.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAMH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc,+BAA+B,CAAC;AAE3D,kEAAkE;AAClE,eAAO,MAAM,gBAAgB,oBAAoB,CAAC;AA8ClD;;;;;;;;;GASG;AACH,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,CAcxD;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAwB9F"}

package/dist/routing/codegen.d.ts

@@ -7,17 +7,22 @@
  * This runs at build time and in dev (regenerated on file changes).
  * No runtime overhead — purely static type generation.
  */
-import type { RouteTree } from './types.js';
+import type { RouteTree } from './types.ts';
 /** Options for route map generation. */
 export interface CodegenOptions {
-    /** Absolute path to the app/ directory. Required for search-params.ts detection. */
+    /** Absolute path to the app/ directory. Required for page searchParams detection. */
     appDir?: string;
     /**
      * Absolute path to the directory where the .d.ts file will be written.
-     * Used to compute correct relative import paths for search-params.ts files.
+     * Used to compute correct relative import paths for page files.
      * Defaults to appDir when not provided (preserves backward compat for tests).
      */
     outputDir?: string;
+    /**
+     * Whether a global schema (app/schema.ts) exists.
+     * Auto-detected from appDir when not explicitly set.
+     */
+    hasSchema?: boolean;
 }
 /**
  * Generate a TypeScript declaration file string from a scanned route tree.

package/dist/routing/codegen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"codegen.d.ts","sourceRoot":"","sources":["../../src/routing/codegen.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,KAAK,EAAE,SAAS,EAAe,MAAM,YAAY,CAAC;AAqBzD,wCAAwC;AACxC,MAAM,WAAW,cAAc;IAC7B,oFAAoF;IACpF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,GAAE,cAAmB,GAAG,MAAM,CAWtF"}
+{"version":3,"file":"codegen.d.ts","sourceRoot":"","sources":["../../src/routing/codegen.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,KAAK,EAAE,SAAS,EAAe,MAAM,YAAY,CAAC;AAMzD,wCAAwC;AACxC,MAAM,WAAW,cAAc;IAC7B,qFAAqF;IACrF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,GAAE,cAAmB,GAAG,MAAM,CActF"}

package/dist/routing/collision-probe.d.ts

@@ -0,0 +1,104 @@
+/**
+ * The order-dependence oracle shared by every route collision validator.
+ *
+ * A "collision space" is a set of pages that compete for URLs with each other:
+ * the main tree, each parallel slot, each intercepting subtree. Two pages in
+ * one space that answer the same URL are ambiguous — `matchNode` resolves the
+ * tie by whichever `children` array lists first, so which page renders is
+ * decided by filesystem enumeration order and renaming a route group can flip
+ * it. Every space rejects that shape, and they all reject it the same way,
+ * through this module.
+ *
+ * **The check asks the real matcher rather than modelling it.** For each leaf
+ * we build a URL it matches, then run `matchUrlParts` twice — once on the
+ * space, once on a clone with every `children` array reversed — and compare the
+ * winners. A URL answered by two or more candidates in the same priority tier
+ * resolves to whichever comes first in `children`, so reversing the arrays
+ * flips it; a URL with a single winner, or one settled by a higher tier, is
+ * unaffected. Order-dependence is therefore detected exactly, with no second
+ * copy of the precedence rules to drift.
+ *
+ * That drift is why this is written as an oracle. The interception validator's
+ * first version normalized each pattern into a "match shape" and compared
+ * shapes, which meant reimplementing `matchNode`'s tiers, its group flattening,
+ * and its zero-length optional-catch-all handling. Five review rounds found
+ * five divergences between the two — param spelling, a zero-length catch-all,
+ * the bracket tokens colliding with legal static directory names, a page
+ * settling a grouped catch-all, and a page settling a *direct* one (which the
+ * model could not express at all, because `matchNode` checks every route-group
+ * page before any direct optional catch-all). Each fix was locally right and
+ * the next divergence surfaced anyway. The model was the defect.
+ *
+ * **Every claim made here is existential** — "here is a URL these two contend
+ * for" — which is what a finite set of probes can actually establish. The
+ * reverse, "this page can never win any URL", is universal, and a probe's
+ * silence is not evidence for it: a leaf that loses every probe may still own
+ * URLs no probe visited. An earlier revision reported that as an
+ * unreachable-page error and produced two false build errors in one review
+ * round. Probe inadequacy must only ever cost a missed collision, never a
+ * rejected app — so nothing here may report a leaf as unreachable.
+ *
+ * See design/07-routing.md §"Comparing Routes by the URLs They Match".
+ */
+import type { SegmentNode } from './types.ts';
+/** One page-or-route-bearing node in a collision space. */
+export interface ProbeLeaf {
+    /** The file that serves it — what the error message names. */
+    filePath: string;
+    /**
+     * The nodes from the space root down to this leaf that contribute URL parts
+     * — route groups excluded, since they are transparent for matching. Empty
+     * for the space root's own page: `matchUrlParts` matches parts against the
+     * root's *children*, so the root itself consumes nothing.
+     */
+    chain: SegmentNode[];
+}
+/** Two files in one space that a single URL resolves to order-dependently. */
+export interface ProbedCollision {
+    /** The contended URL, written for a human (see `describeProbeUrl`). */
+    url: string;
+    /** The file that wins in filesystem order. */
+    first: string;
+    /** The file that wins when every `children` array is reversed. */
+    second: string;
+}
+/**
+ * Find a URL in this collision space whose winner depends on `children` order,
+ * or null if every probed URL resolves the same way in both orderings.
+ *
+ * `spaceRoot` is the node `matchUrlParts` starts from — the app root, a slot
+ * node, or an intercepting directory. `base` is the URL that root sits at, used
+ * only to render the reported URL.
+ */
+export declare function findOrderDependentCollision(spaceRoot: SegmentNode, leaves: Iterable<ProbeLeaf>, base: string): ProbedCollision | null;
+/**
+ * The values a probe's dynamic parts are tried with, in order.
+ *
+ * A probe stands in for "any value" at a dynamic position, so it is only useful
+ * if it reaches the leaf it was built for. A *static* sibling's literal name or
+ * a more specific *affixed* sibling's pattern can claim it instead, and that
+ * higher-priority segment then wins in both orderings — a genuine tie
+ * underneath goes unreported, which is safe but is the whole thing these
+ * validators are for.
+ *
+ * Which values are claimable is a question about `matchNode`'s precedence, so
+ * `probeUrlsForLeaf` asks `matchUrlParts` rather than deciding it here. This
+ * only has to offer enough shapes for the search to find one that works: an
+ * affixed sibling constrains the head of the value, its tail, or both, so head
+ * and tail are varied over an alphanumeric alphabet. The head varies fastest
+ * because a prefix is the more common affix. Exhausting the list is a missed
+ * collision like any other inadequate probe, so this is a search and not a
+ * proof — nothing downstream may treat it as one.
+ *
+ * Exported so a test that has to *name* a capturing static sibling can derive
+ * the name from this list rather than restate it — a fixture spelling the value
+ * out by hand stops being a capture the moment the list changes, and passes.
+ *
+ * Three revisions of a hand-built value each dodged one more capture and were
+ * each followed by another (avoid static names; avoid affix boundary
+ * characters; avoid re-affixed forms of static names — then a strictly more
+ * specific affixed sibling, TIM-1313). Each rule was modelling affix precedence
+ * by hand, which is what the match-shape model was deleted for.
+ */
+export declare function probeCandidates(minLength?: number): Generator<string>;
+//# sourceMappingURL=collision-probe.d.ts.map

package/dist/routing/collision-probe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collision-probe.d.ts","sourceRoot":"","sources":["../../src/routing/collision-probe.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAQ9C,2DAA2D;AAC3D,MAAM,WAAW,SAAS;IACxB,8DAA8D;IAC9D,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;;OAKG;IACH,KAAK,EAAE,WAAW,EAAE,CAAC;CACtB;AAED,8EAA8E;AAC9E,MAAM,WAAW,eAAe;IAC9B,uEAAuE;IACvE,GAAG,EAAE,MAAM,CAAC;IACZ,8CAA8C;IAC9C,KAAK,EAAE,MAAM,CAAC;IACd,kEAAkE;IAClE,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CACzC,SAAS,EAAE,WAAW,EACtB,MAAM,EAAE,QAAQ,CAAC,SAAS,CAAC,EAC3B,IAAI,EAAE,MAAM,GACX,eAAe,GAAG,IAAI,CA4CxB;AA2CD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAiB,eAAe,CAAC,SAAS,SAAI,GAAG,SAAS,CAAC,MAAM,CAAC,CA6BjE"}

package/dist/routing/collision-spaces.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Route collision spaces.
+ *
+ * A collision space is a set of routes that compete for URLs with each other,
+ * and there are three: the main tree, each parallel slot, and each intercepting
+ * subtree. This module owns the first two; `interception.ts` owns the third.
+ * All of them decide order-dependence with the one oracle in
+ * `collision-probe.ts`, so they cannot drift on what counts as two routes
+ * answering a single URL.
+ *
+ * See design/07-routing.md §"Route Collisions".
+ */
+import type { SegmentNode } from './types.ts';
+/**
+ * Validate that no two pages/routes in one collision space answer the same URL.
+ *
+ * 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.
+ *
+ * Each parallel slot is validated as its OWN collision space: a slot's pages
+ * intentionally share URL paths with the parent tree (that's the point of
+ * parallel routes), but two route groups INSIDE one slot claiming the same
+ * URL — e.g. @side/(a)/x/page.tsx + @side/(b)/x/page.tsx — still collide.
+ */
+export declare function validateRouteGroupCollisions(root: SegmentNode): void;
+//# sourceMappingURL=collision-spaces.d.ts.map

package/dist/routing/collision-spaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collision-spaces.d.ts","sourceRoot":"","sources":["../../src/routing/collision-spaces.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAI9C;;;;;;;;;;GAUG;AACH,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,CAEpE"}

package/dist/routing/convention-lint.d.ts

@@ -0,0 +1,55 @@
+/**
+ * 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.
+ *
+ * Most checks are warnings — 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).
+ *
+ * A check emits `level: 'error'` only when the misconfiguration is *proven*
+ * (never inferred from an absence the analysis cannot see through) and fatal
+ * to rendering. `plugins/routing.ts` turns those into a thrown build error,
+ * so a false positive there refuses a working app — see
+ * `classifyClientBoundaryFile` for how that bar is met.
+ *
+ * Design doc: 07-routing.md, 10-error-handling.md
+ */
+import type { RouteTree } from './types.ts';
+export interface ConventionWarning {
+    /** Warning ID for deduplication and filtering. */
+    id: string;
+    /** Human-readable single-line summary. */
+    summary: string;
+    /** Multi-line details with file path and fix suggestion. */
+    details: string;
+    /** Severity: 'warn' for potential issues, 'error' for definite misconfigurations. */
+    level: 'warn' | 'error';
+}
+/**
+ * Run all convention lint checks on a route tree.
+ *
+ * Returns an array of warnings. Empty array means everything looks good.
+ */
+export declare function lintConventions(tree: RouteTree, appDir: string): ConventionWarning[];
+/**
+ * Check if the app/ directory exists. Called before scanning.
+ * Returns a warning if missing, or null if the directory exists.
+ */
+export declare function checkAppDirExists(appDir: string): ConventionWarning | null;
+export interface FormatOptions {
+    /**
+     * Emit ANSI escapes. Off when the text becomes an `Error` message —
+     * whoever prints it decides its formatting, and colored escapes inside
+     * an exception leak into logs and stack traces.
+     */
+    color?: boolean;
+}
+/**
+ * Format warnings for terminal output.
+ *
+ * Groups by severity, uses colors, and includes fix suggestions.
+ */
+export declare function formatConventionWarnings(warnings: ConventionWarning[], options?: FormatOptions): string;
+//# sourceMappingURL=convention-lint.d.ts.map

package/dist/routing/convention-lint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convention-lint.d.ts","sourceRoot":"","sources":["../../src/routing/convention-lint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAGH,OAAO,KAAK,EAAa,SAAS,EAAe,MAAM,YAAY,CAAC;AAYpE,MAAM,WAAW,iBAAiB;IAChC,kDAAkD;IAClD,EAAE,EAAE,MAAM,CAAC;IACX,0CAA0C;IAC1C,OAAO,EAAE,MAAM,CAAC;IAChB,4DAA4D;IAC5D,OAAO,EAAE,MAAM,CAAC;IAChB,qFAAqF;IACrF,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;CACzB;AAID;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,iBAAiB,EAAE,CAgCpF;AAiWD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI,CAe1E;AAUD,MAAM,WAAW,aAAa;IAC5B;;;;OAIG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,iBAAiB,EAAE,EAC7B,OAAO,GAAE,aAAkB,GAC1B,MAAM,CAkCR"}

package/dist/routing/export-detect.d.ts

@@ -0,0 +1,72 @@
+/**
+ * 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.).
+ */
+/**
+ * Check if a file exports a specific named export.
+ * Returns false if the file doesn't exist or can't be parsed.
+ */
+export declare function fileHasExport(filePath: string, exportName: string): boolean;
+/**
+ * Check if a file has any of the given named exports.
+ * Returns the set of matching export names.
+ */
+export declare function fileHasAnyExport(filePath: string, exportNames: readonly string[]): Set<string>;
+/**
+ * Check if a file has a default export.
+ * Returns false if the file doesn't exist or can't be parsed.
+ */
+export declare function fileHasDefaultExport(filePath: string): boolean;
+/**
+ * Whether the default export is *provably* a value constructed by this module:
+ * `export default function/class/() => {}`, or a name bound to a function or
+ * class declared here — whether it leaves via `export default Name` or
+ * `export { Name as default }`. Both spellings are the same fact about where
+ * the value was built, so both must answer the same way.
+ *
+ * This is the sound half of "is this a server component?". A file with no
+ * `'use client'` directive whose default export is built here is a server
+ * component, full stop. Everything else — `export { default } from
+ * './client-thing'`, `export default Imported`, `export default memo(X)`,
+ * an unparseable file — returns false, because the exported value may have
+ * been minted in a module that *does* carry the directive. Callers must not
+ * infer "server component" from a missing directive alone.
+ */
+export declare function fileDefaultExportIsLocalValue(filePath: string): boolean;
+/**
+ * Check if a file has any `export * from '...'` declarations.
+ * Returns false if the file doesn't exist or can't be parsed.
+ */
+export declare function fileHasStarExport(filePath: string): boolean;
+/**
+ * Parsed value of `export const prerender` from a route file.
+ *
+ * - `true` / `false` — literal boolean
+ * - `{ ttl?, tags? }` — ISR options object (prerender: true is implied)
+ * - `undefined` — no `export const prerender` found
+ *
+ * See design/45-cache-lifetimes.md §"Route-Level Static".
+ */
+export type PrerenderExportValue = boolean | {
+    ttl?: number;
+    tags?: string[];
+};
+/**
+ * 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'] };
+ */
+export declare function getPrerenderExport(filePath: string): PrerenderExportValue | undefined;
+/**
+ * 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.
+ */
+export declare function fileHasDirective(filePath: string, directive: string): boolean;
+//# sourceMappingURL=export-detect.d.ts.map

package/dist/routing/export-detect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export-detect.d.ts","sourceRoot":"","sources":["../../src/routing/export-detect.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AA4HH;;;GAGG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAU3E;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,GAAG,CAAC,MAAM,CAAC,CAc9F;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAU9D;AAoED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,6BAA6B,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAiCvE;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAU3D;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,oBAAoB,GAAG,OAAO,GAAG;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AA8C/E;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,oBAAoB,GAAG,SAAS,CA+CrF;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAgB7E"}

package/dist/routing/file-cache.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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.
+ */
+export declare function readFileCached(filePath: string): string;
+//# sourceMappingURL=file-cache.d.ts.map

package/dist/routing/file-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-cache.d.ts","sourceRoot":"","sources":["../../src/routing/file-cache.ts"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAYvD"}

package/dist/routing/index.d.ts

@@ -1,8 +1,14 @@
-export { scanRoutes, classifySegment } from './scanner.js';
-export { generateRouteMap } from './codegen.js';
-export type { CodegenOptions } from './codegen.js';
-export type { RouteTree, SegmentNode, SegmentType, RouteFile, ScannerConfig, InterceptionMarker, } from './types.js';
-export { DEFAULT_PAGE_EXTENSIONS, INTERCEPTION_MARKERS } from './types.js';
-export { collectInterceptionRewrites } from './interception.js';
-export type { InterceptionRewrite } from './interception.js';
+export { scanRoutes } from './scanner.ts';
+export { generateRouteMap } from './codegen.ts';
+export type { CodegenOptions } from './codegen.ts';
+export type { RouteTree, SegmentNode, SegmentType, RouteFile, ScannerConfig, InterceptionMarker, } from './types.ts';
+export { DEFAULT_PAGE_EXTENSIONS, INTERCEPTION_MARKERS } from './types.ts';
+export { collectInterceptionRewrites } from './interception.ts';
+export type { InterceptionRewrite } from './interception.ts';
+export { classifyUrlSegment, classifySegment } from './segment-classify.ts';
+export type { UrlSegment, SegmentClassification } from './segment-classify.ts';
+export { collectLeafRoutes } from './walkers.ts';
+export type { LeafRoute, CollectLeafRoutesOptions } from './walkers.ts';
+export { validateSchemaAgainstRoutes, collectDynamicSegmentsFromTree, } from './schema-validation.ts';
+export type { SchemaWarning } from './schema-validation.ts';
 //# sourceMappingURL=index.d.ts.map

package/dist/routing/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/routing/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAC3D,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAChD,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACnD,YAAY,EACV,SAAS,EACT,WAAW,EACX,WAAW,EACX,SAAS,EACT,aAAa,EACb,kBAAkB,GACnB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,uBAAuB,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAC3E,OAAO,EAAE,2BAA2B,EAAE,MAAM,mBAAmB,CAAC;AAChE,YAAY,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/routing/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAChD,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACnD,YAAY,EACV,SAAS,EACT,WAAW,EACX,WAAW,EACX,SAAS,EACT,aAAa,EACb,kBAAkB,GACnB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,uBAAuB,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAC3E,OAAO,EAAE,2BAA2B,EAAE,MAAM,mBAAmB,CAAC;AAChE,YAAY,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAC7D,OAAO,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC5E,YAAY,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAC/E,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACjD,YAAY,EAAE,SAAS,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AACxE,OAAO,EACL,2BAA2B,EAC3B,8BAA8B,GAC/B,MAAM,wBAAwB,CAAC;AAChC,YAAY,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/routing/index.js

@@ -1,2 +1,5 @@
-import { a as DEFAULT_PAGE_EXTENSIONS, i as scanRoutes, n as generateRouteMap, o as INTERCEPTION_MARKERS, r as classifySegment, t as collectInterceptionRewrites } from "../_chunks/interception-BOoWmLUA.js";
-export { DEFAULT_PAGE_EXTENSIONS, INTERCEPTION_MARKERS, classifySegment, collectInterceptionRewrites, generateRouteMap, scanRoutes };
+import { a as INTERCEPTION_MARKERS, i as DEFAULT_PAGE_EXTENSIONS, n as classifyUrlSegment, t as classifySegment } from "../_chunks/segment-classify-C539Pa2O.js";
+import { n as scanRoutes, r as collectInterceptionRewrites } from "../_chunks/scanner-B_tnqFcF.js";
+import { n as generateRouteMap } from "../_chunks/file-cache-Dw6BJPG7.js";
+import { n as collectDynamicSegmentsFromTree, r as validateSchemaAgainstRoutes, t as collectLeafRoutes } from "../_chunks/walkers-Cm3PC5JT.js";
+export { DEFAULT_PAGE_EXTENSIONS, INTERCEPTION_MARKERS, classifySegment, classifyUrlSegment, collectDynamicSegmentsFromTree, collectInterceptionRewrites, collectLeafRoutes, generateRouteMap, scanRoutes, validateSchemaAgainstRoutes };

package/dist/routing/interception-overlap.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Pattern intersection for intercepted URL patterns.
+ *
+ * Checks whether two intercepted URL patterns can both match the same concrete
+ * URL. Used by the cross-mode claim check (TIM-1319) to detect when a
+ * children-path interceptor and a slot interceptor from the same owner overlap.
+ *
+ * This is not the order-dependence oracle (`findOrderDependentCollision`) the
+ * within-mode collision checks use. `findInterceptionMatch` picks the mode by
+ * first-match on `pathnameMatchesPattern`, which has no priority tiers, so a
+ * static `/feed/foo` and a dynamic `/feed/[id]` both match `/feed/foo` even
+ * though `matchUrlParts` would resolve the static deterministically. The
+ * intersection test catches that: it walks both patterns segment by segment and
+ * asks whether any value satisfies both.
+ *
+ * This is not a model of `matchNode` precedence — that decides *which*
+ * candidate wins when several match one URL. This decides the prior question:
+ * *do* they both match one URL at all? The two questions are independent, and
+ * conflating them is what caused TIM-1308's five-round drift.
+ */
+/**
+ * Check whether two intercepted URL patterns can both match the same concrete
+ * URL. Returns a display string for the overlapping URL, or null.
+ *
+ * Walks both patterns segment by segment:
+ * - Two statics: must be identical.
+ * - Static + dynamic: static must satisfy the dynamic's affix constraints.
+ * - Two dynamics: affix constraints must be compatible.
+ * - A catch-all at either side: compatible with everything remaining.
+ *
+ * If the patterns differ in length, they can only overlap if the longer one's
+ * extra part is an optional catch-all (which also matches zero segments).
+ */
+export declare function interceptedPatternsOverlap(p1: string, p2: string): string | null;
+//# sourceMappingURL=interception-overlap.d.ts.map

package/dist/routing/interception-overlap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interception-overlap.d.ts","sourceRoot":"","sources":["../../src/routing/interception-overlap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAIH;;;;;;;;;;;;GAYG;AACH,wBAAgB,0BAA0B,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAmChF"}