@poe-platform/safe-bash 0.1.799 → 0.1.800

package/dist/safe-bash/command-chunks/chunk-LC2MFKT4.js

@@ -0,0 +1,2489 @@
+import {
+  decodeString
+} from "./chunk-L6DVEBW3.js";
+import {
+  AwkPipes
+} from "./chunk-DB453IE6.js";
+import {
+  AwkArray,
+  SCALAR_ONE,
+  SCALAR_ZERO,
+  compare,
+  formatted,
+  inputValue,
+  inputValueFromSlice,
+  number,
+  numeric,
+  scalar,
+  string,
+  text,
+  truth,
+  unset
+} from "./chunk-V6MSPQLA.js";
+import {
+  Reader
+} from "./chunk-7K6JYKPJ.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-awk/src/awk-runtime.ts
+init_buffer();
+import { tryReadMemoryFileViewSync } from "@poe-platform/safe-fs/core";
+import { FsError, writeBytes } from "../../safe-bash-contracts/index.js";
+import { writeFileOutput } from "../../safe-bash-contracts/filesystem-output.js";
+import { isSyncResolved } from "../../safe-bash-contracts/runtime-control.js";
+import { shellValueByteLength } from "../../safe-bash-contracts/value.js";
+import { decodeBytes, encodeBytes, latin1Bytes, latin1Text } from "../../safe-bash-io-engine/byte-encoding.js";
+import { ProgramError, byteString, bytes, input, virtualPath, write } from "../../safe-bash-io-engine/commands/text-programs/shared.js";
+import { Pattern, substitute } from "../../safe-bash-regex-engine/text/regex.js";
+import { TimeZone, nanosecondsPerSecond } from "../../safe-bash-calendar-engine/time-env/calendar.js";
+import { formatDate } from "../../safe-bash-calendar-engine/time-env/format.js";
+var textDecoder = new TextDecoder("utf-8", { ignoreBOM: true });
+function textSize(value) {
+  return value && !(value instanceof AwkArray) && (value.kind === "string" || value.kind === "numeric") ? value.text.length : 0;
+}
+function isAsciiText(text2) {
+  for (let i = 0; i < text2.length; i++) {
+    if (text2.charCodeAt(i) > 127) return false;
+  }
+  return true;
+}
+function isOperandAssignment(text2) {
+  const eq = text2.indexOf("=");
+  if (eq <= 0) return false;
+  const c0 = text2.charCodeAt(0);
+  if (!(c0 >= 65 && c0 <= 90 || c0 >= 97 && c0 <= 122 || c0 === 95)) return false;
+  for (let i = 1; i < eq; i++) {
+    const c = text2.charCodeAt(i);
+    if (!(c >= 65 && c <= 90 || c >= 97 && c <= 122 || c >= 48 && c <= 57 || c === 95)) return false;
+  }
+  return true;
+}
+function ownScalar(value) {
+  if (value.kind === "string" || value.kind === "numeric") {
+    if (value.text.length < 13 && Object.isFrozen(value)) return value;
+    const ownedText = value.text.length >= 13 ? latin1Text(latin1Bytes(value.text)) : value.text;
+    return value.kind === "numeric" ? { kind: "numeric", text: ownedText, number: value.number } : { kind: "string", text: ownedText };
+  }
+  if (value.kind === "number" && !Object.isFrozen(value)) {
+    return { kind: "number", number: value.number };
+  }
+  return value;
+}
+var DEFAULT_VARIABLES = [
+  ["FS", Object.freeze({ kind: "string", text: " " })],
+  ["RS", Object.freeze({ kind: "string", text: "\n" })],
+  ["OFS", Object.freeze({ kind: "string", text: " " })],
+  ["ORS", Object.freeze({ kind: "string", text: "\n" })],
+  ["OFMT", Object.freeze({ kind: "string", text: "%.6g" })],
+  ["CONVFMT", Object.freeze({ kind: "string", text: "%.6g" })],
+  ["SUBSEP", Object.freeze({ kind: "string", text: "" })],
+  ["NR", numeric(0)],
+  ["FNR", numeric(0)],
+  ["NF", numeric(0)],
+  ["FILENAME", string("")],
+  ["RSTART", numeric(0)],
+  ["RLENGTH", numeric(0)]
+];
+var AWK_ARGV0 = Object.freeze({ kind: "string", text: "awk" });
+function hasMainGetline(node) {
+  if (!node || typeof node !== "object") return false;
+  if (node.kind === "getline" && !node.file && !node.pipe) return true;
+  return Object.values(node).some((child) => Array.isArray(child) ? child.some(hasMainGetline) : hasMainGetline(child));
+}
+var FAST_AWK_MATCH_OFFSETS = new Int32Array(20);
+var RETURN_SCALAR_ZERO = () => SCALAR_ZERO;
+var RETURN_SCALAR_ONE = () => SCALAR_ONE;
+var RELEASED_AWK_SIGNAL = Object.freeze({
+  aborted: false,
+  reason: void 0,
+  onabort: null,
+  throwIfAborted() {
+  },
+  addEventListener() {
+  },
+  removeEventListener() {
+  },
+  dispatchEvent() {
+    return true;
+  }
+});
+var RELEASED_AWK_CONTEXT = Object.freeze({ signal: RELEASED_AWK_SIGNAL });
+var _lastAwkArrayAnchor = new AwkArray();
+var SMALL_ARG_KEYS = ["0", "1", "2", "3", "4", "5", "6", "7", "8"];
+var Flow = class {
+  constructor(kind, value = unset) {
+    this.kind = kind;
+    this.value = value;
+  }
+  kind;
+  value;
+};
+var AwkRuntime = class {
+  constructor(program, context, budget, retention, args, assignments, separator, operandAssignments = true, ordchr = false, inspection) {
+    this.program = program;
+    this.context = context;
+    this.budget = budget;
+    this.retention = retention;
+    this.operandAssignments = operandAssignments;
+    this.ordchr = ordchr;
+    this.inspection = inspection;
+    this.fieldStarts = new Array(64).fill(0);
+    this.fieldEnds = new Array(64).fill(0);
+    this.lazyFieldGen = new Array(64).fill(0);
+    this.lazyFields = new Array(64);
+    this.fieldGeneration = 1;
+    try {
+      for (let i = 0; i < DEFAULT_VARIABLES.length; i++) {
+        const pair = DEFAULT_VARIABLES[i];
+        this.storeScalar(this.variables, pair[0], pair[1]);
+      }
+      this.storeScalar(this.variables, "ARGC", numeric(args.length + 1));
+      if (inspection !== void 0 || retention.capacity <= 65536 || budget.options.maxArrayEntries !== void 0 || budget.options.maxBufferBytes !== void 0 || budget.options.maxRetainedBytes !== void 0) {
+        this.ensureEnviron();
+      }
+      const argv = this.array("ARGV");
+      this.arraySet(argv, "0", AWK_ARGV0);
+      for (let index = 0; index < args.length; index++) {
+        const k = index + 1 < SMALL_ARG_KEYS.length ? SMALL_ARG_KEYS[index + 1] : String(index + 1);
+        this.arraySet(argv, k, inputValue(byteString(args[index])));
+      }
+      if (separator !== void 0) this.set("FS", string(separator));
+      for (const assignment of assignments) this.assignment(assignment);
+    } catch (error) {
+      this.releaseStore(this.variables);
+      throw error;
+    }
+  }
+  program;
+  context;
+  budget;
+  retention;
+  operandAssignments;
+  ordchr;
+  inspection;
+  variables = /* @__PURE__ */ new Map();
+  frames = [];
+  arrays = /* @__PURE__ */ new Map();
+  regexes;
+  outputs;
+  inputs;
+  pipes;
+  environInitialized = false;
+  mainReader;
+  argument = 1;
+  sawFile = false;
+  defaultUsed = false;
+  rawFields = [];
+  get fields() {
+    return this.ensureFields();
+  }
+  set fields(v) {
+    this.rawFields = v;
+  }
+  fieldStarts;
+  fieldEnds;
+  fieldCount = 0;
+  deferredFieldSeparator = " ";
+  fieldsMaterialized = true;
+  fieldGeneration;
+  lazyFieldGen;
+  lazyFields;
+  fieldBytes = 0;
+  rawRecord = "";
+  recordSource = "";
+  recordStart = 0;
+  recordEnd = 0;
+  get record() {
+    return this.rawRecord ??= this.recordSource.slice(this.recordStart, this.recordEnd);
+  }
+  set record(v) {
+    this.rawRecord = v;
+    this.recordSource = v;
+    this.recordStart = 0;
+    this.recordEnd = v.length;
+  }
+  get recordLength() {
+    return this.rawRecord !== void 0 ? this.rawRecord.length : this.recordEnd - this.recordStart;
+  }
+  sliceBox = { source: "", start: 0, end: 0 };
+  recordValue = string("");
+  entries = 0;
+  fsText = " ";
+  rsText = "\n";
+  convfmtText = "%.6g";
+  nrNum = 0;
+  nrDirty = false;
+  fnrNum = 0;
+  fnrDirty = false;
+  nfNum = 0;
+  nfDirty = false;
+  phase = "BEGIN";
+  status = 0;
+  randomSeed = 1;
+  randomState = 1;
+  ensureEnviron() {
+    if (this.environInitialized) return;
+    this.environInitialized = true;
+    const environment = new AwkArray();
+    this.bindArray(this.variables, "ENVIRON", environment);
+    for (const [name, value] of Object.entries(this.context.env)) {
+      this.arraySet(environment, byteString(name), inputValue(byteString(value)));
+    }
+  }
+  store(name) {
+    return this.frames.at(-1)?.has(name) ? this.frames.at(-1) : this.variables;
+  }
+  syncSpecialVars() {
+    if (this.nrDirty) {
+      this.nrDirty = false;
+      this.storeScalar(this.variables, "NR", numeric(this.nrNum));
+    }
+    if (this.fnrDirty) {
+      this.fnrDirty = false;
+      this.storeScalar(this.variables, "FNR", numeric(this.fnrNum));
+    }
+    if (this.nfDirty) {
+      if (this.fieldCount < 0) this.ensureSliceFieldsSplit();
+      this.nfDirty = false;
+      this.storeScalar(this.variables, "NF", numeric(this.nfNum));
+    }
+  }
+  get(name) {
+    if (this.frames.length === 0 || !this.frames.at(-1).has(name)) {
+      if (name === "NR" && this.nrDirty) {
+        this.nrDirty = false;
+        this.storeScalar(this.variables, "NR", numeric(this.nrNum));
+      } else if (name === "FNR" && this.fnrDirty) {
+        this.fnrDirty = false;
+        this.storeScalar(this.variables, "FNR", numeric(this.fnrNum));
+      } else if (name === "NF" && this.nfDirty) {
+        if (this.fieldCount < 0) this.ensureSliceFieldsSplit();
+        this.nfDirty = false;
+        this.storeScalar(this.variables, "NF", numeric(this.nfNum));
+      } else if (name === "ENVIRON" && !this.environInitialized) this.ensureEnviron();
+    }
+    return this.store(name).get(name) ?? unset;
+  }
+  getScalar(name) {
+    return scalar(this.get(name));
+  }
+  asText(value) {
+    if (value.kind === "string" || value.kind === "numeric") return value.text;
+    if (value.kind === "unset") return "";
+    return text(value, text(this.getScalar("CONVFMT"), void 0, this.budget), this.budget);
+  }
+  varText(name) {
+    if (this.frames.length === 0) {
+      if (name === "FS") return this.fsText;
+      if (name === "RS") return this.rsText;
+      if (name === "CONVFMT") return this.convfmtText;
+    }
+    return this.asText(this.getScalar(name));
+  }
+  retainName(path) {
+    this.context.signal.throwIfAborted();
+    return this.retention.replace(0, shellValueByteLength(path), () => path.split("").join(""));
+  }
+  storeScalar(store, name, value) {
+    if (value.kind === "string" || value.kind === "numeric") this.budget.check(value.text);
+    this.retention.admit(textSize(store.get(name)), textSize(value));
+    const owned = ownScalar(value);
+    store.set(name, owned);
+    if (store === this.variables) {
+      if (name === "FS") this.fsText = this.asText(owned);
+      else if (name === "RS") this.rsText = this.asText(owned);
+      else if (name === "CONVFMT") this.convfmtText = this.asText(owned);
+      else if (name === "NR") {
+        this.nrNum = number(owned);
+        this.nrDirty = false;
+      } else if (name === "FNR") {
+        this.fnrNum = number(owned);
+        this.fnrDirty = false;
+      } else if (name === "NF") {
+        this.nfNum = number(owned);
+        this.nfDirty = false;
+      }
+    }
+  }
+  bindArray(store, name, array) {
+    let allocation = this.arrays.get(array);
+    if (!allocation) {
+      allocation = { bytes: 0, references: 0 };
+      this.arrays.set(array, allocation);
+    }
+    allocation.references++;
+    store.set(name, array);
+  }
+  releaseStore(store) {
+    for (const value of store.values()) {
+      if (value instanceof AwkArray) {
+        const allocation = this.arrays.get(value);
+        if (--allocation.references === 0) {
+          this.retention.release(allocation.bytes);
+          this.entries -= value.entries.size;
+          this.arrays.delete(value);
+        }
+      } else this.retention.release(textSize(value));
+    }
+    store.clear();
+  }
+  set(name, value) {
+    if (this.get(name) instanceof AwkArray) throw new ProgramError(`cannot assign a scalar to array '${name}'`);
+    if (name === "NF" && this.store(name) === this.variables) {
+      const length = Math.trunc(number(value));
+      if (!Number.isSafeInteger(length) || length < 0 || length > (this.budget.options.maxFields ?? Infinity)) throw new ProgramError("invalid or excessive NF");
+      const fields = this.ensureFields().slice(0, length);
+      while (fields.length < length) fields.push(string(""));
+      this.rebuild(fields);
+      return;
+    }
+    this.storeScalar(this.store(name), name, value);
+  }
+  setNumber(name, n) {
+    const valNum = (n | 0) === n && (n !== 0 || 1 / n > 0) ? n | 0 : n;
+    const store = this.store(name);
+    if (name === "NF" && store === this.variables) {
+      const val = numeric(valNum);
+      this.set(name, val);
+      return val;
+    }
+    const existing = store.get(name);
+    if (existing instanceof AwkArray) throw new ProgramError(`cannot assign a scalar to array '${name}'`);
+    this.retention.admit(textSize(existing), 0);
+    const box = numeric(valNum);
+    store.set(name, box);
+    if (store === this.variables) {
+      if (name === "FS") this.fsText = this.asText(box);
+      else if (name === "RS") this.rsText = this.asText(box);
+      else if (name === "CONVFMT") this.convfmtText = this.asText(box);
+      else if (name === "NR") {
+        this.nrNum = valNum;
+        this.nrDirty = false;
+      } else if (name === "FNR") {
+        this.fnrNum = valNum;
+        this.fnrDirty = false;
+      }
+    }
+    return box;
+  }
+  array(name) {
+    const value = this.get(name);
+    if (value instanceof AwkArray) return value;
+    if (value.kind !== "unset") throw new ProgramError(`scalar '${name}' used as an array`);
+    const array = new AwkArray();
+    this.bindArray(this.store(name), name, array);
+    return array;
+  }
+  arraySet(array, key, value) {
+    this.budget.check(key);
+    if (value.kind === "string" || value.kind === "numeric") this.budget.check(value.text);
+    const existingValue = array.entries.get(key);
+    if (existingValue !== void 0 && existingValue.kind === "number" && value.kind === "number") {
+      if (this.budget.context.signal.aborted) this.budget.context.signal.throwIfAborted();
+      array.entries.set(key, ownScalar(value));
+      return;
+    }
+    const existing = existingValue !== void 0 || array.entries.has(key);
+    if (!existing && this.entries >= (this.budget.options.maxArrayEntries ?? Infinity)) throw new ProgramError("array entry limit exceeded");
+    const previous = textSize(existingValue), next = textSize(value) + (existing ? 0 : key.length);
+    this.retention.admit(previous, next);
+    const ownedKey = existing || key.length < 13 ? key : latin1Text(latin1Bytes(key));
+    array.entries.set(ownedKey, ownScalar(value));
+    if (next !== previous) this.arrays.get(array).bytes += next - previous;
+    if (!existing) this.entries++;
+  }
+  pattern(source) {
+    const map = this.regexes ??= /* @__PURE__ */ new Map();
+    let pattern = map.get(source);
+    if (!pattern) {
+      pattern = new Pattern(source, true, false, "awk");
+      if (map.size >= 256) map.delete(map.keys().next().value);
+      map.set(source, pattern);
+    }
+    return pattern;
+  }
+  async regex(expression) {
+    return expression.kind === "regex" ? expression.pattern : this.pattern(this.asText(await this.scalarExpression(expression)));
+  }
+  splitSync(value, separator, paragraph) {
+    if (!paragraph && value.length < 256 && (separator === " " || separator.length === 1)) {
+      this.budget.step(value.length);
+      const maxFields = this.budget.options.maxFields ?? Infinity;
+      const parts = [];
+      if (separator === " ") {
+        let start = -1;
+        for (let index = 0; index < value.length; index++) {
+          const ch = value.charCodeAt(index);
+          if (ch === 32 || ch === 9 || ch === 10) {
+            if (start >= 0) {
+              if (parts.length >= maxFields) throw new ProgramError("field count limit exceeded");
+              parts.push(inputValue(value.slice(start, index)));
+              start = -1;
+            }
+          } else if (start < 0) start = index;
+        }
+        if (start >= 0) {
+          if (parts.length >= maxFields) throw new ProgramError("field count limit exceeded");
+          parts.push(inputValue(value.slice(start, value.length)));
+        }
+        return parts;
+      }
+      if (value !== "") {
+        let start = 0;
+        let idx;
+        while ((idx = value.indexOf(separator, start)) >= 0) {
+          if (parts.length >= maxFields) throw new ProgramError("field count limit exceeded");
+          parts.push(inputValue(value.slice(start, idx)));
+          start = idx + 1;
+        }
+        if (parts.length >= maxFields) throw new ProgramError("field count limit exceeded");
+        parts.push(inputValue(value.slice(start, value.length)));
+      }
+      return parts;
+    }
+    return this.split(value, separator, paragraph);
+  }
+  async split(value, separator, paragraph = false) {
+    this.budget.step(value.length);
+    const parts = [];
+    const append = (start, end) => {
+      if (parts.length >= (this.budget.options.maxFields ?? Infinity)) throw new ProgramError("field count limit exceeded");
+      parts.push(inputValue(value.slice(start, end)));
+    };
+    if (separator === " ") {
+      let start = -1;
+      for (let index = 0; index < value.length; index++) {
+        if (index % 256 === 0) await this.budget.checkpointSync();
+        if (" 	\n".includes(value[index])) {
+          if (start >= 0) {
+            append(start, index);
+            start = -1;
+          }
+        } else if (start < 0) start = index;
+      }
+      if (start >= 0) append(start, value.length);
+    } else if (separator === "") {
+      if (value.length > (this.budget.options.maxFields ?? Infinity)) throw new ProgramError("field count limit exceeded");
+      for (let index = 0; index < value.length; index++) {
+        if (index % 256 === 0) await this.budget.checkpointSync();
+        append(index, index + 1);
+      }
+    } else if (typeof separator === "string" && separator.length === 1) {
+      if (!paragraph && value.length < 256) {
+        if (value !== "") {
+          let start2 = 0;
+          let idx;
+          while ((idx = value.indexOf(separator, start2)) >= 0) {
+            append(start2, idx);
+            start2 = idx + 1;
+          }
+          append(start2, value.length);
+        }
+        return parts;
+      }
+      let start = 0;
+      for (let index = 0; index < value.length; index++) {
+        if (index > 0 && index % 256 === 0) {
+          const p = this.budget.checkpointSync();
+          if (p) await p;
+        }
+        if (value[index] === separator || paragraph && value[index] === "\n") {
+          append(start, index);
+          start = index + 1;
+        }
+      }
+      if (value !== "") append(start, value.length);
+    } else {
+      const matcher = typeof separator === "string" ? this.pattern(separator) : separator;
+      const segment = async (start, end) => {
+        if (paragraph) for (let index = start; index < end; index++) {
+          if (index % 256 === 0) await this.budget.checkpointSync();
+          if (value[index] === "\n") {
+            append(start, index);
+            start = index + 1;
+          }
+        }
+        append(start, end);
+      };
+      let consumed = 0;
+      let search = 0;
+      while (search <= value.length) {
+        await this.budget.checkpointSync();
+        const match = await matcher.find(value, this.budget, search);
+        if (!match) break;
+        if (match.start === match.end) {
+          search = match.end + 1;
+          continue;
+        }
+        await segment(consumed, match.start);
+        consumed = match.end;
+        search = match.end;
+      }
+      if (value !== "") await segment(consumed, value.length);
+    }
+    return parts;
+  }
+  parseSliceNumber(record, start, end) {
+    const len = end - start;
+    if (len <= 0) return 0;
+    const first = record.charCodeAt(start);
+    if (first >= 48 && first <= 57 && len <= 9) {
+      let num = first - 48 | 0;
+      for (let i = start + 1; i < end; i++) {
+        const c = record.charCodeAt(i);
+        if (c < 48 || c > 57) {
+          return number(inputValueFromSlice(record, start, end));
+        }
+        num = Math.imul(num, 10) + (c - 48) | 0;
+      }
+      return num;
+    }
+    if (first >= 48 && first <= 57 && len <= 15) {
+      let num = first - 48;
+      for (let i = start + 1; i < end; i++) {
+        const c = record.charCodeAt(i);
+        if (c < 48 || c > 57) {
+          return number(inputValueFromSlice(record, start, end));
+        }
+        num = num * 10 + (c - 48);
+      }
+      return num;
+    }
+    return number(inputValueFromSlice(record, start, end));
+  }
+  getFieldNumber(index) {
+    if (index === 0) return number(this.getField(0));
+    const slot = index - 1;
+    if (this.fieldsMaterialized) {
+      const f = this.rawFields[slot];
+      return f ? number(f) : 0;
+    }
+    if (this.fieldCount < 0) {
+      const sep = this.deferredFieldSeparator;
+      if (sep.length === 1 && sep !== " ") {
+        const source = this.recordSource;
+        const recEnd = this.recordEnd;
+        let start = this.recordStart;
+        if (start >= recEnd) return 0;
+        for (let s = 0; s < slot; s++) {
+          const idx = source.indexOf(sep, start);
+          if (idx < 0 || idx >= recEnd) return 0;
+          start = idx + 1;
+        }
+        const nextIdx = source.indexOf(sep, start);
+        const end = nextIdx >= 0 && nextIdx < recEnd ? nextIdx : recEnd;
+        return this.parseSliceNumber(source, start, end);
+      }
+      this.ensureSliceFieldsSplit();
+    }
+    if (slot < 0 || slot >= this.fieldCount) return 0;
+    if (this.lazyFieldGen[slot] === this.fieldGeneration) {
+      return number(this.lazyFields[slot]);
+    }
+    return this.parseSliceNumber(this.recordSource, this.fieldStarts[slot], this.fieldEnds[slot]);
+  }
+  getField(index) {
+    if (index === 0) {
+      return this.recordValue ??= inputValue(this.record);
+    }
+    if (this.fieldCount < 0) this.ensureSliceFieldsSplit();
+    const slot = index - 1;
+    if (this.fieldsMaterialized) {
+      return this.rawFields[slot] ?? string("");
+    }
+    if (slot < 0 || slot >= this.fieldCount) return string("");
+    if (this.lazyFieldGen[slot] === this.fieldGeneration) {
+      return this.lazyFields[slot];
+    }
+    const val = inputValueFromSlice(this.recordSource, this.fieldStarts[slot], this.fieldEnds[slot]);
+    this.lazyFieldGen[slot] = this.fieldGeneration;
+    this.lazyFields[slot] = val;
+    return val;
+  }
+  ensureFields() {
+    if (this.fieldCount < 0) this.ensureSliceFieldsSplit();
+    if (!this.fieldsMaterialized) {
+      const out = new Array(this.fieldCount);
+      for (let i = 0; i < this.fieldCount; i++) {
+        out[i] = this.lazyFieldGen[i] === this.fieldGeneration ? this.lazyFields[i] : inputValueFromSlice(this.recordSource, this.fieldStarts[i], this.fieldEnds[i]);
+      }
+      this.rawFields = out;
+      this.fieldsMaterialized = true;
+    }
+    return this.rawFields;
+  }
+  ensureSliceFieldsSplit() {
+    if (this.fieldCount >= 0) return;
+    const source = this.recordSource;
+    const recStart = this.recordStart;
+    const recEnd = this.recordEnd;
+    const recLen = recEnd - recStart;
+    const separator = this.deferredFieldSeparator;
+    let count = 0;
+    let fieldBytes = 0;
+    const starts = this.fieldStarts;
+    const ends = this.fieldEnds;
+    if (separator === " ") {
+      let start = -1;
+      for (let index = recStart; index < recEnd; index++) {
+        const ch = source.charCodeAt(index);
+        if (ch === 32 || ch === 9 || ch === 10) {
+          if (start >= 0) {
+            starts[count] = start;
+            ends[count] = index;
+            fieldBytes += index - start;
+            count++;
+            start = -1;
+          }
+        } else if (start < 0) start = index;
+      }
+      if (start >= 0) {
+        starts[count] = start;
+        ends[count] = recEnd;
+        fieldBytes += recEnd - start;
+        count++;
+      }
+    } else if (recLen > 0) {
+      let start = recStart;
+      let idx;
+      while ((idx = source.indexOf(separator, start)) >= 0 && idx < recEnd) {
+        starts[count] = start;
+        ends[count] = idx;
+        fieldBytes += idx - start;
+        count++;
+        start = idx + 1;
+      }
+      starts[count] = start;
+      ends[count] = recEnd;
+      fieldBytes += recEnd - start;
+      count++;
+    }
+    this.retention.admit(0, fieldBytes);
+    this.fieldBytes = fieldBytes;
+    this.fieldCount = count;
+    this.nfNum = count;
+  }
+  setRecordSliceSync(source, recStart, recEnd) {
+    const recLen = recEnd - recStart;
+    if (recLen > this.budget.maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
+    const separator = this.varText("FS");
+    const paragraph = this.varText("RS") === "";
+    const maxFields = this.budget.options.maxFields ?? Infinity;
+    if (!paragraph && recLen < 256 && (separator === " " || separator.length === 1) && maxFields >= 64) {
+      this.budget.step(recLen);
+      if (recLen < 64 && this.retention.capacity === Infinity) {
+        this.retention.admit(this.recordLength + this.fieldBytes, recLen);
+        this.rawRecord = void 0;
+        this.recordSource = source;
+        this.recordStart = recStart;
+        this.recordEnd = recEnd;
+        this.fieldBytes = 0;
+        this.fieldCount = -1;
+        this.deferredFieldSeparator = separator;
+        this.fieldsMaterialized = false;
+        this.fieldGeneration = this.fieldGeneration + 1 | 0 || 1;
+        this.recordValue = void 0;
+        this.nfDirty = true;
+        return;
+      }
+      let count = 0;
+      let fieldBytes = 0;
+      const starts = this.fieldStarts;
+      const ends = this.fieldEnds;
+      if (separator === " ") {
+        let start = -1;
+        for (let index = recStart; index < recEnd; index++) {
+          const ch = source.charCodeAt(index);
+          if (ch === 32 || ch === 9 || ch === 10) {
+            if (start >= 0) {
+              if (count >= maxFields || count >= 64) return this.setRecordSlow(source.slice(recStart, recEnd), separator, paragraph);
+              starts[count] = start;
+              ends[count] = index;
+              fieldBytes += index - start;
+              count++;
+              start = -1;
+            }
+          } else if (start < 0) start = index;
+        }
+        if (start >= 0) {
+          if (count >= maxFields || count >= 64) return this.setRecordSlow(source.slice(recStart, recEnd), separator, paragraph);
+          starts[count] = start;
+          ends[count] = recEnd;
+          fieldBytes += recEnd - start;
+          count++;
+        }
+      } else if (recLen > 0) {
+        let start = recStart;
+        let idx;
+        while ((idx = source.indexOf(separator, start)) >= 0 && idx < recEnd) {
+          if (count >= maxFields || count >= 64) return this.setRecordSlow(source.slice(recStart, recEnd), separator, paragraph);
+          starts[count] = start;
+          ends[count] = idx;
+          fieldBytes += idx - start;
+          count++;
+          start = idx + 1;
+        }
+        if (count >= maxFields || count >= 64) return this.setRecordSlow(source.slice(recStart, recEnd), separator, paragraph);
+        starts[count] = start;
+        ends[count] = recEnd;
+        fieldBytes += recEnd - start;
+        count++;
+      }
+      this.retention.admit(this.recordLength + this.fieldBytes, recLen + fieldBytes);
+      this.rawRecord = void 0;
+      this.recordSource = source;
+      this.recordStart = recStart;
+      this.recordEnd = recEnd;
+      this.fieldBytes = fieldBytes;
+      this.fieldCount = count;
+      this.fieldsMaterialized = false;
+      this.fieldGeneration = this.fieldGeneration + 1 | 0 || 1;
+      this.recordValue = void 0;
+      this.nfNum = count;
+      this.nfDirty = true;
+      return;
+    }
+    return this.setRecordSlow(source.slice(recStart, recEnd), separator, paragraph);
+  }
+  setRecordSync(record, value) {
+    if (value === void 0) return this.setRecordSliceSync(record, 0, record.length);
+    this.budget.check(record);
+    const separator = this.varText("FS");
+    const paragraph = this.varText("RS") === "";
+    const maxFields = this.budget.options.maxFields ?? Infinity;
+    if (value === void 0 && !paragraph && record.length < 256 && (separator === " " || separator.length === 1) && maxFields >= 64) {
+      this.budget.step(record.length);
+      let count = 0;
+      let fieldBytes = 0;
+      const starts = this.fieldStarts;
+      const ends = this.fieldEnds;
+      if (separator === " ") {
+        let start = -1;
+        for (let index = 0; index < record.length; index++) {
+          const ch = record.charCodeAt(index);
+          if (ch === 32 || ch === 9 || ch === 10) {
+            if (start >= 0) {
+              if (count >= maxFields || count >= 64) return this.setRecordSlow(record, separator, paragraph, value);
+              starts[count] = start;
+              ends[count] = index;
+              fieldBytes += index - start;
+              count++;
+              start = -1;
+            }
+          } else if (start < 0) start = index;
+        }
+        if (start >= 0) {
+          if (count >= maxFields || count >= 64) return this.setRecordSlow(record, separator, paragraph, value);
+          starts[count] = start;
+          ends[count] = record.length;
+          fieldBytes += record.length - start;
+          count++;
+        }
+      } else if (record !== "") {
+        let start = 0;
+        let idx;
+        while ((idx = record.indexOf(separator, start)) >= 0) {
+          if (count >= maxFields || count >= 64) return this.setRecordSlow(record, separator, paragraph, value);
+          starts[count] = start;
+          ends[count] = idx;
+          fieldBytes += idx - start;
+          count++;
+          start = idx + 1;
+        }
+        if (count >= maxFields || count >= 64) return this.setRecordSlow(record, separator, paragraph, value);
+        starts[count] = start;
+        ends[count] = record.length;
+        fieldBytes += record.length - start;
+        count++;
+      }
+      this.retention.admit(this.record.length + this.fieldBytes, record.length + fieldBytes);
+      this.record = record;
+      this.fieldBytes = fieldBytes;
+      this.fieldCount = count;
+      this.fieldsMaterialized = false;
+      this.fieldGeneration = this.fieldGeneration + 1 | 0 || 1;
+      this.recordValue = void 0;
+      this.variables.set("NF", numeric(count));
+      return;
+    }
+    return this.setRecordSlow(record, separator, paragraph, value);
+  }
+  setRecordSlow(record, separator, paragraph, value) {
+    const resolvedVal = value ?? inputValue(record);
+    const fields = this.splitSync(record, separator, paragraph);
+    if (!(fields instanceof Promise)) {
+      this.replaceRecord(record, fields, resolvedVal);
+      return;
+    }
+    return fields.then((resolved) => {
+      this.replaceRecord(record, resolved, resolvedVal);
+    });
+  }
+  async setRecord(record, value) {
+    await this.setRecordSync(record, value);
+  }
+  replaceRecord(record, fields, value = string(record)) {
+    let fieldBytes = 0;
+    for (const field of fields) {
+      if (field.kind === "string" || field.kind === "numeric") this.budget.check(field.text);
+      fieldBytes += textSize(field);
+    }
+    this.retention.admit(this.recordLength + this.fieldBytes, record.length + fieldBytes);
+    this.record = record;
+    this.fields = fields;
+    this.fieldCount = fields.length;
+    this.fieldsMaterialized = true;
+    this.fieldBytes = fieldBytes;
+    this.recordValue = value.kind === "string" || value.kind === "numeric" ? { ...value, text: this.record } : value;
+    this.nfNum = fields.length;
+    this.nfDirty = true;
+  }
+  join(parts, separator, suffix = "") {
+    this.budget.step(parts.length + 1);
+    let used = 0;
+    for (let index = 0; index < parts.length; index++) {
+      if (index > 0) {
+        if (separator.length > this.budget.maxBufferBytes - used) throw new ProgramError("text buffer limit exceeded");
+        used += separator.length;
+      }
+      if (parts[index].length > this.budget.maxBufferBytes - used) throw new ProgramError("text buffer limit exceeded");
+      used += parts[index].length;
+    }
+    if (suffix.length > this.budget.maxBufferBytes - used) throw new ProgramError("text buffer limit exceeded");
+    used += suffix.length;
+    this.budget.step(used);
+    return parts.join(separator) + suffix;
+  }
+  rebuild(fields) {
+    const record = this.join(fields.map((value) => this.asText(value)), this.varText("OFS"));
+    this.replaceRecord(record, fields);
+  }
+  key(items) {
+    if (items.length === 1) {
+      const first = this.scalarExpression(items[0]);
+      if (!(first instanceof Promise)) {
+        const k = this.asText(first);
+        this.budget.step(2);
+        if (k.length > this.budget.maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
+        this.budget.step(k.length);
+        return k;
+      }
+    }
+    return this.keySlow(items);
+  }
+  async keySlow(items) {
+    const pieces = [];
+    for (const item of items) pieces.push(this.asText(await this.scalarExpression(item)));
+    return this.join(pieces, this.varText("SUBSEP"));
+  }
+  async reference(expression) {
+    if (expression.kind === "variable") return { get: () => this.get(expression.name), set: (value) => this.set(expression.name, value) };
+    if (expression.kind === "field") {
+      const index = Math.trunc(number(await this.scalarExpression(expression.index)));
+      if (!Number.isSafeInteger(index) || index < 0 || index > (this.budget.options.maxFields ?? Infinity)) throw new ProgramError("invalid or excessive field index");
+      return {
+        get: () => this.getField(index),
+        set: (value) => {
+          if (index === 0) return this.setRecord(this.asText(value), value);
+          const fields = this.ensureFields().slice();
+          while (fields.length < index) fields.push(string(""));
+          fields[index - 1] = value;
+          this.rebuild(fields);
+        }
+      };
+    }
+    if (expression.kind === "array") {
+      const array = this.array(expression.name);
+      const key = await this.key(expression.indexes);
+      return { get: () => {
+        if (!array.entries.has(key)) this.arraySet(array, key, unset);
+        return array.entries.get(key);
+      }, set: (value) => this.arraySet(array, key, value) };
+    }
+    throw new ProgramError("expression is not assignable");
+  }
+  arithmetic(operator, left, right) {
+    if ((operator === "/" || operator === "%") && right === 0) throw new ProgramError("division by zero");
+    const result = operator === "+" ? left + right : operator === "-" ? left - right : operator === "*" ? left * right : operator === "/" ? left / right : operator === "%" ? left % right : left ** right;
+    if (!Number.isFinite(result)) throw new ProgramError("non-finite arithmetic result");
+    return result;
+  }
+  scalarExpression(expression) {
+    const val = this.evaluate(expression);
+    return val instanceof Promise ? val.then(scalar) : scalar(val);
+  }
+  evaluate(expression) {
+    this.budget.step();
+    switch (expression.kind) {
+      case "number":
+        return numeric(expression.value);
+      case "string":
+        return string(expression.value);
+      case "regex":
+        return this.evaluateRegexMatch(expression.pattern);
+      case "variable":
+        return this.get(expression.name);
+      case "field": {
+        if (expression.index.kind === "number") {
+          this.budget.step();
+          const index = Math.trunc(expression.index.value);
+          if (!Number.isSafeInteger(index) || index < 0 || index > (this.budget.options.maxFields ?? Infinity)) throw new ProgramError("invalid or excessive field index");
+          return this.getField(index);
+        }
+        const idxVal = this.scalarExpression(expression.index);
+        if (!(idxVal instanceof Promise)) {
+          const index = Math.trunc(number(idxVal));
+          if (!Number.isSafeInteger(index) || index < 0 || index > (this.budget.options.maxFields ?? Infinity)) throw new ProgramError("invalid or excessive field index");
+          return this.getField(index);
+        }
+        return this.evaluateFieldAsync(idxVal);
+      }
+      case "array": {
+        const array = this.array(expression.name);
+        const k = this.key(expression.indexes);
+        if (!(k instanceof Promise)) {
+          let existing = array.entries.get(k);
+          if (existing === void 0 && !array.entries.has(k)) {
+            this.arraySet(array, k, unset);
+            existing = unset;
+          }
+          return existing;
+        }
+        return this.evaluateArrayAsync(array, k);
+      }
+      case "getline":
+        return this.getline(expression);
+      case "tuple":
+        throw new ProgramError("tuple is only valid as an array membership key");
+      case "conditional": {
+        const cond = this.scalarExpression(expression.condition);
+        return cond instanceof Promise ? this.evaluateConditionalAsync(expression, cond) : this.evaluate(truth(cond) ? expression.yes : expression.no);
+      }
+      case "unary": {
+        if (expression.operator === "++" || expression.operator === "--") {
+          if (expression.operand.kind === "variable") {
+            const name = expression.operand.name;
+            const previous = number(scalar(this.get(name)));
+            const delta = expression.operator === "++" ? 1 : -1;
+            const next = (previous | 0) === previous && previous > -1073741820 && previous < 1073741820 ? previous + delta | 0 : previous + delta;
+            const updated = this.setNumber(name, next);
+            return expression.postfix ? numeric(previous) : updated;
+          }
+          if (expression.operand.kind === "array") {
+            const array = this.array(expression.operand.name);
+            const k = this.key(expression.operand.indexes);
+            if (!(k instanceof Promise)) {
+              let current = array.entries.get(k);
+              if (current === void 0 && !array.entries.has(k)) {
+                this.arraySet(array, k, unset);
+                current = unset;
+              }
+              const previous = number(scalar(current));
+              const next = previous + (expression.operator === "++" ? 1 : -1);
+              this.arraySet(array, k, numeric(next));
+              return numeric(expression.postfix ? previous : next);
+            }
+            return this.evaluateUnaryArrayAsync(expression, array, k);
+          }
+          return this.evaluateUnarySlow(expression);
+        }
+        const operand = this.scalarExpression(expression.operand);
+        if (!(operand instanceof Promise)) {
+          return numeric(expression.operator === "!" ? truth(operand) ? 0 : 1 : expression.operator === "-" ? -number(operand) : number(operand));
+        }
+        return this.evaluateUnaryValueAsync(expression.operator, operand);
+      }
+      case "binary": {
+        const operator = expression.operator;
+        if (operator === "=" || operator === "+=" || operator === "-=" || operator === "*=" || operator === "/=" || operator === "%=" || operator === "^=") {
+          if (expression.left.kind === "variable") {
+            const name = expression.left.name;
+            if (operator !== "=" && expression.right.kind === "field" && expression.right.index.kind === "number") {
+              this.budget.step(2);
+              const idx = Math.trunc(expression.right.index.value);
+              if (Number.isSafeInteger(idx) && idx > 0 && idx <= (this.budget.options.maxFields ?? Infinity)) {
+                const prevNum = number(scalar(this.get(name)));
+                const rightNum = this.getFieldNumber(idx);
+                const nextNum = operator === "+=" && (prevNum | 0) === prevNum && (rightNum | 0) === rightNum && prevNum > -536870912 && prevNum < 536870912 && rightNum > -536870912 && rightNum < 536870912 ? prevNum + rightNum | 0 : this.arithmetic(operator[0], prevNum, rightNum);
+                return this.setNumber(name, nextNum);
+              }
+            }
+            const previous = operator === "=" ? unset : scalar(this.get(name));
+            const rightVal = this.scalarExpression(expression.right);
+            if (!(rightVal instanceof Promise)) {
+              if (operator !== "=") {
+                return this.setNumber(name, this.arithmetic(operator[0], number(previous), number(rightVal)));
+              }
+              this.set(name, rightVal);
+              return rightVal;
+            }
+            return this.evaluateAssignVarAsync(operator, name, previous, rightVal);
+          } else if (expression.left.kind === "array") {
+            const array = this.array(expression.left.name);
+            const k = this.key(expression.left.indexes);
+            if (!(k instanceof Promise)) {
+              let current = operator === "=" ? unset : array.entries.get(k);
+              if (operator !== "=" && current === void 0 && !array.entries.has(k)) {
+                this.arraySet(array, k, unset);
+                current = unset;
+              }
+              const previous = scalar(current);
+              const rightVal = this.scalarExpression(expression.right);
+              if (!(rightVal instanceof Promise)) {
+                const value = operator === "=" ? rightVal : numeric(this.arithmetic(operator[0], number(previous), number(rightVal)));
+                this.arraySet(array, k, value);
+                return value;
+              }
+              return this.evaluateAssignArrayRightAsync(operator, array, k, previous, rightVal);
+            }
+            return this.evaluateAssignArrayKeyAsync(expression, operator, array, k);
+          }
+          return this.evaluateBinarySlow(expression);
+        }
+        if (operator === "~" || operator === "!~") {
+          if (expression.right.kind === "regex") {
+            const left2 = this.scalarExpression(expression.left);
+            if (!(left2 instanceof Promise)) {
+              const matched = expression.right.pattern.tryTestSync(this.asText(left2), this.budget);
+              if (!(matched instanceof Promise)) {
+                return numeric((operator === "~" ? matched : !matched) ? 1 : 0);
+              }
+            }
+          }
+          return this.evaluateBinarySlow(expression);
+        }
+        if (operator === "in") {
+          return this.evaluateBinarySlow(expression);
+        }
+        const left = this.scalarExpression(expression.left);
+        if (left instanceof Promise) return this.evaluateBinaryWithLeftPromise(expression, left);
+        if (operator === "&&" && !truth(left)) return numeric(0);
+        if (operator === "||" && truth(left)) return numeric(1);
+        const right = this.scalarExpression(expression.right);
+        if (right instanceof Promise) return this.evaluateBinaryWithRightPromise(operator, left, right);
+        return this.evaluateBinarySyncOperands(operator, left, right);
+      }
+      case "call":
+        return this.call(expression.name, expression.args);
+    }
+  }
+  evaluateRegexMatch(pattern) {
+    if (pattern.canFindSync() && this.recordLength < 256) {
+      const fastMatched = this.rawRecord !== void 0 ? pattern.findSyncFastInto(this.rawRecord, this.budget, 0, FAST_AWK_MATCH_OFFSETS, this.rawRecord.length, 0) : pattern.findSyncFastInto(this.recordSource, this.budget, this.recordStart, FAST_AWK_MATCH_OFFSETS, this.recordEnd, this.recordStart);
+      const count = ++this.recordChecks;
+      if (count <= 2 || (count & 31) === 0) {
+        const p = this.budget.checkpointSync();
+        if (p) return p.then(fastMatched ? RETURN_SCALAR_ONE : RETURN_SCALAR_ZERO);
+      }
+      return fastMatched ? SCALAR_ONE : SCALAR_ZERO;
+    }
+    const matched = this.rawRecord !== void 0 ? pattern.tryTestSync(this.rawRecord, this.budget, 0, this.rawRecord.length) : pattern.tryTestSync(this.recordSource, this.budget, this.recordStart, this.recordEnd);
+    if (matched instanceof Promise) return matched.then((m) => m ? SCALAR_ONE : SCALAR_ZERO);
+    return matched ? SCALAR_ONE : SCALAR_ZERO;
+  }
+  async evaluateFieldAsync(idxPromise) {
+    const resolved = await idxPromise;
+    const index = Math.trunc(number(resolved));
+    if (!Number.isSafeInteger(index) || index < 0 || index > (this.budget.options.maxFields ?? Infinity)) throw new ProgramError("invalid or excessive field index");
+    return this.getField(index);
+  }
+  async evaluateArrayAsync(array, keyPromise) {
+    const resolvedKey = await keyPromise;
+    let existing = array.entries.get(resolvedKey);
+    if (existing === void 0 && !array.entries.has(resolvedKey)) {
+      this.arraySet(array, resolvedKey, unset);
+      existing = unset;
+    }
+    return existing;
+  }
+  async evaluateConditionalAsync(expression, condPromise) {
+    const c = await condPromise;
+    return this.evaluate(truth(c) ? expression.yes : expression.no);
+  }
+  async evaluateUnaryArrayAsync(expression, array, keyPromise) {
+    const resolvedKey = await keyPromise;
+    let current = array.entries.get(resolvedKey);
+    if (current === void 0 && !array.entries.has(resolvedKey)) {
+      this.arraySet(array, resolvedKey, unset);
+      current = unset;
+    }
+    const previous = number(scalar(current));
+    const next = previous + (expression.operator === "++" ? 1 : -1);
+    this.arraySet(array, resolvedKey, numeric(next));
+    return numeric(expression.postfix ? previous : next);
+  }
+  async evaluateUnaryValueAsync(operator, operandPromise) {
+    const op = await operandPromise;
+    return numeric(operator === "!" ? truth(op) ? 0 : 1 : operator === "-" ? -number(op) : number(op));
+  }
+  async evaluateAssignVarAsync(operator, name, previous, rightPromise) {
+    const resolved = await rightPromise;
+    const value = operator === "=" ? resolved : numeric(this.arithmetic(operator[0], number(previous), number(resolved)));
+    this.set(name, value);
+    return value;
+  }
+  async evaluateAssignArrayRightAsync(operator, array, k, previous, rightPromise) {
+    const resolved = await rightPromise;
+    const value = operator === "=" ? resolved : numeric(this.arithmetic(operator[0], number(previous), number(resolved)));
+    this.arraySet(array, k, value);
+    return value;
+  }
+  async evaluateAssignArrayKeyAsync(expression, operator, array, keyPromise) {
+    const resolvedKey = await keyPromise;
+    let current = operator === "=" ? unset : array.entries.get(resolvedKey);
+    if (operator !== "=" && current === void 0 && !array.entries.has(resolvedKey)) {
+      this.arraySet(array, resolvedKey, unset);
+      current = unset;
+    }
+    const previous = scalar(current);
+    const resolved = await this.scalarExpression(expression.right);
+    const value = operator === "=" ? resolved : numeric(this.arithmetic(operator[0], number(previous), number(resolved)));
+    this.arraySet(array, resolvedKey, value);
+    return value;
+  }
+  async evaluateBinaryWithRightPromise(operator, left, rightPromise) {
+    const r = await rightPromise;
+    return this.evaluateBinarySyncOperands(operator, left, r);
+  }
+  evaluateBinarySyncOperands(operator, left, right) {
+    if (operator === "&&" || operator === "||") return numeric(truth(right) ? 1 : 0);
+    if (operator === "concat") {
+      const leftText = this.asText(left);
+      const rightText = this.asText(right);
+      this.budget.step(0);
+      if (rightText.length > this.budget.maxBufferBytes - leftText.length) throw new ProgramError("text buffer limit exceeded");
+      this.budget.step(leftText.length + rightText.length);
+      return string(leftText + rightText);
+    }
+    if (operator === "==" || operator === "!=" || operator === "<" || operator === "<=" || operator === ">" || operator === ">=") {
+      let order;
+      if (left.kind !== "string" && right.kind !== "string") {
+        const first = number(left);
+        const second = number(right);
+        order = first < second ? -1 : first > second ? 1 : 0;
+      } else {
+        order = compare(left, right, this.varText("CONVFMT"), this.budget);
+      }
+      return numeric((operator === "==" ? order === 0 : operator === "!=" ? order !== 0 : operator === "<" ? order < 0 : operator === "<=" ? order <= 0 : operator === ">" ? order > 0 : order >= 0) ? 1 : 0);
+    }
+    return numeric(this.arithmetic(operator, number(left), number(right)));
+  }
+  async evaluateBinaryWithLeftPromise(expression, leftPromise) {
+    const operator = expression.operator;
+    const left = await leftPromise;
+    if (operator === "&&" && !truth(left)) return numeric(0);
+    if (operator === "||" && truth(left)) return numeric(1);
+    const right = await this.scalarExpression(expression.right);
+    return this.evaluateBinarySyncOperands(operator, left, right);
+  }
+  async evaluateUnarySlow(expression) {
+    if (expression.operator === "++" || expression.operator === "--") {
+      const reference = await this.reference(expression.operand);
+      const previous = number(scalar(reference.get()));
+      const next = previous + (expression.operator === "++" ? 1 : -1);
+      await reference.set(numeric(next));
+      return numeric(expression.postfix ? previous : next);
+    }
+    const operand = await this.scalarExpression(expression.operand);
+    return numeric(expression.operator === "!" ? truth(operand) ? 0 : 1 : expression.operator === "-" ? -number(operand) : number(operand));
+  }
+  async evaluateBinarySlow(expression) {
+    const operator = expression.operator;
+    if (["=", "+=", "-=", "*=", "/=", "%=", "^="].includes(operator)) {
+      const reference = await this.reference(expression.left);
+      const previous = operator === "=" ? unset : scalar(reference.get());
+      let value = await this.scalarExpression(expression.right);
+      if (operator !== "=") value = numeric(this.arithmetic(operator[0], number(previous), number(value)));
+      await reference.set(value);
+      return value;
+    }
+    if (operator === "in") {
+      const array = this.array(expression.right.name);
+      const key = expression.left.kind === "tuple" ? await this.key(expression.left.items) : this.asText(await this.scalarExpression(expression.left));
+      return numeric(array.entries.has(key) ? 1 : 0);
+    }
+    const left = await this.scalarExpression(expression.left);
+    if (operator === "~" || operator === "!~") {
+      const matched = await (await this.regex(expression.right)).find(this.asText(left), this.budget) !== void 0;
+      return numeric((operator === "~" ? matched : !matched) ? 1 : 0);
+    }
+    const right = await this.scalarExpression(expression.right);
+    return this.evaluateBinarySyncOperands(operator, left, right);
+  }
+  async getline(expression) {
+    if (expression.pipe) {
+      const command = textDecoder.decode(latin1Bytes(this.asText(await this.scalarExpression(expression.pipe))));
+      const record2 = await (this.pipes ??= new AwkPipes(this.context, this.budget, this.retention)).read(command, this.varText("RS"));
+      if (record2 === void 0) return numeric(0);
+      if (expression.target) await (await this.reference(expression.target)).set(inputValue(record2));
+      else await this.setRecord(record2);
+      return numeric(1);
+    }
+    if (!expression.file) {
+      const record2 = await this.readMainRecord();
+      if (record2 === void 0) return numeric(0);
+      const target2 = expression.target ? await this.reference(expression.target) : void 0;
+      if (target2) await target2.set(inputValue(record2));
+      else await this.setRecord(record2);
+      return numeric(1);
+    }
+    const target = expression.target ? await this.reference(expression.target) : void 0;
+    const file = textDecoder.decode(latin1Bytes(this.asText(await this.scalarExpression(expression.file))));
+    if (!file) throw new ProgramError("getline requires a nonempty filename");
+    let path;
+    try {
+      path = virtualPath(this.context, file);
+    } catch (error) {
+      if (!(error instanceof FsError)) throw error;
+      this.set("ERRNO", string(byteString(error.message)));
+      return numeric(-1);
+    }
+    const inputs = this.inputs ??= /* @__PURE__ */ new Map();
+    let reader = inputs.get(path);
+    if (!reader) {
+      if (inputs.size >= (this.budget.options.maxGetlineFiles ?? Infinity)) throw new ProgramError("getline open-file limit exceeded");
+      const { context, budget } = this;
+      const name = this.retainName(path);
+      const useStdin = file === "-" || file === "/dev/stdin";
+      const source = (async function* () {
+        if (useStdin) yield* context.stdin;
+        else {
+          budget.step();
+          await budget.checkpointSync();
+          const capabilities = await context.fs.capabilitiesFor?.(name, { signal: context.signal }) ?? context.fs.capabilities;
+          context.signal.throwIfAborted();
+          if (context.fs.readStream && capabilities.streamingRead !== false) yield* context.fs.readStream(name, { signal: context.signal });
+          else yield await context.fs.readFile(name, { signal: context.signal, ...Number.isFinite(budget.maxBufferBytes) ? { maxBytes: budget.maxBufferBytes } : {} });
+        }
+      })();
+      try {
+        reader = new Reader(source, budget, this.retention);
+        inputs.set(name, reader);
+      } catch (error) {
+        this.retention.release(shellValueByteLength(name));
+        throw error;
+      }
+    }
+    let record;
+    try {
+      record = await reader.read(this.varText("RS"));
+    } catch (error) {
+      this.context.signal.throwIfAborted();
+      if (!(error instanceof FsError)) throw error;
+      inputs.delete(path);
+      this.retention.release(shellValueByteLength(path));
+      await reader.close();
+      this.set("ERRNO", string(byteString(error.message)));
+      return numeric(-1);
+    }
+    if (record === void 0) return numeric(0);
+    if (target) await target.set(inputValue(record));
+    else await this.setRecord(record);
+    return numeric(1);
+  }
+  async call(name, args) {
+    const definition = this.program.functions.get(name);
+    if (definition) {
+      if (this.frames.length >= (this.budget.options.maxRecursionDepth ?? Infinity)) throw new ProgramError("function recursion limit exceeded");
+      const frame = /* @__PURE__ */ new Map();
+      try {
+        for (let index = 0; index < definition.parameters.length; index++) {
+          const parameter = definition.parameters[index];
+          const argument = args[index];
+          if (definition.arrays.has(parameter)) {
+            if (argument !== void 0 && argument.kind !== "variable") throw new ProgramError("array parameter requires an array variable");
+            this.bindArray(frame, parameter, argument ? this.array(argument.name) : new AwkArray());
+          } else {
+            const value = argument ? await this.evaluate(argument) : unset;
+            if (value instanceof AwkArray) this.bindArray(frame, parameter, value);
+            else this.storeScalar(frame, parameter, value);
+          }
+        }
+      } catch (error) {
+        this.releaseStore(frame);
+        throw error;
+      }
+      this.frames.push(frame);
+      try {
+        await this.execute(definition.body);
+        return unset;
+      } catch (error) {
+        if (error instanceof Flow && error.kind === "return") return error.value;
+        throw error;
+      } finally {
+        this.frames.pop();
+        this.releaseStore(frame);
+      }
+    }
+    if (name === "length") {
+      const value = args[0] ? await this.evaluate(args[0]) : string(this.record);
+      return numeric(value instanceof AwkArray ? value.entries.size : this.asText(value).length);
+    }
+    if (name === "gensub") {
+      const pattern = await this.regex(args[0]);
+      const rawReplacement = this.asText(await this.scalarExpression(args[1]));
+      let replacement = "";
+      for (let index = 0; index < rawReplacement.length; index++) {
+        const character = rawReplacement[index];
+        if (character === "\\" && index + 1 < rawReplacement.length) {
+          const next = rawReplacement[++index];
+          replacement += "0123456789&\\".includes(next) ? "\\" + next : next;
+        } else replacement += character;
+      }
+      this.budget.step(rawReplacement.length);
+      const how = await this.scalarExpression(args[2]);
+      const target = args[3] ? this.asText(await this.scalarExpression(args[3])) : this.record;
+      const global = this.asText(how).toLowerCase().startsWith("g");
+      const occurrence = Math.max(1, Math.trunc(number(how)) || 1);
+      return string((await substitute(target, pattern, replacement, this.budget, global, occurrence, "sed")).text);
+    }
+    if (name === "asort" || name === "asorti") {
+      const source = this.array(args[0].name);
+      const target = args[1] ? this.array(args[1].name) : source;
+      if (this.entries - target.entries.size + source.entries.size > (this.budget.options.maxArrayEntries ?? Infinity)) throw new ProgramError("array entry limit exceeded");
+      const values2 = [];
+      let size = 0;
+      for (const [key, value] of source.entries) {
+        this.budget.step();
+        const item = name === "asorti" ? string(key) : scalar(value);
+        size += String(values2.length + 1).length + textSize(item);
+        values2.push(item);
+      }
+      const allocation = this.arrays.get(target);
+      const sorted = this.retention.replace(allocation.bytes, size, () => values2.sort((left, right) => {
+        this.budget.step();
+        if (left.kind === "string" && right.kind !== "string") return 1;
+        if (right.kind === "string" && left.kind !== "string") return -1;
+        return compare(left, right, this.varText("CONVFMT"), this.budget);
+      }).map(ownScalar));
+      this.entries += sorted.length - target.entries.size;
+      target.entries.clear();
+      for (let index = 0; index < sorted.length; index++) target.entries.set(String(index + 1), sorted[index]);
+      allocation.bytes = size;
+      return numeric(sorted.length);
+    }
+    if (name === "sub" || name === "gsub") {
+      const pattern = await this.regex(args[0]);
+      const replacement = this.asText(await this.scalarExpression(args[1]));
+      const target = await this.reference(args[2] ?? { kind: "field", index: { kind: "number", value: 0 } });
+      const result2 = await substitute(this.asText(scalar(target.get())), pattern, replacement, this.budget, name === "gsub", 1, "awk");
+      if (result2.count) await target.set(string(result2.text));
+      return numeric(result2.count);
+    }
+    if (name === "split") {
+      const value = this.asText(await this.scalarExpression(args[0]));
+      const target = this.array(args[1].name);
+      const separator = args[2]?.kind === "regex" ? args[2].pattern : args[2] ? this.asText(await this.scalarExpression(args[2])) : this.varText("FS");
+      const parts = await this.split(value, separator);
+      if (this.entries - target.entries.size + parts.length > (this.budget.options.maxArrayEntries ?? Infinity)) throw new ProgramError("array entry limit exceeded");
+      let size = 0;
+      for (let index = 0; index < parts.length; index++) {
+        const part = parts[index];
+        if (part.kind === "string" || part.kind === "numeric") this.budget.check(part.text);
+        const key = String(index + 1);
+        this.budget.check(key);
+        size += key.length + textSize(part);
+      }
+      const allocation = this.arrays.get(target);
+      const entries = this.retention.replace(allocation.bytes, size, () => parts.map((part, index) => [String(index + 1), ownScalar(part)]));
+      this.entries += entries.length - target.entries.size;
+      target.entries.clear();
+      for (const [key, part] of entries) target.entries.set(key, part);
+      allocation.bytes = size;
+      return numeric(parts.length);
+    }
+    if (name === "match") {
+      const value = this.asText(await this.scalarExpression(args[0]));
+      const matched = await (await this.regex(args[1])).find(value, this.budget);
+      this.set("RSTART", numeric(matched ? matched.start + 1 : 0));
+      this.set("RLENGTH", numeric(matched ? matched.end - matched.start : -1));
+      return this.get("RSTART");
+    }
+    const values = [];
+    for (const argument of args) values.push(await this.scalarExpression(argument));
+    const first = values[0] ?? unset;
+    if (name === "systime") return numeric(Math.floor(Date.now() / 1e3));
+    if (name === "strftime" || name === "mktime") {
+      const utc = number(values[name === "strftime" ? 2 : 1] ?? unset) !== 0;
+      const zone = new TimeZone(utc ? "UTC" : this.context.env.TZ ?? "UTC");
+      if (name === "strftime") {
+        const timestamp = values[1] ? Math.trunc(number(values[1])) : Math.floor(Date.now() / 1e3);
+        if (!Number.isFinite(timestamp)) throw new ProgramError("invalid strftime timestamp");
+        const format = values.length ? this.asText(first) : "%a %b %e %H:%M:%S %Z %Y";
+        this.budget.step(format.length);
+        return string(this.budget.check(formatDate(format, BigInt(timestamp) * nanosecondsPerSecond, zone, {
+          maxArguments: Infinity,
+          maxArgumentBytes: Infinity,
+          maxEnvironmentEntries: Infinity,
+          maxOutputBytes: this.budget.maxBufferBytes + 1,
+          maxFormatWidth: this.budget.maxBufferBytes
+        }).slice(0, -1)));
+      }
+      const fields = this.asText(first).trim().split(/\s+/u);
+      if (fields.length < 6 || fields.length > 7 || fields.some((field) => !/^[+-]?\d+$/u.test(field))) return numeric(-1);
+      const parts = fields.map(Number);
+      const date = /* @__PURE__ */ new Date(0);
+      date.setUTCFullYear(parts[0], parts[1] - 1, parts[2]);
+      date.setUTCHours(parts[3], parts[4], parts[5], 0);
+      if (!Number.isFinite(date.getTime())) return numeric(-1);
+      try {
+        const wall = BigInt(date.getTime()) * 1000000n;
+        const offsets = [-183, -2, 0, 2, 183].map((days) => zone.fields(wall + BigInt(days * 86400) * nanosecondsPerSecond).offset);
+        const daylight = parts[6] ?? -1;
+        let offset = daylight > 0 ? Math.max(...offsets) : Math.min(...offsets);
+        if (daylight < 0) {
+          for (const candidate of [...new Set(offsets)].sort((a, b) => b - a)) {
+            const observed = zone.fields(wall - BigInt(candidate) * nanosecondsPerSecond);
+            if (observed.year === date.getUTCFullYear() && observed.month === date.getUTCMonth() + 1 && observed.day === date.getUTCDate() && observed.hour === date.getUTCHours() && observed.minute === date.getUTCMinutes() && observed.second === date.getUTCSeconds()) {
+              offset = candidate;
+              break;
+            }
+          }
+        }
+        return numeric(date.getTime() / 1e3 - offset);
+      } catch {
+        return numeric(-1);
+      }
+    }
+    if (["and", "or", "xor", "compl", "lshift", "rshift"].includes(name)) {
+      const operands = values.map((value) => {
+        const operand = number(value);
+        if (!Number.isFinite(operand) || operand < 0) throw new ProgramError(`invalid argument in '${name}'`);
+        return BigInt.asUintN(64, BigInt(Math.trunc(operand)));
+      });
+      let result2 = operands[0];
+      if (name === "compl") result2 = ~result2;
+      else if (name === "lshift" || name === "rshift") {
+        const shift = operands[1];
+        result2 = shift >= 64n ? 0n : name === "lshift" ? result2 << shift : result2 >> shift;
+      } else for (const operand of operands.slice(1)) result2 = name === "and" ? result2 & operand : name === "or" ? result2 | operand : result2 ^ operand;
+      result2 = BigInt.asUintN(64, result2);
+      for (let bit = 63n; BigInt(Number(result2)) !== result2; bit--) result2 &= ~(1n << bit);
+      return numeric(Number(result2));
+    }
+    if (name === "srand") {
+      const previous = this.randomSeed;
+      this.randomSeed = values.length ? Math.trunc(number(first)) : Math.floor(Date.now() / 1e3);
+      this.randomState = this.randomSeed >>> 0;
+      return numeric(previous);
+    }
+    if (name === "rand") {
+      this.randomState = Math.imul(this.randomState, 1664525) + 1013904223 >>> 0;
+      return numeric(this.randomState / 4294967296);
+    }
+    if (this.ordchr && name === "ord") return numeric(this.asText(first).charCodeAt(0) || 0);
+    if (this.ordchr && name === "chr") {
+      const value = number(first);
+      if (!Number.isFinite(value)) throw new ProgramError("invalid numeric argument in 'chr'");
+      return string(String.fromCharCode(Math.trunc(value) & 255));
+    }
+    if (name === "sprintf") return string(this.budget.check(formatted(this.asText(first), values.slice(1), (value) => this.asText(value), this.budget)));
+    if (name === "substr") {
+      const start = Math.max(0, Math.trunc(number(values[1])) - 1);
+      const length = values[2] === void 0 ? void 0 : Math.max(0, Math.trunc(number(values[2])));
+      return string(this.asText(first).slice(start, length === void 0 ? void 0 : start + length));
+    }
+    if (name === "index") return numeric(this.asText(first).indexOf(this.asText(values[1])) + 1);
+    if (name === "tolower") return string(this.asText(first).replace(/[A-Z]/gu, (character) => character.toLowerCase()));
+    if (name === "toupper") return string(this.asText(first).replace(/[a-z]/gu, (character) => character.toUpperCase()));
+    if (name === "close") {
+      const pipeStatus = await this.pipes?.close(textDecoder.decode(latin1Bytes(this.asText(first))));
+      if (pipeStatus !== void 0) return numeric(pipeStatus);
+      const path = virtualPath(this.context, textDecoder.decode(latin1Bytes(this.asText(first))));
+      const reader = this.inputs?.get(path);
+      this.inputs?.delete(path);
+      if (reader) this.retention.release(shellValueByteLength(path));
+      await reader?.close();
+      const output = this.outputs?.delete(path) ?? false;
+      if (output) this.retention.release(shellValueByteLength(path));
+      return numeric(output || reader !== void 0 ? 0 : -1);
+    }
+    const amount = number(first);
+    const result = name === "int" ? Math.trunc(amount) : name === "sqrt" ? Math.sqrt(amount) : name === "exp" ? Math.exp(amount) : name === "log" ? Math.log(amount) : name === "sin" ? Math.sin(amount) : name === "cos" ? Math.cos(amount) : name === "atan2" ? Math.atan2(amount, number(values[1])) : NaN;
+    if (!Number.isFinite(result)) throw new ProgramError(`invalid mathematical result in '${name}'`);
+    return numeric(result);
+  }
+  recordChecks = 0;
+  stdoutBuffer = "";
+  flushStdout() {
+    if (this.stdoutBuffer.length === 0) return void 0;
+    const chunk = this.stdoutBuffer;
+    this.stdoutBuffer = "";
+    const p = write(this.context, chunk);
+    return isSyncResolved(p) ? void 0 : p;
+  }
+  executeSync(statement) {
+    if (!this.inspection) {
+      const count = ++this.recordChecks;
+      const p = count <= 2 || (count & 31) === 0 ? this.budget.checkpointSync() : void 0;
+      if (!p) {
+        return this.executeSyncBody(statement);
+      } else return this.executeAfterCheckpoint(p, statement);
+    }
+    return this.execute(statement);
+  }
+  tryFastExpressionStatement(expr) {
+    if (this.frames.length !== 0) return false;
+    if (expr.kind === "unary" && (expr.operator === "++" || expr.operator === "--") && expr.operand.kind === "variable") {
+      const name = expr.operand.name;
+      if (name !== "NF" && name !== "NR" && name !== "FNR" && name !== "FS" && name !== "RS" && name !== "CONVFMT") {
+        this.budget.step();
+        const existing = this.variables.get(name);
+        if (existing === void 0 || !(existing instanceof AwkArray)) {
+          const prevNum = existing !== void 0 ? existing.kind === "number" ? existing.number : number(existing) : 0;
+          const rawNext = prevNum + (expr.operator === "++" ? 1 : -1);
+          const next = (rawNext | 0) === rawNext && (rawNext !== 0 || 1 / rawNext > 0) ? rawNext | 0 : rawNext;
+          this.retention.admit(textSize(existing), 0);
+          const box = numeric(next);
+          this.variables.set(name, box);
+          return true;
+        }
+      }
+      return false;
+    }
+    if (expr.kind === "binary" && (expr.operator === "+=" || expr.operator === "-=" || expr.operator === "*=" || expr.operator === "/=") && expr.left.kind === "variable") {
+      const name = expr.left.name;
+      if (name !== "NF" && name !== "NR" && name !== "FNR" && name !== "FS" && name !== "RS" && name !== "CONVFMT") {
+        const right = expr.right;
+        let rightNum;
+        if (right.kind === "field" && right.index.kind === "number") {
+          this.budget.step(3);
+          const idx = Math.trunc(right.index.value);
+          if (idx > 0 && idx <= (this.budget.options.maxFields ?? Infinity)) {
+            rightNum = this.getFieldNumber(idx);
+          }
+        } else if (right.kind === "number") {
+          this.budget.step(2);
+          rightNum = right.value;
+        }
+        if (rightNum !== void 0) {
+          const existing = this.variables.get(name);
+          if (existing === void 0 || !(existing instanceof AwkArray)) {
+            const prevNum = existing !== void 0 ? existing.kind === "number" ? existing.number : number(existing) : 0;
+            const rawNext = expr.operator === "+=" && Number.isFinite(prevNum) && Number.isFinite(rightNum) ? prevNum + rightNum : this.arithmetic(expr.operator[0], prevNum, rightNum);
+            const next = (rawNext | 0) === rawNext && (rawNext !== 0 || 1 / rawNext > 0) ? rawNext | 0 : rawNext;
+            this.retention.admit(textSize(existing), 0);
+            const box = numeric(next);
+            this.variables.set(name, box);
+            return true;
+          }
+        }
+      }
+    }
+    return false;
+  }
+  executeSyncBody(statement) {
+    if (statement.kind === "expression") {
+      this.budget.step();
+      if (!this.inspection && this.tryFastExpressionStatement(statement.expression)) return void 0;
+      const val = this.evaluate(statement.expression);
+      return val instanceof Promise ? this.ignorePromiseValue(val) : void 0;
+    }
+    if (statement.kind === "block") {
+      this.budget.step();
+      for (let i = 0; i < statement.body.length; i++) {
+        const child = statement.body[i];
+        let res;
+        if (child.kind === "expression" && !this.inspection) {
+          this.budget.step();
+          if (this.tryFastExpressionStatement(child.expression)) continue;
+          const val = this.evaluate(child.expression);
+          res = val instanceof Promise ? this.ignorePromiseValue(val) : void 0;
+        } else {
+          res = this.executeSync(child);
+        }
+        if (res instanceof Promise) {
+          return this.executeBlockRemainder(statement.body, i + 1, res);
+        }
+      }
+      return void 0;
+    }
+    if (statement.kind === "if") {
+      this.budget.step();
+      const cond = this.scalarExpression(statement.condition);
+      if (!(cond instanceof Promise)) {
+        const branch = truth(cond) ? statement.yes : statement.no;
+        return branch ? this.executeSync(branch) : void 0;
+      }
+      return this.executeIfAsync(statement, cond);
+    }
+    if (statement.kind === "print" && !statement.redirect && !statement.formatted) {
+      this.budget.step();
+      const args = statement.args;
+      const ofs = args.length ? this.varText("OFS") : "";
+      const ors = this.varText("ORS");
+      if (args.length === 0) {
+        const output2 = this.budget.check(this.record + ors);
+        this.stdoutBuffer += output2;
+        if (this.stdoutBuffer.length >= 16384) return this.flushStdout();
+        return void 0;
+      }
+      const ofmt = this.varText("OFMT");
+      let acc = "";
+      for (let i = 0; i < args.length; i++) {
+        const v = this.scalarExpression(args[i]);
+        if (v instanceof Promise) return this.executePrintRemainder(args, i, v, acc, ofs, ors, ofmt);
+        const t = text(v, ofmt, this.budget);
+        acc = i === 0 ? t : acc + ofs + t;
+      }
+      const output = this.budget.check(acc + ors);
+      this.stdoutBuffer += output;
+      if (this.stdoutBuffer.length >= 16384) return this.flushStdout();
+      return void 0;
+    }
+    return this.execute(statement);
+  }
+  async executePrintRemainder(args, index, pending, acc, ofs, ors, ofmt) {
+    const first = text(await pending, ofmt, this.budget);
+    acc = index === 0 ? first : acc + ofs + first;
+    for (let i = index + 1; i < args.length; i++) {
+      acc += ofs + text(await this.scalarExpression(args[i]), ofmt, this.budget);
+    }
+    this.stdoutBuffer += this.budget.check(acc + ors);
+    if (this.stdoutBuffer.length >= 16384) await this.flushStdout();
+  }
+  async ignorePromiseValue(promise) {
+    await promise;
+  }
+  async executeIfAsync(statement, condPromise) {
+    const resolved = await condPromise;
+    const branch = truth(resolved) ? statement.yes : statement.no;
+    if (branch) {
+      const res = this.executeSync(branch);
+      if (res instanceof Promise) await res;
+    }
+  }
+  async executeAfterCheckpoint(checkpoint, statement) {
+    await checkpoint;
+    const res = this.executeSyncBody(statement);
+    if (res instanceof Promise) await res;
+  }
+  async executeBlockRemainder(body, startIndex, current) {
+    await current;
+    for (let i = startIndex; i < body.length; i++) {
+      const res = this.executeSync(body[i]);
+      if (res instanceof Promise) await res;
+    }
+  }
+  async execute(statement) {
+    this.budget.step();
+    if (this.inspection) await this.inspection.observe(statement, this.phase);
+    const p = this.budget.checkpointSync();
+    if (p) await p;
+    switch (statement.kind) {
+      case "block":
+        for (const child of statement.body) await this.execute(child);
+        return;
+      case "expression":
+        await this.evaluate(statement.expression);
+        return;
+      case "print": {
+        const values = [];
+        for (const argument of statement.args) values.push(await this.scalarExpression(argument));
+        const output = statement.formatted ? this.budget.check(formatted(this.asText(values[0]), values.slice(1), (value) => this.asText(value), this.budget)) : this.join(values.length ? values.map((value) => text(value, this.varText("OFMT"), this.budget)) : [this.record], values.length ? this.varText("OFS") : "", this.varText("ORS"));
+        if (!statement.redirect) {
+          this.stdoutBuffer += output;
+          if (this.stdoutBuffer.length >= 16384) await this.flushStdout();
+          return;
+        }
+        const destination = textDecoder.decode(latin1Bytes(this.asText(await this.scalarExpression(statement.redirect.destination))));
+        if (statement.redirect.pipe) {
+          if (this.stdoutBuffer.length > 0) await this.flushStdout();
+          await (this.pipes ??= new AwkPipes(this.context, this.budget, this.retention)).write(destination, output);
+          return;
+        }
+        if (destination === "/dev/stdout") {
+          this.stdoutBuffer += output;
+          if (this.stdoutBuffer.length >= 16384) await this.flushStdout();
+          return;
+        }
+        if (this.stdoutBuffer.length > 0) await this.flushStdout();
+        if (destination === "/dev/stderr") {
+          this.context.signal.throwIfAborted();
+          await writeBytes(this.context.stderr, bytes(output), this.context.signal);
+          return;
+        }
+        const path = virtualPath(this.context, destination);
+        const outputs = this.outputs ??= /* @__PURE__ */ new Set();
+        if (outputs.has(path)) await writeFileOutput(this.context, bytes(output), (chunk) => this.context.fs.appendFile(path, chunk, { signal: this.context.signal }));
+        else {
+          const name = this.retainName(path);
+          try {
+            const flag = statement.redirect.append ? "a" : "w";
+            await writeFileOutput(this.context, bytes(output), (chunk) => this.context.fs.writeFile(name, chunk, { flag, signal: this.context.signal }));
+            this.context.signal.throwIfAborted();
+            outputs.add(name);
+          } catch (error) {
+            this.retention.release(shellValueByteLength(name));
+            throw error;
+          }
+        }
+        return;
+      }
+      case "if": {
+        const branch = truth(await this.scalarExpression(statement.condition)) ? statement.yes : statement.no;
+        if (branch) await this.execute(branch);
+        return;
+      }
+      case "flow": {
+        if ((statement.flow === "next" || statement.flow === "nextfile") && this.phase !== "record") throw new ProgramError(`${statement.flow} is only valid while processing records`);
+        throw new Flow(statement.flow, statement.value ? await this.scalarExpression(statement.value) : unset);
+      }
+      case "delete": {
+        const array = this.array(statement.target.name);
+        const allocation = this.arrays.get(array);
+        if (statement.target.kind === "variable") {
+          this.retention.release(allocation.bytes);
+          allocation.bytes = 0;
+          this.entries -= array.entries.size;
+          array.entries.clear();
+        } else {
+          const key = await this.key(statement.target.indexes);
+          const value = array.entries.get(key);
+          if (array.entries.delete(key)) {
+            const size = key.length + textSize(value);
+            this.retention.release(size);
+            allocation.bytes -= size;
+            this.entries--;
+          }
+        }
+        return;
+      }
+      case "foreach": {
+        const array = this.array(statement.array);
+        for (const key of [...array.entries.keys()]) {
+          this.budget.step();
+          if (!array.entries.has(key)) continue;
+          this.set(statement.variable, string(key));
+          try {
+            const res = this.executeSync(statement.body);
+            if (res instanceof Promise) await res;
+          } catch (error) {
+            if (error instanceof Flow && error.kind === "break") break;
+            if (!(error instanceof Flow && error.kind === "continue")) throw error;
+          }
+        }
+        return;
+      }
+      case "while":
+      case "do":
+      case "for": {
+        if (statement.kind === "for" && statement.initial) {
+          const initial = this.evaluate(statement.initial);
+          if (initial instanceof Promise) await initial;
+        }
+        let first = true;
+        while (true) {
+          this.budget.step();
+          if (!(statement.kind === "do" && first) && statement.condition) {
+            const condition = this.scalarExpression(statement.condition);
+            if (!truth(condition instanceof Promise ? await condition : condition)) break;
+          }
+          first = false;
+          try {
+            const body = this.executeSync(statement.body);
+            if (body instanceof Promise) await body;
+          } catch (error) {
+            if (error instanceof Flow && error.kind === "break") break;
+            if (!(error instanceof Flow && error.kind === "continue")) throw error;
+          }
+          if (statement.kind === "for" && statement.update) {
+            const update = this.evaluate(statement.update);
+            if (update instanceof Promise) await update;
+          }
+        }
+        return;
+      }
+    }
+  }
+  assignment(assignment) {
+    const match = /^([A-Za-z_][A-Za-z0-9_]*)=([\s\S]*)$/u.exec(assignment);
+    if (!match) throw new ProgramError(`invalid assignment '${assignment}'`);
+    this.set(match[1], inputValue(decodeString(match[2])));
+  }
+  exit(flow) {
+    if (flow.value.kind !== "unset") {
+      const status = Math.trunc(number(flow.value));
+      if (!Number.isFinite(status)) throw new ProgramError("invalid exit status");
+      this.status = (status % 256 + 256) % 256;
+    }
+  }
+  finishSyncCleanup(status) {
+    this.releaseStore(this.variables);
+    this.retention.release(this.recordLength + this.fieldBytes);
+    this.record = "";
+    if (this.rawFields.length > 0) this.rawFields.length = 0;
+    this.fieldCount = 0;
+    this.fieldsMaterialized = true;
+    this.fieldBytes = 0;
+    this.sliceBox.source = "";
+    this.recordValue = unset;
+    this.context.signal.throwIfAborted();
+    this.context = RELEASED_AWK_CONTEXT;
+    this.budget.context = RELEASED_AWK_CONTEXT;
+    this.budget.signal = RELEASED_AWK_SIGNAL;
+    this.retention.signal = RELEASED_AWK_SIGNAL;
+    return status;
+  }
+  runSyncOrAsync() {
+    if (!this.inspection && this.program.begin.length === 0) {
+      try {
+        const progRes = this.tryRunProgramSync();
+        if (typeof progRes === "number") {
+          if (!this.inputs || this.inputs.size === 0) {
+            if (!this.outputs || this.outputs.size === 0) {
+              if (this.mainReader) {
+                const pendingClose = this.mainReader.closeSyncOrAsync();
+                this.mainReader = void 0;
+                if (pendingClose) {
+                  return this.finishRunAfterSyncProgram(progRes, pendingClose);
+                }
+              }
+              if (this.stdoutBuffer.length > 0) {
+                const flushPending = this.flushStdout();
+                if (flushPending) {
+                  return this.finishRunAfterFlush(progRes, flushPending);
+                }
+              }
+              if (this.inspection) this.syncSpecialVars();
+              else {
+                this.nrDirty = false;
+                this.fnrDirty = false;
+                this.nfDirty = false;
+              }
+              return this.finishSyncCleanup(progRes);
+            }
+          }
+          return this.finishRunAfterSyncProgram(progRes, void 0);
+        }
+        return this.finishRunFromPromise(progRes);
+      } catch (error) {
+        return this.finishRunFromPromise(Promise.reject(error));
+      }
+    }
+    return this.run();
+  }
+  async finishRunAfterFlush(status, flushPending) {
+    let failed = false;
+    let failure;
+    try {
+      await flushPending;
+      this.syncSpecialVars();
+    } catch (error) {
+      failed = true;
+      failure = error;
+    }
+    const res = this.finishSyncCleanup(status);
+    if (failed) throw failure;
+    return res;
+  }
+  async finishRunAfterSyncProgram(status, pendingClose) {
+    return this.finishRunFromPromise(
+      pendingClose ? pendingClose.then(() => status) : Promise.resolve(status)
+    );
+  }
+  async finishRunFromPromise(programPromise) {
+    let status = 0, failed = false;
+    let failure;
+    try {
+      status = await programPromise;
+      if (this.stdoutBuffer.length > 0) await this.flushStdout();
+      this.syncSpecialVars();
+      await this.inspection?.publish(this.variables);
+    } catch (error) {
+      failed = true;
+      failure = error;
+    }
+    try {
+      await this.pipes?.closeAll(failed);
+    } catch (error) {
+      if (!failed) {
+        failed = true;
+        failure = error;
+      }
+    }
+    if (this.stdoutBuffer.length > 0) {
+      try {
+        await this.flushStdout();
+      } catch (error) {
+        if (!failed) {
+          failed = true;
+          failure = error;
+        }
+      }
+    }
+    let cleanup;
+    if (this.mainReader && (!this.inputs || this.inputs.size === 0)) {
+      const pendingClose = this.mainReader.closeSyncOrAsync();
+      this.mainReader = void 0;
+      if (pendingClose) {
+        try {
+          await pendingClose;
+        } catch (error) {
+          if (!failed) {
+            failed = true;
+            failure = error;
+          }
+        }
+      }
+    } else if (this.mainReader || this.inputs && this.inputs.size > 0) {
+      const readers = [...this.mainReader ? [this.mainReader] : [], ...this.inputs ? this.inputs.values() : []];
+      this.mainReader = void 0;
+      if (this.inputs) {
+        for (const name of this.inputs.keys()) this.retention.release(shellValueByteLength(name));
+        this.inputs.clear();
+      }
+      cleanup = await Promise.allSettled(readers.map(async (reader) => {
+        await reader.close();
+      }));
+    }
+    if (this.outputs && this.outputs.size > 0) {
+      for (const name of this.outputs) this.retention.release(shellValueByteLength(name));
+      this.outputs.clear();
+    }
+    const res = this.finishSyncCleanup(status);
+    if (failed) throw failure;
+    if (cleanup) {
+      for (const result of cleanup) if (result.status === "rejected") throw result.reason;
+    }
+    return res;
+  }
+  async run() {
+    return this.finishRunFromPromise(this.runProgram());
+  }
+  tryRunProgramSync() {
+    this.phase = "record";
+    let ranges;
+    if (this.program.rules.length || this.program.end.length) {
+      if (!this.mainReader) {
+        this.tryOpenNextMainReaderSync();
+      }
+      while (true) {
+        this.budget.step();
+        if (this.mainReader && this.mainReader.readSliceSync(this.varText("RS"), this.sliceBox)) {
+          this.incrementCounter("NR");
+          this.incrementCounter("FNR");
+          const setRecPromise = this.setRecordSliceSync(this.sliceBox.source, this.sliceBox.start, this.sliceBox.end);
+          if (setRecPromise instanceof Promise) {
+            return this.continueProgramAsyncAfterRecord(setRecPromise, ranges, 0);
+          }
+        } else if (this.mainReader && this.mainReader.isEnded && this.argument >= number(this.getScalar("ARGC"))) {
+          const closePending = this.mainReader.closeSyncOrAsync();
+          this.mainReader = void 0;
+          if (closePending) {
+            return closePending.then(() => this.runEndPhaseSyncOrAsync(0));
+          }
+          break;
+        } else {
+          return this.continueProgramSlowAsync(ranges);
+        }
+        try {
+          for (let index = 0; index < this.program.rules.length; index++) {
+            const rule = this.program.rules[index];
+            let selected = !rule.pattern || ranges !== void 0 && ranges.has(index);
+            if (!selected) {
+              const patVal = this.scalarExpression(rule.pattern);
+              if (patVal instanceof Promise) {
+                return this.continueProgramAsyncAtRule(patVal, ranges, index, "pattern");
+              }
+              selected = truth(patVal);
+            }
+            if (!selected) continue;
+            if (rule.end) {
+              const endVal = this.scalarExpression(rule.end);
+              if (endVal instanceof Promise) {
+                return this.continueProgramAsyncAtRule(endVal, ranges, index, "end");
+              }
+              if (truth(endVal)) ranges?.delete(index);
+              else (ranges ??= /* @__PURE__ */ new Set()).add(index);
+            }
+            const execRes = this.executeSync(rule.action);
+            if (execRes instanceof Promise) {
+              return this.continueProgramAsyncAtRule(execRes, ranges, index, "action");
+            }
+          }
+        } catch (error) {
+          if (!(error instanceof Flow)) throw error;
+          if (error.kind === "exit") {
+            this.exit(error);
+            break;
+          }
+          if (error.kind === "nextfile") {
+            const closePending = this.mainReader?.closeSyncOrAsync();
+            this.mainReader = void 0;
+            if (closePending) return closePending.then(() => this.continueProgramSlowAsync(ranges));
+          } else if (error.kind !== "next") throw error;
+        }
+      }
+    }
+    if (this.mainReader && !hasMainGetline(this.program.end) && ![...this.program.functions.values()].some(hasMainGetline)) {
+      void this.mainReader.close().catch(() => void 0);
+    }
+    return this.runEndPhaseSyncOrAsync(0);
+  }
+  runEndPhaseSyncOrAsync(startIdx) {
+    this.phase = "END";
+    try {
+      for (let i = startIdx; i < this.program.end.length; i++) {
+        const endRes = this.executeSync(this.program.end[i]);
+        if (endRes instanceof Promise) {
+          return this.continueEndPhaseAsync(endRes, i + 1);
+        }
+      }
+    } catch (error) {
+      if (error instanceof Flow && error.kind === "exit") this.exit(error);
+      else throw error;
+    }
+    return this.status;
+  }
+  async continueEndPhaseAsync(pending, nextIdx) {
+    try {
+      await pending;
+      for (let i = nextIdx; i < this.program.end.length; i++) {
+        await this.execute(this.program.end[i]);
+      }
+    } catch (error) {
+      if (error instanceof Flow && error.kind === "exit") this.exit(error);
+      else throw error;
+    }
+    return this.status;
+  }
+  async continueProgramAsyncAfterRecord(pending, ranges, startRule) {
+    await pending;
+    return this.continueProgramAsyncRulesAndLoop(ranges, startRule);
+  }
+  async continueProgramAsyncAtRule(pending, ranges, ruleIdx, step) {
+    const rule = this.program.rules[ruleIdx];
+    try {
+      if (step === "pattern") {
+        if (truth(await pending)) {
+          if (rule.end) {
+            const endVal = this.scalarExpression(rule.end);
+            if (truth(endVal instanceof Promise ? await endVal : endVal)) ranges?.delete(ruleIdx);
+            else (ranges ??= /* @__PURE__ */ new Set()).add(ruleIdx);
+          }
+          const execRes = this.executeSync(rule.action);
+          if (execRes instanceof Promise) await execRes;
+        }
+      } else if (step === "end") {
+        if (truth(await pending)) ranges?.delete(ruleIdx);
+        else (ranges ??= /* @__PURE__ */ new Set()).add(ruleIdx);
+        const execRes = this.executeSync(rule.action);
+        if (execRes instanceof Promise) await execRes;
+      } else {
+        await pending;
+      }
+    } catch (error) {
+      if (!(error instanceof Flow)) throw error;
+      if (error.kind === "exit") {
+        this.exit(error);
+        return this.runEndPhaseSyncOrAsync(0);
+      }
+      if (error.kind === "nextfile") {
+        await this.mainReader?.close();
+        this.mainReader = void 0;
+        return this.continueProgramSlowAsync(ranges);
+      }
+      if (error.kind !== "next") throw error;
+      return this.continueProgramSlowAsync(ranges);
+    }
+    return this.continueProgramAsyncRulesAndLoop(ranges, ruleIdx + 1);
+  }
+  async continueProgramAsyncRulesAndLoop(ranges, startRule) {
+    try {
+      for (let index = startRule; index < this.program.rules.length; index++) {
+        const rule = this.program.rules[index];
+        let selected = !rule.pattern || ranges !== void 0 && ranges.has(index);
+        if (!selected) {
+          const patVal = this.scalarExpression(rule.pattern);
+          selected = truth(patVal instanceof Promise ? await patVal : patVal);
+        }
+        if (!selected) continue;
+        if (rule.end) {
+          const endVal = this.scalarExpression(rule.end);
+          if (truth(endVal instanceof Promise ? await endVal : endVal)) ranges?.delete(index);
+          else (ranges ??= /* @__PURE__ */ new Set()).add(index);
+        }
+        const execRes = this.executeSync(rule.action);
+        if (execRes instanceof Promise) await execRes;
+      }
+    } catch (error) {
+      if (!(error instanceof Flow)) throw error;
+      if (error.kind === "exit") {
+        this.exit(error);
+        return this.runEndPhaseSyncOrAsync(0);
+      }
+      if (error.kind === "nextfile") {
+        await this.mainReader?.close();
+        this.mainReader = void 0;
+      } else if (error.kind !== "next") throw error;
+    }
+    return this.continueProgramSlowAsync(ranges);
+  }
+  async continueProgramSlowAsync(ranges) {
+    while (true) {
+      this.budget.step();
+      if (this.mainReader && this.mainReader.readSliceSync(this.varText("RS"), this.sliceBox)) {
+        this.incrementCounter("NR");
+        this.incrementCounter("FNR");
+        const setRecPromise = this.setRecordSliceSync(this.sliceBox.source, this.sliceBox.start, this.sliceBox.end);
+        if (setRecPromise instanceof Promise) await setRecPromise;
+      } else if (this.mainReader && this.mainReader.isEnded && this.argument >= number(this.getScalar("ARGC"))) {
+        void this.mainReader.close();
+        this.mainReader = void 0;
+        break;
+      } else {
+        const recOrPromise = this.readMainRecordSync();
+        const record = recOrPromise instanceof Promise ? await recOrPromise : recOrPromise;
+        if (record === void 0) break;
+        const setRecPromise = this.setRecordSync(record);
+        if (setRecPromise instanceof Promise) await setRecPromise;
+      }
+      try {
+        for (let index = 0; index < this.program.rules.length; index++) {
+          const rule = this.program.rules[index];
+          let selected = !rule.pattern || ranges !== void 0 && ranges.has(index);
+          if (!selected) {
+            const patVal = this.scalarExpression(rule.pattern);
+            selected = truth(patVal instanceof Promise ? await patVal : patVal);
+          }
+          if (!selected) continue;
+          if (rule.end) {
+            const endVal = this.scalarExpression(rule.end);
+            if (truth(endVal instanceof Promise ? await endVal : endVal)) ranges?.delete(index);
+            else (ranges ??= /* @__PURE__ */ new Set()).add(index);
+          }
+          const execRes = this.executeSync(rule.action);
+          if (execRes instanceof Promise) await execRes;
+        }
+      } catch (error) {
+        if (!(error instanceof Flow)) throw error;
+        if (error.kind === "exit") {
+          this.exit(error);
+          break;
+        }
+        if (error.kind === "nextfile") {
+          await this.mainReader?.close();
+          this.mainReader = void 0;
+        } else if (error.kind !== "next") throw error;
+      }
+    }
+    if (this.mainReader && !hasMainGetline(this.program.end) && ![...this.program.functions.values()].some(hasMainGetline)) {
+      void this.mainReader.close().catch(() => void 0);
+    }
+    return this.runEndPhaseSyncOrAsync(0);
+  }
+  async _unusedOldRun() {
+    let status = 0, failed = false;
+    let failure;
+    try {
+      status = await this.runProgram();
+      if (this.stdoutBuffer.length > 0) await this.flushStdout();
+      this.syncSpecialVars();
+      await this.inspection?.publish(this.variables);
+    } catch (error) {
+      failed = true;
+      failure = error;
+    }
+    if (this.stdoutBuffer.length > 0) {
+      try {
+        await this.flushStdout();
+      } catch (error) {
+        if (!failed) {
+          failed = true;
+          failure = error;
+        }
+      }
+    }
+    let cleanup;
+    if (this.mainReader && (!this.inputs || this.inputs.size === 0)) {
+      const pendingClose = this.mainReader.closeSyncOrAsync();
+      this.mainReader = void 0;
+      if (pendingClose) {
+        try {
+          await pendingClose;
+        } catch (error) {
+          if (!failed) {
+            failed = true;
+            failure = error;
+          }
+        }
+      }
+    } else if (this.mainReader || this.inputs && this.inputs.size > 0) {
+      const readers = [...this.mainReader ? [this.mainReader] : [], ...this.inputs ? this.inputs.values() : []];
+      this.mainReader = void 0;
+      if (this.inputs) {
+        for (const name of this.inputs.keys()) this.retention.release(shellValueByteLength(name));
+        this.inputs.clear();
+      }
+      cleanup = await Promise.allSettled(readers.map(async (reader) => {
+        await reader.close();
+      }));
+    }
+    if (this.outputs && this.outputs.size > 0) {
+      for (const name of this.outputs) this.retention.release(shellValueByteLength(name));
+      this.outputs.clear();
+    }
+    this.releaseStore(this.variables);
+    this.retention.release(this.recordLength + this.fieldBytes);
+    this.record = "";
+    this.fields = [];
+    this.fieldCount = 0;
+    this.fieldsMaterialized = true;
+    this.fieldBytes = 0;
+    this.sliceBox.source = "";
+    this.recordValue = unset;
+    this.context.signal.throwIfAborted();
+    this.context = RELEASED_AWK_CONTEXT;
+    this.budget.context = RELEASED_AWK_CONTEXT;
+    this.budget.signal = RELEASED_AWK_SIGNAL;
+    if (failed) throw failure;
+    if (cleanup) {
+      for (const result of cleanup) if (result.status === "rejected") throw result.reason;
+    }
+    return status;
+  }
+  async readMainRecord() {
+    const syncRes = this.readMainRecordSync();
+    return syncRes instanceof Promise ? await syncRes : syncRes;
+  }
+  incrementCounter(name) {
+    if (this.frames.length === 0 || !this.frames.at(-1).has(name)) {
+      const nrVal = name === "NR" && !this.nrDirty ? this.variables.get("NR") : void 0;
+      if (nrVal && !("entries" in nrVal) && nrVal.kind === "number") {
+        this.nrNum++;
+        this.nrDirty = true;
+        return;
+      }
+      if (name === "NR" && this.nrDirty) {
+        this.nrNum++;
+        return;
+      }
+      const fnrVal = name === "FNR" && !this.fnrDirty ? this.variables.get("FNR") : void 0;
+      if (fnrVal && !("entries" in fnrVal) && fnrVal.kind === "number") {
+        this.fnrNum++;
+        this.fnrDirty = true;
+        return;
+      }
+      if (name === "FNR" && this.fnrDirty) {
+        this.fnrNum++;
+        return;
+      }
+    }
+    this.set(name, numeric(number(this.getScalar(name)) + 1));
+  }
+  readMainRecordSync() {
+    if (this.mainReader) {
+      this.budget.step();
+      const record = this.mainReader.readSync(this.varText("RS"));
+      if (typeof record === "string") {
+        this.incrementCounter("NR");
+        this.incrementCounter("FNR");
+        return record;
+      }
+      if (record instanceof Promise) {
+        return this.readMainRecordAfterPromise(record);
+      }
+      return this.readMainRecordSlowAfterEof();
+    }
+    return this.readMainRecordSlow();
+  }
+  async readMainRecordAfterPromise(recordPromise) {
+    const resolved = await recordPromise;
+    if (resolved !== void 0) {
+      this.incrementCounter("NR");
+      this.incrementCounter("FNR");
+      return resolved;
+    }
+    return this.readMainRecordSlowAfterEof();
+  }
+  async readMainRecordSlowAfterEof() {
+    await this.mainReader?.close();
+    this.mainReader = void 0;
+    return this.readMainRecordSlow();
+  }
+  async readMainRecordSlow() {
+    while (true) {
+      this.budget.step();
+      if (!this.mainReader) {
+        let file;
+        while (this.argument < number(this.getScalar("ARGC"))) {
+          this.budget.step();
+          const argumentOptions = this.budget.options;
+          if (this.argument > (argumentOptions?.maxArguments ?? Infinity)) throw new ProgramError("argument count limit exceeded");
+          const p = this.budget.checkpointSync();
+          if (p) await p;
+          const next = this.asText(this.array("ARGV").entries.get(String(this.argument++)) ?? unset);
+          if (!next) continue;
+          if (this.operandAssignments && /^[A-Za-z_][A-Za-z0-9_]*=/u.test(next)) {
+            this.assignment(next);
+            continue;
+          }
+          file = next;
+          this.sawFile = true;
+          break;
+        }
+        if (file === void 0 && !this.sawFile && !this.defaultUsed) {
+          file = "-";
+          this.defaultUsed = true;
+        }
+        if (file === void 0) return void 0;
+        this.set("FILENAME", string(file));
+        this.set("FNR", numeric(0));
+        this.mainReader = new Reader(input(this.context, decodeBytes(encodeBytes(file, "latin1"), "utf8")), this.budget, this.retention);
+      }
+      const record = await this.mainReader.read(this.varText("RS"));
+      if (record === void 0) {
+        await this.mainReader.close();
+        this.mainReader = void 0;
+        continue;
+      }
+      this.incrementCounter("NR");
+      this.incrementCounter("FNR");
+      return record;
+    }
+  }
+  tryOpenNextMainReaderSync() {
+    const argc = number(this.getScalar("ARGC"));
+    const argumentOptions = this.budget.options;
+    const maxArgs = argumentOptions?.maxArguments ?? Infinity;
+    while (this.argument < argc) {
+      this.budget.step();
+      if (this.argument > maxArgs) throw new ProgramError("argument count limit exceeded");
+      {
+        const cp = this.budget.checkpointSync();
+        if (cp) {
+          cp.catch(() => {
+          });
+          return false;
+        }
+      }
+      const argIdx = this.argument++;
+      const argKey = argIdx < SMALL_ARG_KEYS.length ? SMALL_ARG_KEYS[argIdx] : String(argIdx);
+      const next = this.asText(this.array("ARGV").entries.get(argKey) ?? unset);
+      if (!next) continue;
+      if (this.operandAssignments && isOperandAssignment(next)) {
+        this.assignment(next);
+        continue;
+      }
+      this.sawFile = true;
+      this.set("FILENAME", string(next));
+      if (this.fnrNum !== 0 || this.fnrDirty || this.variables.get("FNR") !== SCALAR_ZERO) {
+        this.set("FNR", SCALAR_ZERO);
+      }
+      const utf8File = isAsciiText(next) ? next : decodeBytes(encodeBytes(next, "latin1"), "utf8");
+      if (utf8File !== "-") {
+        const fastMem = this.context._fastMemoryBackingFs;
+        if (fastMem && fastMem.capabilitiesFor === void 0 && !Object.prototype.hasOwnProperty.call(fastMem, "readStream") && !Object.prototype.hasOwnProperty.call(fastMem, "readFile")) {
+          const resolvedPath = virtualPath(this.context, utf8File);
+          if (resolvedPath !== "/dev" && !resolvedPath.startsWith("/dev/")) {
+            let rawView;
+            try {
+              rawView = tryReadMemoryFileViewSync(fastMem, resolvedPath, void 0, this.context.signal, true);
+            } catch {
+              rawView = void 0;
+            }
+            if (rawView !== void 0 && rawView.byteLength <= this.budget.maxBufferBytes) {
+              this.context.inputBudget?.check(rawView.byteLength);
+              this.context._chargeFastFsOp?.();
+              this.mainReader = Reader.fromMemoryView(rawView, this.budget, this.retention);
+              return true;
+            }
+          }
+        }
+      }
+      this.mainReader = new Reader(input(this.context, utf8File), this.budget, this.retention);
+      return true;
+    }
+    if (!this.sawFile && !this.defaultUsed) {
+      this.defaultUsed = true;
+      this.set("FILENAME", string("-"));
+      this.set("FNR", numeric(0));
+      this.mainReader = new Reader(input(this.context, "-"), this.budget, this.retention);
+      return true;
+    }
+    return false;
+  }
+  async runProgram() {
+    let stopped = false;
+    try {
+      for (const statement of this.program.begin) await this.execute(statement);
+    } catch (error) {
+      if (error instanceof Flow && error.kind === "exit") {
+        this.exit(error);
+        stopped = true;
+      } else throw error;
+    }
+    this.phase = "record";
+    let ranges;
+    if (!stopped && (this.program.rules.length || this.program.end.length)) {
+      if (!this.mainReader) {
+        this.tryOpenNextMainReaderSync();
+      }
+      while (true) {
+        this.budget.step();
+        if (this.mainReader && this.mainReader.readSliceSync(this.varText("RS"), this.sliceBox)) {
+          this.incrementCounter("NR");
+          this.incrementCounter("FNR");
+          const setRecPromise = this.setRecordSliceSync(this.sliceBox.source, this.sliceBox.start, this.sliceBox.end);
+          if (setRecPromise instanceof Promise) await setRecPromise;
+        } else if (this.mainReader && this.mainReader.isEnded && this.argument >= number(this.getScalar("ARGC"))) {
+          void this.mainReader.close();
+          this.mainReader = void 0;
+          break;
+        } else {
+          const recOrPromise = this.readMainRecordSync();
+          const record = recOrPromise instanceof Promise ? await recOrPromise : recOrPromise;
+          if (record === void 0) break;
+          const setRecPromise = this.setRecordSync(record);
+          if (setRecPromise instanceof Promise) await setRecPromise;
+        }
+        try {
+          for (let index = 0; index < this.program.rules.length; index++) {
+            const rule = this.program.rules[index];
+            let selected = !rule.pattern || ranges !== void 0 && ranges.has(index);
+            if (!selected) {
+              const patVal = this.scalarExpression(rule.pattern);
+              selected = truth(patVal instanceof Promise ? await patVal : patVal);
+            }
+            if (!selected) continue;
+            if (rule.end) {
+              const endVal = this.scalarExpression(rule.end);
+              if (truth(endVal instanceof Promise ? await endVal : endVal)) ranges?.delete(index);
+              else (ranges ??= /* @__PURE__ */ new Set()).add(index);
+            }
+            const execRes = this.executeSync(rule.action);
+            if (execRes instanceof Promise) await execRes;
+          }
+        } catch (error) {
+          if (!(error instanceof Flow)) throw error;
+          if (error.kind === "exit") {
+            this.exit(error);
+            break;
+          }
+          if (error.kind === "nextfile") {
+            await this.mainReader?.close();
+            this.mainReader = void 0;
+          } else if (error.kind !== "next") throw error;
+        }
+      }
+    }
+    if (this.mainReader && !hasMainGetline(this.program.end) && ![...this.program.functions.values()].some(hasMainGetline)) {
+      void this.mainReader.close().catch(() => void 0);
+    }
+    this.phase = "END";
+    try {
+      for (const statement of this.program.end) await this.execute(statement);
+    } catch (error) {
+      if (error instanceof Flow && error.kind === "exit") this.exit(error);
+      else throw error;
+    }
+    return this.status;
+  }
+};
+
+export {
+  AwkRuntime
+};