@jterrazz/test 16.1.1 → 18.0.0

package/dist/shared-specs-modules.js

@@ -0,0 +1,1033 @@
+import { n as parsedJson, t as isRecord } from "./shared-json-shape.js";
+import { c as isRelativePath } from "./shared-spec-grammar.js";
+import { a as literalOf, n as argumentsOf$1, r as closingOf } from "./shared-source-scan.js";
+import { createRequire } from "node:module";
+import { GROUND_FOLDERS, PRUNED, RENAMED_FOLDERS, RETIRED_SHARED_FOLDERS, SETUP_FOLDER, TESTS_FOLDER, blankComments, folderChanged, holdsManifest, isFile, isGroundFolder, isProjectRoot, isSpecialFolder, nearestRoot, readFileCached, treeEntries, treeKind } from "@jterrazz/typescript/rules";
+import { existsSync, readFileSync, readdirSync, rmSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
+//#region lint/kit/project/settings-file.ts
+const SETTINGS_FILE = "jterrazz.config.ts";
+//#endregion
+//#region lint/kit/project/specs-anchor.ts
+function segments(path) {
+	return path.split(/[/\\]/u).filter(Boolean);
+}
+/** The NEAREST `specs` ancestor, never above the project root: a checkout living under `~/specs/` must not read as one whole specs tree. */
+function specsAnchor(filename) {
+	const relative = [basename(filename)];
+	let directory = dirname(filename);
+	for (;;) {
+		if (basename(directory) === "specs") return {
+			directory,
+			relative
+		};
+		if (isProjectRoot(directory)) return;
+		const parent = dirname(directory);
+		if (parent === directory) return;
+		relative.unshift(basename(directory));
+		directory = parent;
+	}
+}
+function isUnderSpecs(filename) {
+	return specsAnchor(filename) !== void 0;
+}
+//#endregion
+//#region lint/kit/project/role.ts
+const GROUND = new Set(GROUND_FOLDERS);
+function strayTestRootOf(filename) {
+	const parts = projectSegments(filename);
+	const first = parts.length > 1 ? parts[0] : void 0;
+	if (projectRootOf(dirname(filename)) !== void 0 && (first === "tests" || first === "test")) return first;
+	return null;
+}
+/** The order matters: a `*.specification.ts` is one wherever it sits, and `.tsx` versus `.ts` tells a rendered unit apart as the two project helpers do. Ground swallows only what carries no suffix of its own. */
+function roleOf(filename) {
+	const parts = projectSegments(filename);
+	const base = parts.at(-1) ?? "";
+	const identity = {
+		inSpecs: isUnderSpecs(filename),
+		inTests: parts.slice(0, -1).includes(TESTS_FOLDER),
+		strayTestRoot: strayTestRootOf(filename)
+	};
+	if (base.endsWith(".specification.ts") || base.endsWith(".specification.tsx")) return {
+		...identity,
+		role: "specification"
+	};
+	if (base.endsWith(".spec.yaml")) return {
+		...identity,
+		role: "document"
+	};
+	if (base.endsWith(".spec.ts")) return {
+		...identity,
+		role: "spec"
+	};
+	if (base.endsWith(".test.tsx")) return {
+		...identity,
+		role: "component"
+	};
+	if (base.endsWith(".test.ts")) return {
+		...identity,
+		role: "module"
+	};
+	if (base === "jterrazz.config.ts") return {
+		...identity,
+		role: "config"
+	};
+	if (parts.slice(0, -1).some((segment) => GROUND.has(segment))) return {
+		...identity,
+		role: "ground"
+	};
+	if (parts.slice(0, -1).includes("stubs")) return {
+		...identity,
+		role: "stub"
+	};
+	return {
+		...identity,
+		role: "other"
+	};
+}
+const TEST_ROLES = /* @__PURE__ */ new Set([
+	"component",
+	"module",
+	"spec"
+]);
+/** For the passes that walk a tree and hold only a name: one vocabulary with `roleOf`. */
+function isTestFileName(name) {
+	return name.endsWith(".test.ts") || name.endsWith(".test.tsx") || name.endsWith(".spec.ts");
+}
+/** A `.test.tsx` renders and is not one. */
+function isNodeTestFileName(name) {
+	return name.endsWith(".test.ts") || name.endsWith(".spec.ts");
+}
+function isTestRole(role) {
+	return TEST_ROLES.has(role);
+}
+function packageRootOf(directory) {
+	return nearestRoot(directory, holdsManifest);
+}
+const projectRoots = /* @__PURE__ */ new Map();
+/** Remembered per folder, and forgotten for one directory once its own tree listing changes: a `package.json` written or removed there is what the memo must see. */
+function projectRootOf(directory) {
+	if (!folderChanged(directory) && projectRoots.has(directory)) return projectRoots.get(directory);
+	const root = nearestRoot(directory, isProjectRoot);
+	projectRoots.set(directory, root);
+	return root;
+}
+/** A path no package and no repository holds (a rule's test case, `/repo/...`) is read whole. A workspace member named `specs` is the specs tree itself, so its folder name stays the first segment of what it holds. */
+function projectSegments(filename) {
+	const root = projectRootOf(dirname(filename));
+	if (root === void 0) return segments(filename);
+	return [...basename(root) === "specs" ? ["specs"] : [], ...segments(relative(root, filename))];
+}
+//#endregion
+//#region lint/kit/project/ast.ts
+function fieldOf(value, key) {
+	return typeof value === "object" && value !== null ? Reflect.get(value, key) : void 0;
+}
+function stringValue(node) {
+	if (node === void 0) return;
+	if (node.type === "Literal" && typeof node.value === "string") return node.value;
+	if (node.type !== "TemplateLiteral" || childList(node, "expressions").length > 0) return;
+	const [text] = childList(node, "quasis");
+	return cookedText(text);
+}
+function cookedText(quasi) {
+	const cooked = fieldOf(quasi?.value, "cooked");
+	return typeof cooked === "string" ? cooked : void 0;
+}
+function memberPropertyName(node) {
+	if (node?.type !== "MemberExpression" || node.computed === true) return;
+	const property = child(node, "property");
+	return property?.type === "Identifier" ? stringField(property, "name") ?? "" : void 0;
+}
+const CHAIN_LINKS = {
+	AwaitExpression: "argument",
+	CallExpression: "callee",
+	ChainExpression: "expression",
+	MemberExpression: "object"
+};
+function chainRootName(node) {
+	let current = node;
+	while (current !== void 0) {
+		if (current.type === "Identifier") return stringField(current, "name") ?? "";
+		const link = CHAIN_LINKS[current.type];
+		if (link === void 0) return;
+		current = child(current, link);
+	}
+}
+function specificationMember(callNode) {
+	const callee = child(callNode, "callee");
+	if (callee?.type !== "MemberExpression") return;
+	const object = child(callee, "object");
+	if (object?.type !== "Identifier" || object.name !== "specification") return;
+	return memberPropertyName(callee);
+}
+/** Only an object, among the nodes read here, lists properties. */
+function findProperty(objectNode, name) {
+	return childList(objectNode, "properties").find((property) => propertyKeyName(property) === name);
+}
+function propertyKeyName(property) {
+	if (property.type !== "Property" || property.computed === true) return;
+	const key = child(property, "key");
+	if (key?.type === "Identifier") return stringField(key, "name") ?? "";
+	if (key?.type === "Literal") return String(key.value);
+}
+function walk(root, visit) {
+	visit(root);
+	for (const key of Object.keys(root)) {
+		if (key === "parent") continue;
+		const value = root[key];
+		if (Array.isArray(value)) {
+			for (const item of value) if (isNode(item)) walk(item, visit);
+		} else if (isNode(value)) walk(value, visit);
+	}
+}
+function nodeStart(node) {
+	return typeof node?.start === "number" ? node.start : -1;
+}
+function isNode(value) {
+	return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
+}
+function child(node, key) {
+	const value = node?.[key];
+	return isNode(value) ? value : void 0;
+}
+function childList(node, key) {
+	const value = node?.[key];
+	return Array.isArray(value) ? value.filter((item) => isNode(item)) : [];
+}
+function stringField(node, key) {
+	const value = node?.[key];
+	return typeof value === "string" ? value : void 0;
+}
+function identifierName(node) {
+	if (node?.type !== "Identifier") return;
+	const { name } = node;
+	return typeof name === "string" ? name : void 0;
+}
+function nodeEnd(node) {
+	return typeof node?.end === "number" ? node.end : -1;
+}
+/** `result.stdout`, `result.meta()`; `undefined` for a computed access: two subjects a rule cannot spell must never be equated. */
+function memberPath(node) {
+	if (node === void 0) return;
+	if (node.type === "Identifier") return identifierName(node);
+	if (node.type === "CallExpression") {
+		const callee = memberPath(child(node, "callee"));
+		return callee === void 0 || childList(node, "arguments").length > 0 ? void 0 : `${callee}()`;
+	}
+	if (node.type !== "MemberExpression") return;
+	const object = memberPath(child(node, "object"));
+	const property = memberPropertyName(node);
+	return object === void 0 || property === void 0 ? void 0 : `${object}.${property}`;
+}
+/** `new Date()` with an argument is pinned; its zero-argument form, `Date.now()`, `performance.now()`, `Math.random()` and `randomUUID()` answer differently on the next run. */
+function isSampledValue(node) {
+	if (node.type === "NewExpression") return identifierName(child(node, "callee")) === "Date" && childList(node, "arguments").length === 0;
+	if (node.type !== "CallExpression") return false;
+	const path = memberPath(child(node, "callee"));
+	if (path === void 0) return false;
+	return path === "Date.now" || path === "performance.now" || path === "Math.random" || path === "randomUUID" || path.endsWith(".randomUUID");
+}
+//#endregion
+//#region lint/kit/project/command-words.ts
+const COMMAND_WORD = /^[a-z][a-z0-9-]*$/u;
+/** Without the runner's declared list, the first word alone: a positional argument is never read as a subcommand. */
+function commandWords(line, commands) {
+	const words = line.trim().split(/\s+/u);
+	if (commands === void 0) {
+		const [first = ""] = words;
+		return COMMAND_WORD.test(first) ? [first] : [];
+	}
+	const named = [];
+	for (const word of words) {
+		if (!commands.includes(word)) break;
+		named.push(word);
+	}
+	return named;
+}
+const CLI_CONSTRUCTOR = /\bspecification\s*\.\s*cli\s*\(/u;
+function wordsOf(text, open) {
+	return argumentsOf$1(text.slice(open + 1, closingOf(text, open))).flatMap((entry) => {
+		const word = literalOf(entry);
+		return word === void 0 ? [] : [word];
+	});
+}
+function constantWords(text, name) {
+	const escaped = name.replaceAll("$", String.raw`\$`);
+	const pattern = String.raw`\bconst\s+${escaped}\s*(?::[^=]+)?=\s*\[`;
+	const binding = new RegExp(pattern, "u").exec(text);
+	return binding === null ? void 0 : wordsOf(text, binding.index + binding[0].length - 1);
+}
+/** Written as an array or bound to a `const` of the same file (`commands: COMMANDS`, `{ commands }`). */
+function declaredCommands(door) {
+	const text = blankComments(door);
+	const call = CLI_CONSTRUCTOR.exec(text);
+	if (call === null) return;
+	const open = call.index + call[0].length - 1;
+	const [, options = ""] = argumentsOf$1(text.slice(open + 1, closingOf(text, open)));
+	const list = /[{,\s]commands\s*:\s*\[/u.exec(options);
+	if (list !== null) return wordsOf(options, list.index + list[0].length - 1);
+	const named = /[{,\s]commands\s*:\s*(?<name>[A-Za-z_$][\w$]*)/u.exec(options)?.groups?.name ?? (/[{,\s]commands\s*(?=[,}])/u.test(options) ? "commands" : void 0);
+	return named === void 0 ? void 0 : constantWords(text, named);
+}
+//#endregion
+//#region lint/kit/project/spec-chains.ts
+const SUBJECT_SPECIFICATIONS = [
+	"api",
+	"cli",
+	"job",
+	"mobile",
+	"website"
+];
+function chainAt(text, handle, start) {
+	const calls = [];
+	let index = start + handle.length;
+	for (;;) {
+		const member = /^\s*\.\s*(?<name>[A-Za-z_$][\w$]*)\s*\(/u.exec(text.slice(index));
+		if (member === null) return {
+			calls,
+			end: index,
+			handle,
+			index: start
+		};
+		const { name = "" } = member.groups ?? {};
+		const open = index + member[0].length - 1;
+		const close = closingOf(text, open);
+		calls.push({
+			args: text.slice(open + 1, close),
+			name
+		});
+		index = close + 1;
+	}
+}
+const SPECIFICATION_DOOR = /import\s*\{(?<names>[^}]*)\}\s*from\s*['"](?<from>[^'"]*\.specification(?:\.[jt]s)?)['"]/gu;
+const VIEW = /const\s+(?<view>[A-Za-z_$][\w$]*)\s*=\s*(?<from>[A-Za-z_$][\w$]*)\s*\.\s*with\s*\(/gu;
+function importedDoors(text, wanted) {
+	const doors = /* @__PURE__ */ new Map();
+	for (const found of text.matchAll(SPECIFICATION_DOOR)) {
+		const { from = "", names = "" } = found.groups ?? {};
+		for (const name of names.split(",")) {
+			const [imported = "", local = imported] = name.trim().split(/\s+as\s+/u);
+			if (wanted(imported)) doors.set(local, from);
+		}
+	}
+	return doors;
+}
+function doorsWanted(text, wanted) {
+	const doors = importedDoors(text, wanted);
+	const views = [...text.matchAll(VIEW)];
+	for (let size = -1; size !== doors.size;) {
+		({size} = doors);
+		for (const found of views) {
+			const { from = "", view = "" } = found.groups ?? {};
+			const door = doors.get(from);
+			if (door !== void 0) doors.set(view, door);
+		}
+	}
+	return doors;
+}
+function handlesOf(text) {
+	return [...doorsWanted(text, (imported) => SUBJECT_SPECIFICATIONS.includes(imported)).keys()];
+}
+function chainsOf(text, handles) {
+	if (handles.length === 0) return [];
+	const pattern = new RegExp(String.raw`(?<![.\w$])(?:${handles.join("|")})(?=\s*\.)`, "gu");
+	return [...text.matchAll(pattern)].map((found) => chainAt(text, found[0], found.index));
+}
+function doorsOf(text, specification) {
+	return Object.fromEntries(doorsWanted(text, (imported) => imported === specification));
+}
+//#endregion
+//#region lint/kit/project/subject.ts
+const NO_READING = Object.freeze({
+	collections: [],
+	methodless: []
+});
+const LITERAL_SEGMENT = /^[a-z][a-z._-]*$/u;
+function segmentsOf(path) {
+	return (path.split(/[?#]/u)[0] ?? "").split("/").filter((segment) => segment !== "");
+}
+function isLiteral(segment) {
+	return LITERAL_SEGMENT.test(segment) && !segment.includes("\0");
+}
+/** Every segment that is a value (a hole, a number, an id, a symbol) is written `:id`. */
+function pathTemplate(path) {
+	return `/${segmentsOf(path).map((segment) => isLiteral(segment) ? segment : ":id").join("/")}`;
+}
+function isCollection(word, collections) {
+	return collections.includes(word) || word.endsWith("s") && !/(?:ss|us|is)$/u.test(word);
+}
+function actionOf(method, resource, item, collections) {
+	if (method === "GET") return !item && isCollection(resource, collections) ? "list" : "get";
+	if (method === "POST") return "create";
+	if (method === "PUT" || method === "PATCH") return "update";
+	return method.toLowerCase();
+}
+function followsACollection(segments, index, collections) {
+	return isCollection(segments[index - 1] ?? "", collections);
+}
+/** `btc` in `/indicators/btc/chart`. The last segment is read as the route's: after a collection it names a sub-route far more often than an item. */
+function ambiguousSegment(subject, reading = NO_READING) {
+	if (subject.specification !== "api" || subject.template === true) return;
+	const segments = segmentsOf(subject.path);
+	const { collections } = reading;
+	return segments.find((segment, index) => index < segments.length - 1 && isLiteral(segment) && followsACollection(segments, index, collections));
+}
+function routeFolder(method, path, collections) {
+	const segments = segmentsOf(pathTemplate(path));
+	const literals = segments.filter((segment) => segment !== ":id");
+	if (literals.length === 0) return;
+	if (method === "ALL" || literals.length > 1) return literals.join("/");
+	const [resource = ""] = literals;
+	return `${resource}/${actionOf(method, resource, segments.at(-1) === ":id", collections)}`;
+}
+function underBase(path, basePath) {
+	if (basePath === void 0) return path;
+	if (path === basePath) return "/";
+	return path.startsWith(`${basePath}/`) ? path.slice(basePath.length) : path;
+}
+/** Nothing for a subject with no standard name: the root route, a cli run with no command word, a page, a journey. */
+function subjectFolder(subject, reading = NO_READING) {
+	if (subject.specification === "api") {
+		const mounted = {
+			...subject,
+			path: underBase(subject.path, reading.basePath)
+		};
+		return ambiguousSegment(mounted, reading) === void 0 ? routeFolder(subject.method, mounted.path, reading.collections) : void 0;
+	}
+	if (subject.specification === "cli") return subject.command.length === 0 ? void 0 : subject.command.join("/");
+	return subject.specification === "job" ? subject.job : void 0;
+}
+/** `GET /events/:id`, `trigger digest`, ... */
+function subjectName(subject) {
+	if (subject.specification === "api") return `${subject.method} ${pathTemplate(subject.path)}`;
+	if (subject.specification === "cli") return subject.command.length === 0 ? "exec (no command)" : `exec ${subject.command.join(" ")}`;
+	if (subject.specification === "job") return `trigger ${subject.job}`;
+	return subject.specification === "mobile" ? `open ${subject.journey}` : `visit ${subject.page}`;
+}
+const HTTP_VERBS = {
+	delete: "DELETE",
+	get: "GET",
+	patch: "PATCH",
+	post: "POST",
+	put: "PUT"
+};
+const REQUEST_LINE = /^\s*(?<method>DELETE|GET|HEAD|OPTIONS|PATCH|POST|PUT)\s+(?<path>\S+)/u;
+const REQUEST_FILE = /^file\(\s*(?<quote>['"])(?<path>[^'"]*)\k<quote>\s*\)$/u;
+function requestLineOf(text) {
+	const { method = "", path = "/" } = REQUEST_LINE.exec(text)?.groups ?? {};
+	const verb = HTTP_VERBS[method.toLowerCase()];
+	return verb === void 0 ? [] : [{
+		specification: "api",
+		method: verb,
+		path,
+		template: true
+	}];
+}
+const pageOf = (first) => {
+	const literal = literalOf(first);
+	return literal?.startsWith("/") === true ? [{
+		specification: "website",
+		page: pathTemplate(literal)
+	}] : [];
+};
+const TERMINALS = {
+	exec: (first, _readRequest, commands) => {
+		const line = first?.startsWith("[") === true ? literalOf(argumentsOf$1(first.slice(1, -1)).at(-1)) : literalOf(first);
+		return line === void 0 ? [] : [{
+			command: commandWords(line, commands),
+			specification: "cli"
+		}];
+	},
+	fetch: pageOf,
+	open: (first) => [{
+		specification: "mobile",
+		journey: literalOf(first) ?? "(launch)"
+	}],
+	request: (first, readRequest) => {
+		const path = REQUEST_FILE.exec(first ?? "")?.groups?.path;
+		return path === void 0 ? [] : requestLineOf(readRequest(path) ?? "");
+	},
+	trigger: (first) => {
+		const job = literalOf(first);
+		return job === void 0 ? [] : [{
+			specification: "job",
+			job
+		}];
+	},
+	visit: pageOf
+};
+function routeOf(method, args) {
+	const path = literalOf(args[0]);
+	if (path?.startsWith("/") !== true) return [];
+	const options = args[method === "POST" || method === "PUT" ? 2 : 1] ?? "";
+	return [{
+		specification: "api",
+		method,
+		path,
+		template: /\/:[A-Za-z_$]/u.test(path) || /(?<![\w$])params(?![\w$])/u.test(options)
+	}];
+}
+function declaredMethod(subject, methodless) {
+	if (subject.specification !== "api") return subject;
+	const template = pathTemplate(subject.path);
+	return methodless.some((path) => pathTemplate(path) === template) ? {
+		...subject,
+		method: "ALL"
+	} : subject;
+}
+function subjectsOfChain(chain, readRequest = () => "", reading = NO_READING) {
+	const terminal = chain.calls.at(-1);
+	if (terminal === void 0) return [];
+	const args = argumentsOf$1(terminal.args);
+	const [first] = args;
+	const method = HTTP_VERBS[terminal.name];
+	return (method === void 0 ? TERMINALS[terminal.name]?.(first, readRequest, reading.commands?.[chain.handle]) ?? [] : routeOf(method, args)).map((subject) => declaredMethod(subject, reading.methodless));
+}
+function subjectsOf(source, readRequest, reading = NO_READING) {
+	const text = blankComments(source);
+	return chainsOf(text, handlesOf(text)).flatMap((chain) => subjectsOfChain(chain, readRequest, reading).map((subject) => ({
+		index: chain.index,
+		subject
+	})));
+}
+//#endregion
+//#region lint/kit/project/import-sources.ts
+function attributeText(node) {
+	return stringValue(node) ?? (node?.type === "Identifier" ? String(node.name) : void 0);
+}
+function isJsonImport(declaration) {
+	return childList(declaration, "attributes").some((attribute) => attributeText(child(attribute, "key")) === "type" && stringValue(child(attribute, "value")) === "json");
+}
+function importSourceVisitor(onSource) {
+	const fromSourceField = (node) => {
+		const source = child(node, "source");
+		const value = stringValue(source);
+		if (value !== void 0) onSource({
+			json: isJsonImport(node),
+			node: source ?? node,
+			source: value
+		});
+	};
+	return {
+		ExportAllDeclaration: fromSourceField,
+		ExportNamedDeclaration: fromSourceField,
+		ImportDeclaration: fromSourceField,
+		ImportExpression: fromSourceField
+	};
+}
+//#endregion
+//#region lint/kit/project/path-references.ts
+const FS_READ = /^(?:createReadStream|opendir(?:Sync)?|read\w*)$/u;
+const RELATIVE = /^\.\.?\//u;
+const PATH_BUILDERS = /* @__PURE__ */ new Set(["join", "resolve"]);
+const COMMONJS_ANCHORS = ["__dirname", "__filename"];
+function isMetaMember(node, name) {
+	return child(node, "object")?.type === "MetaProperty" && memberPropertyName(node) === name;
+}
+function isOwnDirectory(node) {
+	return identifierName(node) === "__dirname" || isMetaMember(node, "dirname");
+}
+function calleeName(node) {
+	const callee = child(node, "callee");
+	return identifierName(callee) ?? memberPropertyName(callee);
+}
+function argumentsOf(node) {
+	return childList(node, "arguments");
+}
+function literalArguments(node) {
+	return argumentsOf(node).map((target) => {
+		const literal = stringValue(target);
+		return literal === void 0 ? void 0 : {
+			literal,
+			target
+		};
+	});
+}
+function isAnchor(node, anchors) {
+	if (node === void 0) return false;
+	let found = false;
+	walk(node, (inner) => {
+		found ||= inner.type === "MetaProperty" || anchors.has(identifierName(inner));
+	});
+	return found;
+}
+function anchorsOf(program) {
+	const anchors = new Set(COMMONJS_ANCHORS);
+	for (const statement of childList(program, "body")) {
+		const declaration = statement.type === "ExportNamedDeclaration" ? child(statement, "declaration") : statement;
+		for (const declarator of childList(declaration, "declarations")) {
+			const name = identifierName(child(declarator, "id"));
+			if (name !== void 0 && isAnchor(child(declarator, "init"), anchors)) anchors.add(name);
+		}
+	}
+	return anchors;
+}
+function literalTail(pieces) {
+	const tail = [];
+	for (const piece of pieces) {
+		const value = stringValue(piece);
+		if (value === void 0) break;
+		tail.push(value);
+	}
+	return tail;
+}
+function builtPath(node, here, anchors) {
+	const [first, ...rest] = argumentsOf(node);
+	const tail = literalTail(rest);
+	if (!PATH_BUILDERS.has(calleeName(node)) || !isAnchor(first, anchors) || tail.length === 0) return;
+	return resolve(here, ...tail);
+}
+function templatePath(node, here, anchors) {
+	const [hole] = childList(node, "expressions");
+	const [head, tail] = childList(node, "quasis").map(cookedText);
+	if (!isAnchor(hole, anchors) || head !== "" || tail?.startsWith("/") !== true) return;
+	return resolve(here, `.${tail}`);
+}
+function urlLiteral(node) {
+	const [first] = literalArguments(node);
+	const [, base] = argumentsOf(node);
+	return identifierName(child(node, "callee")) === "URL" && isMetaMember(base, "url") ? first : void 0;
+}
+/** Its `Program` handler reads the module's anchors first, so it must see the program before any node inside it. */
+function pathReferenceVisitor(file, onPath) {
+	const here = () => dirname(file());
+	let anchors = /* @__PURE__ */ new Set();
+	const report = (node, path) => {
+		if (path !== void 0) onPath({
+			node,
+			path
+		});
+	};
+	return {
+		CallExpression(node) {
+			const place = here();
+			report(node, builtPath(node, place, anchors));
+			const [first] = literalArguments(node);
+			if (first !== void 0 && FS_READ.test(calleeName(node) ?? "") && RELATIVE.test(first.literal)) onPath({
+				node: first.target,
+				path: resolve(projectRootOf(place) ?? place, first.literal)
+			});
+		},
+		NewExpression(node) {
+			const url = urlLiteral(node);
+			if (url !== void 0) onPath({
+				node: url.target,
+				path: resolve(here(), url.literal)
+			});
+		},
+		Program(node) {
+			anchors = anchorsOf(node);
+		},
+		TemplateLiteral(node) {
+			report(node, templatePath(node, here(), anchors));
+		}
+	};
+}
+/** A piece that is not a literal leaves the call out. */
+function literalPathVisitor(onPath) {
+	return {
+		CallExpression(node) {
+			if (!PATH_BUILDERS.has(calleeName(node))) return;
+			const [anchor, ...rest] = argumentsOf(node);
+			const pieces = literalTail(rest);
+			const [head] = rest;
+			if (isOwnDirectory(anchor) && head !== void 0 && pieces.length === rest.length) onPath({
+				node: head,
+				pieces
+			});
+		},
+		NewExpression(node) {
+			const url = urlLiteral(node);
+			if (url !== void 0) onPath({
+				node: url.target,
+				pieces: [url.literal]
+			});
+		}
+	};
+}
+function mergeVisitors(...fragments) {
+	const merged = {};
+	for (const fragment of fragments) for (const [type, handler] of Object.entries(fragment)) {
+		const before = merged[type];
+		merged[type] = before === void 0 ? handler : (node) => {
+			before(node);
+			handler(node);
+		};
+	}
+	return merged;
+}
+function visitProgram(program, visitor) {
+	walk(program, (node) => {
+		visitor[node.type]?.(node);
+	});
+}
+//#endregion
+//#region lint/kit/project/module-parser.ts
+let parse;
+function parsedModule(filename, source) {
+	if (parse === void 0) parse = createRequire(import.meta.url)("oxc-parser").parseSync;
+	return parse(filename, source);
+}
+function parseProgram(filename, source) {
+	const { errors, program } = parsedModule(filename, source);
+	return errors.length === 0 ? program : void 0;
+}
+//#endregion
+//#region lint/kit/project/specifiers.ts
+const EXTENSIONS = [
+	".ts",
+	".tsx",
+	".mts",
+	".cts",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs",
+	".json"
+];
+const COMPILED = {
+	".cjs": [".cts"],
+	".js": [".ts", ".tsx"],
+	".jsx": [".tsx"],
+	".mjs": [".mts"]
+};
+function onDisk(path) {
+	if (isFile(path)) return path;
+	const extension = /\.[cm]?jsx?$/u.exec(path)?.[0] ?? "";
+	return [
+		...(COMPILED[extension] ?? []).map((swap) => path.slice(0, -extension.length) + swap),
+		...EXTENSIONS.map((added) => path + added),
+		...EXTENSIONS.map((added) => join(path, `index${added}`))
+	].find((candidate) => isFile(candidate)) ?? path;
+}
+function readJsonc(path) {
+	const text = readFileCached(path);
+	if (text === null) return;
+	return parsedJson(blankComments(text).replaceAll(/,(?=\s*[\]}])/gu, ""), null);
+}
+function recordOf(value) {
+	return isRecord(value) ? value : void 0;
+}
+function targetsOf(value) {
+	if (typeof value === "string") return [value];
+	if (Array.isArray(value)) return value.flatMap((entry) => targetsOf(entry));
+	return Object.values(recordOf(value) ?? {}).flatMap((entry) => targetsOf(entry));
+}
+function substitution(key, specifier) {
+	const star = key.indexOf("*");
+	if (star === -1) return key === specifier ? "" : void 0;
+	const head = key.slice(0, star);
+	const tail = key.slice(star + 1);
+	return specifier.startsWith(head) && specifier.endsWith(tail) && specifier.length >= head.length + tail.length ? specifier.slice(head.length, specifier.length - tail.length) : void 0;
+}
+function mapped(map, specifier, base) {
+	for (const [key, value] of Object.entries(map)) {
+		const star = substitution(key, specifier);
+		if (star !== void 0) return targetsOf(value).map((target) => resolve(base, target.replace("*", star)));
+	}
+	return [];
+}
+function tsconfigOf(directory) {
+	const root = projectRootOf(directory);
+	let current = directory;
+	for (;;) {
+		const candidate = join(current, "tsconfig.json");
+		if (isFile(candidate)) return candidate;
+		const parent = dirname(current);
+		if (current === root || parent === current) return;
+		current = parent;
+	}
+}
+function configCandidates(base) {
+	return [
+		base,
+		`${base}.json`,
+		join(base, "tsconfig.json")
+	];
+}
+function extendedConfig(from, entry) {
+	const directory = dirname(from);
+	if (entry.startsWith(".") || entry.startsWith("/")) return configCandidates(resolve(directory, entry)).find((path) => isFile(path));
+	for (let current = directory;; current = dirname(current)) {
+		const found = configCandidates(join(current, "node_modules", entry)).find((path) => isFile(path));
+		if (found !== void 0 || dirname(current) === current) return found;
+	}
+}
+function resolutionOf(tsconfig, seen) {
+	if (seen.has(tsconfig)) return {};
+	seen.add(tsconfig);
+	const config = recordOf(readJsonc(tsconfig));
+	const bases = targetsOf(config?.extends);
+	const resolution = {};
+	for (const entry of bases) {
+		const base = extendedConfig(tsconfig, entry);
+		if (base !== void 0) Object.assign(resolution, resolutionOf(base, seen));
+	}
+	const options = recordOf(config?.compilerOptions);
+	const directory = dirname(tsconfig);
+	if (typeof options?.baseUrl === "string") resolution.baseUrl = resolve(directory, options.baseUrl);
+	const paths = recordOf(options?.paths);
+	if (paths !== void 0) resolution.paths = {
+		base: directory,
+		paths
+	};
+	return resolution;
+}
+function throughPaths(directory, specifier) {
+	const tsconfig = tsconfigOf(directory);
+	if (tsconfig === void 0) return [];
+	const { baseUrl, paths } = resolutionOf(tsconfig, /* @__PURE__ */ new Set());
+	if (paths === void 0) return [];
+	return mapped(paths.paths, specifier, baseUrl ?? paths.base);
+}
+function throughImports(directory, specifier) {
+	const root = packageRootOf(directory);
+	if (root === void 0) return [];
+	const imports = recordOf(recordOf(readJsonc(join(root, "package.json")))?.imports);
+	return imports === void 0 ? [] : mapped(imports, specifier, root);
+}
+function resolveSpecifier(from, specifier) {
+	const directory = dirname(from);
+	if (specifier === "." || specifier === ".." || /^\.\.?\//u.test(specifier)) return [onDisk(resolve(directory, specifier))];
+	if (specifier.startsWith("/") || specifier.startsWith("node:")) return [];
+	return (specifier.startsWith("#") ? throughImports(directory, specifier) : throughPaths(directory, specifier)).map((target) => onDisk(target));
+}
+//#endregion
+//#region lint/kit/project/tree.ts
+function isPool(dir) {
+	return isGroundFolder(basename(dir)) && basename(dirname(dir)) === "specs";
+}
+function specsRootOfPool(pool) {
+	return dirname(pool);
+}
+function isPruned(dir) {
+	return PRUNED.has(basename(dir)) || isGroundFolder(basename(dir));
+}
+function listFiles(dir, predicate) {
+	const out = [];
+	const visit = (current) => {
+		let entries;
+		try {
+			entries = treeEntries(current);
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			const path = join(current, entry.name);
+			if (entry.isDirectory()) {
+				if (!isPruned(path)) visit(path);
+			} else if (predicate(path)) out.push(path);
+		}
+	};
+	visit(dir);
+	return out;
+}
+function listDirs(dir) {
+	const out = [];
+	const visit = (current) => {
+		out.push(current);
+		let entries;
+		try {
+			entries = treeEntries(current);
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			const path = join(current, entry.name);
+			if (entry.isDirectory() && !isPruned(path)) visit(path);
+		}
+	};
+	visit(dir);
+	return out;
+}
+function findSpecsRoots(dir) {
+	const roots = [];
+	const visit = (current) => {
+		if (basename(current) === "specs") {
+			roots.push(current);
+			return;
+		}
+		let entries;
+		try {
+			entries = treeEntries(current);
+		} catch {
+			return;
+		}
+		for (const entry of entries) if (entry.isDirectory() && !PRUNED.has(entry.name)) visit(join(current, entry.name));
+	};
+	visit(dir);
+	return roots;
+}
+function findPools(dir) {
+	const pools = [];
+	const visit = (current) => {
+		let entries;
+		try {
+			entries = treeEntries(current);
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			if (!entry.isDirectory() || PRUNED.has(entry.name)) continue;
+			const path = join(current, entry.name);
+			if (isPool(path)) pools.push(path);
+			else if (!isGroundFolder(entry.name)) visit(path);
+		}
+	};
+	visit(dir);
+	return pools;
+}
+function readText(path) {
+	try {
+		return readFileSync(path, "utf8");
+	} catch {
+		return "";
+	}
+}
+function readSource(path) {
+	return blankComments(readText(path));
+}
+/** A document counts: a rendered unit's ARIA golden sits in the same `__expected__/` as a spec's. */
+function isReferrer(name) {
+	return isTestFileName(name) || name.endsWith(".spec.yaml");
+}
+function isDir(path) {
+	return treeKind(path) === "directory";
+}
+function columnAt(text, index) {
+	return index - text.lastIndexOf("\n", index - 1);
+}
+function lineAt(text, index) {
+	return text.slice(0, index).split("\n").length;
+}
+const DISK_CALL = /(?<![.\w])(?<kind>file|directory)\(\s*(?<quote>['"`])(?<path>(?:[^'"`\\]|\\.)*)\k<quote>/gu;
+/** A path that is no folder holds no tests and lists no children: it is none. */
+function isConventionalSubdir(path) {
+	if (listFiles(path, isTestFileName).length > 0) return false;
+	let children;
+	try {
+		children = treeEntries(path);
+	} catch {
+		return false;
+	}
+	return !children.some((child) => child.isDirectory() && isGroundFolder(child.name));
+}
+function listReaders(specsRoot) {
+	return listFiles(specsRoot, (path) => path.endsWith(".ts") || path.endsWith(".spec.yaml"));
+}
+function removeIfEmpty(folder) {
+	if (existsSync(folder) && readdirSync(folder).length === 0) rmSync(folder, { recursive: true });
+}
+function isWithin(directory, path) {
+	const rest = relative(directory, path);
+	return rest !== "" && !rest.startsWith("..") && !isAbsolute(rest);
+}
+function lowestCommonFolder(folders) {
+	const [first, ...others] = folders;
+	if (first === void 0) return;
+	let common = first;
+	while (!others.every((folder) => folder === common || isWithin(common, folder))) {
+		const parent = dirname(common);
+		if (parent === common) return;
+		common = parent;
+	}
+	return common;
+}
+function reservedFolderOf(owner, reserved) {
+	return join(owner, reserved);
+}
+function decodeText(path) {
+	let text;
+	try {
+		text = readFileSync(path, "utf8");
+	} catch {
+		return null;
+	}
+	return text.includes("\0") || text.includes("�") ? null : text;
+}
+//#endregion
+//#region lint/kit/project/specs-modules.ts
+const MODULE = /\.(?:[cm]?[jt]sx?)$/u;
+const TEST_OR_SPEC = /\.(?:test|test-d|spec)\.[cm]?[jt]sx?$/u;
+const RUNNER = /\.specification\.[cm]?[jt]sx?$/u;
+function isModuleName(name) {
+	return MODULE.test(name) && !name.endsWith(".d.ts");
+}
+function isTestOrSpecName(name) {
+	return TEST_OR_SPEC.test(name);
+}
+function isRunnerName(name) {
+	return RUNNER.test(name);
+}
+function modulesUnder(specsRoot) {
+	return listFiles(specsRoot, (path) => isModuleName(basename(path)));
+}
+function setupFolderOf(specsRoot, file) {
+	for (let folder = dirname(file); isWithin(specsRoot, folder); folder = dirname(folder)) if (basename(folder) === SETUP_FOLDER) return folder;
+}
+function placeOf(specsRoot, reader) {
+	const setup = setupFolderOf(specsRoot, reader);
+	return setup === void 0 ? dirname(reader) : dirname(setup);
+}
+function importsOf(file) {
+	const program = parseProgram(file, readText(file));
+	if (!isNode(program)) return [];
+	const imported = [];
+	visitProgram(program, importSourceVisitor(({ source }) => {
+		imported.push({
+			relative: isRelativePath(source),
+			targets: resolveSpecifier(file, source)
+		});
+	}));
+	return imported;
+}
+function importedModulesOf(file) {
+	return importsOf(file).flatMap(({ targets }) => targets);
+}
+function importsThroughAlias(file, module) {
+	return importsOf(file).some(({ relative, targets }) => !relative && targets.includes(module));
+}
+function readersOf(modules) {
+	const known = new Set(modules);
+	const readers = /* @__PURE__ */ new Map();
+	for (const file of modules) for (const target of new Set(importedModulesOf(file))) if (target !== file && known.has(target)) readers.set(target, [...readers.get(target) ?? [], file]);
+	return readers;
+}
+function lowestPlaceOf(specsRoot, readers) {
+	return lowestCommonFolder(readers.map((reader) => placeOf(specsRoot, reader)));
+}
+function declaresTests(name) {
+	return isTestOrSpecName(name) || name.endsWith(".spec.yaml");
+}
+function holdsASpec(folder) {
+	let entries;
+	try {
+		entries = treeEntries(folder);
+	} catch {
+		return false;
+	}
+	return entries.some((entry) => entry.isDirectory() ? !PRUNED.has(entry.name) && !isSpecialFolder(entry.name) && holdsASpec(join(folder, entry.name)) : declaresTests(entry.name));
+}
+/** The special folder a bare earlier spelling names (a `setup/` at the specs root or holding no spec), or `undefined`; a `_` name is refused before it is asked. */
+function renamedSpecialOf(specsRoot, folder) {
+	const renamed = RENAMED_FOLDERS[basename(folder)];
+	if (renamed === void 0) return;
+	return dirname(folder) === specsRoot || !holdsASpec(folder) ? renamed : void 0;
+}
+/** A bare `shared/` at the specs root or holding no spec: what specifications share sits at the specs root now; a `_` name is refused before it is asked. */
+function isRetiredShared(specsRoot, folder) {
+	return RETIRED_SHARED_FOLDERS.includes(basename(folder)) && (dirname(folder) === specsRoot || !holdsASpec(folder));
+}
+function isRefusedReserved(specsRoot, folder) {
+	const name = basename(folder);
+	return name.startsWith("_") && !isSpecialFolder(name) || renamedSpecialOf(specsRoot, folder) !== void 0 || isRetiredShared(specsRoot, folder);
+}
+function refusedReservedAbove(specsRoot, file) {
+	for (let folder = dirname(file); isWithin(specsRoot, folder); folder = dirname(folder)) if (isRefusedReserved(specsRoot, folder)) return folder;
+}
+//#endregion
+export { identifierName as $, removeIfEmpty as A, ambiguousSegment as B, lineAt as C, lowestCommonFolder as D, listReaders as E, literalPathVisitor as F, SUBJECT_SPECIFICATIONS as G, subjectFolder as H, mergeVisitors as I, chainRootName as J, doorsOf as K, pathReferenceVisitor as L, specsRootOfPool as M, resolveSpecifier as N, readSource as O, parseProgram as P, findProperty as Q, visitProgram as R, isWithin as S, listFiles as T, subjectName as U, pathTemplate as V, subjectsOf as W, childList as X, child as Y, cookedText as Z, findPools as _, roleOf as _t, isRunnerName as a, nodeStart as at, isDir as b, modulesUnder as c, stringField as ct, refusedReservedAbove as d, isNodeTestFileName as dt, isNode as et, renamedSpecialOf as f, isTestFileName as ft, decodeText as g, projectSegments as gt, columnAt as h, projectRootOf as ht, isRetiredShared as i, nodeEnd as it, reservedFolderOf as j, readText as k, placeOf as l, stringValue as lt, DISK_CALL as m, packageRootOf as mt, importsThroughAlias as n, memberPath as nt, isTestOrSpecName as o, propertyKeyName as ot, setupFolderOf as p, isTestRole as pt, declaredCommands as q, isModuleName as r, memberPropertyName as rt, lowestPlaceOf as s, specificationMember as st, declaresTests as t, isSampledValue as tt, readersOf as u, walk as ut, findSpecsRoots as v, specsAnchor as vt, listDirs as w, isReferrer as x, isConventionalSubdir as y, SETTINGS_FILE as yt, importSourceVisitor as z };
+
+//# sourceMappingURL=shared-specs-modules.js.map