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

package/dist/presets.d.ts

@@ -4,8 +4,8 @@
  * consumer's config the day it ships is a rename nobody adopts — and the reading says so ONCE per
  * process, whatever door read it and however many rules it resolved.
  */
-declare const RENAMED_TO: Record<string, string>;
-type Preset = {
+export declare const RENAMED_TO: Record<string, string>;
+export type Preset = {
     /** Rule ids that belong to this preset but are not ours — enabled alongside, never instead. */
     rules: Record<string, string>;
 };
@@ -20,12 +20,12 @@ type Preset = {
  * The two step rules that appear in `backend-workflows` as well are deliberately NOT here: 026-W2
  * measured them reaching both engines' spellings, and a rule that reaches both presumes neither.
  */
-declare const PRESUMED_ENGINES: readonly {
+export declare const PRESUMED_ENGINES: readonly {
     engine: string;
     packages: readonly string[];
     rules: readonly string[];
 }[];
-declare const PRESETS: {
+export declare const PRESETS: {
     'backend-d1': {
         rules: Record<string, "error">;
     };
@@ -73,8 +73,6 @@ declare const PRESETS: {
         rules: Record<string, "error">;
     };
 };
-type PresetName = keyof typeof PRESETS;
+export type PresetName = keyof typeof PRESETS;
 /** The rule names a preset carries, stripped of the plugin namespace. */
-declare const rulesOfPreset: (preset: PresetName) => string[];
-
-export { PRESETS, PRESUMED_ENGINES, type Preset, type PresetName, RENAMED_TO, rulesOfPreset };
+export declare const rulesOfPreset: (preset: PresetName) => string[];

package/dist/presets.js

@@ -1,9 +1,140 @@
-import {
-  PRESETS,
-  PRESUMED_ENGINES,
-  RENAMED_TO,
-  rulesOfPreset
-} from "./chunk-ZY3XIRRE.js";
+// src/presets.ts
+var FRONTEND = [
+  "atom-no-deps",
+  "cell-must-be-stateful",
+  "cell-must-not-compose-cell",
+  "cell-no-cross-feature-organelles",
+  "cell-no-tissues",
+  "cells-folder-index-is-barrel",
+  "compound-must-be-stateless",
+  "compound-no-stores",
+  "effect-hook-naming",
+  "molecule-atoms-only",
+  "molecule-must-compose",
+  "next-route-segment-is-thin-delegate",
+  "no-brand-names",
+  "no-card-shaped-div",
+  "no-cross-feature-stores",
+  "no-duplicate-jsx-patterns",
+  "no-hook-in-component-disguise",
+  "no-inert-hidden-jsx",
+  "no-inline-data-in-jsx",
+  "no-invalid-feature-folders",
+  "no-logic-in-component-files",
+  "no-raw-html-atoms",
+  "no-react-namespace",
+  "no-renamed-html-props",
+  "no-render-prop-reader",
+  "no-runtime-dead-affordance",
+  "no-trivial-wrapper-component",
+  "no-ts-in-bio-folders",
+  "no-type-definitions-in-components",
+  "organelle-dependency",
+  "organelle-single-source",
+  "tissue-must-compose",
+  "tissue-no-data-props",
+  "tissue-no-hooks",
+  "tissue-no-organelles",
+  "tissue-no-stores",
+  "zustand-v5-best-practices"
+];
+var BACKEND_WORKFLOWS = [
+  "boundary-time-is-primitive",
+  "constants-in-constants-file",
+  "dialect-through-the-seam",
+  "durable-body-reads-through-steps",
+  "mutating-step-declares-retry",
+  "no-date-string-compare",
+  "no-orm-outside-db",
+  "no-raw-sql-outside-allowed",
+  "no-void-port",
+  "queue-loop-is-the-library",
+  "ssot-no-inline-facts",
+  "ssot-no-process-env",
+  "step-declares-compensation-or-none",
+  "tables-declare-their-plane",
+  "time-through-the-door"
+];
+var BACKEND_D1 = ["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"
+};
+var announced = new Set;
+var announceRename = (from) => {
+  if (announced.has(from))
+    return;
+  announced.add(from);
+  process.stderr.write(`biological-architecture: preset "${from}" is now "${RENAMED_TO[from]}" — the old name resolves to the same rules until the next major, then goes.
+`);
+};
+var BACKEND_MEDUSA = [
+  "emit-declares-attempts",
+  "list-take-without-order",
+  "mutating-step-declares-retry",
+  "named-when-block",
+  "no-index-count-as-exact",
+  "no-loader-side-effect-in-index-file",
+  "plugin-route-namespaced",
+  "route-no-inline-mutation",
+  "service-name-not-reserved",
+  "step-declares-compensation-or-none",
+  "store-route-scopes-tenant-data",
+  "subscriber-declares-id",
+  "unique-query-step-name"
+];
+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 PACKAGE_SUBPATHS = ["subpath-over-barrel"];
+var RULE_PREFIX = "biological-architecture";
+var asRules = (names) => Object.fromEntries(names.map((name) => [`${RULE_PREFIX}/${name}`, "error"]));
+var COMMENT_CEILING = {
+  rules: {
+    ...asRules(["max-comment-density"]),
+    "capitalized-comments": "error"
+  }
+};
+var PRESUMED_ENGINES = [
+  {
+    engine: "Medusa",
+    packages: ["@medusajs/framework", "@medusajs/medusa", "@medusajs/utils"],
+    rules: BACKEND_MEDUSA.filter((name) => !BACKEND_WORKFLOWS.includes(name))
+  }
+];
+var PRESETS = {
+  "backend-d1": { rules: asRules(BACKEND_D1) },
+  "backend-medusa": { rules: asRules(BACKEND_MEDUSA) },
+  "backend-sagaflow-cf": {
+    get rules() {
+      announceRename("backend-sagaflow-cf");
+      return asRules(BACKEND_WORKFLOWS_CF);
+    }
+  },
+  "backend-trpc": { rules: asRules(BACKEND_TRPC) },
+  "backend-workflows": { rules: asRules(BACKEND_WORKFLOWS) },
+  "backend-workflows-cf": { rules: asRules(BACKEND_WORKFLOWS_CF) },
+  "comment-ceiling": COMMENT_CEILING,
+  "failure-paths": { rules: asRules(FAILURE_PATHS) },
+  frontend: { rules: asRules(FRONTEND) },
+  integrations: { rules: asRules(INTEGRATIONS) },
+  "package-subpaths": { rules: asRules(PACKAGE_SUBPATHS) },
+  recommended: { rules: asRules(FRONTEND) },
+  "tenant-scoping": { rules: asRules(TENANT_SCOPING) },
+  themekit: { rules: asRules(THEMEKIT) },
+  testbed: { rules: asRules(TESTBED) },
+  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));
 export {
   PRESETS,
   PRESUMED_ENGINES,

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

@@ -0,0 +1,21 @@
+declare const atomNoDeps: {
+    create(context: {
+        filename: string;
+        options?: readonly unknown[];
+        report: (descriptor: {
+            data: Record<string, string>;
+            messageId: string;
+            node: unknown;
+        }) => void;
+    }): import('./lib/visitors.js').Visitor;
+    fixShape: string;
+    meta: {
+        docs: {
+            description: string;
+        };
+        messages: Record<string, string>;
+        schema: unknown[];
+        type: 'problem';
+    };
+};
+export default atomNoDeps;

package/dist/rules/atom-no-deps.js

@@ -0,0 +1,29 @@
+// src/rules/atom-no-deps.ts
+import { directionRule } from "./lib/direction-rule.js";
+var FORBIDDEN_PATTERNS = [
+  /(?:^|\/)molecules\//,
+  /(?:^|\/)compounds\//,
+  /(?:^|\/)organelles\//,
+  /(?:^|\/)cells\//,
+  /(?:^|\/)tissues\//,
+  /(?:^|\/)stores\//,
+  /(?:^|[/@])domains(?:\/|$)/,
+  /\/app\//
+];
+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)),
+  messages: {
+    forbidden: "Atoms cannot import from {{source}}. Atoms are the lowest level and must not depend on higher-level components."
+  },
+  scope: "atoms",
+  typeOnly: "visit"
+});
+var atom_no_deps_default = atomNoDeps;
+export {
+  atom_no_deps_default as default
+};

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

