@geonosis/oxlint-plugin-biological-architecture 0.1.0

package/dist/index.js

@@ -0,0 +1,3916 @@
+import {
+  PRESETS
+} from "./chunk-74VWOEPL.js";
+
+// src/rules/atom-no-deps.ts
+var FORBIDDEN_PATTERNS = [
+  /molecules\//,
+  /compounds\//,
+  /organelles\//,
+  /cells\//,
+  /tissues\//,
+  /stores\//,
+  /domains/,
+  /\/app\//
+];
+var atomNoDeps = {
+  create(context) {
+    const filename = context.filename;
+    const isAtom = /\/atoms\//.test(filename);
+    if (!isAtom) return {};
+    const fromModule = (node) => {
+      if (!node.source) return;
+      const source = node.source.value;
+      for (const pattern of FORBIDDEN_PATTERNS) {
+        if (pattern.test(source)) {
+          context.report({
+            data: { source },
+            messageId: "forbidden",
+            node
+          });
+          break;
+        }
+      }
+    };
+    return {
+      ExportAllDeclaration: fromModule,
+      ExportNamedDeclaration: fromModule,
+      ImportDeclaration: fromModule
+    };
+  },
+  fixShape: `Raw \`<button>\`, \`<input>\`, or a \`<div>\` with border + background in levels 2-6 belongs in an atom.
+An atom imports nothing above itself \u2014 no molecule, compound, organelle, cell, tissue, store or domain,
+and that includes \`export \u2026 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.`,
+  meta: {
+    docs: {
+      description: "Atoms cannot import from molecules, compounds, organelles, cells, stores, or domains"
+    },
+    messages: {
+      forbidden: "Atoms cannot import from {{source}}. Atoms are the lowest level and must not depend on higher-level components."
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var atom_no_deps_default = atomNoDeps;
+
+// src/rules/cell-must-be-stateful.ts
+import * as fs from "fs";
+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 isReexportOnly(file) {
+  try {
+    const src = fs.readFileSync(file, "utf8").replaceAll(/\/\*[\s\S]*?\*\//g, "").replaceAll(/\/\/.*$/gm, "");
+    const hasReexport = /\bexport\b[^;]*\bfrom\b\s*['"]/.test(src);
+    const hasComponent = /\bfunction\b|=>|\breturn\b|<[A-Za-z]/.test(src);
+    return hasReexport && !hasComponent;
+  } catch {
+    return false;
+  }
+}
+function familyHasState(mainFile) {
+  const stem = mainFile.replace(/\.tsx$/, "");
+  for (const suffix of SIBLING_SUFFIXES) {
+    const file = 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 = context.filename.replaceAll(/\\/g, "/");
+    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 {};
+    if (isReexportOnly(context.filename)) return {};
+    let programNode = null;
+    return {
+      Program(node) {
+        programNode = node;
+      },
+      "Program:exit"() {
+        if (!familyHasState(normalized)) {
+          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\` + \u2026). A file in \`cells/\` that is props-in / JSX-out with
+no state anywhere in that family is inert chemistry \u2014 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 \u2014 move it to compounds/."
+    },
+    messages: {
+      shouldBeCompound: 'Cell "{{file}}" holds no state (no hooks, no organelle, no store) anywhere in its family \u2014 it is a stateless display and belongs in compounds/, not cells/.'
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var cell_must_be_stateful_default = cellMustBeStateful;
+
+// src/rules/cell-must-not-compose-cell.ts
+import * as path from "path";
+function cellStem(filePath) {
+  const base = filePath.split("/").pop() || filePath;
+  return base.replace(/\.[jt]sx?$/, "").replace(
+    /\.(parts|sections|summary|layouts|icons|types|hooks|utils|context|store|sidebar|data|config)$/i,
+    ""
+  );
+}
+var cellMustNotComposeCell = {
+  create(context) {
+    const filename = context.filename;
+    const normalized = filename.replaceAll(/\\/g, "/");
+    if (!/(?:^|\/)cells\//.test(normalized)) return {};
+    const currentFile = normalized.split("/").pop() || normalized;
+    const currentDir = path.posix.dirname(normalized);
+    const importerStem = cellStem(normalized);
+    function report(importedPath, node) {
+      if (cellStem(importedPath) === importerStem) return;
+      context.report({
+        data: { currentFile, importedFile: importedPath.split("/").pop() || importedPath },
+        messageId: "forbidden",
+        node
+      });
+    }
+    const fromModule = (node) => {
+      if (!node.source) return;
+      if (node.importKind === "type") return;
+      const source = node.source.value;
+      if (/(?:^|\/)cells\//.test(source)) {
+        report(source, node);
+        return;
+      }
+      if (source.startsWith("./") || source.startsWith("../")) {
+        const resolved = path.posix.normalize(path.posix.join(currentDir, source));
+        if (/(?:^|\/)cells\//.test(resolved)) {
+          report(resolved, node);
+        }
+      }
+    };
+    return {
+      ExportAllDeclaration: fromModule,
+      ExportNamedDeclaration: fromModule,
+      ImportDeclaration: fromModule
+    };
+  },
+  fixShape: `A cell never composes another cell \u2014 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/\`. Private siblings of the SAME
+component (\`invoice-editor.parts.tsx\` from \`invoice-editor.tsx\`) are one cell and are fine.`,
+  meta: {
+    docs: {
+      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."
+    },
+    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/.'
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var cell_must_not_compose_cell_default = cellMustNotComposeCell;
+
+// src/rules/cell-no-tissues.ts
+var HIGHER_LEVEL_PATTERNS = [
+  /(?:features\/[^/]+\/)?tissues\//,
+  /(?:features\/[^/]+\/)?organs\//,
+  /(?:^|\/)layouts\//,
+  /apps\/web\/app\//
+];
+var cellNoTissues = {
+  create(context) {
+    const filename = context.filename;
+    const normalized = filename.replaceAll(/\\/g, "/");
+    const isCell = /(?:features\/[^/]+\/)?cells\//.test(normalized);
+    if (!isCell) return {};
+    const shortName = normalized.split("/").pop() || normalized;
+    const fromModule = (node) => {
+      if (!node.source) return;
+      if (node.importKind === "type") return;
+      const source = node.source.value;
+      for (const pattern of HIGHER_LEVEL_PATTERNS) {
+        if (pattern.test(source)) {
+          context.report({
+            data: { file: shortName, source },
+            messageId: "forbidden",
+            node
+          });
+          return;
+        }
+      }
+    };
+    return {
+      ExportAllDeclaration: fromModule,
+      ExportNamedDeclaration: fromModule,
+      ImportDeclaration: fromModule
+    };
+  },
+  fixShape: `A cell cannot import a tissue, an organ, a layout or an app route \u2014 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 \u2026 from\` is not.`,
+  meta: {
+    docs: {
+      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."
+    },
+    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.'
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var cell_no_tissues_default = cellNoTissues;
+
+// src/rules/cells-folder-index-is-barrel.ts
+var BARREL_FILE_PATTERN = /\/cells\/(?:index\.ts|dynamic\.tsx?)$/;
+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`;
+  }
+}
+var cellsFolderIndexIsBarrel = {
+  create(context) {
+    const filename = context.filename;
+    const normalized = filename.replaceAll(/\\/g, "/");
+    if (!BARREL_FILE_PATTERN.test(normalized)) return {};
+    const shortName = normalized.split("/").pop() || normalized;
+    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") continue;
+          context.report({
+            data: { file: shortName, kind: describeStatement(stmt) },
+            messageId: "notBarrel",
+            node: stmt
+          });
+        }
+      }
+    };
+  },
+  fixShape: `\`cells/index.ts\` and \`cells/dynamic.ts\` are barrels: \`export \u2026 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.`,
+  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."
+    },
+    messages: {
+      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"
+  }
+};
+var cells_folder_index_is_barrel_default = cellsFolderIndexIsBarrel;
+
+// src/rules/compound-must-be-stateless.ts
+var reactForbiddenHooks = /* @__PURE__ */ new Set([
+  "useCallback",
+  "useEffect",
+  "useImperativeHandle",
+  "useLayoutEffect",
+  "useMemo",
+  "useReducer",
+  "useRef",
+  "useState"
+]);
+var COMPOUND_FILE_PATTERN = /(?:(?:features\/[^/]+\/)?compounds\/|packages\/ui\/src\/compounds\/)/;
+var compoundMustBeStateless = {
+  create(context) {
+    const filename = context.filename;
+    const normalized = filename.replaceAll(/\\/g, "/");
+    const isCompound = COMPOUND_FILE_PATTERN.test(normalized);
+    if (!isCompound) return {};
+    const shortName = normalized.split("/").pop() || normalized;
+    return {
+      CallExpression(node) {
+        if (node.callee.type !== "Identifier") return;
+        const name = node.callee.name;
+        if (!name || !/^use[A-Z]/.test(name)) return;
+        context.report({
+          data: { file: shortName, hook: name },
+          messageId: "forbiddenHookCall",
+          node
+        });
+      },
+      ImportDeclaration(node) {
+        if (node.importKind === "type") return;
+        const source = node.source.value;
+        if (source === "react") {
+          const specifiers = node.specifiers ?? [];
+          for (const spec of specifiers) {
+            if (spec.type !== "ImportSpecifier") continue;
+            const importedName = spec.imported?.name;
+            if (!importedName) continue;
+            if (reactForbiddenHooks.has(importedName)) {
+              context.report({
+                data: { file: shortName, hook: importedName },
+                messageId: "forbiddenReactHook",
+                node
+              });
+            }
+          }
+          return;
+        }
+        if (source.includes("/providers/") || source.startsWith("@/providers/")) {
+          context.report({
+            data: { file: shortName, source },
+            messageId: "forbiddenContextImport",
+            node
+          });
+        }
+      }
+    };
+  },
+  fixShape: `A compound is inert: no \`useState\`, no \`useEffect\`, no \`useMemo\`, no store read, no provider import \u2014
+no hook call at all. It takes what it renders as props. If it needs state, the caller is a cell or an
+organelle and holds it; if the file itself needs state, it is not a compound.`,
+  meta: {
+    docs: {
+      description: "Compounds are pure stateless props-in/JSX-out components. They cannot: (1) import React hooks from react, (2) call ANY hook (use* functions), (3) import from providers/ or contexts/. If you need state, this is a cell or organelle."
+    },
+    messages: {
+      forbiddenContextImport: 'Compound "{{file}}" imports from "{{source}}". Compounds must not use context/providers \u2014 receive data via props instead.',
+      forbiddenHookCall: 'Compound "{{file}}" calls hook "{{hook}}". Compounds are stateless \u2014 no hooks allowed. Move to cells/ or organelles/.',
+      forbiddenReactHook: 'Compound "{{file}}" imports "{{hook}}" from react. Compounds are stateless \u2014 move to cells/ or organelles/.'
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var compound_must_be_stateless_default = compoundMustBeStateless;
+
+// src/rules/compound-no-stores.ts
+var FORBIDDEN_PATTERNS2 = [
+  /stores\//,
+  /organelles\//,
+  /cells\//,
+  /tissues\//,
+  /layouts\//,
+  /\/app\//
+];
+var compoundNoStores = {
+  create(context) {
+    const filename = context.filename;
+    if (/__tests__\//.test(filename)) return {};
+    const isCompound = /\/compounds\//.test(filename);
+    if (!isCompound) return {};
+    const fromModule = (node) => {
+      if (!node.source) return;
+      if (node.importKind === "type") return;
+      const source = node.source.value;
+      for (const pattern of FORBIDDEN_PATTERNS2) {
+        if (pattern.test(source)) {
+          context.report({
+            data: { source },
+            messageId: "forbidden",
+            node
+          });
+          break;
+        }
+      }
+    };
+    return {
+      ExportAllDeclaration: fromModule,
+      ExportNamedDeclaration: fromModule,
+      ImportDeclaration: fromModule
+    };
+  },
+  fixShape: `A compound may import atoms, molecules and other compounds. Stores, organelles, cells, tissues,
+layouts and app routes are all above it. Take the data as a prop from the cell that reads the store.
+Type-only imports are exempt; \`export \u2026 from\` is not.`,
+  meta: {
+    docs: {
+      description: "Compounds may only import atoms, molecules, and other compounds. They cannot import organelles, cells, tissues, stores, or app routes \u2014 direction rule: a parent may only compose children at levels <= its own."
+    },
+    messages: {
+      forbidden: "Compounds cannot import from {{source}}. Direction violation \u2014 compounds are level 3 and can only depend on atoms, molecules, other compounds, and shared libs/domains/types."
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var compound_no_stores_default = compoundNoStores;
+
+// src/rules/constants-in-constants-file.ts
+var exemptFiles = [/\/constants\.ts$/, /\/__tests__\//, /\/scripts\//, /\/testing\//, /\.d\.ts$/];
+var screamingSnake = /^[A-Z][A-Z0-9]*(_[A-Z0-9]+)*$/;
+var constantsInConstantsFile = {
+  create(context) {
+    const normalized = context.filename.replace(/\\/g, "/");
+    if (exemptFiles.some((file) => file.test(normalized))) return {};
+    return {
+      ExportNamedDeclaration(node) {
+        const declaration = node.declaration;
+        if (!declaration || declaration.type !== "VariableDeclaration") return;
+        for (const declarator of declaration.declarations ?? []) {
+          const name = declarator.id.type === "Identifier" ? declarator.id.name : void 0;
+          if (name !== void 0 && name.length >= 3 && screamingSnake.test(name)) {
+            context.report({ messageId: "outsideConstantsFile", node, data: { name } });
+          }
+        }
+      }
+    };
+  },
+  fixShape: `A \`SCREAMING_SNAKE\` export is a fact, and a fact lives in a \`constants.ts\` beside its owner \u2014 not
+scattered across the module that happens to use it first. Move the declaration, import it back.
+Non-exported module locals are unaffected.`,
+  meta: {
+    docs: {
+      description: "A SCREAMING_SNAKE export is a constant, and constants live in the constants.ts beside their owner."
+    },
+    messages: {
+      outsideConstantsFile: "{{name}} is a constant declared outside constants.ts. Move it to the constants.ts of its domain, feature lib or package."
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var constants_in_constants_file_default = constantsInConstantsFile;
+
+// src/rules/dialect-through-the-seam.ts
+var seamPattern = /\/packages\/db\/(src\/(schema\/|dialect\.ts$|client\.ts$|cell\/drivers\/)|drizzle[^/]*\.config\.ts$)/;
+var testPattern = /\/(__tests__|testing)\//;
+var dialectModules = [
+  "drizzle-orm/pg-core",
+  "drizzle-orm/sqlite-core",
+  "drizzle-orm/d1",
+  "drizzle-orm/postgres-js",
+  "drizzle-orm/node-postgres",
+  "drizzle-orm/pglite",
+  "drizzle-orm/neon-http",
+  "drizzle-orm/neon-serverless",
+  "postgres",
+  "pg"
+];
+var postgresWords = /\b(to_tsquery|ts_rank|set_config|current_setting|to_char|to_timestamp|regexp_replace|explain|information_schema|set local)\b/i;
+var isDialectModule = (source) => typeof source === "string" && dialectModules.some((module) => source === module || source.startsWith(`${module}/`));
+var dialectThroughTheSeam = {
+  create(context) {
+    const normalized = context.filename.replace(/\\/g, "/");
+    const atTheSeam = seamPattern.test(normalized);
+    const inTests = testPattern.test(normalized);
+    const checkImport = (source, node) => {
+      if (atTheSeam || !isDialectModule(source)) return;
+      context.report({ data: { source }, messageId: "dialectOutsideSeam", node });
+    };
+    const fromModule = (node) => {
+      if (!node.source) return;
+      checkImport(node.source?.value, node);
+    };
+    const checkText = (text, node) => {
+      if (atTheSeam || inTests) return;
+      const word = postgresWords.exec(text)?.[1];
+      if (word === void 0) return;
+      context.report({ data: { word }, messageId: "postgresOutsideDialect", node });
+    };
+    return {
+      ExportAllDeclaration: fromModule,
+      ExportNamedDeclaration: fromModule,
+      ImportDeclaration: fromModule,
+      ImportExpression(node) {
+        if (node.source?.type !== "Literal") return;
+        checkImport(node.source.value, node);
+      },
+      TaggedTemplateExpression(node) {
+        if (node.tag?.type !== "Identifier" || node.tag.name !== "sql") return;
+        checkText((node.quasi?.quasis ?? []).map((part) => part.value?.raw ?? "").join(" "), node);
+      },
+      CallExpression(node) {
+        const callee = node.callee;
+        if (callee?.type !== "MemberExpression") return;
+        if (callee.object?.name !== "sql" || callee.property?.name !== "raw") return;
+        const [first] = node.arguments ?? [];
+        if (first?.type !== "Literal" || typeof first.value !== "string") return;
+        checkText(first.value, node);
+      }
+    };
+  },
+  fixShape: `Dialect-typed names (\`drizzle-orm/pg-core\`, \`drizzle-orm/sqlite-core\`, \`drizzle-orm/d1\`, \u2026) are
+imported only at the seam: the schema, \`dialect.ts\`, \`client.ts\`, the drivers, and drizzle-kit's
+configs. Everywhere else, use the dialect-free aliases the seam exports (\`Database\`, \`AnyColumn\`,
+\`rowsOf\`) so the same query compiles against either engine.`,
+  meta: {
+    docs: {
+      description: "The dialect and the driver are named at one seam in packages/db (the schema, dialect.ts, client.ts, cell/drivers, the drizzle-kit configs); nothing else imports a dialect or driver module, and nothing outside the dialect module spells a Postgres function."
+    },
+    messages: {
+      dialectOutsideSeam: 'This file imports "{{source}}". A dialect or driver module is named only at the seam (packages/db/src/schema, dialect.ts, client.ts, cell/drivers) \u2014 use the neutral types and the cell port from @during/db instead.',
+      postgresOutsideDialect: '"{{word}}" is Postgres, not SQL. Name the fragment in packages/db/src/dialect.ts and call it from here, so the query reads as the question it asks.'
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var dialect_through_the_seam_default = dialectThroughTheSeam;
+
+// src/rules/lib/literal-call.ts
+var literalNamedBy = (node, callee) => {
+  if (node.callee.type !== "Identifier" || node.callee.name !== callee) return null;
+  const [name] = node.arguments ?? [];
+  return name?.type === "Literal" && typeof name.value === "string" ? name.value : null;
+};
+
+// src/rules/document-sagas-are-generic.ts
+var escapeForRegex = (value) => value.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var documentSagasAreGeneric = {
+  create(context) {
+    const prefixes = context.options?.[0]?.perKindPrefixes ?? [];
+    if (prefixes.length === 0) return {};
+    if (!/\/packages\/workflows\/src\//.test(context.filename.replaceAll("\\", "/"))) return {};
+    const perKindPrefix = new RegExp(`^(?:${prefixes.map(escapeForRegex).join("|")})\\.`);
+    return {
+      CallExpression(node) {
+        const name = literalNamedBy(node, "saga");
+        if (name === null || !perKindPrefix.test(name)) return;
+        context.report({ data: { name }, messageId: "perKindSaga", node });
+      }
+    };
+  },
+  fixShape: `A saga named for one document kind (\`invoice.issue\`, \`quote.accept\`) is the hand-written fork the
+generic base entity replaced. Mint it from the generic factory \u2014 \`documentSagas(entity, effects)\` \u2014
+and pass the kind as data. Configure the kind vocabulary through the rule's \`perKindPrefixes\` option.`,
+  meta: {
+    docs: {
+      description: "Document sagas are minted, not written: `documentSagas(entity, effects)` gives every entity that extends Document its create/save/setStatus/remove/send/convert/duplicate/share from one body. A saga literally named for one entity is a fork."
+    },
+    messages: {
+      perKindSaga: '"{{name}}" is a hand-written saga for one entity. Every entity that extends Document gets its sagas from `documentSagas(entity, effects)`; put what this entity decides in its `Document.extend` definition or in its `DocumentEffects`.'
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          perKindPrefixes: { items: { type: "string" }, type: "array" }
+        },
+        type: "object"
+      }
+    ],
+    type: "problem"
+  }
+};
+var document_sagas_are_generic_default = documentSagasAreGeneric;
+
+// src/rules/documents-share-one-table.ts
+var TABLE_CALLEES = ["sqliteTable", "pgTable"];
+var documentsShareOneTable = {
+  create(context) {
+    const perKindTables = new Set(context.options?.[0]?.perKindTables ?? []);
+    if (perKindTables.size === 0) return {};
+    if (!/\/packages\/db\/src\/schema\//.test(context.filename.replaceAll("\\", "/"))) return {};
+    return {
+      CallExpression(node) {
+        for (const callee of TABLE_CALLEES) {
+          const table = literalNamedBy(node, callee);
+          if (table === null || !perKindTables.has(table)) continue;
+          context.report({ data: { table }, messageId: "perKindTable", node });
+          return;
+        }
+      }
+    };
+  },
+  fixShape: `Every document kind is a row of the one \`documents\` table with a \`kind\` column, not a table of its
+own. A \`pgTable('invoices', \u2026)\` beside a \`pgTable('quotes', \u2026)\` is the second storage the base entity
+retired: write the row, not the table. The forbidden table names are the rule's \`perKindTables\`
+option.`,
+  meta: {
+    docs: {
+      description: "Documents share ONE table: `documents` holds the head every kind derives and the body its kind declares. A table named for one kind of document is a second storage."
+    },
+    messages: {
+      perKindTable: '"{{table}}" is a table for one kind of document. Every kind is a row of `documents` \u2014 add the kind to `documentEntities` and let its `headOf` fill the columns.'
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          perKindTables: { items: { type: "string" }, type: "array" }
+        },
+        type: "object"
+      }
+    ],
+    type: "problem"
+  }
+};
+var documents_share_one_table_default = documentsShareOneTable;
+
+// src/rules/effect-hook-naming.ts
+var HOOK_FILE_PATTERN = /(?:features\/[^/]+\/)?organelles\/.*\.ts$/;
+var effectHookNaming = {
+  create(context) {
+    const normalized = context.filename.replaceAll(/\\/g, "/");
+    if (!HOOK_FILE_PATTERN.test(normalized)) return {};
+    const file = normalized.split("/").pop() || "";
+    if (file.endsWith("-effect.ts")) return {};
+    let usesEffect = false;
+    let effectHookName = "";
+    let programNode = null;
+    const exportedFunctions = [];
+    return {
+      CallExpression(node) {
+        if (node.callee.type !== "Identifier") return;
+        if (node.callee.name === "useEffect" || node.callee.name === "useLayoutEffect") {
+          usesEffect = true;
+          effectHookName = node.callee.name;
+        }
+      },
+      "ExportNamedDeclaration > FunctionDeclaration"(node) {
+        if (node.id?.name) {
+          exportedFunctions.push({ name: node.id.name, node });
+        }
+      },
+      Program(node) {
+        programNode = node;
+      },
+      "Program:exit"() {
+        if (!usesEffect) return;
+        const baseName = file.replace(/\.ts$/, "");
+        const suggestedFile = baseName + "-effect.ts";
+        context.report({
+          data: { file, hook: effectHookName, suggested: suggestedFile },
+          messageId: "filenameMissingEffect",
+          node: programNode
+        });
+        for (const fn of exportedFunctions) {
+          if (!fn.name.endsWith("Effect")) {
+            context.report({
+              data: {
+                hook: effectHookName,
+                name: fn.name,
+                suggested: fn.name + "Effect"
+              },
+              messageId: "functionMissingEffect",
+              node: fn.node
+            });
+          }
+        }
+      }
+    };
+  },
+  fixShape: `A hook in \`organelles/\` that calls \`useEffect\` says so in its name: the file is \`use-<thing>-effect.ts\`
+and the exported function is \`use<Thing>Effect\`. A hook that only derives needs neither. Rename the
+file and the export together \u2014 half the pair still fires.`,
+  meta: {
+    docs: {
+      description: 'Hook files that use useEffect/useLayoutEffect must have "-effect" suffix in the filename and "Effect" suffix in the exported function name. This makes side-effectful hooks immediately identifiable.'
+    },
+    messages: {
+      filenameMissingEffect: 'File uses {{hook}} but filename "{{file}}" does not end with "-effect.ts". Rename to "{{suggested}}".',
+      functionMissingEffect: 'Function "{{name}}" uses {{hook}} but does not end with "Effect". Rename to "{{suggested}}".'
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var effect_hook_naming_default = effectHookNaming;
+
+// src/rules/max-comment-density.ts
+var exemptFiles2 = [
+  /\/__tests__\//,
+  /\.config\.(ts|mjs|js)$/,
+  /\.d\.ts$/,
+  /\/scripts\//,
+  /\/testing\//
+];
+var commentCeilingPercent = 10;
+var commentBlockCeilingLines = 3;
+var commentLinesAlwaysAllowed = 3;
+var directive = /^\s*(eslint|oxlint|biome|prettier|@ts-|c8 |v8 |istanbul )/;
+var commentsOf = (sourceCode) => sourceCode.getAllComments?.() ?? sourceCode.ast?.comments ?? [];
+var lineCount = (sourceCode) => sourceCode.lines?.length ?? (sourceCode.text ?? "").split("\n").length;
+var maxCommentDensity = {
+  create(context) {
+    const normalized = context.filename.replace(/\\/g, "/");
+    if (exemptFiles2.some((file) => file.test(normalized))) return {};
+    return {
+      Program(node) {
+        const comments = commentsOf(context.sourceCode).filter((c) => !directive.test(c.value));
+        const total = lineCount(context.sourceCode);
+        if (total === 0) return;
+        const commented = /* @__PURE__ */ new Set();
+        for (const comment of comments) {
+          const lines = comment.loc.end.line - comment.loc.start.line + 1;
+          if (lines > commentBlockCeilingLines) {
+            context.report({
+              messageId: "blockTooLong",
+              node,
+              loc: comment.loc,
+              data: { lines: String(lines), max: String(commentBlockCeilingLines) }
+            });
+          }
+          for (let line = comment.loc.start.line; line <= comment.loc.end.line; line += 1) {
+            commented.add(line);
+          }
+        }
+        const ratio = Math.round(commented.size / total * 100);
+        if (commented.size > commentLinesAlwaysAllowed && ratio > commentCeilingPercent) {
+          context.report({
+            messageId: "aboveCeiling",
+            node,
+            data: { ratio: String(ratio), max: String(commentCeilingPercent) }
+          });
+        }
+      }
+    };
+  },
+  fixShape: `Comments are at most 10 % of a file's lines and no block runs past 3. A 60-line file gets six comment
+lines: budget them before writing. A comment says a non-obvious WHY \u2014 never what the code does, never
+a law citation, never the story of how it came to be. At the ceiling, delete one to add one.`,
+  meta: {
+    docs: {
+      description: "A file carries at most 10 % comment lines and no comment block longer than three lines. Names carry the meaning; a comment is a one-line non-obvious WHY."
+    },
+    messages: {
+      aboveCeiling: "{{ratio}}% of this file is comments (ceiling {{max}}%). Delete narration, law citations and stories; rename until the code says it.",
+      blockTooLong: "A {{lines}}-line comment block (ceiling {{max}}). State the non-obvious WHY in one line or move the explanation into a name."
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var max_comment_density_default = maxCommentDensity;
+
+// src/rules/molecule-atoms-only.ts
+var FORBIDDEN_PATTERNS3 = [
+  /components\/ui\//,
+  /compounds\//,
+  /organelles\//,
+  /cells\//,
+  /tissues\//,
+  /stores\//,
+  /domains/,
+  /\/app\//
+];
+var moleculeAtomsOnly = {
+  create(context) {
+    const filename = context.filename;
+    const isMolecule = /\/molecules\//.test(filename);
+    if (!isMolecule) return {};
+    const fromModule = (node) => {
+      if (!node.source) return;
+      const source = node.source.value;
+      for (const pattern of FORBIDDEN_PATTERNS3) {
+        if (pattern.test(source)) {
+          context.report({
+            data: { source },
+            messageId: "forbidden",
+            node
+          });
+          break;
+        }
+      }
+    };
+    return {
+      ExportAllDeclaration: fromModule,
+      ExportNamedDeclaration: fromModule,
+      ImportDeclaration: fromModule
+    };
+  },
+  fixShape: `A molecule combines atoms and other molecules and nothing else \u2014 no compound, organelle, cell,
+tissue, store or domain, and no state-bearing \`components/ui\` primitive (Calendar, Popover, Carousel).
+Composing a stateful primitive makes the file a cell. \`export \u2026 from\` is checked like an import.`,
+  meta: {
+    docs: {
+      description: "Molecules are inert combinations of atoms. They must not import compounds, organelles, cells, tissues, stores, domains, or the raw state-bearing components/ui primitives \u2014 composing a stateful primitive makes the file a cell."
+    },
+    messages: {
+      forbidden: "Molecules cannot import from {{source}}. Molecules are inert atom-combinations \u2014 state-bearing primitives (components/ui) and higher tiers belong in a cell."
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var molecule_atoms_only_default = moleculeAtomsOnly;
+
+// src/rules/molecule-must-compose.ts
+import fs2 from "fs";
+function isReexportOnly2(file) {
+  try {
+    const src = fs2.readFileSync(file, "utf8").replaceAll(/\/\*[\s\S]*?\*\//g, "").replaceAll(/\/\/.*$/gm, "");
+    const hasReexport = /\bexport\b[^;]*\bfrom\b\s*['"]/.test(src);
+    const hasComponent = /\bfunction\b|=>|\breturn\b|<[A-Za-z]/.test(src);
+    return hasReexport && !hasComponent;
+  } catch {
+    return false;
+  }
+}
+function isCompositionSource(src) {
+  if (/\/(atoms|molecules)(\/|$)/.test(src)) return true;
+  if (/^\.\/[^/]+$/.test(src)) return true;
+  if (src.startsWith("@radix-ui/") || src === "radix-ui" || src.startsWith("radix-ui/")) return true;
+  if (src.startsWith("@react-email/")) return true;
+  return false;
+}
+var moleculeMustCompose = {
+  create(context) {
+    const filename = context.filename;
+    const isMolecule = /\/molecules\/(?!index\.)[^/]+\.tsx?$/.test(filename);
+    if (!isMolecule) return {};
+    if (isReexportOnly2(filename)) return {};
+    const bioImportLocals = /* @__PURE__ */ new Set();
+    const renderedTagNames = /* @__PURE__ */ new Set();
+    let programNode = null;
+    return {
+      ImportDeclaration(node) {
+        if (node.importKind === "type") return;
+        const source = node.source.value;
+        if (!isCompositionSource(source)) return;
+        for (const spec of node.specifiers ?? []) {
+          const localName = spec.local?.name;
+          if (localName) bioImportLocals.add(localName);
+        }
+      },
+      JSXOpeningElement(node) {
+        const name = node.name;
+        if (!name) return;
+        if (name.type === "JSXIdentifier") {
+          const id = name;
+          if (id.name) renderedTagNames.add(id.name);
+        } else if (name.type === "JSXMemberExpression") {
+          const member = name;
+          const root = member.object?.name;
+          if (root) renderedTagNames.add(root);
+        }
+      },
+      "Program:exit"(node) {
+        programNode = node;
+        const composesByRender = [...bioImportLocals].some(
+          (localName) => renderedTagNames.has(localName)
+        );
+        if (!composesByRender) {
+          const shortName = filename.split("/").pop() || filename;
+          context.report({
+            data: { filename: shortName },
+            messageId: "missingComposition",
+            node: programNode
+          });
+        }
+      }
+    };
+  },
+  fixShape: `A molecule must RENDER at least one of the atoms or molecules it imports. An import that never
+appears as a JSX tag is lint-theater: it satisfies a dependency check while composing nothing. If the
+file renders only native HTML, it is an atom; if it renders nothing, delete it. Radix and react-email
+primitives count as composition; a pure \`export \u2026 from\` shim is not a molecule at all.`,
+  meta: {
+    docs: {
+      description: "Molecules MUST RENDER at least one atom or another molecule (or Radix primitive). A molecule is BY DEFINITION a combination \u2014 importing an atom without rendering it is FAKE composition (lint-theater). This rule checks the JSX render tree, not just the import list. That is lint-theater."
+    },
+    messages: {
+      missingComposition: 'Molecule "{{filename}}" does not RENDER any atom, molecule, or Radix primitive. Molecules are BY DEFINITION combinations \u2014 they must actually render at least one ../atoms/, ../molecules/, or @radix-ui/ element. Importing without rendering is FAKE composition. Fix: actually render the imported atom in JSX, OR demote this file to an atom if it only renders a single native HTML element, OR delete it.'
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var molecule_must_compose_default = moleculeMustCompose;
+
+// src/rules/next-route-segment-is-thin-delegate.ts
+var DELEGATE_BASENAMES = /* @__PURE__ */ new Set(["layout.tsx", "page.tsx", "template.tsx"]);
+var FALLBACK_BASENAMES = /* @__PURE__ */ new Set([
+  "default.tsx",
+  "error.tsx",
+  "global-error.tsx",
+  "loading.tsx",
+  "not-found.tsx"
+]);
+var SKIP_KEYS = /* @__PURE__ */ new Set(["parent", "loc", "range", "scope"]);
+function collectReturnStatements(body) {
+  const out = [];
+  const visited = /* @__PURE__ */ new WeakSet();
+  function walk(node) {
+    if (!node || typeof node !== "object") return;
+    if (visited.has(node)) return;
+    visited.add(node);
+    const n = node;
+    if (node !== body && (n.type === "FunctionDeclaration" || n.type === "FunctionExpression" || n.type === "ArrowFunctionExpression")) {
+      return;
+    }
+    if (n.type === "ReturnStatement") {
+      out.push(node);
+    }
+    for (const key of Object.keys(n)) {
+      if (SKIP_KEYS.has(key)) continue;
+      const v = n[key];
+      if (Array.isArray(v)) {
+        for (const item of v) walk(item);
+      } else if (v && typeof v === "object") {
+        walk(v);
+      }
+    }
+  }
+  walk(body);
+  return out;
+}
+function tagOf(el) {
+  const name = el.openingElement?.name;
+  if (!name) return null;
+  if (name.type === "JSXIdentifier") return name.name ?? null;
+  return null;
+}
+function describeReturn(arg) {
+  if (!arg || typeof arg !== "object") return "empty";
+  const a = arg;
+  if (a.type === "Literal" && a.value === null) return "null";
+  if (a.type === "JSXElement") {
+    const t = tagOf(arg);
+    return t ? `<${t}/>` : "JSXElement";
+  }
+  if (a.type === "JSXFragment") return "fragment";
+  return a.type ?? "unknown";
+}
+function bioFolderOf(source) {
+  const m = source.match(/\/(atoms|molecules|compounds|organelles|cells|tissues|lib|stores)\//);
+  return m?.[1] ?? "unknown";
+}
+function isTissueSource(source) {
+  if (!source) return false;
+  return /\/tissues\//.test(source);
+}
+var nextRouteSegmentIsThinDelegate = {
+  create(context) {
+    const normalized = context.filename.replaceAll(/\\/g, "/");
+    if (/__tests__\//.test(normalized)) return {};
+    if (!/(?:^|\/)app\//.test(normalized)) return {};
+    const basename = normalized.split("/").pop() ?? "";
+    if (!DELEGATE_BASENAMES.has(basename)) return {};
+    if (FALLBACK_BASENAMES.has(basename)) return {};
+    const importSources = /* @__PURE__ */ 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
+      });
+    }
+    function checkReturn(ret) {
+      const arg = ret.argument;
+      if (!arg || typeof arg !== "object") return;
+      const a = arg;
+      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);
+        }
+        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;
+        });
+        if (meaningful.length !== 1) {
+          context.report({
+            data: { count: String(meaningful.length), file: basename },
+            messageId: "fragmentMustBeSingleDelegate",
+            node: ret
+          });
+          return;
+        }
+        const child = meaningful[0];
+        if (child === void 0 || child.type !== "JSXElement") {
+          context.report({
+            data: { file: basename, found: "non-element-child" },
+            messageId: "mustBeThinDelegate",
+            node: ret
+          });
+          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);
+        }
+        return;
+      }
+      context.report({
+        data: { file: basename, found: describeReturn(arg) },
+        messageId: "mustBeThinDelegate",
+        node: ret
+      });
+    }
+    return {
+      ExportDefaultDeclaration(node) {
+        const decl = node.declaration;
+        if (!decl || decl.type !== "FunctionDeclaration") return;
+        const returns = collectReturnStatements(decl.body);
+        for (const ret of returns) checkReturn(ret);
+      },
+      ImportDeclaration(node) {
+        const source = node.source?.value ?? "";
+        for (const spec of node.specifiers ?? []) {
+          const local = spec.local?.name;
+          if (local) importSources.set(local, source);
+        }
+      }
+    };
+  },
+  fixShape: `A route segment (\`page.tsx\`, \`layout.tsx\`, \`template.tsx\`) returns exactly one imported component, or
+null. No inline JSX, no native HTML wrapper, no helper function, no local component. The delegate it
+returns is a tissue \u2014 a route that renders a cell directly wraps it in a tissue first. Fallback files
+(\`default\`, \`not-found\`, \`loading\`, \`error\`, \`global-error\`) are exempt.`,
+  meta: {
+    docs: {
+      description: "Next.js route segment files (page/layout/template.tsx) must be thin delegates: return exactly one imported component or null. No inline JSX, no native HTML wrapping, no helpers. Route fallback files are exempt."
+    },
+    messages: {
+      delegateMustBeTissue: "Route segment '{{file}}' delegates to '<{{tag}}/>' imported from '{{source}}' (a {{bio}}). Route segments compose TISSUES only \u2014 import {{tag}} from features/*/tissues/** or wrap it in a new tissue.",
+      fragmentMustBeSingleDelegate: "Route segment '{{file}}' returns a fragment with {{count}} elements. Must be a single imported tissue (wrap the fragment contents in a tissue).",
+      mustBeThinDelegate: "Route segment '{{file}}' must return a single imported tissue or null \u2014 found {{found}}. Move the implementation into a tissue and delegate."
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var next_route_segment_is_thin_delegate_default = nextRouteSegmentIsThinDelegate;
+
+// src/rules/no-brand-names.ts
+import * as fs3 from "fs";
+var EXEMPT_PATH = /\/examples\//;
+var escapeForRegex2 = (value) => value.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var noBrandNames = {
+  create(context) {
+    const { allowedSubstrings = [], brands = [] } = context.options?.[0] ?? {};
+    if (brands.length === 0) return {};
+    const filename = context.filename.replaceAll(/\\/g, "/");
+    if (EXEMPT_PATH.test(filename)) return {};
+    const brandPattern = new RegExp(`\\b(?:${brands.map(escapeForRegex2).join("|")})\\b`, "i");
+    const allowedPatterns = allowedSubstrings.map(
+      (allowed) => new RegExp(escapeForRegex2(allowed), "gi")
+    );
+    let programNode = null;
+    return {
+      Program(node) {
+        programNode = node;
+      },
+      "Program:exit"() {
+        let content = context.sourceCode?.text ?? "";
+        if (content === "") {
+          try {
+            content = fs3.readFileSync(filename, "utf8");
+          } catch {
+            return;
+          }
+        }
+        const lines = content.split("\n");
+        for (const [index, line] of lines.entries()) {
+          const stripped = allowedPatterns.reduce(
+            (text, pattern) => text.replaceAll(pattern, ""),
+            line
+          );
+          const match = stripped.match(brandPattern);
+          if (match) {
+            context.report({
+              data: { brand: match[0], line: String(index + 1) },
+              messageId: "brandLeak",
+              node: programNode
+            });
+            return;
+          }
+        }
+      }
+    };
+  },
+  fixShape: `The kit is brand-agnostic: no brand identity in its source \u2014 not in identifiers, strings, copy or
+comments. Brand names live in the demo/example layer. Configure the rule's \`brands\` list (it does
+nothing with an empty list) and put real demo-asset hosts in \`allowedSubstrings\` so a CDN URL never
+trips it.`,
+  meta: {
+    docs: {
+      description: "No brand identity in a brand-agnostic kit. Brand names (in code, copy, or comments) belong in the examples/demo layer, not the kit source. Configure the brand list and any allowed demo-asset substrings through the rule options; with no brands the rule does nothing."
+    },
+    messages: {
+      brandLeak: 'Brand name "{{brand}}" leaked into the kit at line {{line}}. The kit is brand-agnostic \u2014 move brand identity to the examples/demo layer.'
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allowedSubstrings: { items: { type: "string" }, type: "array" },
+          brands: { items: { type: "string" }, type: "array" }
+        },
+        type: "object"
+      }
+    ],
+    type: "problem"
+  }
+};
+var no_brand_names_default = noBrandNames;
+
+// src/rules/no-card-shaped-div.ts
+var biologicalHierarchyPattern = /\/(molecules|compounds|organelles|cells|layouts)\//;
+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+)`
+);
+function extractClassNameString(node) {
+  if (!node) return null;
+  if (node.type === "Literal") {
+    const literal = node;
+    return typeof literal.value === "string" ? literal.value : null;
+  }
+  if (node.type === "JSXExpressionContainer") {
+    return extractClassNameString(node.expression);
+  }
+  if (node.type === "TemplateLiteral") {
+    const tl = node;
+    return tl.quasis.map((q) => q.value?.raw ?? "").join(" ");
+  }
+  if (node.type === "BinaryExpression") {
+    const bin = node;
+    if (bin.operator !== "+") return null;
+    const left = extractClassNameString(bin.left) ?? "";
+    const right = extractClassNameString(bin.right) ?? "";
+    const combined = (left + " " + right).trim();
+    return combined.length > 0 ? combined : null;
+  }
+  return null;
+}
+function isCardLikeClassName(className) {
+  return BORDER_PATTERN.test(className) && BG_PATTERN.test(className);
+}
+var noCardShapedDiv = {
+  create(context) {
+    const filename = context.filename;
+    if (!biologicalHierarchyPattern.test(filename)) return {};
+    return {
+      JSXOpeningElement(node) {
+        if (node?.name?.type !== "JSXIdentifier" || node.name.name !== "div") return;
+        const classAttr = node.attributes?.find(
+          (a) => a?.type === "JSXAttribute" && a?.name?.type === "JSXIdentifier" && a?.name?.name === "className"
+        );
+        if (!classAttr) return;
+        const cls = extractClassNameString(classAttr.value ?? null);
+        if (!cls) return;
+        if (isCardLikeClassName(cls)) {
+          context.report({ messageId: "cardLike", node });
+        }
+      }
+    };
+  },
+  fixShape: `A raw \`<div>\` whose className carries both a border and a background is a card someone re-drew. Use
+the \`Card\` atom. If the shape is genuinely not a card, drop one of the two classes or move the
+styling into an atom that owns it.`,
+  meta: {
+    docs: {
+      description: "Forbid raw <div> styled as a card (border + background combination). Use the `Card` atom instead so consumers compose the design system rather than recreating it."
+    },
+    messages: {
+      cardLike: "This <div> is styled as a card (className contains both a border and background class). Use the `Card` atom instead. The Card atom centralizes card styling so consumers compose the design system instead of recreating it."
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var no_card_shaped_div_default = noCardShapedDiv;
+
+// src/rules/no-cross-feature-stores.ts
+var BIO_FILE_PATTERN = /features\/([^/]+)\/(cells|organelles)\/.*\.(tsx?|ts)$/;
+var STORE_IMPORT_PATTERN = /(?:@\/)?features\/([^/]+)\/stores\//;
+var SHARED_FEATURE = "shared";
+var noCrossFeatureStores = {
+  create(context) {
+    const normalized = context.filename.replaceAll(/\\/g, "/");
+    const fileMatch = normalized.match(BIO_FILE_PATTERN);
+    if (!fileMatch) return {};
+    const ownFeature = fileMatch[1] ?? "";
+    const file = normalized.split("/").pop() || "unknown";
+    const fromModule = (node) => {
+      if (!node.source) return;
+      if (node.importKind === "type") return;
+      const source = node.source.value;
+      const storeMatch = source.match(STORE_IMPORT_PATTERN);
+      if (!storeMatch) return;
+      const importedFeature = storeMatch[1];
+      if (importedFeature === void 0) return;
+      if (importedFeature === ownFeature) return;
+      if (importedFeature === SHARED_FEATURE) return;
+      context.report({
+        data: {
+          file,
+          importedFeature,
+          ownFeature,
+          source
+        },
+        messageId: "crossFeatureStore",
+        node
+      });
+    };
+    return {
+      ExportAllDeclaration: fromModule,
+      ExportNamedDeclaration: fromModule,
+      ImportDeclaration: fromModule
+    };
+  },
+  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 \u2026 from\` is not.`,
+  meta: {
+    docs: {
+      description: "Cells and organelles must not read stores from other features. A cell/organelle in features/X/ may read only from features/X/stores/ or features/shared/stores/. Cross-feature data flows through the parent tissue/organ as props \u2014 never via direct store import."
+    },
+    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.`
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var no_cross_feature_stores_default = noCrossFeatureStores;
+
+// src/rules/no-d1-transaction.ts
+var transactionMethod = "transaction";
+var databaseHandleNames = /* @__PURE__ */ new Set(["db", "database", "drizzle"]);
+var databaseProperties = /* @__PURE__ */ new Set(["db", "database"]);
+function methodName(callee) {
+  if (callee.type !== "MemberExpression") return null;
+  const property = callee.property;
+  if (!property) return null;
+  if (callee.computed !== true)
+    return property.type === "Identifier" ? property.name ?? null : null;
+  return property.type === "Literal" && typeof property.value === "string" ? property.value : null;
+}
+function receiverName(object) {
+  if (!object) return null;
+  if (object.type === "ThisExpression") return "this";
+  if (object.type === "Identifier") return object.name ?? null;
+  if (object.type !== "MemberExpression" || object.computed === true) return null;
+  const property = object.property?.type === "Identifier" ? object.property.name : void 0;
+  if (property === void 0) return null;
+  const owner = receiverName(object.object);
+  return owner === null ? property : `${owner}.${property}`;
+}
+function isDatabaseReceiver(name) {
+  if (name === null) return false;
+  const last = name.slice(name.lastIndexOf(".") + 1);
+  return databaseHandleNames.has(name.toLowerCase()) || databaseProperties.has(last.toLowerCase());
+}
+function takesACallback(callArguments) {
+  const [first] = callArguments;
+  return first?.type === "ArrowFunctionExpression" || first?.type === "FunctionExpression";
+}
+var tenantPlane = /\/packages\/db\/(src|testing)\//;
+var controlPlane = /\/packages\/db\/src\/(identity|placement|inbox-address)\.ts$|\/schema\/control\//;
+var noD1Transaction = {
+  create(context) {
+    const filename = context.filename.replaceAll("\\", "/");
+    if (tenantPlane.test(filename) && !controlPlane.test(filename)) return {};
+    return {
+      CallExpression(node) {
+        const callee = node.callee;
+        if (!callee) return;
+        if (methodName(callee) !== transactionMethod) return;
+        const receiver = receiverName(callee.object);
+        if (!isDatabaseReceiver(receiver) && !takesACallback(node.arguments ?? [])) return;
+        context.report({
+          data: { receiver: receiver ?? "the database" },
+          messageId: "d1HasNoTransactions",
+          node
+        });
+      }
+    };
+  },
+  fixShape: `\`db.transaction()\` type-checks and then throws at runtime on D1. One step writes at most one atomic
+\`db.batch([...])\`; anything larger is two steps with a compensation between them. Reach for the
+saga, not the transaction.`,
+  meta: {
+    docs: {
+      description: "D1 has no transactions. `db.transaction()` type-checks and then throws at runtime (drizzle issue #2463). The tenant plane in packages/db is Postgres and owns its transactions (plan 037); everywhere else one step is one call into it."
+    },
+    messages: {
+      d1HasNoTransactions: "`{{receiver}}.transaction()` throws at runtime on D1 (drizzle #2463). One step writes at most one atomic `db.batch([...])`; consistency across steps is the workflow's compensation chain."
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var no_d1_transaction_default = noD1Transaction;
+
+// src/rules/no-duplicate-jsx-patterns.ts
+var COMPONENT_FILE_PATTERN = /(?:features\/[^/]+\/)?(compounds|organelles|cells|tissues|organs)\/.+\.tsx$/;
+var MIN_CLASS_LENGTH = 30;
+var MIN_DUPLICATES = 3;
+var ITERATORS = /* @__PURE__ */ new Set(["map", "flatMap", "forEach", "filter", "reduce"]);
+function isInsideIteratedRender(node) {
+  let cur = node.parent;
+  while (cur) {
+    if (cur.type === "ArrayExpression") return true;
+    if (cur.type === "ArrowFunctionExpression" || cur.type === "FunctionExpression") {
+      const call = cur.parent;
+      if (call && call.type === "CallExpression" && call.callee?.type === "MemberExpression" && call.callee.property?.name && ITERATORS.has(call.callee.property.name)) {
+        return true;
+      }
+    }
+    cur = cur.parent;
+  }
+  return false;
+}
+function record(map, key, node) {
+  const line = node.loc?.start.line ?? -1;
+  let entry = map.get(key);
+  if (!entry) {
+    entry = { lines: /* @__PURE__ */ new Set(), nodes: [] };
+    map.set(key, entry);
+  }
+  if (entry.lines.has(line)) return;
+  entry.lines.add(line);
+  entry.nodes.push(node);
+}
+var noDuplicateJsxPatterns = {
+  create(context) {
+    const normalized = context.filename.replaceAll(/\\/g, "/");
+    if (!COMPONENT_FILE_PATTERN.test(normalized)) return {};
+    const classNamesByComponent = /* @__PURE__ */ new Map();
+    const allClassNames = /* @__PURE__ */ new Map();
+    return {
+      JSXOpeningElement(node) {
+        if (node.name.type !== "JSXIdentifier") return;
+        const componentName = node.name.name;
+        if (!componentName) return;
+        if (isInsideIteratedRender(node)) return;
+        const classNameAttr = node.attributes.find(
+          (attr) => attr.type === "JSXAttribute" && attr.name?.name === "className" && attr.value?.type === "Literal" && typeof attr.value.value === "string"
+        );
+        if (!classNameAttr || !classNameAttr.value?.value) return;
+        const className = classNameAttr.value.value;
+        if (className.length < MIN_CLASS_LENGTH) return;
+        record(classNamesByComponent, `${componentName}::${className}`, node);
+        record(allClassNames, className, node);
+      },
+      "Program:exit"() {
+        const reportedClassNames = /* @__PURE__ */ new Set();
+        for (const [key, entry] of classNamesByComponent) {
+          if (entry.nodes.length < MIN_DUPLICATES) continue;
+          const [componentName = "", className = ""] = key.split("::");
+          reportedClassNames.add(className);
+          context.report({
+            data: { component: componentName, count: String(entry.nodes.length) },
+            messageId: "duplicateComponentPattern",
+            node: entry.nodes[1]
+          });
+        }
+        for (const [className, entry] of allClassNames) {
+          if (entry.nodes.length < MIN_DUPLICATES) continue;
+          if (reportedClassNames.has(className)) continue;
+          context.report({
+            data: { count: String(entry.nodes.length), preview: className.slice(0, 50) },
+            messageId: "duplicateClassName",
+            node: entry.nodes[1]
+          });
+        }
+      }
+    };
+  },
+  fixShape: `The same JSX shape written three times is a compound waiting to be named. Extract it and call it
+three times, or drive it from an array with \`.map()\`. Three near-identical blocks that differ only in
+their text are one component with a prop.`,
+  meta: {
+    docs: {
+      description: "Detect a hand-duplicated JSX className pattern (same long className repeated 3+ times) that signals a missed compound extraction. Ignores JSX authored once inside an iterator callback (.map/.forEach/etc.) or array literal, and symmetric pairs."
+    },
+    messages: {
+      duplicateClassName: 'className "{{preview}}..." appears {{count}} times. Extract the repeated pattern into a compound or add a variant to the atom.',
+      duplicateComponentPattern: '<{{component}} className="..."> appears {{count}} times with the same className. Extract a reusable compound that encapsulates this styling.'
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var no_duplicate_jsx_patterns_default = noDuplicateJsxPatterns;
+
+// src/rules/no-hook-in-component-disguise.ts
+var EXPLICIT_SIDE_EFFECT_HOOKS = /* @__PURE__ */ new Set([
+  "useEffect",
+  "useInsertionEffect",
+  "useLayoutEffect",
+  "useRef"
+]);
+var CUSTOM_EFFECT_HOOK_PATTERN = /^use[A-Z][A-Za-z0-9]*Effect$/;
+var STORE_HOOK_PATTERN = /^use[A-Z][A-Za-z0-9]*Store$/;
+function isSideEffectHook(name) {
+  if (EXPLICIT_SIDE_EFFECT_HOOKS.has(name)) return true;
+  if (CUSTOM_EFFECT_HOOK_PATTERN.test(name)) return true;
+  if (STORE_HOOK_PATTERN.test(name)) return true;
+  return false;
+}
+var ROUTE_FALLBACK_BASENAMES = /* @__PURE__ */ new Set([
+  "default.tsx",
+  "error.tsx",
+  "global-error.tsx",
+  "loading.tsx",
+  "not-found.tsx"
+]);
+var R3F_PACKAGES = /* @__PURE__ */ new Set(["@react-three/drei", "@react-three/fiber"]);
+function isPascalCase(name) {
+  return /^[A-Z]/.test(name);
+}
+function isNullLiteral(n) {
+  if (!n) return true;
+  return n.type === "Literal" && n.value === null;
+}
+function isChildrenIdentifier(n) {
+  return Boolean(n && n.type === "Identifier" && n.name === "children");
+}
+function isIdentityFragment(n) {
+  if (!n) return false;
+  if (n.type !== "JSXFragment") return false;
+  const children = n.children ?? [];
+  const meaningful = children.filter((c) => {
+    if (c.type === "JSXText") {
+      const text = c.value ?? c.name ?? "";
+      return text.trim().length > 0;
+    }
+    return true;
+  });
+  if (meaningful.length === 0) return true;
+  if (meaningful.length === 1) {
+    const c = meaningful[0];
+    if (c?.type === "JSXExpressionContainer" && c.expression?.type === "Identifier" && c.expression.name === "children") {
+      return true;
+    }
+  }
+  return false;
+}
+function classifyReturnShape(arg) {
+  if (isNullLiteral(arg)) return "identity";
+  if (isChildrenIdentifier(arg)) return "identity";
+  if (isIdentityFragment(arg)) return "identity";
+  return "real";
+}
+function suggestedHookName(componentName) {
+  const trimmed = componentName.replace(/(Provider|Sync|Listener|Hydration)$/, "");
+  const kebab = trimmed.replaceAll(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+  return kebab || "effect";
+}
+var noHookInComponentDisguise = {
+  create(context) {
+    const normalized = context.filename.replaceAll(/\\/g, "/");
+    if (/__tests__\//.test(normalized)) return {};
+    if (!normalized.endsWith(".tsx")) return {};
+    const basename = normalized.split("/").pop() ?? "";
+    if (ROUTE_FALLBACK_BASENAMES.has(basename)) return {};
+    let fileUsesR3F = false;
+    const scopeStack = [];
+    let pendingName = null;
+    function currentScope() {
+      return scopeStack.at(-1) ?? null;
+    }
+    function enterFunction(name, node) {
+      scopeStack.push({
+        calledHooks: /* @__PURE__ */ new Set(),
+        hasIdentityReturn: false,
+        hasNonIdentityReturn: false,
+        name,
+        node
+      });
+    }
+    function exitFunction() {
+      const scope = scopeStack.pop();
+      if (!scope) return;
+      if (fileUsesR3F) return;
+      if (!isPascalCase(scope.name)) return;
+      if (scope.hasNonIdentityReturn) return;
+      if (!scope.hasIdentityReturn) return;
+      if (basename === "page.tsx" && scope.calledHooks.size === 0) return;
+      const hasHooks = scope.calledHooks.size > 0;
+      context.report({
+        data: {
+          hooks: hasHooks ? [...scope.calledHooks].toSorted((a, b) => a.localeCompare(b)).join(", ") : "",
+          name: scope.name,
+          suggested: suggestedHookName(scope.name)
+        },
+        messageId: hasHooks ? "hookInDisguise" : "passthroughComponent",
+        node: scope.node
+      });
+    }
+    return {
+      ArrowFunctionExpression(node) {
+        const name = pendingName ?? "<anonymous>";
+        pendingName = null;
+        enterFunction(name, node);
+        if (node.body && node.body.type !== "BlockStatement") {
+          const shape = classifyReturnShape(node.body);
+          const scope = currentScope();
+          if (scope) {
+            if (shape === "identity") scope.hasIdentityReturn = true;
+            else scope.hasNonIdentityReturn = true;
+          }
+        }
+      },
+      "ArrowFunctionExpression:exit"() {
+        exitFunction();
+      },
+      CallExpression(node) {
+        if (node.callee.type !== "Identifier") return;
+        const scope = currentScope();
+        if (!scope) return;
+        const name = node.callee.name;
+        if (!name) return;
+        if (isSideEffectHook(name)) {
+          scope.calledHooks.add(name);
+        }
+      },
+      FunctionDeclaration(node) {
+        const name = node.id?.name ?? pendingName ?? "<anonymous>";
+        pendingName = null;
+        enterFunction(name, node);
+      },
+      "FunctionDeclaration:exit"() {
+        exitFunction();
+      },
+      FunctionExpression(node) {
+        const name = node.id?.name ?? pendingName ?? "<anonymous>";
+        pendingName = null;
+        enterFunction(name, node);
+      },
+      "FunctionExpression:exit"() {
+        exitFunction();
+      },
+      ImportDeclaration(node) {
+        if (R3F_PACKAGES.has(node.source.value)) {
+          fileUsesR3F = true;
+        }
+      },
+      ReturnStatement(node) {
+        const scope = currentScope();
+        if (!scope) return;
+        const shape = classifyReturnShape(node.argument);
+        if (shape === "identity") scope.hasIdentityReturn = true;
+        else scope.hasNonIdentityReturn = true;
+      },
+      VariableDeclarator(node) {
+        if (node.id?.type === "Identifier" && node.init && (node.init.type === "ArrowFunctionExpression" || node.init.type === "FunctionExpression")) {
+          pendingName = node.id.name ?? null;
+        }
+      }
+    };
+  },
+  fixShape: `A component that calls hooks, renders nothing, and exists only to run an effect is a hook wearing
+\`.tsx\`. Move it to \`organelles/use-<thing>.ts\`, export it as \`use<Thing>\`, and let the cell call it.
+A component returns UI; a hook returns state.`,
+  meta: {
+    docs: {
+      description: "Forbid components whose body calls side-effect hooks (useEffect/useLayoutEffect/useInsertionEffect/useRef) but whose every return is identity (null, bare `children`, `<></>`, `<>{children}</>`). Such a component renders no real UI \u2014 it's a hook masquerading as a component. Move to organelles/use-*-effect.ts and call the hook from a real component. Exempt: route fallback files (default/not-found/loading/error/global-error.tsx) and files importing from @react-three/fiber or @react-three/drei. That is lint-theater."
+    },
+    messages: {
+      hookInDisguise: "Component '{{name}}' has side-effect hooks ({{hooks}}) but renders only identity/null. It's a hook in disguise \u2014 move to organelles/use-{{suggested}}-effect.ts and call the hook from a real component.",
+      passthroughComponent: "Component '{{name}}' renders only identity/null with no effects. It serves no architectural purpose. If this is a metadata-only layout, move `metadata`/`generateMetadata` to the sibling page.tsx and delete this file. If it's structural, give it real content."
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var no_hook_in_component_disguise_default = noHookInComponentDisguise;
+
+// src/rules/no-inert-hidden-jsx.ts
+var PURELY_PRESENTATIONAL_ATTRS = /* @__PURE__ */ new Set([
+  "className",
+  "data-testid",
+  "aria-hidden",
+  "role",
+  "key"
+]);
+function getAttrName(attr) {
+  if (attr.type !== "JSXAttribute") return null;
+  if (attr.name?.type !== "JSXIdentifier") return null;
+  return attr.name.name ?? null;
+}
+var noInertHiddenJsx = {
+  create(context) {
+    const normalized = context.filename.replaceAll(/\\/g, "/");
+    if (/__tests__\//.test(normalized)) return {};
+    return {
+      JSXOpeningElement(node) {
+        if (node.name?.type !== "JSXIdentifier") return;
+        const componentName = node.name.name;
+        if (!componentName) return;
+        const attributes = node.attributes ?? [];
+        const classNameAttr = attributes.find((a) => getAttrName(a) === "className");
+        if (!classNameAttr || !classNameAttr.value) return;
+        if (classNameAttr.value.type !== "Literal") return;
+        const raw = classNameAttr.value.value;
+        if (typeof raw !== "string") return;
+        if (raw.trim() !== "hidden") return;
+        const hasFunctionalAttr = attributes.some((attr) => {
+          if (attr.type === "JSXSpreadAttribute") return true;
+          const name = getAttrName(attr);
+          if (!name) return false;
+          return !PURELY_PRESENTATIONAL_ATTRS.has(name);
+        });
+        if (hasFunctionalAttr) return;
+        context.report({
+          data: { component: componentName },
+          messageId: "inertHiddenRender",
+          node
+        });
+      }
+    };
+  },
+  fixShape: `JSX rendered behind \`hidden\`, \`display:none\` or a dead branch, purely so a compose rule sees a tag,
+is lint-theater. Render it for real or delete it. A gate satisfied by markup nobody can see was not
+satisfied.`,
+  meta: {
+    docs: {
+      description: 'Forbid JSX elements whose only className is "hidden" AND which have no functional attributes (no event handlers, no id, no href, no type, etc.). Such elements render invisible, non-interactive DOM nodes \u2014 the signature of lint-satisfaction imports. Hidden-but-functional elements (file inputs behind labels, skip links, keyboard triggers) are allowed because they have functional attributes.'
+    },
+    messages: {
+      inertHiddenRender: '<{{component}} className="hidden" /> renders an inert, permanently-invisible, non-interactive DOM node \u2014 the signature of lint-theater. Return null or remove the element. If the element is functional but visually hidden (e.g. file input behind a label), add the functional attribute (onChange, onClick, href, id, type, name, etc.) and the rule will recognize it as a legitimate hidden-but-functional element.'
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var no_inert_hidden_jsx_default = noInertHiddenJsx;
+
+// src/rules/no-inline-data-in-jsx.ts
+var COMPONENT_FILE_PATTERN2 = /(?:features\/[^/]+\/)?(compounds|organelles|cells|tissues|organs)\/.+\.tsx$/;
+var MIN_OBJECTS = 3;
+function countObjects(elements) {
+  if (!elements) return 0;
+  return elements.filter((el) => el.type === "ObjectExpression").length;
+}
+var noInlineDataInJsx = {
+  create(context) {
+    const normalized = context.filename.replaceAll(/\\/g, "/");
+    if (!COMPONENT_FILE_PATTERN2.test(normalized)) return {};
+    const feature = normalized.match(/features\/([^/]+)\//)?.[1] || "";
+    return {
+      // Catch: options={[{ ... }, { ... }, { ... }]}
+      JSXAttribute(node) {
+        if (!node.value || node.value.type !== "JSXExpressionContainer") return;
+        const expr = node.value.expression;
+        if (!expr || expr.type !== "ArrayExpression") return;
+        const objectCount = countObjects(expr.elements);
+        if (objectCount < MIN_OBJECTS) return;
+        const propName = node.name?.name || "unknown";
+        const componentName = node.parent?.name?.type === "JSXIdentifier" ? node.parent.name.name || "unknown" : "unknown";
+        context.report({
+          data: {
+            component: componentName,
+            count: String(objectCount),
+            feature,
+            prop: propName
+          },
+          messageId: "inlineDataArray",
+          node
+        });
+      },
+      // Catch: {[{ ... }, { ... }, { ... }].map(...)} inside JSX
+      JSXExpressionContainer(node) {
+        if (!node.expression || node.expression.type !== "CallExpression") return;
+        const callee = node.expression.callee;
+        if (!callee || callee.type !== "MemberExpression") return;
+        if (callee.property?.name !== "map") return;
+        let arrayNode = callee.object;
+        if (arrayNode && arrayNode.type === "TSAsExpression") {
+          arrayNode = arrayNode.expression;
+        }
+        if (arrayNode && arrayNode.type === "SequenceExpression") {
+          return;
+        }
+        if (!arrayNode || arrayNode.type !== "ArrayExpression") return;
+        const objectCount = countObjects(arrayNode.elements);
+        if (objectCount < MIN_OBJECTS) return;
+        context.report({
+          data: {
+            count: String(objectCount),
+            feature
+          },
+          messageId: "inlineDataInJsx",
+          node
+        });
+      }
+    };
+  },
+  fixShape: `An array of three or more objects written inline in JSX is data, not markup. Move it to a \`lib/\`
+module beside the feature, name it, and import it. The component maps over the import; the fact
+lives in one place.`,
+  meta: {
+    docs: {
+      description: "Forbid inline data arrays (3+ object literals) in JSX. Catches both prop values ({options={[...]}}) and inline expression containers ({[...].map()}). Configuration data must live in lib/, not inline in component JSX."
+    },
+    messages: {
+      inlineDataArray: 'Inline array with {{count}} objects passed to prop "{{prop}}" on <{{component}}>. Extract this data to features/{{feature}}/lib/.',
+      inlineDataInJsx: "Inline array with {{count}} objects in JSX expression. Extract this data to features/{{feature}}/lib/ \u2014 component files are for rendering, not data definitions."
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var no_inline_data_in_jsx_default = noInlineDataInJsx;
+
+// src/rules/no-invalid-feature-folders.ts
+var VALID_FOLDERS = /* @__PURE__ */ new Set([
+  "atoms",
+  "cells",
+  "compounds",
+  "lib",
+  "molecules",
+  "organelles",
+  "stores",
+  "tissues"
+]);
+var FEATURE_PATH_PATTERN = /features\/([^/]+)\/([^/]+)\//;
+var noInvalidFeatureFolders = {
+  create(context) {
+    const normalized = context.filename.replaceAll(/\\/g, "/");
+    const match = normalized.match(FEATURE_PATH_PATTERN);
+    if (!match) return {};
+    const feature = match[1] ?? "";
+    const folder = match[2] ?? "";
+    if (!VALID_FOLDERS.has(folder)) {
+      return {
+        Program(node) {
+          context.report({ data: { feature, folder }, messageId: "invalid", node });
+        }
+      };
+    }
+    if (folder === "lib") {
+      const fileName = normalized.split("/").pop() || "";
+      if (fileName.startsWith("use-") || /^use[A-Z]/.test(fileName)) {
+        return {
+          Program(node) {
+            context.report({
+              data: { feature, file: fileName },
+              messageId: "hookInLib",
+              node
+            });
+          }
+        };
+      }
+    }
+    return {};
+  },
+  fixShape: `A feature folder holds only the tiers and their two neighbours: \`atoms\`, \`molecules\`, \`compounds\`,
+\`organelles\`, \`cells\`, \`tissues\`, \`stores\`, \`lib\`. Anything else (\`components\`, \`utils\`, \`helpers\`,
+\`types\`) is an unclassified pile \u2014 put the file in the tier that describes what it does, and pure
+logic in \`lib/\`.`,
+  meta: {
+    docs: {
+      description: 'Files inside features/*/ must be in a valid biological hierarchy folder. Hooks (use-*) must be in organelles/, not lib/. Folders like "dynamic", "utils", "helpers", "components", "hooks" are forbidden.'
+    },
+    messages: {
+      hookInLib: 'Hook file "{{file}}" is in features/{{feature}}/lib/ but hooks must be in features/{{feature}}/organelles/. lib/ is for pure logic only \u2014 no hooks, no state.',
+      invalid: 'File is in "features/{{feature}}/{{folder}}/" which is not a valid biological hierarchy folder. Valid folders: compounds, organelles, cells, tissues, stores, lib.'
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var no_invalid_feature_folders_default = noInvalidFeatureFolders;
+
+// src/rules/no-logic-in-component-files.ts
+var COMPONENT_FILE_PATTERN3 = /(?:features\/[^/]+\/)?(compounds|organelles|cells|tissues|organs)\/.+\.tsx$/;
+var PRIVATE_OR_NON_ENTRYPOINT = /(\.(parts|sections|summary|layouts|icons|types|hooks|utils|context|store|sidebar|data|config|stories|spec|test)\.tsx$|\/index\.tsx$)/;
+function isReactComponent(name) {
+  return /^[A-Z][a-zA-Z0-9]*$/.test(name) && !/^[A-Z0-9_]+$/.test(name);
+}
+function jsxRootIsComponent(node) {
+  if (!node || node.type !== "JSXElement") return false;
+  const name = node.openingElement?.name;
+  if (!name) return false;
+  if (name.type === "JSXMemberExpression") return true;
+  return name.type === "JSXIdentifier" && /^[A-Z]/.test(name.name || "");
+}
+function isThinWrapper(decl) {
+  if (!decl) return false;
+  try {
+    let body = decl.body;
+    if (!body && decl.declarations?.[0]?.init) {
+      body = decl.declarations[0].init.body;
+    }
+    if (!body || Array.isArray(body)) return false;
+    if (body.type === "JSXElement") return jsxRootIsComponent(body);
+    if (body.type === "BlockStatement" && Array.isArray(body.body)) {
+      const stmts = body.body;
+      if (stmts.length !== 1) return false;
+      const only = stmts[0];
+      if (only?.type !== "ReturnStatement") return false;
+      return jsxRootIsComponent(only.argument);
+    }
+  } catch {
+    return false;
+  }
+  return false;
+}
+var noLogicInComponentFiles = {
+  create(context) {
+    const normalized = context.filename.replaceAll(/\\/g, "/");
+    if (!COMPONENT_FILE_PATTERN3.test(normalized)) return {};
+    if (PRIVATE_OR_NON_ENTRYPOINT.test(normalized)) return {};
+    const exportedComponents = [];
+    let programNode = null;
+    return {
+      ExportNamedDeclaration(node) {
+        const decl = node.declaration;
+        if (!decl) return;
+        if (decl.type === "FunctionDeclaration" && decl.id?.name && isReactComponent(decl.id.name) && !isThinWrapper(decl)) {
+          exportedComponents.push(decl.id.name);
+        }
+        if (decl.type === "VariableDeclaration" && decl.declarations) {
+          for (const d of decl.declarations) {
+            const initType = d.init?.type;
+            const isComponentInit = initType === "ArrowFunctionExpression" || initType === "FunctionExpression" || initType === "CallExpression";
+            if (d.id?.name && isReactComponent(d.id.name) && isComponentInit && !isThinWrapper(decl)) {
+              exportedComponents.push(d.id.name);
+            }
+          }
+        }
+      },
+      Program(node) {
+        programNode = node;
+      },
+      "Program:exit"() {
+        if (exportedComponents.length > 1) {
+          context.report({
+            data: {
+              count: String(exportedComponents.length),
+              names: exportedComponents.join(", ")
+            },
+            messageId: "multipleExportedComponents",
+            node: programNode
+          });
+        }
+      }
+    };
+  },
+  fixShape: `A public component file exports ONE component. Several distinct components in one \`.tsx\` is a
+god-file: split them into sibling files, or into private \`.parts.tsx\` / \`.sections.tsx\` siblings of
+the same component. Thin preset wrappers over one imported component do not count against you.`,
+  meta: {
+    docs: {
+      description: "A public component file (`<name>.tsx` in a bio tier) should export ONE component. Multiple exported components in a single public file is a god-file \u2014 split into separate files. Private sibling splits (.parts/.sections/.layouts/.types), co-located types/helpers/hooks, config constants, and thin preset wrappers are accepted and ignored."
+    },
+    messages: {
+      multipleExportedComponents: "File exports {{count}} components ({{names}}). A public component file should export one component \u2014 split the extras into their own files (or a private .parts sibling if they are internal)."
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var no_logic_in_component_files_default = noLogicInComponentFiles;
+
+// src/rules/no-orm-outside-db.ts
+var ormPackage = "drizzle-orm";
+var dataLayerPattern = /\/packages\/db\//;
+function isOrmModule(source) {
+  if (typeof source !== "string") return false;
+  return source === ormPackage || source.startsWith(`${ormPackage}/`);
+}
+var noOrmOutsideDb = {
+  create(context) {
+    const normalized = context.filename.replace(/\\/g, "/");
+    const contained = dataLayerPattern.test(normalized);
+    const check = (source, node) => {
+      if (contained) return;
+      if (!isOrmModule(source)) return;
+      context.report({ data: { source }, messageId: "ormOutsideDb", node });
+    };
+    const fromModule = (node) => {
+      if (!node.source) return;
+      check(node.source?.value, node);
+    };
+    return {
+      ExportAllDeclaration: fromModule,
+      ExportNamedDeclaration: fromModule,
+      ImportDeclaration: fromModule,
+      // `await import('drizzle-orm')` reaches the ORM exactly as a static import does; only a
+      // module named by something other than a literal is beyond deciding.
+      ImportExpression(node) {
+        if (node.source?.type !== "Literal") return;
+        check(node.source.value, node);
+      }
+    };
+  },
+  fixShape: `\`drizzle-orm\` is imported only inside the data-layer package \u2014 statically or via \`await import()\`.
+Everywhere else, reach the data through a query the data layer exports. The ORM is a storage detail
+below the seam, and a caller that names it has crossed it.`,
+  meta: {
+    docs: {
+      description: "drizzle-orm may only be imported inside packages/db. The ORM is a storage detail below the domain, and containing it caps the cost of ever replacing it at one package's internals. Type-only imports count: a type borrowed from the ORM is a line that a replacement would still have to rewrite."
+    },
+    messages: {
+      ormOutsideDb: 'This file imports "{{source}}". drizzle-orm lives only in packages/db \u2014 reach the data through a query exported from @during/db instead, or add the query there.'
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var no_orm_outside_db_default = noOrmOutsideDb;
+
+// src/rules/no-raw-html-atoms.ts
+var noRawHtmlAtoms = {
+  create(context) {
+    const restrictions = context.options[0];
+    if (!restrictions || restrictions.length === 0) return {};
+    const elementMap = /* @__PURE__ */ new Map();
+    for (const r of restrictions) {
+      elementMap.set(r.element, r);
+    }
+    return {
+      JSXOpeningElement(node) {
+        if (node?.name?.type !== "JSXIdentifier") return;
+        const elementName = node.name.name;
+        if (!elementName) return;
+        const restriction = elementMap.get(elementName);
+        if (!restriction) return;
+        context.report({
+          data: {
+            atom: restriction.atom,
+            element: restriction.element,
+            importPath: restriction.importPath
+          },
+          messageId: "forbidden",
+          node
+        });
+      }
+    };
+  },
+  fixShape: `A native element that already has an atom wrapper (\`<button>\`, \`<input>\`, \`<td>\`, \`<header>\`, \u2026) is
+written as the atom in levels 2-6. Import the atom named in the rule's options and use it. Configure
+the element\u2192atom map per repo; with no map the rule does nothing.`,
+  meta: {
+    docs: {
+      description: "Forbid raw native HTML elements when an atom wrapper exists. Use the atom the options name instead."
+    },
+    messages: {
+      forbidden: 'Use <{{atom}}> from "{{importPath}}" instead of raw <{{element}}>. Native HTML elements that have an atom wrapper must not be used directly in molecules/compounds/cells/tissues - use the atom to preserve consistent styling and behavior.'
+    },
+    schema: [
+      {
+        items: {
+          properties: {
+            atom: { type: "string" },
+            element: { type: "string" },
+            importPath: { type: "string" }
+          },
+          required: ["element", "atom", "importPath"],
+          type: "object"
+        },
+        type: "array"
+      }
+    ],
+    type: "problem"
+  }
+};
+var no_raw_html_atoms_default = noRawHtmlAtoms;
+
+// src/rules/no-raw-sql-outside-allowed.ts
+var allowedFiles = [
+  /\/packages\/db\/src\/ops\/backup\.ts$/,
+  /\/packages\/db\/src\/dialect\.ts$/,
+  /\/packages\/db\/src\/cell\/app-role\.ts$/,
+  /\/packages\/db\/src\/queries\/(reads|writes)\/search\.ts$/,
+  /\/__tests__\//,
+  /\/scripts\//,
+  /\/testing\//,
+  /\/seeds\//,
+  /\/migrations\//
+];
+var statement = /^\s*(select|insert|update|delete|create|drop|alter|pragma)\b/i;
+var isClientPrepare = (callee) => callee.type === "MemberExpression" && callee.property?.type === "Identifier" && callee.property.name === "prepare" && callee.object?.type === "MemberExpression" && callee.object.property?.type === "Identifier" && callee.object.property.name === "$client";
+var noRawSqlOutsideAllowed = {
+  create(context) {
+    const normalized = context.filename.replace(/\\/g, "/");
+    if (allowedFiles.some((file) => file.test(normalized))) return {};
+    return {
+      CallExpression(node) {
+        if (isClientPrepare(node.callee)) context.report({ messageId: "rawSql", node });
+      },
+      TaggedTemplateExpression(node) {
+        if (node.tag.type !== "Identifier" || node.tag.name !== "sql") return;
+        const first = node.quasi.quasis[0]?.value.cooked ?? node.quasi.quasis[0]?.value.raw ?? "";
+        if (statement.test(first)) context.report({ messageId: "rawSql", node });
+      }
+    };
+  },
+  fixShape: `Queries are builders on the schema tables; a raw statement spells the table and column names a second
+time and drifts from the first. Keep a tagged \`sql\` template for fragments the builder cannot express, inside the
+few files the rule allows (backup, dialect, search, migrations).`,
+  meta: {
+    docs: {
+      description: "Queries are drizzle builders; a raw statement spells table and column names a second time. Raw SQL is allowed only where drizzle has no vocabulary: FTS5 and dynamic backup snapshots."
+    },
+    messages: {
+      rawSql: "Raw SQL statement outside the allowed files. Use the drizzle builders on the schema tables; keep sql`` for fragments (count(*), coalesce)."
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var no_raw_sql_outside_allowed_default = noRawSqlOutsideAllowed;
+
+// src/rules/no-react-namespace.ts
+var noReactNamespace = {
+  create(context) {
+    return {
+      MemberExpression(node) {
+        if (node.object.type !== "Identifier" || node.object.name !== "React") return;
+        if (node.property.type !== "Identifier" || !node.property.name) return;
+        context.report({
+          data: { member: node.property.name },
+          messageId: "noReactNamespace",
+          node
+        });
+      },
+      TSQualifiedName(node) {
+        if (node.left.type !== "Identifier" || node.left.name !== "React") return;
+        if (!node.right.name) return;
+        context.report({
+          data: { member: node.right.name },
+          messageId: "noReactNamespace",
+          node
+        });
+      }
+    };
+  },
+  fixShape: `\`React.useState\`, \`React.FC\`, \`React.ReactNode\` \u2014 use named imports instead: \`import { useState }\`,
+\`import type { ReactNode }\`. The namespace form defeats tree-shaking and hides what a file actually
+depends on.`,
+  meta: {
+    docs: {
+      description: 'Forbid React.* namespace access (React.ReactNode, React.MouseEvent, etc.). Use explicit named imports instead: import type { ReactNode, MouseEvent } from "react". This keeps imports explicit and tree-shakeable.'
+    },
+    messages: {
+      noReactNamespace: `Use "import type { {{member}} } from 'react'" instead of "React.{{member}}". Explicit named imports are clearer and tree-shakeable.`
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var no_react_namespace_default = noReactNamespace;
+
+// src/rules/no-renamed-html-props.ts
+var forbiddenPropMap = {
+  ariaAtomic: "aria-atomic",
+  ariaBusy: "aria-busy",
+  ariaChecked: "aria-checked",
+  ariaControls: "aria-controls",
+  ariaCurrent: "aria-current",
+  ariaDescribedby: "aria-describedby",
+  ariaDisabled: "aria-disabled",
+  ariaExpanded: "aria-expanded",
+  ariaHaspopup: "aria-haspopup",
+  ariaHidden: "aria-hidden",
+  ariaInvalid: "aria-invalid",
+  ariaLabel: "aria-label",
+  ariaLabelledby: "aria-labelledby",
+  ariaLive: "aria-live",
+  ariaPressed: "aria-pressed",
+  ariaReadonly: "aria-readonly",
+  ariaRequired: "aria-required",
+  ariaSelected: "aria-selected",
+  dataTestid: "data-testid",
+  dataTestId: "data-testid",
+  testId: "data-testid"
+};
+var biologicalHierarchyPattern2 = /\/(molecules|compounds|organelles|cells|layouts)\//;
+var noRenamedHtmlProps = {
+  create(context) {
+    const filename = context.filename;
+    if (!biologicalHierarchyPattern2.test(filename)) return {};
+    const checkProperty = (member) => {
+      if (member.type !== "TSPropertySignature" && member.type !== "PropertyDefinition") return;
+      const key = member.key;
+      if (!key || key.type !== "Identifier") return;
+      const name = key.name;
+      if (!name) return;
+      const standard = forbiddenPropMap[name];
+      if (!standard) return;
+      context.report({
+        data: { forbidden: name, standard },
+        messageId: "renamed",
+        node: member
+      });
+    };
+    return {
+      TSInterfaceBody(node) {
+        for (const member of node.body) {
+          checkProperty(member);
+        }
+      },
+      TSTypeLiteral(node) {
+        for (const member of node.members) {
+          checkProperty(member);
+        }
+      }
+    };
+  },
+  fixShape: `A prop that HTML already names keeps HTML's name: \`aria-label\`, \`data-testid\`, \`id\`, \`name\`, \`form\`.
+Never \`ariaLabel\`, \`testId\` or \`dataTestid\` in an interface. Extend \`ComponentProps<'element'>\` (or
+the Radix primitive's props) and inherit them instead of re-declaring.`,
+  meta: {
+    docs: {
+      description: "Molecules/compounds/cells/layouts must use HTML-native prop names via ComponentProps spreading instead of renaming them (Radix/shadcn convention)"
+    },
+    messages: {
+      renamed: 'Prop "{{forbidden}}" is a renamed HTML attribute. Use the standard HTML attribute name "{{standard}}" via prop spreading. Extend ComponentProps<Element> or Radix primitive props to inherit HTML attributes instead of renaming them.'
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var no_renamed_html_props_default = noRenamedHtmlProps;
+
+// src/rules/no-render-prop-reader.ts
+var noRenderPropReader = {
+  create(context) {
+    return {
+      JSXOpeningElement(node) {
+        if (node.name?.type !== "JSXIdentifier") return;
+        const componentName = node.name.name;
+        if (!componentName) return;
+        const viewProp = node.attributes?.find(
+          (a) => a.type === "JSXAttribute" && a.name?.type === "JSXIdentifier" && a.name.name === "View" && a.value?.type === "JSXExpressionContainer"
+        );
+        if (viewProp) {
+          context.report({
+            data: { component: componentName },
+            messageId: "renderPropReader",
+            node
+          });
+        }
+      },
+      // Catch definition side: function Foo({ View }: { View: React.ComponentType<...> })
+      TSPropertySignature(node) {
+        if (node.key?.name !== "View") return;
+        const ta = node.typeAnnotation?.typeAnnotation;
+        if (!ta?.typeName) return;
+        const tn = ta.typeName;
+        const isComponentType = tn.type === "TSQualifiedName" && tn.left?.name === "React" && tn.right?.name === "ComponentType" || tn.type === "Identifier" && tn.name === "ComponentType";
+        if (!isComponentType) return;
+        const filename = context.filename.replaceAll(/\\/g, "/");
+        const componentName = filename.split("/").pop()?.replace(".tsx", "") || "unknown";
+        context.report({
+          data: { component: componentName },
+          messageId: "renderPropDefinition",
+          node
+        });
+      }
+    };
+  },
+  fixShape: `\`<Reader View={\u2026} />\`, \`<Reader Wrapper={\u2026} NotFound={\u2026} />\` \u2014 a polymorphic render-prop bridge is
+not an organelle: it holds no state and renders no output of its own. Reclassify one of the two ends.
+The state goes in an organelle that renders its own JSX; the arrangement goes in a tissue.`,
+  meta: {
+    docs: {
+      description: "Forbid the View={} render-prop reader pattern. Organelles should read from stores directly and render their own output \u2014 not act as thin bridges that pass data via render props. A real organelle holds state and renders its own output."
+    },
+    messages: {
+      renderPropDefinition: '"{{component}}" accepts a View prop typed as React.ComponentType. This is the render-prop Reader anti-pattern. The organelle should read from the store directly and render its own JSX.',
+      renderPropReader: "<{{component}}> uses a View={{}} render prop. This is the polymorphic render-prop bridge anti-pattern. The organelle should render its own JSX with store data, or the parent should read from the store directly via useShallow."
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var no_render_prop_reader_default = noRenderPropReader;
+
+// src/rules/no-trivial-wrapper-component.ts
+var ROUTE_BASENAMES = /* @__PURE__ */ new Set([
+  "default.tsx",
+  "error.tsx",
+  "global-error.tsx",
+  "layout.tsx",
+  "loading.tsx",
+  "not-found.tsx",
+  "page.tsx",
+  "template.tsx"
+]);
+var R3F_PACKAGES2 = /* @__PURE__ */ new Set(["@react-three/drei", "@react-three/fiber"]);
+var WALK_SKIP_KEYS = /* @__PURE__ */ new Set(["parent", "loc", "range", "scope"]);
+function functionHasHookCall(body) {
+  let found = false;
+  const visited = /* @__PURE__ */ new WeakSet();
+  function walk(node) {
+    if (found) return;
+    if (!node || typeof node !== "object") return;
+    if (visited.has(node)) return;
+    visited.add(node);
+    const n = node;
+    if (n.type === "FunctionDeclaration" || n.type === "FunctionExpression" || n.type === "ArrowFunctionExpression") {
+      if (node !== body) return;
+    }
+    if (n.type === "CallExpression") {
+      const callee = n.callee;
+      if (callee?.type === "Identifier" && callee.name && /^use[A-Z]/.test(callee.name)) {
+        found = true;
+        return;
+      }
+    }
+    for (const key of Object.keys(n)) {
+      if (WALK_SKIP_KEYS.has(key)) continue;
+      const v = n[key];
+      if (Array.isArray(v)) {
+        for (const item of v) walk(item);
+      } else if (v && typeof v === "object") {
+        walk(v);
+      }
+    }
+  }
+  walk(body);
+  return found;
+}
+function hasMeaningfulChildren(el) {
+  const kids = el.children ?? [];
+  for (const c of kids) {
+    if (c.type === "JSXText") {
+      if ((c.value ?? "").trim().length > 0) return true;
+      continue;
+    }
+    return true;
+  }
+  return false;
+}
+function hasDynamicAttr(el) {
+  const attrs = el.openingElement?.attributes ?? [];
+  for (const a of attrs) {
+    if (a.type === "JSXSpreadAttribute") return true;
+    if (a.type !== "JSXAttribute") continue;
+    const v = a.value;
+    if (!v) continue;
+    if (v.type === "Literal") continue;
+    return true;
+  }
+  return false;
+}
+function checkFunction(fnName, fn, importedLocals, importSources, isBridgeFromTissue, report) {
+  if (!/^[A-Z]/.test(fnName)) return;
+  const body = fn.body;
+  if (!body || body.type !== "BlockStatement") return;
+  const stmts = body.body ?? [];
+  if (stmts.length !== 1) return;
+  const only = stmts[0];
+  if (!only || only.type !== "ReturnStatement") return;
+  const arg = only.argument;
+  if (!arg || arg.type !== "JSXElement") return;
+  const tagNode = arg.openingElement?.name;
+  if (tagNode?.type !== "JSXIdentifier") return;
+  const tag = tagNode.name ?? "";
+  if (!/^[A-Z]/.test(tag)) return;
+  if (!importedLocals.has(tag)) return;
+  if (hasMeaningfulChildren(arg)) return;
+  if (hasDynamicAttr(arg)) return;
+  if (functionHasHookCall(body)) return;
+  if (isBridgeFromTissue) {
+    const source = importSources.get(tag) ?? "";
+    const wrapsNonTissueBio = /\/(cells|compounds|organelles|molecules|atoms)\//.test(source);
+    if (wrapsNonTissueBio) return;
+  }
+  report({
+    data: { inner: tag, name: fnName },
+    messageId: "trivialWrapper",
+    node: fn
+  });
+}
+var noTrivialWrapperComponent = {
+  create(context) {
+    const normalized = context.filename.replaceAll(/\\/g, "/");
+    if (/__tests__\//.test(normalized)) return {};
+    const basename = normalized.split("/").pop() ?? "";
+    if (/(?:^|\/)app\//.test(normalized) && ROUTE_BASENAMES.has(basename)) return {};
+    const isBridgeFromTissue = /(?:features\/[^/]+\/)?tissues\//.test(normalized);
+    let fileUsesR3F = false;
+    const importedLocals = /* @__PURE__ */ new Set();
+    const importSources = /* @__PURE__ */ new Map();
+    return {
+      ExportDefaultDeclaration(node) {
+        if (fileUsesR3F) return;
+        const decl = node.declaration;
+        if (!decl || decl.type !== "FunctionDeclaration") return;
+        const name = decl.id?.name ?? "";
+        if (!name) return;
+        checkFunction(name, decl, importedLocals, importSources, isBridgeFromTissue, context.report);
+      },
+      ExportNamedDeclaration(node) {
+        if (fileUsesR3F) return;
+        const decl = node.declaration;
+        if (!decl || decl.type !== "FunctionDeclaration") return;
+        const name = decl.id?.name ?? "";
+        if (!name) return;
+        checkFunction(name, decl, importedLocals, importSources, isBridgeFromTissue, context.report);
+      },
+      ImportDeclaration(node) {
+        if (R3F_PACKAGES2.has(node.source.value)) {
+          fileUsesR3F = true;
+        }
+        for (const spec of node.specifiers ?? []) {
+          const local = spec.local?.name;
+          if (local) {
+            importedLocals.add(local);
+            importSources.set(local, node.source.value);
+          }
+        }
+      }
+    };
+  },
+  fixShape: `A component whose whole body is \`return <Imported/>\` \u2014 no children, no dynamic attribute, no hook \u2014
+is a rename, not a layer. Delete it and use the imported component directly, or give it the prop that
+justifies its existence. Route files are exempt: thin delegation is their purpose.`,
+  meta: {
+    docs: {
+      description: "Flag components whose body is only `return <ImportedComponent/>` with no children, no dynamic attrs, and no hooks. Such components are trivial wrappers \u2014 pointless renames that add a layer without value. If you need the shape, inline or delete. Route files are exempt (thin delegation is their purpose)."
+    },
+    messages: {
+      trivialWrapper: "Component '{{name}}' is a trivial wrapper \u2014 body is only `return <{{inner}}/>` with no children, no dynamic attrs, no hooks. This is lint-theater: it renames {{inner}} for no reason. Delete the wrapper and call {{inner}} directly, OR give the component real work (wrap in structure, compose multiple elements, add hooks, or pass through children)."
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var no_trivial_wrapper_component_default = noTrivialWrapperComponent;
+
+// src/rules/no-ts-in-bio-folders.ts
+var BIO_FOLDER_TS_PATTERN = /(?:features\/([^/]+)\/)?(atoms|molecules|compounds|cells|tissues|gutenberg|emails|organs)\/[^/]+\.ts$/;
+var noTsInBioFolders = {
+  create(context) {
+    const normalized = context.filename.replaceAll(/\\/g, "/");
+    const match = normalized.match(BIO_FOLDER_TS_PATTERN);
+    if (!match) return {};
+    const file = normalized.split("/").pop() || "";
+    if (file === "index.ts" || file.endsWith(".types.ts")) return {};
+    const folder = match[2] ?? "";
+    return {
+      Program(node) {
+        context.report({
+          data: { file, folder },
+          messageId: "tsInBioFolder",
+          node
+        });
+      }
+    };
+  },
+  fixShape: `Component folders hold \`.tsx\`. A \`.ts\` file in \`atoms/\`, \`molecules/\`, \`compounds/\`, \`cells/\` or
+\`tissues/\` is logic that wandered in \u2014 move it to \`lib/\`, a hook to \`organelles/\`, a store to
+\`stores/\`. The barrel (\`index.ts\`) and a co-located \`<component>.types.ts\` are the two exceptions,
+and \`organelles/\` may hold \`use-*.ts\` hooks by design.`,
+  meta: {
+    docs: {
+      description: "Pure .ts files must not live in biological component folders (atoms/, molecules/, compounds/, cells/, tissues/, gutenberg/, emails/). Component folders are for .tsx files only. Pure logic and config go in lib/; hooks go in organelles/; stores go in stores/. Exception: co-located `<component>.types.ts` files are allowed."
+    },
+    messages: {
+      tsInBioFolder: '"{{file}}" is a .ts file in {{folder}}/. Only .tsx components (and co-located *.types.ts) belong here. Move pure logic to lib/, hooks to organelles/, stores to stores/.'
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var no_ts_in_bio_folders_default = noTsInBioFolders;
+
+// src/rules/no-type-definitions-in-components.ts
+var COMPONENT_FILE_PATTERN4 = /(?:features\/[^/]+\/)?(compounds|organelles|cells|tissues|organs)\/.+\.tsx$/;
+var noTypeDefinitionsInComponents = {
+  create(context) {
+    const normalized = context.filename.replaceAll(/\\/g, "/");
+    if (!COMPONENT_FILE_PATTERN4.test(normalized)) return {};
+    const feature = normalized.match(/features\/([^/]+)\//)?.[1] || "";
+    return {
+      TSInterfaceDeclaration(node) {
+        const name = node.id?.name || "unknown";
+        context.report({
+          data: { feature, name },
+          messageId: "interfaceInComponent",
+          node
+        });
+      },
+      TSTypeAliasDeclaration(node) {
+        const name = node.id?.name || "unknown";
+        context.report({
+          data: { feature, name },
+          messageId: "typeInComponent",
+          node
+        });
+      }
+    };
+  },
+  fixShape: `Props are typed inline in the component's signature. No \`interface FooProps\`, no \`type\` declaration
+in a \`.tsx\`. If a shape is shared, it goes in \`lib/types.ts\` or a co-located \`<component>.types.ts\`
+and is imported.`,
+  meta: {
+    docs: {
+      description: "Component .tsx files must not contain interface or type declarations. Props must be typed inline in the function signature. Shared types go in features/*/lib/types.ts."
+    },
+    messages: {
+      interfaceInComponent: 'Interface "{{name}}" defined in a component file. Inline the props in the function signature: ({ prop }: { prop: Type }) or move shared types to features/{{feature}}/lib/types.ts',
+      typeInComponent: 'Type alias "{{name}}" defined in a component file. Inline the type or move to features/{{feature}}/lib/types.ts'
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var no_type_definitions_in_components_default = noTypeDefinitionsInComponents;
+
+// src/rules/no-void-port.ts
+var voidPromise = (annotation) => {
+  if (annotation.type !== "TSTypeReference" || annotation.typeName?.name !== "Promise") {
+    return false;
+  }
+  const [argument] = (annotation.typeArguments ?? annotation.typeParameters)?.params ?? [];
+  return argument?.type === "TSVoidKeyword";
+};
+var noVoidPort = {
+  create(context) {
+    return {
+      ExportNamedDeclaration(node) {
+        const alias = node.declaration;
+        if (alias?.type !== "TSTypeAliasDeclaration" || alias.id === void 0) return;
+        const fn = alias.typeAnnotation;
+        if (fn?.type !== "TSFunctionType") return;
+        const returned = fn.returnType?.typeAnnotation;
+        if (returned === void 0 || !voidPromise(returned)) return;
+        context.report({ data: { name: alias.id.name }, messageId: "voidPort", node });
+      }
+    };
+  },
+  fixShape: `An exported function type that can fail returns \`Result<void, TaggedError>\`, never \`Promise<void>\` \u2014
+\`void\` leaves the caller no way to know it failed. A module-private callback whose failure channel is
+the engine that catches it is not a port and is unaffected.`,
+  meta: {
+    docs: {
+      description: "An exported function type alias returning Promise<void> is a port with no answer: whoever calls it cannot know it failed. Ports return Result<void, Error> from better-result. A module-private callback is not a port."
+    },
+    messages: {
+      voidPort: '"{{name}}" returns Promise<void>, so the caller cannot know it failed. Return Result<void, YourTaggedError> from better-result and let the caller decide.'
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var no_void_port_default = noVoidPort;
+
+// src/rules/organelle-dependency.ts
+var DEFAULT_SHARED_FEATURES = ["shared"];
+var organelleDependency = {
+  create(context) {
+    const sharedFeatures = new Set(context.options?.[0]?.sharedFeatures ?? DEFAULT_SHARED_FEATURES);
+    const filename = context.filename.replaceAll(/\\/g, "/");
+    const organelleMatch = filename.match(/(?:features\/([^/]+)\/)?organelles\//);
+    if (!organelleMatch) return {};
+    const currentFeature = organelleMatch[1];
+    const shortName = filename.split("/").pop() || filename;
+    return {
+      ImportDeclaration(node) {
+        if (node.importKind === "type") return;
+        const source = node.source.value;
+        if (/\/cells\//.test(source)) {
+          context.report({
+            data: { file: shortName, source },
+            messageId: "forbidden",
+            node
+          });
+          return;
+        }
+        if (/\/tissues\//.test(source) || /\/organs\//.test(source) || /(?:^|\/)layouts\//.test(source) || /apps\/web\/app\//.test(source)) {
+          context.report({
+            data: { file: shortName, source },
+            messageId: "forbidden",
+            node
+          });
+          return;
+        }
+        const crossFeatureOrganelleMatch = source.match(/features\/([^/]+)\/organelles\//);
+        if (crossFeatureOrganelleMatch) {
+          const importedFeature = crossFeatureOrganelleMatch[1] ?? "";
+          if (importedFeature !== currentFeature && !sharedFeatures.has(importedFeature)) {
+            context.report({
+              data: { file: shortName, source },
+              messageId: "forbidden",
+              node
+            });
+          }
+        }
+      }
+    };
+  },
+  fixShape: `An organelle may reach atoms, molecules, compounds, stores, domains and other organelles. Cells,
+tissues, organs and layouts are above it \u2014 a cell contains the organelle, never the reverse.
+Cross-feature organelle imports are allowed only from the features named in the rule's
+\`sharedFeatures\` option (default: \`shared\`); anything else flows through the cell as props.`,
+  meta: {
+    docs: {
+      description: "Organelles may depend on atoms, molecules, compounds, stores, domains, and OTHER ORGANELLES (sub-organelles: nucleolus in nucleus, thylakoid in chloroplast). Organelles cannot depend on cells, tissues, organs, or layouts - direction is wrong: cells contain organelles, not the reverse. Cross-feature organelle imports are allowed only from shared/document/charts (shared infra) or same feature."
+    },
+    messages: {
+      forbidden: 'Organelle "{{file}}" cannot import from "{{source}}". Organelles may depend on atoms, molecules, compounds, stores, domains, and sub-organelles (same feature or shared/document/charts).'
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          sharedFeatures: { items: { type: "string" }, type: "array" }
+        },
+        type: "object"
+      }
+    ],
+    type: "problem"
+  }
+};
+var organelle_dependency_default = organelleDependency;
+
+// src/rules/organelle-single-source.ts
+var ORGANELLE_FILE_PATTERN = /(?:features\/[^/]+\/)?organelles\//;
+var ZUSTAND_STORE_PATTERN = /^use\w+Store$/;
+var FORM_SOURCES = /* @__PURE__ */ new Set(["react-hook-form"]);
+var FORM_CONTEXT_IMPORT_PATTERN = /FormContext$/;
+var organelleSingleSource = {
+  create(context) {
+    const normalized = context.filename.replaceAll(/\\/g, "/");
+    if (!ORGANELLE_FILE_PATTERN.test(normalized)) return {};
+    const file = normalized.split("/").pop()?.replace(/\.tsx?$/, "") || "unknown";
+    const storeHooks = /* @__PURE__ */ new Map();
+    let formNode = null;
+    let formSource = "";
+    let programNode = null;
+    const fromModule = (node) => {
+      if (!node.source) return;
+      if (node.importKind === "type") return;
+      const source = node.source.value;
+      if (FORM_SOURCES.has(source) && !formNode) {
+        formNode = node;
+        formSource = source;
+        return;
+      }
+      if (source.includes("/providers/")) {
+        const specs = node.specifiers ?? [];
+        for (const spec of specs) {
+          const localName = spec.local?.name || "";
+          if (FORM_CONTEXT_IMPORT_PATTERN.test(localName) && !formNode) {
+            formNode = node;
+            formSource = localName;
+          }
+        }
+      }
+    };
+    return {
+      CallExpression(node) {
+        if (node.callee.type !== "Identifier") return;
+        const name = node.callee.name;
+        if (!name) return;
+        if (ZUSTAND_STORE_PATTERN.test(name) && !storeHooks.has(name)) {
+          storeHooks.set(name, node);
+        }
+      },
+      ExportAllDeclaration: fromModule,
+      ExportNamedDeclaration: fromModule,
+      ImportDeclaration: fromModule,
+      Program(node) {
+        programNode = node;
+      },
+      "Program:exit"() {
+        const storeNames = [...storeHooks.keys()];
+        const isTsx = normalized.endsWith(".tsx");
+        if (storeNames.length > 0 && formNode) {
+          context.report({
+            data: {
+              file,
+              formSource,
+              zustandSource: storeNames.join(", ")
+            },
+            messageId: isTsx ? "mixedStoreAndFormComponent" : "mixedStoreAndFormHook",
+            node: programNode
+          });
+        }
+        if (storeNames.length > 1) {
+          context.report({
+            data: {
+              count: String(storeNames.length),
+              file,
+              stores: storeNames.join(", ")
+            },
+            messageId: isTsx ? "multipleStoresComponent" : "multipleStoresHook",
+            node: programNode
+          });
+        }
+      }
+    };
+  },
+  fixShape: `One organelle, one state source: at most ONE Zustand store, and never Zustand and react-hook-form in
+the same file. Mixing them means DECOMPOSE, not promote \u2014 split into one focused organelle per
+source. The CELL is the only level where several sources meet; it derives and passes props down.`,
+  meta: {
+    docs: {
+      description: "Organelles must have a single state source. (1) An organelle must not mix Zustand and react-hook-form \u2014 the cell coordinates across sources. (2) An organelle must read from at most ONE Zustand store \u2014 if it needs multiple stores, the cell should derive and pass the data down."
+    },
+    messages: {
+      mixedStoreAndFormComponent: 'Organelle "{{file}}" mixes Zustand ({{zustandSource}}) and form state ({{formSource}}). DECOMPOSE: split into a store organelle + a form organelle, each with ONE source. Cell composes both and passes derived data as props.',
+      mixedStoreAndFormHook: 'Hook "{{file}}" mixes Zustand ({{zustandSource}}) and form state ({{formSource}}). SPLIT into separate hooks \u2014 one per source. Cell calls both.',
+      multipleStoresComponent: 'Organelle "{{file}}" reads from {{count}} stores ({{stores}}). DECOMPOSE: split into {{count}} focused organelles, each reading ONE store. Cell composes them and passes shared/derived data as props to compounds.',
+      multipleStoresHook: 'Hook "{{file}}" reads from {{count}} stores ({{stores}}). SPLIT into {{count}} hooks \u2014 one per store. Cell calls all of them.'
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var organelle_single_source_default = organelleSingleSource;
+
+// src/rules/queries-require-org-scope.ts
+var QUERY_FILE_PATTERN = /\/db\/src\/queries\/.*\.ts$/;
+function writesOrgId(annotation) {
+  if (!annotation) return false;
+  if (annotation.type === "TSIntersectionType")
+    return (annotation.types ?? []).some((member) => writesOrgId(member));
+  if (annotation.type !== "TSTypeLiteral") return false;
+  return (annotation.members ?? []).some(
+    (member) => member.type === "TSPropertySignature" && member.key?.name === "orgId"
+  );
+}
+function declaresOrgId(param) {
+  return writesOrgId(param.typeAnnotation?.typeAnnotation);
+}
+var queriesRequireOrgScope = {
+  create(context) {
+    const normalized = context.filename.replace(/\\/g, "/");
+    if (!QUERY_FILE_PATTERN.test(normalized)) return {};
+    const check = (name, params, node) => {
+      if (params.some(declaresOrgId)) return;
+      context.report({ data: { name }, messageId: "missingOrgScope", node });
+    };
+    return {
+      "ExportNamedDeclaration > FunctionDeclaration"(node) {
+        if (!node.id?.name) return;
+        check(node.id.name, node.params ?? [], node);
+      },
+      "ExportNamedDeclaration > VariableDeclaration"(node) {
+        for (const declarator of node.declarations ?? []) {
+          const init = declarator.init;
+          if (!init) continue;
+          if (init.type !== "ArrowFunctionExpression" && init.type !== "FunctionExpression")
+            continue;
+          if (declarator.id?.type !== "Identifier" || !declarator.id.name) continue;
+          check(declarator.id.name, init.params ?? [], node);
+        }
+      }
+    };
+  },
+  fixShape: `Every exported query takes \`(db, params)\` where \`params\` WRITES \`orgId: string\` inline in the
+signature \u2014 a type alias says nothing checkable. An intersection is fine as long as one member spells
+\`orgId\`. A query that cannot name the organisation cannot be scoped to it.`,
+  meta: {
+    docs: {
+      description: "Every exported query in packages/db/src/queries/ must take orgId in an inline params type literal. The predicate belongs to the query \u2014 the row-level policies are the wall behind it \u2014 and org scoping is enforced by the query signature, and a params type hidden behind an alias cannot be checked, so the literal must be written in the signature."
+    },
+    messages: {
+      missingOrgScope: 'Query "{{name}}" does not declare orgId. Give it a (db, params) signature whose params type literal includes "orgId: string" \u2014 every read and write is org-scoped (plan 026 D3).'
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var queries_require_org_scope_default = queriesRequireOrgScope;
+
+// src/rules/queue-loop-is-the-library.ts
+var queueMessageMethods = /* @__PURE__ */ new Set(["ack", "retry", "ackAll", "retryAll"]);
+var queueLoopIsTheLibrary = {
+  create(context) {
+    if (/node_modules|\/__tests__\//.test(context.filename)) return {};
+    return {
+      CallExpression(node) {
+        const property = node.callee.type === "MemberExpression" ? node.callee.property : void 0;
+        const name = property?.type === "Identifier" ? property.name : void 0;
+        if (name === void 0 || !queueMessageMethods.has(name)) return;
+        context.report({ data: { method: name }, messageId: "handRolledLoop", node });
+      }
+    };
+  },
+  fixShape: `Application code never calls a queue message's \`ack()\`, \`retry()\`, \`ackAll()\` or \`retryAll()\`. The
+consumer loop, the dedupe and the retry policy belong to the library \u2014 hand it the batch. Your code
+decides what an event MEANS and throws when it cannot.`,
+  meta: {
+    docs: {
+      description: "Application code never calls a queue message's ack/retry: sagaflow's handleQueue owns the consumer loop, the dedupe (`seen`) and the retry policy. A consumer decides what an event means in `onEvent` and throws when it cannot."
+    },
+    messages: {
+      handRolledLoop: `".{{method}}()" is the queue loop, and the loop is sagaflow's: hand the batch to handleQueue({ seen, onEvent }) and throw from onEvent when a message cannot be handled.`
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var queue_loop_is_the_library_default = queueLoopIsTheLibrary;
+
+// src/rules/ssot-no-inline-facts.ts
+var factOwners = [
+  /\/constants\.ts$/,
+  /\/packages\/domains\//,
+  /\/packages\/client\/src\//,
+  /\/lib\/env\.ts$/,
+  /\/lib\/routes\.ts$/,
+  /\/lib\/selectors\.ts$/,
+  /\/src\/paths\.ts$/,
+  /\/rest\/paths\.ts$/,
+  /\/packages\/db\/src\/schema\//,
+  /\/__tests__\//,
+  /\/scripts\//,
+  /\/testing\//,
+  /\/test\//,
+  /\/seeds\//,
+  /\/migrations\//,
+  /\.config\.(ts|mjs|js)$/
+];
+var libraryVocabulary = /* @__PURE__ */ new Set([
+  "use client",
+  "use server",
+  "content-type",
+  "content-length",
+  "content-disposition",
+  "authorization",
+  "cookie",
+  "set-cookie",
+  "cache-control",
+  "user-agent",
+  "application/json",
+  "application/octet-stream",
+  "application/pdf",
+  "application/ld+json",
+  "text/plain",
+  "text/csv",
+  "text/html",
+  "BAD_REQUEST",
+  "UNAUTHORIZED",
+  "FORBIDDEN",
+  "NOT_FOUND",
+  "CONFLICT",
+  "PRECONDITION_FAILED",
+  "TOO_MANY_REQUESTS",
+  "INTERNAL_SERVER_ERROR",
+  "NOT_IMPLEMENTED",
+  "TIMEOUT",
+  "CLIENT_CLOSED_REQUEST",
+  "PAYLOAD_TOO_LARGE",
+  "UNPROCESSABLE_CONTENT",
+  "METHOD_NOT_SUPPORTED",
+  "UNSUPPORTED_MEDIA_TYPE",
+  "BAD_GATEWAY",
+  "SERVICE_UNAVAILABLE",
+  "GATEWAY_TIMEOUT",
+  "PARSE_ERROR",
+  "https://schema.org",
+  "summary_large_image",
+  "https://www.w3.org/2000/svg",
+  "http://www.w3.org/2000/svg"
+]);
+var styleAttributes = /* @__PURE__ */ new Set([
+  "className",
+  "class",
+  "data-testid",
+  "id",
+  "key",
+  "htmlFor",
+  "for",
+  "name",
+  "transform",
+  "style",
+  "placeholder",
+  "autoComplete"
+]);
+var styleCallees = /* @__PURE__ */ new Set(["cn", "clsx", "twMerge", "cva", "tv"]);
+var declarationCallees = /* @__PURE__ */ new Set([
+  "declare",
+  "saga",
+  "step",
+  "action",
+  "defineEvent",
+  "defineWorkflow",
+  "createStep",
+  "sqliteTable",
+  "text",
+  "integer",
+  "real",
+  "blob",
+  "index",
+  "uniqueIndex",
+  "primaryKey",
+  "foreignKey",
+  "check",
+  "literal",
+  "enum"
+]);
+var formFieldCallees = /* @__PURE__ */ new Set([
+  "register",
+  "watch",
+  "useWatch",
+  "setValue",
+  "getValues",
+  "getFieldState",
+  "trigger",
+  "resetField",
+  "setError",
+  "clearErrors",
+  "setFocus",
+  "useController",
+  "useFieldArray"
+]);
+var isFactShaped = (literal) => {
+  if (literal.length < 4 || /\s/.test(literal)) return false;
+  if (libraryVocabulary.has(literal)) return false;
+  if (/^(text|application|image|audio|video|multipart|font)\//.test(literal)) return false;
+  if (literal.startsWith("/")) return true;
+  if (literal.includes("://")) return true;
+  if (/^[A-Z][A-Z0-9]*(_[A-Z0-9]+)+$/.test(literal)) return true;
+  if (/^[a-z][a-z0-9]*(\.[a-z][a-z0-9]*)+$/.test(literal)) return true;
+  return literal.length >= 16 && !/^[a-z0-9:\-[\]/.%#!]+$/.test(literal);
+};
+var nameOf = (node) => {
+  if (node === void 0) return void 0;
+  if (typeof node === "string") return node;
+  if (node.type === "Identifier" || node.type === "JSXIdentifier") return node.name;
+  if (node.type === "Literal") return String(node.value);
+  return void 0;
+};
+var isSpelledAsStyleOrModule = (node) => {
+  let current = node.parent;
+  let child = node;
+  while (current && typeof current.type === "string" && current.type !== "Program") {
+    if (current.type === "JSXAttribute") return styleAttributes.has(nameOf(current.name) ?? "");
+    if (current.type === "Property" && current.key === child) return true;
+    if (current.type === "Property" && styleAttributes.has(nameOf(current.key) ?? "")) return true;
+    if (current.type === "CallExpression") {
+      const callee = current.callee;
+      const calleeName = callee?.type === "MemberExpression" ? nameOf(callee.property) : nameOf(callee);
+      if (styleCallees.has(calleeName ?? "") || formFieldCallees.has(calleeName ?? "")) return true;
+      const firstArgument = current.arguments?.[0];
+      if (declarationCallees.has(calleeName ?? "") && firstArgument === child) return true;
+    }
+    if (current.type === "ImportExpression" || current.type.startsWith("TS")) return true;
+    if ((current.type === "ImportDeclaration" || current.type === "ExportNamedDeclaration" || current.type === "ExportAllDeclaration") && current.source === child) {
+      return true;
+    }
+    child = current;
+    current = current.parent;
+  }
+  return false;
+};
+var ssotNoInlineFacts = {
+  create(context) {
+    const normalized = context.filename.replace(/\\/g, "/");
+    if (factOwners.some((owner) => owner.test(normalized))) return {};
+    const check = (literal, node) => {
+      if (!isFactShaped(literal)) return;
+      if (isSpelledAsStyleOrModule(node)) return;
+      context.report({ data: { literal }, messageId: "inlineFact", node });
+    };
+    return {
+      Literal(node) {
+        if (typeof node.value === "string") check(node.value, node);
+      },
+      TemplateLiteral(node) {
+        if ((node.expressions?.length ?? 0) > 0) return;
+        check(node.quasis?.[0]?.value?.cooked ?? "", node);
+      }
+    };
+  },
+  fixShape: `A route, a URL, a code, a dotted key: a fact is declared once, in the module that owns it, and
+imported. An inline literal used as configuration is a second copy waiting to drift \u2014 name it and put
+it where its owner lives.`,
+  meta: {
+    docs: {
+      description: "A fact \u2014 a route, a URL, a CODE, a dotted.name, a long key \u2014 is declared once, in its owner module (the owning module, lib/routes.ts, lib/env.ts, @during/client), and imported everywhere else. Spelling it inline makes a second source."
+    },
+    messages: {
+      inlineFact: '"{{literal}}" is a fact spelled inline. Declare it once in its owner module and import it.'
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var ssot_no_inline_facts_default = ssotNoInlineFacts;
+
+// src/rules/ssot-no-process-env.ts
+var envDoors = [
+  /\/lib\/env\.ts$/,
+  /\/next\.config\.(ts|mjs|js)$/,
+  /\.config\.(ts|mjs|js)$/,
+  /\/scripts\//,
+  /\/__tests__\//,
+  /\/testing\//,
+  /\/test\//,
+  /\/seeds\//
+];
+var isProcessEnv = (node) => node.object.type === "Identifier" && node.object.name === "process" && node.property.type === "Identifier" && node.property.name === "env";
+var ssotNoProcessEnv = {
+  create(context) {
+    const normalized = context.filename.replace(/\\/g, "/");
+    if (envDoors.some((door) => door.test(normalized))) return {};
+    return {
+      MemberExpression(node) {
+        if (isProcessEnv(node)) context.report({ messageId: "envOutsideDoor", node });
+      }
+    };
+  },
+  fixShape: `\`process.env\` is read at one door per app \u2014 the env module, the framework config, scripts and tests.
+Everywhere else, import the typed value from that door. A second reader is a second place the name
+can be misspelled and a second default nobody agreed to.`,
+  meta: {
+    docs: {
+      description: "A host reads its environment in exactly one place (lib/env.ts, parsed once); every other module imports the parsed `env`. Reading process.env elsewhere makes a second source of configuration."
+    },
+    messages: {
+      envOutsideDoor: "process.env is read outside the env door. Add the variable to lib/env.ts and import `env` from there."
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var ssot_no_process_env_default = ssotNoProcessEnv;
+
+// src/rules/step-opens-its-own-cell.ts
+var STEP = "step";
+var readable = (pattern) => pattern.replaceAll("\\", "").replace(/\$$/, "");
+var stepOpensItsOwnCell = {
+  create(context) {
+    const { engine, within, wrapper } = context.options?.[0] ?? {};
+    if (engine === void 0 || within === void 0) return {};
+    const filename = context.filename.replaceAll("\\", "/");
+    if (!new RegExp(within).test(filename)) return {};
+    if (wrapper !== void 0 && new RegExp(wrapper).test(filename)) return {};
+    const file = filename.split("/").pop() ?? filename;
+    return {
+      ImportDeclaration(node) {
+        if (node.importKind === "type") return;
+        if (node.source.value !== engine) return;
+        for (const specifier of node.specifiers ?? []) {
+          if (specifier.type !== "ImportSpecifier") continue;
+          if (specifier.importKind === "type") continue;
+          if (specifier.imported?.name !== STEP) continue;
+          context.report({
+            data: {
+              engine,
+              file,
+              wrapper: wrapper === void 0 ? "the repo's own step wrapper" : readable(wrapper)
+            },
+            messageId: "engineStep",
+            node
+          });
+        }
+      }
+    };
+  },
+  fixShape: `Inside the guarded workflow tree, import \`step\` from the repo's own wrapper, never from the engine
+package. A durable run hibernates and retries between steps, so each step body must open the
+connection it uses rather than share one opened once per run \u2014 the wrapper does that, the engine's
+\`step\` does not. The wrapper file is the one place allowed to reach the engine. Configure
+\`engine\`, \`within\` and \`wrapper\`; unconfigured, the rule does nothing.`,
+  meta: {
+    docs: {
+      description: "A durable saga takes its `step` from the repo's own wrapper, which opens a connection inside each step body \u2014 a durable run hibernates and retries, so a handle shared across steps is dead by the time a later step uses it. The engine module, the guarded tree and the wrapper file are options; with none the rule does nothing."
+    },
+    messages: {
+      engineStep: '"{{file}}" imports `step` from `{{engine}}`. Import it from {{wrapper}} instead: a durable run spans hibernation and retries, so the connection a step uses has to be opened inside that step rather than shared across steps. The wrapper opens it; the engine\'s `step` does not.'
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          engine: { type: "string" },
+          within: { type: "string" },
+          wrapper: { type: "string" }
+        },
+        type: "object"
+      }
+    ],
+    type: "problem"
+  }
+};
+var step_opens_its_own_cell_default = stepOpensItsOwnCell;
+
+// src/rules/store-route-scopes-tenant-data.ts
+var STORE_ROUTE_PATTERN = /\/api\/store\/.*\/route\.tsx?$/;
+var TENANT_ENTITIES = /* @__PURE__ */ new Set([
+  "cart",
+  "claim",
+  "company",
+  "customer",
+  "employee",
+  "order",
+  "planned_order",
+  "production_order",
+  "quote"
+]);
+var SCOPE_MARKERS = /auth_context|actor_id|customer_id|company_id|\bcustomer\b\s*:/;
+var storeRouteScopesTenantData = {
+  create(context) {
+    const normalized = context.filename.replaceAll(/\\/g, "/");
+    if (!STORE_ROUTE_PATTERN.test(normalized)) return {};
+    const shortName = normalized.split("/").slice(-3).join("/");
+    return {
+      Program(node) {
+        const text = context.sourceCode?.text ?? "";
+        if (text === "" || SCOPE_MARKERS.test(text)) return;
+        for (const entity of TENANT_ENTITIES) {
+          const reads = new RegExp(`entity:\\s*['"\`]${entity}['"\`]`).test(text);
+          if (reads) {
+            context.report({
+              data: { entity, file: shortName },
+              messageId: "unscoped",
+              node
+            });
+            return;
+          }
+        }
+      }
+    };
+  },
+  fixShape: `A customer-facing store route that reads a customer-owned entity (cart, order, quote, company, \u2026)
+narrows the read to the authenticated caller \u2014 \`auth_context\`, \`actor_id\`, \`customer_id\` or
+\`company_id\` must appear in the handler. Without it a publishable key returns every tenant's rows.
+Global catalog entities are deliberately exempt; if the data is genuinely not customer data, it
+belongs on the admin surface.`,
+  meta: {
+    docs: {
+      description: "A /store/** route that reads a customer-owned entity must narrow the read to the authenticated caller. Without it the handler returns every tenant\u2019s rows to anyone holding a publishable key. Global catalog entities are exempt."
+    },
+    messages: {
+      unscoped: 'Store route "{{file}}" reads the customer-owned entity "{{entity}}" without any caller scoping (no auth_context / actor_id / customer_id / company_id in the file). Narrow the read to the authenticated caller, or move it to /admin if it is genuinely not customer data.'
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var store_route_scopes_tenant_data_default = storeRouteScopesTenantData;
+
+// src/rules/tables-declare-their-plane.ts
+var tableCallees = ["sqliteTable", "pgTable"];
+var tablesDeclareTheirPlane = {
+  create(context) {
+    const filename = context.filename.replaceAll("\\", "/");
+    if (!/\/packages\/db\/src\/schema\//.test(filename)) return {};
+    if (/\/schema\/(control|tenant)\//.test(filename)) return {};
+    return {
+      CallExpression(node) {
+        for (const callee of tableCallees) {
+          const table = literalNamedBy(node, callee);
+          if (table !== null) context.report({ data: { table }, messageId: "undeclared", node });
+        }
+      }
+    };
+  },
+  fixShape: `Every table is declared under \`schema/control/\` (who is who, read at the edge) or \`schema/tenant/\`
+(an organisation's rows, placed in a cell). A table declared loose in \`schema/\` has not decided which
+it is, and nothing downstream can place or isolate it. Move the file.`,
+  meta: {
+    docs: {
+      description: "Every table lives under schema/control/ (the control plane) or schema/tenant/ (an organisation's rows, placed in a cell). A table declared elsewhere has not chosen its plane (plan 037)."
+    },
+    messages: {
+      undeclared: '"{{table}}" is declared outside schema/control/ and schema/tenant/. Move it: control-plane tables are read by user, key or address at the edge; tenant tables carry org_id and live in a cell (plan 037).'
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var tables_declare_their_plane_default = tablesDeclareTheirPlane;
+
+// src/rules/tenant-tables-carry-org-id.ts
+var tableCallees2 = /* @__PURE__ */ new Set(["sqliteTable", "pgTable"]);
+var carriesOrgId = (columns) => columns?.type === "ObjectExpression" && (columns.properties ?? []).some(
+  (property) => property.type === "Property" && property.key?.name === "orgId"
+);
+var tenantTablesCarryOrgId = {
+  create(context) {
+    if (!/\/packages\/db\/src\/schema\/tenant\//.test(context.filename.replaceAll("\\", "/"))) {
+      return {};
+    }
+    return {
+      CallExpression(node) {
+        if (node.callee.type !== "Identifier" || !tableCallees2.has(node.callee.name ?? "")) return;
+        const [name, columns] = node.arguments ?? [];
+        const table = name && "value" in name && typeof name.value === "string" ? name.value : "this table";
+        if (carriesOrgId(columns)) return;
+        context.report({ data: { table }, messageId: "noOrgId", node });
+      }
+    };
+  },
+  fixShape: `A tenant-plane table declares an \`orgId\` column. Without it the row cannot be scoped, placed or
+isolated, and it is really a control-plane table in the wrong folder. Add the column, or move the
+table to \`schema/control/\`.`,
+  meta: {
+    docs: {
+      description: "Every table under schema/tenant/ has an `orgId` column: the organisation is the partition key of a cell and the subject of its isolation policy (plan 037)."
+    },
+    messages: {
+      noOrgId: '"{{table}}" is a tenant table without an `orgId` column. Add `orgId: orgIdColumn()` \u2014 or move it to schema/control/ if it is not one organisation\'s (plan 037).'
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var tenant_tables_carry_org_id_default = tenantTablesCarryOrgId;
+
+// src/rules/time-through-the-door.ts
+var timeDoor = /\/packages\/utils\/src\/time\.ts$/;
+var exemptFiles3 = [timeDoor, /\/__tests__\//, /\/scripts\//, /\/testing\//, /\/seeds\//];
+var dateStatics = /* @__PURE__ */ new Set(["parse", "UTC"]);
+var dateInstanceMethods = /* @__PURE__ */ new Set([
+  "toISOString",
+  "toLocaleDateString",
+  "toDateString",
+  "getFullYear",
+  "getMonth",
+  "getDate",
+  "getDay",
+  "getHours",
+  "getUTCFullYear",
+  "getUTCMonth",
+  "getUTCDate",
+  "setFullYear",
+  "setMonth",
+  "setDate"
+]);
+var memberName = (callee) => ({
+  object: callee.object?.type === "Identifier" ? callee.object.name : void 0,
+  property: callee.property?.type === "Identifier" ? callee.property.name : void 0
+});
+var timeThroughTheDoor = {
+  create(context) {
+    const normalized = context.filename.replace(/\\/g, "/");
+    if (exemptFiles3.some((file) => file.test(normalized))) return {};
+    return {
+      ImportDeclaration(node) {
+        if (node.source.value === "dayjs" || node.source.value.startsWith("dayjs/")) {
+          context.report({ messageId: "dayjsOutsideDoor", node });
+        }
+      },
+      NewExpression(node) {
+        if (node.callee.type === "Identifier" && node.callee.name === "Date") {
+          context.report({ messageId: "outsideTimeDoor", node, data: { what: "new Date" } });
+        }
+      },
+      CallExpression(node) {
+        if (node.callee.type !== "MemberExpression") return;
+        const { object, property } = memberName(node.callee);
+        if (property === void 0) return;
+        if (object === "Date" && property === "now") return;
+        if (object === "Date" && dateStatics.has(property) || dateInstanceMethods.has(property)) {
+          context.report({
+            messageId: "outsideTimeDoor",
+            node,
+            data: { what: `${object ?? "\u2026"}.${property}` }
+          });
+        }
+      }
+    };
+  },
+  fixShape: `\`new Date(...)\`, \`Date.parse\`, \`toISOString\`, \`toLocaleDateString\`, \`dayjs\` \u2014 every time operation
+goes through the one time module, which owns the plugins, the zone and the formats. Import
+\`isoDate\` / \`today\` / \`addDays\` from it. \`Date.now()\` is allowed anywhere.`,
+  meta: {
+    docs: {
+      description: "Time is handled by dayjs behind the time module (`utils/time`); nothing else constructs, parses or formats a Date. Date.now() is the one call allowed everywhere."
+    },
+    messages: {
+      outsideTimeDoor: "{{what}} outside the time door. Import the operation from the time module (`utils/time`) (isoDate, today, addDays, addMonths, \u2026) or add it there.",
+      dayjsOutsideDoor: "dayjs is imported outside the time module (`utils/time`). The door owns the plugins and formats; import from it."
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var time_through_the_door_default = timeThroughTheDoor;
+
+// src/rules/tissue-must-compose.ts
+import fs4 from "fs";
+var COMPOSITION_PATTERNS = [
+  // Tier segment with a trailing slash OR at the end of the specifier, so both
+  // relative (`../cells/x`, `../../feature/cells/x`) and self-subpath feature
+  // barrels (`#ui/cart/cells`, `#email/hero/compounds`) are recognized.
+  /\/(atoms|molecules|compounds|cells|tissues|organelles)(\/|$)/,
+  // react-email primitives are the email surface's compositional units — an
+  // email template that arranges <Section>/<Row>/<Container> IS composing.
+  /^@react-email\//,
+  // Flat-kit sibling splits: a tissue arranges its UI across private siblings
+  // (`import { X } from './site-header.parts'`). Importing + rendering those is
+  // real composition, not lint-theater.
+  /\.(parts|sections|layouts)$/
+];
+function isReexportOnly3(file) {
+  try {
+    const src = fs4.readFileSync(file, "utf8").replaceAll(/\/\*[\s\S]*?\*\//g, "").replaceAll(/\/\/.*$/gm, "");
+    const hasReexport = /\bexport\b[^;]*\bfrom\b\s*['"]/.test(src);
+    const hasComponent = /\bfunction\b|=>|\breturn\b|<[A-Za-z]/.test(src);
+    return hasReexport && !hasComponent;
+  } catch {
+    return false;
+  }
+}
+var APP_ROUTE_MUST_COMPOSE = /* @__PURE__ */ new Set(["page.tsx", "layout.tsx", "template.tsx"]);
+var APP_ROUTE_FALLBACKS = /* @__PURE__ */ new Set([
+  "default.tsx",
+  "not-found.tsx",
+  "loading.tsx",
+  "error.tsx",
+  "global-error.tsx"
+]);
+var METADATA_EXEMPT_BASENAMES = /* @__PURE__ */ new Set(["layout.tsx", "template.tsx"]);
+var METADATA_EXPORT_NAMES = /* @__PURE__ */ new Set([
+  "metadata",
+  "viewport",
+  "generateMetadata",
+  "generateViewport"
+]);
+var tissueMustCompose = {
+  create(context) {
+    const filename = context.filename;
+    const normalized = filename.replaceAll(/\\/g, "/");
+    const isTissueDir = /(?:features\/[^/]+\/)?tissues\//.test(normalized);
+    const basename = normalized.split("/").pop() ?? "";
+    const isTissue = isTissueDir && basename.endsWith(".tsx") && basename !== "index.tsx" && !/\.(parts|sections|summary|layouts|icons|types|hooks|utils|context|store|sidebar|data|config|stories|spec|test)\.tsx$/.test(
+      basename
+    );
+    const isAppRouteFile = /\/app\//.test(normalized) && APP_ROUTE_MUST_COMPOSE.has(basename);
+    const isAppFallback = /\/app\//.test(normalized) && APP_ROUTE_FALLBACKS.has(basename);
+    if (isAppFallback) return {};
+    if (!isTissue && !isAppRouteFile) return {};
+    if (isReexportOnly3(filename)) return {};
+    const bioImportLocals = /* @__PURE__ */ new Set();
+    const renderedTagNames = /* @__PURE__ */ new Set();
+    let hasMetadataExport = false;
+    let programNode = null;
+    return {
+      ExportNamedDeclaration(node) {
+        const decl = node.declaration;
+        if (!decl) return;
+        if (decl.type === "VariableDeclaration") {
+          for (const d of decl.declarations ?? []) {
+            const name = d.id?.name;
+            if (name && METADATA_EXPORT_NAMES.has(name)) {
+              hasMetadataExport = true;
+            }
+          }
+        } else if (decl.type === "FunctionDeclaration") {
+          const name = decl.id?.name;
+          if (name && METADATA_EXPORT_NAMES.has(name)) {
+            hasMetadataExport = true;
+          }
+        }
+      },
+      ImportDeclaration(node) {
+        if (node.importKind === "type") return;
+        const source = node.source.value;
+        if (!COMPOSITION_PATTERNS.some((pattern) => pattern.test(source))) return;
+        for (const spec of node.specifiers ?? []) {
+          const localName = spec.local?.name;
+          if (localName) bioImportLocals.add(localName);
+        }
+      },
+      JSXOpeningElement(node) {
+        const name = node.name;
+        if (!name) return;
+        if (name.type === "JSXIdentifier") {
+          const id = name;
+          if (id.name) renderedTagNames.add(id.name);
+        } else if (name.type === "JSXMemberExpression") {
+          const member = name;
+          const root = member.object?.name;
+          if (root) renderedTagNames.add(root);
+        }
+      },
+      "Program:exit"(node) {
+        programNode = node;
+        if (hasMetadataExport && METADATA_EXEMPT_BASENAMES.has(basename)) {
+          return;
+        }
+        const isTrulyEmpty = bioImportLocals.size === 0 && renderedTagNames.size === 0 && !hasMetadataExport;
+        if (basename === "page.tsx" && isTrulyEmpty) {
+          return;
+        }
+        const composesByRender = [...bioImportLocals].some(
+          (localName) => renderedTagNames.has(localName)
+        );
+        if (!composesByRender) {
+          const shortName = normalized.split("/").pop() || normalized;
+          const reason = bioImportLocals.size === 0 ? "noBioImports" : "bioImportedButNotRendered";
+          context.report({
+            data: { file: shortName, reason },
+            messageId: "missingComposition",
+            node: programNode
+          });
+        }
+      }
+    };
+  },
+  fixShape: `A tissue must RENDER something it imported from the tiers below \u2014 a cell, a compound, a molecule, an
+atom or another tissue. A tissue that only passes \`children\` through, or returns null, arranges
+nothing: that is lint-theater. If there is nothing to arrange, the file should not exist.`,
+  meta: {
+    docs: {
+      description: "Tissues MUST RENDER at least one cell, compound, molecule, atom, or other tissue. Tissues arrange bio elements into functional units \u2014 a tissue that imports bio symbols but never renders them is performing FAKE composition (lint-theater). This rule checks the JSX render tree, not just the import list, to close the fake-compose bypass. That is lint-theater."
+    },
+    messages: {
+      missingComposition: 'Tissue/route "{{file}}" does not RENDER any cell/compound/molecule/atom/tissue. Tissues and Next.js route UI files (page/layout/template) MUST arrange bio elements \u2014 passthrough wrappers like `<>{children}</>`, `<div>{children}</div>`, or `return null` are lint-theater. Fix: compose real bio in JSX, OR delete the file if it exists only for metadata (move metadata to a child page.tsx), OR reclassify it. Next.js fallback files (default/not-found/loading/error/global-error) are automatically exempt.'
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var tissue_must_compose_default = tissueMustCompose;
+
+// src/rules/tissue-no-data-props.ts
+var TISSUE_FILE_PATTERN = /(?:features\/[^/]+\/)?tissues\//;
+var APP_LAYOUT_OR_TEMPLATE = /* @__PURE__ */ new Set(["layout.tsx", "template.tsx"]);
+var ROUTE_FALLBACK_BASENAMES2 = /* @__PURE__ */ new Set([
+  "default.tsx",
+  "error.tsx",
+  "global-error.tsx",
+  "loading.tsx",
+  "not-found.tsx"
+]);
+var ALWAYS_ALLOWED_PROP_NAMES = /* @__PURE__ */ new Set(["children", "className", "params", "searchParams"]);
+var REACT_NODE_TYPE_NAMES = /* @__PURE__ */ new Set([
+  "ComponentType",
+  "Element",
+  "JSX",
+  "PropsWithChildren",
+  "ReactElement",
+  "ReactNode"
+]);
+var isKindVocabulary = (name) => /(Kind|EntityName)$/.test(name);
+function isAllowedTypeRefName(name) {
+  if (REACT_NODE_TYPE_NAMES.has(name)) return true;
+  if (isKindVocabulary(name)) return true;
+  if (name.endsWith("Icon")) return true;
+  if (name.endsWith("IconComponent")) return true;
+  if (name.endsWith("IconType")) return true;
+  return false;
+}
+function describeTypeAnnotation(t) {
+  if (!t || !t.type) return "unknown";
+  switch (t.type) {
+    case "TSStringKeyword":
+      return "string";
+    case "TSNumberKeyword":
+      return "number";
+    case "TSBooleanKeyword":
+      return "boolean";
+    case "TSArrayType":
+      return `Array<${describeTypeAnnotation(t.elementType)}>`;
+    case "TSTypeReference":
+      return t.typeName?.name ?? "(unknown-ref)";
+    case "TSUnionType":
+      return (t.types ?? []).map(describeTypeAnnotation).join(" | ");
+    default:
+      return t.type;
+  }
+}
+function isLiteralStringUnion(t) {
+  if (t.type !== "TSUnionType") return false;
+  const types = t.types ?? [];
+  if (types.length === 0) return false;
+  return types.every((x) => x.type === "TSLiteralType" && typeof x.literal?.value === "string");
+}
+var narrowsAKindVocabulary = (t) => {
+  const name = t.typeName?.name ?? "";
+  if (name !== "Exclude" && name !== "Extract") return false;
+  const [subject] = (t.typeArguments ?? t.typeParameters)?.params ?? [];
+  return subject?.type === "TSTypeReference" && isKindVocabulary(subject.typeName?.name ?? "");
+};
+function isAllowedType(t) {
+  if (!t || !t.type) return true;
+  switch (t.type) {
+    case "TSTypeReference":
+      return isAllowedTypeRefName(t.typeName?.name ?? "") || narrowsAKindVocabulary(t);
+    case "TSUnionType":
+      return isLiteralStringUnion(t);
+    // TSTypeLiteral (inline object shape) — allowed because nested shapes
+    // Are typically ReactNode records; if it turns out to contain data
+    // Primitives, the outer check will miss them (v1 limitation).
+    case "TSTypeLiteral":
+      return true;
+    // Primitives and arrays fall through to forbidden.
+    case "TSStringKeyword":
+    case "TSNumberKeyword":
+    case "TSBooleanKeyword":
+    case "TSArrayType":
+      return false;
+    default:
+      return true;
+  }
+}
+var tissueNoDataProps = {
+  create(context) {
+    const normalized = context.filename.replaceAll(/\\/g, "/");
+    if (/__tests__\//.test(normalized)) return {};
+    const basename = normalized.split("/").pop() ?? "";
+    const isFeatureTissue = TISSUE_FILE_PATTERN.test(normalized);
+    const isAppTissue = /(?:^|\/)app\//.test(normalized) && APP_LAYOUT_OR_TEMPLATE.has(basename);
+    if (!isFeatureTissue && !isAppTissue) return {};
+    if (ROUTE_FALLBACK_BASENAMES2.has(basename)) return {};
+    function checkFunction2(node) {
+      const firstParam = node.params?.[0];
+      if (!firstParam) return;
+      const typeLiteral = firstParam.typeAnnotation?.typeAnnotation;
+      if (!typeLiteral || typeLiteral.type !== "TSTypeLiteral") return;
+      const members = typeLiteral.members ?? [];
+      for (const member of members) {
+        if (member.key?.type !== "Identifier") continue;
+        const propName = member.key.name ?? "";
+        if (!propName) continue;
+        if (ALWAYS_ALLOWED_PROP_NAMES.has(propName)) continue;
+        const t = member.typeAnnotation?.typeAnnotation;
+        if (!t) continue;
+        if (isAllowedType(t)) continue;
+        context.report({
+          data: { prop: propName, type: describeTypeAnnotation(t) },
+          messageId: "dataProp",
+          node: member
+        });
+      }
+    }
+    function checkDeclaration(decl) {
+      if (!decl || typeof decl !== "object") return;
+      const d = decl;
+      if (d.type === "FunctionDeclaration") {
+        checkFunction2(d);
+        return;
+      }
+      if (d.type === "VariableDeclaration") {
+        for (const declNode of d.declarations ?? []) {
+          const init = declNode.init;
+          if (init && (init.type === "ArrowFunctionExpression" || init.type === "FunctionExpression")) {
+            checkFunction2(init);
+          }
+        }
+      }
+    }
+    return {
+      // Only inspect the PUBLIC INTERFACE of the tissue file — the default or
+      // Named export. Inner helper functions (not exported) are file-scoped
+      // Implementation details; their props don't define the tissue's
+      // Contract, so they're out of scope for this rule.
+      ExportDefaultDeclaration(node) {
+        checkDeclaration(node.declaration);
+      },
+      ExportNamedDeclaration(node) {
+        checkDeclaration(node.declaration);
+      }
+    };
+  },
+  fixShape: `A tissue takes \`children\`, ReactNode slot props, layout variants, \`params\` and \`searchParams\` \u2014 and
+nothing else. A prop typed \`string\`, \`number\`, an array or a domain type (\`id\`, \`initialData\`,
+\`documents\`) means the file owns data, which makes it a CELL: move it to \`cells/\`. A tissue gets its
+content as slots, never as data.`,
+  meta: {
+    docs: {
+      description: "Tissues must not own data. Props on a tissue must be limited to `children`, ReactNode slot props, `params`, `searchParams`, icon types, or layout-variant literal unions. Any primitive (`string`/`number`/`boolean`), array type, or arbitrary domain type reference means the file is actually a cell \u2014 move it to cells/. That is lint-theater.2 (Tissue self-sufficiency rule)."
+    },
+    messages: {
+      dataProp: "Tissue prop '{{prop}}' has type '{{type}}' which is not allowed on a tissue. Tissues arrange children without owning data. Move the file from features/*/tissues/ to features/*/cells/ \u2014 cells own data. Allowed tissue props: children, params, searchParams, ReactNode slots, literal-union variants, icon types."
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var tissue_no_data_props_default = tissueNoDataProps;
+
+// src/rules/tissue-no-hooks.ts
+var FORBIDDEN_HOOKS = /* @__PURE__ */ new Set([
+  "useCallback",
+  "useEffect",
+  "useImperativeHandle",
+  "useLayoutEffect",
+  "useMemo",
+  "useReducer",
+  "useRef",
+  "useState"
+]);
+var HOOK_CALL_PATTERN = /^use[A-Z]/;
+var TISSUE_FILE_PATTERN2 = /(?:features\/[^/]+\/)?tissues\//;
+var tissueNoHooks = {
+  create(context) {
+    const filename = context.filename;
+    const normalized = filename.replaceAll(/\\/g, "/");
+    const isTissue = TISSUE_FILE_PATTERN2.test(normalized);
+    const shortName = normalized.split("/").pop() || normalized;
+    const isEntrypoint = isTissue && shortName.endsWith(".tsx") && shortName !== "index.tsx" && !/\.(parts|sections|summary|layouts|icons|types|hooks|utils|context|store|sidebar|data|config|stories|spec|test)\.tsx$/.test(
+      shortName
+    );
+    if (!isEntrypoint) return {};
+    return {
+      CallExpression(node) {
+        const called = node.callee;
+        if (called?.type !== "Identifier") return;
+        const name = called.name;
+        if (name === void 0 || !HOOK_CALL_PATTERN.test(name)) return;
+        context.report({
+          data: { file: shortName, hook: name },
+          messageId: "called",
+          node
+        });
+      },
+      ImportDeclaration(node) {
+        if (node.importKind === "type") return;
+        if (node.source.value !== "react") return;
+        const specifiers = node.specifiers ?? [];
+        for (const spec of specifiers) {
+          if (spec.type !== "ImportSpecifier") continue;
+          const importedName = spec.imported?.name;
+          if (!importedName) continue;
+          if (FORBIDDEN_HOOKS.has(importedName)) {
+            context.report({
+              data: { file: shortName, hook: importedName },
+              messageId: "forbidden",
+              node
+            });
+          }
+        }
+      }
+    };
+  },
+  fixShape: `A tissue holds no state: no \`useState\`, no \`useEffect\`, and no call to ANY \`use*()\` \u2014 including a
+hook defined in \`lib/\` that reads a store behind your back. If you need the hook, the file is a cell:
+move it to \`cells/\`, or push the call into a cell the tissue arranges. Private siblings
+(\`.parts.tsx\`, \`.sections.tsx\`) are not the tissue entrypoint and may hold local UI state.`,
+  meta: {
+    docs: {
+      description: "Tissues are pure arrangements of cells and cannot hold state. Tissues cannot import stateful React hooks. State lives only at the organelle and cell levels. If you need hooks in a tissue, the file is actually a cell - promote it or push the logic into a constituent cell."
+    },
+    messages: {
+      called: 'Tissue "{{file}}" calls "{{hook}}". A hook call is state, wherever the hook is defined \u2014 a rule that only reads imports never sees the state a `lib/` hook reaches through. Move this file to cells/, or push the call into a cell it arranges.',
+      forbidden: 'Tissue "{{file}}" imports "{{hook}}" from react. Tissues are pure arrangements of cells and cannot hold state. State lives only at organelle/cell levels. Either push this logic into a cell, or if this file is truly doing cell work, move it to the cells/ tier.'
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var tissue_no_hooks_default = tissueNoHooks;
+
+// src/rules/tissue-no-organelles.ts
+var TISSUE_FILE_PATTERN3 = /(?:features\/[^/]+\/)?tissues\//;
+var tissueNoOrganelles = {
+  create(context) {
+    const filename = context.filename;
+    const normalized = filename.replaceAll(/\\/g, "/");
+    const isTissue = TISSUE_FILE_PATTERN3.test(normalized);
+    if (!isTissue) return {};
+    const shortName = normalized.split("/").pop() || normalized;
+    return {
+      ImportDeclaration(node) {
+        if (node.importKind === "type") return;
+        const source = node.source.value;
+        if (/\/organelles\//.test(source)) {
+          context.report({
+            data: { file: shortName, source },
+            messageId: "forbidden",
+            node
+          });
+        }
+      }
+    };
+  },
+  fixShape: `A tissue never imports an organelle. Organelles live INSIDE cells; go through a cell that hosts the
+organelle and let the tissue arrange the cell. Reaching past the cell is how state gets into a layer
+that is supposed to have none.`,
+  meta: {
+    docs: {
+      description: "Tissues cannot directly import organelles. In biology, tissues arrange cells; organelles live INSIDE cells. To reach an organelle from a tissue, go through a cell. This forces tissues to stay at the cell-arrangement level and keeps state encapsulated in the cells that own their organelles."
+    },
+    messages: {
+      forbidden: 'Tissue "{{file}}" cannot import organelle "{{source}}". Tissues arrange cells; organelles live inside cells. Host this organelle inside a cell, then compose the cell from this tissue.'
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var tissue_no_organelles_default = tissueNoOrganelles;
+
+// src/rules/tissue-no-stores.ts
+var TISSUE_FILE_PATTERN4 = /(?:features\/[^/]+\/)?tissues\//;
+var tissueNoStores = {
+  create(context) {
+    const filename = context.filename;
+    const normalized = filename.replaceAll(/\\/g, "/");
+    const isTissue = TISSUE_FILE_PATTERN4.test(normalized);
+    if (!isTissue) return {};
+    const shortName = normalized.split("/").pop() || normalized;
+    return {
+      ImportDeclaration(node) {
+        if (node.importKind === "type") return;
+        const source = node.source.value;
+        if (/stores\//.test(source)) {
+          context.report({
+            data: { file: shortName, source },
+            messageId: "forbidden",
+            node
+          });
+        }
+      }
+    };
+  },
+  fixShape: `A tissue reads no store. State lives at the organelle and cell tiers only \u2014 a tissue that needs store
+data is a cell wearing the wrong folder. Move it to \`cells/\`, or have a cell read the store and let
+the tissue arrange that cell.`,
+  meta: {
+    docs: {
+      description: "Tissues cannot import from stores. Tissues arrange cells but must not directly access state. State lives at organelle and cell levels. (App route files are classified as organs - see organ-no-stores.)"
+    },
+    messages: {
+      forbidden: 'Tissue "{{file}}" cannot import from "{{source}}". Tissues arrange cells but must not directly access stores. Push the store read into a constituent cell.'
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var tissue_no_stores_default = tissueNoStores;
+
+// src/rules/worker-handles-are-scoped.ts
+var cellWorkerPattern = /\/apps\/api\/src\//;
+var handlerKeys = /* @__PURE__ */ new Set(["fetch", "queue", "scheduled", "email"]);
+var entrypointMakers = /* @__PURE__ */ new Set([
+  "WorkflowEntrypoint",
+  "entrypointFor",
+  "createWorkflowEntrypoint"
+]);
+var cellHandlesAreScoped = {
+  create(context) {
+    const normalized = context.filename.replace(/\\/g, "/");
+    if (!cellWorkerPattern.test(normalized)) return {};
+    let handler = null;
+    let handlerNode = null;
+    let scoped = false;
+    return {
+      ExportDefaultDeclaration(node) {
+        const keys = (node.declaration?.properties ?? []).map((property) => property.key?.name);
+        const named = keys.find((key) => key !== void 0 && handlerKeys.has(key));
+        if (node.declaration?.type !== "ObjectExpression" || named === void 0) return;
+        handler = `the ${named} handler`;
+        handlerNode = node;
+      },
+      CallExpression(node) {
+        if (node.callee?.type !== "Identifier") return;
+        if (node.callee.name === "withCells") scoped = true;
+        if (node.callee.name === "createWorkflowEntrypoint") {
+          handler = "the workflow entrypoint";
+          handlerNode = node;
+        }
+      },
+      // `extends WorkflowEntrypoint`, `extends entrypointFor(...)`, `extends createWorkflowEntrypoint(...)`
+      ClassDeclaration(node) {
+        const parent = node.superClass;
+        const name = parent?.type === "Identifier" ? parent.name : parent?.type === "CallExpression" && parent.callee?.type === "Identifier" ? parent.callee.name : void 0;
+        if (name === void 0 || !entrypointMakers.has(name)) return;
+        handler = "the workflow entrypoint";
+        handlerNode = node;
+      },
+      "Program:exit"(node) {
+        if (handler === null || scoped) return;
+        context.report({
+          data: { handler },
+          messageId: "handlerOutsideWithCells",
+          node: handlerNode ?? node
+        });
+      }
+    };
+  },
+  fixShape: `A worker that opens a database-cell handle wraps every invocation in \`withCells\` \u2014 the module
+handlers (\`fetch\`, \`queue\`, \`scheduled\`, \`email\`) and the workflow entrypoint alike \u2014 so the handle
+is closed when the invocation ends: \`withCells(() => \u2026, (closing) => ctx.waitUntil(closing))\`. A
+handler that declares itself and never calls it opens a pool per call and never closes one.`,
+  meta: {
+    docs: {
+      description: "Every invocation of a cell worker \u2014 the module handlers and the Workflow entrypoint \u2014 runs inside `withCells`, which shares one cell handle per invocation and closes it when the invocation ends. A file that declares such an invocation and never calls `withCells` opens a pool it never closes."
+    },
+    messages: {
+      handlerOutsideWithCells: "This file declares {{handler}} and never calls `withCells`. Wrap the invocation \u2014 `withCells(() => \u2026, (closing) => ctx.waitUntil(closing))` \u2014 so the cell handle it opens is closed when it ends."
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var worker_handles_are_scoped_default = cellHandlesAreScoped;
+
+// src/rules/zustand-v5-best-practices.ts
+var STORE_HOOK_PATTERN2 = /^use\w+Store$/;
+var zustandV5BestPractices = {
+  create(context) {
+    const storeCallsByScope = /* @__PURE__ */ new Map();
+    const functionStack = [];
+    function currentScope() {
+      return functionStack.at(-1) ?? null;
+    }
+    function enterFunction(node) {
+      functionStack.push(node);
+    }
+    function exitFunction() {
+      const scope = functionStack.pop();
+      const storeCalls = storeCallsByScope.get(scope);
+      if (!storeCalls) return;
+      for (const [hookName, data] of storeCalls) {
+        if (data.count > 1) {
+          context.report({
+            data: { count: String(data.count), hook: hookName },
+            messageId: "multipleSelectors",
+            node: data.nodes[1]
+          });
+        }
+      }
+      storeCallsByScope.delete(scope);
+    }
+    return {
+      ArrowFunctionExpression(node) {
+        enterFunction(node);
+      },
+      "ArrowFunctionExpression:exit"() {
+        exitFunction();
+      },
+      CallExpression(node) {
+        if (node.callee.type !== "Identifier") return;
+        const name = node.callee.name;
+        if (!name || !STORE_HOOK_PATTERN2.test(name)) return;
+        if (node.arguments.length === 0) {
+          context.report({
+            data: { hook: name },
+            messageId: "noSelector",
+            node
+          });
+          return;
+        }
+        const firstArg = node.arguments[0];
+        if (firstArg?.type === "CallExpression" && firstArg.callee?.name === "useShallow") return;
+        const scope = currentScope();
+        if (!scope) return;
+        let scopeMap = storeCallsByScope.get(scope);
+        if (!scopeMap) {
+          scopeMap = /* @__PURE__ */ new Map();
+          storeCallsByScope.set(scope, scopeMap);
+        }
+        const existing = scopeMap.get(name) || { count: 0, nodes: [] };
+        existing.nodes.push(node);
+        existing.count++;
+        scopeMap.set(name, existing);
+      },
+      FunctionDeclaration(node) {
+        enterFunction(node);
+      },
+      "FunctionDeclaration:exit"() {
+        exitFunction();
+      },
+      FunctionExpression(node) {
+        enterFunction(node);
+      },
+      "FunctionExpression:exit"() {
+        exitFunction();
+      }
+    };
+  },
+  fixShape: `Never \`useStore()\` with no selector \u2014 that subscribes to the whole store and re-renders on every
+change. One field: \`useStore((s) => s.field)\`. Several fields: ONE call with
+\`useShallow((s) => ({ a: s.a, b: s.b }))\`, never several selector calls in the same component.`,
+  meta: {
+    docs: {
+      description: "Enforce Zustand v5 best practices. (1) Require selector on store hooks \u2014 useStore() without args subscribes to entire state. (2) One call per store per component \u2014 multiple individual selectors must be consolidated with useShallow."
+    },
+    messages: {
+      multipleSelectors: '"{{hook}}" called {{count}} times with individual selectors. Use one call with useShallow: const { ... } = {{hook}}(useShallow((s) => ({ ... })))',
+      noSelector: '"{{hook}}()" called without a selector \u2014 subscribes to ENTIRE store, re-renders on ANY change. Use: {{hook}}((s) => s.field) or {{hook}}(useShallow((s) => ({ ... })))'
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var zustand_v5_best_practices_default = zustandV5BestPractices;
+
+// src/index.ts
+var rules = {
+  "atom-no-deps": atom_no_deps_default,
+  "cell-must-be-stateful": cell_must_be_stateful_default,
+  "cell-must-not-compose-cell": cell_must_not_compose_cell_default,
+  "cell-no-tissues": cell_no_tissues_default,
+  "cells-folder-index-is-barrel": cells_folder_index_is_barrel_default,
+  "compound-must-be-stateless": compound_must_be_stateless_default,
+  "compound-no-stores": compound_no_stores_default,
+  "constants-in-constants-file": constants_in_constants_file_default,
+  "dialect-through-the-seam": dialect_through_the_seam_default,
+  "document-sagas-are-generic": document_sagas_are_generic_default,
+  "documents-share-one-table": documents_share_one_table_default,
+  "effect-hook-naming": effect_hook_naming_default,
+  "max-comment-density": max_comment_density_default,
+  "molecule-atoms-only": molecule_atoms_only_default,
+  "molecule-must-compose": molecule_must_compose_default,
+  "next-route-segment-is-thin-delegate": next_route_segment_is_thin_delegate_default,
+  "no-brand-names": no_brand_names_default,
+  "no-card-shaped-div": no_card_shaped_div_default,
+  "no-cross-feature-stores": no_cross_feature_stores_default,
+  "no-d1-transaction": no_d1_transaction_default,
+  "no-duplicate-jsx-patterns": no_duplicate_jsx_patterns_default,
+  "no-hook-in-component-disguise": no_hook_in_component_disguise_default,
+  "no-inert-hidden-jsx": no_inert_hidden_jsx_default,
+  "no-inline-data-in-jsx": no_inline_data_in_jsx_default,
+  "no-invalid-feature-folders": no_invalid_feature_folders_default,
+  "no-logic-in-component-files": no_logic_in_component_files_default,
+  "no-orm-outside-db": no_orm_outside_db_default,
+  "no-raw-html-atoms": no_raw_html_atoms_default,
+  "no-raw-sql-outside-allowed": no_raw_sql_outside_allowed_default,
+  "no-react-namespace": no_react_namespace_default,
+  "no-renamed-html-props": no_renamed_html_props_default,
+  "no-render-prop-reader": no_render_prop_reader_default,
+  "no-trivial-wrapper-component": no_trivial_wrapper_component_default,
+  "no-ts-in-bio-folders": no_ts_in_bio_folders_default,
+  "no-type-definitions-in-components": no_type_definitions_in_components_default,
+  "no-void-port": no_void_port_default,
+  "organelle-dependency": organelle_dependency_default,
+  "organelle-single-source": organelle_single_source_default,
+  "queries-require-org-scope": queries_require_org_scope_default,
+  "queue-loop-is-the-library": queue_loop_is_the_library_default,
+  "ssot-no-inline-facts": ssot_no_inline_facts_default,
+  "ssot-no-process-env": ssot_no_process_env_default,
+  "step-opens-its-own-cell": step_opens_its_own_cell_default,
+  "store-route-scopes-tenant-data": store_route_scopes_tenant_data_default,
+  "tables-declare-their-plane": tables_declare_their_plane_default,
+  "tenant-tables-carry-org-id": tenant_tables_carry_org_id_default,
+  "time-through-the-door": time_through_the_door_default,
+  "tissue-must-compose": tissue_must_compose_default,
+  "tissue-no-data-props": tissue_no_data_props_default,
+  "tissue-no-hooks": tissue_no_hooks_default,
+  "tissue-no-organelles": tissue_no_organelles_default,
+  "tissue-no-stores": tissue_no_stores_default,
+  "worker-handles-are-scoped": worker_handles_are_scoped_default,
+  "zustand-v5-best-practices": zustand_v5_best_practices_default
+};
+var plugin = {
+  configs: PRESETS,
+  meta: {
+    name: "biological-architecture",
+    version: "0.1.0"
+  },
+  rules
+};
+var index_default = plugin;
+export {
+  PRESETS,
+  index_default as default,
+  rules
+};