@agentage/cli 0.39.0 → 0.41.0

package/dist/core/installer/compare-lock.js

@@ -0,0 +1,51 @@
+import { isRecord } from '../../lib/fs/json-file.js';
+const NODE_MODULES = 'node_modules/';
+const text = (value) => (typeof value === 'string' ? value : '');
+export const parseLock = (raw) => {
+    if (raw === null)
+        return null;
+    try {
+        const value = JSON.parse(raw);
+        return isRecord(value) && isRecord(value['packages']) ? value : null;
+    }
+    catch {
+        return null;
+    }
+};
+const packagesOf = (lock) => (isRecord(lock['packages']) ? lock['packages'] : {});
+// Nested and hoisted copies are the same package: only the name after the last node_modules/.
+const nameAt = (path, entry) => {
+    const name = text(entry['name']) || path.slice(path.lastIndexOf(NODE_MODULES) + NODE_MODULES.length);
+    return `${name}@${text(entry['version'])}`;
+};
+const entryKey = (path, entry) => `${nameAt(path, entry)}+${text(entry['integrity'])}`;
+const installed = (lock) => Object.entries(packagesOf(lock)).filter((pair) => pair[0] !== '' && isRecord(pair[1]));
+// `resolved`, key order and the npm major's layout choices never reach the set.
+export const lockEntries = (lock) => [...new Set(installed(lock).map(([path, entry]) => entryKey(path, entry)))].sort();
+// What package.json asked npm for when it wrote this lock: name -> range or URL.
+export const rootDependencies = (lock) => {
+    const root = packagesOf(lock)[''];
+    const deps = isRecord(root) && isRecord(root['dependencies']) ? root['dependencies'] : {};
+    return Object.fromEntries(Object.entries(deps).map(([name, spec]) => [name, text(spec)]));
+};
+// The version the lock installed for a root dependency; null when it has none.
+export const lockedVersion = (lock, name) => {
+    const entry = lock === null ? null : packagesOf(lock)[`${NODE_MODULES}${name}`];
+    return isRecord(entry) && typeof entry['version'] === 'string' ? entry['version'] : null;
+};
+// npm ci refuses a lock whose root dependencies differ from package.json.
+export const lockAgrees = (lock, dependencies) => {
+    const locked = rootDependencies(lock);
+    const names = Object.keys(dependencies);
+    return (Object.keys(locked).length === names.length &&
+        names.every((name) => locked[name] === dependencies[name]));
+};
+const integrities = (lock) => new Map(installed(lock).map(([path, entry]) => [nameAt(path, entry), text(entry['integrity'])]));
+// The same name@version with another integrity: one of the two locks was changed by hand.
+export const integrityDrift = (a, b) => {
+    const theirs = integrities(b);
+    return [...integrities(a)]
+        .filter(([key, sri]) => theirs.has(key) && theirs.get(key) !== sri)
+        .map(([key]) => key)
+        .sort();
+};

package/dist/core/installer/compat.d.ts

@@ -0,0 +1,20 @@
+export interface Published {
+    version: string;
+    engine: string;
+    kit?: boolean;
+}
+export interface Compatible {
+    version: string | null;
+    skipped: Published[];
+}
+export interface Gate {
+    api: string;
+    kit: string;
+}
+export declare const cliGate: () => Gate;
+export declare const fitsApi: (engine: string, api?: string) => boolean;
+export declare const fits: (p: Omit<Published, "version">, gate?: Gate) => boolean;
+export declare const needsText: ({ engine, kit }: Omit<Published, "version">) => string;
+export declare const needs: (p: Published) => string;
+export declare const newestCompatible: (published: Published[], gate?: Gate) => Compatible;
+export declare const parsePublished: (stdout: string) => Published[] | null;

package/dist/core/installer/compat.js

