@williamthorsen/nmr 0.46.2 → 0.48.0

package/dist/esm/runCli.js

@@ -14,9 +14,12 @@ import { readFilterSelection } from "./helpers/filter-selection.js";
 import { findClosestName } from "./helpers/findClosestName.js";
 import { isHookName } from "./helpers/hook-name.js";
 import { resolvePackageJsonPath } from "./helpers/package-json.js";
+import { quoteForShell } from "./helpers/quoteForShell.js";
 import { composeTranscript } from "./helpers/transcript.js";
+import { acquireMachineLock, formatMisplacedNoLockWarning, HEAVY_COMMANDS, LOCK_TOKEN_ENV_VAR, NO_LOCK_ENV_VAR, } from "./machine-lock.js";
 import { isTerminalStream, OUTPUT_STYLE_ENV_VAR, OUTPUT_STYLE_FLAG, resolveOutputStyles } from "./output-style.js";
 import { renderRecording, renderRefusal, resolveRecording } from "./recording.js";
+import { createSnapshot, DELEGATE_ENV_VAR, DELEGATE_FLAG, DELEGATION_FAILURE_EXIT_CODE, formatMisplacedDelegationWarning, NO_DELEGATE_FLAG, resolveDelegationTarget, runRemotely, } from "./remote-run.js";
 import { assembleReplay } from "./replay-assembly.js";
 import { readReportFormatEnv, REPORT_FORMAT_ENV_VAR, resolveReportFormat } from "./report-format.js";
 import { applyDevBinToSteps, buildRootRegistry, buildWorkspaceRegistry, expandScript, findChainedSelfReference, readPackageJsonScripts, resolveScript, } from "./resolver.js";
@@ -37,6 +40,10 @@ export async function runCli(options) {
         return { exitCode: established.result.exitCode };
     }
     const invocation = established.value;
