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

package/dist/rules/no-ts-in-bio-folders.d.ts

@@ -1,20 +1,8 @@
 import { type RuleContextWithOptions } from './lib/context.js';
+import { type Probe } from './lib/probe.js';
 type Options = {
     extraFolders?: readonly string[] | string;
 };
-/**
- * Issue #5. This rule used to carry its own list of "the architecture's folders" — `atoms,
- * molecules, compounds, cells, tissues, gutenberg, emails, organs`. It omitted `organelles`, which
- * LAW.md declares a tier, and named three folders the law never mentions; `no-invalid-feature-
- * folders` held a second, different list beside it. Which folders are tiers is not this rule's
- * decision: `lib/tiers.ts` declares them, held against LAW.md by a test, and both rules read it.
- * What IS this rule's decision is the one it is named for — a file sitting in a tier folder is not
- * a bare `.ts`.
- *
- * `gutenberg`, `emails` and `organs` were one repo's vocabulary in shared code, which LAW 6
- * forbids, so they are gone from the default and reachable as `extraFolders` by a consumer that
- * genuinely holds components somewhere the law does not name.
- */
 declare const noTsInBioFolders: {
     create(context: RuleContextWithOptions<Options>): {
         Program?: undefined;
@@ -48,5 +36,6 @@ declare const noTsInBioFolders: {
         }[];
         type: 'problem';
     };
+    probe(): Probe;
 };
 export default noTsInBioFolders;

package/dist/rules/no-ts-in-bio-folders.js

@@ -1,6 +1,7 @@
 // src/rules/no-ts-in-bio-folders.ts
 import { PATTERNS, patternsOf } from "./lib/options.js";
 import { fileOf, normalise } from "./lib/paths.js";
+import { optionsBag } from "./lib/schema.js";
 import { tierFolderOf } from "./lib/tiers.js";
 var HOOK_FILE = /^use-|^use[A-Z]/;
 var noTsInBioFolders = {
@@ -42,14 +43,15 @@ law does not name (\`emails/\`) names it in \`extraFolders\` (default: none).`,
     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: [
-      {
-        additionalProperties: false,
-        properties: { extraFolders: PATTERNS },
-        type: "object"
-      }
-    ],
+    schema: optionsBag({ extraFolders: PATTERNS }),
     type: "problem"
+  },
+  probe() {
+    return {
+      path: "src/cells/geonosis-probe.ts",
+      source: `export const computeThing = (n: number) => n * 2
+`
+    };
   }
 };
 var no_ts_in_bio_folders_default = noTsInBioFolders;

package/dist/rules/no-type-definitions-in-components.d.ts

@@ -1,4 +1,5 @@
 import { type RuleContext } from './lib/context.js';
