@jterrazz/test 16.1.1 → 17.0.0

package/dist/shared-appium.adapter.js

@@ -0,0 +1,428 @@
+import { n as refusal } from "./shared-refusal.js";
+import { t as pause } from "./shared-pause.js";
+import { u as evidenceDirectory } from "./shared-artifacts.js";
+import { n as SERVER_CALL_TIMEOUT_MS } from "./shared-session-ledger.js";
+import { c as scopeChain } from "./shared-landmarks.js";
+import { a as ambiguityError, c as asWrittenUnscoped, i as shortened, s as asWritten, t as scenarioFailure } from "./shared-scenario-failure.js";
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+//#region src/specifications/mobile/session/driver-session.ts
+const IDLE_SESSION_BUDGET_S = 300;
+const IOS_PREFIX = /^ios\s+/iu;
+function platformVersion(os) {
+	return os.replace(IOS_PREFIX, "");
+}
+async function loadWebdriverio() {
+	try {
+		const { attach: attachFn, remote: remoteFn } = await import("webdriverio");
+		return {
+			attach: attachFn,
+			remote: remoteFn
+		};
+	} catch {
+		throw new Error(refusal("seam-is-an-optional-peer", {
+			fix: "npm install -D appium webdriverio && npx appium driver install xcuitest",
+			found: ".open() requires `webdriverio`, and it is not installed"
+		}));
+	}
+}
+function headless() {
+	return process.env.TEST_MOBILE_HEADED !== "1";
+}
+function capabilitiesOf(request) {
+	const { name, os, udid } = request.device;
+	return {
+		"appium:automationName": "XCUITest",
+		"appium:bundleId": request.bundleId,
+		"appium:deviceName": name,
+		"appium:isHeadless": headless(),
+		"appium:newCommandTimeout": IDLE_SESSION_BUDGET_S,
+		"appium:noReset": true,
+		...os === void 0 ? {} : { "appium:platformVersion": platformVersion(os) },
+		...udid === void 0 ? {} : { "appium:udid": udid },
+		"appium:wdaLaunchTimeout": request.launchTimeoutMs,
+		platformName: "iOS"
+	};
+}
+async function succeeded(url, method) {
+	try {
+		const response = await fetch(url, {
+			method,
+			signal: AbortSignal.timeout(SERVER_CALL_TIMEOUT_MS)
+		});
+		await response.body?.cancel();
+		return response.ok;
+	} catch {
+		return false;
+	}
+}
+async function firstHeld(serverUrl, ledger, recorded) {
+	const [candidate, ...rest] = recorded;
+	if (candidate === void 0) return;
+	const session = `${serverUrl}/session/${candidate.sessionId}`;
+	if (await succeeded(`${session}/timeouts`, "GET")) return candidate;
+	await succeeded(session, "DELETE");
+	ledger.forget(candidate.sessionId);
+	return await firstHeld(serverUrl, ledger, rest);
+}
+/** Attached to the session the run recorded for this server and capabilities, or created and recorded; `shared` sessions are the run's to end. */
+async function openSession(request) {
+	const { ledger, serverUrl } = request;
+	const url = new URL(serverUrl);
+	const server = {
+		hostname: url.hostname,
+		logLevel: "error",
+		port: Number(url.port)
+	};
+	const capabilities = capabilitiesOf(request);
+	const webdriverio = request.webdriverio ?? await loadWebdriverio();
+	const held = ledger === void 0 ? void 0 : await firstHeld(serverUrl, ledger, ledger.lookup(serverUrl, capabilities));
+	if (held !== void 0) return {
+		driver: await webdriverio.attach({
+			...server,
+			capabilities: held.capabilities,
+			sessionId: held.sessionId
+		}),
+		shared: true
+	};
+	const driver = await webdriverio.remote({
+		...server,
+		capabilities
+	});
+	ledger?.record(capabilities, {
+		capabilities: { ...driver.capabilities },
+		serverUrl,
+		sessionId: driver.sessionId
+	});
+	return {
+		driver,
+		shared: ledger !== void 0
+	};
+}
+//#endregion
+//#region src/specifications/mobile/device/ambiguous.ts
+function formatMatch(match, index) {
+	const label = match.label === void 0 ? "" : ` ${JSON.stringify(match.label)}`;
+	const value = match.value === void 0 ? "" : `  value=${JSON.stringify(match.value)}`;
+	const identifier = match.identifier === void 0 ? "" : `  [testId: ${match.identifier}]`;
+	return `  ${index + 1}. ${match.type}${label}${value}${identifier}`;
+}
+function formatFixes(target, matches) {
+	const fixes = [];
+	if (!target.scope) fixes.push(`scope it       within(testId('...'), ${asWrittenUnscoped(target)}): a screen has no landmarks, and any target works as the scope`);
+	if (target.exact === false) {
+		const remaining = matches.filter((match) => match.label === target.name).length;
+		if (remaining > 0 && remaining < matches.length) fixes.push(`exact name     ${asWrittenUnscoped({
+			...target,
+			exact: true
+		})}   [leaves ${remaining} of ${matches.length}]`);
+	}
+	const identifiers = [...new Set(matches.map((match) => match.identifier).filter((identifier) => identifier !== void 0))];
+	if (identifiers.length > 1 && target.kind !== "testId") fixes.push(`test id        testId(${JSON.stringify(identifiers[0])})   [also here: ${identifiers.slice(1).join(", ")}]`);
+	fixes.push("other element  a button() or field() may name one thing where this does not");
+	return fixes;
+}
+function ambiguousScreenElementError(options) {
+	const { target, matches } = options;
+	return ambiguityError({
+		target,
+		fixes: formatFixes(target, matches),
+		lines: matches.map((match, index) => formatMatch(match, index)),
+		where: "the screen"
+	});
+}
+//#endregion
+//#region src/specifications/mobile/device/projection.ts
+const TAG_PATTERN = /<(?<openTag>[A-Za-z][\w.]*)(?<rawAttributes>(?:\s+[\w:.-]+="[^"]*")*)\s*(?<selfClosing>\/?)>|<\/[\w.]*\s*>/gu;
+const ATTRIBUTE_PATTERN = /(?<key>[\w:.-]+)="(?<value>[^"]*)"/gu;
+const NAMED_ENTITIES = {
+	"&amp;": "&",
+	"&apos;": "'",
+	"&gt;": ">",
+	"&lt;": "<",
+	"&quot;": "\""
+};
+function decodeEntities(value) {
+	return value.replaceAll(/&(?:#x(?<hex>[\dA-Fa-f]+)|#(?<decimal>\d+)|(?<named>amp|apos|gt|lt|quot));/gu, (entity, hex, decimal) => {
+		if (hex !== void 0) return String.fromCodePoint(Number.parseInt(hex, 16));
+		if (decimal !== void 0) return String.fromCodePoint(Number(decimal));
+		return NAMED_ENTITIES[entity] ?? entity;
+	});
+}
+function attributesOf(raw) {
+	return Object.fromEntries([...raw.matchAll(ATTRIBUTE_PATTERN)].map(([, key, value]) => [String(key), decodeEntities(String(value))]));
+}
+function parsePageSource(xml) {
+	const stack = [];
+	let root = null;
+	for (const match of xml.matchAll(TAG_PATTERN)) {
+		const { openTag, rawAttributes, selfClosing } = match.groups ?? {};
+		if (openTag === void 0) {
+			stack.pop();
+			continue;
+		}
+		const node = {
+			attributes: attributesOf(String(rawAttributes)),
+			children: [],
+			tag: openTag
+		};
+		const parent = stack.at(-1);
+		if (parent === void 0) root = node;
+		else parent.children.push(node);
+		if (selfClosing !== "/") stack.push(node);
+	}
+	if (!root) throw new Error(refusal({
+		fix: "restart the Appium server, or upgrade Appium and its XCUITest driver",
+		found: "the page source Appium answered holds no XML element",
+		read: "docs/guides/mobile-specs.md#requirements-what-the-machine-must-have",
+		why: "A screen is read from the XML page source Appium answers."
+	}));
+	return root;
+}
+const present = (attribute) => attribute === "" ? void 0 : attribute;
+function substance(node) {
+	const label = present(node.attributes.label);
+	const value = present(node.attributes.value);
+	const identifier = present(node.attributes.name);
+	return {
+		type: node.tag.replace(/^XCUIElementType/u, ""),
+		...label === void 0 ? {} : { label },
+		...value === void 0 || value === label ? {} : { value },
+		...identifier === void 0 || identifier === label ? {} : { identifier }
+	};
+}
+function hasSubstance(node) {
+	return node.label !== void 0 || node.value !== void 0 || node.identifier !== void 0;
+}
+function repeatsParent(child, parent) {
+	return child.children === void 0 && child.type === parent.type && child.label === parent.label && child.value === parent.value && child.identifier === parent.identifier;
+}
+function projectNode(node) {
+	const own = substance(node);
+	const children = node.children.flatMap((child) => projectNode(child)).filter((child) => !repeatsParent(child, own));
+	if (!hasSubstance(own)) return children;
+	return [{
+		...own,
+		...children.length > 0 ? { children } : {}
+	}];
+}
+function collectTexts(node, texts) {
+	if (node.attributes.visible === "true") {
+		const text = present(node.attributes.label) ?? present(node.attributes.value);
+		if (text !== void 0 && texts.at(-1) !== text) texts.push(text);
+	}
+	for (const child of node.children) collectTexts(child, texts);
+}
+function projectScreen(xml) {
+	let root = parsePageSource(xml);
+	const [onlyChild, ...others] = root.children;
+	if (root.tag === "AppiumAUT" && onlyChild !== void 0 && others.length === 0) root = onlyChild;
+	const texts = [];
+	for (const child of root.children) collectTexts(child, texts);
+	const own = substance(root);
+	const children = root.children.flatMap((child) => projectNode(child)).filter((child) => !repeatsParent(child, own));
+	return {
+		texts,
+		tree: {
+			...own,
+			...children.length > 0 ? { children } : {}
+		}
+	};
+}
+//#endregion
+//#region src/specifications/mobile/device/xcui-query.ts
+function escapePredicate(value) {
+	return value.replaceAll("\\", String.raw`\\`).replaceAll("'", String.raw`\'`);
+}
+const PREDICATES = {
+	button: ({ contains, visible }) => `type == 'XCUIElementTypeButton' AND ${contains("label")} AND ${visible}`,
+	field: ({ contains, visible }) => `type IN {'XCUIElementTypeTextField','XCUIElementTypeSecureTextField'} AND (${contains("label")} OR ${contains("value")}) AND ${visible}`,
+	testId: ({ name, visible }) => `name == '${name}' AND ${visible}`,
+	text: ({ contains, visible }) => `(${contains("label")} OR ${contains("value")}) AND ${visible}`
+};
+function isMobileKind(kind) {
+	return Object.hasOwn(PREDICATES, kind);
+}
+/** Landmarks have no XCUITest analog: the boundary is refused, not approximated. */
+function compilePredicate(target, options) {
+	if (!isMobileKind(target.kind)) throw new Error(refusal("no-landmark-on-mobile", {
+		fix: `scope with within(testId('...'), ...): any target works as the scope`,
+		found: `${asWritten(target)}, a landmark: an iOS screen has no '${target.kind}' region`
+	}));
+	const name = escapePredicate(target.name ?? "");
+	return PREDICATES[target.kind]({
+		contains: (attribute) => target.exact === false ? `${attribute} CONTAINS '${name}'` : `${attribute} == '${name}'`,
+		name,
+		visible: options?.anyVisibility === true ? "1 == 1" : "visible == 1"
+	});
+}
+/** `$$` answers a chainable typed as its array: the one await of it lives here. */
+async function matching(scope, target, options) {
+	return await scope.$$(`-ios predicate string:${compilePredicate(target, options)}`);
+}
+async function captureMatch(element) {
+	const [type, label, value, identifier] = await Promise.all([
+		element.getAttribute("type"),
+		element.getAttribute("label"),
+		element.getAttribute("value"),
+		element.getAttribute("name")
+	]);
+	const shortLabel = label === null || label === "" ? void 0 : shortened(label);
+	return {
+		type: (type ?? "Unknown").replace(/^XCUIElementType/u, ""),
+		...shortLabel === void 0 ? {} : { label: shortLabel },
+		...value === null || value === "" || value === label ? {} : { value },
+		...identifier === null || identifier === "" || identifier === label ? {} : { identifier }
+	};
+}
+async function captureMatches(matches) {
+	return await Promise.all([...matches].slice(0, 10).map(async (match) => await captureMatch(match)));
+}
+/** invariant: actionability includes scroll-into-view: the next pass re-resolves the element as visible. */
+async function scrollToOffscreen(driver, scope, level) {
+	const elementId = (await matching(scope, level, { anyVisibility: true }))[0]?.elementId;
+	if (elementId === void 0) return;
+	try {
+		await driver.executeScript("mobile: scrollToElement", [{ elementId }]);
+	} catch {}
+}
+const LABEL_WIDTH = 60;
+const labelShortened = (label) => label.length > LABEL_WIDTH ? `${label.slice(0, 57)}...` : label;
+/** The labels a page source shows, each at most 60 characters, for a timeout's evidence. */
+function onScreenLabels(source) {
+	return [...new Set([...source.matchAll(/label="(?<label>[^"]{2,})"/gu)].map(([, label]) => labelShortened(String(label))))].slice(0, 15);
+}
+//#endregion
+//#region src/specifications/mobile/device/appium.adapter.ts
+const DEFAULT_ACTION_TIMEOUT_MS = 3e4;
+const POLL_INTERVAL_MS = 500;
+const DEFAULT_WDA_LAUNCH_TIMEOUT_MS = 24e4;
+/** One driver session, opened lazily and reused: WebDriverAgent startup is the expensive part. Every `open()` relaunches the app. */
+var AppiumAdapter = class {
+	actionTimeoutMs;
+	opened = null;
+	launchTimeoutMs;
+	ledger;
+	options;
+	/** Injected by the unit test; production loads webdriverio lazily. */
+	webdriverio;
+	constructor(options) {
+		this.options = {
+			device: options.device,
+			serverUrl: options.serverUrl
+		};
+		this.ledger = options.ledger;
+		this.webdriverio = options.webdriverio;
+		this.actionTimeoutMs = options.timeouts?.action ?? DEFAULT_ACTION_TIMEOUT_MS;
+		this.launchTimeoutMs = options.timeouts?.launch ?? DEFAULT_WDA_LAUNCH_TIMEOUT_MS;
+	}
+	async close() {
+		if (this.opened?.shared === false) await this.opened.driver.deleteSession();
+		this.opened = null;
+	}
+	async open(options) {
+		const driver = await this.session(options.bundleId);
+		try {
+			await driver.executeScript("mobile: terminateApp", [{ bundleId: options.bundleId }]);
+		} catch {}
+		await (options.deepLink === void 0 ? driver.executeScript("mobile: activateApp", [{ bundleId: options.bundleId }]) : driver.executeScript("mobile: deepLink", [{
+			bundleId: options.bundleId,
+			url: options.deepLink
+		}]));
+		if (options.scenario) try {
+			await options.scenario(this.createVisitor(driver));
+		} catch (error) {
+			const evidence = await this.captureEvidence(driver);
+			throw scenarioFailure(error, evidence, "open");
+		}
+		return projectScreen(await driver.getPageSource());
+	}
+	/** `see()` acts on nothing, so any visible match satisfies it: XCUITest trees duplicate labels across container and child. */
+	createVisitor(driver) {
+		return {
+			fill: async (target, value) => {
+				await (await this.resolveOne(driver, target, "fill")).setValue(value);
+			},
+			see: async (target) => {
+				await this.resolveOne(driver, target, "see");
+			},
+			tap: async (target) => {
+				await (await this.resolveOne(driver, target, "tap")).click();
+			}
+		};
+	}
+	/** Scopes stay strict in both modes; the chain resolves outside-in, so an ambiguous scope names itself. */
+	async resolveOne(driver, target, verb) {
+		const chain = scopeChain(target);
+		const anyTarget = verb === "see";
+		const deadline = Date.now() + this.actionTimeoutMs;
+		let tryScroll = true;
+		for (;;) {
+			const resolved = await this.resolveChain(driver, chain, anyTarget, tryScroll);
+			tryScroll = false;
+			if (resolved) return resolved;
+			if (Date.now() > deadline) throw await this.timeoutError(driver, target, verb);
+			await pause(POLL_INTERVAL_MS);
+		}
+	}
+	async resolveChain(driver, chain, anyTarget, tryScroll) {
+		let scope = driver;
+		let element = null;
+		for (const [index, level] of chain.entries()) {
+			const matches = await matching(scope, level);
+			const first = matches[0];
+			if (first === void 0) {
+				if (tryScroll) await scrollToOffscreen(driver, scope, level);
+				return null;
+			}
+			const isTarget = index === chain.length - 1;
+			if (await matches.length > 1 && (!anyTarget || !isTarget)) throw ambiguousScreenElementError({
+				target: level,
+				matches: await captureMatches(matches)
+			});
+			scope = first;
+			element = first;
+		}
+		return element;
+	}
+	/** Screenshot the failing state into a temp file; never masks the original error. */
+	async captureEvidence(driver) {
+		try {
+			const dir = mkdtempSync(evidenceDirectory("mobile-"));
+			const path = resolve(dir, "failure.png");
+			writeFileSync(path, Buffer.from(await driver.takeScreenshot(), "base64"));
+			return path;
+		} catch {
+			return null;
+		}
+	}
+	async timeoutError(driver, target, verb) {
+		let excerpt = "";
+		try {
+			const labels = onScreenLabels(await driver.getPageSource());
+			if (labels.length > 0) excerpt = `\nCurrently on screen: ${labels.join(" | ")}`;
+			if (labels.length === 1) excerpt += "\nThe app is stalled on the splash: nothing but its launch screen is up.";
+		} catch {}
+		return new Error(refusal({
+			fix: "designate what this screen shows, or raise `timeouts.action` for a slow build",
+			found: `${verb}(${asWritten(target)}) timed out after ${this.actionTimeoutMs}ms: no visible match.${excerpt}`,
+			read: "docs/guides/mobile-specs.md#declared-timeouts",
+			why: "A mobile verb waits for one visible match, within the declared action budget."
+		}));
+	}
+	async session(bundleId) {
+		this.opened ??= await openSession({
+			bundleId,
+			device: this.options.device,
+			launchTimeoutMs: this.launchTimeoutMs,
+			ledger: this.ledger,
+			serverUrl: this.options.serverUrl,
+			webdriverio: this.webdriverio
+		});
+		return this.opened.driver;
+	}
+};
+//#endregion
+export { AppiumAdapter };
+
+//# sourceMappingURL=shared-appium.adapter.js.map

package/dist/shared-artifacts.js

@@ -0,0 +1,32 @@
+import { mkdirSync } from "node:fs";
+import { basename, join, resolve } from "node:path";
+import { tmpdir } from "node:os";
+//#region lint/kit/project/artifacts.ts
+/** Every path here is relative to the project root. */
+const ARTIFACTS_DIR = ".artifacts";
+const VITEST_ARTIFACTS_DIR = `${ARTIFACTS_DIR}/vitest`;
+const COVERAGE_DIR = `${VITEST_ARTIFACTS_DIR}/coverage`;
+const SQLITE_TEMPLATE_DIR = `${VITEST_ARTIFACTS_DIR}/sqlite`;
+/** Attachments and Browser Mode failure screenshots, which Vitest 5 would put in `.vitest/`. */
+const ATTACHMENTS_DIR = `${VITEST_ARTIFACTS_DIR}/attachments`;
+/** Under the project: the run's temp root is gone by the time the error naming the file is read. */
+const EVIDENCE_DIR = `${VITEST_ARTIFACTS_DIR}/evidence`;
+/** Filed under the run's temp root name, `<pid>-...`: the next run's start sweeps every run that is no longer alive. */
+function evidenceDirectory(prefix) {
+	const parent = resolve(EVIDENCE_DIR, basename(tmpdir()));
+	mkdirSync(parent, { recursive: true });
+	return join(parent, prefix);
+}
+const SCREENSHOTS_DIR = `${VITEST_ARTIFACTS_DIR}/screenshots`;
+const BLOB_DIR = `${VITEST_ARTIFACTS_DIR}/blob`;
+/** Vitest 5's file-writing reporters, each pinned under the artifacts folder. */
+const REPORTER_OUTPUT_FILES = {
+	blob: `${BLOB_DIR}/blob.json`,
+	html: `${VITEST_ARTIFACTS_DIR}/html/index.html`,
+	json: `${VITEST_ARTIFACTS_DIR}/json/output.json`,
+	junit: `${VITEST_ARTIFACTS_DIR}/junit/output.xml`
+};
+//#endregion
+export { EVIDENCE_DIR as a, SQLITE_TEMPLATE_DIR as c, COVERAGE_DIR as i, VITEST_ARTIFACTS_DIR as l, ATTACHMENTS_DIR as n, REPORTER_OUTPUT_FILES as o, BLOB_DIR as r, SCREENSHOTS_DIR as s, ARTIFACTS_DIR as t, evidenceDirectory as u };
+
+//# sourceMappingURL=shared-artifacts.js.map

package/dist/shared-chapter.js

@@ -0,0 +1,7 @@
+import "@jterrazz/typescript/rules";
+//#region lint/kit/catalogue/chapter.ts
+const CATALOGUE_CHAPTER = "docs/reference/linting.md";
+//#endregion
+export { CATALOGUE_CHAPTER as t };
+
+//# sourceMappingURL=shared-chapter.js.map

package/dist/shared-container.port.d.ts

@@ -0,0 +1,31 @@
+//#region src/services/containers/container.port.d.ts
+/** A running service container (database, cache, ...). */
+type ContainerPort = {
+  /** Start the container and wait until ready. */
+  start: () => Promise<void>;
+  /** Stop and remove the container. */
+  stop: () => Promise<void>;
+  /** Get the mapped host port for a container port. */
+  getMappedPort: (containerPort: number) => number;
+  /** Get the host to connect to. */
+  getHost: () => string;
+  /** Get a full connection string for this service. */
+  getConnectionString: () => string;
+  /** Get container logs (stdout + stderr): all of them, or those logged since a moment. */
+  getLogs: (since?: Date) => Promise<string>;
+};
+type ContainerRequest = ContainerOptions & {
+  image: string;
+  port: number;
+  env?: Record<string, string>;
+};
+/** How a service asks its container to run, beyond its image, port and environment. */
+type ContainerOptions = {
+  /** The command the image's entrypoint is handed, replacing its default. */
+  command?: string[];
+  /** Paths mounted as memory disks, each with its mount options. */
+  tmpfs?: Record<string, string>;
+};
+//#endregion
+export { ContainerPort as n, ContainerRequest as r, ContainerOptions as t };
+//# sourceMappingURL=shared-container.port.d.ts.map

package/dist/shared-derived-projects.js

@@ -0,0 +1,58 @@
+import { t as SPECIFICATIONS } from "./shared-specifications.js";
+import { TESTS_FOLDER } from "@jterrazz/typescript/rules";
+import { existsSync, readdirSync } from "node:fs";
+import { basename, join } from "node:path";
+//#region lint/kit/project/derived-projects.ts
+const SPECS = "specs";
+const UNIT = "unit";
+const FOLDERED = /* @__PURE__ */ new Set([...SPECIFICATIONS, "component"]);
+const IN_PROCESS = /* @__PURE__ */ new Set([
+	"api",
+	"integration",
+	"job"
+]);
+const SPECIFICATION_MODULE = ".specification.ts";
+const MODULE_TEST = /\.test\.ts$/u;
+const RENDERED_TEST = /\.test\.tsx$/u;
+const UNWALKED_NAME = /^(?:[._]|node_modules$|dist$)/u;
+const isUnwalked = (name) => name !== TESTS_FOLDER && UNWALKED_NAME.test(name);
+function holds(path, pattern) {
+	return readdirSync(path, { withFileTypes: true }).some((entry) => {
+		if (isUnwalked(entry.name)) return false;
+		return entry.isDirectory() ? holds(join(path, entry.name), pattern) : pattern.test(entry.name);
+	});
+}
+const foldersIn = (path) => existsSync(path) ? readdirSync(path, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !isUnwalked(entry.name)).map(({ name }) => name).toSorted() : [];
+function runnerOf(root, folder, specification) {
+	if (!IN_PROCESS.has(specification)) return {};
+	const modules = readdirSync(join(root, folder)).filter((name) => name.endsWith(SPECIFICATION_MODULE));
+	const own = `${specification}${SPECIFICATION_MODULE}`;
+	return modules.length === 1 && modules[0] === own ? { runner: `./${folder}/${own}` } : {};
+}
+const isSpecsMember = (root) => basename(root) === SPECS && existsSync(join(root, "package.json"));
+/** The projects a tree names, each with the options it derives: one per `specs/<specification>/` folder (an in-process one handed as its `runner` the folder's one specification module, `<specification>.specification.ts`), `unit` over each root holding a module test (`specs/unit/` is one root among them), `component` over each holding a rendered one. */
+function derivedProjects(root) {
+	const member = isSpecsMember(root);
+	const prefix = member ? "" : `${SPECS}/`;
+	const specs = foldersIn(member ? root : join(root, SPECS));
+	const named = specs.filter((folder) => FOLDERED.has(folder));
+	const roots = [...member ? [] : foldersIn(root).filter((folder) => folder !== SPECS), ...specs.filter((folder) => !named.includes(folder)).map((folder) => `${prefix}${folder}`)];
+	const holding = (pattern) => roots.filter((folder) => holds(join(root, folder), pattern));
+	const rendered = [...named.includes("component") ? [`${prefix}component/**/*.test.tsx`] : [], ...holding(RENDERED_TEST).map((folder) => `${folder}/**/*.test.tsx`)];
+	const unitRoots = holding(MODULE_TEST);
+	const projects = /* @__PURE__ */ new Map();
+	if (unitRoots.length > 0) projects.set(UNIT, { roots: unitRoots });
+	for (const specification of named) projects.set(specification, runnerOf(root, `${prefix}${specification}`, specification));
+	if (rendered.length > 0) projects.set("component", { include: rendered });
+	return projects;
+}
+/** The specification modules a tree holds, `specs/<specification>/<specification>.specification.ts`: documents bind one by name, and no import reaches it. */
+function specificationModules(root) {
+	const member = isSpecsMember(root);
+	const prefix = member ? "" : `${SPECS}/`;
+	return foldersIn(member ? root : join(root, SPECS)).filter((folder) => FOLDERED.has(folder)).map((folder) => `${prefix}${folder}/${folder}${SPECIFICATION_MODULE}`).filter((path) => existsSync(join(root, path)));
+}
+//#endregion
+export { specificationModules as n, derivedProjects as t };
+
+//# sourceMappingURL=shared-derived-projects.js.map