@design.estate/wcctools 5.1.0 → 6.1.0

package/dist_ts/standards/checker.js

@@ -0,0 +1,88 @@
+import * as plugins from '../plugins.js';
+import { severityIn } from './rule.js';
+import { allowlistStaleRuleId, standardRules } from './rules/index.js';
+/** The rules of a profile, in the order of docs/standard.md. */
+export const rulesOfProfile = (profileArg) => standardRules.filter((ruleArg) => severityIn(ruleArg, profileArg) !== null);
+/** The rules of a profile as the shell and the AI agent see them. */
+export const describeStandardRules = (profileArg) => rulesOfProfile(profileArg).map((ruleArg) => ({
+    id: ruleArg.id,
+    severity: severityIn(ruleArg, profileArg),
+    fixMode: ruleArg.fixMode,
+    allowlistCategories: [...(ruleArg.allowlistCategories ?? [])],
+}));
+/** Runs the rules of the configured profile; findings carry their fix actions. */
+export const detectFindings = (projectArg, loadedArg, rulesArg = rulesOfProfile(loadedArg.profile)) => {
+    const context = { project: projectArg, config: loadedArg.config, profile: loadedArg.profile };
+    const detected = [];
+    for (const rule of rulesArg) {
+        const allowlist = loadedArg.config.allowlist?.[rule.id] ?? {};
+        for (const finding of rule.detect(context)) {
+            detected.push({ rule, finding, allowlisted: Object.hasOwn(allowlist, finding.key) });
+        }
+    }
+    return detected;
+};
+const locate = (projectArg, fileArg, positionArg) => {
+    const text = projectArg.files.get(fileArg);
+    if (text === undefined) {
+        return { line: 1, column: 1 };
+    }
+    if (/\.(ts|tsx|mts|cts)$/.test(fileArg)) {
+        return projectArg.lineAndColumn(fileArg, positionArg);
+    }
+    const before = text.slice(0, positionArg);
+    return { line: before.split('\n').length, column: positionArg - before.lastIndexOf('\n') };
+};
+/** Checks a repository against the standard: findings, allowlist, baselines. */
+export const checkStandard = (projectArg, loadedArg) => {
+    const { config, profile } = loadedArg;
+    const detected = detectFindings(projectArg, loadedArg);
+    const findings = detected.map(({ rule, finding, allowlisted }) => ({
+        ruleId: rule.id,
+        severity: severityIn(rule, profile),
+        file: finding.file,
+        ...locate(projectArg, finding.file, finding.position),
+        message: finding.message,
+        fixable: !!finding.fix,
+        ...(allowlisted ? { covered: 'allowlist' } : {}),
+    }));
+    // An allowlist entry without its finding is stale: the list only shrinks.
+    for (const [ruleId, entries] of Object.entries(config.allowlist ?? {})) {
+        for (const key of Object.keys(entries)) {
+            if (!detected.some(({ rule, finding }) => rule.id === ruleId && finding.key === key)) {
+                findings.push({
+                    ruleId: allowlistStaleRuleId,
+                    severity: 'error',
+                    file: '.smartconfig.json',
+                    line: 1,
+                    column: 1,
+                    message: `the ${ruleId} allowlist entry '${key}' matches no finding; remove it`,
+                    fixable: false,
+                });
+            }
+        }
+    }
+    // Baselines: per rule and file, a count at or below the baseline is covered; above it nothing is.
+    const baselineSlack = [];
+    for (const [ruleId, counts] of Object.entries(config.baselines ?? {})) {
+        for (const [file, baseline] of Object.entries(counts)) {
+            const inFile = findings.filter((findingArg) => findingArg.ruleId === ruleId && findingArg.file === file && !findingArg.covered);
+            if (inFile.length <= baseline) {
+                inFile.forEach((findingArg) => {
+                    findingArg.covered = 'baseline';
+                });
+            }
+            if (inFile.length < baseline) {
+                baselineSlack.push({ ruleId, file, baseline, current: inFile.length });
+            }
+        }
+    }
+    findings.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line || a.column - b.column || a.ruleId.localeCompare(b.ruleId));
+    return {
+        profile,
+        findings,
+        baselineSlack,
+        ok: !findings.some((findingArg) => findingArg.severity === 'error' && !findingArg.covered),
+    };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/standards/classes.gitrepo.d.ts

