@loomhelix/deptrail 0.1.0

package/dist/actions/text-diff.js

@@ -0,0 +1,203 @@
+export const DIFF_CONTEXT_LINES = 3;
+export const MAX_EDIT_DISTANCE = 4000;
+const NO_NEWLINE_MARKER = '\';
+const LINE_PREFIX = { equal: ' ', remove: '-', add: '+' };
+function splitLines(text) {
+    if (text === null || text === '')
+        return { lines: [], keys: [], lastLineUnterminated: false };
+    const lines = text.split('\n');
+    const lastLineUnterminated = lines[lines.length - 1] !== '';
+    if (!lastLineUnterminated)
+        lines.pop();
+    const keys = lines.slice();
+    if (lastLineUnterminated)
+        keys[keys.length - 1] += '\n';
+    return { lines, keys, lastLineUnterminated };
+}
+function commonPrefixLength(before, after) {
+    const limit = Math.min(before.length, after.length);
+    let length = 0;
+    while (length < limit && before[length] === after[length])
+        length++;
+    return length;
+}
+function commonSuffixLength(before, after, prefix) {
+    const limit = Math.min(before.length, after.length) - prefix;
+    let length = 0;
+    while (length < limit && before[before.length - 1 - length] === after[after.length - 1 - length])
+        length++;
+    return length;
+}
+function replacementOperations(removedCount, addedCount, oldOffset, newOffset) {
+    const operations = [];
+    for (let index = 0; index < removedCount; index++) {
+        operations.push({ kind: 'remove', oldIndex: oldOffset + index, newIndex: newOffset });
+    }
+    for (let index = 0; index < addedCount; index++) {
+        operations.push({ kind: 'add', oldIndex: oldOffset + removedCount, newIndex: newOffset + index });
+    }
+    return operations;
+}
+function myersTrace(before, after, maxDistance) {
+    const beforeLength = before.length;
+    const afterLength = after.length;
+    const limit = Math.min(beforeLength + afterLength, maxDistance);
+    const offset = limit + 1;
+    const furthest = new Int32Array(2 * limit + 3);
+    const trace = [];
+    for (let distance = 0; distance <= limit; distance++) {
+        const snapshot = new Int32Array(distance + 1);
+        for (let diagonal = -distance; diagonal <= distance; diagonal += 2) {
+            let x;
+            if (diagonal === -distance || (diagonal !== distance && furthest[offset + diagonal - 1] < furthest[offset + diagonal + 1])) {
+                x = furthest[offset + diagonal + 1];
+            }
+            else {
+                x = furthest[offset + diagonal - 1] + 1;
+            }
+            let y = x - diagonal;
+            while (x < beforeLength && y < afterLength && before[x] === after[y]) {
+                x++;
+                y++;
+            }
+            furthest[offset + diagonal] = x;
+            snapshot[(diagonal + distance) / 2] = x;
+            if (x >= beforeLength && y >= afterLength) {
+                trace.push(snapshot);
+                return trace;
+            }
+        }
+        trace.push(snapshot);
+    }
+    return null;
+}
+function operationsFromTrace(trace, beforeLength, afterLength) {
+    const reversed = [];
+    let x = beforeLength;
+    let y = afterLength;
+    for (let distance = trace.length - 1; distance >= 0; distance--) {
+        const diagonal = x - y;
+        let previousX = 0;
+        let previousY = 0;
+        let editFromRemoval = false;
+        if (distance > 0) {
+            const previous = trace[distance - 1];
+            const valueAt = (k) => previous[(k + distance - 1) / 2];
+            const cameFromAbove = diagonal === -distance || (diagonal !== distance && valueAt(diagonal - 1) < valueAt(diagonal + 1));
+            const previousDiagonal = cameFromAbove ? diagonal + 1 : diagonal - 1;
+            previousX = valueAt(previousDiagonal);
+            previousY = previousX - previousDiagonal;
+            editFromRemoval = !cameFromAbove;
+        }
+        const snakeStartX = distance > 0 ? (editFromRemoval ? previousX + 1 : previousX) : 0;
+        while (x > snakeStartX) {
+            x--;
+            y--;
+            reversed.push({ kind: 'equal', oldIndex: x, newIndex: y });
+        }
+        if (distance > 0) {
+            if (editFromRemoval) {
+                reversed.push({ kind: 'remove', oldIndex: previousX, newIndex: previousY });
+            }
+            else {
+                reversed.push({ kind: 'add', oldIndex: previousX, newIndex: previousY });
+            }
+            x = previousX;
+            y = previousY;
+        }
+    }
+    return reversed.reverse();
+}
+function diffOperations(before, after) {
+    const prefix = commonPrefixLength(before, after);
+    const suffix = commonSuffixLength(before, after, prefix);
+    const middleBefore = before.slice(prefix, before.length - suffix);
+    const middleAfter = after.slice(prefix, after.length - suffix);
+    const operations = [];
+    for (let index = 0; index < prefix; index++)
+        operations.push({ kind: 'equal', oldIndex: index, newIndex: index });
+    const trace = myersTrace(middleBefore, middleAfter, MAX_EDIT_DISTANCE);
+    const middle = trace
+        ? operationsFromTrace(trace, middleBefore.length, middleAfter.length)
+        : replacementOperations(middleBefore.length, middleAfter.length, 0, 0);
+    for (const operation of middle) {
+        operations.push({ kind: operation.kind, oldIndex: operation.oldIndex + prefix, newIndex: operation.newIndex + prefix });
+    }
+    for (let index = 0; index < suffix; index++) {
+        operations.push({
+            kind: 'equal',
+            oldIndex: before.length - suffix + index,
+            newIndex: after.length - suffix + index
+        });
+    }
+    return operations;
+}
+function hunkRanges(operations) {
+    const ranges = [];
+    let current = null;
+    for (let index = 0; index < operations.length; index++) {
+        if (operations[index].kind === 'equal')
+            continue;
+        const start = Math.max(0, index - DIFF_CONTEXT_LINES);
+        const end = Math.min(operations.length, index + DIFF_CONTEXT_LINES + 1);
+        if (current && start <= current[1]) {
+            current[1] = end;
+        }
+        else {
+            current = [start, end];
+            ranges.push(current);
+        }
+    }
+    return ranges;
+}
+function rangeText(start, count) {
+    if (count === 1)
+        return String(start);
+    return `${start},${count}`;
+}
+function hunkHeader(slice) {
+    const oldCount = slice.filter((operation) => operation.kind !== 'add').length;
+    const newCount = slice.filter((operation) => operation.kind !== 'remove').length;
+    const oldStart = oldCount === 0 ? slice[0].oldIndex : slice[0].oldIndex + 1;
+    const newStart = newCount === 0 ? slice[0].newIndex : slice[0].newIndex + 1;
+    return `@@ -${rangeText(oldStart, oldCount)} +${rangeText(newStart, newCount)} @@`;
+}
+function renderHunk(slice, before, after) {
+    const output = [hunkHeader(slice)];
+    for (const operation of slice) {
+        const source = operation.kind === 'add' ? after : before;
+        const index = operation.kind === 'add' ? operation.newIndex : operation.oldIndex;
+        output.push(LINE_PREFIX[operation.kind] + source.lines[index]);
+        if (source.lastLineUnterminated && index === source.lines.length - 1)
+            output.push(NO_NEWLINE_MARKER);
+    }
+    return output;
+}
+export function unifiedDiff(path, beforeText, afterText) {
+    if (beforeText === afterText)
+        return { diff: '', added: 0, removed: 0 };
+    const before = splitLines(beforeText);
+    const after = splitLines(afterText);
+    const operations = diffOperations(before.keys, after.keys);
+    const ranges = hunkRanges(operations);
+    if (ranges.length === 0)
+        return { diff: '', added: 0, removed: 0 };
+    const output = [
+        beforeText === null ? '--- /dev/null' : `--- a/${path}`,
+        afterText === null ? '+++ /dev/null' : `+++ b/${path}`
+    ];
+    for (const [start, end] of ranges)
+        output.push(...renderHunk(operations.slice(start, end), before, after));
+    const added = operations.filter((operation) => operation.kind === 'add').length;
+    const removed = operations.filter((operation) => operation.kind === 'remove').length;
+    return { diff: output.join('\n') + '\n', added, removed };
+}
+export function truncateUtf8(text, maxBytes) {
+    const bytes = Buffer.from(text, 'utf8');
+    if (bytes.length <= maxBytes)
+        return { text, truncated: false };
+    const lastLineBreak = bytes.subarray(0, maxBytes).lastIndexOf(0x0a);
+    if (lastLineBreak < 0)
+        return { text: '', truncated: true };
+    return { text: bytes.subarray(0, lastLineBreak + 1).toString('utf8'), truncated: true };
+}

