@nifrajs/ts-plugin 2.4.0

package/README.md

@@ -0,0 +1,33 @@
+# @nifrajs/ts-plugin
+
+A TypeScript language-service plugin for [nifra](https://github.com/nifrajs/nifra). It adds go-to-definition on route-path string literals: put your cursor on `"/orders"` in `navigate({ to: "/orders" })`, `<Link to="/orders">`, or `href="/orders"`, and jump straight to the `routes/` file that serves it.
+
+The routing rules are nifra's own - it discovers routes with `@nifrajs/web` and matches them with `@nifrajs/core`'s pattern matcher - so a path resolves to exactly the file it would serve at runtime, dynamic segments included (`/users/42` → `routes/users/[id].tsx`).
+
+## Install
+
+```sh
+npm install -D @nifrajs/ts-plugin
+```
+
+## Enable
+
+Add it to your `tsconfig.json`:
+
+```json
+{
+  "compilerOptions": {
+    "plugins": [{ "name": "@nifrajs/ts-plugin" }]
+  }
+}
+```
+
+In VS Code, run "TypeScript: Select TypeScript Version" from the Command Palette and choose "Use Workspace Version" so the editor loads the plugin from your project.
+
+## For agents
+
+Start with [`LLM.md`](./LLM.md) - this package's contract card (the exports it ships and how it wires in). [`llms-full.txt`](../../llms-full.txt) is the full machine-readable corpus for the whole framework.
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,159 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  findRoutesDir: () => findRoutesDir,
+  findRoutePathLiteral: () => findRoutePathLiteral,
+  default: () => src_default
+});
+module.exports = __toCommonJS(exports_src);
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+var import_fs = require("@nifrajs/web/fs");
+
+// src/resolve.ts
+var import_pattern = require("@nifrajs/core/pattern");
+var compiledRouteCache = new WeakMap;
+function compiledRoutes(routes) {
+  const cached = compiledRouteCache.get(routes);
+  if (cached !== undefined)
+    return cached;
+  const compiled = import_pattern.sortRoutesBySpecificity(routes.map((route) => ({ route, pattern: import_pattern.compileRoutePattern(route.pattern) })));
+  compiledRouteCache.set(routes, compiled);
+  return compiled;
+}
+function resolveRouteFile(path, routes) {
+  if (!path.startsWith("/"))
+    return;
+  const pathname = path.split(/[?#]/, 1)[0] ?? path;
+  for (const { route, pattern } of compiledRoutes(routes)) {
+    if (import_pattern.matchRoutePattern(pattern, pathname).matched)
+      return route.file;
+  }
+  return;
+}
+
+// src/index.ts
+function findRoutesDir(fromFile, exists = import_node_fs.existsSync) {
+  let dir = import_node_path.dirname(fromFile);
+  for (let i = 0;i < 64; i++) {
+    if (exists(import_node_path.join(dir, "routes")))
+      return import_node_path.join(dir, "routes");
+    const parent = import_node_path.dirname(dir);
+    if (parent === dir)
+      return;
+    dir = parent;
+  }
+  return;
+}
+function innermostNodeAt(tsm, source, node, position) {
+  if (position < node.getStart(source) || position > node.getEnd())
+    return;
+  let found = node;
+  node.forEachChild((child) => {
+    const inChild = innermostNodeAt(tsm, source, child, position);
+    if (inChild !== undefined)
+      found = inChild;
+  });
+  return found;
+}
+function findRoutePathLiteral(tsm, source, position) {
+  const node = innermostNodeAt(tsm, source, source, position);
+  if (node === undefined || !tsm.isStringLiteralLike(node))
+    return;
+  if (!node.text.startsWith("/"))
+    return;
+  const start = node.getStart(source) + 1;
+  return { text: node.text, span: { start, length: Math.max(0, node.getWidth(source) - 2) } };
+}
+function routeDefinitionAt(tsm, ls, fileName, position) {
+  const source = ls.getProgram()?.getSourceFile(fileName);
+  if (source === undefined)
+    return;
+  const literal = findRoutePathLiteral(tsm, source, position);
+  if (literal === undefined)
+    return;
+  const routesDir = findRoutesDir(fileName);
+  if (routesDir === undefined)
+    return;
+  let file;
+  try {
+    file = resolveRouteFile(literal.text, import_fs.discoverRoutes(routesDir).routes);
+  } catch {
+    return;
+  }
+  if (file === undefined)
+    return;
+  const target = import_node_path.isAbsolute(file) ? file : import_node_path.join(routesDir, file);
+  if (!import_node_fs.existsSync(target))
+    return;
+  return {
+    definitions: [
+      {
+        fileName: target,
+        textSpan: { start: 0, length: 0 },
+        kind: tsm.ScriptElementKind.moduleElement,
+        name: literal.text,
+        containerName: "",
+        containerKind: tsm.ScriptElementKind.unknown
+      }
+    ],
+    textSpan: literal.span
+  };
+}
+function init(modules) {
+  const tsm = modules.typescript;
+  return {
+    create(info) {
+      const ls = info.languageService;
+      const proxy = Object.create(null);
+      const writable = proxy;
+      for (const key of Object.keys(ls)) {
+        const member = ls[key];
+        writable[key] = typeof member === "function" ? member.bind(ls) : member;
+      }
+      proxy.getDefinitionAndBoundSpan = (fileName, position) => routeDefinitionAt(tsm, ls, fileName, position) ?? ls.getDefinitionAndBoundSpan(fileName, position);
+      return proxy;
+    }
+  };
+}
+var src_default = init;
+
+module.exports = module.exports && module.exports.default ? module.exports.default : module.exports

package/dist/index.d.cts

@@ -0,0 +1,5 @@
+import type * as ts from "typescript";
+
+declare function init(modules: { typescript: typeof ts }): ts.server.PluginModule;
+
+export = init;

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+import type * as ts from "typescript";
+/** Walk up from a source file to the nearest directory that has a `routes/` folder - the app root. */
+export declare function findRoutesDir(fromFile: string, exists?: (p: string) => boolean): string | undefined;
+/**
+ * If `position` sits on a string-literal route path (`"/..."`), return its text and the span INSIDE the
+ * quotes (so the editor highlights the path, not the quotes). Exported for unit testing against a
+ * `SourceFile` built with `ts.createSourceFile`.
+ */
+export declare function findRoutePathLiteral(tsm: typeof ts, source: ts.SourceFile, position: number): {
+    text: string;
+    span: ts.TextSpan;
+} | undefined;
+declare function init(modules: {
+    typescript: typeof ts;
+}): ts.server.PluginModule;
+export default init;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,KAAK,EAAE,MAAM,YAAY,CAAA;AAGrC,sGAAsG;AACtG,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,MAAM,EAChB,MAAM,GAAE,CAAC,CAAC,EAAE,MAAM,KAAK,OAAoB,GAC1C,MAAM,GAAG,SAAS,CASpB;AAkBD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,OAAO,EAAE,EACd,MAAM,EAAE,EAAE,CAAC,UAAU,EACrB,QAAQ,EAAE,MAAM,GACf;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,EAAE,CAAC,QAAQ,CAAA;CAAE,GAAG,SAAS,CAMjD;AAuCD,iBAAS,IAAI,CAAC,OAAO,EAAE;IAAE,UAAU,EAAE,OAAO,EAAE,CAAA;CAAE,GAAG,EAAE,CAAC,MAAM,CAAC,YAAY,CAuBxE;AAED,eAAe,IAAI,CAAA"}

package/dist/resolve.d.ts

@@ -0,0 +1,12 @@
+/** A route as the plugin needs it: its URL pattern and the source file that serves it. */
+export interface RouteLocation {
+    readonly pattern: string;
+    readonly file: string;
+}
+/**
+ * Resolve a route path literal to the first route whose pattern matches it. Query/hash are ignored
+ * (a link's `?tab=x` does not change which route file serves it). Returns the route's `file`, or
+ * undefined when the value is not a path or matches no route.
+ */
+export declare function resolveRouteFile(path: string, routes: readonly RouteLocation[]): string | undefined;
+//# sourceMappingURL=resolve.d.ts.map

package/dist/resolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../src/resolve.ts"],"names":[],"mappings":"AAYA,0FAA0F;AAC1F,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB;AAsBD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,SAAS,aAAa,EAAE,GAC/B,MAAM,GAAG,SAAS,CASpB"}

package/dist/resolve.js

@@ -0,0 +1,37 @@
+/**
+ * The pure half of the plugin: resolve a concrete route path (a string literal the user typed, e.g.
+ * `"/users/42"`) to the `routes/` file that serves it. It matches the path against each route's compiled
+ * pattern using nifra's OWN router matcher (`@nifrajs/core/pattern`), so a path resolves here exactly as
+ * it would at runtime - the plugin never re-derives the file-based routing rules.
+ */
+import { compileRoutePattern, matchRoutePattern, sortRoutesBySpecificity, } from "@nifrajs/core/pattern";
+// The language service asks for definitions repeatedly while the cursor moves. Cache the immutable
+// compilation/specificity sort by manifest identity so each query only performs route matching; a new
+// manifest array naturally gets a fresh entry when routes are added or removed.
+const compiledRouteCache = new WeakMap();
+function compiledRoutes(routes) {
+    const cached = compiledRouteCache.get(routes);
+    if (cached !== undefined)
+        return cached;
+    const compiled = sortRoutesBySpecificity(routes.map((route) => ({ route, pattern: compileRoutePattern(route.pattern) })));
+    compiledRouteCache.set(routes, compiled);
+    return compiled;
+}
+/**
+ * Resolve a route path literal to the first route whose pattern matches it. Query/hash are ignored
+ * (a link's `?tab=x` does not change which route file serves it). Returns the route's `file`, or
+ * undefined when the value is not a path or matches no route.
+ */
+export function resolveRouteFile(path, routes) {
+    if (!path.startsWith("/"))
+        return undefined;
+    const pathname = path.split(/[?#]/, 1)[0] ?? path;
+    // Runtime/client routing sorts by specificity before matching, so a static route wins over a
+    // dynamic one regardless of manifest discovery order.
+    for (const { route, pattern } of compiledRoutes(routes)) {
+        if (matchRoutePattern(pattern, pathname).matched)
+            return route.file;
+    }
+    return undefined;
+}
+//# sourceMappingURL=resolve.js.map

package/dist/resolve.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.js","sourceRoot":"","sources":["../src/resolve.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EACL,mBAAmB,EACnB,iBAAiB,EACjB,uBAAuB,GACxB,MAAM,uBAAuB,CAAA;AAa9B,mGAAmG;AACnG,sGAAsG;AACtG,gFAAgF;AAChF,MAAM,kBAAkB,GAAG,IAAI,OAAO,EAA8D,CAAA;AAEpG,SAAS,cAAc,CAAC,MAAgC;IACtD,MAAM,MAAM,GAAG,kBAAkB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAA;IAC7C,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO,MAAM,CAAA;IACvC,MAAM,QAAQ,GAAG,uBAAuB,CACtC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,mBAAmB,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CAChF,CAAA;IACD,kBAAkB,CAAC,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAA;IACxC,OAAO,QAAQ,CAAA;AACjB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAC9B,IAAY,EACZ,MAAgC;IAEhC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC;QAAE,OAAO,SAAS,CAAA;IAC3C,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,CAAA;IACjD,6FAA6F;IAC7F,sDAAsD;IACtD,KAAK,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,cAAc,CAAC,MAAM,CAAC,EAAE,CAAC;QACxD,IAAI,iBAAiB,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,OAAO;YAAE,OAAO,KAAK,CAAC,IAAI,CAAA;IACrE,CAAC;IACD,OAAO,SAAS,CAAA;AAClB,CAAC"}

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@nifrajs/ts-plugin",
+  "version": "2.4.0",
+  "description": "TypeScript language-service plugin for nifra - go-to-definition from a route-path string literal to the routes/ file that serves it.",
+  "keywords": [
+    "bun",
+    "typescript",
+    "nifra",
+    "web-framework",
+    "full-stack",
+    "tsserver",
+    "language-service",
+    "editor"
+  ],
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "bun": "./src/index.ts",
+      "import": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      },
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.cjs"
+    },
+    "./resolve": {
+      "bun": "./src/resolve.ts",
+      "types": "./dist/resolve.d.ts",
+      "default": "./dist/resolve.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "bun run build.ts"
+  },
+  "dependencies": {
+    "@nifrajs/core": "2.4.0",
+    "@nifrajs/web": "2.4.0"
+  },
+  "peerDependencies": {
+    "typescript": ">=5.5.0"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nifrajs/nifra.git",
+    "directory": "packages/ts-plugin"
+  },
+  "bugs": {
+    "url": "https://github.com/nifrajs/nifra/issues"
+  },
+  "homepage": "https://github.com/nifrajs/nifra#readme"
+}

package/src/index.ts

@@ -0,0 +1,131 @@
+/**
+ * `@nifrajs/ts-plugin` - a TypeScript language-service plugin. It adds ONE thing to the editor:
+ * go-to-definition on a route-path string literal jumps to the `routes/` file that serves it, so
+ * `navigate({ to: "/orders" })`, `<Link to="/orders">`, or `href="/orders"` are click-through.
+ *
+ * Wire it up in a project's tsconfig:
+ * ```json
+ * { "compilerOptions": { "plugins": [{ "name": "@nifrajs/ts-plugin" }] } }
+ * ```
+ *
+ * The routing rules are nifra's own: it discovers routes with `@nifrajs/web`'s `discoverRoutes` and
+ * matches with `@nifrajs/core`'s pattern matcher (see ./resolve.ts), so a path resolves to exactly the
+ * file it would serve at runtime. The plugin only wires that into `getDefinitionAndBoundSpan`.
+ */
+import { existsSync } from "node:fs"
+import { dirname, isAbsolute, join } from "node:path"
+import { discoverRoutes } from "@nifrajs/web/fs"
+import type * as ts from "typescript"
+import { resolveRouteFile } from "./resolve.ts"
+
+/** Walk up from a source file to the nearest directory that has a `routes/` folder - the app root. */
+export function findRoutesDir(
+  fromFile: string,
+  exists: (p: string) => boolean = existsSync,
+): string | undefined {
+  let dir = dirname(fromFile)
+  for (let i = 0; i < 64; i++) {
+    if (exists(join(dir, "routes"))) return join(dir, "routes")
+    const parent = dirname(dir)
+    if (parent === dir) return undefined
+    dir = parent
+  }
+  return undefined
+}
+
+/** The innermost AST node whose span contains `position`. */
+function innermostNodeAt(
+  tsm: typeof ts,
+  source: ts.SourceFile,
+  node: ts.Node,
+  position: number,
+): ts.Node | undefined {
+  if (position < node.getStart(source) || position > node.getEnd()) return undefined
+  let found: ts.Node = node
+  node.forEachChild((child) => {
+    const inChild = innermostNodeAt(tsm, source, child, position)
+    if (inChild !== undefined) found = inChild
+  })
+  return found
+}
+
+/**
+ * If `position` sits on a string-literal route path (`"/..."`), return its text and the span INSIDE the
+ * quotes (so the editor highlights the path, not the quotes). Exported for unit testing against a
+ * `SourceFile` built with `ts.createSourceFile`.
+ */
+export function findRoutePathLiteral(
+  tsm: typeof ts,
+  source: ts.SourceFile,
+  position: number,
+): { text: string; span: ts.TextSpan } | undefined {
+  const node = innermostNodeAt(tsm, source, source, position)
+  if (node === undefined || !tsm.isStringLiteralLike(node)) return undefined
+  if (!node.text.startsWith("/")) return undefined
+  const start = node.getStart(source) + 1 // step past the opening quote
+  return { text: node.text, span: { start, length: Math.max(0, node.getWidth(source) - 2) } }
+}
+
+/** Build the route go-to-definition for the literal at `position`, or undefined to fall through. */
+function routeDefinitionAt(
+  tsm: typeof ts,
+  ls: ts.LanguageService,
+  fileName: string,
+  position: number,
+): ts.DefinitionInfoAndBoundSpan | undefined {
+  const source = ls.getProgram()?.getSourceFile(fileName)
+  if (source === undefined) return undefined
+  const literal = findRoutePathLiteral(tsm, source, position)
+  if (literal === undefined) return undefined
+  const routesDir = findRoutesDir(fileName)
+  if (routesDir === undefined) return undefined
+  let file: string | undefined
+  try {
+    file = resolveRouteFile(literal.text, discoverRoutes(routesDir).routes)
+  } catch {
+    return undefined // a routes/ dir that can't be scanned is not this plugin's error to raise
+  }
+  if (file === undefined) return undefined
+  const target = isAbsolute(file) ? file : join(routesDir, file)
+  if (!existsSync(target)) return undefined
+  return {
+    definitions: [
+      {
+        fileName: target,
+        textSpan: { start: 0, length: 0 },
+        kind: tsm.ScriptElementKind.moduleElement,
+        name: literal.text,
+        containerName: "",
+        containerKind: tsm.ScriptElementKind.unknown,
+      },
+    ],
+    textSpan: literal.span,
+  }
+}
+
+function init(modules: { typescript: typeof ts }): ts.server.PluginModule {
+  const tsm = modules.typescript
+  return {
+    create(info: ts.server.PluginCreateInfo): ts.LanguageService {
+      const ls = info.languageService
+      // Proxy the language service, delegating every method to the real one except the one we augment.
+      // Plain ASSIGNMENT (not Object.defineProperty) so each property stays writable - the override
+      // below reassigns one, which a non-writable property would reject at runtime.
+      const proxy = Object.create(null) as ts.LanguageService
+      const writable = proxy as unknown as Record<string, unknown>
+      for (const key of Object.keys(ls) as Array<keyof ts.LanguageService>) {
+        const member = ls[key]
+        writable[key] =
+          typeof member === "function"
+            ? (member as (...args: unknown[]) => unknown).bind(ls)
+            : member
+      }
+      proxy.getDefinitionAndBoundSpan = (fileName, position) =>
+        routeDefinitionAt(tsm, ls, fileName, position) ??
+        ls.getDefinitionAndBoundSpan(fileName, position)
+      return proxy
+    },
+  }
+}
+
+export default init

package/src/resolve.ts

@@ -0,0 +1,56 @@
+/**
+ * The pure half of the plugin: resolve a concrete route path (a string literal the user typed, e.g.
+ * `"/users/42"`) to the `routes/` file that serves it. It matches the path against each route's compiled
+ * pattern using nifra's OWN router matcher (`@nifrajs/core/pattern`), so a path resolves here exactly as
+ * it would at runtime - the plugin never re-derives the file-based routing rules.
+ */
+import {
+  compileRoutePattern,
+  matchRoutePattern,
+  sortRoutesBySpecificity,
+} from "@nifrajs/core/pattern"
+
+/** A route as the plugin needs it: its URL pattern and the source file that serves it. */
+export interface RouteLocation {
+  readonly pattern: string
+  readonly file: string
+}
+
+type CompiledRouteLocation = {
+  readonly route: RouteLocation
+  readonly pattern: ReturnType<typeof compileRoutePattern>
+}
+
+// The language service asks for definitions repeatedly while the cursor moves. Cache the immutable
+// compilation/specificity sort by manifest identity so each query only performs route matching; a new
+// manifest array naturally gets a fresh entry when routes are added or removed.
+const compiledRouteCache = new WeakMap<readonly RouteLocation[], readonly CompiledRouteLocation[]>()
+
+function compiledRoutes(routes: readonly RouteLocation[]): readonly CompiledRouteLocation[] {
+  const cached = compiledRouteCache.get(routes)
+  if (cached !== undefined) return cached
+  const compiled = sortRoutesBySpecificity(
+    routes.map((route) => ({ route, pattern: compileRoutePattern(route.pattern) })),
+  )
+  compiledRouteCache.set(routes, compiled)
+  return compiled
+}
+
+/**
+ * Resolve a route path literal to the first route whose pattern matches it. Query/hash are ignored
+ * (a link's `?tab=x` does not change which route file serves it). Returns the route's `file`, or
+ * undefined when the value is not a path or matches no route.
+ */
+export function resolveRouteFile(
+  path: string,
+  routes: readonly RouteLocation[],
+): string | undefined {
+  if (!path.startsWith("/")) return undefined
+  const pathname = path.split(/[?#]/, 1)[0] ?? path
+  // Runtime/client routing sorts by specificity before matching, so a static route wins over a
+  // dynamic one regardless of manifest discovery order.
+  for (const { route, pattern } of compiledRoutes(routes)) {
+    if (matchRoutePattern(pattern, pathname).matched) return route.file
+  }
+  return undefined
+}