+import { type Probe } from './lib/probe.js';
 declare const noTypeDefinitionsInComponents: {
     create(context: RuleContext): {
         TSInterfaceDeclaration?: undefined;
@@ -29,5 +30,6 @@ declare const noTypeDefinitionsInComponents: {
         schema: never[];
         type: 'problem';
     };
+    probe(): Probe;
 };
 export default noTypeDefinitionsInComponents;

package/dist/rules/no-type-definitions-in-components.js

@@ -1,6 +1,6 @@
 // src/rules/no-type-definitions-in-components.ts
 import { normalise } from "./lib/paths.js";
-var COMPONENT_FILE_PATTERN = /(?:^|\/)(?:features\/[^/]+\/)?(compounds|organelles|cells|tissues|organs)\/.+\.tsx$/;
+import { COMPONENT_FILE_PATTERN } from "./lib/tiers.js";
 var noTypeDefinitionsInComponents = {
   create(context) {
     const normalized = normalise(context.filename);
@@ -40,6 +40,17 @@ and is imported.`,
     },
     schema: [],
     type: "problem"
+  },
+  probe() {
+    return {
+      path: "src/cells/geonosis-probe.tsx",
+      source: `type Label = string
+
+export function GeonosisProbe({ label }: { label: Label }) {
+  return <button type="button">{label}</button>
+}
+`
+    };
   }
 };
 var no_type_definitions_in_components_default = noTypeDefinitionsInComponents;

package/dist/rules/no-unregistered-plugin-dir.d.ts

@@ -1,37 +1,8 @@
 import { type RuleContextWithOptions } from './lib/context.js';
 import { type Probe } from './lib/probe.js';
 interface Options {
-    /**
-     * What a plugin directory's entry file is called. REQUIRED, and it used to have a default.
-     *
-     * Run read-only over a Medusa storefront with a default of `index.ts` / `config.ts`, the rule
-     * reported zero findings on two roots whose directories are all registered — which read as a
-     * pass. It was not one: a Medusa storefront's plugin directories contain `service.ts` and no
-     * index at all, so the rule matched no file and answered a question it had never asked. The
-     * control run that names a registry containing none of them also reported zero, which is what
-     * caught it. A default that happens not to match a repo's layout is the silent zero
-     * `requireOption` exists to prevent.
-     */
     manifests?: string[];
-    /**
-     * The file that names them, read as source. Repo-root-relative.
-     *
-     * A LIST when the registry is split across files — a Medusa storefront's `medusa-config.ts`
-     * imports `medusa-config.fulfillment.ts`, and the carrier directories are registered in the half
-     * that is imported. Reading only the file the option named reported two registered carriers as
-     * dead weight, and a false positive on a working tree is how a rule gets turned off.
-     *
-     * The halves are listed rather than followed: chasing `import` statements out of a registry would
-     * need the repo's whole module resolution set up inside a linter, and would guess.
-     */
     registry?: string | string[];
-    /**
-     * The directories whose children are registrants. Repo-root-relative.
-     *
-     * A bare string means the children are DIRECTORIES, each holding one of `manifests`. A root
-     * written `{ path, files: true }` means the children are files, and each file is a registrant
-     * named by its own basename — a seam with no directories in it at all.
-     */
     roots?: (Root | string)[];
 }
 interface Root {
@@ -97,18 +68,6 @@ declare const noUnregisteredPluginDir: {
         }[];
         type: 'problem';
     };
-    /**
-     * A directory under a configured root, carrying a manifest, that the registry does not name — and
-     * the registry itself, because the rule reads it off disk and returns silently when it is not
-     * there. One file cannot be both the directory under `roots` and the registry at the consumer's
-     * own path, so the probe declares two. It was a single file until 2026-08-30, and every consumer
-     * enforcing this rule over a real registry read as a permanent FAIL for it: the probe fired
-     * nothing, which was the truth about the probe and a lie about the repo.
-     *
-     * The registry it writes carries no string literal at all, so nothing in it can name the
-     * directory beside it — the probe must be a directory the registry does NOT reach, or the rule is
-     * right to stay quiet.
-     */
     probe(options: readonly unknown[]): {
         files: Probe[];
     };

package/dist/rules/no-unregistered-plugin-dir.js

@@ -2,24 +2,16 @@
 import { readFileSync } from "node:fs";
 import { stripComments } from "./lib/module-text.js";
 import { requireOption } from "./lib/options.js";
-import { normalise } from "./lib/paths.js";
+import { normalise, rootedAt, trimSlashes } from "./lib/paths.js";
 import { bagOf } from "./lib/probe.js";
 import { optionsBag, STRING, STRINGS } from "./lib/schema.js";
 var RULE = "no-unregistered-plugin-dir";
 var ACCEPTS = "{ roots: (string | { path: string, files: boolean })[], registry: string | string[], manifests: string[] }";
-var trimSlashes = (path) => path.replace(/^\/+/, "").replace(/\/+$/, "");
 var literalsOf = (source) => [...stripComments(source).matchAll(/['"`]([^'"`\n]+)['"`]/g)].map((match) => match[1] ?? "");
 var names = (literal, directory) => {
   const segments = trimSlashes(literal.replace(/^\.\/?/, "")).split("/");
   return segments.includes(directory);
 };
-var rootedAt = (filename, root) => {
-  const marker = `/${root}/`;
-  const at = filename.indexOf(marker);
-  if (at < 0)
-    return null;
-  return { after: filename.slice(at + marker.length), repoRoot: filename.slice(0, at) };
-};
 var oneDirectory = (segments, manifests) => {
   if (segments.length !== 2)
     return null;

package/dist/rules/no-void-port.d.ts

@@ -1,9 +1,6 @@
 import { type RuleContextWithOptions } from './lib/context.js';
+import type { Probe } from './lib/probe.js';
 interface Options {
-    /**
-     * Regexes over the names of exported function-type aliases whose failure channel is an engine
-     * that catches the throw. Empty by default: a repo names its own engine contracts.
-     */
     engineCallbacks?: string[];
 }
 declare const voidPromise: (annotation: {
@@ -61,5 +58,6 @@ declare const noVoidPort: {
         }[];
         type: 'problem';
     };
+    probe(): Probe;
 };
 export default noVoidPort;

package/dist/rules/no-void-port.js

@@ -45,6 +45,13 @@ empty by default); a \`Result\` there would be ignored by the engine, never read
       engineCallbacks: STRINGS
     }),
     type: "problem"
+  },
+  probe() {
+    return {
+      path: "geonosis-probe-port.ts",
+      source: `export type GeonosisProbePort = () => Promise<void>
+`
+    };
   }
 };
 var no_void_port_default = noVoidPort;

package/dist/rules/organelle-dependency.d.ts

@@ -9,6 +9,7 @@ declare const organelleDependency: {
         }) => 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/organelle-dependency.js

@@ -4,13 +4,8 @@ import {
   crossesFeatureBoundary,
   SHARED_FEATURES_SCHEMA
 } from "./lib/shared-features.js";
-var ABOVE_AN_ORGANELLE = [
-  /\/cells\//,
-  /\/tissues\//,
-  /\/organs\//,
-  /(?:^|\/)layouts\//,
-  /(?:^|\/)app\//
-];
+import { APP_FOLDER, inOrgans, inTier, LAYOUTS_FOLDER } from "./lib/tiers.js";
+var aboveAnOrganelle = (path) => inTier(path, "cells") || inTier(path, "tissues") || inOrgans(path) || LAYOUTS_FOLDER.test(path) || APP_FOLDER.test(path);
 var CROSS_FEATURE_ORGANELLE = /(?:^|[/@])features\/([^/]+)\/organelles\//;
 var organelleDependency = directionRule({
   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 the same feature or one the `sharedFeatures` option names (default: shared).",
@@ -19,7 +14,7 @@ tissues, organs and layouts are above it — a cell contains the organelle, neve
 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.`,
   forbidden: (target, importer, options) => {
-    if (ABOVE_AN_ORGANELLE.some((pattern) => pattern.test(target.path)))
+    if (aboveAnOrganelle(target.path))
       return true;
     const importedFeature = CROSS_FEATURE_ORGANELLE.exec(target.path)?.[1];
     return crossesFeatureBoundary(importedFeature, importer.feature, options);
@@ -28,6 +23,13 @@ Cross-feature organelle imports are allowed only from the features named in the
     forbidden: 'Organelle "{{file}}" cannot import from "{{source}}". Organelles may depend on atoms, molecules, compounds, stores, domains, and sub-organelles (same feature, or one the `sharedFeatures` option names).'
   },
   optionsFrom: (raw) => raw ?? {},
+  probe: () => ({
+    path: "src/organelles/geonosis-probe.tsx",
+    source: `import { Up } from '../cells/geonosis-up'
+
+export const GeonosisProbe = Up
+`
+  }),
   scope: "organelles",
   schema: SHARED_FEATURES_SCHEMA
 });

package/dist/rules/organelle-single-source.d.ts

@@ -1,4 +1,5 @@
 import { type RuleContext } from './lib/context.js';
+import { type Probe } from './lib/probe.js';
 declare const organelleSingleSource: {
     create(context: RuleContext): import('./lib/visitors.js').Visitor;
     fixShape: string;
@@ -15,5 +16,6 @@ declare const organelleSingleSource: {
         schema: never[];
         type: 'problem';
     };
+    probe(): Probe;
 };
 export default organelleSingleSource;

package/dist/rules/organelle-single-source.js

@@ -1,27 +1,40 @@
 // src/rules/organelle-single-source.ts
+import { STORE_HOOK_NAME } from "./lib/hooks.js";
+import { isRelative } from "./lib/imports.js";
+import { fileFor } from "./lib/module-text.js";
 import { normalise } from "./lib/paths.js";
+import {
+  FORM_CONTEXT_IMPORT_PATTERN,
+  FORM_SOURCES,
+  isProvidersSource,
+  stateSourcesOf
+} from "./lib/state-sources.js";
+import { inTier } from "./lib/tiers.js";
 import { mergeVisitors, onImportSource } from "./lib/visitors.js";
-var ORGANELLE_FILE_PATTERN = /(?:^|\/)(?:features\/[^/]+\/)?organelles\//;
-var ZUSTAND_STORE_PATTERN = /^use\w+Store$/;
-var FORM_SOURCES = new Set(["react-hook-form"]);
-var FORM_CONTEXT_IMPORT_PATTERN = /FormContext$/;
 var organelleSingleSource = {
   create(context) {
     const normalized = normalise(context.filename);
-    if (!ORGANELLE_FILE_PATTERN.test(normalized))
+    if (!inTier(normalized, "organelles"))
       return {};
     const file = normalized.split("/").pop()?.replace(/\.tsx?$/, "") || "unknown";
     const storeHooks = new Map;
     let formNode = null;
     let formSource = "";
     let programNode = null;
+    const called = new Set;
+    const siblings = [];
     const fromModule = (source, node) => {
       if (FORM_SOURCES.has(source) && !formNode) {
         formNode = node;
         formSource = source;
         return;
       }
-      if (/(?:^|\/)providers(?:\/|$)/.test(source)) {
+      if (isRelative(source)) {
+        const locals = (node.specifiers ?? []).flatMap((spec) => spec.local?.name ?? []);
+        if (locals.length > 0)
+          siblings.push({ locals, node, source });
+      }
+      if (isProvidersSource(source)) {
         const specs = node.specifiers ?? [];
         for (const spec of specs) {
           const localName = spec.local?.name || "";
@@ -39,7 +52,8 @@ var organelleSingleSource = {
         const name = node.callee.name;
         if (!name)
           return;
-        if (ZUSTAND_STORE_PATTERN.test(name) && !storeHooks.has(name)) {
+        called.add(name);
+        if (STORE_HOOK_NAME.test(name) && !storeHooks.has(name)) {
           storeHooks.set(name, node);
         }
       },
@@ -47,6 +61,24 @@ var organelleSingleSource = {
         programNode = node;
       },
       "Program:exit"() {
+        for (const sibling of siblings) {
+          if (!sibling.locals.some((local) => called.has(local)))
+            continue;
+          const home = fileFor(context.filename, sibling.source);
+          if (home === undefined || home === context.filename || !inTier(home, "organelles")) {
+            continue;
+          }
+          const reached = stateSourcesOf(home);
+          for (const store of reached.stores) {
+            if (!storeHooks.has(store))
+              storeHooks.set(store, sibling.node);
+          }
+          const [form] = reached.forms;
+          if (form !== undefined && !formNode) {
+            formNode = sibling.node;
+            formSource = form;
+          }
+        }
         const storeNames = [...storeHooks.keys()];
         const isTsx = normalized.endsWith(".tsx");
         if (storeNames.length > 0 && formNode) {
@@ -76,10 +108,12 @@ var organelleSingleSource = {
   },
   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 — split into one focused organelle per
-source. The CELL is the only level where several sources meet; it derives and passes props down.`,
+source. The CELL is the only level where several sources meet; it derives and passes props down.
+A source read by a sibling organelle hook this file calls is this file's source too: moving a read
+next door does not split the organelle, it only hides one of its two sources.`,
   meta: {
     docs: {
-      description: "Organelles must have a single state source. (1) An organelle must not mix Zustand and react-hook-form — the cell coordinates across sources. (2) An organelle must read from at most ONE Zustand store — if it needs multiple stores, the cell should derive and pass the data down."
+      description: "Organelles must have a single state source, counting the sources of the sibling organelle hooks they call. (1) An organelle must not mix Zustand and react-hook-form — the cell coordinates across sources. (2) An organelle must read from at most ONE Zustand store — 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.',
@@ -89,6 +123,21 @@ source. The CELL is the only level where several sources meet; it derives and pa
     },
     schema: [],
     type: "problem"
+  },
+  probe() {
+    return {
+      path: "src/organelles/geonosis-probe.tsx",
+      source: `declare const useGeonosisAStore: <T>(select: (state: { a: T }) => T) => T
+declare const useGeonosisBStore: <T>(select: (state: { b: T }) => T) => T
+
+export function GeonosisProbe() {
+  const a = useGeonosisAStore((state) => state.a)
+  const b = useGeonosisBStore((state) => state.b)
+
+  return <div>{String(a) + String(b)}</div>
+}
+`
+    };
   }
 };
 var organelle_single_source_default = organelleSingleSource;

package/dist/rules/plugin-route-namespaced.d.ts

@@ -1,19 +1,13 @@
 import { type RuleContextWithOptions } from './lib/context.js';
 import { type Probe } from './lib/probe.js';
 interface PackageRule {
-    /** The package-name template `{dir}` is substituted into. Used only in messages. */
     name?: string;
-    /** The namespace segment routes must sit under. `{dir}` is the directory. Optional — see below. */
     namespace?: string;
-    /** Whether routes owned by this group must carry a namespace segment. */
     namespaced?: boolean;
-    /** The directory whose children are packages. */
     under: string;
 }
 interface Options {
-    /** Which directories hold packages, and which of them are namespace-checked. Required. */
     packages?: PackageRule[];
-    /** The scopes a plugin route may live under. Default: Medusa's two. */
     scopes?: string[];
 }
 declare const pluginRouteNamespaced: {
@@ -69,11 +63,6 @@ declare const pluginRouteNamespaced: {
         }[];
         type: 'problem';
     };
-    /**
-     * A plugin route sitting bare on a scope: `/store` and nothing of the plugin's own after it. The
-     * package directory is invented rather than read, because the offence is a PATH shape and a
-     * directory that does not exist yet has the same one.
-     */
     probe(options: readonly unknown[]): Probe;
 };
 export default pluginRouteNamespaced;

package/dist/rules/plugin-route-namespaced.js

@@ -1,6 +1,6 @@
 // src/rules/plugin-route-namespaced.ts
 import { requireOption } from "./lib/options.js";
-import { normalise } from "./lib/paths.js";
+import { normalise, trimSlashes } from "./lib/paths.js";
 import { bagOf, firstOf } from "./lib/probe.js";
 import { optionsBag, STRING, STRINGS } from "./lib/schema.js";
 var RULE = "plugin-route-namespaced";
@@ -18,7 +18,7 @@ var readPackages = (configured) => {
 };
 var ownerOf = (path, rules) => {
   for (const rule of rules) {
-    const prefix = `/${rule.under.replaceAll(/^\/+|\/+$/g, "")}/`;
+    const prefix = `/${trimSlashes(rule.under)}/`;
     const at = `/${path}`.indexOf(prefix);
     if (at === -1)
       continue;

package/dist/rules/queries-require-org-scope.d.ts

@@ -1,9 +1,7 @@
 import { type RuleContextWithOptions } from './lib/context.js';
 import { type Probe } from './lib/probe.js';
 interface Options {
-    /** Regex source(s), tested against the normalised filename: the query modules. */
     queries?: string | string[];
-    /** The field a tenant is scoped by. Default: `orgId`. */
     tenantKey?: string;
 }
 type TypeNode = {
@@ -82,7 +80,6 @@ declare const queriesRequireOrgScope: {
         }[];
         type: 'problem';
     };
-    /** An exported query in the tree the options name, whose params never write `orgId`. */
     probe(options: readonly unknown[]): Probe;
 };
 export default queriesRequireOrgScope;

package/dist/rules/queries-require-org-scope.js

@@ -1,9 +1,8 @@
 // src/rules/queries-require-org-scope.ts
-import { PATTERNS, patternsOf, requireOption } from "./lib/options.js";
+import { DEFAULT_TENANT_KEY, PATTERNS, patternsOf, requireOption } from "./lib/options.js";
 import { normalise } from "./lib/paths.js";
 import { bagOf, firstOf, pathMatching } from "./lib/probe.js";
-import { STRING } from "./lib/schema.js";
-var DEFAULT_TENANT_KEY = "orgId";
+import { optionsBag, STRING } from "./lib/schema.js";
 var RULE = "queries-require-org-scope";
 var ACCEPTS = "{ queries: string | string[] (regex sources over the filename: the query modules) }";
 function writesKey(annotation, key) {
@@ -59,13 +58,7 @@ nothing.`,
     messages: {
       missingOrgScope: 'Query "{{name}}" does not declare {{key}}. Give it a (db, params) signature whose params type literal includes "{{key}}: string" — every read and write is scoped to its tenant.'
     },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: { queries: PATTERNS, tenantKey: STRING },
-        type: "object"
-      }
-    ],
+    schema: optionsBag({ queries: PATTERNS, tenantKey: STRING }),
     type: "problem"
   },
   probe(options) {

package/dist/rules/queue-loop-is-the-library.js

@@ -1,9 +1,10 @@
 // src/rules/queue-loop-is-the-library.ts
-import { normalise } from "./lib/paths.js";
+import { isTestFile, normalise } from "./lib/paths.js";
 var queueMessageMethods = new Set(["ack", "retry", "ackAll", "retryAll"]);
 var queueLoopIsTheLibrary = {
   create(context) {
-    if (/node_modules|\/__tests__\//.test(normalise(context.filename)))
+    const path = normalise(context.filename);
+    if (path.includes("node_modules") || isTestFile(path))
       return {};
     return {
       CallExpression(node) {

package/dist/rules/route-no-inline-mutation.d.ts

@@ -1,30 +1,11 @@
+import { type SourceCode } from './lib/comments.js';
 import type { AnyNode } from './lib/nodes.js';
 import { type Probe } from './lib/probe.js';
 interface Options {
-    /** The annotation that marks a deliberately bare write. Default: the scanner's vocabulary. */
     inlineMutationOk?: string;
-    /** The call names that generate a service write. Default: what `MedusaService` generates. */
     mutationPrefixes?: string[];
-    /** Regex sources for the files that are route handlers. Default: Medusa's `api/**\/route.ts`. */
     paths?: string[];
 }
-type Comment = {
-    loc?: {
-        end?: {
-            line?: number;
-        };
-        start?: {
-            line?: number;
-        };
-    };
-    value?: string;
-};
-type SourceCode = {
-    ast?: {
-        comments?: Comment[];
-    };
-    getAllComments?: () => Comment[];
-};
 declare const routeNoInlineMutation: {
     create(context: {
         filename: string;
@@ -71,11 +52,6 @@ declare const routeNoInlineMutation: {
         }[];
         type: 'problem';
     };
-    /**
-     * A route writing through a service in its own body, with no escape marker on it. The write name
-     * is built from the configured prefix, because `writesWith` reads a capital after the prefix and
-     * a probe spelling `creatething` would pass the rule it is meant to trip.
-     */
     probe(options: readonly unknown[]): Probe;
 };
 export default routeNoInlineMutation;

package/dist/rules/route-no-inline-mutation.js

@@ -1,4 +1,5 @@
 // src/rules/route-no-inline-mutation.ts
+import { commentsOf } from "./lib/comments.js";
 import {
   DEFAULT_MUTATION_PREFIXES,
   mutationPrefixesOf,
@@ -12,7 +13,6 @@ import { optionsBag, STRING, STRINGS } from "./lib/schema.js";
 var RULE = "route-no-inline-mutation";
 var DEFAULT_PATHS = [String.raw`(?:^|/)api/.*/route\.[cm]?[jt]sx?$`];
 var DEFAULT_INLINE_MUTATION_OK = "arch:inline-mutation-ok";
-var commentsOf = (sourceCode) => sourceCode?.getAllComments?.() ?? sourceCode?.ast?.comments ?? [];
 var isStatement = (node) => typeof node.type === "string" && (node.type.endsWith("Statement") || node.type === "VariableDeclaration");
 var lineOf = (node, edge) => {
   const loc = node.loc;
@@ -51,12 +51,7 @@ var annotated = (found, comments, marker) => {
   const end = lineOf(anchor, "end") ?? start;
   if (start === null || end === null)
     return false;
-  return comments.some((comment) => {
-    if (!(comment.value ?? "").includes(marker))
-      return false;
-    const line = comment.loc?.start?.line;
-    return typeof line === "number" && line >= start - 1 && line <= end;
-  });
+  return comments.some((comment) => comment.value.includes(marker) && comment.loc.start.line >= start - 1 && comment.loc.start.line <= end);
 };
 var routeNoInlineMutation = {
   create(context) {

package/dist/rules/router-schema-parity.d.ts

@@ -1,15 +1,10 @@
 import { type RuleContextWithOptions } from './lib/context.js';
 import { type Probe } from './lib/probe.js';
 interface Options {
-    /** Basenames that are neither a router nor a schema — `_app`, `index`, `errors`, `pagination`. */
     ignore?: string[];
-    /** Router basename -> the schema basenames it serves. */
     mounts?: Record<string, string[]>;
-    /** Repo-root-relative directory of the routers. */
     routers?: string;
-    /** Repo-root-relative directory of the schemas. */
     schemas?: string;
-    /** What a schema file adds to the shared basename, if anything — `.schema`. */
     suffix?: string;
 }
 declare const routerSchemaParity: {
@@ -51,10 +46,6 @@ declare const routerSchemaParity: {
         }[];
         type: 'problem';
     };
-    /**
-     * A router with no schema half. The two directories are repo-root-relative, and the missing half
-     * is a question about the tree the run is over: nothing writes the twin, so nothing is there.
-     */
     probe(options: readonly unknown[]): Probe;
 };
 export default routerSchemaParity;

package/dist/rules/router-schema-parity.js

@@ -1,24 +1,20 @@
 // src/rules/router-schema-parity.ts
 import { existsSync } from "node:fs";
 import { requireOption } from "./lib/options.js";
-import { normalise } from "./lib/paths.js";
+import { normalise, rootedAt, trimSlashes } from "./lib/paths.js";
 import { bagOf } from "./lib/probe.js";
 import { optionsBag, STRING, STRINGS } from "./lib/schema.js";
 var RULE = "router-schema-parity";
 var EXTENSIONS = [".ts", ".tsx"];
-var trimSlashes = (path) => path.replace(/^\/+/, "").replace(/\/+$/, "");
 var baseOf = (file) => file.replace(/\.[cm]?[jt]sx?$/, "");
 var NEITHER_HALF = /\.(?:test|spec|d)$/;
 var existsWithAnyExtension = (withoutExtension) => EXTENSIONS.map((extension) => `${withoutExtension}${extension}`).find((path) => existsSync(path)) ?? null;
 var directlyUnder = (filename, directory) => {
-  const marker = `/${directory}/`;
-  const at = filename.indexOf(marker);
-  if (at < 0)
+  const rooted = rootedAt(filename, directory);
+  if (rooted === null || rooted.after.includes("/") || NEITHER_HALF.test(baseOf(rooted.after))) {
     return null;
-  const after = filename.slice(at + marker.length);
-  if (after.includes("/") || NEITHER_HALF.test(baseOf(after)))
-    return null;
-  return { base: baseOf(after), repoRoot: filename.slice(0, at) };
+  }
+  return { base: baseOf(rooted.after), repoRoot: rooted.repoRoot };
 };
 var routerSchemaParity = {
   create(context) {

package/dist/rules/service-name-not-reserved.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 register a module. Default: Medusa's `Module`. */
     moduleFactories?: string[];
-    /** The keys the framework owns. Default: the 32 values of `Modules` at 2.19.0. */
     reserved?: string[];
 }
 declare const serviceNameNotReserved: {
@@ -41,7 +39,6 @@ declare const serviceNameNotReserved: {
         }[];
         type: 'problem';
     };
-    /** A module registered under a key the framework owns — the first of the configured list. */
     probe(options: readonly unknown[]): Probe;
 };
 export default serviceNameNotReserved;