ast-mcp-server 0.15.1 → 0.17.0

package/dist/services/angular-template-scope.js

@@ -0,0 +1,163 @@
+import { Node, SyntaxKind } from "ts-morph";
+import { componentDecorator, isAngularCoreExport, isCoreDecorator } from "./angular-decorators.js";
+export const MAX_SCOPE_VISITS = 10_000;
+export const MAX_SCOPE_DEPTH = 32;
+export class ScopeWorkExhausted extends Error {
+}
+/** Follows aliases to the declarations a node refers to. */
+function declarationsOf(node) {
+    const symbol = node.getSymbol();
+    const resolved = symbol?.isAlias() ? (symbol.getAliasedSymbol() ?? symbol) : symbol;
+    return resolved?.getDeclarations() ?? [];
+}
+const isExternal = (declaration) => declaration.getSourceFile().isFromExternalLibrary();
+function ngModuleMetadata(cls) {
+    const decorator = cls.getDecorators().find((candidate) => isCoreDecorator(candidate, "NgModule"));
+    if (!decorator)
+        return undefined;
+    const metadata = decorator.getArguments()[0];
+    return Node.isObjectLiteralExpression(metadata) ? metadata : "opaque";
+}
+/** Elements of a metadata array: none when the key is absent, `opaque` when not an array literal. */
+function listOf(metadata, key) {
+    const property = metadata.getProperty(key);
+    if (!property)
+        return [];
+    const list = Node.isPropertyAssignment(property) ? property.getInitializer() : undefined;
+    return Node.isArrayLiteralExpression(list) ? list.getElements() : "opaque";
+}
+function merge(results) {
+    if (results.includes("target"))
+        return "target";
+    return results.includes("opaque") ? "opaque" : "other";
+}
+/**
+ * Resolves, with ts-morph only, whether the target is in a consumer's scope. Memoized per
+ * request. Anything that cannot be proven is `opaque`; the caller decides what that costs.
+ */
+export function createScopeResolver(target, options) {
+    const memo = new Map();
+    const tick = () => {
+        if (--options.budget.scopeVisits < 0)
+            throw new ScopeWorkExhausted();
+        options.rc.checkpoint();
+    };
+    const referenceOf = (expression) => {
+        tick();
+        if (Node.isCallExpression(expression)) {
+            const callee = expression.getExpression();
+            const [arrow] = expression.getArguments();
+            if (isAngularCoreExport(callee, "forwardRef")) {
+                return Node.isArrowFunction(arrow) && !Node.isBlock(arrow.getBody())
+                    ? referenceOf(arrow.getBody())
+                    : "opaque";
+            }
+            let root = callee;
+            while (Node.isPropertyAccessExpression(root))
+                root = root.getExpression();
+            // A library cannot export project classes, so its calls never add the target.
+            const declarations = Node.isIdentifier(root) ? declarationsOf(root) : [];
+            return declarations.length > 0 && declarations.every(isExternal) ? "external" : "opaque";
+        }
+        if (!Node.isIdentifier(expression))
+            return "opaque";
+        const declarations = declarationsOf(expression);
+        const [declaration] = declarations;
+        if (declarations.length !== 1 || !Node.isClassDeclaration(declaration))
+            return "opaque";
+        return isExternal(declaration) ? "external" : declaration;
+    };
+    /** What an element of `imports` / `exports` makes visible: itself, or a module's exports. */
+    const contribution = (expression, trail, depth) => {
+        const reference = referenceOf(expression);
+        if (reference === "external")
+            return "other";
+        if (reference === "opaque")
+            return "opaque";
+        if (reference === target)
+            return "target";
+        const metadata = ngModuleMetadata(reference);
+        if (!metadata)
+            return "other";
+        if (trail.has(reference))
+            return "other";
+        if (depth > MAX_SCOPE_DEPTH || metadata === "opaque")
+            return "opaque";
+        if (reference.getSourceFile().isDeclarationFile())
+            return "opaque";
+        trail.add(reference);
+        const exported = listOf(metadata, "exports");
+        if (exported === "opaque")
+            return "opaque";
+        return merge(exported.map((element) => contribution(element, trail, depth + 1)));
+    };
+    const scopeOf = (imports, trail) => merge(imports.map((element) => contribution(element, trail, 1)));
+    const verdictOf = (found) => found === "target" ? "includes" : found === "opaque" ? "opaque" : "excludes";
+    let declaring;
+    /** Every project NgModule with the classes it declares; built once, on first module consumer. */
+    const declaringModules = () => {
+        if (declaring)
+            return declaring;
+        declaring = { modules: [], opaque: false };
+        const classes = target
+            .getProject()
+            .getSourceFiles()
+            .filter((file) => !file.isDeclarationFile() &&
+            !file.isFromExternalLibrary() &&
+            file.getFullText().includes("NgModule"))
+            .flatMap((file) => file.getDescendantsOfKind(SyntaxKind.ClassDeclaration));
+        for (const cls of classes) {
+            const metadata = ngModuleMetadata(cls);
+            if (!metadata)
+                continue;
+            const list = metadata === "opaque" ? "opaque" : listOf(metadata, "declarations");
+            const references = list === "opaque" ? [] : list.map(referenceOf);
+            if (metadata === "opaque" || list === "opaque" || references.includes("opaque")) {
+                declaring.opaque = true;
+                continue;
+            }
+            declaring.modules.push({
+                metadata,
+                declared: new Set(references.filter((reference) => typeof reference !== "string")),
+            });
+        }
+        return declaring;
+    };
+    const resolve = (consumer) => {
+        if (consumer === target)
+            return "includes";
+        const metadata = componentDecorator(consumer)?.getArguments()[0];
+        if (!Node.isObjectLiteralExpression(metadata))
+            return "opaque";
+        const flag = metadata.getProperty("standalone");
+        const initializer = Node.isPropertyAssignment(flag) ? flag.getInitializer() : undefined;
+        if (flag && !Node.isTrueLiteral(initializer) && !Node.isFalseLiteral(initializer)) {
+            return "opaque";
+        }
+        const standalone = flag
+            ? Node.isTrueLiteral(initializer)
+            : options.coreMajor !== undefined && options.coreMajor >= 19;
+        const trail = new Set();
+        if (!standalone) {
+            if (!flag && options.coreMajor === undefined)
+                return "opaque";
+            const { modules, opaque } = declaringModules();
+            const owners = modules.filter((module) => module.declared.has(consumer));
+            if (opaque || owners.length !== 1)
+                return "opaque";
+            const [owner] = owners;
+            if (owner.declared.has(target))
+                return "includes";
+            const imports = listOf(owner.metadata, "imports");
+            return imports === "opaque" ? "opaque" : verdictOf(scopeOf(imports, trail));
+        }
+        const imports = listOf(metadata, "imports");
+        return imports === "opaque" ? "opaque" : verdictOf(scopeOf(imports, trail));
+    };
+    return (consumer) => {
+        let verdict = memo.get(consumer);
+        if (!verdict)
+            memo.set(consumer, (verdict = resolve(consumer)));
+        return verdict;
+    };
+}

