eslint-plugin-import-structure 0.0.0-stage → 0.10.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Cunarist
+
+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

@@ -1,3 +1,90 @@
-# Temporary Holding Version
+# eslint-plugin-import-structure
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Import-structure rules for both [ESLint](https://eslint.org) and [Oxlint](https://oxc.rs/docs/guide/usage/linter): a module graph that stays layered and free of cycles.\
+Install with `npm install --save-dev eslint-plugin-import-structure`. Requires Node.js 22.18+.
+
+```ts
+// Oxlint, through Vite+: vite.config.ts
+import plugin from "eslint-plugin-import-structure";
+import { defineConfig } from "vite-plus";
+const rules = { ...plugin.configs.modules.rules };
+export default defineConfig({
+  lint: { jsPlugins: ["eslint-plugin-import-structure"], rules },
+});
+```
+
+```ts
+// ESLint 9: eslint.config.ts (loading a .ts config needs jiti)
+import plugin from "eslint-plugin-import-structure";
+import { parser } from "typescript-eslint";
+const ts = { files: ["**/*.ts"], languageOptions: { parser } };
+export default [ts, plugin.configs.modules];
+```
+
+## Configs and rules
+
+- `modules`: areas reached only through their `package.json` `imports` aliases, layered by their order.
+- `all`: every rule, including ones added later. Rules take no options.
+
+The order of the `#` aliases in `package.json` is the layer order, top first; an area may only import aliases declared below its own.
+
+### Modules
+
+An alias owns its target, and code outside the owned area reaches it only through the alias.
+The rule never depends on folder or file names; an alias may point anywhere.
+
+- An alias to a folder's `index.ts` owns that folder and everything below it. An alias to any other file owns only that file.
+- No file may be owned by 2 aliases: no alias inside another alias's area, and no 2 aliases with the same target.
+  `enforce-layer-order` reports an overlap once at the top of every file 2 aliases claim, since lint cannot report on `package.json`.
+- Outside an area, any other route to an owned file is a bypass: a deeper alias specifier such as `#a/one.ts` (`no-barrel-bypass`), or a relative path (`no-relative-bypass`, and `prefer-alias-import`, which rewrites a path to the alias's exact target).
+- Inside an area, relative imports of siblings and subfolders are free.
+- `../` is banned in every file, owned or not (`no-parent-import`). Anything above a file needs an alias.
+- Files no alias owns need no `index.ts` and no alias, and import `./` siblings and subfolders freely.
+- Don't declare `/*` subpath patterns: any use of one that reaches an owned area is a bypass (`no-barrel-bypass`). Entry points are named `index.ts` only (`enforce-mod-file`).
+
+```jsonc
+"imports": {
+  "#a": "./a/index.ts", // owns a/ and everything below it
+  "#f": "./b/f.ts", // owns only b/f.ts; b/g.ts stays unowned
+}
+```
+
+```ts
+// in main.ts, which no alias owns
+import { a } from "#a"; // ✅
+import { one } from "#a/one.ts"; // ❌ deeper alias specifier
+import { two } from "./a/two.ts"; // ❌ relative path into #a
+import { f } from "./b/f.ts"; // ❌ relative path to a file alias; use "#f"
+import { g } from "./b/g.ts"; // ✅ unowned
+// in a/one.ts, owned by #a
+import { two } from "./two.ts"; // ✅ sibling
+import { deep } from "./sub/deep.ts"; // ✅ subfolder of the same area
+import { x } from "../x.ts"; // ❌ no ../ anywhere
+```
+
+The other rules (import order, duplicate sources, wildcards, absolute paths, self-imports) are not about aliases and apply to every file.
+
+<!-- prettier-ignore-start -->
+<!-- begin auto-generated rules list -->
+
+💼 [Configurations](https://github.com/cunarist/eslint-plugin-import-structure#configs-and-rules) enabled in.\
+🧭 Set in the `modules` [configuration](https://github.com/cunarist/eslint-plugin-import-structure#configs-and-rules).
+
+| Name                                                                   | Description                                                                  | 💼 |
+| :--------------------------------------------------------------------- | :--------------------------------------------------------------------------- | :- |
+| [enforce-import-order](docs/rules/enforce-import-order.md)             | Enforce grouped and sorted import declarations and import members            | 🧭 |
+| [enforce-layer-order](docs/rules/enforce-layer-order.md)               | Enforce the order of `package.json` `imports` as the layer order             | 🧭 |
+| [enforce-mod-file](docs/rules/enforce-mod-file.md)                     | Enforce `index.ts` as the name of module entry points                        | 🧭 |
+| [no-absolute-import](docs/rules/no-absolute-import.md)                 | Disallow absolute paths and `file:` URLs as module specifiers                | 🧭 |
+| [no-barrel-bypass](docs/rules/no-barrel-bypass.md)                     | Disallow `#` specifiers deeper than an alias                                 | 🧭 |
+| [no-duplicate-import-source](docs/rules/no-duplicate-import-source.md) | Disallow separate import declarations from the same source                   | 🧭 |
+| [no-parent-import](docs/rules/no-parent-import.md)                     | Disallow parent-relative module specifiers                                   | 🧭 |
+| [no-relative-bypass](docs/rules/no-relative-bypass.md)                 | Disallow relative specifiers that reach into an alias's area from outside it | 🧭 |
+| [no-self-import](docs/rules/no-self-import.md)                         | Disallow a module from importing itself                                      | 🧭 |
+| [no-wildcard-import](docs/rules/no-wildcard-import.md)                 | Disallow namespace imports                                                   | 🧭 |
+| [prefer-alias-import](docs/rules/prefer-alias-import.md)               | Require the `#` alias for a module that `package.json` declares              | 🧭 |
+
+<!-- end auto-generated rules list -->
+<!-- prettier-ignore-end -->
+
+License: MIT.

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+import { ConfigObject, Plugin } from "@eslint/core";
+//#region src/plugin/index.d.ts
+/** The flat configs at `plugin.configs`: `modules` and `all`. */
+interface ModulesConfigs {
+  modules: ConfigObject;
+  all: ConfigObject;
+}
+/** The plugin, with its configs known by name. */
+interface ModulesPlugin {
+  meta?: Plugin["meta"];
+  rules?: Plugin["rules"];
+  configs: ModulesConfigs;
+}
+/**
+ * The plugin, for ESLint `plugins` or Oxlint `jsPlugins`, and the package's
+ * only export. Configs: `modules` holds the ported rules, and
+ * `all` turns on every rule, so a new rule joins it by itself.
+ */
+declare const plugin: ModulesPlugin;
+//#endregion
+export { plugin as default };

package/dist/index.js

@@ -0,0 +1,1167 @@
+import { readFileSync, statSync } from "node:fs";
+//#region src/helpers/docs.ts
+/** Where a rule's `.md` lives, so `meta.docs.url` links to the source of truth. */
+const DOCS_BASE = "https://github.com/cunarist/eslint-plugin-import-structure/blob/main/docs/rules";
+/** The documentation URL of a rule, e.g. `no-self-import`. */
+function docsUrl(rule) {
+	return `${DOCS_BASE}/${rule}.md`;
+}
+//#endregion
+//#region src/helpers/import-order.ts
+/** The three import groups, in the order they must appear. */
+const IMPORT_GROUPS = [
+	"package",
+	"`#` alias",
+	"relative"
+];
+/**
+* Classifies a specifier into its `IMPORT_GROUPS` index. Anything that is
+* neither a `#` alias nor a path is a package, which covers bare names,
+* `node:` builtins, and URLs alike.
+*/
+function importGroup(specifier) {
+	if (specifier.startsWith("#")) return 1;
+	if (specifier.startsWith(".") || specifier.startsWith("/")) return 2;
+	return 0;
+}
+/** The name of a group, for a message. */
+function groupName(group) {
+	return IMPORT_GROUPS[group] ?? "";
+}
+/**
+* Orders specifiers by code point rather than locale, so the result does not
+* depend on collation rules that quietly ignore punctuation.
+*/
+function compareSpecifiers(a, b) {
+	if (a < b) return -1;
+	return a > b ? 1 : 0;
+}
+/**
+* Whether an import only runs a module for its side effects, as in
+* `import "./polyfill.ts";`. Such imports can depend on running before or
+* after their neighbours, so the fix never moves them.
+*/
+function isSideEffect(node) {
+	return node.specifiers.length === 0;
+}
+/** Sorts imports by group, then by specifier. */
+function compareEntries(a, b) {
+	return a.group - b.group || compareSpecifiers(a.specifier, b.specifier);
+}
+/**
+* The imports in their fixed order: side-effect imports keep their places,
+* and the imports in each run between them are sorted within that run, so no
+* import crosses a side-effect import.
+*/
+function fixedOrder(entries) {
+	const ordered = [];
+	let run = [];
+	for (const entry of entries) if (isSideEffect(entry.node)) {
+		ordered.push(...run.toSorted(compareEntries), entry);
+		run = [];
+	} else run.push(entry);
+	ordered.push(...run.toSorted(compareEntries));
+	return ordered;
+}
+/**
+* Whether imports are in group order and sorted within each group, which is
+* what the rewrite needs to clear every order problem.
+*/
+function isSorted(entries) {
+	return entries.every((entry, index) => {
+		const previous = entries[index - 1];
+		return previous === void 0 || compareEntries(previous, entry) <= 0;
+	});
+}
+/** What is wrong between two neighbouring imports, or `null` if nothing. */
+function orderProblem(previous, current, blankLine) {
+	const names = /* @__PURE__ */ new Map([["group", groupName(current.group)], ["previous", groupName(previous.group)]]);
+	if (current.group < previous.group) return {
+		messageId: "groupOrder",
+		data: names
+	};
+	if (current.group > previous.group && !blankLine) return {
+		messageId: "missingBlankLine",
+		data: names
+	};
+	if (current.group === previous.group && blankLine) return {
+		messageId: "extraBlankLine",
+		data: names
+	};
+	if (current.group === previous.group && compareSpecifiers(current.specifier, previous.specifier) < 0) return {
+		messageId: "sourceOrder",
+		data: /* @__PURE__ */ new Map([["specifier", current.specifier], ["previous", previous.specifier]])
+	};
+	return null;
+}
+//#endregion
+//#region src/helpers/paths.ts
+/**
+* Path helpers that work on forward-slash paths, whatever the platform, so
+* `C:\dir\a.ts`, `/dir/a.ts`, and `file:///dir/a.ts` compare alike.
+*/
+/** A Windows drive path after a leading slash, as in `/C:/dir`. */
+const SLASHED_DRIVE_PATTERN$1 = /^\/[a-zA-Z]:/u;
+/** Every backslash, which Windows uses as a separator. */
+const BACKSLASH_PATTERN = /\\/gu;
+/**
+* Normalizes a path by removing the `file://` prefix and converting
+* backslashes to forward slashes on Windows.
+*/
+function normalizePath(path) {
+	if (path === "") return path;
+	let normalized = path;
+	if (normalized.startsWith("file://")) {
+		normalized = decodeURIComponent(normalized.slice(7));
+		if (SLASHED_DRIVE_PATTERN$1.test(normalized)) normalized = normalized.slice(1);
+	}
+	return normalized.replace(BACKSLASH_PATTERN, "/");
+}
+/** The parent directory of a path, without a trailing slash. */
+function parentDir(path) {
+	const normalized = normalizePath(path);
+	const index = normalized.lastIndexOf("/");
+	return index <= 0 ? normalized : normalized.slice(0, index);
+}
+/** The last segment of a path. */
+function baseName(path) {
+	const normalized = normalizePath(path);
+	return normalized.slice(normalized.lastIndexOf("/") + 1);
+}
+/**
+* The last segment without its extension, so `index.ts`, `index.tsx` and
+* `index.js` all yield `index`. A leading dot is kept, so `.gitignore` is its
+* own stem rather than an empty string.
+*/
+function stemName(path) {
+	const base = baseName(path);
+	const dot = base.lastIndexOf(".");
+	return dot <= 0 ? base : base.slice(0, dot);
+}
+/**
+* Resolves a relative path such as `../utils/index.ts` against a directory,
+* returning a normalized absolute path.
+*/
+function resolveFrom(baseDir, relative) {
+	const segments = normalizePath(baseDir).split("/");
+	for (const segment of normalizePath(relative).split("/")) {
+		if (segment === "" || segment === ".") continue;
+		if (segment === "..") {
+			if (segments.length > 1) segments.pop();
+			continue;
+		}
+		segments.push(segment);
+	}
+	return segments.join("/");
+}
+/**
+* Whether a path lies inside a directory. Segment aware, so `/src/utils` does
+* not contain `/src/utils-extra/index.ts`.
+*/
+function isInsideDir(path, dir) {
+	return path.startsWith(dir.endsWith("/") ? dir : `${dir}/`);
+}
+//#endregion
+//#region src/helpers/imports.ts
+/**
+* Reads the `#` entries of the nearest `package.json` `imports` field, the
+* Node.js subpath imports that name a project's modules and, by their order,
+* its layers.
+*/
+/**
+* File name stems that mark a directory's public entry point. Compared
+* without the extension so `.ts`, `.tsx`, `.js` and friends all count. Only
+* `index` qualifies; a `mod` file is a plain module.
+*/
+const BARREL_STEMS = ["index"];
+/** Entry-point stems the `enforce-mod-file` rule rejects. */
+const REJECTED_STEMS = ["mod"];
+/** The config file searched for in every directory up from a file. */
+const CONFIG_NAME = "package.json";
+/** A query or fragment suffix, which never names part of a path. */
+const QUERY_PATTERN = /[?#].*$/u;
+/** A path written with a Windows drive after a leading slash, as in `/C:/dir`. */
+const SLASHED_DRIVE_PATTERN = /^\/[a-zA-Z]:/u;
+/**
+* Parsed configs keyed by file path. An entry is reused only while the file's
+* modification time is unchanged, so an editor session sees edits.
+*/
+const configCache = /* @__PURE__ */ new Map();
+/** The modification time of a file, or `null` when it does not exist. */
+function modifiedAt(path) {
+	try {
+		const stats = statSync(path, { throwIfNoEntry: false });
+		return stats?.isFile() === true ? stats.mtimeMs : null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Walks up from a file to the nearest `package.json` and reads its
+* `#`-prefixed imports. Like Node.js, the search stops at that file even when
+* it declares no `#` entries, so a nested package never borrows the imports
+* of an enclosing one. Returns `null` when no `package.json` exists up the
+* tree, or when the nearest one cannot be read or declares no local `#` entry.
+*/
+function findImportsConfig(fromFile) {
+	let dir = parentDir(normalizePath(fromFile));
+	for (;;) {
+		const configPath = `${dir}/${CONFIG_NAME}`;
+		const mtimeMs = modifiedAt(configPath);
+		if (mtimeMs !== null) return cachedConfig(configPath, dir, mtimeMs);
+		const parent = parentDir(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+}
+/** One config file, read through the cache. */
+function cachedConfig(configPath, configDir, mtimeMs) {
+	const cached = configCache.get(configPath);
+	if (cached?.mtimeMs === mtimeMs) return cached.config;
+	const config = readConfig(configPath, configDir);
+	configCache.set(configPath, {
+		mtimeMs,
+		config
+	});
+	return config;
+}
+/** The `imports` object of a parsed `package.json`, or `null` if it has none. */
+function importsField(parsed) {
+	if (typeof parsed !== "object" || parsed === null) return null;
+	const imports = Reflect.get(parsed, "imports");
+	return typeof imports === "object" && imports !== null ? imports : null;
+}
+/**
+* Parses one config file and returns its `imports` object. `null` when the
+* file is unreadable, is not JSON, or has no `imports` object.
+*/
+function readImportsField(configPath) {
+	let parsed = null;
+	try {
+		parsed = JSON.parse(readFileSync(configPath, "utf8"));
+	} catch {
+		return null;
+	}
+	return importsField(parsed);
+}
+/**
+* Whether an `imports` entry is a `#` alias with a relative string target.
+* Only those point at local files. A "#" alias for a package, or a condition
+* object, is legitimate but irrelevant here.
+*/
+function isLocalEntry(specifier, value) {
+	return specifier.startsWith("#") && typeof value === "string" && (value.startsWith("./") || value.startsWith("../"));
+}
+/** A subpath pattern entry, split around the `*` at index `star`. */
+function patternEntry(specifier, star, target) {
+	return {
+		specifier,
+		prefix: specifier.slice(0, star),
+		suffix: specifier.slice(star + 1),
+		target
+	};
+}
+/** An exact entry, resolved from the config directory, declared at `index`. */
+function moduleEntry(configDir, specifier, value, index) {
+	const target = resolveFrom(configDir, value);
+	const isBarrel = BARREL_STEMS.includes(stemName(target));
+	return {
+		specifier,
+		target,
+		dir: isBarrel ? parentDir(target) : target,
+		isBarrel,
+		index
+	};
+}
+/**
+* Reads and parses one config file. Returns `null` when the file
+* is unreadable, is not JSON, or has no local `#` entries.
+*/
+function readConfig(configPath, configDir) {
+	const imports = readImportsField(configPath);
+	if (imports === null) return null;
+	const entries = [];
+	const byTarget = /* @__PURE__ */ new Map();
+	const bySpecifier = /* @__PURE__ */ new Map();
+	const patterns = [];
+	for (const [specifier, value] of Object.entries(imports)) {
+		if (!isLocalEntry(specifier, value)) continue;
+		const star = specifier.indexOf("*");
+		if (star !== -1) {
+			patterns.push(patternEntry(specifier, star, value));
+			continue;
+		}
+		const entry = moduleEntry(configDir, specifier, value, entries.length);
+		entries.push(entry);
+		bySpecifier.set(specifier, entry);
+		if (!byTarget.has(entry.target)) byTarget.set(entry.target, entry);
+	}
+	if (entries.length === 0 && patterns.length === 0) return null;
+	patterns.sort((a, b) => b.prefix.length - a.prefix.length);
+	return {
+		configDir,
+		entries,
+		byTarget,
+		bySpecifier,
+		patterns
+	};
+}
+//#endregion
+//#region src/helpers/modules.ts
+/**
+* Looks up the areas the `#` aliases of a `package.json` `imports` config
+* own: which alias owns a file, which one a specifier names, and whether an
+* import touches an owned area at all.
+*
+* An alias owns its target. An alias to a folder's `index.ts` owns that
+* folder and everything below it; an alias to any other file owns only that
+* file. Nothing here depends on folder or file names.
+*/
+/**
+* Whether a normalized path lies in the area an alias owns. A folder alias's
+* area includes the folder path itself, so a directory specifier such as
+* `./utils` cannot reach the area by path.
+*/
+function ownsPath(entry, path) {
+	return entry.target === path || entry.isBarrel && (path === entry.dir || isInsideDir(path, entry.dir));
+}
+/**
+* Every alias whose area holds a file, in declaration order. More than one
+* means two aliases overlap, which `enforce-layer-order` reports.
+*/
+function claimingEntries(config, filePath) {
+	const path = normalizePath(filePath);
+	return config.entries.filter((entry) => ownsPath(entry, path));
+}
+/**
+* Whether `entry` is among the aliases that claim a file. A file two aliases
+* overlap on counts as inside both areas, so the overlap is reported once by
+* `enforce-layer-order` rather than again as a bypass.
+*/
+function isClaimedBy(config, filePath, entry) {
+	return claimingEntries(config, filePath).some((claimant) => claimant.index === entry.index);
+}
+/**
+* Finds the alias that owns a file, which is the one with the most specific
+* area containing it. Returns `null` for a file no alias owns.
+*/
+function findOwningEntry(config, filePath) {
+	let best = null;
+	for (const entry of claimingEntries(config, filePath)) if (best === null || entry.dir.length > best.dir.length) best = entry;
+	return best;
+}
+/**
+* The exact alias a deeper `#` specifier reaches past, such as `#utils` for
+* `#utils/internal.ts`, whether or not a subpath pattern makes it resolve.
+* The longest alias wins. Returns `null` when no alias is a prefix.
+*/
+function deeperAliasOwner(config, specifier) {
+	let best = null;
+	for (const entry of config.entries) if (specifier.startsWith(`${entry.specifier}/`) && (best === null || entry.specifier.length > best.specifier.length)) best = entry;
+	return best;
+}
+/**
+* Finds the subpath pattern a deep `#` specifier reaches through, such as
+* `#utils/*` for `#utils/internal.ts`. Returns `null` when none match.
+*/
+function findPatternEntry(config, specifier) {
+	for (const pattern of config.patterns) if (specifier.length >= pattern.prefix.length + pattern.suffix.length && specifier.startsWith(pattern.prefix) && specifier.endsWith(pattern.suffix)) return pattern;
+	return null;
+}
+/**
+* Resolves the module a `#` specifier belongs to, whether it is an exact
+* entry such as `#utils` or a deep one such as `#utils/internal.ts`.
+*/
+function targetModule(config, specifier) {
+	const exact = config.bySpecifier.get(specifier);
+	if (exact !== void 0) return exact;
+	return deeperAliasOwner(config, specifier);
+}
+/**
+* Resolves a local module specifier far enough to tell which file it names.
+* Package specifiers have no local target, so they give `null`.
+*/
+function resolveLocalSpecifier(filename, specifier) {
+	const path = specifier.replace(QUERY_PATTERN, "");
+	if (specifier.startsWith(".")) return resolveFrom(parentDir(normalizePath(filename)), path);
+	if (specifier.startsWith("file:")) return normalizePath(path);
+	if (specifier.startsWith("/")) {
+		const absolute = normalizePath(path);
+		return SLASHED_DRIVE_PATTERN.test(absolute) ? absolute.slice(1) : absolute;
+	}
+	if (!specifier.startsWith("#")) return null;
+	const config = findImportsConfig(filename);
+	if (config === null) return null;
+	const exact = config.bySpecifier.get(specifier);
+	if (exact !== void 0) return exact.target;
+	const pattern = findPatternEntry(config, specifier);
+	if (pattern === null) return null;
+	const matched = specifier.slice(pattern.prefix.length, specifier.length - pattern.suffix.length).replace(QUERY_PATTERN, "");
+	return resolveFrom(config.configDir, pattern.target.replaceAll("*", matched));
+}
+/**
+* The module a specifier points at, whether it was written as a `#` alias or
+* as a path. Resolving both means the layer rules cannot be sidestepped by
+* spelling the same target a different way. Returns `null` for specifiers
+* that leave the project, such as package names.
+*/
+function resolveTarget(config, filename, specifier) {
+	if (specifier.startsWith("#")) return targetModule(config, specifier);
+	if (!specifier.startsWith(".")) return null;
+	const resolved = resolveFrom(parentDir(normalizePath(filename)), specifier);
+	return config.byTarget.get(resolved) ?? null;
+}
+/** Whether a path lies in the area some alias owns. */
+function isModulePath(config, path) {
+	const normalized = normalizePath(path);
+	return config.entries.some((entry) => ownsPath(entry, normalized));
+}
+/**
+* Whether an import touches an owned area: the importing file or the file it
+* names lies in one. Imports between files no alias owns, such as
+* `vite.config.ts` reaching `./scripts/build.ts`, give `false`, and so does
+* everything in a project whose `package.json` declares no `#` alias.
+*/
+function isInModuleScope(filename, specifier) {
+	const config = findImportsConfig(filename);
+	if (config === null) return false;
+	if (isModulePath(config, filename)) return true;
+	const target = resolveLocalSpecifier(filename, specifier);
+	return target !== null && isModulePath(config, target);
+}
+//#endregion
+//#region src/helpers/specifiers.ts
+/**
+* Builds a visitor that runs `check` for every module specifier in a file,
+* so each rule only describes what to do with one specifier.
+*/
+function visitSpecifiers(check) {
+	function handle(node) {
+		const source = node.source;
+		if (source === null) return;
+		if (source.type === "TemplateLiteral") {
+			const [quasi] = source.quasis;
+			if (source.expressions.length === 0 && source.quasis.length === 1 && quasi !== void 0) check(source, quasi.value.raw);
+			return;
+		}
+		if (source.type === "Literal" && typeof source.value === "string") check(source, source.value);
+	}
+	return {
+		ImportDeclaration: handle,
+		ExportNamedDeclaration: handle,
+		ExportAllDeclaration: handle,
+		ImportExpression: handle,
+		TSImportType(node) {
+			check(node.source, node.source.value);
+		}
+	};
+}
+/**
+* Rewrites a specifier while keeping the original quote character. A template
+* literal has no quote of its own, and rewriting it as a plain string is the
+* point, so it falls through to double quotes.
+*/
+function quoteLike(original, specifier) {
+	const quote = original.type === "Literal" && original.raw.startsWith("'") ? "'" : "\"";
+	return quote + specifier + quote;
+}
+//#endregion
+//#region src/rules/enforce-import-order.ts
+/** Every line break, for counting the lines between two imports. */
+const NEWLINE_PATTERN = /\n/gu;
+/**
+* Orders imported names case insensitively, unlike `compareSpecifiers`.
+* Specifiers are lowercase paths where only punctuation is ambiguous, but a
+* member list mixes `PascalCase` types, `camelCase` functions and
+* `SCREAMING_CASE` constants. Sorting those by code point would clump them by
+* case, which hides the alphabetical order a reader is scanning for.
+*/
+function compareMembers(a, b) {
+	const lowered = compareSpecifiers(a.toLowerCase(), b.toLowerCase());
+	return lowered === 0 ? compareSpecifiers(a, b) : lowered;
+}
+/**
+* The names inside the braces of an import, in source order. Default and
+* namespace bindings sit outside the braces and are left alone.
+*/
+function namedSpecifiers(node) {
+	return node.specifiers.filter((specifier) => specifier.type === "ImportSpecifier");
+}
+/** The name a member is sorted by, which is the one written first. */
+function memberName(specifier) {
+	const imported = specifier.imported;
+	return imported.type === "Identifier" ? imported.name : specifier.local.name;
+}
+/** Whether a comment lies inside a range of the source. */
+function hasCommentWithin(source, start, end) {
+	return source.getAllComments().some((comment) => comment.range[0] >= start && comment.range[1] <= end);
+}
+/**
+* Rewrites the braces of one import in sorted order, preserving whether the
+* list was written on one line or spread across several. `null` when a
+* comment anywhere in the import could end up beside a different member, or
+* when a multiline list does not start its first member on a line of its
+* own, since there is no indent to reuse.
+*/
+function fixMemberOrder(source, node, members) {
+	const first = members.at(0);
+	const last = members.at(-1);
+	if (first === void 0 || last === void 0) return null;
+	const start = first.range[0];
+	const end = last.range[1];
+	if (hasCommentWithin(source, node.range[0], node.range[1])) return null;
+	const text = source.text;
+	const sorted = members.toSorted((a, b) => compareMembers(memberName(a), memberName(b)));
+	const multiline = text.slice(start, end).includes("\n");
+	const lead = text.slice(text.lastIndexOf("\n", start) + 1, start);
+	if (multiline && lead.trim() !== "") return null;
+	const separator = multiline ? `,\n${multiline ? lead : ""}` : ", ";
+	const replacement = sorted.map((member) => source.getText(member)).join(separator);
+	return (fixer) => fixer.replaceTextRange([start, end], replacement);
+}
+/**
+* Builds the whole-block rewrite, but only when nothing would be lost and the
+* rewrite changes something. Comments inside the block have no home in the
+* rewritten text, and statements interleaved between imports would be erased
+* by a single range replacement, so both cases give `null` and report
+* without a fix. So does a block that cannot be put fully in order without
+* moving a side-effect import, rather than fixing it halfway.
+*/
+function fixImportBlock(source, body, entries) {
+	const first = entries.at(0);
+	const last = entries.at(-1);
+	if (first === void 0 || last === void 0) return null;
+	const start = first.node.range[0];
+	const end = last.node.range[1];
+	const contiguous = body.indexOf(last.node) - body.indexOf(first.node) + 1 === entries.length;
+	const lineEnd = source.text.indexOf("\n", end);
+	const commentEnd = lineEnd === -1 ? source.text.length : lineEnd;
+	if (!contiguous || hasCommentWithin(source, start, commentEnd)) return null;
+	const ordered = fixedOrder(entries);
+	if (!isSorted(ordered)) return null;
+	let replacement = "";
+	let previousGroup = null;
+	for (const entry of ordered) {
+		if (previousGroup !== null) replacement += entry.group === previousGroup ? "\n" : "\n\n";
+		replacement += source.getText(entry.node);
+		previousGroup = entry.group;
+	}
+	return (fixer) => fixer.replaceTextRange([start, end], replacement);
+}
+/**
+* Reports the first import member that sorts before the one ahead of it, with
+* a fix that sorts the whole member list when it is safe. Returns whether a
+* report was made.
+*/
+function reportMemberOrder(context, source, imports) {
+	for (const node of imports) {
+		const members = namedSpecifiers(node);
+		for (const [index, member] of members.entries()) {
+			const before = members[index - 1];
+			if (before === void 0) continue;
+			const name = memberName(member);
+			const previous = memberName(before);
+			if (compareMembers(name, previous) >= 0) continue;
+			const fix = fixMemberOrder(source, node, members);
+			context.report({
+				node: member,
+				messageId: "memberOrder",
+				data: {
+					name,
+					previous
+				},
+				...fix === null ? {} : { fix }
+			});
+			return true;
+		}
+	}
+	return false;
+}
+/**
+* Reports the first import out of group order, sort order, or blank-line
+* spacing, with a fix that rewrites the whole block when it is safe.
+*/
+function reportImportOrder(context, source, body, imports) {
+	const entries = imports.map((node) => ({
+		node,
+		specifier: node.source.value,
+		group: importGroup(node.source.value)
+	}));
+	for (const [index, current] of entries.entries()) {
+		const previous = entries[index - 1];
+		if (previous === void 0) continue;
+		const problem = orderProblem(previous, current, (source.text.slice(previous.node.range[1], current.node.range[0]).match(NEWLINE_PATTERN) ?? []).length >= 2);
+		if (problem === null) continue;
+		const fix = fixImportBlock(source, body, entries);
+		context.report({
+			node: current.node,
+			messageId: problem.messageId,
+			data: Object.fromEntries(problem.data),
+			...fix === null ? {} : { fix }
+		});
+		return;
+	}
+}
+/**
+* `enforce-import-order` - groups imports as packages, then `#` aliases, then
+* relative paths, separated by a blank line and each sorted by code point.
+* Names inside the braces are sorted too, ignoring case and any `type`
+* modifier.
+*
+* The fix rewrites the import block, unless a comment or another statement
+* sits between the imports, so nothing gets discarded. Side-effect imports
+* stay where they are and no import is moved across one.
+*/
+const enforceImportOrderRule = {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "Enforce grouped and sorted import declarations and import members",
+			url: docsUrl("enforce-import-order")
+		},
+		fixable: "code",
+		schema: [],
+		messages: {
+			memberOrder: "Expected '{{name}}' before '{{previous}}'.",
+			groupOrder: "Expected {{group}} imports before {{previous}} imports.",
+			missingBlankLine: "Expected a blank line between {{previous}} imports and {{group}} imports.",
+			extraBlankLine: "Unexpected blank line between {{group}} imports.",
+			sourceOrder: "Expected '{{specifier}}' before '{{previous}}'."
+		}
+	},
+	create(context) {
+		const source = context.sourceCode;
+		return { "Program:exit"(program) {
+			const body = program.body;
+			const imports = body.filter((statement) => statement.type === "ImportDeclaration");
+			if (!reportMemberOrder(context, source, imports)) reportImportOrder(context, source, body, imports);
+		} };
+	}
+};
+//#endregion
+//#region src/rules/enforce-layer-order.ts
+/**
+* `enforce-layer-order` - treats the order of `#` aliases in `package.json`
+* `imports` as the layer order, top layer first: an area may only import
+* aliases declared below its own. Also rejects a file that imports its own
+* area's alias, by alias or by path, and a file that two aliases claim.
+*
+* This makes cycles between areas structurally impossible rather than
+* merely detectable. Lint cannot report on `package.json` itself, so an
+* overlap fires once at the top of every file it affects.
+*/
+const enforceLayerOrderRule = {
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Enforce the order of `package.json` `imports` as the layer order",
+			url: docsUrl("enforce-layer-order")
+		},
+		schema: [],
+		messages: {
+			ownEntry: "'{{owner}}' must not import its own entry point through '{{specifier}}'.",
+			upward: "'{{owner}}' must not import '{{target}}', which is declared above it in package.json.",
+			overlap: "This file is owned by more than one alias in package.json: {{aliases}}."
+		}
+	},
+	create(context) {
+		return {
+			...visitSpecifiers((node, specifier) => {
+				const config = findImportsConfig(context.filename);
+				if (config === null) return;
+				const owner = findOwningEntry(config, context.filename);
+				const target = resolveTarget(config, context.filename, specifier);
+				if (owner === null || target === null) return;
+				if (target.index === owner.index) {
+					context.report({
+						node,
+						messageId: "ownEntry",
+						data: {
+							owner: owner.specifier,
+							specifier
+						}
+					});
+					return;
+				}
+				if (target.index < owner.index) context.report({
+					node,
+					messageId: "upward",
+					data: {
+						owner: owner.specifier,
+						target: target.specifier
+					}
+				});
+			}),
+			Program(node) {
+				const config = findImportsConfig(context.filename);
+				const claiming = config === null ? [] : claimingEntries(config, context.filename);
+				if (claiming.length < 2) return;
+				context.report({
+					node,
+					loc: {
+						line: 1,
+						column: 0
+					},
+					messageId: "overlap",
+					data: { aliases: claiming.map((entry) => entry.specifier).join(", ") }
+				});
+			}
+		};
+	}
+};
+//#endregion
+//#region src/rules/enforce-mod-file.ts
+/**
+* `enforce-mod-file` - requires module entry points to be named `index.ts`,
+* the Node.js convention. Reports both a file named `mod` and any project
+* specifier pointing at one.
+*
+* The rule keeps its original name from when it required `mod.ts`; on
+* Node.js the entry point is `index.ts`. One name everywhere means a
+* module's entry point is never ambiguous. Only the folders `#` entries own
+* are modules, so a file outside them, and an import between such files, is
+* left alone.
+*/
+const enforceModFileRule = {
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Enforce `index.ts` as the name of module entry points",
+			url: docsUrl("enforce-mod-file")
+		},
+		schema: [],
+		messages: {
+			fileName: "Expected the entry point to be named 'index.ts' but found '{{name}}'.",
+			specifier: "'{{specifier}}' points at a 'mod' entry point."
+		}
+	},
+	create(context) {
+		return {
+			...visitSpecifiers((node, specifier) => {
+				if (!specifier.startsWith(".") && !specifier.startsWith("#")) return;
+				if (REJECTED_STEMS.includes(stemName(specifier)) && isInModuleScope(context.filename, specifier)) context.report({
+					node,
+					messageId: "specifier",
+					data: { specifier }
+				});
+			}),
+			Program(node) {
+				const filename = normalizePath(context.filename);
+				const config = findImportsConfig(filename);
+				if (REJECTED_STEMS.includes(stemName(filename)) && config !== null && isModulePath(config, filename)) context.report({
+					node,
+					messageId: "fileName",
+					data: { name: baseName(filename) }
+				});
+			}
+		};
+	}
+};
+//#endregion
+//#region src/rules/no-absolute-import.ts
+/**
+* `no-absolute-import` - rejects specifiers starting with `/` or `file:`.
+*
+* A leading slash resolves against the file system root rather than the
+* project root, and a `file:` URL hard codes one machine's layout.
+*/
+const noAbsoluteImportRule = {
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Disallow absolute paths and `file:` URLs as module specifiers",
+			url: docsUrl("no-absolute-import")
+		},
+		schema: [],
+		messages: { absolute: "'{{specifier}}' is an absolute path." }
+	},
+	create(context) {
+		return visitSpecifiers((node, specifier) => {
+			if (specifier.startsWith("/") || specifier.startsWith("file:")) context.report({
+				node,
+				messageId: "absolute",
+				data: { specifier }
+			});
+		});
+	}
+};
+//#endregion
+//#region src/rules/no-barrel-bypass.ts
+/**
+* `no-barrel-bypass` - rejects a `#` specifier deeper than an alias, such as
+* `#components/internal.ts` beside `#components`, whether or not a subpath
+* pattern makes it resolve, and any use of a subpath pattern that reaches
+* into an owned area.
+*
+* Code outside an alias's area reaches it only through the exact alias, so
+* the area keeps one public surface. Switching to the alias is a suggestion,
+* since its target may not export the name yet.
+*/
+const noBarrelBypassRule = {
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Disallow `#` specifiers deeper than an alias",
+			url: docsUrl("no-barrel-bypass")
+		},
+		hasSuggestions: true,
+		schema: [],
+		messages: {
+			bypass: "'{{specifier}}' reaches past the entry point '{{owner}}'.",
+			internals: "'{{specifier}}' reaches into module internals.",
+			useEntry: "Import from '{{owner}}' instead."
+		}
+	},
+	create(context) {
+		return visitSpecifiers((node, specifier) => {
+			if (!specifier.startsWith("#")) return;
+			const config = findImportsConfig(context.filename);
+			if (config === null || config.bySpecifier.has(specifier)) return;
+			const owner = deeperAliasOwner(config, specifier);
+			if (owner === null) {
+				if (findPatternEntry(config, specifier) !== null && isInModuleScope(context.filename, specifier)) context.report({
+					node,
+					messageId: "internals",
+					data: { specifier }
+				});
+				return;
+			}
+			context.report({
+				node,
+				messageId: "bypass",
+				data: {
+					specifier,
+					owner: owner.specifier
+				},
+				suggest: [{
+					messageId: "useEntry",
+					data: { owner: owner.specifier },
+					fix: (fixer) => fixer.replaceText(node, quoteLike(node, owner.specifier))
+				}]
+			});
+		});
+	}
+};
+//#endregion
+//#region src/rules/no-duplicate-import-source.ts
+/**
+* The declarations in a same-source group that another one in the group can
+* absorb. A value import absorbs anything, so the first one keeps its place
+* and the rest are reported. With no value import, the bare imports collapse
+* into one and the type-only imports into another, and those two survive.
+*/
+function mergeableImports(group) {
+	const typeOnly = group.filter((node) => node.importKind === "type");
+	const runtime = group.filter((node) => node.importKind !== "type");
+	const firstValue = runtime.find((node) => node.specifiers.length > 0);
+	if (firstValue !== void 0) return group.filter((node) => node !== firstValue);
+	return [...runtime.slice(1), ...typeOnly.slice(1)];
+}
+/**
+* `no-duplicate-import-source` - rejects separate static import declarations
+* with the same module specifier. Re-exports and dynamic imports are
+* different operations and are left alone.
+*
+* A type-only import beside a bare one is the exception. The type-only
+* declaration disappears from the emitted module, so folding the bare import
+* into it would drop the side effect that registers a custom element or
+* installs a polyfill. Those two say different things and both have to stay.
+*/
+const noDuplicateImportSourceRule = {
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Disallow separate import declarations from the same source",
+			url: docsUrl("no-duplicate-import-source")
+		},
+		schema: [],
+		messages: { duplicate: "Import source '{{specifier}}' is duplicated." }
+	},
+	create(context) {
+		const groups = /* @__PURE__ */ new Map();
+		return {
+			ImportDeclaration(node) {
+				const specifier = node.source.value;
+				const group = groups.get(specifier) ?? [];
+				group.push(node);
+				groups.set(specifier, group);
+			},
+			"Program:exit"(_node) {
+				for (const [specifier, group] of groups) for (const node of mergeableImports(group)) context.report({
+					node: node.source,
+					messageId: "duplicate",
+					data: { specifier }
+				});
+			}
+		};
+	}
+};
+//#endregion
+//#region src/rules/no-parent-import.ts
+/**
+* `no-parent-import` - rejects `../` specifiers in every file, owned by an
+* alias or not, rewriting one to its `#` alias where `package.json` declares
+* an alias for exactly that file.
+*
+* Reaching up and back down couples two files through their layout instead
+* of a name. Anything above a file is reached through an alias.
+*/
+const noParentImportRule = {
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Disallow parent-relative module specifiers",
+			url: docsUrl("no-parent-import")
+		},
+		fixable: "code",
+		schema: [],
+		messages: {
+			parentImport: "Unexpected parent-relative import '{{specifier}}'.",
+			useAlias: "Parent-relative import '{{specifier}}' should be '{{alias}}'."
+		}
+	},
+	create(context) {
+		return visitSpecifiers((node, specifier) => {
+			if (!specifier.startsWith("../")) return;
+			const config = findImportsConfig(context.filename);
+			const resolved = resolveLocalSpecifier(context.filename, specifier);
+			const entry = resolved === null ? void 0 : config?.byTarget.get(resolved);
+			if (config === null || entry === void 0 || isClaimedBy(config, context.filename, entry)) {
+				context.report({
+					node,
+					messageId: "parentImport",
+					data: { specifier }
+				});
+				return;
+			}
+			context.report({
+				node,
+				messageId: "useAlias",
+				data: {
+					specifier,
+					alias: entry.specifier
+				},
+				fix: (fixer) => fixer.replaceText(node, quoteLike(node, entry.specifier))
+			});
+		});
+	}
+};
+//#endregion
+//#region src/rules/no-relative-bypass.ts
+/**
+* `no-relative-bypass` - rejects a `./` specifier that reaches into an area
+* an alias owns from outside that area.
+*
+* An alias owns its target: an alias to a folder's `index.ts` owns that
+* folder and everything below it, and an alias to any other file owns only
+* that file. Code outside an area reaches it only through the alias. Inside
+* an area, siblings and subfolders are free, and so are files no alias owns.
+* A path to an alias's exact target is left to `prefer-alias-import`, which
+* rewrites it to the alias.
+*/
+const noRelativeBypassRule = {
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Disallow relative specifiers that reach into an alias's area from outside it",
+			url: docsUrl("no-relative-bypass")
+		},
+		schema: [],
+		messages: { bypass: "'{{specifier}}' reaches into the area of '{{alias}}' from outside it." }
+	},
+	create(context) {
+		return visitSpecifiers((node, specifier) => {
+			if (!specifier.startsWith("./")) return;
+			const config = findImportsConfig(context.filename);
+			const resolved = resolveLocalSpecifier(context.filename, specifier);
+			if (config === null || resolved === null || config.byTarget.has(resolved)) return;
+			const target = findOwningEntry(config, resolved);
+			if (target === null || isClaimedBy(config, context.filename, target)) return;
+			context.report({
+				node,
+				messageId: "bypass",
+				data: {
+					specifier,
+					alias: target.specifier
+				}
+			});
+		});
+	}
+};
+//#endregion
+//#region src/rules/no-self-import.ts
+/**
+* `no-self-import` - rejects any statically knowable specifier that resolves
+* to the importing file: a relative path, an absolute path or `file:` URL, an
+* exact `#` entry, or a `#` subpath pattern.
+*
+* A self-import is an immediate circular dependency.
+*/
+const noSelfImportRule = {
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Disallow a module from importing itself",
+			url: docsUrl("no-self-import")
+		},
+		schema: [],
+		messages: { selfImport: "'{{specifier}}' imports the current file." }
+	},
+	create(context) {
+		return visitSpecifiers((node, specifier) => {
+			if (resolveLocalSpecifier(context.filename, specifier) !== normalizePath(context.filename)) return;
+			context.report({
+				node,
+				messageId: "selfImport",
+				data: { specifier }
+			});
+		});
+	}
+};
+//#endregion
+//#region src/rules/no-wildcard-import.ts
+/**
+* `no-wildcard-import` - requires imports to name the bindings they depend
+* on, so `import * as name` is rejected, `type` or not.
+*
+* An explicit list keeps each file's dependency surface narrow and visible at
+* the import site. Side-effect imports and re-exports are left alone.
+*/
+const noWildcardImportRule = {
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Disallow namespace imports",
+			url: docsUrl("no-wildcard-import")
+		},
+		schema: [],
+		messages: { wildcard: "Unexpected wildcard import." }
+	},
+	create(context) {
+		return { ImportDeclaration(node) {
+			const namespace = node.specifiers.find((specifier) => specifier.type === "ImportNamespaceSpecifier");
+			if (namespace !== void 0) context.report({
+				node: namespace,
+				messageId: "wildcard"
+			});
+		} };
+	}
+};
+//#endregion
+//#region src/rules/prefer-alias-import.ts
+/**
+* `prefer-alias-import` - requires the `#` alias when a `./` specifier names
+* the exact target of an alias from outside that alias's area, a same-folder
+* sibling included. An alias owns its target, so its target has one spelling
+* everywhere outside it.
+*
+* One spelling per module keeps `package.json` `imports` the single source of
+* truth, and keeps the layer rules from being sidestepped by a path.
+*/
+const preferAliasImportRule = {
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Require the `#` alias for a module that `package.json` declares",
+			url: docsUrl("prefer-alias-import")
+		},
+		fixable: "code",
+		schema: [],
+		messages: { useAlias: "'{{specifier}}' is declared as '{{alias}}' in package.json." }
+	},
+	create(context) {
+		return visitSpecifiers((node, specifier) => {
+			if (!specifier.startsWith("./")) return;
+			const config = findImportsConfig(context.filename);
+			const resolved = resolveLocalSpecifier(context.filename, specifier);
+			const entry = resolved === null ? void 0 : config?.byTarget.get(resolved);
+			if (config === null || entry === void 0) return;
+			if (isClaimedBy(config, context.filename, entry)) return;
+			context.report({
+				node,
+				messageId: "useAlias",
+				data: {
+					specifier,
+					alias: entry.specifier
+				},
+				fix: (fixer) => fixer.replaceText(node, quoteLike(node, entry.specifier))
+			});
+		});
+	}
+};
+//#endregion
+//#region src/rules/index.ts
+/**
+* Every rule, keyed by rule id, in alphabetical order.
+*
+* A `Map` rather than an object literal: a rule record is a lookup keyed by
+* rule id, so the ids belong in value position.
+*/
+const rules = /* @__PURE__ */ new Map([
+	["enforce-import-order", enforceImportOrderRule],
+	["enforce-layer-order", enforceLayerOrderRule],
+	["enforce-mod-file", enforceModFileRule],
+	["no-absolute-import", noAbsoluteImportRule],
+	["no-barrel-bypass", noBarrelBypassRule],
+	["no-duplicate-import-source", noDuplicateImportSourceRule],
+	["no-parent-import", noParentImportRule],
+	["no-relative-bypass", noRelativeBypassRule],
+	["no-self-import", noSelfImportRule],
+	["no-wildcard-import", noWildcardImportRule],
+	["prefer-alias-import", preferAliasImportRule]
+]);
+//#endregion
+//#region src/plugin/index.ts
+/** The prefix of every rule id, as ESLint derives it from the package name. */
+const NAMESPACE = "import-structure";
+/**
+* The `modules` preset - every rule the plugin was ported with.
+*
+* Bans the import patterns that create cycles, keeps every module behind one
+* entry point, layers modules by their `package.json` `imports` order, and
+* keeps import blocks grouped and sorted.
+*/
+const MODULES = [
+	"no-self-import",
+	"no-parent-import",
+	"no-absolute-import",
+	"prefer-alias-import",
+	"no-barrel-bypass",
+	"no-relative-bypass",
+	"no-wildcard-import",
+	"enforce-mod-file",
+	"no-duplicate-import-source",
+	"enforce-import-order",
+	"enforce-layer-order"
+];
+/** The plugin before its configs exist, which each config refers back to. */
+const basePlugin = {
+	meta: {
+		name: "eslint-plugin-import-structure",
+		version: "0.10.2",
+		namespace: NAMESPACE
+	},
+	rules: Object.fromEntries(rules)
+};
+/**
+* A flat config that loads the plugin and turns every given rule on. A config
+* is only a list of rule ids, so one rule can sit in several configs.
+*/
+function presetConfig(preset, ruleIds) {
+	return {
+		name: `${NAMESPACE}/${preset}`,
+		plugins: Object.fromEntries([[NAMESPACE, basePlugin]]),
+		rules: Object.fromEntries(ruleIds.map((id) => [`${NAMESPACE}/${id}`, "error"]))
+	};
+}
+/**
+* The plugin, for ESLint `plugins` or Oxlint `jsPlugins`, and the package's
+* only export. Configs: `modules` holds the ported rules, and
+* `all` turns on every rule, so a new rule joins it by itself.
+*/
+const plugin = Object.assign(basePlugin, { configs: {
+	modules: presetConfig("modules", MODULES),
+	all: presetConfig("all", [...rules.keys()])
+} });
+//#endregion
+export { plugin as default };

