@dep-radius/core 0.1.0

package/dist/run.d.ts

@@ -0,0 +1,10 @@
+import { type Ctx, type Options, type RunEvent } from "./options.ts";
+import type { Brief } from "./model.ts";
+export declare function toolVersion(): string;
+export interface Spec {
+    name: string;
+    version?: string;
+}
+export declare function parseSpec(input: string): Spec;
+export declare function run(opts: Options, ctx: Ctx, onEvent?: (e: RunEvent) => void): Promise<Brief>;
+//# sourceMappingURL=run.d.ts.map

package/dist/run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../src/run.ts"],"names":[],"mappings":"AAgBA,OAAO,EACL,KAAK,GAAG,EAER,KAAK,OAAO,EACZ,KAAK,QAAQ,EACd,MAAM,cAAc,CAAA;AACrB,OAAO,KAAK,EACV,KAAK,EAMN,MAAM,YAAY,CAAA;AAEnB,wBAAgB,WAAW,IAAI,MAAM,CAQpC;AAED,MAAM,WAAW,IAAI;IACnB,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAI7C;AAED,wBAAsB,GAAG,CACvB,IAAI,EAAE,OAAO,EACb,GAAG,EAAE,GAAG,EACR,OAAO,GAAE,CAAC,CAAC,EAAE,QAAQ,KAAK,IAAe,GACxC,OAAO,CAAC,KAAK,CAAC,CA4JhB"}

package/dist/run.js

