@dep-radius/core 0.1.0

package/dist/surface/entries.js

@@ -0,0 +1,187 @@
+import semver from "semver";
+import ts from "typescript";
+const WILDCARD_CAP = 50;
+const RUNTIME_CONDITIONS = ["import", "require", "node", "default", "module"];
+// A `types` condition anywhere in an export's condition tree wins; otherwise a runtime file with a
+// declaration beside it. Custom conditions ("@acme/source") point at sources and are ignored.
+export function typesForTarget(value, has, star) {
+    const sub = (s) => (star !== undefined ? s.replace(/\*/g, star) : s);
+    if (typeof value === "string") {
+        const p = norm(sub(value));
+        if (/\.d\.[cm]?ts$/.test(p))
+            return has(p) ? p : undefined;
+        for (const d of declarationFor(p))
+            if (has(d))
+                return d;
+        return undefined;
+    }
+    if (Array.isArray(value)) {
+        for (const v of value) {
+            const r = typesForTarget(v, has, star);
+            if (r)
+                return r;
+        }
+        return undefined;
+    }
+    if (!value || typeof value !== "object")
+        return undefined;
+    const o = value;
+    if ("types" in o) {
+        const r = typesForTarget(o.types, has, star);
+        if (r)
+            return r;
+    }
+    for (const c of RUNTIME_CONDITIONS) {
+        if (!(c in o))
+            continue;
+        const r = typesForTarget(o[c], has, star);
+        if (r)
+            return r;
+    }
+    return undefined;
+}
+function declarationFor(p) {
+    const m = /\.(m|c)?js$/.exec(p);
+    if (m) {
+        const base = p.slice(0, -m[0].length);
+        return [`${base}.d.${m[1] ?? ""}ts`, `${base}.d.ts`];
+    }
+    if (/\.[cm]?ts$/.test(p) && !/\.d\.[cm]?ts$/.test(p))
+        return [p.replace(/\.([cm]?)ts$/, ".d.$1ts")];
+    return [`${p}.d.ts`, `${p}/index.d.ts`];
+}
+function norm(p) {
+    return p.replace(/^\.\//, "").replace(/^\//, "");
+}
+export function resolveEntries(pj, files, wantedSubpaths = []) {
+    const set = new Set(files);
+    const has = (p) => set.has(p);
+    const entries = [];
+    let wildcardTruncated = false;
+    const exp = pj.exports;
+    const exportMap = exp === undefined
+        ? undefined
+        : typeof exp === "string" ||
+            Array.isArray(exp) ||
+            !Object.keys(exp).some((k) => k.startsWith("."))
+            ? { ".": exp }
+            : exp;
+    if (exportMap) {
+        for (const [key, value] of Object.entries(exportMap)) {
+            if (key === "./package.json" || value === null)
+                continue;
+            if (!key.includes("*")) {
+                const t = typesForTarget(value, has);
+                if (t)
+                    entries.push({ subpath: key, typesFile: t });
+                continue;
+            }
+            const [pre, post] = key.split("*");
+            const pattern = firstString(value);
+            if (!pattern || !pattern.includes("*"))
+                continue;
+            const [fpre, fpost] = norm(pattern).split("*");
+            const stars = new Set();
+            for (const f of files) {
+                if (!f.startsWith(fpre))
+                    continue;
+                const rest = f.slice(fpre.length);
+                const star = fpost
+                    ? rest.endsWith(fpost)
+                        ? rest.slice(0, -fpost.length)
+                        : undefined
+                    : rest.replace(/\.d\.[cm]?ts$|\.[cm]?js$/, "");
+                if (star && !star.includes("/"))
+                    stars.add(star);
+            }
+            const sorted = [...stars].sort();
+            const wanted = sorted.filter((s) => wantedSubpaths.includes(`${pre}${s}${post}`));
+            const picked = [...new Set([...sorted.slice(0, WILDCARD_CAP), ...wanted])];
+            if (sorted.length > picked.length)
+                wildcardTruncated = true;
+            for (const star of picked) {
+                const t = typesForTarget(value, has, star);
+                if (t)
+                    entries.push({ subpath: `${pre}${star}${post}`, typesFile: t });
+            }
+        }
+    }
+    else {
+        let main = typeof pj.types === "string"
+            ? pj.types
+            : typeof pj.typings === "string"
+                ? pj.typings
+                : undefined;
+        const tv = pj.typesVersions;
+        if (tv) {
+            const range = Object.keys(tv).find((r) => r === "*" || semver.satisfies(ts.version, r));
+            const mapping = range ? tv[range] : undefined;
+            const star = mapping?.["*"]?.[0];
+            if (star)
+                main = star.replace("*", (main ?? "index.d.ts").replace(/^\.\//, ""));
+        }
+        const candidates = [
+            main,
+            typeof pj.main === "string" ? pj.main : undefined,
+            "index.d.ts",
+        ].filter((x) => !!x);
+        for (const c of candidates) {
+            const t = /\.d\.[cm]?ts$/.test(c)
+                ? has(norm(c))
+                    ? norm(c)
+                    : undefined
+                : declarationFor(norm(c)).find(has);
+            if (t) {
+                entries.push({ subpath: ".", typesFile: t });
+                break;
+            }
+        }
+        for (const w of wantedSubpaths) {
+            if (w === ".")
+                continue;
+            const t = declarationFor(norm(w)).find(has);
+            if (t)
+                entries.push({ subpath: w, typesFile: t });
+        }
+    }
+    entries.sort((a, b) => a.subpath === "."
+        ? -1
+        : b.subpath === "."
+            ? 1
+            : a.subpath.localeCompare(b.subpath));
+    return { entries, wildcardTruncated };
+}
+function firstString(v) {
+    if (typeof v === "string")
+        return v;
+    if (Array.isArray(v)) {
+        for (const x of v) {
+            const r = firstString(x);
+            if (r)
+                return r;
+        }
+        return undefined;
+    }
+    if (v && typeof v === "object") {
+        const o = v;
+        for (const k of ["types", ...RUNTIME_CONDITIONS])
+            if (k in o) {
+                const r = firstString(o[k]);
+                if (r)
+                    return r;
+            }
+    }
+    return undefined;
+}
+// Whether a version ships its own declarations, read from the packument without a download.
+export function declaresTypes(pv) {
+    if (pv.types || pv.typings)
+        return true;
+    if (pv.exports !== undefined &&
+        JSON.stringify(pv.exports).includes('"types"'))
+        return true;
+    if (pv.exports !== undefined &&
+        /\.d\.[cm]?ts"/.test(JSON.stringify(pv.exports)))
+        return true;
+    return undefined;
+}

package/dist/surface/extract.d.ts

@@ -0,0 +1,15 @@
+import type { Ctx } from "../options.ts";
+import type { Packument } from "../registry/packument.ts";
+import type { RegistryConfig } from "../registry/npmrc.ts";
+import type { Surface } from "../model.ts";
+export type ExtractResult = {
+    ok: true;
+    surface: Surface;
+} | {
+    ok: false;
+    reason: "no-types" | "offline-uncached" | "failed";
+    detail?: string;
+};
+export declare function extractSurface(ctx: Ctx, cfg: RegistryConfig, p: Packument, version: string, wantedSubpaths?: string[]): Promise<ExtractResult>;
+export declare function build(pkg: string, version: string, integrity: string, files: Map<string, Buffer>, wantedSubpaths?: string[]): ExtractResult;
+//# sourceMappingURL=extract.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"extract.d.ts","sourceRoot":"","sources":["../../src/surface/extract.ts"],"names":[],"mappings":"AAEA,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,EAAa,OAAO,EAA6B,MAAM,aAAa,CAAA;AAKhF,MAAM,MAAM,aAAa,GACrB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,GAC9B;IACE,EAAE,EAAE,KAAK,CAAA;IACT,MAAM,EAAE,UAAU,GAAG,kBAAkB,GAAG,QAAQ,CAAA;IAClD,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAEL,wBAAsB,cAAc,CAClC,GAAG,EAAE,GAAG,EACR,GAAG,EAAE,cAAc,EACnB,CAAC,EAAE,SAAS,EACZ,OAAO,EAAE,MAAM,EACf,cAAc,GAAE,MAAM,EAAO,GAC5B,OAAO,CAAC,aAAa,CAAC,CA6BxB;AAED,wBAAgB,KAAK,CACnB,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAC1B,cAAc,GAAE,MAAM,EAAO,GAC5B,aAAa,CAsbf"}

package/dist/surface/extract.js

@@ -0,0 +1,460 @@
+import ts from "typescript";
+import { resolveEntries } from "./entries.js";
+import { integrityHex } from "../infra/hash.js";
+import { createVfsHost, PKG_ROOT } from "./vfs-host.js";
+import { getTarballFiles } from "../registry/tarball.js";
+import { ALGO, signatureText, typeText } from "./signature.js";
+import { formatPath, parsePath } from "../symbol-path.js";
+const SYMBOL_CAP = 25_000;
+const NAMESPACE_DEPTH = 2;
+export async function extractSurface(ctx, cfg, p, version, wantedSubpaths = []) {
+    const pv = p.versions[version];
+    if (!pv)
+        return {
+            ok: false,
+            reason: "failed",
+            detail: `version ${version} not in registry`,
+        };
+    const integrity = pv.dist.integrity ?? pv.dist.shasum ?? pv.dist.tarball;
+    const wantedKey = wantedSubpaths
+        .filter((w) => w.includes("/") && w !== ".")
+        .sort()
+        .join(",");
+    const key = `surfaces/${integrityHex(integrity) ?? Buffer.from(integrity).toString("hex").slice(0, 64)}.a${ALGO}.ts${ts.version}${wantedKey ? `.${Buffer.from(wantedKey).toString("base64url").slice(0, 40)}` : ""}.json`;
+    const cached = await ctx.cache.getJson(key);
+    if (cached)
+        return cached.value;
+    const tb = await getTarballFiles(ctx, cfg, pv);
+    if (!tb.ok)
+        return {
+            ok: false,
+            reason: tb.reason === "offline-uncached" ? "offline-uncached" : "failed",
+            detail: tb.reason,
+        };
+    const result = await ctx.heavy(async () => build(p.name, version, integrity, tb.files, wantedSubpaths));
+    await ctx.cache.setJson(key, result, ctx.now);
+    return result;
+}
+export function build(pkg, version, integrity, files, wantedSubpaths = []) {
+    const pjBuf = files.get("package.json");
+    let pj = {};
+    try {
+        pj = pjBuf
+            ? JSON.parse(pjBuf.toString("utf8"))
+            : {};
+    }
+    catch {
+        return { ok: false, reason: "failed", detail: "unreadable package.json" };
+    }
+    const fileList = [...files.keys()];
+    const { entries, wildcardTruncated } = resolveEntries(pj, fileList, wantedSubpaths);
+    if (entries.length === 0)
+        return { ok: false, reason: "no-types" };
+    const options = {
+        noEmit: true,
+        skipLibCheck: true,
+        types: [],
+        module: ts.ModuleKind.NodeNext,
+        moduleResolution: ts.ModuleResolutionKind.NodeNext,
+        target: ts.ScriptTarget.ES2022,
+        lib: ["lib.es2023.d.ts", "lib.dom.d.ts"],
+        strict: true,
+        allowJs: false,
+        noLib: false,
+    };
+    const host = createVfsHost(files);
+    const program = ts.createProgram({
+        rootNames: entries.map((e) => `${PKG_ROOT}/${e.typesFile}`),
+        options,
+        host,
+    });
+    const checker = program.getTypeChecker();
+    const symbols = {};
+    const surfaceEntries = {};
+    const firstPath = new Map();
+    const pendingReturns = [];
+    const flags = new Set();
+    if (wildcardTruncated)
+        flags.add("wildcard-truncated");
+    let count = 0;
+    const inPackage = (s) => !!s?.declarations?.some((d) => d.getSourceFile().fileName.startsWith(`${PKG_ROOT}/`));
+    const deprecatedOf = (s) => !!s.declarations?.some((d) => ts.getJSDocDeprecatedTag(d));
+    const emit = (sym) => {
+        if (count >= SYMBOL_CAP) {
+            flags.add("symbol-cap");
+            return false;
+        }
+        if (symbols[sym.path])
+            return false;
+        symbols[sym.path] = sym;
+        count++;
+        return true;
+    };
+    const resolveAlias = (s) => {
+        if (!(s.flags & ts.SymbolFlags.Alias))
+            return s;
+        try {
+            return checker.getAliasedSymbol(s);
+        }
+        catch {
+            return s;
+        }
+    };
+    const typeSymbolOf = (t) => {
+        const s = t.aliasSymbol ?? t.getSymbol();
+        if (!s || !inPackage(s))
+            return undefined;
+        if (s.flags &
+            (ts.SymbolFlags.Class |
+                ts.SymbolFlags.Interface |
+                ts.SymbolFlags.TypeAlias))
+            return s;
+        return undefined;
+    };
+    const isThisType = (t) => !!(t.flags & ts.TypeFlags.TypeParameter) &&
+        t.isThisType === true;
+    const callSigs = (t, path) => {
+        const sigs = t.getCallSignatures();
+        const first = sigs[0];
+        if (first) {
+            const rs = typeSymbolOf(checker.getReturnTypeOfSignature(first));
+            if (rs)
+                pendingReturns.push({ path, field: "returns", target: rs });
+        }
+        return sigs.map((s) => signatureText(checker, s)).sort();
+    };
+    const walkMembers = (ownerPath, type, sep, pkgName, entry, segs) => {
+        for (const prop of checker.getPropertiesOfType(type)) {
+            const name = prop.getName();
+            if (name === "prototype" ||
+                name.startsWith("__@") ||
+                name.startsWith("#"))
+                continue;
+            const decl = prop.valueDeclaration ?? prop.declarations?.[0];
+            if (decl &&
+                ts.getCombinedModifierFlags(decl) &
+                    (ts.ModifierFlags.Private | ts.ModifierFlags.Protected))
+                continue;
+            const path = formatPath(pkgName, entry, [...segs, { name, sep }]);
+            let ptype;
+            try {
+                ptype = decl
+                    ? checker.getTypeOfSymbolAtLocation(prop, decl)
+                    : checker.getTypeOfSymbol(prop);
+            }
+            catch {
+                continue;
+            }
+            const record = {
+                path,
+                kind: sep === "#" ? "member" : "static-member",
+                sig: [],
+                deprecated: deprecatedOf(prop),
+            };
+            if (!emit(record))
+                continue;
+            const sigs = ptype.getCallSignatures();
+            if (sigs.length > 0) {
+                record.sig = sigs.map((s) => signatureText(checker, s)).sort();
+                const r = checker.getReturnTypeOfSignature(sigs[0]);
+                const rs = isThisType(r) ? undefined : typeSymbolOf(r);
+                if (rs)
+                    pendingReturns.push({ path, field: "returns", target: rs });
+                // `refine(): Ch extends ... ? this & X : this` has no symbol, and is still the owner
+                else if (isThisType(r) ||
+                    mentionsOwner(checker.typeToString(r), ownerPath))
+                    record.returns = ownerPath;
+            }
+            else {
+                record.sig = [typeText(checker, ptype)];
+                const ts2 = typeSymbolOf(ptype);
+                if (ts2)
+                    pendingReturns.push({ path, field: "instanceOf", target: ts2 });
+            }
+        }
+    };
+    const walk = (pkgName, entry, segs, raw, nsDepth) => {
+        if (count >= SYMBOL_CAP) {
+            flags.add("symbol-cap");
+            return;
+        }
+        const sym = resolveAlias(raw);
+        const path = formatPath(pkgName, entry, segs);
+        const seen = firstPath.get(sym);
+        const f = sym.flags;
+        const isModule = !!(f & ts.SymbolFlags.ValueModule) &&
+            !!sym.declarations?.some((d) => ts.isSourceFile(d) || ts.isModuleDeclaration(d));
+        const isNamespaceOnly = isModule ||
+            (!!(f & ts.SymbolFlags.NamespaceModule) &&
+                !(f &
+                    (ts.SymbolFlags.Function |
+                        ts.SymbolFlags.Class |
+                        ts.SymbolFlags.Variable |
+                        ts.SymbolFlags.Interface |
+                        ts.SymbolFlags.TypeAlias |
+                        ts.SymbolFlags.Enum)));
+        if (seen && seen !== path) {
+            emit({
+                path,
+                kind: isNamespaceOnly ? "namespace" : kindOf(f),
+                sig: [],
+                deprecated: false,
+                aliasOf: seen,
+            });
+            return;
+        }
+        firstPath.set(sym, path);
+        if (isNamespaceOnly) {
+            emit({ path, kind: "namespace", sig: [], deprecated: false });
+            if (nsDepth >= NAMESPACE_DEPTH)
+                return;
+            let exports = [];
+            try {
+                exports = checker.getExportsOfModule(sym);
+            }
+            catch {
+                return;
+            }
+            for (const e of [...exports].sort((a, b) => a.getName().localeCompare(b.getName()))) {
+                walk(pkgName, entry, [...segs, { name: e.getName(), sep: "." }], e, nsDepth + 1);
+            }
+            return;
+        }
+        const record = {
+            path,
+            kind: kindOf(f),
+            sig: [],
+            deprecated: deprecatedOf(sym),
+        };
+        if (!emit(record))
+            return;
+        try {
+            if (f & ts.SymbolFlags.Class) {
+                const staticType = checker.getTypeOfSymbol(sym);
+                record.sig = staticType
+                    .getConstructSignatures()
+                    .map((s) => signatureText(checker, s))
+                    .sort();
+                record.instanceOf = path;
+                walkMembers(path, checker.getDeclaredTypeOfSymbol(sym), "#", pkgName, entry, segs);
+                walkMembers(path, staticType, ".", pkgName, entry, segs);
+            }
+            else if (f & ts.SymbolFlags.Interface) {
+                const t = checker.getDeclaredTypeOfSymbol(sym);
+                record.sig = t
+                    .getCallSignatures()
+                    .map((s) => signatureText(checker, s))
+                    .sort();
+                walkMembers(path, t, "#", pkgName, entry, segs);
+            }
+            else if (f & ts.SymbolFlags.TypeAlias) {
+                const t = checker.getDeclaredTypeOfSymbol(sym);
+                const tps = sym.declarations?.[0]?.typeParameters?.map((tp) => tp.name.text) ?? [];
+                record.sig = [typeText(checker, t, tps)];
+                if (t.flags & ts.TypeFlags.Object && !(t.flags & ts.TypeFlags.Union))
+                    walkMembers(path, t, "#", pkgName, entry, segs);
+            }
+            else if (f & ts.SymbolFlags.Enum) {
+                const t = checker.getTypeOfSymbol(sym);
+                for (const m of checker.getPropertiesOfType(t)) {
+                    emit({
+                        path: formatPath(pkgName, entry, [
+                            ...segs,
+                            { name: m.getName(), sep: "." },
+                        ]),
+                        kind: "enum-member",
+                        sig: [typeText(checker, checker.getTypeOfSymbol(m))],
+                        deprecated: deprecatedOf(m),
+                    });
+                }
+            }
+            else if (f &
+                (ts.SymbolFlags.Function |
+                    ts.SymbolFlags.Variable |
+                    ts.SymbolFlags.Property)) {
+                const decl = sym.valueDeclaration ?? sym.declarations?.[0];
+                const t = decl
+                    ? checker.getTypeOfSymbolAtLocation(sym, decl)
+                    : checker.getTypeOfSymbol(sym);
+                const sigs = callSigs(t, path);
+                record.sig = sigs.length > 0 ? sigs : [typeText(checker, t)];
+                if (sigs.length === 0) {
+                    const ts2 = typeSymbolOf(t);
+                    if (ts2)
+                        pendingReturns.push({ path, field: "instanceOf", target: ts2 });
+                    else if (f & ts.SymbolFlags.Variable &&
+                        t.flags & ts.TypeFlags.Object &&
+                        nsDepth < NAMESPACE_DEPTH) {
+                        walkMembers(path, t, ".", pkgName, entry, segs);
+                    }
+                }
+                // function merged with a namespace: createApp(), createApp.json()
+                if (f & ts.SymbolFlags.NamespaceModule && nsDepth < NAMESPACE_DEPTH) {
+                    for (const e of checker.getExportsOfModule(sym))
+                        walk(pkgName, entry, [...segs, { name: e.getName(), sep: "." }], e, nsDepth + 1);
+                }
+            }
+            // a class, interface or type merged with a namespace: Dialog.Root and Dialog.Root.Props
+            if (f &
+                (ts.SymbolFlags.Class |
+                    ts.SymbolFlags.Interface |
+                    ts.SymbolFlags.TypeAlias |
+                    ts.SymbolFlags.Enum) &&
+                f & ts.SymbolFlags.NamespaceModule &&
+                nsDepth < NAMESPACE_DEPTH) {
+                for (const e of checker.getExportsOfModule(sym))
+                    walk(pkgName, entry, [...segs, { name: e.getName(), sep: "." }], e, nsDepth + 1);
+            }
+        }
+        catch (error) {
+            record.sig = [`#error:${String(error).slice(0, 40)}`];
+        }
+    };
+    for (const e of entries) {
+        const sf = program.getSourceFile(`${PKG_ROOT}/${e.typesFile}`);
+        if (!sf)
+            continue;
+        const moduleSym = checker.getSymbolAtLocation(sf);
+        if (!moduleSym)
+            continue;
+        const exportEquals = !!moduleSym.exports?.has(ts.InternalSymbolName.ExportEquals);
+        const externalReexports = unresolvedReexports(sf, pkg, options, host);
+        surfaceEntries[e.subpath] = {
+            typesFile: e.typesFile,
+            exportEquals,
+            ...(externalReexports.length > 0 ? { externalReexports } : {}),
+        };
+        if (exportEquals) {
+            const target = resolveAlias(moduleSym.exports.get(ts.InternalSymbolName.ExportEquals));
+            const decl = target.valueDeclaration ?? target.declarations?.[0];
+            const path = formatPath(pkg, e.subpath, []);
+            if (decl &&
+                target.flags &
+                    (ts.SymbolFlags.Function |
+                        ts.SymbolFlags.Variable |
+                        ts.SymbolFlags.Class)) {
+                const t = checker.getTypeOfSymbolAtLocation(target, decl);
+                const construct = t.getConstructSignatures();
+                const callable = t.getCallSignatures().length > 0 || construct.length > 0;
+                const record = {
+                    path,
+                    kind: target.flags & ts.SymbolFlags.Class
+                        ? "class"
+                        : callable
+                            ? "function"
+                            : "variable",
+                    sig: [],
+                    deprecated: deprecatedOf(target),
+                };
+                if (emit(record)) {
+                    record.sig = callable
+                        ? [
+                            ...callSigs(t, path),
+                            ...construct.map((s) => `new ${signatureText(checker, s)}`),
+                        ].sort()
+                        : [typeText(checker, t)];
+                    if (construct[0]) {
+                        const rs = typeSymbolOf(checker.getReturnTypeOfSignature(construct[0]));
+                        if (rs)
+                            pendingReturns.push({ path, field: "instanceOf", target: rs });
+                    }
+                    // `export = globals` where globals is an object: its properties are the module's names
+                    if (!callable && t.flags & ts.TypeFlags.Object)
+                        walkMembers(path, t, ".", pkg, e.subpath, []);
+                }
+            }
+        }
+        let exports = [];
+        try {
+            exports = checker.getExportsOfModule(moduleSym);
+        }
+        catch {
+            continue;
+        }
+        for (const ex of [...exports].sort((a, b) => a.getName().localeCompare(b.getName()))) {
+            if (ex.escapedName === ts.InternalSymbolName.ExportEquals)
+                continue;
+            walk(pkg, e.subpath, [{ name: ex.getName(), sep: "." }], ex, 0);
+        }
+    }
+    for (const r of pendingReturns) {
+        const target = firstPath.get(r.target);
+        const rec = symbols[r.path];
+        if (target && rec)
+            rec[r.field] = target;
+    }
+    if (hasUnresolvedImports(program, options, host, pkg))
+        flags.add("external-types-unresolved");
+    return {
+        ok: true,
+        surface: {
+            pkg,
+            version,
+            integrity,
+            ts: ts.version,
+            algo: ALGO,
+            typesFrom: pkg.startsWith("@types/") ? "@types" : "package",
+            entries: surfaceEntries,
+            symbols,
+            flags: [...flags].sort(),
+        },
+    };
+}
+// On an instantiated owner `this` already reads as the owner's name: `C extends ... ? StringSchema & X : StringSchema`
+function mentionsOwner(text, ownerPath) {
+    const owner = parsePath(ownerPath).segs.at(-1)?.name;
+    if (/(?<![\w$.])this(?![\w$])/.test(text))
+        return true;
+    return (!!owner &&
+        new RegExp(`(?<![\\w$.])${owner.replace(/[$]/g, "\\$")}(?![\\w$])`).test(text));
+}
+function kindOf(f) {
+    if (f & ts.SymbolFlags.Class)
+        return "class";
+    if (f & ts.SymbolFlags.Interface)
+        return "interface";
+    if (f & ts.SymbolFlags.TypeAlias)
+        return "type";
+    if (f & ts.SymbolFlags.Enum)
+        return "enum";
+    if (f & ts.SymbolFlags.Function)
+        return "function";
+    if (f & (ts.SymbolFlags.ValueModule | ts.SymbolFlags.NamespaceModule))
+        return "namespace";
+    return "variable";
+}
+function unresolvedReexports(sf, pkg, options, host) {
+    const out = [];
+    for (const stmt of sf.statements) {
+        if (!ts.isExportDeclaration(stmt) ||
+            !stmt.moduleSpecifier ||
+            !ts.isStringLiteral(stmt.moduleSpecifier))
+            continue;
+        const name = stmt.moduleSpecifier.text;
+        if (name.startsWith(".") || name === pkg || name.startsWith(`${pkg}/`))
+            continue;
+        if (!ts.resolveModuleName(name, sf.fileName, options, host).resolvedModule &&
+            !out.includes(name))
+            out.push(name);
+    }
+    return out;
+}
+// Imports of the package's own dependencies resolve to nothing in the virtual host, the same way in
+// both versions. Worth a flag, not worth a full type check to find.
+function hasUnresolvedImports(program, options, host, pkg) {
+    let checked = 0;
+    for (const sf of program.getSourceFiles()) {
+        if (!sf.fileName.startsWith(`${PKG_ROOT}/`))
+            continue;
+        for (const imp of ts.preProcessFile(sf.text, true, true).importedFiles) {
+            const name = imp.fileName;
+            if (name.startsWith(".") || name === pkg || name.startsWith(`${pkg}/`))
+                continue;
+            if (++checked > 500)
+                return false;
+            if (!ts.resolveModuleName(name, sf.fileName, options, host).resolvedModule)
+                return true;
+        }
+    }
+    return false;
+}

package/dist/surface/signature.d.ts

@@ -0,0 +1,6 @@
+import ts from "typescript";
+export declare const ALGO = 8;
+export declare function typeText(checker: ts.TypeChecker, type: ts.Type, typeParams?: string[]): string;
+export declare function signatureText(checker: ts.TypeChecker, sig: ts.Signature): string;
+export declare function normalizeTypeText(input: string): string;
+//# sourceMappingURL=signature.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"signature.d.ts","sourceRoot":"","sources":["../../src/surface/signature.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAM3B,eAAO,MAAM,IAAI,IAAI,CAAA;AAWrB,wBAAgB,QAAQ,CACtB,OAAO,EAAE,EAAE,CAAC,WAAW,EACvB,IAAI,EAAE,EAAE,CAAC,IAAI,EACb,UAAU,GAAE,MAAM,EAAO,GACxB,MAAM,CAIR;AAID,wBAAgB,aAAa,CAC3B,OAAO,EAAE,EAAE,CAAC,WAAW,EACvB,GAAG,EAAE,EAAE,CAAC,SAAS,GAChB,MAAM,CAmBR;AAcD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAOvD"}