package/dist/actions/types.js

@@ -0,0 +1 @@
+export {};

package/dist/actions/update-options.js

@@ -0,0 +1,232 @@
+import semver from 'semver';
+import { ParentLinkResolver } from "../query/dependents.js";
+import { nodeMeta, requestedRange, worstSeverity } from "../query/enrichment-lookup.js";
+import { ALL_KINDS, findNode } from "../query/lookup.js";
+import { normalizedRequestedRange } from "../query/node-fix.js";
+import { isAffected } from "../query/versions.js";
+import { relockTarget } from "./fix-options.js";
+import { importerLabel } from "./labels.js";
+import { catalogNameOf, rewriteRange } from "./range-style.js";
+import { setRangeStep } from "./set-range.js";
+const DECLARING_FIELDS = ['dependencies', 'devDependencies', 'optionalDependencies'];
+const PEER_FIELD = 'peerDependencies';
+const ALIAS_PREFIX = 'npm:';
+const VERSION_PLACEHOLDER = '<version>';
+const LATEST_TAG = 'latest';
+const DEFAULT_CATALOG = 'default';
+const MAJOR_UPDATE = 'major update';
+const EMPTY_SELECTION = 'Select at least one workspace package';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function declaredRange(manifest, field, name) {
+    const section = manifest[field];
+    if (!isRecord(section))
+        return undefined;
+    const range = section[name];
+    return typeof range === 'string' ? range : undefined;
+}
+function templateOf(specifier) {
+    const rewritten = rewriteRange(specifier, VERSION_PLACEHOLDER);
+    return rewritten.editable ? { editable: true, template: rewritten.specifier } : { editable: false, reason: rewritten.reason };
+}
+function catalogEntryOf(root, entry) {
+    const catalog = catalogNameOf(entry.specifier);
+    return catalog === undefined ? entry.specifier : root.config?.catalogs[catalog]?.[entry.key];
+}
+function editability(root, entry) {
+    const resolved = catalogEntryOf(root, entry);
+    if (resolved !== undefined)
+        return templateOf(resolved);
+    return { editable: false, reason: `the ${catalogNameOf(entry.specifier)} catalog has no entry for ${entry.key}` };
+}
+function aliasedPackageOf(specifier) {
+    if (!specifier.startsWith(ALIAS_PREFIX))
+        return undefined;
+    const versionSeparator = specifier.lastIndexOf('@');
+    return versionSeparator <= ALIAS_PREFIX.length ? specifier.slice(ALIAS_PREFIX.length) : specifier.slice(ALIAS_PREFIX.length, versionSeparator);
+}
+function declaresPackage(root, entry, name) {
+    const aliased = aliasedPackageOf(catalogEntryOf(root, entry) ?? entry.specifier);
+    return aliased === undefined ? entry.key === name : aliased === name;
+}
+function manifestEntries(manifest, field) {
+    const section = manifest[field];
+    if (!isRecord(section))
+        return [];
+    return Object.entries(section).flatMap(([key, specifier]) => (typeof specifier === 'string' ? [{ key, specifier }] : []));
+}
+function declaringEntry(root, manifest, name) {
+    for (const field of DECLARING_FIELDS) {
+        const declaring = manifestEntries(manifest, field).filter((entry) => declaresPackage(root, entry, name));
+        const entry = declaring.find((candidate) => candidate.key === name) ?? declaring[0];
+        if (entry !== undefined)
+            return { field, entry };
+    }
+    return undefined;
+}
+function declaringImporter(root, id, manifest, name) {
+    const declaring = declaringEntry(root, manifest, name);
+    if (declaring === undefined)
+        return undefined;
+    const { field, entry } = declaring;
+    const peerRange = declaredRange(manifest, PEER_FIELD, entry.key);
+    return {
+        id,
+        field,
+        ...(entry.key === name ? {} : { alias: entry.key }),
+        specifier: entry.specifier,
+        ...editability(root, entry),
+        ...(peerRange === undefined ? {} : { peerRange }),
+    };
+}
+function declaringImporters(root, name, manifests) {
+    return root.importers.flatMap((importer) => {
+        const manifest = manifests.get(importer.id);
+        const declaring = manifest === undefined ? undefined : declaringImporter(root, importer.id, manifest, name);
+        return declaring === undefined ? [] : [declaring];
+    });
+}
+function dependsDirectly(importer, node) {
+    return importer.deps.some((edge) => edge.to === node.id && edge.kind !== 'peer');
+}
+function parentRanges(view, root, node, meta) {
+    return new ParentLinkResolver(root, ALL_KINDS).of(node).flatMap((link) => {
+        const parent = findNode(root, link.id);
+        return parent === undefined ? [] : [normalizedRequestedRange(root, node, meta, requestedRange(view, root, parent, link.range, node))];
+    });
+}
+function newerReleases(meta, current) {
+    if (semver.valid(current) === null)
+        return [];
+    return meta.versions.filter((version) => semver.valid(version) !== null && semver.prerelease(version) === null && semver.gt(version, current));
+}
+function latestOf(meta, current) {
+    const latest = meta.distTags[LATEST_TAG];
+    return latest !== undefined && semver.valid(latest) !== null && latest !== current ? latest : undefined;
+}
+function packageAdvisories(view, name) {
+    const loaded = view.advisoriesOf(name);
+    return loaded.state === 'ok' || loaded.state === 'stale' ? loaded.advisories : [];
+}
+function publishedVersion(meta, advisories, version) {
+    const severity = worstSeverity(advisories.filter((advisory) => isAffected(version, advisory)).map((advisory) => advisory.severity));
+    return {
+        version,
+        ...(severity === undefined ? {} : { severity }),
+        ...(meta.deprecated[version] === undefined ? {} : { deprecated: true }),
+        ...(semver.prerelease(version) === null ? {} : { prerelease: true }),
+    };
+}
+function registryChoices(view, root, node) {
+    const meta = nodeMeta(view, root, node);
+    if (meta === undefined)
+        return { versions: [] };
+    const wanted = relockTarget(parentRanges(view, root, node, meta), newerReleases(meta, node.version));
+    const latest = latestOf(meta, node.version);
+    const advisories = packageAdvisories(view, node.name);
+    return {
+        ...(wanted === undefined ? {} : { wanted }),
+        ...(latest === undefined ? {} : { latest }),
+        versions: meta.versions
+            .filter((version) => semver.valid(version) !== null)
+            .sort(semver.rcompare)
+            .map((version) => publishedVersion(meta, advisories, version)),
+    };
+}
+export function updateActions(context, node, manifests) {
+    const { view, root } = context;
+    if (!root.importers.some((importer) => dependsDirectly(importer, node)))
+        return undefined;
+    return { name: node.name, current: node.version, ...registryChoices(view, root, node), importers: declaringImporters(root, node.name, manifests) };
+}
+function majorWarnings(current, target) {
+    if (semver.valid(current) === null || semver.valid(target) === null)
+        return [];
+    return semver.major(target) > semver.major(current) ? [MAJOR_UPDATE] : [];
+}
+function peerWarnings(selected) {
+    return selected.flatMap((importer) => (importer.peerRange === undefined ? [] : [`${importerLabel(importer.id)}: peerDependencies ${importer.peerRange} unchanged`]));
+}
+function locksCurrent(root, importer, update) {
+    return importer.deps.some((edge) => {
+        const target = root.packages.get(edge.to);
+        return edge.kind !== 'peer' && target?.name === update.name && target.version === update.current;
+    });
+}
+function lockingImporters(root, update) {
+    return root.importers.filter((importer) => locksCurrent(root, importer, update)).map((importer) => importer.id);
+}
+function wantedPlan(update, root) {
+    const wanted = update.wanted;
+    if (wanted === undefined)
+        return { error: `${update.name} has no newer version within its ranges` };
+    return {
+        goal: { kind: 'update', name: update.name, importers: lockingImporters(root, update), target: wanted },
+        steps: [{ kind: 'relock', name: update.name, from: update.current, to: wanted, reason: `every requesting range accepts ${wanted}` }],
+        warnings: majorWarnings(update.current, wanted),
+    };
+}
+function targetVersion(update, choice, version) {
+    const target = choice === 'latest' ? update.latest : version;
+    if (target === undefined)
+        return { error: choice === 'latest' ? `${update.name} has no latest version to update to` : `Select a version of ${update.name}` };
+    if (!update.versions.some((entry) => entry.version === target))
+        return { error: `${target} is not a published version of ${update.name}` };
+    if (target === update.current)
+        return { error: `${target} is the current version` };
+    return { version: target };
+}
+function selectedImporters(update, ids) {
+    const requested = new Set(ids);
+    if (requested.size === 0)
+        return { error: EMPTY_SELECTION };
+    for (const id of requested) {
+        const declaring = update.importers.find((importer) => importer.id === id);
+        if (declaring === undefined)
+            return { error: `${id} does not declare ${update.name}` };
+        if (!declaring.editable)
+            return { error: `${id}: ${declaring.reason}` };
+    }
+    return { importers: update.importers.filter((importer) => requested.has(importer.id)) };
+}
+function catalogEntryKey(step) {
+    return step.place === 'catalog' ? `${step.catalog ?? DEFAULT_CATALOG}\0${step.dependency}` : undefined;
+}
+function rangeReason(choice, update, target) {
+    return choice === 'latest' ? `${target} is the latest version of ${update.name}` : `${target} is the selected version of ${update.name}`;
+}
+function rangePlan(update, root, choice, target, selected) {
+    const reason = rangeReason(choice, update, target);
+    const steps = [];
+    const editedCatalogEntries = new Set();
+    for (const importer of selected) {
+        const dependency = importer.alias ?? update.name;
+        const result = setRangeStep(root, { importer: importer.id, field: importer.field, dependency, specifier: importer.specifier, target, reason });
+        if ('unavailable' in result)
+            return { error: result.unavailable };
+        const catalogEntry = catalogEntryKey(result.step);
+        if (catalogEntry !== undefined) {
+            if (editedCatalogEntries.has(catalogEntry))
+                continue;
+            editedCatalogEntries.add(catalogEntry);
+        }
+        steps.push(result.step);
+    }
+    return {
+        goal: { kind: 'update', name: update.name, importers: selected.map((importer) => importer.id), target },
+        steps,
+        warnings: [...majorWarnings(update.current, target), ...peerWarnings(selected)],
+    };
+}
+export function updateSteps(update, root, choice, version, importers) {
+    if (choice === 'wanted')
+        return wantedPlan(update, root);
+    const target = targetVersion(update, choice, version);
+    if ('error' in target)
+        return target;
+    const selected = selectedImporters(update, importers);
+    if ('error' in selected)
+        return selected;
+    return rangePlan(update, root, choice, target.version, selected.importers);
+}

