@williamthorsen/nmr 0.48.0 → 0.49.0

package/dist/esm/runner.d.ts

@@ -1,24 +1,5 @@
-import type { Writable } from 'node:stream';
+import { type RunCommandOptions, type RunCommandResult } from './child-process.js';
 import type { Step } from './steps.js';
-/** Where one of a child's output streams goes: a descriptor to which the child writes, or a pipe read by nmr. */
-export type OutputChannel = number | 'pipe';
-/** The channel on which each of a child's output streams runs. */
-export interface OutputChannels {
-    stderr: OutputChannel;
-    stdout: OutputChannel;
-}
-export interface RunCommandOptions {
-    /** The channel on which each of the child's output streams runs. */
-    channels: OutputChannels;
-    /** When true, suppresses output on success and writes captured output to stderr on failure. */
-    quiet?: boolean;
-    /** Stream that subprocess stdout flows to in non-quiet mode. Defaults to `process.stdout`. */
-    stdout?: Writable;
-    /** Stream that subprocess stderr flows to (and that quiet-mode failure output is written to). Defaults to `process.stderr`. */
-    stderr?: Writable;
-    /** Environment for the subprocess. Defaults to `process.env`. */
-    env?: NodeJS.ProcessEnv;
-}
 /** What a step list needs to run. Each step's channels follow its kind, so the caller chooses none of them. */
 export type RunStepsOptions = Omit<RunCommandOptions, 'channels'>;
 /** A bounded copy of what a step list's own commands wrote, each stream kept apart from the other. */
@@ -34,39 +15,6 @@ export interface RunStepsResult {
      */
     retainedOutput?: RetainedOutput;
 }
-/** How a command ended, and the exit code that reports that ending to nmr's own caller. */
-type CommandCompletion = {
-    outcome: 'exited';
-    exitCode: number;
-} | {
-    outcome: 'signaled';
-    exitCode: number;
-    signal: NodeJS.Signals;
-} | {
-    outcome: 'spawn-failed';
-    exitCode: number;
-    error: Error;
-};
-export type RunCommandResult = CommandCompletion & {
-    /**
-     * Output retained while the command ran, elided in the middle when it overran the bound.
-     * `undefined` when the stream was handed to the child directly, or when capture stopped early
-     * and the retained copy would understate what the command produced.
-     */
-    stdout: Buffer | undefined;
-    stderr: Buffer | undefined;
-};
-/**
- * Returns the channel on which a stream runs: the stream's own descriptor when it is a terminal and output is
- * not being withheld, so that the child's terminal detection matches nmr's, and a pipe everywhere else.
- */
-export declare function resolveChannel(stream: Writable, quiet: boolean): OutputChannel;
-/**
- * Returns the channel for a step that runs an nmr process below this one: nmr's own descriptor whenever it has
- * one, so that the child writes where nmr writes, without an ancestor between them relaying bytes. A stream
- * without a descriptor falls back to a pipe.
- */
-export declare function resolveInheritedChannel(stream: Writable): OutputChannel;
 /**
  * Runs a step list in order and resolves once one fails or all have run, implementing the `&&` semantics that
  * nmr promises: The first non-zero exit ends the sequence and is the code returned.
@@ -100,4 +48,3 @@ export declare function runSteps(steps: readonly Step[], cwd: string | undefined
  * is approximate.
  */
 export declare function runCommand(command: string, cwd: string | undefined, options: RunCommandOptions): Promise<RunCommandResult>;
-export {};

package/dist/esm/runner.js

@@ -1,19 +1,7 @@
-import { spawn } from 'node:child_process';
-import os from 'node:os';
 import process from 'node:process';
-import { reportError } from '@williamthorsen/nmr-core';
-import { createBoundedBuffer } from "./helpers/createBoundedBuffer.js";
+import { describeSignalExitCode, startSpawned, } from "./child-process.js";
 import { createOutputRecorder } from "./helpers/createOutputRecorder.js";
