@loozo/angular-router 0.0.2 → 0.0.3

package/node/src/generation/anchor.js

@@ -0,0 +1,92 @@
+import ts from "typescript";
+import { statSync } from "node:fs";
+import { realpath, stat } from "node:fs/promises";
+import { resolve } from "node:path";
+async function stamp(file) {
+    try {
+        const info = await stat(file);
+        return `${info.mtimeMs}:${info.size}`;
+    }
+    catch {
+        return "missing";
+    }
+}
+// Immutable canonical factory descriptors for one generation session. Inputs are
+// the effective options, entry, factory names and every file the anchor program
+// read (sources and package metadata). A new higher-priority resolution candidate
+// appearing mid-session is not detected; dependency changes need a new session.
+// Recomputation builds a throwaway program, so no SourceFile or Symbol outlives it.
+export class AnchorState {
+    #key;
+    #anchor;
+    #inputs = new Map();
+    clear() {
+        this.#key = undefined;
+        this.#anchor = undefined;
+        this.#inputs.clear();
+    }
+    async anchor(entry, names, options) {
+        const { configFile: _configFile, ...settings } = options;
+        const key = JSON.stringify({ entry, names, settings });
+        if (this.#anchor && key === this.#key) {
+            const files = [...this.#inputs.keys()];
+            const current = await Promise.all(files.map(stamp));
+            let unchanged = true;
+            for (let index = 0; index < files.length; index += 1) {
+                if (current[index] !== this.#inputs.get(files[index])) {
+                    unchanged = false;
+                }
+            }
+            if (unchanged) {
+                return this.#anchor;
+            }
+        }
+        this.#key = undefined;
+        this.#anchor = undefined;
+        this.#inputs.clear();
+        const inputs = new Map();
+        const host = ts.createCompilerHost(options, true);
+        const read = host.readFile.bind(host);
+        // Stamp before reading, so an edit racing this pass invalidates the next one.
+        host.readFile = (file) => {
+            const path = resolve(file);
+            try {
+                const info = statSync(path);
+                inputs.set(path, `${info.mtimeMs}:${info.size}`);
+            }
+            catch {
+                inputs.set(path, "missing");
+            }
+            return read(file);
+        };
+        const program = ts.createProgram({ rootNames: [entry], options, host });
+        const checker = program.getTypeChecker();
+        const module = checker.getSymbolAtLocation(program.getSourceFile(entry));
+        const exports = checker.getExportsOfModule(module);
+        const anchor = new Map();
+        for (const name of names) {
+            let symbol = exports.find((value) => value.name === name);
+            if (symbol && symbol.flags & ts.SymbolFlags.Alias) {
+                symbol = checker.getAliasedSymbol(symbol);
+            }
+            if (!symbol?.declarations?.length) {
+                anchor.set(name, undefined);
+                continue;
+            }
+            const declarations = [];
+            for (const declaration of symbol.declarations) {
+                declarations.push({
+                    file: await realpath(declaration.getSourceFile().fileName),
+                    kind: declaration.kind,
+                    pos: declaration.pos,
+                    end: declaration.end,
+                });
+            }
+            anchor.set(name, declarations);
+        }
+        this.#key = key;
+        this.#anchor = anchor;
+        this.#inputs = inputs;
+        return anchor;
+    }
+}

package/node/src/generation/compiler.d.ts

@@ -0,0 +1,6 @@
+import ts from "typescript";
+export declare class CompilerState {
+    #private;
+    clear(): void;
+    createProgram(rootNames: readonly string[], options: ts.CompilerOptions, host: ts.CompilerHost): ts.Program;
+}

package/node/src/generation/compiler.js

@@ -0,0 +1,68 @@
+import ts from "typescript";
+import { resolve } from "node:path";
+// One graph's content-aware SourceFiles, including native binding data.
+// Hosts, Programs, checkers and native resolution caches are fresh on every pass.
+export class CompilerState {
+    #files = new Map();
+    #optionsKey;
+    clear() {
+        this.#files.clear();
+        this.#optionsKey = undefined;
+    }
+    createProgram(rootNames, options, host) {
+        // configFile is an AST, not an effective compiler setting. Configs and their
+        // diagnostics are parsed afresh by discovery; never serialize/retain that AST.
+        const { configFile: _configFile, ...settings } = options;
+        const optionsKey = JSON.stringify(settings);
+        if (optionsKey !== this.#optionsKey) {
+            this.clear();
+            this.#optionsKey = optionsKey;
+        }
+        host.getSourceFile = (file, language, _onError, shouldCreateNewSourceFile) => {
+            const key = host.getCanonicalFileName(resolve(file));
+            const text = host.readFile(file);
+            if (text === undefined) {
+                this.#files.delete(key);
+                return undefined;
+            }
+            let languageVersion;
+            let impliedNodeFormat;
+            let jsDocParsingMode = host.jsDocParsingMode;
+            if (typeof language === "object") {
+                languageVersion = language.languageVersion;
+                impliedNodeFormat = language.impliedNodeFormat;
+                jsDocParsingMode = language.jsDocParsingMode;
+            }
+            else {
+                languageVersion = language;
+            }
+            const cached = this.#files.get(key);
+            // The external-module indicator supplied in `language` derives from the
+            // effective settings above; implied format/JSDoc mode are per-file inputs.
+            if (!shouldCreateNewSourceFile &&
+                cached &&
+                cached.source.text === text &&
+                cached.languageVersion === languageVersion &&
+                cached.impliedNodeFormat === impliedNodeFormat &&
+                cached.jsDocParsingMode === jsDocParsingMode) {
+                return cached.source;
+            }
+            const source = ts.createSourceFile(file, text, language, true);
+            this.#files.set(key, { source, languageVersion, impliedNodeFormat, jsDocParsingMode });
+            return source;
+        };
+        // Deliberately do not supply oldProgram: package metadata, missing lookups,
+        // module/type/lib resolutions and directory existence must be current.
+        const program = ts.createProgram({ rootNames, options, host });
+        const retained = new Set();
+        for (const source of program.getSourceFiles()) {
+            retained.add(host.getCanonicalFileName(resolve(source.fileName)));
+        }
+        for (const file of this.#files.keys()) {
+            if (!retained.has(file)) {
+                this.#files.delete(file);
+            }
+        }
+        return program;
+    }
+}

package/node/src/generation/emit.d.ts

@@ -0,0 +1,3 @@
+import { type Declaration, type Sources } from "./sources.js";
+export declare function specifier(from: string, file: string): string;
+export declare function emit(sources: Sources, selected: ReadonlyMap<string, Declaration>): Map<string, string>;

package/node/src/generation/files.d.ts

@@ -0,0 +1,26 @@
+export declare const markers: {
+    readonly "routes.generated.ts": "// @loozo/angular-router routegen: owned routes.generated.ts";
+    readonly "destinations.generated.ts": "// @loozo/angular-router routegen: owned destinations.generated.ts";
+    readonly "route.generated.ts": "// @loozo/angular-router routegen: owned route.generated.ts";
+};
+export declare const launchMarkers: {
+    readonly "rpc.generated.ts": "// @loozo/angular-launch: owned rpc.generated.ts";
+    readonly "context.generated.d.ts": "// @loozo/angular-launch: owned context.generated.d.ts";
+    readonly "server.generated.ts": "// @loozo/angular-launch: owned server.generated.ts";
+};
+export declare function contains(directory: string, file: string): boolean;
+export declare function metadata(path: string): Promise<import("fs").Stats | undefined>;
+export declare function workspacePaths(workspace: string): Promise<{
+    canonical: string;
+    resolve(path: string, directory?: boolean): string;
+}>;
+export declare function auditPath(path: string): Promise<void>;
+export declare function walk(directory: string): Promise<string[]>;
+export interface OutputPlan {
+    changed: string[];
+    missing: string[];
+    stale: string[];
+    desired: ReadonlyMap<string, string>;
+}
+export declare function planOutputs(desired: ReadonlyMap<string, string>, encountered: readonly string[], globals: readonly string[], mode?: "router-and-launch"): Promise<OutputPlan>;
+export declare function publish(plan: OutputPlan, check: boolean, stopped: () => boolean, authored: ReadonlyMap<string, string>, seeds: ReadonlySet<string>): void;

package/node/src/generation/files.js

@@ -6,6 +6,11 @@ export const markers = {
     "destinations.generated.ts": "// @loozo/angular-router routegen: owned destinations.generated.ts",
     "route.generated.ts": "// @loozo/angular-router routegen: owned route.generated.ts",
 };
+export const launchMarkers = {
+    "rpc.generated.ts": "// @loozo/angular-launch: owned rpc.generated.ts",
+    "context.generated.d.ts": "// @loozo/angular-launch: owned context.generated.d.ts",
+    "server.generated.ts": "// @loozo/angular-launch: owned server.generated.ts",
+};
 export function contains(directory, file) {
     const suffix = relative(directory, file);
     return (suffix === "" || (!isAbsolute(suffix) && suffix !== ".." && !suffix.startsWith(`..${sep}`)));
@@ -110,13 +115,15 @@ export async function walk(directory) {
     await visit(directory);
     return result;
 }
-export async function planOutputs(desired, encountered, globals) {
+export async function planOutputs(desired, encountered, globals, mode) {
     const changed = [];
     const missing = [];
     const stale = [];
     const possible = new Set([...desired.keys(), ...globals]);
     for (const path of encountered) {
-        if (path.endsWith(`${sep}route.generated.ts`)) {
+        if (path.endsWith(`${sep}route.generated.ts`) ||
+            (mode === "router-and-launch" &&
+                Object.keys(launchMarkers).some((name) => path.endsWith(`${sep}${name}`)))) {
             possible.add(path);
         }
     }
@@ -134,8 +141,12 @@ export async function planOutputs(desired, encountered, globals) {
             throw new Error(`Generated output is not a regular file: ${path}`);
         }
         const bytes = await readFile(path, "utf8");
+        const ownership = { ...markers };
+        if (mode === "router-and-launch") {
+            Object.assign(ownership, launchMarkers);
+        }
         const name = path.slice(path.lastIndexOf(sep) + 1);
-        const owned = bytes.split("\n", 1)[0] === markers[name];
+        const owned = bytes.split("\n", 1)[0] === ownership[name];
         if (!owned) {
             if (expected !== undefined) {
                 throw new Error(`Unmarked generated-output collision: ${path}`);

package/node/src/generation/filesystem.d.ts

@@ -0,0 +1,7 @@
+import ts from "typescript";
+import { type Declaration } from "./sources.js";
+export interface AutoDefineRoutes {
+    filename?: string;
+}
+export declare function transparent(root: string, directory: string): boolean;
+export declare function synchronize(root: string, declarations: readonly Declaration[], pages: ReadonlyMap<string, string>, options: ts.CompilerOptions, { filename }: AutoDefineRoutes, checker: ts.TypeChecker): Promise<Map<string, string>>;

package/node/src/generation/generate.d.ts

@@ -0,0 +1,16 @@
+import type { AutoDefineRoutes } from "./filesystem.js";
+import type { CompilerState } from "./compiler.js";
+import type { AnchorState } from "./anchor.js";
+export interface GenerationOptions {
+    tsconfig: string;
+    scanDirectories: string[];
+    outDirectory: string;
+    check?: boolean;
+    autoDefineRoutes?: AutoDefineRoutes;
+}
+export interface GenerationState {
+    discovery: CompilerState;
+    overlay: CompilerState;
+    anchor: AnchorState;
+}
+export declare function generate(workspace: string, options: GenerationOptions, stopped: () => boolean, state?: GenerationState): Promise<void>;

package/node/src/generation/generate.js

@@ -1,10 +1,10 @@
 import { resolve } from "node:path";
 import { discover } from "./sources.js";
-import { selections, validateProgram } from "./validate.js";
+import { createValidationProgram, selections, validateRoutes } from "./validate.js";
 import { emit } from "./emit.js";
 import { auditPath, metadata, planOutputs, publish, walk } from "./files.js";
-export async function generate(workspace, options, stopped) {
-    const sources = await discover(workspace, options.tsconfig, options.scanDirectories, options.outDirectory, options.autoDefineRoutes);
+export async function generate(workspace, options, stopped, state) {
+    const sources = await discover(workspace, options.tsconfig, options.scanDirectories, options.outDirectory, options.autoDefineRoutes, undefined, undefined, undefined, state?.discovery);
     const selected = selections(sources);
     const desired = emit(sources, selected);
     const globalFiles = [
@@ -25,6 +25,7 @@ export async function generate(workspace, options, stopped) {
             throw new Error(`Filesystem definition is not a regular file: ${file}`);
         }
     }
-    await validateProgram(sources, desired, plan.stale);
+    const validation = createValidationProgram(sources, desired, plan.stale, state?.overlay);
+    await validateRoutes(sources, desired, validation, state?.anchor);
     publish(plan, options.check === true, stopped, sources.authored, seeds);
 }

package/node/src/generation/index.d.ts

@@ -0,0 +1,16 @@
+import type { CompilerState } from "./compiler.js";
+export declare function prepareLaunchRoutes(workspace: string, options: {
+    tsconfig: string;
+    scanDirectories: string[];
+    outDirectory: string;
+}, typeEntry: string, compiler?: CompilerState): Promise<{
+    sources: import("./sources.js").Sources;
+    desired: Map<string, string>;
+}>;
+export { CompilerState } from "./compiler.js";
+export { AnchorState } from "./anchor.js";
+export { createValidationProgram, validateRoutes } from "./validate.js";
+export { planOutputs, publish, walk, auditPath, launchMarkers } from "./files.js";
+export { fail, properties, namedImport, genuineImport } from "./sources.js";
+export { specifier } from "./emit.js";
+export type { Sources, Declaration, LaunchDeclaration } from "./sources.js";

package/node/src/generation/index.js

@@ -0,0 +1,15 @@
+// Closed integration seam for @loozo/angular-launch. Node-only, not a plugin API.
+import { discover } from "./sources.js";
+import { selections } from "./validate.js";
+import { emit } from "./emit.js";
+export async function prepareLaunchRoutes(workspace, options, typeEntry, compiler) {
+    const sources = await discover(workspace, options.tsconfig, options.scanDirectories, options.outDirectory, undefined, new Map(), false, { typeEntry }, compiler);
+    const desired = emit(sources, selections(sources));
+    return { sources, desired };
+}
+export { CompilerState } from "./compiler.js";
+export { AnchorState } from "./anchor.js";
+export { createValidationProgram, validateRoutes } from "./validate.js";
+export { planOutputs, publish, walk, auditPath, launchMarkers } from "./files.js";
+export { fail, properties, namedImport, genuineImport } from "./sources.js";
+export { specifier } from "./emit.js";

package/node/src/generation/overlay.d.ts

@@ -0,0 +1,3 @@
+import ts from "typescript";
+export declare function overlayHost(options: ts.CompilerOptions, authored: ReadonlyMap<string, string>): ts.CompilerHost;
+export declare function overlayDirectory(authored: ReadonlyMap<string, string>, resolveDirectory: (directory: string) => string): ts.ParseConfigHost["readDirectory"];

package/node/src/generation/selectors.d.ts

@@ -0,0 +1,2 @@
+import type { Declaration, Sources } from "./sources.js";
+export declare function relativeSelections(sources: Sources, selected: ReadonlyMap<string, Declaration>): Map<string, Map<string, string>>;

package/node/src/generation/sources.d.ts

@@ -0,0 +1,50 @@
+import ts from "typescript";
+import { type Segment } from "../../_core/src/path.js";
+import type { CompilerState } from "./compiler.js";
+import { type AutoDefineRoutes } from "./filesystem.js";
+export interface Declaration {
+    file: string;
+    id: string;
+    source: ts.SourceFile;
+    rawText: string;
+    config: Map<string, ts.Expression>;
+    path: string;
+    segments: readonly Segment[];
+    effective: readonly Segment[];
+    parent?: Declaration;
+    target?: Declaration;
+    children: Declaration[];
+    page?: string;
+    retained: boolean;
+    full: boolean;
+}
+export interface LaunchDeclaration {
+    file: string;
+    kind: "defineContext" | "defineRpc";
+    call: ts.CallExpression;
+}
+export interface LaunchMode {
+    typeEntry: string;
+}
+export interface Sources {
+    configFile: string;
+    parsed: ts.ParsedCommandLine;
+    roots: string[];
+    output: string;
+    encountered: string[];
+    declarations: Declaration[];
+    factoryEntry: string;
+    deferredFactories: Declaration[];
+    authored: ReadonlyMap<string, string>;
+    filesystem: boolean;
+    launch?: {
+        typeEntry: string;
+        declarations: LaunchDeclaration[];
+    };
+}
+export declare function fail(node: ts.Node, message: string): never;
+export declare function properties(node: ts.Expression, label: string): Map<string, ts.Expression>;
+export declare function resolveModule(name: string, source: string, options: ts.CompilerOptions, host?: ts.ModuleResolutionHost): string | undefined;
+export declare function namedImport(source: ts.SourceFile, name: ts.Expression, imported: string): ts.ImportDeclaration | undefined;
+export declare function genuineImport(statement: ts.ImportDeclaration, expected: string, options: ts.CompilerOptions, host?: ts.ModuleResolutionHost): Promise<boolean>;
+export declare function discover(workspace: string, config: string, scans: readonly string[], out: string, auto?: AutoDefineRoutes, authored?: ReadonlyMap<string, string>, filesystem?: boolean, launch?: LaunchMode, compiler?: CompilerState): Promise<Sources>;

package/node/src/generation/sources.js

@@ -41,7 +41,7 @@ export function properties(node, label) {
 export function resolveModule(name, source, options, host = ts.sys) {
     return ts.resolveModuleName(name, source, options, host).resolvedModule?.resolvedFileName;
 }
-function namedImport(source, name, imported) {
+export function namedImport(source, name, imported) {
     if (!ts.isIdentifier(name)) {
         return undefined;
     }
@@ -90,7 +90,7 @@ function moduleText(statement) {
     }
     return statement.moduleSpecifier.text;
 }
-async function genuineImport(statement, expected, options, host = ts.sys) {
+export async function genuineImport(statement, expected, options, host = ts.sys) {
     const actual = resolveModule(moduleText(statement), statement.getSourceFile().fileName, options, host);
     if (!actual) {
         return false;
@@ -172,7 +172,7 @@ const keys = new Set([
     "title",
     "data",
 ]);
-export async function discover(workspace, config, scans, out, auto, authored = new Map(), filesystem = auto !== undefined) {
+export async function discover(workspace, config, scans, out, auto, authored = new Map(), filesystem = auto !== undefined, launch, compiler) {
     if (scans.length !== 1) {
         throw new Error("scanDirectories must contain exactly one directory");
     }
@@ -223,7 +223,7 @@ export async function discover(workspace, config, scans, out, auto, authored = n
             continue;
         }
         await auditPath(normalized);
-        if (contains(root, normalized)) {
+        if (launch || contains(root, normalized)) {
             candidates.push(normalized);
         }
     }
@@ -233,14 +233,22 @@ export async function discover(workspace, config, scans, out, auto, authored = n
     const manifest = JSON.parse(manifestBytes);
     const factoryEntry = await realpath(resolve(packageRoot, manifest.exports["."].types));
     const declarations = [];
+    const launchDeclarations = [];
+    const launchEntry = launch && (await realpath(launch.typeEntry));
     const pages = new Map();
     const deferredFactories = [];
     const syntaxHost = overlayHost(parsed.options, authored);
-    const syntaxProgram = ts.createProgram({
-        rootNames: candidates,
-        options: parsed.options,
-        host: syntaxHost,
-    });
+    let syntaxProgram;
+    if (compiler) {
+        syntaxProgram = compiler.createProgram(candidates, parsed.options, syntaxHost);
+    }
+    else {
+        syntaxProgram = ts.createProgram({
+            rootNames: candidates,
+            options: parsed.options,
+            host: syntaxHost,
+        });
+    }
     for (const file of candidates) {
         const bytes = syntaxHost.readFile(file);
         if (bytes === undefined) {
@@ -281,6 +289,33 @@ export async function discover(workspace, config, scans, out, auto, authored = n
             fail(defaults[1], "Multiple competing default exports");
         }
         const node = defaults[0];
+        const inRoutes = contains(root, file);
+        if (launchEntry && ts.isExportAssignment(node) && ts.isCallExpression(node.expression)) {
+            const call = node.expression;
+            let kind;
+            let imported = namedImport(source, call.expression, "defineContext");
+            if (imported) {
+                kind = "defineContext";
+            }
+            else if (inRoutes) {
+                imported = namedImport(source, call.expression, "defineRpc");
+                if (imported) {
+                    kind = "defineRpc";
+                }
+            }
+            if (kind && imported) {
+                if (!(await genuineImport(imported, launchEntry, parsed.options, syntaxHost))) {
+                    fail(imported, `${kind} must resolve to Launch's concrete server entry`);
+                }
+                launchDeclarations.push({ file, kind, call });
+                continue;
+            }
+        }
+        // Context is audited over all application roots; unrelated bootstrap defaults
+        // outside route scans are not route declarations.
+        if (!inRoutes) {
+            continue;
+        }
         if (ts.isClassDeclaration(node)) {
             await component(source, node, parsed.options);
             if (pages.has(dirname(file))) {
@@ -363,7 +398,7 @@ export async function discover(workspace, config, scans, out, auto, authored = n
     }
     if (auto) {
         const edits = await synchronize(roots[0], declarations, pages, parsed.options, auto, syntaxProgram.getTypeChecker());
-        return discover(workspace, config, scans, out, undefined, edits, true);
+        return discover(workspace, config, scans, out, undefined, edits, true, launch, compiler);
     }
     if (filesystem) {
         for (let index = declarations.length - 1; index >= 0; index -= 1) {
@@ -519,6 +554,10 @@ export async function discover(workspace, config, scans, out, auto, authored = n
             fail(declaration.source, "Factory facade is not a final retained generated location");
         }
     }
+    let launchSources;
+    if (launchEntry) {
+        launchSources = { typeEntry: launchEntry, declarations: launchDeclarations };
+    }
     return {
         configFile,
         parsed,
@@ -530,5 +569,6 @@ export async function discover(workspace, config, scans, out, auto, authored = n
         deferredFactories,
         authored,
         filesystem,
+        launch: launchSources,
     };
 }

package/node/src/generation/validate.d.ts

@@ -0,0 +1,12 @@
+import ts from "typescript";
+import { type Declaration, type Sources } from "./sources.js";
+import type { CompilerState } from "./compiler.js";
+import { AnchorState } from "./anchor.js";
+export declare function authoredPath(declaration: Declaration): string;
+export declare function selections(sources: Sources): Map<string, Declaration>;
+export declare function createValidationProgram(sources: Sources, generated: ReadonlyMap<string, string>, stale: readonly string[], compiler?: CompilerState): {
+    program: ts.Program;
+    host: ts.CompilerHost;
+    obsolete: Set<string>;
+};
+export declare function validateRoutes(sources: Sources, generated: ReadonlyMap<string, string>, validation: ReturnType<typeof createValidationProgram>, canonical?: AnchorState): Promise<void>;

package/node/src/generation/validate.js

@@ -4,6 +4,7 @@ import { basename, dirname, resolve, sep } from "node:path";
 import { auditPath, contains } from "./files.js";
 import { fail, properties, resolveModule } from "./sources.js";
 import { overlayHost } from "./overlay.js";
+import { AnchorState } from "./anchor.js";
 export function authoredPath(declaration) {
     const parts = [];
     for (const segment of declaration.effective) {
@@ -111,9 +112,13 @@ export function selections(sources) {
     }
     return result;
 }
-// Overlay only the final generated locations. Never evaluate application code.
-export async function validateProgram(sources, generated, stale) {
-    const host = overlayHost(sources.parsed.options, sources.authored);
+// Overlay only final generated locations. Never evaluate application code.
+export function createValidationProgram(sources, generated, stale, compiler) {
+    const options = { ...sources.parsed.options };
+    if (sources.launch) {
+        options.skipLibCheck = false;
+    }
+    const host = overlayHost(options, sources.authored);
     const originalRead = host.readFile.bind(host);
     const originalExists = host.fileExists.bind(host);
     const originalDirectoryExists = host.directoryExists.bind(host);
@@ -141,14 +146,24 @@ export async function validateProgram(sources, generated, stale) {
         }
         return ts.createSourceFile(file, text, language, true);
     };
-    const program = ts.createProgram({
-        rootNames: [
-            ...sources.parsed.fileNames.filter((file) => !obsolete.has(resolve(file))),
-            sources.factoryEntry,
-        ],
-        options: sources.parsed.options,
-        host,
-    });
+    const rootNames = [
+        ...sources.parsed.fileNames.filter((file) => !obsolete.has(resolve(file))),
+        sources.factoryEntry,
+    ];
+    if (sources.launch) {
+        rootNames.push(sources.launch.typeEntry, ...generated.keys());
+    }
+    let program;
+    if (compiler) {
+        program = compiler.createProgram(rootNames, options, host);
+    }
+    else {
+        program = ts.createProgram({ rootNames, options, host });
+    }
+    return { program, host, obsolete };
+}
+export async function validateRoutes(sources, generated, validation, canonical) {
+    const { program, host, obsolete } = validation;
     if (sources.filesystem) {
         const diagnostics = [];
         for (const declaration of sources.declarations) {
@@ -176,20 +191,8 @@ export async function validateProgram(sources, generated, stale) {
     // Anchor the public export's declaration independently of application paths,
     // which can also redirect imports inside the concrete public type entry.
     const canonicalOptions = { ...sources.parsed.options, paths: undefined, baseUrl: undefined };
-    const canonicalProgram = ts.createProgram({
-        rootNames: [sources.factoryEntry],
-        options: canonicalOptions,
-        host: ts.createCompilerHost(canonicalOptions, true),
-    });
-    const canonicalChecker = canonicalProgram.getTypeChecker();
-    const canonicalEntry = canonicalProgram.getSourceFile(sources.factoryEntry);
-    const canonicalModule = canonicalChecker.getSymbolAtLocation(canonicalEntry);
-    let canonicalFactory = canonicalChecker
-        .getExportsOfModule(canonicalModule)
-        .find((symbol) => symbol.name === "defineRoute");
-    if (canonicalFactory.flags & ts.SymbolFlags.Alias) {
-        canonicalFactory = canonicalChecker.getAliasedSymbol(canonicalFactory);
-    }
+    const anchor = await (canonical ?? new AnchorState()).anchor(sources.factoryEntry, ["defineRoute"], canonicalOptions);
+    const canonicalFactory = anchor.get("defineRoute");
     // Tentative own-facade admission is not authority for its re-exported binding.
     // Prove both the concrete module boundary and the final native alias identity.
     for (const declaration of sources.declarations) {
@@ -215,17 +218,14 @@ export async function validateProgram(sources, generated, stale) {
         }
         if (!actualFactory?.declarations?.length ||
             actualFactory !== concreteFactory ||
-            actualFactory.declarations.length !== canonicalFactory.declarations?.length) {
+            actualFactory.declarations.length !== canonicalFactory?.length) {
             fail(call, "Factory binding does not resolve to the concrete defineRoute export");
         }
         for (let index = 0; index < actualFactory.declarations.length; index += 1) {
             const actual = actualFactory.declarations[index];
-            const canonical = canonicalFactory.declarations[index];
-            const [actualFile, canonicalFile] = await Promise.all([
-                realpath(actual.getSourceFile().fileName),
-                realpath(canonical.getSourceFile().fileName),
-            ]);
-            if (actualFile !== canonicalFile ||
+            const canonical = canonicalFactory[index];
+            const actualFile = await realpath(actual.getSourceFile().fileName);
+            if (actualFile !== canonical.file ||
                 actual.kind !== canonical.kind ||
                 actual.pos !== canonical.pos ||
                 actual.end !== canonical.end) {
@@ -237,6 +237,10 @@ export async function validateProgram(sources, generated, stale) {
         resolve(sources.output, "routes.generated.ts"),
         resolve(sources.output, "destinations.generated.ts"),
     ]);
+    if (sources.launch) {
+        globalTargets.add(resolve(sources.output, "context.generated.d.ts"));
+        globalTargets.add(resolve(sources.output, "server.generated.ts"));
+    }
     for (const source of program.getSourceFiles()) {
         if (source.fileName.includes("/node_modules/") ||
             program.isSourceFileFromExternalLibrary(source) ||
@@ -292,7 +296,8 @@ export async function validateProgram(sources, generated, stale) {
                 candidates.add(resolve(file));
             }
             for (const candidate of candidates) {
-                const facadeTarget = basename(candidate) === "route.generated.ts" &&
+                const facadeTarget = (basename(candidate) === "route.generated.ts" ||
+                    (sources.launch && basename(candidate) === "rpc.generated.ts")) &&
                     !candidate.split(sep).includes("node_modules") &&
                     sources.roots.some((root) => contains(root, candidate));
                 if ((facadeTarget || globalTargets.has(candidate)) && !generated.has(candidate)) {