+    const delegated = await runOnDelegateHost(invocation);
+    if (delegated !== undefined) {
+        return delegated;
+    }
     const planned = await planRun(invocation);
     const { exitCode, isUnknownCommand = false } = planned.settled ? planned.result : await executePlan(planned.value);
     if (exitCode !== 0 && !isUnknownCommand && isTopLevelInvocation(options.env)) {
@@ -91,6 +98,7 @@ async function establishInvocation(options) {
             anchorDir,
             command: parsedArgs.command,
             context,
+            cwd,
             env,
             format,
             parsedArgs,
@@ -121,6 +129,7 @@ async function planRun(invocation) {
         env,
         format: invocation.format,
         shouldBypassCache,
+        shouldBypassLock: parsedArgs.shouldBypassLock,
         passthrough: parsedArgs.passthrough,
         runId,
         snapshot,
@@ -135,7 +144,15 @@ async function planRun(invocation) {
     };
     const delegation = composeDelegation({ childEnv, command, parsedArgs });
     if (delegation !== undefined) {
-        const result = await runDelegation({ context, delegation, parsedArgs, runOptions, stderr });
+        const lock = await takeMachineLock(invocation);
+        let result;
+        try {
+            const heldDelegation = { ...delegation, env: addLockEnv(delegation.env, lock) };
+            result = await runDelegation({ context, delegation: heldDelegation, parsedArgs, runOptions, stderr });
+        }
+        finally {
+            await lock?.release();
+        }
         return {
             settled: true,
             result: { ...result, isUnknownCommand: result.exitCode !== 0 && !isDefinedInAnyScope(command, context) },
@@ -243,6 +260,77 @@ async function executePlan(plan) {
     reportVerdict({ command, scope, ...outcome }, stdout, format, styles.stdout);
     return { exitCode };
 }
+async function runOnDelegateHost(invocation) {
+    const { command, context, cwd, env, format, parsedArgs, scope, stderr, stdout, styles } = invocation;
+    if (parsedArgs.passthrough.some(isDelegationFlag)) {
+        stderr.write(`${formatMisplacedDelegationWarning(command, styles.stderr)}
+`);
+    }
+    const target = resolveDelegationTarget({
+        command,
+        env,
+        flagHost: parsedArgs.delegateHost,
+        isOptedOut: parsedArgs.shouldRunLocally,
+        isReading: parsedArgs.shouldPrintLog,
+    });
+    if (target.kind === 'local') {
+        return undefined;
+    }
+    if (target.kind === 'refused') {
+        reportError(target.error, stderr);
+        return { exitCode: 1 };
+    }
+    const { host } = target;
+    const startedAtMs = Date.now();
+    const snapshot = createSnapshot(cwd, env);
+    if (!snapshot.ok && snapshot.isUnsupported) {
+        if (target.source === 'flag') {
+            reportError(`Cannot delegate to ${host}: ${snapshot.reason}`, stderr);
+            return { exitCode: 1 };
+        }
+        stderr.write(`nmr: running ${command} here rather than on ${host}: ${snapshot.reason}\n`);
+        return undefined;
+    }
+    const result = snapshot.ok
+        ? await runRemotely({
+            cwd,
+            env,
+            host,
+            monorepoRoot: context.monorepoRoot,
+            nmrArgs: composeForwardedArgs(command, parsedArgs),
+            remoteEnv: {
+                [COMMAND_VERBOSITY_ENV_VAR]: invocation.verbosity,
+                [OUTPUT_STYLE_ENV_VAR]: styles.stdout,
+                [REPORT_FORMAT_ENV_VAR]: format,
+            },
+            snapshot,
+            stderr,
+            stdout,
+        })
+        : { ok: false, message: 'could not snapshot the working tree', output: snapshot.reason };
+    const durationMs = Date.now() - startedAtMs;
+    if (!result.ok) {
+        if (result.output.trim() !== '') {
+            stderr.write(result.output.endsWith('\n') ? result.output : `${result.output}\n`);
+        }
+        const verdict = {
+            command,
+            detail: result.message,
+            durationMs,
+            exitCode: DELEGATION_FAILURE_EXIT_CODE,
+            host,
+            outcome: 'failed',
+            scope,
+        };
+        reportVerdict(verdict, stdout, format, styles.stdout);
+        return { exitCode: DELEGATION_FAILURE_EXIT_CODE };
+    }
+    const outcome = result.exitCode === 0
+        ? { outcome: 'passed', durationMs }
+        : { outcome: 'failed', durationMs, exitCode: result.exitCode };
+    reportVerdict({ command, host, scope, ...outcome }, stdout, format, styles.stdout);
+    return { exitCode: result.exitCode };
+}
 const FILTER_FLAGS = new Set(['-F', '--filter']);
 const BOOLEAN_FLAGS = new Map([
     ['-?', 'shouldShowHelp'],
@@ -250,6 +338,8 @@ const BOOLEAN_FLAGS = new Map([
     ['--json', 'shouldEmitJson'],
     ['--log', 'shouldPrintLog'],
     ['--no-cache', 'shouldBypassCache'],
+    [NO_DELEGATE_FLAG, 'shouldRunLocally'],
+    ['--no-lock', 'shouldBypassLock'],
     ['-q', 'quiet'],
     ['--quiet', 'quiet'],
     ['-R', 'recursive'],
@@ -260,18 +350,29 @@ const BOOLEAN_FLAGS = new Map([
     ['--workspace-root', 'isWorkspaceRoot'],
 ]);
 function buildChildEnv(options) {
-    const { env, format, passthrough, runId, shouldBypassCache, snapshot, styles, verbosity } = options;
+    const { env, format, passthrough, runId, shouldBypassCache, shouldBypassLock, snapshot, styles, verbosity } = options;
     const bypassesCache = shouldBypassCache || passthrough.length > 0;
+    const { [DELEGATE_ENV_VAR]: _delegateHost, ...inheritedEnv } = env;
     return {
-        ...env,
+        ...inheritedEnv,
         ...(snapshot !== undefined && { [TREE_SNAPSHOT_ENV_VAR]: encodeTreeSnapshot(snapshot) }),
         ...(bypassesCache && { [NO_CACHE_ENV_VAR]: '1' }),
+        ...(shouldBypassLock && { [NO_LOCK_ENV_VAR]: '1' }),
         [COMMAND_VERBOSITY_ENV_VAR]: verbosity,
         [OUTPUT_STYLE_ENV_VAR]: styles.stdout,
         [REPORT_FORMAT_ENV_VAR]: format,
         [RUN_ID_ENV_VAR]: runId,
     };
 }
+function addLockEnv(env, lock) {
+    if (lock?.token !== undefined) {
+        return { ...env, [LOCK_TOKEN_ENV_VAR]: lock.token };
+    }
+    if (lock?.isChainUnlocked === true) {
+        return { ...env, [NO_LOCK_ENV_VAR]: '1' };
+    }
+    return env;
+}
 function acceptsArguments(step) {
     return step.kind === 'opaque' || step.shouldDeclineArguments !== true;
 }
@@ -319,6 +420,19 @@ function composeDelegation(options) {
         },
     };
 }
+function composeForwardedArgs(command, parsedArgs) {
+    return [
+        ...(parsedArgs.filter === undefined ? [] : ['--filter', parsedArgs.filter]),
+        ...(parsedArgs.recursive ? ['--recursive'] : []),
+        ...(parsedArgs.isWorkspaceRoot ? ['--workspace-root'] : []),
+        ...(parsedArgs.quiet ? ['--quiet'] : []),
+        ...(parsedArgs.shouldEmitJson ? ['--json'] : []),
+        ...(parsedArgs.shouldBypassCache ? ['--no-cache'] : []),
+        ...(parsedArgs.shouldBypassLock ? ['--no-lock'] : []),
+        command,
+        ...parsedArgs.passthrough,
+    ];
+}
 async function composeRetention(options) {
     const { anchorDir, command, key, retainedOutput, runId } = options;
     if (retainedOutput !== undefined) {
@@ -638,8 +752,10 @@ function parseArgs(args) {
         quiet: false,
         recursive: false,
         shouldBypassCache: false,
+        shouldBypassLock: false,
         shouldEmitJson: false,
         shouldPrintLog: false,
+        shouldRunLocally: false,
         shouldShowHelp: false,
         shouldShowVersion: false,
         passthrough: [],
@@ -674,6 +790,15 @@ function parseArgs(args) {
             index += styleArgument.consumedCount;
             continue;
         }
+        const delegateArgument = readDelegateArgument(args, index);
+        if (delegateArgument !== undefined) {
+            if (!delegateArgument.ok) {
+                return delegateArgument;
+            }
+            parsedArgs.delegateHost = delegateArgument.value;
+            index += delegateArgument.consumedCount;
+            continue;
+        }
         parsedArgs.command = arg;
         parsedArgs.passthrough = args.slice(index + 1);
         break;
@@ -720,18 +845,24 @@ function readPresentation(options) {
     }
     return { ok: true, format: format.format, styles, verbosity: verbosity.verbosity };
 }
-function readOutputStyleArgument(args, index) {
+function readDelegateArgument(args, index) {
+    return readFlagValue(args, index, DELEGATE_FLAG, 'a host argument');
+}
+function readFlagValue(args, index, flag, requirement) {
     const arg = args[index] ?? '';
-    const assignment = arg.startsWith(`${OUTPUT_STYLE_FLAG}=`) ? arg.slice(OUTPUT_STYLE_FLAG.length + 1) : undefined;
-    if (arg !== OUTPUT_STYLE_FLAG && assignment === undefined) {
+    const assignment = arg.startsWith(`${flag}=`) ? arg.slice(flag.length + 1) : undefined;
+    if (arg !== flag && assignment === undefined) {
         return undefined;
     }
     const value = assignment ?? args[index + 1];
     if (!value) {
-        return { ok: false, error: `${OUTPUT_STYLE_FLAG} requires a value argument: auto, plain, or rich` };
+        return { ok: false, error: `${flag} requires ${requirement}` };
     }
     return { ok: true, value, consumedCount: assignment === undefined ? 2 : 1 };
 }
+function readOutputStyleArgument(args, index) {
+    return readFlagValue(args, index, OUTPUT_STYLE_FLAG, 'a value argument: auto, plain, or rich');
+}
 function readRunnableSteps(resolvedScript, workspacePackageDirs) {
     if (workspacePackageDirs.length > 0) {
         return { isEmptiedByWorkspace: false, steps: resolvedScript.steps };
@@ -764,6 +895,46 @@ function resolveReportingVerbosity(options) {
     const { format, ...ladder } = options;
     return format === 'json' ? 'quiet' : resolveVerbosity(ladder);
 }
+async function readGate(plan) {
+    const { key, snapshot } = plan;
+    const { context, env, stderr, stdout } = plan.invocation;
+    if (key === undefined || snapshot === undefined) {
+        return undefined;
+    }
+    const quiet = plan.runOptions.quiet === true;
+    return {
+        buildOutputBefore: await readBuildOutputState(context.monorepoRoot, context.config),
+        key,
+        retentionKey: computeRetentionKey({
+            channels: { stderr: resolveChannel(stderr, quiet), stdout: resolveChannel(stdout, quiet) },
+            env,
+            passKey: key,
+        }),
+        snapshot,
+    };
+}
+async function recallPass(plan, gate) {
+    const { anchorDir, command, context, env, stderr } = plan.invocation;
+    const { monorepoRoot } = context;
+    const recalledPass = await lookUpRecordedPass({
+        anchorDir,
+        buildOutput: gate.buildOutputBefore,
+        command,
+        env,
+        key: gate.key,
+        monorepoRoot,
+        retentionKey: gate.retentionKey,
+        stderr,
+    });
+    if (recalledPass === undefined) {
+        return undefined;
+    }
+    const { entry, ...recall } = recalledPass;
+    if (recall.replay !== undefined) {
+        await certifyRetention({ anchorDir, command, entry, env, monorepoRoot, runId: plan.runId, stderr });
+    }
+    return { exitCode: 0, outcome: { outcome: 'recalled', ...recall } };
+}
 async function recordPass(options) {
     const { anchorDir, command, env, monorepoRoot, snapshot, stderr } = options;
     const currentRead = resolveTreeSnapshot({ monorepoRoot, env: {} });
@@ -862,70 +1033,61 @@ async function runDelegation(options) {
     return runSteps([step], context.monorepoRoot, { ...runOptions, env: delegation.env });
 }
 async function runGated(plan) {
-    const { commandString, key, snapshot } = plan;
+    const { commandString, key } = plan;
     const { anchorDir, command, context, env, stderr, stdout } = plan.invocation;
     const { config, monorepoRoot } = context;
-    const quiet = plan.runOptions.quiet === true;
-    const gate = key !== undefined && snapshot !== undefined
-        ? {
-            buildOutputBefore: await readBuildOutputState(monorepoRoot, config),
-            key,
-            retentionKey: computeRetentionKey({
-                channels: { stderr: resolveChannel(stderr, quiet), stdout: resolveChannel(stdout, quiet) },
-                env,
-                passKey: key,
-            }),
-            snapshot,
-        }
-        : undefined;
+    let gate = await readGate(plan);
     if (gate !== undefined && !plan.shouldBypassCache) {
-        const recalledPass = await lookUpRecordedPass({
-            anchorDir,
-            buildOutput: gate.buildOutputBefore,
-            command,
-            env,
-            key: gate.key,
-            monorepoRoot,
-            retentionKey: gate.retentionKey,
-            stderr,
-        });
-        if (recalledPass !== undefined) {
-            const { entry, ...recall } = recalledPass;
-            if (recall.replay !== undefined) {
-                await certifyRetention({ anchorDir, command, entry, env, monorepoRoot, runId: plan.runId, stderr });
-            }
-            return { exitCode: 0, outcome: { outcome: 'recalled', ...recall } };
+        const recalled = await recallPass(plan, gate);
+        if (recalled !== undefined) {
+            return recalled;
         }
     }
-    if (plan.overrideNotice !== undefined) {
-        stdout.write(plan.overrideNotice);
+    const lock = await takeMachineLock(plan.invocation);
+    try {
+        if (lock?.waited === true && key !== undefined) {
+            gate = await readGate(plan);
+            if (gate !== undefined && !plan.shouldBypassCache) {
+                const recalled = await recallPass(plan, gate);
+                if (recalled !== undefined) {
+                    return recalled;
+                }
+            }
+        }
+        if (plan.overrideNotice !== undefined) {
+            stdout.write(plan.overrideNotice);
+        }
+        const runOptions = { ...plan.runOptions, env: addLockEnv(plan.runOptions.env ?? env, lock) };
+        const startedAtMs = Date.now();
+        const { exitCode, retainedOutput } = await runSteps(plan.steps, anchorDir, runOptions);
+        const durationMs = Date.now() - startedAtMs;
+        if (exitCode === 0 && gate !== undefined) {
+            await recordPass({
+                anchorDir,
+                buildOutputBefore: gate.buildOutputBefore,
+                command,
+                commandString,
+                config,
+                durationMs,
+                env,
+                key: gate.key,
+                monorepoRoot,
+                ownSteps: plan.ownSteps,
+                retainedOutput,
+                retentionKey: gate.retentionKey,
+                runId: plan.runId,
+                snapshot: gate.snapshot,
+                stderr,
+            });
+        }
+        return {
+            exitCode,
+            outcome: exitCode === 0 ? { outcome: 'passed', durationMs } : { outcome: 'failed', durationMs, exitCode },
+        };
     }
-    const startedAtMs = Date.now();
-    const { exitCode, retainedOutput } = await runSteps(plan.steps, anchorDir, plan.runOptions);
-    const durationMs = Date.now() - startedAtMs;
-    if (exitCode === 0 && gate !== undefined) {
-        await recordPass({
-            anchorDir,
-            buildOutputBefore: gate.buildOutputBefore,
-            command,
-            commandString,
-            config,
-            durationMs,
-            env,
-            key: gate.key,
-            monorepoRoot,
-            ownSteps: plan.ownSteps,
-            retainedOutput,
-            retentionKey: gate.retentionKey,
-            runId: plan.runId,
-            snapshot: gate.snapshot,
-            stderr,
-        });
+    finally {
+        await lock?.release();
     }
-    return {
-        exitCode,
-        outcome: exitCode === 0 ? { outcome: 'passed', durationMs } : { outcome: 'failed', durationMs, exitCode },
-    };
 }
 function formatMisplacedFlagHint(args, passthrough, style) {
     const { flagNames, movedTokens, remainingTokens } = splitMisplacedFlags(passthrough);
@@ -951,10 +1113,28 @@ function isDefinedInAnyScope(command, context) {
     }
     return [context.monorepoRoot, ...context.workspacePackageDirs].some((dir) => Object.hasOwn(readPackageJsonScripts(dir) ?? {}, command));
 }
+function isDelegationFlag(arg) {
+    return arg === DELEGATE_FLAG || arg === NO_DELEGATE_FLAG || arg.startsWith(`${DELEGATE_FLAG}=`);
+}
 function isTopLevelInvocation(env) {
     const runId = env[RUN_ID_ENV_VAR];
     return runId === undefined || runId === '';
 }
+async function takeMachineLock(invocation) {
+    const { anchorDir, command, env, parsedArgs, stderr, styles } = invocation;
+    if (!HEAVY_COMMANDS.has(command) || parsedArgs.shouldPrintLog) {
+        return undefined;
+    }
+    if (parsedArgs.passthrough.includes('--no-lock')) {
+        stderr.write(`${formatMisplacedNoLockWarning(command, styles.stderr)}\n`);
+    }
+    return acquireMachineLock({
+        command,
+        dir: anchorDir,
+        env: parsedArgs.shouldBypassLock ? { ...env, [NO_LOCK_ENV_VAR]: '1' } : env,
+        stderr,
+    });
+}
 function readMisplacedFlagLength(args, index) {
     const arg = args[index] ?? '';
     if (FILTER_FLAGS.has(arg)) {
@@ -964,8 +1144,8 @@ function readMisplacedFlagLength(args, index) {
     if (booleanFlag !== undefined) {
         return booleanFlag === 'shouldShowHelp' || booleanFlag === 'shouldShowVersion' ? undefined : 1;
     }
-    const styleArgument = readOutputStyleArgument(args, index);
-    return styleArgument?.ok === true ? styleArgument.consumedCount : undefined;
+    const valueArgument = readOutputStyleArgument(args, index) ?? readDelegateArgument(args, index);
+    return valueArgument?.ok === true ? valueArgument.consumedCount : undefined;
 }
 function splitMisplacedFlags(passthrough) {
     const flagNames = new Set();
@@ -984,15 +1164,12 @@ function splitMisplacedFlags(passthrough) {
             index++;
             continue;
         }
-        flagNames.add(arg.startsWith(`${OUTPUT_STYLE_FLAG}=`) ? OUTPUT_STYLE_FLAG : arg);
+        flagNames.add(arg.split('=', 1)[0] ?? arg);
         movedTokens.push(...passthrough.slice(index, index + flagLength));
         index += flagLength;
     }
     return { flagNames: [...flagNames], movedTokens, remainingTokens };
 }
-function quoteForShell(arg) {
-    return "'" + arg.replace(/'/g, String.raw `'\''`) + "'";
-}
 function wrapWithHooks(command, mainSteps, registry, anchorDir, isWorkspaceRoot) {
     const steps = [];
     if (hasRunnableHook(`${command}:pre`, registry, anchorDir, isWorkspaceRoot)) {

package/dist/esm/verdict.d.ts

@@ -29,6 +29,8 @@ export type NoOpReason = 'empty-override' | 'empty-workspace' | 'noop-override';
  */
 export type Verdict = {
     command: string;
+    /** The host on which a delegated command ran, which a command that ran here does not have. */
+    host?: string;
     scope: string;
 } & VerdictOutcome;
 /**

package/dist/esm/verdict.js

@@ -23,13 +23,14 @@ const MIN_CUT_BYTES = Buffer.byteLength(TRUNCATION_MARK);
 const REPLAY_MARKER = 'replayed:';
 function describeOutcome(verdict, style) {
     const statuses = STATUS_GLYPHS[style];
+    const onHost = verdict.host === undefined ? '' : ` on ${verdict.host}`;
     switch (verdict.outcome) {
         case 'passed':
-            return { marker: statuses.passed.text, phrase: `passed in ${formatDuration(verdict.durationMs)}` };
+            return { marker: statuses.passed.text, phrase: `passed${onHost} in ${formatDuration(verdict.durationMs)}` };
         case 'failed':
             return {
                 marker: statuses.failed.text,
-                phrase: `failed in ${formatDuration(verdict.durationMs)} (exit ${verdict.exitCode})`,
+                phrase: `failed${onHost} in ${formatDuration(verdict.durationMs)} (exit ${verdict.exitCode})`,
             };
         case 'recalled': {
             const saving = formatSaving(verdict.savedMs);

package/dist/esm/vitest-max-workers.d.ts

@@ -0,0 +1,11 @@
+export interface MachineCapacity {
+    coreCount: number;
+    totalMemoryBytes: number;
+}
+/** Returns the worker count for a machine: one per `GIB_PER_WORKER` of memory, bounded by one fewer than the cores. */
+export declare function deriveDefaultMaxWorkers({ coreCount, totalMemoryBytes }: MachineCapacity): number;
+/**
+ * Returns the value of the last `--maxWorkers` argument: a number, or a percentage string that Vitest resolves against
+ * the core count. An argument whose value is neither counts as absent, which leaves Vitest to report it.
+ */
+export declare function readMaxWorkersFlag(args: readonly string[]): number | string | undefined;

package/dist/esm/vitest-max-workers.js

@@ -0,0 +1,35 @@
+const SMALL_MACHINE_MAX_CORES = 2;
+const SMALL_MACHINE_MAX_WORKERS = 3;
+const GIB_PER_WORKER = 4;
+const BYTES_PER_GIB = 2 ** 30;
+const MAX_WORKERS_FLAGS = ['--maxWorkers', '--max-workers'];
+const PERCENTAGE_PATTERN = /^\d+%$/;
+const POSITIVE_INTEGER_PATTERN = /^[1-9]\d*$/;
+export function deriveDefaultMaxWorkers({ coreCount, totalMemoryBytes }) {
+    if (coreCount <= SMALL_MACHINE_MAX_CORES)
+        return SMALL_MACHINE_MAX_WORKERS;
+    const memoryBound = Math.max(1, Math.floor(totalMemoryBytes / (GIB_PER_WORKER * BYTES_PER_GIB)));
+    return Math.min(coreCount - 1, memoryBound);
+}
+export function readMaxWorkersFlag(args) {
+    let rawValue;
+    args.forEach((arg, index) => {
+        if (MAX_WORKERS_FLAGS.includes(arg)) {
+            rawValue = args[index + 1];
+            return;
+        }
+        const flag = MAX_WORKERS_FLAGS.find((name) => arg.startsWith(`${name}=`));
+        if (flag !== undefined)
+            rawValue = arg.slice(flag.length + 1);
+    });
+    return parseMaxWorkersValue(rawValue);
+}
+function parseMaxWorkersValue(rawValue) {
+    if (rawValue === undefined)
+        return undefined;
+    if (POSITIVE_INTEGER_PATTERN.test(rawValue))
+        return Number(rawValue);
+    if (PERCENTAGE_PATTERN.test(rawValue))
+        return rawValue;
+    return undefined;
+}

package/dist/esm/vitest-source-resolution.js

@@ -135,10 +135,9 @@ function matchSubpath(exportsValue, subpath) {
             continue;
         const base = key.slice(0, star);
         const suffix = key.slice(star + 1);
-        if (!subpath.startsWith(base) || !subpath.endsWith(suffix))
-            continue;
-        if (subpath.length < base.length + suffix.length)
+        if (!subpath.startsWith(base) || !subpath.endsWith(suffix) || subpath.length < base.length + suffix.length) {
             continue;
+        }
         if (bestMatch !== undefined && bestMatch.base.length >= base.length)
             continue;
         bestMatch = { base, value, wildcard: subpath.slice(base.length, subpath.length - suffix.length) };

package/dist/esm/vitest.js

@@ -5,14 +5,13 @@ import { defaultExclude, mergeConfig } from 'vitest/config';
 import { listGitIgnoredPaths } from "./git-ignored-paths.js";
 import { isObject } from "./helpers/type-guards.js";
 import { ALL_TEST_PATTERNS, buildTierPatterns, TEST_COLLECTION_EXCLUDE, TIER_NAMES } from "./tiers.js";
+import { deriveDefaultMaxWorkers, readMaxWorkersFlag } from "./vitest-max-workers.js";
 import { createSourceResolutionPlugin } from "./vitest-source-resolution.js";
 import { getWorkspacePackageDirs } from "./workspace.js";
 import { toWorkspacePackageGlobs } from "./workspace-globs.js";
 const [RESIDUAL_TIER, ...NAMED_TIERS] = TIER_NAMES;
 const TIERED_PATTERNS = NAMED_TIERS.flatMap(buildTierPatterns);
 const TIER_TIMEOUT_MS = 30_000;
-const SMALL_MACHINE_MAX_CORES = 2;
-const SMALL_MACHINE_MAX_WORKERS = 3;
 const GIT_ISOLATION_SETUP_FILE = resolveGitIsolationSetupFile();
 const CLIENT_CONDITIONS = ['module', 'browser', 'development|production'];
 const SERVER_CONDITIONS = ['module', 'node', 'development|production'];
@@ -99,7 +98,11 @@ function buildProjects(layers, extraExclude, projectRoot, ignoredPathsRoot) {
         })),
     ];
     const collectionExclude = buildCollectionExclude(layers, ignoredPathsRoot);
-    const maxWorkers = resolveDefaultMaxWorkers();
+    const defaultMaxWorkers = deriveDefaultMaxWorkers({
+        coreCount: os.availableParallelism(),
+        totalMemoryBytes: os.totalmem(),
+    });
+    const flagMaxWorkers = readMaxWorkersFlag(process.argv.slice(2));
     const shouldIsolateGit = resolveFlag(layers, 'shouldIsolateGit', true);
     return projectTiers.map(({ exclude, include, name, timeoutMs }) => {
         const project = {
@@ -108,7 +111,7 @@ function buildProjects(layers, extraExclude, projectRoot, ignoredPathsRoot) {
             test: {
                 exclude: [...collectionExclude, ...exclude, ...extraExclude],
                 include,
-                ...(maxWorkers !== undefined && { maxWorkers }),
+                maxWorkers: defaultMaxWorkers,
                 name,
                 ...(shouldIsolateGit && { setupFiles: [GIT_ISOLATION_SETUP_FILE] }),
                 ...(timeoutMs !== undefined && { hookTimeout: timeoutMs, testTimeout: timeoutMs }),
@@ -118,7 +121,9 @@ function buildProjects(layers, extraExclude, projectRoot, ignoredPathsRoot) {
         for (const layer of layers) {
             mergedProject = applyLayer(mergedProject, layer, name);
         }
-        return mergedProject;
+        return flagMaxWorkers === undefined
+            ? mergedProject
+            : mergeConfig(mergedProject, { test: { maxWorkers: flagMaxWorkers } });
     });
 }
 function applyLayer(project, layer, tier) {
@@ -175,9 +180,6 @@ function formatOptionKeys(keys) {
         .map((key) => `\`${key}\``)
         .join(', ');
 }
-function resolveDefaultMaxWorkers() {
-    return os.availableParallelism() <= SMALL_MACHINE_MAX_CORES ? SMALL_MACHINE_MAX_WORKERS : undefined;
-}
 function resolveFlag(layers, name, isOnByDefault) {
     let resolvedFlag = isOnByDefault;
     for (const layer of layers) {

package/docs/check-cache.md

@@ -93,7 +93,7 @@ $ nmr check
 ⏩ nmr-core: check: passed 3m ago on this tree, saved ~48s — replayed: nmr-core: fmt:check: All matched files use Prettier code style!; nmr-core: test: Test Files 6 passed (6) Tests 41 passed (41)
 ```
 
-The assembly is flat: A constituent that is itself a composite contributes its own leaves' lines, so a skipped `ci` replays a package's `test` rather than one opaque `check:strict` line. A delegate expands into the scopes to which it fans out, and a constituent that did not record an excerpt is absent rather than inferred: `typecheck` and `lint:check` print nothing on success and contribute nothing above, and a command outside the [cacheable set](#what-is-cached) records nothing at all. `ci` replays what `check:strict` earned and nothing for `build`.
+The assembly is flat: A constituent that is itself a composite contributes its own leaves' lines, so a skipped `ci` replays a package's `test` rather than one opaque `check:strict` line. A fan-out expands into the scopes that it selects, and a constituent that did not record an excerpt is absent rather than inferred: `typecheck` and `lint:check` print nothing on success and contribute nothing above, and a command outside the [cacheable set](#what-is-cached) records nothing at all. `ci` replays what `check:strict` earned and nothing for `build`.
 
 Every excerpt in the assembly was certified during a single run, on a single tree, because nmr assembles it when the composite records its pass rather than when it skips. `NMR_RUN_ID` makes that provable; see [reserved environment variables](#reserved-environment-variables).
 
@@ -133,7 +133,7 @@ $ nmr --log test
 🟠 nmr: test: no recording; the last pass was 3m ago, on a tree that this is not
 ```
 
-**`--log` applies to the scopes that `-F` and `-R` select.** nmr passes the flag to the delegate. Each scope prints its own recording. There a scope with nothing to show reports its gap and exits 0: Partial coverage is normal for a survey, and failing on the first gap would hide every scope that had something to show. A selection that does not include any scope is the other case and fails, as it does for a run: An empty selection is not a partial survey.
+**`--log` applies to the scopes that `-F` and `-R` select.** nmr passes the flag to each scope that it selects. Each scope prints its own recording. There a scope with nothing to show reports its gap and exits 0: Partial coverage is normal for a survey, and failing on the first gap would hide every scope that had something to show. A selection that does not include any scope is the other case and fails, as it does for a run: An empty selection is not a partial survey.
 
 **Retention has a ceiling of 256 KiB per recorded pass**, distinct from the 512 bytes to which a verdict line is held. nmr keeps 128 KiB from each end of a transcript that overruns it, because a run's opening and its closing statement each contain what the other does not, and it marks the drop with a line that names the dropped bytes, rather than cutting silently.