@geonosis/oxlint-plugin-biological-architecture 3.1.0 → 3.3.0

package/dist/rules/lib/hooks.d.ts

@@ -1,20 +1,5 @@
 import { type AnyNode } from './nodes.js';
-/**
- * React's own naming convention: a function called `use<Something>` is a hook.
- *
- * Exported because two other rules test a bare callee identifier against this exact pattern
- * without needing `hookCalledBy`'s member-expression reach — spelling the regex a second and a
- * third time drifted nothing here, but there is no reason to trust that forever.
- */
 export declare const HOOK_NAME: RegExp;
-/**
- * The hook a call names, spelled as the file spelled it — or null when the call is not a hook.
- *
- * Two stateless-tier rules read a call's callee as a bare identifier and nothing else, so
- * `React.useState(0)` and `hooks.useCart()` held state in a tissue and in a compound under both
- * rules at "error": the hook was there, the name was there, and the rule was looking one node too
- * high. A member call is read here too — the object is whatever the file imported the hook
- * through, and the property is the hook. A computed member (`hooks[name]()`) names nothing this
- * can read and is left alone, as every unreadable shape in this plugin is.
- */
+export declare const STORE_HOOK_NAME: RegExp;
 export declare const hookCalledBy: (node: AnyNode) => string | null;
+export declare const hookNameOf: (node: AnyNode) => string | null;

package/dist/rules/lib/hooks.js

@@ -1,21 +1,26 @@
 // src/rules/lib/hooks.ts
 import { calleeNameOf, propertyNameOf } from "./nodes.js";
 var HOOK_NAME = /^use[A-Z]/;
+var STORE_HOOK_NAME = /^use\w+Store$/;
 var hookCalledBy = (node) => {
+  const name = hookNameOf(node);
+  if (name === null || calleeNameOf(node) !== null)
+    return name;
+  const object = node.callee.object;
+  const through = object?.type === "Identifier" && typeof object.name === "string" ? object.name : null;
+  return through === null ? name : `${through}.${name}`;
+};
+var hookNameOf = (node) => {
   const bare = calleeNameOf(node);
   if (bare !== null)
     return HOOK_NAME.test(bare) ? bare : null;
   const callee = node.callee;
-  if (callee === undefined)
-    return null;
-  const property = propertyNameOf(callee);
-  if (property === null || !HOOK_NAME.test(property))
-    return null;
-  const object = callee.object;
-  const through = object?.type === "Identifier" && typeof object.name === "string" ? object.name : null;
-  return through === null ? property : `${through}.${property}`;
+  const property = callee === undefined ? null : propertyNameOf(callee);
+  return property !== null && HOOK_NAME.test(property) ? property : null;
 };
 export {
   HOOK_NAME,
-  hookCalledBy
+  STORE_HOOK_NAME,
+  hookCalledBy,
+  hookNameOf
 };

package/dist/rules/lib/imports.d.ts