@@ -0,0 +1,44 @@
+import { EXTENSION_API_VERSION } from '../../extension.js';
+import { isRecord } from '../../lib/fs/json-file.js';
+import { kitVersion } from '../kit-version.js';
+import { manifestInfo } from '../loader/manifest.js';
+import { isRange, newestFirst, satisfies } from '../semver-range.js';
+export const cliGate = () => ({ api: EXTENSION_API_VERSION, kit: kitVersion() });
+export const fitsApi = (engine, api = EXTENSION_API_VERSION) => isRange(engine) && satisfies(api, engine);
+// The gate picks the API by manifest shape.
+export const fits = (p, gate = cliGate()) => fitsApi(p.engine, p.kit ? gate.kit : gate.api);
+export const needsText = ({ engine, kit }) => `needs ${kit ? 'kit' : 'extension API'} ${engine}`;
+export const needs = (p) => `${p.version}: ${needsText(p)}`;
+// The resolver's rule: the newest version this CLI can load, instead of whatever `latest` is.
+export const newestCompatible = (published, gate = cliGate()) => {
+    const sorted = [...published].sort((a, b) => newestFirst(a.version, b.version));
+    const at = sorted.findIndex((p) => fits(p, gate));
+    if (at === -1)
+        return { version: null, skipped: sorted };
+    return { version: sorted[at]?.version ?? null, skipped: sorted.slice(0, at) };
+};
+// npm view names a nested field by its path: `agentage.parts`.
+const publishedOf = (item) => {
+    if (typeof item === 'string')
+        return { version: item, engine: manifestInfo({}).engine };
+    if (!isRecord(item) || typeof item['version'] !== 'string')
+        return null;
+    const parts = item['agentage.parts'];
+    const info = manifestInfo(parts === undefined ? item : { ...item, agentage: { parts } });
+    const kit = info.kind === 'kit' ? { kit: true } : {};
+    return { version: item['version'], engine: info.engine, ...kit };
+};
+// npm view prints one object per version, a lone object for one version, or bare versions.
+export const parsePublished = (stdout) => {
+    if (stdout.trim() === '')
+        return [];
+    let value;
+    try {
+        value = JSON.parse(stdout);
+    }
+    catch {
+        return null;
+    }
+    const items = (Array.isArray(value) ? value : [value]).map(publishedOf);
+    return items.every((p) => p !== null) ? items : null;
+};

package/dist/core/installer/installer.d.ts

@@ -0,0 +1,28 @@
+import { type Profile } from '../profile/schema.js';
+import { type Npm, type NpmCommand } from './npm.js';
+import { type TreeFiles } from './tree.js';
+export type InstallSet = Pick<Profile, 'extensions' | 'registries'> & {
+    lock?: Record<string, unknown> | null;
+};
+export interface InstallPlan extends TreeFiles {
+    extensionsDir: string;
+    install: Record<string, string>;
+    registries: Record<string, string>;
+    npm: NpmCommand | null;
+    tree: string | null;
+    reuse: boolean;
+}
+export interface InstallResult {
+    tree: string;
+    npm: NpmCommand | null;
+    reused: boolean;
+    count: number;
+}
+export declare const planInstall: (set: InstallSet) => InstallPlan;
+export declare const lastLines: (output: string, count?: number) => string;
+export declare const runNpmInto: (staging: string, command: NpmCommand, npm: Npm, packages?: string[]) => Promise<{
+    tree: string;
+    lock: string;
+}>;
+export declare const refuseDrift: (dir: string) => void;
+export declare const install: (set: InstallSet, prepare?: () => Promise<Npm>) => Promise<InstallResult>;

package/dist/core/installer/installer.js

