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

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;

package/dist/rules/cells-folder-index-is-barrel.js

@@ -1,46 +1,68 @@
 // src/rules/cells-folder-index-is-barrel.ts
 import { isCellsBarrel } from "./lib/cells-barrel.js";
-import { normalise } from "./lib/paths.js";
-function describeStatement(stmt) {
-  switch (stmt.type) {
-    case "ClassDeclaration":
-      return "a class declaration";
-    case "ExportDefaultDeclaration":
-      return "a default export declaration";
-    case "ExportNamedDeclaration":
-      return "a named export declaration (not a re-export)";
-    case "ExpressionStatement":
-      return "a top-level expression statement";
-    case "FunctionDeclaration":
-      return "a function declaration";
-    case "ImportDeclaration":
-      return "a side-effect import";
-    case "VariableDeclaration":
-      return "a variable declaration";
-    default:
-      return `a ${stmt.type} statement`;
-  }
-}
+import { landingsOf } from "./lib/landing.js";
+import { normalise, fileOf } from "./lib/paths.js";
+import { inTier } from "./lib/tiers.js";
+var DESCRIPTIONS = {
+  ClassDeclaration: "a class declaration",
+  ExportDefaultDeclaration: "a default export declaration",
+  ExportNamedDeclaration: "a named export declaration (not a re-export)",
+  ExpressionStatement: "a top-level expression statement",
+  FunctionDeclaration: "a function declaration",
+  ImportDeclaration: "a side-effect import",
+  VariableDeclaration: "a variable declaration"
+};
+var reexportedFrom = (statement) => (statement.type === "ExportNamedDeclaration" || statement.type === "ExportAllDeclaration") && typeof statement.source?.value === "string" ? statement.source.value : undefined;
+var namesOf = (statement) => statement.type === "ExportAllDeclaration" ? [] : (statement.specifiers ?? []).flatMap((one) => typeof one.exported?.name === "string" ? [one.exported.name] : []);
+var landsInOrganelles = (filename, statement, source) => {
+  const landed = landingsOf(filename, source, namesOf(statement));
+  if (landed.door === undefined)
+    return inTier(`${source}/`, "organelles");
+  return [landed.door, ...landed.homes.values()].some((file) => inTier(file, "organelles"));
+};
 var cellsFolderIndexIsBarrel = {
   create(context) {
     const filename = context.filename;
     const normalized = normalise(filename);
-    if (!isCellsBarrel(normalized))
-      return {};
-    const shortName = normalized.split("/").pop() || normalized;
+    const shortName = fileOf(normalized);
+    if (!isCellsBarrel(normalized)) {
+      if (!inTier(normalized, "cells"))
+        return {};
+      return {
+        Program(node) {
+          const sources = node.body.map(reexportedFrom);
+          if (sources.length === 0 || sources.some((one) => one === undefined))
+            return;
+          const names = node.body.flatMap(namesOf);
+          const organelle = node.body.find((statement) => landsInOrganelles(filename, statement, reexportedFrom(statement) ?? ""));
+          if (organelle === undefined)
+            return;
+          context.report({
+            data: {
+              file: shortName,
+              names: names.length > 0 ? names.join(", ") : "*",
+              source: reexportedFrom(organelle) ?? ""
+            },
+            messageId: "organelleWearingCells",
+            node: organelle
+          });
+        }
+      };
+    }
     return {
       Program(node) {
-        for (const stmt of node.body) {
-          if (stmt.type === "ExportAllDeclaration")
-            continue;
-          if (stmt.type === "ExportNamedDeclaration" && stmt.source)
-            continue;
-          if (stmt.type === "ImportDeclaration" && stmt.importKind === "type")
+        for (const statement of node.body) {
+          const isReexport = reexportedFrom(statement) !== undefined;
+          if (isReexport || statement.type === "ImportDeclaration" && statement.importKind === "type") {
             continue;
+          }
           context.report({
-            data: { file: shortName, kind: describeStatement(stmt) },
+            data: {
+              file: shortName,
+              kind: DESCRIPTIONS[statement.type] ?? `a ${statement.type} statement`
+            },
             messageId: "notBarrel",
-            node: stmt
+            node: statement
           });
         }
       }
@@ -48,16 +70,26 @@ var cellsFolderIndexIsBarrel = {
   },
   fixShape: `\`cells/index.ts\` and \`cells/dynamic.ts\` are barrels: \`export … from\` lines and nothing else. No
 function, class or variable declaration, no side-effect import. Logic that wants to live in the
-barrel belongs in a cell file the barrel re-exports.`,
+barrel belongs in a cell file the barrel re-exports. A file in \`cells/\` that is not a barrel and only
+re-exports an organelle is that organelle wearing the cell folder, and every parent that composes it
+becomes a cell composing a cell: import the organelle where it is used, or write the cell here.`,
   meta: {
     docs: {
-      description: "Barrel files under cells/ (index.ts, dynamic.ts, dynamic.tsx) must contain ONLY re-export statements. Component definitions belong in their own file."
+      description: "Barrel files under cells/ (index.ts, dynamic.ts, dynamic.tsx) must contain ONLY re-export statements. Component definitions belong in their own file. Any other file in cells/ that only re-exports an organelle is an organelle wearing the cell folder."
     },
     messages: {
+      organelleWearingCells: 'File "{{file}}" only re-exports {{names}} from "{{source}}", which is an organelle. A file in cells/ that holds no cell is an organelle wearing the cell folder, and every parent that composes it becomes a cell composing a cell. Import the organelle where it is used, or write the cell here.',
       notBarrel: 'Barrel file "{{file}}" contains {{kind}}. Barrel files under cells/ must be pure re-export manifests (only `export * from` or `export { X } from`). Component definitions belong in their own file.'
     },
     schema: [],
     type: "problem"
+  },
+  probe() {
+    return {
+      path: "src/cells/index.ts",
+      source: `export const geonosisProbe = 1
+`
+    };
   }
 };
 var cells_folder_index_is_barrel_default = cellsFolderIndexIsBarrel;

package/dist/rules/compound-must-be-stateless.d.ts

@@ -1,5 +1,6 @@
 import { type RuleContext } from './lib/context.js';
 import type { AnyNode } from './lib/nodes.js';
+import { type Probe } from './lib/probe.js';
 interface ImportNode {
     importKind?: string;
     source: {
@@ -35,5 +36,6 @@ declare const compoundMustBeStateless: {
         schema: never[];
         type: 'problem';
     };
+    probe(): Probe;
 };
 export default compoundMustBeStateless;