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

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

@@ -1,47 +1,21 @@
-/**
- * The one place a filename becomes a path.
- *
- * oxlint hands a rule the name the platform gave it, so on Windows it arrives with backslashes and
- * every pattern in this plugin — which is written with `/` — misses. Thirty-seven rules carried
- * their own copy of the conversion, spelled three different ways, and one of them fixed only the
- * first separator. A single fix to how a path is read had to be found rule by rule; now there is
- * one line to find.
- */
 export declare const normalise: (filename: string) => string;
-/**
- * The last segment of a path — what a diagnostic calls the file. An empty last segment is not a
- * name, so a path that ends in a separator answers with itself rather than with `""`.
- */
 export declare const fileOf: (path: string) => string;
-/**
- * Whether a file IS a door a repo named — one grammar for every rule that has doors (#204).
- *
- * A repo writes its time module down once and enables two rules with it. `time-through-the-door`
- * took a REGEX over the filename; `boundary-time-is-primitive` compared a plain path, so the same
- * spelling — `packages/utils/src/time\.ts$`, or the specifier callers import it by — made the
- * second rule report the door's own signatures. All three spellings are accepted here: the exact
- * path, a path the filename ends with (a specifier is one), and a regex over the filename.
- */
 export declare const isDoor: (filename: string, door: string) => boolean;
-/**
- * Whether a file IS one of an ENUMERATED list of modules — never a pattern.
- *
- * The counterpart to a path grant, and deliberately not `isDoor`: a door accepts a regex, and a
- * regex is exactly the glob whose exemption stops wherever it happens to stop. An entry here names
- * one module, by its full path or by the tail a repo writes it as, so the count of exemptions is a
- * number a reader can hold.
- */
 export declare const isModule: (filename: string, module: string) => boolean;
-/**
- * Whether a NORMALISED path sits inside a `__tests__/` directory — the exemption five rules
- * (tissue-no-data-props, next-route-segment-is-thin-delegate, no-inert-hidden-jsx,
- * no-hook-in-component-disguise, no-trivial-wrapper-component) each spelled as their own
- * `/__tests__\//` literal. Takes an already-`normalise`d path, the shape every call site already
- * held in a local before testing it.
- */
+export declare const isExempt: (filename: string, { allow, exemptModules }: {
+    allow?: string[];
+    exemptModules?: string[];
+}) => boolean;
 export declare const isTestFile: (path: string) => boolean;
-/**
- * Whether a NORMALISED path matches any of a list of regex sources — `dialect-through-the-seam`
- * and `no-d1-transaction` each carried this loop by hand, over the same shape of option.
- */
 export declare const anyOf: (patterns: readonly string[], path: string) => boolean;
+export declare const matchesAny: (patterns: readonly RegExp[], path: string) => boolean;
+export declare const trimSlashes: (path: string) => string;
+export declare const rootedAt: (filename: string, directory: string) => {
+    after: string;
+    repoRoot: string;
+} | null;
+export declare const HARNESS_PATHS: string[];
+export declare const ROUTE_FALLBACK_BASENAMES: Set<string>;
+export declare const LAYOUT_BASENAMES: Set<string>;
+export declare const ROUTE_BODY_BASENAMES: Set<string>;
+export declare const ROUTE_BASENAMES: Set<string>;

package/dist/rules/lib/paths.js

