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

package/dist/presets.js

@@ -34,6 +34,7 @@ var FRONTEND = [
   "organelle-single-source",
   "tissue-must-compose",
   "tissue-no-data-props",
+  "tissue-no-fetch",
   "tissue-no-hooks",
   "tissue-no-organelles",
   "tissue-no-stores",
@@ -56,7 +57,11 @@ var BACKEND_WORKFLOWS = [
   "tables-declare-their-plane",
   "time-through-the-door"
 ];
-var BACKEND_D1 = ["no-d1-transaction", "worker-handles-are-scoped"];
+var BACKEND_D1 = [
+  "list-take-without-order",
+  "no-d1-transaction",
+  "worker-handles-are-scoped"
+];
 var BACKEND_WORKFLOWS_CF = ["step-opens-its-own-cell"];
 var RENAMED_TO = {
   "backend-sagaflow-cf": "backend-workflows-cf"
@@ -84,18 +89,22 @@ var BACKEND_MEDUSA = [
   "subscriber-declares-id",
   "unique-query-step-name"
 ];
+var WORKFLOW_RULES = new Set(BACKEND_WORKFLOWS);
 var FAILURE_PATHS = ["no-swallowed-catch"];
 var INTEGRATIONS = ["no-unregistered-plugin-dir"];
 var BACKEND_TRPC = ["router-schema-parity"];
 var TENANT_SCOPING = [
   "queries-require-org-scope",
-  "store-route-scopes-tenant-data",
   "tables-declare-their-plane",
   "tenant-tables-carry-org-id"
 ];
 var TOOLING = ["layer-walls", "no-generic-utility-package", "todo-names-its-plan"];
 var THEMEKIT = ["font-roles-only", "tokens-only-colors"];
-var TESTBED = ["no-mock-db-in-integration", "test-no-clock-polling-for-promise-flips"];
+var TESTBED = [
+  "hermetic-e2e-no-wall-clock-waits",
+  "no-mock-db-in-integration",
+  "test-no-clock-polling-for-promise-flips"
+];
 var PACKAGE_SUBPATHS = ["subpath-over-barrel"];
 var RULE_PREFIX = "biological-architecture";
 var asRules = (names) => Object.fromEntries(names.map((name) => [`${RULE_PREFIX}/${name}`, "error"]));
@@ -105,13 +114,35 @@ var COMMENT_CEILING = {
     "capitalized-comments": "error"
   }
 };
+var ACROSS_ENGINES = new Set(["list-take-without-order"]);
 var PRESUMED_ENGINES = [
   {
     engine: "Medusa",
     packages: ["@medusajs/framework", "@medusajs/medusa", "@medusajs/utils"],
-    rules: BACKEND_MEDUSA.filter((name) => !BACKEND_WORKFLOWS.includes(name))
+    rules: BACKEND_MEDUSA.filter((name) => !WORKFLOW_RULES.has(name) && !ACROSS_ENGINES.has(name))
   }
 ];
+var TIER_RULES = {
+  atoms: ["atom-no-deps"],
+  cells: [
+    "cell-must-be-stateful",
+    "cell-must-not-compose-cell",
+    "cell-no-cross-feature-organelles",
+    "cell-no-tissues",
+    "cells-folder-index-is-barrel"
+  ],
+  compounds: ["compound-must-be-stateless", "compound-no-stores"],
+  molecules: ["molecule-atoms-only", "molecule-must-compose"],
+  organelles: ["organelle-dependency", "organelle-single-source"],
+  tissues: [
+    "tissue-must-compose",
+    "tissue-no-data-props",
+    "tissue-no-fetch",
+    "tissue-no-hooks",
+    "tissue-no-organelles",
+    "tissue-no-stores"
+  ]
+};
 var PRESETS = {
   "backend-d1": { rules: asRules(BACKEND_D1) },
   "backend-medusa": { rules: asRules(BACKEND_MEDUSA) },
@@ -136,9 +167,68 @@ var PRESETS = {
   tooling: { rules: asRules(TOOLING) }
 };
 var rulesOfPreset = (preset) => Object.keys(PRESETS[preset].rules).filter((id) => id.startsWith(`${RULE_PREFIX}/`)).map((id) => id.slice(RULE_PREFIX.length + 1));
+var SECTIONS = {
+  frontend: {
+    blurb: "The tier rules every React repo gets. `recommended` is this preset.",
+    order: 1
+  },
+  "backend-workflows": {
+    blurb: "Workflows, the data layer, and single-source-of-truth. Storage-engine facts live in `backend-d1`.",
+    order: 2
+  },
+  "backend-d1": {
+    blurb: "Cloudflare D1 and cell-worker facts. False on any other engine — enable per repo.",
+    order: 3
+  },
+  "backend-workflows-cf": {
+    blurb: "The org workflow engine on Cloudflare Workflows. False next door — an inline run never hibernates.",
+    order: 4
+  },
+  "backend-medusa": { blurb: "Medusa's storefront route surface.", order: 5 },
+  "backend-trpc": {
+    blurb: "The router/schema mirror. A layout convention, not a framework fact — both directories are options, and in one consumer they are in different packages.",
+    order: 6
+  },
+  integrations: {
+    blurb: "The integration seam. Enforces nothing until the repo says where its plugin directories live and which file registers them.",
+    order: 7
+  },
+  "package-subpaths": {
+    blurb: "Where a package's names are imported from. The map is each of the repo's own packages' `exports`, read off disk; `packages` overrides it per package.",
+    order: 8
+  },
+  "tenant-scoping": {
+    blurb: "Every row placed, scoped and narrowed to one organisation.",
+    order: 9
+  },
+  themekit: {
+    blurb: "Conformance with a themekit: the component library never hardcodes what the theme decides. Inert until the repo says how its own tokens are spelled.",
+    order: 10
+  },
+  testbed: {
+    blurb: "The harness. Enforces nothing until the repo says where its integration suites live and what its database module is called.",
+    order: 11
+  },
+  "comment-ceiling": {
+    blurb: "The comment posture. Opt in per repo — the two source repos were defensible and opposite.",
+    order: 12
+  },
+  "failure-paths": {
+    blurb: "The modules a repo cannot afford to fail quietly on. Requires `paths` — which of them fetch and refresh; enabled without it the rule reports that once a run and judges nothing.",
+    order: 13
+  },
+  tooling: {
+    blurb: "A repo's own layers, walled. Enforces nothing until the walls are declared.",
+    order: 14
+  }
+};
+var isPresetName = (name) => (name in PRESETS);
+var presetSections = () => Object.entries(SECTIONS).flatMap(([name, doc]) => isPresetName(name) ? [{ ...doc, name }] : []).toSorted((a, b) => a.order - b.order);
 export {
   PRESETS,
   PRESUMED_ENGINES,
   RENAMED_TO,
+  TIER_RULES,
+  presetSections,
   rulesOfPreset
 };

package/dist/registry.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from './index.js';
+export declare const registered: Record<string, Rule>;

package/dist/registry.js

@@ -0,0 +1,172 @@
+// src/registry.ts
+import atomNoDeps from "./rules/atom-no-deps.js";
+import boundaryTimeIsPrimitive from "./rules/boundary-time-is-primitive.js";
+import cellMustBeStateful from "./rules/cell-must-be-stateful.js";
+import cellMustNotComposeCell from "./rules/cell-must-not-compose-cell.js";
+import cellNoCrossFeatureOrganelles from "./rules/cell-no-cross-feature-organelles.js";
+import cellNoTissues from "./rules/cell-no-tissues.js";
+import cellsFolderIndexIsBarrel from "./rules/cells-folder-index-is-barrel.js";
+import compoundMustBeStateless from "./rules/compound-must-be-stateless.js";
+import compoundNoStores from "./rules/compound-no-stores.js";
+import constantsInConstantsFile from "./rules/constants-in-constants-file.js";
+import dialectThroughTheSeam from "./rules/dialect-through-the-seam.js";
+import durableBodyReadsThroughSteps from "./rules/durable-body-reads-through-steps.js";
+import effectHookNaming from "./rules/effect-hook-naming.js";
+import emitDeclaresAttempts from "./rules/emit-declares-attempts.js";
+import fontRolesOnly from "./rules/font-roles-only.js";
+import hermeticE2eNoWallClockWaits from "./rules/hermetic-e2e-no-wall-clock-waits.js";
+import iconControlHasName from "./rules/icon-control-has-name.js";
+import layerWalls from "./rules/layer-walls.js";
+import listTakeWithoutOrder from "./rules/list-take-without-order.js";
+import maxCommentDensity from "./rules/max-comment-density.js";
+import moleculeAtomsOnly from "./rules/molecule-atoms-only.js";
+import moleculeMustCompose from "./rules/molecule-must-compose.js";
+import mutatingStepDeclaresRetry from "./rules/mutating-step-declares-retry.js";
+import namedWhenBlock from "./rules/named-when-block.js";
+import nextRouteSegmentIsThinDelegate from "./rules/next-route-segment-is-thin-delegate.js";
+import noBrandNames from "./rules/no-brand-names.js";
+import noCardShapedDiv from "./rules/no-card-shaped-div.js";
+import noCrossFeatureStores from "./rules/no-cross-feature-stores.js";
+import noD1Transaction from "./rules/no-d1-transaction.js";
+import noDateStringCompare from "./rules/no-date-string-compare.js";
+import noDuplicateJsxPatterns from "./rules/no-duplicate-jsx-patterns.js";
+import noGenericUtilityPackage from "./rules/no-generic-utility-package.js";
+import noHookInComponentDisguise from "./rules/no-hook-in-component-disguise.js";
+import noIndexCountAsExact from "./rules/no-index-count-as-exact.js";
+import noInertHiddenJsx from "./rules/no-inert-hidden-jsx.js";
+import noInlineDataInJsx from "./rules/no-inline-data-in-jsx.js";
+import noInvalidFeatureFolders from "./rules/no-invalid-feature-folders.js";
+import noLoaderSideEffectInIndexFile from "./rules/no-loader-side-effect-in-index-file.js";
+import noLogicInComponentFiles from "./rules/no-logic-in-component-files.js";
+import noMockDbInIntegration from "./rules/no-mock-db-in-integration.js";
+import noOrmOutsideDb from "./rules/no-orm-outside-db.js";
+import noRawHtmlAtoms from "./rules/no-raw-html-atoms.js";
+import noRawSqlOutsideAllowed from "./rules/no-raw-sql-outside-allowed.js";
+import noReactNamespace from "./rules/no-react-namespace.js";
+import noRenamedHtmlProps from "./rules/no-renamed-html-props.js";
+import noRenderPropReader from "./rules/no-render-prop-reader.js";
+import noRuntimeDeadAffordance from "./rules/no-runtime-dead-affordance.js";
+import noSwallowedCatch from "./rules/no-swallowed-catch.js";
+import noTrivialWrapperComponent from "./rules/no-trivial-wrapper-component.js";
+import noTsInBioFolders from "./rules/no-ts-in-bio-folders.js";
+import noTypeDefinitionsInComponents from "./rules/no-type-definitions-in-components.js";
+import noUnregisteredPluginDir from "./rules/no-unregistered-plugin-dir.js";
+import noVoidPort from "./rules/no-void-port.js";
+import organelleDependency from "./rules/organelle-dependency.js";
+import organelleSingleSource from "./rules/organelle-single-source.js";
+import pluginRouteNamespaced from "./rules/plugin-route-namespaced.js";
+import queriesRequireOrgScope from "./rules/queries-require-org-scope.js";
+import queueLoopIsTheLibrary from "./rules/queue-loop-is-the-library.js";
+import routeNoInlineMutation from "./rules/route-no-inline-mutation.js";
+import routerSchemaParity from "./rules/router-schema-parity.js";
+import serviceNameNotReserved from "./rules/service-name-not-reserved.js";
+import ssotNoInlineFacts from "./rules/ssot-no-inline-facts.js";
+import ssotNoProcessEnv from "./rules/ssot-no-process-env.js";
+import stepDeclaresCompensationOrNone from "./rules/step-declares-compensation-or-none.js";
+import stepOpensItsOwnCell from "./rules/step-opens-its-own-cell.js";
+import storeRouteScopesTenantData from "./rules/store-route-scopes-tenant-data.js";
+import subpathOverBarrel from "./rules/subpath-over-barrel.js";
+import subscriberDeclaresId from "./rules/subscriber-declares-id.js";
+import tablesDeclareTheirPlane from "./rules/tables-declare-their-plane.js";
+import tenantTablesCarryOrgId from "./rules/tenant-tables-carry-org-id.js";
+import testNoClockPollingForPromiseFlips from "./rules/test-no-clock-polling-for-promise-flips.js";
+import timeThroughTheDoor from "./rules/time-through-the-door.js";
+import tissueMustCompose from "./rules/tissue-must-compose.js";
+import tissueNoDataProps from "./rules/tissue-no-data-props.js";
+import tissueNoFetch from "./rules/tissue-no-fetch.js";
+import tissueNoHooks from "./rules/tissue-no-hooks.js";
+import tissueNoOrganelles from "./rules/tissue-no-organelles.js";
+import tissueNoStores from "./rules/tissue-no-stores.js";
+import todoNamesItsPlan from "./rules/todo-names-its-plan.js";
+import tokensOnlyColors from "./rules/tokens-only-colors.js";
+import uniqueQueryStepName from "./rules/unique-query-step-name.js";
+import workerHandlesAreScoped from "./rules/worker-handles-are-scoped.js";
+import zustandV5BestPractices from "./rules/zustand-v5-best-practices.js";
+var registered = {
+  "atom-no-deps": atomNoDeps,
+  "boundary-time-is-primitive": boundaryTimeIsPrimitive,
+  "cell-must-be-stateful": cellMustBeStateful,
+  "cell-must-not-compose-cell": cellMustNotComposeCell,
+  "cell-no-cross-feature-organelles": cellNoCrossFeatureOrganelles,
+  "cell-no-tissues": cellNoTissues,
+  "cells-folder-index-is-barrel": cellsFolderIndexIsBarrel,
+  "compound-must-be-stateless": compoundMustBeStateless,
+  "compound-no-stores": compoundNoStores,
+  "constants-in-constants-file": constantsInConstantsFile,
+  "dialect-through-the-seam": dialectThroughTheSeam,
+  "durable-body-reads-through-steps": durableBodyReadsThroughSteps,
+  "effect-hook-naming": effectHookNaming,
+  "emit-declares-attempts": emitDeclaresAttempts,
+  "font-roles-only": fontRolesOnly,
+  "hermetic-e2e-no-wall-clock-waits": hermeticE2eNoWallClockWaits,
+  "icon-control-has-name": iconControlHasName,
+  "layer-walls": layerWalls,
+  "list-take-without-order": listTakeWithoutOrder,
+  "max-comment-density": maxCommentDensity,
+  "molecule-atoms-only": moleculeAtomsOnly,
+  "molecule-must-compose": moleculeMustCompose,
+  "mutating-step-declares-retry": mutatingStepDeclaresRetry,
+  "named-when-block": namedWhenBlock,
+  "next-route-segment-is-thin-delegate": nextRouteSegmentIsThinDelegate,
+  "no-brand-names": noBrandNames,
+  "no-card-shaped-div": noCardShapedDiv,
+  "no-cross-feature-stores": noCrossFeatureStores,
+  "no-d1-transaction": noD1Transaction,
+  "no-date-string-compare": noDateStringCompare,
+  "no-duplicate-jsx-patterns": noDuplicateJsxPatterns,
+  "no-generic-utility-package": noGenericUtilityPackage,
+  "no-hook-in-component-disguise": noHookInComponentDisguise,
+  "no-index-count-as-exact": noIndexCountAsExact,
+  "no-inert-hidden-jsx": noInertHiddenJsx,
+  "no-inline-data-in-jsx": noInlineDataInJsx,
+  "no-invalid-feature-folders": noInvalidFeatureFolders,
+  "no-loader-side-effect-in-index-file": noLoaderSideEffectInIndexFile,
+  "no-logic-in-component-files": noLogicInComponentFiles,
+  "no-mock-db-in-integration": noMockDbInIntegration,
+  "no-orm-outside-db": noOrmOutsideDb,
+  "no-raw-html-atoms": noRawHtmlAtoms,
+  "no-raw-sql-outside-allowed": noRawSqlOutsideAllowed,
+  "no-react-namespace": noReactNamespace,
+  "no-renamed-html-props": noRenamedHtmlProps,
+  "no-render-prop-reader": noRenderPropReader,
+  "no-runtime-dead-affordance": noRuntimeDeadAffordance,
+  "no-swallowed-catch": noSwallowedCatch,
+  "no-trivial-wrapper-component": noTrivialWrapperComponent,
+  "no-ts-in-bio-folders": noTsInBioFolders,
+  "no-type-definitions-in-components": noTypeDefinitionsInComponents,
+  "no-unregistered-plugin-dir": noUnregisteredPluginDir,
+  "no-void-port": noVoidPort,
+  "organelle-dependency": organelleDependency,
+  "organelle-single-source": organelleSingleSource,
+  "plugin-route-namespaced": pluginRouteNamespaced,
+  "queries-require-org-scope": queriesRequireOrgScope,
+  "queue-loop-is-the-library": queueLoopIsTheLibrary,
+  "route-no-inline-mutation": routeNoInlineMutation,
+  "router-schema-parity": routerSchemaParity,
+  "service-name-not-reserved": serviceNameNotReserved,
+  "ssot-no-inline-facts": ssotNoInlineFacts,
+  "ssot-no-process-env": ssotNoProcessEnv,
+  "step-declares-compensation-or-none": stepDeclaresCompensationOrNone,
+  "step-opens-its-own-cell": stepOpensItsOwnCell,
+  "store-route-scopes-tenant-data": storeRouteScopesTenantData,
+  "subpath-over-barrel": subpathOverBarrel,
+  "subscriber-declares-id": subscriberDeclaresId,
+  "tables-declare-their-plane": tablesDeclareTheirPlane,
+  "tenant-tables-carry-org-id": tenantTablesCarryOrgId,
+  "test-no-clock-polling-for-promise-flips": testNoClockPollingForPromiseFlips,
+  "time-through-the-door": timeThroughTheDoor,
+  "tissue-must-compose": tissueMustCompose,
+  "tissue-no-data-props": tissueNoDataProps,
+  "tissue-no-fetch": tissueNoFetch,
+  "tissue-no-hooks": tissueNoHooks,
+  "tissue-no-organelles": tissueNoOrganelles,
+  "tissue-no-stores": tissueNoStores,
+  "todo-names-its-plan": todoNamesItsPlan,
+  "tokens-only-colors": tokensOnlyColors,
+  "unique-query-step-name": uniqueQueryStepName,
+  "worker-handles-are-scoped": workerHandlesAreScoped,
+  "zustand-v5-best-practices": zustandV5BestPractices
+};
+export {
+  registered
+};

package/dist/rules/atom-no-deps.d.ts

@@ -9,6 +9,7 @@ declare const atomNoDeps: {
         }) => 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/atom-no-deps.js

@@ -1,25 +1,24 @@
 // src/rules/atom-no-deps.ts
 import { directionRule } from "./lib/direction-rule.js";
-var FORBIDDEN_PATTERNS = [
-  /(?:^|\/)molecules\//,
-  /(?:^|\/)compounds\//,
-  /(?:^|\/)organelles\//,
-  /(?:^|\/)cells\//,
-  /(?:^|\/)tissues\//,
-  /(?:^|\/)stores\//,
-  /(?:^|[/@])domains(?:\/|$)/,
-  /\/app\//
-];
+import { inTiersAbove, APP_FOLDER, STORES_FOLDER } from "./lib/tiers.js";
+var FORBIDDEN_PATTERNS = [STORES_FOLDER, /(?:^|[/@])domains(?:\/|$)/, APP_FOLDER];
 var atomNoDeps = directionRule({
   description: "Atoms cannot import from molecules, compounds, organelles, cells, stores, or domains",
   fixShape: `Raw \`<button>\`, \`<input>\`, or a \`<div>\` with border + background in levels 2-6 belongs in an atom.
 An atom imports nothing above itself — no molecule, compound, organelle, cell, tissue, store or domain,
 and that includes \`export … from\`. If an atom needs a shared constant, the constant moves down to the atom
 tier or into a plain \`lib/\` module, never the other way round.`,
-  forbidden: (target) => FORBIDDEN_PATTERNS.some((pattern) => pattern.test(target.path)),
+  forbidden: (target) => inTiersAbove(target.path, "atoms") || FORBIDDEN_PATTERNS.some((pattern) => pattern.test(target.path)),
   messages: {
     forbidden: "Atoms cannot import from {{source}}. Atoms are the lowest level and must not depend on higher-level components."
   },
+  probe: () => ({
+    path: "src/atoms/geonosis-probe.tsx",
+    source: `import { Up } from '../molecules/geonosis-up'
+
+export const GeonosisProbe = Up
+`
+  }),
   scope: "atoms",
   typeOnly: "visit"
 });

package/dist/rules/boundary-time-is-primitive.d.ts

@@ -1,9 +1,7 @@
 import { type RuleContextWithOptions } from './lib/context.js';
 import { type Probe } from './lib/probe.js';
 interface Options {
-    /** The modules that may name these types in an exported signature, each written out in full. */
     doors?: string[];
-    /** The type names that must not cross an exported boundary. A namespace covers its members. */
     types?: string[];
 }
 declare const boundaryTimeIsPrimitive: {
@@ -46,11 +44,6 @@ declare const boundaryTimeIsPrimitive: {
         }[];
         type: 'problem';
     };
-    /**
-     * A file that is not one of the declared doors, exporting the repo's own first forbidden type.
-     * `String(at)` rather than a second annotation: one finding is the claim, and a probe that fired
-     * twice would pass a count nobody asked for.
-     */
     probe(options: readonly unknown[]): Probe;
 };
 export default boundaryTimeIsPrimitive;

