exadev-eslint-config 3.0.2 → 3.1.0

package/README.md

@@ -193,7 +193,7 @@ export default tseslint.config(
 );
 ```
 
-`plugin.configs.recommended`/`plugin.configs.barrel` carry no `files`/`ignores` and are safe unscoped — `no-side-effects-in-index` and `no-non-barrel-reexport` each check `context.filename` themselves (self-scoping). For a barrel not at `src/index.ts`, or a project-specific exception, layer an override on top (e.g. `{ files: ['lib/other.ts'], rules: { 'exadev/no-non-barrel-reexport': 'off' } }`) rather than wiring all four rules individually.
+`plugin.configs.recommended`/`plugin.configs.barrel` carry no `files`/`ignores` and are safe unscoped — `no-side-effects-in-index` and `no-non-barrel-reexport` each check `context.filename` themselves (self-scoping). For a barrel not at `src/index.ts`, or a project-specific exception, layer an override on top (e.g. `{ files: ['lib/other.ts'], rules: { 'exadev/no-non-barrel-reexport': 'off' } }`) rather than wiring all four rules individually. A package that publishes several entry points declares them through `exadev/barrel-policy`'s `entries` option instead (see [Package entry points](#package-entry-points)), which keeps each entry held to the barrel rules rather than switching them off.
 
 ## Optional features
 
@@ -376,7 +376,7 @@ Bundled into `exadevConfig()`'s default output the same way React/Next.js auto-d
 
 | Rule | Fixable | Description |
 | --- | --- | --- |
-| `barrel-policy` | | **Umbrella rule selecting a whole index-file barrel policy.** One `{ mode }` option covers the four barrel rules below. See [Barrel policy](#barrel-policy). |
+| `barrel-policy` | | **Umbrella rule selecting a whole index-file barrel policy.** One `{ mode }` option covers the four barrel rules below, and an `entries` option declares a package's other entry files as barrels. See [Barrel policy](#barrel-policy). |
 | `no-index-files` | | **Bans any `index.*` file outright** (mode 1). The strictest policy. |
 | `no-non-barrel-index` | | **Only `src/index.ts` may be named `index.*`** — any other `index.ts`/`.js`/etc would be silently selected by a consumer's bare directory import. |
 | `no-non-barrel-reexport` | ✓ | **Re-exports belong only in a barrel.** Catches the split form across two statements (`import { x } from './y'; export { x };` or `export default x;`) which no AST selector alone can match. Autofix deletes the export and the now-pointless import when it was the import's only use. Self-scopes away from any index file. |
@@ -465,6 +465,33 @@ Notes on `'auto'`:
 
 In every mode, re-exports are banned outside a permitted barrel, and a permitted barrel may contain only re-export statements. The umbrella composes the identical predicates the standalone rules use (shared in [`src/rules/barrel-helpers.ts`](src/rules/barrel-helpers.ts)). It is non-fixable — the autofix lives on `no-non-barrel-reexport`.
 
+### Package entry points
+
+A package that publishes subpath exports (`"./layout"`, `"./store/node"`) has a module behind each one, and that module is an entry point exactly as `src/index.ts` is: its job is to re-export a surface, usually another package's. `single` treats only `src/index.ts` as a barrel and `siblings` only accepts re-exports from a direct sibling, so neither mode can describe such a package, and turning the rule off for the entry files would also stop checking that they hold nothing but re-exports. The `entries` option lists them instead:
+
+```ts
+export default defineConfig(...exadevConfig(), {
+  rules: {
+    'exadev/barrel-policy': ['error', { mode: 'single', entries: ['src/layout.ts', 'src/store/*.ts', 'src/*/index.ts'] }],
+  },
+});
+```
+
+`entries` is a list of globs in the [file glob form](#file-level-rules), relative to the directory of the `package.json` nearest the linted file rather than to ESLint's working directory, so one shared config serves every package in a workspace. A glob is matched as written, with no widening to any depth: `src/*.ts` selects the files directly in `src`, and `src/*/index.ts` one level of index files below it. A leading `!` excludes. A file with no `package.json` above it is no package's entry point.
+
+A matched file is a permitted barrel in the mode's terms:
+
+| `mode` | What an entry file may contain | Where its re-exports may come from |
+| --- | --- | --- |
+| `'single'` (and `'auto'` resolved to `single`) | only re-exports | anywhere, as for `src/index.ts` |
+| `'siblings'` | only re-exports | a package (`pkg`, `@scope/pkg/sub`, `node:fs`) or a direct sibling (`./module`) |
+
+An entry file that is an index file below `src` is not reported as a second index file in `single` mode. Every file the list does not match keeps the behaviour its mode gives it: a re-export from it is still reported, an index file it does not match is still reported in `single` mode, and a non-entry index file in `siblings` mode still re-exports only from its siblings. In `siblings` mode a relative path that is not a sibling (`../shared`, `./a/b`) and a subpath import (`#internal`, which resolves to a file of this package) are reported from an entry file too.
+
+`entries` beside `mode: 'banned'` is an error when the rule is created, since that mode permits no barrel. Under `'auto'`, a package with neither `exports` nor `main` resolves to `banned` and publishes no entry point, so the list selects nothing there.
+
+Why a list rather than reading `exports`: an `exports` target names the built file (`./dist/layout.js`), and which source file produced it depends on the build tool's configuration (tsdown or tsup entries, `tsc`'s `rootDir` and `outDir`, a bundler's input map), which a lint rule cannot read. Deriving the entries would therefore guess, and a wrong guess either reports a real entry point or lets an ordinary module re-export freely; the list states them exactly.
+
 ## File-level rules
 
 `required-exports`, `required-imports`, `import-policy` and `filename-pattern` check one file against a convention that depends on its path. Each self-scopes through `context.filename`, so it is a no-op on every other file and can sit in a shared config without a `files` array of its own. None needs type information, and none is in `recommended`, since each takes options only a project can supply.

package/dist/index.cjs

@@ -485,7 +485,7 @@ function buildOptionalPluginConfig(preset, options = {}) {
 }
 //#endregion
 //#region package.json