@@ -16,13 +16,46 @@ var isModule = (filename, module) => {
   const named = module.replace(/^\.?\//, "");
   return path === named || path.endsWith(`/${named}`);
 };
+var isExempt = (filename, { allow = [], exemptModules = [] }) => exemptModules.some((module) => isModule(filename, module)) || allow.some((path) => filename.includes(path));
 var isTestFile = (path) => /__tests__\//.test(path);
 var anyOf = (patterns, path) => patterns.some((pattern) => new RegExp(pattern).test(path));
+var matchesAny = (patterns, path) => patterns.some((pattern) => pattern.test(path));
+var trimSlashes = (path) => path.replace(/^\/+/, "").replace(/\/+$/, "");
+var rootedAt = (filename, directory) => {
+  const marker = `/${directory}/`;
+  const at = filename.indexOf(marker);
+  return at < 0 ? null : { after: filename.slice(at + marker.length), repoRoot: filename.slice(0, at) };
+};
+var HARNESS_PATHS = [
+  String.raw`/__tests__/`,
+  String.raw`/scripts/`,
+  String.raw`/testing/`,
+  String.raw`/seeds/`
+];
+var ROUTE_FALLBACK_BASENAMES = new Set([
+  "default.tsx",
+  "error.tsx",
+  "global-error.tsx",
+  "loading.tsx",
+  "not-found.tsx"
+]);
+var LAYOUT_BASENAMES = new Set(["layout.tsx", "template.tsx"]);
+var ROUTE_BODY_BASENAMES = new Set([...LAYOUT_BASENAMES, "page.tsx"]);
+var ROUTE_BASENAMES = new Set([...ROUTE_FALLBACK_BASENAMES, ...ROUTE_BODY_BASENAMES]);
 export {
+  HARNESS_PATHS,
+  LAYOUT_BASENAMES,
+  ROUTE_BASENAMES,
+  ROUTE_BODY_BASENAMES,
+  ROUTE_FALLBACK_BASENAMES,
   anyOf,
   fileOf,
   isDoor,
+  isExempt,
   isModule,
   isTestFile,
-  normalise
+  matchesAny,
+  normalise,
+  rootedAt,
+  trimSlashes
 };

package/dist/rules/lib/pattern-match.d.ts

@@ -1,16 +1,6 @@
-/**
- * The longest match for a wildcard pattern against a source string — tsc's own rule for
- * `tsconfig.json` `paths`, and the same rule Node uses for `package.json` `imports`. An exact key
- * wins outright; a pattern with one `*` matches when the source starts with what comes before it
- * and ends with what comes after, and among those the longest fixed (non-star) part wins.
- *
- * `tsconfig-paths.ts` and `package-imports.ts` each carried this loop by hand, spelled identically
- * down to the variable names — one truth about how a wildcard map is searched, read for two
- * different maps. What each caller does with the match (a `paths` entry names several targets and
- * takes `target.replace`; an `imports` value is one target read through `conditionTargetOf` and
- * takes `target.replaceAll`) is NOT unified here, because those two shapes are not the same truth.
- */
 export declare const longestMatch: <Value>(entries: Iterable<[string, Value]>, source: string) => {
     matched: string;
     value: Value;
 } | undefined;
+export declare const escapeForRegex: (value: string) => string;
+export declare const readableSource: (pattern: string) => string;

package/dist/rules/lib/pattern-match.js

@@ -24,6 +24,10 @@ var longestMatch = (entries, source) => {
   }
   return best === undefined ? undefined : { matched: best.matched, value: best.value };
 };
+var escapeForRegex = (value) => value.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var readableSource = (pattern) => pattern.replaceAll("\\", "").replace(/\$$/, "");
 export {
-  longestMatch
+  escapeForRegex,
+  longestMatch,
+  readableSource
 };

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

@@ -1,55 +1,12 @@
-/**
- * The file a rule says MUST fire it, given the options it was handed.
- *
- * `requireOption` closed one hole: an enabled rule with no option reports that, once a run,
- * instead of reading as a clean tree. It leaves the next one open. A rule CONFIGURED with a repo's own
- * vocabulary — its own brand, `packages/workflows/src/`, `@repo/db` — cannot be exercised by a corpus
- * that ships fixtures saying `acme` and `corpus/workflows/`, so "fires nowhere" is what an
- * adoption's doctor reports about a rule the repo is enforcing perfectly well. Both consumers filed
- * exactly that on 2026-08-30, and both were right about the fact and wrong about whose defect it is.
- *
- * A probe is the answer the rule itself can give: hand it the options and it writes the smallest
- * source that must fire it under THOSE options, at a path that lands where it looks. It is a claim,
- * so it is tested through the real binary — a probe that does not fire is a rule that cannot be
- * exercised, and the honest thing then is to say so rather than to widen the probe until it does.
- */
 export type Probe = {
-    /** Repo-root-relative, `/`-separated. It must satisfy every PATH option the rule reads. */
     path: string;
     source: string;
 };