-const SIGNAL_EXIT_BASE = 128;
-const PIPE_DRAIN_GRACE_MS = 2_000;
-export function resolveChannel(stream, quiet) {
-    if (quiet)
-        return 'pipe';
-    return isTerminal(stream) ? stream.fd : 'pipe';
-}
-export function resolveInheritedChannel(stream) {
-    return hasDescriptor(stream) ? stream.fd : 'pipe';
-}
+import { isTerminal, resolveChannel, resolveInheritedChannel } from "./output-channel.js";
 export async function runSteps(steps, cwd, options) {
     const resolvedOptions = {
         ...options,
@@ -97,43 +85,6 @@ export async function runCommand(command, cwd, options) {
 function runSpawned(spec, cwd, options) {
     return startSpawned(spec, cwd, options).result;
 }
-function startSpawned({ args, file, input, shouldUseShell }, cwd, options) {
-    const quiet = options.quiet === true;
-    const stdout = options.stdout ?? process.stdout;
-    const stderr = options.stderr ?? process.stderr;
-    const env = options.env ?? process.env;
-    const child = spawn(file, args, {
-        shell: shouldUseShell,
-        stdio: [input, options.channels.stdout, options.channels.stderr],
-        cwd,
-        env,
-    });
-    return { child, result: collectResult(child, { quiet, stderr, stdout }) };
-}
-async function collectResult(child, { quiet, stderr, stdout }) {
-    const stdoutCapture = child.stdout === null ? undefined : captureStream(child.stdout, quiet ? undefined : stdout);
-    const stderrCapture = child.stderr === null ? undefined : captureStream(child.stderr, quiet ? undefined : stderr);
-    const commandCompletion = await awaitCompletion(child, () => {
-        stdoutCapture?.stopReading();
-        stderrCapture?.stopReading();
-    });
-    stdoutCapture?.detach();
-    stderrCapture?.detach();
-    const result = {
-        ...commandCompletion,
-        stdout: stdoutCapture?.readBuffer(),
-        stderr: stderrCapture?.readBuffer(),
-    };
-    if (result.outcome === 'spawn-failed') {
-        reportError(result.error.message, stderr);
-        return result;
-    }
-    if (quiet && result.exitCode !== 0) {
-        writeBuffer(result.stdout, stderr);
-        writeBuffer(result.stderr, stderr);
-    }
-    return result;
-}
 function startStep(step, cwd, options) {
     const { quiet, stderr, stdout } = options;
     if (step.kind === 'opaque') {
@@ -161,81 +112,11 @@ function composeRetainedOutput(parts, isCaptureWhole) {
         },
     };
 }
-function captureStream(source, destination) {
-    const retainedCopy = createBoundedBuffer();
-    let isComplete = true;
-    function stopReading() {
-        if (destination !== undefined)
-            source.unpipe(destination);
-        source.destroy();
-    }
-    function abandon() {
-        isComplete = false;
-        stopReading();
-    }
-    source.on('error', abandon);
-    if (destination !== undefined) {
-        destination.on('error', abandon);
-        source.pipe(destination, { end: false });
-    }
-    source.on('data', (chunk) => retainedCopy.append(chunk));
-    return {
-        readBuffer: () => (isComplete ? retainedCopy.readBuffer() : undefined),
-        detach: () => {
-            destination?.off('error', abandon);
-        },
-        stopReading,
-    };
-}
-function awaitCompletion(child, stopReading) {
-    return new Promise((resolve) => {
-        let exitCompletion;
-        let graceTimer;
-        let isSettled = false;
-        function settle(completion) {
-            if (isSettled)
-                return;
-            isSettled = true;
-            if (graceTimer !== undefined)
-                clearTimeout(graceTimer);
-            resolve(completion);
-        }
-        child.on('error', (error) => {
-            settle({ outcome: 'spawn-failed', exitCode: 1, error });
-        });
-        child.on('exit', (code, signal) => {
-            const exitDescription = describeExit(code, signal);
-            exitCompletion = exitDescription;
-            graceTimer = setTimeout(() => {
-                stopReading();
-                settle(exitDescription);
-            }, PIPE_DRAIN_GRACE_MS);
-        });
-        child.on('close', () => {
-            settle(exitCompletion ?? { outcome: 'exited', exitCode: 1 });
-        });
-    });
-}
 function buildBackgroundEnv(options) {
     const env = options.env ?? process.env;
     const shouldForceColor = isTerminal(options.stdout) && (env['NO_COLOR'] ?? '') === '' && env['FORCE_COLOR'] === undefined;
     return shouldForceColor ? { ...env, FORCE_COLOR: '1' } : env;
 }
-function describeExit(code, signal) {
-    if (signal !== null) {
-        return { outcome: 'signaled', exitCode: describeSignalExitCode(signal), signal };
-    }
-    return { outcome: 'exited', exitCode: code ?? 1 };
-}
-function describeSignalExitCode(signal) {
-    return SIGNAL_EXIT_BASE + os.constants.signals[signal];
-}
-function hasDescriptor(stream) {
-    return 'fd' in stream && typeof stream.fd === 'number';
-}
-function isTerminal(stream) {
-    return 'isTTY' in stream && stream.isTTY === true && hasDescriptor(stream);
-}
 async function recordResult(run, result) {
     run.result = await result;
 }
@@ -259,7 +140,3 @@ function startBackgroundRun(step, options, launch) {
     run.settled = recordResult(run, started.result);
     return run;
 }
-function writeBuffer(buffer, destination) {
-    if (buffer !== undefined && buffer.length > 0)
-        destination.write(buffer);
-}

package/dist/esm/shell-syntax.d.ts

@@ -0,0 +1,30 @@
+/** Drops the leading `NAME=value` assignments, leaving the program name at the head. */
+export declare function dropLeadingAssignments(tokens: readonly string[]): readonly string[];
+/** Reports whether a POSIX shell reads the token literally, so that it does not need any quoting. */
+export declare function isShellSafeToken(token: string): boolean;
+/** Quotes a token that the shell would not read literally, and leaves every other token bare. */
+export declare function quoteToken(token: string): string;
+/**
+ * Splits a command into the segments that a shell would run as separate commands, breaking on `&&`, `||`, `;`,
+ * `|`, and a newline, outside quotes.
+ *
+ * Quote and escape state are tracked character by character rather than by matching tokens, so a separator
+ * standing inside an argument stays part of the segment containing it. A backslash escapes outside quotes and
+ * inside a double-quoted run; inside a single-quoted run the shell reads it literally, and so does this.
+ * `tokenizeSegment` tracks the same state on the same rules.
+ *
+ * A separator standing inside a redirection operator does not end a command: `nmr build 2>&1` is one segment.
+ */
+export declare function splitSegments(command: string): string[];
+/** Splits a composite element into argv tokens, dropping the empty tokens that surrounding whitespace would leave. */
+export declare function tokenize(element: string): string[];
+/**
+ * Splits a shell segment into the tokens that a shell reads, keeping a quoted run attached to the token
+ * containing it, so that an environment assignment containing a quoted space stays one token.
+ *
+ * Tracks quote and escape state as `splitSegments` does, the two sharing one set of rules.
+ *
+ * Keeps the quotes rather than stripping them: Both questions asked of a token, whether it assigns an
+ * environment variable and whether it names the program, read the same on the raw token.
+ */
+export declare function tokenizeSegment(segment: string): string[];

package/dist/esm/shell-syntax.js

@@ -0,0 +1,120 @@
+const ENV_ASSIGNMENT = /^\w+=/;
+const QUOTES = new Set(['"', "'"]);
+const SEGMENT_SEPARATORS = new Set([';', '|', '&', '\n', '\r']);
+const SHELL_SAFE_TOKEN = /^[\w@%+=:,./-]+$/;
+const TOKEN_SEPARATORS = new Set([' ', '\t', '\n', '\r']);
+export function dropLeadingAssignments(tokens) {
+    const start = tokens.findIndex((token) => !ENV_ASSIGNMENT.test(token));
+    return start === -1 ? [] : tokens.slice(start);
+}
+export function isShellSafeToken(token) {
+    return SHELL_SAFE_TOKEN.test(token);
+}
+export function quoteToken(token) {
+    if (isShellSafeToken(token)) {
+        return token;
+    }
+    return "'" + token.replaceAll("'", String.raw `'\''`) + "'";
+}
+export function splitSegments(command) {
+    const segments = [];
+    let currentSegment = '';
+    let quote;
+    let index = 0;
+    while (index < command.length) {
+        const char = command[index] ?? '';
+        if (quote !== undefined) {
+            if (char === '\\' && quote === '"') {
+                currentSegment += char + (command[index + 1] ?? '');
+                index += 2;
+                continue;
+            }
+            currentSegment += char;
+            if (char === quote)
+                quote = undefined;
+            index += 1;
+            continue;
+        }
+        if (char === '\\') {
+            currentSegment += char + (command[index + 1] ?? '');
+            index += 2;
+            continue;
+        }
+        if (QUOTES.has(char)) {
+            quote = char;
+            currentSegment += char;
+            index += 1;
+            continue;
+        }
+        if (SEGMENT_SEPARATORS.has(char)) {
+            if (isRedirectionOperator(char, currentSegment, command[index + 1])) {
+                currentSegment += char;
+                index += 1;
+                continue;
+            }
+            index += command[index + 1] === char ? 2 : 1;
+            segments.push(currentSegment);
+            currentSegment = '';
+            continue;
+        }
+        currentSegment += char;
+        index += 1;
+    }
+    segments.push(currentSegment);
+    return segments;
+}
+export function tokenize(element) {
+    return element.split(/\s+/).filter((token) => token.length > 0);
+}
+export function tokenizeSegment(segment) {
+    const tokens = [];
+    let currentToken = '';
+    let quote;
+    let index = 0;
+    while (index < segment.length) {
+        const char = segment[index] ?? '';
+        if (quote !== undefined) {
+            if (char === '\\' && quote === '"') {
+                currentToken += char + (segment[index + 1] ?? '');
+                index += 2;
+                continue;
+            }
+            currentToken += char;
+            if (char === quote)
+                quote = undefined;
+            index += 1;
+            continue;
+        }
+        if (char === '\\') {
+            currentToken += char + (segment[index + 1] ?? '');
+            index += 2;
+            continue;
+        }
+        if (QUOTES.has(char)) {
+            quote = char;
+            currentToken += char;
+            index += 1;
+            continue;
+        }
+        if (TOKEN_SEPARATORS.has(char)) {
+            if (currentToken !== '') {
+                tokens.push(currentToken);
+            }
+            currentToken = '';
+            index += 1;
+            continue;
+        }
+        currentToken += char;
+        index += 1;
+    }
+    if (currentToken !== '') {
+        tokens.push(currentToken);
+    }
+    return tokens;
+}
+function isRedirectionOperator(char, precedingText, nextChar) {
+    if (char !== '&' && char !== '|') {
+        return false;
+    }
+    return (char === '&' && nextChar === '>') || /[<>]\s*$/.test(precedingText);
+}

package/dist/esm/steps.d.ts

@@ -90,8 +90,6 @@ export declare function findNmrCrossing(steps: readonly Step[]): string | undefi
  * literally would be quoted whole by the rendering, turning the element into a command that nobody wrote.
  */
 export declare function findUnexpressibleToken(element: string): string | undefined;
-/** Quotes a token that the shell would not read literally, and leaves every other token bare. */
-export declare function quoteToken(token: string): string;
 /**
  * Returns the command that a structural step's nmr process runs, whether the step hands that command to other
  * scopes rather than running it in its own scope, and whether it anchors the command at the monorepo root.

package/dist/esm/steps.js

@@ -1,4 +1,4 @@
-const ENV_ASSIGNMENT = /^\w+=/;
+import { dropLeadingAssignments, isShellSafeToken, quoteToken, splitSegments, tokenize, tokenizeSegment, } from "./shell-syntax.js";
 const LAUNCHERS = new Map([
     ['bun', new Set(['x'])],
     ['bunx', new Set()],
@@ -7,10 +7,6 @@ const LAUNCHERS = new Map([
     ['pnpm', new Set(['dlx', 'exec'])],
     ['yarn', new Set(['dlx', 'exec'])],
 ]);
-const QUOTES = new Set(['"', "'"]);
-const SEGMENT_SEPARATORS = new Set([';', '|', '&', '\n', '\r']);
-const SHELL_SAFE_TOKEN = /^[\w@%+=:,./-]+$/;
-const TOKEN_SEPARATORS = new Set([' ', '\t', '\n', '\r']);
 export function composeNmrStep(element, isWorkspaceRoot, flags = {}) {
     const { shouldDeclineArguments = false, shouldRunInBackground = false } = flags;
     const nmrFlags = isWorkspaceRoot ? ['-w'] : [];
@@ -33,13 +29,7 @@ export function findNmrCrossing(steps) {
     return undefined;
 }
 export function findUnexpressibleToken(element) {
-    return tokenize(element).find((token) => !SHELL_SAFE_TOKEN.test(token));
-}
-export function quoteToken(token) {
-    if (SHELL_SAFE_TOKEN.test(token)) {
-        return token;
-    }
-    return "'" + token.replaceAll("'", String.raw `'\''`) + "'";
+    return tokenize(element).find((token) => !isShellSafeToken(token));
 }
 export function readNmrStep(step) {
     if (step.kind !== 'structural') {
@@ -80,7 +70,7 @@ export function readSoleNmrCommand(script) {
     if (program !== 'nmr' || command === undefined || rest.length > 0) {
         return undefined;
     }
-    return SHELL_SAFE_TOKEN.test(command) && !command.startsWith('-') ? command : undefined;
+    return isShellSafeToken(command) && !command.startsWith('-') ? command : undefined;
 }
 export function readStepListSelfReference(options) {
     const { commandName, elements, scope } = options;
@@ -96,16 +86,6 @@ export function readStepListSelfReference(options) {
 export function renderChain(steps) {
     return steps.map(renderStep).join(' && ');
 }
-function dropLeadingAssignments(tokens) {
-    const start = tokens.findIndex((token) => !ENV_ASSIGNMENT.test(token));
-    return start === -1 ? [] : tokens.slice(start);
-}
-function isRedirectionOperator(char, precedingText, nextChar) {
-    if (char !== '&' && char !== '|') {
-        return false;
-    }
-    return (char === '&' && nextChar === '>') || /[<>]\s*$/.test(precedingText);
-}
 function isReentry(target, commandName, scope) {
     if (target.command !== commandName) {
         return false;
@@ -196,99 +176,3 @@ function readNmrTarget(tokens) {
 function renderStep(step) {
     return step.kind === 'opaque' ? step.command : step.argv.map(quoteToken).join(' ');
 }
-function splitSegments(command) {
-    const segments = [];
-    let currentSegment = '';
-    let quote;
-    let index = 0;
-    while (index < command.length) {
-        const char = command[index] ?? '';
-        if (quote !== undefined) {
-            if (char === '\\' && quote === '"') {
-                currentSegment += char + (command[index + 1] ?? '');
-                index += 2;
-                continue;
-            }
-            currentSegment += char;
-            if (char === quote)
-                quote = undefined;
-            index += 1;
-            continue;
-        }
-        if (char === '\\') {
-            currentSegment += char + (command[index + 1] ?? '');
-            index += 2;
-            continue;
-        }
-        if (QUOTES.has(char)) {
-            quote = char;
-            currentSegment += char;
-            index += 1;
-            continue;
-        }
-        if (SEGMENT_SEPARATORS.has(char)) {
-            if (isRedirectionOperator(char, currentSegment, command[index + 1])) {
-                currentSegment += char;
-                index += 1;
-                continue;
-            }
-            index += command[index + 1] === char ? 2 : 1;
-            segments.push(currentSegment);
-            currentSegment = '';
-            continue;
-        }
-        currentSegment += char;
-        index += 1;
-    }
-    segments.push(currentSegment);
-    return segments;
-}
-function tokenize(element) {
-    return element.split(/\s+/).filter((token) => token.length > 0);
-}
-function tokenizeSegment(segment) {
-    const tokens = [];
-    let currentToken = '';
-    let quote;
-    let index = 0;
-    while (index < segment.length) {
-        const char = segment[index] ?? '';
-        if (quote !== undefined) {
-            if (char === '\\' && quote === '"') {
-                currentToken += char + (segment[index + 1] ?? '');
-                index += 2;
-                continue;
-            }
-            currentToken += char;
-            if (char === quote)
-                quote = undefined;
-            index += 1;
-            continue;
-        }
-        if (char === '\\') {
-            currentToken += char + (segment[index + 1] ?? '');
-            index += 2;
-            continue;
-        }
-        if (QUOTES.has(char)) {
-            quote = char;
-            currentToken += char;
-            index += 1;
-            continue;
-        }
-        if (TOKEN_SEPARATORS.has(char)) {
-            if (currentToken !== '') {
-                tokens.push(currentToken);
-            }
-            currentToken = '';
-            index += 1;
-            continue;
-        }
-        currentToken += char;
-        index += 1;
-    }
-    if (currentToken !== '') {
-        tokens.push(currentToken);
-    }
-    return tokens;
-}

package/dist/esm/types.d.ts

@@ -54,6 +54,11 @@ export interface OutputConfig {
 export interface NmrConfig {
     build?: BuildConfig;
     checkCache?: CheckCacheConfig;
+    /**
+     * Set to `false` to keep every check on the machine that has the tree, whatever `NMR_DELEGATE` or the user
+     * config says. A delegation flag still sends a run elsewhere.
+     */
+    delegate?: false;
     devBin?: Record<string, string>;
     output?: OutputConfig;
     workspaceScripts?: Record<string, ScriptValue>;

package/dist/esm/user-config.d.ts

@@ -0,0 +1,34 @@
+import type { HostList } from './remote-run.js';
+/** The values that `delegate.when` accepts, each naming the runs that delegate without being asked. */
+export declare const DELEGATE_WHEN_VALUES: readonly ["agent", "always"];
+export type DelegateWhen = (typeof DELEGATE_WHEN_VALUES)[number];
+/**
+ * Renders a path for a message, with `~` standing for the home directory that `env` names when the path lies under
+ * it.
+ */
+export declare function formatDisplayPath(filePath: string, env: NodeJS.ProcessEnv): string;
+/** A user config, with the path from which it was loaded. */
+export interface LoadedUserConfig {
+    config: UserConfig;
+    path: string;
+}
+/**
+ * Loads and validates the user config that `env` locates, or returns `undefined` when `env` locates none or the file
+ * does not exist.
+ */
+export declare function loadUserConfig(env: NodeJS.ProcessEnv): Promise<LoadedUserConfig | undefined>;
+/**
+ * Returns the user config's path, resolved from `env` alone so that a caller's environment decides which file is
+ * read: under `XDG_CONFIG_HOME` when that is an absolute path, as the XDG base-directory spec requires, otherwise
+ * under `HOME`'s `.config`. Returns `undefined` when `env` names neither.
+ */
+export declare function resolveUserConfigPath(env: NodeJS.ProcessEnv): string | undefined;
+/** The machine-level settings that `$XDG_CONFIG_HOME/nmr/config.ts` declares. */
+export interface UserConfig {
+    delegate?: UserDelegateConfig;
+}
+/** This machine's delegation hosts, and which runs delegate to them without being asked. */
+export interface UserDelegateConfig {
+    hosts: HostList;
+    when?: DelegateWhen;
+}

package/dist/esm/user-config.js

@@ -0,0 +1,93 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { assertRecognizedKeys } from "./config-validation.js";
+import { isObject } from "./helpers/type-guards.js";
+import { UserError } from "./UserError.js";
+export const DELEGATE_WHEN_VALUES = ['agent', 'always'];
+export function formatDisplayPath(filePath, env) {
+    const home = env['HOME'];
+    if (home === undefined || !path.isAbsolute(home)) {
+        return filePath;
+    }
+    const relativePath = path.relative(home, filePath);
+    if (relativePath === '' || relativePath.startsWith('..') || path.isAbsolute(relativePath)) {
+        return filePath;
+    }
+    return path.join('~', relativePath);
+}
+export async function loadUserConfig(env) {
+    const configPath = resolveUserConfigPath(env);
+    if (configPath === undefined || !existsSync(configPath)) {
+        return undefined;
+    }
+    const importedModule = await import(__rewriteRelativeImportExtension(pathToFileURL(configPath).href));
+    const loadedConfig = isObject(importedModule) ? importedModule['default'] : undefined;
+    return { config: validateUserConfig(loadedConfig, configPath), path: configPath };
+}
+export function resolveUserConfigPath(env) {
+    const configHome = env['XDG_CONFIG_HOME'];
+    if (configHome !== undefined && path.isAbsolute(configHome)) {
+        return path.join(configHome, USER_CONFIG_RELATIVE_PATH);
+    }
+    const home = env['HOME'];
+    if (home !== undefined && path.isAbsolute(home)) {
+        return path.join(home, '.config', USER_CONFIG_RELATIVE_PATH);
+    }
+    return undefined;
+}
+const USER_CONFIG_RELATIVE_PATH = path.join('nmr', 'config.ts');
+const RECOGNIZED_KEYS = ['delegate'];
+const RECOGNIZED_DELEGATE_KEYS = ['hosts', 'when'];
+function isDelegateWhen(value) {
+    const values = DELEGATE_WHEN_VALUES;
+    return values.includes(value);
+}
+function validateDelegateField(value, configPath) {
+    const delegate = value['delegate'];
+    if (delegate === undefined) {
+        return undefined;
+    }
+    if (!isObject(delegate)) {
+        throw new UserError(`Invalid nmr config at ${configPath}: \`delegate\` must be an object`);
+    }
+    assertRecognizedKeys(delegate, RECOGNIZED_DELEGATE_KEYS, configPath, 'delegate.');
+    const hosts = validateHosts(delegate['hosts'], configPath);
+    const when = delegate['when'];
+    if (when === undefined) {
+        return { hosts };
+    }
+    if (!isDelegateWhen(when)) {
+        const renderedValue = typeof when === 'string' ? when : JSON.stringify(when);
+        throw new UserError(`Invalid nmr config at ${configPath}: \`delegate.when\` is \`${renderedValue}\`, which is not one of: ` +
+            DELEGATE_WHEN_VALUES.join(', '));
+    }
+    return { hosts, when };
+}
+function validateHosts(value, configPath) {
+    const names = Array.isArray(value) && value.every((host) => typeof host === 'string')
+        ? value.map((host) => host.trim())
+        : [];
+    const [first, ...rest] = new Set(names);
+    if (first === undefined || names.includes('')) {
+        throw new UserError(`Invalid nmr config at ${configPath}: \`delegate.hosts\` must be a non-empty array of host names, ` +
+            'in order of preference');
+    }
+    return [first, ...rest];
+}
+function validateUserConfig(value, configPath) {
+    if (!isObject(value)) {
+        throw new UserError(`Invalid nmr config at ${configPath}: expected an object, got ${typeof value}`);
+    }
+    assertRecognizedKeys(value, RECOGNIZED_KEYS, configPath);
+    const delegate = validateDelegateField(value, configPath);
+    return delegate === undefined ? {} : { delegate };
+}