fauxnix-cli 0.2.1 → 0.4.0

package/dist/parser.js

@@ -1,4 +1,4 @@
-import { FauxnixParseError, } from './ast.js';
+import { FauxnixParseError, isUnquotedLiteral, wordToString, } from './ast.js';
 const OPERATORS = [
     '&&', '||', '>>', '<<', '2>&1', '1>&2', '2>', '&>>', '&>', '>', '<', '|', ';',
 ];
@@ -6,28 +6,37 @@ export function tokenize(input) {
     const tokens = [];
     let i = 0;
     const n = input.length;
-    const pushWord = (parts) => {
+    const pushWord = (parts, tightLeft) => {
         if (parts.length > 0)
-            tokens.push({ type: 'WORD', parts });
+            tokens.push({ type: 'WORD', parts, tightLeft });
     };
     let cur = [];
     let fdDigits = '';
+    let lastWasWs = true;
+    let wordTightLeft = false;
     const flush = () => {
-        pushWord(cur);
+        pushWord(cur, wordTightLeft);
         cur = [];
         fdDigits = '';
     };
+    const beginWordPart = () => {
+        if (cur.length === 0)
+            wordTightLeft = !lastWasWs;
+        lastWasWs = false;
+    };
     while (i < n) {
         const ch = input[i];
         // whitespace separates words; newline acts as ';'
         if (ch === ' ' || ch === '\t' || ch === '\r') {
             flush();
+            lastWasWs = true;
             i++;
             continue;
         }
         if (ch === '\n') {
             flush();
-            tokens.push({ type: 'OP', op: ';' });
+            tokens.push({ type: 'OP', op: '\n', tightLeft: false });
+            lastWasWs = true;
             i++;
             continue;
         }
@@ -76,8 +85,10 @@ export function tokenize(input) {
             if (matched === '<<') {
                 throw new FauxnixParseError('fauxnix: heredocs (<<) are not supported yet. Pass the text via echo pipe or a temp file instead.');
             }
+            const tightLeft = !lastWasWs;
             flush();
-            tokens.push({ type: 'OP', op: matched });
+            tokens.push({ type: 'OP', op: matched, tightLeft });
+            lastWasWs = false;
             i += advance;
             continue;
         }
@@ -86,12 +97,14 @@ export function tokenize(input) {
             const end = input.indexOf("'", i + 1);
             if (end === -1)
                 throw new FauxnixParseError('fauxnix: unclosed single quote');
+            beginWordPart();
             cur.push({ kind: 'SingleQuoted', text: input.slice(i + 1, end) });
             i = end + 1;
             continue;
         }
         // double quotes — interpolated
         if (ch === '"') {
+            beginWordPart();
             i++;
             const parts = [];
             let buf = '';
@@ -129,10 +142,12 @@ export function tokenize(input) {
         if (ch === '$') {
             const v = readDollar(input, i);
             if (v) {
+                beginWordPart();
                 cur.push(v.part);
                 i = v.next;
                 continue;
             }
+            beginWordPart();
             cur.push({ kind: 'Text', text: '$' });
             i++;
             continue;
@@ -140,20 +155,24 @@ export function tokenize(input) {
         if (ch === '`') {
             throw new FauxnixParseError('fauxnix: backticks are not supported. Use $(...) command substitution instead.');
         }
-        // escape outside quotes
+        // escape outside quotes — keep the escape so [[ =~ ]] / == can
+        // treat `\*` as a literal rather than a metacharacter
         if (ch === '\\' && i + 1 < n) {
-            cur.push({ kind: 'Text', text: input[i + 1] });
+            beginWordPart();
+            cur.push({ kind: 'Text', text: input[i + 1], escaped: true });
             i += 2;
             continue;
         }
         // track leading digits (potential fd number for redirects)
         if (/[0-9]/.test(ch) && cur.length === 0 && fdDigits.length < 2) {
+            beginWordPart();
             fdDigits += ch;
             cur.push({ kind: 'Text', text: ch });
             i++;
             continue;
         }
         fdDigits = '';
+        beginWordPart();
         cur.push({ kind: 'Text', text: ch });
         i++;
     }
@@ -181,7 +200,11 @@ function readDollar(input, i) {
         if (end === -1)
             throw new FauxnixParseError('fauxnix: unclosed ${');
         const name = input.slice(j + 1, end);
-        if (!isNameStart(name[0]) || !name.split('').every(isNameChar)) {
+        const sub = name.match(/^([A-Za-z_][A-Za-z0-9_]*)\[([0-9]+|@|\*)\]$/);
+        if (sub) {
+            return { part: { kind: 'Var', name: sub[1], index: sub[2] }, next: end + 1 };
+        }
+        if (!name || !isNameStart(name[0]) || !name.split('').every(isNameChar)) {
             // ${VAR:-default} etc. — unsupported, kept as raw text
             return { part: { kind: 'Text', text: input.slice(i, end + 1) }, next: end + 1 };
         }
@@ -226,6 +249,228 @@ function readDollar(input, i) {
     }
     return null;
 }
+function hasBareAmp(w) {
+    let depth = 0;
+    for (const p of w) {
+        if (p.kind !== 'Text' || p.escaped)
+            continue;
+        for (const c of p.text) {
+            if (c === '(')
+                depth++;
+            else if (c === ')' && depth > 0)
+                depth--;
+            else if (c === '&' && depth === 0)
+                return true;
+        }
+    }
+    return false;
+}
+function looksLikeArithWord(w) {
+    const s = wordToString(w);
+    return (/^[0-9a-fA-FxX#+\-*/%()<>&=!~|^?,: \t]+$/.test(s) && /[+\-*/%<>&=!~|^?]/.test(s));
+}
+function hasBareNonExtglobParen(w) {
+    const chars = [];
+    for (const p of w) {
+        if (p.kind === 'Text' && !p.escaped) {
+            for (const c of p.text)
+                chars.push(c);
+        }
+        else {
+            chars.push('\0');
+        }
+    }
+    for (let i = 0; i < chars.length; i++) {
+        if (chars[i] !== '(')
+            continue;
+        const prev = i > 0 ? chars[i - 1] : '';
+        if (prev !== '@' && prev !== '*' && prev !== '?' && prev !== '+' && prev !== '!')
+            return true;
+    }
+    return false;
+}
+function regexHasExtraClose(w) {
+    let depth = 0;
+    for (const p of w) {
+        if (p.kind !== 'Text' || p.escaped)
+            continue;
+        for (const c of p.text) {
+            if (c === '(')
+                depth++;
+            else if (c === ')') {
+                if (depth === 0)
+                    return true;
+                depth--;
+            }
+        }
+    }
+    return false;
+}
+function unmatchedOpenParen(w) {
+    let depth = 0;
+    for (const p of w) {
+        if (p.kind !== 'Text' || p.escaped)
+            continue;
+        for (const c of p.text) {
+            if (c === '(')
+                depth++;
+            else if (c === ')' && depth > 0)
+                depth--;
+        }
+    }
+    return depth > 0;
+}
+/** True when `w` has an unclosed unquoted `@(…)`, `+(…)`, `*(…)`, `?(…)`, or `!(…)`. */
+function unmatchedExtglob(w) {
+    const chars = [];
+    for (const p of w) {
+        if (p.kind === 'Text' && !p.escaped) {
+            for (const c of p.text)
+                chars.push(c);
+        }
+        else {
+            chars.push('\0');
+        }
+    }
+    let depth = 0;
+    for (let i = 0; i < chars.length; i++) {
+        const c = chars[i];
+        if ((c === '@' || c === '*' || c === '?' || c === '+' || c === '!') &&
+            chars[i + 1] === '(') {
+            depth++;
+            i++;
+            continue;
+        }
+        if (c === ')' && depth > 0)
+            depth--;
+    }
+    return depth > 0;
+}
+/**
+ * Peel grouping `(` / `)` that bash tokenizes even without spaces,
+ * but leave extglob `@(…)` / `!(foo)bar` intact.
+ */
+function splitCondParens(w) {
+    const leading = [];
+    const trailing = [];
+    let rest = w.map((p) => (p.kind === 'Text' ? { ...p } : p));
+    for (;;) {
+        if (rest.length === 0)
+            break;
+        const p = rest[0];
+        if (p.kind !== 'Text' || p.escaped || !p.text.startsWith('('))
+            break;
+        leading.push([{ kind: 'Text', text: '(' }]);
+        rest =
+            p.text.length === 1
+                ? rest.slice(1)
+                : [{ kind: 'Text', text: p.text.slice(1), escaped: p.escaped }, ...rest.slice(1)];
+    }
+    for (;;) {
+        if (rest.length === 0)
+            break;
+        const last = rest[rest.length - 1];
+        if (last.kind !== 'Text' || last.escaped || !last.text.endsWith(')'))
+            break;
+        const without = last.text.length === 1
+            ? rest.slice(0, -1)
+            : [
+                ...rest.slice(0, -1),
+                { kind: 'Text', text: last.text.slice(0, -1), escaped: last.escaped },
+            ];
+        if (unmatchedExtglob(without) || unmatchedOpenParen(without))
+            break;
+        trailing.unshift([{ kind: 'Text', text: ')' }]);
+        rest = without;
+    }
+    const mid = rest.length > 0 ? [rest] : [];
+    return [...leading, ...mid, ...trailing];
+}
+function groupingDepth(args) {
+    let d = 0;
+    for (const w of args) {
+        if (isUnquotedLiteral(w, '('))
+            d++;
+        else if (isUnquotedLiteral(w, ')'))
+            d--;
+    }
+    return d;
+}
+/** Peel trailing grouping `)` off a `=~` operand when a `(` is still open. */
+function peelTrailingGroupCloses(w, max) {
+    if (max <= 0)
+        return w.length ? [w] : [];
+    const { rest, trailing } = (() => {
+        const trailing = [];
+        let rest = w.map((p) => (p.kind === 'Text' ? { ...p } : p));
+        while (trailing.length < max) {
+            if (rest.length === 0)
+                break;
+            const last = rest[rest.length - 1];
+            if (last.kind !== 'Text' || last.escaped || !last.text.endsWith(')'))
+                break;
+            const without = last.text.length === 1
+                ? rest.slice(0, -1)
+                : [
+                    ...rest.slice(0, -1),
+                    { kind: 'Text', text: last.text.slice(0, -1), escaped: last.escaped },
+                ];
+            if (unmatchedOpenParen(without))
+                break;
+            rest = without;
+            trailing.unshift([{ kind: 'Text', text: ')' }]);
+        }
+        return { rest, trailing };
+    })();
+    const mid = rest.length > 0 ? [rest] : [];
+    return [...mid, ...trailing];
+}
+function canNlInsideDblBracket(args) {
+    if (args.length === 0)
+        return true;
+    const last = args[args.length - 1];
+    if (isUnquotedLiteral(last, '&&') ||
+        isUnquotedLiteral(last, '||') ||
+        isUnquotedLiteral(last, '!') ||
+        isUnquotedLiteral(last, '('))
+        return true;
+    if (isUnquotedLiteral(last, '=~') ||
+        isUnquotedLiteral(last, '==') ||
+        isUnquotedLiteral(last, '=') ||
+        isUnquotedLiteral(last, '!=') ||
+        isUnquotedLiteral(last, '-e') ||
+        isUnquotedLiteral(last, '-a') ||
+        isUnquotedLiteral(last, '-f') ||
+        isUnquotedLiteral(last, '-d') ||
+        isUnquotedLiteral(last, '-r') ||
+        isUnquotedLiteral(last, '-w') ||
+        isUnquotedLiteral(last, '-x') ||
+        isUnquotedLiteral(last, '-s') ||
+        isUnquotedLiteral(last, '-z') ||
+        isUnquotedLiteral(last, '-n') ||
+        isUnquotedLiteral(last, '-L') ||
+        isUnquotedLiteral(last, '-h') ||
+        isUnquotedLiteral(last, '-v'))
+        return false;
+    if (args.length === 1)
+        return false;
+    return true;
+}
+/** Most recent unquoted `=~` / `==` / `=` / `!=` still open in this `[[`. */
+function pendingPatternOp(args) {
+    for (let i = args.length - 1; i >= 0; i--) {
+        const w = args[i];
+        if (isUnquotedLiteral(w, '=~'))
+            return '=~';
+        if (isUnquotedLiteral(w, '==') ||
+            isUnquotedLiteral(w, '=') ||
+            isUnquotedLiteral(w, '!='))
+            return '==';
+        if (isUnquotedLiteral(w, '&&') || isUnquotedLiteral(w, '||'))
+            return null;
+    }
+    return null;
+}
 /* ------------------------------------------------------------------ */
 /* Parser                                                              */
 /* ------------------------------------------------------------------ */
@@ -237,17 +482,18 @@ export function parseCommand(input) {
     const parseList = () => {
         const segments = [];
         let op = ';';
-        while (peek().type === 'OP' && peek().op === ';')
+        const isListSep = (o) => o === ';' || o === '\n';
+        while (peek().type === 'OP' && isListSep(peek().op))
             next();
         while (peek().type !== 'EOF') {
             const pipeline = parsePipeline();
             segments.push({ pipeline, op });
             const t = peek();
-            if (t.type === 'OP' && (t.op === '&&' || t.op === '||' || t.op === ';')) {
-                op = t.op;
+            if (t.type === 'OP' && (t.op === '&&' || t.op === '||' || isListSep(t.op))) {
+                op = t.op === '\n' ? ';' : t.op;
                 next();
-                while (peek().type === 'OP' && peek().op === ';')
-                    next(); // trailing / duplicate ;
+                while (peek().type === 'OP' && isListSep(peek().op))
+                    next();
             }
             else if (t.type === 'EOF') {
                 break;
@@ -283,6 +529,95 @@ export function parseCommand(input) {
             if (t.type === 'EOF')
                 break;
             // possible redirect operator
+            // Inside `[[ ... ]]`, && || < > and other redirect-shaped tokens are
+            // conditional operators (or just words), not shell redirects/lists.
+            // Stop this special case at the first *unquoted* ]].
+            if (t.type === 'OP' &&
+                name !== null &&
+                isUnquotedLiteral(name, '[[') &&
+                !args.some((w) => isUnquotedLiteral(w, ']]')) &&
+                (t.op === '&&' ||
+                    t.op === '||' ||
+                    t.op === '|' ||
+                    t.op === '>' ||
+                    t.op === '<' ||
+                    t.op === '>>' ||
+                    t.op === '2>' ||
+                    t.op === '2>>' ||
+                    t.op === '&>' ||
+                    t.op === '&>>' ||
+                    t.op === '2>&1' ||
+                    t.op === '1>&2')) {
+                next();
+                // Glue `|` onto the surrounding words so `=~ ^a|z$`,
+                // `=~ (a | b)c`, and `== @(x | y)` stay one operand. A
+                // spaced `|` outside an open regex / extglob group is a
+                // syntax error (bash).
+                const last = args.length ? args[args.length - 1] : null;
+                const lastIsEqTilde = last !== null && isUnquotedLiteral(last, '=~');
+                const prevIsEqTilde = args.length >= 2 && isUnquotedLiteral(args[args.length - 2], '=~');
+                const openRe = last !== null &&
+                    pendingPatternOp(args) === '=~' &&
+                    unmatchedOpenParen(last);
+                const openExt = last !== null &&
+                    pendingPatternOp(args) === '==' &&
+                    unmatchedExtglob(last);
+                const inRe = lastIsEqTilde || prevIsEqTilde || openRe;
+                if (t.op === '|' || ((inRe || openExt) && t.tightLeft && t.op === '||')) {
+                    if (t.op === '|' &&
+                        !lastIsEqTilde &&
+                        !(prevIsEqTilde && t.tightLeft) &&
+                        !openRe &&
+                        !openExt) {
+                        throw new FauxnixParseError("fauxnix: [[: syntax error near unexpected token `|'");
+                    }
+                    const piece = t.tightLeft || lastIsEqTilde
+                        ? [{ kind: 'Text', text: t.op }]
+                        : [{ kind: 'Text', text: ' ' }, { kind: 'Text', text: t.op }];
+                    if (lastIsEqTilde)
+                        args.push(piece);
+                    else
+                        args[args.length - 1] = [...args[args.length - 1], ...piece];
+                    const n = peek();
+                    if (n.type === 'WORD' && n.tightLeft && n.parts) {
+                        next();
+                        args[args.length - 1] = [...args[args.length - 1], ...n.parts];
+                    }
+                }
+                else if (t.op === '&&' || t.op === '||' || t.op === '>' || t.op === '<') {
+                    if (openRe && last) {
+                        const piece = t.tightLeft
+                            ? [{ kind: 'Text', text: t.op }]
+                            : [{ kind: 'Text', text: ' ' }, { kind: 'Text', text: t.op }];
+                        args[args.length - 1] = [...last, ...piece];
+                        const n = peek();
+                        if (n.type === 'WORD' && n.tightLeft && n.parts) {
+                            next();
+                            args[args.length - 1] = [...args[args.length - 1], ...n.parts];
+                        }
+                    }
+                    else {
+                        args.push([{ kind: 'Text', text: t.op }]);
+                        if (t.op === '&&' || t.op === '||') {
+                            while (peek().type === 'OP' && peek().op === '\n')
+                                next();
+                        }
+                    }
+                }
+                else {
+                    throw new FauxnixParseError("fauxnix: [[: syntax error near unexpected token `" + t.op + "'");
+                }
+                continue;
+            }
+            if (t.type === 'OP' &&
+                t.op === '\n' &&
+                name !== null &&
+                isUnquotedLiteral(name, '[[') &&
+                !args.some((w) => isUnquotedLiteral(w, ']]')) &&
+                canNlInsideDblBracket(args)) {
+                next();
+                continue;
+            }
             if (t.type === 'OP' && isRedirectOp(t.op)) {
                 const op = t.op;
                 next();
@@ -308,12 +643,86 @@ export function parseCommand(input) {
                 next();
             }
             else {
-                args.push(word);
+                if (isUnquotedLiteral(name, '[[') && !args.some((a) => isUnquotedLiteral(a, ']]'))) {
+                    const pending = pendingPatternOp(args);
+                    const last = args.length ? args[args.length - 1] : null;
+                    // bash keeps `( x )` / `@(foo|bar baz)` as one =~ / extglob operand
+                    if (last &&
+                        !isUnquotedLiteral(word, ']]') &&
+                        !isUnquotedLiteral(word, '&&') &&
+                        !isUnquotedLiteral(word, '||') &&
+                        ((pending === '=~' && unmatchedOpenParen(last)) ||
+                            (pending === '==' && unmatchedExtglob(last)))) {
+                        const glued = [...last, { kind: 'Text', text: ' ' }, ...word];
+                        const pieces = pending === '=~'
+                            ? peelTrailingGroupCloses(glued, groupingDepth(args.slice(0, -1)))
+                            : splitCondParens(glued);
+                        args.pop();
+                        for (const sw of pieces) {
+                            if (sw.length > 0)
+                                args.push(sw);
+                        }
+                        next();
+                        continue;
+                    }
+                    if (hasBareAmp(word) && !(pending === '=~' && last && unmatchedOpenParen(last))) {
+                        throw new FauxnixParseError("fauxnix: [[: syntax error near unexpected token `&'");
+                    }
+                    if (pending === '==' && hasBareNonExtglobParen(word)) {
+                        throw new FauxnixParseError("fauxnix: [[: syntax error near unexpected token `('");
+                    }
+                    const pieces = pending === '=~'
+                        ? peelTrailingGroupCloses(word, groupingDepth(args))
+                        : splitCondParens(word);
+                    if (pending !== '=~') {
+                        for (const sw of pieces) {
+                            if (!isUnquotedLiteral(sw, '(') &&
+                                !isUnquotedLiteral(sw, ')') &&
+                                hasBareNonExtglobParen(sw) &&
+                                !looksLikeArithWord(sw)) {
+                                throw new FauxnixParseError("fauxnix: [[: syntax error near unexpected token `('");
+                            }
+                        }
+                    }
+                    for (const sw of pieces) {
+                        if (sw.length > 0)
+                            args.push(sw);
+                    }
+                }
+                else {
+                    args.push(word);
+                }
                 next();
             }
         }
-        if (!name)
+        if (!name) {
+            // assignment-only segment (`X=1; cmd`) — no command word
+            if (assignments.length > 0) {
+                return { kind: 'SimpleCommand', assignments, name: null, args: [], redirects };
+            }
             throw new FauxnixParseError('fauxnix: expected a command');
+        }
+        if (isUnquotedLiteral(name, '[[')) {
+            const close = args.findIndex((w) => isUnquotedLiteral(w, ']]'));
+            if (close < 0)
+                throw new FauxnixParseError("fauxnix: [[: missing `]]'");
+            if (close !== args.length - 1) {
+                throw new FauxnixParseError("fauxnix: [[: syntax error near unexpected token after `]]'");
+            }
+            if (args.slice(0, close).some((w) => unmatchedExtglob(w))) {
+                throw new FauxnixParseError('fauxnix: [[: syntax error in conditional expression');
+            }
+            for (let i = 0; i < close; i++) {
+                if (!isUnquotedLiteral(args[i], '=~') || i + 1 >= close)
+                    continue;
+                if (regexHasExtraClose(args[i + 1])) {
+                    throw new FauxnixParseError("fauxnix: [[: syntax error near unexpected token `)'");
+                }
+                if (unmatchedOpenParen(args[i + 1])) {
+                    throw new FauxnixParseError('fauxnix: [[: syntax error in conditional expression: unexpected end of file');
+                }
+            }
+        }
         return { kind: 'SimpleCommand', assignments, name, args, redirects };
     };
     const readRedirectTarget = () => {

package/dist/registry.js

@@ -18,6 +18,16 @@ export function registeredNames() {
 /* ------------------------------------------------------------------ */
 /** Escape a JS string into a single-quoted PowerShell string literal. */
 export function psStr(s) {
+    if (/[\r\n]/.test(s)) {
+        return ('"' +
+            s
+                .replace(/`/g, '``')
+                .replace(/"/g, '`"')
+                .replace(/\$/g, '`$')
+                .replace(/\r/g, '`r')
+                .replace(/\n/g, '`n') +
+            '"');
+    }
     return "'" + s.replace(/'/g, "''") + "'";
 }
 /** bash-style stderr line + exit-flag, as PS statements. */

package/dist/translator.d.ts

@@ -1,7 +1,9 @@
-import { CommandList, Redirect, SimpleCommand, Word } from './ast.js';
+import { Assignment, CommandList, Redirect, SimpleCommand, Word } from './ast.js';
 import { PipelineCtx } from './registry.js';
 /** Map a bash $VAR name to a PowerShell expression (usable inside $(...)). */
-export declare function varExpr(name: string): string;
+export declare function varExpr(name: string, index?: string): string;
+/** Escape text destined for the inside of a PS double-quoted string. */
+export declare function escapeDq(s: string): string;
 /** Normalize a literal POSIX-ish path to its Windows equivalent. */
 export declare function normalizeLiteralPath(s: string): string;
 /**
@@ -15,7 +17,9 @@ export declare function pathExpr(s: string): string;
  * Literal words become single-quoted strings; dynamic ones become
  * double-quoted strings with $(...) interpolation.
  */
-export declare function exprOfWord(w: Word): string;
+export declare function exprOfWord(w: Word, opts?: {
+    preserveCmdSub?: boolean;
+}): string;
 /** Literal text of a word when it contains no interpolation, else null. */
 export declare function literalOfWord(w: Word): string | null;
 /**
@@ -23,9 +27,39 @@ export declare function literalOfWord(w: Word): string | null;
  * Literal paths get POSIX-ish normalization (/dev/null, /tmp, /d/...).
  */
 export declare function operandExpr(w: Word): string;
-/** Translate the inside of $(...) — pipelines only, no wrappers. */
-export declare function translateCmdSub(cmdText: string): string;
+/**
+ * `${name[@]}` / `"pre${name[@]}post"` — one argv per element.
+ * Unquoted `${name[*]}` also splats (bash); quoted `"${name[*]}"` stays one join.
+ */
+export declare function splatSpec(w: Word): {
+    name: string;
+    prefix: string;
+    suffix: string;
+} | null;
+/** PS expression of a string[]: `@` words splat, others stay one element. */
+export declare function argListExpr(words: Word[], fn?: (w: Word) => string): string;
+/**
+ * Translate the inside of $(...).
+ * `keepNl`: quoted words and assignments keep interior newlines (bash).
+ * Unquoted command words join non-empty lines with a space (IFS
+ * word-split approximation). Handlers often emit one string object, so
+ * a bare `$(…)` interpolation would keep those newlines.
+ */
+export declare function translateCmdSub(cmdText: string, keepNl?: boolean): string;
 export declare function translateSimple(cmd: SimpleCommand, position: PipelineCtx['position'], hasStdin: boolean): string;
+/** PS expr: encode a string so SETVALS records can stay newline-delimited. */
+export declare function encodeSetValExpr(srcExpr: string): string;
+/**
+ * Apply env assignments (and optional unsets) only for `body`, then restore.
+ * All assignment *values* are evaluated before any name is mutated.
+ * `persistWords` are evaluated after the prefix is applied (so
+ * `export "$NAME"` sees the current env) and those names are not restored.
+ */
+export declare function wrapTempEnv(sets: Assignment[], body: string, extra?: {
+    unsets?: string[];
+    persistNames?: Set<string>;
+    persistWords?: Word[];
+}): string;
 export interface PipelineParts {
     /** Generated function definitions (empty for single commands). */
     defs: string;