@facilis.dev/analyze 0.0.0-stage → 0.1.1

package/dist/passes/job-relations.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Job `run(ctx)` -> relation usage (D-157 applied to jobs). A job's `db` is the
+ * system-scoped client, so its usage has no elevation bucket: it is the route walk with the
+ * `{ db }` seed on the first parameter and elevations disabled. The walk and the name
+ * resolution are the route ones (`route-relations-walk.ts` / `route-relation-resolve.ts`),
+ * so the two passes cannot drift.
+ */
+import type { ModuleGraph } from "../module-graph.js";
+import type { Diagnostic, TableFact, ViewFact } from "../types.js";
+import type { JobFact, JobRelationsFact } from "../types-jobs.js";
+export interface JobRelationsScan {
+    readonly jobs: readonly JobFact[];
+    /** Usage per job, keyed by the job name (unique across the project). */
+    readonly relations: Readonly<Record<string, JobRelationsFact>>;
+    readonly diagnostics: readonly Diagnostic[];
+}
+/** Attach relation-usage facts to every scannable job and derive the D-157 diagnostics. */
+export declare function buildJobRelationFacts(graph: ModuleGraph, jobs: readonly JobFact[], tables: readonly TableFact[], views: readonly ViewFact[]): JobRelationsScan;

package/dist/passes/job-relations.js

@@ -0,0 +1,52 @@
+/**
+ * Job `run(ctx)` -> relation usage (D-157 applied to jobs). A job's `db` is the
+ * system-scoped client, so its usage has no elevation bucket: it is the route walk with the
+ * `{ db }` seed on the first parameter and elevations disabled. The walk and the name
+ * resolution are the route ones (`route-relations-walk.ts` / `route-relation-resolve.ts`),
+ * so the two passes cannot drift.
+ */
+import { callArguments, unwrapExpression } from "../ast/node.js";
+import { EMPTY_JOB_RELATIONS } from "../types-jobs.js";
+import { createRelationIndex } from "./route-relation-resolve.js";
+import { scanFunctionUsage } from "./route-relations-walk.js";
+import { jobRelationDiagnostics } from "./job-relations-diagnostics.js";
+import { resolveJobCall } from "./jobs.js";
+import { readStaticObject, sortDiagnostics } from "./static-read.js";
+/** A job runs as `facilis_system`: `run`'s first parameter is the context, no elevations. */
+const JOB_SEED = { contextParam: 0, elevations: false };
+/** The function expression of the definition's `run` property, when inspectable. */
+function runFunction(graph, file, call) {
+    const object = readStaticObject(callArguments(call)[0], { graph, file: file.path }, { code: "job-definition-static", report: false });
+    const value = unwrapExpression(object.fields.get("run")?.node);
+    return value?.type === "ArrowFunctionExpression" || value?.type === "FunctionExpression"
+        ? value
+        : undefined;
+}
+function toJobRelations(usage) {
+    return {
+        used: usage.used,
+        unresolved: usage.unresolved,
+        rawSql: usage.rawSql,
+        opaque: usage.opaque,
+    };
+}
+/** Attach relation-usage facts to every scannable job and derive the D-157 diagnostics. */
+export function buildJobRelationFacts(graph, jobs, tables, views) {
+    const index = createRelationIndex(tables, views);
+    const relations = {};
+    const diagnostics = [];
+    for (const job of jobs) {
+        const file = graph.file(job.sourceFile);
+        const call = file === undefined ? null : resolveJobCall(file);
+        const run = file !== undefined && call !== null ? runFunction(graph, file, call) : undefined;
+        if (file === undefined || run === undefined) {
+            // The definition warning is the finding; an empty usage avoids a false unused warning.
+            relations[job.name] = EMPTY_JOB_RELATIONS;
+            continue;
+        }
+        const usage = toJobRelations(scanFunctionUsage(graph, file, run, index, JOB_SEED));
+        relations[job.name] = usage;
+        diagnostics.push(...jobRelationDiagnostics(job, usage));
+    }
+    return { jobs, relations, diagnostics: sortDiagnostics(diagnostics) };
+}

