fauxnix-cli 0.2.1 → 0.4.0

package/dist/translator.js

@@ -1,11 +1,17 @@
-import { FauxnixParseError, } from './ast.js';
+import { FauxnixParseError, isUnquotedLiteral, } from './ast.js';
 import { parseCommand } from './parser.js';
 import { lookup, psStr } from './registry.js';
 /* ------------------------------------------------------------------ */
 /* Variable mapping                                                    */
 /* ------------------------------------------------------------------ */
 /** Map a bash $VAR name to a PowerShell expression (usable inside $(...)). */
-export function varExpr(name) {
+export function varExpr(name, index) {
+    // Indexed reads always go through fx-subget → fx-arrload → fx-scalar0 so
+    // ${PWD[0]} keeps the special mapping and ${bash_rematch[0]} stays
+    // case-exact (a `$env:name` fallback would alias BASH_REMATCH on Windows).
+    if (index !== undefined) {
+        return '(fx-subget ' + psStr(name) + ' ' + psStr(index) + ')';
+    }
     switch (name) {
         case 'HOME':
             return '$HOME';
@@ -36,8 +42,13 @@ export function varExpr(name) {
 /* Word → PowerShell expression                                        */
 /* ------------------------------------------------------------------ */
 /** Escape text destined for the inside of a PS double-quoted string. */
-function escDq(s) {
-    return s.replace(/`/g, '``').replace(/"/g, '\\"').replace(/\$/g, '`$');
+export function escapeDq(s) {
+    return s
+        .replace(/`/g, '``')
+        .replace(/"/g, '`"')
+        .replace(/\$/g, '`$')
+        .replace(/\r/g, '`r')
+        .replace(/\n/g, '`n');
 }
 /** Normalize a literal POSIX-ish path to its Windows equivalent. */
 export function normalizeLiteralPath(s) {
@@ -80,7 +91,7 @@ export function pathExpr(s) {
  * Literal words become single-quoted strings; dynamic ones become
  * double-quoted strings with $(...) interpolation.
  */
-export function exprOfWord(w) {
+export function exprOfWord(w, opts) {
     // tilde expansion (unquoted leading ~)
     const expanded = [];
     if (w.length > 0 && w[0].kind === 'Text' && w[0].text.startsWith('~')) {
@@ -95,7 +106,12 @@ export function exprOfWord(w) {
     }
     // single bare variable → bare expression
     if (expanded.length === 1 && expanded[0].kind === 'Var') {
-        return varExpr(expanded[0].name);
+        return varExpr(expanded[0].name, expanded[0].index);
+    }
+    // Bare `$(...)` must not sit inside a PS expandable string: the
+    // substitution body contains `"` / `$_` that would break interpolation.
+    if (expanded.length === 1 && expanded[0].kind === 'CmdSub') {
+        return '$(' + translateCmdSub(expanded[0].cmd, opts?.preserveCmdSub === true) + ')';
     }
     const literal = expanded.every((p) => p.kind === 'Text' || p.kind === 'SingleQuoted');
     if (literal) {
@@ -104,28 +120,28 @@ export function exprOfWord(w) {
     }
     // dynamic — build a PS double-quoted string with interpolation
     let out = '"';
-    const emitPart = (p) => {
+    const emitPart = (p, quoted) => {
         switch (p.kind) {
             case 'Text':
-                out += escDq(p.text);
+                out += escapeDq(p.text);
                 break;
             case 'SingleQuoted':
-                out += escDq(p.text);
+                out += escapeDq(p.text);
                 break;
             case 'DoubleQuoted':
                 for (const q of p.parts)
-                    emitPart(q);
+                    emitPart(q, true);
                 break;
             case 'Var':
-                out += '$(' + varExpr(p.name) + ')';
+                out += '$(' + varExpr(p.name, p.index) + ')';
                 break;
             case 'CmdSub':
-                out += '$(' + translateCmdSub(p.cmd) + ')';
+                out += '$(' + translateCmdSub(p.cmd, quoted || opts?.preserveCmdSub === true) + ')';
                 break;
         }
     };
     for (const p of expanded)
-        emitPart(p);
+        emitPart(p, false);
     out += '"';
     return out;
 }
@@ -148,27 +164,136 @@ export function operandExpr(w) {
         return pathExpr(normalizeLiteralPath(lit));
     return exprOfWord(w);
 }
+/** Flatten quotes but remember whether a part sat inside `"..."`. */
+function wordPartsForSplat(w) {
+    const out = [];
+    const walk = (parts, quoted) => {
+        for (const p of parts) {
+            if (p.kind === 'DoubleQuoted')
+                walk(p.parts, true);
+            else
+                out.push({ part: p, quoted });
+        }
+    };
+    walk(w, false);
+    return out;
+}
+/**
+ * `${name[@]}` / `"pre${name[@]}post"` — one argv per element.
+ * Unquoted `${name[*]}` also splats (bash); quoted `"${name[*]}"` stays one join.
+ */
+export function splatSpec(w) {
+    const parts = wordPartsForSplat(w);
+    let name = null;
+    let prefix = '';
+    let suffix = '';
+    let seen = false;
+    for (const { part: p, quoted } of parts) {
+        const splat = p.kind === 'Var' && (p.index === '@' || (p.index === '*' && !quoted));
+        if (splat) {
+            if (seen)
+                return null;
+            seen = true;
+            name = p.name;
+            continue;
+        }
+        if (p.kind !== 'Text' && p.kind !== 'SingleQuoted')
+            return null;
+        if (seen)
+            suffix += p.text;
+        else
+            prefix += p.text;
+    }
+    return name ? { name, prefix, suffix } : null;
+}
+/** PS expression of a string[]: `@` words splat, others stay one element. */
+export function argListExpr(words, fn = exprOfWord) {
+    if (words.length === 0)
+        return '@()';
+    return ('(' +
+        words
+            .map((w) => {
+            const s = splatSpec(w);
+            if (!s)
+                return '@(' + fn(w) + ')';
+            if (!s.prefix && !s.suffix)
+                return '@(fx-arrload ' + psStr(s.name) + ')';
+            return ('@($( $fx_sp = @(fx-arrload ' +
+                psStr(s.name) +
+                '); if ($fx_sp.Count -eq 0) { $fx_sp = @(' +
+                psStr(s.prefix + s.suffix) +
+                ') } else { $fx_sp[0] = ' +
+                psStr(s.prefix) +
+                ' + $fx_sp[0]; $fx_sp[$fx_sp.Count-1] = $fx_sp[$fx_sp.Count-1] + ' +
+                psStr(s.suffix) +
+                ' }; $fx_sp ))');
+        })
+            .join(' + ') +
+        ')');
+}
 /* ------------------------------------------------------------------ */
 /* Command substitution                                                */
 /* ------------------------------------------------------------------ */
-/** Translate the inside of $(...) — pipelines only, no wrappers. */
-export function translateCmdSub(cmdText) {
+/**
+ * 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 function translateCmdSub(cmdText, keepNl = false) {
     const list = parseCommand(cmdText);
     if (list.segments.length !== 1) {
         throw new FauxnixParseError('fauxnix: command substitution with ; && || is not supported yet');
     }
     const { defs, call } = translatePipelineBody(list.segments[0].pipeline);
-    return defs ? defs + '\n' + call : call;
+    const inner = defs ? defs + '\n' + call : call;
+    const collected = '(fx-csub { ' + inner + ' })';
+    if (keepNl)
+        return collected;
+    return ('((' +
+        collected +
+        " -split [string][char]10 | Where-Object { $_ -ne '' }) -join ' ')");
 }
 /* ------------------------------------------------------------------ */
 /* Simple command translation                                          */
 /* ------------------------------------------------------------------ */
 export function translateSimple(cmd, position, hasStdin) {
+    // assignment-only segment (`X=1; cmd`): bash semantics are "set for the
+    // rest of the shell". Reuse the export code path — persist + env shadow —
+    // so empty values (`X=`) and `[[ -v X ]]` behave like bash (documented
+    // deviation: shell var vs exported var are indistinguishable here).
+    if (cmd.name === null) {
+        const exportHandler = lookup('export');
+        const words = cmd.assignments.map((a) => [
+            { kind: 'Text', text: a.name + '=' },
+            ...a.value,
+        ]);
+        return exportHandler ? exportHandler(words, { position, hasStdin }) : '';
+    }
     const nameLit = literalOfWord(cmd.name);
+    const nameSplat = splatSpec(cmd.name);
     let body;
-    if (nameLit !== null) {
+    if (nameSplat) {
+        const invoke = '& $fx_cmd @fx_na';
+        body = [
+            '$fx_cw = @(fx-arrload ' + psStr(nameSplat.name) + ')',
+            'if ($fx_cw.Count -eq 0) { $fx_cw = @(' + psStr(nameSplat.prefix + nameSplat.suffix) + ') }',
+            'else { $fx_cw[0] = ' +
+                psStr(nameSplat.prefix) +
+                ' + $fx_cw[0]; $fx_cw[$fx_cw.Count-1] = $fx_cw[$fx_cw.Count-1] + ' +
+                psStr(nameSplat.suffix) +
+                ' }',
+            '$fx_cmd = [string]$fx_cw[0]',
+            '$fx_na = ' + argListExpr(cmd.args),
+            'if ($fx_cw.Count -gt 1) { $fx_na = @($fx_cw[1..($fx_cw.Count - 1)]) + $fx_na }',
+            (hasStdin ? '($input | ' + invoke + ')' : invoke) + ' | ForEach-Object { [string]$_ }',
+            'if ($LASTEXITCODE -gt 0) { $script:fx_exit = $LASTEXITCODE } elseif ($LASTEXITCODE -lt 0) { $script:fx_exit = 1 }',
+        ].join('\n');
+    }
+    else if (nameLit !== null) {
         const handler = lookup(nameLit);
-        if (handler) {
+        if (handler && !(nameLit === '[[' && !isUnquotedLiteral(cmd.name, '[['))) {
             body = handler(cmd.args, { position, hasStdin });
         }
         else {
@@ -176,12 +301,11 @@ export function translateSimple(cmd, position, hasStdin) {
             // invoked with the call operator and an argv-style argument array —
             // no string re-parsing of user text.
             const nameExpr = psStr(nameLit);
-            const argExprs = cmd.args.map((a) => exprOfWord(a));
-            const args = argExprs.length ? ' @(' + argExprs.join(', ') + ')' : '';
-            const call = '& ' + nameExpr + args;
+            const invoke = '& ' + nameExpr + ' @fx_na';
             body = [
+                '$fx_na = ' + argListExpr(cmd.args),
                 // feed pipeline stdin into the native process when we are a non-first stage
-                (hasStdin ? '($input | ' + call + ')' : call) + ' | ForEach-Object { [string]$_ }',
+                (hasStdin ? '($input | ' + invoke + ')' : invoke) + ' | ForEach-Object { [string]$_ }',
                 'if ($LASTEXITCODE -gt 0) { $script:fx_exit = $LASTEXITCODE } elseif ($LASTEXITCODE -lt 0) { $script:fx_exit = 1 }',
             ].join('\n');
         }
@@ -189,23 +313,277 @@ export function translateSimple(cmd, position, hasStdin) {
     else {
         // dynamic command name — evaluate it
         const nameExpr = exprOfWord(cmd.name);
-        const argExprs = cmd.args.map((a) => exprOfWord(a));
-        const args = argExprs.length ? ' @(' + argExprs.join(', ') + ')' : '';
-        const call = '& (' + nameExpr + ')' + args;
+        const invoke = '& (' + nameExpr + ') @fx_na';
         body = [
-            (hasStdin ? '($input | ' + call + ')' : call) + ' | ForEach-Object { [string]$_ }',
+            '$fx_na = ' + argListExpr(cmd.args),
+            (hasStdin ? '($input | ' + invoke + ')' : invoke) + ' | ForEach-Object { [string]$_ }',
             'if ($LASTEXITCODE -gt 0) { $script:fx_exit = $LASTEXITCODE } elseif ($LASTEXITCODE -lt 0) { $script:fx_exit = 1 }',
         ].join('\n');
     }
-    // `VAR=value cmd ...` prefix — set process env for the invocation.
+    // `VAR=value cmd` is command-scoped. Values are captured in the
+    // current environment, then applied, then restored — including when
+    // the command throws — so they never leak into later list segments
+    // or the persisted MCP session. `VAR=x export VAR` keeps VAR (bash).
     if (cmd.assignments.length > 0) {
-        const sets = cmd.assignments
-            .map((a) => '$env:' + a.name + ' = ' + exprOfWord(a.value))
-            .join('; ');
-        body = sets + '\n' + body;
+        const persistNames = new Set();
+        const persistWords = [];
+        if (nameLit === 'export') {
+            for (const w of cmd.args) {
+                const lit = literalExportName(w);
+                if (lit === '')
+                    continue; // flag
+                if (lit)
+                    persistNames.add(lit);
+                else
+                    persistWords.push(w);
+            }
+        }
+        body = wrapTempEnv(cmd.assignments, body, { persistNames, persistWords });
     }
     return body;
 }
+/** Literal `NAME` / `NAME=...` from an export argument. `''` = flag. */
+function literalExportName(w) {
+    if (w.length === 0)
+        return null;
+    let s = '';
+    for (const p of w) {
+        if (p.kind !== 'Text' && p.kind !== 'SingleQuoted')
+            return null;
+        const eq = p.text.indexOf('=');
+        if (eq >= 0) {
+            const name = s + p.text.slice(0, eq);
+            return /^[A-Za-z_][A-Za-z0-9_]*$/.test(name) ? name : null;
+        }
+        s += p.text;
+    }
+    if (s.startsWith('-'))
+        return '';
+    return /^[A-Za-z_][A-Za-z0-9_]*$/.test(s) ? s : null;
+}
+let tempEnvSeq = 0;
+/** PS expr: encode a string so SETVALS records can stay newline-delimited. */
+export function encodeSetValExpr(srcExpr) {
+    return ('([string](' +
+        srcExpr +
+        ')).Replace([string][char]92, ([string][char]92 + [string][char]92)).Replace([string][char]13, ([string][char]92 + [char]114)).Replace([string][char]10, ([string][char]92 + [char]110))');
+}
+/**
+ * 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 function wrapTempEnv(sets, body, extra) {
+    const unsets = extra?.unsets ?? [];
+    const persistNames = extra?.persistNames ?? new Set();
+    const persistWords = extra?.persistWords;
+    const names = [];
+    const seen = new Set();
+    for (const s of sets) {
+        if (!seen.has(s.name)) {
+            seen.add(s.name);
+            names.push(s.name);
+        }
+    }
+    for (const u of unsets) {
+        if (!seen.has(u)) {
+            seen.add(u);
+            names.push(u);
+        }
+    }
+    if (names.length === 0)
+        return body;
+    const assigned = new Set(sets.map((s) => s.name));
+    const id = tempEnvSeq++;
+    const save = '$fx_es' + id;
+    const arrSave = '$fx_ar' + id;
+    const keep = persistWords && persistWords.length > 0 ? '$fx_ek' + id : '';
+    const lines = [
+        save + ' = @{}',
+        arrSave + ' = @{}',
+        '$fx_sv0' + id + ' = $env:FAUXNIX_SETVARS',
+        '$fx_uv0' + id + ' = $env:FAUXNIX_UNSETVARS',
+        '$fx_xv0' + id + ' = $env:FAUXNIX_SETVALS',
+    ];
+    for (const n of names) {
+        const p = psStr('Env:\\' + n);
+        lines.push(save +
+            '[' +
+            psStr(n) +
+            '] = $(if (Test-Path -LiteralPath ' +
+            p +
+            ') { [string](Get-Item -LiteralPath ' +
+            p +
+            ').Value } else { $null })');
+        lines.push(arrSave + '[' + psStr(n) + '] = (fx-arrpackget ' + psStr(n) + ')');
+    }
+    const valVars = [];
+    for (let i = 0; i < sets.length; i++) {
+        const vn = '$fx_ev' + id + '_' + i;
+        valVars.push(vn);
+        lines.push(vn + ' = ' + exprOfWord(sets[i].value, { preserveCmdSub: true }));
+    }
+    lines.push('try {');
+    for (const u of unsets) {
+        const uq = u.replace(/'/g, "''");
+        lines.push('  Remove-Item -LiteralPath ' + psStr('Env:\\' + u) + ' -ErrorAction SilentlyContinue');
+        lines.push('  fx-arrdrop ' + psStr(u));
+        // `env -u NAME` must hide NAME from fx-envget / fx-isset for the
+        // wrapped body. Removing Env:\NAME is not enough: an earlier
+        // `export NAME=x` still lives in SETVARS/SETVALS, and special
+        // names (PATH, HOME, …) have hardcoded fallbacks.
+        lines.push("  $env:FAUXNIX_SETVARS = (@($env:FAUXNIX_SETVARS -split ';' | Where-Object { $_ -ne '' -and $_ -cne '" +
+            uq +
+            "' }) -join ';')");
+        lines.push("  $env:FAUXNIX_UNSETVARS = ((@($env:FAUXNIX_UNSETVARS -split ';' | Where-Object { $_ -ne '' -and $_ -cne '" +
+            uq +
+            "' }) + '" +
+            uq +
+            "') -join ';')");
+        lines.push('  $fx_sm = @(); foreach ($fx_pair in @($env:FAUXNIX_SETVALS -split [string][char]10)) { $fx_eq = $fx_pair.IndexOf([char]61); if ($fx_eq -lt 1) { continue }; if ($fx_pair.Substring(0, $fx_eq) -cne \'' +
+            uq +
+            '\') { $fx_sm += $fx_pair } }; $env:FAUXNIX_SETVALS = ($fx_sm -join [string][char]10)');
+    }
+    for (let i = 0; i < sets.length; i++) {
+        const n = sets[i].name;
+        const nq = n.replace(/'/g, "''");
+        lines.push('  $env:' + n + ' = ' + valVars[i]);
+        lines.push('  fx-arrdrop ' + psStr(n));
+        lines.push("  $env:FAUXNIX_SETVARS = ((@($env:FAUXNIX_SETVARS -split ';' | Where-Object { $_ -ne '' -and $_ -cne '" +
+            nq +
+            "' }) + '" +
+            nq +
+            "') -join ';')");
+        lines.push("  $env:FAUXNIX_UNSETVARS = (@($env:FAUXNIX_UNSETVARS -split ';' | Where-Object { $_ -ne '' -and $_ -cne '" +
+            nq +
+            "' }) -join ';')");
+        lines.push('  $fx_sm = @(); foreach ($fx_pair in @($env:FAUXNIX_SETVALS -split [string][char]10)) { $fx_eq = $fx_pair.IndexOf([char]61); if ($fx_eq -lt 1) { continue }; if ($fx_pair.Substring(0, $fx_eq) -cne \'' +
+            nq +
+            '\') { $fx_sm += $fx_pair } }; $fx_sm += (\'' +
+            nq +
+            "' + [string][char]61 + " +
+            encodeSetValExpr(valVars[i]) +
+            '); $env:FAUXNIX_SETVALS = ($fx_sm -join [string][char]10)');
+    }
+    if (keep) {
+        lines.push('  ' + keep + ' = @{}');
+        for (const w of persistWords) {
+            const ev = '$fx_en' + id + '_' + lines.length;
+            lines.push('  ' + ev + ' = [string](' + exprOfWord(w) + ')');
+            lines.push('  if (' +
+                ev +
+                " -notmatch '^-') { $fx_nm = if (" +
+                ev +
+                ".Contains([string][char]61)) { " +
+                ev +
+                '.Substring(0, ' +
+                ev +
+                ".IndexOf([string][char]61)) } else { " +
+                ev +
+                " }; if ($fx_nm -match '^[A-Za-z_][A-Za-z0-9_]*$') { " +
+                keep +
+                '[$fx_nm] = $true } }');
+        }
+    }
+    for (const l of body.split('\n'))
+        lines.push(l ? '  ' + l : l);
+    lines.push('} finally {');
+    lines.push('  $env:FAUXNIX_SETVARS = $fx_sv0' + id);
+    lines.push('  $env:FAUXNIX_UNSETVARS = $fx_uv0' + id);
+    lines.push('  $env:FAUXNIX_SETVALS = $fx_xv0' + id);
+    for (const n of names) {
+        if (persistNames.has(n))
+            continue;
+        const p = psStr('Env:\\' + n);
+        if (keep) {
+            lines.push('  $fx_skip = if (' + keep + '[' + psStr(n) + ']) { $true } else { $false }');
+            lines.push('  if (-not $fx_skip) { if ($null -eq ' +
+                save +
+                '[' +
+                psStr(n) +
+                ']) { Remove-Item -LiteralPath ' +
+                p +
+                ' -ErrorAction SilentlyContinue } else { Set-Item -LiteralPath ' +
+                p +
+                ' -Value ' +
+                save +
+                '[' +
+                psStr(n) +
+                '] } }');
+        }
+        else {
+            lines.push('  if ($null -eq ' +
+                save +
+                '[' +
+                psStr(n) +
+                ']) { Remove-Item -LiteralPath ' +
+                p +
+                ' -ErrorAction SilentlyContinue } else { Set-Item -LiteralPath ' +
+                p +
+                ' -Value ' +
+                save +
+                '[' +
+                psStr(n) +
+                '] }');
+        }
+        const restoreArr = 'fx-arrpackset ' + psStr(n) + ' ' + arrSave + '[' + psStr(n) + ']';
+        if (keep) {
+            lines.push('  if (-not $fx_skip) { ' + restoreArr + ' }');
+        }
+        else {
+            lines.push('  ' + restoreArr);
+        }
+    }
+    for (const n of persistNames) {
+        const nq = n.replace(/'/g, "''");
+        const ep = psStr('Env:\\' + n);
+        // Bare `export UNSET` only marks the name for export; it must stay
+        // unset (`[[ -v UNSET ]]` is false). Persist a record only when the
+        // prefix assigned the name (including empty) or it already exists.
+        const cond = assigned.has(n) ? '$true' : '(Test-Path -LiteralPath ' + ep + ')';
+        lines.push('  if (' + cond + ') {');
+        lines.push("    $env:FAUXNIX_SETVARS = ((@($env:FAUXNIX_SETVARS -split ';' | Where-Object { $_ -ne '' -and $_ -cne '" +
+            nq +
+            "' }) + '" +
+            nq +
+            "') -join ';')");
+        lines.push("    $env:FAUXNIX_UNSETVARS = (@($env:FAUXNIX_UNSETVARS -split ';' | Where-Object { $_ -ne '' -and $_ -cne '" +
+            nq +
+            "' }) -join ';')");
+        lines.push('    $fx_pv = $(if (Test-Path -LiteralPath ' +
+            ep +
+            ') { [string](Get-Item -LiteralPath ' +
+            ep +
+            ").Value } else { '' })");
+        lines.push('    $fx_sm = @(); foreach ($fx_pair in @($env:FAUXNIX_SETVALS -split [string][char]10)) { $fx_eq = $fx_pair.IndexOf([char]61); if ($fx_eq -lt 1) { continue }; if ($fx_pair.Substring(0, $fx_eq) -cne \'' +
+            nq +
+            '\') { $fx_sm += $fx_pair } }; $fx_sm += (\'' +
+            nq +
+            "' + [string][char]61 + " +
+            encodeSetValExpr('$fx_pv') +
+            '); $env:FAUXNIX_SETVALS = ($fx_sm -join [string][char]10)');
+        lines.push('  }');
+    }
+    if (keep) {
+        const had = '@(' +
+            [...assigned].map((n) => "'" + n.replace(/'/g, "''") + "'").join(',') +
+            ')';
+        lines.push('  foreach ($fx_pn in @(' + keep + '.Keys)) {');
+        lines.push('    if (-not ((Test-Path -LiteralPath (\'Env:\\\' + $fx_pn)) -or (' +
+            had +
+            ' -ccontains $fx_pn))) { continue }');
+        lines.push("    $env:FAUXNIX_SETVARS = ((@($env:FAUXNIX_SETVARS -split ';' | Where-Object { $_ -ne '' -and $_ -cne $fx_pn }) + $fx_pn) -join ';')");
+        lines.push("    $env:FAUXNIX_UNSETVARS = (@($env:FAUXNIX_UNSETVARS -split ';' | Where-Object { $_ -ne '' -and $_ -cne $fx_pn }) -join ';')");
+        lines.push("    $fx_pv = $(if (Test-Path -LiteralPath ('Env:\\' + $fx_pn)) { [string](Get-Item -LiteralPath ('Env:\\' + $fx_pn)).Value } else { '' })");
+        lines.push('    $fx_sm = @(); foreach ($fx_pair in @($env:FAUXNIX_SETVALS -split [string][char]10)) { $fx_eq = $fx_pair.IndexOf([char]61); if ($fx_eq -lt 1) { continue }; if ($fx_pair.Substring(0, $fx_eq) -cne $fx_pn) { $fx_sm += $fx_pair } }; $fx_sm += ($fx_pn + [string][char]61 + ' +
+            encodeSetValExpr('$fx_pv') +
+            '); $env:FAUXNIX_SETVALS = ($fx_sm -join [string][char]10)');
+        lines.push('  }');
+    }
+    lines.push('}');
+    return lines.join('\n');
+}
 /** Unique suffix for generated stage functions (nested pipelines included). */
 let stageSeq = 0;
 /**
@@ -302,6 +680,144 @@ export function wrapScript(body) {
         "  if ($parts[$parts.Count - 1] -eq '') { $parts = $parts[0..($parts.Count - 2)] }",
         '  return $parts',
         '}',
+        'function fx-csub([scriptblock]$b) {',
+        '  $fx_prevcs = $script:fx_csub',
+        '  $script:fx_csub = $true',
+        '  try { $fx_o = @(& $b | ForEach-Object { [string]$_ }) }',
+        '  finally { $script:fx_csub = $fx_prevcs }',
+        '  $fx_s = ($fx_o -join [string][char]10)',
+        '  while ($fx_s.Length -gt 0 -and $fx_s[$fx_s.Length - 1] -eq [char]10) {',
+        '    $fx_s = $fx_s.Substring(0, $fx_s.Length - 1)',
+        '  }',
+        '  return $fx_s',
+        '}',
+        'function fx-svenc($s) {',
+        '  return ([string]$s).Replace([string][char]92, ([string][char]92 + [string][char]92)).Replace([string][char]13, ([string][char]92 + [char]114)).Replace([string][char]10, ([string][char]92 + [char]110))',
+        '}',
+        'function fx-svdec($s) {',
+        '  $s = [string]$s',
+        '  $sb = New-Object System.Text.StringBuilder',
+        '  $i = 0',
+        '  while ($i -lt $s.Length) {',
+        '    $c = $s[$i]',
+        '    if ($c -eq [char]92 -and ($i + 1) -lt $s.Length) {',
+        '      $n2 = $s[$i + 1]',
+        '      if ($n2 -eq [char]110) { [void]$sb.Append([char]10); $i += 2; continue }',
+        '      if ($n2 -eq [char]114) { [void]$sb.Append([char]13); $i += 2; continue }',
+        '      if ($n2 -eq [char]92) { [void]$sb.Append([char]92); $i += 2; continue }',
+        '    }',
+        '    [void]$sb.Append($c)',
+        '    $i++',
+        '  }',
+        '  return [string]$sb',
+        '}',
+        'function fx-arrload($n) {',
+        '  $n = [string]$n',
+        '  foreach ($fx_pair in @($env:FAUXNIX_ARRS -split [string][char]10)) {',
+        '    $fx_eq = $fx_pair.IndexOf([char]61)',
+        '    if ($fx_eq -lt 1) { continue }',
+        '    if ($fx_pair.Substring(0, $fx_eq) -cne $n) { continue }',
+        '    $out = @()',
+        '    foreach ($el in @($fx_pair.Substring($fx_eq + 1) -split [string][char]30)) { $out += ,(fx-svdec $el) }',
+        '    return $out',
+        '  }',
+        '  $s0 = fx-scalar0 $n',
+        '  if ($null -eq $s0) { return @() }',
+        '  return @([string]$s0)',
+        '}',
+        'function fx-scalar0($n) {',
+        '  $n = [string]$n',
+        "  if (@($env:FAUXNIX_UNSETVARS -split ';' | Where-Object { $_ -ceq $n }).Count -gt 0) { return $null }",
+        '  foreach ($fx_pair in @($env:FAUXNIX_SETVALS -split [string][char]10)) {',
+        '    $fx_eq = $fx_pair.IndexOf([char]61)',
+        '    if ($fx_eq -lt 1) { continue }',
+        '    if ($fx_pair.Substring(0, $fx_eq) -ceq $n) { return (fx-svdec $fx_pair.Substring($fx_eq + 1)) }',
+        '  }',
+        "  if ($n -ceq 'HOME') { return [string]$HOME }",
+        "  if ($n -ceq 'PWD') { return [string]$PWD.Path }",
+        "  if ($n -ceq 'USER' -or $n -ceq 'LOGNAME') { return [string]$env:USERNAME }",
+        "  if ($n -ceq 'PATH') { return [string]$env:PATH }",
+        "  if ($n -ceq 'SHELL') { return 'powershell' }",
+        "  if ($n -ceq 'TERM') { return 'xterm-256color' }",
+        "  if ($n -ceq 'OLDPWD') { return $(if ($env:FAUXNIX_OLDPWD) { [string]$env:FAUXNIX_OLDPWD } else { $null }) }",
+        "  if ($n -ceq 'HOSTNAME') { return [string]$env:COMPUTERNAME }",
+        '  $ev = Get-ChildItem Env: | Where-Object { $_.Name -ceq $n } | Select-Object -First 1',
+        '  if ($ev) { return [string]$ev.Value }',
+        '  return $null',
+        '}',
+        'function fx-ifs1 {',
+        "  $s = fx-scalar0 'IFS'",
+        "  if ($null -eq $s) { return ' ' }",
+        "  if ([string]$s -eq '') { return '' }",
+        '  return [string]$s[0]',
+        '}',
+        'function fx-arrdrop($n) {',
+        '  $n = [string]$n',
+        '  $fx_sm = @()',
+        '  foreach ($fx_pair in @($env:FAUXNIX_ARRS -split [string][char]10)) {',
+        '    $fx_eq = $fx_pair.IndexOf([char]61)',
+        '    if ($fx_eq -lt 1) { continue }',
+        '    if ($fx_pair.Substring(0, $fx_eq) -cne $n) { $fx_sm += $fx_pair }',
+        '  }',
+        '  $env:FAUXNIX_ARRS = ($fx_sm -join [string][char]10)',
+        '}',
+        'function fx-arrhas($n) {',
+        '  $n = [string]$n',
+        '  foreach ($fx_pair in @($env:FAUXNIX_ARRS -split [string][char]10)) {',
+        '    $fx_eq = $fx_pair.IndexOf([char]61)',
+        '    if ($fx_eq -lt 1) { continue }',
+        '    if ($fx_pair.Substring(0, $fx_eq) -ceq $n) { return $true }',
+        '  }',
+        '  return $false',
+        '}',
+        'function fx-arrpackget($n) {',
+        '  $n = [string]$n',
+        '  foreach ($fx_pair in @($env:FAUXNIX_ARRS -split [string][char]10)) {',
+        '    $fx_eq = $fx_pair.IndexOf([char]61)',
+        '    if ($fx_eq -lt 1) { continue }',
+        '    if ($fx_pair.Substring(0, $fx_eq) -ceq $n) { return $fx_pair.Substring($fx_eq + 1) }',
+        '  }',
+        '  return $null',
+        '}',
+        'function fx-arrpackset($n, $pay) {',
+        '  fx-arrdrop $n',
+        '  if ($null -eq $pay) { return }',
+        "  $env:FAUXNIX_ARRS = ((@($env:FAUXNIX_ARRS -split [string][char]10 | Where-Object { $_ -ne '' }) + ([string]$n + [string][char]61 + [string]$pay)) -join [string][char]10)",
+        '}',
+        'function fx-arrput($n, $vals) {',
+        '  $n = [string]$n',
+        '  $vals = @($vals)',
+        '  fx-arrdrop $n',
+        '  if ($vals.Count -eq 0) { } else {',
+        '    $encs = @(); foreach ($v in $vals) { $encs += (fx-svenc $v) }',
+        "    $env:FAUXNIX_ARRS = ((@($env:FAUXNIX_ARRS -split [string][char]10 | Where-Object { $_ -ne '' }) + ($n + [string][char]61 + ($encs -join [string][char]30))) -join [string][char]10)",
+        '  }',
+        "  $fx_0 = $(if ($vals.Count -gt 0) { [string]$vals[0] } else { '' })",
+        '  Set-Item -LiteralPath (\'Env:\\\' + $n) -Value $fx_0',
+        "  $env:FAUXNIX_SETVARS = ((@($env:FAUXNIX_SETVARS -split ';' | Where-Object { $_ -ne '' -and $_ -cne $n }) + $n) -join ';')",
+        "  $env:FAUXNIX_UNSETVARS = (@($env:FAUXNIX_UNSETVARS -split ';' | Where-Object { $_ -ne '' -and $_ -cne $n }) -join ';')",
+        '  $fx_sv = @(); foreach ($fx_pair in @($env:FAUXNIX_SETVALS -split [string][char]10)) { $fx_eq = $fx_pair.IndexOf([char]61); if ($fx_eq -lt 1) { continue }; if ($fx_pair.Substring(0, $fx_eq) -cne $n) { $fx_sv += $fx_pair } }',
+        "  $fx_sv += ($n + [string][char]61 + (fx-svenc $fx_0)); $env:FAUXNIX_SETVALS = ($fx_sv -join [string][char]10)",
+        '}',
+        'function fx-arrclr($n) {',
+        '  $n = [string]$n',
+        '  fx-arrdrop $n',
+        "  Remove-Item -LiteralPath ('Env:\\' + $n) -ErrorAction SilentlyContinue",
+        "  $env:FAUXNIX_SETVARS = (@($env:FAUXNIX_SETVARS -split ';' | Where-Object { $_ -ne '' -and $_ -cne $n }) -join ';')",
+        "  $env:FAUXNIX_UNSETVARS = ((@($env:FAUXNIX_UNSETVARS -split ';' | Where-Object { $_ -ne '' -and $_ -cne $n }) + $n) -join ';')",
+        '  $fx_sv = @(); foreach ($fx_pair in @($env:FAUXNIX_SETVALS -split [string][char]10)) { $fx_eq = $fx_pair.IndexOf([char]61); if ($fx_eq -lt 1) { continue }; if ($fx_pair.Substring(0, $fx_eq) -cne $n) { $fx_sv += $fx_pair } }; $env:FAUXNIX_SETVALS = ($fx_sv -join [string][char]10)',
+        '}',
+        'function fx-subget($n, $ix) {',
+        '  $arr = @(fx-arrload $n)',
+        '  $ix = [string]$ix',
+        // argv-level `@` is expanded by argListExpr; this is the scalar/quoted-* join.
+        "  if ($ix -eq '*') { return ($arr -join (fx-ifs1)) }",
+        "  if ($ix -eq '@') { return ($arr -join (fx-ifs1)) }",
+        '  $i = 0',
+        '  if (-not [int]::TryParse($ix, [ref]$i)) { return \'\' }',
+        "  if ($i -lt 0 -or $i -ge $arr.Count) { return '' }",
+        '  return [string]$arr[$i]',
+        '}',
         'try {',
         ...body.split('\n').map((l) => '  ' + l),
         '} catch [System.Management.Automation.CommandNotFoundException] {',