@dep-radius/core 0.1.0

package/dist/surface/signature.js

@@ -0,0 +1,229 @@
+import ts from "typescript";
+import { sha1 } from "../infra/hash.js";
+// Bump when a normalization changes: the cache key carries it, so old surfaces are never compared
+// with new ones.
+export const ALGO = 8;
+const FLAGS = ts.TypeFormatFlags.NoTruncation |
+    ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope |
+    ts.TypeFormatFlags.WriteArrowStyleSignature |
+    ts.TypeFormatFlags.OmitParameterModifiers |
+    ts.TypeFormatFlags.WriteTypeArgumentsOfSignature;
+const MAX_LEN = 3000;
+export function typeText(checker, type, typeParams = []) {
+    let s = checker.typeToString(type, undefined, FLAGS);
+    s = renameTypeParams(s, typeParams);
+    return normalizeTypeText(s);
+}
+// Parameter names are dropped (renaming one breaks nobody) and type parameters are renamed by
+// position, so `<T>(value: T) => T` and `<U>(v: U) => U` print the same.
+export function signatureText(checker, sig) {
+    const tps = sig.getTypeParameters() ?? [];
+    const names = tps.map((tp) => tp.symbol?.name ?? "T");
+    const tpText = tps.map((tp, i) => {
+        const c = tp.getConstraint();
+        return c ? `$T${i} extends ${typeText(checker, c, names)}` : `$T${i}`;
+    });
+    const params = sig.getParameters().map((p) => {
+        const decl = p.valueDeclaration;
+        const type = decl
+            ? checker.getTypeOfSymbolAtLocation(p, decl)
+            : checker.getTypeOfSymbol(p);
+        const rest = !!decl?.dotDotDotToken;
+        const optional = !!decl && (!!decl.questionToken || !!decl.initializer);
+        return `${rest ? "..." : ""}${typeText(checker, type, names)}${optional ? "?" : ""}`;
+    });
+    const ret = typeText(checker, checker.getReturnTypeOfSignature(sig), names);
+    const out = `${tpText.length > 0 ? `<${tpText.join(", ")}>` : ""}(${params.join(", ")}) => ${ret}`;
+    return out.length > MAX_LEN ? `#${sha1(out)}` : out;
+}
+function renameTypeParams(s, names) {
+    let out = s;
+    names.forEach((n, i) => {
+        if (!n || n.startsWith("$T"))
+            return;
+        out = out.replace(new RegExp(`(?<![\\w$.])${n.replace(/[$]/g, "\\$")}(?![\\w$])`, "g"), `$T${i}`);
+    });
+    return out;
+}
+export function normalizeTypeText(input) {
+    let s = stripQualifiers(input.replace(/import\("[^"]*"\)\./g, ""))
+        .replace(/\s+/g, " ")
+        .replace(/;\s*}/g, " }")
+        .trim();
+    s = sortOperands(s);
+    return s.length > MAX_LEN ? `#${sha1(s)}` : s;
+}
+// `ui.Component` and `Component` are the same type printed
+// through two import styles; the qualifier follows how a declaration file imports, not the API.
+function stripQualifiers(s) {
+    let out = "";
+    let inStr;
+    for (let i = 0; i < s.length; i++) {
+        const ch = s[i];
+        if (inStr) {
+            out += ch;
+            if (ch === inStr && s[i - 1] !== "\\")
+                inStr = undefined;
+            continue;
+        }
+        if (ch === '"' || ch === "'" || ch === "`") {
+            inStr = ch;
+            out += ch;
+            continue;
+        }
+        const m = /^[A-Za-z_$][\w$]*\.(?=[A-Za-z_$])/.exec(s.slice(i));
+        const prev = s[i - 1];
+        if (m && (prev === undefined || !/[\w$.]/.test(prev))) {
+            // drop every qualifier in a row: a.b.C -> C
+            let j = i + m[0].length;
+            for (let n = /^[A-Za-z_$][\w$]*\.(?=[A-Za-z_$])/.exec(s.slice(j)); n; n = /^[A-Za-z_$][\w$]*\.(?=[A-Za-z_$])/.exec(s.slice(j)))
+                j += n[0].length;
+            i = j - 1;
+            continue;
+        }
+        out += ch;
+    }
+    return out;
+}
+// Union and intersection members print in type-id order, which moves when unrelated code changes.
+// Sort them at every bracket depth.
+function sortOperands(s) {
+    // `error?: string | undefined` inside an object type: the label is not a union member
+    const label = /^((?:readonly\s+)?(?:[\w$]+|"[^"]*"|'[^']*'|\[[^\]]*\])\??:\s*)/.exec(s);
+    if (label?.[1])
+        return label[1] + sortOperands(s.slice(label[1].length));
+    const parts = splitTop(s, ["|", "&"]);
+    if (parts.items.length > 1) {
+        const op = parts.op;
+        return parts.items
+            .map((p) => sortOperands(p.trim()))
+            .sort()
+            .join(` ${op} `);
+    }
+    let out = "";
+    let i = 0;
+    while (i < s.length) {
+        const ch = s[i];
+        if (ch === "(" || ch === "<" || ch === "[" || ch === "{") {
+            const close = matching(s, i);
+            if (close < 0)
+                return s;
+            const inner = s.slice(i + 1, close);
+            out +=
+                ch +
+                    splitSeparators(inner)
+                        .map((seg) => {
+                        const lead = seg.match(/^\s*/)?.[0] ?? "";
+                        const trail = seg.slice(lead.length).match(/\s*[,;]?\s*$/)?.[0] ?? "";
+                        return (lead +
+                            sortOperands(seg.slice(lead.length, seg.length - trail.length)) +
+                            trail);
+                    })
+                        .join("") +
+                    s[close];
+            i = close + 1;
+        }
+        else {
+            out += ch;
+            i++;
+        }
+    }
+    return out;
+}
+// "a, B<c, d>; e" -> ["a, ", "B<c, d>; ", "e"]: separators at depth zero only, kept on their segment
+function splitSeparators(s) {
+    const out = [];
+    let depth = 0;
+    let inStr;
+    let cur = "";
+    for (let i = 0; i < s.length; i++) {
+        const ch = s[i];
+        cur += ch;
+        if (inStr) {
+            if (ch === inStr && s[i - 1] !== "\\")
+                inStr = undefined;
+            continue;
+        }
+        if (ch === '"' || ch === "'" || ch === "`")
+            inStr = ch;
+        else if ("(<[{".includes(ch))
+            depth++;
+        else if (")]}".includes(ch) || (ch === ">" && s[i - 1] !== "="))
+            depth--;
+        else if (depth === 0 && (ch === "," || ch === ";")) {
+            out.push(cur);
+            cur = "";
+        }
+    }
+    if (cur)
+        out.push(cur);
+    return out;
+}
+function splitTop(s, ops) {
+    let depth = 0;
+    let inStr;
+    const items = [];
+    let cur = "";
+    let op;
+    for (let i = 0; i < s.length; i++) {
+        const ch = s[i];
+        if (inStr) {
+            cur += ch;
+            if (ch === inStr && s[i - 1] !== "\\")
+                inStr = undefined;
+            continue;
+        }
+        if (ch === '"' || ch === "'" || ch === "`") {
+            inStr = ch;
+            cur += ch;
+            continue;
+        }
+        if ("(<[{".includes(ch))
+            depth++;
+        else if (")>]}".includes(ch) && !(ch === ">" && s[i - 1] === "="))
+            depth--;
+        if (depth === 0 && ops.includes(ch) && s[i + 1] !== ch && s[i - 1] !== ch) {
+            if (op && op !== ch)
+                return { items: [s] };
+            op = ch;
+            items.push(cur);
+            cur = "";
+            continue;
+        }
+        cur += ch;
+    }
+    items.push(cur);
+    return items.length > 1 ? { items, op: op } : { items: [s] };
+}
+function matching(s, open) {
+    const pairs = {
+        "(": ")",
+        "<": ">",
+        "[": "]",
+        "{": "}",
+    };
+    const stack = [];
+    let inStr;
+    for (let i = open; i < s.length; i++) {
+        const ch = s[i];
+        if (inStr) {
+            if (ch === inStr && s[i - 1] !== "\\")
+                inStr = undefined;
+            continue;
+        }
+        if (ch === '"' || ch === "'" || ch === "`") {
+            inStr = ch;
+            continue;
+        }
+        if (pairs[ch])
+            stack.push(pairs[ch]);
+        else if (ch === ">" && s[i - 1] === "=")
+            continue;
+        else if (ch === stack[stack.length - 1]) {
+            stack.pop();
+            if (stack.length === 0)
+                return i;
+        }
+    }
+    return -1;
+}

package/dist/surface/vfs-host.d.ts

@@ -0,0 +1,5 @@
+import ts from "typescript";
+export declare const PKG_ROOT = "/pkg";
+export declare function createVfsHost(files: Map<string, Buffer>): ts.CompilerHost;
+export declare function libPath(name: string): string;
+//# sourceMappingURL=vfs-host.d.ts.map

package/dist/surface/vfs-host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vfs-host.d.ts","sourceRoot":"","sources":["../../src/surface/vfs-host.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,MAAM,YAAY,CAAA;AAE3B,eAAO,MAAM,QAAQ,SAAS,CAAA;AAO9B,wBAAgB,aAAa,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,EAAE,CAAC,YAAY,CAiDzE;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE5C"}

package/dist/surface/vfs-host.js

@@ -0,0 +1,54 @@
+import { dirname, join } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import ts from "typescript";
+export const PKG_ROOT = "/pkg";
+const libDir = dirname(ts.getDefaultLibFilePath({}));
+const libSources = new Map();
+// A compiler host that sees the tarball's declarations under /pkg and the TypeScript lib files the
+// tool itself bundles, nothing else: the user's node_modules can never change a surface.
+export function createVfsHost(files) {
+    const texts = new Map();
+    const dirs = new Set([PKG_ROOT]);
+    for (const [rel, buf] of files) {
+        const abs = `${PKG_ROOT}/${rel}`;
+        texts.set(abs, buf.toString("utf8"));
+        let d = dirname(abs);
+        while (d.startsWith(PKG_ROOT) && !dirs.has(d)) {
+            dirs.add(d);
+            d = dirname(d);
+        }
+    }
+    const isLib = (f) => f.startsWith(libDir);
+    return {
+        getSourceFile(fileName, languageVersion) {
+            if (isLib(fileName)) {
+                let sf = libSources.get(fileName);
+                if (!sf && existsSync(fileName)) {
+                    sf = ts.createSourceFile(fileName, readFileSync(fileName, "utf8"), languageVersion, false);
+                    libSources.set(fileName, sf);
+                }
+                return sf;
+            }
+            const text = texts.get(fileName);
+            return text === undefined
+                ? undefined
+                : ts.createSourceFile(fileName, text, languageVersion, false);
+        },
+        getDefaultLibFileName: (o) => ts.getDefaultLibFilePath(o),
+        getDefaultLibLocation: () => libDir,
+        writeFile: () => { },
+        getCurrentDirectory: () => PKG_ROOT,
+        getCanonicalFileName: (f) => f,
+        useCaseSensitiveFileNames: () => true,
+        getNewLine: () => "\n",
+        fileExists: (f) => texts.has(f) || (isLib(f) && existsSync(f)),
+        readFile: (f) => texts.get(f) ??
+            (isLib(f) && existsSync(f) ? readFileSync(f, "utf8") : undefined),
+        directoryExists: (d) => dirs.has(d.replace(/\/$/, "")) || isLib(d) || d === libDir,
+        getDirectories: () => [],
+        realpath: (p) => p,
+    };
+}
+export function libPath(name) {
+    return join(libDir, name);
+}

package/dist/symbol-path.d.ts

@@ -0,0 +1,28 @@
+import type { CanonPath, ChainSeg, RawRef, Surface } from "./model.ts";
+export interface Seg {
+    name: string;
+    sep: "." | "#";
+}
+export declare function entryPrefix(pkg: string, entry: string): string;
+export declare function formatPath(pkg: string, entry: string, segs: Seg[]): CanonPath;
+export declare function parsePath(path: CanonPath): {
+    prefix: string;
+    segs: Seg[];
+};
+export declare function lastName(path: CanonPath): string;
+export declare function isNamespaceAlias(imported: string, called: boolean): boolean;
+export declare function effectiveChain(ref: RawRef): {
+    segs: ChainSeg[];
+    startsCalled: boolean;
+};
+export interface Resolution {
+    paths: CanonPath[];
+    unresolvedTail: string[];
+    missingHead: boolean;
+}
+export declare function resolveRef(surface: Surface, ref: RawRef): Resolution;
+export declare function level0Names(ref: RawRef): {
+    strong: string[];
+    weak: string[];
+};
+//# sourceMappingURL=symbol-path.d.ts.map

package/dist/symbol-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbol-path.d.ts","sourceRoot":"","sources":["../src/symbol-path.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EACT,QAAQ,EACR,MAAM,EACN,OAAO,EAER,MAAM,YAAY,CAAA;AAQnB,MAAM,WAAW,GAAG;IAClB,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,GAAG,GAAG,GAAG,CAAA;CACf;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAE9D;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,SAAS,CAM7E;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,SAAS,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,GAAG,EAAE,CAAA;CAAE,CAgB1E;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,CAGhD;AAID,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO,CAE3E;AAGD,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG;IAC3C,IAAI,EAAE,QAAQ,EAAE,CAAA;IAChB,YAAY,EAAE,OAAO,CAAA;CACtB,CAaA;AAED,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,SAAS,EAAE,CAAA;IAElB,cAAc,EAAE,MAAM,EAAE,CAAA;IAExB,WAAW,EAAE,OAAO,CAAA;CACrB;AAQD,wBAAgB,UAAU,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,GAAG,UAAU,CA+IpE;AAID,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG;IAAE,MAAM,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAA;CAAE,CAa7E"}

package/dist/symbol-path.js

@@ -0,0 +1,223 @@
+export function entryPrefix(pkg, entry) {
+    return entry === "." ? pkg : `${pkg}${entry.slice(1)}`;
+}
+export function formatPath(pkg, entry, segs) {
+    let out = `${entryPrefix(pkg, entry)}:`;
+    segs.forEach((s, i) => {
+        out += i === 0 ? s.name : `${s.sep}${s.name}`;
+    });
+    return out;
+}
+export function parsePath(path) {
+    const colon = path.indexOf(":", path.startsWith("@") ? path.indexOf("/") : 0);
+    const prefix = path.slice(0, colon);
+    const rest = path.slice(colon + 1);
+    const segs = [];
+    let sep = ".";
+    let cur = "";
+    for (const ch of rest) {
+        if (ch === "." || ch === "#") {
+            if (cur)
+                segs.push({ name: cur, sep });
+            sep = ch;
+            cur = "";
+        }
+        else
+            cur += ch;
+    }
+    if (cur)
+        segs.push({ name: cur, sep });
+    return { prefix, segs };
+}
+export function lastName(path) {
+    const segs = parsePath(path).segs;
+    return segs[segs.length - 1]?.name ?? "";
+}
+// A short or default named import that is not itself called is almost always a namespace alias:
+// `import { v } from "lib"; v.object()`. Called, it is a function: `import { fr } from "lib/locales"; fr()`.
+export function isNamespaceAlias(imported, called) {
+    return !called && (imported === "default" || imported.length <= 2);
+}
+// The chain as seen from the package's entry module, before any surface is known.
+export function effectiveChain(ref) {
+    const b = ref.binding;
+    let segs;
+    if (b.kind === "named") {
+        segs = isNamespaceAlias(b.imported, ref.callSelf)
+            ? [...ref.chain]
+            : [{ name: b.imported, call: ref.callSelf }, ...ref.chain];
+    }
+    else {
+        segs = [...ref.chain];
+    }
+    segs = segs.filter((s, i) => !(i === 0 && s.name === "default"));
+    const startsCalled = b.kind !== "named" && ref.callSelf;
+    return { segs, startsCalled };
+}
+const MAX_HOPS = 6;
+// Level 1: walk a usage chain through a surface. `v.email().max(254)` from "lib" resolves to
+// lib:email, then through its return type to lib:EmailSchema#max.
+export function resolveRef(surface, ref) {
+    // the surface's own name: @types/lib answers for code that imports "lib"
+    const prefix = entryPrefix(surface.pkg, ref.entry);
+    const out = { paths: [], unresolvedTail: [], missingHead: false };
+    if (ref.binding.kind === "derived") {
+        if (!ref.origin) {
+            out.unresolvedTail = ref.chain.map((s) => s.name);
+            return out;
+        }
+        // walk the construction, then the reads: only the reads are this site's own paths
+        const o = ref.origin;
+        const base = resolveRef(surface, {
+            ...ref,
+            binding: o.binding,
+            entry: o.entry,
+            chain: o.chain,
+            callSelf: o.callSelf,
+            origin: undefined,
+        });
+        const full = resolveRef(surface, {
+            ...ref,
+            binding: o.binding,
+            entry: o.entry,
+            chain: [
+                ...o.chain.map((s, i) => i === o.chain.length - 1 && ref.callSelf ? { ...s, call: true } : s),
+                ...ref.chain,
+            ],
+            callSelf: o.chain.length === 0 ? o.callSelf || ref.callSelf : o.callSelf,
+            origin: undefined,
+        });
+        // the walk is sequential, so the construction's paths are a prefix of the full walk
+        const prefixLen = base.paths.every((p, i) => full.paths[i] === p)
+            ? base.paths.length
+            : 0;
+        return {
+            paths: full.paths.slice(prefixLen),
+            unresolvedTail: full.unresolvedTail,
+            missingHead: false,
+        };
+    }
+    const entry = surface.entries[ref.entry];
+    if (!entry) {
+        out.missingHead = true;
+        out.unresolvedTail = ref.chain.map((s) => s.name);
+        return out;
+    }
+    const sym = (p) => {
+        let s = surface.symbols[p];
+        for (let i = 0; i < 5 && s?.aliasOf; i++) {
+            const next = surface.symbols[s.aliasOf];
+            if (!next)
+                break;
+            s = next;
+        }
+        return s;
+    };
+    const modulePath = `${prefix}:`;
+    const lookup = (cur, name) => cur.kind === "ns"
+        ? cur.base.endsWith(":")
+            ? `${cur.base}${name}`
+            : `${cur.base}.${name}`
+        : `${cur.path}#${name}`;
+    const b = ref.binding;
+    let cursor = { kind: "ns", base: modulePath };
+    let segs;
+    let startCall = false;
+    if (b.kind === "named") {
+        if (isNamespaceAlias(b.imported, ref.callSelf) &&
+            !surface.symbols[`${modulePath}${b.imported}`])
+            segs = [...ref.chain];
+        else
+            segs = [{ name: b.imported, call: ref.callSelf }, ...ref.chain];
+    }
+    else if (b.kind === "default") {
+        // ESM default export, else CommonJS interop hands over the module itself
+        const d = surface.symbols[`${modulePath}default`];
+        if (d)
+            segs = [{ name: "default", call: ref.callSelf }, ...ref.chain];
+        else {
+            segs = [...ref.chain];
+            startCall = ref.callSelf;
+        }
+    }
+    else {
+        segs = [...ref.chain];
+        startCall = ref.callSelf;
+    }
+    if (startCall) {
+        const self = surface.symbols[modulePath];
+        if (!self) {
+            out.unresolvedTail = segs.map((s) => s.name);
+            return out;
+        }
+        out.paths.push(modulePath);
+        cursor = self.returns
+            ? { kind: "type", path: self.returns }
+            : self.instanceOf
+                ? { kind: "type", path: self.instanceOf }
+                : undefined;
+    }
+    else if (segs.length === 0) {
+        return out;
+    }
+    let hops = 0;
+    for (let i = 0; i < segs.length; i++) {
+        const seg = segs[i];
+        if (!cursor || hops++ >= MAX_HOPS) {
+            out.unresolvedTail.push(...segs.slice(i).map((s) => s.name));
+            break;
+        }
+        const path = lookup(cursor, seg.name);
+        const raw = surface.symbols[path];
+        const found = sym(path);
+        if (!raw || !found) {
+            if (i === 0 && !startCall)
+                out.missingHead = true;
+            out.unresolvedTail.push(...segs.slice(i).map((s) => s.name));
+            break;
+        }
+        out.paths.push(path);
+        if (raw.aliasOf && found.path !== path)
+            out.paths.push(found.path);
+        if (found.kind === "namespace") {
+            cursor = { kind: "ns", base: found.path };
+            continue;
+        }
+        if (seg.call || seg.construct) {
+            const next = seg.construct
+                ? (found.instanceOf ?? found.returns)
+                : found.returns;
+            cursor = next ? { kind: "type", path: next } : undefined;
+            continue;
+        }
+        if (found.kind === "class" || found.kind === "enum")
+            cursor = { kind: "ns", base: found.path };
+        else if (found.kind === "interface" || found.kind === "type")
+            cursor = { kind: "type", path: found.path };
+        else if (found.instanceOf)
+            cursor = { kind: "type", path: found.instanceOf };
+        else
+            cursor =
+                found.kind === "variable" ? { kind: "ns", base: found.path } : undefined;
+    }
+    return out;
+}
+// Strong: segments up to and including the first call. Weak: what follows, and everything on a
+// derived value or on the result of calling the package itself (`createApp().use`).
+export function level0Names(ref) {
+    if (ref.binding.kind === "derived")
+        return { strong: [], weak: ref.chain.map((s) => s.name) };
+    const { segs, startsCalled } = effectiveChain(ref);
+    const strong = [];
+    const weak = [];
+    let called = startsCalled;
+    for (const s of segs) {
+        if (called)
+            weak.push(s.name);
+        else
+            strong.push(s.name);
+        if (s.call)
+            called = true;
+    }
+    return { strong, weak };
+}

package/dist/usage/files.d.ts

@@ -0,0 +1,18 @@
+export declare const SOURCE_EXT: RegExp;
+export declare const STYLE_EXT: RegExp;
+export interface SourceText {
+    rel: string;
+    blocks: {
+        text: string;
+        lineOffset: number;
+        kind: "ts" | "tsx" | "js" | "jsx";
+    }[];
+}
+export type Skip = {
+    rel: string;
+    reason: "generated" | "too-large";
+};
+export declare function isScannable(rel: string): boolean;
+export declare function skippedByLocation(rel: string): boolean;
+export declare function readSource(root: string, rel: string): Promise<SourceText | Skip>;
+//# sourceMappingURL=files.d.ts.map

package/dist/usage/files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"files.d.ts","sourceRoot":"","sources":["../../src/usage/files.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,UAAU,QAA0C,CAAA;AACjE,eAAO,MAAM,SAAS,QAA4C,CAAA;AAElE,MAAM,WAAW,UAAU;IACzB,GAAG,EAAE,MAAM,CAAA;IAEX,MAAM,EAAE;QACN,IAAI,EAAE,MAAM,CAAA;QACZ,UAAU,EAAE,MAAM,CAAA;QAClB,IAAI,EAAE,IAAI,GAAG,KAAK,GAAG,IAAI,GAAG,KAAK,CAAA;KAClC,EAAE,CAAA;CACJ;AAED,MAAM,MAAM,IAAI,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,WAAW,GAAG,WAAW,CAAA;CAAE,CAAA;AAIrE,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAIhD;AAED,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAQtD;AAED,wBAAsB,UAAU,CAC9B,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CA+C5B"}

package/dist/usage/files.js

@@ -0,0 +1,83 @@
+import { join } from "node:path";
+import { readFile } from "node:fs/promises";
+import { SKIP_DIRS } from "../inventory/manifests.js";
+export const SOURCE_EXT = /\.(?:[cm]?[jt]sx?|vue|svelte|astro)$/i;
+export const STYLE_EXT = /\.(?:css|scss|sass|less|pcss|postcss)$/i;
+const MAX_BYTES = 1_500_000;
+export function isScannable(rel) {
+    if (!SOURCE_EXT.test(rel))
+        return false;
+    const segs = rel.split("/");
+    return !segs.slice(0, -1).some((s) => SKIP_DIRS.has(s));
+}
+export function skippedByLocation(rel) {
+    return (SOURCE_EXT.test(rel) &&
+        rel
+            .split("/")
+            .slice(0, -1)
+            .some((s) => SKIP_DIRS.has(s) && s !== "node_modules"));
+}
+export async function readSource(root, rel) {
+    const buf = await readFile(join(root, rel));
+    if (buf.byteLength > MAX_BYTES)
+        return { rel, reason: "too-large" };
+    const text = buf.toString("utf8");
+    if (looksMinified(text))
+        return { rel, reason: "generated" };
+    const lower = rel.toLowerCase();
+    if (lower.endsWith(".vue") || lower.endsWith(".svelte")) {
+        const blocks = [];
+        const re = /<script\b([^>]*)>([\s\S]*?)<\/script>/gi;
+        for (let m = re.exec(text); m; m = re.exec(text)) {
+            const attrs = m[1] ?? "";
+            const body = m[2] ?? "";
+            const start = m.index + m[0].indexOf(">") + 1;
+            const ts = /\blang\s*=\s*["']?(ts|tsx)/i.test(attrs);
+            blocks.push({
+                text: body,
+                lineOffset: lineOf(text, start) - 1,
+                kind: ts ? "ts" : "js",
+            });
+        }
+        return { rel, blocks };
+    }
+    if (lower.endsWith(".astro")) {
+        const blocks = [];
+        const fm = /^---\r?\n([\s\S]*?)\r?\n---/.exec(text);
+        if (fm?.[1] !== undefined)
+            blocks.push({ text: fm[1], lineOffset: 1, kind: "ts" });
+        const re = /<script\b[^>]*>([\s\S]*?)<\/script>/gi;
+        for (let m = re.exec(text); m; m = re.exec(text)) {
+            const start = m.index + m[0].indexOf(">") + 1;
+            blocks.push({
+                text: m[1] ?? "",
+                lineOffset: lineOf(text, start) - 1,
+                kind: "ts",
+            });
+        }
+        return { rel, blocks };
+    }
+    const kind = /\.[cm]?tsx$/i.test(lower)
+        ? "tsx"
+        : /\.[cm]?ts$/i.test(lower)
+            ? "ts"
+            : /\.jsx$/i.test(lower)
+                ? "jsx"
+                : "js";
+    return { rel, blocks: [{ text, lineOffset: 0, kind }] };
+}
+function lineOf(text, index) {
+    let line = 1;
+    for (let i = 0; i < index; i++)
+        if (text.charCodeAt(i) === 10)
+            line++;
+    return line;
+}
+// Bundles and minified output have very long lines; reading them as source would invent usage.
+function looksMinified(text) {
+    if (text.length < 5000)
+        return false;
+    const lines = text.split("\n");
+    const long = lines.filter((l) => l.length > 1000).length;
+    return long > 0 && text.length / lines.length > 300;
+}

package/dist/usage/link.d.ts

@@ -0,0 +1,23 @@
+import type { FileFacts } from "./parse.ts";
+import type { LocalResolver } from "./resolve-local.ts";
+import type { BlindSpotKind, ChainSeg, Counted, Inventory, OpaqueKind, RawRef, RefOrigin, Site, UsageMap } from "../model.ts";
+export interface LinkInput {
+    root: string;
+    facts: Map<string, FileFacts>;
+    resolver: LocalResolver;
+    inventory: Inventory;
+    globalSkipped: Site[];
+}
+interface Acc {
+    refs: RawRef[];
+    blind: Map<BlindSpotKind, Site[]>;
+    opaque: Map<OpaqueKind, Site[]>;
+    proxied: boolean;
+}
+export declare function link(input: LinkInput): Promise<UsageMap & {
+    acc: Map<string, Acc>;
+}>;
+export declare function extendOrigin(origin: RefOrigin, chain: ChainSeg[], callSelf: boolean): RefOrigin;
+export declare function counted<K extends string>(m: Map<K, Site[]>): Counted<K>[];
+export {};
+//# sourceMappingURL=link.d.ts.map

package/dist/usage/link.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"link.d.ts","sourceRoot":"","sources":["../../src/usage/link.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAsB,MAAM,YAAY,CAAA;AAC/D,OAAO,KAAK,EAAE,aAAa,EAAU,MAAM,oBAAoB,CAAA;AAC/D,OAAO,KAAK,EAEV,aAAa,EACb,QAAQ,EACR,OAAO,EAEP,SAAS,EACT,UAAU,EAEV,MAAM,EACN,SAAS,EACT,IAAI,EACJ,QAAQ,EACT,MAAM,aAAa,CAAA;AAoBpB,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;IAC7B,QAAQ,EAAE,aAAa,CAAA;IACvB,SAAS,EAAE,SAAS,CAAA;IACpB,aAAa,EAAE,IAAI,EAAE,CAAA;CACtB;AAED,UAAU,GAAG;IACX,IAAI,EAAE,MAAM,EAAE,CAAA;IACd,KAAK,EAAE,GAAG,CAAC,aAAa,EAAE,IAAI,EAAE,CAAC,CAAA;IACjC,MAAM,EAAE,GAAG,CAAC,UAAU,EAAE,IAAI,EAAE,CAAC,CAAA;IAC/B,OAAO,EAAE,OAAO,CAAA;CACjB;AAED,wBAAsB,IAAI,CACxB,KAAK,EAAE,SAAS,GACf,OAAO,CAAC,QAAQ,GAAG;IAAE,GAAG,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;CAAE,CAAC,CA2mB/C;AAyBD,wBAAgB,YAAY,CAC1B,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,QAAQ,EAAE,EACjB,QAAQ,EAAE,OAAO,GAChB,SAAS,CASX;AAED,wBAAgB,OAAO,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,EAAE,CASzE"}