package/dist/passes/jobs.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `server/jobs/**` definitions -> JobFacts (D-157 applied to jobs).
+ *
+ * One default export per file: a `defineJob()` call from `@facilis.dev/core`. A file that is not
+ * a valid definition is a warning, not an error: jobs are optional, so a broken file must not
+ * hide the rest of the project. `dbTables` is the declaration the runtime guard enforces, so
+ * an unreadable one is explicit (null) and its warning keeps the jobs gate red.
+ */
+import { type AstNode } from "../ast/node.js";
+import type { ModuleGraph, ProjectFile } from "../module-graph.js";
+import type { Diagnostic } from "../types.js";
+import type { JobFact } from "../types-jobs.js";
+export interface JobResult {
+    readonly jobs: readonly JobFact[];
+    readonly diagnostics: readonly Diagnostic[];
+}
+/** The `defineJob(...)` call of a valid definition, for later passes (D-157). */
+export declare function resolveJobCall(file: ProjectFile): AstNode | null;
+/** Read every job module under `server/jobs/` into facts (test files are skipped). */
+export declare function buildJobFacts(graph: ModuleGraph): JobResult;

package/dist/passes/jobs.js

@@ -0,0 +1,133 @@
+/**
+ * `server/jobs/**` definitions -> JobFacts (D-157 applied to jobs).
+ *
+ * One default export per file: a `defineJob()` call from `@facilis.dev/core`. A file that is not
+ * a valid definition is a warning, not an error: jobs are optional, so a broken file must not
+ * hide the rest of the project. `dbTables` is the declaration the runtime guard enforces, so
+ * an unreadable one is explicit (null) and its warning keeps the jobs gate red.
+ */
+import { callArguments, identifierName, unwrapExpression } from "../ast/node.js";
+import { warning } from "../diagnostics.js";
+import { defaultExportExpression, isLocallyDeclared, readStaticObject, refOf, relativePath, sortDiagnostics, } from "./static-read.js";
+const CORE_SPECIFIER = "@facilis.dev/core";
+const JOBS_DIR = "server/jobs/";
+const STATIC_CODE = "job-definition-static";
+/** The default export must be a `defineJob(...)` call of the core import. */
+function resolveDefinition(file) {
+    const expression = defaultExportExpression(file);
+    if (expression === undefined) {
+        return { call: null, reason: "the job file has no default export" };
+    }
+    if (expression.type !== "CallExpression") {
+        return { call: null, reason: "the default export is not a defineJob() call" };
+    }
+    const callee = unwrapExpression(expression.callee);
+    const name = callee?.type === "Identifier" ? identifierName(callee) : undefined;
+    if (name === undefined)
+        return { call: null, reason: "the defineJob callee cannot be resolved" };
+    if (isLocallyDeclared(file, name)) {
+        return { call: null, reason: '"' + name + '" is shadowed by a local declaration' };
+    }
+    const imported = file.module.imports.find((entry) => entry.local === name);
+    if (imported === undefined ||
+        imported.specifier !== CORE_SPECIFIER ||
+        imported.imported !== "defineJob") {
+        return {
+            call: null,
+            reason: "the default export is not the defineJob import from @facilis.dev/core",
+        };
+    }
+    return { call: expression, reason: "" };
+}
+/** The `defineJob(...)` call of a valid definition, for later passes (D-157). */
+export function resolveJobCall(file) {
+    return resolveDefinition(file).call;
+}
+function stringArray(value) {
+    if (!Array.isArray(value))
+        return null;
+    return value.every((entry) => typeof entry === "string") ? [...value] : null;
+}
+function scanFile(graph, file) {
+    const context = { graph, file: file.path };
+    const definition = resolveDefinition(file);
+    const ref = refOf(context, definition.call ?? defaultExportExpression(file));
+    if (definition.call === null) {
+        return { job: null, diagnostics: [warning("job-definition", definition.reason, ref)] };
+    }
+    const object = readStaticObject(callArguments(definition.call)[0], context, {
+        code: STATIC_CODE,
+        report: false,
+    });
+    // A structural read failure (spread/computed key) makes the whole definition suspect: keep
+    // it visible as an unknown and as a warning, as the route config reader does.
+    const unknown = [...object.unknown];
+    const diagnostics = object.unknown.map((item) => warning(item.code, item.reason, item.source));
+    const note = (reason, at) => {
+        const source = refOf(context, at);
+        unknown.push({ code: STATIC_CODE, reason, source });
+        diagnostics.push(warning(STATIC_CODE, reason, source));
+    };
+    const nameField = object.fields.get("name");
+    let name = null;
+    if (nameField !== undefined &&
+        nameField.ok &&
+        typeof nameField.value === "string" &&
+        nameField.value.length > 0) {
+        name = nameField.value;
+    }
+    if (name === null) {
+        diagnostics.push(warning("job-definition", "the job name cannot be read statically", refOf(context, nameField?.node)));
+        return { job: null, diagnostics };
+    }
+    const tablesField = object.fields.get("dbTables");
+    let dbTables = null;
+    if (tablesField === undefined) {
+        note("dbTables is missing; declare the relations the job touches ([] means none)", undefined);
+    }
+    else if (!tablesField.ok) {
+        note("dbTables cannot be read statically: " + (tablesField.reason ?? "unsupported"), tablesField.node);
+    }
+    else {
+        dbTables = stringArray(tablesField.value);
+        if (dbTables === null)
+            note("dbTables must be a string[]", tablesField.node);
+    }
+    const rawSqlField = object.fields.get("rawSql");
+    let rawSql = false;
+    if (rawSqlField !== undefined && !rawSqlField.ok) {
+        rawSql = null;
+        note("rawSql cannot be read statically: " + (rawSqlField.reason ?? "unsupported"), rawSqlField.node);
+    }
+    else if (rawSqlField !== undefined) {
+        if (typeof rawSqlField.value === "boolean")
+            rawSql = rawSqlField.value;
+        else {
+            // An unreadable derogation is never assumed: db.execute then fails closed (D-157).
+            rawSql = null;
+            note("rawSql must be a boolean", rawSqlField.node);
+        }
+    }
+    return {
+        job: { name, sourceFile: file.path, source: ref, dbTables, rawSql, unknown },
+        diagnostics,
+    };
+}
+/** Read every job module under `server/jobs/` into facts (test files are skipped). */
+export function buildJobFacts(graph) {
+    const files = [...graph.files.values()]
+        .filter((file) => {
+        const relative = relativePath(graph.root, file.path);
+        return relative.startsWith(JOBS_DIR) && !relative.endsWith(".test.ts");
+    })
+        .toSorted((left, right) => left.path.localeCompare(right.path));
+    const jobs = [];
+    const diagnostics = [];
+    for (const file of files) {
+        const scanned = scanFile(graph, file);
+        if (scanned.job !== null)
+            jobs.push(scanned.job);
+        diagnostics.push(...scanned.diagnostics);
+    }
+    return { jobs, diagnostics: sortDiagnostics(diagnostics) };
+}