@@ -1,9 +1,3 @@
-/**
- * How a file names another file, read once.
- *
- * Twenty-one rules parsed an import source themselves and each covered a different subset of the
- * five ways it can be written, because each was written by whoever needed one of them that day.
- */
 export type ModuleNode = {
     arguments?: {
         type?: string;
@@ -19,34 +13,19 @@ export type ModuleNode = {
         type?: string;
         value?: unknown;
     } | null;
-    /** What the import brought in, for the rules that judge an import by its names. */
     specifiers?: {
         imported?: {
             name?: string;
         };
+        importKind?: string;
         local?: {
             name?: string;
         };
         type?: string;
     }[];
 };
-/**
- * The module a node names, or null when it names none — `export const x = 1` names nothing, a call
- * that is not a `require` names nothing, and `import(`./${name}`)` names something no rule can
- * read. A rule that guessed at the last one would report a finding whose source it cannot print.
- */
 export declare const sourceOf: (node: ModuleNode) => string | null;
-/** `import type X from`, `import { … } from` graded type, and `export type … from`. */
 export declare const isTypeOnly: (node: ModuleNode) => boolean;
-/** Whether a specifier is relative — walked from the importer, never resolved through an alias. */
 export declare const isRelative: (source: string) => boolean;
-/**
- * Where a relative source lands, as a path — and any other source unchanged.
- *
- * `../../billing/organelles/totals` carries no feature name and no tier name until it is resolved
- * against the file that wrote it. Two rules did that and the rest did not, so the same breach was a
- * finding or not depending on which rule happened to look at it. `@/features/x` is NOT relative: it
- * is an alias the bundler resolves, and joining it to the importer's directory would invent a path
- * that exists nowhere.
- */
 export declare const resolveRelative: (importer: string, source: string) => string;
+export declare const isR3fImport: (node: ModuleNode) => boolean;

package/dist/rules/lib/imports.js

@@ -2,13 +2,13 @@
 import * as path from "node:path";
 import { literalNamedBy } from "./literal-call.js";
 import { normalise } from "./paths.js";
-var REQUIRE = "require";
+var R3F_PACKAGES = new Set(["@react-three/drei", "@react-three/fiber"]);
 var sourceOf = (node) => {
   const source = node.source;
   if (source === undefined || source === null) {
     if (node.callee === undefined)
       return null;
-    return literalNamedBy(node, REQUIRE);
+    return literalNamedBy(node, "require");
   }
   if (source.type !== undefined && source.type !== "Literal")
     return null;
@@ -17,7 +17,12 @@ var sourceOf = (node) => {
 var isTypeOnly = (node) => node.importKind === "type" || node.exportKind === "type";
 var isRelative = (source) => source === "." || source === ".." || source.startsWith("./") || source.startsWith("../");
 var resolveRelative = (importer, source) => isRelative(source) ? path.posix.normalize(path.posix.join(path.posix.dirname(normalise(importer)), source)) : source;
+var isR3fImport = (node) => {
+  const source = sourceOf(node);
+  return source !== null && R3F_PACKAGES.has(source);
+};
 export {
+  isR3fImport,
   isRelative,
   isTypeOnly,
   resolveRelative,

package/dist/rules/lib/jsx.d.ts

@@ -0,0 +1,31 @@
+export interface JsxAttribute {
+    name?: {
+        name?: string;
+        type: string;
+    };
+    type: string;
+    value?: {
+        type: string;
+        value?: unknown;
+    } | null;
+}
+export interface JsxOpeningElement {
+    attributes?: JsxAttribute[];
+    loc?: unknown;
+    name: {
+        name?: string;
+        type: string;
+    };
+    type: 'JSXOpeningElement';
+}
+export declare const isCapitalised: (name: string) => boolean;
+export declare const attributeNamed: (node: {
+    attributes?: readonly JsxAttribute[];
+}, name: string) => JsxAttribute | undefined;
+export declare const tagNameOf: (node: {
+    name?: JsxOpeningElement['name'];
+} | undefined) => string | undefined;
+export declare const meaningfulChildren: <Child extends {
+    type: string;
+    value?: string;
+}>(children: readonly Child[] | undefined) => Child[];

package/dist/rules/lib/jsx.js

@@ -0,0 +1,11 @@
+// src/rules/lib/jsx.ts
+var isCapitalised = (name) => /^[A-Z]/.test(name);
+var attributeNamed = (node, name) => node.attributes?.find((attribute) => attribute?.type === "JSXAttribute" && attribute.name?.type === "JSXIdentifier" && attribute.name.name === name);
+var tagNameOf = (node) => node?.name?.type === "JSXIdentifier" && node.name.name ? node.name.name : undefined;
+var meaningfulChildren = (children) => (children ?? []).filter((child) => child.type !== "JSXText" || (child.value ?? "").trim() !== "");
+export {
+  attributeNamed,
+  isCapitalised,
+  meaningfulChildren,
+  tagNameOf
+};

package/dist/rules/lib/landing.d.ts

@@ -1,50 +1,10 @@
-/**
- * Where an import LANDS, and where the code behind each name it takes LIVES.
- *
- * Two consumer issues were one blindness. A direction rule read the specifier as a string and
- * stopped, so `@/components/organelles` — a bare barrel, which names no file in a tier folder —
- * was invisible (#4), and a one-line `export { CustomCarousel } from '@/kit/organelles/carousel'`
- * sitting in `cells/` laundered an organelle into the cell tier for every rule that looked (#11).
- * The Store adoption that found #4 read 78 → 8 → 5 → 1 as tier fixes landed, which is to say its
- * early numbers measured the rules' blindness as much as the code.
- *
- * So the specifier is resolved on disk: relative to the importer, through the repo's own
- * `package.json` `imports` for a `#` subpath, or through its `tsconfig.json` (or `jsconfig.json`)
- * `paths` — never an alias this plugin knows (LAW 6). The file it lands on is the
- * DOOR. Each name the import takes is then followed through `export … from` and `export *` to the
- * file that declares it, the HOME, to a depth of eight and never twice through one file. A name
- * the door does not export and a bare package are left at the door; a specifier nothing on disk
- * answers lands nowhere, and the rule judges the spelling as before. An import that takes the
- * whole module — a namespace, `export *`, `import()`, `require()` — takes every name the door
- * carries (row 593), narrowed to the members the file reaches when it is a namespace.
- */
 type Landings = {
-    /** The file the specifier resolves to, absolute — or nowhere. */
     door: string | undefined;
-    /** Imported name → the absolute file whose code it is; the door when it could not be followed. */
     homes: Map<string, string>;
 };
-/** The absolute file a specifier names from a file, or undefined when nothing on disk answers. */
 export declare const resolveSource: (importer: string, source: string) => string | undefined;
-/**
- * Every name a module exports, its `export *` modules followed to the same depth as a home is. A
- * namespace import, an `export *`, `import()` and `require()` take the whole module (row 593), and
- * "the whole module" is this list — each name then lands where its code lives, as a named import's
- * would.
- */
 export declare const exportedNamesOf: (file: string) => Set<string>;
 export declare const landingsOf: (importer: string, source: string, names: readonly string[]) => Landings;
-/**
- * Whether a specifier's last segment IS a tier folder — `@/components/organelles`, `../cells`.
- * A folder named `organelles` is the organelles tier whichever alias reaches it, so when nothing
- * on disk answers the spelling is still judged as the folder it names.
- */
 export declare const namesATierFolder: (source: string) => boolean;
-/**
- * The root a landed path is judged from: the nearest directory above the importer holding a
- * `package.json` or a `tsconfig.json`, else the importer's own. An absolute path would be judged
- * with every directory above the repo in it, and a checkout under `/app/` or `/home/cells/` would
- * make every resolved import a breach.
- */
 export declare const rootOf: (file: string) => string;
 export {};

package/dist/rules/lib/literal-call.d.ts

@@ -8,4 +8,5 @@ export type LiteralCall = {
         value?: unknown;
     }[];
 };
+export declare const TABLE_CALLEES: string[];
 export declare const literalNamedBy: (node: LiteralCall, callee: string) => string | null;

package/dist/rules/lib/literal-call.js

@@ -1,4 +1,5 @@
 // src/rules/lib/literal-call.ts
+var TABLE_CALLEES = ["sqliteTable", "pgTable"];
 var literalNamedBy = (node, callee) => {
   if (node.callee.type !== "Identifier" || node.callee.name !== callee)
     return null;
@@ -6,5 +7,6 @@ var literalNamedBy = (node, callee) => {
   return name?.type === "Literal" && typeof name.value === "string" ? name.value : null;
 };
 export {
+  TABLE_CALLEES,
   literalNamedBy
 };

package/dist/rules/lib/module-text.d.ts

@@ -1,43 +1,19 @@
-/**
- * What a module's TEXT says it exports, read with regexes and never a parser — the same reading
- * `doors.ts` did for a package's `exports` map, shared now with the landing resolver, because a
- * barrel and a re-export shim are the same shape read for a different question.
- *
- * A table is read once per file per process: `create` runs once per FILE, and the tree does not
- * change under a lint run.
- */
 type ExportTable = {
-    /** Names whose code is HERE: declarations, `export { A as B }` with no `from`, `default`. */
     declared: Set<string>;
-    /** Exported name → the name and module it is taken from: `export { A as B } from './x'`. */
     reexports: Map<string, {
         name: string;
         source: string;
     }>;
-    /** The modules `export * from` hands through, in order. */
     stars: string[];
 };
 export declare const EXTENSIONS: string[];
-/**
- * Source with its comments blanked to spaces, strings stepped over whole — a glob like `'src/*'`
- * opens no comment and a URL keeps its `//`. Blanked, not cut: the tokens either side of a comment
- * stay apart and every line keeps its number. Every text reader in the plugin reads through it.
- */
 export declare const stripComments: (source: string) => string;
-/** The file at a base path: itself, with an extension, or its index — or nothing on disk. */
 export declare const fileAt: (base: string) => string | undefined;
-/** A relative module specifier as the file it names, or undefined when nothing on disk answers. */
 export declare const fileFor: (from: string, specifier: string) => string | undefined;
-/** The export table of a file, or undefined when it cannot be read. */
+export declare const readSource: (file: string) => string | undefined;
+export declare const recordOf: (value: unknown) => Record<string, unknown> | undefined;
+export declare const readManifest: (file: string) => Record<string, unknown> | undefined;
 export declare const exportTableOf: (file: string) => ExportTable | undefined;
-/**
- * The file an `exports` or `imports` value points at, whatever conditions it is wrapped in — a
- * string, an array of alternatives, or a conditions object read in the order a bundler would.
- */
 export declare const conditionTargetOf: (value: unknown) => string | undefined;
-/**
- * JSON as `tsconfig.json` writes it: comments and trailing commas allowed. `JSON.parse` refuses
- * both, and a reader that stripped `//` blindly would cut `"$schema": "https://…"` in half.
- */
 export declare const parseLooseJson: (text: string) => unknown;
 export {};

package/dist/rules/lib/module-text.js

@@ -49,14 +49,26 @@ var entriesOf = (list) => list.split(",").map((one) => one.trim().replace(/^type
   const [taken, exported] = one.split(/\s+as\s+/);
   return { exported: exported ?? taken ?? "", taken: taken ?? "" };
 });
-var tables = new Map;
-var readTable = (file) => {
-  let source;
+var readSource = (file) => {
   try {
-    source = stripComments(readFileSync(file, "utf8"));
+    return stripComments(readFileSync(file, "utf8"));
   } catch {
     return;
   }
+};
+var recordOf = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? Object.fromEntries(Object.entries(value)) : undefined;
+var readManifest = (file) => {
+  try {
+    return recordOf(JSON.parse(readFileSync(file, "utf8")));
+  } catch {
+    return;
+  }
+};
+var tables = new Map;
+var readTable = (file) => {
+  const source = readSource(file);
+  if (source === undefined)
+    return;
   const declared = new Set;
   const reexports = new Map;
   const stars = [];
@@ -119,5 +131,8 @@ export {
   fileAt,
   fileFor,
   parseLooseJson,
+  readManifest,
+  readSource,
+  recordOf,
   stripComments
 };

package/dist/rules/lib/mutations.d.ts

@@ -1,19 +1,5 @@
 import { type AnyNode } from './nodes.js';
-/**
- * What a WRITE is, in one place. `mutating-step-declares-retry` asks it of a step's invoke body and
- * `route-no-inline-mutation` asks it of a route handler; two copies of this, spelled slightly
- * differently, is how the two rules would come to disagree about which calls are writes — the same
- * drift `lib/steps.ts` exists to prevent for what a step is.
- *
- * The CRUD names `MedusaService` generates. A framework fact, so a default rather than a blank.
- */
 export declare const DEFAULT_MUTATION_PREFIXES: string[];
 export declare const mutationPrefixesOf: (rule: string, configured: string[] | undefined) => string[];
-/**
- * `svc.createOrder(…)` — a generated CRUD write, told from `listOrders` by the capital after the
- * prefix, and from `createOrderWorkflow(scope)` by being a METHOD on something. A bare identifier
- * call is the workflow door itself, which is the shape both rules exist to send people towards.
- */
 export declare const writesWith: (prefixes: readonly string[]) => (node: AnyNode) => boolean;
-/** The method name a write call carries, for a message that points at something. */
 export declare const writeNameOf: (node: AnyNode) => string;

package/dist/rules/lib/nodes.d.ts

@@ -1,25 +1,8 @@
 export type AnyNode = {
     type?: string;
 } & Record<string, unknown>;
-/**
- * Every node under this one, this one included.
- *
- * A visitor is handed the node it asked for, and some facts live in its BODY — whether a step's
- * invoke function writes anything is the one that made this necessary, and it can be behind an
- * `if`, inside a `try`, or two closures down. A rule that only read the statements directly under
- * the arrow would pass every step that guarded its write. Children are visited in source order.
- *
- * `parent` is skipped: oxlint hands nodes with back-references, and following one walks the whole
- * program from wherever it started.
- */
 export declare const walkNode: (node: unknown, visit: (node: AnyNode) => void, descends?: (node: AnyNode) => boolean) => void;
-/**
- * Every node under a function's OWN body, stopping at a nested function — a hook called inside a
- * closure this function merely defines belongs to that closure, not to this one. Two rules walked
- * this by hand, one to find a hook call and one to collect `return` statements.
- */
+export declare const FUNCTION_BOUNDARY_TYPES: Set<string>;
 export declare const walkOwnFunctionBody: (body: unknown, visit: (node: AnyNode) => void) => void;
-/** The name a `MemberExpression`'s non-computed property carries, or null. */
 export declare const propertyNameOf: (node: AnyNode) => string | null;
-/** The name an `Identifier` callee carries, or null — a method call is never one of these. */
 export declare const calleeNameOf: (node: AnyNode) => string | null;

package/dist/rules/lib/nodes.js

@@ -64,6 +64,7 @@ var calleeNameOf = (node) => {
   return callee?.type === "Identifier" && typeof callee.name === "string" ? callee.name : null;
 };
 export {
+  FUNCTION_BOUNDARY_TYPES,
   calleeNameOf,
   propertyNameOf,
   walkNode,

package/dist/rules/lib/objects.d.ts

@@ -1,17 +1,8 @@
 import type { AnyNode } from './nodes.js';
-/** The expression under any `as` / `satisfies` — a retyped value is the value it was. */
 export declare const withoutTypes: (node: unknown) => AnyNode | undefined;
-/**
- * The properties of an object literal, or **null when it cannot be read whole**.
- *
- * A spread hides properties, and the posture this plugin already took for `emit-declares-attempts`
- * is the one that holds here too: a rule that guessed at what a spread contains would fire on every
- * repo that factored its configs out, and people would learn to ignore it. Unreadable is not the
- * same as absent, and only one of the two is a finding.
- */
 export declare const propertiesOf: (node: unknown) => AnyNode[] | null;
-/** The value of the named property, or undefined. `name` and `'name'` are read alike; `[name]` is not. */
 export declare const valueOf: (properties: readonly AnyNode[], name: string) => AnyNode | undefined;
 export declare const hasProperty: (properties: readonly AnyNode[], name: string) => boolean;
-/** The string a node literally is, or null — a constant is a value this cannot read. */
 export declare const stringOf: (node: unknown) => string | null;
+export declare const keyNameOf: (node: AnyNode) => string | null;
+export declare const destructuredNamesOf: (pattern: unknown) => string[] | null;

package/dist/rules/lib/objects.js

@@ -26,8 +26,29 @@ var stringOf = (node) => {
   const literal = node;
   return literal?.type === "Literal" && typeof literal.value === "string" ? literal.value : null;
 };
+var keyNameOf = (node) => {
+  const key = node.key;
+  if (key?.type === "Identifier" && typeof key.name === "string")
+    return key.name;
+  return stringOf(key);
+};
+var destructuredNamesOf = (pattern) => {
+  const at = pattern;
+  if (at?.type !== "ObjectPattern")
+    return null;
+  const names = [];
+  for (const one of at.properties ?? []) {
+    const name = one.type === "Property" && one.computed !== true ? keyNameOf(one) : null;
+    if (name === null)
+      return null;
+    names.push(name);
+  }
+  return names;
+};
 export {
+  destructuredNamesOf,
   hasProperty,
+  keyNameOf,
   propertiesOf,
   stringOf,
   valueOf,

package/dist/rules/lib/options.d.ts

@@ -1,34 +1,10 @@
-/**
- * #199: the rule and the option it REQUIRES, in one fixed position at the front of the finding.
- *
- * The prose after it quotes every option the rule accepts, which is what a consumer with a
- * half-written config needs — and is exactly why a reader matching the option name anywhere in the
- * message cannot tell a required option from a mentioned one. `refuses-bare.bin.test.ts` asserted
- * that way and passed for a release over an entry claiming `engine` for a rule that requires
- * `within`. The doctor and the cli read the pair out of this header and nowhere else.
- */
 export declare const refusalHeader: (rule: string, option: string) => string;
-/**
- * The signal a rule raises when an option it cannot run without is missing. Carries the pair a
- * reader would otherwise parse back out of the sentence. Caught by `reportingOncePerRun` in the
- * registry; a `create` reached WITHOUT the registry (a unit test on the rule module) sees it thrown,
- * which is the rule saying what it requires, not the plugin's behaviour.
- */
 export declare class OptionMissing extends Error {
     readonly option: string;
     readonly rule: string;
     constructor(rule: string, option: string, message: string);
 }
-/**
- * A regex-source option in either shape: a bare string is a one-element list.
- *
- * The seven tree options #12 added in one commit shipped as three strings and four lists. A
- * consumer wrote `seam` as a string, oxlint refused the config at options validation, and every
- * rule in it read 0 with exit 1 — a config mistake presenting as a clean zero. One shape rule for
- * all of them, read here and declared by `PATTERNS` below, so the reader never has to know which.
- */
 export declare const patternsOf: (value: string | readonly string[] | null | undefined) => string[];
-/** The JSON schema for an option `patternsOf` reads: `string | string[]`. */
 export declare const PATTERNS: {
     anyOf: ({
         type: 'string';
@@ -40,35 +16,10 @@ export declare const PATTERNS: {
         type: 'array';
     })[];
 };
-/**
- * #203: a test file is not a door/seam rule's business anywhere, so the default says so — the
- * fallback for an `exempt` option a repo has not configured.
- *
- * `time-through-the-door` 1.4.0 had `__tests__` compiled in; making every path an option (law 6)
- * emptied it, and the reach GREW — a Workers + D1 app's first RC run reported six findings in test
- * files that had never been in scope. Test paths are not consumer vocabulary the way a door is:
- * every repo spells them these three ways, and a repo with a fourth spelling names its own list and
- * replaces this one. `dialect-through-the-seam` held the identical array as its own copy; one now.
- */
+export declare const DEFAULT_TENANT_KEY = "orgId";
 export declare const DEFAULT_TEST_EXEMPT: string[];
-/**
- * The value, or the requirement raised, naming the rule and the option. Read by the rule, judged
- * here: some of these options are keyed and one is positional, and what they have in common is not
- * their shape but that the rule cannot fire without them.
- *
- * `accepts` is the whole option bag written out — `{ roots: string[], registry: string | string[] }`
- * — appended so the accepted shape comes back WITH the finding. Without it the only way to learn
- * what a rule takes is to read the dist bundle, which is how a consumer whose registry is split
- * reached for a list, was told `should be string`, and could not tell from the refusal whether a
- * list was a shape the rule had or a shape it lacked. Optional, so a rule that has not written its
- * shape down is reported exactly as it always was.
- *
- * #205 is history now: a `requireOptionHere` once waited for a file a tree-scoped rule would judge
- * and named it in the refusal, because a refusal thrown over every package the preset reached was
- * noise a consumer learned to route around. Reported once a run, a refusal has no per-package
- * noise to wait out, and no rule was calling it, so it is gone.
- */
 export declare const requireOption: <Value>(rule: string, value: Value | null | undefined, option: string, accepts?: string) => Value;
 type Create<Context> = (context: Context) => Record<string, unknown>;
-export declare const reportingOncePerRun: <Context>(create: Create<Context>) => Create<Context>;
+export declare const onceFor: (key: string, file: string) => boolean;
+export declare const reportingOncePerRun: <Context>(create: Create<Context>, rule?: string) => Create<Context>;
 export {};

package/dist/rules/lib/options.js

@@ -1,5 +1,5 @@
 // src/rules/lib/options.ts
-var NOTHING = "nothing";
+import { designatedFile } from "./run-files.js";
 var isMissing = (value) => value === undefined || value === null || value === "" || Array.isArray(value) && value.length === 0;
 var refusalHeader = (rule, option) => `biological-architecture/${rule} requires option \`${option}\`.`;
 
@@ -20,43 +20,74 @@ var PATTERNS = {
     { items: { type: "string" }, type: "array" }
   ]
 };
+var DEFAULT_TENANT_KEY = "orgId";
 var DEFAULT_TEST_EXEMPT = ["__tests__/", String.raw`\.test\.`, String.raw`\.spec\.`];
 var requireOption = (rule, value, option, accepts) => {
   if (isMissing(value)) {
-    throw new OptionMissing(rule, option, `${refusalHeader(rule, option)} It is enabled but its \`${option}\` option is ${NOTHING}, so it judges no file — this finding stands in for every file it did not read, once a run. Configure \`${option}\`, or turn the rule off: an enabled rule that judges nothing would otherwise read exactly like a rule that found nothing.${accepts === undefined ? "" : ` It accepts ${accepts}.`}`);
+    throw new OptionMissing(rule, option, `${refusalHeader(rule, option)} It is enabled but its \`${option}\` option is nothing, so it judges no file — this finding stands in for every file it did not read, once a run. Configure \`${option}\`, or turn the rule off: an enabled rule that judges nothing would otherwise read exactly like a rule that found nothing.${accepts === undefined ? "" : ` It accepts ${accepts}.`}`);
   }
   return value;
 };
 var raisedOver = new Map;
-var fileOf = (context) => {
+var filenameOf = (context) => {
   const named = context?.filename;
   return typeof named === "string" ? named : "";
 };
-var reportingOncePerRun = (create) => (context) => {
+var badPatternMessage = (rule, error) => `biological-architecture/${rule} threw a SyntaxError — ${error.message}. An option of this rule holds a pattern that is not a regular expression. This finding stands in for every file it could not judge, once a run; fix the pattern, or turn the rule off.`;
+var onceFor = (key, file) => {
+  if (file === "")
+    return true;
+  const designated = designatedFile(key.split("/")[0] ?? key);
+  if (designated !== null)
+    return file === designated;
+  const first = raisedOver.get(key);
+  if (first !== undefined && first !== file)
+    return false;
+  raisedOver.set(key, file);
+  return true;
+};
+var refusalVisitor = (context, key, finding) => onceFor(key, filenameOf(context)) ? {
+  Program(node) {
+    context.report({ ...finding, node });
+  }
+} : {};
+var reportedAtVisit = (visitor, rule, context) => Object.fromEntries(Object.entries(visitor).map(([name, handler]) => [
+  name,
+  typeof handler === "function" ? (node) => {
+    try {
+      handler(node);
+    } catch (error) {
+      if (!(error instanceof SyntaxError))
+        throw error;
+      if (!onceFor(`${rule}/pattern`, filenameOf(context)))
+        return;
+      context.report({ message: badPatternMessage(rule, error), node });
+    }
+  } : handler
+]));
+var reportingOncePerRun = (create, rule = "") => (context) => {
   try {
-    return create(context);
+    return reportedAtVisit(create(context), rule, context);
   } catch (error) {
+    if (error instanceof SyntaxError) {
+      return refusalVisitor(context, `${rule}/pattern`, {
+        message: badPatternMessage(rule, error)
+      });
+    }
     if (!(error instanceof OptionMissing))
       throw error;
-    const file = fileOf(context);
-    if (file !== "") {
-      const key = `${error.rule}/${error.option}`;
-      const first = raisedOver.get(key);
-      if (first !== undefined && first !== file)
-        return {};
-      raisedOver.set(key, file);
-    }
-    return {
-      Program(node) {
-        context.report({ message: error.message, node });
-      }
-    };
+    return refusalVisitor(context, `${error.rule}/${error.option}`, {
+      data: { option: error.option, rule: error.rule },
+      message: error.message
+    });
   }
 };
 export {
+  DEFAULT_TENANT_KEY,
   DEFAULT_TEST_EXEMPT,
   OptionMissing,
   PATTERNS,
+  onceFor,
   patternsOf,
   refusalHeader,
   reportingOncePerRun,

package/dist/rules/lib/package-imports.d.ts

@@ -1,6 +1 @@
-/**
- * The places the manifest says a `#` specifier may be, best match first — as bases without
- * extensions, for the caller to find the file at. A target that is not relative names a package,
- * which is not a file in this repo, and is left out. Empty when no manifest maps it.
- */
 export declare const importCandidates: (importer: string, source: string) => string[];

package/dist/rules/lib/package-imports.js

@@ -1,18 +1,12 @@
 // src/rules/lib/package-imports.ts
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
-import { conditionTargetOf } from "./module-text.js";
+import { conditionTargetOf, readManifest, recordOf } from "./module-text.js";
 import { longestMatch } from "./pattern-match.js";
 var manifests = new Map;
 var readImports = (file) => {
-  try {
-    const parsed = JSON.parse(readFileSync(file, "utf8"));
-    if (typeof parsed.imports !== "object" || parsed.imports === null)
-      return null;
-    return { dir: dirname(file), imports: parsed.imports };
-  } catch {
-    return null;
-  }
+  const imports = recordOf(readManifest(file)?.imports);
+  return imports === undefined ? null : { dir: dirname(file), imports };
 };
 var importsFor = (dir) => {
   const known = manifests.get(dir);