-/**
- * A probe that needs a TREE rather than a file.
- *
- * A rule that reads a sibling off disk — a registry, a schema's twin — cannot be exercised by one
- * file however right its source is: `no-unregistered-plugin-dir` returns silently when the registry
- * its options name is not there, so the single-file probe fired nothing and every consumer
- * enforcing the rule over a real registry read as a permanent FAIL. The answer is not a widened
- * probe, which would be the rule claiming evidence it does not have; it is a probe that may declare
- * the sibling too, and a reader that mounts all of them.
- */
 export type ProbeTree = {
     files: readonly Probe[];
 };
 export type ProbeFn = (options: readonly unknown[]) => Probe | ProbeTree;
-/** The files a probe declares, whichever of the two forms it answered in. */
 export declare const filesOf: (answer: Probe | ProbeTree) => readonly Probe[];
-/** The bag a rule reads its keyed options out of, whatever the caller passed. */
 export declare const bagOf: <Options>(options: readonly unknown[]) => Partial<Options>;
-/**
- * The first configured value, or the first default. A probe reads the option the same way `create`
- * does, defaults included — otherwise a repo keeping a default would get a probe built for a value
- * its rule is not using, which fires nowhere and blames the repo for it.
- */
 export declare const firstOf: (configured: readonly string[] | undefined, fallback: readonly string[]) => string;
-/**
- * A path a regex option would match, built back out of the regex.
- *
- * The path options in this plugin are regex SOURCES — `within`, `paths`, `directories`, a layer's
- * `paths` — so a probe cannot be written against them without inverting one. This inverts the
- * subset those options are actually written in: anchors, non-capturing groups, one-segment
- * wildcards and escaped separators. It is deliberately not a general inverse, and it never has to
- * be trusted: the caller tests the result against the pattern it came from and refuses when it
- * does not match, which turns a wrong guess into a sentence rather than into a silent zero.
- */
 export declare const pathMatching: (pattern: string, leaf: string) => string;

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

@@ -1,20 +1,2 @@
-/**
- * A pure re-export shim (only `export … from`, no component) is a compatibility alias left behind
- * when a component moves to a feature folder — not the tier it sits in. Three rules read this off
- * the file, each with its own copy.
- */
 export declare function isReexportOnly(file: string): boolean;
-/**
- * Where a shim's code LIVES, when that is not the shim's own tier — or undefined when the file is
- * not a pure re-export shim at all.
- *
- * The three "must" rules exempted every shim outright, and that was #11's hole surviving in three
- * rules the direction rules' fix did not reach (row 594): `cells/laundered.tsx` re-exporting a
- * stateless compound is a cell that holds no state, and `tissues/alias.tsx` re-exporting a compound
- * is a tissue that composes nothing. Each name the shim hands on is followed to the file that
- * declares it, as the direction rules follow it; an `export *` is judged at the module it hands
- * through. A home in the shim's own tier is the alias the exemption was written for and is not
- * named. A re-export nothing on disk answers — a bare package — is not named either: unresolved
- * stays exempt, exactly as before.
- */
 export declare const launderedHomesOf: (file: string) => string[] | undefined;

package/dist/rules/lib/render-tracking.d.ts