package/dist/services/angular-template-typecheck-core.js

@@ -0,0 +1,139 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { MAX_MESSAGE_CHARS, } from "./angular-template-typecheck-protocol.js";
+/** Loads the TypeScript that ngtsc itself resolves, then the pre-validated compiler-cli entry. */
+export async function loadToolchain(cliEntry) {
+    const tsEntry = createRequire(cliEntry).resolve("typescript");
+    const ts = (await import(pathToFileURL(tsEntry).href)).default;
+    const cli = (await import(pathToFileURL(cliEntry).href));
+    return { ts, cli };
+}
+/** True when the public surface this driver needs is present (never touches `private/*`). */
+export function probeCompilerApi(cli) {
+    return (typeof cli.NgtscProgram === "function" &&
+        typeof cli.readConfiguration === "function" &&
+        typeof cli.createCompilerHost === "function" &&
+        typeof cli.NgtscProgram.prototype?.getNgSemanticDiagnostics === "function");
+}
+/** Forces the options that make an emit or a build-info write impossible. */
+export function withNoEmit(options) {
+    return {
+        ...options,
+        noEmit: true,
+        incremental: false,
+        composite: false,
+        tsBuildInfoFile: undefined,
+    };
+}
+/** Scope B: an edited template or a scoped component file, never anything under node_modules. */
+export function isInScope(fileName, scopeFiles) {
+    return scopeFiles.has(fileName) && !fileName.split(/[\\/]/u).includes("node_modules");
+}
+export function toWireDiagnostic(ts, root, diagnostic) {
+    const { file } = diagnostic;
+    const start = diagnostic.start ?? null;
+    const position = file && start !== null ? file.getLineAndCharacterOfPosition(start) : null;
+    return {
+        code: diagnostic.code,
+        category: ts.DiagnosticCategory[diagnostic.category] ?? String(diagnostic.category),
+        file: file ? path.relative(root, file.fileName) : "",
+        line: position ? position.line + 1 : null,
+        column: position ? position.character + 1 : null,
+        message: ts
+            .flattenDiagnosticMessageText(diagnostic.messageText, "\n")
+            .slice(0, MAX_MESSAGE_CHARS),
+        start,
+        length: diagnostic.length ?? null,
+    };
+}
+/**
+ * Host over the disk with an optional in-memory overlay. Unchanged files come from one cache
+ * shared by both runs, so the after run reuses the identical SourceFile objects and only parses
+ * overlay files again.
+ */
+function createCheckHost({ ts, cli }, options, overlay, shared) {
+    const tsHost = ts.createCompilerHost(options, true);
+    const { readFile, fileExists, getSourceFile } = tsHost;
+    const fresh = new Map();
+    tsHost.writeFile = () => {
+        throw new Error("The template type check must not write files.");
+    };
+    tsHost.readFile = (name) => overlay?.get(name) ?? readFile.call(tsHost, name);
+    tsHost.fileExists = (name) => overlay?.has(name) === true || fileExists.call(tsHost, name);
+    tsHost.getSourceFile = (name, languageVersion, ...rest) => {
+        const text = overlay?.get(name);
+        if (text !== undefined) {
+            if (!fresh.has(name))
+                fresh.set(name, ts.createSourceFile(name, text, languageVersion, true));
+            return fresh.get(name);
+        }
+        if (!shared.has(name)) {
+            shared.set(name, getSourceFile.call(tsHost, name, languageVersion, ...rest));
+        }
+        return shared.get(name);
+    };
+    const ngHost = cli.createCompilerHost({ options, tsHost });
+    if (overlay) {
+        // With `oldProgram` reuse ngtsc re-analyzes a component only if it is told which resources changed.
+        const resources = new Set([...overlay.keys()].filter((name) => !/\.[cm]?tsx?$/u.test(name)));
+        ngHost.getModifiedResourceFiles = () => resources;
+    }
+    return ngHost;
+}
+async function checkSide(toolchain, config, request, overlay, shared, oldProgram) {
+    const host = createCheckHost(toolchain, config.options, overlay, shared);
+    const program = new toolchain.cli.NgtscProgram(config.rootNames, config.options, host, oldProgram);
+    await program.loadNgStructureAsync();
+    const compiler = program.compiler;
+    if (typeof compiler?.getComponentsWithTemplateFile !== "function")
+        return "unsupported";
+    const scope = new Set(request.templates);
+    for (const template of request.templates) {
+        for (const component of compiler.getComponentsWithTemplateFile(template)) {
+            scope.add(component.getSourceFile().fileName);
+        }
+    }
+    const root = path.dirname(request.tsconfig);
+    const diagnostics = program
+        .getNgSemanticDiagnostics()
+        .filter((diagnostic) => diagnostic.file && isInScope(diagnostic.file.fileName, scope))
+        .map((diagnostic) => toWireDiagnostic(toolchain.ts, root, diagnostic));
+    return { program, diagnostics };
+}
+const fail = (reason) => ({
+    v: 1,
+    ok: false,
+    reason,
+});
+/** Runs ngtsc on the disk state, then on disk plus overlay, and returns both scoped lists. */
+export async function runTemplateTypeCheck(request, load = loadToolchain) {
+    try {
+        const toolchain = await load(request.cliEntry);
+        if (!probeCompilerApi(toolchain.cli))
+            return fail("compiler_unsupported");
+        const read = toolchain.cli.readConfiguration(request.tsconfig);
+        if (read.errors.length > 0)
+            return fail("check_failed");
+        const config = { options: withNoEmit(read.options), rootNames: read.rootNames };
+        const shared = new Map();
+        const overlay = new Map(request.overlay.map((file) => [file.absolutePath, file.text]));
+        const before = await checkSide(toolchain, config, request, undefined, shared, undefined);
+        if (before === "unsupported")
+            return fail("compiler_unsupported");
+        if (before.diagnostics.length > request.maxDiagnostics)
+            return fail("work_exhausted");
+        const after = await checkSide(toolchain, config, request, overlay, shared, before.program);
+        if (after === "unsupported")
+            return fail("compiler_unsupported");
+        if (after.diagnostics.length > request.maxDiagnostics)
+            return fail("work_exhausted");
+        return { v: 1, ok: true, before: before.diagnostics, after: after.diagnostics };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "";
+        return fail(message.startsWith("The Angular Compiler requires TypeScript")
+            ? "typescript_incompatible"
+            : "check_failed");
+    }
+}

