@velarscript/node 0.12.0 → 0.13.0

package/dist/serve-runtime.js.map

@@ -1 +1 @@
-{"version":3,"file":"serve-runtime.js","sourceRoot":"","sources":["../src/serve-runtime.ts"],"names":[],"mappings":"AAAA,0EAA0E;AAC1E,8EAA8E;AAC9E,+EAA+E;AAC/E,MAAM,CAAC,MAAM,wBAAwB,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAknGjD,CAAC,SAAS,EAAE,CAAC"}
+{"version":3,"file":"serve-runtime.js","sourceRoot":"","sources":["../src/serve-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gCAAgC,EAAE,MAAM,kBAAkB,CAAC;AAEpE,0EAA0E;AAC1E,8EAA8E;AAC9E,+EAA+E;AAC/E,MAAM,CAAC,MAAM,wBAAwB,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6CAw/BL,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA63E5E,CAAC,SAAS,EAAE,CAAC"}

package/dist/server-analyzer.d.ts

@@ -18,6 +18,16 @@ export declare function parseRouteResultHint(value: string | undefined): {
 export declare class VelarNodeAnalyzer extends Analyzer {
     private readonly contextualRouteParameters;
     private readonly routeInputs;
+    /** Servers declared by the module under analysis, the only spread targets this analyzer can resolve. */
+    private readonly moduleServers;
+    /** Module-level `const alias = name` and `let alias = name` bindings, so a spread of an alias resolves to the server it names. */
+    private readonly moduleServerAliases;
+    /** Local names imported from velar/serve that name a path-preserving combinator, so a spread of a call resolves through it. */
+    private readonly moduleServeCombinators;
+    /** One answer per `let` alias name to "was this binding ever reassigned?", because the predicate walks the whole program. */
+    private readonly stableAliases;
+    /** The program under analysis, held for the alias-stability walk. */
+    private moduleProgram;
     private readonly nodeModulePath;
     constructor(context?: AnalysisContext, extensions?: readonly CompilerAnalysisExtension[]);
     analyze(program: Program): readonly import("@velarscript/compiler").Diagnostic[];
@@ -27,6 +37,48 @@ export declare class VelarNodeAnalyzer extends Analyzer {
         readonly kind: string;
     }, parameter: Parameter): ValueType | null;
     private analyzeServer;
+    /**
+     * Enters one route into this server's shape map and compares it against every route already
+     * entered, whether that route was written here or composed in by a spread. Composition is why the
+     * entries carry an origin: a conflicting route the author cannot see in his own file has to name
+     * the server it came from.
+     */
+    private recordRoute;
+    /**
+     * The routes and fallback a spread composes into the server that writes it, or null when the
+     * spread is not statically resolvable. This analyzer sees one module, so a spread contributes
+     * only when its value reaches a server declared in this module: a plain identifier, an alias of
+     * one, or a velar/serve combinator call around one — `use`, `bodyLimit`, `docs` and `lifecycle`
+     * carry paths through unchanged, and `prefix` translates them by its literal path. An imported
+     * server, a computed prefix path, or any other expression is let through unchecked, because a
+     * false conflict here would block a correct program; D90 R19's runtime referee judges the final
+     * table at assembly instead. Composition is followed transitively; the visited set bounds a
+     * cycle and starts holding the composing server, so a cycle never folds a server's own routes
+     * back into itself and reports each as conflicting with itself.
+     */
+    private composedItems;
+    /**
+     * The server declaration a spread value names, or null when it is anything else. A
+     * `const other = base` alias chain of this module's own servers resolves too, because the alias
+     * holds exactly that ServeApp — and so does a `let` alias the whole module never reassigns,
+     * because an unwritten `let` holds its initializer exactly as a `const` does. A reassigned or
+     * ambiguous `let`, a member path, a conditional, an import, or a parameter contributes nothing.
+     * A call resolves through the path-preserving velar/serve combinators when the callee still
+     * reaches its velar/serve import: `prefix` with a literal path translates what its app argument
+     * declares, and `use`/`bodyLimit`/`docs`/`lifecycle` pass it through untouched. A computed
+     * prefix path contributes nothing — the assembly-time referee owns it. An alias's initializer
+     * re-enters this resolver whole, so `const scoped = prefix("/api", routes)` resolves exactly as
+     * the spelled-out spread does; the followed set bounds an alias cycle.
+     */
+    private resolveComposedServer;
+    /** Whether a `let` alias has never been reassigned, asked once per name and program. */
+    private aliasBindingIsStable;
+    /**
+     * Whether a name still reaches the declaration this module recorded for it. An import, a
+     * shadowing binding, or a parameter of the same name reaches a different binding.
+     */
+    private resolvesTo;
+    private analyzeNotFound;
     private analyzeRoute;
 }
 export declare function inferNodeIntrinsic(context: CompilerIntrinsicAnalysisContext): ValueType | undefined;

package/dist/server-analyzer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server-analyzer.d.ts","sourceRoot":"","sources":["../src/server-analyzer.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EASR,KAAK,eAAe,EACpB,KAAK,yBAAyB,EAC9B,KAAK,gCAAgC,EACrC,KAAK,SAAS,EACd,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,KAAK,SAAS,EACf,MAAM,iCAAiC,CAAC;AAyBzC,MAAM,MAAM,oBAAoB,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,SAAS,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,GAAG,QAAQ,GAAG,YAAY,GAAG,UAAU,CAAC;AAC/I,MAAM,MAAM,kBAAkB,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,QAAQ,GAAG,YAAY,GAAG,UAAU,CAAC;AAC5I,KAAK,aAAa,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAEvD,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,oBAAoB,EAAE,IAAI,EAAE,kBAAkB,EAAE,MAAM,EAAE,aAAa,EAAE,UAAU,UAAQ,GAAG,MAAM,CAE5I;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG;IAClE,QAAQ,CAAC,MAAM,EAAE,oBAAoB,CAAC;IACtC,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAC/B,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;CAC9B,GAAG,IAAI,CAcP;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,aAAa,EAAE,YAAY,EAAE,SAAS,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAErH;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG;IAAC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAAC,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;CAAC,GAAG,IAAI,CAWjL;AAED,qBAAa,iBAAkB,SAAQ,QAAQ;IAC7C,OAAO,CAAC,QAAQ,CAAC,yBAAyB,CAAgC;IAC1E,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAyC;IACrE,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAgB;IAE/C,YAAY,OAAO,GAAE,eAAoB,EAAE,UAAU,GAAE,SAAS,yBAAyB,EAAO,EAG/F;IAEQ,OAAO,CAAC,OAAO,EAAE,OAAO,yDAShC;IAED,UAAmB,4BAA4B,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAI7E;IAED,UAAmB,yBAAyB,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAI1E;IAED,UAAmB,kCAAkC,CACnD,SAAS,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EACpC,SAAS,EAAE,SAAS,GACnB,SAAS,GAAG,IAAI,CAYlB;IAED,OAAO,CAAC,aAAa;IAyBrB,OAAO,CAAC,YAAY;CAqGrB;AAID,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,gCAAgC,GAAG,SAAS,GAAG,SAAS,CA0KnG"}
+{"version":3,"file":"server-analyzer.d.ts","sourceRoot":"","sources":["../src/server-analyzer.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EASR,KAAK,eAAe,EACpB,KAAK,yBAAyB,EAC9B,KAAK,gCAAgC,EAErC,KAAK,SAAS,EACd,KAAK,OAAO,EAGZ,KAAK,SAAS,EACd,KAAK,SAAS,EACf,MAAM,iCAAiC,CAAC;AA4CzC,MAAM,MAAM,oBAAoB,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,SAAS,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,GAAG,QAAQ,GAAG,YAAY,GAAG,UAAU,CAAC;AAC/I,MAAM,MAAM,kBAAkB,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,QAAQ,GAAG,YAAY,GAAG,UAAU,CAAC;AAC5I,KAAK,aAAa,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAEvD,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,oBAAoB,EAAE,IAAI,EAAE,kBAAkB,EAAE,MAAM,EAAE,aAAa,EAAE,UAAU,UAAQ,GAAG,MAAM,CAE5I;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG;IAClE,QAAQ,CAAC,MAAM,EAAE,oBAAoB,CAAC;IACtC,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAC/B,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;CAC9B,GAAG,IAAI,CAcP;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,aAAa,EAAE,YAAY,EAAE,SAAS,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAErH;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG;IAAC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAAC,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;CAAC,GAAG,IAAI,CAWjL;AAED,qBAAa,iBAAkB,SAAQ,QAAQ;IAC7C,OAAO,CAAC,QAAQ,CAAC,yBAAyB,CAAgC;IAC1E,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAyC;IACrE,wGAAwG;IACxG,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA4C;IAC1E,kIAAkI;IAClI,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAkC;IACtE,+HAA+H;IAC/H,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAgF;IACvH,6HAA6H;IAC7H,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA8B;IAC5D,qEAAqE;IACrE,OAAO,CAAC,aAAa,CAAwB;IAC7C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAgB;IAE/C,YAAY,OAAO,GAAE,eAAoB,EAAE,UAAU,GAAE,SAAS,yBAAyB,EAAO,EAG/F;IAEQ,OAAO,CAAC,OAAO,EAAE,OAAO,yDA+BhC;IAED,UAAmB,4BAA4B,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAI7E;IAED,UAAmB,yBAAyB,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAI1E;IAED,UAAmB,kCAAkC,CACnD,SAAS,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EACpC,SAAS,EAAE,SAAS,GACnB,SAAS,GAAG,IAAI,CAYlB;IAED,OAAO,CAAC,aAAa;IAgCrB;;;;;OAKG;IACH,OAAO,CAAC,WAAW;IA+BnB;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,aAAa;IAuCrB;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,qBAAqB;IA+B7B,wFAAwF;IACxF,OAAO,CAAC,oBAAoB;IAQ5B;;;OAGG;IACH,OAAO,CAAC,UAAU;IAKlB,OAAO,CAAC,eAAe;IAwBvB,OAAO,CAAC,YAAY;CAqGrB;AAID,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,gCAAgC,GAAG,SAAS,GAAG,SAAS,CA0KnG"}

package/dist/server-analyzer.js

@@ -1,4 +1,5 @@
-import { Analyzer, anyType, boolType, describeType, nullType, numberType, optionalOf, stringType, unknownType, } from "@velarscript/compiler/extension";
+import { Analyzer, bindingNeverReassigned, boolType, describeType, nullType, numberType, optionalOf, stringType, unknownType, spanIdentity, } from "@velarscript/compiler/extension";
+import { routeShape } from "./route-shape.js";
 import { isNodeServerStatement } from "./server-ast.js";
 import { isNodeProviderType, isNodeRouteInputType, isServeRequestType, nodeProviderResult, nodeProviderType, nodeRouteInputType, nodeRouteInputValue, serveAppType, serveRequestType, } from "./server-types.js";
 const routeHintPrefix = "node.route-param:";
@@ -8,6 +9,7 @@ const sseEventType = { kind: "object", fields: new Map([
         ["data", stringType], ["event", optionalOf(stringType)], ["id", optionalOf(stringType)], ["retry", optionalOf(numberType)],
     ]), optionalFields: new Set(["event", "id", "retry"]) };
 const sseSendType = { kind: "function", parameterNames: ["event"], parameters: [{ kind: "union", members: [stringType, sseEventType] }], requiredParameters: 1, result: { kind: "promise", value: nullType } };
+const serveCombinators = new Set(["prefix", "use", "bodyLimit", "docs", "lifecycle"]);
 export function routeParameterHint(source, kind, schema, descriptor = false) {
     return `${routeHintPrefix}${JSON.stringify({ source, kind, schema, descriptor })}`;
 }
@@ -45,12 +47,47 @@ export function parseRouteResultHint(value) {
 export class VelarNodeAnalyzer extends Analyzer {
     contextualRouteParameters = new Map();
     routeInputs = new Map();
+    /** Servers declared by the module under analysis, the only spread targets this analyzer can resolve. */
+    moduleServers = new Map();
+    /** Module-level `const alias = name` and `let alias = name` bindings, so a spread of an alias resolves to the server it names. */
+    moduleServerAliases = new Map();
+    /** Local names imported from velar/serve that name a path-preserving combinator, so a spread of a call resolves through it. */
+    moduleServeCombinators = new Map();
+    /** One answer per `let` alias name to "was this binding ever reassigned?", because the predicate walks the whole program. */
+    stableAliases = new Map();
+    /** The program under analysis, held for the alias-stability walk. */
+    moduleProgram = null;
     nodeModulePath;
     constructor(context = {}, extensions = []) {
         super(context, extensions);
         this.nodeModulePath = context.path ?? null;
     }
     analyze(program) {
+        this.moduleServers.clear();
+        this.moduleServerAliases.clear();
+        this.moduleServeCombinators.clear();
+        this.stableAliases.clear();
+        this.moduleProgram = program;
+        for (const statement of program.body) {
+            if (isNodeServerStatement(statement)) {
+                if (!this.moduleServers.has(statement.name))
+                    this.moduleServers.set(statement.name, statement);
+                continue;
+            }
+            if (statement.kind === "ImportDeclaration" && statement.source === "velar/serve") {
+                for (const specifier of statement.specifiers) {
+                    if (specifier.namespace || !serveCombinators.has(specifier.imported))
+                        continue;
+                    if (!this.moduleServeCombinators.has(specifier.local)) {
+                        this.moduleServeCombinators.set(specifier.local, { imported: specifier.imported, span: specifier.span });
+                    }
+                }
+                continue;
+            }
+            const alias = moduleServerAlias(statement);
+            if (alias && !this.moduleServerAliases.has(alias.name))
+                this.moduleServerAliases.set(alias.name, alias);
+        }
         if (!(this.nodeModulePath ?? "").endsWith(".test.vel")) {
             for (const statement of program.body) {
                 if ((statement.kind === "ImportDeclaration" || statement.kind === "ReExportDeclaration") && statement.source === "velar/server-test") {
@@ -93,22 +130,221 @@ export class VelarNodeAnalyzer extends Analyzer {
         if (!this.isPredeclared(statement))
             this.declareBinding(statement.name, false, serveAppType, statement.span);
         const routes = new Map();
+        let notFound = null;
         for (const item of statement.items) {
             if (item.kind === "NodeServerSpread") {
                 this.requireAssignable(this.inferExpression(item.value, serveAppType), serveAppType, item.value.span);
+                const composed = this.composedItems(statement, item);
+                if (!composed)
+                    continue;
+                if (composed.notFound) {
+                    if (notFound)
+                        this.typeError(describeFallbackCollision(notFound, composed.notFound), item.span);
+                    else
+                        notFound = composed.notFound;
+                }
+                for (const entry of composed.routes)
+                    this.recordRoute(entry, routes, item.span);
                 continue;
             }
-            const shape = routeShape(item.path);
-            const key = `${item.method} ${shape}`;
-            const previous = routes.get(key);
-            if (previous) {
-                this.typeError(`Route '${item.method} ${item.path}' conflicts with '${previous.method} ${previous.path}'; parameter names do not make two route shapes distinct`, item.pathSpan);
+            if (item.kind === "NodeNotFoundDeclaration") {
+                const written = { fallback: item, spread: null, origin: [] };
+                if (notFound)
+                    this.typeError(describeFallbackCollision(notFound, written), item.span);
+                else
+                    notFound = written;
+                this.analyzeNotFound(item);
+                continue;
             }
-            else
-                routes.set(key, item);
+            this.recordRoute({ route: item, path: item.path, spread: null, origin: [] }, routes, item.pathSpan);
             this.analyzeRoute(item);
         }
     }
+    /**
+     * Enters one route into this server's shape map and compares it against every route already
+     * entered, whether that route was written here or composed in by a spread. Composition is why the
+     * entries carry an origin: a conflicting route the author cannot see in his own file has to name
+     * the server it came from.
+     */
+    recordRoute(entry, routes, span) {
+        const key = `${entry.route.method} ${routeShape(entry.path)}`;
+        const previous = routes.get(key);
+        if (previous) {
+            this.typeError(describeRouteCollision(previous, entry), span);
+            return;
+        }
+        // Two routes of one method can share a concrete path. Where one declares a literal at every
+        // position the other does and more, the router's literal-beats-capture score picks it every
+        // time, which is the intended precedence behind '/users/me' beside '/users/{id:string}'.
+        // Where neither is more specific the winner is declaration order alone and the loser can
+        // never run, so the overlap is an error. A pair whose shared path is unrealizable — a
+        // '{n:number}' capture against the literal 'b' — is not an overlap.
+        const segments = routeSegments(entry.path);
+        for (const other of routes.values()) {
+            if (other.route.method !== entry.route.method)
+                continue;
+            // Two routes one spread composed in were already compared against each other while that
+            // server was analyzed; reporting them again here would duplicate its diagnostic.
+            if (entry.spread !== null && other.spread === entry.spread)
+                continue;
+            const declared = routeSegments(other.path);
+            if (routeSpecificityDecides(declared, segments))
+                continue;
+            const shared = routeSharedPath(declared, segments);
+            if (shared === null)
+                continue;
+            this.typeError(`Route ${describeComposedRoute(other)} overlaps ${describeComposedRoute(entry)}; both match '${shared}' and neither is more specific — narrow or remove one`, span);
+        }
+        routes.set(key, entry);
+    }
+    /**
+     * The routes and fallback a spread composes into the server that writes it, or null when the
+     * spread is not statically resolvable. This analyzer sees one module, so a spread contributes
+     * only when its value reaches a server declared in this module: a plain identifier, an alias of
+     * one, or a velar/serve combinator call around one — `use`, `bodyLimit`, `docs` and `lifecycle`
+     * carry paths through unchanged, and `prefix` translates them by its literal path. An imported
+     * server, a computed prefix path, or any other expression is let through unchecked, because a
+     * false conflict here would block a correct program; D90 R19's runtime referee judges the final
+     * table at assembly instead. Composition is followed transitively; the visited set bounds a
+     * cycle and starts holding the composing server, so a cycle never folds a server's own routes
+     * back into itself and reports each as conflicting with itself.
+     */
+    composedItems(statement, spread) {
+        const target = this.resolveComposedServer(spread.value);
+        if (!target)
+            return null;
+        const routes = [];
+        const shapes = new Set();
+        const visited = new Set([statement]);
+        let notFound = null;
+        const collect = (server, prefix, origin) => {
+            if (visited.has(server))
+                return;
+            visited.add(server);
+            for (const item of server.items) {
+                if (item.kind === "NodeServerSpread") {
+                    const nested = this.resolveComposedServer(item.value);
+                    if (nested)
+                        collect(nested.server, prefix + nested.prefix, [...origin, nested.server.name]);
+                    continue;
+                }
+                if (item.kind === "NodeNotFoundDeclaration") {
+                    // The runtime refuses `prefix` around an app with @notFound outright, so a fallback seen
+                    // through a prefix never reaches any composed table and composing it here would report
+                    // a duplicate the program cannot have.
+                    if (prefix === "")
+                        notFound ??= { fallback: item, spread, origin };
+                    continue;
+                }
+                // A server that conflicts with itself already reported it; one entry per shape is what
+                // reaches the composing server, exactly as one entry per shape reaches its own map.
+                const path = prefixedRoutePath(prefix, item.path);
+                const shape = `${item.method} ${routeShape(path)}`;
+                if (shapes.has(shape))
+                    continue;
+                shapes.add(shape);
+                routes.push({ route: item, path, spread, origin });
+            }
+        };
+        collect(target.server, target.prefix, [target.server.name]);
+        return { routes, notFound };
+    }
+    /**
+     * The server declaration a spread value names, or null when it is anything else. A
+     * `const other = base` alias chain of this module's own servers resolves too, because the alias
+     * holds exactly that ServeApp — and so does a `let` alias the whole module never reassigns,
+     * because an unwritten `let` holds its initializer exactly as a `const` does. A reassigned or
+     * ambiguous `let`, a member path, a conditional, an import, or a parameter contributes nothing.
+     * A call resolves through the path-preserving velar/serve combinators when the callee still
+     * reaches its velar/serve import: `prefix` with a literal path translates what its app argument
+     * declares, and `use`/`bodyLimit`/`docs`/`lifecycle` pass it through untouched. A computed
+     * prefix path contributes nothing — the assembly-time referee owns it. An alias's initializer
+     * re-enters this resolver whole, so `const scoped = prefix("/api", routes)` resolves exactly as
+     * the spelled-out spread does; the followed set bounds an alias cycle.
+     */
+    resolveComposedServer(value, followed = new Set()) {
+        if (value.kind === "CallExpression" && !value.optional) {
+            if (value.callee.kind !== "IdentifierExpression")
+                return null;
+            const combinator = this.moduleServeCombinators.get(value.callee.name);
+            if (!combinator || !this.resolvesTo(value.callee.name, combinator.span))
+                return null;
+            const appIndex = combinator.imported === "prefix" ? 1 : 0;
+            const app = value.arguments[appIndex];
+            if (!app || value.argumentNames?.slice(0, appIndex + 1).some((argumentName) => argumentName !== null))
+                return null;
+            const inner = this.resolveComposedServer(app, followed);
+            if (!inner)
+                return null;
+            if (combinator.imported !== "prefix")
+                return inner;
+            const path = value.arguments[0];
+            if (!path || path.kind !== "LiteralExpression" || typeof path.value !== "string")
+                return null;
+            // The same literal shapes the runtime accepts; anything else is the runtime referee's to
+            // refuse, and claiming routes for it here would report conflicts against a table that
+            // never assembles.
+            if (path.value === "/")
+                return inner;
+            if (!path.value.startsWith("/") || path.value.endsWith("/") || /[{}*?#\\]|\/\//u.test(path.value))
+                return null;
+            return { server: inner.server, prefix: path.value + inner.prefix };
+        }
+        if (value.kind !== "IdentifierExpression")
+            return null;
+        const name = value.name;
+        const declaration = this.moduleServers.get(name);
+        if (declaration)
+            return this.resolvesTo(name, declaration.span) ? { server: declaration, prefix: "" } : null;
+        const alias = this.moduleServerAliases.get(name);
+        if (!alias || followed.has(name) || !this.resolvesTo(name, alias.span))
+            return null;
+        if (alias.binding === "let" && !this.aliasBindingIsStable(alias))
+            return null;
+        followed.add(name);
+        return this.resolveComposedServer(alias.initializer, followed);
+    }
+    /** Whether a `let` alias has never been reassigned, asked once per name and program. */
+    aliasBindingIsStable(alias) {
+        const cached = this.stableAliases.get(alias.name);
+        if (cached !== undefined)
+            return cached;
+        const stable = this.moduleProgram !== null && bindingNeverReassigned(this.moduleProgram, alias.name, alias.span);
+        this.stableAliases.set(alias.name, stable);
+        return stable;
+    }
+    /**
+     * Whether a name still reaches the declaration this module recorded for it. An import, a
+     * shadowing binding, or a parameter of the same name reaches a different binding.
+     */
+    resolvesTo(name, span) {
+        const binding = this.lookup(name);
+        return binding !== null && spanIdentity(binding.span) === spanIdentity(span);
+    }
+    analyzeNotFound(fallback) {
+        this.analyzeFunctionDeclaration(fallback, null, true, false, true, "Not-found fallback");
+        if (fallback.parameters.length > 1) {
+            this.typeError("@notFound accepts at most one Request parameter", fallback.signatureSpan);
+        }
+        const parameter = fallback.parameters[0];
+        if (parameter) {
+            if (parameter.rest)
+                this.typeError("@notFound Request cannot be a rest parameter", parameter.span);
+            if (parameter.defaultValue)
+                this.typeError("@notFound Request is supplied by the server and cannot have a default value", parameter.span);
+            if (!parameter.type)
+                this.typeError("@notFound Request requires the explicit Request type", parameter.span);
+            else {
+                const resolved = this.expandAliases(this.resolveValidatedAnnotation(parameter.type));
+                if (!isServeRequestType(resolved))
+                    this.typeError(`@notFound parameter must be Request; received ${describeType(resolved)}`, parameter.span);
+            }
+        }
+        const result = this.expandAliases(this.inferredFunctionResult(fallback));
+        if (!isRouteResult(result, (identity) => this.fieldsOf(identity), new Set())) {
+            this.typeError(`@notFound must return Data or a response from velar/serve; received ${describeType(result)}`, fallback.returnType?.span ?? fallback.span);
+        }
+    }
     analyzeRoute(route) {
         const pathNames = validateRoutePath(route.path, route.pathSpan, (message) => this.typeError(message, route.pathSpan));
         this.analyzeFunctionDeclaration(route, null, true, false, true, "Route");
@@ -216,7 +452,7 @@ export function inferNodeIntrinsic(context) {
     switch (intrinsic.name) {
         case "serve.response.json": {
             arity(1, 3);
-            const value = inferAt(0, anyType);
+            const value = inferAt(0, unknownType);
             if (argumentAt(1))
                 inferAt(1, numberType);
             if (argumentAt(2))
@@ -225,7 +461,7 @@ export function inferNodeIntrinsic(context) {
         }
         case "serve.response.created": {
             arity(1, 2);
-            const value = inferAt(0, anyType);
+            const value = inferAt(0, unknownType);
             if (argumentAt(1))
                 inferAt(1, optionalOf(responseHeadersType));
             return nodeResponseValue("json", value, 201, "application/json");
@@ -619,8 +855,137 @@ function openApiObjectSchema(fields, fieldsOf, seen, enumValuesOf) {
         additionalProperties: false,
     };
 }
-function routeShape(path) {
-    return path.split("/").map((part) => part.startsWith("{") && part.endsWith("}") ? "{}" : part).join("/");
+/**
+ * A module-level `const name = expression` or `let name = expression` binding, the indirect
+ * spellings of a spread target that can still be exactly the value the initializer resolves to: a
+ * bare name, or a velar/serve combinator call the resolver sees through. A `let` alias resolves
+ * only after the stability predicate confirms the module never reassigns it — that check belongs
+ * to the resolver, which is the point that knows the whole program. A pattern binding is excluded
+ * because it never holds the whole value.
+ */
+function moduleServerAlias(statement) {
+    if (statement.kind !== "VariableDeclaration")
+        return null;
+    const declaration = statement;
+    if (declaration.pattern.kind !== "NameBindingPattern")
+        return null;
+    if (declaration.initializer.kind !== "IdentifierExpression" && declaration.initializer.kind !== "CallExpression")
+        return null;
+    return { name: declaration.pattern.name, initializer: declaration.initializer, binding: declaration.binding, span: declaration.pattern.span };
+}
+function describeComposedOrigin(entry) {
+    return entry.origin.map((name) => `'${name}'`).join(" → ");
+}
+function describeComposedRoute(entry) {
+    // The effective path: a route seen through prefix(...) collides at its translated address, and
+    // that address is the one the author has to narrow.
+    const route = `'${entry.route.method} ${entry.path}'`;
+    return entry.origin.length === 0 ? route : `${route} (composed in from ${describeComposedOrigin(entry)})`;
+}
+/**
+ * Why two routes claim one method and shape. Three causes reach this point and each names a
+ * different repair, so the message has to tell them apart: one server composed in along two paths
+ * declares its route once and cannot be narrowed at all, two routes spelling the same path have no
+ * parameter names to blame, and only the third is the shape collision parameter names hide.
+ */
+function describeRouteCollision(previous, entry) {
+    // One declaration reaching this server twice is only reachable through spreads: a server's own
+    // items are never collected back into it, so both sides carry an origin.
+    const declaring = entry.origin[entry.origin.length - 1];
+    if (previous.route === entry.route && declaring !== undefined) {
+        const paths = describeComposedOrigin(previous) === describeComposedOrigin(entry)
+            ? `both times from ${describeComposedOrigin(entry)}`
+            : `from ${describeComposedOrigin(previous)} and from ${describeComposedOrigin(entry)}`;
+        return `Route '${entry.route.method} ${entry.path}' is composed in twice, ${paths}; '${declaring}' declares it once — remove one spread`;
+    }
+    if (previous.path === entry.path) {
+        return `Route ${describeComposedRoute(entry)} duplicates ${describeComposedRoute(previous)}; one method and path answer from a single route`;
+    }
+    return `Route ${describeComposedRoute(entry)} conflicts with ${describeComposedRoute(previous)}; parameter names do not make two route shapes distinct`;
+}
+/**
+ * Both sides of a duplicate @notFound. A fallback a spread composes in is invisible in the author's
+ * own file, so naming one contributor and not the other leaves him looking for a declaration that
+ * is not there; two spreads each composing one name neither by default.
+ */
+function describeFallbackCollision(previous, entry) {
+    const rule = "A server can declare only one @notFound fallback";
+    if (previous.origin.length === 0 && entry.origin.length === 0)
+        return rule;
+    const source = (fallback, second) => {
+        const article = second ? "another" : "one";
+        return fallback.origin.length === 0
+            ? `this server declares ${article}`
+            : `${describeComposedOrigin(fallback)} composes ${article} in`;
+    };
+    return `${rule}; ${source(previous, false)} and ${source(entry, true)}`;
+}
+/** A composed route's address as the runtime's `prefix` will spell it: the literal prefix, then the path. */
+function prefixedRoutePath(prefix, path) {
+    if (prefix === "")
+        return path;
+    return prefix + (path === "/" ? "" : path);
+}
+const routeDecimalPattern = /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?$/u;
+function routeSegments(path) {
+    return path.split("/").map((segment) => {
+        const match = /^\{([A-Za-z_][A-Za-z0-9_]*):([A-Za-z_][A-Za-z0-9_]*)\}$/u.exec(segment);
+        return match ? { capture: match[1], captureType: match[2] } : { literal: segment };
+    });
+}
+function routeCaptureAdmits(captureType, literal) {
+    if (captureType === "number")
+        return routeDecimalPattern.test(literal) && Number.isFinite(Number(literal));
+    if (captureType === "bool")
+        return literal === "true" || literal === "false";
+    return true;
+}
+function routeSharedSegment(left, right) {
+    if ("literal" in left) {
+        if ("literal" in right)
+            return left.literal === right.literal ? left.literal : null;
+        return routeCaptureAdmits(right.captureType, left.literal) ? left.literal : null;
+    }
+    if ("literal" in right)
+        return routeCaptureAdmits(left.captureType, right.literal) ? right.literal : null;
+    const types = new Set([left.captureType, right.captureType]);
+    if (types.has("number") && types.has("bool"))
+        return null;
+    if (types.has("number"))
+        return "1";
+    if (types.has("bool"))
+        return "true";
+    return left.capture;
+}
+function routeSharedPath(left, right) {
+    if (left.length !== right.length)
+        return null;
+    const shared = [];
+    for (let index = 0; index < left.length; index += 1) {
+        const segment = routeSharedSegment(left[index], right[index]);
+        if (segment === null)
+            return null;
+        shared.push(segment);
+    }
+    return shared.join("/");
+}
+function routeLiteralPositions(segments) {
+    const positions = new Set();
+    for (let index = 0; index < segments.length; index += 1)
+        if ("literal" in segments[index])
+            positions.add(index);
+    return positions;
+}
+function routeSpecificityDecides(left, right) {
+    const leftLiterals = routeLiteralPositions(left);
+    const rightLiterals = routeLiteralPositions(right);
+    if (leftLiterals.size === rightLiterals.size)
+        return false;
+    const [subset, superset] = leftLiterals.size < rightLiterals.size ? [leftLiterals, rightLiterals] : [rightLiterals, leftLiterals];
+    for (const position of subset)
+        if (!superset.has(position))
+            return false;
+    return true;
 }
 function validateRoutePath(path, _sourceSpan, report) {
     const names = new Set();