pasika 0.3.2 → 0.3.4

package/dist/enforcement/parse-docs.js

@@ -1,94 +0,0 @@
-import { readdirSync, readFileSync, statSync } from "node:fs";
-import path from "node:path";
-import { hashRequirement, normalizeRequirement } from "./normalize.js";
-const KIND_BY_SUFFIX = [
-    ["-rule.md", "rule"],
-    ["-guide.md", "guide"],
-    ["-reference.md", "reference"],
-    ["-policy.md", "policy"],
-];
-/** Words that carry requirement strength, longest first so `MUST NOT` wins over `MUST`. */
-const RFC_2119 = /\b(?<keyword>MUST NOT|MUST|SHOULD NOT|SHOULD|MAY)\b/;
-function listMarkdownFiles(dir) {
-    return readdirSync(dir).flatMap((entry) => {
-        const entryPath = path.join(dir, entry);
-        if (statSync(entryPath).isDirectory()) {
-            // Underscore folders hold templates and other support assets, not documents.
-            return entry.startsWith("_") ? [] : listMarkdownFiles(entryPath);
-        }
-        return entry.endsWith(".md") ? [entryPath] : [];
-    });
-}
-/**
- * Blanks fenced code blocks and unwraps inline code spans, keeping one entry per
- * source line so reported line numbers still match the file.
- */
-function toProse(body, codeSpanReplacement) {
-    let insideFence = false;
-    return body.split("\n").map((line) => {
-        if (/^\s*(?:```|~~~)/.test(line)) {
-            insideFence = !insideFence;
-            return "";
-        }
-        if (insideFence)
-            return "";
-        return line.replaceAll(/`(?<content>[^`]*)`/g, codeSpanReplacement);
-    });
-}
-function findDocLinks(line) {
-    return [...line.matchAll(/\]\((?<target>[^)]*\.md[^)]*)\)/g)].map((match) => match.groups?.target ?? "");
-}
-export function parseDoc(filePath, docsRoot) {
-    const body = readFileSync(filePath, "utf8");
-    const prose = toProse(body, "$<content>");
-    const proseWithoutCode = toProse(body, "");
-    const fileName = path.basename(filePath);
-    const kind = KIND_BY_SUFFIX.find(([suffix]) => fileName.endsWith(suffix))?.[1];
-    const requirements = [];
-    const steps = [];
-    const exampleHeadings = [];
-    const sectionHeadings = [];
-    const docLinks = [];
-    prose.forEach((line, index) => {
-        const lineNumber = index + 1;
-        for (const target of findDocLinks(line)) {
-            docLinks.push({ line: lineNumber, target });
-        }
-        if (/^\s*[-*]\s/.test(line) && RFC_2119.test(line)) {
-            const text = normalizeRequirement(line);
-            requirements.push({ text, hash: hashRequirement(text), raw: line.replace(/^\s*[-*]\s+/, ""), line: lineNumber });
-        }
-        if (/^\s*\d+\.\s/.test(line)) {
-            steps.push({ line: lineNumber, text: line.replace(/^\s*\d+\.\s+/, ""), links: findDocLinks(line) });
-        }
-        if (/^## (?:Incorrect|Correct)\b/.test(line)) {
-            exampleHeadings.push({ line: lineNumber, text: line.slice(3).trim() });
-        }
-        else if (line.startsWith("## ")) {
-            sectionHeadings.push({ line: lineNumber, text: line.slice(3).trim() });
-        }
-    });
-    const title = /^# (?<title>.+)$/m.exec(body)?.groups?.title?.trim() ?? "";
-    const overview = prose.slice(1).find((line) => line.trim() !== "" && !line.startsWith("#"));
-    return {
-        filePath,
-        doc: path.relative(docsRoot, filePath).split(path.sep).join("/"),
-        fileName,
-        kind,
-        title,
-        overview,
-        prose,
-        proseWithoutCode,
-        requirements,
-        steps,
-        exampleHeadings,
-        docLinks,
-        sectionHeadings,
-    };
-}
-export function parseDocs(docsRoot) {
-    return listMarkdownFiles(docsRoot)
-        .sort((a, b) => a.localeCompare(b))
-        .map((filePath) => parseDoc(filePath, docsRoot));
-}
-export { RFC_2119 };