package/dist/services/angular-template-typecheck-protocol.js

@@ -0,0 +1,75 @@
+import path from "node:path";
+import { z } from "zod";
+/** Caps shared by both ends of the one-shot IPC channel (v1). */
+export const MAX_WIRE_DIAGNOSTICS = 5000;
+export const MAX_OVERLAY_BYTES = 32 * 1024 * 1024;
+export const MAX_TEMPLATES = 2000;
+export const MAX_OVERLAY_FILES = 10_000;
+const MAX_PATH_CHARS = 4096;
+export const MAX_MESSAGE_CHARS = 8192;
+const absolutePath = z
+    .string()
+    .max(MAX_PATH_CHARS)
+    .refine((value) => path.isAbsolute(value), "must be an absolute path");
+export const RequestSchema = z
+    .object({
+    v: z.literal(1),
+    tsconfig: absolutePath,
+    cliEntry: absolutePath,
+    templates: z.array(absolutePath).max(MAX_TEMPLATES),
+    overlay: z
+        .array(z.object({ absolutePath, text: z.string() }).strict())
+        .max(MAX_OVERLAY_FILES)
+        .refine((files) => files.reduce((total, file) => total + Buffer.byteLength(file.text, "utf8"), 0) <=
+        MAX_OVERLAY_BYTES, "overlay exceeds the byte cap"),
+    maxDiagnostics: z.number().int().min(1).max(MAX_WIRE_DIAGNOSTICS),
+})
+    .strict();
+const position = z.number().int().nonnegative().nullable();
+export const WireDiagnosticSchema = z
+    .object({
+    code: z.number().int(),
+    category: z.string().max(32),
+    /** Project-relative path. */
+    file: z.string().max(MAX_PATH_CHARS),
+    line: position,
+    column: position,
+    message: z.string().max(MAX_MESSAGE_CHARS),
+    start: position,
+    length: position,
+})
+    .strict();
+/** Only a successful reply carries diagnostics, so a non-completed status can never include any. */
+export const ResponseSchema = z.discriminatedUnion("ok", [
+    z
+        .object({
+        v: z.literal(1),
+        ok: z.literal(true),
+        before: z.array(WireDiagnosticSchema).max(MAX_WIRE_DIAGNOSTICS),
+        after: z.array(WireDiagnosticSchema).max(MAX_WIRE_DIAGNOSTICS),
+    })
+        .strict(),
+    z
+        .object({
+        v: z.literal(1),
+        ok: z.literal(false),
+        reason: z.enum([
+            "compiler_unsupported",
+            "typescript_incompatible",
+            "work_exhausted",
+            "check_failed",
+        ]),
+    })
+        .strict(),
+]);
+/** Separates an over-cap reply (work bound) from a malformed one (check failure). */
+export function parseResponse(value) {
+    if (typeof value === "object" && value !== null) {
+        const { before, after } = value;
+        const oversizedSide = (side) => Array.isArray(side) && side.length > MAX_WIRE_DIAGNOSTICS;
+        if (oversizedSide(before) || oversizedSide(after))
+            return { status: "oversized" };
+    }
+    const parsed = ResponseSchema.safeParse(value);
+    return parsed.success ? { status: "valid", response: parsed.data } : { status: "malformed" };
+}