@@ -0,0 +1,13 @@
+/** The git operations `wcctools fix` needs, run with an argument vector and no shell. */
+export declare class GitRepo {
+    readonly rootDir: string;
+    constructor(rootDirArg: string);
+    run(argsArg: string[]): Promise<string>;
+    /** The repository's top-level directory, or null when the directory is not inside a git work tree. */
+    topLevel(): Promise<string | null>;
+    /** `git status --porcelain` lines; empty for a clean tree (untracked files count as changes). */
+    statusLines(): Promise<string[]>;
+    /** Tracked files, relative to the repository root. */
+    trackedFiles(): Promise<string[]>;
+    move(fromArg: string, toArg: string): Promise<void>;
+}

package/dist_ts/standards/classes.gitrepo.js

@@ -0,0 +1,43 @@
+import * as plugins from '../plugins.js';
+/** The git operations `wcctools fix` needs, run with an argument vector and no shell. */
+export class GitRepo {
+    rootDir;
+    constructor(rootDirArg) {
+        this.rootDir = rootDirArg;
+    }
+    run(argsArg) {
+        return new Promise((resolve, reject) => {
+            plugins.childProcess.execFile('git', argsArg, { cwd: this.rootDir, maxBuffer: 64 * 1024 * 1024, encoding: 'utf8' }, (error, stdout, stderr) => {
+                if (error) {
+                    reject(new Error(`git ${argsArg.join(' ')} failed: ${stderr.trim() || error.message}`));
+                    return;
+                }
+                resolve(stdout);
+            });
+        });
+    }
+    /** The repository's top-level directory, or null when the directory is not inside a git work tree. */
+    async topLevel() {
+        try {
+            return (await this.run(['rev-parse', '--show-toplevel'])).trim();
+        }
+        catch (error) {
+            if (error instanceof Error && /not a git repository/i.test(error.message)) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    /** `git status --porcelain` lines; empty for a clean tree (untracked files count as changes). */
+    async statusLines() {
+        return (await this.run(['status', '--porcelain'])).split('\n').filter((lineArg) => lineArg.length > 0);
+    }
+    /** Tracked files, relative to the repository root. */
+    async trackedFiles() {
+        return (await this.run(['ls-files', '-z'])).split('\0').filter((fileArg) => fileArg.length > 0);
+    }
+    async move(fromArg, toArg) {
+        await this.run(['mv', '--', fromArg, toArg]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/standards/classes.sourceedits.d.ts

@@ -0,0 +1,15 @@
+import type { ITextEdit } from './helpers.ast.js';
+/**
+ * Span edits of one file's text. Edits never re-print the file: each replaces [start, end) of the
+ * original text. Identical edits count once; an edit overlapping an earlier accepted one is
+ * dropped (the fixer retries it on the edited text). Insertions at the same offset keep the order
+ * they were added in.
+ */
+export declare class SourceEdits {
+    private readonly accepted;
+    dropped: number;
+    add(editArg: ITextEdit): boolean;
+    get size(): number;
+    /** Applies the accepted edits from the end of the text backwards. */
+    apply(textArg: string): string;
+}

package/dist_ts/standards/classes.sourceedits.js

@@ -0,0 +1,54 @@
+/**
+ * Span edits of one file's text. Edits never re-print the file: each replaces [start, end) of the
+ * original text. Identical edits count once; an edit overlapping an earlier accepted one is
+ * dropped (the fixer retries it on the edited text). Insertions at the same offset keep the order
+ * they were added in.
+ */
+export class SourceEdits {
+    accepted = [];
+    dropped = 0;
+    add(editArg) {
+        if (editArg.start > editArg.end) {
+            throw new Error(`Invalid edit span ${editArg.start}-${editArg.end}`);
+        }
+        if (this.accepted.some((otherArg) => otherArg.start === editArg.start && otherArg.end === editArg.end && otherArg.text === editArg.text)) {
+            return true;
+        }
+        const overlaps = this.accepted.some((otherArg) => {
+            const otherIsInsert = otherArg.start === otherArg.end;
+            const isInsert = editArg.start === editArg.end;
+            if (otherIsInsert && isInsert) {
+                return false;
+            }
+            if (isInsert) {
+                return editArg.start > otherArg.start && editArg.start < otherArg.end;
+            }
+            if (otherIsInsert) {
+                return otherArg.start > editArg.start && otherArg.start < editArg.end;
+            }
+            return editArg.start < otherArg.end && otherArg.start < editArg.end;
+        });
+        if (overlaps) {
+            this.dropped++;
+            return false;
+        }
+        this.accepted.push({ ...editArg, order: this.accepted.length });
+        return true;
+    }
+    get size() {
+        return this.accepted.length;
+    }
+    /** Applies the accepted edits from the end of the text backwards. */
+    apply(textArg) {
+        const ordered = [...this.accepted].sort((a, b) => b.start - a.start || b.end - a.end || b.order - a.order);
+        let text = textArg;
+        for (const edit of ordered) {
+            if (edit.end > text.length) {
+                throw new Error(`Edit span ${edit.start}-${edit.end} exceeds the text length ${text.length}`);
+            }
+            text = text.slice(0, edit.start) + edit.text + text.slice(edit.end);
+        }
+        return text;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/standards/classes.standardfixer.d.ts

@@ -0,0 +1,40 @@
+import * as plugins from '../plugins.js';
+import type { ILoadedStandardConfig, IStandardConfigWriter } from './config.js';
+export interface IStandardFixOptions {
+    rootDir: string;
+    loaded: ILoadedStandardConfig;
+    /** Rules to fix; opt-in rules run only when named here. Default: every `auto` rule of the profile. */
+    rules?: readonly string[];
+    dryRun?: boolean;
+    /** Persists the configuration when moves rename files the allowlist or baselines name; without it such moves are refused. */
+    configWriter?: IStandardConfigWriter;
+}
+/**
+ * `wcctools fix`: applies the fixes of the selected rules to an in-memory copy of the repository,
+ * one rule after another on the re-parsed result, validates that every path of the resulting plan
+ * stays inside the repository root, then writes the configuration, moves files with `git mv`, writes
+ * the edited files and checks again. Refuses to run on a dirty work tree and never commits, so a
+ * failure part-way through the writes is undone with `git reset --hard` and `git clean -fd`.
+ */
+export declare class StandardFixer {
+    private readonly options;
+    constructor(optionsArg: IStandardFixOptions);
+    private selectRules;
+    run(): Promise<plugins.interfaces.IStandardFixResult>;
+    /**
+     * Refuses a plan with a path that leaves the repository root, lexically (an absolute path or a `..`
+     * segment) or physically (through a symbolic link that resolves outside the root or dangles).
+     * Runs before anything is written, so a refused plan leaves the repository and its surroundings as
+     * they were.
+     */
+    private assertInsideRoot;
+    /** True when the file, or its nearest existing ancestor, resolves to a path inside the real root. */
+    private resolvesInside;
+    private isSymbolicLink;
+    /** `git mv` in an order where no move overwrites a file that has not moved away yet. */
+    private commitMoves;
+    /** Creates a directory one path component at a time. */
+    private ensureDir;
+    /** Removes directories that moves left empty, walking up towards the repository root. */
+    private removeEmptyDirs;
+}

package/dist_ts/standards/classes.standardfixer.js

@@ -0,0 +1,210 @@
+import * as plugins from '../plugins.js';
+import { rekeyStandardConfig } from './baselines.js';
+import { checkStandard, detectFindings, rulesOfProfile } from './checker.js';
+import { GitRepo } from './classes.gitrepo.js';
+import { loadStandardProject, standardSideFiles } from './classes.standardproject.js';
+import { FixBatch, StandardTree } from './classes.standardtree.js';
+import { StandardUsageError } from './errors.js';
+import { dirOf, isRepoPath, isTypeScriptSource } from './helpers.paths.js';
+import { fixOrder, standardRules } from './rules/index.js';
+/** How often one rule is re-run on the edited tree to apply edits that overlapped in an earlier run. */
+const maxRunsPerRule = 5;
+/**
+ * `wcctools fix`: applies the fixes of the selected rules to an in-memory copy of the repository,
+ * one rule after another on the re-parsed result, validates that every path of the resulting plan
+ * stays inside the repository root, then writes the configuration, moves files with `git mv`, writes
+ * the edited files and checks again. Refuses to run on a dirty work tree and never commits, so a
+ * failure part-way through the writes is undone with `git reset --hard` and `git clean -fd`.
+ */
+export class StandardFixer {
+    options;
+    constructor(optionsArg) {
+        this.options = optionsArg;
+    }
+    selectRules() {
+        const { profile } = this.options.loaded;
+        const inProfile = new Set(rulesOfProfile(profile).map((ruleArg) => ruleArg.id));
+        if (!this.options.rules || this.options.rules.length === 0) {
+            return fixOrder.filter((idArg) => inProfile.has(idArg) && standardRules.find((ruleArg) => ruleArg.id === idArg).fixMode === 'auto');
+        }
+        for (const id of this.options.rules) {
+            const rule = standardRules.find((ruleArg) => ruleArg.id === id);
+            if (!rule) {
+                throw new StandardUsageError(`Unknown rule '${id}'`);
+            }
+            if (!inProfile.has(id)) {
+                throw new StandardUsageError(`Rule '${id}' is not part of the '${profile}' profile`);
+            }
+            if (rule.fixMode === 'none') {
+                throw new StandardUsageError(`Rule '${id}' has no fix`);
+            }
+        }
+        return fixOrder.filter((idArg) => this.options.rules.includes(idArg));
+    }
+    async run() {
+        const { rootDir, loaded } = this.options;
+        const selected = this.selectRules();
+        const git = new GitRepo(rootDir);
+        const topLevel = await git.topLevel();
+        if (!topLevel || plugins.fsSync.realpathSync(topLevel) !== plugins.fsSync.realpathSync(rootDir)) {
+            throw new StandardUsageError(`wcctools fix runs at the root of a git repository; ${rootDir} is not one`);
+        }
+        const status = await git.statusLines();
+        if (status.length > 0) {
+            throw new StandardUsageError(`wcctools fix needs a clean work tree; git status reports ${status.length} change(s). Commit or stash them first.`);
+        }
+        const trackedFiles = await git.trackedFiles();
+        const files = new Map();
+        for (const file of trackedFiles) {
+            if (isTypeScriptSource(file) || standardSideFiles.includes(file)) {
+                files.set(file, await plugins.fs.readFile(plugins.path.join(rootDir, file), 'utf8'));
+            }
+        }
+        const tree = new StandardTree(files, trackedFiles, (fileArg) => plugins.fsSync.existsSync(plugins.path.join(rootDir, fileArg)));
+        for (const ruleId of selected) {
+            const rule = standardRules.find((ruleArg) => ruleArg.id === ruleId);
+            for (let run = 0; run < maxRunsPerRule; run++) {
+                const fixable = detectFindings(tree.project(), loaded, [rule]).filter((detectedArg) => !detectedArg.allowlisted && detectedArg.finding.fix);
+                if (fixable.length === 0) {
+                    break;
+                }
+                const batch = new FixBatch();
+                fixable.forEach((detectedArg) => detectedArg.finding.fix(batch));
+                if (tree.apply(rule.id, batch) === 0) {
+                    break;
+                }
+            }
+        }
+        const plan = tree.plan();
+        await this.assertInsideRoot(plan);
+        const rekeyed = rekeyStandardConfig(loaded.config, plan.moves);
+        if (rekeyed.changed.length > 0 && !this.options.configWriter) {
+            throw new StandardUsageError(`wcctools fix would move files that the standard configuration names (${rekeyed.changed.join(', ')}) but has no configuration writer`);
+        }
+        const loadedAfter = { ...loaded, config: rekeyed.config };
+        if (this.options.dryRun) {
+            return { dryRun: true, plan, remaining: checkStandard(tree.project(), loadedAfter) };
+        }
+        // Every path is validated above. The configuration goes first: a refused write (the file changed
+        // since it was read) leaves the tree untouched. A failure after it leaves a partial result that the
+        // clean work tree fix started from restores (`git reset --hard`, `git clean -fd`).
+        if (rekeyed.changed.length > 0) {
+            await this.options.configWriter.writeStandardConfig(rekeyed.config);
+        }
+        await this.commitMoves(git, plan.moves);
+        for (const file of [...plan.created, ...plan.edited.map((editedArg) => editedArg.file)]) {
+            await this.ensureDir(dirOf(file));
+            await plugins.fs.writeFile(plugins.path.join(rootDir, file), tree.files.get(file), 'utf8');
+        }
+        await this.removeEmptyDirs(plan.moves.map((moveArg) => dirOf(moveArg.from)));
+        return { dryRun: false, plan, remaining: checkStandard(await loadStandardProject(rootDir), loadedAfter) };
+    }
+    /**
+     * Refuses a plan with a path that leaves the repository root, lexically (an absolute path or a `..`
+     * segment) or physically (through a symbolic link that resolves outside the root or dangles).
+     * Runs before anything is written, so a refused plan leaves the repository and its surroundings as
+     * they were.
+     */
+    async assertInsideRoot(planArg) {
+        const realRoot = await plugins.fs.realpath(this.options.rootDir);
+        const paths = [
+            ...planArg.moves.flatMap((moveArg) => [moveArg.from, moveArg.to]),
+            ...planArg.created,
+            ...planArg.edited.map((editedArg) => editedArg.file),
+        ];
+        const outside = [];
+        for (const file of new Set(paths)) {
+            if (!isRepoPath(file) || !(await this.resolvesInside(realRoot, file))) {
+                outside.push(file);
+            }
+        }
+        if (outside.length > 0) {
+            throw new StandardUsageError(`wcctools fix refuses to write outside the repository root: ${outside.join(', ')}`);
+        }
+    }
+    /** True when the file, or its nearest existing ancestor, resolves to a path inside the real root. */
+    async resolvesInside(realRootArg, fileArg) {
+        let current = plugins.path.join(realRootArg, fileArg);
+        while (true) {
+            try {
+                const real = await plugins.fs.realpath(current);
+                return real === realRootArg || real.startsWith(`${realRootArg}${plugins.path.sep}`);
+            }
+            catch (error) {
+                const code = error.code;
+                if (code !== 'ENOENT' && code !== 'ENOTDIR') {
+                    throw error;
+                }
+            }
+            if (await this.isSymbolicLink(current)) {
+                // A dangling link: writing through it would create its target, wherever that is.
+                return false;
+            }
+            const parent = plugins.path.dirname(current);
+            if (parent === current) {
+                return false;
+            }
+            current = parent;
+        }
+    }
+    async isSymbolicLink(pathArg) {
+        try {
+            return (await plugins.fs.lstat(pathArg)).isSymbolicLink();
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === 'ENOENT' || code === 'ENOTDIR') {
+                return false;
+            }
+            throw error;
+        }
+    }
+    /** `git mv` in an order where no move overwrites a file that has not moved away yet. */
+    async commitMoves(gitArg, movesArg) {
+        const pending = [...movesArg];
+        while (pending.length > 0) {
+            const index = pending.findIndex((moveArg) => !plugins.fsSync.existsSync(plugins.path.join(this.options.rootDir, moveArg.to)));
+            if (index === -1) {
+                throw new Error(`Cannot order the moves ${pending.map((moveArg) => `${moveArg.from} → ${moveArg.to}`).join(', ')}`);
+            }
+            const [move] = pending.splice(index, 1);
+            await this.ensureDir(dirOf(move.to));
+            await gitArg.move(move.from, move.to);
+        }
+    }
+    /** Creates a directory one path component at a time. */
+    async ensureDir(dirArg) {
+        let current = this.options.rootDir;
+        for (const segment of dirArg.split('/').filter((segmentArg) => segmentArg && segmentArg !== '.')) {
+            current = plugins.path.join(current, segment);
+            try {
+                await plugins.fs.mkdir(current);
+            }
+            catch (error) {
+                if (error.code !== 'EEXIST') {
+                    throw error;
+                }
+            }
+        }
+    }
+    /** Removes directories that moves left empty, walking up towards the repository root. */
+    async removeEmptyDirs(dirsArg) {
+        for (const start of [...new Set(dirsArg)].sort((a, b) => b.length - a.length)) {
+            let dir = start;
+            while (dir && dir !== '.') {
+                try {
+                    await plugins.fs.rmdir(plugins.path.join(this.options.rootDir, dir));
+                }
+                catch (error) {
+                    const code = error.code;
+                    if (code === 'ENOTEMPTY' || code === 'EEXIST' || code === 'ENOENT') {
+                        break;
+                    }
+                    throw error;
+                }
+                dir = dirOf(dir);
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.standardfixer.js","sourceRoot":"","sources":["../../../ts/standards/classes.standardfixer.ts"],"names":[],"mappings":"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"}

package/dist_ts/standards/classes.standardproject.d.ts

@@ -0,0 +1,80 @@
+import * as plugins from '../plugins.js';
+import * as ast from './helpers.ast.js';
+/** A class decorated with `@customElement(…)`. */
+export interface IStandardElement {
+    file: string;
+    sourceFile: ast.TSourceFile;
+    classNode: ast.TClassDeclaration;
+    className: string | null;
+    decoratorCall: ast.TCallExpression;
+    /** The literal tag, or null when the decorator argument is not a string literal. */
+    tag: string | null;
+    exported: boolean;
+    inDemoFile: boolean;
+}
+/** A class member decorated with `@property(…)` or `@state(…)`. */
+export interface IStandardProperty {
+    file: string;
+    sourceFile: ast.TSourceFile;
+    classNode: ast.TClassDeclaration;
+    member: ast.TClassElement;
+    name: string;
+    decorator: 'property' | 'state';
+    call: ast.TCallExpression;
+    /** The options object literal; null when the decorator has no argument or a non-literal one. */
+    options: ast.TObjectLiteralExpression | null;
+    /** True when the decorator has an argument that is not an object literal. */
+    dynamicOptions: boolean;
+    isPublic: boolean;
+    inDemoFile: boolean;
+}
+/** An `export … from '<relative>'` declaration. */
+export interface IStandardReexport {
+    file: string;
+    statement: plugins.typescript.ExportDeclaration;
+    specifier: string;
+    /** The resolved repository path, or null when it does not resolve to a known file. */
+    target: string | null;
+}
+export type TParseCache = Map<string, {
+    text: string;
+    sourceFile: ast.TSourceFile;
+}>;
+/** The root barrel every reachability check starts from. */
+export declare const rootBarrel = "ts_web/index.ts";
+export declare const elementsBarrel = "ts_web/elements/index.ts";
+/**
+ * The syntax-only model of a catalog the rules read: its files, elements, reactive properties and
+ * barrel graph. Built from a map of repository paths to file texts, so the same model serves a
+ * repository on disk and the fixer's in-memory tree.
+ */
+export declare class StandardProject {
+    readonly files: ReadonlyMap<string, string>;
+    private readonly existsOnDisk;
+    private readonly parseCache;
+    private elementsCache;
+    private propertiesCache;
+    private reexportsCache;
+    constructor(filesArg: ReadonlyMap<string, string>, existsOnDiskArg: (fileArg: string) => boolean, parseCacheArg?: TParseCache);
+    /** True when the file is part of the model or exists in the repository. */
+    exists(fileArg: string): boolean;
+    /** The `ts_web/**\/*.ts` sources, sorted. */
+    get webFiles(): string[];
+    sourceFile(fileArg: string): ast.TSourceFile;
+    /** `compilerOptions.experimentalDecorators` of tsconfig.json (its `extends` chain is not followed). */
+    get experimentalDecorators(): boolean;
+    get elements(): IStandardElement[];
+    get properties(): IStandardProperty[];
+    /** The `export … from` declarations of a file with relative specifiers. */
+    reexports(fileArg: string): IStandardReexport[];
+    /** Every file reached from a barrel by following `export … from` declarations. */
+    reachableFrom(fileArg: string): Set<string>;
+    lineAndColumn(fileArg: string, positionArg: number): {
+        line: number;
+        column: number;
+    };
+}
+/** The files besides `ts_web/**` a check reads. */
+export declare const standardSideFiles: string[];
+/** Reads the files the standard covers from a repository on disk. */
+export declare const loadStandardProject: (rootDirArg: string) => Promise<StandardProject>;