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

package/dist/rules/next-route-segment-is-thin-delegate.js

@@ -1,15 +1,15 @@
 // src/rules/next-route-segment-is-thin-delegate.ts
-import { walkOwnFunctionBody } from "./lib/nodes.js";
-import { isTestFile, normalise } from "./lib/paths.js";
-var DELEGATE_BASENAMES = new Set(["layout.tsx", "page.tsx", "template.tsx"]);
-var FUNCTIONS = new Set(["ArrowFunctionExpression", "FunctionDeclaration", "FunctionExpression"]);
-var FALLBACK_BASENAMES = new Set([
-  "default.tsx",
-  "error.tsx",
-  "global-error.tsx",
-  "loading.tsx",
-  "not-found.tsx"
-]);
+import { sourceOf } from "./lib/imports.js";
+import { isCapitalised, meaningfulChildren } from "./lib/jsx.js";
+import { FUNCTION_BOUNDARY_TYPES, walkOwnFunctionBody } from "./lib/nodes.js";
+import {
+  fileOf,
+  isTestFile,
+  normalise,
+  ROUTE_BODY_BASENAMES,
+  ROUTE_FALLBACK_BASENAMES
+} from "./lib/paths.js";
+import { APP_FOLDER, folderOf, TIERS } from "./lib/tiers.js";
 function collectReturnStatements(body) {
   const out = [];
   walkOwnFunctionBody(body, (node) => {
@@ -41,47 +41,42 @@ function describeReturn(arg) {
   return a.type ?? "unknown";
 }
 function bioFolderOf(source) {
-  const m = source.match(/\/(atoms|molecules|compounds|organelles|cells|tissues|lib|stores)(?:\/|$)/);
-  return m?.[1] ?? "unknown";
+  return folderOf(source, [...TIERS, "lib", "stores"]) ?? "unknown";
 }
 function isTissueSource(source) {
   if (!source)
     return false;
-  return /\/tissues(?:\/|$)/.test(source);
+  return folderOf(source, ["tissues"]) !== undefined;
 }
 var nextRouteSegmentIsThinDelegate = {
   create(context) {
     const normalized = normalise(context.filename);
     if (isTestFile(normalized))
       return {};
-    if (!/(?:^|\/)app\//.test(normalized))
+    if (!APP_FOLDER.test(normalized))
       return {};
-    const basename = normalized.split("/").pop() ?? "";
-    if (!DELEGATE_BASENAMES.has(basename))
+    const basename = fileOf(normalized);
+    if (!ROUTE_BODY_BASENAMES.has(basename))
       return {};
-    if (FALLBACK_BASENAMES.has(basename))
+    if (ROUTE_FALLBACK_BASENAMES.has(basename))
       return {};
     const importSources = new Map;
-    function isImportedPascalCase(tag) {
-      if (!tag)
-        return false;
-      if (!/^[A-Z]/.test(tag))
-        return false;
-      return importSources.has(tag);
-    }
-    function reportNonTissueDelegate(tag, ret) {
-      const source = importSources.get(tag) ?? "";
-      context.report({
-        data: {
-          bio: bioFolderOf(source),
-          file: basename,
-          source,
-          tag
-        },
-        messageId: "delegateMustBeTissue",
-        node: ret
-      });
-    }
+    const delegate = (tag, found, ret) => {
+      const source = tag === null ? undefined : importSources.get(tag);
+      if (tag === null || source === undefined || !isCapitalised(tag)) {
+        context.report({
+          data: { file: basename, found },
+          messageId: "mustBeThinDelegate",
+          node: ret
+        });
+      } else if (!isTissueSource(source)) {
+        context.report({
+          data: { bio: bioFolderOf(source), file: basename, source, tag },
+          messageId: "delegateMustBeTissue",
+          node: ret
+        });
+      }
+    };
     function checkReturn(arg, ret) {
       if (!arg || typeof arg !== "object")
         return;
@@ -89,28 +84,11 @@ var nextRouteSegmentIsThinDelegate = {
       if (a.type === "Literal" && a.value === null)
         return;
       if (a.type === "JSXElement") {
-        const tag = tagOf(arg);
-        if (!isImportedPascalCase(tag)) {
-          context.report({
-            data: { file: basename, found: describeReturn(arg) },
-            messageId: "mustBeThinDelegate",
-            node: ret
-          });
-          return;
-        }
-        const source = importSources.get(tag);
-        if (!isTissueSource(source)) {
-          reportNonTissueDelegate(tag, ret);
-        }
+        delegate(tagOf(arg), describeReturn(arg), ret);
         return;
       }
       if (a.type === "JSXFragment") {
-        const kids = arg.children ?? [];
-        const meaningful = kids.filter((c) => {
-          if (c.type === "JSXText")
-            return (c.value ?? "").trim().length > 0;
-          return true;
-        });
+        const meaningful = meaningfulChildren(arg.children);
         if (meaningful.length !== 1) {
           context.report({
             data: { count: String(meaningful.length), file: basename },
@@ -129,18 +107,7 @@ var nextRouteSegmentIsThinDelegate = {
           return;
         }
         const tagName = child.openingElement?.name?.type === "JSXIdentifier" ? child.openingElement.name.name ?? null : null;
-        if (!isImportedPascalCase(tagName)) {
-          context.report({
-            data: { file: basename, found: `fragment><${tagName ?? "?"}/></fragment` },
-            messageId: "mustBeThinDelegate",
-            node: ret
-          });
-          return;
-        }
-        const source = importSources.get(tagName);
-        if (!isTissueSource(source)) {
-          reportNonTissueDelegate(tagName, ret);
-        }
+        delegate(tagName, `fragment><${tagName ?? "?"}/></fragment`, ret);
         return;
       }
       context.report({
@@ -152,7 +119,7 @@ var nextRouteSegmentIsThinDelegate = {
     return {
       ExportDefaultDeclaration(node) {
         const decl = node.declaration;
-        if (!decl || !FUNCTIONS.has(decl.type))
+        if (!decl || !FUNCTION_BOUNDARY_TYPES.has(decl.type))
           return;
         if (decl.body !== undefined && decl.body.type !== "BlockStatement") {
           checkReturn(decl.body, decl.body);
@@ -162,7 +129,7 @@ var nextRouteSegmentIsThinDelegate = {
           checkReturn(ret.argument, ret);
       },
       ImportDeclaration(node) {
-        const source = node.source?.value ?? "";
+        const source = sourceOf(node) ?? "";
         for (const spec of node.specifiers ?? []) {
           const local = spec.local?.name;
           if (local)
@@ -186,6 +153,15 @@ returns is a tissue — a route that renders a cell directly wraps it in a tissu
     },
     schema: [],
     type: "problem"
+  },
+  probe() {
+    return {
+      path: "src/app/geonosis-probe/page.tsx",
+      source: `export default function Page() {
+  return <div>inline markup</div>
+}
+`
+    };
   }
 };
 var next_route_segment_is_thin_delegate_default = nextRouteSegmentIsThinDelegate;

package/dist/rules/no-brand-names.d.ts

@@ -1,8 +1,6 @@
 import { type Probe } from './lib/probe.js';
 interface Options {
-    /** Substrings stripped before the scan — a real demo-asset host, so a CDN URL never trips. */
     allowedSubstrings?: string[];
-    /** Brand names, matched case-insensitively on a word boundary. */
     brands?: string[];
 }
 declare const noBrandNames: {
@@ -52,13 +50,6 @@ declare const noBrandNames: {
         }[];
         type: 'problem';
     };
-    /**
-     * The brand list is a Medusa storefront's and the corpus says `acme`, so this rule reads as
-     * firing nowhere in the repo whose brands it was configured with — one of the two findings that
-     * opened this. The brand goes on a line of its own so no `allowedSubstrings` entry can strip it
-     * away: a CDN host is stripped before the scan, and a probe hiding inside one would prove the
-     * opposite of what it claims.
-     */
     probe(options: readonly unknown[]): Probe;
 };
 export default noBrandNames;

package/dist/rules/no-brand-names.js

@@ -2,10 +2,10 @@
 import * as fs from "node:fs";
 import { requireOption } from "./lib/options.js";
 import { normalise } from "./lib/paths.js";
+import { escapeForRegex } from "./lib/pattern-match.js";
 import { bagOf } from "./lib/probe.js";
 import { optionsBag, STRINGS } from "./lib/schema.js";
 var EXEMPT_PATH = /\/examples\//;
-var escapeForRegex = (value) => value.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&");
 var noBrandNames = {
   create(context) {
     const { allowedSubstrings = [], brands = [] } = context.options?.[0] ?? {};

package/dist/rules/no-card-shaped-div.d.ts

@@ -1,44 +1,5 @@
-interface BinaryExpression {
-    left: ClassNameExpression | null;
-    operator: string;
-    right: ClassNameExpression | null;
-    type: 'BinaryExpression';
-}
-type ClassNameExpression = {
-    type: string;
-} | BinaryExpression | JSXExpressionContainer | Literal | TemplateLiteral;
-interface JSXAttribute {
-    name?: {
-        name?: string;
-        type: string;
-    };
-    type: string;
-    value?: ClassNameExpression | null;
-}
-interface JSXExpressionContainer {
-    expression: ClassNameExpression | null;
-    type: 'JSXExpressionContainer';
-}
-interface JSXOpeningElement {
-    attributes: JSXAttribute[];
-    name: {
-        name?: string;
-        type: string;
-    };
-    type: 'JSXOpeningElement';
-}
-interface Literal {
-    type: 'Literal';
-    value: unknown;
-}
-interface TemplateLiteral {
-    quasis: {
-        value?: {
-            raw?: string;
-        };
-    }[];
-    type: 'TemplateLiteral';
-}
+import { type JsxOpeningElement } from './lib/jsx.js';
+import { type Probe } from './lib/probe.js';
 declare const noCardShapedDiv: {
     create(context: {
         filename: string;
@@ -50,7 +11,7 @@ declare const noCardShapedDiv: {
     }): {
         JSXOpeningElement?: undefined;
     } | {
-        JSXOpeningElement(node: JSXOpeningElement): void;
+        JSXOpeningElement(node: JsxOpeningElement): void;
     };
     fixShape: string;
     meta: {
@@ -63,5 +24,6 @@ declare const noCardShapedDiv: {
         schema: never[];
         type: 'problem';
     };
+    probe(): Probe;
 };
 export default noCardShapedDiv;

package/dist/rules/no-card-shaped-div.js

@@ -1,6 +1,7 @@
 // src/rules/no-card-shaped-div.ts
+import { attributeNamed, tagNameOf } from "./lib/jsx.js";
 import { normalise } from "./lib/paths.js";
-var biologicalHierarchyPattern = /\/(molecules|compounds|organelles|cells|layouts)\//;
+import { ABOVE_ATOMS_FOLDER } from "./lib/tiers.js";
 var MODIFIER_PREFIX = "(?:(?:dark|print|sm|md|lg|xl|2xl|first|last|odd|even):)?";
 var BORDER_PATTERN = new RegExp(`(?:^|\\s)${MODIFIER_PREFIX}border(?:\\s|$|-[1-9]\\d*(?:\\s|$))`);
 var BG_PATTERN = new RegExp(`(?:^|\\s)${MODIFIER_PREFIX}bg-(?:white|black|container|page|neutral-\\d+|gray-\\d+|zinc-\\d+|stone-\\d+|slate-\\d+)`);
@@ -35,13 +36,13 @@ function isCardLikeClassName(className) {
 var noCardShapedDiv = {
   create(context) {
     const filename = normalise(context.filename);
-    if (!biologicalHierarchyPattern.test(filename))
+    if (!ABOVE_ATOMS_FOLDER.test(filename))
       return {};
     return {
       JSXOpeningElement(node) {
-        if (node?.name?.type !== "JSXIdentifier" || node.name.name !== "div")
+        if (tagNameOf(node) !== "div")
           return;
-        const classAttr = node.attributes?.find((a) => a?.type === "JSXAttribute" && a?.name?.type === "JSXIdentifier" && a?.name?.name === "className");
+        const classAttr = attributeNamed(node, "className");
         if (!classAttr)
           return;
         const cls = extractClassNameString(classAttr.value ?? null);
@@ -65,6 +66,13 @@ styling into an atom that owns it.`,
     },
     schema: [],
     type: "problem"
+  },
+  probe() {
+    return {
+      path: "src/cells/geonosis-probe.tsx",
+      source: `export const GeonosisProbe = () => <div className="border bg-white" />
+`
+    };
   }
 };
 var no_card_shaped_div_default = noCardShapedDiv;

package/dist/rules/no-cross-feature-stores.d.ts

@@ -9,6 +9,7 @@ declare const noCrossFeatureStores: {
         }) => void;
     }): import('./lib/visitors.js').Visitor;
     fixShape: string;
+    probe?: ((options: readonly unknown[]) => import('./lib/probe.js').Probe | import('./lib/probe.js').ProbeTree) | undefined;
     meta: {
         docs: {
             description: string;

package/dist/rules/no-cross-feature-stores.js

@@ -1,8 +1,8 @@
 // src/rules/no-cross-feature-stores.ts
 import { directionRule } from "./lib/direction-rule.js";
+import { crossesFeatureBoundary } from "./lib/shared-features.js";
 var BIO_FILE_PATTERN = /(?:^|\/)features\/([^/]+)\/(cells|organelles)\/.*\.(tsx?|ts)$/;
 var STORE_IMPORT_PATTERN = /(?:^|\/|@\/)features\/([^/]+)\/stores\//;
-var SHARED_FEATURE = "shared";
 var storeFeatureOf = (source) => STORE_IMPORT_PATTERN.exec(source)?.[1];
 var noCrossFeatureStores = directionRule({
   data: (target, importer) => ({
@@ -15,14 +15,18 @@ var noCrossFeatureStores = directionRule({
   fixShape: `A cell or organelle in \`features/X/\` reads only \`features/X/stores/*\` and \`features/shared/stores/*\`.
 Another feature's store is a hidden coupling: let the data flow through the parent tissue as props
 instead. Type-only imports are exempt; \`export … from\` is not.`,
-  forbidden: (target, importer) => {
-    const importedFeature = storeFeatureOf(target.path);
-    return importedFeature !== undefined && importedFeature !== importer.feature && importedFeature !== SHARED_FEATURE;
-  },
+  forbidden: (target, importer) => crossesFeatureBoundary(storeFeatureOf(target.path), importer.feature, {}),
   messages: {
     crossFeatureStore: `"{{file}}" in feature "{{ownFeature}}" imports from another feature's store: "{{source}}" (feature: "{{importedFeature}}"). Cross-feature data must flow through the parent as props. Only features/{{ownFeature}}/stores/* and features/shared/stores/* are allowed here.`
   },
   messageId: "crossFeatureStore",
+  probe: () => ({
+    path: "src/features/geonosis/cells/geonosis-probe.tsx",
+    source: `import { other } from '@/features/geonosis-neighbour/stores/other'
+
+export const GeonosisProbe = other
+`
+  }),
   scope: (importer) => BIO_FILE_PATTERN.test(importer.path)
 });
 var no_cross_feature_stores_default = noCrossFeatureStores;

package/dist/rules/no-d1-transaction.d.ts

@@ -1,11 +1,7 @@
 import { type RuleContextWithOptions } from './lib/context.js';
+import type { Probe } from './lib/probe.js';
 interface Options {
-    /**
-     * Regex sources over the normalised filename: files inside `transacts` whose handle is still D1
-     * — the control plane's own modules, its schema.
-     */
     except?: string | string[];
-    /** Regex sources over the normalised filename: the files whose database transacts (a Postgres cell). */
     transacts?: string | string[];
 }
 type Node = {
@@ -65,5 +61,6 @@ declare const noD1Transaction: {
         }[];
         type: 'problem';
     };
+    probe(): Probe;
 };
 export default noD1Transaction;

package/dist/rules/no-d1-transaction.js

@@ -82,6 +82,13 @@ judged until the repo says which of its handles may transact.`,
       transacts: PATTERNS
     }),
     type: "problem"
+  },
+  probe() {
+    return {
+      path: "geonosis-probe-d1.ts",
+      source: `export const geonosisProbe = (db) => db.transaction(async () => 1)
+`
+    };
   }
 };
 var no_d1_transaction_default = noD1Transaction;

package/dist/rules/no-date-string-compare.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 noDateStringCompare: {
     create(context: RuleContextWithRawOptions): {
         BinaryExpression(node: AnyNode): void;
@@ -24,5 +25,6 @@ declare const noDateStringCompare: {
         }[];
         type: 'problem';
     };
+    probe(options: readonly unknown[]): Probe;
 };
 export default noDateStringCompare;

package/dist/rules/no-date-string-compare.js

@@ -1,7 +1,7 @@
 // src/rules/no-date-string-compare.ts
 import { calleeNameOf, propertyNameOf } from "./lib/nodes.js";
 import { bagOf } from "./lib/probe.js";
-import { STRING } from "./lib/schema.js";
+import { optionsBag, STRING } from "./lib/schema.js";
 var FIELD_PATTERN = "(?:_at|[a-z]At)$";
 var RELATIONAL = new Set(["<", "<=", ">", ">="]);
 var COMPARE = "localeCompare";
@@ -84,14 +84,20 @@ and a template with copy in it are both left alone. Which names hold a timestamp
     messages: {
       textOrder: 'Ordering "{{field}}" by {{ordering}} on a string compares the TEXT of a timestamp: a Date stringifies to "Fri Aug 30 2026 …", so this sorts by weekday name. Compare `.getTime()` or `Date.parse()`, or order on the ISO string the API returned.'
     },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: { fieldPattern: STRING },
-        type: "object"
-      }
-    ],
+    schema: optionsBag({ fieldPattern: STRING }),
     type: "problem"
+  },
+  probe(options) {
+    const field = "created_at";
+    const pattern = bagOf(options).fieldPattern ?? FIELD_PATTERN;
+    if (!new RegExp(pattern).test(field)) {
+      throw new Error(`no probe can be built: \`${field}\` is not a field the pattern ${pattern} holds a time in`);
+    }
+    return {
+      path: "geonosis-probe-order.ts",
+      source: `export const geonosisProbe = (left, right) => String(left.${field}).localeCompare(String(right.${field}))
+`
+    };
   }
 };
 var no_date_string_compare_default = noDateStringCompare;

package/dist/rules/no-duplicate-jsx-patterns.d.ts

@@ -1,4 +1,5 @@
 import { type RuleContext } from './lib/context.js';
+import { type Probe } from './lib/probe.js';
 interface JSXNode {
     attributes: {
         name?: {
@@ -51,5 +52,6 @@ declare const noDuplicateJsxPatterns: {
         schema: never[];
         type: 'problem';
     };
+    probe(): Probe;
 };
 export default noDuplicateJsxPatterns;

package/dist/rules/no-duplicate-jsx-patterns.js

@@ -1,6 +1,6 @@
 // src/rules/no-duplicate-jsx-patterns.ts
 import { normalise } from "./lib/paths.js";
-var COMPONENT_FILE_PATTERN = /(?:^|\/)(?:features\/[^/]+\/)?(compounds|organelles|cells|tissues|organs)\/.+\.tsx$/;
+import { COMPONENT_FILE_PATTERN } from "./lib/tiers.js";
 var MIN_CLASS_LENGTH = 30;
 var MIN_DUPLICATES = 3;
 var ITERATORS = new Set(["map", "flatMap", "forEach", "filter", "reduce"]);
@@ -95,6 +95,21 @@ their text are one component with a prop.`,
     },
     schema: [],
     type: "problem"
+  },
+  probe() {
+    return {
+      path: "src/cells/geonosis-probe.tsx",
+      source: `export function GeonosisProbe() {
+  return (
+    <div>
+      <p className="mb-[4px] text-[12px] leading-[16px] font-bold">a</p>
+      <p className="mb-[4px] text-[12px] leading-[16px] font-bold">b</p>
+      <p className="mb-[4px] text-[12px] leading-[16px] font-bold">c</p>
+    </div>
+  )
+}
+`
+    };
   }
 };
 var no_duplicate_jsx_patterns_default = noDuplicateJsxPatterns;

package/dist/rules/no-generic-utility-package.d.ts

@@ -1,8 +1,35 @@
 import { type RuleContextWithRawOptions } from './lib/context.js';
 import { type ProbeTree } from './lib/probe.js';
+interface Declared {
+    declarations?: {
+        id?: {
+            name?: string;
+        };
+    }[];
+    id?: {
+        name?: string;
+    };
+}
+interface Statement {
+    declaration?: Declared | null;
+    exported?: {
+        name?: string;
+        value?: string;
+    } | null;
+    source?: unknown;
+    specifiers?: {
+        exported?: {
+            name?: string;
+            value?: string;
+        };
+    }[];
+    type?: string;
+}
 declare const noGenericUtilityPackage: {
     create(context: RuleContextWithRawOptions): {
-        Program(node: unknown): void;
+        Program(node: {
+            body?: Statement[];
+        }): void;
     };
     fixShape: string;
     meta: {
@@ -10,11 +37,31 @@ declare const noGenericUtilityPackage: {
             description: string;
         };
         messages: {
+            beyondTheDoor: string;
             generic: string;
         };
         schema: {
             additionalProperties: boolean;
             properties: {
+                allow: {
+                    items: {
+                        additionalProperties: boolean;
+                        properties: {
+                            exports: {
+                                items: {
+                                    type: 'string';
+                                };
+                                type: 'array';
+                            };
+                            package: {
+                                type: 'string';
+                            };
+                        };
+                        required: string[];
+                        type: 'object';
+                    };
+                    type: 'array';
+                };
                 entries: {
                     items: {
                         type: 'string';
@@ -32,7 +79,6 @@ declare const noGenericUtilityPackage: {
         }[];
         type: 'problem';
     };
-    /** The manifest AND the entry: the name is in the manifest, and the finding lands on the entry. */
     probe(options: readonly unknown[]): ProbeTree;
 };
 export default noGenericUtilityPackage;

package/dist/rules/no-generic-utility-package.js

@@ -1,8 +1,8 @@
 // src/rules/no-generic-utility-package.ts
-import { readFileSync } from "node:fs";
+import { readManifest } from "./lib/module-text.js";
 import { normalise } from "./lib/paths.js";
 import { bagOf } from "./lib/probe.js";
-import { optionsBag, STRINGS } from "./lib/schema.js";
+import { optionsBag, STRING, STRINGS } from "./lib/schema.js";
 var NAMES = ["common", "helpers", "misc", "shared", "utils"];
 var ENTRIES = [
   "index.ts",
@@ -15,19 +15,41 @@ var ENTRIES = [
   "src/index.jsx"
 ];
 var MANIFEST = "package.json";
-var nameOf = (root) => {
-  try {
-    const manifest = JSON.parse(readFileSync(`${root}/${MANIFEST}`, "utf8"));
-    return typeof manifest.name === "string" ? manifest.name : null;
-  } catch {
-    return null;
+var exportedNames = (body) => body.flatMap((statement) => {
+  if (statement.type === "ExportDefaultDeclaration")
+    return ["default"];
+  if (statement.type === "ExportAllDeclaration") {
+    return [statement.exported?.name ?? statement.exported?.value ?? "*"];
   }
+  if (statement.type !== "ExportNamedDeclaration")
+    return [];
+  const declared = statement.declaration;
+  const fromDeclaration = [
+    declared?.id?.name,
+    ...(declared?.declarations ?? []).map((one) => one.id?.name)
+  ];
+  const fromSpecifiers = (statement.specifiers ?? []).map((one) => one.exported?.name ?? one.exported?.value);
+  return [...fromDeclaration, ...fromSpecifiers].filter((one) => one !== undefined);
+});
+var doorSchema = {
+  items: {
+    additionalProperties: false,
+    properties: { exports: STRINGS, package: STRING },
+    required: ["package", "exports"],
+    type: "object"
+  },
+  type: "array"
+};
+var nameOf = (root) => {
+  const name = readManifest(`${root}/${MANIFEST}`)?.name;
+  return typeof name === "string" ? name : null;
 };
 var noGenericUtilityPackage = {
   create(context) {
     const options = bagOf(context.options);
     const names = new Set(options.names ?? NAMES);
     const entries = options.entries ?? ENTRIES;
+    const allowed = options.allow ?? [];
     const filename = normalise(context.filename);
     return {
       Program(node) {
@@ -40,6 +62,18 @@ var noGenericUtilityPackage = {
         const last = name.split("/").at(-1) ?? "";
         if (!names.has(last))
           return;
+        const door = allowed.find((one) => one.package === name);
+        if (door !== undefined) {
+          const extra = exportedNames(node.body ?? []).filter((one) => !door.exports.includes(one));
+          if (extra.length === 0)
+            return;
+          context.report({
+            data: { extra: extra.join(", "), name, allowed: door.exports.join(", ") },
+            messageId: "beyondTheDoor",
+            node
+          });
+          return;
+        }
         context.report({ data: { generic: last, name }, messageId: "generic", node });
       }
     };
@@ -49,15 +83,20 @@ about what is inside, so nothing can be refused entry and everything arrives: we
 object, a time door. Split it by what each export is FOR and give each half a name that would make a
 wrong import obviously wrong — the formatting goes to the feature's own lib, the constants go beside
 their owner, a door gets its own package named after the thing it is a door to. Delete the rest. The
-anti-names are the \`names\` option and the default is the universal list, never a repo's vocabulary.`,
+anti-names are the \`names\` option and the default is the universal list, never a repo's vocabulary.
+One package may keep a generic name for one reason: \`allow: [{ package, exports }]\` names the door it
+survives to hold, and the package is clean while its entry exports nothing else — a second export is
+the finding. A star re-export cannot be vouched for and counts as one.`,
   meta: {
     docs: {
       description: "A workspace package named `utils` / `common` / `helpers` / `shared` / `misc` is named for nothing, so it accretes everything. Reported once, at the package entry, from the name in its own manifest."
     },
     messages: {
+      beyondTheDoor: 'The package "{{name}}" is allowed to hold {{allowed}} and nothing else, and it also exports {{extra}}. Move each of those to the package named for what it does.',
       generic: 'The package "{{name}}" is named for nothing: "{{generic}}" says what is inside to no one, so nothing can be refused entry and everything arrives. Split it by what each export is for and name each half after the thing it does.'
     },
     schema: optionsBag({
+      allow: doorSchema,
       entries: STRINGS,
       names: STRINGS
     }),