@poe-platform/safe-bash 0.1.526 → 0.1.528

package/dist/safe-bash/core.browser.js

@@ -38650,6 +38650,40 @@ var Parser4 = class {
       const body = this.nonemptyScript(/* @__PURE__ */ new Set(["done"]));
       this.expect("done", true);
       command7 = { kind, condition, body, redirects: [] };
+    } else if (this.is("for") && this.peek().value === "(" && this.lexer.source.startsWith("((", this.peek().offset)) {
+      this.advance();
+      const start = this.current.offset + 2;
+      let partStart = start;
+      let depth = 0;
+      let end = start;
+      this.budget.admit(4);
+      const sources2 = [];
+      for (; end < this.lexer.source.length; end++) {
+        this.budget.admit();
+        const character = this.lexer.source[end];
+        if (character === "(") depth++;
+        else if (character === ")") {
+          if (!depth && this.lexer.source[end + 1] === ")") break;
+          if (--depth < 0) this.error("Unterminated arithmetic for", true);
+        } else if (character === ";" && !depth) {
+          if (sources2.length === 2) this.error("Arithmetic for requires three expressions");
+          sources2.push(this.lexer.source.slice(partStart, end));
+          partStart = end + 1;
+        }
+      }
+      if (end === this.lexer.source.length) this.error("Unterminated arithmetic for", true);
+      if (sources2.length !== 2) this.error("Arithmetic for requires three expressions");
+      sources2.push(this.lexer.source.slice(partStart, end));
+      const expressions = sources2.map((source2) => source2.trim() ? prepareArithmetic(source2, this.budget) : void 0);
+      this.lexer.position = end + 2;
+      this.lookahead = void 0;
+      this.current = this.lexer.next();
+      if (this.is(";")) this.advance();
+      this.newlines();
+      this.expect("do", true);
+      const body = this.nonemptyScript(/* @__PURE__ */ new Set(["done"]));
+      this.expect("done", true);
+      command7 = { kind: "arithmetic-for", expressions, body, redirects: [] };
     } else if (this.is("for") || this.is("select")) {
       const kind = this.advance().value;
       const name2 = this.advance().value;
@@ -39654,6 +39688,12 @@ function commandText(command7, indent) {
     case "arithmetic":
       text3 = `(( ${command7.source} ))`;
       break;
+    case "arithmetic-for":
+      text3 = `for (( ${command7.expressions.map((expression) => expression?.source ?? "").join("; ")} ));
+do
+${nested}${scriptText(command7.body, nested)};
+${indent}done`;
+      break;
     case "conditional":
       text3 = `[[${command7.source}]]`;
       break;
@@ -40839,14 +40879,16 @@ var controlNames = /* @__PURE__ */ new Set([
   "LC_CTYPE"
 ]);
 var OwnedText = class {
-  constructor(value2, bytes3, admission) {
+  constructor(value2, bytes3, admission, rawValue) {
     this.value = value2;
     this.bytes = bytes3;
     this.admission = admission;
+    this.rawValue = rawValue;
   }
   value;
   bytes;
   admission;
+  rawValue;
   references = 1;
   retain() {
     if (this.references === Number.MAX_SAFE_INTEGER) throw new ArrayFailure("reference capacity is not representable");
@@ -40872,6 +40914,38 @@ async function textToken(owner, value2, signal) {
   const admission = owner.reserve({ payload: bytes3, metadata: 32, work: 4 });
   return new OwnedText(value2, bytes3, admission);
 }
+async function valueToken(owner, value2, signal) {
+  if (typeof value2 === "string") return textToken(owner, value2, signal);
+  const bytes3 = shellValueByteLength(value2);
+  const temporary = owner.reserve({ payload: bytes3 * 3, metadata: 64, work: 4 });
+  try {
+    const input3 = shellValueBytes(value2);
+    const decoder2 = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+    let text3 = "";
+    for (let offset = 0; offset < bytes3; offset += 1024) {
+      const end = Math.min(bytes3, offset + 1024);
+      owner.reserve({ work: end - offset }).release();
+      await owner.ledger.checkpoint(signal, end - offset);
+      if (text3 !== void 0) try {
+        text3 += decoder2.decode(input3.subarray(offset, end), { stream: end < bytes3 });
+      } catch (error) {
+        if (!(error instanceof TypeError) || "code" in error && error.code !== "ERR_ENCODING_INVALID_ENCODED_DATA") throw error;
+        text3 = void 0;
+      }
+    }
+    if (text3 !== void 0) return await textToken(owner, text3, signal);
+    const admission = owner.reserve({ payload: bytes3 * 4, metadata: 128, work: 4 });
+    try {
+      const raw = shellValueFromBytes(input3);
+      return new OwnedText(shellValueText(raw), bytes3, admission, raw);
+    } catch (error) {
+      admission.release();
+      throw error;
+    }
+  } finally {
+    temporary.release();
+  }
+}
 var IndexedBinding = class _IndexedBinding {
   constructor(owner) {
     this.owner = owner;
@@ -41108,6 +41182,116 @@ var BindingStore = class _BindingStore {
   }
 };
 
+// packages/safe-bash/src/shell/mapfile.ts
+init_platform();
+var MapfileUsageError = class extends Error {
+  constructor(message3, status2) {
+    super(message3);
+    this.status = status2;
+  }
+  status;
+};
+async function mapfileOptions(context2, work, allocation) {
+  const options3 = { name: "MAPFILE", strip: false, delimiter: 10, count: 0, skip: 0, origin: 0, preserve: false, callback: void 0, quantum: 5e3 };
+  const args = getCommandArguments(context2);
+  let cursor = 0;
+  const numeric4 = async (text3, maximum) => {
+    let value2 = 0;
+    let index = 0;
+    const whitespace2 = (code) => code === 32 || code >= 9 && code <= 13;
+    while (index < text3.length && whitespace2(text3.charCodeAt(index))) {
+      const pending = stringCheckpoint(work);
+      if (pending) await pending;
+      index++;
+    }
+    const negative = text3[index] === "-";
+    if (negative || text3[index] === "+") index++;
+    let digits = 0;
+    for (; index < text3.length; index++) {
+      const pending = stringCheckpoint(work);
+      if (pending) await pending;
+      const digit3 = text3.charCodeAt(index) - 48;
+      if (digit3 < 0 || digit3 > 9) break;
+      if (value2 > Math.floor((maximum - digit3) / 10)) throw new MapfileUsageError(`${text3}: invalid number`, 1);
+      value2 = value2 * 10 + digit3;
+      digits++;
+    }
+    for (; index < text3.length; index++) {
+      const pending = stringCheckpoint(work);
+      if (pending) await pending;
+      if (!whitespace2(text3.charCodeAt(index))) throw new MapfileUsageError(`${text3}: invalid number`, 1);
+    }
+    if (!digits || negative && value2 !== 0) throw new MapfileUsageError(`${text3}: invalid number`, 1);
+    return value2;
+  };
+  while (cursor < context2.args.length) {
+    const option = context2.args[cursor];
+    if (option === "--") {
+      cursor++;
+      break;
+    }
+    if (!option.startsWith("-") || option === "-") break;
+    cursor++;
+    for (let index = 1; index < option.length; index++) {
+      const pending = stringCheckpoint(work);
+      if (pending) await pending;
+      const flag = option[index];
+      if (flag === "t") {
+        options3.strip = true;
+        continue;
+      }
+      if (!"dnsOCc".includes(flag)) throw new MapfileUsageError(`-${flag}: invalid option`, 2);
+      const attached = index + 1 < option.length;
+      const operandIndex = attached ? cursor - 1 : cursor++;
+      const operand = attached ? option.slice(index + 1) : context2.args[operandIndex];
+      if (operand === void 0) throw new MapfileUsageError(`-${flag}: option requires an argument`, 2);
+      if (flag === "d") {
+        const bytes3 = shellValueBytes(args.values[operandIndex], allocation);
+        options3.delimiter = bytes3[attached ? index + 1 : 0] ?? 0;
+      } else if (flag === "C") options3.callback = operand;
+      else {
+        const value2 = await numeric4(operand, flag === "O" ? 2147483647 : Number.MAX_SAFE_INTEGER);
+        if (flag === "c") {
+          if (!value2) throw new MapfileUsageError("0: invalid callback quantum", 1);
+          options3.quantum = value2;
+        } else if (flag === "n") options3.count = value2;
+        else if (flag === "s") options3.skip = value2;
+        else {
+          options3.origin = value2;
+          options3.preserve = true;
+        }
+      }
+      break;
+    }
+  }
+  options3.name = context2.args[cursor] ?? "MAPFILE";
+  if (!/^[a-zA-Z_][a-zA-Z_0-9]*$/u.test(options3.name)) throw new MapfileUsageError(`${options3.name}: invalid identifier`, 1);
+  return options3;
+}
+async function collectMapfile(options3, input3, hooks) {
+  let skipped = 0;
+  let written = 0;
+  while (!options3.count || written < options3.count) {
+    hooks.loop();
+    const allocation = hooks.allocation();
+    try {
+      const record4 = await input3.mapfileRecord(options3.delimiter, options3.strip, allocation);
+      if (!record4.present) break;
+      if (skipped < options3.skip) {
+        skipped++;
+        continue;
+      }
+      const index = options3.origin + written;
+      if (index > 2147483647) throw new MapfileUsageError("array index exceeds 2147483647", 1);
+      if (options3.callback !== void 0 && (written + 1) % options3.quantum === 0) await hooks.callback(options3.callback, index, record4.value);
+      await hooks.write(index, record4.value);
+      written++;
+    } finally {
+      allocation.close();
+    }
+  }
+}
+
 // packages/safe-bash/src/shell/arrays/state.ts
 init_platform();
 var sessions = /* @__PURE__ */ new WeakMap();
@@ -41869,6 +42053,8 @@ var shellBuiltinNames = /* @__PURE__ */ new Set([
   "local",
   "unset",
   "read",
+  "mapfile",
+  "readarray",
   "exit",
   "return",
   "break",
@@ -42867,6 +43053,7 @@ var InvocationCancellationOwner = class {
     this.#failures.push(...result2.failures);
   }
 };
+var mapfileCallbackStates = /* @__PURE__ */ new WeakSet();
 var Runtime = class _Runtime {
   constructor(fs, commands, middleware, budget, signal = budget.signal, fileWrites = /* @__PURE__ */ new Map(), outputFiles = /* @__PURE__ */ new Map(), commandSignal = signal, cancellation, cancellationState, cancellationOwner, cancellationDepth, cancellationMaxDepth, outcomeFrame = void 0, inputProfile = fs) {
     this.fs = fs;
@@ -43178,6 +43365,18 @@ var Runtime = class _Runtime {
     this.signal.throwIfAborted();
     if (error instanceof NounsetFailure || error instanceof Flow2 || error instanceof ShellLimitError || error instanceof ShellSyntaxError) throw error;
   }
+  arithmeticValue(program, state, io) {
+    return evaluatePositionalArithmetic(program, {
+      parseBudget: this.budget.parsing,
+      positional: state.positional,
+      arg0: state.arg0 ?? "virtual-bash",
+      owner: arrayStore(state)?.owner,
+      maximumBytes: this.budget.limits.maxExpansionBytes,
+      checkpoint: () => this.signal.throwIfAborted(),
+      requireParameter: (name2, value2) => this.requireParameter(value2, name2, state, io),
+      limit: () => this.budget.fail("maxExpansionBytes")
+    }, (prepared) => evaluateArithmetic(prepared, this.arithmeticVariables(state, io.diagnosticLine), this.budget.parsing));
+  }
   arithmeticVariables(state, line) {
     return new Proxy(state.variables, {
       get: (target, key) => {
@@ -43205,7 +43404,7 @@ var Runtime = class _Runtime {
       this.writeVariable(state, name2, value2, origin);
       return;
     }
-    await this.arrayZero(state, name2, async () => shellValueText(value2));
+    await this.arrayZero(state, name2, async () => value2);
   }
   async prepareVariable(state, name2, saved, scalarLegacy = false) {
     const store = requireArrays(state);
@@ -43362,6 +43561,7 @@ var Runtime = class _Runtime {
     const store = requireArrays(state);
     const operation2 = ArrayOwner.create(store.owner.ledger, store.owner);
     const holding = store.owner.hold();
+    const valueAllocation = this.budget.values.scope();
     let staged;
     try {
       const watch = await store.watch(name2, operation2, this.signal);
@@ -43378,8 +43578,9 @@ var Runtime = class _Runtime {
       const current = store.get(name2);
       if (!current) throw new ArrayFailure("stale binding");
       staged = await current.copy(this.signal);
-      const value2 = append ? await this.arrayJoin(operation2, [current.get(0) ?? "", expanded], "") : expanded;
-      const token = await textToken(staged.owner, value2, this.signal);
+      const previous = current.values.get(0)?.text.rawValue ?? current.get(0) ?? "";
+      const value2 = !append ? expanded : typeof previous === "string" && typeof expanded === "string" ? await this.arrayJoin(operation2, [previous, expanded], "") : concatShellValues([previous, expanded], valueAllocation);
+      const token = await valueToken(staged.owner, value2, this.signal);
       try {
         staged.insert(0, token);
       } catch (error) {
@@ -43407,6 +43608,7 @@ var Runtime = class _Runtime {
         await staged?.release();
         await operation2.close();
       } finally {
+        valueAllocation.close();
         holding.release();
       }
     }
@@ -43470,7 +43672,7 @@ var Runtime = class _Runtime {
       const preserve = assignment.kind === "element" || assignment.append;
       staged = preserve && current ? await current.copy(this.signal) : IndexedBinding.create(store.owner);
       if (preserve && !current && state.variables[name2] !== void 0) {
-        const token = await textToken(staged.owner, state.variables[name2], this.signal);
+        const token = await valueToken(staged.owner, stateMonitor(state)?.values.get(name2, state.variables[name2]) ?? state.variables[name2], this.signal);
         try {
           staged.insert(0, token);
         } catch (error) {
@@ -43482,7 +43684,7 @@ var Runtime = class _Runtime {
       let cursor = assignment.append && assignment.kind === "compound" ? initialMaximum + 1 : 0;
       const insert = async (index, value2) => {
         if (index > 2147483647) throw new ArrayFailure("index outside 0..2147483647");
-        const token = await textToken(staged.owner, value2, this.signal);
+        const token = await valueToken(staged.owner, value2, this.signal);
         try {
           staged.insert(index, token);
         } catch (error) {
@@ -43491,11 +43693,12 @@ var Runtime = class _Runtime {
         }
         writes++;
       };
+      const join = async (values) => values.every((value2) => typeof value2 === "string") ? this.arrayJoin(operation2, values, "") : concatShellValues(values, io[valueScope]);
       if (assignment.kind === "element") {
         const index = numericIndex(assignment.index);
-        const fields3 = await this.word(assignment.value, state, io, false);
-        let value2 = await this.arrayJoin(operation2, fields3, "");
-        if (assignment.append) value2 = await this.arrayJoin(operation2, [staged.get(index) ?? "", value2], "");
+        const fields3 = await this.valueWord(assignment.value, state, io, false);
+        let value2 = await join(fields3);
+        if (assignment.append) value2 = await join([staged.values.get(index)?.text.rawValue ?? staged.get(index) ?? "", value2]);
         await insert(index, value2);
       } else for (const entry of assignment.entries) {
         const original = compoundEntryWords.get(entry);
@@ -43506,16 +43709,16 @@ var Runtime = class _Runtime {
             expandedEntry = true;
             const values = await this.valueWord(expanded, state, io, true, false, false, false, void 0, false);
             for (const value2 of values) {
-              await insert(cursor, shellValueText(value2));
+              await insert(cursor, value2);
               cursor++;
             }
           }
           if (expandedEntry) continue;
         }
-        const fields3 = await this.word(entry.value, state, io, entry.index === void 0);
+        const fields3 = await this.valueWord(entry.value, state, io, entry.index === void 0);
         if (entry.index) {
           const index = numericIndex(entry.index);
-          await insert(index, await this.arrayJoin(operation2, fields3, ""));
+          await insert(index, await join(fields3));
           cursor = index + 1;
         } else for (const value2 of fields3) {
           await insert(cursor, value2);
@@ -43878,16 +44081,7 @@ var Runtime = class _Runtime {
         }
         if (command7.kind === "arithmetic") {
           try {
-            return Number(evaluatePositionalArithmetic(command7.expression, {
-              parseBudget: this.budget.parsing,
-              positional: state.positional,
-              arg0: state.arg0 ?? "virtual-bash",
-              owner: arrayStore(state)?.owner,
-              maximumBytes: this.budget.limits.maxExpansionBytes,
-              checkpoint: () => this.signal.throwIfAborted(),
-              requireParameter: (name2, value2) => this.requireParameter(value2, name2, state, io),
-              limit: () => this.budget.fail("maxExpansionBytes")
-            }, (prepared) => evaluateArithmetic(prepared, this.arithmeticVariables(state, io.diagnosticLine), this.budget.parsing)) === 0n);
+            return Number(this.arithmeticValue(command7.expression, state, io) === 0n);
           } catch (error) {
             this.rethrowArithmeticControl(error);
             throw new PublicDiagnostic(`((: ${message2(error, this.budget.onInternalError)}`);
@@ -43946,6 +44140,29 @@ var Runtime = class _Runtime {
               status3 = result2.status;
               if (result2.stop) break;
             }
+          } else if (command7.kind === "arithmetic-for") {
+            const evaluate = async (program) => {
+              if (!program) return 1n;
+              try {
+                return this.arithmeticValue(program, state, io);
+              } catch (error) {
+                this.rethrowArithmeticControl(error);
+                await this.diagnostic(io, `((: ${message2(error, this.budget.onInternalError)}`);
+                return void 0;
+              }
+            };
+            if (await evaluate(command7.expressions[0]) === void 0) return 1;
+            while (true) {
+              this.budget.loop();
+              await yieldTurn(this.signal);
+              const condition = await evaluate(command7.expressions[1]);
+              if (condition === void 0) return 1;
+              if (condition === 0n) break;
+              const result2 = await this.loopBody(command7.body, state, io);
+              status3 = result2.status;
+              if (result2.stop) break;
+              if (await evaluate(command7.expressions[2]) === void 0) return 1;
+            }
           } else if (command7.kind === "select") {
             const values = command7.words ? await this.valueWords(command7.words, state, io) : this.positionalValues(state);
             if (!values.length) return 0;
@@ -44392,8 +44609,8 @@ var Runtime = class _Runtime {
             throw new ArrayFailure("indexed binding cannot be a command prefix");
           }
           await this.arrayZero(state, assignment.name, async () => {
-            const fields3 = await this.word(assignment.value, state, io, false);
-            return this.arrayJoin(requireArrays(state).owner, fields3, "");
+            const fields3 = await this.valueWord(assignment.value, state, io, false);
+            return fields3.every((value3) => typeof value3 === "string") ? this.arrayJoin(requireArrays(state).owner, fields3, "") : concatShellValues(fields3, io[valueScope]);
           }, assignment.append);
           continue;
         }
@@ -44712,6 +44929,8 @@ var Runtime = class _Runtime {
             functionRestoration?.close();
             throw error;
           }
+          const callerLoopDepth = state.loopDepth;
+          if (mapfileCallbackStates.has(state)) state.loopDepth = 0;
           try {
             return { exitCode: await this.command(body, state, { ...io, ...context3, scriptName: body.sourceName ?? io.scriptName ?? "shell" }) };
           } catch (error) {
@@ -44725,6 +44944,7 @@ var Runtime = class _Runtime {
               savedPositionals.close();
               state.positionalSetVersion = positionalSetVersion;
               state.functionDepth--;
+              state.loopDepth = callerLoopDepth;
               state.depth--;
               state.locals.pop();
             };
@@ -46196,12 +46416,119 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
       allocation.close();
     }
   }
+  async mapfileBuiltin(context2, state) {
+    const allocation = this.budget.values.scope();
+    const work = { remaining: this.budget.limits.maxExpansionBytes * 8, signal: this.signal, exhausted: () => this.budget.fail("maxExpansionBytes") };
+    let pinned;
+    let releaseHolding;
+    try {
+      const options3 = await mapfileOptions(context2, work, allocation);
+      if (state.readonlyVariables?.has(options3.name)) throw new MapfileUsageError(`${options3.name}: readonly variable`, 1);
+      if (controlNames.has(options3.name) || state.exported.has(options3.name)) throw new ArrayFailure("control or exported binding cannot be indexed");
+      const store = requireArrays(state);
+      const holding = store.owner.hold();
+      releaseHolding = () => holding.release();
+      if (!options3.preserve || !store.get(options3.name)) await this.arrayAssignment({ kind: "compound", name: options3.name, append: options3.preserve, entries: [] }, state, context2);
+      const entry = store.bindings.get(options3.name);
+      allocation.reserve(128 + import_buffer.Buffer.byteLength(options3.name) * 2, 0);
+      pinned = entry.binding.retain();
+      const input3 = context2.stdin instanceof ShellInput ? context2.stdin : new ShellInput(context2.stdin, this.budget, this.signal);
+      let pendingFlow;
+      await collectMapfile(options3, input3, {
+        allocation: () => this.budget.values.scope(),
+        loop: () => this.budget.loop(),
+        write: async (index, value2) => {
+          if (pinned !== entry.binding) {
+            const previous = pinned;
+            pinned = entry.binding.retain();
+            await previous.release();
+          }
+          const operation2 = ArrayOwner.create(store.owner.ledger, store.owner);
+          let staged;
+          try {
+            const current = pinned;
+            const attached = store.bindings.get(options3.name) === entry;
+            const watch = attached ? await store.watch(options3.name, operation2, this.signal) : void 0;
+            const supersede = attached ? await stateMonitor(state).prepareTypedPublication(options3.name, operation2, this.signal) : void 0;
+            if (attached) await this.prepareArrayObservers(state, operation2);
+            const tickets = operation2.reserve({ generation: true, version: true, epoch: true, work: 8 });
+            staged = current.references > (attached ? 2 : 1) ? await current.copy(this.signal) : current.retain();
+            const token = await valueToken(staged.owner, value2, this.signal);
+            try {
+              this.signal.throwIfAborted();
+              if (watch && !watch.valid()) throw new ArrayFailure("stale binding");
+              staged.insert(index, token);
+            } catch (error) {
+              token.release();
+              throw error;
+            }
+            if (attached) {
+              let released;
+              stateMonitor(state).publish(tickets, options3.name, () => {
+                supersede();
+                released = store.publish(options3.name, staged, tickets);
+              });
+              staged = void 0;
+              await released;
+            } else {
+              const previous = pinned;
+              pinned = staged;
+              entry.binding = staged;
+              staged = void 0;
+              await previous.release();
+            }
+          } finally {
+            try {
+              await staged?.release();
+            } finally {
+              await operation2.close();
+            }
+          }
+        },
+        callback: async (source2, index, value2) => {
+          if (pendingFlow) return;
+          const callbackAllocation = this.budget.values.scope();
+          const nested = mapfileCallbackStates.has(state);
+          try {
+            const quoted2 = shellValueText(await transformParameter(value2, "Q", { maximumBytes: this.budget.limits.maxExpansionBytes, byteLocale: byteLocale(state.variables), work, allocation: callbackAllocation }));
+            if (import_buffer.Buffer.byteLength(source2) + import_buffer.Buffer.byteLength(quoted2) + String(index).length + 2 > this.budget.limits.maxExpansionBytes) this.budget.fail("maxExpansionBytes");
+            mapfileCallbackStates.add(state);
+            await this.evalBuiltin({ ...context2, args: [source2, String(index), quoted2] }, state, context2, false);
+          } catch (error) {
+            if (error instanceof Flow2 && (error.kind === "break" || error.kind === "continue")) pendingFlow = error;
+            else throw error;
+          } finally {
+            if (!nested) mapfileCallbackStates.delete(state);
+            callbackAllocation.close();
+          }
+        }
+      });
+      if (pendingFlow) throw pendingFlow;
+      return 0;
+    } catch (error) {
+      this.signal.throwIfAborted();
+      if (!(error instanceof MapfileUsageError)) throw error;
+      await this.diagnostic(context2, `${context2.command}: ${error.message}`);
+      return error.status;
+    } finally {
+      try {
+        await pinned?.release();
+      } finally {
+        try {
+          releaseHolding?.();
+        } finally {
+          allocation.close();
+        }
+      }
+    }
+  }
   async builtin(context2, state, assignments2, diagnose, suppressSpecial = false) {
     const { command: command7, args, stdout, stderr } = context2;
     if (command7 === ":" || command7 === "true") return 0;
     if (command7 === "false") return 1;
     if (command7 === "shopt") return this.shoptBuiltin(context2, state);
     if (command7 === "let") return this.letBuiltin(context2, state);
+    if (command7 === "mapfile" || command7 === "readarray") return this.mapfileBuiltin(context2, state);
     if (command7 === "getopts") return this.getoptsBuiltin(context2, state);
     if (command7 === "pushd" || command7 === "dirs" || command7 === "popd") return this.directoryStackBuiltin(context2, state, diagnose);
     if (command7 === "pwd") {
@@ -46757,7 +47084,7 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
     if (part.kind === "variable" && part.transform) {
       const selector2 = getArraySelector(part);
       if (selector2?.kind === "members" || part.name === "@" || part.name === "*") {
-        const members = selector2 ? await this.arrayMembers(part.name, state) : this.positionalValues(state);
+        const members = selector2 ? await this.arrayMembers(part.name, state, io) : this.positionalValues(state);
         const ifs = state.variables.IFS ?? " ";
         const separator = ifs.length ? String.fromCodePoint(ifs.codePointAt(0)) : "";
         const fragments = [];
@@ -46801,6 +47128,7 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
     const token = index === void 0 || selector?.kind === "members" ? void 0 : binding?.values.get(index)?.text;
     token?.retain();
     try {
+      if (token?.rawValue && part.kind === "variable" && !part.length && !part.operator && !part.substring) return shellValueFromBytes(shellValueBytes(token.rawValue, io[valueScope]), io[valueScope]);
       const value2 = await this.partValue(part, state, io, hereString);
       if (binding) await textToken(requireArrays(state).owner, shellValueText(value2), this.signal);
       return value2;
@@ -46918,8 +47246,11 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
         return part.length ? this.parameterLength(value3 ?? "") : value3 ?? "";
       }
       if (part.length) return String(binding?.values.size ?? (state.variables[part.name] === void 0 ? 0 : 1));
-      const values = await this.arrayMembers(part.name, state);
-      return this.arrayJoin(store.owner, values, Array.from(state.variables.IFS ?? " ")[0] ?? "");
+      const values = await this.arrayMembers(part.name, state, io);
+      const separator = Array.from(state.variables.IFS ?? " ")[0] ?? "";
+      if (values.every((value3) => typeof value3 === "string")) return this.arrayJoin(store.owner, values, separator);
+      io[valueScope]?.reserve(values.length * 32 + 64, 0);
+      return concatShellValues(values.flatMap((value3, index) => index ? [separator, value3] : [value3]), io[valueScope]);
     }
     let value2 = part.name === "?" ? String(state.status) : part.name === "-" ? `${state.errexit ? "e" : ""}${state.nounset ? "u" : ""}${state.braceexpand !== false ? "B" : ""}` : part.name === "#" ? String(state.positional.length) : part.name === "@" || part.name === "*" ? state.positional.join(hereString && (part.name === "@" || !part.quoted) ? " " : Array.from(state.variables.IFS ?? " ")[0] ?? "") : /^0+$/u.test(part.name) ? state.arg0 ?? "virtual-bash" : /^\d+$/u.test(part.name) ? state.positional[Number(part.name) - 1] : this.variable(state, part.name);
     let retained = value2;
@@ -47328,7 +47659,7 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
             emptyNameGroups.add(quoteGroup);
           }
         } else if (part.kind === "variable" && split4 && (selector?.kind === "members" && !part.length && (!part.quoted || selector.separator === "@") || part.transform && part.name === "@")) {
-          const members = selector?.kind === "members" ? await this.arrayMembers(part.name, state) : this.positionalValues(state);
+          const members = selector?.kind === "members" ? await this.arrayMembers(part.name, state, io) : this.positionalValues(state);
           for (let position = 0; position < members.length; position++) {
             if (position > 0) addField();
             const original = members[position];
@@ -47470,7 +47801,7 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
     for (const value2 of values) if (typeof value2 !== "string") allocation.hold(value2);
     return createCommandArguments(values, allocation);
   }
-  async arrayMembers(name2, state) {
+  async arrayMembers(name2, state, io) {
     const store = requireArrays(state);
     const holding = store.owner.hold();
     try {
@@ -47489,8 +47820,9 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
         const values = [];
         for (const index of indices) {
           store.owner.reserve({ metadata: 32, allocatedSlots: 1, work: 4 });
-          const value2 = binding.get(index);
-          await textToken(store.owner, value2, this.signal);
+          const token = binding.values.get(index).text;
+          const value2 = token.rawValue === void 0 ? token.value : shellValueFromBytes(shellValueBytes(token.rawValue, io[valueScope]), io[valueScope]);
+          if (typeof value2 === "string") await textToken(store.owner, value2, this.signal);
           values.push(value2);
           await store.owner.ledger.checkpoint(this.signal);
         }
@@ -48165,6 +48497,51 @@ var ShellInput = class _ShellInput {
       }
     });
   }
+  mapfileRecord(delimiter, strip, allocation) {
+    return this.#cursor.consume(this.signal, async () => {
+      this.#cursor.admitBoundedRead();
+      allocation.reserve(64, 0);
+      const parts = [];
+      let length = 0;
+      let truncated = false;
+      let pulls = 0;
+      while (true) {
+        if (++pulls % 128 === 0) await yieldTurn(this.signal);
+        const result2 = await this.#cursor.take(this.signal);
+        if (result2.done) return { value: concatShellValues(parts, allocation), present: length > 0 };
+        const chunk = result2.value;
+        for (let offset = 0; offset < chunk.length; ) {
+          await yieldTurn(this.signal);
+          if (length >= this.budget.limits.maxOutputBytes) this.budget.fail("maxOutputBytes");
+          const end = Math.min(offset + 1024, chunk.length, offset + this.budget.limits.maxOutputBytes - length);
+          allocation.reserve(end - offset + 64, 0);
+          const output2 = new Uint8Array(end - offset);
+          let used = 0;
+          let terminated = false;
+          while (offset < end) {
+            const byte = chunk[offset++];
+            this.#cursor.position++;
+            if (++length > this.budget.limits.maxOutputBytes) this.budget.fail("maxOutputBytes");
+            if (byte === delimiter) {
+              if (!strip && byte !== 0 && !truncated) output2[used++] = byte;
+              terminated = true;
+              break;
+            }
+            if (byte === 0) truncated = true;
+            if (!truncated) output2[used++] = byte;
+          }
+          if (used) {
+            allocation.reserve(32, 0);
+            parts.push(shellValueFromBytes(output2.subarray(0, used), allocation));
+          }
+          if (terminated) {
+            if (offset < chunk.length) this.#cursor.remainder = chunk.subarray(offset);
+            return { value: concatShellValues(parts, allocation), present: true };
+          }
+        }
+      }
+    });
+  }
   async readBounded(raw, options3) {
     const text3 = new ReadText();
     let characters = 0;