package/dist/services/angular-template-typecheck.js

@@ -0,0 +1,262 @@
+import { fork } from "node:child_process";
+import { readFileSync, realpathSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { isSupportedVersion, isUnderAncestorNodeModules, isWithin, rangeVerdict, resolveFrom, } from "./angular-package-resolution.js";
+import { MAX_OVERLAY_BYTES, MAX_OVERLAY_FILES, MAX_TEMPLATES, MAX_WIRE_DIAGNOSTICS, parseResponse, } from "./angular-template-typecheck-protocol.js";
+import { compareObservedDiagnostics, } from "./diagnostics.js";
+import { NO_REQUEST_CONTEXT, RequestContextError } from "./request-context.js";
+const UNSUPPORTED = { ok: false, reason: "compiler_unsupported" };
+/** Locates an installed package through the shared guard, or reports why it cannot be trusted. */
+function locatePackage(tsConfigFilePath, name, projectDir) {
+    const manifestPath = resolveFrom(tsConfigFilePath, `${name}/package.json`);
+    if (!manifestPath) {
+        try {
+            createRequire(tsConfigFilePath).resolve(`${name}/package.json`);
+        }
+        catch (error) {
+            if (error.code === "MODULE_NOT_FOUND")
+                return "missing";
+        }
+        return "unsupported";
+    }
+    try {
+        const dir = realpathSync(path.dirname(manifestPath));
+        if (!isUnderAncestorNodeModules(dir, projectDir))
+            return "unsupported";
+        const manifest = JSON.parse(readFileSync(path.join(dir, "package.json"), "utf8"));
+        return manifest?.name === name ? { dir, manifest } : "unsupported";
+    }
+    catch {
+        return "unsupported";
+    }
+}
+function majorOf(version) {
+    return Number(String(version).split(".")[0]);
+}
+/** In-process checks before any spawn; TypeScript is resolved from the compiler-cli, as ngtsc does. */
+export function preflightTemplateTypeCheck(tsConfigFilePath) {
+    let projectDir;
+    try {
+        projectDir = realpathSync(path.dirname(tsConfigFilePath));
+    }
+    catch {
+        return UNSUPPORTED;
+    }
+    const cli = locatePackage(tsConfigFilePath, "@angular/compiler-cli", projectDir);
+    if (cli === "missing")
+        return { ok: false, reason: "compiler_cli_missing" };
+    if (cli === "unsupported")
+        return UNSUPPORTED;
+    const compiler = locatePackage(tsConfigFilePath, "@angular/compiler", projectDir);
+    const core = locatePackage(tsConfigFilePath, "@angular/core", projectDir);
+    if (typeof compiler === "string" || typeof core === "string")
+        return UNSUPPORTED;
+    const version = cli.manifest.version;
+    if (!isSupportedVersion(version) || compiler.manifest.version !== version)
+        return UNSUPPORTED;
+    if (!isSupportedVersion(core.manifest.version) ||
+        majorOf(core.manifest.version) !== majorOf(version)) {
+        return UNSUPPORTED;
+    }
+    const entry = resolveFrom(tsConfigFilePath, "@angular/compiler-cli");
+    let cliEntry;
+    try {
+        cliEntry = entry && realpathSync(entry);
+    }
+    catch {
+        return UNSUPPORTED;
+    }
+    if (!cliEntry || !isWithin(cli.dir, cliEntry))
+        return UNSUPPORTED;
+    const peer = cli.manifest.peerDependencies?.typescript;
+    const typescript = resolveFrom(path.join(cli.dir, "package.json"), "typescript/package.json");
+    if (typeof peer !== "string")
+        return UNSUPPORTED;
+    if (!typescript)
+        return { ok: false, reason: "typescript_incompatible" };
+    let typescriptVersion;
+    try {
+        typescriptVersion = JSON.parse(readFileSync(typescript, "utf8")).version;
+    }
+    catch {
+        return UNSUPPORTED;
+    }
+    const verdict = rangeVerdict(String(typescriptVersion), peer);
+    if (verdict === "unsupported")
+        return UNSUPPORTED;
+    if (verdict === "unsatisfied")
+        return { ok: false, reason: "typescript_incompatible" };
+    return { ok: true, cliDir: cli.dir, cliEntry };
+}
+function emptyDelta(status, reason) {
+    return { status, reason, added: [], removed: [], addedErrors: [] };
+}
+const MAX_CHECK_MS = 30_000;
+const MIN_CHECK_MS = 2_000;
+const RESERVE_MS = 10_000;
+const CHILD_HEAP_MB = 1024;
+const EXIT_SETTLE_MS = 500;
+const OOM_EXIT_CODE = 134;
+const DEFAULT_ENTRY = fileURLToPath(new URL("../angular-template-typecheck-entry.js", import.meta.url));
+const UNBOUNDED_CONTEXT = {
+    signal: NO_REQUEST_CONTEXT.signal,
+    checkpoint: () => NO_REQUEST_CONTEXT.checkpoint(),
+    remainingMs: () => MAX_CHECK_MS + RESERVE_MS,
+};
+/** Time the child may run: capped, and leaving a reserve for the rest of the operation. */
+export function checkBudgetMs(remainingMs) {
+    return Math.min(MAX_CHECK_MS, remainingMs - RESERVE_MS);
+}
+function outcomeOf(code, signal, reply) {
+    if (signal === "SIGABRT" || code === OOM_EXIT_CODE) {
+        return { kind: "reason", reason: "work_exhausted" };
+    }
+    if (code !== 0)
+        return { kind: "reason", reason: "check_failed" };
+    const parsed = parseResponse(reply);
+    if (parsed.status === "valid")
+        return { kind: "reply", response: parsed.response };
+    return {
+        kind: "reason",
+        reason: parsed.status === "oversized" ? "work_exhausted" : "check_failed",
+    };
+}
+/** Runs one child to completion; it is always reaped before this settles. */
+function runChild(request, budgetMs, ctx, deps) {
+    return new Promise((resolve, reject) => {
+        let child;
+        try {
+            child = (deps.spawn ?? fork)(deps.entry ?? DEFAULT_ENTRY, [], {
+                execPath: process.execPath,
+                execArgv: [`--max-old-space-size=${CHILD_HEAP_MB}`],
+                env: {},
+                serialization: "advanced",
+                stdio: ["ignore", "ignore", "ignore", "ipc"],
+            });
+        }
+        catch {
+            return resolve({ kind: "reason", reason: "check_failed" });
+        }
+        let reply;
+        let killedFor;
+        let failed = false;
+        let settled = false;
+        const kill = (why) => {
+            killedFor ??= why;
+            child.kill("SIGKILL");
+        };
+        const settle = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            ctx.signal.removeEventListener("abort", onAbort);
+            if (result instanceof Error)
+                reject(result);
+            else
+                resolve(result);
+        };
+        const onAbort = () => kill("abort");
+        const timer = setTimeout(() => kill("deadline"), budgetMs);
+        ctx.signal.addEventListener("abort", onAbort, { once: true });
+        child.once("message", (message) => {
+            reply = message;
+        });
+        child.once("error", () => {
+            failed = true;
+            // No pid means the spawn itself failed and no exit will follow; otherwise reap first.
+            if (child.pid === undefined)
+                settle({ kind: "reason", reason: "check_failed" });
+            else
+                child.kill("SIGKILL");
+        });
+        child.once("exit", (code, signal) => {
+            const finish = () => {
+                if (killedFor === "abort")
+                    settle(abortError(ctx));
+                else if (killedFor === "deadline")
+                    settle({ kind: "deadline" });
+                else if (failed)
+                    settle({ kind: "reason", reason: "check_failed" });
+                else
+                    settle(outcomeOf(code, signal, reply));
+            };
+            // Pending IPC messages are delivered before the channel reports closed.
+            if (!child.connected)
+                return finish();
+            child.once("disconnect", finish);
+            setTimeout(finish, EXIT_SETTLE_MS).unref();
+        });
+        if (ctx.signal.aborted)
+            return onAbort();
+        child.send(request, () => undefined);
+    });
+}
+function abortError(ctx) {
+    try {
+        ctx.checkpoint();
+    }
+    catch (error) {
+        return error;
+    }
+    return new RequestContextError("REQUEST_CANCELLED");
+}
+function observations(diagnostics) {
+    return diagnostics.map(({ start, length, ...shown }, ordinal) => ({
+        public: {
+            code: shown.code,
+            category: shown.category,
+            file: shown.file,
+            line: shown.line,
+            column: shown.column,
+            message: shown.message,
+        },
+        start,
+        length,
+        ordinal,
+    }));
+}
+function diagnosticsOf(response, changes, ctx) {
+    if (!response.ok) {
+        const reason = response.reason;
+        return emptyDelta(reason === "compiler_unsupported" || reason === "typescript_incompatible"
+            ? "unavailable"
+            : "unfinished", reason);
+    }
+    const delta = compareObservedDiagnostics(observations(response.before), observations(response.after), changes, ctx);
+    return { status: "completed", ...delta };
+}
+/**
+ * Entry point of the template type check: preflight and limits in-process, then one forked child
+ * under a wall-clock budget. A client abort kills the child and rethrows `REQUEST_CANCELLED`.
+ */
+export async function checkTemplateTypes(input, ctx = UNBOUNDED_CONTEXT, deps = {}) {
+    ctx.checkpoint();
+    const preflight = preflightTemplateTypeCheck(input.tsConfigFilePath);
+    if (!preflight.ok)
+        return emptyDelta("unavailable", preflight.reason);
+    const overlayBytes = input.overlay.reduce((total, file) => total + Buffer.byteLength(file.text, "utf8"), 0);
+    if (input.templates.length > MAX_TEMPLATES ||
+        input.overlay.length > MAX_OVERLAY_FILES ||
+        overlayBytes > MAX_OVERLAY_BYTES) {
+        return emptyDelta("unfinished", "work_exhausted");
+    }
+    const budgetMs = checkBudgetMs(ctx.remainingMs());
+    if (budgetMs < MIN_CHECK_MS)
+        return emptyDelta("unfinished", "deadline");
+    const outcome = await runChild({
+        v: 1,
+        tsconfig: input.tsConfigFilePath,
+        cliEntry: preflight.cliEntry,
+        templates: [...input.templates],
+        overlay: input.overlay.map(({ absolutePath, text }) => ({ absolutePath, text })),
+        maxDiagnostics: MAX_WIRE_DIAGNOSTICS,
+    }, budgetMs, ctx, deps);
+    if (outcome.kind === "deadline")
+        return emptyDelta("unfinished", "deadline");
+    if (outcome.kind === "reason")
+        return emptyDelta("unfinished", outcome.reason);
+    return diagnosticsOf(outcome.response, input.changes, ctx);
+}