package/dist/actions/workspace-edit.js

@@ -0,0 +1,33 @@
+import { isMap, isScalar, parseDocument, YAMLMap } from 'yaml';
+export class WorkspaceEditError extends Error {
+}
+const UNINDENTED_SEQUENCE = /^( *)[^\s#-][^\n]*:[ \t]*(?:#[^\n]*)?\r?\n\1- /m;
+const INDENTED_MAPPING_LINE = /^( +)[^\s#-][^\n]*:/m;
+const DEFAULT_INDENT = 2;
+function indentOf(source) {
+    return INDENTED_MAPPING_LINE.exec(source)?.[1].length ?? DEFAULT_INDENT;
+}
+function prepareIntermediateMaps(document, path) {
+    if (document.contents !== null && !isMap(document.contents)) {
+        throw new WorkspaceEditError('The workspace file is not a map');
+    }
+    for (let length = 1; length < path.length; length++) {
+        const prefix = path.slice(0, length);
+        const node = document.getIn(prefix, true);
+        if (node === undefined)
+            return;
+        if (isScalar(node) && node.value === null)
+            document.setIn(prefix, new YAMLMap());
+        else if (!isMap(node))
+            throw new WorkspaceEditError(`${prefix.join('.')} is not a map`);
+    }
+}
+export function setWorkspaceString(text, path, value) {
+    const source = text ?? '';
+    const document = parseDocument(source);
+    if (document.errors.length > 0)
+        throw new WorkspaceEditError(document.errors[0].message);
+    prepareIntermediateMaps(document, path);
+    document.setIn(path, value);
+    return document.toString({ lineWidth: 0, indent: indentOf(source), indentSeq: !UNINDENTED_SEQUENCE.test(source) });
+}

package/dist/adapters/command-runner.js

@@ -0,0 +1,127 @@
+import { spawn } from 'node:child_process';
+import { StringDecoder } from 'node:string_decoder';
+const DEFAULT_TIMEOUT_MS = 5 * 60 * 1000;
+const KILL_GRACE_MS = 5000;
+const TIMED_OUT_EXIT_CODE = 124;
+const NOT_STARTED_EXIT_CODE = 1;
+function terminate(child) {
+    if (child.pid === undefined)
+        return;
+    child.kill('SIGTERM');
+    setTimeout(() => child.kill('SIGKILL'), KILL_GRACE_MS).unref();
+}
+export function createSpawnRunner(options) {
+    const running = new Set();
+    const run = (command, args, cwd) => new Promise((resolve, reject) => {
+        const child = spawn(command, args, { cwd, shell: false });
+        running.add(child);
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            terminate(child);
+        }, options.timeoutMs);
+        const settle = () => {
+            clearTimeout(timer);
+            running.delete(child);
+        };
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        child.stdout.on('data', (chunk) => stdoutChunks.push(chunk));
+        child.stderr.on('data', (chunk) => stderrChunks.push(chunk));
+        child.on('error', (error) => {
+            settle();
+            reject(error);
+        });
+        child.on('close', (code) => {
+            settle();
+            const stderr = Buffer.concat(stderrChunks).toString('utf8');
+            resolve({
+                code: timedOut ? TIMED_OUT_EXIT_CODE : (code ?? 1),
+                stdout: Buffer.concat(stdoutChunks).toString('utf8'),
+                stderr: timedOut ? `${stderr}\n${command} timed out after ${options.timeoutMs} ms` : stderr,
+            });
+        });
+    });
+    return Object.assign(run, {
+        killRunning() {
+            for (const child of running)
+                terminate(child);
+        },
+    });
+}
+function createLineSplitter(onLine) {
+    const decoder = new StringDecoder('utf8');
+    let pending = '';
+    const emit = (line) => onLine?.(line.endsWith('\r') ? line.slice(0, -1) : line);
+    return {
+        write(chunk) {
+            const text = decoder.write(chunk);
+            const parts = (pending + text).split('\n');
+            pending = parts.pop() ?? '';
+            for (const line of parts)
+                emit(line);
+            return text;
+        },
+        flush() {
+            const rest = pending + decoder.end();
+            pending = '';
+            if (rest !== '')
+                emit(rest);
+        },
+    };
+}
+export function createProcessRunner() {
+    const running = new Set();
+    const run = (request) => {
+        if (request.signal?.aborted)
+            return Promise.resolve({ code: NOT_STARTED_EXIT_CODE, stdout: '', stderr: '', timedOut: false, cancelled: true });
+        return new Promise((resolve, reject) => {
+            const child = spawn(request.command, [...request.args], { cwd: request.cwd, env: request.env, shell: false });
+            running.add(child);
+            let timedOut = false;
+            let cancelled = false;
+            const timer = setTimeout(() => {
+                timedOut = true;
+                terminate(child);
+            }, request.timeoutMs);
+            const cancel = () => {
+                cancelled = true;
+                terminate(child);
+            };
+            request.signal?.addEventListener('abort', cancel, { once: true });
+            const settle = () => {
+                clearTimeout(timer);
+                request.signal?.removeEventListener('abort', cancel);
+                running.delete(child);
+            };
+            const stdoutSplitter = createLineSplitter(request.onLine);
+            const stderrSplitter = createLineSplitter(request.onLine);
+            let stdout = '';
+            let stderr = '';
+            child.stdout.on('data', (chunk) => {
+                stdout += stdoutSplitter.write(chunk);
+            });
+            child.stderr.on('data', (chunk) => {
+                stderr += stderrSplitter.write(chunk);
+            });
+            child.on('error', (error) => {
+                settle();
+                reject(error);
+            });
+            child.on('close', (code) => {
+                settle();
+                stdoutSplitter.flush();
+                stderrSplitter.flush();
+                resolve({ code: timedOut ? TIMED_OUT_EXIT_CODE : (code ?? 1), stdout, stderr, timedOut, cancelled });
+            });
+        });
+    };
+    return {
+        run,
+        killRunning() {
+            for (const child of running)
+                terminate(child);
+        },
+    };
+}
+export const spawnRunner = createSpawnRunner({ timeoutMs: DEFAULT_TIMEOUT_MS });

package/dist/adapters/manifest-only.js

@@ -0,0 +1,20 @@
+import { IMPORTER_BLOCKS, declaredDependencies, importerKeyOf, isNonRegistrySpec, readManifest } from "./package-manifest.js";
+export async function buildManifestOnly(reader, root, builder) {
+    for (const importerPath of root.importerPaths) {
+        const importerKey = importerKeyOf(root, importerPath);
+        const read = await readManifest(reader, importerPath);
+        if ('problem' in read) {
+            builder.warn(read.problem);
+            builder.addImporter(importerKey, importerKey);
+            continue;
+        }
+        const importerId = builder.addImporter(importerKey, read.manifest.name ?? importerKey);
+        for (const { name, range, kind } of declaredDependencies(read.manifest, IMPORTER_BLOCKS)) {
+            const packageId = `${name}@${range}`;
+            builder.addPackage(packageId, name, range);
+            if (isNonRegistrySpec(range))
+                builder.markNonRegistry(packageId);
+            builder.addEdge(importerId, { to: packageId, kind, range });
+        }
+    }
+}