package/dist/passes/jsx-text.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Direct text/i18n facts for one page-preview node.
+ *
+ * The preview is schematic, not a render: reading only an element's own JSX children keeps a
+ * section's label without pulling in what nested elements render. A `t("key")` child becomes
+ * `tKey` (D-043) and literal text stays alongside it as the UI's fallback, because the UI
+ * prefers the translated key. Dynamic expressions are skipped rather than guessed. Content
+ * intrinsics (<input>, <img>, ...) carry their copy in an attribute instead of a child, so
+ * `jsxContentFields` falls back to that attribute.
+ */
+import { type AstNode } from "../ast/node.js";
+/** The optional `PagePreviewNode` text fields; a field is omitted, never empty. */
+export interface JsxTextFields {
+    readonly text?: string;
+    readonly tKey?: string;
+}
+/**
+ * The first direct non-empty text child and the first direct `t("key")` child of an element.
+ * Both are kept when the element renders one of each: the UI shows `tKey`, falling back to
+ * `text`. Returns undefined when the element has neither, so callers emit no empty field.
+ */
+export declare function jsxTextFields(node: AstNode): JsxTextFields | undefined;
+/**
+ * The copy a content intrinsic renders: its direct JSX text first (where `t("key")` becomes
+ * `tKey`), then the first static placeholder/alt/aria-label attribute it carries. A dynamic
+ * attribute never becomes copy, but does not hide a later static fallback either.
+ */
+export declare function jsxContentFields(node: AstNode, name: string): JsxTextFields | undefined;

package/dist/passes/jsx-text.js

