@c9up/helix 0.1.7 → 0.1.9

package/bin/helix.js

@@ -38,7 +38,62 @@ const FLAG_SPEC = {
 	tsx: { kind: "boolean", help: "Use tsx loader for workers (default: true)" },
 	include: { kind: "string[]", help: "Glob patterns to include" },
 	exclude: { kind: "string[]", help: "Glob patterns to exclude" },
-	grep: { kind: "string", help: "Filter tests by name (not yet implemented)" },
+	grep: {
+		kind: "string",
+		help: "Only run tests whose full name matches (regex or substring)",
+	},
+	retries: { kind: "number", help: "Extra attempts on failure (default 0)" },
+	tags: {
+		kind: "string",
+		help: "Comma-separated tag filter (@fast, ~@slow to exclude); OR by default",
+	},
+	"match-all": {
+		kind: "boolean",
+		help: "Require ALL --tags instead of any (Japa parity)",
+	},
+	// Japa's parser accepts both spellings (`matchAll` with `match-all` as its
+	// alias), so both work here too.
+	matchAll: {
+		kind: "boolean",
+		help: "Alias of --match-all",
+	},
+	tests: {
+		kind: "string",
+		help: "Comma-separated exact test titles to run (Japa --tests)",
+	},
+	groups: {
+		kind: "string",
+		help: "Comma-separated exact group titles to run (Japa --groups)",
+	},
+	suite: {
+		kind: "string",
+		help: "Name of the suite these files belong to (Japa meta.suite)",
+	},
+	files: {
+		kind: "string",
+		help: "Comma-separated substrings matched against test file paths (Japa --files)",
+	},
+	reporters: {
+		kind: "string",
+		help: "Comma-separated reporters to activate, e.g. spec,json (Japa --reporters)",
+	},
+	bail: { kind: "boolean", help: "Stop at the first failure (Japa --bail)" },
+	"bail-layer": {
+		kind: "string",
+		help: "How far a bail reaches: group|suite|runner (Japa --bail-layer)",
+	},
+	failed: {
+		kind: "boolean",
+		help: "Re-run only the tests that failed last run (Japa --failed)",
+	},
+	"list-pinned": {
+		kind: "boolean",
+		help: "Print the tests marked .pin() and run nothing (Japa --list-pinned)",
+	},
+	"force-exit": {
+		kind: "boolean",
+		help: "process.exit() as soon as the run ends, without draining the event loop (Japa --force-exit)",
+	},
 	watch: { kind: "boolean", help: "Watch mode — re-run on file changes" },
 	"watch-debounce": {
 		kind: "number",
@@ -188,12 +243,50 @@ function findTsxLoader() {
 	return undefined;
 }
 
+/** Trailing `.test.ts` / `.spec.js` / … stripped, so `--files=user` matches `user.test.ts`. */
+const TEST_SUFFIX = /(\.(test|spec))?\.[cm]?[jt]sx?$/;
+
+/**
+ * Japa's `--files` rule: keep a file when its path ENDS WITH the filter, or
+ * when every segment of the filter (read right-to-left, `*` matching anything)
+ * matches the corresponding path segment of the file minus its test suffix.
+ * `--files=user` keeps `tests/unit/user.test.ts`; `--files=unit/*` keeps
+ * everything under a `unit` directory.
+ */
+function filterByFileFilters(files, raw) {
+	if (raw === undefined) return files;
+	const filters = String(raw)
+		.split(",")
+		.map((f) => f.trim())
+		.filter((f) => f.length > 0);
+	if (filters.length === 0) return files;
+	return files.filter((file) => {
+		const unix = file.split(path.sep).join("/");
+		const withoutSuffix = unix.replace(TEST_SUFFIX, "");
+		return filters.some((filter) => {
+			if (unix.endsWith(filter)) return true;
+			const filterSegments = filter.split("/").reverse();
+			const fileSegments = withoutSuffix.split("/").reverse();
+			return filterSegments.every(
+				(segment, i) =>
+					fileSegments[i] !== undefined &&
+					(segment === "*" || fileSegments[i].endsWith(segment)),
+			);
+		});
+	});
+}
+
 function printHelp() {
 	const lines = [
 		"helix — Vitest-compatible test runner",
 		"",
 		"Usage:",
-		"  helix test [files...|dirs...]",
+		"  helix test [files...|dirs...|suites...]",
+		"",
+		"  Positionals name test files or directories. When every one of them",
+		"  matches a suite declared in helix.config.*, they name SUITES instead",
+		"  (AdonisJS `node ace test unit functional`). With no positional and a",
+		"  config present, every suite runs, in order.",
 		"",
 		"Flags:",
 	];
@@ -290,15 +383,66 @@ async function main() {
 	).href;
 	try {
 		// Probe by resolving through dynamic import; Node throws synchronously.
-		const { run } = await import(runModule);
+		const { run, runSuites } = await import(runModule);
 		const discoverModule = pathToFileURL(
 			useDist
 				? path.resolve(here, "../dist/cli/discover.js")
 				: path.resolve(here, "../src/cli/discover.ts"),
 		).href;
 		const { discover } = await import(discoverModule);
+		const suitesModule = pathToFileURL(
+			useDist
+				? path.resolve(here, "../dist/cli/suites.js")
+				: path.resolve(here, "../src/cli/suites.ts"),
+		).href;
+		const {
+			loadHelixConfig,
+			resolveHelixConfig,
+			resolveSuiteFiles,
+			selectSuites,
+		} = await import(suitesModule);
+
+		// AdonisJS parity: positionals may name SUITES declared in
+		// `helix.config.*` (`helix test unit`). When they don't — or there is no
+		// config — they stay what they have always been: paths.
+		const helixConfig = await loadHelixConfig(process.cwd());
+		const selectedSuites = selectSuites(helixConfig, parsed.positional);
+
+		// AdonisJS `tests/bootstrap.ts`: resolved once here, imported by every
+		// worker before its test file. Forwarded through the env so it reaches
+		// the worker under BOTH orchestrators.
+		const bootstrapModule = pathToFileURL(
+			useDist
+				? path.resolve(here, "../dist/runtime/bootstrap.js")
+				: path.resolve(here, "../src/runtime/bootstrap.ts"),
+		).href;
+		const { resolveBootstrap } = await import(bootstrapModule);
+		const { runGlobalHooks } = await import(
+			pathToFileURL(
+				useDist
+					? path.resolve(here, "../dist/runtime/global-hooks.js")
+					: path.resolve(here, "../src/runtime/global-hooks.ts"),
+			).href
+		);
+		process.env.HELIX_BOOTSTRAP =
+			resolveBootstrap(process.cwd(), helixConfig.bootstrap) ?? "";
+		// A `suites[].configure` callback lives in the config module; the worker
+		// re-imports it by path, since the function itself cannot be forwarded.
+		// Only named when a suite actually declares one, so a project without any
+		// pays nothing.
+		const declaresConfigure = (helixConfig.suites ?? []).some(
+			(suite) => typeof suite.configure === "function",
+		);
+		process.env.HELIX_SUITE_CONFIG = declaresConfigure
+			? (resolveHelixConfig(process.cwd()) ?? "")
+			: "";
 
-		const expanded = await expandPositionals(parsed.positional, discover);
+		const expanded = selectedSuites
+			? []
+			: filterByFileFilters(
+					await expandPositionals(parsed.positional, discover),
+					parsed.flags.files,
+				);
 		const tsxLoader = findTsxLoader();
 		if (parsed.flags.tsx !== false && !tsxLoader) {
 			process.stderr.write(
@@ -340,17 +484,41 @@ async function main() {
 			root: process.cwd(),
 			files: expanded,
 			threads: parsed.flags.threads,
-			timeoutMs: parsed.flags.timeout,
+			timeoutMs: parsed.flags.timeout ?? helixConfig.timeout,
 			reporter: parsed.flags.reporter,
+			reporters: parsed.flags.reporters
+				? String(parsed.flags.reporters)
+						.split(",")
+						.map((r) => r.trim())
+						.filter((r) => r.length > 0)
+				: undefined,
+			bail: parsed.flags.bail === true,
+			listPinned: parsed.flags["list-pinned"] === true,
+			failed: parsed.flags.failed === true,
 			useColors: parsed.flags.colors,
 			discovery: {
 				suffixes: parsed.flags.include,
 				hardExcludes: parsed.flags.exclude,
 			},
-			nodeArgs:
-				parsed.flags.tsx === false || !tsxLoader
-					? undefined
-					: ["--import", tsxLoader],
+			// `japaPlugins` points `@japa/runner/core` at helix's shim in every
+			// worker, so an official Japa plugin instruments helix. Appended to
+			// the loader list rather than replacing it: the test files still need
+			// their TS loader.
+			nodeArgs: [
+				...(parsed.flags.tsx === false || !tsxLoader
+					? []
+					: ["--import", tsxLoader]),
+				...(helixConfig.japaPlugins === true
+					? [
+							"--import",
+							pathToFileURL(
+								useDist
+									? path.resolve(here, "../dist/japa/japa-alias.mjs")
+									: path.resolve(here, "../src/japa/japa-alias.mjs"),
+							).href,
+						]
+					: []),
+			],
 			coverage: parsed.flags.coverage
 				? {
 						enabled: true,
@@ -373,8 +541,140 @@ async function main() {
 					}
 				: undefined,
 		};
-		const outcome = await run(cfg);
-		return outcome.exitCode;
+		// Per-test runtime filters travel to workers via env so they survive
+		// BOTH the TS pool and the Rust native orchestrator (child processes
+		// inherit this process's env; see runtime/worker.ts).
+		if (parsed.flags.grep !== undefined) {
+			process.env.HELIX_GREP = String(parsed.flags.grep);
+		}
+		if (parsed.flags.retries !== undefined) {
+			process.env.HELIX_RETRIES = String(parsed.flags.retries);
+		}
+		// Not used to resolve the timeout (the orchestrator carries it in the
+		// run instruction) — exported so a plugin can read it off `api.cliArgs`.
+		if (parsed.flags.timeout !== undefined) {
+			process.env.HELIX_TIMEOUT = String(parsed.flags.timeout);
+		}
+		if (parsed.flags.tags !== undefined) {
+			process.env.HELIX_TAGS = String(parsed.flags.tags);
+		}
+		if (parsed.flags["match-all"] === true || parsed.flags.matchAll === true) {
+			process.env.HELIX_MATCH_ALL = "1";
+		}
+		if (parsed.flags.tests !== undefined) {
+			process.env.HELIX_TESTS = String(parsed.flags.tests);
+		}
+		if (parsed.flags.groups !== undefined) {
+			process.env.HELIX_GROUPS = String(parsed.flags.groups);
+		}
+		if (parsed.flags.suite !== undefined) {
+			process.env.HELIX_SUITE = String(parsed.flags.suite);
+		}
+		if (parsed.flags.files !== undefined) {
+			process.env.HELIX_FILES = String(parsed.flags.files);
+		}
+		if (parsed.flags.bail === true) {
+			process.env.HELIX_BAIL = "1";
+		}
+		// Flags a plugin reads off `api.cliArgs` but the runtime itself doesn't
+		// act on — forwarded for the same reason as the filters: Japa hands its
+		// plugins the whole flag set.
+		if (cfg.reporters !== undefined) {
+			process.env.HELIX_REPORTERS = cfg.reporters.join(",");
+		} else if (parsed.flags.reporter !== undefined) {
+			process.env.HELIX_REPORTERS = String(parsed.flags.reporter);
+		}
+		if (parsed.flags.failed === true) {
+			process.env.HELIX_FAILED = "1";
+		}
+		// `--force-exit`, or `forceExit` in the config (AdonisJS `tests.forceExit`).
+		// Read back by `finish()` below, and by a plugin off `api.cliArgs`.
+		if (parsed.flags["list-pinned"] === true) {
+			process.env.HELIX_LIST_PINNED = "1";
+		}
+		// Positionals reach a plugin as `api.cliArgs._`, like Japa's.
+		if (parsed.positional.length > 0) {
+			process.env.HELIX_POSITIONALS = parsed.positional.join(",");
+		}
+		if (parsed.flags["force-exit"] === true || helixConfig.forceExit === true) {
+			process.env.HELIX_FORCE_EXIT = "1";
+		}
+		if (parsed.flags["bail-layer"] !== undefined) {
+			process.env.HELIX_BAIL_LAYER = String(parsed.flags["bail-layer"]);
+		}
+		// `--failed` replays the previous run's failures as a `--tests` filter,
+		// exactly like Japa's retry plugin.
+		if (parsed.flags.failed === true) {
+			const failedModule = pathToFileURL(
+				useDist
+					? path.resolve(here, "../dist/cli/failed-cache.js")
+					: path.resolve(here, "../src/cli/failed-cache.ts"),
+			).href;
+			const { readFailedCache } = await import(failedModule);
+			const failedTests = await readFailedCache(process.cwd());
+			if (failedTests.length === 0) {
+				process.stdout.write(
+					"helix: no failing tests cached — running all of them\n",
+				);
+			} else {
+				process.env.HELIX_TESTS = failedTests.join(",");
+			}
+		}
+
+		// `runnerHooks` run ONCE around the whole run, here, and the workers are
+		// told to skip them — Japa's semantics, and the difference between
+		// migrating once and migrating once per test file.
+		const dropGlobalHooks = await runGlobalHooks(process.env.HELIX_BOOTSTRAP, {
+			japaPlugins: helixConfig.japaPlugins === true,
+		});
+
+		if (!selectedSuites) {
+			try {
+				const outcome = await run(cfg);
+				return outcome.exitCode;
+			} finally {
+				await dropGlobalHooks();
+			}
+		}
+
+		// Suites run one after another (Japa runs them in sequence too), each
+		// with its own files, timeout, retries and `meta.suite` name. The
+		// sequence is handed to the orchestrator as a whole so watch mode
+		// wraps ALL of it in one watcher and the `--failed` cache holds every
+		// suite's failures.
+		const steps = [];
+		for (const suite of selectedSuites) {
+			const suiteFiles = filterByFileFilters(
+				await resolveSuiteFiles(suite, process.cwd(), cfg.discovery),
+				parsed.flags.files,
+			);
+			if (suiteFiles.length === 0) {
+				process.stderr.write(`helix: suite "${suite.name}": no test files\n`);
+				continue;
+			}
+			// A suite's `retries` overrides `--retries` for that suite only. Set
+			// on EVERY step (empty = unset, see `envCount`) so a suite that
+			// declares none doesn't inherit the previous suite's value.
+			const retries = suite.retries ?? parsed.flags.retries;
+			const env = {
+				HELIX_SUITE: suite.name,
+				HELIX_RETRIES: retries === undefined ? "" : String(retries),
+			};
+			steps.push({
+				env,
+				config: {
+					...cfg,
+					files: suiteFiles,
+					timeoutMs: cfg.timeoutMs ?? suite.timeout,
+				},
+			});
+		}
+		try {
+			const outcome = await runSuites(steps, cfg);
+			return outcome.exitCode;
+		} finally {
+			await dropGlobalHooks();
+		}
 	} catch (err) {
 		// Re-exec under tsx when Node can't satisfy the TS-source imports
 		// natively. Two failure shapes seen in the wild:
@@ -424,9 +724,25 @@ async function main() {
 	}
 }
 
+/**
+ * Japa semantics: the process exits on its own once the event loop drains, so a
+ * resource a test left open surfaces as a hang you can diagnose — rather than
+ * being swallowed by an unconditional `process.exit`, which also truncates
+ * pending stdout writes. `--force-exit` is the escape hatch, exactly as in Japa.
+ */
+function finish(code) {
+	process.exitCode = code;
+	// The env var carries the config-declared `forceExit`; the argv check also
+	// covers a failure that happened before the config was ever read.
+	const forced =
+		process.env.HELIX_FORCE_EXIT === "1" ||
+		process.argv.includes("--force-exit");
+	if (forced) process.exit(code);
+}
+
 main()
-	.then((code) => process.exit(code))
+	.then(finish)
 	.catch((err) => {
 		process.stderr.write(`helix: ${err instanceof Error ? err.stack : err}\n`);
-		process.exit(2);
+		finish(2);
 	});

package/dist/cli/failed-cache.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The `--failed` cache — Japa's "run what failed last time".
+ *
+ * Japa writes the failed test TITLES to a cache file after every run, and
+ * `--failed` turns them into a `--tests` filter on the next one. Same contract
+ * here, same file shape (`{ tests: string[] }`), under
+ * `node_modules/.cache/helix/summary.json`.
+ *
+ * Named deviation: the cache is written only when the run produced per-test
+ * detail — i.e. the TypeScript pool. The native (Rust) engine reports totals
+ * only, so a run it owns leaves the previous cache untouched rather than
+ * blanking it. `--failed` therefore forces the TypeScript pool.
+ */
+import type { Summary } from "./summary.js";
+/** Titles of the tests that failed, in run order, without duplicates. */
+export declare function failedTestTitles(summary: Summary): string[];
+/**
+ * Persist the failed titles for a later `--failed`. Never throws: a run must
+ * not fail because its cache could not be written.
+ */
+export declare function writeFailedCache(root: string, summary: Summary): Promise<void>;
+/**
+ * The titles cached by the previous run, or an empty list when there is no
+ * usable cache (never run, unreadable, or malformed).
+ */
+export declare function readFailedCache(root: string): Promise<string[]>;
+//# sourceMappingURL=failed-cache.d.ts.map

package/dist/cli/failed-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"failed-cache.d.ts","sourceRoot":"","sources":["../../src/cli/failed-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAIH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAO5C,yEAAyE;AACzE,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,EAAE,CAQ3D;AAED;;;GAGG;AACH,wBAAsB,gBAAgB,CACrC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,OAAO,GACd,OAAO,CAAC,IAAI,CAAC,CAYf;AAED;;;GAGG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAWrE"}

package/dist/cli/failed-cache.js

@@ -0,0 +1,64 @@
+/**
+ * The `--failed` cache — Japa's "run what failed last time".
+ *
+ * Japa writes the failed test TITLES to a cache file after every run, and
+ * `--failed` turns them into a `--tests` filter on the next one. Same contract
+ * here, same file shape (`{ tests: string[] }`), under
+ * `node_modules/.cache/helix/summary.json`.
+ *
+ * Named deviation: the cache is written only when the run produced per-test
+ * detail — i.e. the TypeScript pool. The native (Rust) engine reports totals
+ * only, so a run it owns leaves the previous cache untouched rather than
+ * blanking it. `--failed` therefore forces the TypeScript pool.
+ */
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+/** Where the cache lives, relative to the project root. */
+function cacheFile(root) {
+    return path.join(root, "node_modules", ".cache", "helix", "summary.json");
+}
+/** Titles of the tests that failed, in run order, without duplicates. */
+export function failedTestTitles(summary) {
+    const titles = new Set();
+    for (const file of summary.files) {
+        for (const test of file.tests) {
+            if (test.status === "fail")
+                titles.add(test.name);
+        }
+    }
+    return [...titles];
+}
+/**
+ * Persist the failed titles for a later `--failed`. Never throws: a run must
+ * not fail because its cache could not be written.
+ */
+export async function writeFailedCache(root, summary) {
+    const file = cacheFile(root);
+    try {
+        await mkdir(path.dirname(file), { recursive: true });
+        await writeFile(file, JSON.stringify({ tests: failedTestTitles(summary) }), "utf8");
+    }
+    catch {
+        // Best-effort — a read-only or missing node_modules is not a run failure.
+    }
+}
+/**
+ * The titles cached by the previous run, or an empty list when there is no
+ * usable cache (never run, unreadable, or malformed).
+ */
+export async function readFailedCache(root) {
+    try {
+        const raw = await readFile(cacheFile(root), "utf8");
+        const parsed = JSON.parse(raw);
+        if (parsed === null || typeof parsed !== "object")
+            return [];
+        const tests = Reflect.get(parsed, "tests");
+        if (!Array.isArray(tests))
+            return [];
+        return tests.filter((t) => typeof t === "string");
+    }
+    catch {
+        return [];
+    }
+}
+//# sourceMappingURL=failed-cache.js.map

package/dist/cli/failed-cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"failed-cache.js","sourceRoot":"","sources":["../../src/cli/failed-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC9D,OAAO,IAAI,MAAM,WAAW,CAAC;AAG7B,2DAA2D;AAC3D,SAAS,SAAS,CAAC,IAAY;IAC9B,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,cAAc,EAAE,QAAQ,EAAE,OAAO,EAAE,cAAc,CAAC,CAAC;AAC3E,CAAC;AAED,yEAAyE;AACzE,MAAM,UAAU,gBAAgB,CAAC,OAAgB;IAChD,MAAM,MAAM,GAAG,IAAI,GAAG,EAAU,CAAC;IACjC,KAAK,MAAM,IAAI,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC;QAClC,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;YAC/B,IAAI,IAAI,CAAC,MAAM,KAAK,MAAM;gBAAE,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACnD,CAAC;IACF,CAAC;IACD,OAAO,CAAC,GAAG,MAAM,CAAC,CAAC;AACpB,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CACrC,IAAY,EACZ,OAAgB;IAEhB,MAAM,IAAI,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;IAC7B,IAAI,CAAC;QACJ,MAAM,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QACrD,MAAM,SAAS,CACd,IAAI,EACJ,IAAI,CAAC,SAAS,CAAC,EAAE,KAAK,EAAE,gBAAgB,CAAC,OAAO,CAAC,EAAE,CAAC,EACpD,MAAM,CACN,CAAC;IACH,CAAC;IAAC,MAAM,CAAC;QACR,0EAA0E;IAC3E,CAAC;AACF,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe,CAAC,IAAY;IACjD,IAAI,CAAC;QACJ,MAAM,GAAG,GAAG,MAAM,QAAQ,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,CAAC;QACpD,MAAM,MAAM,GAAY,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACxC,IAAI,MAAM,KAAK,IAAI,IAAI,OAAO,MAAM,KAAK,QAAQ;YAAE,OAAO,EAAE,CAAC;QAC7D,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAC3C,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;YAAE,OAAO,EAAE,CAAC;QACrC,OAAO,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAe,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC;IAChE,CAAC;IAAC,MAAM,CAAC;QACR,OAAO,EAAE,CAAC;IACX,CAAC;AACF,CAAC"}

package/dist/cli/glob.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Glob patterns for suite `files` entries.
+ *
+ * AdonisJS declares suites with real globs — its own defaults are
+ * `tests/unit/**​/*.spec.(js|ts)` — so an `adonisrc.ts` suite list has to be
+ * portable verbatim. Compiles to a `RegExp` over root-relative POSIX paths:
+ * `*`, `**`, `?`, `{a,b}`, `(a|b)`, `[abc]`, and the extglob quantifiers with an
+ * exact regex equivalent — `@(a|b)`, `?(a|b)`, `*(a|b)`, `+(a|b)`.
+ *
+ * An ENTRY may also start with `!` to exclude what it matches from the suite,
+ * the way a file list is usually written.
+ *
+ * One form stays refused: `!(a|b)`, the negated extglob GROUP. Its semantics
+ * ("anything in this segment other than a or b", composing with whatever
+ * follows) have no faithful regex rendering, and a near-miss would silently
+ * select the wrong files — the one thing a file selector must not do.
+ */
+/** Whether an entry is a pattern rather than a plain path. */
+export declare function isGlob(entry: string): boolean;
+/** Whether an entry excludes rather than selects (a leading `!`). */
+export declare function isNegated(entry: string): boolean;
+/** The pattern an entry carries, with any leading `!` stripped. */
+export declare function withoutNegation(entry: string): string;
+/** The reason an entry cannot be compiled, or `undefined` when it can. */
+export declare function globRejection(entry: string): string | undefined;
+/**
+ * The leading path that contains no pattern character — the directory a walk
+ * can start from. `tests/unit/**​/*.spec.ts` → `tests/unit`.
+ */
+export declare function globBaseDir(entry: string): string;
+/**
+ * Compile a glob to an anchored `RegExp`. Paths are matched with `/`
+ * separators, relative to the root the pattern was declared against.
+ */
+export declare function globToRegExp(entry: string): RegExp;
+//# sourceMappingURL=glob.d.ts.map

package/dist/cli/glob.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glob.d.ts","sourceRoot":"","sources":["../../src/cli/glob.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH,8DAA8D;AAC9D,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAE7C;AAKD,qEAAqE;AACrE,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEhD;AAED,mEAAmE;AACnE,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAErD;AAED,0EAA0E;AAC1E,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAK/D;AAeD;;;GAGG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAKjD;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAwElD"}