carrick 0.3.58 → 0.3.59

package/sidecar/dist/src/capture/deno-project.js

@@ -0,0 +1,513 @@
+/** Deno owns module resolution; both compiler frontends consume its graph. */
+import ts from 'typescript';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { pathToFileURL, fileURLToPath } from 'node:url';
+import { createHash } from 'node:crypto';
+import { execFileSync } from 'node:child_process';
+import { rewriteSpecifiers } from './specifiers.js';
+function readConfig(file) {
+    const parsed = ts.parseConfigFileTextToJson(file, fs.readFileSync(file, 'utf8'));
+    if (parsed.error)
+        throw new Error(ts.flattenDiagnosticMessageText(parsed.error.messageText, '\n'));
+    return parsed.config;
+}
+/** Explicit TS configs keep their existing behaviour, including mixed repos. */
+export function findDenoConfig(repoRoot, explicit) {
+    if (explicit && !/^deno\.jsonc?$/.test(path.basename(explicit)))
+        return undefined;
+    let dir = path.resolve(repoRoot);
+    const configs = [];
+    while (true) {
+        const file = ['deno.json', 'deno.jsonc'].map(n => path.join(dir, n)).find(f => fs.existsSync(f));
+        if (file)
+            configs.push({ file, config: readConfig(file) });
+        if (fs.existsSync(path.join(dir, '.git')) || path.dirname(dir) === dir)
+            break;
+        dir = path.dirname(dir);
+    }
+    if (!configs.length)
+        return undefined;
+    const nearest = configs[0];
+    if (explicit && path.resolve(repoRoot, explicit) !== nearest.file) {
+        throw new Error('Explicit Deno config must be the nearest deno.json or deno.jsonc for the service directory.');
+    }
+    const declaredWorkspace = configs.find(c => c.config.workspace?.some(member => {
+        const memberRoot = path.resolve(path.dirname(c.file), member);
+        const relative = path.relative(memberRoot, path.resolve(repoRoot));
+        return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+    }));
+    if (!explicit && path.dirname(nearest.file) !== path.resolve(repoRoot) &&
+        fs.existsSync(path.join(repoRoot, 'package.json')) && !declaredWorkspace)
+        return undefined;
+    const workspace = declaredWorkspace ?? nearest;
+    const opts = { ...workspace.config.compilerOptions, ...nearest.config.compilerOptions };
+    const typesOwner = nearest.config.compilerOptions?.types !== undefined ? nearest.file : workspace.file;
+    if (Array.isArray(opts.types)) {
+        opts.types = opts.types.map((spec) => typeof spec === 'string' && (spec.startsWith('.') || path.isAbsolute(spec))
+            ? pathToFileURL(path.resolve(path.dirname(typesOwner), spec)).href : spec);
+    }
+    return {
+        configPath: explicit ? path.resolve(repoRoot, explicit) : nearest.file,
+        workspaceRoot: path.dirname(workspace.file),
+        compilerOptions: opts,
+        exclude: [...(workspace.config.exclude ?? []).map(p => path.resolve(path.dirname(workspace.file), p)),
+            ...(nearest.config.exclude ?? []).map(p => path.resolve(path.dirname(nearest.file), p))],
+    };
+}
+function runDeno(args, cwd) {
+    try {
+        return execFileSync('deno', args, {
+            cwd, encoding: 'utf8', timeout: 120_000, maxBuffer: 64 * 1024 * 1024,
+            stdio: ['ignore', 'pipe', 'pipe'], env: { ...process.env, DENO_NO_UPDATE_CHECK: '1' },
+        });
+    }
+    catch (err) {
+        const detail = err;
+        throw new Error(`Deno type preparation failed. Install Deno on PATH and prepare the project's dependencies without lifecycle scripts before scanning. ${detail.stderr || detail.message}`);
+    }
+}
+/** One request's immutable graph, shared by analysis, emit and relocation. */
+export class DenoProject {
+    config;
+    repoRoot;
+    cacheDir;
+    parsed;
+    globals;
+    diagnostics = [];
+    pinned = {};
+    modules = new Map();
+    localPaths = new Map();
+    edges = new Map();
+    redirects;
+    npmPackages;
+    externalNames = new Map();
+    constructor(config, repoRoot) {
+        this.config = config;
+        this.repoRoot = repoRoot;
+        const cache = path.join(config.workspaceRoot, '.carrick', 'deno', createHash('sha256').update(path.resolve(repoRoot)).digest('hex').slice(0, 16));
+        this.cacheDir = cache;
+        fs.mkdirSync(cache, { recursive: true });
+        const raw = { ...config.compilerOptions };
+        const libs = Array.isArray(raw.lib) ? raw.lib : ['deno.window'];
+        const denoLibs = libs.filter(l => l.startsWith('deno.'));
+        if (denoLibs.some(l => !['deno.window', 'deno.ns', 'deno.unstable'].includes(l))) {
+            throw new Error(`Unsupported Deno type libraries: ${denoLibs.join(', ')}. Supported runtime scopes are deno.window and deno.ns.`);
+        }
+        delete raw.types;
+        delete raw.jsxImportSourceTypes;
+        const runtime = denoLibs.includes('deno.window');
+        this.parsed = ts.parseJsonConfigFileContent({
+            compilerOptions: {
+                target: 'ESNext', module: 'ESNext', moduleResolution: 'Bundler', strict: true,
+                allowJs: true, checkJs: false, skipLibCheck: true, resolveJsonModule: true,
+                ...raw, lib: ['esnext', ...libs.filter(l => !l.startsWith('deno.'))],
+                allowImportingTsExtensions: true, noEmit: true,
+            },
+            include: ['**/*.ts', '**/*.tsx', '**/*.mts', '**/*.cts', '**/*.js', '**/*.jsx'],
+            exclude: ['**/node_modules/**', '**/.git/**', '**/.carrick/**', '**/dist/**', '**/.vite/**', ...config.exclude],
+        }, ts.sys, repoRoot);
+        this.parsed.options.rootDir = config.workspaceRoot;
+        this.globals = [];
+        if (denoLibs.length) {
+            const declarations = runDeno(['types'], repoRoot);
+            // deno types concatenates its libs, leaving references to Deno-only lib
+            // names that stock TypeScript cannot load. The declarations themselves
+            // come unchanged from the installed compiler; no ambient stand-ins.
+            let text = declarations.replace(/^\/\/\/\s*<reference\s+(?:no-default-lib="true"|lib="deno\.[^"]+")\s*\/>\s*$/gm, '');
+            if (!runtime) {
+                const source = ts.createSourceFile('runtime.d.ts', text, ts.ScriptTarget.Latest, true);
+                text = source.statements.filter(s => (ts.isModuleDeclaration(s) && (s.name.text === 'Deno' || denoLibs.includes('deno.unstable'))) ||
+                    (ts.isInterfaceDeclaration(s) && s.name.text === 'ImportMeta')).map(s => s.getFullText(source)).join('\n');
+            }
+            const globalPath = path.join(cache, 'runtime.d.ts');
+            fs.writeFileSync(globalPath, text);
+            this.globals.push(globalPath);
+        }
+        // The graph root lives within the service so compilerOptions.types uses
+        // that member's import-map scope, just like the real source files do.
+        const entry = path.join(repoRoot, '.carrick', 'deno', 'graph.ts');
+        fs.mkdirSync(path.dirname(entry), { recursive: true });
+        const roots = this.parsed.fileNames.map(f => pathToFileURL(f).href);
+        const extraTypes = config.compilerOptions.types;
+        if (Array.isArray(extraTypes))
+            roots.push(...extraTypes.filter((t) => typeof t === 'string'));
+        fs.writeFileSync(entry, roots.map(s => `import ${JSON.stringify(s)};`).join('\n'));
+        let graph;
+        try {
+            graph = JSON.parse(runDeno(['info', '--json', '--frozen', '--node-modules-dir=none', '--config', config.configPath, entry], repoRoot));
+        }
+        finally {
+            fs.rmSync(entry, { force: true });
+        }
+        if (!Array.isArray(graph.modules))
+            throw new Error('Unsupported deno info JSON: missing modules array');
+        this.redirects = graph.redirects ?? {};
+        this.npmPackages = graph.npmPackages ?? {};
+        for (const [id, pkg] of Object.entries(this.npmPackages)) {
+            if (!pkg.localPath) {
+                throw new Error(`Deno npm graph lacks localPath for ${id}. Use Deno 2.9.4 and run deno install --frozen --node-modules-dir=none before scanning.`);
+            }
+        }
+        for (const module of graph.modules) {
+            this.modules.set(module.specifier, module);
+            if (module.error)
+                this.diagnostics.push(`${module.specifier}: ${module.error}`);
+            if (!module.local)
+                continue;
+            let local = module.local;
+            if (!module.specifier.startsWith('file:')) {
+                const extensions = { TypeScript: '.ts', Tsx: '.tsx', JavaScript: '.js', Jsx: '.jsx', Dts: '.d.ts', Json: '.json', Mts: '.mts', Cts: '.cts' };
+                const extension = extensions[module.mediaType ?? ''];
+                if (!extension) {
+                    this.diagnostics.push(`${module.specifier}: unsupported media type ${module.mediaType}`);
+                    continue;
+                }
+                local = path.join(cache, 'remote', createHash('sha256').update(module.specifier).digest('hex') + extension);
+                fs.mkdirSync(path.dirname(local), { recursive: true });
+                fs.copyFileSync(module.local, local);
+            }
+            this.localPaths.set(module.specifier, path.resolve(local));
+        }
+        for (const module of graph.modules) {
+            const local = this.localPaths.get(module.specifier);
+            if (!local)
+                continue;
+            const edges = new Map();
+            for (const dep of module.dependencies ?? []) {
+                const target = dep.type ?? dep.code;
+                if (target)
+                    edges.set(dep.specifier, target);
+                if (target?.error)
+                    this.diagnostics.push(`${module.specifier}: ${dep.specifier}: ${target.error}`);
+            }
+            this.edges.set(local, edges);
+        }
+        // Deno's extra type roots must participate in both compiler programs.
+        const entryModule = this.modules.get(pathToFileURL(entry).href);
+        for (const dep of entryModule?.dependencies ?? []) {
+            if (Array.isArray(extraTypes) && extraTypes.includes(dep.specifier)) {
+                const local = this.targetPath(dep.type ?? dep.code);
+                if (local)
+                    this.globals.push(local);
+            }
+        }
+        fs.writeFileSync(path.join(cache, 'resolution-diagnostics.json'), JSON.stringify(this.diagnostics, null, 2));
+        this.parsed.fileNames.push(...this.globals);
+    }
+    targetPath(resolution, from = this.repoRoot) {
+        if (!resolution?.specifier || resolution.error)
+            return undefined;
+        let spec = resolution.specifier;
+        const seen = new Set();
+        while (!seen.has(spec)) {
+            seen.add(spec);
+            const next = this.redirects[spec] ?? this.modules.get(spec)?.typesDependency?.dependency.specifier;
+            if (!next)
+                break;
+            spec = next;
+        }
+        const npm = this.modules.get(spec)?.npmPackage;
+        if (npm) {
+            const pkg = this.npmPackages[npm];
+            const suffix = /^npm:\/?(?:@[^/]+\/[^/@]+|[^/@]+)@[^/]+(.*)$/.exec(spec)?.[1] ?? '';
+            if (pkg?.localPath && !fs.existsSync(path.join(pkg.localPath, 'package.json'))) {
+                const diagnostic = `Deno npm dependency ${npm} is not cached; run deno install --frozen --node-modules-dir=none.`;
+                if (!this.diagnostics.includes(diagnostic))
+                    this.diagnostics.push(diagnostic);
+                return undefined;
+            }
+            return pkg && this.resolveNpm(pkg.name + suffix, from, this.parsed.options, pkg)?.resolvedFileName;
+        }
+        return this.localPaths.get(spec) ?? (spec.startsWith('file:') ? fileURLToPath(spec) : undefined);
+    }
+    resolve(spec, from, options, host = ts.sys) {
+        const edge = this.edges.get(path.resolve(from))?.get(spec);
+        if (edge) {
+            const target = this.targetPath(edge, from);
+            if (!target || !fs.existsSync(target))
+                return undefined;
+            if (!/\.(?:[cm]?tsx?|jsx?|json)$/i.test(target))
+                return undefined;
+            return { resolvedFileName: target, isExternalLibraryImport: this.isNpmFile(target) };
+        }
+        // Generated capture imports and the internals of installed npm packages
+        // use TypeScript resolution. Recorded failed Deno edges never fall back.
+        return this.resolveNpm(spec, from, options) ?? ts.resolveModuleName(spec, from, options, host).resolvedModule;
+    }
+    npmOwner(file) {
+        return Object.values(this.npmPackages).find(pkg => pkg.localPath &&
+            (file === pkg.localPath || file.startsWith(pkg.localPath + path.sep)));
+    }
+    isNpmFile(file) {
+        return !!this.npmOwner(file) || file.split(path.sep).includes('node_modules');
+    }
+    /** Let TypeScript interpret real package exports/types using Deno's exact
+     * dependency graph. Only the resolution host sees virtual node_modules;
+     * every returned source path points at the existing Deno cache. */
+    resolveNpm(spec, from, options, exact) {
+        if (spec.startsWith('.') || path.isAbsolute(spec))
+            return undefined;
+        const name = spec.startsWith('@') ? spec.split('/').slice(0, 2).join('/') : spec.split('/')[0];
+        const owner = this.npmOwner(from);
+        const candidates = exact ? [exact] : owner
+            ? [owner, ...owner.dependencies.map(id => this.npmPackages[id]).filter((pkg) => !!pkg)]
+            : Object.values(this.npmPackages);
+        const matches = candidates.filter(pkg => pkg.name === name);
+        // Never select an arbitrary version outside a recorded graph edge.
+        const pkg = matches.length === 1 ? matches[0] : matches.find(p => p.version === this.pinned[name]);
+        if (!pkg?.localPath)
+            return undefined;
+        const virtualRoot = path.join(this.cacheDir, 'npm-resolution');
+        const scopedTypes = [...(this.edges.get(path.resolve(from))?.values() ?? [])].flatMap(edge => {
+            let specifier = edge.specifier;
+            const seen = new Set();
+            while (specifier && this.redirects[specifier] && !seen.has(specifier)) {
+                seen.add(specifier);
+                specifier = this.redirects[specifier];
+            }
+            const id = specifier && this.modules.get(specifier)?.npmPackage;
+            return id && this.npmPackages[id] ? [this.npmPackages[id]] : [];
+        });
+        const virtualModules = path.join(virtualRoot, 'node_modules');
+        const actual = (file) => {
+            if (!file.startsWith(virtualModules + path.sep))
+                return file;
+            const relative = file.slice(virtualModules.length + 1).split(path.sep);
+            const packageName = relative.slice(0, relative[0].startsWith('@') ? 2 : 1).join('/');
+            const alternatives = Object.values(this.npmPackages).filter(p => p.name === packageName);
+            const selected = packageName === name ? pkg : scopedTypes.find(p => p.name === packageName)
+                ?? (owner ? candidates.find(p => p.name === packageName) : undefined)
+                ?? alternatives.find(p => p.version === this.pinned[packageName])
+                ?? (alternatives.length === 1 ? alternatives[0] : undefined);
+            return selected?.localPath ? path.join(selected.localPath, ...relative.slice(packageName.startsWith('@') ? 2 : 1)) : file;
+        };
+        const host = {
+            fileExists: file => ts.sys.fileExists(actual(file)),
+            readFile: file => ts.sys.readFile(actual(file)),
+            directoryExists: dir => dir === virtualRoot || dir === virtualModules || dir === path.join(virtualModules, '@types') || ts.sys.directoryExists(actual(dir)),
+            realpath: file => actual(file),
+            getCurrentDirectory: () => virtualRoot,
+        };
+        const result = ts.resolveModuleName(spec, path.join(virtualRoot, 'entry.ts'), options, host).resolvedModule;
+        return result && { ...result, resolvedFileName: actual(result.resolvedFileName), isExternalLibraryImport: true };
+    }
+    host(options) {
+        const host = ts.createCompilerHost(options);
+        host.resolveModuleNames = (names, from) => names.map(name => this.resolve(name, from, options, host));
+        host.resolveTypeReferenceDirectives = (names, from) => names.map(name => this.resolveTypeReference(typeof name === 'string' ? name : name.fileName, from, options, host));
+        return host;
+    }
+    resolveTypeReference(spec, from, options, host = ts.sys) {
+        if (this.edges.get(path.resolve(from))?.has(spec)) {
+            const resolved = this.resolve(spec, from, options, host);
+            return resolved ? { resolvedFileName: resolved.resolvedFileName, primary: true } : undefined;
+        }
+        return ts.resolveTypeReferenceDirective(spec, from, options, host).resolvedTypeReferenceDirective;
+    }
+    /** Turn a Deno npm alias into its real package export, with the exact pin. */
+    externalName(spec, target, from) {
+        const key = `${spec}\0${target}`;
+        if (this.externalNames.has(key))
+            return this.externalNames.get(key);
+        let dir = path.dirname(target);
+        while (this.isNpmFile(dir)) {
+            const file = path.join(dir, 'package.json');
+            if (fs.existsSync(file)) {
+                const pkg = JSON.parse(fs.readFileSync(file, 'utf8'));
+                if (pkg.name && pkg.version) {
+                    if (this.pinned[pkg.name] && this.pinned[pkg.name] !== pkg.version) {
+                        throw new Error(`Deno capture references multiple versions of ${pkg.name}; a single stub dependency cannot preserve both ${this.pinned[pkg.name]} and ${pkg.version}.`);
+                    }
+                    this.pinned[pkg.name] = pkg.version;
+                    // DefinitelyTyped declarations keep their public runtime specifier;
+                    // importing @types/foo directly is rejected by TypeScript (TS6137).
+                    if (pkg.name.startsWith('@types/')) {
+                        const publicName = pkg.name.slice('@types/'.length).replace(/^([^_]+)__/, '@$1/');
+                        let code = this.edges.get(path.resolve(from))?.get(spec)?.specifier;
+                        const seen = new Set();
+                        while (code && this.redirects[code] && !seen.has(code)) {
+                            seen.add(code);
+                            code = this.redirects[code];
+                        }
+                        const id = code && this.modules.get(code)?.npmPackage;
+                        const runtimePackage = id && this.npmPackages[id];
+                        if (runtimePackage && runtimePackage.name === publicName) {
+                            if (this.pinned[publicName] && this.pinned[publicName] !== runtimePackage.version) {
+                                throw new Error(`Deno capture references multiple versions of ${publicName}.`);
+                            }
+                            this.pinned[publicName] = runtimePackage.version;
+                        }
+                        const suffix = (code && /^npm:\/?(?:@[^/]+\/[^/@]+|[^/@]+)@[^/]+(.*)$/.exec(code)?.[1])
+                            || (spec.startsWith(publicName + '/') ? spec.slice(publicName.length) : '');
+                        return publicName + suffix;
+                    }
+                    const plain = spec.replace(/^npm:/, '').replace(/(@[^/]+\/[^/@]+|^[^/@]+)@[^/]+/, '$1');
+                    let result;
+                    if (plain === pkg.name || plain.startsWith(`${pkg.name}/`))
+                        result = plain;
+                    else {
+                        const relative = './' + path.relative(dir, target).split(path.sep).join('/');
+                        const contains = (value) => typeof value === 'string' ? value === relative : !!value && typeof value === 'object' && Object.values(value).some(contains);
+                        if (pkg.exports && typeof pkg.exports === 'object') {
+                            for (const [entry, value] of Object.entries(pkg.exports)) {
+                                if (entry.startsWith('.') && contains(value))
+                                    result = pkg.name + (entry === '.' ? '' : entry.slice(1));
+                            }
+                        }
+                        if (!result && contains(pkg.exports))
+                            result = pkg.name;
+                    }
+                    if (result)
+                        this.externalNames.set(key, result);
+                    return result;
+                }
+            }
+            dir = path.dirname(dir);
+        }
+        return undefined;
+    }
+    /** Relocate Deno's per-file resolutions into the portable declaration tree. */
+    rewrite(typesDir, files, sourceByEmitted) {
+        let count = 0;
+        const emittedBySource = new Map([...sourceByEmitted].map(([rel, source]) => [path.resolve(source), rel]));
+        for (const rel of files) {
+            const from = sourceByEmitted.get(rel);
+            if (!from)
+                continue;
+            const file = path.join(typesDir, rel);
+            const result = rewriteSpecifiers(fs.readFileSync(file, 'utf8'), spec => {
+                const target = this.resolve(spec, from, this.parsed.options)?.resolvedFileName;
+                if (!target)
+                    return undefined;
+                if (this.isNpmFile(target))
+                    return this.externalName(spec, target, from);
+                const dest = emittedBySource.get(path.resolve(target));
+                if (!dest)
+                    return undefined;
+                let relative = path.posix.relative(path.posix.dirname(rel), dest).replace(/\.d\.(ts|mts|cts)$/, '');
+                if (!relative.startsWith('.'))
+                    relative = './' + relative;
+                return relative;
+            });
+            if (result.rewrites)
+                fs.writeFileSync(file, result.text);
+            count += result.rewrites;
+        }
+        const runtime = this.globals.find(file => path.basename(file) === 'runtime.d.ts');
+        const runtimeRel = runtime && emittedBySource.get(path.resolve(runtime));
+        if (runtimeRel)
+            isolateRuntime(typesDir, files, runtimeRel);
+        const references = this.globals.filter(file => file !== runtime)
+            .map(file => emittedBySource.get(path.resolve(file)))
+            .filter((file) => file !== undefined)
+            .map(file => `/// <reference path=${JSON.stringify('./' + file)} />`);
+        if (references.length) {
+            const surface = path.join(typesDir, 'surface.d.ts');
+            fs.writeFileSync(surface, references.join('\n') + '\n' + fs.readFileSync(surface, 'utf8'));
+        }
+        return count;
+    }
+}
+/** Runtime declarations belong to their producer, not the checker's globals. */
+function isolateRuntime(typesDir, files, runtimeRel) {
+    const runtimePath = path.join(typesDir, runtimeRel);
+    const program = ts.createProgram(files.map(file => path.join(typesDir, file)), {
+        strict: true, skipLibCheck: true, target: ts.ScriptTarget.ESNext,
+        module: ts.ModuleKind.ESNext, moduleResolution: ts.ModuleResolutionKind.Bundler,
+        types: [],
+    });
+    const checker = program.getTypeChecker();
+    const runtime = program.getSourceFile(runtimePath);
+    const retained = new Set();
+    const pending = [];
+    const retainSymbol = (node) => {
+        if (ts.isIdentifier(node) && ts.isQualifiedName(node.parent) && node.parent.left === node)
+            return;
+        const symbol = checker.getSymbolAtLocation(node);
+        // Runtime additions to standard library interfaces retain the compiler's
+        // merged standard type; they cannot become a standalone shadow interface.
+        if (symbol?.declarations?.some(d => program.isSourceFileDefaultLibrary(d.getSourceFile())))
+            return;
+        for (const declaration of symbol?.declarations ?? []) {
+            if (declaration.getSourceFile() !== runtime)
+                continue;
+            let statement = declaration;
+            while (statement.parent && !ts.isSourceFile(statement.parent) && !ts.isModuleBlock(statement.parent))
+                statement = statement.parent;
+            if (ts.isStatement(statement) && !retained.has(statement)) {
+                retained.add(statement);
+                pending.push(statement);
+            }
+        }
+    };
+    for (const rel of files) {
+        if (rel === runtimeRel)
+            continue;
+        const file = path.join(typesDir, rel);
+        const source = program.getSourceFile(file);
+        if (!source)
+            continue;
+        let specifier = path.posix.relative(path.posix.dirname(rel), runtimeRel).replace(/\.d\.ts$/, '');
+        if (!specifier.startsWith('.'))
+            specifier = './' + specifier;
+        const edits = [];
+        const visit = (node) => {
+            if (ts.isIdentifier(node) || ts.isQualifiedName(node))
+                retainSymbol(node);
+            if (ts.isIdentifier(node)) {
+                const symbol = checker.getSymbolAtLocation(node);
+                const declarations = symbol?.declarations;
+                if (declarations?.some(d => d.getSourceFile() === runtime) &&
+                    !declarations.some(d => program.isSourceFileDefaultLibrary(d.getSourceFile())) &&
+                    // Only a type's root identifier, never a property or a declaration.
+                    ((ts.isTypeReferenceNode(node.parent) && node.parent.typeName === node) ||
+                        (ts.isQualifiedName(node.parent) && node.parent.left === node) ||
+                        (ts.isTypeQueryNode(node.parent) && node.parent.exprName === node))) {
+                    edits.push({ start: node.getStart(source), end: node.getEnd(), text: `import(${JSON.stringify(specifier)}).${node.text}` });
+                }
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(source);
+        let text = source.text;
+        for (const edit of edits.sort((a, b) => b.start - a.start))
+            text = text.slice(0, edit.start) + edit.text + text.slice(edit.end);
+        if (edits.length)
+            fs.writeFileSync(file, text);
+    }
+    while (pending.length) {
+        const visit = (node) => {
+            if (ts.isIdentifier(node) || ts.isQualifiedName(node))
+                retainSymbol(node);
+            ts.forEachChild(node, visit);
+        };
+        visit(pending.pop());
+    }
+    const prune = (statement) => {
+        if (ts.isModuleDeclaration(statement) && statement.body && ts.isModuleBlock(statement.body)) {
+            const children = statement.body.statements.map(prune).filter((s) => s !== undefined);
+            if (!children.length && !retained.has(statement))
+                return undefined;
+            return ts.factory.updateModuleDeclaration(statement, statement.modifiers, statement.name, ts.factory.updateModuleBlock(statement.body, children));
+        }
+        return retained.has(statement) ? statement : undefined;
+    };
+    const statements = runtime.statements.map(prune).filter((s) => s !== undefined);
+    const names = new Set();
+    for (const statement of statements) {
+        if (ts.isVariableStatement(statement)) {
+            for (const declaration of statement.declarationList.declarations) {
+                if (ts.isIdentifier(declaration.name))
+                    names.add(declaration.name.text);
+            }
+        }
+        else if ((ts.isInterfaceDeclaration(statement) || ts.isTypeAliasDeclaration(statement) ||
+            ts.isModuleDeclaration(statement) || ts.isClassDeclaration(statement) ||
+            ts.isFunctionDeclaration(statement) || ts.isEnumDeclaration(statement)) && statement.name && ts.isIdentifier(statement.name)) {
+            names.add(statement.name.text);
+        }
+    }
+    const text = ts.createPrinter().printFile(ts.factory.updateSourceFile(runtime, statements));
+    fs.writeFileSync(runtimePath, '// Runtime declarations from deno types. Copyright the Deno authors. MIT license.\n/// <reference lib="esnext" />\n' + text + `\nexport { ${[...names].sort().join(', ')} };\n`);
+}

package/sidecar/dist/src/capture/index.d.ts

@@ -29,6 +29,7 @@
  */
 import type { CaptureStubOptions, CaptureStubResult } from './api.js';
 export type { CaptureStubOptions, CaptureStubResult } from './api.js';
+export { DenoProject, findDenoConfig } from './deno-project.js';
 export { runCheck } from './check.js';
 export type { CheckProgress } from './check.js';
 /** Same normalization intent as bundle_file_stems on the Rust side. */