@@ -1,8 +1,3 @@
-/**
- * Whether a file RENDERS one of the tiers it imports, not merely names it — a gate satisfied by an
- * import nobody renders was not satisfied. `molecule-must-compose` and `tissue-must-compose` both
- * read this off the import list and the JSX tree; each had its own copy of the reader.
- */
 type ImportSpecifierNode = {
     imported?: {
         name?: string;
@@ -45,10 +40,7 @@ export type JsxOpeningElementNode = {
     };
     type: 'JSXOpeningElement';
 };
-/** The identifier a JSX tag renders under — `<Foo/>`'s own name, or `<NS.Foo/>`'s namespace root. */
 export declare const rootTagNameOf: (name: JsxOpeningElementNode['name'] | undefined) => string | undefined;
-/** The local names an import brings in, added to `into` when its source composes and it is a value. */
 export declare const collectCompositionLocals: (node: CompositionImportNode, isComposition: (source: string) => boolean, into: Set<string>) => void;
-/** Whether any of the imported locals was actually rendered as a JSX tag. */
 export declare const rendersAnyOf: (locals: ReadonlySet<string>, renderedTagNames: ReadonlySet<string>) => boolean;
 export {};

package/dist/rules/lib/run-files.d.ts

@@ -0,0 +1,18 @@
+type Override = {
+    files: string[];
+    rules: Record<string, unknown>;
+};
+type Run = {
+    candidates: string[];
+    overrides: Override[];
+    prefixes: string[];
+    root: string;
+    rules: Record<string, unknown>;
+};
+export declare const runOf: ({ argv, cwd }: {
+    argv: readonly string[];
+    cwd: string;
+}) => Run | null;
+export declare const designatedIn: (run: Run, rule: string, accepts: (file: string, text: string) => boolean) => string | null;
+export declare const designatedFile: (rule: string, salt?: string, accepts?: (file: string, text: string) => boolean) => string | null;
+export {};

package/dist/rules/lib/run-files.js

@@ -0,0 +1,144 @@
+// src/rules/lib/run-files.ts
+import { spawnSync } from "node:child_process";
+import { closeSync, existsSync, openSync, readFileSync, readSync } from "node:fs";
+import { basename, dirname, join, matchesGlob, relative, resolve } from "node:path";
+import { parseLooseJson } from "./module-text.js";
+var LINTED = /\.(?:[cm]?[jt]sx?)$/;
+var HEAD_BYTES = 4096;
+var SWITCHES_OFF = /\b(?:oxlint|eslint)-disable(?!-(?:next-)?line)\b/;
+var PLUGIN_NAME = "biological-architecture";
+var FLAGS_WITH_VALUE = new Set([
+  "-c",
+  "--config",
+  "-f",
+  "--format",
+  "--threads",
+  "--tsconfig",
+  "-D",
+  "-W",
+  "-A",
+  "--deny",
+  "--warn",
+  "--allow",
+  "--max-warnings"
+]);
+var UNKNOWABLE = ["--ignore-path", "--ignore-pattern", "--no-ignore", "--lsp", "--stdin-filepath"];
+var recordOf = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? Object.fromEntries(Object.entries(value)) : {};
+var stringsOf = (value) => Array.isArray(value) ? value.filter((one) => typeof one === "string") : [];
+var ignoredBy = (path, patterns) => patterns.some((pattern) => {
+  const bare = pattern.replace(/^\.\//, "").replace(/\/$/, "");
+  if (!bare.includes("/"))
+    return path.split("/").some((segment) => matchesGlob(segment, bare));
+  return matchesGlob(path, bare) || matchesGlob(path, `${bare}/**`);
+});
+var looselyMatches = (path, glob) => matchesGlob(path, glob) || matchesGlob(path, `**/${glob}`) || matchesGlob(basename(path), glob);
+var switchedOff = (file) => {
+  let handle;
+  try {
+    handle = openSync(file, "r");
+    const buffer = Buffer.alloc(HEAD_BYTES);
+    const read = readSync(handle, buffer, 0, HEAD_BYTES, 0);
+    return SWITCHES_OFF.test(buffer.subarray(0, read).toString("utf8"));
+  } catch {
+    return true;
+  } finally {
+    if (handle !== undefined)
+      closeSync(handle);
+  }
+};
+var prefixesOf = (jsPlugins) => {
+  const names = (Array.isArray(jsPlugins) ? jsPlugins : []).flatMap((entry) => {
+    if (typeof entry === "string") {
+      return entry.includes("oxlint-plugin-biological-architecture") ? [PLUGIN_NAME] : [];
+    }
+    const { name, specifier } = recordOf(entry);
+    return typeof name === "string" && typeof specifier === "string" && specifier.includes("oxlint-plugin-biological-architecture") ? [name] : [];
+  });
+  return names.length === 0 ? [PLUGIN_NAME] : names;
+};
+var runOf = ({ argv, cwd }) => {
+  let config;
+  const paths = [];
+  for (let at = 0;at < argv.length; at += 1) {
+    const word = argv[at] ?? "";
+    const name = word.split("=")[0] ?? word;
+    if (UNKNOWABLE.includes(name))
+      return null;
+    if (name === "-c" || name === "--config") {
+      config = word.includes("=") ? word.slice(word.indexOf("=") + 1) : argv[at += 1];
+    } else if (FLAGS_WITH_VALUE.has(word))
+      at += 1;
+    else if (!word.startsWith("-"))
+      paths.push(word);
+  }
+  const configPath = config === undefined ? join(cwd, ".oxlintrc.json") : resolve(cwd, config);
+  if (!/\.jsonc?$/.test(configPath) || !existsSync(configPath))
+    return null;
+  const declared = parseLooseJson(readFileSync(configPath, "utf8"));
+  const record = recordOf(declared);
+  const patterns = stringsOf(record["ignorePatterns"]);
+  if (patterns.some((one) => one.startsWith("!")))
+    return null;
+  const listed = spawnSync("git", ["ls-files", "-co", "--exclude-standard", "-z", "--", ...paths.length === 0 ? ["."] : paths], { cwd, encoding: "utf8", maxBuffer: 256 * 1024 * 1024 });
+  if (listed.status !== 0)
+    return null;
+  const root = dirname(configPath);
+  return {
+    candidates: listed.stdout.split("\x00").filter((path) => LINTED.test(path)).map((path) => resolve(cwd, path)).filter((path) => existsSync(path) && !ignoredBy(relative(root, path), patterns)).toSorted(),
+    overrides: (Array.isArray(record["overrides"]) ? record["overrides"] : []).map((one) => ({
+      files: stringsOf(recordOf(one)["files"]),
+      rules: recordOf(recordOf(one)["rules"])
+    })),
+    prefixes: prefixesOf(record["jsPlugins"]),
+    root,
+    rules: recordOf(record["rules"])
+  };
+};
+var isOff = (level) => {
+  const first = Array.isArray(level) ? level[0] : level;
+  return first === "off" || first === 0;
+};
+var designatedIn = (run, rule, accepts) => {
+  const keys = run.prefixes.map((prefix) => `${prefix}/${rule}`);
+  const base = keys.map((key) => run.rules[key]).find((level) => level !== undefined);
+  if (isOff(base))
+    return null;
+  const mentioning = run.overrides.filter((one) => keys.some((key) => (key in one.rules)));
+  return run.candidates.find((path) => {
+    const here = relative(run.root, path);
+    if (mentioning.some((one) => one.files.some((glob) => looselyMatches(here, glob)))) {
+      return false;
+    }
+    if (switchedOff(path))
+      return false;
+    try {
+      return accepts(path, readFileSync(path, "utf8"));
+    } catch {
+      return false;
+    }
+  }) ?? null;
+};
+var HOST = /[\\/]oxlint[\\/]bin[\\/]oxlint(?:\.\w+)?$/;
+var run;
+var designated = new Map;
+var designatedFile = (rule, salt = "", accepts = () => true) => {
+  if (run === undefined) {
+    const [, script = "", ...argv] = process.argv;
+    try {
+      run = HOST.test(script) ? runOf({ argv, cwd: process.cwd() }) : null;
+    } catch {
+      run = null;
+    }
+  }
+  if (run === null)
+    return null;
+  const key = `${rule}\x00${salt}`;
+  if (!designated.has(key))
+    designated.set(key, designatedIn(run, rule, accepts));
+  return designated.get(key) ?? null;
+};
+export {
+  designatedFile,
+  designatedIn,
+  runOf
+};

package/dist/rules/lib/shared-features.d.ts

@@ -1,13 +1,6 @@
-/**
- * Which features may be reached ACROSS feature boundaries is one repo's layout, so it is an
- * option — `organelle-dependency` and `cell-no-cross-feature-organelles` draw the same boundary
- * from two sides, on the same option, with the same default: the one name every feature-sliced
- * repo agrees on.
- */
 export type SharedFeaturesOptions = {
     sharedFeatures?: string[];
 };
-/** The JSON schema for `{ sharedFeatures?: string[] }`, read by both rules that take it. */
 export declare const SHARED_FEATURES_SCHEMA: {
     additionalProperties: boolean;
     properties: {
@@ -20,5 +13,4 @@ export declare const SHARED_FEATURES_SCHEMA: {
     };
     type: 'object';
 }[];
-/** Whether `importedFeature` is a DIFFERENT feature the options have not named as shared. */
 export declare const crossesFeatureBoundary: (importedFeature: string | undefined, ownFeature: string | undefined, options: SharedFeaturesOptions) => boolean;

package/dist/rules/lib/shared-features.js

@@ -1,14 +1,7 @@
 // src/rules/lib/shared-features.ts
+import { optionsBag, STRINGS } from "./schema.js";
 var DEFAULT_SHARED_FEATURES = ["shared"];
-var SHARED_FEATURES_SCHEMA = [
-  {
-    additionalProperties: false,
-    properties: {
-      sharedFeatures: { items: { type: "string" }, type: "array" }
-    },
-    type: "object"
-  }
-];
+var SHARED_FEATURES_SCHEMA = optionsBag({ sharedFeatures: STRINGS });
 var crossesFeatureBoundary = (importedFeature, ownFeature, options) => importedFeature !== undefined && importedFeature !== ownFeature && !new Set(options.sharedFeatures ?? DEFAULT_SHARED_FEATURES).has(importedFeature);
 export {
   SHARED_FEATURES_SCHEMA,

package/dist/rules/lib/state-sources.d.ts

@@ -0,0 +1,8 @@
+export declare const FORM_SOURCES: Set<string>;
+export declare const FORM_CONTEXT_IMPORT_PATTERN: RegExp;
+export declare const isProvidersSource: (source: string) => boolean;
+export interface StateSources {
+    forms: Set<string>;
+    stores: Set<string>;
+}
+export declare const stateSourcesOf: (file: string, seen?: Set<string>) => StateSources;

package/dist/rules/lib/state-sources.js

@@ -0,0 +1,55 @@
+// src/rules/lib/state-sources.ts
+import { STORE_HOOK_NAME } from "./hooks.js";
+import { isRelative } from "./imports.js";
+import { fileFor, readSource } from "./module-text.js";
+import { inTier } from "./tiers.js";
+var FORM_SOURCES = new Set(["react-hook-form"]);
+var FORM_CONTEXT_IMPORT_PATTERN = /FormContext$/;
+var isProvidersSource = (source) => /(?:^|\/)providers(?:\/|$)/.test(source);
+var IMPORT = /\bimport\s+(type\s+)?([^'";]*?)\s*from\s*['"]([^'"]+)['"]/g;
+var STORE_CALL = /(?<!function\s)\b(use\w+Store)\s*\(/g;
+var DEPTH = 4;
+var localsOf = (clause) => {
+  const named = /\{([^}]*)\}/.exec(clause)?.[1] ?? "";
+  const bare = clause.replace(/\{[^}]*\}/, "").replaceAll(",", " ").trim();
+  const fromBare = /^[A-Za-z_$][\w$]*$/.test(bare) ? [bare] : [];
+  const fromNamed = named.split(",").map((one) => one.trim()).filter((one) => one !== "" && !one.startsWith("type ")).map((one) => one.split(/\s+as\s+/).at(-1) ?? "");
+  return [...fromBare, ...fromNamed].filter((one) => one !== "");
+};
+var importsOf = (text) => [...text.matchAll(IMPORT)].flatMap((found) => found[1] === undefined ? [{ locals: localsOf(found[2] ?? ""), source: found[3] ?? "" }] : []);
+var isCalled = (text, name) => new RegExp(String.raw`(?<![\w$.])${name.replaceAll("$", String.raw`\$`)}\s*\(`).test(text);
+var gather = (file, seen, depth, into) => {
+  if (seen.has(file) || depth > DEPTH)
+    return;
+  seen.add(file);
+  const text = readSource(file);
+  if (text === undefined)
+    return;
+  for (const found of text.matchAll(STORE_CALL)) {
+    const name = found[1] ?? "";
+    if (STORE_HOOK_NAME.test(name))
+      into.stores.add(name);
+  }
+  for (const one of importsOf(text)) {
+    if (FORM_SOURCES.has(one.source))
+      into.forms.add(one.source);
+    else if (isProvidersSource(one.source) && one.locals.some((local) => FORM_CONTEXT_IMPORT_PATTERN.test(local))) {
+      into.forms.add(one.source);
+    } else if (isRelative(one.source) && one.locals.some((local) => isCalled(text, local))) {
+      const next = fileFor(file, one.source);
+      if (next !== undefined && inTier(next, "organelles"))
+        gather(next, seen, depth + 1, into);
+    }
+  }
+};
+var stateSourcesOf = (file, seen = new Set) => {
+  const into = { forms: new Set, stores: new Set };
+  gather(file, seen, 0, into);
+  return into;
+};
+export {
+  FORM_CONTEXT_IMPORT_PATTERN,
+  FORM_SOURCES,
+  isProvidersSource,
+  stateSourcesOf
+};

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

@@ -1,11 +1,10 @@
 import { type AnyNode } from './nodes.js';
+export declare const DEFAULT_STEP_FACTORIES: string[];
+export declare const DEFAULT_WORKFLOW_FACTORIES: string[];
+export declare const workflowFactoriesOf: (rule: string, configured: string[] | undefined) => Set<string>;
 export declare const stepFactoriesOf: (rule: string, configured: string[] | undefined) => Set<string>;
 export declare const isStepCall: (node: AnyNode, factories: ReadonlySet<string>) => boolean;
 export declare const argumentsOf: (node: AnyNode) => AnyNode[];
-/**
- * The step's config, told apart three ways: a bare string name (a call that can carry no config at
- * all), an object this rule can read, and an object it cannot — a spread, or a variable.
- */
 export type StepConfig = {
     kind: 'bare';
 } | {
@@ -15,5 +14,4 @@ export type StepConfig = {
     kind: 'unreadable';
 };
 export declare const configOf: (node: AnyNode) => StepConfig;
-/** Whatever names the step in a message: its literal name, its config's `name`, or the factory. */
 export declare const stepNameOf: (node: AnyNode, config: StepConfig) => string;

package/dist/rules/lib/steps.js

@@ -3,6 +3,8 @@ import { calleeNameOf } from "./nodes.js";
 import { propertiesOf, stringOf, valueOf } from "./objects.js";
 import { requireOption } from "./options.js";
 var DEFAULT_STEP_FACTORIES = ["createStep"];
+var DEFAULT_WORKFLOW_FACTORIES = ["createWorkflow"];
+var workflowFactoriesOf = (rule, configured) => new Set(requireOption(rule, configured ?? DEFAULT_WORKFLOW_FACTORIES, "workflowFactories"));
 var stepFactoriesOf = (rule, configured) => new Set(requireOption(rule, configured ?? DEFAULT_STEP_FACTORIES, "stepFactories"));
 var isStepCall = (node, factories) => {
   const callee = calleeNameOf(node);
@@ -29,9 +31,12 @@ var stepNameOf = (node, config) => {
   return calleeNameOf(node) ?? "a step";
 };
 export {
+  DEFAULT_STEP_FACTORIES,
+  DEFAULT_WORKFLOW_FACTORIES,
   argumentsOf,
   configOf,
   isStepCall,
   stepFactoriesOf,
-  stepNameOf
+  stepNameOf,
+  workflowFactoriesOf
 };

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

@@ -1,12 +1,3 @@
-/**
- * Reading the two places a component says what something looks like: `className` and `style`.
- *
- * Both conformance rules need the same three things — the string behind a `className`, the
- * `property: 'literal'` pairs behind a `style` object, and the arbitrary values a Tailwind class
- * carries in brackets — and neither of them needs the other's vocabulary. Written once here so the
- * two cannot disagree about what a className IS, which is the divergence the union of two plugins
- * was cut to end.
- */
 interface Node {
     type: string;
 }
@@ -20,46 +11,22 @@ interface Attribute extends Node {
 export interface OpeningElement extends Node {
     attributes?: Attribute[];
 }
-/** One `key: 'value'` pair of an inline style object, where both sides were written out. */
 interface StyleEntry {
     property: string;
     value: string;
 }
-/**
- * The literal text of a `className`, or nothing.
- *
- * A className assembled at runtime — `cn(base, isActive && 'x')`, a template with a hole — has no
- * one text, and guessing at one is how a rule reports a line the reader cannot find the value on.
- * Template quasis are joined because their static halves ARE written out, and a hardcoded colour
- * hides in them exactly as well as in a plain string.
- */
 export declare const classNameOf: (node: OpeningElement) => string | undefined;
-/**
- * The written-out entries of a `style={{ … }}` object.
- *
- * Only the pairs where BOTH halves are written out: a computed key or a value read from a variable
- * is a value this file cannot see, and reporting on it would be a guess. A spread is skipped for
- * the same reason.
- */
+export declare const staticClassNameOf: (node: OpeningElement) => string | undefined;
+export declare const keyOf: (property: {
+    computed?: boolean;
+    key?: Node & {
+        name?: string;
+        value?: unknown;
+    };
+}) => string | undefined;
 export declare const styleEntriesOf: (node: OpeningElement) => StyleEntry[];
-/**
- * Tailwind arbitrary values, as `[utility, inner]` pairs: `bg-[#fff]` → `['bg', '#fff']`.
- *
- * The utility half is returned because what is inside the brackets only means something with it:
- * `[tan]` is a colour after `text-` and a font after `font-`, and a rule that looked at the inner
- * text alone would have to guess which.
- */
+export declare const styleObjectOf: (node: OpeningElement) => Node | null;
 export declare const arbitraryValuesOf: (className: string) => [utility: string, inner: string][];
-/**
- * The custom properties the element sets on ITSELF, in its own `style`.
- *
- * A component that writes `style={{ '--pb-text': fromAProp }}` and reads `text-[var(--pb-text)]`
- * back is using a local alias: the variable is declared and consumed on one element and never
- * leaves it. Treating that as a component reaching around the theme reports an accepted convention,
- * which is how a rule earns the reputation that gets it switched off — measured on a consumer's
- * kit, where the pattern appears fifty times.
- */
 export declare const localVariablesOf: (node: OpeningElement) => Set<string>;
-/** The custom property a `var(--x)` names, or nothing. */
 export declare const variableOf: (value: string) => string | undefined;
 export {};