@goodbones/core 0.1.0-beta.10 → 0.1.0-beta.12

package/src/manifest/json-schema.ts

@@ -31,14 +31,21 @@ const isObject = (value: JsonValue): value is JsonObject =>
 
 const isList = (value: JsonValue): value is ReadonlyArray<JsonValue> => Array.isArray(value);
 
-// The generator names the recursive schemas after its own internal wrappers.
-// A stable name is what a `$ref` in an error message or a docs page can
-// point at: the tree's node, and a campaign's detector.
-const DEFINITION_NAMES: Readonly<Record<string, string>> = {
-  Suspend_: "ManifestNode",
-  Union_: "Detector",
+// The generator names the recursive schemas after its own internal wrappers,
+// numbered in the order it meets them. A stable name is what a `$ref` in an
+// error message or a docs page can point at: the tree's node, and an
+// objective's detector — told apart by what each declares, since the order
+// moves with the manifest's shape.
+const definitionNameOf = (name: string, definition: JsonValue): string => {
+  if (!/^(Suspend|Union)_\d*$/.test(name)) return name;
+  const text = JSON.stringify(definition);
+  if (text.includes('"children"')) return "ManifestNode";
+  if (text.includes('"all"')) return "Detector";
+  return name;
 };
 
+const DEFINITION_NAMES: Record<string, string> = {};
+
 const USE_REFERENCE = "#/$defs/Use";
 const INCLUDE_REFERENCE = "#/$defs/Include";
 
@@ -98,8 +105,40 @@ const SCHEMA_PROPERTY: JsonObject = {
   description: "For editors. Ignored by the loader.",
 };
 
-export const manifestJsonSchema = (): JsonObject => {
-  const generated = Schema.toJsonSchemaDocument(Manifest) as unknown as {
+// A `Record` whose keys are checked — the campaign and objective ids —
+// generates as `patternProperties`, which alone admits any other key beside
+// the matching ones. Closed here, so an editor flags an id in the wrong
+// shape as the loader would.
+const withKeyPatterns = (value: JsonValue): JsonValue => {
+  if (Array.isArray(value)) return value.map(withKeyPatterns);
+  if (!isObject(value)) return value;
+  const rebuilt: Record<string, JsonValue> = {};
+  for (const [childKey, entry] of entriesOf(value)) rebuilt[childKey] = withKeyPatterns(entry);
+  if (
+    rebuilt.type === "object" &&
+    "patternProperties" in rebuilt &&
+    !("additionalProperties" in rebuilt)
+  ) {
+    rebuilt.additionalProperties = false;
+  }
+  return rebuilt;
+};
+
+export type ManifestJsonSchemaOptions = {
+  // The manifest keys of families the core does not own, as the fields of
+  // their own codecs — `CampaignsManifest.fields` from @goodbones/campaigns.
+  // Generated together with the core's, so the published schema describes the
+  // manifest a host with those families loaded will actually decode, and a
+  // host without them publishes a schema without those keys.
+  readonly extensions?: ReadonlyArray<Schema.Struct.Fields> | undefined;
+};
+
+export const manifestJsonSchema = (options: ManifestJsonSchemaOptions = {}): JsonObject => {
+  const whole =
+    options.extensions === undefined || options.extensions.length === 0
+      ? Manifest
+      : Schema.Struct(Object.assign({}, Manifest.fields, ...options.extensions));
+  const generated = Schema.toJsonSchemaDocument(whole) as unknown as {
     readonly schema: JsonObject;
     readonly definitions: JsonObject;
   };
@@ -108,6 +147,9 @@ export const manifestJsonSchema = (): JsonObject => {
     throw new Error("the manifest schema generated with no properties");
   }
 
+  for (const [name, definition] of entriesOf(generated.definitions)) {
+    DEFINITION_NAMES[name] = definitionNameOf(name, definition);
+  }
   const definitions: Record<string, JsonValue> = {};
   for (const [name, definition] of entriesOf(generated.definitions)) {
     definitions[DEFINITION_NAMES[name] ?? name] = admitReferences(definition);
@@ -124,7 +166,7 @@ export const manifestJsonSchema = (): JsonObject => {
       $schema: SCHEMA_PROPERTY,
       defs: DEFS_PROPERTY,
       ...Object.fromEntries(
-        entriesOf(properties).map(([key, value]) => [key, admitReferences(value)]),
+        entriesOf(properties).map(([key, value]) => [key, withKeyPatterns(admitReferences(value))]),
       ),
     },
     $defs: { ...definitions, Use, Include },
@@ -135,8 +177,8 @@ export const manifestJsonSchema = (): JsonObject => {
 // `architecture.yaml` that the root manifest `include`s is shaped like. The
 // node's object form, with the `$schema` and `defs` keys such a file may carry
 // at the top, over the same definitions as the whole manifest.
-export const manifestNodeJsonSchema = (): JsonObject => {
-  const whole = manifestJsonSchema();
+export const manifestNodeJsonSchema = (options: ManifestJsonSchemaOptions = {}): JsonObject => {
+  const whole = manifestJsonSchema(options);
   const definitions = whole.$defs;
   if (definitions === undefined || !isObject(definitions)) {
     throw new Error("the manifest schema generated with no definitions");

package/src/manifest/manifest.ts

@@ -2,14 +2,7 @@ import * as Result from "effect/Result";
 import * as Schema from "effect/Schema";
 import * as SchemaIssue from "effect/SchemaIssue";
 
-import {
-  CampaignUnit,
-  DeclarationKind,
-  ImportProbeTarget,
-  ProbeDiagnostic,
-  ReportFormat,
-  ResolveConfig,
-} from "../domain/architecture-config.js";
+import { DeclarationKind, ResolveConfig } from "../domain/architecture-config.js";
 import { ConfigInvalid } from "../domain/architecture-error.js";
 import {
   type ManifestLocator,
@@ -17,6 +10,7 @@ import {
   renderManifestPath,
 } from "../domain/manifest-location.js";
 import { expandManifest, originOf, type Substitution } from "./expand.js";
+import type { ManifestExtension } from "./extension.js";
 
 // A manifest is a tree of nodes keyed by path pattern, where everything the
 // architecture says about a part of the tree is written at that part of the tree.
@@ -112,7 +106,7 @@ const Members = Schema.Struct({
 // is about; exactly one demand says what is required of them, and none means
 // `forbid` — a selected site is the violation. Stated on a folder it covers
 // the subtree, like `members`.
-const SurfaceConvention = Schema.Union([
+export const SurfaceConvention = Schema.Union([
   Schema.Literals(["kebab-case", "camelCase", "PascalCase", "snake_case"]),
   Schema.Struct({ regex: Schema.String }),
 ]);
@@ -281,201 +275,27 @@ const Limits = Schema.Struct({
   conformance: Schema.optionalKey(ConformanceCeilings),
 });
 
-// A campaign: a migration the repository is running, tracked as an object —
-// a detector, a rationale, a guide, an owner, a definition of done, and a
-// ledger of every place the pattern still occurs. Where a rule says what may
-// never happen, a campaign names what the code is moving away from.
-//
-// The detector is a predicate algebra: `all`, `any` and `not` over leaf
-// terms, the same three words ast-grep uses. Leaf terms reuse the other
-// families' vocabularies where one exists.
-
-// A regular expression over the whole repo-relative path, matched as the
-// `structure` naming rules are: with `subject` and `convention`, the capture
-// group named holds the name being judged, and the term holds when the name
-// has the convention's shape.
-const PathTerm = Schema.Struct({
-  file: Globs,
-  fileNot: Schema.optionalKey(Globs),
-  subject: Schema.optionalKey(Schema.Finite),
-  convention: Schema.optionalKey(SurfaceConvention),
-});
 
-// Holds when some import of the file resolves to the target — a path glob,
-// `{ external: <package> }` or `{ builtin: <module> }` — and, with `symbols`,
-// pulls one of those names across it.
-const ImportsTerm = Schema.Struct({
-  resolves: ImportProbeTarget,
-  symbols: Schema.optionalKey(Schema.Array(Schema.String)),
+const decodeTree = Schema.decodeUnknownResult(Schema.Record(Schema.String, ManifestNodeSchema), {
+  errors: "all",
+  onExcessProperty: "error",
 });
 
-// Holds for an export site the selectors admit — the `surface` selectors.
-const ExportsTerm = Schema.Struct({
-  name: Schema.optionalKey(Globs),
-  kinds: Schema.optionalKey(Schema.Array(Schema.Literals(["named", "default", "namespace"]))),
-  declares: Schema.optionalKey(Schema.Array(DeclarationKind)),
-  reexport: Schema.optionalKey(Schema.Boolean),
-});
-
-// Holds for a member site the selectors admit — the `members` selectors.
-const MembersTerm = Schema.Struct({
-  subject: Schema.Literals(["members", "calls"]),
-  name: Schema.optionalKey(Globs),
-  in: Schema.optionalKey(Globs),
-  declares: Schema.optionalKey(Schema.Array(DeclarationKind)),
-});
-
-// A regular expression over the file's text, multiline.
-const ContentTerm = Schema.Struct({ regex: Schema.String });
-
-// How a metavariable is narrowed: by the text it captured, or by what the
-// identifier at its root is bound to — the module it resolves to and the
-// name it was imported as (`member`), which is how `class $N extends $BASE`
-// says "a React component" rather than "any class with a base".
-const CaptureNarrowing = Schema.Struct({
-  regex: Schema.optionalKey(Schema.String),
-  binding: Schema.optionalKey(
-    Schema.Struct({
-      resolves: ImportProbeTarget,
-      member: Schema.optionalKey(Schema.Array(Schema.String)),
-    }),
-  ),
-});
-
-// An ast-grep rule object — `pattern`, `kind`, `regex`, `has`, `inside`,
-// `precedes`, `follows`, `nthChild`, `all`, `any`, `not` — with `where`
-// beside it. The rule is the engine's to validate; the manifest only knows
-// which keys are a rule's and which is the narrowing. `kind` names are the
-// engine's node kinds, which today are tree-sitter's.
-const SyntaxTerm = Schema.Struct({
-  pattern: Schema.optionalKey(Schema.Unknown),
-  kind: Schema.optionalKey(Schema.Unknown),
-  regex: Schema.optionalKey(Schema.Unknown),
-  nthChild: Schema.optionalKey(Schema.Unknown),
-  inside: Schema.optionalKey(Schema.Unknown),
-  has: Schema.optionalKey(Schema.Unknown),
-  precedes: Schema.optionalKey(Schema.Unknown),
-  follows: Schema.optionalKey(Schema.Unknown),
-  all: Schema.optionalKey(Schema.Unknown),
-  any: Schema.optionalKey(Schema.Unknown),
-  not: Schema.optionalKey(Schema.Unknown),
-  where: Schema.optionalKey(Schema.Record(Schema.String, CaptureNarrowing)),
-});
-
-// One program to run or file to read, or several: a tool that takes one
-// project at a time is run once per project, and the outputs are read as
-// one report — a diagnostic two of them print is one diagnostic.
-const ReportSources = Schema.Union([
-  Schema.String,
-  Schema.Array(Schema.String).check(Schema.isMinLength(1)),
-]);
-
-// A finding of another program, read from the output of `command` (run
-// from the repository root, once per `check`) or from `file` (written by
-// an earlier step) in one of the known formats — `tsc`, `eslint --format
-// json`, `oxlint --format json` — or by a `regex` with named groups. Holds
-// for each diagnostic on the file whose code the term speaks to.
-const ReportTerm = Schema.Struct({
-  command: Schema.optionalKey(ReportSources),
-  file: Schema.optionalKey(ReportSources),
-  format: ReportFormat,
-  pattern: Schema.optionalKey(Schema.String),
-  codes: Schema.optionalKey(Schema.Array(Schema.String)),
-  codesNot: Schema.optionalKey(Schema.Array(Schema.String)),
-}).check(
-  // Refused at decode, where the issue names a line, rather than in the
-  // lowering: a term that names both sources or neither, and a `regex`
-  // term with nothing to match lines against.
-  Schema.makeFilter((term) => {
-    const issues: Array<Schema.FilterIssue> = [];
-    if ((term.command === undefined) === (term.file === undefined)) {
-      issues.push(
-        "a report term names exactly one of `command` (a program to run) and `file` (a report already written)",
-      );
-    }
-    if (term.format === "regex" && term.pattern === undefined) {
-      issues.push({
-        path: ["pattern"],
-        issue: "a `regex` report term needs a `pattern` with named groups `file` and `line`",
-      });
-    }
-    return issues;
-  }),
-);
-
-export type DetectorSpec =
-  | { readonly all: ReadonlyArray<DetectorSpec> }
-  | { readonly any: ReadonlyArray<DetectorSpec> }
-  | { readonly not: DetectorSpec }
-  | { readonly path: typeof PathTerm.Type }
-  | { readonly imports: typeof ImportsTerm.Type }
-  | { readonly exports: typeof ExportsTerm.Type }
-  | { readonly members: typeof MembersTerm.Type }
-  // The `structure` parity strings: holds when every named sibling exists.
-  | { readonly requires: ReadonlyArray<string> }
-  | { readonly content: typeof ContentTerm.Type }
-  | { readonly syntax: typeof SyntaxTerm.Type }
-  | { readonly report: typeof ReportTerm.Type }
-  // `module#export`: a predicate function the host imports before loading.
-  | { readonly fn: string };
-
-// Each object carries exactly one term key, so a misspelled one is a decode
-// error that names the line rather than a term quietly dropped.
-const DetectorRef = Schema.suspend((): Schema.Codec<DetectorSpec> => DetectorSpec);
-
-const DetectorSpec = Schema.Union([
-  Schema.Struct({ all: Schema.Array(DetectorRef) }),
-  Schema.Struct({ any: Schema.Array(DetectorRef) }),
-  Schema.Struct({ not: DetectorRef }),
-  Schema.Struct({ path: PathTerm }),
-  Schema.Struct({ imports: ImportsTerm }),
-  Schema.Struct({ exports: ExportsTerm }),
-  Schema.Struct({ members: MembersTerm }),
-  Schema.Struct({ requires: Schema.Array(Schema.String) }),
-  Schema.Struct({ content: ContentTerm }),
-  Schema.Struct({ syntax: SyntaxTerm }),
-  Schema.Struct({ report: ReportTerm }),
-  Schema.Struct({ fn: Schema.String }),
-]);
-
-// A source the campaign is proven against at load. `path` alone proves a
-// path-shaped detector; `source` is parsed, `edges` answers the `imports`
-// term and a binding narrowing in place of the live resolver, `files`
-// answers `requires` in place of the file system, and `report` answers a
-// `report` term in place of running anything — one-based positions, as a
-// tool prints them.
-const CampaignProbe = Schema.Struct({
-  path: Schema.String,
-  source: Schema.optionalKey(Schema.String),
-  edges: Schema.optionalKey(Schema.Record(Schema.String, ImportProbeTarget)),
-  files: Schema.optionalKey(Schema.Array(Schema.String)),
-  report: Schema.optionalKey(Schema.Array(ProbeDiagnostic)),
-});
+// A tree of nodes, as an `endState` is once rebased: decoded like the
+// manifest's own, every issue listed.
+export const decodeManifestTree = (
+  raw: unknown,
+): Result.Result<Readonly<Record<string, ManifestNode>>, string> => {
+  const decoded = decodeTree(raw);
+  return Result.isFailure(decoded)
+    ? Result.fail(
+        flatten(decoded.failure.issue)
+          .issues.map((issue) => `${renderManifestPath(pathOf(issue))}: ${issue.message}`)
+          .join("\n"),
+      )
+    : Result.succeed(decoded.success);
+};
 
-// `30d`, `12h`: how long a campaign may go without progress before the
-// conformance report calls it stalled.
-const Duration = Schema.String.check(Schema.isPattern(/^\d+[dh]$/));
-
-const Campaign = Schema.Struct({
-  // The ledger file's name, and the rule name's tail: `campaign/<id>`.
-  id: Schema.String.check(Schema.isPattern(/^[a-z0-9]+(?:-[a-z0-9]+)*$/)),
-  title: Schema.optionalKey(Schema.String),
-  why: Schema.String,
-  // What a reader at a hit does about it — the message every hit carries.
-  how: Schema.String,
-  owner: Schema.optionalKey(Schema.String),
-  // Which files the campaign selects. Alias-aware globs, as the graph rules
-  // take; a campaign's reach is its scope, so it joins no coverage row.
-  scope: Globs,
-  unit: CampaignUnit,
-  detect: DetectorSpec,
-  probes: Schema.Struct({
-    fires: Schema.Array(CampaignProbe),
-    ignores: Schema.optionalKey(Schema.Array(CampaignProbe)),
-  }),
-  staleAfter: Duration,
-  onComplete: Schema.optionalKey(Schema.Literals(["keep", "remove"])),
-});
 
 export const Manifest = Schema.Struct({
   // How an import specifier becomes a file. Every pattern below is matched
@@ -491,10 +311,6 @@ export const Manifest = Schema.Struct({
   exports: Schema.optionalKey(Schema.Array(ExportRestriction)),
   graph: Schema.optionalKey(Graph),
   limits: Schema.optionalKey(Limits),
-  campaigns: Schema.optionalKey(Schema.Array(Campaign)),
-  // Where each campaign's ledger is written: `<ledger>/<id>.json`, relative
-  // to the manifest. Defaults to `.architecture-campaigns`.
-  ledger: Schema.optionalKey(Schema.String),
   // Shorthands expanded in every glob, so a pattern reads the way the repo's own
   // imports do rather than repeating `packages/server/src` on every line.
   aliases: Schema.optionalKey(Schema.Record(Schema.String, Schema.String)),
@@ -510,17 +326,8 @@ export type GraphSpec = typeof Graph.Type;
 export type LimitsSpec = typeof Limits.Type;
 export type NamingSpec = typeof Naming.Type;
 export type ExportRestriction = typeof ExportRestriction.Type;
-export type CampaignSpec = typeof Campaign.Type;
-export type CampaignProbeSpec = typeof CampaignProbe.Type;
-export type SyntaxTermSpec = typeof SyntaxTerm.Type;
 
-export const DEFAULT_LEDGER_DIR = ".architecture-campaigns";
 
-// `30d` → milliseconds. The schema has already refused any other shape.
-export const durationMs = (duration: string): number => {
-  const amount = Number(duration.slice(0, -1));
-  return amount * (duration.endsWith("h") ? 3_600_000 : 86_400_000);
-};
 
 export const globsOf = (globs: string | ReadonlyArray<string>): ReadonlyArray<string> =>
   typeof globs === "string" ? [globs] : globs;
@@ -534,6 +341,10 @@ const flatten = SchemaIssue.makeFormatterStandardSchemaV1();
 
 export type DecodedManifest = {
   readonly manifest: Manifest;
+  // What each family the core does not own decoded out of the keys it claims,
+  // keyed by the extension's id. The core carries these and never looks
+  // inside them.
+  readonly extensions: ReadonlyMap<string, unknown>;
   // Things the manifest said in a form that still loads but is on its way out.
   // The host prints them; nothing else acts on them.
   readonly notices: ReadonlyArray<string>;
@@ -639,10 +450,15 @@ const normalizeLegacyMembers = (
   return { input: { ...input, tree }, notices };
 };
 
+
 export type DecodeManifestOptions = {
   // Turns a path in the file into a line and column. The YAML reader supplies
   // one; a JavaScript module has no positions to give and passes nothing.
   readonly locate?: ManifestLocator | undefined;
+  // Families the core does not own. Each claims top-level keys, which are
+  // split off before the core decodes what is left and handed to that
+  // family's own codec.
+  readonly extensions?: ReadonlyArray<ManifestExtension> | undefined;
 };
 
 const fileLabelOf = (configPath: string): string => configPath.split(/[\\/]/).at(-1) ?? configPath;
@@ -714,7 +530,35 @@ export const decodeManifest = (
   }
   const { substitutions, value } = expanded.success;
 
-  const resolve = normalizeLegacyResolve(value);
+  const extensions = options.extensions ?? [];
+  const describe = (path: ManifestPath, detail: string): string =>
+    describeIssue(configPath, options.locate, substitutions, path, detail);
+
+  // The keys a family the core does not own claims are split off here. What
+  // is left is decoded by the core's codec with excess properties refused, so
+  // a key nobody claims is still the misspelling it always was.
+  const claimed = new Map<string, string>();
+  for (const extension of extensions) {
+    for (const key of extension.manifestKeys) {
+      const already = claimed.get(key);
+      if (already !== undefined) {
+        return Result.fail(
+          new ConfigInvalid({
+            configPath,
+            detail:
+              `two loaded families both claim the manifest key \`${key}\` ` +
+              `("${already}" and "${extension.id}"). Load one of them.`,
+          }),
+        );
+      }
+      claimed.set(key, extension.id);
+    }
+  }
+  const core = isRecord(value)
+    ? Object.fromEntries(Object.entries(value).filter(([key]) => !claimed.has(key)))
+    : value;
+
+  const resolve = normalizeLegacyResolve(core);
   const members = normalizeLegacyMembers(resolve.input);
   const decoded = decode(members.input);
   if (Result.isFailure(decoded)) {
@@ -728,8 +572,32 @@ export const decodeManifest = (
       }),
     );
   }
+
+  // Each family decodes its own slice, and renders its issues the way the
+  // core renders its own. One family's failure is reported on its own: the
+  // core's decode already succeeded, so there is nothing to collect it with.
+  const decodedExtensions = new Map<string, unknown>();
+  for (const extension of extensions) {
+    const slice = isRecord(value)
+      ? Object.fromEntries(
+          extension.manifestKeys.flatMap((key) => (key in value ? [[key, value[key]]] : [])),
+        )
+      : {};
+    const result = extension.decode(slice, describe);
+    if (Result.isFailure(result)) {
+      return Result.fail(
+        new ConfigInvalid({
+          configPath,
+          detail: `the manifest does not decode:\n${result.failure.join("\n")}`,
+        }),
+      );
+    }
+    decodedExtensions.set(extension.id, result.success);
+  }
+
   return Result.succeed({
     manifest: decoded.success,
+    extensions: decodedExtensions,
     notices: [...resolve.notices, ...members.notices],
     substitutions,
   });

package/src/ports/file-system.ts

@@ -5,4 +5,7 @@ export type FileSystem = {
   readonly exists: (repoRelativePath: string) => boolean;
   // The file's text, or `null` when it is absent or unreadable.
   readonly readText: (repoRelativePath: string) => string | null;
+  // The names in a folder — the per-sector records under a campaign's
+  // ledger directory are found this way. Empty when the folder is absent.
+  readonly list: (repoRelativeDir: string) => ReadonlyArray<string>;
 };

package/src/testing.ts

@@ -4,5 +4,4 @@
 export { makeFactExtractorFake } from "./infrastructure/fact-extractor-fake.js";
 export { makeFileSystemFake } from "./infrastructure/file-system-fake.js";
 export { makeModuleResolverFake } from "./infrastructure/module-resolver-fake.js";
-export { makeReportSourceFake } from "./infrastructure/report-source-fake.js";
 export { makeSyntaxMatcherFake, type StagedMatch } from "./infrastructure/syntax-matcher-fake.js";

package/build/dts/core/campaigns.d.ts

@@ -1,141 +0,0 @@
-import * as Result from "effect/Result";
-import type { BindingKind, CampaignProbe, CampaignRule, CampaignUnit, DeclarationKind, MemberSubject, ReportFormat } from "../domain/architecture-config.js";
-import { PatternInvalid } from "../domain/architecture-error.js";
-import type { SourceFacts } from "../domain/facts.js";
-import type { Violation } from "../domain/violation.js";
-import type { CampaignPredicate, Range } from "../ports/campaign-predicate.js";
-import type { FactExtractor } from "../ports/fact-extractor.js";
-import type { FileSystem } from "../ports/file-system.js";
-import type { ModuleResolver } from "../ports/module-resolver.js";
-import type { ReportSource, ReportSpec } from "../ports/report-source.js";
-import type { SyntaxMatcher, SyntaxTree } from "../ports/syntax-matcher.js";
-export type { CampaignPredicate, CampaignPredicateInput, CampaignSubject, Range, } from "../ports/campaign-predicate.js";
-type Target = {
-    readonly kind: "path";
-    readonly pattern: RegExp;
-} | {
-    readonly kind: "external";
-    readonly name: string;
-} | {
-    readonly kind: "builtin";
-    readonly name: string;
-};
-type CompiledNarrowing = {
-    readonly capture: string;
-    readonly regex: RegExp | null;
-    readonly binding: {
-        readonly resolves: Target;
-        readonly member: ReadonlyArray<string> | null;
-    } | null;
-};
-export type CompiledDetector = {
-    readonly kind: "all";
-    readonly terms: ReadonlyArray<CompiledDetector>;
-} | {
-    readonly kind: "any";
-    readonly terms: ReadonlyArray<CompiledDetector>;
-} | {
-    readonly kind: "not";
-    readonly term: CompiledDetector;
-} | {
-    readonly kind: "path";
-    readonly file: ReadonlyArray<RegExp>;
-    readonly fileNot: ReadonlyArray<RegExp>;
-    readonly subject: number | null;
-    readonly convention: RegExp | null;
-} | {
-    readonly kind: "imports";
-    readonly resolves: Target;
-    readonly symbols: ReadonlyArray<string> | null;
-} | {
-    readonly kind: "exports";
-    readonly name: ReadonlyArray<RegExp>;
-    readonly kinds: ReadonlyArray<BindingKind> | null;
-    readonly declares: ReadonlyArray<DeclarationKind> | null;
-    readonly reexport: boolean | null;
-} | {
-    readonly kind: "members";
-    readonly subject: MemberSubject;
-    readonly name: ReadonlyArray<RegExp>;
-    readonly in: ReadonlyArray<RegExp>;
-    readonly declares: ReadonlyArray<DeclarationKind> | null;
-} | {
-    readonly kind: "requires";
-    readonly templates: ReadonlyArray<string>;
-} | {
-    readonly kind: "content";
-    readonly regex: RegExp;
-} | {
-    readonly kind: "syntax";
-    readonly rule: unknown;
-    readonly where: ReadonlyArray<CompiledNarrowing>;
-} | {
-    readonly kind: "report";
-    readonly command: ReadonlyArray<string> | null;
-    readonly file: ReadonlyArray<string> | null;
-    readonly format: ReportFormat;
-    readonly pattern: string | null;
-    readonly codes: ReadonlySet<string> | null;
-    readonly codesNot: ReadonlySet<string>;
-} | {
-    readonly kind: "fn";
-    readonly name: string;
-};
-export type CompiledCampaign = {
-    readonly name: string;
-    readonly id: string;
-    readonly title: string | null;
-    readonly message: string;
-    readonly why: string;
-    readonly owner: string | null;
-    readonly scope: ReadonlyArray<RegExp>;
-    readonly unit: CampaignUnit;
-    readonly detect: CompiledDetector;
-    readonly probes: {
-        readonly fires: ReadonlyArray<CampaignProbe>;
-        readonly ignores: ReadonlyArray<CampaignProbe>;
-    };
-    readonly staleAfter: number;
-    readonly onComplete: "keep" | "remove";
-};
-export declare const compileCampaignRule: (rule: CampaignRule) => Result.Result<CompiledCampaign, PatternInvalid>;
-export declare const compileCampaignRules: (rules: ReadonlyArray<CampaignRule>) => Result.Result<ReadonlyArray<CompiledCampaign>, PatternInvalid>;
-export declare const campaignsSelecting: (rules: ReadonlyArray<CompiledCampaign>, file: string) => ReadonlyArray<CompiledCampaign>;
-declare const LEAF_ORDER: readonly ["path", "imports", "exports", "members", "requires", "content", "syntax", "report", "fn"];
-type LeafKind = (typeof LEAF_ORDER)[number];
-export declare const leafTermsOf: (detector: CompiledDetector) => ReadonlyArray<LeafKind>;
-export type CampaignInput = {
-    readonly file: string;
-    readonly text: string;
-    readonly facts: SourceFacts;
-    readonly resolver: ModuleResolver;
-    readonly fileSystem: FileSystem;
-    readonly syntax: SyntaxTree | null;
-    readonly functions: ReadonlyMap<string, CampaignPredicate>;
-    readonly reports: ReportSource;
-};
-export type CampaignHit = {
-    readonly violation: Violation;
-    readonly campaign: string;
-    readonly range?: Range;
-};
-export declare const matchKeyOf: (anchor: string | null, text: string) => string;
-export declare const evaluateCampaign: (rule: CompiledCampaign, input: CampaignInput) => ReadonlyArray<CampaignHit>;
-export declare const reportSpecsOf: (rules: ReadonlyArray<CompiledCampaign>) => ReadonlyArray<ReportSpec>;
-export declare const evaluateCampaigns: (selected: ReadonlyArray<CompiledCampaign>, input: CampaignInput) => ReadonlyArray<CampaignHit>;
-export type TermAnswer = {
-    readonly term: string;
-    readonly answer: boolean;
-    readonly count?: number;
-};
-export declare const explainCampaign: (rule: CompiledCampaign, input: CampaignInput) => ReadonlyArray<TermAnswer>;
-export declare const probeInputOf: (probe: CampaignProbe, extractor: FactExtractor, matcher: SyntaxMatcher | null, functions: ReadonlyMap<string, CampaignPredicate>) => CampaignInput;
-export type FailedProbe = {
-    readonly name: string;
-    readonly probe: CampaignProbe;
-    readonly expected: "fires" | "ignores";
-    readonly admittedBy?: string;
-    readonly outOfScope?: boolean;
-};
-export declare const campaignsFailingTheirProbe: (rules: ReadonlyArray<CompiledCampaign>, extractor: FactExtractor, matcherFor: (file: string) => SyntaxMatcher | null, functions: ReadonlyMap<string, CampaignPredicate>) => ReadonlyArray<FailedProbe>;
-//# sourceMappingURL=campaigns.d.ts.map

package/build/dts/core/campaigns.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"campaigns.d.ts","sourceRoot":"","sources":["../../../src/core/campaigns.ts"],"names":[],"mappings":"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"}