@@ -0,0 +1,87 @@
+import { join } from 'node:path';
+import {} from '../../lib/npm/npm-cli.js';
+import { extensionsDir } from '../paths.js';
+import {} from '../profile/schema.js';
+import { lockAgrees, lockEntries, parseLock } from './compare-lock.js';
+import { prepareNpm } from './npm.js';
+import { driftLines, lockDrift } from './plan.js';
+import { clearStaging, collectTrees, commitTree, discardTree, isComplete, LOCK_FILE, manifestText, npmrcText, pointCurrent, promoteFiles, readText, sortedSet, stageTree, treeName, withInstallLock, } from './tree.js';
+// The current lock rides into the staged tree, so npm keeps every pin it can.
+const lockPlan = (dir, install, raw) => {
+    if (Object.keys(install).length === 0) {
+        const tree = treeName([]);
+        return { lock: null, npm: null, tree, reuse: isComplete(dir, tree) };
+    }
+    const lock = parseLock(raw);
+    if (lock === null)
+        return { lock: null, npm: 'install', tree: null, reuse: false };
+    if (!lockAgrees(lock, install))
+        return { lock: raw, npm: 'install', tree: null, reuse: false };
+    const tree = treeName(lockEntries(lock));
+    const reuse = isComplete(dir, tree);
+    return { lock: raw, npm: reuse ? null : 'ci', tree, reuse };
+};
+// Reads only: `setup --dry-run` prints this and stops.
+export const planInstall = (set) => {
+    const dir = extensionsDir();
+    const install = sortedSet(set.extensions);
+    const registries = sortedSet(set.registries);
+    const files = { manifest: manifestText(install), npmrc: npmrcText(registries) };
+    const raw = set.lock ? `${JSON.stringify(set.lock, null, 2)}\n` : readText(join(dir, LOCK_FILE));
+    const lock = lockPlan(dir, install, raw);
+    return { extensionsDir: dir, install, registries, ...files, ...lock };
+};
+// npm's last lines, enough to see why it failed.
+export const lastLines = (output, count = 20) => output
+    .split(/\r?\n/)
+    .filter((line) => line.trim() !== '')
+    .slice(-count)
+    .join('\n');
+const npmFailure = (command, res) => new Error(`npm ${command} failed (exit ${res.code}); extensions/current is unchanged\n` +
+    lastLines(`${res.stdout}\n${res.stderr}`));
+// The staged tree's name and lock text, once npm succeeded in it; `packages` limits an update.
+export const runNpmInto = async (staging, command, npm, packages = []) => {
+    const res = await npm(command, staging, packages);
+    if (res.code !== 0)
+        throw npmFailure(command, res);
+    const lock = readText(join(staging, LOCK_FILE));
+    const parsed = parseLock(lock);
+    if (lock === null || parsed === null)
+        throw new Error(`npm ${command} wrote no usable ${LOCK_FILE}`);
+    return { tree: treeName(lockEntries(parsed)), lock };
+};
+const build = async (plan, prepare) => {
+    const npm = plan.npm === null ? null : await prepare();
+    const staging = stageTree(plan.extensionsDir, plan);
+    try {
+        const built = npm === null || plan.npm === null
+            ? { tree: treeName([]), lock: null }
+            : await runNpmInto(staging, plan.npm, npm);
+        commitTree(plan.extensionsDir, staging, built.tree);
+        return built;
+    }
+    catch (err) {
+        discardTree(staging);
+        throw err;
+    }
+};
+// A lock that disagrees with its own tree on a package's bytes is never built on.
+export const refuseDrift = (dir) => {
+    const { integrity } = lockDrift(dir);
+    if (integrity.length > 0)
+        throw new Error(driftLines(integrity).join('\n'));
+};
+const execute = async (plan, prepare) => {
+    refuseDrift(plan.extensionsDir);
+    clearStaging(plan.extensionsDir);
+    const built = plan.reuse && plan.tree !== null
+        ? { tree: plan.tree, lock: plan.lock }
+        : await build(plan, prepare);
+    pointCurrent(plan.extensionsDir, built.tree);
+    promoteFiles(plan.extensionsDir, { manifest: plan.manifest, lock: built.lock });
+    collectTrees(plan.extensionsDir, built.tree);
+    const count = Object.keys(plan.install).length;
+    return { tree: built.tree, npm: plan.npm, reused: plan.reuse, count };
+};
+// Plans again under the lock: a run that waited sees the tree the first one built.
+export const install = async (set, prepare = prepareNpm) => withInstallLock(extensionsDir(), () => execute(planInstall(set), prepare));