@@ -0,0 +1,121 @@
+/**
+ * Direct text/i18n facts for one page-preview node.
+ *
+ * The preview is schematic, not a render: reading only an element's own JSX children keeps a
+ * section's label without pulling in what nested elements render. A `t("key")` child becomes
+ * `tKey` (D-043) and literal text stays alongside it as the UI's fallback, because the UI
+ * prefers the translated key. Dynamic expressions are skipped rather than guessed. Content
+ * intrinsics (<input>, <img>, ...) carry their copy in an attribute instead of a child, so
+ * `jsxContentFields` falls back to that attribute.
+ */
+import { asNode, memberName, nodeArray, unwrapExpression } from "../ast/node.js";
+import { jsxAttribute, jsxAttributeValue, jsxChildren } from "./jsx.js";
+/** JSX collapses source indentation into spaces; mirror it so labels carry no layout trivia. */
+function collapseJsxText(value) {
+    const collapsed = value.replace(/\s+/g, " ").trim();
+    return collapsed === "" ? undefined : collapsed;
+}
+/** A string literal value, or undefined for any other expression. */
+function literalText(node) {
+    // oxc emits ESTree `Literal`; `StringLiteral` is accepted for parser independence.
+    if (node.type !== "Literal" && node.type !== "StringLiteral")
+        return undefined;
+    return typeof node.value === "string" ? node.value : undefined;
+}
+/** A template literal without substitutions keeps its static text. */
+function templateText(node) {
+    if (nodeArray(node, "expressions").length > 0)
+        return undefined;
+    const quasi = nodeArray(node, "quasis")[0];
+    const value = quasi?.value;
+    if (typeof value !== "object" || value === null)
+        return undefined;
+    const cooked = value.cooked;
+    if (typeof cooked === "string")
+        return cooked;
+    const raw = value.raw;
+    return typeof raw === "string" ? raw : undefined;
+}
+/** A direct text child: JSX text, or a static string/template expression. */
+function textChild(child) {
+    if (child.type === "JSXText") {
+        return typeof child.value === "string" ? collapseJsxText(child.value) : undefined;
+    }
+    if (child.type !== "JSXExpressionContainer")
+        return undefined;
+    const expression = unwrapExpression(child.expression);
+    if (expression === undefined)
+        return undefined;
+    const value = expression.type === "TemplateLiteral" ? templateText(expression) : literalText(expression);
+    // A literal was authored as written, so only surrounding whitespace is dropped here.
+    const trimmed = value?.trim();
+    return trimmed === undefined || trimmed === "" ? undefined : trimmed;
+}
+/** A `t("key")` / `i18n.t("key")` child; the callee may be a member, the key may not be dynamic. */
+function translationChild(child) {
+    if (child.type !== "JSXExpressionContainer")
+        return undefined;
+    const call = unwrapExpression(child.expression);
+    if (call === undefined || call.type !== "CallExpression")
+        return undefined;
+    const callee = asNode(call.callee);
+    if (callee === undefined)
+        return undefined;
+    const calleeName = callee.type === "Identifier" ? callee.name : memberName(callee);
+    if (calleeName !== "t")
+        return undefined;
+    const argument = nodeArray(call, "arguments")[0];
+    const key = argument === undefined ? undefined : literalText(argument);
+    return key === undefined || key.trim() === "" ? undefined : key;
+}
+/**
+ * The first direct non-empty text child and the first direct `t("key")` child of an element.
+ * Both are kept when the element renders one of each: the UI shows `tKey`, falling back to
+ * `text`. Returns undefined when the element has neither, so callers emit no empty field.
+ */
+export function jsxTextFields(node) {
+    let text;
+    let tKey;
+    for (const child of jsxChildren(node)) {
+        text ??= textChild(child);
+        tKey ??= translationChild(child);
+    }
+    if (text === undefined && tKey === undefined)
+        return undefined;
+    return { ...(text === undefined ? {} : { text }), ...(tKey === undefined ? {} : { tKey }) };
+}
+/** The attributes that stand in for missing JSX copy, in reading order per intrinsic. */
+const COPY_ATTRIBUTES = {
+    input: ["placeholder", "aria-label", "value"],
+    textarea: ["placeholder", "aria-label"],
+    select: ["aria-label"],
+    button: ["aria-label"],
+    a: ["aria-label"],
+    img: ["alt"],
+};
+const DEFAULT_COPY_ATTRIBUTES = ["aria-label"];
+/** An attribute value as static text: a string literal or a substitution-free template. */
+function attributeText(attribute) {
+    const expression = jsxAttributeValue(attribute);
+    if (expression === undefined)
+        return undefined;
+    const value = expression.type === "TemplateLiteral" ? templateText(expression) : literalText(expression);
+    const trimmed = value?.trim();
+    return trimmed === undefined || trimmed === "" ? undefined : trimmed;
+}
+/**
+ * The copy a content intrinsic renders: its direct JSX text first (where `t("key")` becomes
+ * `tKey`), then the first static placeholder/alt/aria-label attribute it carries. A dynamic
+ * attribute never becomes copy, but does not hide a later static fallback either.
+ */
+export function jsxContentFields(node, name) {
+    const fields = jsxTextFields(node);
+    if (fields !== undefined)
+        return fields;
+    for (const attributeName of COPY_ATTRIBUTES[name] ?? DEFAULT_COPY_ATTRIBUTES) {
+        const text = attributeText(jsxAttribute(node, attributeName));
+        if (text !== undefined)
+            return { text };
+    }
+    return undefined;
+}