package/package.json

@@ -1,6 +1,74 @@
 {
   "name": "eslint-plugin-import-structure",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.10.2",
+  "description": "ESLint and Oxlint rules that keep a module graph layered and free of cycles, with package.json \"#\" imports as the layer order.",
+  "keywords": [
+    "eslint",
+    "eslint-plugin",
+    "eslintplugin",
+    "import",
+    "import-structure",
+    "imports",
+    "oxlint"
+  ],
+  "homepage": "https://github.com/cunarist/eslint-plugin-import-structure#readme",
+  "bugs": {
+    "url": "https://github.com/cunarist/eslint-plugin-import-structure/issues"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cunarist/eslint-plugin-import-structure.git"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "imports": {
+    "#plugin": "./src/plugin/index.ts",
+    "#rules": "./src/rules/index.ts",
+    "#testing": "./src/testing/index.ts",
+    "#helpers": "./src/helpers/index.ts"
+  },
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "scripts": {
+    "docs": "eslint-doc-generator"
+  },
+  "dependencies": {
+    "@eslint/core": "^0.17.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.20.5",
+    "@typescript-eslint/parser": "^8.71.1",
+    "@typescript-eslint/types": "^8.71.1",
+    "eslint": "^9.39.5",
+    "eslint-doc-generator": "^3.7.1",
+    "vite-plus": "^1.1.0"
+  },
+  "engines": {
+    "node": ">=22.18"
+  },
+  "eslint-doc-generator": {
+    "configEmoji": [
+      [
+        "modules",
+        "🧭"
+      ]
+    ],
+    "ignoreConfig": [
+      "all"
+    ],
+    "ruleListColumns": [
+      "name",
+      "description",
+      "configsError"
+    ],
+    "ruleDocSectionInclude": [
+      "Rule Details",
+      "When Not To Use It"
+    ],
+    "urlConfigs": "https://github.com/cunarist/eslint-plugin-import-structure#configs-and-rules"
+  }
+}