@descryy/adapter-go 0.1.0

package/dist/routes.js

@@ -0,0 +1,661 @@
+/**
+ * `API_ROUTE` from Go source — DEC-117.
+ *
+ *     API_ROUTE ──SERVES_API──▶ API_ENDPOINT ◀──USES_API── caller
+ *
+ * ## The receiver is the evidence, never the method name
+ *
+ * A verb-shaped call is not a route. `r.Get(...)` is written by cache clients,
+ * config readers, sync maps and test helpers, and admitting on the name is how
+ * the Python client extractor would have minted **2,280 wrong edges** (DEC-132).
+ * So the receiver must trace to a routing package, by one of three routes and no
+ * others:
+ *
+ * | shape | evidence |
+ * | --- | --- |
+ * | `http.HandleFunc("GET /orders/{id}", h)` | the base is a **package alias** the file's import table resolves to a routing import path |
+ * | `mux := http.NewServeMux()` … `mux.HandleFunc(…)` | the **construction** is the evidence — assigned from a constructor in a routing package, in the same function |
+ * | `v1 := r.Group("/v1")` … `v1.GET(…)` | the **grouping call** is the evidence — `r` was itself already evidence, and `Group` is one of that framework's own group-binding methods |
+ * | `r.Methods("GET").Path("/orders").HandlerFunc(h)` | the **fluent chain bottoms out at an identifier** that is itself evidence — gorilla/mux's own shape, unwound one call at a time |
+ *
+ * A local *called* `router` is not evidence, and neither is a parameter typed as
+ * one: binding on the type would admit any function that merely accepts a
+ * router, and this adapter has no checker to confirm the type resolves to the
+ * package it appears to name. The one deliberate exception is the framework's
+ * own group-*callback* parameter (`r.Route("/v1", func(r chi.Router) { … })`):
+ * that parameter's type is corroborated by the call site that introduced it —
+ * the reader already confirmed `r`'s own outer binding before ever looking at
+ * the callback — so it is not the same hazard as trusting an arbitrary
+ * function's parameter in isolation.
+ *
+ * ## A pattern with no verb is refused, not defaulted
+ *
+ * `mux.HandleFunc("/orders/{id}", h)` matches **every** method. Emitting it as a
+ * `GET` invents a fact, and that is DEC-114 exactly — a verb the reader never
+ * established became `GET` and manufactured a join reported as a confirmed
+ * contract match that did not exist. Emitting one route per verb would be worse:
+ * five routes nothing declared. gorilla/mux's own version of the same rule: a
+ * chain with no `.Methods(...)` anywhere in it is refused the same way, and a
+ * chain whose `.Methods(...)` names several verbs mints one route per verb —
+ * that is not a guess, it is the registration's own stated cardinality.
+ *
+ * ## gorilla/mux: a chain, not a two-argument call
+ *
+ * `r.Methods(http.MethodPost).Path("/orders").HandlerFunc(h)` nests one
+ * `call_expression` inside another, one per fluent step, in any order the
+ * caller wrote them. `unwindChain` walks from the outermost call down through
+ * each `selector_expression` until it reaches the identifier the whole chain
+ * is rooted on — the same identifier this file already requires evidence for
+ * everywhere else. Only the outermost call of a chain is processed (guarded by
+ * `isChainHead`); every inner link is visited too, as the walk continues into
+ * ordinary children, but is recognised as mid-chain and skipped rather than
+ * misread as a call of its own. `.PathPrefix(p).Subrouter()` — gorilla's own
+ * grouping idiom — is the two-step case: the whole chain becomes a new router
+ * local when assigned, the same way `.Group(p)` does for gin and echo, just
+ * one call longer.
+ *
+ * `RegisterXServer(grpcServer, impl)` — gRPC's service registration — is a
+ * categorically different shape: no HTTP verb, no path template written at
+ * the call site, evidence split across two files instead of local to one.
+ * Read separately, in `grpc.ts`, not by this file.
+ */
+import { baseTypeName } from "./parse.js";
+const FRAMEWORKS = new Map([
+    ["net/http", { constructors: new Set(["NewServeMux"]), groupAssignMethods: new Set(), groupCallbackMethods: new Set() }],
+    [
+        "github.com/gin-gonic/gin",
+        { constructors: new Set(["Default", "New"]), groupAssignMethods: new Set(["Group"]), groupCallbackMethods: new Set() },
+    ],
+    [
+        "github.com/go-chi/chi",
+        {
+            constructors: new Set(["NewRouter"]),
+            groupAssignMethods: new Set(),
+            groupCallbackMethods: new Set(["Route", "Group"]),
+            callbackParamType: "Router",
+        },
+    ],
+    [
+        "github.com/go-chi/chi/v5",
+        {
+            constructors: new Set(["NewRouter"]),
+            groupAssignMethods: new Set(),
+            groupCallbackMethods: new Set(["Route", "Group"]),
+            callbackParamType: "Router",
+        },
+    ],
+    [
+        "github.com/labstack/echo",
+        { constructors: new Set(["New"]), groupAssignMethods: new Set(["Group"]), groupCallbackMethods: new Set() },
+    ],
+    [
+        "github.com/labstack/echo/v4",
+        { constructors: new Set(["New"]), groupAssignMethods: new Set(["Group"]), groupCallbackMethods: new Set() },
+    ],
+    [
+        "github.com/gorilla/mux",
+        // `.PathPrefix(p).Subrouter()` is a two-step chain, not a single group-assign
+        // call — handled specially in `bindingFromChain`, not through either set here.
+        { constructors: new Set(["NewRouter"]), groupAssignMethods: new Set(), groupCallbackMethods: new Set() },
+    ],
+]);
+const GORILLA_MUX = "github.com/gorilla/mux";
+const ROUTING_PACKAGES = new Set(FRAMEWORKS.keys());
+/** `net/http`'s own named verb constants, as gorilla/mux's `.Methods(...)` most often receives them. */
+const HTTP_METHOD_CONSTANTS = new Map([
+    ["MethodGet", "GET"],
+    ["MethodHead", "HEAD"],
+    ["MethodPost", "POST"],
+    ["MethodPut", "PUT"],
+    ["MethodPatch", "PATCH"],
+    ["MethodDelete", "DELETE"],
+    ["MethodConnect", "CONNECT"],
+    ["MethodOptions", "OPTIONS"],
+    ["MethodTrace", "TRACE"],
+]);
+/**
+ * Registration methods that take the verb from the pattern string rather than
+ * from their own name. `net/http`'s two.
+ */
+const PATTERN_METHODS = new Set(["HandleFunc", "Handle"]);
+/** Registration methods whose *name* is the verb. */
+const VERB_METHODS = new Map(["Get", "Post", "Put", "Patch", "Delete", "Head", "Options"].flatMap((verb) => [
+    [verb, verb.toUpperCase()],
+    [verb.toUpperCase(), verb.toUpperCase()],
+]));
+/** The text of a string literal, or `undefined` for anything assembled elsewhere. */
+export function literalOf(node) {
+    if (node === null)
+        return undefined;
+    if (node.type !== "interpreted_string_literal" && node.type !== "raw_string_literal")
+        return undefined;
+    const text = node.text;
+    // A raw literal cannot contain an escape, and an interpreted one that does is
+    // not a path this reader should be splitting.
+    if (text.includes("\\"))
+        return undefined;
+    return text.replace(/^["`]|["`]$/g, "");
+}
+/**
+ * Walks a `call_expression` down through nested `X.M1(…).M2(…)…Mn(…)` links
+ * until it reaches the identifier the whole chain is rooted on.
+ *
+ * `undefined` for anything that is not a plain method-call chain on a name —
+ * an index expression, a parenthesised expression, a call whose callee is not
+ * a selector at all. Those are not evidence this file can read either way.
+ */
+function unwindChain(call) {
+    const steps = [];
+    let current = call;
+    for (;;) {
+        const callee = current.childForFieldName("function");
+        if (callee === null || callee.type !== "selector_expression")
+            return undefined;
+        const base = callee.childForFieldName("operand");
+        const member = callee.childForFieldName("field");
+        if (base === null || member === null)
+            return undefined;
+        steps.unshift({ member: member.text, call: current });
+        if (base.type === "identifier")
+            return { root: base, steps };
+        if (base.type === "call_expression") {
+            current = base;
+            continue;
+        }
+        return undefined;
+    }
+}
+/**
+ * Is `call` the outermost link of its own chain?
+ *
+ * A chain is walked once, from its outermost call — every inner link is still
+ * visited by the generic tree walk (it is a real `call_expression`, wholly
+ * unaware it sits inside a bigger one), and without this guard each inner link
+ * would be re-processed as if it were its own, shorter chain.
+ */
+function isChainHead(call) {
+    const parent = call.parent;
+    if (parent === null || parent.type !== "selector_expression")
+        return true;
+    const operand = parent.childForFieldName("operand");
+    if (operand === null || !operand.equals(call))
+        return true;
+    const grandparent = parent.parent;
+    if (grandparent === null || grandparent.type !== "call_expression")
+        return true;
+    const fn = grandparent.childForFieldName("function");
+    return fn === null || !fn.equals(parent);
+}
+/** A string literal, or a `net/http` named verb constant (`http.MethodPost`), upper-cased. */
+function verbTextOf(node, unit) {
+    const literal = literalOf(node);
+    if (literal !== undefined)
+        return literal.toUpperCase();
+    if (node === null || node.type !== "selector_expression")
+        return undefined;
+    const base = node.childForFieldName("operand");
+    const field = node.childForFieldName("field");
+    if (base === null || base.type !== "identifier" || field === null)
+        return undefined;
+    if (unit.imports.get(base.text) !== "net/http")
+        return undefined;
+    return HTTP_METHOD_CONSTANTS.get(field.text);
+}
+/** `{id:[0-9]+}` -> `{id}` — gorilla/mux's own regex-constrained path-variable syntax. */
+function stripGorillaConstraints(path) {
+    return path.replace(/\{([^:}]+):[^}]*\}/g, "{$1}");
+}
+/**
+ * What an unwound assignment-RHS chain binds, if anything: a package
+ * constructor, a single-call group-assign (gin/echo's `.Group(prefix)`), or
+ * gorilla/mux's own two-call `.PathPrefix(prefix).Subrouter()`.
+ *
+ * `found` is the router-local map built so far in this same top-down pass —
+ * Go's declare-before-use rule is what makes a lookup into it, mid-scan,
+ * sound rather than order-dependent luck.
+ */
+function bindingFromChain(unwound, unit, found, refusals) {
+    const { root, steps } = unwound;
+    if (root.type !== "identifier")
+        return undefined;
+    if (steps.length === 1) {
+        const step = steps[0];
+        const path = unit.imports.get(root.text);
+        const pkgSpec = path === undefined ? undefined : FRAMEWORKS.get(path);
+        if (pkgSpec !== undefined && pkgSpec.constructors.has(step.member)) {
+            return { importPath: path, prefix: "" };
+        }
+        const baseLocal = found.get(root.text);
+        const spec = baseLocal === undefined ? undefined : FRAMEWORKS.get(baseLocal.importPath);
+        if (baseLocal === undefined || spec === undefined || !spec.groupAssignMethods.has(step.member))
+            return undefined;
+        const arg = step.call.childForFieldName("arguments")?.namedChild(0) ?? null;
+        const literal = literalOf(arg);
+        if (literal === undefined) {
+            refusals.push({
+                rawTarget: `${root.text}.${step.member}`,
+                reason: "a route group registration whose prefix is not a string literal. Refused rather than guessed: " +
+                    "the prefix is assembled somewhere else, and half a prefix is an endpoint that does not exist.",
+                line: step.call.startPosition.row + 1,
+            });
+            return undefined;
+        }
+        return { importPath: baseLocal.importPath, prefix: baseLocal.prefix + literal };
+    }
+    if (steps.length === 2 && steps[0]?.member === "PathPrefix" && steps[1]?.member === "Subrouter") {
+        const baseLocal = found.get(root.text);
+        if (baseLocal === undefined || baseLocal.importPath !== GORILLA_MUX)
+            return undefined;
+        const arg = steps[0].call.childForFieldName("arguments")?.namedChild(0) ?? null;
+        const literal = literalOf(arg);
+        if (literal === undefined) {
+            refusals.push({
+                rawTarget: `${root.text}.PathPrefix.Subrouter`,
+                reason: "a route group registration whose prefix is not a string literal. Refused rather than guessed: " +
+                    "the prefix is assembled somewhere else, and half a prefix is an endpoint that does not exist.",
+                line: steps[1].call.startPosition.row + 1,
+            });
+            return undefined;
+        }
+        return { importPath: baseLocal.importPath, prefix: baseLocal.prefix + literal };
+    }
+    return undefined;
+}
+/**
+ * Locals bound to a router, per function body — a constructed root router, or a
+ * group bound from one by assignment.
+ *
+ * Scoped to the enclosing function on purpose: a package-level `var mux = ...`
+ * is a different lifetime and a different reader problem, and admitting it here
+ * would mean tracking assignment order across files to know whether the name
+ * still holds a router at the call site.
+ *
+ * Single top-down pass, extending `found` as it goes: Go requires a name be
+ * declared before it is used, so by the time `v1.GET(…)` is reached, an earlier
+ * `v1 := r.Group("/v1")` in the same body has already been recorded.
+ */
+function routerLocals(body, unit, refusals) {
+    const found = new Map();
+    const visit = (node) => {
+        if (node.type === "short_var_declaration" || node.type === "assignment_statement") {
+            const left = node.childForFieldName("left");
+            const right = node.childForFieldName("right");
+            const name = left?.namedChild(0);
+            const rhs = right?.namedChild(0);
+            if (name !== null && name !== undefined && name.type === "identifier" && rhs !== null && rhs !== undefined && rhs.type === "call_expression") {
+                const unwound = unwindChain(rhs);
+                if (unwound !== undefined) {
+                    const bound = bindingFromChain(unwound, unit, found, refusals);
+                    if (bound !== undefined)
+                        found.set(name.text, bound);
+                }
+            }
+        }
+        for (let i = 0; i < node.namedChildCount; i += 1) {
+            const child = node.namedChild(i);
+            if (child !== null)
+                visit(child);
+        }
+    };
+    visit(body);
+    return found;
+}
+/**
+ * Split a `net/http` pattern into a verb and a path.
+ *
+ * Returns `undefined` when the pattern names no method — the refusal that
+ * DEC-114 is about. `[METHOD ][HOST]/[PATH]` is the documented shape; only the
+ * method half is read here, because a host is a deployment fact rather than a
+ * route identity and merging on it would be a guess.
+ */
+function splitPattern(pattern) {
+    const space = pattern.indexOf(" ");
+    if (space === -1)
+        return undefined;
+    const method = pattern.slice(0, space).trim();
+    const path = pattern.slice(space + 1).trim();
+    if (!/^[A-Z]+$/.test(method) || !path.startsWith("/"))
+        return undefined;
+    return { method, path };
+}
+/**
+ * Is every placeholder in this template a plain path parameter?
+ *
+ * `{id...}` is a multi-segment wildcard and `{$}` anchors the end of a path.
+ * **Neither is a path parameter**, and normalising them to `{param}` would merge
+ * routes that serve different requests — the identity defect DEC-055 measured,
+ * arriving by a different door.
+ */
+function templateIsPlain(path) {
+    for (const match of path.matchAll(/\{([^}]*)\}/g)) {
+        const inner = match[1] ?? "";
+        if (inner === "" || inner === "$" || inner.endsWith("..."))
+            return false;
+    }
+    return true;
+}
+/**
+ * A group-callback's own single parameter, split into its name and the
+ * package-qualified type it was declared with — or `undefined` when the
+ * parameter list is not exactly one plainly-qualified parameter.
+ */
+function soleParameter(list) {
+    if (list === null)
+        return undefined;
+    let found;
+    let count = 0;
+    for (let i = 0; i < list.namedChildCount; i += 1) {
+        const parameter = list.namedChild(i);
+        if (parameter === null || parameter.type !== "parameter_declaration")
+            continue;
+        count += 1;
+        const nameNode = parameter.childForFieldName("name");
+        const typeText = baseTypeName(parameter.childForFieldName("type"));
+        const dot = typeText === undefined ? -1 : typeText.indexOf(".");
+        if (nameNode !== null && typeText !== undefined && dot !== -1) {
+            found = { name: nameNode.text, qualifier: typeText.slice(0, dot), typeName: typeText.slice(dot + 1) };
+        }
+    }
+    return count === 1 ? found : undefined;
+}
+/**
+ * Every route registration in one file, with a ledger row for each refusal.
+ *
+ * Call sites are found by walking function bodies rather than the whole file, so
+ * the router-local set is always the one in scope at the call.
+ */
+export function readGoRoutes(root, unit) {
+    const declarations = [];
+    const refusals = [];
+    const readCall = (call, locals) => {
+        const callee = call.childForFieldName("function");
+        if (callee === null || callee.type !== "selector_expression")
+            return;
+        const base = callee.childForFieldName("operand");
+        const member = callee.childForFieldName("field");
+        if (base === null || member === null || base.type !== "identifier")
+            return;
+        const method = member.text;
+        const isPatternMethod = PATTERN_METHODS.has(method);
+        const verb = VERB_METHODS.get(method);
+        if (!isPatternMethod && verb === undefined)
+            return;
+        const importPath = unit.imports.get(base.text);
+        const viaPackage = importPath !== undefined && ROUTING_PACKAGES.has(importPath);
+        const local = locals.get(base.text);
+        const line = call.startPosition.row + 1;
+        if (!viaPackage && local === undefined) {
+            // Only refuse calls that already look like registrations. Every other
+            // `x.Get(...)` in the repository is not a route and not a gap, and filing
+            // it would inflate the ledger with the 2,280-edge population.
+            if (isPatternMethod) {
+                refusals.push({
+                    rawTarget: `${base.text}.${method}`,
+                    reason: "an HTTP route registration, but the receiver is neither a routing package nor a router " +
+                        "constructed in this function. Refused rather than guessed: a route admitted on the method " +
+                        "name alone would claim an endpoint nothing serves.",
+                    line,
+                });
+            }
+            return;
+        }
+        const framework = importPath ?? local.importPath;
+        const prefix = local?.prefix ?? "";
+        const argument = call.childForFieldName("arguments")?.namedChild(0) ?? null;
+        const written = literalOf(argument);
+        if (written === undefined) {
+            refusals.push({
+                rawTarget: `${base.text}.${method}`,
+                reason: "an HTTP route registration whose path is not a string literal. Refused rather than guessed: " +
+                    "the template is assembled somewhere else, and half a template is an endpoint that does not exist.",
+                line,
+            });
+            return;
+        }
+        let verbHere;
+        let path;
+        if (isPatternMethod) {
+            const split = splitPattern(written);
+            if (split === undefined) {
+                refusals.push({
+                    rawTarget: written,
+                    reason: "an HTTP route registration whose pattern names no method, so it matches every verb. " +
+                        "Refused rather than defaulted to GET: a verb this reader never established would " +
+                        "manufacture a join and report a contract match that does not exist (DEC-114).",
+                    line,
+                });
+                return;
+            }
+            verbHere = split.method;
+            path = split.path;
+        }
+        else {
+            verbHere = verb;
+            path = written;
+            if (!path.startsWith("/")) {
+                refusals.push({
+                    rawTarget: written,
+                    reason: "an HTTP route registration whose path is not repository-relative.",
+                    line,
+                });
+                return;
+            }
+        }
+        const template = prefix + path;
+        if (!templateIsPlain(template)) {
+            refusals.push({
+                rawTarget: written,
+                reason: "an HTTP route whose template contains a wildcard or an end-of-path anchor rather than a " +
+                    "path parameter. Refused rather than normalised: collapsing it to {param} would merge routes " +
+                    "that serve different requests.",
+                line,
+            });
+            return;
+        }
+        declarations.push({ method: verbHere, template, written, framework, line });
+    };
+    /**
+     * `router.Route("/v1", func(r chi.Router) { … })` / `router.Group(func(r chi.Router) { … })`.
+     *
+     * Returns `true` when the call was a group-callback shape and has already
+     * been fully handled (walked with an extended scope, or refused) — the
+     * caller must not also visit it as an ordinary call or recurse into it again.
+     * Returns `false` for anything else, including a same-named method on a
+     * receiver that never qualified as a router in the first place.
+     */
+    const tryGroupCallback = (call, locals) => {
+        const callee = call.childForFieldName("function");
+        if (callee === null || callee.type !== "selector_expression")
+            return false;
+        const base = callee.childForFieldName("operand");
+        const member = callee.childForFieldName("field");
+        if (base === null || member === null || base.type !== "identifier")
+            return false;
+        const local = locals.get(base.text);
+        const spec = local === undefined ? undefined : FRAMEWORKS.get(local.importPath);
+        if (local === undefined || spec === undefined || !spec.groupCallbackMethods.has(member.text))
+            return false;
+        const args = call.childForFieldName("arguments");
+        const argCount = args?.namedChildCount ?? 0;
+        // `Route(pattern, fn)` takes two; `Group(fn)` takes one. Anything else is
+        // not this framework's grouping call after all — fall through unhandled.
+        if (argCount !== 1 && argCount !== 2)
+            return false;
+        const funcLit = args?.namedChild(argCount - 1) ?? null;
+        if (funcLit === null || funcLit.type !== "func_literal")
+            return false;
+        const line = call.startPosition.row + 1;
+        const rawTarget = `${base.text}.${member.text}`;
+        let addedPrefix = "";
+        if (argCount === 2) {
+            const literal = literalOf(args?.namedChild(0) ?? null);
+            if (literal === undefined) {
+                refusals.push({
+                    rawTarget,
+                    reason: "a grouped route registration whose prefix is not a string literal. Refused rather than guessed: " +
+                        "the prefix is assembled somewhere else, and half a prefix is an endpoint that does not exist.",
+                    line,
+                });
+                return true;
+            }
+            addedPrefix = literal;
+        }
+        const param = soleParameter(funcLit.childForFieldName("parameters"));
+        const paramPath = param === undefined ? undefined : unit.imports.get(param.qualifier);
+        const confirmed = param !== undefined && paramPath === local.importPath && param.typeName === spec.callbackParamType;
+        if (!confirmed) {
+            refusals.push({
+                rawTarget,
+                reason: "a grouped route registration whose callback parameter this reader could not confirm as the same " +
+                    "framework's own router type. Refused rather than walked: a parameter merely typed as a router is " +
+                    "not by itself evidence, and here even the written type could not be matched against the framework's.",
+                line,
+            });
+            return true;
+        }
+        const body = funcLit.childForFieldName("body");
+        if (body === null)
+            return true;
+        const childLocals = new Map(locals);
+        childLocals.set(param.name, { importPath: local.importPath, prefix: local.prefix + addedPrefix });
+        walkForRoutes(body, childLocals);
+        return true;
+    };
+    /**
+     * gorilla/mux's fluent chain: `.Methods(…)`, `.Path(…)`, `.HandleFunc(…)`,
+     * `.Handler(…)`/`.HandlerFunc(…)`, in any order, any subset, rooted at a
+     * confirmed gorilla/mux router.
+     *
+     * Returns `true` once the chain has been fully judged — emitted, or refused —
+     * so the caller does not also try it as a two-argument call. Returns `false`
+     * for a mid-chain link (guarded by `isChainHead`) and for any chain that
+     * never actually attempted a path or a handler at all: `.Name(…)` alone, or
+     * a `.PathPrefix(…).Subrouter()` grouping call, are real gorilla/mux calls
+     * this file simply is not the reader for — not evidence of an incomplete
+     * registration, so not refused either.
+     */
+    const tryGorillaChain = (call, locals) => {
+        if (!isChainHead(call))
+            return false;
+        const unwound = unwindChain(call);
+        if (unwound === undefined)
+            return false;
+        const { root, steps } = unwound;
+        const local = locals.get(root.text);
+        if (local === undefined || local.importPath !== GORILLA_MUX)
+            return false;
+        let pathAttempted = false;
+        let pathLiteral;
+        let handlerSeen = false;
+        const verbs = [];
+        let verbsUnresolved = false;
+        for (const step of steps) {
+            if (step.member === "Path") {
+                pathAttempted = true;
+                pathLiteral = literalOf(step.call.childForFieldName("arguments")?.namedChild(0) ?? null);
+            }
+            else if (step.member === "HandleFunc") {
+                pathAttempted = true;
+                handlerSeen = true;
+                pathLiteral = literalOf(step.call.childForFieldName("arguments")?.namedChild(0) ?? null);
+            }
+            else if (step.member === "Handler" || step.member === "HandlerFunc") {
+                handlerSeen = true;
+            }
+            else if (step.member === "Methods") {
+                const args = step.call.childForFieldName("arguments");
+                const count = args?.namedChildCount ?? 0;
+                for (let i = 0; i < count; i += 1) {
+                    const verb = verbTextOf(args?.namedChild(i) ?? null, unit);
+                    if (verb === undefined)
+                        verbsUnresolved = true;
+                    else
+                        verbs.push(verb);
+                }
+            }
+            // Any other link (`.Name(…)`, `.Queries(…)`, `.Headers(…)`, `.Schemes(…)`,
+            // `.PathPrefix(…)`) narrows matching without bearing on route identity
+            // here, or (`.Subrouter()`) is the grouping shape `routerLocals` already
+            // owns — intentionally ignored, not evidence of anything unhandled.
+        }
+        if (!handlerSeen || !pathAttempted)
+            return false;
+        const line = call.startPosition.row + 1;
+        const rawTarget = `${root.text}.${steps.map((step) => step.member).join(".")}(…)`;
+        if (pathLiteral === undefined) {
+            refusals.push({
+                rawTarget,
+                reason: "an HTTP route registration whose path is not a string literal. Refused rather than guessed: " +
+                    "the template is assembled somewhere else, and half a template is an endpoint that does not exist.",
+                line,
+            });
+            return true;
+        }
+        if (verbsUnresolved) {
+            refusals.push({
+                rawTarget,
+                reason: "an HTTP route registration whose .Methods(...) argument is not a string literal or a " +
+                    "recognised net/http Method constant. Refused rather than guessed.",
+                line,
+            });
+            return true;
+        }
+        if (verbs.length === 0) {
+            refusals.push({
+                rawTarget,
+                reason: "an HTTP route registration with no .Methods(...) anywhere in its chain, so it matches every " +
+                    "verb. Refused rather than defaulted to GET: a verb this reader never established would " +
+                    "manufacture a join and report a contract match that does not exist (DEC-114).",
+                line,
+            });
+            return true;
+        }
+        const template = local.prefix + stripGorillaConstraints(pathLiteral);
+        if (!templateIsPlain(template)) {
+            refusals.push({
+                rawTarget,
+                reason: "an HTTP route whose template contains a wildcard or an end-of-path anchor rather than a " +
+                    "path parameter. Refused rather than normalised: collapsing it to {param} would merge routes " +
+                    "that serve different requests.",
+                line,
+            });
+            return true;
+        }
+        for (const method of new Set(verbs)) {
+            declarations.push({ method, template, written: pathLiteral, framework: local.importPath, line });
+        }
+        return true;
+    };
+    const walkForRoutes = (node, locals) => {
+        if (node.type === "call_expression") {
+            if (tryGroupCallback(node, locals))
+                return;
+            if (tryGorillaChain(node, locals))
+                return;
+            readCall(node, locals);
+        }
+        for (let i = 0; i < node.namedChildCount; i += 1) {
+            const child = node.namedChild(i);
+            if (child !== null)
+                walkForRoutes(child, locals);
+        }
+    };
+    const findBodies = (node) => {
+        if (node.type === "function_declaration" || node.type === "method_declaration") {
+            const body = node.childForFieldName("body");
+            if (body !== null) {
+                const locals = routerLocals(body, unit, refusals);
+                walkForRoutes(body, locals);
+            }
+            return;
+        }
+        for (let i = 0; i < node.namedChildCount; i += 1) {
+            const child = node.namedChild(i);
+            if (child !== null)
+                findBodies(child);
+        }
+    };
+    findBodies(root);
+    return { declarations, refusals };
+}
+//# sourceMappingURL=routes.js.map