package/dist/core/installer/latest.d.ts

@@ -0,0 +1,27 @@
+import { type InstallSet } from './installer.js';
+import { type Npm } from './npm.js';
+export interface VersionChange {
+    name: string;
+    from: string | null;
+    to: string | null;
+}
+export interface Held {
+    name: string;
+    version: string;
+    newer: string;
+    engine: string;
+    kit: boolean;
+}
+export interface LatestResult {
+    changes: VersionChange[];
+    held: Held[];
+    unchanged: number;
+    tree: string | null;
+    current: boolean;
+}
+export type Staged = Omit<LatestResult, 'tree' | 'current'> & {
+    tree: string;
+    dir: string;
+};
+export type Check = (staged: Staged) => Promise<boolean>;
+export declare const updateLatest: (set: InstallSet, prepare: () => Promise<Npm>, check: Check) => Promise<LatestResult>;

package/dist/core/installer/latest.js

@@ -0,0 +1,90 @@
+import { join } from 'node:path';
+import { isRecord, readJson } from '../../lib/fs/json-file.js';
+import { manifestInfo } from '../loader/manifest.js';
+import { extensionsDir } from '../paths.js';
+import { fits } from './compat.js';
+import { lockEntries, lockedVersion, parseLock, rootDependencies } from './compare-lock.js';
+import { planInstall, refuseDrift, runNpmInto, } from './installer.js';
+import {} from './npm.js';
+import { clearStaging, collectTrees, commitTree, discardTree, pointCurrent, promoteFiles, readText, stageTree, treePath, withInstallLock, } from './tree.js';
+const diff = (names, before, after) => names
+    .map((name) => ({ name, from: lockedVersion(before, name), to: lockedVersion(after, name) }))
+    .filter((change) => change.from !== change.to);
+// Every extension the profile names or the old lock installed, sorted.
+const namesOf = (plan, before) => {
+    const installed = before === null ? [] : Object.keys(rootDependencies(before));
+    return [...new Set([...Object.keys(plan.install), ...installed])].sort();
+};
+const update = async (plan, npm, packages = []) => {
+    const staging = stageTree(plan.extensionsDir, plan);
+    try {
+        const { tree, lock } = await runNpmInto(staging, 'update', npm, packages);
+        return { staging, tree, lock: parseLock(lock), raw: lock };
+    }
+    catch (err) {
+        discardTree(staging);
+        throw err;
+    }
+};
+const engineIn = (staging, name) => {
+    const info = manifestInfo(readJson(join(staging, 'node_modules', name, 'package.json'), isRecord) ?? {});
+    return { engine: info.engine, kit: info.kind === 'kit' };
+};
+// An extension whose new version needs another extension API stays where it was.
+const heldIn = (built, changes) => changes.flatMap(({ name, from, to }) => {
+    if (from === null || to === null)
+        return [];
+    const range = engineIn(built.staging, name);
+    return fits(range) ? [] : [{ name, version: from, newer: to, ...range }];
+});
+const unchanged = (plan, changes) => Object.keys(plan.install).filter((name) => !changes.some((c) => c.name === name)).length;
+// One update; when it moved an extension past the extension API, again without moving that one.
+const settle = async (plan, npm, names, before) => {
+    const first = await update(plan, npm);
+    const changes = diff(names, before, first.lock);
+    const held = heldIn(first, changes);
+    if (held.length === 0)
+        return { built: first, held };
+    discardTree(first.staging);
+    const moving = changes.map((c) => c.name).filter((name) => !held.some((h) => h.name === name));
+    return { built: moving.length === 0 ? null : await update(plan, npm, moving), held };
+};
+const sameEntries = (a, b) => (a ? lockEntries(a).join('\n') : '') === (b ? lockEntries(b).join('\n') : '');
+// A tree that failed its check goes, unless extensions/current already names it.
+const dropUnlessCurrent = (dir, tree) => {
+    if (readText(join(dir, 'current'))?.trim() !== tree)
+        discardTree(treePath(dir, tree));
+};
+// The new tree becomes current only once it passed the check; then it is the only tree left.
+const commit = async (plan, built, staged, check) => {
+    commitTree(plan.extensionsDir, built.staging, built.tree);
+    if (!(await check(staged))) {
+        dropUnlessCurrent(plan.extensionsDir, built.tree);
+        return false;
+    }
+    pointCurrent(plan.extensionsDir, built.tree);
+    promoteFiles(plan.extensionsDir, { manifest: plan.manifest, lock: built.raw });
+    collectTrees(plan.extensionsDir, built.tree);
+    return true;
+};
+const run = async (plan, prepare, check) => {
+    refuseDrift(plan.extensionsDir);
+    clearStaging(plan.extensionsDir);
+    const before = parseLock(plan.lock);
+    const names = namesOf(plan, before);
+    const none = { changes: [], held: [], unchanged: 0, tree: null, current: false };
+    if (names.length === 0)
+        return none;
+    const { built, held } = await settle(plan, await prepare(), names, before);
+    const changes = built === null ? [] : diff(names, before, built.lock);
+    const result = { ...none, changes, held, unchanged: unchanged(plan, changes) };
+    if (built === null || sameEntries(before, built.lock)) {
+        if (built !== null)
+            discardTree(built.staging);
+        return result;
+    }
+    const staged = { ...result, tree: built.tree, dir: treePath(plan.extensionsDir, built.tree) };
+    return { ...result, tree: built.tree, current: await commit(plan, built, staged, check) };
+};
+// `setup --latest`: npm update from the current lock, under the install lock for the whole run.
+export const updateLatest = (set, prepare, check) => withInstallLock(extensionsDir(), () => run(planInstall(set), prepare, check));

