typescript-virtual-container 1.4.3 → 1.4.4

package/src/modules/neofetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"neofetch.d.ts","sourceRoot":"","sources":["neofetch.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAsGvD,MAAM,WAAW,YAAY;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,eAAe,CAAC;IAC7B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;CACxB;AAkKD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,CA2E9D"}

package/src/modules/shellInteractive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shellInteractive.d.ts","sourceRoot":"","sources":["shellInteractive.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,8BAA8B,EAAS,MAAM,oBAAoB,CAAC;AAChF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAEN,KAAK,YAAY,EAEjB,MAAM,gBAAgB,CAAC;AA4BxB,wBAAgB,sBAAsB,CACrC,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,YAAY,EAC1B,MAAM,EAAE,WAAW,GACjB,8BAA8B,CAMhC;AAED,wBAAgB,gBAAgB,CAC/B,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,YAAY,EAC1B,MAAM,EAAE,WAAW,GACjB,8BAA8B,CAMhC"}

package/src/modules/shellRuntime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shellRuntime.d.ts","sourceRoot":"","sources":["shellRuntime.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,YAAY;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACb;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAK/C;AAED,wBAAgB,gBAAgB,CAC/B,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,YAAY,GACxB,MAAM,CAUR;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAOnE;AAED,wBAAsB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAoB3E;AAED,wBAAsB,qBAAqB,CAC1C,OAAO,SAAc,GACnB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAQxB"}

package/{dist → src}/self-standalone.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"self-standalone.d.ts","sourceRoot":"","sources":["../src/self-standalone.ts"],"names":[],"mappings":""}
+{"version":3,"file":"self-standalone.d.ts","sourceRoot":"","sources":["self-standalone.ts"],"names":[],"mappings":""}

package/src/standalone-wo-sftp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standalone-wo-sftp.d.ts","sourceRoot":"","sources":["standalone-wo-sftp.ts"],"names":[],"mappings":""}

package/{dist → src}/standalone.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"standalone.d.ts","sourceRoot":"","sources":["../src/standalone.ts"],"names":[],"mappings":""}
+{"version":3,"file":"standalone.d.ts","sourceRoot":"","sources":["standalone.ts"],"names":[],"mappings":""}

package/{dist → src}/types/commands.d.ts