package/dist/passes/jsx.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Small ESTree/JSX helpers shared by the route-table and page-preview passes.
+ *
+ * The analyzer's parser contract is parser-independent ESTree, so these helpers only read
+ * structural keys (`openingElement.name`, `attributes`, `children`, `expression`); they never
+ * execute project code and never depend on oxc-specific node types.
+ */
+import { type AstNode } from "../ast/node.js";
+/** `JSXIdentifier` / `JSXMemberExpression` / `JSXNamespacedName` -> display name. */
+export declare function jsxName(node: AstNode | undefined): string | null;
+export declare function openingElement(node: AstNode): AstNode | undefined;
+export declare function elementName(node: AstNode): string | null;
+export declare function jsxChildren(node: AstNode): AstNode[];
+export declare function jsxAttributes(node: AstNode): AstNode[];
+/** The first attribute with this name, or undefined. */
+export declare function jsxAttribute(node: AstNode, name: string): AstNode | undefined;
+/** The value expression of an attribute, unwrapped from `JSXExpressionContainer`. */
+export declare function jsxAttributeValue(attribute: AstNode | undefined): AstNode | undefined;
+/** A JSX element/fragment value, when the expression is one. */
+export declare function jsxElementValue(value: AstNode | undefined): AstNode | undefined;
+export declare function isJsxElement(node: AstNode | undefined): node is AstNode;
+export declare function isSectionIntrinsic(name: string): boolean;
+export declare function isContentIntrinsic(name: string): boolean;
+export declare function isRoleIntrinsic(name: string): boolean;

package/dist/passes/jsx.js