package/dist/core/installer/npm.d.ts

@@ -0,0 +1,11 @@
+import { type NpmResult } from '../../lib/npm/npm-cli.js';
+export declare const DEFAULT_REGISTRY = "https://registry.npmjs.org";
+export type NpmCommand = 'ci' | 'install' | 'update';
+export type Npm = (command: NpmCommand, tree: string, packages?: string[]) => Promise<NpmResult>;
+export type LookupCommand = 'pack' | 'view';
+export type NpmManifest = (command: LookupCommand, spec: string, registries: Record<string, string>) => Promise<NpmResult>;
+export declare const npmArgs: (command: NpmCommand, tree: string, env?: NodeJS.ProcessEnv, packages?: string[]) => string[];
+export declare const manifestArgs: (command: LookupCommand, spec: string, registries: Record<string, string>, prefix: string, env?: NodeJS.ProcessEnv) => string[];
+export declare const npmMajor: (env?: NodeJS.ProcessEnv) => Promise<number>;
+export declare const prepareNpm: (env?: NodeJS.ProcessEnv) => Promise<Npm>;
+export declare const prepareManifest: (env?: NodeJS.ProcessEnv) => Promise<NpmManifest>;

package/dist/core/installer/npm.js

@@ -0,0 +1,76 @@
+import { requireNpm10, resolveNpmCli, runNpm } from '../../lib/npm/npm-cli.js';
+import { extensionsDir } from '../paths.js';
+// Every package whose scope the profile's `registries` does not name comes from here.
+export const DEFAULT_REGISTRY = 'https://registry.npmjs.org';
+const NPM_TIMEOUT_MS = 10 * 60_000;
+const LOOKUP_TIMEOUT_MS = 2 * 60_000;
+// `name` keeps every version an object: npm view unwraps to bare values when the first has one field.
+const LOOKUP_FLAGS = {
+    pack: ['--dry-run', '--json'],
+    view: ['name', 'version', 'engines', 'agentage.parts', '--json'],
+};
+// npm reads its env config case-insensitively, so either spelling may carry these paths.
+const npmConfig = (env, key) => {
+    const name = `npm_config_${key}`;
+    const found = Object.keys(env).find((k) => k.toLowerCase() === name);
+    return (found && env[found]) || null;
+};
+// Carried as flags: runNpm drops every npm_config_* variable from the child env.
+const configFlags = (env) => {
+    const userconfig = npmConfig(env, 'userconfig');
+    const cache = npmConfig(env, 'cache');
+    return [
+        ...(userconfig ? ['--userconfig', userconfig] : []),
+        ...(cache ? ['--cache', cache] : []),
+    ];
+};
+// Scoped registries come from the tree's own .npmrc; runNpm appends --no-audit --no-fund.
+export const npmArgs = (command, tree, env = process.env, packages = []) => [
+    command,
+    ...packages,
+    '--prefix',
+    tree,
+    '--registry',
+    DEFAULT_REGISTRY,
+    '--ignore-scripts',
+    '--no-update-notifier',
+    ...configFlags(env),
+];
+// `--prefix` keeps a project .npmrc in the working directory out of it; scopes go as flags.
+export const manifestArgs = (command, spec, registries, prefix, env = process.env) => [
+    command,
+    spec,
+    ...LOOKUP_FLAGS[command],
+    '--ignore-scripts',
+    '--prefix',
+    prefix,
+    '--registry',
+    DEFAULT_REGISTRY,
+    ...Object.entries(registries).map(([scope, url]) => `--${scope}:registry=${url}`),
+    '--no-update-notifier',
+    ...configFlags(env),
+];
+// Resolves npm-cli.js once and refuses npm below 10 before anything runs.
+const checkedNpm = async (env) => {
+    const npmCli = resolveNpmCli({ env });
+    const run = (args, opts) => runNpm([...args, ...configFlags(env)], { ...opts, npmCli });
+    return { npmCli, version: await requireNpm10(run) };
+};
+const checkedNpmCli = async (env) => (await checkedNpm(env)).npmCli;
+// The npm major that writes the lock, pushed next to it.
+export const npmMajor = async (env = process.env) => Number.parseInt((await checkedNpm(env)).version, 10);
+export const prepareNpm = async (env = process.env) => {
+    const npmCli = await checkedNpmCli(env);
+    return (command, tree, packages = []) => runNpm(npmArgs(command, tree, env, packages), {
+        cwd: tree,
+        timeoutMs: NPM_TIMEOUT_MS,
+        npmCli,
+    });
+};
+export const prepareManifest = async (env = process.env) => {
+    const npmCli = await checkedNpmCli(env);
+    return (command, spec, registries) => runNpm(manifestArgs(command, spec, registries, extensionsDir(), env), {
+        timeoutMs: LOOKUP_TIMEOUT_MS,
+        npmCli,
+    });
+};