@@ -57,7 +57,7 @@ export interface SudoChallenge {
      * Returns a `CommandResult` written to the terminal, or `null` to show
      * another prompt (pass `nextPrompt` to change the prompt text).
      */
-    onPassword?: (input: string, shell: import("../VirtualShell").VirtualShell) => Promise<{
+    onPassword?: (input: string, shell: VirtualShell) => Promise<{
         result: CommandResult | null;
         nextPrompt?: string;
     }>;

package/src/types/commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["commands.ts"],"names":[],"mappings":"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"}

package/src/types/commands.ts

@@ -60,7 +60,7 @@ export interface SudoChallenge {
 	 * Returns a `CommandResult` written to the terminal, or `null` to show
 	 * another prompt (pass `nextPrompt` to change the prompt text).
 	 */
-	onPassword?: (input: string, shell: import("../VirtualShell").VirtualShell) => Promise<{
+	onPassword?: (input: string, shell: VirtualShell) => Promise<{
 		result: CommandResult | null;
 		nextPrompt?: string;
 	}>;

package/src/types/pipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline.d.ts","sourceRoot":"","sources":["pipeline.ts"],"names":[],"mappings":"AAAA,iDAAiD;AACjD,MAAM,WAAW,eAAe;IAC/B,mBAAmB;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,wBAAwB;IACxB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,2CAA2C;IAC3C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,4CAA4C;IAC5C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,sCAAsC;IACtC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,6CAA6C;IAC7C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,uCAAuC;IACvC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,uCAAuC;IACvC,cAAc,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,wDAAwD;AACxD,MAAM,MAAM,SAAS,GAAG,IAAI,GAAG,IAAI,GAAG,GAAG,CAAC;AAE1C,yCAAyC;AACzC,MAAM,WAAW,QAAQ;IACxB,uCAAuC;IACvC,QAAQ,EAAE,eAAe,EAAE,CAAC;IAC5B,uCAAuC;IACvC,OAAO,EAAE,OAAO,CAAC;IACjB,sCAAsC;IACtC,KAAK,CAAC,EAAE,MAAM,CAAC;CACf;AAED,0FAA0F;AAC1F,MAAM,WAAW,SAAS;IACzB,8CAA8C;IAC9C,QAAQ,EAAE,QAAQ,CAAC;IACnB,0DAA0D;IAC1D,EAAE,CAAC,EAAE,SAAS,CAAC;IACf,2CAA2C;IAC3C,IAAI,CAAC,EAAE,SAAS,CAAC;CACjB;AAED,2CAA2C;AAC3C,MAAM,WAAW,MAAM;IACtB,0CAA0C;IAC1C,UAAU,EAAE,SAAS,EAAE,CAAC;IACxB,kDAAkD;IAClD,OAAO,EAAE,OAAO,CAAC;IACjB,oCAAoC;IACpC,KAAK,CAAC,EAAE,MAAM,CAAC;CACf"}

package/src/types/streams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streams.d.ts","sourceRoot":"","sources":["streams.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,UAAU;IAC1B,qCAAqC;IACrC,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,iCAAiC;IACjC,GAAG,IAAI,IAAI,CAAC;IACZ,qDAAqD;IACrD,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,+BAA+B;IAC/B,MAAM,EAAE;QACP,qCAAqC;QACrC,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;KAC1B,CAAC;CACF;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC3B,2CAA2C;IAC3C,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,qCAAqC;IACrC,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,yBAAyB;IACzB,GAAG,IAAI,IAAI,CAAC;IACZ,gDAAgD;IAChD,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI,CAAC;IAC3D,wCAAwC;IACxC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI,CAAC;CAC/C"}

package/src/types/vfs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vfs.d.ts","sourceRoot":"","sources":["vfs.ts"],"names":[],"mappings":"AAAA,oCAAoC;AACpC,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,WAAW,CAAC;AAE/C,oEAAoE;AACpE,MAAM,WAAW,WAAW;IAC3B,qCAAqC;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,qCAAqC;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,4BAA4B;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,+BAA+B;IAC/B,SAAS,EAAE,IAAI,CAAC;IAChB,6BAA6B;IAC7B,SAAS,EAAE,IAAI,CAAC;CAChB;AAED,0CAA0C;AAC1C,MAAM,WAAW,WAAY,SAAQ,WAAW;IAC/C,IAAI,EAAE,MAAM,CAAC;IACb,mDAAmD;IACnD,UAAU,EAAE,OAAO,CAAC;IACpB,4DAA4D;IAC5D,IAAI,EAAE,MAAM,CAAC;CACb;AAED,+CAA+C;AAC/C,MAAM,WAAW,gBAAiB,SAAQ,WAAW;IACpD,IAAI,EAAE,WAAW,CAAC;IAClB,8CAA8C;IAC9C,aAAa,EAAE,MAAM,CAAC;CACtB;AAED,kDAAkD;AAClD,MAAM,MAAM,YAAY,GAAG,WAAW,GAAG,gBAAgB,CAAC;AAE1D,wDAAwD;AACxD,MAAM,WAAW,gBAAgB;IAChC,uDAAuD;IACvD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,0CAA0C;IAC1C,QAAQ,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,qDAAqD;AACrD,MAAM,WAAW,aAAa;IAC7B,gDAAgD;IAChD,SAAS,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,gEAAgE;AAChE,MAAM,WAAW,mBAAmB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,mCAAmC;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,iCAAiC;IACjC,SAAS,EAAE,MAAM,CAAC;CAClB;AAED,gDAAgD;AAChD,MAAM,WAAW,mBAAoB,SAAQ,mBAAmB;IAC/D,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,OAAO,CAAC;IACpB,qCAAqC;IACrC,aAAa,EAAE,MAAM,CAAC;CACtB;AAED,qDAAqD;AACrD,MAAM,WAAW,wBAAyB,SAAQ,mBAAmB;IACpE,IAAI,EAAE,WAAW,CAAC;IAClB,QAAQ,EAAE,eAAe,EAAE,CAAC;CAC5B;AAED,kDAAkD;AAClD,MAAM,MAAM,eAAe,GAAG,mBAAmB,GAAG,wBAAwB,CAAC;AAE7E,gDAAgD;AAChD,MAAM,WAAW,WAAW;IAC3B,IAAI,EAAE,wBAAwB,CAAC;CAC/B;AAED,0DAA0D;AAC1D,MAAM,WAAW,YAAY;IAC5B,mDAAmD;IACnD,KAAK,EAAE,MAAM,CAAC;IACd,iFAAiF;IACjF,QAAQ,EAAE,MAAM,CAAC;IACjB,8EAA8E;IAC9E,QAAQ,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,uCAAuC;AACvC,MAAM,WAAW,UAAU;IAC1B,KAAK,EAAK,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;CAClB"}

package/{dist → src}/utils/expand.d.ts

@@ -18,9 +18,9 @@
  *   $((expr))     arithmetic (integer)
  */
 /**
- * Evaluate a simple integer arithmetic expression.
+ * Evaluate a simple integer arithmetic expression with a bounded parser.
  * Supports: +  -  *  /  %  **  unary-  ( )
- * Variables are resolved from `env` before evaluation.
+ * Variables are resolved from `env`.
  * Returns NaN on syntax error.
  */
 export declare function evalArith(expr: string, env: Record<string, string>): number;

package/src/utils/expand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expand.d.ts","sourceRoot":"","sources":["expand.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAmDH;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CA6F3E;AAoCD;;;;;;;;;GASG;AAEH;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAgFpD;AAsCD,wBAAgB,UAAU,CACzB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC3B,QAAQ,SAAI,EACZ,IAAI,CAAC,EAAE,MAAM,GACX,MAAM,CAyDR;AAID;;;;;;;;;;GAUG;AACH,wBAAsB,WAAW,CAChC,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC3B,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GACtC,OAAO,CAAC,MAAM,CAAC,CAmEjB"}

package/src/utils/expand.js

@@ -0,0 +1,476 @@
+/**
+ * expand.ts
+ *
+ * Centralised shell variable and expression expansion.
+ * Used by `runCommand` (index.ts), `echo`, and `sh.ts`.
+ *
+ * Handles (in order):
+ *   ~             tilde to $HOME
+ *   $?            last exit code
+ *   $$            mock PID
+ *   $#            argument count (0 outside scripts)
+ *   ${#VAR}       string length
+ *   ${VAR:-def}   default if unset/empty
+ *   ${VAR:=def}   assign default if unset/empty
+ *   ${VAR:+val}   alternate value if set
+ *   ${VAR}        simple braced reference
+ *   $VAR          simple reference
+ *   $((expr))     arithmetic (integer)
+ */
+function tokenizeArith(expr, env) {
+    const tokens = [];
+    let i = 0;
+    while (i < expr.length) {
+        const ch = expr[i];
+        if (/\s/.test(ch)) {
+            i++;
+            continue;
+        }
+        if (ch === "+") {
+            tokens.push({ type: "plus" });
+            i++;
+            continue;
+        }
+        if (ch === "-") {
+            tokens.push({ type: "minus" });
+            i++;
+            continue;
+        }
+        if (ch === "*") {
+            if (expr[i + 1] === "*") {
+                tokens.push({ type: "pow" });
+                i += 2;
+                continue;
+            }
+            tokens.push({ type: "mul" });
+            i++;
+            continue;
+        }
+        if (ch === "/") {
+            tokens.push({ type: "div" });
+            i++;
+            continue;
+        }
+        if (ch === "%") {
+            tokens.push({ type: "mod" });
+            i++;
+            continue;
+        }
+        if (ch === "(") {
+            tokens.push({ type: "lparen" });
+            i++;
+            continue;
+        }
+        if (ch === ")") {
+            tokens.push({ type: "rparen" });
+            i++;
+            continue;
+        }
+        if (/\d/.test(ch)) {
+            let j = i + 1;
+            while (j < expr.length && /\d/.test(expr[j]))
+                j++;
+            tokens.push({ type: "number", value: Number(expr.slice(i, j)) });
+            i = j;
+            continue;
+        }
+        if (/[A-Za-z_]/.test(ch)) {
+            let j = i + 1;
+            while (j < expr.length && /[A-Za-z0-9_]/.test(expr[j]))
+                j++;
+            const name = expr.slice(i, j);
+            const raw = env[name];
+            const value = raw === undefined || raw === "" ? 0 : Number(raw);
+            tokens.push({ type: "number", value: Number.isFinite(value) ? value : 0 });
+            i = j;
+            continue;
+        }
+        return [];
+    }
+    return tokens;
+}
+/**
+ * Evaluate a simple integer arithmetic expression with a bounded parser.
+ * Supports: +  -  *  /  %  **  unary-  ( )
+ * Variables are resolved from `env`.
+ * Returns NaN on syntax error.
+ */
+export function evalArith(expr, env) {
+    const trimmed = expr.trim();
+    if (trimmed.length === 0 || trimmed.length > 1024)
+        return NaN;
+    const tokens = tokenizeArith(trimmed, env);
+    if (tokens.length === 0)
+        return NaN;
+    let index = 0;
+    const peek = () => tokens[index];
+    const consume = () => tokens[index++];
+    const parsePrimary = () => {
+        const token = consume();
+        if (!token)
+            return NaN;
+        if (token.type === "number")
+            return token.value;
+        if (token.type === "lparen") {
+            const value = parseExpression();
+            if (tokens[index]?.type !== "rparen")
+                return NaN;
+            index++;
+            return value;
+        }
+        return NaN;
+    };
+    const parseUnary = () => {
+        const token = peek();
+        if (token?.type === "plus") {
+            consume();
+            return parseUnary();
+        }
+        if (token?.type === "minus") {
+            consume();
+            return -parseUnary();
+        }
+        return parsePrimary();
+    };
+    const parsePower = () => {
+        let left = parseUnary();
+        while (peek()?.type === "pow") {
+            consume();
+            const right = parseUnary();
+            left = left ** right;
+        }
+        return left;
+    };
+    const parseTerm = () => {
+        let left = parsePower();
+        while (true) {
+            const token = peek();
+            if (token?.type === "mul") {
+                consume();
+                left *= parsePower();
+                continue;
+            }
+            if (token?.type === "div") {
+                consume();
+                const right = parsePower();
+                left = right === 0 ? NaN : left / right;
+                continue;
+            }
+            if (token?.type === "mod") {
+                consume();
+                const right = parsePower();
+                left = right === 0 ? NaN : left % right;
+                continue;
+            }
+            return left;
+        }
+    };
+    const parseExpression = () => {
+        let left = parseTerm();
+        while (true) {
+            const token = peek();
+            if (token?.type === "plus") {
+                consume();
+                left += parseTerm();
+                continue;
+            }
+            if (token?.type === "minus") {
+                consume();
+                left -= parseTerm();
+                continue;
+            }
+            return left;
+        }
+    };
+    const result = parseExpression();
+    if (!Number.isFinite(result) || index !== tokens.length)
+        return NaN;
+    return Math.trunc(result);
+}
+// ─── synchronous expansion ───────────────────────────────────────────────────
+/**
+ * Apply a replacer only to portions of `input` that are NOT inside single quotes.
+ * Single-quoted content is passed through verbatim (POSIX sh behaviour).
+ */
+function outsideSingleQuotes(input, replacer) {
+    const parts = [];
+    let i = 0;
+    while (i < input.length) {
+        const sqIdx = input.indexOf("'", i);
+        if (sqIdx === -1) {
+            // No more single quotes — expand the rest
+            parts.push(replacer(input.slice(i)));
+            break;
+        }
+        // Expand the part before the single quote
+        parts.push(replacer(input.slice(i, sqIdx)));
+        // Find closing single quote — everything inside is literal
+        const closeIdx = input.indexOf("'", sqIdx + 1);
+        if (closeIdx === -1) {
+            // Unclosed quote — treat rest as literal
+            parts.push(input.slice(sqIdx));
+            break;
+        }
+        parts.push(input.slice(sqIdx, closeIdx + 1)); // include quotes
+        i = closeIdx + 1;
+    }
+    return parts.join("");
+}
+/**
+ * Expand all shell variable and expression forms synchronously.
+ * Does NOT handle `$(cmd)` — that requires async; see `expandAsync`.
+ * Content inside single quotes is left verbatim per POSIX sh rules.
+ *
+ * @param input     Raw string possibly containing `$VAR`, `${...}`, `$((...))`.
+ * @param env       Current session env vars.
+ * @param lastExit  Last command exit code (for `$?`).
+ * @param home      Home directory path (for `~`).
+ */
+/**
+ * Expand brace expressions in a single token.
+ * - `{a,b,c}` → `["a", "b", "c"]`
+ * - `{1..5}` → `["1", "2", "3", "4", "5"]`
+ * - `{a..e}` → `["a", "b", "c", "d", "e"]`
+ * - `prefix{a,b}suffix` → `["prefixasuffix", "prefixbsuffix"]`
+ * Returns a single-element array when no brace expansion applies.
+ */
+export function expandBraces(token) {
+    const MaxBraceDepth = 8;
+    const MaxBraceExpansions = 256;
+    function expandBracesInternal(value, depth) {
+        if (depth > MaxBraceDepth)
+            return [value];
+        // Find the first { not preceded by $
+        let braceDepth = 0;
+        let start = -1;
+        for (let i = 0; i < value.length; i++) {
+            const ch = value[i];
+            if (ch === "{" && value[i - 1] !== "$") {
+                if (braceDepth === 0)
+                    start = i;
+                braceDepth++;
+            }
+            else if (ch === "}") {
+                braceDepth--;
+                if (braceDepth === 0 && start !== -1) {
+                    const prefix = value.slice(0, start);
+                    const inner = value.slice(start + 1, i);
+                    const suffix = value.slice(i + 1);
+                    // Range: {1..5} or {a..e}
+                    const rangeMatch = inner.match(/^(-?\d+)\.\.(-?\d+)(?:\.\.-?(\d+))?$/) ||
+                        inner.match(/^([a-z])\.\.([a-z])$/);
+                    if (rangeMatch) {
+                        const items = [];
+                        if (/\d/.test(rangeMatch[1])) {
+                            const from = parseInt(rangeMatch[1], 10);
+                            const to = parseInt(rangeMatch[2], 10);
+                            const step = rangeMatch[3] ? parseInt(rangeMatch[3], 10) : 1;
+                            const inc = from <= to ? step : -step;
+                            for (let n = from; from <= to ? n <= to : n >= to; n += inc) {
+                                items.push(String(n));
+                            }
+                        }
+                        else {
+                            const from = rangeMatch[1].charCodeAt(0);
+                            const to = rangeMatch[2].charCodeAt(0);
+                            const inc = from <= to ? 1 : -1;
+                            for (let c = from; from <= to ? c <= to : c >= to; c += inc) {
+                                items.push(String.fromCharCode(c));
+                            }
+                        }
+                        const expanded = items.map((v) => `${prefix}${v}${suffix}`);
+                        const output = [];
+                        for (const item of expanded) {
+                            output.push(...expandBracesInternal(item, depth + 1));
+                            if (output.length > MaxBraceExpansions)
+                                return [value];
+                        }
+                        return output;
+                    }
+                    // Comma list: {a,b,c} — split respecting nested braces
+                    const parts = [];
+                    let cur = "";
+                    let innerDepth = 0;
+                    for (const ch2 of inner) {
+                        if (ch2 === "{") {
+                            innerDepth++;
+                            cur += ch2;
+                        }
+                        else if (ch2 === "}") {
+                            innerDepth--;
+                            cur += ch2;
+                        }
+                        else if (ch2 === "," && innerDepth === 0) {
+                            parts.push(cur);
+                            cur = "";
+                        }
+                        else {
+                            cur += ch2;
+                        }
+                    }
+                    parts.push(cur);
+                    if (parts.length > 1) {
+                        const output = [];
+                        for (const part of parts) {
+                            output.push(...expandBracesInternal(`${prefix}${part}${suffix}`, depth + 1));
+                            if (output.length > MaxBraceExpansions)
+                                return [value];
+                        }
+                        return output;
+                    }
+                    break;
+                }
+            }
+        }
+        return [value];
+    }
+    return expandBracesInternal(token, 0);
+}
+function expandArithmeticChunks(input, env) {
+    let result = "";
+    let index = 0;
+    while (index < input.length) {
+        if (input[index] === "$" && input[index + 1] === "(" && input[index + 2] === "(") {
+            let scan = index + 3;
+            let depth = 0;
+            while (scan < input.length) {
+                const ch = input[scan];
+                if (ch === "(") {
+                    depth++;
+                }
+                else if (ch === ")") {
+                    if (depth > 0) {
+                        depth--;
+                    }
+                    else if (input[scan + 1] === ")") {
+                        const expr = input.slice(index + 3, scan);
+                        const value = evalArith(expr, env);
+                        result += Number.isNaN(value) ? "0" : String(value);
+                        index = scan + 2;
+                        break;
+                    }
+                }
+                scan++;
+            }
+            if (scan >= input.length) {
+                result += input.slice(index);
+                break;
+            }
+            continue;
+        }
+        result += input[index];
+        index++;
+    }
+    return result;
+}
+export function expandSync(input, env, lastExit = 0, home) {
+    const homePath = home ?? env.HOME ?? "/home/user";
+    return outsideSingleQuotes(input, (chunk) => {
+        let s = chunk;
+        // Tilde expansion — only at start of token or after `:` or whitespace
+        s = s.replace(/(^|[\s:])~(\/|$)/g, (_, pre, post) => `${pre}${homePath}${post}`);
+        // $? $$ $#
+        s = s.replace(/\$\?/g, String(lastExit));
+        s = s.replace(/\$\$/g, "1");
+        s = s.replace(/\$#/g, "0");
+        // $(( arithmetic )) — must come before ${ and $VAR to avoid conflicts
+        s = expandArithmeticChunks(s, env);
+        // ${#VAR} — string length
+        s = s.replace(/\$\{#([A-Za-z_][A-Za-z0-9_]*)\}/g, (_, name) => String((env[name] ?? "").length));
+        // ${VAR:-default}
+        s = s.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*):-([^}]*)\}/g, (_, name, def) => env[name] !== undefined && env[name] !== "" ? env[name] : def);
+        // ${VAR:=default} — also assigns to env
+        s = s.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*):=([^}]*)\}/g, (_, name, def) => {
+            if (env[name] === undefined || env[name] === "")
+                env[name] = def;
+            return env[name];
+        });
+        // ${VAR:+alternate}
+        s = s.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*):\+([^}]*)\}/g, (_, name, alt) => env[name] !== undefined && env[name] !== "" ? alt : "");
+        // ${VAR}
+        s = s.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_, name) => env[name] ?? "");
+        // $VAR and positional params $1 $2 ...
+        s = s.replace(/\$([A-Za-z_][A-Za-z0-9_]*|\d+)/g, (_, name) => env[name] ?? "");
+        return s;
+    });
+}
+// ─── async expansion (includes $(cmd)) ──────────────────────────────────────
+/**
+ * Expand all shell forms including `$(cmd)` command substitution.
+ *
+ * Processes `$(...)` blocks depth-first, respecting single-quote boundaries.
+ * Then delegates to `expandSync` for the remaining forms.
+ *
+ * @param input     Raw string.
+ * @param env       Current session env vars.
+ * @param lastExit  Last exit code.
+ * @param runCmd    Async callback to execute a command and return its stdout.
+ */
+export async function expandAsync(input, env, lastExit, runCmd) {
+    const depthKey = "__shellExpandDepth";
+    const maxDepth = 8;
+    const currentDepth = Number(env[depthKey] ?? "0");
+    if (currentDepth >= maxDepth) {
+        return expandSync(input, env, lastExit);
+    }
+    env[depthKey] = String(currentDepth + 1);
+    try {
+        // $(cmd) substitution — skip content inside single quotes
+        if (input.includes("$(")) {
+            let result = "";
+            let inSingle = false;
+            let i = 0;
+            while (i < input.length) {
+                const ch = input[i];
+                if (ch === "'" && !inSingle) {
+                    inSingle = true;
+                    result += ch;
+                    i++;
+                    continue;
+                }
+                if (ch === "'" && inSingle) {
+                    inSingle = false;
+                    result += ch;
+                    i++;
+                    continue;
+                }
+                if (!inSingle && ch === "$" && input[i + 1] === "(") {
+                    // $((expr)) arithmetic — NOT a $(cmd) substitution, skip it
+                    if (input[i + 2] === "(") {
+                        result += ch;
+                        i++;
+                        continue;
+                    }
+                    // Find matching ) with depth tracking
+                    let depth = 0;
+                    let j = i + 1;
+                    while (j < input.length) {
+                        if (input[j] === "(")
+                            depth++;
+                        else if (input[j] === ")") {
+                            depth--;
+                            if (depth === 0)
+                                break;
+                        }
+                        j++;
+                    }
+                    const sub = input.slice(i + 2, j).trim();
+                    const out = (await runCmd(sub)).replace(/\n$/, "");
+                    result += out;
+                    i = j + 1;
+                    continue;
+                }
+                result += ch;
+                i++;
+            }
+            input = result;
+        }
+        return expandSync(input, env, lastExit);
+    }
+    finally {
+        if (currentDepth <= 0)
+            delete env[depthKey];
+        else
+            env[depthKey] = String(currentDepth);
+    }
+}