@@ -0,0 +1,135 @@
+/**
+ * Small ESTree/JSX helpers shared by the route-table and page-preview passes.
+ *
+ * The analyzer's parser contract is parser-independent ESTree, so these helpers only read
+ * structural keys (`openingElement.name`, `attributes`, `children`, `expression`); they never
+ * execute project code and never depend on oxc-specific node types.
+ */
+import { asNode, nodeArray } from "../ast/node.js";
+/** `JSXIdentifier` / `JSXMemberExpression` / `JSXNamespacedName` -> display name. */
+export function jsxName(node) {
+    if (node === undefined)
+        return null;
+    if (node.type === "JSXIdentifier")
+        return typeof node.name === "string" ? node.name : null;
+    if (node.type === "JSXMemberExpression") {
+        const object = jsxName(asNode(node.object));
+        const property = jsxName(asNode(node.property));
+        return object === null || property === null ? null : object + "." + property;
+    }
+    if (node.type === "JSXNamespacedName") {
+        const namespace = jsxName(asNode(node.namespace));
+        const name = jsxName(asNode(node.name));
+        return namespace === null || name === null ? null : namespace + ":" + name;
+    }
+    return null;
+}
+export function openingElement(node) {
+    return node.type === "JSXElement" ? asNode(node.openingElement) : undefined;
+}
+export function elementName(node) {
+    return jsxName(asNode(openingElement(node)?.name));
+}
+export function jsxChildren(node) {
+    return nodeArray(node, "children");
+}
+export function jsxAttributes(node) {
+    const opening = openingElement(node);
+    return opening === undefined ? [] : nodeArray(opening, "attributes");
+}
+/** The first attribute with this name, or undefined. */
+export function jsxAttribute(node, name) {
+    for (const attribute of jsxAttributes(node)) {
+        if (attribute.type !== "JSXAttribute")
+            continue;
+        if (jsxName(asNode(attribute.name)) === name)
+            return attribute;
+    }
+    return undefined;
+}
+/** The value expression of an attribute, unwrapped from `JSXExpressionContainer`. */
+export function jsxAttributeValue(attribute) {
+    if (attribute === undefined)
+        return undefined;
+    const value = asNode(attribute.value);
+    if (value === undefined)
+        return undefined;
+    if (value.type === "JSXExpressionContainer")
+        return asNode(value.expression);
+    return value;
+}
+/** A JSX element/fragment value, when the expression is one. */
+export function jsxElementValue(value) {
+    if (value === undefined)
+        return undefined;
+    if (value.type === "JSXElement" || value.type === "JSXFragment")
+        return value;
+    return undefined;
+}
+export function isJsxElement(node) {
+    return node !== undefined && (node.type === "JSXElement" || node.type === "JSXFragment");
+}
+/** JSX elements that carry a page section (layout-only `<div>` stays flattened away). */
+const SECTION_INTRINSICS = new Set([
+    "header",
+    "main",
+    "section",
+    "nav",
+    "aside",
+    "footer",
+    "form",
+    "table",
+    "ul",
+    "h1",
+    "h2",
+    "h3",
+]);
+/**
+ * Text-bearing intrinsics: they get a preview node when they carry copy, so the copy is not
+ * lost inside a flattened layout wrapper.
+ */
+const CONTENT_INTRINSICS = new Set([
+    "p",
+    "span",
+    "strong",
+    "em",
+    "small",
+    "b",
+    "i",
+    "code",
+    "pre",
+    "blockquote",
+    "button",
+    "a",
+    "input",
+    "select",
+    "textarea",
+    "label",
+    "img",
+    "video",
+    "audio",
+    "h4",
+    "h5",
+    "h6",
+]);
+/** Content intrinsics with a control role: drawn even without readable copy (a bare input, media). */
+const ROLE_INTRINSICS = new Set([
+    "button",
+    "a",
+    "input",
+    "select",
+    "textarea",
+    "label",
+    "img",
+    "video",
+    "audio",
+]);
+export function isSectionIntrinsic(name) {
+    return SECTION_INTRINSICS.has(name);
+}
+export function isContentIntrinsic(name) {
+    return CONTENT_INTRINSICS.has(name);
+}
+export function isRoleIntrinsic(name) {
+    return ROLE_INTRINSICS.has(name);
+}

package/dist/passes/path-expression.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Client path expressions -> static prefixes and route matches (§3.4 of the AST DSL
+ * contract).
+ *
+ * A path is read as a static prefix plus a dynamic tail: literal strings and const strings
+ * are exact, while concatenations and templates keep the leading static segments. One hop of
+ * a path-builder function is inlined (the builder's return expression); anything deeper is
+ * dynamic, not guessed.
+ */
+import { type AstNode } from "../ast/node.js";
+import { type StaticContext } from "../static-eval.js";
+import type { HttpMethod, PathKind, RouteFact, UnknownFact } from "../types.js";
+export interface ExtractedPath {
+    readonly kind: PathKind;
+    /** Source text of the argument, for the inspector. */
+    readonly expression: string;
+    /** Leading static text; null when the path has no readable static part. */
+    readonly staticPrefix: string | null;
+    /** Fully static path, when the whole expression is known. */
+    readonly path: string | null;
+    readonly unknown: readonly UnknownFact[];
+}
+/** Extract the path of one client call; failures stay in the unknown channel. */
+export declare function extractPathExpression(argument: AstNode | undefined, context: StaticContext, call: AstNode, code: string): ExtractedPath;
+/** Route ids whose template can produce the call path for the given method. */
+export declare function matchRouteIds(routes: readonly RouteFact[], path: string | null, staticPrefix: string | null, method: HttpMethod): string[];