package/dist/core/installer/plan.d.ts

@@ -0,0 +1,25 @@
+export type PlanVerb = 'add' | 'update' | 'remove' | 'off' | 'unchanged';
+export interface PlanEntry {
+    verb: PlanVerb;
+    name: string;
+    wanted: string | null;
+    current: string | null;
+}
+export type PlanSummary = Record<PlanVerb, number>;
+export interface Plan {
+    extensions: PlanEntry[];
+    summary: PlanSummary;
+}
+export interface Desired {
+    install: Record<string, string>;
+    off: string[];
+}
+export interface LockDrift {
+    integrity: string[];
+    matches: boolean;
+}
+export declare const planChanges: (desired: Desired, current: Record<string, string>) => Plan;
+export declare const pendingChanges: (summary: PlanSummary) => string[];
+export declare const currentDependencies: (dir?: string) => Record<string, string>;
+export declare const lockDrift: (dir?: string) => LockDrift;
+export declare const driftLines: (integrity: string[]) => string[];

package/dist/core/installer/plan.js

@@ -0,0 +1,52 @@
+import { join } from 'node:path';
+import { currentTree } from '../loader/discover.js';
+import { extensionsDir } from '../paths.js';
+import { integrityDrift, lockEntries, parseLock, rootDependencies } from './compare-lock.js';
+import { LOCK_FILE, readText } from './tree.js';
+// A changed range is an update: npm would resolve it again.
+const verbOf = (wanted, current, off) => {
+    if (current === null)
+        return 'add';
+    if (wanted === null)
+        return 'remove';
+    if (wanted !== current)
+        return 'update';
+    return off ? 'off' : 'unchanged';
+};
+const entryOf = (name, desired, current) => {
+    const wanted = desired.install[name] ?? null;
+    const now = current[name] ?? null;
+    return { verb: verbOf(wanted, now, desired.off.includes(name)), name, wanted, current: now };
+};
+// One entry per package the profile or the current tree names, sorted by name.
+export const planChanges = (desired, current) => {
+    const names = [...new Set([...Object.keys(desired.install), ...Object.keys(current)])].sort();
+    const extensions = names.map((name) => entryOf(name, desired, current));
+    const summary = { add: 0, update: 0, remove: 0, off: 0, unchanged: 0 };
+    for (const entry of extensions)
+        summary[entry.verb] += 1;
+    return { extensions, summary };
+};
+// What setup would change, e.g. ["1 to add"]; `off` stays installed, so it is never pending.
+export const pendingChanges = (summary) => ['add', 'update', 'remove']
+    .filter((verb) => summary[verb] > 0)
+    .map((verb) => `${summary[verb]} to ${verb}`);
+const treeLock = (dir) => {
+    const tree = currentTree(dir).dir;
+    return tree === null ? null : parseLock(readText(join(tree, LOCK_FILE)));
+};
+// What the last install asked npm for; a tree reused for the same packages keeps its first lock.
+export const currentDependencies = (dir = extensionsDir()) => {
+    const finished = currentTree(dir).dir !== null;
+    const lock = finished ? parseLock(readText(join(dir, LOCK_FILE))) : null;
+    return lock === null ? {} : rootDependencies(lock);
+};
+// extensions/package-lock.json describes the current tree; anything else was changed by hand.
+export const lockDrift = (dir = extensionsDir()) => {
+    const root = parseLock(readText(join(dir, LOCK_FILE)));
+    const tree = treeLock(dir);
+    const entries = (lock) => (lock === null ? '' : lockEntries(lock).join('\n'));
+    const integrity = root && tree ? integrityDrift(root, tree) : [];
+    return { integrity, matches: entries(root) === entries(tree) };
+};
+export const driftLines = (integrity) => integrity.map((key) => `integrity drift: ${key}`);

package/dist/core/installer/resolve.d.ts

@@ -0,0 +1,26 @@
+import { type Published } from './compat.js';
+import { type NpmManifest } from './npm.js';
+export type Resolved = {
+    kind: 'package';
+    name: string;
+    spec: string;
+    skipped: Published[];
+} | {
+    kind: 'dev';
+    name: string;
+    path: string;
+    kit: boolean;
+};
+export interface Found {
+    name: string;
+    version: string;
+}
+export type Lookup = (spec: string) => Promise<Found | null>;
+export type Versions = (name: string) => Promise<Published[] | null>;
+export interface Registry {
+    find: Lookup;
+    versions: Versions;
+}
+export declare const candidatesFor: (name: string) => string[];
+export declare const resolveName: (input: string, registry: Registry) => Promise<Resolved>;
+export declare const registryLookup: (prepare: () => Promise<NpmManifest>, registries: Record<string, string>) => Registry;