@esportsplus/typescript 0.32.0 → 0.33.1

package/build/guard/exceptions/derive.js

@@ -0,0 +1,478 @@
+import { dirname } from 'node:path';
+import * as NodeFS from 'node:fs';
+import * as ts from '../adapter.js';
+import { API } from 'typescript/unstable/sync';
+import { bodyOf, hasModifier, isAwaited, unwrap } from '../kernel/ast.js';
+import { isFunctionLike } from '../kernel/ids.js';
+import { resolveBackingJs } from './resolve-js.js';
+import { ORIGIN_CAP, originOf } from './value.js';
+const GLOBAL_ERROR_CLASSES = new Set([
+    'AggregateError',
+    'Error',
+    'EvalError',
+    'RangeError',
+    'ReferenceError',
+    'SyntaxError',
+    'TypeError',
+    'URIError',
+]);
+const MAX_AVG_LINE = 300;
+const MAX_FILE_BYTES = 512 * 1024;
+const MAX_DEPTH = 6;
+function createThrowIndex() {
+    return {
+        api: null,
+        contents: new Map(),
+        nextProject: 0,
+        parsed: new Map(),
+        resolved: new Map(),
+        snapshots: [],
+        summaries: new Map(),
+    };
+}
+function disposeThrowIndex(index) {
+    for (let snapshot of index.snapshots) {
+        try {
+            if (!snapshot.isDisposed()) {
+                snapshot.dispose();
+            }
+        }
+        catch {
+        }
+    }
+    try {
+        index.api?.close();
+    }
+    catch {
+    }
+    index.api = null;
+    index.contents.clear();
+    index.parsed.clear();
+    index.resolved.clear();
+    index.snapshots.length = 0;
+    index.summaries.clear();
+}
+function isMinified(text) {
+    let lines = 1;
+    for (let i = 0, n = text.length; i < n; i++) {
+        if (text[i] === '\n') {
+            lines += 1;
+        }
+    }
+    return text.length / lines > MAX_AVG_LINE;
+}
+function normalize(fileName) {
+    return fileName.replace(/\\/g, '/');
+}
+function overlayFileSystem(contents) {
+    return {
+        fileExists: (fileName) => contents.has(normalize(fileName)) || undefined,
+        getAccessibleEntries: (directoryName) => {
+            let directory = normalize(directoryName), files = [];
+            for (let fileName of contents.keys()) {
+                let slash = fileName.lastIndexOf('/');
+                if (fileName.slice(0, slash) === directory) {
+                    files.push(fileName.slice(slash + 1));
+                }
+            }
+            return files.length > 0 ? { directories: [], files } : undefined;
+        },
+        readFile: (fileName) => contents.get(normalize(fileName)),
+    };
+}
+function parseText(index, text) {
+    try {
+        if (!index.api) {
+            index.api = new API({ cwd: '/guard-scan', fs: overlayFileSystem(index.contents) });
+        }
+        let directory = `/guard-scan/${index.nextProject++}`, config = `${directory}/tsconfig.json`, file = `${directory}/scan.js`;
+        index.contents.set(file, text);
+        index.contents.set(config, JSON.stringify({
+            compilerOptions: {
+                allowJs: true,
+                checkJs: false,
+                module: 'commonjs',
+                noEmit: true,
+                target: 'esnext',
+            },
+            files: ['scan.js'],
+        }));
+        let snapshot = index.api.updateSnapshot({ openProjects: [config] });
+        index.snapshots.push(snapshot);
+        return (snapshot
+            .getProject(config)
+            ?.program.getSourceFile(file) ?? null);
+    }
+    catch {
+        return null;
+    }
+}
+function parseFile(index, realpath) {
+    let stat;
+    try {
+        stat = NodeFS.statSync(realpath);
+    }
+    catch {
+        return undefined;
+    }
+    const cached = index.parsed.get(realpath);
+    if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) {
+        return cached;
+    }
+    if (cached) {
+        index.summaries.clear();
+    }
+    let text = '';
+    try {
+        text = stat.size <= MAX_FILE_BYTES ? NodeFS.readFileSync(realpath, 'utf8') : '';
+    }
+    catch {
+        text = '';
+    }
+    const sourceFile = text.length > 0 && !isMinified(text) ? parseText(index, text) : null;
+    const parsed = {
+        fileIndex: sourceFile ? indexFile(sourceFile) : null,
+        mtimeMs: stat.mtimeMs,
+        size: stat.size,
+        sourceFile,
+    };
+    index.parsed.set(realpath, parsed);
+    return parsed;
+}
+function classifyThrow(expr) {
+    if (!expr) {
+        return 'Error';
+    }
+    const value = unwrap(expr);
+    if (ts.isNewExpression(value) &&
+        ts.isIdentifier(value.expression) &&
+        GLOBAL_ERROR_CLASSES.has(value.expression.text)) {
+        return value.expression.text;
+    }
+    return 'Error';
+}
+function initializerFn(node) {
+    const initializer = node.initializer;
+    return initializer && isFunctionLike(initializer) ? initializer : undefined;
+}
+function requireSpecifier(expr) {
+    if (!expr || !ts.isCallExpression(expr) || !ts.isIdentifier(expr.expression) || expr.expression.text !== 'require') {
+        return undefined;
+    }
+    const arg = expr.arguments[0];
+    return arg && ts.isStringLiteral(arg) ? arg.text : undefined;
+}
+function targetOf(expr, fns, classes) {
+    const value = unwrap(expr);
+    if (isFunctionLike(value)) {
+        return value;
+    }
+    if (ts.isIdentifier(value)) {
+        return fns.get(value.text) ?? classes.get(value.text);
+    }
+    return undefined;
+}
+function collectDeclarations(sourceFile, classes, fns, imports, namespaces) {
+    for (const statement of sourceFile.statements) {
+        if (ts.isFunctionDeclaration(statement) && statement.name) {
+            fns.set(statement.name.text, statement);
+        }
+        else if (ts.isClassDeclaration(statement) && statement.name) {
+            classes.set(statement.name.text, statement);
+        }
+        else if (ts.isVariableStatement(statement)) {
+            for (const declaration of statement.declarationList.declarations) {
+                const fn = initializerFn(declaration);
+                if (fn && ts.isIdentifier(declaration.name)) {
+                    fns.set(declaration.name.text, fn);
+                }
+                const specifier = requireSpecifier(declaration.initializer);
+                if (specifier && ts.isIdentifier(declaration.name)) {
+                    namespaces.set(declaration.name.text, specifier);
+                }
+                else if (specifier && ts.isObjectBindingPattern(declaration.name)) {
+                    for (const element of declaration.name.elements) {
+                        if (ts.isBindingElement(element) && element.name && ts.isIdentifier(element.name)) {
+                            const property = element.propertyName;
+                            imports.set(element.name.text, {
+                                exportName: property && ts.isIdentifier(property) ? property.text : element.name.text,
+                                specifier,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        else if (ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier) && statement.importClause) {
+            const specifier = statement.moduleSpecifier.text;
+            const clause = statement.importClause;
+            if (clause.name) {
+                imports.set(clause.name.text, { exportName: 'default', specifier });
+            }
+            if (clause.namedBindings && ts.isNamespaceImport(clause.namedBindings)) {
+                namespaces.set(clause.namedBindings.name.text, specifier);
+            }
+            else if (clause.namedBindings && ts.isNamedImports(clause.namedBindings)) {
+                for (const element of clause.namedBindings.elements) {
+                    imports.set(element.name.text, { exportName: (element.propertyName ?? element.name).text, specifier });
+                }
+            }
+        }
+    }
+}
+function collectExports(sourceFile, classes, fns, exportsByName, reexports) {
+    let reexportAll;
+    const add = (name, expr) => {
+        const target = targetOf(expr, fns, classes);
+        if (target) {
+            exportsByName.set(name, target);
+        }
+    };
+    for (const statement of sourceFile.statements) {
+        const exported = hasModifier(statement, ts.SyntaxKind.ExportKeyword);
+        const defaultExport = hasModifier(statement, ts.SyntaxKind.DefaultKeyword);
+        if (ts.isFunctionDeclaration(statement) && exported) {
+            exportsByName.set(defaultExport ? 'default' : statement.name?.text ?? 'default', statement);
+        }
+        else if (ts.isClassDeclaration(statement) && exported) {
+            exportsByName.set(defaultExport ? 'default' : statement.name?.text ?? 'default', statement);
+        }
+        else if (ts.isVariableStatement(statement) && exported) {
+            for (const declaration of statement.declarationList.declarations) {
+                if (ts.isIdentifier(declaration.name)) {
+                    add(declaration.name.text, (declaration.initializer ?? declaration.name));
+                }
+            }
+        }
+        else if (ts.isExportAssignment(statement) && !statement.isExportEquals) {
+            add('default', statement.expression);
+        }
+        else if (ts.isExportDeclaration(statement) && statement.moduleSpecifier && ts.isStringLiteral(statement.moduleSpecifier)) {
+            const specifier = statement.moduleSpecifier.text;
+            if (!statement.exportClause) {
+                reexportAll = specifier;
+            }
+            else if (ts.isNamedExports(statement.exportClause)) {
+                for (const element of statement.exportClause.elements) {
+                    reexports.set(element.name.text, { exportName: (element.propertyName ?? element.name).text, specifier });
+                }
+            }
+        }
+        else if (ts.isExpressionStatement(statement) && ts.isBinaryExpression(statement.expression) && statement.expression.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+            reexportAll = collectCjsExport(statement.expression, add) ?? reexportAll;
+        }
+    }
+    return reexportAll;
+}
+function collectCjsExport(assign, add) {
+    const left = assign.left;
+    if (!ts.isPropertyAccessExpression(left)) {
+        return undefined;
+    }
+    if (ts.isIdentifier(left.expression) && left.expression.text === 'exports') {
+        add(left.name.text, assign.right);
+        return undefined;
+    }
+    if (ts.isPropertyAccessExpression(left.expression) && ts.isIdentifier(left.expression.expression) && left.expression.expression.text === 'module' && left.expression.name.text === 'exports') {
+        add(left.name.text, assign.right);
+        return undefined;
+    }
+    if (!ts.isIdentifier(left.expression) || left.expression.text !== 'module' || left.name.text !== 'exports') {
+        return undefined;
+    }
+    const required = requireSpecifier(assign.right);
+    if (required) {
+        return required;
+    }
+    const value = unwrap(assign.right);
+    if (!ts.isObjectLiteralExpression(value)) {
+        add('default', assign.right);
+        return undefined;
+    }
+    for (const property of value.properties) {
+        if (ts.isPropertyAssignment(property) && (ts.isIdentifier(property.name) || ts.isStringLiteral(property.name))) {
+            add(property.name.text, property.initializer);
+        }
+        else if (ts.isShorthandPropertyAssignment(property) && ts.isIdentifier(property.name)) {
+            add(property.name.text, property.name);
+        }
+    }
+    return undefined;
+}
+function indexFile(sourceFile) {
+    const classes = new Map();
+    const exportsByName = new Map();
+    const fns = new Map();
+    const imports = new Map();
+    const namespaces = new Map();
+    const reexports = new Map();
+    collectDeclarations(sourceFile, classes, fns, imports, namespaces);
+    const reexportAll = collectExports(sourceFile, classes, fns, exportsByName, reexports);
+    return { classes, exportsByName, fns, imports, namespaces, reexportAll, reexports };
+}
+function locateExport(index, realpath, exportName, seen = new Set()) {
+    const key = `${realpath}\0${exportName}`;
+    if (seen.has(key)) {
+        return undefined;
+    }
+    const parsed = parseFile(index, realpath);
+    if (!parsed?.sourceFile || !parsed.fileIndex) {
+        return undefined;
+    }
+    const target = parsed.fileIndex.exportsByName.get(exportName);
+    if (target) {
+        return { fileIndex: parsed.fileIndex, realpath, sourceFile: parsed.sourceFile, target };
+    }
+    const redirect = parsed.fileIndex.reexports.get(exportName) ??
+        (parsed.fileIndex.reexportAll ? { exportName, specifier: parsed.fileIndex.reexportAll } : undefined);
+    if (!redirect) {
+        return undefined;
+    }
+    const next = resolveBackingJs(realpath, redirect.specifier);
+    return next ? locateExport(index, next, redirect.exportName, new Set(seen).add(key)) : undefined;
+}
+function findMethod(sourceFile, classNode, memberName) {
+    const members = classNode.members ?? [];
+    for (const member of members) {
+        if (ts.isMethodDeclaration(member) && ts.isIdentifier(member.name) && member.name.text === memberName) {
+            return member;
+        }
+    }
+    const name = classNode.name;
+    if (!name || !ts.isIdentifier(name)) {
+        return undefined;
+    }
+    for (const statement of sourceFile.statements) {
+        if (!ts.isExpressionStatement(statement) || !ts.isBinaryExpression(statement.expression) || statement.expression.operatorToken.kind !== ts.SyntaxKind.EqualsToken) {
+            continue;
+        }
+        const left = statement.expression.left;
+        if (ts.isPropertyAccessExpression(left) &&
+            ts.isPropertyAccessExpression(left.expression) &&
+            ts.isIdentifier(left.expression.expression) &&
+            left.expression.expression.text === name.text &&
+            left.expression.name.text === 'prototype' &&
+            left.name.text === memberName) {
+            const target = unwrap(statement.expression.right);
+            if (isFunctionLike(target)) {
+                return target;
+            }
+        }
+    }
+    return undefined;
+}
+function importedTarget(index, realpath, fileIndex, call) {
+    if (ts.isIdentifier(call.expression)) {
+        const binding = fileIndex.imports.get(call.expression.text);
+        if (!binding) {
+            return undefined;
+        }
+        const next = resolveBackingJs(realpath, binding.specifier);
+        return next ? locateExport(index, next, binding.exportName) : undefined;
+    }
+    if (ts.isPropertyAccessExpression(call.expression) && ts.isIdentifier(call.expression.expression)) {
+        const specifier = fileIndex.namespaces.get(call.expression.expression.text);
+        if (!specifier) {
+            return undefined;
+        }
+        const next = resolveBackingJs(realpath, specifier);
+        return next ? locateExport(index, next, call.expression.name.text) : undefined;
+    }
+    return undefined;
+}
+function mergeClasses(into, from) {
+    for (const [name, origins] of from) {
+        const existing = into.get(name);
+        if (!existing) {
+            into.set(name, origins.slice(0, ORIGIN_CAP));
+            continue;
+        }
+        for (const origin of origins) {
+            if (existing.length < ORIGIN_CAP && !existing.some((candidate) => candidate.pos === origin.pos && candidate.fileName === origin.fileName)) {
+                existing.push(origin);
+            }
+        }
+    }
+}
+function computeEscaping(index, realpath, sourceFile, fileIndex, functionNode, depth, chain) {
+    const classes = new Map();
+    const body = bodyOf(functionNode);
+    if (!body || depth <= 0 || chain.has(functionNode)) {
+        return classes;
+    }
+    const nextChain = new Set(chain).add(functionNode);
+    const visit = (node) => {
+        if (node !== functionNode && isFunctionLike(node)) {
+            return;
+        }
+        if (ts.isThrowStatement(node)) {
+            const name = classifyThrow(node.expression);
+            const origins = classes.get(name) ?? [];
+            if (origins.length < ORIGIN_CAP) {
+                origins.push(originOf(node, sourceFile, realpath));
+            }
+            classes.set(name, origins);
+        }
+        else if (ts.isCallExpression(node)) {
+            let target = ts.isIdentifier(node.expression) ? fileIndex.fns.get(node.expression.text) : undefined;
+            let targetPath = realpath;
+            let targetSource = sourceFile;
+            let targetIndex = fileIndex;
+            if (!target) {
+                const imported = importedTarget(index, realpath, fileIndex, node);
+                if (imported) {
+                    target = imported.target;
+                    targetPath = imported.realpath;
+                    targetSource = imported.sourceFile;
+                    targetIndex = imported.fileIndex;
+                }
+            }
+            if (target && !(hasModifier(target, ts.SyntaxKind.AsyncKeyword) && !isAwaited(node))) {
+                mergeClasses(classes, computeEscaping(index, targetPath, targetSource, targetIndex, target, depth - 1, nextChain));
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    ts.forEachChild(body, visit);
+    return classes;
+}
+function computeSummary(index, realpath, exportName, memberName) {
+    const located = locateExport(index, realpath, exportName);
+    if (!located) {
+        return null;
+    }
+    let target = located.target;
+    if (memberName) {
+        const method = findMethod(located.sourceFile, target, memberName);
+        if (!method) {
+            return null;
+        }
+        target = method;
+    }
+    return {
+        async: hasModifier(target, ts.SyntaxKind.AsyncKeyword),
+        classes: computeEscaping(index, located.realpath, located.sourceFile, located.fileIndex, target, MAX_DEPTH, new Set()),
+    };
+}
+function deriveThrows(index, params) {
+    let resolution = `${dirname(params.importerFileName)}\0${params.specifier}`, realpath = index.resolved.get(resolution);
+    if (!index.resolved.has(resolution)) {
+        realpath = resolveBackingJs(params.importerFileName, params.specifier);
+        index.resolved.set(resolution, realpath);
+    }
+    if (!realpath) {
+        return undefined;
+    }
+    parseFile(index, realpath);
+    const key = `${realpath}\0${params.exportName}\0${params.memberName ?? ''}`;
+    let cached = index.summaries.get(key);
+    if (!index.summaries.has(key)) {
+        cached = computeSummary(index, realpath, params.exportName, params.memberName);
+        index.summaries.set(key, cached);
+    }
+    if (!cached || (cached.async && !params.awaited) || cached.classes.size === 0) {
+        return undefined;
+    }
+    return { classes: cached.classes };
+}
+export { createThrowIndex, deriveThrows, disposeThrowIndex };

package/build/guard/exceptions/resolve-js.d.ts

@@ -0,0 +1,2 @@
+declare function resolveBackingJs(importerFileName: string, specifier: string): string | undefined;
+export { resolveBackingJs };

package/build/guard/exceptions/resolve-js.js

@@ -0,0 +1,26 @@
+import * as NodeFS from 'node:fs';
+import * as NodePath from 'node:path';
+import { createRequire, isBuiltin } from 'node:module';
+const SCANNABLE = new Set(['.cjs', '.js', '.mjs']);
+function resolveBackingJs(importerFileName, specifier) {
+    if (isBuiltin(specifier)) {
+        return undefined;
+    }
+    let resolved;
+    try {
+        resolved = createRequire(importerFileName).resolve(specifier);
+    }
+    catch {
+        return undefined;
+    }
+    if (!SCANNABLE.has(NodePath.extname(resolved).toLowerCase())) {
+        return undefined;
+    }
+    try {
+        return NodeFS.realpathSync(resolved);
+    }
+    catch {
+        return resolved;
+    }
+}
+export { resolveBackingJs };

package/build/{probe → guard}/exceptions/value.d.ts

@@ -13,6 +13,7 @@ type ExceptionsValue = {
     readonly origins: ReadonlyMap<string, ReadonlyArray<ExceptionOrigin>>;
 };
 declare const TOP_KEY = "\0top";
+declare const ORIGIN_CAP = 4;
 declare function bottom(): ExceptionsValue;
 declare function top(): ExceptionsValue;
 declare function single(key: string, display: string): ExceptionsValue;
@@ -24,7 +25,7 @@ declare function widen(prev: ExceptionsValue, next: ExceptionsValue, round: numb
 declare function subtract(a: ExceptionsValue, keys: ReadonlySet<string>): ExceptionsValue;
 declare function isEmpty(v: ExceptionsValue): boolean;
 declare function render(v: ExceptionsValue): string;
-declare function constituentsOf(type: ts.Type): ReadonlyArray<ts.Type>;
+declare function originOf(node: ts.Node, sourceFile: ts.SourceFile, fileName?: string): ExceptionOrigin;
 declare function refOfType(checker: ts.TypeChecker, t: ts.Type): {
     top: true;
 } | {
@@ -36,4 +37,4 @@ declare function typeRef(checker: ts.TypeChecker, type: ts.Type): ReadonlyArray<
     key: string;
     display: string;
 }>;
-export { TOP_KEY, bottom, constituentsOf, equals, isEmpty, join, originsOf, refOfType, render, single, subtract, top, type ExceptionOrigin, type ExceptionsValue, typeRef, widen, withOrigin };
+export { ORIGIN_CAP, TOP_KEY, bottom, equals, isEmpty, join, originOf, originsOf, refOfType, render, single, subtract, top, type ExceptionOrigin, type ExceptionsValue, typeRef, widen, withOrigin };

package/build/{probe → guard}/exceptions/value.js

@@ -1,4 +1,6 @@
 import * as ts from '../adapter.js';
+import { constituents } from '../kernel/ast.js';
+import { locationOf } from '../kernel/ids.js';
 const TOP_KEY = '\u0000top';
 const TOP_DISPLAY = 'an unknown error';
 const WIDEN_CAP = 8;
@@ -122,8 +124,14 @@ function render(v) {
         return TOP_DISPLAY;
     return Array.from(v.types.values()).sort().join(' | ');
 }
-function constituentsOf(type) {
-    return ts.unionTypes(type) ?? [type];
+function originOf(node, sourceFile, fileName = sourceFile.fileName) {
+    const location = locationOf(node, sourceFile);
+    const text = node.getText(sourceFile).replace(/\s+/g, ' ').trim();
+    return {
+        ...location,
+        fileName,
+        text: text.length > 120 ? `${text.slice(0, 117)}…` : text,
+    };
 }
 function basename(p) {
     const i = Math.max(p.lastIndexOf('/'), p.lastIndexOf('\\'));
@@ -146,7 +154,7 @@ function refOfType(checker, t) {
 }
 function typeRef(checker, type) {
     const out = [];
-    for (const t of constituentsOf(type)) {
+    for (const t of constituents(type)) {
         const r = refOfType(checker, t);
         if (r.top)
             out.push({ key: TOP_KEY, display: TOP_DISPLAY });
@@ -155,4 +163,4 @@ function typeRef(checker, type) {
     }
     return out;
 }
-export { TOP_KEY, bottom, constituentsOf, equals, isEmpty, join, originsOf, refOfType, render, single, subtract, top, typeRef, widen, withOrigin };
+export { ORIGIN_CAP, TOP_KEY, bottom, equals, isEmpty, join, originOf, originsOf, refOfType, render, single, subtract, top, typeRef, widen, withOrigin };

package/build/{probe → guard}/kernel/analyze.d.ts

@@ -1,8 +1,9 @@
 import * as ts from '../adapter.js';
 import type { Diagnostic, AnalyzeConfig } from './types.js';
+import type { ThrowIndex } from '../exceptions/derive.js';
 type AnalyzeResult = {
     readonly diagnostics: ReadonlyArray<Diagnostic>;
 };
-declare function analyzeProgram(program: ts.Program, checker: ts.TypeChecker, config: AnalyzeConfig): AnalyzeResult;
+declare function analyzeProgram(program: ts.Program, checker: ts.TypeChecker, config: AnalyzeConfig, throwIndex?: ThrowIndex): AnalyzeResult;
 declare function analyze(config: AnalyzeConfig): AnalyzeResult;
 export { analyze, analyzeProgram, type AnalyzeResult };

package/build/guard/kernel/analyze.js

@@ -0,0 +1,84 @@
+import { channelFor } from '../channels.js';
+import { buildCallGraph } from './graph.js';
+import { buildProgram } from './program.js';
+import { createThrowIndex, disposeThrowIndex } from '../exceptions/derive.js';
+import { runChannel } from './fixpoint.js';
+import { loadOverlays } from '../overlay/load.js';
+function analyzeProgram(program, checker, config, throwIndex) {
+    const index = throwIndex ?? createThrowIndex();
+    try {
+        return runAnalysis(program, checker, config, index);
+    }
+    finally {
+        if (!throwIndex) {
+            disposeThrowIndex(index);
+        }
+    }
+}
+function runAnalysis(program, checker, config, throwIndex) {
+    const overlays = loadOverlays();
+    const graph = buildCallGraph(program, checker, overlays);
+    const analysis = { checker, graph };
+    const built = new Map();
+    const instance = (name) => {
+        const cached = built.get(name);
+        if (cached) {
+            return cached;
+        }
+        const channelConfig = config.channels[name];
+        const channel = channelConfig
+            ? channelFor(name, throwIndex)
+            : undefined;
+        if (!channelConfig || !channel) {
+            return undefined;
+        }
+        const entry = [channelConfig, channel];
+        built.set(name, entry);
+        return entry;
+    };
+    const enabled = new Set();
+    for (const [name, channelConfig] of Object.entries(config.channels)) {
+        if (channelConfig.severity !== 'off') {
+            enabled.add(name);
+        }
+    }
+    const runnable = new Set();
+    const include = (name, stack) => {
+        if (runnable.has(name) || stack.has(name)) {
+            return;
+        }
+        const inst = instance(name);
+        if (!inst) {
+            return;
+        }
+        const next = new Set(stack).add(name);
+        for (const dep of inst[1].dependsOn ?? []) {
+            include(dep, next);
+        }
+        runnable.add(name);
+    };
+    for (const name of enabled) {
+        include(name, new Set());
+    }
+    const diagnostics = [];
+    const peers = new Map();
+    for (const name of runnable) {
+        const [channelConfig, channel] = instance(name);
+        const result = runChannel(analysis, channel, channelConfig.options, peers);
+        peers.set(name, result.store);
+        if (enabled.has(name)) {
+            diagnostics.push(...result.diagnostics);
+        }
+    }
+    return { diagnostics };
+}
+function analyze(config) {
+    const built = buildProgram(config.tsconfigPath);
+    try {
+        return analyzeProgram(built.program, built.checker, config);
+    }
+    finally {
+        built.dispose();
+    }
+}
+export { analyze, analyzeProgram };

package/build/guard/kernel/ast.d.ts

@@ -0,0 +1,13 @@
+import * as ts from '../adapter.js';
+import type { FunctionLike } from './types.js';
+type UnwrapOptions = {
+    assertions?: boolean;
+    awaits?: boolean;
+};
+declare const bodyOf: (node: ts.Node) => ts.Node | undefined;
+declare const constituents: (type: ts.Type) => ReadonlyArray<ts.Type>;
+declare const hasModifier: (node: ts.Node, kind: ts.SyntaxKind) => boolean;
+declare const isAwaited: (call: ts.CallExpression) => boolean;
+declare const paramSymbols: (checker: ts.TypeChecker, fn: FunctionLike) => Map<ts.Symbol, number>;
+declare const unwrap: (expr: ts.Expression, options?: UnwrapOptions) => ts.Expression;
+export { bodyOf, constituents, hasModifier, isAwaited, paramSymbols, unwrap };