-var version = "3.0.2";
+var version = "3.1.0";
 //#endregion
 //#region src/react.ts
 /**
@@ -629,6 +629,14 @@ function isDirectSibling(specifier) {
 	return rest !== "." && rest !== ".." && rest !== "" && !rest.includes("/");
 }
 /**
+* True when a module specifier names a package rather than a file of this one: a bare specifier (`pkg`, `pkg/sub`, `@scope/pkg/sub`) or a Node builtin (`fs`, `node:fs`). Rejects a relative path (`./x`, `../x`, `.`), an absolute path (`/x`), a subpath import (`#x`, which resolves through this package's own `imports` map to one of its own files) and any other URL scheme (`file:`, `https:`, and a Windows drive letter, which has the same shape).
+*/
+function isPackageSpecifier(specifier) {
+	if (specifier.startsWith(".") || specifier.startsWith("/") || specifier.startsWith("#")) return false;
+	const scheme = /^[a-z][a-z\d+.-]*:/i.exec(specifier);
+	return scheme === null || scheme[0] === "node:";
+}
+/**
 * Runtime type guard narrowing ESLint's `any`-typed context.options entry to BarrelMode without an assertion. ESLint validates the enum in a rule's meta.schema before the rule runs, so a well-configured caller never reaches the false branch; the guard exists to satisfy the type-aware lint rules (no-unsafe-argument) that a plain comparison against `any` does not, since comparing `any` to a string literal leaves the value typed as `any` rather than narrowing it.
 */
 function isBarrelMode(value) {
@@ -764,31 +772,41 @@ function decideAutoBarrelMode(packageJson) {
 	const hasMain = typeof main === "string" && main.length > 0;
 	return hasExports || hasMain ? "single" : "banned";
 }
+const packageRootByStartDir = /* @__PURE__ */ new Map();
 const packageJsonByStartDir = /* @__PURE__ */ new Map();
 /**
-* The real, filesystem-backed ReadPackageJsonFn: walks upward from startDir to the nearest ancestor package.json (inclusive of startDir itself), parses it, and returns undefined once the walk reaches the filesystem root with nothing found. A found manifest that is not a usable JSON object (isRecord rejects an array as well as a string, number, boolean or null) collapses to the same undefined, matching workspace-graph.ts's identical readDeclaredManifest: this rule has nothing to read `exports`/`main` off an array-shaped or scalar manifest any more than off a wholly absent one, so the two are indistinguishable to decideAutoBarrelMode's caller. This is the production default threaded through resolveAutoMode/createBarrelPolicyRule below; tests inject a stub instead so they never touch the real filesystem.
+* The real, filesystem-backed FindPackageRootFn: walks upward from startDir to the nearest directory holding a package.json (startDir itself included) and returns that directory, or undefined once the walk reaches the filesystem root with nothing found. Only the file's existence is checked, so a manifest that does not parse still marks its directory as the package root.
 */
-function findNearestPackageJson(startDir) {
-	const cached = packageJsonByStartDir.get(startDir);
-	if (packageJsonByStartDir.has(startDir)) return cached;
+function findNearestPackageRoot(startDir) {
+	const cached = packageRootByStartDir.get(startDir);
+	if (packageRootByStartDir.has(startDir)) return cached;
 	let dir = startDir;
 	for (;;) {
-		const candidate = (0, node_path.join)(dir, "package.json");
-		if ((0, node_fs.existsSync)(candidate)) {
-			const parsed = JSON.parse((0, node_fs.readFileSync)(candidate, "utf8"));
-			const result = isRecord(parsed) ? parsed : void 0;
-			packageJsonByStartDir.set(startDir, result);
-			return result;
+		if ((0, node_fs.existsSync)((0, node_path.join)(dir, "package.json"))) {
+			packageRootByStartDir.set(startDir, dir);
+			return dir;
 		}
 		const parent = (0, node_path.dirname)(dir);
 		if (parent === dir) {
-			packageJsonByStartDir.set(startDir, void 0);
+			packageRootByStartDir.set(startDir, void 0);
 			return;
 		}
 		dir = parent;
 	}
 }
 /**
+* The real, filesystem-backed ReadPackageJsonFn: finds the nearest ancestor package.json through findNearestPackageRoot (startDir itself included), parses it, and returns undefined when there is none. A found manifest that is not a usable JSON object (isRecord rejects an array as well as a string, number, boolean or null) collapses to the same undefined, matching workspace-graph.ts's identical readDeclaredManifest: this rule has nothing to read `exports`/`main` off an array-shaped or scalar manifest any more than off a wholly absent one, so the two are indistinguishable to decideAutoBarrelMode's caller. This is the production default threaded through resolveAutoMode/createBarrelPolicyRule below; tests inject a stub instead so they never touch the real filesystem.
+*/
+function findNearestPackageJson(startDir) {
+	const cached = packageJsonByStartDir.get(startDir);
+	if (packageJsonByStartDir.has(startDir)) return cached;
+	const root = findNearestPackageRoot(startDir);
+	const parsed = root === void 0 ? void 0 : JSON.parse((0, node_fs.readFileSync)((0, node_path.join)(root, "package.json"), "utf8"));
+	const result = isRecord(parsed) ? parsed : void 0;
+	packageJsonByStartDir.set(startDir, result);
+	return result;
+}
+/**
 * filename is a file path (e.g. context.filename); the walk starts from its containing directory, not from filename itself. No ancestor package.json (a file outside any real package) resolves to 'banned' — the same conservative default as a package with neither exports nor main.
 */
 function resolveAutoMode(filename, readPackageJsonFn = findNearestPackageJson) {
@@ -808,31 +826,52 @@ function readMode(options) {
 	return options.mode;
 }
 /**
+* Extracts and validates the `entries` option: the package's declared entry files, as globs relative to the directory of the nearest `package.json`. Returns `undefined` when the options carry no `entries` key, since an absent list declares no entry files at all. Throws, naming the option, for a list `readFileGlobs` rejects (not an array of non-empty strings, a duplicate glob, no include, or a glob minimatch cannot compile), and for `entries` beside `mode: 'banned'`, which permits no barrel for an entry to be. Call it after readMode, which has already rejected an options value that is not an object.
+*/
+function readEntries(options) {
+	if (!isRecord(options) || !("entries" in options)) return void 0;
+	if (options["mode"] === "banned") throw new Error("exadev/barrel-policy: \"entries\" declares barrels, which mode 'banned' forbids; use 'single', 'siblings' or 'auto' with entries.");
+	return readFileGlobs(options["entries"], "exadev/barrel-policy entries");
+}
+/**
+* Whether `filename` matches one of the `entries` globs, matched against its forward-slash path relative to the directory of its nearest package.json. A file with no package.json above it belongs to no package, so it declares no entry point.
+*/
+function isDeclaredEntry(filename, entries, findPackageRoot) {
+	const root = findPackageRoot((0, node_path.dirname)(filename));
+	if (root === void 0) return false;
+	return createPathMatcher(entries)(relativeToCwd(filename, root));
+}
+/**
 * The convenience layer over this package's barrel rules: one rule id, one `{ mode }` option selecting one of three complete index-file policies, so a consumer writes a single config entry instead of wiring several rules together. The three modes are the orthogonal combinations of "which files may be barrels", "what a barrel may contain", and "where a barrel's re-exports may come from":
 *
 * 'banned'   — no index files at all; re-exports banned everywhere. 'single'   — exactly src/index.ts may be a barrel; it contains only re-exports; re-exports banned everywhere else. 'siblings' — any index file may be a barrel; each contains only re-exports; each re-export comes from a direct sibling (./module); re-exports banned in every non-index file.
 *
 * Implemented self-contained (its own visitor + message ids) over the shared predicates in barrel-helpers.ts, so the standalone rules and this umbrella share one source of truth for "what is an index file", "what is a pure re-export", "what is a direct sibling", and "what is a split-statement re-export" — no behavioural drift between the granular rules and the convenience one. A consumer uses EITHER this umbrella (one line, opinionated) OR the individual rules (full control, e.g. 'single' plus one extra cross-package re-export exception); not both, since they would double-report the same violations.
 *
+* The `entries` option adds a package's own declared entry files to the permitted barrels of 'single' and 'siblings' (and of 'auto' where it resolves to 'single'): a package that publishes several subpath exports has one module behind each, and each such module is an entry point exactly as src/index.ts is. An entry file is held to the barrel contents rule (only re-exports). In 'single' its re-exports may come from anywhere, as src/index.ts's may; in 'siblings' each must name a package or a direct sibling, since an entry point's job is to publish another package's surface or its own directory's. Every file the list does not match keeps the behaviour its mode gives it. The entries are listed, not derived from package.json's `exports`, because an exports target names the built file (`./dist/layout.js`), and mapping that back to its source depends on the build tool's own configuration, which this rule cannot read.
+*
 * Unlike the standalone no-non-barrel-reexport, this umbrella is non-fixable: the autofix belongs on the granular rule, and a policy-level rule that sometimes fixes and sometimes doesn't would surface that inconsistency under one rule id. Consumers who want the autofix use no-non-barrel-reexport directly.
 *
-* A factory, not a plain object, specifically so a test can inject a stub ReadPackageJsonFn (see barrel-auto-detect.ts) without that resolver becoming part of the rule's public JSON options schema — ESLint validates context.options against meta.schema with additionalProperties: false, so there is no options-based channel to smuggle a function through even if one were wanted. The default export below is this factory called with the real, filesystem-backed default; barrel-policy.unit.test.ts imports createBarrelPolicyRule directly to exercise 'auto' against fabricated package.json data with zero real filesystem I/O. Mirrors the requireFn-as-parameter-with-a-real-default shape optional-plugin.ts's tryRequire already establishes for the same "injectable in tests, defaulted in production" problem.
+* A factory, not a plain object, specifically so a test can inject stub BarrelPolicySeams (see barrel-auto-detect.ts) without those resolvers becoming part of the rule's public JSON options schema: ESLint validates context.options against meta.schema with additionalProperties: false, so there is no options-based channel to pass a function through even if one were wanted. The default export below is this factory called with the real, filesystem-backed defaults; barrel-policy.unit.test.ts imports createBarrelPolicyRule directly to exercise 'auto' and `entries` against fabricated package data with no real filesystem I/O. Mirrors the requireFn-as-parameter-with-a-real-default shape optional-plugin.ts's tryRequire already establishes for the same "injectable in tests, defaulted in production" problem.
 */
-function createBarrelPolicyRule(readPackageJsonFn = findNearestPackageJson) {
+function createBarrelPolicyRule({ readPackageJson = findNearestPackageJson, findPackageRoot = findNearestPackageRoot } = {}) {
 	return {
 		meta: {
 			type: "problem",
 			schema: [{
 				type: "object",
-				properties: { mode: {
-					type: "string",
-					enum: [
-						"banned",
-						"single",
-						"siblings",
-						"auto"
-					]
-				} },
+				properties: {
+					mode: {
+						type: "string",
+						enum: [
+							"banned",
+							"single",
+							"siblings",
+							"auto"
+						]
+					},
+					entries: fileGlobsSchema
+				},
 				additionalProperties: false
 			}],
 			messages: {
@@ -840,14 +879,41 @@ function createBarrelPolicyRule(readPackageJsonFn = findNearestPackageJson) {
 				nonMainIndexFile: "Only src/index.ts may be a barrel in this project — this index file is not it. Move its contents into the module that owns them or give the file a descriptive name.",
 				sideEffectInBarrel: "A barrel may contain only re-export statements ('export * from ...' / 'export { x } from ...' / 'export type { x } from ...') — nothing else, so it can never have a side effect at import time by construction. Found: {{ description }}.",
 				reexportOutsideBarrel: "Re-exports belong only in a barrel (index) file — import this value directly in the file that uses it instead of re-exporting it through this one.",
-				notADirectSibling: "A barrel may re-export only from a direct sibling file or folder ('./module' or './module.ts') — found '{{ source }}'. Move the source closer, or import it directly at the call site rather than re-exporting it through this barrel."
+				notADirectSibling: "A barrel may re-export only from a direct sibling file or folder ('./module' or './module.ts') — found '{{ source }}'. Move the source closer, or import it directly at the call site rather than re-exporting it through this barrel.",
+				notAPackageOrSibling: "A package entry point may re-export only from a package ('pkg', '@scope/pkg/sub') or a direct sibling file or folder ('./module'); found '{{ source }}'. Re-export it through the package that owns it, move the source beside this entry point, or import it directly at the call site."
 			}
 		},
 		create(context) {
 			const filename = context.filename;
 			const rawMode = readMode(context.options[0]);
-			const mode = rawMode === "auto" ? resolveAutoMode(filename, readPackageJsonFn) : rawMode;
+			const entries = readEntries(context.options[0]);
+			const mode = rawMode === "auto" ? resolveAutoMode(filename, readPackageJson) : rawMode;
+			const isEntry = mode !== "banned" && entries !== void 0 && isDeclaredEntry(filename, entries, findPackageRoot);
+			const isBarrel = isEntry || isPermittedBarrel(filename, mode);
 			const detector = createSplitReexportDetector();
+			/**
+			* Reports a re-export whose source `source` this file may not name: any re-export outside a barrel, and, in 'siblings' mode, a barrel's re-export that is not from a direct sibling (or, in a declared entry file, from a package either).
+			*/
+			function checkReexportSource(node, source) {
+				if (!isBarrel) {
+					context.report({
+						node,
+						messageId: "reexportOutsideBarrel"
+					});
+					return;
+				}
+				if (mode !== "siblings" || isDirectSibling(source)) return;
+				if (!isEntry) context.report({
+					node,
+					messageId: "notADirectSibling",
+					data: { source }
+				});
+				else if (!isPackageSpecifier(source)) context.report({
+					node,
+					messageId: "notAPackageOrSibling",
+					data: { source }
+				});
+			}
 			return {
 				Program(node) {
 					if (mode === "banned") {
@@ -857,79 +923,36 @@ function createBarrelPolicyRule(readPackageJsonFn = findNearestPackageJson) {
 						});
 						return;
 					}
-					if (mode === "single") {
-						if (isIndexFile(filename) && !isMainBarrel(filename)) {
-							context.report({
-								node,
-								messageId: "nonMainIndexFile"
-							});
-							return;
-						}
-						if (isMainBarrel(filename)) {
-							for (const statement of node.body) if (!isPureReexport(statement)) context.report({
-								node: statement,
-								messageId: "sideEffectInBarrel",
-								data: { description: statement.type }
-							});
-						}
-						return;
-					}
-					if (isIndexFile(filename)) {
-						for (const statement of node.body) if (!isPureReexport(statement)) context.report({
-							node: statement,
-							messageId: "sideEffectInBarrel",
-							data: { description: statement.type }
+					if (isIndexFile(filename) && !isBarrel) {
+						context.report({
+							node,
+							messageId: "nonMainIndexFile"
 						});
+						return;
 					}
+					if (!isBarrel) return;
+					for (const statement of node.body) if (!isPureReexport(statement)) context.report({
+						node: statement,
+						messageId: "sideEffectInBarrel",
+						data: { description: statement.type }
+					});
 				},
 				ImportDeclaration: (node) => {
 					detector.visitImport(node);
 				},
 				ExportNamedDeclaration(node) {
 					detector.visitExportNamed(node);
-					if (hasSource(node) && !isInsideAmbientModuleDeclaration(node)) {
-						const source = moduleSpecifierValue(node.source);
-						if (!isPermittedBarrel(filename, mode)) context.report({
-							node,
-							messageId: "reexportOutsideBarrel"
-						});
-						else if (mode === "siblings" && !isDirectSibling(source)) context.report({
-							node,
-							messageId: "notADirectSibling",
-							data: { source }
-						});
-					}
+					if (hasSource(node) && !isInsideAmbientModuleDeclaration(node)) checkReexportSource(node, moduleSpecifierValue(node.source));
 				},
 				ExportAllDeclaration(node) {
 					if (isInsideAmbientModuleDeclaration(node)) return;
-					const source = moduleSpecifierValue(node.source);
-					if (!isPermittedBarrel(filename, mode)) context.report({
-						node,
-						messageId: "reexportOutsideBarrel"
-					});
-					else if (mode === "siblings" && !isDirectSibling(source)) context.report({
-						node,
-						messageId: "notADirectSibling",
-						data: { source }
-					});
+					checkReexportSource(node, moduleSpecifierValue(node.source));
 				},
 				ExportDefaultDeclaration: (node) => {
 					detector.visitExportDefault(node);
 				},
 				"Program:exit"() {
-					for (const violation of detector.violations()) if (isPermittedBarrel(filename, mode)) {
-						if (mode === "siblings") {
-							const importSource = moduleSpecifierValue(violation.trackedImport.declaration.source);
-							if (!isDirectSibling(importSource)) context.report({
-								node: violation.kind === "named" ? violation.specifier : violation.declaration,
-								messageId: "notADirectSibling",
-								data: { source: importSource }
-							});
-						}
-					} else context.report({
-						node: violation.kind === "named" ? violation.specifier : violation.declaration,
-						messageId: "reexportOutsideBarrel"
-					});
+					for (const violation of detector.violations()) checkReexportSource(violation.kind === "named" ? violation.specifier : violation.declaration, moduleSpecifierValue(violation.trackedImport.declaration.source));
 				}
 			};
 		}

package/dist/index.d.cts

@@ -8,16 +8,20 @@ import "@typescript-eslint/utils/json-schema";
  */
 type PublicConfigArray = Config[];
 /**
- * What each of PublicPlugin's four bundled configs actually resolves to at runtime (src/plugin.ts's own getters): `recommended`/`barrel` are each a single flat config object; `react`/`nextjs` are each an array, since building React/Next.js support composes more than one upstream config block (src/react.ts/src/nextjs.ts). Never a LegacyConfigObject: `@eslint/core`'s own `Plugin['configs']` allows one, but none of the four getters ever return one, so the public type doesn't need to describe one either.
+ * What `recommended` and `barrel` (src/plugin.ts's own getters) resolve to at runtime: each a single flat config object. Never a LegacyConfigObject: `@eslint/core`'s own `Plugin['configs']` allows one, but neither getter ever returns one, so the public type doesn't need to describe one either.
  */
-type PublicConfigObject = ConfigObject | ConfigObject[];
+type PublicConfigObject = ConfigObject;
+/**
+ * What `react` and `nextjs` resolve to at runtime: each an array, since building React/Next.js support composes more than one upstream config block (src/react.ts/src/nextjs.ts). Typed as the array it is, so a consumer can spread it (`defineConfig(...plugin.configs.react)`) as well as pass it to `extends`.
+ */
+type PublicConfigObjectArray = ConfigObject[];
 /**
  * Derived from ESLintCoreConfigObject's own `plugins` field (a real library type, not a hand-written interface), matching the derivation style ConfigValue above already uses. The named `plugin` export (this package's public entry point for a consumer wiring `plugins: { exadev: plugin }` straight into `defineConfig()`) needs `@eslint/core`'s own Plugin shape for the same reason PublicConfigArray needs ESLintCoreConfig: `plugin`'s internal build (src/plugin.ts) is typed against `@typescript-eslint/utils`' `TSESLint.FlatConfig.Plugin`, whose `configs` field (`Record<string, TSESLint.FlatConfig.Config | TSESLint.FlatConfig.ConfigArray>`) is not assignable to `@eslint/core`'s own `Record<string, LegacyConfigObject | ConfigObject | ConfigObject[]>` under `exactOptionalPropertyTypes: true` (confirmed directly: a bare `defineConfig({ plugins: { exadev: plugin } })` fails TS2375 on exactly this property before the cast in src/to-public-plugin.ts is applied). `@eslint/core` itself is deliberately not a direct import here, the same way PublicConfigArray avoids one for Config: indexing through `eslint/config`'s own re-exported `ConfigObject` keeps this package's peer surface at just `eslint`, which every consumer already has.
  *
- * PublicPlugin further narrows Plugin's own `configs` field down to the shape README.md actually documents: exactly the four literal keys src/plugin.ts's own object declares, each typed as PublicConfigObject above, in place of Plugin's own `configs?: Record<string, LegacyConfigObject | ConfigObject | ConfigObject[]> | undefined`. Without this narrowing, `plugin.configs.recommended` fails three ways at once under a plain `strict: true` consumer tsconfig plus this repo's own `noPropertyAccessFromIndexSignature`: TS4111 (Plugin['configs'] has no literal keys, only an index signature, so dot access is rejected), TS18048 even after switching to index access (`configs` itself is optional on the un-narrowed type), and TS2322 wherever the result is then used as an `extends` element (LegacyConfigObject's own `plugins` field is `string[]`, not the `Record<string, Plugin>` an `ExtendsElement`/`InfiniteArray<ConfigWithExtends>` requires): confirmed directly against `tseslint.config({ extends: [plugin.configs.recommended] })` and the equivalent `defineConfig()` React/Next.js examples (README.md's own "lighter option" and "Optional features" sections; see src/readme-examples.ts).
+ * PublicPlugin further narrows Plugin's own `configs` field down to the shape README.md actually documents: exactly the four literal keys src/plugin.ts's own object declares, each typed as what its getter returns (PublicConfigObject or PublicConfigObjectArray above), in place of Plugin's own `configs?: Record<string, LegacyConfigObject | ConfigObject | ConfigObject[]> | undefined`. Without this narrowing, `plugin.configs.recommended` fails three ways at once under a plain `strict: true` consumer tsconfig plus this repo's own `noPropertyAccessFromIndexSignature`: TS4111 (Plugin['configs'] has no literal keys, only an index signature, so dot access is rejected), TS18048 even after switching to index access (`configs` itself is optional on the un-narrowed type), and TS2322 wherever the result is then used as an `extends` element (LegacyConfigObject's own `plugins` field is `string[]`, not the `Record<string, Plugin>` an `ExtendsElement`/`InfiniteArray<ConfigWithExtends>` requires): confirmed directly against `tseslint.config({ extends: [plugin.configs.recommended] })` and the equivalent `defineConfig()` React/Next.js examples (README.md's own "lighter option" and "Optional features" sections; see src/readme-examples.ts).
  */
 type PublicPlugin = Omit<NonNullable<ConfigObject['plugins']>[string], 'configs'> & {
-  readonly configs: Readonly<Record<'recommended' | 'barrel' | 'react' | 'nextjs', PublicConfigObject>>;
+  readonly configs: Readonly<Record<'recommended' | 'barrel', PublicConfigObject> & Record<'react' | 'nextjs', PublicConfigObjectArray>>;
 };
 //#endregion
 //#region src/agent-skills.d.ts

package/dist/index.d.ts

@@ -8,16 +8,20 @@ import "@typescript-eslint/utils/json-schema";
  */
 type PublicConfigArray = Config[];
 /**
- * What each of PublicPlugin's four bundled configs actually resolves to at runtime (src/plugin.ts's own getters): `recommended`/`barrel` are each a single flat config object; `react`/`nextjs` are each an array, since building React/Next.js support composes more than one upstream config block (src/react.ts/src/nextjs.ts). Never a LegacyConfigObject: `@eslint/core`'s own `Plugin['configs']` allows one, but none of the four getters ever return one, so the public type doesn't need to describe one either.
+ * What `recommended` and `barrel` (src/plugin.ts's own getters) resolve to at runtime: each a single flat config object. Never a LegacyConfigObject: `@eslint/core`'s own `Plugin['configs']` allows one, but neither getter ever returns one, so the public type doesn't need to describe one either.
  */
-type PublicConfigObject = ConfigObject | ConfigObject[];
+type PublicConfigObject = ConfigObject;
+/**
+ * What `react` and `nextjs` resolve to at runtime: each an array, since building React/Next.js support composes more than one upstream config block (src/react.ts/src/nextjs.ts). Typed as the array it is, so a consumer can spread it (`defineConfig(...plugin.configs.react)`) as well as pass it to `extends`.
+ */
+type PublicConfigObjectArray = ConfigObject[];
 /**
  * Derived from ESLintCoreConfigObject's own `plugins` field (a real library type, not a hand-written interface), matching the derivation style ConfigValue above already uses. The named `plugin` export (this package's public entry point for a consumer wiring `plugins: { exadev: plugin }` straight into `defineConfig()`) needs `@eslint/core`'s own Plugin shape for the same reason PublicConfigArray needs ESLintCoreConfig: `plugin`'s internal build (src/plugin.ts) is typed against `@typescript-eslint/utils`' `TSESLint.FlatConfig.Plugin`, whose `configs` field (`Record<string, TSESLint.FlatConfig.Config | TSESLint.FlatConfig.ConfigArray>`) is not assignable to `@eslint/core`'s own `Record<string, LegacyConfigObject | ConfigObject | ConfigObject[]>` under `exactOptionalPropertyTypes: true` (confirmed directly: a bare `defineConfig({ plugins: { exadev: plugin } })` fails TS2375 on exactly this property before the cast in src/to-public-plugin.ts is applied). `@eslint/core` itself is deliberately not a direct import here, the same way PublicConfigArray avoids one for Config: indexing through `eslint/config`'s own re-exported `ConfigObject` keeps this package's peer surface at just `eslint`, which every consumer already has.
  *
- * PublicPlugin further narrows Plugin's own `configs` field down to the shape README.md actually documents: exactly the four literal keys src/plugin.ts's own object declares, each typed as PublicConfigObject above, in place of Plugin's own `configs?: Record<string, LegacyConfigObject | ConfigObject | ConfigObject[]> | undefined`. Without this narrowing, `plugin.configs.recommended` fails three ways at once under a plain `strict: true` consumer tsconfig plus this repo's own `noPropertyAccessFromIndexSignature`: TS4111 (Plugin['configs'] has no literal keys, only an index signature, so dot access is rejected), TS18048 even after switching to index access (`configs` itself is optional on the un-narrowed type), and TS2322 wherever the result is then used as an `extends` element (LegacyConfigObject's own `plugins` field is `string[]`, not the `Record<string, Plugin>` an `ExtendsElement`/`InfiniteArray<ConfigWithExtends>` requires): confirmed directly against `tseslint.config({ extends: [plugin.configs.recommended] })` and the equivalent `defineConfig()` React/Next.js examples (README.md's own "lighter option" and "Optional features" sections; see src/readme-examples.ts).
+ * PublicPlugin further narrows Plugin's own `configs` field down to the shape README.md actually documents: exactly the four literal keys src/plugin.ts's own object declares, each typed as what its getter returns (PublicConfigObject or PublicConfigObjectArray above), in place of Plugin's own `configs?: Record<string, LegacyConfigObject | ConfigObject | ConfigObject[]> | undefined`. Without this narrowing, `plugin.configs.recommended` fails three ways at once under a plain `strict: true` consumer tsconfig plus this repo's own `noPropertyAccessFromIndexSignature`: TS4111 (Plugin['configs'] has no literal keys, only an index signature, so dot access is rejected), TS18048 even after switching to index access (`configs` itself is optional on the un-narrowed type), and TS2322 wherever the result is then used as an `extends` element (LegacyConfigObject's own `plugins` field is `string[]`, not the `Record<string, Plugin>` an `ExtendsElement`/`InfiniteArray<ConfigWithExtends>` requires): confirmed directly against `tseslint.config({ extends: [plugin.configs.recommended] })` and the equivalent `defineConfig()` React/Next.js examples (README.md's own "lighter option" and "Optional features" sections; see src/readme-examples.ts).
  */
 type PublicPlugin = Omit<NonNullable<ConfigObject['plugins']>[string], 'configs'> & {
-  readonly configs: Readonly<Record<'recommended' | 'barrel' | 'react' | 'nextjs', PublicConfigObject>>;
+  readonly configs: Readonly<Record<'recommended' | 'barrel', PublicConfigObject> & Record<'react' | 'nextjs', PublicConfigObjectArray>>;
 };
 //#endregion
 //#region src/agent-skills.d.ts

package/dist/index.js

@@ -450,7 +450,7 @@ function buildOptionalPluginConfig(preset, options = {}) {
 }
 //#endregion
 //#region package.json
-var version = "3.0.2";
+var version = "3.1.0";
 //#endregion
 //#region src/react.ts
 /**
@@ -594,6 +594,14 @@ function isDirectSibling(specifier) {
 	return rest !== "." && rest !== ".." && rest !== "" && !rest.includes("/");
 }
 /**
+* True when a module specifier names a package rather than a file of this one: a bare specifier (`pkg`, `pkg/sub`, `@scope/pkg/sub`) or a Node builtin (`fs`, `node:fs`). Rejects a relative path (`./x`, `../x`, `.`), an absolute path (`/x`), a subpath import (`#x`, which resolves through this package's own `imports` map to one of its own files) and any other URL scheme (`file:`, `https:`, and a Windows drive letter, which has the same shape).
+*/
+function isPackageSpecifier(specifier) {
+	if (specifier.startsWith(".") || specifier.startsWith("/") || specifier.startsWith("#")) return false;
+	const scheme = /^[a-z][a-z\d+.-]*:/i.exec(specifier);
+	return scheme === null || scheme[0] === "node:";
+}
+/**
 * Runtime type guard narrowing ESLint's `any`-typed context.options entry to BarrelMode without an assertion. ESLint validates the enum in a rule's meta.schema before the rule runs, so a well-configured caller never reaches the false branch; the guard exists to satisfy the type-aware lint rules (no-unsafe-argument) that a plain comparison against `any` does not, since comparing `any` to a string literal leaves the value typed as `any` rather than narrowing it.
 */
 function isBarrelMode(value) {
@@ -729,31 +737,41 @@ function decideAutoBarrelMode(packageJson) {
 	const hasMain = typeof main === "string" && main.length > 0;
 	return hasExports || hasMain ? "single" : "banned";
 }
+const packageRootByStartDir = /* @__PURE__ */ new Map();
 const packageJsonByStartDir = /* @__PURE__ */ new Map();
 /**
-* The real, filesystem-backed ReadPackageJsonFn: walks upward from startDir to the nearest ancestor package.json (inclusive of startDir itself), parses it, and returns undefined once the walk reaches the filesystem root with nothing found. A found manifest that is not a usable JSON object (isRecord rejects an array as well as a string, number, boolean or null) collapses to the same undefined, matching workspace-graph.ts's identical readDeclaredManifest: this rule has nothing to read `exports`/`main` off an array-shaped or scalar manifest any more than off a wholly absent one, so the two are indistinguishable to decideAutoBarrelMode's caller. This is the production default threaded through resolveAutoMode/createBarrelPolicyRule below; tests inject a stub instead so they never touch the real filesystem.
+* The real, filesystem-backed FindPackageRootFn: walks upward from startDir to the nearest directory holding a package.json (startDir itself included) and returns that directory, or undefined once the walk reaches the filesystem root with nothing found. Only the file's existence is checked, so a manifest that does not parse still marks its directory as the package root.
 */
-function findNearestPackageJson(startDir) {
-	const cached = packageJsonByStartDir.get(startDir);
-	if (packageJsonByStartDir.has(startDir)) return cached;
+function findNearestPackageRoot(startDir) {
+	const cached = packageRootByStartDir.get(startDir);
+	if (packageRootByStartDir.has(startDir)) return cached;
 	let dir = startDir;
 	for (;;) {
-		const candidate = join(dir, "package.json");
-		if (existsSync(candidate)) {
-			const parsed = JSON.parse(readFileSync(candidate, "utf8"));
-			const result = isRecord(parsed) ? parsed : void 0;
-			packageJsonByStartDir.set(startDir, result);
-			return result;
+		if (existsSync(join(dir, "package.json"))) {
+			packageRootByStartDir.set(startDir, dir);
+			return dir;
 		}
 		const parent = dirname(dir);
 		if (parent === dir) {
-			packageJsonByStartDir.set(startDir, void 0);
+			packageRootByStartDir.set(startDir, void 0);
 			return;
 		}
 		dir = parent;
 	}
 }
 /**
+* The real, filesystem-backed ReadPackageJsonFn: finds the nearest ancestor package.json through findNearestPackageRoot (startDir itself included), parses it, and returns undefined when there is none. A found manifest that is not a usable JSON object (isRecord rejects an array as well as a string, number, boolean or null) collapses to the same undefined, matching workspace-graph.ts's identical readDeclaredManifest: this rule has nothing to read `exports`/`main` off an array-shaped or scalar manifest any more than off a wholly absent one, so the two are indistinguishable to decideAutoBarrelMode's caller. This is the production default threaded through resolveAutoMode/createBarrelPolicyRule below; tests inject a stub instead so they never touch the real filesystem.
+*/
+function findNearestPackageJson(startDir) {
+	const cached = packageJsonByStartDir.get(startDir);
+	if (packageJsonByStartDir.has(startDir)) return cached;
+	const root = findNearestPackageRoot(startDir);
+	const parsed = root === void 0 ? void 0 : JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+	const result = isRecord(parsed) ? parsed : void 0;
+	packageJsonByStartDir.set(startDir, result);
+	return result;
+}
+/**
 * filename is a file path (e.g. context.filename); the walk starts from its containing directory, not from filename itself. No ancestor package.json (a file outside any real package) resolves to 'banned' — the same conservative default as a package with neither exports nor main.
 */
 function resolveAutoMode(filename, readPackageJsonFn = findNearestPackageJson) {
@@ -773,31 +791,52 @@ function readMode(options) {
 	return options.mode;
 }
 /**
+* Extracts and validates the `entries` option: the package's declared entry files, as globs relative to the directory of the nearest `package.json`. Returns `undefined` when the options carry no `entries` key, since an absent list declares no entry files at all. Throws, naming the option, for a list `readFileGlobs` rejects (not an array of non-empty strings, a duplicate glob, no include, or a glob minimatch cannot compile), and for `entries` beside `mode: 'banned'`, which permits no barrel for an entry to be. Call it after readMode, which has already rejected an options value that is not an object.
+*/
+function readEntries(options) {
+	if (!isRecord(options) || !("entries" in options)) return void 0;
+	if (options["mode"] === "banned") throw new Error("exadev/barrel-policy: \"entries\" declares barrels, which mode 'banned' forbids; use 'single', 'siblings' or 'auto' with entries.");
+	return readFileGlobs(options["entries"], "exadev/barrel-policy entries");
+}
+/**
+* Whether `filename` matches one of the `entries` globs, matched against its forward-slash path relative to the directory of its nearest package.json. A file with no package.json above it belongs to no package, so it declares no entry point.
+*/
+function isDeclaredEntry(filename, entries, findPackageRoot) {
+	const root = findPackageRoot(dirname(filename));
+	if (root === void 0) return false;
+	return createPathMatcher(entries)(relativeToCwd(filename, root));
+}
+/**
 * The convenience layer over this package's barrel rules: one rule id, one `{ mode }` option selecting one of three complete index-file policies, so a consumer writes a single config entry instead of wiring several rules together. The three modes are the orthogonal combinations of "which files may be barrels", "what a barrel may contain", and "where a barrel's re-exports may come from":
 *
 * 'banned'   — no index files at all; re-exports banned everywhere. 'single'   — exactly src/index.ts may be a barrel; it contains only re-exports; re-exports banned everywhere else. 'siblings' — any index file may be a barrel; each contains only re-exports; each re-export comes from a direct sibling (./module); re-exports banned in every non-index file.
 *
 * Implemented self-contained (its own visitor + message ids) over the shared predicates in barrel-helpers.ts, so the standalone rules and this umbrella share one source of truth for "what is an index file", "what is a pure re-export", "what is a direct sibling", and "what is a split-statement re-export" — no behavioural drift between the granular rules and the convenience one. A consumer uses EITHER this umbrella (one line, opinionated) OR the individual rules (full control, e.g. 'single' plus one extra cross-package re-export exception); not both, since they would double-report the same violations.
 *
+* The `entries` option adds a package's own declared entry files to the permitted barrels of 'single' and 'siblings' (and of 'auto' where it resolves to 'single'): a package that publishes several subpath exports has one module behind each, and each such module is an entry point exactly as src/index.ts is. An entry file is held to the barrel contents rule (only re-exports). In 'single' its re-exports may come from anywhere, as src/index.ts's may; in 'siblings' each must name a package or a direct sibling, since an entry point's job is to publish another package's surface or its own directory's. Every file the list does not match keeps the behaviour its mode gives it. The entries are listed, not derived from package.json's `exports`, because an exports target names the built file (`./dist/layout.js`), and mapping that back to its source depends on the build tool's own configuration, which this rule cannot read.
+*
 * Unlike the standalone no-non-barrel-reexport, this umbrella is non-fixable: the autofix belongs on the granular rule, and a policy-level rule that sometimes fixes and sometimes doesn't would surface that inconsistency under one rule id. Consumers who want the autofix use no-non-barrel-reexport directly.
 *
-* A factory, not a plain object, specifically so a test can inject a stub ReadPackageJsonFn (see barrel-auto-detect.ts) without that resolver becoming part of the rule's public JSON options schema — ESLint validates context.options against meta.schema with additionalProperties: false, so there is no options-based channel to smuggle a function through even if one were wanted. The default export below is this factory called with the real, filesystem-backed default; barrel-policy.unit.test.ts imports createBarrelPolicyRule directly to exercise 'auto' against fabricated package.json data with zero real filesystem I/O. Mirrors the requireFn-as-parameter-with-a-real-default shape optional-plugin.ts's tryRequire already establishes for the same "injectable in tests, defaulted in production" problem.
+* A factory, not a plain object, specifically so a test can inject stub BarrelPolicySeams (see barrel-auto-detect.ts) without those resolvers becoming part of the rule's public JSON options schema: ESLint validates context.options against meta.schema with additionalProperties: false, so there is no options-based channel to pass a function through even if one were wanted. The default export below is this factory called with the real, filesystem-backed defaults; barrel-policy.unit.test.ts imports createBarrelPolicyRule directly to exercise 'auto' and `entries` against fabricated package data with no real filesystem I/O. Mirrors the requireFn-as-parameter-with-a-real-default shape optional-plugin.ts's tryRequire already establishes for the same "injectable in tests, defaulted in production" problem.
 */
-function createBarrelPolicyRule(readPackageJsonFn = findNearestPackageJson) {
+function createBarrelPolicyRule({ readPackageJson = findNearestPackageJson, findPackageRoot = findNearestPackageRoot } = {}) {
 	return {
 		meta: {
 			type: "problem",
 			schema: [{
 				type: "object",
-				properties: { mode: {
-					type: "string",
-					enum: [
-						"banned",
-						"single",
-						"siblings",
-						"auto"
-					]
-				} },
+				properties: {
+					mode: {
+						type: "string",
+						enum: [
+							"banned",
+							"single",
+							"siblings",
+							"auto"
+						]
+					},
+					entries: fileGlobsSchema
+				},
 				additionalProperties: false
 			}],
 			messages: {
@@ -805,14 +844,41 @@ function createBarrelPolicyRule(readPackageJsonFn = findNearestPackageJson) {
 				nonMainIndexFile: "Only src/index.ts may be a barrel in this project — this index file is not it. Move its contents into the module that owns them or give the file a descriptive name.",
 				sideEffectInBarrel: "A barrel may contain only re-export statements ('export * from ...' / 'export { x } from ...' / 'export type { x } from ...') — nothing else, so it can never have a side effect at import time by construction. Found: {{ description }}.",
 				reexportOutsideBarrel: "Re-exports belong only in a barrel (index) file — import this value directly in the file that uses it instead of re-exporting it through this one.",
-				notADirectSibling: "A barrel may re-export only from a direct sibling file or folder ('./module' or './module.ts') — found '{{ source }}'. Move the source closer, or import it directly at the call site rather than re-exporting it through this barrel."
+				notADirectSibling: "A barrel may re-export only from a direct sibling file or folder ('./module' or './module.ts') — found '{{ source }}'. Move the source closer, or import it directly at the call site rather than re-exporting it through this barrel.",
+				notAPackageOrSibling: "A package entry point may re-export only from a package ('pkg', '@scope/pkg/sub') or a direct sibling file or folder ('./module'); found '{{ source }}'. Re-export it through the package that owns it, move the source beside this entry point, or import it directly at the call site."
 			}
 		},
 		create(context) {
 			const filename = context.filename;
 			const rawMode = readMode(context.options[0]);
-			const mode = rawMode === "auto" ? resolveAutoMode(filename, readPackageJsonFn) : rawMode;
+			const entries = readEntries(context.options[0]);
+			const mode = rawMode === "auto" ? resolveAutoMode(filename, readPackageJson) : rawMode;
+			const isEntry = mode !== "banned" && entries !== void 0 && isDeclaredEntry(filename, entries, findPackageRoot);
+			const isBarrel = isEntry || isPermittedBarrel(filename, mode);
 			const detector = createSplitReexportDetector();
+			/**
+			* Reports a re-export whose source `source` this file may not name: any re-export outside a barrel, and, in 'siblings' mode, a barrel's re-export that is not from a direct sibling (or, in a declared entry file, from a package either).
+			*/
+			function checkReexportSource(node, source) {
+				if (!isBarrel) {
+					context.report({
+						node,
+						messageId: "reexportOutsideBarrel"
+					});
+					return;
+				}
+				if (mode !== "siblings" || isDirectSibling(source)) return;
+				if (!isEntry) context.report({
+					node,
+					messageId: "notADirectSibling",
+					data: { source }
+				});
+				else if (!isPackageSpecifier(source)) context.report({
+					node,
+					messageId: "notAPackageOrSibling",
+					data: { source }
+				});
+			}
 			return {
 				Program(node) {
 					if (mode === "banned") {
@@ -822,79 +888,36 @@ function createBarrelPolicyRule(readPackageJsonFn = findNearestPackageJson) {
 						});
 						return;
 					}
-					if (mode === "single") {
-						if (isIndexFile(filename) && !isMainBarrel(filename)) {
-							context.report({
-								node,
-								messageId: "nonMainIndexFile"
-							});
-							return;
-						}
-						if (isMainBarrel(filename)) {
-							for (const statement of node.body) if (!isPureReexport(statement)) context.report({
-								node: statement,
-								messageId: "sideEffectInBarrel",
-								data: { description: statement.type }
-							});
-						}
-						return;
-					}
-					if (isIndexFile(filename)) {
-						for (const statement of node.body) if (!isPureReexport(statement)) context.report({
-							node: statement,
-							messageId: "sideEffectInBarrel",
-							data: { description: statement.type }
+					if (isIndexFile(filename) && !isBarrel) {
+						context.report({
+							node,
+							messageId: "nonMainIndexFile"
 						});
+						return;
 					}
+					if (!isBarrel) return;
+					for (const statement of node.body) if (!isPureReexport(statement)) context.report({
+						node: statement,
+						messageId: "sideEffectInBarrel",
+						data: { description: statement.type }
+					});
 				},
 				ImportDeclaration: (node) => {
 					detector.visitImport(node);
 				},
 				ExportNamedDeclaration(node) {
 					detector.visitExportNamed(node);
-					if (hasSource(node) && !isInsideAmbientModuleDeclaration(node)) {
-						const source = moduleSpecifierValue(node.source);
-						if (!isPermittedBarrel(filename, mode)) context.report({
-							node,
-							messageId: "reexportOutsideBarrel"
-						});
-						else if (mode === "siblings" && !isDirectSibling(source)) context.report({
-							node,
-							messageId: "notADirectSibling",
-							data: { source }
-						});
-					}
+					if (hasSource(node) && !isInsideAmbientModuleDeclaration(node)) checkReexportSource(node, moduleSpecifierValue(node.source));
 				},
 				ExportAllDeclaration(node) {
 					if (isInsideAmbientModuleDeclaration(node)) return;
-					const source = moduleSpecifierValue(node.source);
-					if (!isPermittedBarrel(filename, mode)) context.report({
-						node,
-						messageId: "reexportOutsideBarrel"
-					});
-					else if (mode === "siblings" && !isDirectSibling(source)) context.report({
-						node,
-						messageId: "notADirectSibling",
-						data: { source }
-					});
+					checkReexportSource(node, moduleSpecifierValue(node.source));
 				},
 				ExportDefaultDeclaration: (node) => {
 					detector.visitExportDefault(node);
 				},
 				"Program:exit"() {
-					for (const violation of detector.violations()) if (isPermittedBarrel(filename, mode)) {
-						if (mode === "siblings") {
-							const importSource = moduleSpecifierValue(violation.trackedImport.declaration.source);
-							if (!isDirectSibling(importSource)) context.report({
-								node: violation.kind === "named" ? violation.specifier : violation.declaration,
-								messageId: "notADirectSibling",
-								data: { source: importSource }
-							});
-						}
-					} else context.report({
-						node: violation.kind === "named" ? violation.specifier : violation.declaration,
-						messageId: "reexportOutsideBarrel"
-					});
+					for (const violation of detector.violations()) checkReexportSource(violation.kind === "named" ? violation.specifier : violation.declaration, moduleSpecifierValue(violation.trackedImport.declaration.source));
 				}
 			};
 		}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "exadev-eslint-config",
   "description": "Shared custom ESLint rules and plugin for ExaDev projects",
-  "version": "3.0.2",
+  "version": "3.1.0",
   "dependencies": {
     "@eslint/js": "^10.0.1",
     "@microsoft/tsdoc": "0.17.1",