@exadev/eslint-config 0.0.0 → 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Joseph Mearman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,77 @@
+# @exadev/eslint-config
+
+> A real ESLint plugin (not a shareable config) exposing custom rules shared across ExaDev projects, starting with the [documents.js](https://github.com/ExaDev/documents.js) family (`documents.js`, `ooxml.js`, `odf.js`, `document-schema.js`, `pdf-codec`, `markdown-codec`). Also published under the unscoped alias `exadev-eslint-config`.
+
+## Why
+
+Every one of those repos independently carried identical copies of a handful of custom ESLint rules (barrel/index discipline, re-export placement, pointless-alias detection). Keeping them as per-repo copies meant a bug fix in one rule had to be found, fixed, and re-verified separately in every repo it was copied into. This package is the single source of truth for those rules instead.
+
+Only the *rules* are centralized here, not each consumer's whole `eslint.config.ts`. Every repo's own file-scoping (`files`/`ignores`), tsconfig wiring, and Worker-isomorphism import bans genuinely differ from repo to repo -- forcing those into one shared config would mean either losing real per-repo distinctions or building a heavily-parameterised config just to route around them. Each consumer keeps its own `eslint.config.ts`, importing rule implementations from here instead of a local copy.
+
+## Usage
+
+```sh
+pnpm add -D @exadev/eslint-config
+```
+
+```ts
+// eslint.config.ts
+import exadev from '@exadev/eslint-config';
+import tseslint from 'typescript-eslint';
+
+export default tseslint.config(
+  // ...your own config...
+  {
+    files: ['src/**/*.ts'],
+    ignores: ['src/index.ts'],
+    plugins: { exadev },
+    rules: {
+      'exadev/no-non-barrel-reexport': 'error',
+    },
+  },
+);
+```
+
+Or use one of the bundled configs to enable a whole set at once:
+
+```ts
+import exadev from '@exadev/eslint-config';
+import { defineConfig } from 'eslint/config';
+
+export default defineConfig([
+  {
+    files: ['**/*.ts'],
+    plugins: { exadev },
+    extends: ['exadev/recommended'], // every rule this plugin defines
+    // or: extends: ['exadev/barrel'], // just the barrel-discipline trio (no-non-barrel-index, no-non-barrel-reexport, no-side-effects-in-index)
+  },
+]);
+```
+
+## Rules
+
+| Rule | Fixable | Description |
+| --- | --- | --- |
+| `no-non-barrel-index` | | Only `src/index.ts` may be named `index.*` -- any other module named `index.ts`/`.js`/etc would be silently selected by a consumer's bare directory import. |
+| `no-non-barrel-reexport` | ✓ | Re-exports belong only in the public barrel. Catches both the single-statement form (`export { x } from './y'`, already caught by a plain `no-restricted-syntax` rule) and the split form across two statements (`import { x } from './y'; export { x };` or `export default x;`), which no AST selector alone can match. The autofix deletes the offending export, and the now-pointless import alongside it whenever that export was the import's only use anywhere in the file. |
+| `no-pointless-reassignment` | ✓ | `const foo = bar` where both sides are plain identifiers and the alias adds no transformation. |
+| `no-side-effects-in-index` | | The public barrel may contain only re-export statements -- nothing that could execute at import time. |
+
+## Development
+
+```sh
+pnpm install
+pnpm lint
+pnpm typecheck
+pnpm build
+```
+
+No test suite exists for these rules currently -- each is verified by real-world usage against the repos it was extracted from, the same way it was verified before being centralized here.
+
+## Release
+
+Conventional commits (enforced by commitlint) drive [semantic-release](https://semantic-release.gitbook.io/semantic-release) on every push to `main`: version bump, `CHANGELOG.md`, GitHub Release, and an npm publish via OIDC trusted publishing (no stored token). A second CI job republishes the identical build under the unscoped alias `exadev-eslint-config`.
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,39 @@
+//#endregion
+//#region src/index.ts
+const plugin = {
+	meta: {
+		name: "@exadev/eslint-config",
+		version: "1.0.0",
+		namespace: "exadev"
+	},
+	rules: {
+		"no-non-barrel-index": require("./rules/no-non-barrel-index.cjs"),
+		"no-non-barrel-reexport": require("./rules/no-non-barrel-reexport.cjs"),
+		"no-pointless-reassignment": require("./rules/no-pointless-reassignment.cjs"),
+		"no-side-effects-in-index": require("./rules/no-side-effects-in-index.cjs")
+	},
+	configs: {}
+};
+const { configs } = plugin;
+if (configs === void 0) throw new Error("Unreachable: configs was just initialized to {} in the object literal above.");
+Object.assign(configs, {
+	recommended: {
+		plugins: { exadev: plugin },
+		rules: {
+			"exadev/no-non-barrel-index": "error",
+			"exadev/no-non-barrel-reexport": "error",
+			"exadev/no-pointless-reassignment": "error",
+			"exadev/no-side-effects-in-index": "error"
+		}
+	},
+	barrel: {
+		plugins: { exadev: plugin },
+		rules: {
+			"exadev/no-non-barrel-index": "error",
+			"exadev/no-non-barrel-reexport": "error",
+			"exadev/no-side-effects-in-index": "error"
+		}
+	}
+});
+//#endregion
+module.exports = plugin;

package/dist/index.d.cts

@@ -0,0 +1,4 @@
+import { ESLint } from "eslint";
+//#region src/index.d.ts
+declare const plugin: ESLint.Plugin;
+export = plugin;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import { ESLint } from "eslint";
+//#region src/index.d.ts
+declare const plugin: ESLint.Plugin;
+//#endregion
+export { plugin as default };

package/dist/index.js

@@ -0,0 +1,43 @@
+import noNonBarrelIndex from "./rules/no-non-barrel-index.js";
+import noNonBarrelReexport from "./rules/no-non-barrel-reexport.js";
+import noPointlessReassignment from "./rules/no-pointless-reassignment.js";
+import noSideEffectsInIndex from "./rules/no-side-effects-in-index.js";
+//#endregion
+//#region src/index.ts
+const plugin = {
+	meta: {
+		name: "@exadev/eslint-config",
+		version: "1.0.0",
+		namespace: "exadev"
+	},
+	rules: {
+		"no-non-barrel-index": noNonBarrelIndex,
+		"no-non-barrel-reexport": noNonBarrelReexport,
+		"no-pointless-reassignment": noPointlessReassignment,
+		"no-side-effects-in-index": noSideEffectsInIndex
+	},
+	configs: {}
+};
+const { configs } = plugin;
+if (configs === void 0) throw new Error("Unreachable: configs was just initialized to {} in the object literal above.");
+Object.assign(configs, {
+	recommended: {
+		plugins: { exadev: plugin },
+		rules: {
+			"exadev/no-non-barrel-index": "error",
+			"exadev/no-non-barrel-reexport": "error",
+			"exadev/no-pointless-reassignment": "error",
+			"exadev/no-side-effects-in-index": "error"
+		}
+	},
+	barrel: {
+		plugins: { exadev: plugin },
+		rules: {
+			"exadev/no-non-barrel-index": "error",
+			"exadev/no-non-barrel-reexport": "error",
+			"exadev/no-side-effects-in-index": "error"
+		}
+	}
+});
+//#endregion
+export { plugin as default };

package/dist/rules/no-non-barrel-index.cjs

@@ -0,0 +1,24 @@
+//#region src/rules/no-non-barrel-index.ts
+const INDEX_BASENAME = /^index\.[cm]?[tj]s$/;
+const noNonBarrelIndex = {
+	meta: {
+		type: "problem",
+		schema: [],
+		messages: { barrel: "Only src/index.ts may be named index.* (the public convenience barrel); give any other module a descriptive filename." }
+	},
+	create(context) {
+		const filename = context.filename;
+		const slash = filename.lastIndexOf("/");
+		const basename = slash === -1 ? filename : filename.slice(slash + 1);
+		if (!INDEX_BASENAME.test(basename)) return {};
+		if (filename.endsWith("/src/index.ts")) return {};
+		return { Program(node) {
+			context.report({
+				node,
+				messageId: "barrel"
+			});
+		} };
+	}
+};
+//#endregion
+module.exports = noNonBarrelIndex;

package/dist/rules/no-non-barrel-index.d.cts

@@ -0,0 +1,4 @@
+import { Rule } from "eslint";
+//#region src/rules/no-non-barrel-index.d.ts
+declare const noNonBarrelIndex: Rule.RuleModule;
+export = noNonBarrelIndex;

package/dist/rules/no-non-barrel-index.d.ts

@@ -0,0 +1,5 @@
+import { Rule } from "eslint";
+//#region src/rules/no-non-barrel-index.d.ts
+declare const noNonBarrelIndex: Rule.RuleModule;
+//#endregion
+export { noNonBarrelIndex as default };

package/dist/rules/no-non-barrel-index.js

@@ -0,0 +1,24 @@
+//#region src/rules/no-non-barrel-index.ts
+const INDEX_BASENAME = /^index\.[cm]?[tj]s$/;
+const noNonBarrelIndex = {
+	meta: {
+		type: "problem",
+		schema: [],
+		messages: { barrel: "Only src/index.ts may be named index.* (the public convenience barrel); give any other module a descriptive filename." }
+	},
+	create(context) {
+		const filename = context.filename;
+		const slash = filename.lastIndexOf("/");
+		const basename = slash === -1 ? filename : filename.slice(slash + 1);
+		if (!INDEX_BASENAME.test(basename)) return {};
+		if (filename.endsWith("/src/index.ts")) return {};
+		return { Program(node) {
+			context.report({
+				node,
+				messageId: "barrel"
+			});
+		} };
+	}
+};
+//#endregion
+export { noNonBarrelIndex as default };

package/dist/rules/no-non-barrel-reexport.cjs

@@ -0,0 +1,88 @@
+//#region src/rules/no-non-barrel-reexport.ts
+function removeListMember(fixer, sourceCode, declaration, members, target) {
+	if (members.length === 1) return fixer.remove(declaration);
+	const targetIndex = members.indexOf(target);
+	const isLast = targetIndex === members.length - 1;
+	const neighbor = members[isLast ? targetIndex - 1 : targetIndex + 1];
+	if (neighbor === void 0) throw new Error("Unreachable: a list with more than one member always has a neighbor either side of any member within it.");
+	return isLast ? fixer.removeRange([sourceCode.getRange(neighbor)[1], sourceCode.getRange(target)[1]]) : fixer.removeRange([sourceCode.getRange(target)[0], sourceCode.getRange(neighbor)[0]]);
+}
+function importIsOnlyUsedByThisExport(sourceCode, trackedImport, usageIdentifier) {
+	const variable = sourceCode.getDeclaredVariables(trackedImport.declaration).find((candidate) => candidate.defs.some((def) => def.node === trackedImport.specifier));
+	if (variable === void 0) return false;
+	if (variable.references.length !== 1) return false;
+	const [onlyReference] = variable.references;
+	if (onlyReference === void 0) throw new Error("Unreachable: the length check above guarantees exactly one element.");
+	return onlyReference.identifier === usageIdentifier;
+}
+const noNonBarrelReexport = {
+	meta: {
+		type: "problem",
+		fixable: "code",
+		schema: [],
+		messages: {
+			splitStatementReexport: "'{{ name }}' is imported here and handed straight back out via a bare export -- the identical re-export 'export { {{ name }} } from ...' would be, just split across two statements. Re-exports belong only in src/index.ts (the public barrel).",
+			splitStatementDefaultReexport: "'{{ name }}' is imported here and handed straight back out via `export default` -- the identical re-export 'export { {{ name }} as default } from ...' would be, just split across two statements. Re-exports belong only in src/index.ts (the public barrel)."
+		}
+	},
+	create(context) {
+		const importsByName = /* @__PURE__ */ new Map();
+		const bareExportSpecifiers = [];
+		const defaultExportDeclarations = [];
+		return {
+			ImportDeclaration(node) {
+				for (const specifier of node.specifiers) importsByName.set(specifier.local.name, {
+					declaration: node,
+					specifier
+				});
+			},
+			ExportNamedDeclaration(node) {
+				if (node.source !== null && node.source !== void 0) return;
+				for (const specifier of node.specifiers) bareExportSpecifiers.push({
+					declaration: node,
+					specifier
+				});
+			},
+			ExportDefaultDeclaration(node) {
+				defaultExportDeclarations.push(node);
+			},
+			"Program:exit"() {
+				const { sourceCode } = context;
+				for (const { declaration, specifier } of bareExportSpecifiers) {
+					const name = specifier.local.type === "Identifier" ? specifier.local.name : void 0;
+					if (name === void 0) continue;
+					const trackedImport = importsByName.get(name);
+					if (trackedImport === void 0) continue;
+					context.report({
+						node: specifier,
+						messageId: "splitStatementReexport",
+						data: { name },
+						fix(fixer) {
+							const fixes = [removeListMember(fixer, sourceCode, declaration, declaration.specifiers, specifier)];
+							if (specifier.local.type === "Identifier" && importIsOnlyUsedByThisExport(sourceCode, trackedImport, specifier.local)) fixes.push(removeListMember(fixer, sourceCode, trackedImport.declaration, trackedImport.declaration.specifiers, trackedImport.specifier));
+							return fixes;
+						}
+					});
+				}
+				for (const declarationNode of defaultExportDeclarations) {
+					const name = declarationNode.declaration.type === "Identifier" ? declarationNode.declaration.name : void 0;
+					if (name === void 0) continue;
+					const trackedImport = importsByName.get(name);
+					if (trackedImport === void 0) continue;
+					context.report({
+						node: declarationNode,
+						messageId: "splitStatementDefaultReexport",
+						data: { name },
+						fix(fixer) {
+							const fixes = [fixer.remove(declarationNode)];
+							if (declarationNode.declaration.type === "Identifier" && importIsOnlyUsedByThisExport(sourceCode, trackedImport, declarationNode.declaration)) fixes.push(removeListMember(fixer, sourceCode, trackedImport.declaration, trackedImport.declaration.specifiers, trackedImport.specifier));
+							return fixes;
+						}
+					});
+				}
+			}
+		};
+	}
+};
+//#endregion
+module.exports = noNonBarrelReexport;

package/dist/rules/no-non-barrel-reexport.d.cts

@@ -0,0 +1,4 @@
+import { Rule } from "eslint";
+//#region src/rules/no-non-barrel-reexport.d.ts
+declare const noNonBarrelReexport: Rule.RuleModule;
+export = noNonBarrelReexport;

package/dist/rules/no-non-barrel-reexport.d.ts

@@ -0,0 +1,5 @@
+import { Rule } from "eslint";
+//#region src/rules/no-non-barrel-reexport.d.ts
+declare const noNonBarrelReexport: Rule.RuleModule;
+//#endregion
+export { noNonBarrelReexport as default };

package/dist/rules/no-non-barrel-reexport.js

@@ -0,0 +1,88 @@
+//#region src/rules/no-non-barrel-reexport.ts
+function removeListMember(fixer, sourceCode, declaration, members, target) {
+	if (members.length === 1) return fixer.remove(declaration);
+	const targetIndex = members.indexOf(target);
+	const isLast = targetIndex === members.length - 1;
+	const neighbor = members[isLast ? targetIndex - 1 : targetIndex + 1];
+	if (neighbor === void 0) throw new Error("Unreachable: a list with more than one member always has a neighbor either side of any member within it.");
+	return isLast ? fixer.removeRange([sourceCode.getRange(neighbor)[1], sourceCode.getRange(target)[1]]) : fixer.removeRange([sourceCode.getRange(target)[0], sourceCode.getRange(neighbor)[0]]);
+}
+function importIsOnlyUsedByThisExport(sourceCode, trackedImport, usageIdentifier) {
+	const variable = sourceCode.getDeclaredVariables(trackedImport.declaration).find((candidate) => candidate.defs.some((def) => def.node === trackedImport.specifier));
+	if (variable === void 0) return false;
+	if (variable.references.length !== 1) return false;
+	const [onlyReference] = variable.references;
+	if (onlyReference === void 0) throw new Error("Unreachable: the length check above guarantees exactly one element.");
+	return onlyReference.identifier === usageIdentifier;
+}
+const noNonBarrelReexport = {
+	meta: {
+		type: "problem",
+		fixable: "code",
+		schema: [],
+		messages: {
+			splitStatementReexport: "'{{ name }}' is imported here and handed straight back out via a bare export -- the identical re-export 'export { {{ name }} } from ...' would be, just split across two statements. Re-exports belong only in src/index.ts (the public barrel).",
+			splitStatementDefaultReexport: "'{{ name }}' is imported here and handed straight back out via `export default` -- the identical re-export 'export { {{ name }} as default } from ...' would be, just split across two statements. Re-exports belong only in src/index.ts (the public barrel)."
+		}
+	},
+	create(context) {
+		const importsByName = /* @__PURE__ */ new Map();
+		const bareExportSpecifiers = [];
+		const defaultExportDeclarations = [];
+		return {
+			ImportDeclaration(node) {
+				for (const specifier of node.specifiers) importsByName.set(specifier.local.name, {
+					declaration: node,
+					specifier
+				});
+			},
+			ExportNamedDeclaration(node) {
+				if (node.source !== null && node.source !== void 0) return;
+				for (const specifier of node.specifiers) bareExportSpecifiers.push({
+					declaration: node,
+					specifier
+				});
+			},
+			ExportDefaultDeclaration(node) {
+				defaultExportDeclarations.push(node);
+			},
+			"Program:exit"() {
+				const { sourceCode } = context;
+				for (const { declaration, specifier } of bareExportSpecifiers) {
+					const name = specifier.local.type === "Identifier" ? specifier.local.name : void 0;
+					if (name === void 0) continue;
+					const trackedImport = importsByName.get(name);
+					if (trackedImport === void 0) continue;
+					context.report({
+						node: specifier,
+						messageId: "splitStatementReexport",
+						data: { name },
+						fix(fixer) {
+							const fixes = [removeListMember(fixer, sourceCode, declaration, declaration.specifiers, specifier)];
+							if (specifier.local.type === "Identifier" && importIsOnlyUsedByThisExport(sourceCode, trackedImport, specifier.local)) fixes.push(removeListMember(fixer, sourceCode, trackedImport.declaration, trackedImport.declaration.specifiers, trackedImport.specifier));
+							return fixes;
+						}
+					});
+				}
+				for (const declarationNode of defaultExportDeclarations) {
+					const name = declarationNode.declaration.type === "Identifier" ? declarationNode.declaration.name : void 0;
+					if (name === void 0) continue;
+					const trackedImport = importsByName.get(name);
+					if (trackedImport === void 0) continue;
+					context.report({
+						node: declarationNode,
+						messageId: "splitStatementDefaultReexport",
+						data: { name },
+						fix(fixer) {
+							const fixes = [fixer.remove(declarationNode)];
+							if (declarationNode.declaration.type === "Identifier" && importIsOnlyUsedByThisExport(sourceCode, trackedImport, declarationNode.declaration)) fixes.push(removeListMember(fixer, sourceCode, trackedImport.declaration, trackedImport.declaration.specifiers, trackedImport.specifier));
+							return fixes;
+						}
+					});
+				}
+			}
+		};
+	}
+};
+//#endregion
+export { noNonBarrelReexport as default };

package/dist/rules/no-pointless-reassignment.cjs

@@ -0,0 +1,57 @@
+//#region src/rules/no-pointless-reassignment.ts
+function isIdentifierReference(reference) {
+	return reference.identifier.type === "Identifier";
+}
+const noPointlessReassignment = {
+	meta: {
+		type: "problem",
+		fixable: "code",
+		schema: [],
+		messages: { pointlessReassignment: "Pointless reassignment: '{{ name }}' is just an alias for '{{ value }}'. Use the original directly." }
+	},
+	create(context) {
+		return { VariableDeclarator(node) {
+			if (node.id.type !== "Identifier" || node.init?.type !== "Identifier" || node.id.name.startsWith("_")) return;
+			if (node.parent.type !== "VariableDeclaration" || node.parent.kind !== "const") return;
+			const scope = context.sourceCode.getScope(node);
+			const sourceVariable = scope.references.find((reference) => reference.identifier === node.init)?.resolved;
+			if (!sourceVariable || sourceVariable.references.some((reference) => reference.isWrite() && !reference.init)) return;
+			const aliasName = node.id.name;
+			const originalName = node.init.name;
+			context.report({
+				node,
+				messageId: "pointlessReassignment",
+				data: {
+					name: aliasName,
+					value: originalName
+				},
+				fix(fixer) {
+					const variable = scope.set.get(aliasName);
+					if (!variable) return null;
+					if (variable.references.filter((reference) => reference.isWrite() && reference.identifier !== node.id).length > 0) return null;
+					const readRefs = variable.references.filter((reference) => reference.isRead() && isIdentifierReference(reference));
+					if (readRefs.some((reference) => {
+						const afterToken = context.sourceCode.getTokenAfter(reference.identifier);
+						if (afterToken?.value === ":") return false;
+						if (afterToken?.value !== "}" && afterToken?.value !== ",") return false;
+						let token = context.sourceCode.getTokenBefore(reference.identifier);
+						while (token) {
+							if (token.value === "{") return true;
+							if (token.value === "[" || token.value === "(") return false;
+							if (token.value === ":") return false;
+							token = context.sourceCode.getTokenBefore(token);
+						}
+						return false;
+					})) return null;
+					const fixes = readRefs.map((reference) => fixer.replaceText(reference.identifier, originalName));
+					const declaration = node.parent;
+					if (declaration.type !== "VariableDeclaration" || declaration.declarations.length !== 1) return null;
+					fixes.push(fixer.remove(declaration));
+					return fixes;
+				}
+			});
+		} };
+	}
+};
+//#endregion
+module.exports = noPointlessReassignment;

package/dist/rules/no-pointless-reassignment.d.cts

@@ -0,0 +1,4 @@
+import { Rule } from "eslint";
+//#region src/rules/no-pointless-reassignment.d.ts
+declare const noPointlessReassignment: Rule.RuleModule;
+export = noPointlessReassignment;

package/dist/rules/no-pointless-reassignment.d.ts

@@ -0,0 +1,5 @@
+import { Rule } from "eslint";
+//#region src/rules/no-pointless-reassignment.d.ts
+declare const noPointlessReassignment: Rule.RuleModule;
+//#endregion
+export { noPointlessReassignment as default };

package/dist/rules/no-pointless-reassignment.js

@@ -0,0 +1,57 @@
+//#region src/rules/no-pointless-reassignment.ts
+function isIdentifierReference(reference) {
+	return reference.identifier.type === "Identifier";
+}
+const noPointlessReassignment = {
+	meta: {
+		type: "problem",
+		fixable: "code",
+		schema: [],
+		messages: { pointlessReassignment: "Pointless reassignment: '{{ name }}' is just an alias for '{{ value }}'. Use the original directly." }
+	},
+	create(context) {
+		return { VariableDeclarator(node) {
+			if (node.id.type !== "Identifier" || node.init?.type !== "Identifier" || node.id.name.startsWith("_")) return;
+			if (node.parent.type !== "VariableDeclaration" || node.parent.kind !== "const") return;
+			const scope = context.sourceCode.getScope(node);
+			const sourceVariable = scope.references.find((reference) => reference.identifier === node.init)?.resolved;
+			if (!sourceVariable || sourceVariable.references.some((reference) => reference.isWrite() && !reference.init)) return;
+			const aliasName = node.id.name;
+			const originalName = node.init.name;
+			context.report({
+				node,
+				messageId: "pointlessReassignment",
+				data: {
+					name: aliasName,
+					value: originalName
+				},
+				fix(fixer) {
+					const variable = scope.set.get(aliasName);
+					if (!variable) return null;
+					if (variable.references.filter((reference) => reference.isWrite() && reference.identifier !== node.id).length > 0) return null;
+					const readRefs = variable.references.filter((reference) => reference.isRead() && isIdentifierReference(reference));
+					if (readRefs.some((reference) => {
+						const afterToken = context.sourceCode.getTokenAfter(reference.identifier);
+						if (afterToken?.value === ":") return false;
+						if (afterToken?.value !== "}" && afterToken?.value !== ",") return false;
+						let token = context.sourceCode.getTokenBefore(reference.identifier);
+						while (token) {
+							if (token.value === "{") return true;
+							if (token.value === "[" || token.value === "(") return false;
+							if (token.value === ":") return false;
+							token = context.sourceCode.getTokenBefore(token);
+						}
+						return false;
+					})) return null;
+					const fixes = readRefs.map((reference) => fixer.replaceText(reference.identifier, originalName));
+					const declaration = node.parent;
+					if (declaration.type !== "VariableDeclaration" || declaration.declarations.length !== 1) return null;
+					fixes.push(fixer.remove(declaration));
+					return fixes;
+				}
+			});
+		} };
+	}
+};
+//#endregion
+export { noPointlessReassignment as default };

package/dist/rules/no-side-effects-in-index.cjs

@@ -0,0 +1,23 @@
+//#region src/rules/no-side-effects-in-index.ts
+function isPureReexport(statement) {
+	if (statement.type === "ExportAllDeclaration") return true;
+	return statement.type === "ExportNamedDeclaration" && statement.source !== null && statement.source !== void 0;
+}
+const noSideEffectsInIndex = {
+	meta: {
+		type: "problem",
+		schema: [],
+		messages: { notAPureReexport: "The public barrel (src/index.ts) 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 }}." }
+	},
+	create(context) {
+		return { Program(node) {
+			for (const statement of node.body) if (!isPureReexport(statement)) context.report({
+				node: statement,
+				messageId: "notAPureReexport",
+				data: { description: statement.type }
+			});
+		} };
+	}
+};
+//#endregion
+module.exports = noSideEffectsInIndex;

package/dist/rules/no-side-effects-in-index.d.cts

@@ -0,0 +1,4 @@
+import { Rule } from "eslint";
+//#region src/rules/no-side-effects-in-index.d.ts
+declare const noSideEffectsInIndex: Rule.RuleModule;
+export = noSideEffectsInIndex;

package/dist/rules/no-side-effects-in-index.d.ts

@@ -0,0 +1,5 @@
+import { Rule } from "eslint";
+//#region src/rules/no-side-effects-in-index.d.ts
+declare const noSideEffectsInIndex: Rule.RuleModule;
+//#endregion
+export { noSideEffectsInIndex as default };

package/dist/rules/no-side-effects-in-index.js

@@ -0,0 +1,23 @@
+//#region src/rules/no-side-effects-in-index.ts
+function isPureReexport(statement) {
+	if (statement.type === "ExportAllDeclaration") return true;
+	return statement.type === "ExportNamedDeclaration" && statement.source !== null && statement.source !== void 0;
+}
+const noSideEffectsInIndex = {
+	meta: {
+		type: "problem",
+		schema: [],
+		messages: { notAPureReexport: "The public barrel (src/index.ts) 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 }}." }
+	},
+	create(context) {
+		return { Program(node) {
+			for (const statement of node.body) if (!isPureReexport(statement)) context.report({
+				node: statement,
+				messageId: "notAPureReexport",
+				data: { description: statement.type }
+			});
+		} };
+	}
+};
+//#endregion
+export { noSideEffectsInIndex as default };

package/package.json

@@ -1,5 +1,80 @@
 {
   "name": "@exadev/eslint-config",
-  "version": "0.0.0",
-  "private": false
+  "version": "1.0.0",
+  "description": "Shared custom ESLint rules for ExaDev projects, starting with the documents.js family",
+  "type": "module",
+  "sideEffects": false,
+  "license": "MIT",
+  "packageManager": "pnpm@11.6.0",
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": {
+        "import": "./dist/index.d.ts",
+        "require": "./dist/index.d.cts"
+      },
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./*": {
+      "types": {
+        "import": "./dist/*.d.ts",
+        "require": "./dist/*.d.cts"
+      },
+      "import": "./dist/*.js",
+      "require": "./dist/*.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "eslint",
+    "eslintplugin",
+    "eslint-plugin"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ExaDev/eslint-config.git"
+  },
+  "peerDependencies": {
+    "eslint": ">=10.0.0"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18.5",
+    "@commitlint/cli": "^21.2.1",
+    "@commitlint/config-conventional": "^21.2.0",
+    "@eslint/js": "^10.0.1",
+    "@semantic-release/changelog": "^7.0.0",
+    "@semantic-release/git": "^11.0.1",
+    "@types/node": "^24.9.2",
+    "eslint": "^10.8.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^17.2.0",
+    "publint": "^0.3.21",
+    "semantic-release": "^25.0.8",
+    "tsdown": "^0.22.13",
+    "turbo": "^2.10.8",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.65.0"
+  },
+  "scripts": {
+    "build": "turbo run _build",
+    "_build": "tsdown",
+    "lint": "turbo run _lint",
+    "_lint": "eslint . --fix --cache --max-warnings 0",
+    "typecheck": "turbo run _typecheck",
+    "_typecheck": "tsc -p tsconfig.json",
+    "prepublishOnly": "pnpm run lint && pnpm run typecheck && tsdown && publint && attw --pack",
+    "prepare": "husky",
+    "release": "semantic-release"
+  }
 }