@aoelite/refpact-ts 0.0.0-stage → 0.1.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AoElite
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,39 @@
-# Temporary Holding Version
+# refpact
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Architecture tests for TypeScript 6 and 7: rules about what files may import, checked as
+ordinary tests under Vitest or `node --test`. The compiler of your project resolves each
+import.
+
+```sh
+pnpm add --save-dev @aoelite/refpact-ts
+```
+
+```ts
+import { test } from "vitest";
+import { anyOf, loadProject, pkg, rule } from "@aoelite/refpact-ts";
+
+const app = loadProject("tsconfig.json");
+
+test("the user interface does not import the database", () => {
+  rule("the user interface does not import the database")
+    .files(anyOf("src/ui/**"))
+    .mustNotImport(anyOf("src/db/**", pkg("pg")))
+    .check(app);
+});
+```
+
+`check` throws an error, and the message of the error is the report:
+
+```text
+rule `the user interface does not import the database` is violated in 1 place(s):
+  src/ui/view.ts:3:10: [the user interface does not import the database] src/ui/view.ts uses src/db/client.ts#query (import, written as src/db/index.ts#query)
+```
+
+- [The TypeScript guide](https://github.com/AoElite/RefPact/blob/main/docs/typescript.md):
+  how to install the package, every rule, and the limits of the analysis.
+- [All that you can check](https://github.com/AoElite/RefPact#what-you-can-check), also in
+  Rust.
+
+## License
+
+MIT

package/dist/baseline.d.ts

@@ -0,0 +1,26 @@
+import type { BaselineEntry, PathFormat, Violation } from "./core/index.ts";
+import type { Failure } from "./rules.ts";
+/**
+ * A file of violations that the project accepts for now.
+ *
+ * A rule uses a baseline only when it is checked with `checkWithBaseline`. Plain `check`
+ * never reads one.
+ *
+ * The file is text, one accepted violation per line, without line numbers of the source.
+ * Commit it. To write it, run the tests once with `REFPACT_BASELINE=update`.
+ */
+export declare class Baseline {
+    /** The absolute path of the file. */
+    readonly file: string;
+    /** @internal */
+    constructor(file: string);
+    /** @internal The entries, or the reason why the file cannot be read. A file that is not there is empty. */
+    read(): readonly BaselineEntry[] | Failure;
+    /** @internal Replaces the entries of one rule with its current violations. */
+    write(rule: string, violations: readonly Violation[], format: PathFormat): Failure | undefined;
+}
+/**
+ * The baseline in the file at `file`. A relative path is relative to the working directory;
+ * in a test, give a path from `import.meta.dirname`.
+ */
+export declare function baseline(file: string): Baseline;

package/dist/baseline.js

@@ -0,0 +1,65 @@
+/** The baseline file. */
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { baselineEntries, formatBaseline, parseBaseline } from "./core/index.js";
+/**
+ * A file of violations that the project accepts for now.
+ *
+ * A rule uses a baseline only when it is checked with `checkWithBaseline`. Plain `check`
+ * never reads one.
+ *
+ * The file is text, one accepted violation per line, without line numbers of the source.
+ * Commit it. To write it, run the tests once with `REFPACT_BASELINE=update`.
+ */
+export class Baseline {
+    /** The absolute path of the file. */
+    file;
+    /** @internal */
+    constructor(file) {
+        this.file = path.resolve(file);
+    }
+    /** @internal The entries, or the reason why the file cannot be read. A file that is not there is empty. */
+    read() {
+        if (!existsSync(this.file)) {
+            return [];
+        }
+        let text;
+        try {
+            text = readFileSync(this.file, "utf8");
+        }
+        catch (error) {
+            return { type: "baseline", message: `refpact: cannot read ${this.file}: ${error.message}` };
+        }
+        const parsed = parseBaseline(text);
+        if (!parsed.ok) {
+            return { type: "baseline", message: `${this.file}:${parsed.line}: this line of the baseline is not valid` };
+        }
+        return parsed.entries;
+    }
+    /** @internal Replaces the entries of one rule with its current violations. */
+    write(rule, violations, format) {
+        const entries = this.read();
+        if (!Array.isArray(entries)) {
+            return entries;
+        }
+        const kept = entries.filter((entry) => entry.rule !== rule);
+        try {
+            mkdirSync(path.dirname(this.file), { recursive: true });
+            // Written beside the file and moved, so that a reader never sees half a file.
+            const partial = `${this.file}.partial`;
+            writeFileSync(partial, formatBaseline([...kept, ...baselineEntries(violations, format)]));
+            renameSync(partial, this.file);
+        }
+        catch (error) {
+            return { type: "baseline", message: `refpact: cannot write ${this.file}: ${error.message}` };
+        }
+        return undefined;
+    }
+}
+/**
+ * The baseline in the file at `file`. A relative path is relative to the working directory;
+ * in a test, give a path from `import.meta.dirname`.
+ */
+export function baseline(file) {
+    return new Baseline(file);
+}

package/dist/core/index.d.ts

@@ -0,0 +1,79 @@
+/**
+ * The language-neutral core: rules evaluated over facts, reports and baselines.
+ *
+ * The core is the Rust crate `refpact-core`, run as WebAssembly. This module turns its JSON
+ * requests (SPEC section 8) into functions. A fact set crosses into the core once, on its
+ * first evaluation, and stays there while the object lives, so each further rule sends only
+ * the rule.
+ */
+import type { FactSet, Path, RawPattern, Rule, Severity } from "./model.ts";
+import type { Applied, BaselineEntry, BaselineKey, EvaluateResult, ParsedBaseline, PathFormat, RuleError, SelectResult, Violation } from "./results.ts";
+export type * from "./model.ts";
+export type * from "./results.ts";
+/** Evaluates one rule against one fact set (SPEC section 4). */
+export declare function evaluate(rule: Rule, facts: FactSet): EvaluateResult;
+/**
+ * Applies the subjects, the filters and the exemptions of a rule with a custom check, and
+ * answers what the rule sees (SPEC section 8), so that the caller finds the violations. The
+ * check is the constraint of the rule, or the demand of a rule about items.
+ */
+export declare function select(rule: Rule, facts: FactSet): SelectResult;
+/** The text form of a diagram: a Mermaid flowchart, or a Graphviz graph in DOT. */
+export type DiagramFormat = "mermaid" | "dot";
+/** The diagram of a rule, or the reasons why the rule cannot be evaluated. */
+export type DiagramResult = {
+    /** The rule can be evaluated. */
+    readonly ok: true;
+    /** The diagram. */
+    readonly text: string;
+} | {
+    /** The rule cannot be evaluated. */
+    readonly ok: false;
+    /** The reasons, in the order of the specification. */
+    readonly errors: readonly RuleError[];
+};
+/** A layer of a diagram of layers (SPEC 4.17). */
+export interface DiagramLayer {
+    /** The name of the layer, which is the label of its node. */
+    readonly name: string;
+    /** The units of the layer: unit patterns, which match units exactly. */
+    readonly units: readonly RawPattern[];
+    /** The layers that the layer must not use, by their position in the list of layers. */
+    readonly mustNotUse: readonly number[];
+}
+/**
+ * The nodes of a diagram: the subjects of the rule when this is `undefined`, the slices of
+ * the subjects, or the layers from the top to the bottom.
+ */
+export type DiagramNodes = {
+    /** The slice patterns, as for `must-be-acyclic` with slices. */
+    readonly slices: readonly RawPattern[];
+} | {
+    /** The layers, from the top to the bottom. */
+    readonly layers: readonly DiagramLayer[];
+} | undefined;
+/**
+ * The diagram of what a rule sees (SPEC 4.17): its subjects, the slices or the layers, and the
+ * references between them. The constraint of the rule is not evaluated.
+ */
+export declare function diagram(rule: Rule, facts: FactSet, nodes: DiagramNodes, format?: DiagramFormat): DiagramResult;
+/** Prints a path as reports print it. */
+export declare function printPath(path: Path, format: PathFormat): string;
+/** One line for one violation: file, line, column, rule name, unit and offending path. */
+export declare function renderViolation(violation: Violation, format: PathFormat): string;
+/** All violations of one rule, one per line, with a heading, and the reason of the rule when it has one. */
+export declare function renderViolations(rule: string, violations: readonly Violation[], format: PathFormat, reason?: string, severity?: Severity): string;
+/** One sentence for one error. */
+export declare function renderError(error: RuleError): string;
+/** All errors of one rule, one per line, with a heading. */
+export declare function renderErrors(rule: string, errors: readonly RuleError[]): string;
+/** The `unit` and `what` of the key of a violation (SPEC 7.1). */
+export declare function baselineKey(violation: Violation, format: PathFormat): BaselineKey;
+/** One entry for each key of the violations, with the number of violations that have it. */
+export declare function baselineEntries(violations: readonly Violation[], format: PathFormat): BaselineEntry[];
+/** Removes the violations of one rule that the baseline accepts (SPEC 7.3). */
+export declare function applyBaseline(rule: string, violations: readonly Violation[], baseline: readonly BaselineEntry[], format: PathFormat): Applied;
+/** Writes the text form of a baseline, sorted, so that a change shows as a small difference. */
+export declare function formatBaseline(entries: readonly BaselineEntry[]): string;
+/** Reads the text form of a baseline (SPEC 7.2). */
+export declare function parseBaseline(text: string): ParsedBaseline;

package/dist/core/index.js

@@ -0,0 +1,90 @@
+import { call, currentGeneration } from "./wasm.js";
+const loaded = new WeakMap();
+const unload = new FinalizationRegistry(({ handle, generation }) => {
+    if (generation === currentGeneration()) {
+        call(JSON.stringify({ op: "drop-facts", handle }));
+    }
+});
+/** The handle of a fact set in the core, after loading it when it is not loaded. */
+function handleOf(facts) {
+    const generation = currentGeneration();
+    const known = loaded.get(facts);
+    if (known !== undefined && known.generation === generation) {
+        return known.handle;
+    }
+    const { handle } = JSON.parse(call(`{"op":"load-facts","facts":${JSON.stringify(facts)}}`));
+    const entry = { handle, generation };
+    loaded.set(facts, entry);
+    unload.register(facts, entry);
+    return handle;
+}
+/** Only the fields of a path format, so that a fact set given as the format does not cross whole. */
+function formatOf(format) {
+    return {
+        separator: format.separator,
+        ...(format.attachedPrefixes !== undefined && { attachedPrefixes: format.attachedPrefixes }),
+        ...(format.hiddenPrefixes !== undefined && { hiddenPrefixes: format.hiddenPrefixes }),
+    };
+}
+function request(op, body) {
+    return JSON.parse(call(JSON.stringify({ op, ...body })));
+}
+/** Evaluates one rule against one fact set (SPEC section 4). */
+export function evaluate(rule, facts) {
+    return request("evaluate", { handle: handleOf(facts), rule });
+}
+/**
+ * Applies the subjects, the filters and the exemptions of a rule with a custom check, and
+ * answers what the rule sees (SPEC section 8), so that the caller finds the violations. The
+ * check is the constraint of the rule, or the demand of a rule about items.
+ */
+export function select(rule, facts) {
+    return request("select", { handle: handleOf(facts), rule });
+}
+/**
+ * The diagram of what a rule sees (SPEC 4.17): its subjects, the slices or the layers, and the
+ * references between them. The constraint of the rule is not evaluated.
+ */
+export function diagram(rule, facts, nodes, format = "mermaid") {
+    return request("diagram", { handle: handleOf(facts), rule, ...nodes, format });
+}
+/** Prints a path as reports print it. */
+export function printPath(path, format) {
+    return request("print-path", { path, format: formatOf(format) }).text;
+}
+/** One line for one violation: file, line, column, rule name, unit and offending path. */
+export function renderViolation(violation, format) {
+    return request("render-violation", { violation, format: formatOf(format) }).text;
+}
+/** All violations of one rule, one per line, with a heading, and the reason of the rule when it has one. */
+export function renderViolations(rule, violations, format, reason, severity = "error") {
+    return request("render-violations", { rule, reason, severity, violations, format: formatOf(format) }).text;
+}
+/** One sentence for one error. */
+export function renderError(error) {
+    return request("render-error", { error }).text;
+}
+/** All errors of one rule, one per line, with a heading. */
+export function renderErrors(rule, errors) {
+    return request("render-errors", { rule, errors }).text;
+}
+/** The `unit` and `what` of the key of a violation (SPEC 7.1). */
+export function baselineKey(violation, format) {
+    return request("baseline-key", { violation, format: formatOf(format) });
+}
+/** One entry for each key of the violations, with the number of violations that have it. */
+export function baselineEntries(violations, format) {
+    return request("baseline-entries", { violations, format: formatOf(format) }).entries;
+}
+/** Removes the violations of one rule that the baseline accepts (SPEC 7.3). */
+export function applyBaseline(rule, violations, baseline, format) {
+    return request("apply-baseline", { rule, violations, entries: baseline, format: formatOf(format) });
+}
+/** Writes the text form of a baseline, sorted, so that a change shows as a small difference. */
+export function formatBaseline(entries) {
+    return request("format-baseline", { entries }).text;
+}
+/** Reads the text form of a baseline (SPEC 7.2). */
+export function parseBaseline(text) {
+    return request("parse-baseline", { text });
+}

package/dist/core/model.d.ts

@@ -0,0 +1,340 @@
+/** A path: a non-empty list of non-empty segments (SPEC section 1). */
+export type Path = readonly string[];
+/** A raw pattern: segments that the core validates (SPEC section 2). */
+export type RawPattern = readonly string[];
+/** What a front end found in one project (SPEC section 3). */
+export interface FactSet {
+    /** Text that separates segments when a path is printed. */
+    readonly separator: string;
+    /** Paths of all units. Rust: modules. TypeScript: files. */
+    readonly units: readonly Path[];
+    /** Paths of all known named things inside units. */
+    readonly items: readonly Path[];
+    /** The number of lines of each unit, in the order of `units`. Absent or empty for front ends that do not count them. */
+    readonly unitLines?: readonly number[];
+    /** All reference kinds the front end can produce. */
+    readonly kinds: readonly string[];
+    /** All markers the front end can produce. */
+    readonly markers: readonly string[];
+    /** All tags the front end can produce. */
+    readonly tags: readonly string[];
+    /** The facts, in a stable order. */
+    readonly facts: readonly Fact[];
+    /** The named items that the units declare, in a stable order. Default: none. */
+    readonly declarations?: readonly Declaration[];
+    /** All item kinds the front end can produce. Default: none. */
+    readonly itemKinds?: readonly string[];
+    /** All visibilities the front end can produce. Default: none. */
+    readonly visibilities?: readonly string[];
+    /** All relations the front end can produce. Default: none. */
+    readonly relations?: readonly string[];
+    /** All modifiers of declarations the front end can produce. Default: none. */
+    readonly modifiers?: readonly string[];
+    /** The names of all properties of references the front end can produce. Default: none. */
+    readonly properties?: readonly string[];
+    /** Segments that reports print without a separator before them, by prefix. Default: none. */
+    readonly attachedPrefixes?: readonly string[];
+    /** Prefixes that reports leave out of the first segment of a path. Default: none. */
+    readonly hiddenPrefixes?: readonly string[];
+}
+/** One observation at one place in the source. */
+export interface Fact {
+    /** The unit that contains the fact. */
+    readonly unit: Path;
+    /** The file, as the front end names it. */
+    readonly file: string;
+    /** The line in the file. */
+    readonly line: number;
+    /** The column in the line. */
+    readonly column: number;
+    /** The tags of the fact. */
+    readonly tags: readonly string[];
+    /** Text that is copied to the violation. */
+    readonly note?: string;
+    /**
+     * The path of the innermost declaration that contains the fact. Absent outside every
+     * declaration, and for front ends that do not record it.
+     */
+    readonly item?: Path;
+    /** What was observed. */
+    readonly what: Reference | Marker;
+}
+/** A named item that a unit declares, such as a type or a function (SPEC section 3). */
+export interface Declaration {
+    /** The path of the item. */
+    readonly path: Path;
+    /** The name of the item as the code writes it. */
+    readonly name: string;
+    /** The unit that declares the item. */
+    readonly unit: Path;
+    /** The file, as the front end names it. */
+    readonly file: string;
+    /** The line of the name. */
+    readonly line: number;
+    /** The column of the name. */
+    readonly column: number;
+    /** The line on which the item ends. Absent for front ends that do not record it. */
+    readonly endLine?: number;
+    /** The tags of the declaration. */
+    readonly tags: readonly string[];
+    /** The kind of item, one of the item kinds of the fact set. */
+    readonly kind: string;
+    /** The visibility, one of the visibilities of the fact set. */
+    readonly visibility: string;
+    /** The paths that the item is tied to, such as the classes that it extends. */
+    readonly relations: readonly Relation[];
+    /**
+     * What the declaration says of the item besides its kind and its visibility, such as
+     * `async` or `documented`. Each is one of the modifiers of the fact set.
+     */
+    readonly modifiers: readonly string[];
+}
+/** A tie between a declared item and a path. */
+export interface Relation {
+    /** The kind of tie, one of the relations of the fact set. */
+    readonly relation: string;
+    /** The path. */
+    readonly target: Path;
+}
+/** The unit refers to a path. */
+export interface Reference {
+    /** Tells a reference from a marker. */
+    readonly type: "reference";
+    /** The path the code refers to, resolved as far as the front end can. */
+    readonly target: Path;
+    /** Further paths the same reference denotes, such as the definition behind a re-export. */
+    readonly aliases: readonly Path[];
+    /** The kind of the reference, one of the kinds of the fact set. */
+    readonly kind: string;
+    /** Whether the front end proved the path. */
+    readonly certainty: Certainty;
+    /**
+     * What the front end knows of the target besides its path, by name, such as the version
+     * of a package. No built-in rule reads them; a check of your own does.
+     */
+    readonly properties?: Readonly<Record<string, string>>;
+}
+/** The unit contains something that has a name but no path, such as an unsafe block. */
+export interface Marker {
+    /** Tells a marker from a reference. */
+    readonly type: "marker";
+    /** The marker, one of the markers of the fact set. */
+    readonly marker: string;
+}
+/** `candidate`: the front end could not prove this path, for example a name behind a glob import. */
+export type Certainty = "exact" | "candidate";
+/** One architecture rule (SPEC section 4). */
+export interface Rule {
+    /** The name, printed with every violation. An empty name is an error. */
+    readonly name: string;
+    /** Why the rule exists, printed with its violations. Default: no reason. */
+    readonly reason?: string;
+    /**
+     * `error`: a violation fails the check. `warning`: a violation is reported, and the check
+     * passes. It does not change the evaluation. Default: `error`.
+     */
+    readonly severity?: Severity;
+    /** The units the rule applies to. */
+    readonly subjects: Subjects;
+    /** What the units must do or must not do. */
+    readonly constraint: Constraint;
+    /** The reference kinds the rule looks at. Default: all kinds. */
+    readonly kinds?: KindFilter;
+    /** Facts with one of these tags are not checked. Default: none. */
+    readonly ignoreTags?: readonly string[];
+    /** Whether candidate references count. Default: `include`. */
+    readonly candidates?: Candidates;
+    /** References that the rule does not see. Default: none. */
+    readonly exemptions?: readonly Exemption[];
+    /**
+     * The names of the properties of references that the check of the rule reads. One that the
+     * front end does not produce is an error. Default: none.
+     */
+    readonly properties?: readonly string[];
+}
+/**
+ * References that a rule does not see (SPEC 4.13): those of the units that a `from` pattern
+ * matches exactly, with a path that a `to` pattern matches within.
+ */
+export interface Exemption {
+    /** The units. An empty list is an error. */
+    readonly from: readonly RawPattern[];
+    /** The paths. An empty list is an error. */
+    readonly to: readonly RawPattern[];
+}
+/** Which units a rule applies to. */
+export interface Subjects {
+    /** The units that are selected before the exceptions. */
+    readonly include: Include;
+    /** Absent: no exceptions. An empty list is an error. */
+    readonly except?: readonly RawPattern[];
+}
+/** The units a rule selects before its exceptions: all units, or those that a pattern matches exactly. */
+export type Include = {
+    readonly type: "all";
+} | {
+    readonly type: "any-of";
+    /** The patterns. An empty list is an error. */
+    readonly patterns: readonly RawPattern[];
+};
+/**
+ * What a rule demands of its subjects (SPEC section 4).
+ *
+ * - `must-not-use`: no reference may lead to one of the targets.
+ * - `must-only-use`: every reference must lead to one of the targets, or stay inside its own unit.
+ * - `must-not-contain`: the units must not contain one of the markers.
+ * - `must-be-acyclic`: the references between the units, or between the slices, must not form a cycle.
+ * - `must-be-independent`: no reference may lead from one slice to another slice.
+ * - `must-be-used`: each unit must be referred to from outside itself and the units below it.
+ * - `must-not-reach`: no chain of references may lead from the units to one of the targets.
+ * - `must-be-reachable-from`: a chain of references must lead from one of the roots to each unit.
+ * - `must-be-in`: each unit must be matched exactly by one of the places.
+ * - `must-only-be-used-by`: only the users, and the selected units, may refer to the selected units.
+ * - `items`: the declarations of the units that the filters select must meet a demand.
+ * - `custom`: a check of the binding, which finds the violations itself (SPEC 4.15). Only
+ *   `select` takes it.
+ */
+export type Constraint = {
+    readonly type: "must-not-use";
+    /** The paths that the units must not refer to. */
+    readonly targets: Targets;
+} | {
+    readonly type: "must-only-use";
+    /** The only paths that the units may refer to outside themselves. */
+    readonly targets: Targets;
+} | {
+    readonly type: "must-not-contain";
+    /** The markers. An empty list is an error. */
+    readonly markers: readonly string[];
+} | {
+    readonly type: "must-be-acyclic";
+    /** Without `slices`, each unit is a node. An empty list is an error. */
+    readonly slices?: readonly RawPattern[];
+} | {
+    readonly type: "must-be-independent";
+    /** The patterns of the slices. An empty list is an error. */
+    readonly slices: readonly RawPattern[];
+} | {
+    readonly type: "must-be-used";
+} | {
+    readonly type: "must-not-reach";
+    /** The paths that no chain from the units may end at. */
+    readonly targets: Targets;
+} | {
+    readonly type: "must-be-reachable-from";
+    /** The patterns of the root units. An empty list is an error. */
+    readonly roots: readonly RawPattern[];
+} | {
+    readonly type: "must-be-in";
+    /** The places, which match units exactly. An empty list is an error. */
+    readonly places: readonly RawPattern[];
+} | {
+    readonly type: "must-only-be-used-by";
+    /** The units that may refer to the selected units, which match units exactly. An empty list is an error. */
+    readonly users: readonly RawPattern[];
+} | {
+    /** Each unit must have at most a number of lines (SPEC 4.16). */
+    readonly type: "must-not-exceed-lines";
+    /** The number of lines that a unit may have. */
+    readonly lines: number;
+} | ({
+    readonly type: "items";
+} & Items) | CustomConstraint;
+/**
+ * A check of the binding (SPEC 4.15), as a constraint or as the demand of a rule about
+ * items. The core applies the rest of the rule, and `select` answers what the rule sees.
+ */
+export interface CustomConstraint {
+    /** Tells a custom check from the built-in ones. */
+    readonly type: "custom";
+    /** Lists of paths that the check looks for. For each list, `select` marks the first path of each reference that it matches. */
+    readonly targets?: readonly Targets[];
+    /** Lists of unit patterns. For each list, `select` answers the units that it matches exactly. */
+    readonly units?: readonly (readonly RawPattern[])[];
+}
+/** A rule about declarations (SPEC 4.12): filters, which all must hold, and a demand. */
+export interface Items {
+    /** Absent: any name. Otherwise a glob must match the name. An empty list is an error. */
+    readonly named?: readonly string[];
+    /** Absent: any kind. An empty list is an error. */
+    readonly kinds?: readonly string[];
+    /** Absent: any visibility. An empty list is an error. */
+    readonly visibilities?: readonly string[];
+    /** The relations that the item must have, each to one of its paths. Absent or empty: any. */
+    readonly related?: readonly Related[];
+    /** Absent: any modifiers. Otherwise the item must have one of these. An empty list is an error. */
+    readonly modifiers?: readonly string[];
+    /** What each selected declaration must meet. */
+    readonly must: Demand;
+}
+/** A relation to one of some paths. */
+export interface Related {
+    /** The kind of tie, such as `extends`. */
+    readonly relation: string;
+    /** The paths, which match the target within. An empty list is an error. */
+    readonly anyOf: readonly RawPattern[];
+}
+/**
+ * What each declaration of a rule about items must meet: not to exist, to reside in one of
+ * some units, to have a name that a glob matches, to have a relation or a modifier.
+ */
+export type Demand = {
+    /** No declaration may be selected. */
+    readonly type: "not-exist";
+} | {
+    /** The unit of the declaration must be one of the places. */
+    readonly type: "reside-in";
+    /** The places, which match units exactly. An empty list is an error. */
+    readonly places: readonly RawPattern[];
+} | {
+    /** A glob must match the name. */
+    readonly type: "be-named";
+    /** The globs. An empty list is an error. */
+    readonly names: readonly string[];
+} | ({
+    /** The item must have the relation to one of the paths. */
+    readonly type: "have";
+} & Related) | {
+    /** The item must have one of the modifiers. */
+    readonly type: "have-modifier";
+    /** The modifiers. An empty list is an error. */
+    readonly modifiers: readonly string[];
+} | {
+    /** No reference inside the item may lead to one of the targets (SPEC 4.12). */
+    readonly type: "not-use";
+    /** The paths that the code of the item must not refer to. */
+    readonly targets: Targets;
+} | {
+    /** Every reference inside the item must lead to one of the targets, or stay in its unit (SPEC 4.12). */
+    readonly type: "only-use";
+    /** The only paths that the code of the item may refer to outside its unit. */
+    readonly targets: Targets;
+} | {
+    /** The item must have at most a number of lines (SPEC 4.16). */
+    readonly type: "not-exceed-lines";
+    /** The number of lines that an item may have. */
+    readonly lines: number;
+} | CustomConstraint;
+/** Targets of a rule about uses: the union of both lists. */
+export interface Targets {
+    /** Checked for existence when they are inside the analysed project. */
+    readonly anyOf: readonly RawPattern[];
+    /** Never checked for existence. */
+    readonly unverified: readonly RawPattern[];
+}
+/** How much a violation of a rule weighs (SPEC section 4). */
+export type Severity = "error" | "warning";
+/** Which reference kinds a rule looks at: all kinds, some kinds only, or all kinds except some. */
+export type KindFilter = {
+    readonly type: "all";
+} | {
+    readonly type: "only";
+    /** The kinds the rule looks at. */
+    readonly kinds: readonly string[];
+} | {
+    readonly type: "except";
+    /** The kinds the rule does not look at. */
+    readonly kinds: readonly string[];
+};
+/** Whether a rule looks at candidate references. `include`: they count like exact references. */
+export type Candidates = "include" | "ignore";

package/dist/core/model.js

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