@@ -0,0 +1,218 @@
+import { createRequire } from "node:module";
+import semver from "semver";
+import ts from "typescript";
+import { scanUsage } from "./usage/scan.js";
+import { matchNotes } from "./notes/match.js";
+import { limitsFor } from "./render/limits.js";
+import { collectNotes } from "./notes/collect.js";
+import { buildPackageBrief } from "./analyze/brief.js";
+import { getPackument } from "./registry/packument.js";
+import { buildInventory } from "./inventory/installed.js";
+import { selectCandidate } from "./registry/candidates.js";
+import { listProjectFiles } from "./inventory/manifests.js";
+import { isAgeExcluded, loadRegistryConfig } from "./registry/npmrc.js";
+import { analyzeSurface } from "./surface/analyze.js";
+import { DEFAULT_MIN_AGE_MS, } from "./options.js";
+export function toolVersion() {
+    try {
+        return createRequire(import.meta.url)("../package.json").version;
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+export function parseSpec(input) {
+    const at = input.lastIndexOf("@");
+    if (at > 0)
+        return { name: input.slice(0, at), version: input.slice(at + 1) };
+    return { name: input };
+}
+export async function run(opts, ctx, onEvent = () => { }) {
+    const root = opts.root;
+    const files = await listProjectFiles(root);
+    const inventory = await buildInventory(root, { prod: opts.prod }, files);
+    const cfg = loadRegistryConfig(root, ctx.env);
+    const minAgeMs = opts.minAgeMs ?? cfg.minimumReleaseAgeMs ?? DEFAULT_MIN_AGE_MS;
+    const specs = opts.specs.map(parseSpec);
+    const notAnalyzed = [...inventory.notAnalyzed];
+    let targets = inventory.installed;
+    if (specs.length > 0) {
+        targets = inventory.installed.filter((d) => specs.some((s) => s.name === d.name || d.declaredBy.some((b) => b.key === s.name)));
+        for (const s of specs) {
+            if (!targets.some((d) => d.name === s.name || d.declaredBy.some((b) => b.key === s.name))) {
+                notAnalyzed.push({
+                    pkg: s.name,
+                    reason: inventory.local.includes(s.name)
+                        ? "a local workspace package"
+                        : "not a dependency of this project",
+                });
+            }
+        }
+    }
+    const scanned = targets.length > 0
+        ? await scanUsage(ctx, root, files, inventory, (done, total) => onEvent({ type: "files", done, total }))
+        : emptyUsage();
+    let upToDate = 0;
+    const briefs = [];
+    onEvent({ type: "packages", total: targets.length });
+    let finished = 0;
+    const analyse = async (dep) => {
+        const pack = await getPackument(ctx, cfg, dep.name);
+        if (!pack.ok) {
+            notAnalyzed.push({
+                pkg: dep.name,
+                reason: `registry: ${pack.reason}${pack.detail ? ` (${pack.detail})` : ""}`,
+            });
+            return;
+        }
+        if (!pack.packument.versions[dep.version] &&
+            !dep.flags.includes("not-in-registry"))
+            dep.flags.push("not-in-registry");
+        const spec = specs.find((s) => s.name === dep.name || dep.declaredBy.some((b) => b.key === s.name));
+        const choice = selectCandidate(pack.packument, dep.version, {
+            now: ctx.now,
+            minAgeMs,
+            ageExcluded: (v) => isAgeExcluded(cfg, dep.name, v),
+            latest: opts.latest,
+            ...(spec?.version ? { explicit: spec.version } : {}),
+        });
+        if (choice.kind === "error") {
+            notAnalyzed.push({ pkg: dep.name, reason: choice.reason });
+            return;
+        }
+        if (choice.kind === "up-to-date") {
+            upToDate++;
+            return;
+        }
+        const candidate = choice.candidate;
+        const usage = usageFor(scanned, dep, inventory.installed);
+        const typesPackageInstalled = inventory.installed.some((d) => d.name === typesPackageName(dep.name));
+        const disabled = { status: "disabled", touched: [] };
+        const [notes, surface] = await Promise.all([
+            opts.notes
+                ? collectNotes(ctx, cfg, pack.packument, candidate)
+                : Promise.resolve(undefined),
+            opts.surface
+                ? analyzeSurface(ctx, cfg, pack.packument, candidate, usage, {
+                    typesPackageInstalled,
+                }).catch((error) => ({
+                    status: "failed",
+                    detail: String(error).slice(0, 200),
+                    touched: [],
+                }))
+                : Promise.resolve(disabled),
+        ]);
+        const match = notes
+            ? matchNotes(notes.entries, usage?.strongNames ?? [], usage?.weakNames ?? [])
+            : undefined;
+        const { blindSpots: surfaceBlind, ...surfaceOut } = surface;
+        const merged = usage && surfaceBlind
+            ? { ...usage, blindSpots: [...usage.blindSpots, ...surfaceBlind] }
+            : usage;
+        briefs.push(buildPackageBrief({
+            dep,
+            candidate,
+            usage: merged,
+            surface: surfaceOut,
+            notes,
+            match,
+            notesDisabled: !opts.notes,
+        }));
+    };
+    await Promise.all(targets.map((dep) => {
+        onEvent({ type: "package-start", name: dep.name });
+        return analyse(dep).finally(() => {
+            finished++;
+            onEvent({
+                type: "package",
+                name: dep.name,
+                done: finished,
+                total: targets.length,
+            });
+        });
+    }));
+    briefs.sort((a, b) => a.pkg.localeCompare(b.pkg) || semver.compare(a.from, b.from));
+    const exitCode = briefs.some((b) => b.verdict === "blocked")
+        ? 2
+        : briefs.some((b) => b.verdict === "review")
+            ? 1
+            : 0;
+    return {
+        schemaVersion: 1,
+        tool: { version: toolVersion(), typescript: ts.version },
+        root,
+        generatedAt: new Date(ctx.now).toISOString(),
+        manifests: inventory.manifests.length,
+        packages: briefs,
+        upToDate,
+        notAnalyzed: dedupeNotAnalyzed(notAnalyzed),
+        global: scanned.global,
+        limits: limitsFor(briefs, scanned.global),
+        exitCode,
+    };
+}
+// @types/X is used exactly where X is used.
+function usageFor(scanned, dep, installed) {
+    const own = scanned.packages[dep.id];
+    if (!dep.name.startsWith("@types/"))
+        return own;
+    const bare = dep.name.slice("@types/".length);
+    const target = bare.includes("__") ? `@${bare.replace("__", "/")}` : bare;
+    const sources = Object.values(scanned.packages).filter((p) => p.pkg === target || (target === "node" && p.pkg.startsWith("node:")));
+    if (sources.length === 0) {
+        const exists = installed.some((d) => d.name === target);
+        return {
+            installedId: dep.id,
+            pkg: dep.name,
+            refs: own?.refs ?? [],
+            strongNames: own?.strongNames ?? [],
+            weakNames: own?.weakNames ?? [],
+            files: own?.files ?? 0,
+            blindSpots: own?.blindSpots ?? [],
+            opaque: [
+                ...(own?.opaque ?? []),
+                {
+                    kind: "ambient-types",
+                    count: 1,
+                    examples: [
+                        {
+                            file: dep.declaredBy[0]?.manifest ?? "package.json",
+                            line: 1,
+                            col: 1,
+                            typeOnly: true,
+                            text: exists
+                                ? `types for ${target}, which no scanned file imports`
+                                : "ambient types",
+                        },
+                    ],
+                },
+            ],
+        };
+    }
+    const merged = {
+        installedId: dep.id,
+        pkg: dep.name,
+        refs: sources.flatMap((s) => s.refs),
+        strongNames: [...new Set(sources.flatMap((s) => s.strongNames))].sort(),
+        weakNames: [...new Set(sources.flatMap((s) => s.weakNames))].sort(),
+        files: sources.reduce((n, s) => n + s.files, 0),
+        blindSpots: sources.flatMap((s) => s.blindSpots),
+        opaque: [...(own?.opaque ?? [])],
+    };
+    return merged;
+}
+function typesPackageName(name) {
+    return name.startsWith("@")
+        ? `@types/${name.slice(1).replace("/", "__")}`
+        : `@types/${name}`;
+}
+function emptyUsage() {
+    return { scannedFiles: 0, packages: {}, global: [] };
+}
+function dedupeNotAnalyzed(list) {
+    const seen = new Map();
+    for (const n of list)
+        if (!seen.has(n.pkg))
+            seen.set(n.pkg, n);
+    return [...seen.values()].sort((a, b) => a.pkg.localeCompare(b.pkg));
+}

package/dist/surface/analyze.d.ts

@@ -0,0 +1,13 @@
+import type { Ctx } from "../options.ts";
+import type { Packument } from "../registry/packument.ts";
+import type { RegistryConfig } from "../registry/npmrc.ts";
+import type { BlindSpotKind, Candidate, Counted, PackageBrief, PackageUsage } from "../model.ts";
+export type SurfaceOutcome = PackageBrief["surface"] & {
+    truncatedOnUsedEntry?: boolean;
+    blindSpots?: Counted<BlindSpotKind>[];
+};
+export interface SurfaceContext {
+    typesPackageInstalled: boolean;
+}
+export declare function analyzeSurface(ctx: Ctx, cfg: RegistryConfig, p: Packument, c: Candidate, usage: PackageUsage | undefined, sctx?: SurfaceContext): Promise<SurfaceOutcome>;
+//# sourceMappingURL=analyze.d.ts.map

package/dist/surface/analyze.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyze.d.ts","sourceRoot":"","sources":["../../src/surface/analyze.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,eAAe,CAAA;AAKxC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAA;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAG1D,OAAO,KAAK,EACV,aAAa,EACb,SAAS,EACT,OAAO,EACP,YAAY,EACZ,YAAY,EAKb,MAAM,aAAa,CAAA;AAEpB,MAAM,MAAM,cAAc,GAAG,YAAY,CAAC,SAAS,CAAC,GAAG;IACrD,oBAAoB,CAAC,EAAE,OAAO,CAAA;IAC9B,UAAU,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,EAAE,CAAA;CACtC,CAAA;AAED,MAAM,WAAW,cAAc;IAE7B,qBAAqB,EAAE,OAAO,CAAA;CAC/B;AAED,wBAAsB,cAAc,CAClC,GAAG,EAAE,GAAG,EACR,GAAG,EAAE,cAAc,EACnB,CAAC,EAAE,SAAS,EACZ,CAAC,EAAE,SAAS,EACZ,KAAK,EAAE,YAAY,GAAG,SAAS,EAC/B,IAAI,GAAE,cAAiD,GACtD,OAAO,CAAC,cAAc,CAAC,CAsKzB"}

package/dist/surface/analyze.js

@@ -0,0 +1,166 @@
+import { ALGO } from "./signature.js";
+import { declaresTypes } from "./entries.js";
+import { extractSurface } from "./extract.js";
+import { uniqueSites } from "../analyze/brief.js";
+import { getTarballFiles } from "../registry/tarball.js";
+import { diffSurfaces, surfaceChangeCount } from "./delta.js";
+import { lastName, parsePath, resolveRef } from "../symbol-path.js";
+export async function analyzeSurface(ctx, cfg, p, c, usage, sctx = { typesPackageInstalled: false }) {
+    const refs = usage?.refs ?? [];
+    // no named usage: a diff would have nothing to land on, and costs two downloads
+    if (refs.length === 0)
+        return {
+            status: "disabled",
+            detail: "not computed: no named usage to compare",
+            touched: [],
+        };
+    const from = p.versions[c.from];
+    const to = p.versions[c.to];
+    if (!from || !to)
+        return {
+            status: "failed",
+            detail: "installed version missing from the registry",
+            touched: [],
+        };
+    if (declaresTypes(from) === undefined && declaresTypes(to) === undefined) {
+        const tb = await getTarballFiles(ctx, cfg, to);
+        if (tb.ok && ![...tb.files.keys()].some((f) => /\.d\.[cm]?ts$/.test(f))) {
+            return {
+                status: sctx.typesPackageInstalled ? "types-from-@types" : "no-types",
+                touched: [],
+            };
+        }
+        if (!tb.ok && tb.reason === "offline-uncached")
+            return { status: "offline-uncached", touched: [] };
+    }
+    const wanted = [...new Set(refs.map((r) => r.entry))];
+    const [a, b] = await Promise.all([
+        extractSurface(ctx, cfg, p, c.from, wanted),
+        extractSurface(ctx, cfg, p, c.to, wanted),
+    ]);
+    if (!a.ok || !b.ok) {
+        const bad = !a.ok ? a : !b.ok ? b : undefined;
+        if (bad?.reason === "no-types")
+            return {
+                status: sctx.typesPackageInstalled ? "types-from-@types" : "no-types",
+                touched: [],
+            };
+        if (bad?.reason === "offline-uncached")
+            return { status: "offline-uncached", touched: [] };
+        return {
+            status: "failed",
+            detail: `type surface: ${bad?.detail ?? "extraction failed"}`,
+            touched: [],
+        };
+    }
+    const deltaKey = `deltas/${keyOf(a.surface.integrity)}__${keyOf(b.surface.integrity)}.a${ALGO}.json`;
+    let delta = (await ctx.cache.getJson(deltaKey))?.value;
+    if (!delta) {
+        delta = diffSurfaces(a.surface, b.surface);
+        await ctx.cache.setJson(deltaKey, delta, ctx.now);
+    }
+    // resolve every reference against the OLD surface: what the code compiles against today
+    const byPath = new Map();
+    const byMember = new Map();
+    const missing = [];
+    const missingEntries = new Set();
+    const add = (m, k, s) => {
+        const l = m.get(k) ?? [];
+        l.push(s);
+        m.set(k, l);
+    };
+    for (const r of refs) {
+        const res = resolveRef(a.surface, r);
+        for (const path of res.paths)
+            add(byPath, path, r.site);
+        for (const name of res.unresolvedTail)
+            add(byMember, name, r.site);
+        if (res.missingHead) {
+            missing.push(r.site);
+            missingEntries.add(r.origin?.entry ?? r.entry);
+        }
+    }
+    // `export * from "other-lib"`: the names live in another package's types, which radius does not
+    // follow. The notes are the only net here, said as such rather than as a hundred blind spots.
+    const elsewhere = [
+        ...new Set([...missingEntries].flatMap((e) => a.surface.entries[e]?.externalReexports ?? [])),
+    ];
+    if (elsewhere.length > 0) {
+        return {
+            status: "types-elsewhere",
+            detail: `its types are re-exported from ${elsewhere.join(", ")}, which is not followed`,
+            touched: [],
+        };
+    }
+    const touched = [];
+    const consider = (bucket, change) => {
+        const all = [change.path, ...change.alsoAt];
+        const strongSites = [];
+        for (const path of all) {
+            strongSites.push(...(byPath.get(path) ?? []));
+            if (bucket === "removed") {
+                // a removed namespace or type takes every path under it
+                for (const [used, sites] of byPath)
+                    if (used.startsWith(`${path}.`) || used.startsWith(`${path}#`))
+                        strongSites.push(...sites);
+            }
+        }
+        if (strongSites.length > 0) {
+            touched.push({
+                change,
+                bucket,
+                strength: "strong",
+                sites: uniqueSites(strongSites),
+            });
+            return;
+        }
+        // a member you reach through a value the walk lost track of: same name, possibly the same thing
+        if (all.some((p) => parsePath(p).segs.at(-1)?.sep === "#")) {
+            const sites = byMember.get(lastName(change.path));
+            if (sites && sites.length > 0)
+                touched.push({
+                    change,
+                    bucket,
+                    strength: "weak",
+                    sites: uniqueSites(sites),
+                });
+        }
+    };
+    for (const ch of delta.removed)
+        consider("removed", ch);
+    for (const ch of delta.changed)
+        consider("changed", ch);
+    for (const ch of delta.deprecated)
+        consider("deprecated", ch);
+    const usedEntries = new Set(wanted);
+    const truncatedOnUsedEntry = a.surface.flags.includes("symbol-cap") ||
+        b.surface.flags.includes("symbol-cap") ||
+        [...usedEntries].some((e) => !a.surface.entries[e] &&
+            (a.surface.flags.includes("wildcard-truncated") ||
+                b.surface.flags.includes("wildcard-truncated")));
+    return {
+        status: "computed",
+        changes: surfaceChangeCount(delta),
+        added: delta.added.length,
+        touched: touched.sort((x, y) => order(x) - order(y) || x.change.path.localeCompare(y.change.path)),
+        truncatedOnUsedEntry,
+        ...(missing.length > 0
+            ? {
+                blindSpots: [
+                    {
+                        kind: "unresolved-against-surface",
+                        count: missing.length,
+                        examples: uniqueSites(missing).slice(0, 3),
+                    },
+                ],
+            }
+            : {}),
+    };
+}
+function order(t) {
+    return ((t.bucket === "removed" ? 0 : t.bucket === "changed" ? 2 : 4) +
+        (t.strength === "weak" ? 1 : 0));
+}
+function keyOf(integrity) {
+    return Buffer.from(integrity).toString("base64url").slice(0, 48);
+}

package/dist/surface/delta.d.ts

@@ -0,0 +1,5 @@
+import type { Surface, SurfaceDelta } from "../model.ts";
+export declare function diffSurfaces(a: Surface, b: Surface): SurfaceDelta;
+export declare function sameModuloAny(a: string[], b: string[]): boolean;
+export declare function surfaceChangeCount(d: SurfaceDelta): number;
+//# sourceMappingURL=delta.d.ts.map

package/dist/surface/delta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delta.d.ts","sourceRoot":"","sources":["../../src/surface/delta.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAEV,OAAO,EAEP,YAAY,EAEb,MAAM,aAAa,CAAA;AAGpB,wBAAgB,YAAY,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,YAAY,CAwEjE;AASD,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,OAAO,CAK/D;AAqFD,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,YAAY,GAAG,MAAM,CAE1D"}

package/dist/surface/delta.js

@@ -0,0 +1,173 @@
+import { parsePath } from "../symbol-path.js";
+// A pure function of two surfaces: identical for everyone who compares these two versions.
+export function diffSurfaces(a, b) {
+    const raw = {
+        removed: [],
+        changed: [],
+        deprecated: [],
+        widened: [],
+        added: [],
+    };
+    // a type from a dependency the virtual host cannot load prints as `any` on one side and by name
+    // on the other when a declaration merely adds an annotation: not a change anyone can act on
+    const lenient = a.flags.includes("external-types-unresolved") ||
+        b.flags.includes("external-types-unresolved");
+    const sigOf = (s, sym) => {
+        let cur = sym;
+        for (let i = 0; i < 5 && cur.aliasOf; i++) {
+            const next = s.symbols[cur.aliasOf];
+            if (!next)
+                break;
+            cur = next;
+        }
+        return cur.sig;
+    };
+    for (const [path, before] of Object.entries(a.symbols)) {
+        const after = b.symbols[path];
+        if (!after) {
+            raw.removed.push({
+                path,
+                kind: before.kind,
+                before: sigOf(a, before),
+                alsoAt: [],
+            });
+            continue;
+        }
+        if (before.kind === "namespace" && after.kind === "namespace")
+            continue;
+        const sa = sigOf(a, before);
+        const sb = sigOf(b, after);
+        if (!sameMultiset(sa, sb) && !(lenient && sameModuloAny(sa, sb))) {
+            raw[isWidening(sa, sb) ? "widened" : "changed"].push({
+                path,
+                kind: after.kind,
+                before: sa,
+                after: sb,
+                alsoAt: [],
+            });
+        }
+        else if (!before.deprecated && after.deprecated && !before.aliasOf) {
+            raw.deprecated.push({
+                path,
+                kind: after.kind,
+                before: sa,
+                after: sb,
+                alsoAt: [],
+            });
+        }
+    }
+    for (const [path, after] of Object.entries(b.symbols)) {
+        if (!a.symbols[path])
+            raw.added.push({
+                path,
+                kind: after.kind,
+                after: sigOf(b, after),
+                alsoAt: [],
+            });
+    }
+    return {
+        removed: collapse(dropChildrenOfRemoved(raw.removed)),
+        changed: collapse(raw.changed),
+        deprecated: collapse(raw.deprecated),
+        widened: collapse(raw.widened),
+        added: collapse(dropChildrenOfRemoved(raw.added)),
+    };
+}
+function sameMultiset(a, b) {
+    if (a.length !== b.length)
+        return false;
+    const x = [...a].sort();
+    const y = [...b].sort();
+    return x.every((v, i) => v === y[i]);
+}
+export function sameModuloAny(a, b) {
+    if (a.length !== b.length || a.length === 0)
+        return false;
+    const x = [...a].sort();
+    const y = [...b].sort();
+    return x.every((s, i) => anyMatches(s, y[i]) || anyMatches(y[i], s));
+}
+function anyMatches(withAny, other) {
+    if (!/(?<![\w$])any(?![\w$])/.test(withAny))
+        return false;
+    const pattern = withAny
+        .split(/(?<![\w$])any(?![\w$])/)
+        .map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
+        .join("[\\w$.<>\\[\\], |&]+?");
+    return new RegExp(`^${pattern}$`).test(other);
+}
+// Adding an overload, or appending optional parameters, breaks no existing call.
+function isWidening(before, after) {
+    if (before.length === 0)
+        return false;
+    const afterSet = new Set(after);
+    if (before.every((s) => afterSet.has(s)))
+        return true;
+    return before.every((old) => after.some((neu) => appendsOptional(old, neu)));
+}
+function appendsOptional(old, neu) {
+    const po = /^(<[^>]*>)?\((.*)\) => (.*)$/.exec(old);
+    const pn = /^(<[^>]*>)?\((.*)\) => (.*)$/.exec(neu);
+    if (!po || !pn)
+        return false;
+    if ((po[1] ?? "") !== (pn[1] ?? "") || po[3] !== pn[3])
+        return false;
+    const a = po[2] ?? "";
+    const b = pn[2] ?? "";
+    if (!b.startsWith(a))
+        return false;
+    const extra = b.slice(a.length).replace(/^,\s*/, "");
+    return (extra.length > 0 &&
+        extra.split(/,\s*/).every((p) => p.endsWith("?") || p.startsWith("...")));
+}
+function parentOf(path) {
+    const { prefix, segs } = parsePath(path);
+    if (segs.length <= 1)
+        return undefined;
+    let out = `${prefix}:${segs[0].name}`;
+    for (const s of segs.slice(1, -1))
+        out += `${s.sep}${s.name}`;
+    return out;
+}
+// A removed class takes its members with it: report the class.
+function dropChildrenOfRemoved(changes) {
+    const paths = new Set(changes.map((c) => c.path));
+    return changes.filter((c) => {
+        for (let p = parentOf(c.path); p; p = parentOf(p))
+            if (paths.has(p))
+                return false;
+        return true;
+    });
+}
+// The same change seen through several entries (lib:email, lib/v2:email, lib:ns.email) is one change.
+function collapse(changes) {
+    const groups = new Map();
+    for (const c of changes) {
+        const segs = parsePath(c.path).segs;
+        const last = segs[segs.length - 1];
+        const key = JSON.stringify([
+            c.kind,
+            last?.sep,
+            last?.name,
+            c.before ?? null,
+            c.after ?? null,
+        ]);
+        const list = groups.get(key) ?? [];
+        list.push(c);
+        groups.set(key, list);
+    }
+    const out = [];
+    for (const list of groups.values()) {
+        list.sort((x, y) => rank(x.path) - rank(y.path) || x.path.localeCompare(y.path));
+        const [head, ...rest] = list;
+        out.push({ ...head, alsoAt: rest.map((r) => r.path) });
+    }
+    return out.sort((x, y) => x.path.localeCompare(y.path));
+}
+function rank(path) {
+    const { prefix, segs } = parsePath(path);
+    return prefix.split("/").length * 10 + segs.length;
+}
+export function surfaceChangeCount(d) {
+    return d.removed.length + d.changed.length + d.deprecated.length;
+}

package/dist/surface/entries.d.ts

@@ -0,0 +1,16 @@
+export interface EntryFile {
+    subpath: string;
+    typesFile: string;
+}
+export interface EntryResolution {
+    entries: EntryFile[];
+    wildcardTruncated: boolean;
+}
+export declare function typesForTarget(value: unknown, has: (p: string) => boolean, star?: string): string | undefined;
+export declare function resolveEntries(pj: Record<string, unknown>, files: string[], wantedSubpaths?: string[]): EntryResolution;
+export declare function declaresTypes(pv: {
+    types?: string;
+    typings?: string;
+    exports?: unknown;
+}): boolean | undefined;
+//# sourceMappingURL=entries.d.ts.map

package/dist/surface/entries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entries.d.ts","sourceRoot":"","sources":["../../src/surface/entries.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,SAAS;IACxB,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,SAAS,EAAE,CAAA;IACpB,iBAAiB,EAAE,OAAO,CAAA;CAC3B;AAOD,wBAAgB,cAAc,CAC5B,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,OAAO,EAC3B,IAAI,CAAC,EAAE,MAAM,GACZ,MAAM,GAAG,SAAS,CA2BpB;AAiBD,wBAAgB,cAAc,CAC5B,EAAE,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC3B,KAAK,EAAE,MAAM,EAAE,EACf,cAAc,GAAE,MAAM,EAAO,GAC5B,eAAe,CAkGjB;AAuBD,wBAAgB,aAAa,CAAC,EAAE,EAAE;IAChC,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB,GAAG,OAAO,GAAG,SAAS,CAatB"}