ox-dep-lint 0.4.0 → 0.5.0

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## 0.5.0
+
+### Minor Changes
+
+- 57698bb: `invalid-package` now reports a workspace member whose `dependencies`, `devDependencies`, `optionalDependencies` or `peerDependencies` is not an object: a string (`"dependencies": "some string"`), a list, a number, a boolean or `null`. 0.4 read no names from such a field and said nothing, so a forbidden or undeclared edge written there passed unseen. The finding names the field and what it holds, once per field; the member is still checked, as if that field declared nothing. The root `package.json` is not judged this way.
+
+  This is a minor release rather than a patch because it can fail a check that passed on 0.4 (the rule in `.changeset/README.md`: before 1.0, a change to what the rules report is a minor bump). Fix the field, or baseline the finding by its own target, the member's directory and the field joined by `#`:
+
+  ```ts
+  baseline: [
+    {
+      file: "tools/quality/package.json",
+      rule: "invalid-package",
+      target: "tools/quality#peerDependencies",
+      reason: "...",
+    },
+  ]
+  ```
+
+  Such an entry covers only that field. If the `package.json` later cannot be read or loses its name, which drops the member from the check, that is still reported, with the directory as its target.
+
+### Patch Changes
+
+- 57698bb: A path that disappears while the check runs is skipped instead of reported as `unreadable-path`. A test that creates and removes a temporary tree inside a package while the CLI walks it (tsukuri's `tools/quality/.scan-x/...`) no longer fails the check with `ENOENT`. This covers every place the check lists, stats or reads: the walk of each package, the `workspaces` and kind globs, a member's `package.json`, a symbolic link's destination, and a development file that shipped code imports. `ENOTDIR` (a directory on the way replaced by a file) is skipped the same way. A path that exists but cannot be read (`EACCES` and every other error) is still a finding: `unreadable-path`, or `invalid-package` for a member's `package.json`, or `shipped-imports-development-file` for a development file that shipped code imports, or `symbolic-link` (to an unreadable destination) for a link, and the oxlint plugin, which shares these functions, behaves the same. The file count the CLI prints no longer includes files that disappeared.
+
 ## 0.4.0
 
 ### Minor Changes

package/README.md

@@ -28,10 +28,10 @@ ox-dep-lint replaces the hand-written module graph checks of three repositories
 | `self-import-by-name`              | A package importing itself by its own name (off by default).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | both                                                         |
 | `package-without-kind`             | A workspace package that no kind's globs hold.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | both                                                         |
 | `package-outside-workspace`        | A directory a kind names, with a `package.json`, that the root `workspaces` leave out, so nothing in it would be checked.                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | CLI                                                          |
-| `invalid-package`                  | A workspace member whose `package.json` cannot be read, has no name, or has another member's name.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | CLI                                                          |
+| `invalid-package`                  | A workspace member whose `package.json` cannot be read, has no name, or has another member's name; or one with a dependency field (`dependencies`, `devDependencies`, `optionalDependencies`, `peerDependencies`) that is not an object (`"dependencies": "x"`, a list, a number, `null`), so no edge in it could be read. Such a member is still checked, as if that field declared nothing. A field's finding has the target `<directory>#<field>` (`tools/quality#peerDependencies`), so a baseline entry for it cannot cover the other causes, whose target is the directory.           | CLI                                                          |
 | `directory-without-package`        | A directory a root `workspaces` glob matches that has no `package.json` and lies neither inside nor above a member, so no package owns its files and nothing checks them (tsukuri's "directory in no tier"). Also a dot directory such a glob would match (`packages/.template`), with or without a `package.json`: npm and Bun workspaces never match dot directories, so it is no package. Only the topmost of nested ones is reported; a negated glob (`!tools/legacy` or `!tools/legacy/**`) leaves the directory out. Silence one with `ignore` (`tools/vendored/**`) or the baseline. | CLI                                                          |
 | `symbolic-link`                    | Every symbolic link under a package directory, whatever it points at (a file, a directory, nothing, a cycle) and whatever its name (`.d.ts`, `.md`, `.json`, extensionless); a link a `workspaces` or kind glob matches or names (`packages/x -> ../elsewhere`); and a link a glob passes through (`packages` itself a link). The check never follows one. It skips only links inside directories it skips on purpose: `node_modules`, `.git`, and directories `ignore`, `output` or an unchecked file class cover through a trailing `/**`.                                                | both (the plugin on each file oxlint reaches through a link) |
-| `unreadable-path`                  | A directory the walk, a `workspaces` glob or a kind glob cannot list, or a source file the check cannot read (`EACCES`), unless the check skips it on purpose. It used to stop the check with exit code 2.                                                                                                                                                                                                                                                                                                                                                                                  | CLI                                                          |
+| `unreadable-path`                  | A directory the walk, a `workspaces` glob or a kind glob cannot list, or a source file the check cannot read (`EACCES`), unless the check skips it on purpose. It used to stop the check with exit code 2. A path removed while the check runs (`ENOENT`, or `ENOTDIR` when a directory on the way became a file), such as a test's temporary tree, is skipped with no finding.                                                                                                                                                                                                             | CLI                                                          |
 | `package-cycle`                    | A cycle between packages through their runtime dependency fields.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | CLI                                                          |
 | `stale-baseline`                   | A baseline entry that no finding needs any more, so the baseline can only shrink.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | CLI                                                          |
 | `parse-error`                      | A file that does not parse, so its imports cannot be checked.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | both                                                         |
@@ -102,7 +102,7 @@ Releases are published from a `v*` tag by `.github/workflows/release.yml`, with
 
 ## Running it
 
-The CLI walks every workspace package's directory, dot directories included (`src/.internal/`), skipping only `node_modules` and `.git` and reading nothing under `output`, so generated and gitignored sources and nested repositories are checked too, and runs the whole-graph checks. Tool caches such as `.wrangler` and `.astro` are in the default `output`; for another cache, set `output` to the defaults plus its glob, since `output` replaces the defaults. The CLI never follows a symbolic link: every link is a `symbolic-link` finding, and a directory it cannot list or a file it cannot read is an `unreadable-path` finding. What it still does not report: plain files directly at a workspace glob's level (`packages/x.ts`), and FIFOs and sockets.
+The CLI walks every workspace package's directory, dot directories included (`src/.internal/`), skipping only `node_modules` and `.git` and reading nothing under `output`, so generated and gitignored sources and nested repositories are checked too, and runs the whole-graph checks. Tool caches such as `.wrangler` and `.astro` are in the default `output`; for another cache, set `output` to the defaults plus its glob, since `output` replaces the defaults. The CLI never follows a symbolic link: every link is a `symbolic-link` finding, and a directory it cannot list or a file it cannot read is an `unreadable-path` finding; one that disappears between being listed and being read is skipped. What it still does not report: plain files directly at a workspace glob's level (`packages/x.ts`), and FIFOs and sockets.
 
 ```sh
 ox-dep-lint            # finds ox-dep-lint.config.{ts,mts,js,mjs,json} at the workspace root

package/dist/{check-BbeuFBNh.mjs → check-CWi8LUnB.mjs}

@@ -1,4 +1,4 @@
-import { C as attempt, D as matchesGlob, c as linkDestination, d as reads, f as reportsLink, g as withoutBaselined, h as unreadablePathFinding, i as edgeRefusal, l as passedOver, m as symbolicLinkFinding, n as coversDirectory, o as findingsForFile, p as skipsDirectory, r as createEngine, s as ignoresDirectory, t as baselineCovers, v as directoriesMatching, w as codeOf } from "./engine-DmECSDnu.mjs";
+import { C as attempt, E as vanished, O as matchesGlob, c as linkDestination, d as reads, f as reportsLink, g as withoutBaselined, h as unreadablePathFinding, i as edgeRefusal, l as passedOver, m as symbolicLinkFinding, n as coversDirectory, o as findingsForFile, p as skipsDirectory, r as createEngine, s as ignoresDirectory, t as baselineCovers, v as directoriesMatching, w as codeOf } from "./engine-CwR59HVO.mjs";
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import nodePath from "node:path";
 // src/graph.ts
@@ -20,13 +20,16 @@ const graphFindings = (engine) => {
 		line: 1,
 		column: 0
 	};
-	for (const problem of workspace.problems) findings.push({
-		rule: "invalid-package",
-		file: `${problem.directory}/package.json`,
-		...at,
-		message: problem.message,
-		target: problem.directory
-	});
+	for (const problem of workspace.problems) {
+		const target = problem.field === void 0 ? problem.directory : `${problem.directory}#${problem.field}`;
+		findings.push({
+			rule: "invalid-package",
+			file: `${problem.directory}/package.json`,
+			...at,
+			message: problem.message,
+			target
+		});
+	}
 	const members = /* @__PURE__ */ new Set([...workspace.packages.map((entry) => entry.directory), ...workspace.problems.map((problem) => problem.directory)]);
 	const unlistedByKinds = {
 		links: [],
@@ -109,15 +112,6 @@ const isFile = (absolute) => {
 		return false;
 	}
 };
-/** The error code of a directory that cannot be listed, or undefined when it can. */
-const unreadable = (absolute) => {
-	try {
-		readdirSync(absolute);
-		return;
-	} catch (cause) {
-		return codeOf(cause);
-	}
-};
 /**
 * What the root's `workspaces` globs (and a kind's globs) match that is no package: a directory without a
 * `package.json`, whose files no package owns and so nothing checks (only the topmost of nested ones); a dot directory,
@@ -140,15 +134,16 @@ const directoriesWithoutPackage = (engine, members, unlistedByKinds) => {
 	for (const glob of workspace.globs.filter((pattern) => !pattern.startsWith("!"))) for (const directory of directoriesMatching(workspace.root, glob, unlisted)) if (!candidates.has(directory)) candidates.set(directory, glob);
 	const withoutPackage = (directory, glob) => {
 		if (above(directory) || !isDirectory(nodePath.join(workspace.root, directory))) return;
-		const code = unreadable(nodePath.join(workspace.root, directory));
-		return code === void 0 ? {
+		const listed = attempt(() => readdirSync(nodePath.join(workspace.root, directory)));
+		if (!listed.ok) return vanished(listed.error) ? void 0 : unreadablePathFinding(directory, codeOf(listed.error));
+		return {
 			rule: "directory-without-package",
 			file: directory,
 			line: 1,
 			column: 0,
 			message: `${directory} matches the workspaces glob ${glob} but has no package.json, so no package owns what it holds and nothing in it is checked: make it a package, remove it, or add ${directory}/** to ignore`,
 			target: directory
-		} : unreadablePathFinding(directory, code);
+		};
 	};
 	const dotDirectory = (directory) => ({
 		rule: "directory-without-package",
@@ -173,7 +168,10 @@ const directoriesWithoutPackage = (engine, members, unlistedByKinds) => {
 		})),
 		...unlisted.links.map((link) => ({
 			path: link,
-			finding: () => isFile(nodePath.join(workspace.root, link)) ? void 0 : symbolicLinkFinding(link, linkDestination(nodePath.join(workspace.root, link)))
+			finding: () => {
+				const destination = isFile(nodePath.join(workspace.root, link)) ? void 0 : linkDestination(nodePath.join(workspace.root, link));
+				return destination === void 0 ? void 0 : symbolicLinkFinding(link, destination);
+			}
 		}))
 	].toSorted((left, right) => left.path.split("/").length - right.path.split("/").length || left.path.localeCompare(right.path));
 	const findings = /* @__PURE__ */ new Map();
@@ -289,7 +287,7 @@ const staleBaseline = (engine, findings) => engine.config.baseline.filter((entry
 * other dot directories hold sources too). A walk rather than `git ls-files`: generated and gitignored sources still
 * ship, and a nested repository or submodule inside a package is still part of it. A symbolic link is never followed:
 * every one is a finding, whatever it points at, unless it lies in a directory the check skips on purpose; and so is a
-* directory the walk cannot list.
+* directory the walk cannot list. A path removed between being listed and being read is skipped, with no finding.
 */
 const walkSources = (engine) => {
 	const files = /* @__PURE__ */ new Set();
@@ -300,7 +298,7 @@ const walkSources = (engine) => {
 		try {
 			entries = readdirSync(nodePath.join(root, relative), { withFileTypes: true });
 		} catch (cause) {
-			if (!skipsDirectory(engine, relative)) findings.set(relative, unreadablePathFinding(relative, codeOf(cause)));
+			if (!vanished(cause) && !skipsDirectory(engine, relative)) findings.set(relative, unreadablePathFinding(relative, codeOf(cause)));
 			return;
 		}
 		for (const entry of entries) {
@@ -308,7 +306,8 @@ const walkSources = (engine) => {
 			if (entry.isDirectory()) {
 				if (!passedOver(entry.name)) walk(path);
 			} else if (entry.isSymbolicLink()) {
-				if (reportsLink(engine, path)) findings.set(path, symbolicLinkFinding(path, linkDestination(nodePath.join(root, path))));
+				const destination = reportsLink(engine, path) ? linkDestination(nodePath.join(root, path)) : void 0;
+				if (destination !== void 0) findings.set(path, symbolicLinkFinding(path, destination));
 			} else if (entry.isFile() && reads(engine, path)) files.add(path);
 		}
 	};
@@ -323,17 +322,25 @@ const listSourceFiles = (engine) => [...walkSources(engine).files];
 const checkWorkspace = (root, config) => {
 	const engine = createEngine(root, config);
 	const { files, findings: walked } = walkSources(engine);
-	const perFile = files.flatMap((file) => {
+	const perFile = [];
+	let checked = 0;
+	for (const file of files) {
 		const text = attempt(() => readFileSync(nodePath.join(root, file), "utf8"));
-		return text.ok ? findingsForFile(engine, file, text.value) : [unreadablePathFinding(file, codeOf(text.error), "file")];
-	}).filter((finding) => finding.rule !== "package-without-kind");
+		if (text.ok) {
+			checked += 1;
+			perFile.push(...findingsForFile(engine, file, text.value));
+		} else if (!vanished(text.error)) {
+			checked += 1;
+			perFile.push(unreadablePathFinding(file, codeOf(text.error), "file"));
+		}
+	}
 	const all = [
 		...walked,
-		...perFile,
+		...perFile.filter((finding) => finding.rule !== "package-without-kind"),
 		...graphFindings(engine)
 	];
 	return {
-		files: files.length,
+		files: checked,
 		findings: [...withoutBaselined(engine, all), ...staleBaseline(engine, all)]
 	};
 };

package/dist/cli.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { y as findWorkspaceRoot } from "./engine-DmECSDnu.mjs";
-import { n as formatFinding, t as checkWorkspace } from "./check-BbeuFBNh.mjs";
+import { y as findWorkspaceRoot } from "./engine-CwR59HVO.mjs";
+import { n as formatFinding, t as checkWorkspace } from "./check-CWi8LUnB.mjs";
 import { existsSync, readFileSync } from "node:fs";
 import nodePath from "node:path";
 import process from "node:process";

package/dist/{engine-DmECSDnu.mjs → engine-CwR59HVO.mjs}

@@ -537,6 +537,15 @@ const attempt = (operation) => {
 };
 /** The message of something thrown, which need not be an Error. */
 const messageOf = (cause) => cause instanceof Error ? cause.message : String(cause);
+/**
+* Whether something thrown by `node:fs` says the path is no longer there: `ENOENT`, or `ENOTDIR` when a directory on the
+* way was replaced by a file. A path removed between being listed and being read (a test's temporary tree, an editor's
+* swap file) fails this way, and is skipped rather than reported as unreadable.
+*/
+const vanished = (cause) => {
+	const code = codeOf(cause);
+	return code === "ENOENT" || code === "ENOTDIR";
+};
 /** The error code of something thrown by `node:fs` (`EACCES`), or its message when it has none. */
 const codeOf = (cause) => typeof cause === "object" && cause !== null && "code" in cause && typeof cause.code === "string" ? cause.code : messageOf(cause);
 // src/workspace.ts
@@ -546,12 +555,36 @@ const codeOf = (cause) => typeof cause === "object" && cause !== null && "code"
 */
 /** The manifest at `path`, or why it cannot be read. */
 const readManifest = (path) => {
-	const parsed = attempt(() => JSON.parse(readFileSync(path, "utf8")));
-	if (!parsed.ok) return failure(`${path}: ${messageOf(parsed.error)}`);
-	if (typeof parsed.value !== "object" || parsed.value === null) return failure(`${path} is not a JSON object`);
+	const text = attempt(() => readFileSync(path, "utf8"));
+	if (!text.ok) return failure({
+		message: `${path}: ${messageOf(text.error)}`,
+		vanished: vanished(text.error)
+	});
+	const parsed = attempt(() => JSON.parse(text.value));
+	if (!parsed.ok) return failure({
+		message: `${path}: ${messageOf(parsed.error)}`,
+		vanished: false
+	});
+	if (typeof parsed.value !== "object" || parsed.value === null) return failure({
+		message: `${path} is not a JSON object`,
+		vanished: false
+	});
 	return success(parsed.value);
 };
-const namesOf = (field) => typeof field === "object" && field !== null && !Array.isArray(field) ? Object.keys(field).toSorted() : [];
+/** Whether a dependency field has the shape npm and Bun require: an object of package names to version ranges. */
+const isRecord = (field) => typeof field === "object" && field !== null && !Array.isArray(field);
+const namesOf = (field) => isRecord(field) ? Object.keys(field).toSorted() : [];
+/**
+* A message for each dependency field of `manifest` that is present and not an object (`"dependencies": "x"`, a list, a
+* number, null). Such a field declares nothing the check can read, so without a finding its edges would pass unseen.
+*/
+const malformedFields = (manifest) => allManifestFields.filter((field) => manifest[field] !== void 0 && !isRecord(manifest[field])).map((field) => {
+	const value = manifest[field];
+	return {
+		field,
+		message: `${field} is ${value === null ? "null" : Array.isArray(value) ? "a list" : `a ${typeof value}`}, not an object of package names to version ranges, so no dependency in it is read`
+	};
+});
 const fieldsOf = (manifest) => ({
 	dependencies: namesOf(manifest.dependencies),
 	devDependencies: namesOf(manifest.devDependencies),
@@ -566,7 +599,7 @@ const aliasesOf = (manifest) => {
 		manifest.devDependencies,
 		manifest.optionalDependencies,
 		manifest.peerDependencies
-	]) if (typeof field === "object" && field !== null && !Array.isArray(field)) for (const [name, spec] of Object.entries(field)) {
+	]) if (isRecord(field)) for (const [name, spec] of Object.entries(field)) {
 		const target = typeof spec === "string" ? /^npm:(?<target>@?[^@]+)/u.exec(spec)?.groups?.target : void 0;
 		if (target !== void 0) aliases.set(name, target);
 	}
@@ -637,7 +670,7 @@ const directoriesMatching = (root, pattern, unlisted) => {
 		if (depth >= depthLimit) return;
 		const listed = attempt(() => readdirSync(nodePath.join(root, relative), { withFileTypes: true }));
 		if (!listed.ok) {
-			unlisted?.unreadable.push({
+			if (!vanished(listed.error)) unlisted?.unreadable.push({
 				directory: relative,
 				code: codeOf(listed.error)
 			});
@@ -656,12 +689,13 @@ const directoriesMatching = (root, pattern, unlisted) => {
 		return [];
 	}
 	if (base === clean) return existsSync(nodePath.join(root, base)) ? [base] : [];
-	if (existsSync(nodePath.join(root, base)) && statSync(nodePath.join(root, base)).isDirectory()) walk(base, base === "" ? 0 : base.split("/").length);
+	const status = attempt(() => statSync(nodePath.join(root, base)));
+	if (status.ok && status.value.isDirectory()) walk(base, base === "" ? 0 : base.split("/").length);
 	return found;
 };
 const loadWorkspace = (root) => {
 	const rootRead = readManifest(nodePath.join(root, "package.json"));
-	if (!rootRead.ok) throw new Error(rootRead.error);
+	if (!rootRead.ok) throw new Error(rootRead.error.message);
 	const rootManifest = rootRead.value;
 	const globs = workspaceGlobs(rootManifest) ?? [];
 	const directories = /* @__PURE__ */ new Set();
@@ -672,10 +706,11 @@ const loadWorkspace = (root) => {
 	const byName = /* @__PURE__ */ new Map();
 	for (const directory of [...directories].toSorted()) {
 		const read = readManifest(nodePath.join(root, directory, "package.json"));
+		if (!read.ok && read.error.vanished) continue;
 		if (!read.ok) {
 			problems.push({
 				directory,
-				message: `package.json cannot be read: ${read.error}`
+				message: `package.json cannot be read: ${read.error.message}`
 			});
 			continue;
 		}
@@ -695,6 +730,11 @@ const loadWorkspace = (root) => {
 			});
 			continue;
 		}
+		for (const { field, message } of malformedFields(manifest)) problems.push({
+			directory,
+			message,
+			field
+		});
 		const entry = {
 			name: manifest.name,
 			directory,
@@ -1240,13 +1280,11 @@ const unreadablePathFinding = (path, code, kind = "directory") => ({
 	message: kind === "directory" ? `${path} cannot be read (${code}), so the files in it cannot be checked: make it readable, or add ${path}/** to ignore` : `${path} cannot be read (${code}), so its imports cannot be checked: make it readable, or add it to ignore`,
 	target: path
 });
-/** The destination a symbolic link names, as written. */
+/** The destination a symbolic link names, as written, or undefined when the link has been removed since it was seen. */
 const linkDestination = (absolute) => {
-	try {
-		return readlinkSync(absolute);
-	} catch {
-		return "an unreadable destination";
-	}
+	const destination = attempt(() => readlinkSync(absolute));
+	if (destination.ok) return destination.value;
+	return vanished(destination.error) ? void 0 : "an unreadable destination";
 };
 /**
 * The first symbolic link on the way from `owner`'s directory down to `file` (both repository-relative), the file
@@ -1305,6 +1343,7 @@ const developmentFileBreaks = (engine, file) => {
 		read.set(directory, modifiedTime(nodePath.join(engine.workspace.root, directory)) ?? -1);
 		const reached = [];
 		const text = attempt(() => readFileSync(absolute, "utf8"));
+		if (!text.ok && vanished(text.error)) continue;
 		if (!text.ok) {
 			breaks = `${next} cannot be read (${codeOf(text.error)}), so it cannot be judged`;
 			break;
@@ -1331,7 +1370,10 @@ const findingsForFile = (engine, file, text, options = {}) => {
 	const owner = packageOfFile(workspace, file);
 	if (owner === void 0 || !sourceFile.test(file)) return [];
 	const link = linkOnPath(engine, owner, file);
-	if (link !== void 0) return reportsLink(engine, link) ? [symbolicLinkFinding(link, linkDestination(nodePath.join(workspace.root, link)))] : [];
+	if (link !== void 0) {
+		const destination = reportsLink(engine, link) ? linkDestination(nodePath.join(workspace.root, link)) : void 0;
+		return destination === void 0 ? [] : [symbolicLinkFinding(link, destination)];
+	}
 	if (!reads(engine, file) && developmentImports === void 0) return [];
 	const packageRelative = file.slice(owner.directory.length + 1);
 	const classified = effectivePolicy(engine, owner, packageRelative);
@@ -1463,4 +1505,4 @@ const findingsForFile = (engine, file, text, options = {}) => {
 const baselineCovers = (entry, finding) => entry.file === finding.file && entry.rule === finding.rule && entry.target === finding.target;
 /** `findings` less those the baseline covers. */
 const withoutBaselined = (engine, findings) => findings.filter((finding) => !engine.config.baseline.some((entry) => baselineCovers(entry, finding)));
-export { defineConfig as A, attempt as C, matchesGlob as D, matchesAny as E, configProblems as O, packageOfFile as S, failure as T, importForms as _, effectivePolicy as a, loadWorkspace as b, linkDestination as c, reads as d, reportsLink as f, withoutBaselined as g, unreadablePathFinding as h, edgeRefusal as i, resolveConfig as j, defaultFileClasses as k, passedOver as l, symbolicLinkFinding as m, coversDirectory as n, findingsForFile as o, skipsDirectory as p, createEngine as r, ignoresDirectory as s, baselineCovers as t, policyOf as u, directoriesMatching as v, codeOf as w, packageNameOf as x, findWorkspaceRoot as y };
+export { defaultFileClasses as A, attempt as C, matchesAny as D, vanished as E, resolveConfig as M, matchesGlob as O, packageOfFile as S, failure as T, importForms as _, effectivePolicy as a, loadWorkspace as b, linkDestination as c, reads as d, reportsLink as f, withoutBaselined as g, unreadablePathFinding as h, edgeRefusal as i, defineConfig as j, configProblems as k, passedOver as l, symbolicLinkFinding as m, coversDirectory as n, findingsForFile as o, skipsDirectory as p, createEngine as r, ignoresDirectory as s, baselineCovers as t, policyOf as u, directoriesMatching as v, codeOf as w, packageNameOf as x, findWorkspaceRoot as y };

package/dist/index.d.mts

@@ -14,10 +14,15 @@ interface Workspace {
   readonly byName: ReadonlyMap<string, WorkspacePackage>;
   /** The root package's own dependency fields. */
   readonly rootManifest: Readonly<Record<ManifestField, readonly string[]>>;
-  /** Members that cannot be checked: no name, a name another member has, an unreadable package.json. */
+  /**
+   * Members whose package.json is wrong. With no name, a name another member has, or a package.json that cannot be read,
+   * the member cannot be checked and is not in `packages`; with a dependency field that is not an object, it is, as if
+   * that field declared nothing, and `field` names it.
+   */
   readonly problems: readonly {
     readonly directory: string;
     readonly message: string;
+    readonly field?: ManifestField;
   }[];
   /** The root package.json's `workspaces` globs, negations (`!apps/old`) included. */
   readonly globs: readonly string[];
@@ -138,7 +143,7 @@ interface SourceWalk {
  * other dot directories hold sources too). A walk rather than `git ls-files`: generated and gitignored sources still
  * ship, and a nested repository or submodule inside a package is still part of it. A symbolic link is never followed:
  * every one is a finding, whatever it points at, unless it lies in a directory the check skips on purpose; and so is a
- * directory the walk cannot list.
+ * directory the walk cannot list. A path removed between being listed and being read is skipped, with no finding.
  */
 export declare const walkSources: (engine: Engine) => SourceWalk;
 /** The source files `walkSources` finds. */

package/dist/index.mjs

@@ -1,3 +1,3 @@
-import { A as defineConfig, D as matchesGlob, E as matchesAny, O as configProblems, S as packageOfFile, _ as importForms, a as effectivePolicy, b as loadWorkspace, d as reads, g as withoutBaselined, j as resolveConfig, k as defaultFileClasses, o as findingsForFile, r as createEngine, u as policyOf, x as packageNameOf, y as findWorkspaceRoot } from "./engine-DmECSDnu.mjs";
-import { a as graphFindings, i as walkSources, n as formatFinding, o as staleBaseline, r as listSourceFiles, t as checkWorkspace } from "./check-BbeuFBNh.mjs";
+import { A as defaultFileClasses, D as matchesAny, M as resolveConfig, O as matchesGlob, S as packageOfFile, _ as importForms, a as effectivePolicy, b as loadWorkspace, d as reads, g as withoutBaselined, j as defineConfig, k as configProblems, o as findingsForFile, r as createEngine, u as policyOf, x as packageNameOf, y as findWorkspaceRoot } from "./engine-CwR59HVO.mjs";
+import { a as graphFindings, i as walkSources, n as formatFinding, o as staleBaseline, r as listSourceFiles, t as checkWorkspace } from "./check-CWi8LUnB.mjs";
 export { checkWorkspace, configProblems, createEngine, defaultFileClasses, defineConfig, effectivePolicy, findWorkspaceRoot, findingsForFile, formatFinding, graphFindings, importForms, listSourceFiles, loadWorkspace, matchesAny, matchesGlob, packageNameOf, packageOfFile, policyOf, reads, resolveConfig, staleBaseline, walkSources, withoutBaselined };

package/dist/plugin.mjs

@@ -1,4 +1,4 @@
-import { C as attempt, T as failure, g as withoutBaselined, o as findingsForFile, r as createEngine, y as findWorkspaceRoot } from "./engine-DmECSDnu.mjs";
+import { C as attempt, T as failure, g as withoutBaselined, o as findingsForFile, r as createEngine, y as findWorkspaceRoot } from "./engine-CwR59HVO.mjs";
 import { statSync } from "node:fs";
 import nodePath from "node:path";
 // src/plugin.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ox-dep-lint",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Module dependency graph rules for oxlint: package kinds, outside packages, runtime and test-only modules, undeclared, escaping and computed imports",
   "license": "MIT",
   "author": "Philip B. Krogh",