package/dist/rules/cell-must-be-stateful.d.ts

@@ -1,11 +1,10 @@
 import { type RuleContext } from './lib/context.js';
+import { type Probe } from './lib/probe.js';
 declare const cellMustBeStateful: {
     create(context: RuleContext): {
         Program?: undefined;
-        'Program:exit'?: undefined;
     } | {
         Program(node: unknown): void;
-        'Program:exit'(): void;
     };
     fixShape: string;
     meta: {
@@ -18,5 +17,6 @@ declare const cellMustBeStateful: {
         schema: never[];
         type: 'problem';
     };
+    probe(): Probe;
 };
 export default cellMustBeStateful;

package/dist/rules/cell-must-be-stateful.js

@@ -1,7 +1,8 @@
 // src/rules/cell-must-be-stateful.ts
 import * as fs from "node:fs";
-import { normalise } from "./lib/paths.js";
+import { normalise, fileOf } from "./lib/paths.js";
 import { launderedHomesOf } from "./lib/reexports.js";
+import { CELL_PRIVATE_SIBLING, inTier } from "./lib/tiers.js";
 var STATE_SIGNATURE = /\buse[A-Z]\w*\s*\(|from\s+['"][^'"]*\/organelles(?:\/|['"])|from\s+['"][^'"]*\/stores?(?:\/|['"])|createContext\s*\(/;
 var SIBLING_SUFFIXES = [
   ".tsx",
@@ -15,41 +16,32 @@ var SIBLING_SUFFIXES = [
   ".data.tsx",
   ".steps.tsx"
 ];
-var PRIVATE_OR_NON_ENTRY = /\.(parts|sections|layouts|types|icons|sidebar|summary|form|data|steps|stories|test|spec)\.tsx$/;
-function familyHasState(mainFile) {
-  const stem = mainFile.replace(/\.tsx$/, "");
-  for (const file of [mainFile, ...SIBLING_SUFFIXES.map((suffix) => stem + suffix)]) {
-    try {
-      if (fs.existsSync(file) && STATE_SIGNATURE.test(fs.readFileSync(file, "utf8"))) {
-        return true;
-      }
-    } catch {}
+var readable = (file) => {
+  try {
+    return fs.readFileSync(file, "utf8");
+  } catch {
+    return "";
   }
-  return false;
-}
+};
+var familyHasState = (mainFile) => {
+  const stem = mainFile.replace(/\.tsx$/, "");
+  return [mainFile, ...SIBLING_SUFFIXES.map((suffix) => stem + suffix)].some((file) => STATE_SIGNATURE.test(readable(file)));
+};
 var cellMustBeStateful = {
   create(context) {
     const normalized = normalise(context.filename);
-    const base = normalized.split("/").pop() || "";
-    const isCellEntrypoint = /(?:^|\/)cells\//.test(normalized) && base.endsWith(".tsx") && base !== "index.tsx" && !PRIVATE_OR_NON_ENTRY.test(base);
+    const base = fileOf(normalized);
+    const isCellEntrypoint = inTier(normalized, "cells") && base.endsWith(".tsx") && base !== "index.tsx" && !CELL_PRIVATE_SIBLING.test(base);
     if (!isCellEntrypoint)
       return {};
     const laundered = launderedHomesOf(context.filename);
     if (laundered !== undefined && laundered.length === 0)
       return {};
     const judged = laundered ?? [normalized];
-    let programNode = null;
     return {
       Program(node) {
-        programNode = node;
-      },
-      "Program:exit"() {
         if (!judged.every((file) => familyHasState(normalise(file)))) {
-          context.report({
-            data: { file: base },
-            messageId: "shouldBeCompound",
-            node: programNode
-          });
+          context.report({ data: { file: base }, messageId: "shouldBeCompound", node });
         }
       }
     };
@@ -67,6 +59,15 @@ stateful, put the store read or the organelle in it rather than taking the data
     },
     schema: [],
     type: "problem"
+  },
+  probe() {
+    return {
+      path: "src/cells/geonosis-probe.tsx",
+      source: `export function GeonosisProbe({ label }: { label: string }) {
+  return <div>{label}</div>
+}
+`
+    };
   }
 };
 var cell_must_be_stateful_default = cellMustBeStateful;

package/dist/rules/cell-must-not-compose-cell.d.ts

@@ -9,6 +9,7 @@ declare const cellMustNotComposeCell: {
         }) => 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/cell-must-not-compose-cell.js

@@ -1,8 +1,8 @@
 // src/rules/cell-must-not-compose-cell.ts
 import { isCellsBarrel } from "./lib/cells-barrel.js";
 import { directionRule } from "./lib/direction-rule.js";
+import { inTier } from "./lib/tiers.js";
 var cellStem = (filePath) => filePath.replace(/\.[jt]sx?$/, "").replace(/\.(parts|sections|summary|layouts|icons|types|hooks|utils|context|store|sidebar|data|config)$/i, "");
-var IN_CELLS = /(?:^|\/)cells\//;
 var cellMustNotComposeCell = directionRule({
   data: (target, importer) => ({ currentFile: importer.file, importedFile: target.file }),
   description: "Cells must not import from any other cell anywhere in the repo. No same-feature exception, no shared/document/charts exception. Cells compose only atoms, molecules, compounds, and organelles. Type-only imports are allowed.",
@@ -17,11 +17,18 @@ the other. A stateless adapter between cells is a tissue — it may take the dat
 component (\`invoice-editor.parts.tsx\` from \`invoice-editor.tsx\`) are one cell and are fine. The
 barrels \`cells/index.ts\`, \`cells/dynamic.ts\` and \`cells/dynamic.tsx\` are exempt — re-exporting
 siblings is the shape \`cells-folder-index-is-barrel\` requires of them.`,
-  forbidden: (target, importer) => IN_CELLS.test(target.path) && cellStem(target.file) !== cellStem(importer.file),
+  forbidden: (target, importer) => inTier(target.path, "cells") && cellStem(target.file) !== cellStem(importer.file),
   messages: {
     forbidden: 'Cell "{{currentFile}}" imports from another cell "{{importedFile}}". Cells never compose other cells. Decompose: if this is arrangement, move the parent to tissues/. If the import is a stateless display, move the child to compounds/. If the child is a store adapter, move it to organelles/.'
   },
-  scope: (importer) => IN_CELLS.test(importer.path) && !isCellsBarrel(importer.path)
+  probe: () => ({
+    path: "src/cells/geonosis-probe.tsx",
+    source: `import { Other } from './geonosis-other'
+
+export const GeonosisProbe = Other
+`
+  }),
+  scope: (importer) => inTier(importer.path, "cells") && !isCellsBarrel(importer.path)
 });
 var cell_must_not_compose_cell_default = cellMustNotComposeCell;
 export {

package/dist/rules/cell-no-cross-feature-organelles.d.ts

@@ -9,6 +9,7 @@ declare const cellNoCrossFeatureOrganelles: {
         }) => 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/cell-no-cross-feature-organelles.js

@@ -28,6 +28,13 @@ aliased sources are judged alike: \`../../billing/organelles/totals\` lands wher
     forbidden: `Cell "{{file}}" in feature "{{ownFeature}}" imports "{{source}}", an organelle of feature "{{importedFeature}}". A cell hosts its own feature's organelles; another feature's state arrives as props from the tissue above. Only features/{{ownFeature}}/organelles/* and the shared features are allowed here.`
   },
   optionsFrom: (raw) => raw ?? {},
+  probe: () => ({
+    path: "src/features/geonosis/cells/geonosis-probe.tsx",
+    source: `import { other } from '@/features/geonosis-neighbour/organelles/other'
+
+export const GeonosisProbe = other
+`
+  }),
   scope: "cells",
   schema: SHARED_FEATURES_SCHEMA
 });

package/dist/rules/cell-no-tissues.d.ts

@@ -9,6 +9,7 @@ declare const cellNoTissues: {
         }) => 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/cell-no-tissues.js

@@ -1,20 +1,24 @@
 // src/rules/cell-no-tissues.ts
 import { directionRule } from "./lib/direction-rule.js";
-var HIGHER_LEVEL_PATTERNS = [
-  /(?:^|\/)(?:features\/[^/]+\/)?tissues\//,
-  /(?:^|\/)(?:features\/[^/]+\/)?organs\//,
-  /(?:^|\/)layouts\//,
-  /(?:^|\/)app\//
-];
+import { matchesAny } from "./lib/paths.js";
+import { APP_FOLDER, inOrgans, inTier, LAYOUTS_FOLDER } from "./lib/tiers.js";
+var OTHER_HIGHER_LEVEL_FOLDERS = [LAYOUTS_FOLDER, APP_FOLDER];
 var cellNoTissues = directionRule({
   description: "Cells cannot import tissues, organs, or app route files. Direction is wrong: tissues compose cells (not the reverse), and organs compose tissues and cells.",
   fixShape: `A cell cannot import a tissue, an organ, a layout or an app route — that is the direction
 inverted. If a cell needs a layout around it, take the layout as \`children\` and let a tissue arrange
 both. Type-only imports are exempt; \`export … from\` is not.`,
-  forbidden: (target) => HIGHER_LEVEL_PATTERNS.some((pattern) => pattern.test(target.path)),
+  forbidden: (target) => inTier(target.path, "tissues") || inOrgans(target.path) || matchesAny(OTHER_HIGHER_LEVEL_FOLDERS, target.path),
   messages: {
     forbidden: 'Cell "{{file}}" cannot import higher-level component "{{source}}". Direction is wrong: tissues/organs compose cells, not the reverse. If this cell needs to render a layout-like wrapper, the wrapper should be a compound, or this cell should be promoted.'
   },
+  probe: () => ({
+    path: "src/cells/geonosis-probe.tsx",
+    source: `import { Up } from '../tissues/geonosis-up'
+
+export const GeonosisProbe = Up
+`
+  }),
   scope: "cells"
 });
 var cell_no_tissues_default = cellNoTissues;

package/dist/rules/cells-folder-index-is-barrel.d.ts

@@ -1,24 +1,24 @@
 import { type RuleContext } from './lib/context.js';
-interface ProgramNode {
-    body: Statement[];
-    loc?: unknown;
-    type: 'Program';
-}
+import { type Probe } from './lib/probe.js';
 interface Statement {
-    declaration?: unknown;
     importKind?: string;
-    loc?: unknown;
     source?: {
-        value: string;
+        value?: unknown;
     } | null;
-    specifiers?: unknown[];
+    specifiers?: {
+        exported?: {
+            name?: unknown;
+        };
+    }[];
     type: string;
 }
 declare const cellsFolderIndexIsBarrel: {
     create(context: RuleContext): {
         Program?: undefined;
     } | {
-        Program(node: ProgramNode): void;
+        Program(node: {
+            body: Statement[];
+        }): void;
     };
     fixShape: string;
     meta: {
@@ -26,10 +26,12 @@ declare const cellsFolderIndexIsBarrel: {
             description: string;
         };
         messages: {
+            organelleWearingCells: string;
             notBarrel: string;
         };
         schema: never[];
         type: 'problem';
     };
+    probe(): Probe;
 };
 export default cellsFolderIndexIsBarrel;