vouchington-tooling 0.20.0 → 0.22.0

package/dist/dependency-license-policy/execute-pnpm.mjs

@@ -0,0 +1,83 @@
+import { spawn } from 'node:child_process';
+const MAX_BUFFER_BYTES = 1024 * 1024;
+export function signalFromAbort(signal) {
+    if (signal.reason === 'SIGINT' || signal.reason === 'SIGTERM' || signal.reason === 'SIGHUP') {
+        return signal.reason;
+    }
+    return 'SIGTERM';
+}
+export function stopChildProcess(child, signal) {
+    if (child.pid === undefined) {
+        child.kill(signal);
+        return;
+    }
+    try {
+        process.kill(-child.pid, signal);
+    }
+    catch {
+        child.kill(signal);
+    }
+}
+export function collectChildStream(stream, chunks, onOverflow) {
+    if (stream === null)
+        throw new Error('license audit child is missing a stdio pipe');
+    stream.setEncoding('utf8');
+    stream.on('data', (chunk) => {
+        chunks.push(chunk);
+        if (Buffer.byteLength(chunks.join('')) > MAX_BUFFER_BYTES)
+            onOverflow();
+    });
+}
+function finishOnce(settle) {
+    let settled = false;
+    return (result) => {
+        if (settled)
+            return;
+        settled = true;
+        settle(result);
+    };
+}
+/** Runs pnpm in its own process group so a signal can reach it and its children. */
+export const executePnpm = (command, args, options) => new Promise((resolve) => {
+    const child = spawn(command, args, {
+        cwd: options.cwd,
+        detached: true,
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    const stdout = [];
+    const stderr = [];
+    let overflow = false;
+    const stop = () => {
+        stopChildProcess(child, overflow ? 'SIGKILL' : signalFromAbort(options.signal));
+    };
+    if (options.signal.aborted)
+        stop();
+    else
+        options.signal.addEventListener('abort', stop, { once: true });
+    const markOverflow = () => {
+        overflow = true;
+        stop();
+    };
+    collectChildStream(child.stdout, stdout, markOverflow);
+    collectChildStream(child.stderr, stderr, markOverflow);
+    const finish = finishOnce((result) => {
+        options.signal.removeEventListener('abort', stop);
+        resolve(result);
+    });
+    child.once('error', (error) => {
+        finish({ error, status: null, stderr: stderr.join(''), stdout: stdout.join('') });
+    });
+    child.once('close', (status) => {
+        const result = { status, stderr: stderr.join(''), stdout: stdout.join('') };
+        if (!overflow) {
+            finish(result);
+            return;
+        }
+        finish({
+            ...result,
+            error: Object.assign(new Error('child output maxBuffer exceeded'), {
+                code: 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER',
+            }),
+        });
+    });
+});

package/dist/dependency-license-policy/types.d.mts

@@ -4,15 +4,17 @@ export interface PnpmLicenseReportEntry {
 }
 /** Shape emitted by `pnpm licenses list --json`. */
 export type PnpmLicenseReport = Record<string, PnpmLicenseReportEntry[]>;
-export type PnpmExecutor = (command: string, args: string[], options: {
-    cwd: string;
-    encoding: 'utf8';
-}) => {
-    error?: Error;
-    status: number | null;
-    stderr: string;
-    stdout: string;
-};
+export interface PnpmCommandResult {
+    readonly error?: Error;
+    readonly status: number | null;
+    readonly stderr: string;
+    readonly stdout: string;
+}
+export type PnpmExecutor = (command: string, args: readonly string[], options: {
+    readonly cwd: string;
+    readonly encoding: 'utf8';
+    readonly signal: AbortSignal;
+}) => PnpmCommandResult | Promise<PnpmCommandResult>;
 export interface DependencyLicenseAllowlistEntry {
     /** Exact SPDX atom allowed by this entry. */
     readonly licenseId: string;

package/dist/dependency-license-policy/workspace.d.mts

@@ -1,3 +1,4 @@
+import { type LicenseAuditWorkspaceOptions } from './audit-directory.mts';
 export interface PnpmLicenseAuditWorkspace {
     readonly cleanup: () => void;
     readonly cwd: string;
@@ -19,4 +20,5 @@ export declare function renderPnpmLicenseAuditFiles(lockfileSource: string, work
     lockfile: string;
     workspace: string;
 }): PnpmLicenseAuditFiles;
-export declare function preparePnpmLicenseAuditWorkspace(repoRoot: string, lockfileSource: string, workspaceSource: string): PnpmLicenseAuditWorkspace;
+export declare function licenseAuditParentDirectory(directory?: string): string;
+export declare function preparePnpmLicenseAuditWorkspace(repoRoot: string, lockfileSource: string, workspaceSource: string, options?: LicenseAuditWorkspaceOptions): PnpmLicenseAuditWorkspace;

package/dist/dependency-license-policy/workspace.mjs

@@ -1,7 +1,8 @@
-import { copyFileSync, existsSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { copyFileSync, existsSync, mkdtempSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { isMap, parseDocument, stringify as stringifyYaml } from 'yaml';
+import { LICENSE_AUDIT_DIRECTORY_PREFIX, reclaimStaleLicenseAuditDirectories, removeAuditDirectory, writeAuditPid, } from './audit-directory.mjs';
 const PLATFORM_KEYS = ['os', 'cpu', 'libc'];
 function parseYamlDocument(source, path) {
     const document = parseDocument(source);
@@ -71,9 +72,15 @@ export function renderPnpmLicenseAuditFiles(lockfileSource, workspaceSource, pat
         workspace: stringifyYaml({ ...workspace, packages: [], supportedArchitectures }),
     };
 }
-export function preparePnpmLicenseAuditWorkspace(repoRoot, lockfileSource, workspaceSource) {
-    const auditRoot = mkdtempSync(join(tmpdir(), 'dependency-license-audit-'));
+export function licenseAuditParentDirectory(directory) {
+    return directory ?? tmpdir();
+}
+export function preparePnpmLicenseAuditWorkspace(repoRoot, lockfileSource, workspaceSource, options = {}) {
+    const directory = licenseAuditParentDirectory(options.directory);
+    reclaimStaleLicenseAuditDirectories(directory, options);
+    const auditRoot = mkdtempSync(join(directory, LICENSE_AUDIT_DIRECTORY_PREFIX));
     try {
+        writeAuditPid(auditRoot, options.pid);
         copyFileSync(join(repoRoot, 'package.json'), join(auditRoot, 'package.json'));
         const npmrc = join(repoRoot, '.npmrc');
         if (existsSync(npmrc))
@@ -86,11 +93,11 @@ export function preparePnpmLicenseAuditWorkspace(repoRoot, lockfileSource, works
         writeFileSync(join(auditRoot, 'pnpm-workspace.yaml'), files.workspace, 'utf8');
     }
     catch (error) {
-        rmSync(auditRoot, { force: true, recursive: true });
+        removeAuditDirectory(auditRoot);
         throw error;
     }
     return {
         cwd: auditRoot,
-        cleanup: () => rmSync(auditRoot, { force: true, recursive: true }),
+        cleanup: () => removeAuditDirectory(auditRoot),
     };
 }

package/dist/gh-api-shell-quoting/argument-scan.d.mts

@@ -0,0 +1,7 @@
+export type ShellQuotingHit = {
+    offset: number;
+    excerpt: string;
+};
+export declare function consumeArgumentCharacter(text: string, index: number, frame: {
+    scanningArgs: boolean;
+}, hits: ShellQuotingHit[], offsets: number[]): number | undefined;

package/dist/gh-api-shell-quoting/argument-scan.mjs

@@ -0,0 +1,35 @@
+function excerptAround(text, index) {
+    return text.slice(Math.max(0, index - 24), Math.min(text.length, index + 12)).trim();
+}
+// While `frame.scanningArgs` is set, `;`, `|`, and a real `&` end the argument list. `&&` is the
+// Bash and-operator, `2>&1`/`>&2`/`<&3` are fd-duplication redirects, and a whitespace-preceded
+// `&` backgrounds the command. Only an `&` or `?` embedded in an unquoted argument is unsafe.
+// Returns the next scan index when this character is consumed, otherwise undefined so the caller
+// can keep matching a `gh api` head.
+export function consumeArgumentCharacter(text, index, frame, hits, offsets) {
+    if (!frame.scanningArgs)
+        return undefined;
+    const char = text[index];
+    if (char === ';' || char === '|') {
+        frame.scanningArgs = false;
+        return index + 1;
+    }
+    if (char === '&') {
+        if (text[index + 1] === '&') {
+            frame.scanningArgs = false;
+            return index + 2;
+        }
+        if (index > 0 && /[><]/.test(text[index - 1]))
+            return index + 1;
+        if (!(index > 0 && /[ \t]/.test(text[index - 1])))
+            hits.push({ offset: offsets[index], excerpt: excerptAround(text, index) });
+        frame.scanningArgs = false;
+        return index + 1;
+    }
+    if (char === '?') {
+        hits.push({ offset: offsets[index], excerpt: excerptAround(text, index) });
+        frame.scanningArgs = false;
+        return index + 1;
+    }
+    return undefined;
+}

package/dist/gh-api-shell-quoting/logical-line.d.mts

@@ -0,0 +1,3 @@
+import { type ShellQuotingHit } from './argument-scan.mts';
+export type { ShellQuotingHit } from './argument-scan.mts';
+export declare function scanLogicalLine(text: string, offsets: number[]): ShellQuotingHit[];

package/dist/gh-api-shell-quoting/logical-line.mjs

@@ -0,0 +1,90 @@
+import { consumeArgumentCharacter } from './argument-scan.mjs';
+const GH_API_BOUNDARY = /[\s;|&(){}]/;
+const GH_API_HEAD = /^gh[ \t]+api\b/;
+function matchGhApiHead(text, index) {
+    if (index > 0 && !GH_API_BOUNDARY.test(text[index - 1]))
+        return 0;
+    const match = GH_API_HEAD.exec(text.slice(index));
+    return match ? match[0].length : 0;
+}
+function newFrame() {
+    return { inSingleQuote: false, inDoubleQuote: false, scanningArgs: false, parenDepth: 0 };
+}
+function pushSubstitutionFrame(stack) {
+    const frame = newFrame();
+    frame.parenDepth = 1;
+    stack.push(frame);
+}
+// Scans one already-joined logical line for `gh api` calls and returns at most one hit per call —
+// the first unquoted `?` or `&`, whichever comes first. `offsets[k]` maps character k of `text`
+// back to its absolute offset in the original source, so callers can report real line numbers.
+export function scanLogicalLine(text, offsets) {
+    const hits = [];
+    const stack = [newFrame()];
+    let i = 0;
+    while (i < text.length) {
+        const frame = stack[stack.length - 1];
+        const char = text[i];
+        if (frame.inSingleQuote) {
+            if (char === "'")
+                frame.inSingleQuote = false;
+            i += 1;
+            continue;
+        }
+        if (char === '\\') {
+            i += 2;
+            continue;
+        }
+        if (frame.inDoubleQuote) {
+            if (char === '"') {
+                frame.inDoubleQuote = false;
+                i += 1;
+                continue;
+            }
+            if (char === '$' && text[i + 1] === '(') {
+                pushSubstitutionFrame(stack);
+                i += 2;
+                continue;
+            }
+            i += 1;
+            continue;
+        }
+        if (char === '#' && (i === 0 || /\s/.test(text[i - 1])))
+            break;
+        if (char === "'") {
+            frame.inSingleQuote = true;
+            i += 1;
+            continue;
+        }
+        if (char === '"') {
+            frame.inDoubleQuote = true;
+            i += 1;
+            continue;
+        }
+        if (char === '$' && text[i + 1] === '(') {
+            pushSubstitutionFrame(stack);
+            i += 2;
+            continue;
+        }
+        if (stack.length > 1 && (char === '(' || char === ')')) {
+            frame.parenDepth += char === '(' ? 1 : -1;
+            i += 1;
+            if (frame.parenDepth === 0)
+                stack.pop();
+            continue;
+        }
+        const argumentIndex = consumeArgumentCharacter(text, i, frame, hits, offsets);
+        if (argumentIndex !== undefined) {
+            i = argumentIndex;
+            continue;
+        }
+        const headLength = frame.scanningArgs ? 0 : matchGhApiHead(text, i);
+        if (headLength > 0) {
+            frame.scanningArgs = true;
+            i += headLength;
+            continue;
+        }
+        i += 1;
+    }
+    return hits;
+}

package/dist/gh-api-shell-quoting/scan.d.mts

@@ -1,7 +1,5 @@
-export type ShellQuotingHit = {
-    offset: number;
-    excerpt: string;
-};
+import { type ShellQuotingHit } from './logical-line.mts';
+export type { ShellQuotingHit } from './logical-line.mts';
 export declare function lineNumberAt(source: string, offset: number): number;
 /** Hits in `text` with offsets relative to `text` itself, not any enclosing document. */
 export declare function ghApiShellQuotingHits(text: string): ShellQuotingHit[];

package/dist/gh-api-shell-quoting/scan.mjs

@@ -10,125 +10,7 @@
 // call's argument list. A general-purpose shell tokenizer whose "expandable" notion conflates
 // glob metacharacters with `$`/backtick expansion would false-positive on a quoted
 // `"…${VAR}…?per_page=1"`, so this scanner tracks its own narrower quote-state machine instead.
-const GH_API_BOUNDARY = /[\s;|&(){}]/;
-const GH_API_HEAD = /^gh[ \t]+api\b/;
-function matchGhApiHead(text, index) {
-    if (index > 0 && !GH_API_BOUNDARY.test(text[index - 1]))
-        return 0;
-    const match = GH_API_HEAD.exec(text.slice(index));
-    return match ? match[0].length : 0;
-}
-function excerptAround(text, index) {
-    return text.slice(Math.max(0, index - 24), Math.min(text.length, index + 12)).trim();
-}
-function newFrame() {
-    return { inSingleQuote: false, inDoubleQuote: false, scanningArgs: false, parenDepth: 0 };
-}
-function pushSubstitutionFrame(stack) {
-    const frame = newFrame();
-    frame.parenDepth = 1;
-    stack.push(frame);
-}
-// Scans one already-joined logical line for `gh api` calls and returns at most one hit per call —
-// the first unquoted `?` or `&`, whichever comes first. `offsets[k]` maps character k of `text`
-// back to its absolute offset in the original source, so callers can report real line numbers.
-function scanLogicalLine(text, offsets) {
-    const hits = [];
-    const stack = [newFrame()];
-    let i = 0;
-    while (i < text.length) {
-        const frame = stack[stack.length - 1];
-        const char = text[i];
-        if (frame.inSingleQuote) {
-            if (char === "'")
-                frame.inSingleQuote = false;
-            i += 1;
-            continue;
-        }
-        if (char === '\\') {
-            i += 2;
-            continue;
-        }
-        if (frame.inDoubleQuote) {
-            if (char === '"') {
-                frame.inDoubleQuote = false;
-                i += 1;
-                continue;
-            }
-            if (char === '$' && text[i + 1] === '(') {
-                pushSubstitutionFrame(stack);
-                i += 2;
-                continue;
-            }
-            i += 1;
-            continue;
-        }
-        if (char === '#' && (i === 0 || /\s/.test(text[i - 1])))
-            break;
-        if (char === "'") {
-            frame.inSingleQuote = true;
-            i += 1;
-            continue;
-        }
-        if (char === '"') {
-            frame.inDoubleQuote = true;
-            i += 1;
-            continue;
-        }
-        if (char === '$' && text[i + 1] === '(') {
-            pushSubstitutionFrame(stack);
-            i += 2;
-            continue;
-        }
-        if (stack.length > 1 && (char === '(' || char === ')')) {
-            frame.parenDepth += char === '(' ? 1 : -1;
-            i += 1;
-            if (frame.parenDepth === 0)
-                stack.pop();
-            continue;
-        }
-        if (frame.scanningArgs) {
-            if (char === ';' || char === '|') {
-                frame.scanningArgs = false;
-                i += 1;
-                continue;
-            }
-            if (char === '&') {
-                if (text[i + 1] === '&') {
-                    frame.scanningArgs = false;
-                    i += 2;
-                    continue;
-                }
-                // `2>&1`/`>&2`/`<&3` fd-duplication redirects don't end the argument list; whitespace-
-                // preceded `&` is Bash's background operator and does. Only an `&` embedded in an
-                // unquoted argument is unsafe.
-                if (i > 0 && /[><]/.test(text[i - 1])) {
-                    i += 1;
-                    continue;
-                }
-                if (!(i > 0 && /[ \t]/.test(text[i - 1])))
-                    hits.push({ offset: offsets[i], excerpt: excerptAround(text, i) });
-                frame.scanningArgs = false;
-                i += 1;
-                continue;
-            }
-            if (char === '?') {
-                hits.push({ offset: offsets[i], excerpt: excerptAround(text, i) });
-                frame.scanningArgs = false;
-                i += 1;
-                continue;
-            }
-        }
-        const headLength = frame.scanningArgs ? 0 : matchGhApiHead(text, i);
-        if (headLength > 0) {
-            frame.scanningArgs = true;
-            i += headLength;
-            continue;
-        }
-        i += 1;
-    }
-    return hits;
-}
+import { scanLogicalLine } from './logical-line.mjs';
 // A logical line joins physical lines across a trailing, unescaped `\` — bash line continuation —
 // so a `gh api \` / URL-on-next-line split (common in multi-line `run:` steps) is scanned as one
 // command instead of two truncated fragments.

package/dist/gh-cli/diff.d.mts

@@ -1,6 +1,26 @@
-import type { RunTextCommand } from './exec.mts';
+/** A command that emits a unified diff on stdout, such as `git diff` or `gh pr diff`. */
+export interface DiffCommand {
+    readonly executable: string;
+    readonly args: readonly string[];
+    readonly cwd?: string;
+}
+export type DiffBlockCallback = (block: string) => void | Promise<void>;
+export declare class DiffCommandError extends Error {
+    readonly command: DiffCommand;
+    readonly details: {
+        code?: number | null;
+        signal?: NodeJS.Signals | null;
+        stderr: string;
+    };
+    constructor(command: DiffCommand, details: {
+        code?: number | null;
+        signal?: NodeJS.Signals | null;
+        stderr: string;
+    }, options?: ErrorOptions);
+}
 /**
- * Runs `git diff <base>...HEAD` and returns the raw diff text. The base is parameterized rather
- * than hardcoded so callers can diff against any ref (`origin/main`, a release branch, etc.).
+ * Spawns a command without a shell and emits its unified-diff output one file patch at a time.
+ * A preamble is retained with the first patch (or emitted alone); callbacks are provisional until
+ * this promise resolves, because a later command failure rejects after prior patches were emitted.
  */
-export declare function getDiffAgainstBase(runGit: RunTextCommand, base: string): Promise<string>;
+export declare function processDiffCommand(command: DiffCommand, onBlock: DiffBlockCallback): Promise<void>;

package/dist/gh-cli/diff.mjs

@@ -1,7 +1,114 @@
+import { spawn } from 'node:child_process';
+import { StringDecoder } from 'node:string_decoder';
+const STDERR_TAIL_BYTES = 16 * 1024;
+export class DiffCommandError extends Error {
+    command;
+    details;
+    constructor(command, details, options) {
+        const status = details.code === null ? details.signal : details.code;
+        super(`${command.executable} ${status === undefined ? 'failed to start' : `exited with ${status}`}${details.stderr ? `: ${details.stderr}` : ''}`, options);
+        this.command = command;
+        this.details = details;
+        this.name = 'DiffCommandError';
+    }
+}
+function appendTail(tail, chunk) {
+    const combined = Buffer.concat([tail, chunk]);
+    return combined.length <= STDERR_TAIL_BYTES ? combined : combined.subarray(-STDERR_TAIL_BYTES);
+}
+function diagnostic(tail) {
+    return tail.toString('utf8').trim();
+}
 /**
- * Runs `git diff <base>...HEAD` and returns the raw diff text. The base is parameterized rather
- * than hardcoded so callers can diff against any ref (`origin/main`, a release branch, etc.).
+ * Spawns a command without a shell and emits its unified-diff output one file patch at a time.
+ * A preamble is retained with the first patch (or emitted alone); callbacks are provisional until
+ * this promise resolves, because a later command failure rejects after prior patches were emitted.
  */
-export async function getDiffAgainstBase(runGit, base) {
-    return runGit(['diff', `${base}...HEAD`]);
+export async function processDiffCommand(command, onBlock) {
+    const child = spawn(command.executable, [...command.args], {
+        cwd: command.cwd,
+        shell: false,
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let stderr = Buffer.alloc(0);
+    let streamError;
+    const terminate = () => {
+        if (child.exitCode === null && !child.killed)
+            child.kill('SIGKILL');
+    };
+    child.stderr.on('data', (chunk) => {
+        stderr = appendTail(stderr, chunk);
+    });
+    child.stderr.on('error', (error) => {
+        streamError ??= error;
+        terminate();
+    });
+    const completion = new Promise((resolve) => {
+        child.once('error', (error) => resolve({ code: null, error, signal: null }));
+        child.once('close', (code, signal) => resolve({ code, signal }));
+    });
+    const decoder = new StringDecoder('utf8');
+    let block = '';
+    let pending = '';
+    let sawFileHeader = false;
+    let callbackError;
+    const acceptLine = async (line) => {
+        if (line.startsWith('diff --git ') && sawFileHeader) {
+            try {
+                await onBlock(block);
+            }
+            catch (error) {
+                callbackError = error;
+                throw error;
+            }
+            block = '';
+        }
+        if (line.startsWith('diff --git '))
+            sawFileHeader = true;
+        block += line;
+    };
+    const acceptText = async (text) => {
+        pending += text;
+        for (let newline = pending.indexOf('\n'); newline >= 0; newline = pending.indexOf('\n')) {
+            const line = pending.slice(0, newline + 1);
+            pending = pending.slice(newline + 1);
+            await acceptLine(line);
+        }
+    };
+    try {
+        for await (const chunk of child.stdout)
+            await acceptText(decoder.write(chunk));
+        await acceptText(decoder.end());
+        if (pending)
+            await acceptLine(pending);
+        if (streamError)
+            throw streamError;
+        if (block) {
+            try {
+                await onBlock(block);
+            }
+            catch (error) {
+                callbackError = error;
+                throw error;
+            }
+        }
+        const result = await completion;
+        if (streamError)
+            throw streamError;
+        if (result.error)
+            throw new DiffCommandError(command, { stderr: diagnostic(stderr) }, { cause: result.error });
+        if (result.code !== 0 || result.signal !== null)
+            throw new DiffCommandError(command, {
+                code: result.code,
+                signal: result.signal,
+                stderr: diagnostic(stderr),
+            });
+    }
+    catch (error) {
+        terminate();
+        await completion;
+        if (error === callbackError || error instanceof DiffCommandError)
+            throw error;
+        throw new DiffCommandError(command, { stderr: diagnostic(stderr) }, { cause: streamError ?? error });
+    }
 }

package/dist/gh-cli/index.d.mts

@@ -1,6 +1,7 @@
 export { createCommandRunner, runGh, runGit } from './exec.mts';
 export type { ExecFileText, RunTextCommand } from './exec.mts';
-export { getDiffAgainstBase } from './diff.mts';
+export { DiffCommandError, processDiffCommand } from './diff.mts';
+export type { DiffBlockCallback, DiffCommand } from './diff.mts';
 export { GITHUB_BODY_MAX_CHARACTERS, validateGitHubBodyLength } from './body-length.mts';
 export type { GitHubBodyLengthValidation } from './body-length.mts';
 export { assertHeadPushed, buildGhPrCreateArgs, createPullRequest, DetachedHeadError, HeadNotPushedError, HeadOutOfDateError, resolveHeadBranch, } from './pr-create.mts';

package/dist/gh-cli/index.mjs

@@ -1,4 +1,4 @@
 export { createCommandRunner, runGh, runGit } from './exec.mjs';
-export { getDiffAgainstBase } from './diff.mjs';
+export { DiffCommandError, processDiffCommand } from './diff.mjs';
 export { GITHUB_BODY_MAX_CHARACTERS, validateGitHubBodyLength } from './body-length.mjs';
 export { assertHeadPushed, buildGhPrCreateArgs, createPullRequest, DetachedHeadError, HeadNotPushedError, HeadOutOfDateError, resolveHeadBranch, } from './pr-create.mjs';

package/dist/gha-workspace-policy/docker-options.d.mts

@@ -0,0 +1,4 @@
+export declare function dockerOptions(block: string): {
+    user: string | undefined;
+    volumes: string[];
+} | undefined;