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

package/dist/rules/tissue-no-hooks.js

@@ -1,5 +1,7 @@
 // src/rules/tissue-no-hooks.ts
-import { hookCalledBy } from "./lib/hooks.js";
+import { hookCalledBy, hookNameOf } from "./lib/hooks.js";
+import { sourceOf } from "./lib/imports.js";
+import { optionsBag, STRINGS } from "./lib/schema.js";
 import { tissueEntrypointOf } from "./lib/tissue-entrypoint.js";
 var FORBIDDEN_HOOKS = new Set([
   "useCallback",
@@ -16,11 +18,14 @@ var tissueNoHooks = {
     const { basename: shortName, isEntrypoint } = tissueEntrypointOf(context.filename);
     if (!isEntrypoint)
       return {};
+    const reads = new Set((context.options?.[0]?.contextHooks ?? []).filter((one) => !FORBIDDEN_HOOKS.has(one)));
     return {
       CallExpression(node) {
         const name = hookCalledBy(node);
         if (name === null)
           return;
+        if (reads.has(hookNameOf(node) ?? ""))
+          return;
         context.report({
           data: { file: shortName, hook: name },
           messageId: "called",
@@ -30,7 +35,7 @@ var tissueNoHooks = {
       ImportDeclaration(node) {
         if (node.importKind === "type")
           return;
-        if (node.source.value !== "react")
+        if (sourceOf(node) !== "react")
           return;
         const specifiers = node.specifiers ?? [];
         for (const spec of specifiers) {
@@ -52,7 +57,9 @@ var tissueNoHooks = {
   },
   fixShape: `A tissue holds no state: no \`useState\`, no \`useEffect\`, and no call to ANY \`use*()\` — 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
+move it to \`cells/\`, or push the call into a cell the tissue arranges. A hook that only reads the
+framework's context (\`useTranslations\`, \`usePathname\`) is named in \`contextHooks\`, a list that is
+empty until the repo writes it and never excuses \`useState\` and its kin. Private siblings
 (\`.parts.tsx\`, \`.sections.tsx\`) are not the tissue entrypoint and may hold local UI state.`,
   meta: {
     docs: {
@@ -62,8 +69,19 @@ move it to \`cells/\`, or push the call into a cell the tissue arranges. Private
       called: 'Tissue "{{file}}" calls "{{hook}}". A hook call is state, wherever the hook is defined — 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: [],
+    schema: optionsBag({ contextHooks: STRINGS }),
     type: "problem"
+  },
+  probe() {
+    return {
+      path: "src/tissues/geonosis-probe.tsx",
+      source: `declare const useGeonosisThing: () => number
+
+export function GeonosisProbe() {
+  return <div>{useGeonosisThing()}</div>
+}
+`
+    };
   }
 };
 var tissue_no_hooks_default = tissueNoHooks;

package/dist/rules/tissue-no-organelles.d.ts

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

package/dist/rules/tissue-no-organelles.js

@@ -1,14 +1,22 @@
 // src/rules/tissue-no-organelles.ts
 import { directionRule } from "./lib/direction-rule.js";
+import { inTier } from "./lib/tiers.js";
 var tissueNoOrganelles = directionRule({
   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.",
   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.`,
-  forbidden: (target) => /\/organelles\//.test(target.path),
+  forbidden: (target) => inTier(target.path, "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.'
   },
+  probe: () => ({
+    path: "src/tissues/geonosis-probe.tsx",
+    source: `import { up } from '../organelles/geonosis-up'
+
+export const GeonosisProbe = up
+`
+  }),
   scope: "tissues"
 });
 var tissue_no_organelles_default = tissueNoOrganelles;

package/dist/rules/tissue-no-stores.d.ts

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

package/dist/rules/tissue-no-stores.js

@@ -1,14 +1,22 @@
 // src/rules/tissue-no-stores.ts
 import { directionRule } from "./lib/direction-rule.js";
+import { STORES_FOLDER } from "./lib/tiers.js";
 var tissueNoStores = directionRule({
   description: "Tissues cannot import from stores. Tissues arrange cells but must not directly access state. State lives at organelle and cell levels.",
   fixShape: `A tissue reads no store. State lives at the organelle and cell tiers only — 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.`,
-  forbidden: (target) => /(?:^|\/)stores\//.test(target.path),
+  forbidden: (target) => STORES_FOLDER.test(target.path),
   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.'
   },
+  probe: () => ({
+    path: "src/tissues/geonosis-probe.tsx",
+    source: `import { up } from '../stores/geonosis-up'
+
+export const GeonosisProbe = up
+`
+  }),
   scope: "tissues"
 });
 var tissue_no_stores_default = tissueNoStores;

package/dist/rules/todo-names-its-plan.d.ts

@@ -1,31 +1,9 @@
+import { type SourceCode } from './lib/comments.js';
 import { type Probe } from './lib/probe.js';
 interface Options {
-    /** What a plan id looks like, as a regex source. `\d{3,}` is the NNN a plan file is named for. */
     id?: string;
-    /**
-     * The words this repo treats as debt markers. Matched case-sensitively, on a word boundary and
-     * followed by `(`, `:`, whitespace or the end of the comment — the shapes a marker is written in.
-     */
     markers?: string[];
 }
-type Comment = {
-    loc: {
-        end: {
-            line: number;
-        };
-        start: {
-            line: number;
-        };
-    };
-    type: string;
-    value: string;
-};
-type SourceCode = {
-    ast?: {
-        comments?: Comment[];
-    };
-    getAllComments?: () => Comment[];
-};
 declare const todoNamesItsPlan: {
     create(context: {
         filename: string;
@@ -65,11 +43,6 @@ declare const todoNamesItsPlan: {
         }[];
         type: 'problem';
     };
-    /**
-     * The repo's OWN first marker, in a comment, citing nothing. It has to be the configured word:
-     * a probe hardcoding one spelling would report the rule as unreachable in every repo that spells
-     * its debt with another, which is the whole class of finding probes exist to end.
-     */
     probe(options: readonly unknown[]): Probe;
 };
 export default todoNamesItsPlan;

package/dist/rules/todo-names-its-plan.js

@@ -1,10 +1,10 @@
 // src/rules/todo-names-its-plan.ts
+import { commentsOf } from "./lib/comments.js";
 import { requireOption } from "./lib/options.js";
+import { escapeForRegex } from "./lib/pattern-match.js";
 import { bagOf, firstOf } from "./lib/probe.js";
 import { optionsBag, STRING, STRINGS } from "./lib/schema.js";
 var ID_DEFAULT = String.raw`\d{3,}`;
-var commentsOf = (sourceCode) => sourceCode?.getAllComments?.() ?? sourceCode?.ast?.comments ?? [];
-var escapeForRegex = (value) => value.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&");
 var todoNamesItsPlan = {
   create(context) {
     const { id = ID_DEFAULT, markers = [] } = context.options?.[0] ?? {};

package/dist/rules/tokens-only-colors.d.ts

@@ -3,52 +3,22 @@ import type { AnyNode } from './lib/nodes.js';
 import { type Probe } from './lib/probe.js';
 import { type OpeningElement } from './lib/styling.js';
 interface Options {
-    /** Paths where a literal is the point — the theme file, the palette, the token layer. */
     allow?: string[];
-    /**
-     * The modules this rule does not judge, each written out in full — the enumeration a pattern
-     * cannot be. A glob grants its exemption to wherever it stops and nobody counts what accumulates
-     * on the far side; a list of module names is a number a reader can hold.
-     */
     exemptModules?: string[];
-    /** The prefixes a themed custom property starts with. One string or several. */
     tokenPrefix?: string | string[];
 }
 declare const tokensOnlyColors: {
     create(context: RuleContextWithOptions<Options>): {
         JSXOpeningElement?: undefined;
-        /**
-         * A colour that arrives as a DEFAULT — `({ color = '#090909' })` — is never written in a JSX
-         * attribute, so the visitor above cannot see it. It reaches the element through a prop and
-         * paints in the brand it was typed for, from the one place nobody looked: seventy-two icons
-         * in one kit carried the same hex this way, under this rule, at "error", for its whole life.
-         * A default is a value the component CHOOSES, which is exactly what a token is for.
-         *
-         * A bare word is left alone. `variant = 'primary'` and `size = 'small'` are defaults too, and
-         * a rule that read every English word as a colour would be turned off within the week.
-         */
+        Property?: undefined;
         AssignmentPattern?: undefined;
     } | {
         JSXOpeningElement(node: OpeningElement): void;
-        /**
-         * A colour that arrives as a DEFAULT — `({ color = '#090909' })` — is never written in a JSX
-         * attribute, so the visitor above cannot see it. It reaches the element through a prop and
-         * paints in the brand it was typed for, from the one place nobody looked: seventy-two icons
-         * in one kit carried the same hex this way, under this rule, at "error", for its whole life.
-         * A default is a value the component CHOOSES, which is exactly what a token is for.
-         *
-         * A bare word is left alone. `variant = 'primary'` and `size = 'small'` are defaults too, and
-         * a rule that read every English word as a colour would be turned off within the week.
-         */
+        Property(node: AnyNode): void;
         AssignmentPattern(node: AnyNode): void;
     };
     fixShape: string;
     meta: {
-        /**
-         * #139: which option grants by PATTERN and which one ENUMERATES. Declared on the rule so the
-         * doctor needs no list of its own — a rule that gains a path grant and forgets to say so is a
-         * grant nothing counts, which is the defect this pair exists to end.
-         */
         grants: {
             modules: string;
             paths: string;
@@ -90,11 +60,6 @@ declare const tokensOnlyColors: {
         }[];
         type: 'problem';
     };
-    /**
-     * A named colour in an inline style, which fires under any token prefix — the question is whether
-     * the rule RUNS in this repo, and a probe spelled out of the prefix would be defeated by a repo
-     * that happened to declare a token of the same name.
-     */
     probe(): Probe;
 };
 export default tokensOnlyColors;

package/dist/rules/tokens-only-colors.js

@@ -6,20 +6,23 @@ import {
   isColorShorthand,
   isColorUtility
 } from "./lib/colors.js";
-import { requireOption } from "./lib/options.js";
-import { isModule, normalise } from "./lib/paths.js";
+import { DEFAULT_TEST_EXEMPT, requireOption } from "./lib/options.js";
+import { anyOf, isExempt, normalise } from "./lib/paths.js";
 import { optionsBag, STRINGS } from "./lib/schema.js";
 import {
   arbitraryValuesOf,
   classNameOf,
+  keyOf,
   localVariablesOf,
   styleEntriesOf,
+  styleObjectOf,
   variableOf
 } from "./lib/styling.js";
 var defaultedName = (node) => {
   const left = node.left;
   return left?.type === "Identifier" ? left.name ?? "default" : "default";
 };
+var isNamedOnly = (value) => /^[a-z]+$/i.test(value.trim());
 var tokenOffence = (value, prefixes, local) => {
   const variable = variableOf(value);
   if (variable !== undefined) {
@@ -31,16 +34,27 @@ var tokenOffence = (value, prefixes, local) => {
 };
 var tokensOnlyColors = {
   create(context) {
-    const { allow = [], exemptModules = [], tokenPrefix } = context.options?.[0] ?? {};
+    const { tokenPrefix, ...exempt } = context.options?.[0] ?? {};
     const prefixes = [requireOption("tokens-only-colors", tokenPrefix, "tokenPrefix")].flat();
-    requireOption("tokens-only-colors", prefixes, "tokenPrefix");
     const filename = normalise(context.filename);
-    if (exemptModules.some((module) => isModule(filename, module)))
-      return {};
-    if (allow.some((path) => filename.includes(path)))
+    if (isExempt(filename, exempt))
       return {};
+    const readByAnElement = new WeakSet;
+    const reportDefault = (node, property, value) => {
+      const offence = tokenOffence(value, prefixes, new Set);
+      if (offence === undefined || offence === "colorLiteral" && isNamedOnly(value))
+        return;
+      if (offence === "foreignVariable" && !isColorProperty(property))
+        return;
+      context.report({ data: { property, value }, messageId: offence, node });
+    };
+    const isTest = anyOf([...DEFAULT_TEST_EXEMPT, "__fixtures__/", "__visual__/"], filename);
     return {
       JSXOpeningElement(node) {
+        const styled = styleObjectOf(node);
+        for (const entry of styled?.properties ?? []) {
+          readByAnElement.add(entry);
+        }
         const report = (messageId, data) => context.report({ data, messageId, node });
         const local = localVariablesOf(node);
         for (const { property, value } of styleEntriesOf(node)) {
@@ -68,20 +82,22 @@ var tokensOnlyColors = {
           }
         }
       },
+      Property(node) {
+        if (isTest || readByAnElement.has(node))
+          return;
+        const value = node.value;
+        if (value?.type !== "Literal" || typeof value.value !== "string")
+          return;
+        const name = keyOf(node);
+        if (name === undefined)
+          return;
+        reportDefault(node, name, value.value);
+      },
       AssignmentPattern(node) {
         const right = node.right;
         if (right?.type !== "Literal" || typeof right.value !== "string")
           return;
-        const offence = tokenOffence(right.value, prefixes, new Set);
-        if (offence === undefined || offence === "colorLiteral" && isNamedOnly(right.value))
-          return;
-        if (offence === "foreignVariable" && !isColorProperty(defaultedName(node)))
-          return;
-        context.report({
-          data: { property: defaultedName(node), value: right.value },
-          messageId: offence,
-          node
-        });
+        reportDefault(node, defaultedName(node), right.value);
       }
     };
   },
@@ -122,7 +138,6 @@ exactly like a clean tree.`,
     };
   }
 };
-var isNamedOnly = (value) => /^[a-z]+$/i.test(value.trim());
 var tokens_only_colors_default = tokensOnlyColors;
 export {
   tokens_only_colors_default as default

package/dist/rules/unique-query-step-name.d.ts

@@ -2,9 +2,7 @@ import { type RuleContextWithOptions } from './lib/context.js';
 import { type AnyNode } from './lib/nodes.js';
 import { type Probe } from './lib/probe.js';
 interface Options {
-    /** The call names that read through the query graph. No default: see the note above. */
     queryStepCalls?: string[];
-    /** The call names that define a workflow. Default: Medusa's `createWorkflow`. */
     workflowFactories?: string[];
 }
 declare const uniqueQueryStepName: {
@@ -40,11 +38,6 @@ declare const uniqueQueryStepName: {
         }[];
         type: 'problem';
     };
-    /**
-     * Two query steps in one body, one named and one not — which is one finding rather than two. A
-     * body with a single un-named step collides with nothing and is deliberately exempt, so a probe
-     * built from one would fire nothing and read as a rule that cannot be exercised.
-     */
     probe(options: readonly unknown[]): Probe;
 };
 export default uniqueQueryStepName;

package/dist/rules/unique-query-step-name.js

@@ -1,19 +1,15 @@
 // src/rules/unique-query-step-name.ts
-import { calleeNameOf, walkNode } from "./lib/nodes.js";
+import { walkNode } from "./lib/nodes.js";
 import { propertiesOf, stringOf, valueOf } from "./lib/objects.js";
 import { requireOption } from "./lib/options.js";
 import { bagOf, firstOf } from "./lib/probe.js";
 import { optionsBag, STRINGS } from "./lib/schema.js";
+import { DEFAULT_WORKFLOW_FACTORIES, isStepCall, workflowFactoriesOf } from "./lib/steps.js";
 var RULE = "unique-query-step-name";
 var ACCEPTS = "{ queryStepCalls: string[] (required), workflowFactories: string[] }";
-var DEFAULT_WORKFLOW_FACTORIES = ["createWorkflow"];
 var CONFIG = "config";
 var NAME = "name";
 var COLLIDES_FROM = 2;
-var isCallOf = (node, names) => {
-  const callee = calleeNameOf(node);
-  return callee !== null && names.has(callee);
-};
 var ABSENT = { kind: "absent" };
 var UNREADABLE = { kind: "unreadable" };
 var chainedName = (node, steps) => {
@@ -26,7 +22,7 @@ var chainedName = (node, steps) => {
   if (property?.type !== "Identifier" || property.name !== CONFIG)
     return null;
   const inner = callee.object;
-  if (inner === undefined || !isCallOf(inner, steps))
+  if (inner === undefined || !isStepCall(inner, steps))
     return null;
   const [first] = node.arguments ?? [];
   const properties = propertiesOf(first);
@@ -47,18 +43,18 @@ var stepsIn = (body, calls) => {
   });
   const steps = [];
   walkNode(body, (node) => {
-    if (isCallOf(node, calls))
+    if (isStepCall(node, calls))
       steps.push({ name: names.get(node) ?? ABSENT, node });
   });
   return steps;
 };
 var uniqueQueryStepName = {
   create(context) {
-    const factories = new Set(requireOption(RULE, context.options?.[0]?.workflowFactories ?? DEFAULT_WORKFLOW_FACTORIES, "workflowFactories"));
+    const factories = workflowFactoriesOf(RULE, context.options?.[0]?.workflowFactories);
     const calls = new Set(requireOption(RULE, context.options?.[0]?.queryStepCalls, "queryStepCalls", ACCEPTS));
     return {
       CallExpression(node) {
-        if (!isCallOf(node, factories))
+        if (!isStepCall(node, factories))
           return;
         const steps = stepsIn(node.arguments ?? [], calls);
         if (steps.length < COLLIDES_FROM)

package/dist/rules/worker-handles-are-scoped.d.ts

@@ -1,26 +1,30 @@
 import { type RuleContextWithOptions } from './lib/context.js';
 import { type Probe } from './lib/probe.js';
 interface Options {
-    /** Regex source, tested against the normalised filename: the tree that holds the cell workers. */
     within?: string;
-    /** The calls that open a scoped handle — `withCells`, `withConnection`, whatever this repo has. */
     wrapper?: string[];
 }
+interface Callee {
+    computed?: boolean;
+    name?: string;
+    property?: {
+        name?: string;
+        type?: string;
+    };
+    type?: string;
+}
 declare const cellHandlesAreScoped: {
     create(context: RuleContextWithOptions<Options>): {
+        ExportDefaultDeclaration?: undefined;
         CallExpression?: undefined;
         'Program:exit'?: undefined;
-        ExportDefaultDeclaration?: undefined;
         ClassDeclaration?: undefined;
     } | {
         ExportDefaultDeclaration(node: {
             declaration?: unknown;
         }): void;
         CallExpression(node: {
-            callee?: {
-                type?: string;
-                name?: string;
-            };
+            callee?: Callee;
         }): void;
         ClassDeclaration(node: {
             superClass?: {
@@ -59,7 +63,6 @@ declare const cellHandlesAreScoped: {
         }[];
         type: 'problem';
     };
-    /** A module handler inside the configured tree that never opens a scope — the smallest breach. */
     probe(options: readonly unknown[]): Probe;
 };
 export default cellHandlesAreScoped;

package/dist/rules/worker-handles-are-scoped.js

@@ -12,6 +12,14 @@ var entrypointMakers = new Set([
   "entrypointFor",
   "createWorkflowEntrypoint"
 ]);
+var calleeName = (callee) => {
+  if (callee?.type === "Identifier")
+    return callee.name;
+  if (callee?.type === "MemberExpression" && callee.computed !== true) {
+    return callee.property?.type === "Identifier" ? callee.property.name : undefined;
+  }
+  return;
+};
 var cellHandlesAreScoped = {
   create(context) {
     const within = requireOption(RULE, context.options?.[0]?.within, "within", ACCEPTS);
@@ -33,11 +41,10 @@ var cellHandlesAreScoped = {
         handlerNode = node;
       },
       CallExpression(node) {
-        if (node.callee?.type !== "Identifier")
-          return;
-        if (node.callee.name !== undefined && scopedBy.has(node.callee.name))
+        const called = calleeName(node.callee);
+        if (called !== undefined && scopedBy.has(called))
           scoped = true;
-        if (node.callee.name === "createWorkflowEntrypoint") {
+        if (node.callee?.type === "Identifier" && node.callee.name === "createWorkflowEntrypoint") {
           handler = "the workflow entrypoint";
           handlerNode = node;
         }
@@ -64,7 +71,7 @@ var cellHandlesAreScoped = {
   fixShape: `A worker that opens a database-cell handle wraps every invocation in the repo's scope wrapper — the
 module handlers (\`fetch\`, \`queue\`, \`scheduled\`, \`email\`) and the workflow entrypoint alike — so the
 handle is closed when the invocation ends: \`withCells(() => …, (closing) => ctx.waitUntil(closing))\`.
-A handler that declares itself and never calls it opens a pool per call and never closes one. Name
+The call may be a member — \`cellOf(env).withConnection(…)\` — as well as a bare name. A handler that declares itself and never calls it opens a pool per call and never closes one. Name
 the wrapper in \`wrapper\` and the tree the cell workers live in in \`within\`; enabled without either
 the rule reports that once a run and judges nothing.`,
   meta: {

package/dist/rules/zustand-v5-best-practices.d.ts

@@ -1,4 +1,5 @@
 import { type RuleContext } from './lib/context.js';
+import { type Probe } from './lib/probe.js';
 interface CallExpression {
     arguments: {
         callee?: {
@@ -17,24 +18,12 @@ interface CallExpression {
     };
     type: 'CallExpression';
 }
-/**
- * Zustand v5 best practices — single rule enforcing all patterns:
- *
- * 1. REQUIRE SELECTOR: useStore() without args subscribes to entire state.
- *    Fix: useStore((s) => s.field) or useStore(useShallow((s) => ({ ... })))
- *
- * 2. SINGLE CALL PER STORE: multiple useStore((s) => s.x) calls create
- *    separate subscriptions. Fix: consolidate with useShallow.
- *
- * 3. useShallow BYPASS: calls wrapped in useShallow are always allowed,
- *    even if there are multiple (edge case for different selector shapes).
- */
 declare const zustandV5BestPractices: {
     create(context: RuleContext): {
-        ArrowFunctionExpression(node: unknown): void;
-        'ArrowFunctionExpression:exit'(): void;
+        ArrowFunctionExpression: () => void;
+        'ArrowFunctionExpression:exit': () => void;
         CallExpression(node: CallExpression): void;
-        FunctionDeclaration(node: unknown): void;
+        FunctionDeclaration: () => void;
         ImportDeclaration(node: {
             source: {
                 value: string;
@@ -45,9 +34,9 @@ declare const zustandV5BestPractices: {
                 };
             }[];
         }): void;
-        'FunctionDeclaration:exit'(): void;
-        FunctionExpression(node: unknown): void;
-        'FunctionExpression:exit'(): void;
+        'FunctionDeclaration:exit': () => void;
+        FunctionExpression: () => void;
+        'FunctionExpression:exit': () => void;
     };
     fixShape: string;
     meta: {
@@ -61,5 +50,6 @@ declare const zustandV5BestPractices: {
         schema: never[];
         type: 'problem';
     };
+    probe(): Probe;
 };
 export default zustandV5BestPractices;