@geonosis/oxlint-plugin-biological-architecture 3.0.0 → 3.2.0

package/dist/rules/service-name-not-reserved.js

@@ -6,40 +6,7 @@ import { bagOf, firstOf } from "./lib/probe.js";
 import { optionsBag, STRINGS } from "./lib/schema.js";
 var RULE = "service-name-not-reserved";
 var DEFAULT_MODULE_FACTORIES = ["Module"];
-var MODULES_2_19 = [
-  "analytics",
-  "api_key",
-  "auth",
-  "cache",
-  "caching",
-  "cart",
-  "currency",
-  "customer",
-  "event_bus",
-  "file",
-  "fulfillment",
-  "index",
-  "inventory",
-  "link_modules",
-  "locking",
-  "notification",
-  "order",
-  "payment",
-  "pricing",
-  "product",
-  "promotion",
-  "rbac",
-  "region",
-  "sales_channel",
-  "search",
-  "settings",
-  "stock_location",
-  "store",
-  "tax",
-  "translation",
-  "user",
-  "workflows"
-];
+var MODULES_2_19 = "analytics api_key auth cache caching cart currency customer event_bus file fulfillment index inventory link_modules locking notification order payment pricing product promotion rbac region sales_channel search settings stock_location store tax translation user workflows".split(" ");
 var serviceNameNotReserved = {
   create(context) {
     const factories = new Set(requireOption(RULE, context.options?.[0]?.moduleFactories ?? DEFAULT_MODULE_FACTORIES, "moduleFactories"));

package/dist/rules/ssot-no-inline-facts.js

@@ -1,16 +1,13 @@
 // src/rules/ssot-no-inline-facts.ts
 import { PATTERNS, patternsOf } from "./lib/options.js";
-import { anyOf, normalise } from "./lib/paths.js";
+import { anyOf, HARNESS_PATHS, normalise } from "./lib/paths.js";
 import { optionsBag, STRINGS } from "./lib/schema.js";
 var CONVENTIONAL_OWNERS = [
   String.raw`/constants\.ts$`,
   String.raw`/lib/env\.ts$`,
   String.raw`/lib/routes\.ts$`,
-  String.raw`/__tests__/`,
-  String.raw`/scripts/`,
-  String.raw`/testing/`,
+  ...HARNESS_PATHS,
   String.raw`/test/`,
-  String.raw`/seeds/`,
   String.raw`/migrations/`,
   String.raw`\.config\.(ts|mjs|js)$`
 ];

package/dist/rules/ssot-no-process-env.js

@@ -1,14 +1,12 @@
 // src/rules/ssot-no-process-env.ts
 import { PATTERNS, patternsOf } from "./lib/options.js";
-import { anyOf, normalise } from "./lib/paths.js";
+import { anyOf, HARNESS_PATHS, normalise } from "./lib/paths.js";
+import { optionsBag } from "./lib/schema.js";
 var CONVENTIONAL_DOORS = [
   String.raw`/lib/env\.ts$`,
   String.raw`\.config\.(ts|mjs|js)$`,
-  String.raw`/scripts/`,
-  String.raw`/__tests__/`,
-  String.raw`/testing/`,
+  ...HARNESS_PATHS,
   String.raw`/test/`,
-  String.raw`/seeds/`,
   String.raw`\.(test|spec)\.[cm]?[jt]sx?$`
 ];
 var isProcessEnv = (node) => node.object.type === "Identifier" && node.object.name === "process" && node.property.type === "Identifier" && node.property.name === "env";
@@ -35,13 +33,7 @@ it in \`doors\` (regex sources over the path); tests, scripts, seeds and config
     messages: {
       envOutsideDoor: "process.env is read outside the env door. Add the variable to the env module (lib/env.ts, or the `doors` this repo names) and import `env` from there."
     },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: { doors: PATTERNS },
-        type: "object"
-      }
-    ],
+    schema: optionsBag({ doors: PATTERNS }),
     type: "problem"
   }
 };

package/dist/rules/step-declares-compensation-or-none.d.ts

@@ -1,7 +1,7 @@
 import { type RuleContextWithOptions } from './lib/context.js';
 import type { AnyNode } from './lib/nodes.js';
+import { type Probe } from './lib/probe.js';
 interface Options {
-    /** The call names that define a step. Default: Medusa's `createStep`. */
     stepFactories?: string[];
 }
 declare const stepDeclaresCompensationOrNone: {
@@ -30,5 +30,6 @@ declare const stepDeclaresCompensationOrNone: {
         }[];
         type: 'problem';
     };
+    probe(options: readonly unknown[]): Probe;
 };
 export default stepDeclaresCompensationOrNone;

package/dist/rules/step-declares-compensation-or-none.js

@@ -1,7 +1,15 @@
 // src/rules/step-declares-compensation-or-none.ts
 import { valueOf } from "./lib/objects.js";
+import { bagOf, firstOf } from "./lib/probe.js";
 import { optionsBag, STRINGS } from "./lib/schema.js";
-import { argumentsOf, configOf, isStepCall, stepFactoriesOf, stepNameOf } from "./lib/steps.js";
+import {
+  argumentsOf,
+  configOf,
+  DEFAULT_STEP_FACTORIES,
+  isStepCall,
+  stepFactoriesOf,
+  stepNameOf
+} from "./lib/steps.js";
 var RULE = "step-declares-compensation-or-none";
 var NO_COMPENSATION = "noCompensation";
 var WITH_COMPENSATION = 3;
@@ -44,6 +52,14 @@ variable — passes, since the flag may be in the base. Configure \`stepFactorie
       stepFactories: STRINGS
     }),
     type: "problem"
+  },
+  probe(options) {
+    const factory = firstOf(bagOf(options).stepFactories, DEFAULT_STEP_FACTORIES);
+    return {
+      path: "geonosis-probe-step.ts",
+      source: `export const geonosisProbe = ${factory}({ name: 'geonosis-probe' }, async () => 1)
+`
+    };
   }
 };
 var step_declares_compensation_or_none_default = stepDeclaresCompensationOrNone;

package/dist/rules/step-opens-its-own-cell.d.ts

@@ -1,37 +1,19 @@
 import { type RuleContextWithOptions } from './lib/context.js';
+import { type ModuleNode } from './lib/imports.js';
 import { type Probe } from './lib/probe.js';
 interface Options {
-    /** The module specifier the engine's `step` comes from — the OLD spelling, off unless set. */
     engine?: string;
-    /** The calls that build a durable host's flow. Default: the engine's own two. */
     hosts?: string[];
-    /** The key a run scope is declared under. Default: `perStep`. */
     scopeKey?: string;
-    /** Regex source, tested against the normalised filename: the tree whose steps must be durable. */
     within?: string;
-    /** Regex source: the one file allowed to reach `engine`, because it opens the handle. */
     wrapper?: string;
 }
-interface ImportNode {
-    importKind?: string;
-    loc?: unknown;
-    source: {
-        value: string;
-    };
-    specifiers?: {
-        imported?: {
-            name?: string;
-        };
-        importKind?: string;
-        type: string;
-    }[];
-}
 declare const stepOpensItsOwnCell: {
     create(context: RuleContextWithOptions<Options>): {
         Program?: undefined;
         ImportDeclaration?: undefined;
     } | {
-        ImportDeclaration(node: ImportNode): void;
+        ImportDeclaration(node: ModuleNode): void;
         Program(node: unknown): void;
     };
     fixShape: string;
@@ -72,11 +54,6 @@ declare const stepOpensItsOwnCell: {
         }[];
         type: 'problem';
     };
-    /**
-     * The probe is built for the spelling the OPTIONS select. A repo that named an `engine` is on the
-     * older one and is exercised by a saga reaching past its wrapper — which is also why the path has
-     * to land inside `within` and outside `wrapper`, the one file allowed to make that import.
-     */
     probe(options: readonly unknown[]): Probe;
 };
 export default stepOpensItsOwnCell;

package/dist/rules/step-opens-its-own-cell.js

@@ -1,8 +1,10 @@
 // src/rules/step-opens-its-own-cell.ts
+import { sourceOf } from "./lib/imports.js";
 import { calleeNameOf, walkNode } from "./lib/nodes.js";
-import { propertiesOf } from "./lib/objects.js";
+import { keyNameOf, propertiesOf } from "./lib/objects.js";
 import { requireOption } from "./lib/options.js";
-import { normalise } from "./lib/paths.js";
+import { normalise, fileOf } from "./lib/paths.js";
+import { readableSource } from "./lib/pattern-match.js";
 import { bagOf, firstOf, pathMatching } from "./lib/probe.js";
 import { optionsBag, STRING, STRINGS } from "./lib/schema.js";
 var RULE = "step-opens-its-own-cell";
@@ -10,7 +12,6 @@ var STEP = "step";
 var ACCEPTS = "{ within: string (required), hosts: string[], scopeKey: string, engine: string, wrapper: string }";
 var DEFAULT_HOSTS = ["createRuntime", "entrypointFor"];
 var DEFAULT_SCOPE_KEY = "perStep";
-var readable = (pattern) => pattern.replaceAll("\\", "").replace(/\$$/, "");
 var isHostCall = (node, hosts) => {
   const callee = calleeNameOf(node);
   return callee !== null && hosts.has(callee);
@@ -25,16 +26,10 @@ var opaque = (call, hosts) => {
   });
   return unreadable;
 };
-var namesKey = (node, key) => {
-  if (node.type !== "Property")
-    return false;
-  const named = node.key;
-  return named?.type === "Identifier" && named.name === key || named?.type === "Literal" && named.value === key;
-};
 var declaresScope = (call, scopeKey) => {
   let declared = false;
   walkNode(call, (inner) => {
-    if (namesKey(inner, scopeKey))
+    if (inner.type === "Property" && keyNameOf(inner) === scopeKey)
       declared = true;
   });
   return declared;
@@ -49,7 +44,7 @@ var stepOpensItsOwnCell = {
     const filename = normalise(context.filename);
     if (!new RegExp(within).test(filename))
       return {};
-    const file = filename.split("/").pop() ?? filename;
+    const file = fileOf(filename);
     const isWrapper = wrapper !== undefined && new RegExp(wrapper).test(filename);
     return {
       ImportDeclaration(node) {
@@ -57,7 +52,7 @@ var stepOpensItsOwnCell = {
           return;
         if (node.importKind === "type")
           return;
-        if (node.source.value !== engine)
+        if (sourceOf(node) !== engine)
           return;
         for (const specifier of node.specifiers ?? []) {
           if (specifier.type !== "ImportSpecifier")
@@ -70,7 +65,7 @@ var stepOpensItsOwnCell = {
             data: {
               engine,
               file,
-              wrapper: wrapper === undefined ? "the repo's own step wrapper" : readable(wrapper)
+              wrapper: wrapper === undefined ? "the repo's own step wrapper" : readableSource(wrapper)
             },
             messageId: "engineStep",
             node

package/dist/rules/store-route-scopes-tenant-data.js

@@ -1,38 +1,21 @@
 // src/rules/store-route-scopes-tenant-data.ts
-import { readFileSync } from "node:fs";
 import { resolveRelative, sourceOf } from "./lib/imports.js";
-import { stripComments } from "./lib/module-text.js";
+import { fileAt, readSource } from "./lib/module-text.js";
 import { walkNode } from "./lib/nodes.js";
+import { keyNameOf, stringOf } from "./lib/objects.js";
 import { normalise } from "./lib/paths.js";
+import { escapeForRegex } from "./lib/pattern-match.js";
 import { bagOf, firstOf, pathMatching } from "./lib/probe.js";
 import { optionsBag, STRINGS } from "./lib/schema.js";
 var ENTITIES = ["cart", "claim", "company", "customer", "employee", "order", "quote"];
 var ROUTES = [String.raw`/api/store/.*/route\.tsx?$`];
 var SCOPING_CALLS = ["auth_context", "actor_id", "customer_id", "company_id"];
 var ENTITY_KEY = "entity";
-var SUFFIXES = ["", ".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.tsx", "/index.js"];
-var keyNameOf = (node) => {
-  const key = node.key;
-  if (key?.type === "Identifier" && typeof key.name === "string")
-    return key.name;
-  return key?.type === "Literal" && typeof key.value === "string" ? key.value : null;
-};
-var stringValueOf = (node) => {
-  const value = node.value;
-  return value?.type === "Literal" && typeof value.value === "string" ? value.value : null;
-};
 var siblingSourceOf = (importer, source) => {
   if (!source.startsWith("."))
     return null;
-  const landed = resolveRelative(importer, source);
-  for (const suffix of SUFFIXES) {
-    try {
-      return stripComments(readFileSync(`${landed}${suffix}`, "utf8"));
-    } catch {
-      continue;
-    }
-  }
-  return null;
+  const file = fileAt(resolveRelative(importer, source));
+  return file === undefined ? null : readSource(file) ?? null;
 };
 var MODULE_NODES = new Set([
   "CallExpression",
@@ -41,15 +24,14 @@ var MODULE_NODES = new Set([
   "ImportDeclaration",
   "ImportExpression"
 ]);
-var escaped = (literal) => literal.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&");
 var readIn = (text, entities) => {
   for (const entity of entities) {
-    if (new RegExp(`${ENTITY_KEY}\\s*:\\s*['"\`]${escaped(entity)}['"\`]`).test(text))
+    if (new RegExp(`${ENTITY_KEY}\\s*:\\s*['"\`]${escapeForRegex(entity)}['"\`]`).test(text))
       return entity;
   }
   return null;
 };
-var namesAny = (text, names) => names.some((name) => new RegExp(`(?<![\\w$])${escaped(name)}(?![\\w$])`).test(text));
+var namesAny = (text, names) => names.some((name) => new RegExp(`(?<![\\w$])${escapeForRegex(name)}(?![\\w$])`).test(text));
 var storeRouteScopesTenantData = {
   create(context) {
     const options = bagOf(context.options);
@@ -67,7 +49,7 @@ var storeRouteScopesTenantData = {
         const sources = [];
         walkNode(program, (node) => {
           if (node.type === "Property" && keyNameOf(node) === ENTITY_KEY) {
-            const entity = stringValueOf(node);
+            const entity = stringOf(node.value);
             if (entity !== null && entities.includes(entity) && read === null) {
               read = { entity, node };
             }

package/dist/rules/subpath-over-barrel.d.ts

@@ -6,11 +6,6 @@ type Declared = {
     subpaths?: Record<string, string[]>;
 };
 interface Options {
-    /**
-     * A package to read differently from its exports: with `subpaths`, a hand-written map that
-     * REPLACES the one on disk; with a name alone, a package read off its exports even though it is
-     * not the repo's own.
-     */
     packages?: Declared[];
 }
 declare const subpathOverBarrel: {
@@ -24,6 +19,8 @@ declare const subpathOverBarrel: {
             description: string;
         };
         messages: {
+            nothingResolves: string;
+            unresolvedPackage: string;
             rootBarrel: string;
         };
         schema: {
@@ -55,11 +52,6 @@ declare const subpathOverBarrel: {
         }[];
         type: 'problem';
     };
-    /**
-     * One import of one name, at the root — the smallest shape that must fire. From the hand-written
-     * map when there is one; otherwise a private package planted under `node_modules` with one door,
-     * which is exactly what the default reads.
-     */
     probe(options: readonly unknown[]): Probe | {
         files: readonly Probe[];
     };

package/dist/rules/subpath-over-barrel.js

@@ -1,13 +1,32 @@
 // src/rules/subpath-over-barrel.ts
-import { doorsOf, resolvePackage } from "./lib/doors.js";
+import { statSync } from "node:fs";
+import { doorsOf, nodeModulesAbove, resolvePackage } from "./lib/doors.js";
 import { bagOf } from "./lib/probe.js";
 import { optionsBag, STRING } from "./lib/schema.js";
+import { hasWorkspaceAbove } from "./lib/workspace-members.js";
 var homesOf = (declared) => new Map(Object.entries(declared.subpaths ?? {}).flatMap(([subpath, names]) => names.map((name) => [name, subpath])));
 var read = new Map;
 var doorsFor = (manifest) => {
-  if (!read.has(manifest))
-    read.set(manifest, doorsOf(manifest));
-  return read.get(manifest)?.homes;
+  let stamp = 0;
+  try {
+    stamp = statSync(manifest).mtimeMs;
+  } catch {
+    stamp = 0;
+  }
+  const held = read.get(manifest);
+  if (held?.stamp === stamp)
+    return held.doors?.homes;
+  const doors = doorsOf(manifest);
+  read.set(manifest, { doors, stamp });
+  return doors?.homes;
+};
+var PACKAGE_ROOT = /^(?:@[^/]+\/)?[^/]+$/;
+var told = new Set;
+var firstTime = (key) => {
+  if (told.has(key))
+    return false;
+  told.add(key);
+  return true;
 };
 var namesTakenBy = (node) => {
   if (node.importKind === "type" || node.exportKind === "type")
@@ -32,16 +51,32 @@ var namesTakenBy = (node) => {
 var subpathOverBarrel = {
   create(context) {
     const declared = new Map((context.options?.[0]?.packages ?? []).filter((one) => typeof one.name === "string").map((one) => [one.name, one]));
-    const homesFor = (source) => {
+    const writtenByHand = [...declared.values()].some((one) => one.subpaths !== undefined);
+    const tell = (messageId, source, node) => {
+      if (firstTime(`${messageId}/${source}`)) {
+        context.report({ data: { package: source }, messageId, node });
+      }
+    };
+    const homesFor = (source, node) => {
       const written = declared.get(source);
       if (written?.subpaths !== undefined)
         return homesOf(written);
       const found = resolvePackage(context.filename, source);
-      if (found === undefined)
+      if (found === undefined) {
+        if (written !== undefined)
+          tell("unresolvedPackage", source, node);
+        else if (!writtenByHand && PACKAGE_ROOT.test(source) && !nodeModulesAbove(context.filename) && !hasWorkspaceAbove(context.filename)) {
+          tell("nothingResolves", "", node);
+        }
         return;
+      }
       if (!found.own && written === undefined)
         return;
-      return doorsFor(found.manifest);
+      const doors = doorsFor(found.manifest);
+      if ((doors === undefined || doors.size === 0) && written !== undefined) {
+        tell("unresolvedPackage", source, node);
+      }
+      return doors;
     };
     const fromRoot = (node) => {
       const source = node.source?.value;
@@ -50,7 +85,7 @@ var subpathOverBarrel = {
       const names = namesTakenBy(node);
       if (names === null || names.length === 0)
         return;
-      const home = homesFor(source);
+      const home = homesFor(source, node);
       if (home === undefined)
         return;
       const reached = new Set(names.map((name) => home.get(name)));
@@ -75,7 +110,9 @@ it to reach one pays for every other — at install, at bundle and at worker sta
 show for it. An import whose names span two subpaths is what the root is for and is left alone, as
 is a type-only import, which erases before any of that happens. The map is the package's own
 \`package.json\` \`exports\`, read for the repo's own packages (a workspace link, or
-private) with the names behind each door read off its entry file; nothing to configure. \`packages\`
+private, or a member of the workspace the repo declares in pnpm-workspace.yaml or package.json
+\`workspaces\`) with the names behind each door read off its entry file; a door written as a pattern
+(\`./icons/*\`) is expanded by listing the files its target names; nothing to configure. \`packages\`
 overrides it: \`{ name, subpaths: { document: ['Document', …] } }\` replaces the map for a package
 whose exports do not describe its real doors, and \`{ name }\` alone reads a third-party package's
 doors too.`,
@@ -84,6 +121,8 @@ doors too.`,
       description: "A root import whose names all live under one of the package's subpaths names the subpath instead. The root entry is the union of every subpath's module graph, so reaching one through it pays for all of them. Names spanning two subpaths, and type-only imports, are exempt. The map is read off the package's own `exports` for the repo's own packages; `packages` overrides it per package."
     },
     messages: {
+      nothingResolves: "No package resolves from this tree: there is no node_modules above this file and no workspace membership (pnpm-workspace.yaml, or package.json workspaces) to read the repo’s own packages from, so subpath-over-barrel reads no door and judges nothing here. Link the workspace, or declare its packages in the workspace manifest.",
+      unresolvedPackage: 'The package "{{package}}" is named in `packages` and no door could be read from it: nothing resolves it, or its `exports` name no file a root import could be placed under. subpath-over-barrel judges nothing for it until it resolves.',
       rootBarrel: "Every name imported here from `{{package}}` lives under `{{subpath}}`. Import from the subpath: the root entry re-exports all of them, so this file takes the union of every subpath’s module graph to reach one of them."
     },
     schema: optionsBag({

package/dist/rules/subscriber-declares-id.d.ts

@@ -2,7 +2,6 @@ import { type RuleContextWithOptions } from './lib/context.js';
 import type { AnyNode } from './lib/nodes.js';
 import { type Probe } from './lib/probe.js';
 interface Options {
-    /** Regex sources for the directories a subscriber lives in. Default: Medusa's `subscribers/`. */
     paths?: string[];
 }
 declare const subscriberDeclaresId: {
@@ -33,7 +32,6 @@ declare const subscriberDeclaresId: {
         }[];
         type: 'problem';
     };
-    /** A subscriber config with an event and no id, inside the configured subscriber tree. */
     probe(options: readonly unknown[]): Probe;
 };
 export default subscriberDeclaresId;

package/dist/rules/subscriber-declares-id.js

@@ -3,7 +3,7 @@ import { propertiesOf, valueOf } from "./lib/objects.js";
 import { requireOption } from "./lib/options.js";
 import { fileOf, normalise } from "./lib/paths.js";
 import { bagOf, firstOf, pathMatching } from "./lib/probe.js";
-import { STRINGS } from "./lib/schema.js";
+import { optionsBag, STRINGS } from "./lib/schema.js";
 var RULE = "subscriber-declares-id";
 var DEFAULT_PATHS = ["(?:^|/)subscribers/"];
 var CONFIG = "config";
@@ -54,13 +54,7 @@ other than \`subscribers/\`.`,
     messages: {
       inferred: 'Subscriber "{{file}}" declares no `config.context.subscriberId`, so Medusa infers one from its function or file name. Another subscriber that infers the same id dedupes this one — silently, with no error and no way to tell which handler survived. Write the id down.'
     },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: { paths: STRINGS },
-        type: "object"
-      }
-    ],
+    schema: optionsBag({ paths: STRINGS }),
     type: "problem"
   },
   probe(options) {

package/dist/rules/tables-declare-their-plane.d.ts

@@ -2,7 +2,6 @@ import { type RuleContextWithOptions } from './lib/context.js';
 import { type LiteralCall } from './lib/literal-call.js';
 import { type Probe } from './lib/probe.js';
 interface Options {
-    /** Regex source(s) over the filename: the schema tree whose tables must pick a plane. */
     schema?: string | string[];
 }
 declare const tablesDeclareTheirPlane: {
@@ -38,7 +37,6 @@ declare const tablesDeclareTheirPlane: {
         }[];
         type: 'problem';
     };
-    /** A table loose in the schema tree the options name — outside both planes by construction. */
     probe(options: readonly unknown[]): Probe;
 };
 export default tablesDeclareTheirPlane;

package/dist/rules/tables-declare-their-plane.js

@@ -1,11 +1,11 @@
 // src/rules/tables-declare-their-plane.ts
-import { literalNamedBy } from "./lib/literal-call.js";
+import { literalNamedBy, TABLE_CALLEES } from "./lib/literal-call.js";
 import { PATTERNS, patternsOf, requireOption } from "./lib/options.js";
 import { normalise } from "./lib/paths.js";
 import { bagOf, firstOf, pathMatching } from "./lib/probe.js";
+import { optionsBag } from "./lib/schema.js";
 var RULE = "tables-declare-their-plane";
 var ACCEPTS = "{ schema: string | string[] (regex sources over the filename: the schema tree) }";
-var tableCallees = ["sqliteTable", "pgTable"];
 var PLANES = /(?:^|\/)(?:control|tenant)\//;
 var tablesDeclareTheirPlane = {
   create(context) {
@@ -18,7 +18,7 @@ var tablesDeclareTheirPlane = {
       return {};
     return {
       CallExpression(node) {
-        for (const callee of tableCallees) {
+        for (const callee of TABLE_CALLEES) {
           const table = literalNamedBy(node, callee);
           if (table !== null)
             context.report({ data: { table }, messageId: "undeclared", node });
@@ -38,13 +38,7 @@ that once a run and judges nothing.`,
     messages: {
       undeclared: '"{{table}}" is declared outside control/ and tenant/ in the schema tree. Move it: control-plane tables are read by user, key or address at the edge; tenant tables carry the tenant key and live in a cell.'
     },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: { schema: PATTERNS },
-        type: "object"
-      }
-    ],
+    schema: optionsBag({ schema: PATTERNS }),
     type: "problem"
   },
   probe(options) {

package/dist/rules/tenant-tables-carry-org-id.d.ts

@@ -1,10 +1,8 @@
 import { type RuleContextWithOptions } from './lib/context.js';
-import type { LiteralCall } from './lib/literal-call.js';
+import { type LiteralCall } from './lib/literal-call.js';
 import { type Probe } from './lib/probe.js';
 interface Options {
-    /** Regex source(s), tested against the normalised filename: the tenant-plane schema tree. */
     tenant?: string | string[];
-    /** The column a tenant is scoped by. Default: `orgId`. */
     tenantKey?: string;
 }
 type ObjectExpression = {
@@ -60,7 +58,6 @@ declare const tenantTablesCarryOrgId: {
         }[];
         type: 'problem';
     };
-    /** A table in the tenant tree the options name, declared with no `orgId` column. */
     probe(options: readonly unknown[]): Probe;
 };
 export default tenantTablesCarryOrgId;

package/dist/rules/tenant-tables-carry-org-id.js

@@ -1,12 +1,11 @@
 // src/rules/tenant-tables-carry-org-id.ts
-import { PATTERNS, patternsOf, requireOption } from "./lib/options.js";
+import { TABLE_CALLEES } from "./lib/literal-call.js";
+import { DEFAULT_TENANT_KEY, PATTERNS, patternsOf, requireOption } from "./lib/options.js";
 import { normalise } from "./lib/paths.js";
 import { bagOf, firstOf, pathMatching } from "./lib/probe.js";
-import { STRING } from "./lib/schema.js";
-var DEFAULT_TENANT_KEY = "orgId";
+import { optionsBag, STRING } from "./lib/schema.js";
 var RULE = "tenant-tables-carry-org-id";
 var ACCEPTS = "{ tenant: string (a regex over the filename: the tenant-plane schema tree) }";
-var tableCallees = new Set(["sqliteTable", "pgTable"]);
 var carriesKey = (columns, key) => columns?.type === "ObjectExpression" && (columns.properties ?? []).some((property) => property.type === "Property" && (property.key?.name ?? property.key?.value) === key);
 var tenantTablesCarryOrgId = {
   create(context) {
@@ -17,7 +16,7 @@ var tenantTablesCarryOrgId = {
       return {};
     return {
       CallExpression(node) {
-        if (node.callee.type !== "Identifier" || !tableCallees.has(node.callee.name ?? ""))
+        if (node.callee.type !== "Identifier" || !TABLE_CALLEES.includes(node.callee.name ?? ""))
           return;
         const [name, columns] = node.arguments ?? [];
         const table = name && "value" in name && typeof name.value === "string" ? name.value : "this table";
@@ -38,13 +37,7 @@ enabled without it the rule reports that once a run and judges nothing.`,
     messages: {
       noOrgId: '"{{table}}" is a tenant table without a `{{key}}` column. Add one — or move it to the control plane if it is not one tenant\'s.'
     },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: { tenant: PATTERNS, tenantKey: STRING },
-        type: "object"
-      }
-    ],
+    schema: optionsBag({ tenant: PATTERNS, tenantKey: STRING }),
     type: "problem"
   },
   probe(options) {

package/dist/rules/test-no-clock-polling-for-promise-flips.d.ts

@@ -1,5 +1,6 @@
 import { type RuleContextWithRawOptions } from './lib/context.js';
 import { type AnyNode } from './lib/nodes.js';
+import { type Probe } from './lib/probe.js';
 declare const testNoClockPollingForPromiseFlips: {
     create(context: RuleContextWithRawOptions): {
         ArrowFunctionExpression?: undefined;
@@ -38,5 +39,6 @@ declare const testNoClockPollingForPromiseFlips: {
         }[];
         type: 'problem';
     };
+    probe(options: readonly unknown[]): Probe;
 };
 export default testNoClockPollingForPromiseFlips;