package/dist/enforcement/types.d.ts

@@ -1,54 +0,0 @@
-/**
- * The enforcement registry — the record of how every documented requirement is
- * checked.
- *
- * A requirement is identified by the hash of its canonical text, not by a
- * hand-written id. Rewording a requirement therefore changes its hash, which
- * makes `pasika coverage` report it as changed until someone re-confirms that
- * the recorded enforcement still covers it.
- */
-import { z } from "zod";
-export declare const enforcementKindSchema: z.ZodEnum<{
-    eslint: "eslint";
-    doctor: "doctor";
-    judgment: "judgment";
-    permission: "permission";
-    planned: "planned";
-}>;
-export declare const requirementSchema: z.ZodObject<{
-    doc: z.ZodString;
-    text: z.ZodString;
-    hash: z.ZodString;
-    kind: z.ZodEnum<{
-        eslint: "eslint";
-        doctor: "doctor";
-        judgment: "judgment";
-        permission: "permission";
-        planned: "planned";
-    }>;
-    ref: z.ZodOptional<z.ZodString>;
-    note: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export declare const registrySchema: z.ZodObject<{
-    requirements: z.ZodArray<z.ZodObject<{
-        doc: z.ZodString;
-        text: z.ZodString;
-        hash: z.ZodString;
-        kind: z.ZodEnum<{
-            eslint: "eslint";
-            doctor: "doctor";
-            judgment: "judgment";
-            permission: "permission";
-            planned: "planned";
-        }>;
-        ref: z.ZodOptional<z.ZodString>;
-        note: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type EnforcementKind = z.infer<typeof enforcementKindSchema>;
-export type Requirement = z.infer<typeof requirementSchema>;
-export type Registry = z.infer<typeof registrySchema>;
-/** Every kind, in the order the coverage summary prints them. */
-export declare const ENFORCEMENT_KINDS: EnforcementKind[];
-/** The kinds that count as mechanically enforced today. */
-export declare const MECHANICAL_KINDS: EnforcementKind[];

package/dist/enforcement/types.js

@@ -1,50 +0,0 @@
-/**
- * The enforcement registry — the record of how every documented requirement is
- * checked.
- *
- * A requirement is identified by the hash of its canonical text, not by a
- * hand-written id. Rewording a requirement therefore changes its hash, which
- * makes `pasika coverage` report it as changed until someone re-confirms that
- * the recorded enforcement still covers it.
- */
-import { z } from "zod";
-export const enforcementKindSchema = z.enum([
-    /** An ESLint rule reports it. */
-    "eslint",
-    /** A `pasika doctor` check reports it. */
-    "doctor",
-    /** No mechanical check can decide it; a reviewer or agent applies it. */
-    "judgment",
-    /** The requirement grants permission, so there is nothing to check. */
-    "permission",
-    /** A mechanical check is possible but not written yet. */
-    "planned",
-]);
-export const requirementSchema = z.object({
-    /** Document path relative to the docs root. */
-    doc: z.string(),
-    /** Canonical requirement text: links flattened, code spans unwrapped, whitespace collapsed. */
-    text: z.string(),
-    /** Short hash of `text`. */
-    hash: z.string(),
-    kind: enforcementKindSchema,
-    /**
-     * Identifier of the check that covers this requirement: an ESLint rule id or
-     * a doctor check id. Several ids are comma-separated.
-     * Absent for judgment and permission.
-     */
-    ref: z.string().optional(),
-    /**
-     * For `judgment`, why no mechanical check can decide it. For `planned`, the
-     * check that should cover it. For `eslint` and `doctor`, what the existing
-     * check does not cover.
-     */
-    note: z.string().optional(),
-});
-export const registrySchema = z.object({
-    requirements: z.array(requirementSchema),
-});
-/** Every kind, in the order the coverage summary prints them. */
-export const ENFORCEMENT_KINDS = ["eslint", "doctor", "planned", "judgment", "permission"];
-/** The kinds that count as mechanically enforced today. */
-export const MECHANICAL_KINDS = ["eslint", "doctor"];

package/dist/eslint/pasika/ast-types.d.ts

@@ -1,122 +0,0 @@
-/**
- * Local AST node types for the parser-specific shapes ESLint's ESTree types
- * do not carry: JSX nodes and TypeScript type nodes.
- *
- * Every extra field is optional so that any `Rule.Node` is assignable to these
- * types — the handler parameters of the rules must accept whatever the parser
- * hands them. Narrowing happens with `type`-discriminant checks inside each
- * rule, exactly as in `no-arbitrary-tailwind.ts`.
- */
-import type { Rule } from "eslint";
-import type * as ESTree from "estree";
-/** JSXIdentifier — the parser-specific name node of a JSX element or attribute. */
-export interface JsxIdentifier {
-    type: "JSXIdentifier";
-    name: string;
-}
-/** JSXMemberExpression — `<Foo.Bar>`, used by element and attribute names. */
-export interface JsxMemberExpression {
-    type: "JSXMemberExpression";
-    object: JsxIdentifier | JsxMemberExpression;
-    property: JsxIdentifier;
-}
-/** JSXExpressionContainer — the `{expression}` part of a JSX attribute value. */
-export interface JsxExpressionContainer {
-    type: "JSXExpressionContainer";
-    expression: ESTree.Expression;
-}
-/** JSXAttribute — `name="value"` or `name={expression}`. */
-export type JsxAttribute = Omit<Rule.Node, "type"> & {
-    type: string;
-    name: JsxIdentifier;
-    value: ESTree.Literal | JsxExpressionContainer | null;
-    parent?: JsxOpeningElementNode;
-};
-/** JSXSpreadAttribute — `{...props}`. */
-export interface JsxSpreadAttribute {
-    type: "JSXSpreadAttribute";
-    name?: never;
-    value?: never;
-    argument: ESTree.Expression;
-}
-/** Anything that can appear inside `attributes` of a JSX opening element. */
-export type JsxAttributeLike = JsxAttribute | JsxSpreadAttribute;
-/** JSXOpeningElement — the part before the closing `>` of an element. */
-export interface JsxOpeningElement {
-    type: "JSXOpeningElement";
-    name: JsxIdentifier | JsxMemberExpression;
-    attributes: JsxAttributeLike[];
-}
-/** A node that may be a JSX element — used for parents and helper parameters. */
-export type MaybeJsxElement = Rule.Node & {
-    openingElement?: JsxOpeningElement;
-};
-/** JSXElement as received by a `JSXElement` visitor. */
-export type JsxElementNode = MaybeJsxElement & {
-    parent?: MaybeJsxElement;
-};
-/** JSXAttribute as received by a `JSXAttribute` visitor, with its parent chain. */
-export type JsxAttributeNode = Rule.Node & {
-    name?: JsxIdentifier;
-    value?: ESTree.Literal | JsxExpressionContainer | null;
-    parent?: JsxOpeningElementNode;
-};
-/** JSXOpeningElement reached through a parent chain. */
-export type JsxOpeningElementNode = Rule.Node & {
-    name?: JsxIdentifier;
-    attributes?: JsxAttributeLike[];
-    parent?: JsxElementNode;
-};
-/**
- * FunctionDeclaration as seen by a rule visitor. ESLint's ESTree typing says
- * `id` is always present, but an anonymous `export default function () {}`
- * reaches the visitor with `id: null`, so the field is kept nullable.
- */
-export type FunctionDeclarationNode = Rule.Node & {
-    id?: {
-        name?: string;
-    } | null;
-    body?: ESTree.BlockStatement;
-};
-/**
- * TSTypeAliasDeclaration — `type X = ...`, from the typescript-eslint parser.
- *
- * Kept as a plain `Rule.Node` intersection so it can be passed to
- * `context.report`, which requires an ESTree node.
- */
-export type TsTypeAliasDeclarationNode = Rule.Node & {
-    id?: {
-        type?: string;
-        name?: string;
-    };
-    typeAnnotation?: TsTypeNode;
-};
-/**
- * A member of a type literal (TSPropertySignature, TSIndexSignature, ...).
- *
- * The `type` field is widened (via Omit) so it can be compared against the
- * parser-specific "TSPropertySignature" string that ESTree's union lacks.
- */
-export type TsTypeElementNode = Omit<Rule.Node, "type"> & {
-    type: string;
-    key?: {
-        type?: string;
-        name?: string;
-    };
-    typeAnnotation?: TsTypeAnnotationNode;
-};
-/** TSTypeAnnotation — the `: T` wrapper around a type node. */
-export type TsTypeAnnotationNode = Omit<Rule.Node, "type"> & {
-    type: string;
-    typeAnnotation?: TsTypeNode;
-};
-/** Any TypeScript type node the rules read (TSTypeLiteral, TSUnionType, ...). */
-export type TsTypeNode = Omit<Rule.Node, "type"> & {
-    type: string;
-    members?: TsTypeElementNode[];
-    types?: TsTypeNode[];
-    literal?: {
-        type?: string;
-        value?: unknown;
-    };
-};

package/dist/eslint/pasika/ast-types.js

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

package/dist/eslint/pasika/project/ccf.d.ts

@@ -1,48 +0,0 @@
-import type { ProjectIndex } from "./index.js";
-export declare const SUPPORT_FOLDERS: Set<string>;
-/** Path of a file relative to the source root, as segments. */
-export declare function segmentsOf(file: string, sourceRoot: string): string[];
-/** Folder of a file relative to the source root, as segments. */
-export declare function folderSegmentsOf(file: string, sourceRoot: string): string[];
-export declare const isUnderApp: (segments: string[]) => boolean;
-export declare const isConfigModule: (segments: string[]) => boolean;
-export declare const isUnderCompositions: (segments: string[]) => boolean;
-export interface ComponentPlacement {
-    /** Consumers that count toward the calculation, as absolute paths. */
-    countedConsumers: string[];
-    /** Folder the component belongs in, relative to the source root. */
-    expectedFolder: string[];
-    /** Why the expected folder is what it is, for the report. */
-    reason: "ccf" | "across-features" | "across-layers";
-}
-/**
- * Resolves where a component belongs from the files that import it.
- *
- * Imports from `src/app/` and from configuration modules drop out, consumers
- * under `src/compositions/` count only when every consumer is there, and a
- * result of `src/features/` becomes `src/shared/` because no feature may import
- * from another. Returns undefined when no consumer counts, which is the case the
- * "lives in the feature it represents" requirement covers instead.
- */
-export declare function resolveComponentPlacement(componentFile: string, index: ProjectIndex): ComponentPlacement | undefined;
-export declare const formatFolder: (folder: string[]) => string;
-export interface SupportPlacement {
-    countedConsumers: string[];
-    expectedFolder: string[];
-    reason: "app-consumer" | "config-module" | "ccf" | "across-features" | "across-layers";
-}
-/**
- * Resolves where a support file belongs from the files that import it.
- *
- * A consumer inside a support folder is owned by that folder's parent, so the
- * calculation lands on the scope that uses the file rather than on a sibling
- * support folder. A consumer under `src/app/` forces the root support folder, a
- * set of consumers inside one configuration module keeps the file in that module,
- * and consumers spanning features land in the root support folder.
- */
-export declare function resolveSupportPlacement(supportFile: string, supportFolder: string, index: ProjectIndex): SupportPlacement | undefined;
-/**
- * Consumers for a message. A widely used file can have dozens, so the list is
- * capped: the point is to show where the requirement comes from, not to enumerate.
- */
-export declare function describeConsumers(consumers: string[], sourceRoot: string): string;

package/dist/eslint/pasika/project/ccf.js

@@ -1,119 +0,0 @@
-import path from "node:path";
-export const SUPPORT_FOLDERS = new Set(["hooks", "types", "schemas", "constants", "utils"]);
-/** Path of a file relative to the source root, as segments. */
-export function segmentsOf(file, sourceRoot) {
-    const relative = path.relative(sourceRoot, file);
-    return relative.startsWith("..") ? [] : relative.split(path.sep);
-}
-/** Folder of a file relative to the source root, as segments. */
-export function folderSegmentsOf(file, sourceRoot) {
-    return segmentsOf(file, sourceRoot).slice(0, -1);
-}
-export const isUnderApp = (segments) => segments[0] === "app";
-export const isConfigModule = (segments) => segments[0] === "config";
-export const isUnderCompositions = (segments) => segments[0] === "compositions";
-/** The longest folder prefix every path shares. */
-function commonPrefix(folders) {
-    if (folders.length === 0)
-        return [];
-    const [first = []] = folders;
-    const shared = [];
-    for (const [depth, segment] of first.entries()) {
-        if (!folders.every((folder) => folder[depth] === segment))
-            break;
-        shared.push(segment);
-    }
-    return shared;
-}
-/** Walks out of any trailing support folders, since a component never lives in one. */
-function outOfSupportFolders(folder) {
-    const result = [...folder];
-    while (result.length > 0 && SUPPORT_FOLDERS.has(result[result.length - 1] ?? ""))
-        result.pop();
-    return result;
-}
-/**
- * Resolves where a component belongs from the files that import it.
- *
- * Imports from `src/app/` and from configuration modules drop out, consumers
- * under `src/compositions/` count only when every consumer is there, and a
- * result of `src/features/` becomes `src/shared/` because no feature may import
- * from another. Returns undefined when no consumer counts, which is the case the
- * "lives in the feature it represents" requirement covers instead.
- */
-export function resolveComponentPlacement(componentFile, index) {
-    const consumers = [...(index.consumers.get(componentFile) ?? [])];
-    const relevant = consumers.filter((consumer) => {
-        const segments = segmentsOf(consumer, index.sourceRoot);
-        return segments.length > 0 && !isUnderApp(segments) && !isConfigModule(segments);
-    });
-    if (relevant.length === 0)
-        return undefined;
-    const outsideCompositions = relevant.filter((consumer) => !isUnderCompositions(segmentsOf(consumer, index.sourceRoot)));
-    const counted = outsideCompositions.length > 0 ? outsideCompositions : relevant;
-    const shared = outOfSupportFolders(commonPrefix(counted.map((consumer) => folderSegmentsOf(consumer, index.sourceRoot))));
-    // A shared folder of `features` or of the source root itself means no single
-    // feature owns the component, so it belongs to the shared layer.
-    if (shared.length === 1 && shared[0] === "features") {
-        return { countedConsumers: counted, expectedFolder: ["shared"], reason: "across-features" };
-    }
-    if (shared.length === 0) {
-        return { countedConsumers: counted, expectedFolder: ["shared"], reason: "across-layers" };
-    }
-    return { countedConsumers: counted, expectedFolder: shared, reason: "ccf" };
-}
-export const formatFolder = (folder) => `src/${folder.join("/")}/`;
-/** The folder that owns a consumer: its own folder, stepped out of any support folder. */
-function owningFolderOf(consumer, sourceRoot) {
-    return outOfSupportFolders(folderSegmentsOf(consumer, sourceRoot));
-}
-/** The configuration module a file belongs to. `config/<name>/...` only: `config/<file>.ts` is not a module. */
-const configModuleOf = (segments) => isConfigModule(segments) && segments.length >= 3 ? segments[1] : undefined;
-/**
- * Resolves where a support file belongs from the files that import it.
- *
- * A consumer inside a support folder is owned by that folder's parent, so the
- * calculation lands on the scope that uses the file rather than on a sibling
- * support folder. A consumer under `src/app/` forces the root support folder, a
- * set of consumers inside one configuration module keeps the file in that module,
- * and consumers spanning features land in the root support folder.
- */
-export function resolveSupportPlacement(supportFile, supportFolder, index) {
-    const consumers = [...(index.consumers.get(supportFile) ?? [])].filter((consumer) => segmentsOf(consumer, index.sourceRoot).length > 0);
-    if (consumers.length === 0)
-        return undefined;
-    const consumerSegments = consumers.map((consumer) => segmentsOf(consumer, index.sourceRoot));
-    if (consumerSegments.some((segments) => isUnderApp(segments))) {
-        return { countedConsumers: consumers, expectedFolder: [supportFolder], reason: "app-consumer" };
-    }
-    const configModules = new Set(consumerSegments.map((segments) => configModuleOf(segments)));
-    const [onlyConfigModule] = [...configModules];
-    if (configModules.size === 1 && onlyConfigModule !== undefined) {
-        return {
-            countedConsumers: consumers,
-            expectedFolder: ["config", onlyConfigModule, supportFolder],
-            reason: "config-module",
-        };
-    }
-    const shared = commonPrefix(consumers.map((consumer) => owningFolderOf(consumer, index.sourceRoot)));
-    if (shared.length === 1 && shared[0] === "features") {
-        return { countedConsumers: consumers, expectedFolder: [supportFolder], reason: "across-features" };
-    }
-    if (shared.length === 0) {
-        return { countedConsumers: consumers, expectedFolder: [supportFolder], reason: "across-layers" };
-    }
-    return { countedConsumers: consumers, expectedFolder: [...shared, supportFolder], reason: "ccf" };
-}
-/**
- * Consumers for a message. A widely used file can have dozens, so the list is
- * capped: the point is to show where the requirement comes from, not to enumerate.
- */
-export function describeConsumers(consumers, sourceRoot) {
-    const shown = 3;
-    const names = consumers
-        .map((consumer) => path.relative(path.dirname(sourceRoot), consumer).split(path.sep).join("/"))
-        .sort((left, right) => left.localeCompare(right));
-    if (names.length <= shown)
-        return names.join(", ");
-    return `${names.slice(0, shown).join(", ")} and ${String(names.length - shown)} more`;
-}

package/dist/eslint/pasika/project/index.d.ts

@@ -1,21 +0,0 @@
-import { type ParsedModule } from "./parse-module.js";
-export interface ProjectIndex {
-    sourceRoot: string;
-    /** Absolute file path to its parsed module. */
-    modules: Map<string, ParsedModule>;
-    /** Absolute file path to the files that import it. */
-    consumers: Map<string, Set<string>>;
-    /** `file` and name joined by a NUL, to the files that import that name from it. */
-    symbolConsumers: Map<string, Set<string>>;
-}
-export declare const symbolKey: (file: string, name: string) => string;
-/** Resolves an import specifier to a file inside the source tree, if it points at one. */
-export declare function resolveSpecifier(fromFile: string, specifier: string, sourceRoot: string): string | undefined;
-/**
- * The project index for a source tree, rebuilt only when the tree changed.
- * Returns undefined when the tree does not exist, which is how a repository
- * without a `src/` folder opts out of every cross-file rule.
- */
-export declare function getProjectIndex(sourceRoot: string): ProjectIndex | undefined;
-/** Drops the memoized index. Used by tests that write a fresh tree per case. */
-export declare function clearProjectIndex(): void;

package/dist/eslint/pasika/project/index.js

@@ -1,139 +0,0 @@
-import { readdirSync, statSync } from "node:fs";
-import path from "node:path";
-import { parseModule } from "./parse-module.js";
-const MODULE_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
-const INDEX_BASENAMES = ["index.ts", "index.tsx", "index.mts", "index.cts", "index.js", "index.jsx"];
-/**
- * How long a built index is trusted before its inputs are re-checked. A long
- * lived ESLint server keeps this module in memory across edits, so the index has
- * to notice a changed tree without re-reading it on every single file.
- */
-const REVALIDATE_AFTER_MS = 2000;
-export const symbolKey = (file, name) => `${file}\u0000${name}`;
-function listSourceFiles(dir) {
-    let entries;
-    try {
-        entries = readdirSync(dir);
-    }
-    catch {
-        return [];
-    }
-    return entries.flatMap((entry) => {
-        if (entry.startsWith(".") || entry === "node_modules")
-            return [];
-        const entryPath = path.join(dir, entry);
-        let stats;
-        try {
-            stats = statSync(entryPath);
-        }
-        catch {
-            return [];
-        }
-        if (stats.isDirectory())
-            return listSourceFiles(entryPath);
-        return MODULE_EXTENSIONS.includes(path.extname(entry)) ? [entryPath] : [];
-    });
-}
-/** Cheap fingerprint of the tree, so an unchanged tree is never re-parsed. */
-function fingerprint(files) {
-    let total = 0;
-    for (const file of files) {
-        try {
-            total += statSync(file).mtimeMs;
-        }
-        catch {
-            /* A file removed between listing and stat just drops out of the fingerprint. */
-        }
-    }
-    return `${String(files.length)}:${String(total)}`;
-}
-/** Resolves an import specifier to a file inside the source tree, if it points at one. */
-export function resolveSpecifier(fromFile, specifier, sourceRoot) {
-    let base;
-    if (specifier.startsWith("@/")) {
-        base = path.resolve(sourceRoot, specifier.slice(2));
-    }
-    else if (specifier.startsWith(".")) {
-        base = path.resolve(path.dirname(fromFile), specifier);
-    }
-    else {
-        return undefined;
-    }
-    const candidates = [
-        base,
-        ...MODULE_EXTENSIONS.map((extension) => `${base}${extension}`),
-        ...INDEX_BASENAMES.map((name) => path.join(base, name)),
-    ];
-    for (const candidate of candidates) {
-        try {
-            if (statSync(candidate).isFile())
-                return candidate;
-        }
-        catch {
-            /* Try the next candidate. */
-        }
-    }
-    return undefined;
-}
-function build(sourceRoot, files) {
-    const modules = new Map();
-    const consumers = new Map();
-    const symbolConsumers = new Map();
-    for (const file of files) {
-        try {
-            modules.set(file, parseModule(file));
-        }
-        catch {
-            /* A file that cannot be read or parsed contributes nothing to the graph. */
-        }
-    }
-    for (const [file, module] of modules) {
-        for (const moduleImport of module.imports) {
-            const target = resolveSpecifier(file, moduleImport.specifier, sourceRoot);
-            if (!target || !modules.has(target))
-                continue;
-            const fileConsumers = consumers.get(target) ?? new Set();
-            fileConsumers.add(file);
-            consumers.set(target, fileConsumers);
-            for (const name of moduleImport.names) {
-                const key = symbolKey(target, name);
-                const nameConsumers = symbolConsumers.get(key) ?? new Set();
-                nameConsumers.add(file);
-                symbolConsumers.set(key, nameConsumers);
-            }
-        }
-    }
-    return { sourceRoot, modules, consumers, symbolConsumers };
-}
-let cache;
-/**
- * The project index for a source tree, rebuilt only when the tree changed.
- * Returns undefined when the tree does not exist, which is how a repository
- * without a `src/` folder opts out of every cross-file rule.
- */
-export function getProjectIndex(sourceRoot) {
-    const now = Date.now();
-    if (cache?.index.sourceRoot === sourceRoot && now - cache.checkedAt < REVALIDATE_AFTER_MS) {
-        return cache.index;
-    }
-    try {
-        if (!statSync(sourceRoot).isDirectory())
-            return undefined;
-    }
-    catch {
-        return undefined;
-    }
-    const files = listSourceFiles(sourceRoot).sort((left, right) => left.localeCompare(right));
-    const currentFingerprint = fingerprint(files);
-    if (cache?.index.sourceRoot === sourceRoot && cache.fingerprint === currentFingerprint) {
-        cache.checkedAt = now;
-        return cache.index;
-    }
-    const index = build(sourceRoot, files);
-    cache = { index, checkedAt: now, fingerprint: currentFingerprint };
-    return index;
-}
-/** Drops the memoized index. Used by tests that write a fresh tree per case. */
-export function clearProjectIndex() {
-    cache = undefined;
-}