@@ -0,0 +1,56 @@
+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: {
+    create(context: RuleContextWithOptions<Options>): {
+        ExportNamedDeclaration?: undefined;
+        ExportDefaultDeclaration?: undefined;
+    } | {
+        ExportNamedDeclaration: (node: {
+            declaration?: unknown;
+        }) => void;
+        ExportDefaultDeclaration: (node: {
+            declaration?: unknown;
+        }) => void;
+    };
+    fixShape: string;
+    meta: {
+        docs: {
+            description: string;
+        };
+        messages: {
+            libraryTypeAtBoundary: string;
+        };
+        schema: {
+            additionalProperties: boolean;
+            properties: {
+                doors: {
+                    items: {
+                        type: 'string';
+                    };
+                    type: 'array';
+                };
+                types: {
+                    items: {
+                        type: 'string';
+                    };
+                    type: 'array';
+                };
+            };
+            type: 'object';
+        }[];
+        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/boundary-time-is-primitive.js

@@ -0,0 +1,134 @@
+// src/rules/boundary-time-is-primitive.ts
+import { walkNode } from "./lib/nodes.js";
+import { requireOption } from "./lib/options.js";
+import { isDoor } from "./lib/paths.js";
+import { bagOf, firstOf } from "./lib/probe.js";
+import { optionsBag, STRINGS } from "./lib/schema.js";
+var RULE = "boundary-time-is-primitive";
+var ACCEPTS = "{ types: string[] (type or namespace names), doors: string[] (a path, a specifier, or a regex over the filename; default none) }";
+var asNode = (value) => typeof value === "object" && value !== null ? value : undefined;
+var nameOf = (value) => {
+  const name = asNode(value)?.["name"];
+  return typeof name === "string" ? name : undefined;
+};
+var referencedType = (reference) => {
+  const typeName = asNode(reference["typeName"]);
+  if (typeName === undefined)
+    return;
+  if (typeName.type === "Identifier")
+    return nameOf(typeName);
+  if (typeName.type !== "TSQualifiedName")
+    return;
+  const namespace = nameOf(typeName["left"]);
+  const member = nameOf(typeName["right"]);
+  return namespace === undefined || member === undefined ? undefined : `${namespace}.${member}`;
+};
+var forbids = (types, referenced) => types.includes(referenced) || types.includes(referenced.split(".")[0] ?? referenced);
+var functionSignature = (value) => {
+  const fn = asNode(value);
+  if (fn?.type !== "ArrowFunctionExpression" && fn?.type !== "FunctionExpression")
+    return [];
+  return [fn["params"], fn["returnType"]];
+};
+var signatureOf = (declaration) => {
+  if (declaration.type === "FunctionDeclaration" || declaration.type === "TSDeclareFunction") {
+    return [declaration["params"], declaration["returnType"]];
+  }
+  if (declaration.type === "VariableDeclaration") {
+    const declarators = Array.isArray(declaration["declarations"]) ? declaration["declarations"] : [];
+    return declarators.flatMap((one) => [
+      asNode(one)?.["id"] === undefined ? undefined : asNode(asNode(one)?.["id"])?.["typeAnnotation"],
+      ...functionSignature(asNode(one)?.["init"])
+    ]);
+  }
+  if (declaration.type === "ArrowFunctionExpression" || declaration.type === "FunctionExpression") {
+    return functionSignature(declaration);
+  }
+  if (declaration.type === "TSTypeAliasDeclaration")
+    return [declaration["typeAnnotation"]];
+  if (declaration.type === "TSInterfaceDeclaration")
+    return [declaration["body"]];
+  if (declaration.type === "ClassDeclaration") {
+    const members = asNode(declaration["body"])?.["body"];
+    return (Array.isArray(members) ? members : []).flatMap((member) => [
+      asNode(member)?.["typeAnnotation"],
+      ...functionSignature(asNode(member)?.["value"])
+    ]);
+  }
+  return [];
+};
+var declaredName = (declaration) => {
+  const own = nameOf(declaration["id"]);
+  if (own !== undefined)
+    return own;
+  const declarators = Array.isArray(declaration["declarations"]) ? declaration["declarations"] : [];
+  return nameOf(asNode(declarators[0])?.["id"]) ?? "the export";
+};
+var behindADoor = (filename, doors) => doors.some((door) => isDoor(filename, door));
+var boundaryTimeIsPrimitive = {
+  create(context) {
+    const types = requireOption(RULE, context.options?.[0]?.types, "types", ACCEPTS);
+    const doors = context.options?.[0]?.doors ?? [];
+    if (behindADoor(context.filename, doors))
+      return {};
+    const behind = doors.length === 0 ? "the module that owns the library" : doors.join(", ");
+    const report = (node) => {
+      const declaration = asNode(node.declaration);
+      if (declaration === undefined)
+        return;
+      for (const root of signatureOf(declaration)) {
+        walkNode(root, (found) => {
+          if (found.type !== "TSTypeReference")
+            return;
+          const referenced = referencedType(found);
+          if (referenced === undefined || !forbids(types, referenced))
+            return;
+          context.report({
+            data: { doors: behind, name: declaredName(declaration), type: referenced },
+            messageId: "libraryTypeAtBoundary",
+            node: found
+          });
+        });
+      }
+    };
+    return {
+      ExportNamedDeclaration: report,
+      ExportDefaultDeclaration: report
+    };
+  },
+  fixShape: `An exported signature carries time as a PRIMITIVE: epoch milliseconds for an instant, an ISO date
+string (\`YYYY-MM-DD\`) for a business date. A \`Date\`, a \`Dayjs\` or a \`Temporal\` type in a parameter,
+a return or an exported shape hands every caller the library and its configuration, and no database
+column, wire message or contract can hold one at all — the boundary is where the conversion belongs.
+Convert at the door the \`doors\` option names; that module is the one place allowed to say the
+library's type out loud, and a display string is produced at the edge from the primitive rather than
+carried across as a formatted value. Only the signature is judged: a \`Date\` a function builds and
+keeps inside its own body is its own business.`,
+  meta: {
+    docs: {
+      description: "A date-library type in an exported signature couples every caller to the library and its configuration. Time crosses a boundary as a primitive — epoch milliseconds or an ISO date string — and the library type stays inside the module the `doors` option names. Enabled without `types` it reports that once a run and judges nothing."
+    },
+    messages: {
+      libraryTypeAtBoundary: '"{{name}}" puts `{{type}}` in an exported signature. Time crosses a boundary as a primitive — epoch milliseconds for an instant, an ISO date string for a business date — and `{{type}}` stays behind {{doors}}.'
+    },
+    schema: optionsBag({
+      doors: STRINGS,
+      types: STRINGS
+    }),
+    type: "problem"
+  },
+  probe(options) {
+    const { doors = [], types = [] } = bagOf(options);
+    const type = firstOf(types, []);
+    const path = ["geonosis-probe-boundary.ts", "src/geonosis-probe-boundary.ts"].find((candidate) => !behindADoor(candidate, doors));
+    if (path === undefined) {
+      throw new Error(`biological-architecture/${RULE}: every path a probe could be written at is itself one of the declared \`doors\` (${doors.join(", ")}), so there is nowhere left for this rule to speak.`);
+    }
+    return { path, source: `export const boundary = (at: ${type}): string => String(at)
+` };
+  }
+};
+var boundary_time_is_primitive_default = boundaryTimeIsPrimitive;
+export {
+  boundary_time_is_primitive_default as default
+};

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

@@ -0,0 +1,22 @@
+import { type RuleContext } from './lib/context.js';
+declare const cellMustBeStateful: {
+    create(context: RuleContext): {
+        Program?: undefined;
+        'Program:exit'?: undefined;
+    } | {
+        Program(node: unknown): void;
+        'Program:exit'(): void;
+    };
+    fixShape: string;
+    meta: {
+        docs: {
+            description: string;
+        };
+        messages: {
+            shouldBeCompound: string;
+        };
+        schema: never[];
+        type: 'problem';
+    };
+};
+export default cellMustBeStateful;

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

@@ -0,0 +1,75 @@
+// src/rules/cell-must-be-stateful.ts
+import * as fs from "node:fs";
+import { normalise } from "./lib/paths.js";
+import { launderedHomesOf } from "./lib/reexports.js";
+var STATE_SIGNATURE = /\buse[A-Z]\w*\s*\(|from\s+['"][^'"]*\/organelles(?:\/|['"])|from\s+['"][^'"]*\/stores?(?:\/|['"])|createContext\s*\(/;
+var SIBLING_SUFFIXES = [
+  ".tsx",
+  ".parts.tsx",
+  ".sections.tsx",
+  ".layouts.tsx",
+  ".icons.tsx",
+  ".sidebar.tsx",
+  ".summary.tsx",
+  ".form.tsx",
+  ".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 {}
+  }
+  return false;
+}
+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);
+    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
+          });
+        }
+      }
+    };
+  },
+  fixShape: `A cell OWNS state: a \`use*()\` call, an organelle import, or a store read, somewhere in its family
+(\`x.tsx\` + \`x.parts.tsx\` + \`x.sections.tsx\` + …). A file in \`cells/\` that is props-in / JSX-out with
+no state anywhere in that family is inert chemistry — move it to \`compounds/\`. If it should be
+stateful, put the store read or the organelle in it rather than taking the data as a prop.`,
+  meta: {
+    docs: {
+      description: "A cell must own state (a hook, a state-bearing organelle, or a store) somewhere in its family. A cell whose whole family is stateless props-in/JSX-out is a compound — move it to compounds/."
+    },
+    messages: {
+      shouldBeCompound: 'Cell "{{file}}" holds no state (no hooks, no organelle, no store) anywhere in its family — it is a stateless display and belongs in compounds/, not cells/.'
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var cell_must_be_stateful_default = cellMustBeStateful;
+export {
+  cell_must_be_stateful_default as default
+};

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

@@ -0,0 +1,21 @@
+declare const cellMustNotComposeCell: {
+    create(context: {
+        filename: string;
+        options?: readonly unknown[];
+        report: (descriptor: {
+            data: Record<string, string>;
+            messageId: string;
+            node: unknown;
+        }) => void;
+    }): import('./lib/visitors.js').Visitor;
+    fixShape: string;
+    meta: {
+        docs: {
+            description: string;
+        };
+        messages: Record<string, string>;
+        schema: unknown[];
+        type: 'problem';
+    };
+};
+export default cellMustNotComposeCell;

package/dist/rules/cell-must-not-compose-cell.js

@@ -0,0 +1,29 @@
+// src/rules/cell-must-not-compose-cell.ts
+import { isCellsBarrel } from "./lib/cells-barrel.js";
+import { directionRule } from "./lib/direction-rule.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.",
+  fixShape: `A cell never composes another cell — not same-feature, not \`shared/\`, no exception. If you want to,
+one of the two is misclassified: arrangement goes up to a \`tissues/\` file, a stateless display goes
+down to \`compounds/\`, a store adapter goes sideways to \`organelles/\`. A parent that holds state AND
+hosts a cell (a summary card that opens a modal-hosted form) is two cells side by side: the child
+hosts its own modal and reads whether it is open from the store, the parent writes it, and a
+\`tissues/\` file arranges both. Cells coordinate through a store, never through props from one to
+the other. A stateless adapter between cells is a tissue — it may take the data it hands down
+(\`{ collections: Collection[] }\`); it may not take a handler. Private siblings of the SAME
+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),
+  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)
+});
+var cell_must_not_compose_cell_default = cellMustNotComposeCell;
+export {
+  cell_must_not_compose_cell_default as default
+};

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

@@ -0,0 +1,21 @@
+declare const cellNoCrossFeatureOrganelles: {
+    create(context: {
+        filename: string;
+        options?: readonly unknown[];
+        report: (descriptor: {
+            data: Record<string, string>;
+            messageId: string;
+            node: unknown;
+        }) => void;
+    }): import('./lib/visitors.js').Visitor;
+    fixShape: string;
+    meta: {
+        docs: {
+            description: string;
+        };
+        messages: Record<string, string>;
+        schema: unknown[];
+        type: 'problem';
+    };
+};
+export default cellNoCrossFeatureOrganelles;

package/dist/rules/cell-no-cross-feature-organelles.js

@@ -0,0 +1,37 @@
+// src/rules/cell-no-cross-feature-organelles.ts
+import { directionRule } from "./lib/direction-rule.js";
+import {
+  crossesFeatureBoundary,
+  SHARED_FEATURES_SCHEMA
+} from "./lib/shared-features.js";
+var FEATURE_ORGANELLE = /(?:^|[/@])features\/([^/]+)\/organelles\//;
+var organelleFeatureOf = (path) => FEATURE_ORGANELLE.exec(path)?.[1];
+var cellNoCrossFeatureOrganelles = directionRule({
+  data: (target, importer) => ({
+    file: importer.file,
+    importedFeature: organelleFeatureOf(target.path) ?? "",
+    ownFeature: importer.feature ?? "",
+    source: target.source
+  }),
+  description: "Cells must not import another feature's organelles. An organelle is a feature's own state compartment; a cell in features/X/ hosts features/X/organelles/* and the features named in sharedFeatures (default: shared). Another feature's state arrives as props from the tissue above.",
+  fixShape: `A cell hosts its OWN feature's organelles. Another feature's organelle is that feature's state
+compartment, and a cell that imports one couples two features through a hook instead of through
+props — take the value as a prop and let the tissue above arrange both, or move the organelle into a
+feature every cell may read (the rule's \`sharedFeatures\` option, default \`shared\`). Relative and
+aliased sources are judged alike: \`../../billing/organelles/totals\` lands where
+\`@/features/billing/organelles/totals\` lands. Type-only imports are exempt; \`export … from\` is not.`,
+  forbidden: (target, importer, options) => {
+    const importedFeature = organelleFeatureOf(target.path);
+    return crossesFeatureBoundary(importedFeature, importer.feature, options);
+  },
+  messages: {
+    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 ?? {},
+  scope: "cells",
+  schema: SHARED_FEATURES_SCHEMA
+});
+var cell_no_cross_feature_organelles_default = cellNoCrossFeatureOrganelles;
+export {
+  cell_no_cross_feature_organelles_default as default
+};

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

@@ -0,0 +1,21 @@
+declare const cellNoTissues: {
+    create(context: {
+        filename: string;
+        options?: readonly unknown[];
+        report: (descriptor: {
+            data: Record<string, string>;
+            messageId: string;
+            node: unknown;
+        }) => void;
+    }): import('./lib/visitors.js').Visitor;
+    fixShape: string;
+    meta: {
+        docs: {
+            description: string;
+        };
+        messages: Record<string, string>;
+        schema: unknown[];
+        type: 'problem';
+    };
+};
+export default cellNoTissues;