@poe-platform/safe-bash 0.1.798 → 0.1.800

package/dist/safe-bash-command-yq/index.js

@@ -1,735 +1,3432 @@
-import {
-  encodeJson,
-  encodeRaw,
-  encodeYaml
-} from "../safe-bash/command-chunks/chunk-6XMBTEUK.js";
-import {
-  parseYamlDocuments
-} from "../safe-bash/command-chunks/chunk-LHIOAFWW.js";
 import {
   parseTomlDocument
 } from "../safe-bash/command-chunks/chunk-L22T3H7L.js";
 import {
-  YqLedger,
-  resolveYqLimits,
-  yqCaps
+  YqLedger
 } from "../safe-bash/command-chunks/chunk-EMPU65ZK.js";
-import {
-  YqError,
-  fromJqLimit
-} from "../safe-bash/command-chunks/chunk-DW2F3N6R.js";
+import "../safe-bash/command-chunks/chunk-DW2F3N6R.js";
 import {
   init_buffer
 } from "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
 
 // packages/safe-bash-command-yq/src/index.ts
 init_buffer();
-import { utf8ByteLength, utf8Encoder } from "../safe-bash-query-engine/bytes.js";
-import { escapeText } from "../safe-bash-query-engine/escaping.js";
-import { pathOf } from "../safe-bash-query-engine/path.js";
-import {
-  commandRuntimeIdentity,
-  createOutputOperation,
-  FsError,
-  getCommandArguments,
-  readBytes
-} from "../safe-bash-contracts/index.js";
-import { shellValueByteLength } from "../safe-bash-contracts/value.js";
-import { yieldTurn } from "../safe-bash-contracts/yield.js";
-import { createYqQuerySession, YqValueFailure } from "../safe-bash-query-engine/query-core.js";
-import { interruptible, JqError, JqLimitError, wellFormed } from "../safe-bash-query-engine/limits.js";
-var help = "virtual-bash restricted YAML/TOML profile\nusage: yq [eval|e] [OPTION ...] [--] [FILTER [FILE ...]]\n       yq [eval|e] --help\n       yq [eval|e] --version\noptions:\n  -p, --input-format FORMAT   FORMAT is yaml (default) or toml\n      --input-format=FORMAT   same as above\n  -o, --output-format FORMAT  FORMAT is yaml or json\n      --output-format=FORMAT  same as above\n  -c, --compact-output       compact JSON; requires -o json\n  -r, --unwrapScalar         raw strings; requires -o json\n  -h, --help                 show this help (sole argument)\n      --version              show profile identity (sole argument)\n";
-var version = "virtual-bash restricted YAML/TOML profile\n";
-var diagnosticFallback = "yq: limit: DIAGNOSTIC_TRUNCATED\n";
-var RawDocumentFramer = class {
-  #ranges = [];
-  #offset = 0;
-  #frameStart = 0;
-  #frameLine = 0;
-  #lineStart = 0;
-  #lineNumber = 0;
-  #line = "";
-  #pendingCr = false;
-  #frameBytes = 0;
-  #lineBytes = 0;
-  #lineCouldBeMarker = true;
-  #markerComment = false;
-  #leadingWhitespace = true;
-  #lineHasContent = false;
-  #bomBytes = 0;
-  #hasContent = false;
-  admit(chunk) {
-    for (const byte of chunk) {
-      this.#offset++;
-      if (this.#pendingCr && byte !== 10) {
-        this.#pendingCr = false;
-        this.#finishLine(this.#offset - 1);
-      }
-      this.#lineBytes++;
-      if (this.#lineBytes > yqCaps.maxDocumentBytes) throw new YqError("limit", "LIMIT_MAX_DOCUMENT_BYTES", 5);
-      if (this.#pendingCr) {
-        this.#pendingCr = false;
-        this.#finishLine(this.#offset);
-        continue;
-      }
-      if (this.#lineStart === this.#frameStart && this.#lineBytes <= 3) {
-        const expected = this.#lineBytes === 1 ? 239 : this.#lineBytes === 2 && this.#bomBytes === 1 ? 187 : this.#lineBytes === 3 && this.#bomBytes === 2 ? 191 : void 0;
-        if (byte === expected) {
-          this.#bomBytes++;
-          continue;
-        }
-        if (this.#bomBytes > 0) {
-          this.#lineCouldBeMarker = false;
-          this.#lineHasContent = true;
-          this.#leadingWhitespace = false;
-        }
-      }
-      if (this.#leadingWhitespace && byte !== 32 && byte !== 9 && byte !== 13 && byte !== 10) {
-        this.#lineHasContent = byte !== 35 && byte !== 37;
-        this.#leadingWhitespace = false;
-      }
-      if (this.#lineCouldBeMarker && byte !== 13 && byte !== 10 && !this.#markerComment) {
-        if (this.#line.length < 3) {
-          if (this.#line.length === 0 ? byte === 45 || byte === 46 : byte === this.#line.charCodeAt(0)) {
-            this.#line += String.fromCharCode(byte);
-          } else {
-            this.#lineCouldBeMarker = false;
-          }
-        } else if (byte === 32 || byte === 9) {
-          if (this.#line.length === 3) this.#line += " ";
-        } else if (byte === 35) {
-          this.#markerComment = true;
-        } else {
-          this.#lineCouldBeMarker = false;
-        }
-      }
-      if (!this.#lineCouldBeMarker && this.#lineBytes > yqCaps.maxDocumentBytes - this.#frameBytes) {
-        throw new YqError("limit", "LIMIT_MAX_DOCUMENT_BYTES", 5);
-      }
-      if (byte === 13) this.#pendingCr = true;
-      else if (byte === 10) this.#finishLine(this.#offset);
+
+// packages/safe-bash-command-yq/src/mike.ts
+init_buffer();
+import { utf8ByteLength as utf8ByteLength6, utf8Encoder as utf8Encoder4 } from "../safe-bash-query-engine/bytes.js";
+import { escapeText } from "../safe-bash-contracts/escaping.js";
+
+// packages/safe-bash-command-yq/src/formats.ts
+init_buffer();
+import { utf8ByteLength as utf8ByteLength3, utf8Encoder as utf8Encoder2, encodeBase64, decodeBase64 } from "../safe-bash-query-engine/bytes.js";
+import { parseXmlSteps } from "@poe-platform/safe-fs/core";
+
+// packages/safe-bash-command-yq/src/nodes.ts
+init_buffer();
+import { utf8ByteLength, utf8Encoder, utf8Decoder } from "../safe-bash-query-engine/bytes.js";
+
+// packages/safe-bash-command-yq/src/native-work.ts
+init_buffer();
+import { createOutputOperation } from "../safe-bash-contracts/index.js";
+import { inheritYieldCheckpoint, yieldTurn } from "../safe-bash-contracts/yield.js";
+var mikeLimits = Object.freeze({
+  maxInputBytes: Infinity,
+  maxDocumentBytes: Infinity,
+  maxScalarBytes: Infinity,
+  maxNodes: Infinity,
+  maxParserNodes: Infinity,
+  maxDepth: Infinity,
+  maxExpressionDepth: Infinity,
+  maxExpressionBytes: Infinity,
+  maxAliases: Infinity,
+  maxDocuments: Infinity,
+  maxOutputBytes: Infinity,
+  maxSteps: Infinity
+});
+var MikeError = class extends Error {
+  constructor(message, usage = false) {
+    super(message);
+    this.usage = usage;
+  }
+  usage;
+};
+function limitsFor(options = {}) {
+  if (!options || typeof options !== "object" || Array.isArray(options)) throw new TypeError("invalid yq limits");
+  const limits = { ...mikeLimits };
+  for (const [name, value2] of Object.entries(options)) {
+    if (!Object.hasOwn(limits, name) || value2 !== Infinity && (!Number.isSafeInteger(value2) || value2 < 1)) {
+      throw new TypeError(`invalid yq limit: ${name}`);
     }
+    limits[name] = value2;
+  }
+  return Object.freeze(limits);
+}
+var NativeWork = class {
+  constructor(context, limits) {
+    this.context = context;
+    this.limits = limits;
+    inheritYieldCheckpoint(context.signal, this.signal);
+    context.registerCleanup?.(() => this.close());
+    const abort = () => {
+      this.#aborted = true;
+      this.controller.abort(context.signal.reason);
+    };
+    this.signal.addEventListener("abort", () => {
+      this.#aborted = true;
+    }, { once: true });
+    if (context.signal.aborted) abort();
+    else context.signal.addEventListener("abort", abort, { once: true });
+    this.#cleanup.push(() => {
+      context.signal.removeEventListener("abort", abort);
+    });
   }
-  finish(bytes) {
-    if (this.#lineBytes > 0) {
-      this.#pendingCr = false;
-      this.#finishLine(this.#offset);
+  context;
+  limits;
+  capturePositions = false;
+  positions = /* @__PURE__ */ new WeakMap();
+  implicitTags = /* @__PURE__ */ new WeakSet();
+  headComments = /* @__PURE__ */ new WeakMap();
+  controller = new AbortController();
+  signal = this.controller.signal;
+  #cleanup = [];
+  #pending = /* @__PURE__ */ new Set();
+  #closing;
+  #open = true;
+  #aborted = false;
+  #steps = 0;
+  #yieldAt = 1024;
+  #input = 0;
+  #nodes = 0;
+  #aliases = 0;
+  #output = 0;
+  #documents = 0;
+  assertOpen() {
+    if (this.#aborted) {
+      this.context.signal.throwIfAborted();
+      this.signal.throwIfAborted();
     }
-    if (this.#frameStart < this.#offset) this.#ranges.push({ start: this.#frameStart, end: this.#offset, lineOffset: this.#frameLine });
-    return this.#ranges.map((range) => ({
-      bytes: bytes.subarray(range.start, range.end),
-      rawBytes: range.end - range.start,
-      lineOffset: range.lineOffset
-    }));
+    if (!this.#open) throw new MikeError("yq invocation is closed");
   }
-  #finishLine(end) {
-    const marker = this.#lineCouldBeMarker && this.#line.startsWith("---");
-    const endMarker = this.#lineCouldBeMarker && this.#line.startsWith("...");
-    if (marker && this.#hasContent && this.#lineStart > this.#frameStart) {
-      this.#ranges.push({ start: this.#frameStart, end: this.#lineStart, lineOffset: this.#frameLine });
-      this.#frameStart = this.#lineStart;
-      this.#frameLine = this.#lineNumber;
-      this.#frameBytes = this.#lineBytes;
-      this.#hasContent = false;
-    } else {
-      if (this.#lineBytes > yqCaps.maxDocumentBytes - this.#frameBytes) throw new YqError("limit", "LIMIT_MAX_DOCUMENT_BYTES", 5);
-      this.#frameBytes += this.#lineBytes;
-    }
-    if (this.#lineHasContent && !marker && !endMarker) this.#hasContent = true;
-    if (endMarker && this.#frameStart < end) {
-      this.#ranges.push({ start: this.#frameStart, end, lineOffset: this.#frameLine });
-      this.#frameStart = end;
-      this.#frameLine = this.#lineNumber + 1;
-      this.#frameBytes = 0;
-      this.#hasContent = false;
-    }
-    this.#line = "";
-    this.#lineBytes = 0;
-    this.#lineCouldBeMarker = true;
-    this.#markerComment = false;
-    this.#leadingWhitespace = true;
-    this.#lineHasContent = false;
-    this.#bomBytes = 0;
-    this.#lineStart = end;
-    this.#lineNumber++;
+  tick(units = 1) {
+    this.assertOpen();
+    this.#steps += units;
+    if (!Number.isSafeInteger(this.#steps) || this.#steps > this.limits.maxSteps) throw new MikeError("yq limit exceeded: maxSteps");
+    if (this.#steps >= this.#yieldAt) {
+      this.#yieldAt = this.#steps + 1024;
+      return yieldTurn(this.signal).then(() => {
+        this.assertOpen();
+      });
+    }
   }
-};
-var SinkFailure = class {
-  constructor(reason) {
-    this.reason = reason;
+  input(bytes) {
+    this.assertOpen();
+    if (bytes > this.limits.maxInputBytes - this.#input) throw new MikeError("yq limit exceeded: maxInputBytes");
+    this.#input += bytes;
   }
-  reason;
-};
-var InvocationOwner = class {
-  #accepting = true;
-  #callbacks = [];
-  #closePromise;
-  assertOpen(signal) {
-    if (signal.aborted) throw signal.reason;
-    if (!this.#accepting) throw new Error("yq invocation is closed");
+  node(count = 1) {
+    this.assertOpen();
+    this.#nodes += count;
+    if (this.#nodes > this.limits.maxNodes) throw new MikeError("yq limit exceeded: maxNodes");
+  }
+  alias() {
+    if (++this.#aliases > this.limits.maxAliases) throw new MikeError("yq limit exceeded: maxAliases");
+  }
+  document() {
+    this.assertOpen();
+    if (++this.#documents > this.limits.maxDocuments) throw new MikeError("yq limit exceeded: maxDocuments");
+  }
+  depth(depth) {
+    if (depth > this.limits.maxDepth) throw new MikeError("yq limit exceeded: maxDepth");
+  }
+  output(bytes) {
+    this.assertOpen();
+    if (bytes > this.limits.maxOutputBytes - this.#output) throw new MikeError("yq limit exceeded: maxOutputBytes");
+    this.#output += bytes;
   }
   register(cleanup) {
-    if (!this.#accepting) throw new Error("yq invocation is closed");
-    if (typeof cleanup !== "function") throw new TypeError("cleanup must be callable");
-    this.#callbacks.push(cleanup);
+    this.assertOpen();
+    this.#cleanup.push(cleanup);
+  }
+  track(promise) {
+    this.#pending.add(promise);
+    void promise.then(() => this.#pending.delete(promise), () => this.#pending.delete(promise));
+    return promise;
+  }
+  async acquire(start, release) {
+    this.assertOpen();
+    let resource;
+    let settled;
+    const ready = new Promise((resolve) => {
+      settled = resolve;
+    });
+    let released;
+    const dispose = () => released ??= ready.then(async () => {
+      if (resource) await release(resource.value);
+    });
+    this.register(dispose);
+    try {
+      const value2 = await this.track(Promise.resolve().then(() => {
+        this.assertOpen();
+        return start();
+      }));
+      resource = { value: value2 };
+      settled();
+      this.assertOpen();
+      return value2;
+    } catch (error) {
+      settled();
+      await dispose();
+      throw error;
+    }
+  }
+  async readFile(path) {
+    this.assertOpen();
+    const fs = this.context.fs;
+    const capabilities = fs.capabilitiesFor ? await this.track(fs.capabilitiesFor(path, { signal: this.signal })) : fs.capabilities;
+    this.assertOpen();
+    if (fs.readStream && capabilities.streamingRead !== false) {
+      return this.collect(() => fs.readStream(path, { signal: this.signal }));
+    }
+    const bytes = await this.track(fs.readFile(path, {
+      signal: this.signal,
+      ...Number.isFinite(this.limits.maxInputBytes) ? { maxBytes: this.limits.maxInputBytes } : {}
+    }));
+    this.input(bytes.length);
+    return bytes;
+  }
+  async collect(start) {
+    const iterator = await this.acquire(() => start()[Symbol.asyncIterator](), async (value2) => {
+      await value2.return?.();
+    });
+    const chunks = [];
+    let size = 0;
+    let chunksSinceYield = 0;
+    while (true) {
+      this.assertOpen();
+      const next = await this.track(Promise.resolve(iterator.next()));
+      this.assertOpen();
+      if (next.done) break;
+      if (!(next.value instanceof Uint8Array)) throw new TypeError("Byte sources must yield Uint8Array chunks");
+      this.input(next.value.byteLength);
+      if (next.value.byteLength) {
+        const copy = new Uint8Array(next.value);
+        chunks.push(copy);
+        size += copy.length;
+      }
+      const checkpoint = this.tick();
+      chunksSinceYield++;
+      if (checkpoint) {
+        await checkpoint;
+        chunksSinceYield = 0;
+      } else if (chunksSinceYield >= 1024) {
+        await yieldTurn(this.signal);
+        chunksSinceYield = 0;
+        this.assertOpen();
+      }
+    }
+    const result = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+      result.set(chunk, offset);
+      offset += chunk.length;
+      {
+        const t = this.tick();
+        if (t) await t;
+      }
+    }
+    return result;
+  }
+  async write(bytes, stderr = false) {
+    this.assertOpen();
+    const operation = createOutputOperation({ signal: this.signal, registerCleanup: (cleanup) => this.register(cleanup) }, stderr ? this.context.stderr : this.context.stdout);
+    try {
+      await this.track(operation.output.write(bytes));
+      this.assertOpen();
+    } finally {
+      await operation.close();
+    }
   }
   close() {
-    if (this.#closePromise) return this.#closePromise;
-    this.#accepting = false;
-    this.#closePromise = (async () => {
-      const results = await Promise.allSettled(this.#callbacks.map(async (cleanup) => cleanup()));
-      const failures = results.filter((result) => result.status === "rejected").map((result) => result.reason);
-      if (failures.length === 1) throw failures[0];
-      if (failures.length > 1) throw new AggregateError(failures, "yq invocation cleanup failed");
+    if (this.#closing) return this.#closing;
+    this.#open = false;
+    this.controller.abort(new MikeError("yq invocation is closed"));
+    this.#closing = (async () => {
+      const closed = Promise.allSettled(this.#cleanup.map(async (cleanup) => cleanup()));
+      while (this.#pending.size) await Promise.allSettled([...this.#pending]);
+      const failures = (await closed).filter((result) => result.status === "rejected").map((result) => result.reason);
+      if (failures.length) throw new AggregateError(failures, "yq cleanup failed");
     })();
-    void this.#closePromise.catch(() => {
+    void this.#closing.catch(() => {
     });
-    return this.#closePromise;
+    return this.#closing;
   }
 };
-function cli(code) {
-  return new YqError("cli", code, 2);
+
+// packages/safe-bash-command-yq/src/comments.ts
+init_buffer();
+async function recordHeadComments(node, prefix, input, yaml, work) {
+  const normalize = (text) => text.split("\n").map((line) => line.startsWith("# ") ? line.slice(2) : line).join("\n");
+  const comments = async (tokens) => {
+    const parts = [];
+    let lineStart = true;
+    let skipNewline = false;
+    for (const token of tokens) {
+      {
+        const t = work.tick();
+        if (t) await t;
+      }
+      if (token.type === "comment" && lineStart) parts.push(token.source);
+      else if (token.type === "newline") {
+        if (parts.length && !skipNewline) parts.push("\n");
+        lineStart = true;
+        skipNewline = false;
+      } else if (token.type === "doc-start" || token.type === "directive") skipNewline = true;
+      else if (token.type === "seq-item-ind") lineStart = true;
+      else if (token.type !== "space") lineStart = false;
+    }
+    const text = parts.join("");
+    return normalize(text.endsWith("\n") ? text.slice(0, -1) : text);
+  };
+  let head = "";
+  if (input !== void 0) {
+    const parts = [];
+    let offset = 0;
+    let remainder = "";
+    while (offset < input.length || remainder) {
+      const newline = input.indexOf("\n", offset);
+      const end = newline < 0 ? input.length : newline + 1;
+      const line = remainder + input.slice(offset, end);
+      {
+        const t = work.tick(line.length + 1);
+        if (t) await t;
+      }
+      offset = end;
+      remainder = "";
+      const content = line.endsWith("\r\n") ? line.slice(0, -2) : line.endsWith("\n") ? line.slice(0, -1) : line;
+      const trimmed = content.trimStart();
+      if (trimmed.trimEnd() === "---") continue;
+      if (trimmed.startsWith("---") && (trimmed[3] === " " || trimmed[3] === "	")) {
+        remainder = trimmed.slice(3).trimStart();
+        continue;
+      }
+      if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith("%YAML")) parts.push(line);
+      else break;
+    }
+    const text = parts.join("");
+    head = normalize(text.endsWith("\n") ? text.slice(0, -1) : text);
+  } else head = await comments(prefix);
+  const visit = async (current, leading, documentRoot = false) => {
+    {
+      const t = work.tick();
+      if (t) await t;
+    }
+    const token = current.srcToken;
+    const block = token?.type === "block-map" || token?.type === "block-seq";
+    if (leading && (!block || documentRoot)) work.headComments.set(current, leading);
+    const inherited = block && !documentRoot ? leading : "";
+    const combine = (head2) => inherited && head2 ? `${inherited}
+${head2}` : inherited || head2;
+    if (yaml.isMap(current) && (token?.type === "block-map" || token?.type === "flow-collection")) {
+      for (let index = 0; index < current.items.length; index++) {
+        const pair = current.items[index];
+        const item = token.items[index];
+        if (!item) continue;
+        const head2 = await comments(item.start);
+        if (yaml.isNode(pair.key)) await visit(pair.key, index === 0 ? combine(head2) : head2);
+        if (yaml.isNode(pair.value)) await visit(pair.value, await comments(item.sep ?? []));
+      }
+    } else if (yaml.isSeq(current) && (token?.type === "block-seq" || token?.type === "flow-collection")) {
+      for (let index = 0; index < current.items.length; index++) {
+        const child = current.items[index];
+        const item = token.items[index];
+        if (yaml.isNode(child) && item) {
+          const head2 = await comments(item.start);
+          await visit(child, index === 0 ? combine(head2) : head2);
+        }
+      }
+    }
+  };
+  await visit(node, head, input !== void 0);
 }
-function preflightArguments(context) {
-  const args = context.args;
-  if (args.length > yqCaps.maxArgvEntries) throw cli("CLI_ARGV_ENTRIES_LIMIT");
-  let bytes = 0;
-  for (const argument of args) {
-    if (!wellFormed(argument)) throw cli("CLI_INVALID_UNICODE");
-    const incoming = utf8ByteLength(argument);
-    if (incoming > yqCaps.maxArgvUtf8Bytes - bytes) throw cli("CLI_ARGV_BYTES_LIMIT");
-    bytes += incoming;
+
+// packages/safe-bash-command-yq/src/nodes.ts
+async function loadYaml() {
+  try {
+    return await import("../safe-bash/bundled-yaml/index.js");
+  } catch {
+    throw new MikeError("the optional yaml@2.9.0 peer is required for this yq profile");
   }
-  const carrier = getCommandArguments(context);
-  bytes = 0;
-  const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
-  for (let index = 0; index < args.length; index++) {
-    const incoming = shellValueByteLength(carrier.values[index]);
-    if (incoming > yqCaps.maxArgvUtf8Bytes - bytes) throw cli("CLI_ARGV_BYTES_LIMIT");
-    bytes += incoming;
-    let decoded;
-    try {
-      decoded = decoder.decode(carrier.bytes(index));
-    } catch {
-      throw cli("CLI_INVALID_UNICODE");
-    }
-    if (decoded !== args[index]) throw cli("CLI_INVALID_UNICODE");
+}
+function scalar(yaml, work, value2, float = false) {
+  work.node();
+  if (typeof value2 === "string" && utf8ByteLength(value2) > work.limits.maxScalarBytes) throw new MikeError("yq limit exceeded: maxScalarBytes");
+  const node = new yaml.Scalar(value2);
+  if (float) node.minFractionDigits = 0;
+  return node;
+}
+function root(document) {
+  return { node: document.doc.contents, document, isDocumentRoot: true };
+}
+function nodeTag(node, yaml) {
+  if (node.tag) return node.tag.replace("tag:yaml.org,2002:", "!!");
+  if (yaml.isMap(node)) return "!!map";
+  if (yaml.isSeq(node)) return "!!seq";
+  if (yaml.isAlias(node)) return "";
+  const value2 = node.value;
+  if (value2 === null || value2 === void 0) return "!!null";
+  if (typeof value2 === "boolean") return "!!bool";
+  if (typeof value2 === "number" && (node.minFractionDigits !== void 0 || node.format === "EXP" || node.source?.includes("."))) return "!!float";
+  if (typeof value2 === "bigint" || typeof value2 === "number" && Number.isInteger(value2)) return "!!int";
+  if (typeof value2 === "number") return "!!float";
+  return "!!str";
+}
+function truth(node, yaml) {
+  return !yaml.isScalar(node) || node.value !== null && node.value !== void 0 && node.value !== false;
+}
+function dereference(candidate, yaml, work) {
+  let node = candidate.node;
+  const seen = /* @__PURE__ */ new Set();
+  while (yaml.isAlias(node)) {
+    work.alias();
+    if (seen.has(node)) throw new MikeError("cyclic YAML alias");
+    seen.add(node);
+    const resolved = node.resolve(candidate.document.doc);
+    if (!resolved) throw new MikeError(`unknown anchor '${node.source}' referenced`);
+    node = resolved;
   }
+  return node === candidate.node ? candidate : { node, document: candidate.document, isDerived: candidate.isDerived ?? false, ...candidate.ancestry ? { ancestry: candidate.ancestry } : {} };
 }
-function isInformationForm(args) {
-  const offset = args[0] === "eval" || args[0] === "e" ? 1 : 0;
-  if (args.length !== offset + 1) return void 0;
-  const token = args[offset];
-  if (token === "-h" || token === "--help") return "help";
-  if (token === "--version") return "version";
-  return void 0;
+async function inspectNode(node, yaml, work, allocate = false) {
+  const pending = [{ node, depth: 0 }];
+  let count = 0;
+  while (pending.length) {
+    const current = pending.pop();
+    work.depth(current.depth);
+    if (++count > work.limits.maxParserNodes) throw new MikeError("yq limit exceeded: maxParserNodes");
+    {
+      const t = work.tick();
+      if (t) await t;
+    }
+    if (allocate) work.node();
+    if (yaml.isScalar(current.node)) {
+      if (typeof current.node.value === "string" && utf8ByteLength(current.node.value) > work.limits.maxScalarBytes) throw new MikeError("yq limit exceeded: maxScalarBytes");
+    } else if (yaml.isMap(current.node)) {
+      for (const pair of current.node.items) {
+        if (yaml.isNode(pair.key)) pending.push({ node: pair.key, depth: current.depth + 1 });
+        if (yaml.isNode(pair.value)) pending.push({ node: pair.value, depth: current.depth + 1 });
+      }
+    } else if (yaml.isSeq(current.node)) {
+      for (const child of current.node.items) if (yaml.isNode(child)) pending.push({ node: child, depth: current.depth + 1 });
+    }
+  }
 }
-function parseArguments(args, inputFormat) {
-  let index = args[0] === "eval" || args[0] === "e" ? 1 : 0;
-  if (args[0] === "eval-all" || args[0] === "ea") throw cli("CLI_UNSUPPORTED_COMMAND");
-  let ended = false;
-  let inputFormatSeen = false;
-  let format = "yaml";
-  let explicitJson = false;
-  let formatSeen = false;
-  let compact = false;
-  let compactSeen = false;
-  let raw = false;
-  let rawSeen = false;
-  const operands = [];
-  const refused = /^(?:-s|-n|-p|-i|--slurp|--null-input|--input-format|--yaml-schema|--schema|--json-schema|--failsafe-schema|--inplace|--in-place|--allow-lossy-write|--write|--split-exp|--front-matter|--xml|--properties|--color-output)(?:=.*)?$/u;
-  for (; index < args.length; index++) {
-    const argument = args[index];
-    if (!ended && argument === "--") {
-      ended = true;
-      continue;
+async function cloneNode(node, yaml, work) {
+  await inspectNode(node, yaml, work, true);
+  work.assertOpen();
+  const cloned = node.clone();
+  const pending = [{ original: node, cloned }];
+  while (pending.length) {
+    const current = pending.pop();
+    {
+      const t = work.tick();
+      if (t) await t;
     }
-    if (!ended && (argument === "-p" || argument === "--input-format" || argument.startsWith("--input-format="))) {
-      if (inputFormatSeen) throw cli("CLI_DUPLICATE_OPTION");
-      const value = argument.startsWith("--input-format=") ? argument.slice("--input-format=".length) : args[++index];
-      if (value === void 0 || value === "") throw cli("CLI_MISSING_OPTION_VALUE");
-      if (value !== "yaml" && value !== "toml") throw cli("CLI_INVALID_OPTION_VALUE");
-      inputFormatSeen = true;
-      inputFormat = value;
-      continue;
+    if (work.implicitTags.has(current.original)) work.implicitTags.add(current.cloned);
+    const position = work.positions.get(current.original);
+    if (position) work.positions.set(current.cloned, position);
+    const head = work.headComments.get(current.original);
+    if (head !== void 0) work.headComments.set(current.cloned, head);
+    if (yaml.isMap(current.original) && yaml.isMap(current.cloned)) for (let index = 0; index < current.original.items.length; index++) {
+      const original = current.original.items[index];
+      const copy = current.cloned.items[index];
+      if (yaml.isNode(original.key) && yaml.isNode(copy.key)) pending.push({ original: original.key, cloned: copy.key });
+      if (yaml.isNode(original.value) && yaml.isNode(copy.value)) pending.push({ original: original.value, cloned: copy.value });
     }
-    if (!ended && (argument === "-o" || argument === "--output-format")) {
-      if (formatSeen) throw cli("CLI_DUPLICATE_OPTION");
-      const value = args[++index];
-      if (value === void 0) throw cli("CLI_MISSING_OPTION_VALUE");
-      if (value !== "yaml" && value !== "json") throw cli("CLI_INVALID_OPTION_VALUE");
-      formatSeen = true;
-      format = value;
-      explicitJson = value === "json";
-      continue;
+    else if (yaml.isSeq(current.original) && yaml.isSeq(current.cloned)) for (let index = 0; index < current.original.items.length; index++) {
+      const original = current.original.items[index];
+      const copy = current.cloned.items[index];
+      if (yaml.isNode(original) && yaml.isNode(copy)) pending.push({ original, cloned: copy });
     }
-    if (!ended && argument.startsWith("--output-format=")) {
-      if (formatSeen) throw cli("CLI_DUPLICATE_OPTION");
-      const value = argument.slice("--output-format=".length);
-      if (value === "") throw cli("CLI_MISSING_OPTION_VALUE");
-      if (value !== "yaml" && value !== "json") throw cli("CLI_INVALID_OPTION_VALUE");
-      formatSeen = true;
-      format = value;
-      explicitJson = value === "json";
-      continue;
+  }
+  return cloned;
+}
+async function replace(candidate, incoming, yaml, work, clobber = false) {
+  const node = await cloneNode(incoming, yaml, work);
+  const previous = candidate.node;
+  const head = work.headComments.get(previous);
+  if (head !== void 0 && !work.headComments.has(node)) work.headComments.set(node, head);
+  if (previous.comment !== void 0) node.comment = previous.comment;
+  if (previous.commentBefore !== void 0) node.commentBefore = previous.commentBefore;
+  if (previous.spaceBefore !== void 0) node.spaceBefore = previous.spaceBefore;
+  if ("anchor" in previous && "anchor" in node) node.anchor = previous.anchor;
+  if (!clobber && previous.tag && (!previous.tag.startsWith("tag:yaml.org,2002:") || nodeTag(node, yaml) === nodeTag(previous, yaml))) {
+    node.tag = previous.tag;
+    if (work.implicitTags.has(previous)) work.implicitTags.add(node);
+  }
+  if (yaml.isScalar(node) && yaml.isScalar(previous) && previous.type !== void 0) node.type = previous.type;
+  if (candidate.parent) {
+    if (yaml.isMap(candidate.parent)) candidate.parent.items[candidate.slot].value = node;
+    else candidate.parent.items[candidate.slot] = node;
+  } else if (candidate.isDocumentRoot) candidate.document.doc.contents = node;
+  candidate.node = node;
+}
+async function admitCst(token, work) {
+  const pending = [{ value: token, depth: 0 }];
+  let nodes = 0;
+  let composed = 0;
+  let bytes = 0;
+  const maxParserNodes = work.limits.maxParserNodes;
+  const maxNodes8 = maxParserNodes * 8;
+  const maxDocBytes = work.limits.maxDocumentBytes;
+  const maxScalarBytes = work.limits.maxScalarBytes;
+  const checkDocBytes = maxDocBytes !== Infinity;
+  while (pending.length) {
+    const { value: value2, depth } = pending.pop();
+    if (!value2 || typeof value2 !== "object") continue;
+    {
+      const t = work.tick();
+      if (t) await t;
     }
-    if (!ended && (argument === "-c" || argument === "--compact-output")) {
-      if (compactSeen) throw cli("CLI_DUPLICATE_OPTION");
-      compactSeen = true;
-      compact = true;
+    if (Array.isArray(value2)) {
+      for (let i = 0; i < value2.length; i++) {
+        const child = value2[i];
+        if (child && typeof child === "object") pending.push({ value: child, depth });
+      }
       continue;
     }
-    if (!ended && (argument === "-r" || argument === "--unwrapScalar")) {
-      if (rawSeen) throw cli("CLI_DUPLICATE_OPTION");
-      rawSeen = true;
-      raw = true;
-      continue;
+    const item = value2;
+    const itemType = item.type;
+    const collection = itemType === "block-map" || itemType === "block-seq" || itemType === "flow-collection";
+    if (collection || itemType === "alias" || itemType === "scalar" || itemType === "single-quoted-scalar" || itemType === "double-quoted-scalar" || itemType === "block-scalar") {
+      if (++composed > maxParserNodes) throw new MikeError("yq limit exceeded: maxParserNodes");
+      work.node();
+    }
+    work.depth(depth);
+    if (itemType && ++nodes > maxNodes8) throw new MikeError("yq limit exceeded: maxParserNodes");
+    if (typeof item.source === "string") {
+      if (item.source.length > maxScalarBytes) throw new MikeError("yq limit exceeded: maxScalarBytes");
+      if (checkDocBytes) {
+        bytes += utf8ByteLength(item.source);
+        if (bytes > maxDocBytes) throw new MikeError("yq limit exceeded: maxDocumentBytes");
+      }
+    }
+    const nextDepth = depth + (collection ? 1 : 0);
+    for (const key in item) {
+      const child = item[key];
+      if (child && typeof child === "object") pending.push({ value: child, depth: nextDepth });
     }
-    if (!ended && refused.test(argument)) throw cli("CLI_UNSUPPORTED_OPTION");
-    if (!ended && argument.startsWith("-") && argument !== "-") throw cli("CLI_UNKNOWN_OPTION");
-    operands.push(argument);
-  }
-  if ((compact || raw) && !explicitJson) throw cli("CLI_INCOMPATIBLE_OPTIONS");
-  const filter = operands[0] ?? ".";
-  const files = operands.slice(1);
-  let stdinSeen = false;
-  for (const file of files) {
-    if (file === "-") {
-      if (stdinSeen) throw cli("CLI_DUPLICATE_STDIN");
-      stdinSeen = true;
-    } else if (utf8ByteLength(file) > yqCaps.maxVfsOperandPathBytes) throw cli("CLI_VFS_OPERAND_LIMIT");
-  }
-  return { inputFormat, format, explicitJson, compact, raw, filter, files };
-}
-function displayedSource(source) {
-  if (source === "<stdin>") return source;
-  const parts = ['"'];
-  let bytes = 2;
-  let truncated = false;
-  for (const character of source) {
-    const encoded = escapeText(JSON.stringify(character).slice(1, -1), "diagnostic");
-    const incoming = utf8ByteLength(encoded);
-    if (incoming > yqCaps.maxDisplayedFilenameBytes - bytes) {
-      truncated = true;
-      break;
-    }
-    parts.push(encoded);
-    bytes += incoming;
-  }
-  if (truncated) {
-    while (parts.length > 1 && utf8ByteLength(parts.join("")) + 4 > yqCaps.maxDisplayedFilenameBytes) parts.pop();
-    parts.push("...");
   }
-  parts.push('"');
-  return parts.join("");
 }
-function diagnostic(error) {
-  let location = "";
-  if (error.source !== void 0) {
-    location = ` at ${displayedSource(error.source)}`;
-    if (error.line !== void 0 && error.column !== void 0) location += `:${error.line}:${error.column}`;
+async function decodeJsonDocument(source, filename, yaml, work) {
+  let offset = 0;
+  let nodes = 0;
+  const admit = () => {
+    if (++nodes > work.limits.maxParserNodes) throw new MikeError("yq limit exceeded: maxParserNodes");
+    work.node();
+  };
+  const fail = (context) => {
+    throw new MikeError(`bad file '${filename}': ${context ? `json: ${context} unexpected end of JSON input` : "invalid JSON input"}`);
+  };
+  const skip = async () => {
+    while (offset < source.length && " 	\r\n".includes(source[offset])) {
+      offset++;
+      {
+        const t = work.tick();
+        if (t) await t;
+      }
+    }
+  };
+  const string = async () => {
+    const start = offset++;
+    let escaped = false;
+    while (offset < source.length) {
+      {
+        const t = work.tick();
+        if (t) await t;
+      }
+      const character = source[offset++];
+      if (!escaped && character === '"') {
+        let value2;
+        try {
+          value2 = JSON.parse(source.slice(start, offset));
+        } catch {
+          return fail();
+        }
+        if (utf8ByteLength(value2) > work.limits.maxScalarBytes) throw new MikeError("yq limit exceeded: maxScalarBytes");
+        return utf8Decoder.decode(utf8Encoder.encode(value2));
+      }
+      if (!escaped && character === "\\") escaped = true;
+      else escaped = false;
+    }
+    return fail();
+  };
+  const parse = async (depth, context = "null") => {
+    await skip();
+    {
+      const t = work.tick();
+      if (t) await t;
+    }
+    work.depth(depth);
+    const character = source[offset];
+    if (character === void 0) return fail(context === "value of object" ? "object of object" : context);
+    admit();
+    if (character === "{") {
+      offset++;
+      const node = new yaml.YAMLMap();
+      await skip();
+      if (source[offset] === "}") {
+        offset++;
+        return node;
+      }
+      for (; ; ) {
+        if (source[offset] !== '"') return fail();
+        admit();
+        const key = new yaml.Scalar(await string());
+        await skip();
+        if (source[offset++] !== ":") return fail();
+        const value3 = await parse(depth + 1, "value of object");
+        node.items.push(new yaml.Pair(key, value3));
+        await skip();
+        if (source[offset] === "}") {
+          offset++;
+          return node;
+        }
+        if (source[offset] === '"') continue;
+        if (source[offset++] !== ",") return fail("object of object");
+        await skip();
+      }
+    }
+    if (character === "[") {
+      offset++;
+      const node = new yaml.YAMLSeq();
+      await skip();
+      if (source[offset] === "]") {
+        offset++;
+        return node;
+      }
+      for (; ; ) {
+        node.items.push(await parse(depth + 1));
+        await skip();
+        if (source[offset] === "]") {
+          offset++;
+          return node;
+        }
+        if (source[offset++] !== ",") return fail();
+        await skip();
+      }
+    }
+    if (character === '"') return new yaml.Scalar(await string());
+    if (character === "}" || character === "]" || character === ",") return fail(context);
+    const start = offset;
+    while (offset < source.length && !' 	\r\n,]}"'.includes(source[offset])) {
+      offset++;
+      {
+        const t = work.tick();
+        if (t) await t;
+      }
+    }
+    let value2;
+    try {
+      value2 = JSON.parse(source.slice(start, offset));
+    } catch {
+      return fail();
+    }
+    if (value2 !== null && typeof value2 !== "number" && typeof value2 !== "boolean") return fail();
+    if (typeof value2 === "number" && Number.isFinite(value2)) {
+      if (Number.isInteger(value2)) {
+        const integer = BigInt(value2);
+        const clamped = integer < -(1n << 63n) ? -(1n << 63n) : integer >= 1n << 63n ? (1n << 63n) - 1n : integer;
+        if (Number(clamped) === value2) return new yaml.Scalar(clamped);
+      }
+      const node = new yaml.Scalar(value2);
+      const magnitude = Math.abs(value2);
+      node.source = (magnitude < 1e-4 || magnitude >= 1e6 ? value2.toExponential() : String(value2)).replace(/e([+-])([0-9])$/u, "e$10$2");
+      node.tag = "tag:yaml.org,2002:float";
+      work.implicitTags.add(node);
+      return node;
+    }
+    return new yaml.Scalar(value2);
+  };
+  const contents = await parse(0);
+  await skip();
+  if (offset !== source.length) fail();
+  const doc = new yaml.Document();
+  doc.contents = contents;
+  return doc;
+}
+async function adaptQuotedIndent(text, filename, yaml, work) {
+  const additions = [];
+  const failures = /* @__PURE__ */ new Map();
+  if (!text.includes('"') && !text.includes("'")) return { text, insertions: [], failures };
+  let size = utf8ByteLength(text);
+  let sourceOffset = 0;
+  let quotedUntil = 0;
+  const lexer = new yaml.Lexer();
+  const closeQuote = async (start, limit) => {
+    const quote = text[start];
+    let escaped = false;
+    for (let index = start + 1; index < limit; index++) {
+      {
+        const t = work.tick();
+        if (t) await t;
+      }
+      if (index - start > work.limits.maxScalarBytes) throw new MikeError("yq limit exceeded: maxScalarBytes");
+      const character = text[index];
+      if (character === "\n") {
+        const marker = text.slice(index + 1, index + 4);
+        const after = text[index + 4];
+        if ((marker === "---" || marker === "...") && (after === void 0 || " 	\r\n".includes(after))) {
+          const line = text.slice(0, start).split("\n").length;
+          const column = start - text.lastIndexOf("\n", start);
+          const markerLine = text.slice(0, index + 1).split("\n").length;
+          if (!failures.has(start)) work.node();
+          failures.set(start, `bad file '${filename}': yaml: while scanning a quoted scalar at line ${line}, column ${column}: line ${markerLine}: found unexpected document indicator`);
+          return -1;
+        }
+      }
+      if (quote === '"') {
+        if (!escaped && character === '"') return index + 1;
+        if (!escaped && character === "\\") escaped = true;
+        else escaped = false;
+      } else if (character === "'") {
+        if (text[index + 1] === "'") index++;
+        else return index + 1;
+      }
+    }
+    return -1;
+  };
+  scan: for (let offset = 0; offset <= text.length; offset += 4096) {
+    const incomplete = offset + 4096 < text.length;
+    await work.tick(Math.min(4096, text.length - offset) + 1);
+    for (const lexeme of lexer.lex(text.slice(offset, offset + 4096), incomplete)) {
+      {
+        const t = work.tick();
+        if (t) await t;
+      }
+      if (lexeme === yaml.CST.DOCUMENT || lexeme === yaml.CST.FLOW_END || lexeme === yaml.CST.SCALAR) continue;
+      const start = sourceOffset;
+      sourceOffset += lexeme.length;
+      if (start < quotedUntil || lexeme[0] !== '"' && lexeme[0] !== "'") continue;
+      const closed = await closeQuote(start, sourceOffset);
+      if (failures.size) break scan;
+      if (closed >= 0) continue;
+      const end = await closeQuote(start, text.length);
+      if (failures.size) break scan;
+      if (end < 0) continue;
+      quotedUntil = end;
+      const lineStart = text.lastIndexOf("\n", start) + 1;
+      let indentation = 0;
+      while (text[lineStart + indentation] === " ") {
+        indentation++;
+        {
+          const t = work.tick();
+          if (t) await t;
+        }
+      }
+      for (let index = start; index < end; index++) {
+        {
+          const t = work.tick();
+          if (t) await t;
+        }
+        if (text[index] !== "\n") continue;
+        let spaces = 0;
+        while (text[index + 1 + spaces] === " ") {
+          spaces++;
+          {
+            const t = work.tick();
+            if (t) await t;
+          }
+        }
+        if (spaces > indentation) continue;
+        const length = indentation + 1 - spaces;
+        if (length > work.limits.maxInputBytes - size) throw new MikeError("yq limit exceeded: maxInputBytes");
+        work.node(3);
+        additions.push({ offset: index + 1, length });
+        size += length;
+      }
+    }
+    if (!incomplete) break;
   }
-  return `yq: ${error.category}: ${error.code}${location}
-`;
+  if (!additions.length) return { text, insertions: [], failures };
+  const chunks = [];
+  const insertions = [];
+  let copied = 0;
+  let inserted = 0;
+  for (const addition of additions) {
+    {
+      const t = work.tick(addition.length + 1);
+      if (t) await t;
+    }
+    chunks.push(text.slice(copied, addition.offset), " ".repeat(addition.length));
+    insertions.push({ offset: addition.offset + inserted, length: addition.length });
+    copied = addition.offset;
+    inserted += addition.length;
+  }
+  chunks.push(text.slice(copied));
+  return { text: chunks.join(""), insertions, failures };
 }
-function classifyValueFailure(error) {
-  const category = error.code.startsWith("ENCODE_") ? "encode" : "schema";
-  return new YqError(category, error.code, 5);
-}
-function withSource(error, source) {
-  if (error.source !== void 0) return error;
-  return new YqError(error.category, error.code, error.status, source, error.line, error.column);
-}
-async function collectSource(context, owner, session, sourceName, source, vfs, inputFormat) {
-  let producer;
-  let finished = false;
-  let producerReturn;
-  const closeProducer = () => {
-    if (producerReturn) return producerReturn;
-    if (!producer || finished || !producer.return) return Promise.resolve({ done: true, value: void 0 });
-    producerReturn = Promise.resolve().then(() => producer.return());
-    return producerReturn;
+async function decodeDocuments(text, filename, fileIndex, format, yaml, work, onDocument) {
+  const documents = [];
+  const sources = [];
+  const originalText = text;
+  let insertions = [];
+  let quotedFailures = /* @__PURE__ */ new Map();
+  const originalOffset = (offset) => {
+    let added = 0;
+    for (const insertion of insertions) {
+      if (insertion.offset >= offset) break;
+      added += Math.min(insertion.length, offset - insertion.offset);
+    }
+    return offset - added;
   };
-  owner.register(async () => {
-    await closeProducer();
-  });
-  let iterator;
-  let returned;
-  owner.register(async () => {
-    if (iterator?.return) {
-      returned ??= Promise.resolve().then(() => iterator.return());
-      await returned;
+  const position = (offset) => {
+    const index = originalOffset(offset);
+    const prefix2 = originalText.slice(0, index);
+    return { line: prefix2.split("\n").length, column: index - prefix2.lastIndexOf("\n") };
+  };
+  const accept = async (doc, implicit = false) => {
+    work.assertOpen();
+    const startOffset = originalOffset(doc.range?.[0] ?? 0);
+    const endOffset = originalOffset(doc.range?.[2] ?? text.length);
+    for (const [offset, failure] of quotedFailures) if (offset >= startOffset && offset < endOffset) throw new MikeError(failure);
+    const error = doc.errors.find((error2) => !(error2.code === "MISSING_CHAR" && error2.message === "Comments must be separated from other tokens by white space characters"));
+    if (error) {
+      let message = error.message;
+      const start = position(doc.contents?.range?.[0] ?? doc.range?.[0] ?? 0);
+      if (message.startsWith("Flow sequence") && message.includes("end with a ]")) message = `while parsing a flow node at line ${start.line}: did not find expected node content`;
+      else if (message.startsWith("Missing closing") && message.includes("quote")) {
+        const end = position(error.pos[0]);
+        message = `while scanning a quoted scalar at line ${start.line}: line ${end.line}, column ${end.column}: found unexpected end of stream`;
+      } else if (message === "Missing , or : between flow sequence items") message = `while parsing a flow sequence at <unknown position>: line ${start.line}: did not find expected ',' or ']'`;
+      else if (error.code === "MULTILINE_IMPLICIT_KEY") {
+        let colon = error.pos[1];
+        while (text[colon] === " " || text[colon] === "	") {
+          colon++;
+          {
+            const t = work.tick();
+            if (t) await t;
+          }
+        }
+        const location = position(colon);
+        message = `line ${location.line}, column ${location.column}: mapping values are not allowed in this context`;
+      }
+      throw new MikeError(`bad file '${filename}': yaml: ${message}`);
     }
-  });
-  iterator = readBytes({ [Symbol.asyncIterator]() {
-    owner.assertOpen(context.signal);
-    producer = source[Symbol.asyncIterator]();
-    return {
-      async next() {
-        owner.assertOpen(context.signal);
-        const next = await producer.next();
-        if (next.done) finished = true;
-        return next;
-      },
-      return: closeProducer
+    work.document();
+    if (!doc.contents) {
+      const empty = new yaml.Scalar(null);
+      empty.source = "";
+      work.node();
+      doc.contents = empty;
+    }
+    await inspectNode(doc.contents, yaml, work, true);
+    const source = sources.shift();
+    if (format === "yaml") await recordHeadComments(doc.contents, source ? [...source.prefix, ...source.token.start] : [], documents.length === 0 ? text : void 0, yaml, work);
+    const anchors = /* @__PURE__ */ new Set();
+    const pending = [doc.contents];
+    while (pending.length) {
+      {
+        const t = work.tick();
+        if (t) await t;
+      }
+      const node = pending.pop();
+      if (work.capturePositions && node.range && format === "yaml") {
+        {
+          const t = work.tick(node.range[0] + 1);
+          if (t) await t;
+        }
+        let offset = node.range[0];
+        if ("anchor" in node && node.anchor) {
+          const anchorOffset = text.lastIndexOf(`&${node.anchor}`, offset);
+          if (anchorOffset >= startOffset) offset = anchorOffset;
+        }
+        work.positions.set(node, position(offset));
+      }
+      if ("anchor" in node && node.anchor) anchors.add(node.anchor);
+      if (yaml.isAlias(node)) {
+        work.alias();
+        if (!anchors.has(node.source)) {
+          const location = position((node.range?.[0] ?? 0) + 1);
+          throw new MikeError(`bad file '${filename}': yaml: line ${location.line}, column ${location.column}: unknown anchor '${node.source}' referenced`);
+        }
+      } else if (yaml.isMap(node)) {
+        for (let index = node.items.length - 1; index >= 0; index--) {
+          const pair = node.items[index];
+          if (yaml.isNode(pair.value)) pending.push(pair.value);
+          if (yaml.isNode(pair.key)) pending.push(pair.key);
+        }
+      } else if (yaml.isSeq(node)) {
+        for (let index = node.items.length - 1; index >= 0; index--) if (yaml.isNode(node.items[index])) pending.push(node.items[index]);
+      }
+    }
+    const document = { doc, filename: implicit ? "" : filename, fileIndex, documentIndex: documents.length, format };
+    documents.push(document);
+    await onDocument?.(document);
+  };
+  if (format === "json") {
+    let start = 0;
+    let depth = 0;
+    let quoted = false;
+    let escaped = false;
+    let tokens = 0;
+    const acceptJson = async (end) => {
+      const source = text.slice(start, end).trim();
+      start = end;
+      if (!source) return;
+      if (utf8ByteLength(source) > work.limits.maxDocumentBytes) throw new MikeError("yq limit exceeded: maxDocumentBytes");
+      const doc = await decodeJsonDocument(source, filename, yaml, work);
+      await accept(doc);
     };
-  } }, context.signal)[Symbol.asyncIterator]();
-  const chunks = [];
-  const framer = inputFormat === "yaml" ? new RawDocumentFramer() : void 0;
-  let size = 0;
-  let chunksSinceYield = 0;
-  while (true) {
-    let next;
-    try {
-      next = await iterator.next();
-    } catch (failure) {
-      if (context.signal.aborted) throw context.signal.reason;
-      if (vfs && failure instanceof FsError) throw new YqError("vfs", "VFS_INPUT_READ", 2, sourceName);
-      throw failure;
-    }
-    owner.assertOpen(context.signal);
-    if (next.done) break;
-    const chunk = next.value;
-    await session.ownedWork.charge(1);
-    if (++chunksSinceYield === 1024) {
-      await yieldTurn(context.signal);
-      chunksSinceYield = 0;
-    }
-    owner.assertOpen(context.signal);
-    if (chunk.byteLength === 0) continue;
-    session.ownedWork.admitInputBytes(chunk.byteLength);
-    if (chunk.byteLength > yqCaps.maxInputBytes - size) throw fromJqLimit(new JqLimitError("maxInputBytes"));
-    if (inputFormat === "toml" && chunk.byteLength > yqCaps.maxDocumentBytes - size) throw new YqError("limit", "LIMIT_MAX_DOCUMENT_BYTES", 5);
-    framer?.admit(chunk);
-    const owned = new Uint8Array(chunk);
-    owner.assertOpen(context.signal);
-    chunks.push(owned);
-    size += owned.byteLength;
-  }
-  owner.assertOpen(context.signal);
-  const bytes = new Uint8Array(size);
-  let offset = 0;
-  for (const chunk of chunks) {
-    bytes.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-  owner.assertOpen(context.signal);
-  return framer ? framer.finish(bytes) : [{ bytes, rawBytes: size, lineOffset: 0 }];
-}
-async function sourceFrames(context, owner, session, sourceName, inputFormat) {
-  if (sourceName === "-") return collectSource(context, owner, session, "<stdin>", context.stdin, false, inputFormat);
-  const path = pathOf(context, sourceName);
-  await session.ownedWork.charge();
-  owner.assertOpen(context.signal);
-  let capabilities;
-  try {
-    capabilities = context.fs.capabilitiesFor ? await interruptible(() => context.fs.capabilitiesFor(path, { signal: context.signal }), context.signal) : context.fs.capabilities;
-  } catch (failure) {
-    if (context.signal.aborted) throw context.signal.reason;
-    if (failure instanceof FsError) throw new YqError("vfs", "VFS_INPUT_OPEN", 2, sourceName);
-    throw failure;
-  }
-  owner.assertOpen(context.signal);
-  if (context.fs.readStream && capabilities.streamingRead !== false) {
-    let source;
-    try {
-      source = context.fs.readStream(path, { signal: context.signal });
-    } catch (failure) {
-      if (context.signal.aborted) throw context.signal.reason;
-      if (failure instanceof FsError) throw new YqError("vfs", "VFS_INPUT_OPEN", 2, sourceName);
-      throw failure;
+    for (let index = 0; index < text.length; index++) {
+      if ((index & 255) === 0) {
+        const t = work.tick(256);
+        if (t) await t;
+      }
+      const character = text[index];
+      if (quoted) {
+        if (escaped) escaped = false;
+        else if (character === "\\") escaped = true;
+        else if (character === '"') {
+          quoted = false;
+          if (depth === 0) await acceptJson(index + 1);
+        }
+      } else if (character === '"') quoted = true;
+      else if (character === "{" || character === "[") {
+        depth++;
+        work.depth(depth);
+      } else if (character === "}" || character === "]") {
+        depth--;
+        if (depth === 0) {
+          await acceptJson(index + 1);
+          tokens = 0;
+        }
+      } else if (/\s/u.test(character) && depth === 0) await acceptJson(index + 1);
+      if (!quoted && ",:{}[]".includes(character) && ++tokens > work.limits.maxParserNodes) throw new MikeError("yq limit exceeded: maxParserNodes");
     }
-    return collectSource(context, owner, session, sourceName, source, true, inputFormat);
+    await acceptJson(text.length);
+    return documents;
   }
-  let bytes;
-  try {
-    bytes = await context.fs.readFile(path, { signal: context.signal, ...Number.isFinite(inputFormat === "toml" ? yqCaps.maxDocumentBytes : yqCaps.maxInputBytes) ? { maxBytes: inputFormat === "toml" ? yqCaps.maxDocumentBytes : yqCaps.maxInputBytes } : {} });
-  } catch (failure) {
-    if (context.signal.aborted) throw context.signal.reason;
-    if (inputFormat === "toml" && failure instanceof FsError && failure.code === "EFBIG") throw new YqError("limit", "LIMIT_MAX_DOCUMENT_BYTES", 5);
-    if (failure instanceof FsError) throw new YqError("vfs", "VFS_INPUT_READ", 2, sourceName);
-    throw failure;
-  }
-  owner.assertOpen(context.signal);
-  session.ownedWork.admitInputBytes(bytes.byteLength);
-  if (inputFormat === "toml") {
-    if (bytes.byteLength > yqCaps.maxDocumentBytes) throw new YqError("limit", "LIMIT_MAX_DOCUMENT_BYTES", 5);
-    return [{ bytes: new Uint8Array(bytes), rawBytes: bytes.byteLength, lineOffset: 0 }];
-  }
-  const framer = new RawDocumentFramer();
-  framer.admit(bytes);
-  const owned = new Uint8Array(bytes);
-  owner.assertOpen(context.signal);
-  return framer.finish(owned);
-}
-function decodeDocument(bytes, inputFormat) {
-  try {
-    return new TextDecoder("utf-8", { fatal: true, ignoreBOM: inputFormat === "toml" }).decode(bytes);
-  } catch {
-    throw new YqError("input", "INPUT_INVALID_UTF8", 5);
+  const admitText = async (input) => {
+    let documentBytes = 0;
+    for (let offset = 0; offset < input.length; ) {
+      const newline = input.indexOf("\n", offset);
+      const end = newline < 0 ? input.length : newline + 1;
+      if (end - offset > work.limits.maxScalarBytes) throw new MikeError("yq limit exceeded: maxScalarBytes");
+      const line = input.slice(offset, end);
+      if (/^(?:---|\.\.\.)(?:[ \t\r\n]|$)/u.test(line)) documentBytes = 0;
+      documentBytes += utf8ByteLength(line);
+      if (documentBytes > work.limits.maxDocumentBytes) throw new MikeError("yq limit exceeded: maxDocumentBytes");
+      {
+        const t = work.tick(line.length + 1);
+        if (t) await t;
+      }
+      offset = end;
+    }
+  };
+  await admitText(text);
+  const adapted = await adaptQuotedIndent(text, filename, yaml, work);
+  quotedFailures = adapted.failures;
+  if (adapted.text !== text) {
+    await admitText(adapted.text);
+    text = adapted.text;
+    insertions = adapted.insertions;
+  }
+  const lexer = new yaml.Lexer();
+  const parser = new yaml.Parser();
+  const composer = new yaml.Composer({ keepSourceTokens: true, intAsBigInt: true, uniqueKeys: false, merge: false, prettyErrors: false, logLevel: "silent" });
+  let hasDocument = false;
+  let prefix = [];
+  const token = async (item) => {
+    await admitCst(item, work);
+    if (item.type === "document") {
+      hasDocument = true;
+      sources.push({ token: item, prefix });
+      prefix = [];
+    } else if (item.type === "comment" || item.type === "newline") prefix.push(item);
+    for (const doc of composer.next(item)) await accept(doc);
+  };
+  for (let offset = 0; offset <= text.length; offset += 4096) {
+    await work.tick(Math.min(4096, text.length - offset) + 1);
+    const incomplete = offset + 4096 < text.length;
+    for (const lexeme of lexer.lex(text.slice(offset, offset + 4096), incomplete)) {
+      if (utf8ByteLength(lexeme) > work.limits.maxScalarBytes) throw new MikeError("yq limit exceeded: maxScalarBytes");
+      {
+        const t = work.tick();
+        if (t) await t;
+      }
+      work.depth(parser.stack.length);
+      for (const item of parser.next(lexeme)) await token(item);
+    }
+    if (!incomplete) break;
   }
+  for (const item of parser.end()) await token(item);
+  for (const doc of composer.end(documents.length === 0, text.length)) await accept(doc, !hasDocument);
+  return documents;
 }
-async function writeOperation(operation, bytes, owner, callerSignal) {
-  owner.assertOpen(callerSignal);
-  try {
-    await operation.output.write(bytes);
-  } catch (failure) {
-    throw new SinkFailure(failure);
-  }
-  owner.assertOpen(callerSignal);
-}
-async function runCommand(context, owner, inputFormat, limits) {
-  const ledger = new YqLedger(limits);
-  let session;
-  let stdout;
-  let stderr;
-  const stdoutOperation = () => {
-    stdout ??= createOutputOperation({ signal: context.signal, registerCleanup: (cleanup) => owner.register(cleanup) }, context.stdout);
-    return stdout;
+
+// packages/safe-bash-command-yq/src/native-encoder.ts
+init_buffer();
+import { utf8ByteLength as utf8ByteLength2 } from "../safe-bash-query-engine/bytes.js";
+async function encodeNative(candidate, options, yaml, work) {
+  await inspectNode(candidate.node, yaml, work);
+  if (options.indent > work.limits.maxOutputBytes) throw new MikeError("yq limit exceeded: maxOutputBytes");
+  const spacing = Math.max(0, options.indent);
+  const chunks = [];
+  let bytes = 0;
+  const append = (text2) => {
+    const incoming = utf8ByteLength2(text2);
+    if (incoming > work.limits.maxOutputBytes - bytes) throw new MikeError("yq limit exceeded: maxOutputBytes");
+    bytes += incoming;
+    chunks.push(text2);
   };
-  const stderrOperation = () => {
-    stderr ??= createOutputOperation({ signal: context.signal, registerCleanup: (cleanup) => owner.register(cleanup) }, context.stderr);
-    return stderr;
+  const indent = (depth) => {
+    const count = spacing * depth;
+    if (count > work.limits.maxOutputBytes - bytes) throw new MikeError("yq limit exceeded: maxOutputBytes");
+    append(" ".repeat(count));
   };
-  const emitDiagnostic = async (error) => {
-    const preferred = utf8Encoder.encode(diagnostic(error));
-    const fallback = utf8Encoder.encode(diagnosticFallback);
-    const selected = ledger.canAdmitDiagnostic(preferred.byteLength) ? preferred : ledger.canAdmitDiagnostic(fallback.byteLength) ? fallback : void 0;
-    if (!selected) return;
-    ledger.admitDiagnostic(selected.byteLength);
-    session?.ownedWork.admitOutputBytes(selected.byteLength);
-    await writeOperation(stderrOperation(), selected, owner, context.signal);
+  const primitive = (node) => {
+    if (!yaml.isScalar(node) || node.value == null) return "null";
+    if (typeof node.value === "bigint") return node.value.toString();
+    if (typeof node.value === "number" && !Number.isFinite(node.value)) return node.value === Infinity ? ".inf" : node.value === -Infinity ? "-.inf" : ".nan";
+    return String(node.value);
   };
-  try {
-    preflightArguments(context);
-    const info = isInformationForm(context.args);
-    if (context.args.some((argument) => argument === "-h" || argument === "--help" || argument === "--version") && info === void 0) {
-      throw cli("CLI_INFO_COMBINATION");
-    }
-    if (info) {
-      const bytes = utf8Encoder.encode(info === "help" ? help : version);
-      ledger.admitStdout(bytes.byteLength);
-      await writeOperation(stdoutOperation(), bytes, owner, context.signal);
-      return { exitCode: 0 };
-    }
-    const options = parseArguments(context.args, inputFormat);
-    if (utf8ByteLength(options.filter) > yqCaps.maxQuerySourceBytes) throw new YqError("limit", "LIMIT_MAX_QUERY_SOURCE_BYTES", 5);
-    owner.register(async () => session?.close());
-    session = createYqQuerySession({ signal: context.signal, limits });
-    try {
-      session.compileOnce(options.filter);
-    } catch (failure) {
-      if (failure instanceof JqLimitError) throw fromJqLimit(failure);
-      if (failure instanceof JqError) throw new YqError("query", "QUERY_COMPILE_FAILED", 3);
-      throw failure;
-    }
-    const files = options.files.length > 0 ? options.files : ["-"];
-    let emitted = 0;
-    for (const file of files) {
-      const sourceName = file === "-" ? "<stdin>" : file;
-      let frames;
-      try {
-        frames = await sourceFrames(context, owner, session, file, options.inputFormat);
-      } catch (failure) {
-        throw failure instanceof YqError ? withSource(failure, sourceName) : failure;
-      }
-      owner.assertOpen(context.signal);
-      for (const frame of frames) {
-        ledger.admitDocumentBytes(frame.rawBytes);
-        let input;
-        try {
-          input = decodeDocument(frame.bytes, options.inputFormat);
-        } catch (failure) {
-          throw failure instanceof YqError ? withSource(failure, sourceName) : failure;
+  if (options.format === "yaml" && yaml.isScalar(candidate.node) && candidate.node.value === null && (candidate.node.source === "" || candidate.document.filename === "")) {
+    return candidate.document.doc.directives?.docStart && candidate.node === candidate.document.doc.contents ? "---\n" : "\n";
+  }
+  if (options.unwrap && yaml.isScalar(candidate.node)) return `${candidate.node.source ?? primitive(candidate.node)}
+`;
+  if (options.format === "json") {
+    const write = async (current, depth) => {
+      {
+        const t = work.tick();
+        if (t) await t;
+      }
+      work.depth(depth);
+      const base = dereference(current, yaml, work);
+      const node = base.node;
+      if (yaml.isScalar(node)) {
+        if (typeof node.value === "number" && !Number.isFinite(node.value)) {
+          throw new MikeError(`${"json: error calling MarshalJSON for type *yqlib.CandidateNode: ".repeat(depth + 1)}strconv.ParseFloat: parsing ${JSON.stringify(node.source ?? primitive(node))}: invalid syntax`);
         }
-        owner.assertOpen(context.signal);
-        try {
-          const documents = options.inputFormat === "toml" ? [await parseTomlDocument(input, session.ownedWork, ledger, frame.rawBytes)] : parseYamlDocuments(input, session.ownedWork, ledger, frame.rawBytes, frame.lineOffset);
-          for await (const document of documents) {
-            owner.assertOpen(context.signal);
-            try {
-              await session.ownedWork.measure(document);
-            } catch (failure) {
-              if (failure instanceof JqLimitError) throw fromJqLimit(failure);
-              if (failure instanceof YqValueFailure) throw classifyValueFailure(failure);
-              throw failure;
-            }
-            owner.assertOpen(context.signal);
-            const iterator = session.run(document);
-            const firstBatchedResult = emitted + 2;
-            let outBatch;
-            let outBatchUsed = 0;
-            const flushOutBatch = async () => {
-              if (outBatchUsed > 0) {
-                const slice = outBatch.subarray(0, outBatchUsed);
-                outBatchUsed = 0;
-                await writeOperation(stdoutOperation(), slice, owner, context.signal);
-              }
-            };
-            try {
-              while (true) {
-                let next;
-                try {
-                  next = await iterator.next();
-                } catch (failure) {
-                  await flushOutBatch();
-                  if (context.signal.aborted) throw context.signal.reason;
-                  if (failure instanceof JqLimitError) throw fromJqLimit(failure);
-                  if (failure instanceof JqError) throw new YqError("query", "QUERY_RUNTIME_FAILED", 5, sourceName);
-                  throw failure;
-                }
-                owner.assertOpen(context.signal);
-                if (next.done) break;
-                try {
-                  const m = session.ownedWork.measureSync ? session.ownedWork.measureSync(next.value) : session.ownedWork.measure(next.value);
-                  if (m instanceof Promise) await m;
-                } catch (failure) {
-                  await flushOutBatch();
-                  if (failure instanceof JqLimitError) throw fromJqLimit(failure);
-                  if (failure instanceof YqValueFailure) throw classifyValueFailure(failure);
-                  throw failure;
-                }
-                owner.assertOpen(context.signal);
-                session.ownedWork.admitResult();
-                const separator = emitted === 0 || options.format === "json" ? "" : "---\n";
-                const suffixBytes = utf8ByteLength(separator) + 1;
-                const remaining = yqCaps.stdoutCapBytes - ledger.stdoutBytes;
-                if (suffixBytes > remaining) {
-                  await flushOutBatch();
-                  throw new YqError("limit", "LIMIT_MAX_OUTPUT_BYTES", 5, sourceName);
-                }
-                let encoded;
-                try {
-                  if (options.format === "yaml") {
-                    const e = encodeYaml(next.value, session.ownedWork, remaining - suffixBytes);
-                    encoded = e instanceof Promise ? await e : e;
-                  } else if (options.raw && typeof next.value === "string") {
-                    encoded = await encodeRaw(next.value, session.ownedWork, remaining - 1);
-                  } else {
-                    encoded = await encodeJson(next.value, session.ownedWork, !options.compact, remaining - 1);
-                  }
-                } catch (failure) {
-                  await flushOutBatch();
-                  if (failure instanceof JqLimitError) throw fromJqLimit(failure);
-                  if (failure instanceof YqValueFailure) throw classifyValueFailure(failure);
-                  throw failure;
-                }
-                owner.assertOpen(context.signal);
-                const encodedBytes = utf8ByteLength(encoded);
-                const outputBytes = encodedBytes + suffixBytes;
-                try {
-                  ledger.admitStdout(outputBytes);
-                  session.ownedWork.admitOutputBytes(outputBytes);
-                } catch (failure) {
-                  await flushOutBatch();
-                  throw failure;
-                }
-                owner.assertOpen(context.signal);
-                if (emitted < firstBatchedResult || outputBytes >= 8192) {
-                  await flushOutBatch();
-                  const output = new Uint8Array(outputBytes);
-                  let offset = 0;
-                  if (separator !== "") offset += utf8Encoder.encodeInto(separator, output).written;
-                  offset += utf8Encoder.encodeInto(encoded, output.subarray(offset)).written;
-                  output[offset] = 10;
-                  owner.assertOpen(context.signal);
-                  await writeOperation(stdoutOperation(), output, owner, context.signal);
-                } else {
-                  const batch = outBatch ??= new Uint8Array(16384);
-                  if (outBatchUsed + outputBytes > batch.byteLength) await flushOutBatch();
-                  if (separator !== "") outBatchUsed += utf8Encoder.encodeInto(separator, batch.subarray(outBatchUsed)).written;
-                  outBatchUsed += utf8Encoder.encodeInto(encoded, batch.subarray(outBatchUsed)).written;
-                  batch[outBatchUsed++] = 10;
-                }
-                emitted++;
-              }
-              await flushOutBatch();
-            } finally {
-              outBatchUsed = 0;
-              await iterator.return(void 0);
-              owner.assertOpen(context.signal);
-            }
-          }
-        } catch (failure) {
-          throw failure instanceof YqError ? withSource(failure, sourceName) : failure;
+        const custom = node.tag && !node.tag.startsWith("tag:yaml.org,2002:") && typeof node.value === "string" && /^(?:true|false|null|[+-]?[0-9]+(?:\.[0-9]+)?)$/u.test(node.value);
+        const typed = node.tag === "tag:yaml.org,2002:int" || node.tag === "tag:yaml.org,2002:float" || node.tag === "tag:yaml.org,2002:bool" || node.tag === "tag:yaml.org,2002:null";
+        if (typeof node.value === "string" && (custom || typed)) {
+          const text2 = node.value;
+          if (/^[+-]?[0-9]+$/u.test(text2)) append(BigInt(text2).toString());
+          else if (/^[+-]?[0-9]+\.[0-9]+$/u.test(text2)) append(JSON.stringify(Number(text2)));
+          else if (["true", "false", "null"].includes(text2)) append(text2);
+          else throw new MikeError(`cannot encode ${node.tag} value as JSON`);
+        } else if (typeof node.value === "number" && node.tag === "tag:yaml.org,2002:float" && node.source && /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?$/u.test(node.source)) append(node.source);
+        else append(typeof node.value === "string" ? JSON.stringify(node.value) : primitive(node));
+        return;
+      }
+      if (yaml.isAlias(node)) throw new MikeError("cyclic YAML alias");
+      const map = yaml.isMap(node);
+      append(map ? "{" : "[");
+      const items = node.items;
+      for (let index = 0; index < items.length; index++) {
+        if (index) append(",");
+        if (spacing) {
+          append("\n");
+          indent(depth + 1);
         }
+        let child;
+        if (map) {
+          const pair = node.items[index];
+          if (!yaml.isScalar(pair.key)) throw new MikeError("cannot encode complex YAML key as JSON");
+          append(JSON.stringify(String(pair.key.value)));
+          append(spacing ? ": " : ":");
+          child = pair.value;
+        } else child = items[index];
+        await write({ node: child, document: current.document }, depth + 1);
+      }
+      if (items.length && spacing) {
+        append("\n");
+        indent(depth);
       }
+      append(map ? "}" : "]");
+    };
+    await write(candidate, 0);
+    append("\n");
+    return chunks.join("");
+  }
+  if (options.indent < 0) throw new MikeError("indent must not be negative");
+  const pending = [{ node: candidate.node, depth: 0 }];
+  let projected = 0;
+  while (pending.length) {
+    const { node, depth } = pending.pop();
+    {
+      const t = work.tick();
+      if (t) await t;
     }
-    return { exitCode: 0 };
-  } catch (failure) {
-    if (context.signal.aborted) throw context.signal.reason;
-    if (failure instanceof SinkFailure) throw failure.reason;
-    let normal;
-    if (failure instanceof YqError) normal = failure;
-    else if (failure instanceof JqLimitError) normal = fromJqLimit(failure);
-    else if (failure instanceof YqValueFailure) normal = classifyValueFailure(failure);
-    if (!normal) throw failure;
-    await emitDiagnostic(normal);
-    return { exitCode: normal.status };
-  }
-}
-async function execute(context, inputFormat, limits) {
-  const owner = new InvocationOwner();
-  context.registerCleanup?.(() => owner.close());
-  let result;
-  let primary;
-  let hasPrimary = false;
-  try {
-    result = await runCommand(context, owner, inputFormat, limits);
-  } catch (failure) {
-    primary = failure;
-    hasPrimary = true;
+    projected += 32 + depth * Math.max(options.indent, 2) + 6 * utf8ByteLength2(node.comment ?? "") + 6 * utf8ByteLength2(node.commentBefore ?? "");
+    if (yaml.isScalar(node)) projected += 6 * utf8ByteLength2(String(node.value));
+    else if (yaml.isMap(node)) for (const pair of node.items) {
+      if (yaml.isScalar(pair.key) && pair.key.value === "<<" && pair.key.type === "PLAIN") pair.key.tag = "tag:yaml.org,2002:merge";
+      pending.push({ node: pair.key, depth: depth + 1 }, { node: pair.value, depth: depth + 1 });
+    }
+    else if (yaml.isSeq(node)) for (const child of node.items) pending.push({ node: child, depth: depth + 1 });
+    if (projected > mikeLimits.maxOutputBytes) throw new MikeError("yq limit exceeded: maxOutputBytes");
   }
-  let cleanup;
-  let hasCleanup = false;
-  try {
-    await owner.close();
-  } catch (failure) {
-    cleanup = failure;
-    hasCleanup = true;
-  }
-  if (context.signal.aborted) throw context.signal.reason;
-  if (hasPrimary) throw primary;
-  if (hasCleanup) throw cleanup;
-  return result;
-}
-function admittedOptions(options) {
-  if (typeof options !== "object" || options === null) throw new TypeError("options must be an object");
-  if (Object.keys(options).some((key) => key !== "replace" && key !== "inputFormat" && key !== "limits")) throw new TypeError("unsupported yq option");
-  const { replace = false, inputFormat = "yaml" } = options;
-  if (typeof replace !== "boolean") throw new TypeError("replace must be a boolean");
-  if (inputFormat !== "yaml" && inputFormat !== "toml") throw new TypeError("inputFormat must be yaml or toml");
-  return { replace, inputFormat, limits: resolveYqLimits(options.limits) };
-}
-function createYqCommand(options = {}) {
-  const { inputFormat, limits } = admittedOptions(options);
-  return Object.freeze({
-    name: "yq",
-    runtimeIdentity: commandRuntimeIdentity,
-    description: "Bounded restricted YAML/TOML query and formatter",
-    execute: (context) => execute(context, inputFormat, limits)
+  work.assertOpen();
+  const doc = new yaml.Document();
+  doc.schema.tags = doc.schema.tags.map((tag) => {
+    if (!tag.stringify) return tag;
+    const original = tag.stringify;
+    const stringify = (item, context, onComment, onChompKeep) => {
+      const node = item;
+      if (yaml.isScalar(node) && typeof node.value !== "string" && node.source) return node.source;
+      return yaml.isCollection(node) ? node.toString(context, onComment, onChompKeep) : original(item, context, onComment, onChompKeep);
+    };
+    return { ...tag, stringify };
   });
+  doc.contents = await cloneNode(candidate.node, yaml, work);
+  const formatting = [doc.contents];
+  while (formatting.length) {
+    const node = formatting.pop();
+    {
+      const t = work.tick();
+      if (t) await t;
+    }
+    if (work.implicitTags.has(node) && node.tag?.startsWith("tag:yaml.org,2002:")) delete node.tag;
+    if (options.prettyPrint) {
+      if (yaml.isScalar(node)) node.type = "PLAIN";
+      else if (yaml.isCollection(node)) node.flow = false;
+    }
+    if (yaml.isScalar(node) && (node.type === "QUOTE_DOUBLE" || node.type === "QUOTE_SINGLE")) node.value = node.source ?? String(node.value);
+    else if (yaml.isMap(node)) for (const pair of node.items) {
+      if (yaml.isNode(pair.key)) formatting.push(pair.key);
+      if (yaml.isNode(pair.value)) formatting.push(pair.value);
+    }
+    else if (yaml.isSeq(node)) {
+      for (const child of node.items) if (yaml.isNode(child)) formatting.push(child);
+    }
+  }
+  if (candidate.node === candidate.document.doc.contents) {
+    if (options.preserveDocumentStart && doc.directives) doc.directives.docStart = candidate.document.doc.directives?.docStart ?? null;
+    if (!options.preserveDocumentStart && candidate.document.doc.directives?.docStart && candidate.document.doc.commentBefore != null) {
+      doc.contents.commentBefore = candidate.document.doc.commentBefore + (doc.contents.commentBefore ?? "");
+    } else doc.commentBefore = candidate.document.doc.commentBefore;
+    doc.comment = candidate.document.doc.comment;
+  }
+  const text = doc.toString({ indent: options.indent === 0 ? 4 : Math.max(2, options.indent), indentSeq: !options.compactSequence, flowCollectionPadding: false, lineWidth: 0, verifyAliasOrder: false });
+  append(text);
+  return chunks.join("");
 }
-function createYqCommands(options = {}) {
-  return Object.freeze([createYqCommand(options)]);
+
+// packages/safe-bash-command-yq/src/formats.ts
+import { Decimal, numberText } from "../safe-bash-query-engine/numbers.js";
+function mapping(value2) {
+  return value2 !== null && typeof value2 === "object" && !Array.isArray(value2);
 }
-function yqCommands(options = {}) {
-  const captured = admittedOptions(options);
-  const { replace } = captured;
-  const definitions = createYqCommands(captured);
-  const plugin = {
-    name: "yq-commands",
-    setup(host) {
-      if (!replace) for (const definition of definitions) {
-        if (host.commands.has(definition.name)) throw new Error(`Command already registered: ${definition.name}`);
+async function properties(text, work) {
+  let nodes = 0;
+  const admit = (count) => {
+    if (count > work.limits.maxParserNodes - nodes) throw new MikeError("yq limit exceeded: maxParserNodes");
+    work.node(count);
+    nodes += count;
+  };
+  admit(1);
+  const result = /* @__PURE__ */ Object.create(null);
+  let offset = 0;
+  while (offset < text.length) {
+    const newline = text.indexOf("\n", offset);
+    const end = newline < 0 ? text.length : newline;
+    const line = text.slice(offset, end).trim();
+    offset = end + 1;
+    {
+      const t = work.tick(line.length + 1);
+      if (t) await t;
+    }
+    if (!line || line.startsWith("#") || line.startsWith(";") || line.startsWith("!")) continue;
+    let equal = line.indexOf("=");
+    if (equal < 0) equal = line.indexOf(":");
+    if (equal < 0) throw new MikeError("invalid props entry");
+    const key = line.slice(0, equal).trim();
+    let depth = 1;
+    work.depth(depth);
+    if (1 + 2 * depth > work.limits.maxParserNodes) throw new MikeError("yq limit exceeded: maxParserNodes");
+    for (let index = 0; index < key.length; index++) {
+      {
+        const t = work.tick();
+        if (t) await t;
+      }
+      if (key[index] !== ".") continue;
+      work.depth(++depth);
+      if (1 + 2 * depth > work.limits.maxParserNodes) throw new MikeError("yq limit exceeded: maxParserNodes");
+    }
+    let target = result;
+    let start = 0;
+    while (true) {
+      {
+        const t = work.tick();
+        if (t) await t;
+      }
+      const dot = key.indexOf(".", start);
+      const component = key.slice(start, dot < 0 ? key.length : dot);
+      if (dot < 0) {
+        admit(Object.hasOwn(target, component) ? 1 : 2);
+        target[component] = line.slice(equal + 1).trim();
+        break;
       }
-      for (const definition of definitions) host.commands.register(definition, { replace: replace ?? false });
+      if (!mapping(target[component] ?? null)) {
+        admit(Object.hasOwn(target, component) ? 1 : 2);
+        target[component] = /* @__PURE__ */ Object.create(null);
+      }
+      target = target[component];
+      start = dot + 1;
     }
+  }
+  return result;
+}
+async function table(text, delimiter, yaml, work) {
+  const rows = [];
+  let row = [], field = "", quoted = false, closed = false;
+  const cell = () => {
+    if (utf8ByteLength3(field) > work.limits.maxScalarBytes) throw new MikeError("yq limit exceeded: maxScalarBytes");
+    row.push(field);
+    field = "";
+    closed = false;
   };
-  return Object.freeze(plugin);
+  for (let index = 0; index < text.length; index++) {
+    {
+      const t = work.tick();
+      if (t) await t;
+    }
+    const char = text[index];
+    if (quoted) {
+      if (char === '"') {
+        if (text[index + 1] === '"') {
+          field += '"';
+          index++;
+        } else {
+          quoted = false;
+          closed = true;
+        }
+      } else field += char;
+    } else if (char === '"' && field === "" && !closed) quoted = true;
+    else if (char === delimiter) cell();
+    else if (char === "\n" || char === "\r") {
+      cell();
+      rows.push(row);
+      row = [];
+      if (char === "\r" && text[index + 1] === "\n") index++;
+    } else {
+      if (closed || char === '"') throw new MikeError("invalid delimited input");
+      field += char;
+    }
+    if (rows.length + row.length > work.limits.maxParserNodes) throw new MikeError("yq limit exceeded: maxParserNodes");
+  }
+  if (quoted) throw new MikeError("unterminated quoted field");
+  if (field || row.length || closed) {
+    cell();
+    rows.push(row);
+  }
+  const headers = rows.shift() ?? [];
+  const result = [];
+  for (const cells of rows) {
+    {
+      const t = work.tick();
+      if (t) await t;
+    }
+    if (cells.length !== headers.length) throw new MikeError("wrong number of fields");
+    const item = /* @__PURE__ */ Object.create(null);
+    for (let index = 0; index < cells.length; index++) {
+      const parsed = yaml.parseDocument(cells[index], { schema: "core" });
+      item[headers[index]] = !parsed.errors.length && yaml.isScalar(parsed.contents) && typeof parsed.contents.value !== "string" ? parsed.contents.value : cells[index];
+    }
+    result.push(item);
+  }
+  return result;
+}
+async function xmlValue(element, work, depth = 0) {
+  {
+    const t = work.tick();
+    if (t) await t;
+  }
+  work.depth(depth);
+  const result = /* @__PURE__ */ Object.create(null);
+  for (const attribute of element.attributes) result[`+@${attribute.name}`] = attribute.value;
+  for (const child of element.children) {
+    const value2 = await xmlValue(child, work, depth + 1);
+    if (Object.hasOwn(result, child.name)) {
+      const previous = result[child.name];
+      result[child.name] = Array.isArray(previous) ? [...previous, value2] : [previous, value2];
+    } else result[child.name] = value2;
+  }
+  const text = element.text.trim();
+  if (!Object.keys(result).length) return text;
+  if (text) result["+content"] = text;
+  return result;
+}
+async function decodeFormat(text, filename, fileIndex, format, yaml, work, accept) {
+  if (format === "yaml" || format === "json") {
+    await decodeDocuments(text, filename, fileIndex, format, yaml, work, accept);
+    return;
+  }
+  if (utf8ByteLength3(text) > work.limits.maxDocumentBytes) throw new MikeError("yq limit exceeded: maxDocumentBytes");
+  let value2;
+  try {
+    if (format === "csv" || format === "tsv") value2 = await table(text, format === "csv" ? "," : "	", yaml, work);
+    else if (format === "base64") {
+      const clean = text.split("\n").join("").split("\r").join("");
+      let data;
+      try {
+        data = decodeBase64(clean);
+      } catch {
+        throw new MikeError("invalid base64 input");
+      }
+      if (encodeBase64(data) !== clean) throw new MikeError("invalid base64 input");
+      value2 = new TextDecoder("utf-8", { fatal: true }).decode(data);
+    } else if (format === "uri") value2 = decodeURIComponent(text.split("+").join(" "));
+    else if (format === "xml") {
+      const parser = parseXmlSteps(text, { maxDepth: work.limits.maxDepth, maxNodes: work.limits.maxParserNodes, maxTextLength: work.limits.maxScalarBytes });
+      let step = parser.next();
+      while (!step.done) {
+        {
+          const t = work.tick(step.value);
+          if (t) await t;
+        }
+        step = parser.next();
+      }
+      value2 = { [step.value.name]: await xmlValue(step.value, work) };
+    } else if (format === "toml") {
+      const parsed = await parseTomlDocument(text, { charge: async (units) => {
+        const t = work.tick(units);
+        if (t) await t;
+      }, assertOpen: () => work.assertOpen() }, new YqLedger(), utf8ByteLength3(text));
+      const convert = (item) => {
+        if (item instanceof Decimal) return Number(numberText(item));
+        if (Array.isArray(item)) return item.map(convert);
+        if (item && typeof item === "object") return Object.fromEntries(Object.entries(item).map(([key, child]) => [key, convert(child)]));
+        return item;
+      };
+      value2 = convert(parsed);
+    } else if (format === "props") value2 = await properties(text, work);
+    else if (format === "ini") {
+      value2 = /* @__PURE__ */ Object.create(null);
+      let section = value2;
+      for (const source of text.split("\n")) {
+        {
+          const t = work.tick(source.length + 1);
+          if (t) await t;
+        }
+        const line = source.trim();
+        if (!line || line.startsWith("#") || line.startsWith(";") || line.startsWith("!")) continue;
+        if (line.startsWith("[") && line.endsWith("]")) {
+          const name = line.slice(1, -1);
+          section = /* @__PURE__ */ Object.create(null);
+          value2[name] = section;
+          continue;
+        }
+        let equal = line.indexOf("=");
+        if (equal < 0) equal = line.indexOf(":");
+        if (equal < 0) throw new MikeError(`invalid ${format} entry`);
+        section[line.slice(0, equal).trim()] = line.slice(equal + 1).trim();
+      }
+    } else throw new MikeError(`format '${format}' does not support decoding`);
+  } catch (error) {
+    if (error instanceof MikeError) throw error;
+    throw new MikeError(`bad ${format} input: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  await decodeDocuments(JSON.stringify(value2), filename, fileIndex, "json", yaml, work, accept);
+}
+async function encodeFormat(candidate, format, yaml, work) {
+  const encoded = await encodeNative(candidate, { format: "json", indent: 0, unwrap: false, compactSequence: false }, yaml, work);
+  const value2 = JSON.parse(encoded);
+  const chunks = [];
+  let size = 0;
+  const append = (text) => {
+    const bytes = utf8ByteLength3(text);
+    if (bytes > work.limits.maxOutputBytes - size) throw new MikeError("yq limit exceeded: maxOutputBytes");
+    size += bytes;
+    chunks.push(text);
+  };
+  const primitive = (item) => item === null ? "" : typeof item === "object" ? JSON.stringify(item) : String(item);
+  if (format === "base64" || format === "uri") {
+    if (typeof value2 !== "string") throw new MikeError(`${format} encoding requires a string`);
+    append(format === "base64" ? encodeBase64(utf8Encoder2.encode(value2)) : encodeURIComponent(value2).split("%20").join("+").split("!").join("%21").split("'").join("%27").split("(").join("%28").split(")").join("%29").split("*").join("%2A"));
+  } else if (format === "csv" || format === "tsv") {
+    if (!Array.isArray(value2)) throw new MikeError("CSV/TSV encoding requires an array");
+    const delimiter = format === "csv" ? "," : "	";
+    const headers = mapping(value2[0] ?? null) ? Object.keys(value2[0]) : void 0;
+    const row = (cells) => {
+      append(cells.map((item) => {
+        const text = primitive(item);
+        return text.includes(delimiter) || text.includes('"') || text.includes("\n") || text.includes("\r") ? '"' + text.split('"').join('""') + '"' : text;
+      }).join(delimiter) + "\n");
+    };
+    if (headers) row(headers);
+    for (const item of value2) {
+      {
+        const t = work.tick();
+        if (t) await t;
+      }
+      if (headers && mapping(item)) row(headers.map((key) => item[key] ?? null));
+      else if (Array.isArray(item)) row(item);
+      else throw new MikeError("CSV/TSV rows must be arrays or maps");
+    }
+  } else if (format === "lua") {
+    const write = async (item, depth) => {
+      {
+        const t = work.tick();
+        if (t) await t;
+      }
+      work.depth(depth);
+      if (item === null) {
+        append("nil");
+        return;
+      }
+      if (typeof item !== "object") {
+        append(JSON.stringify(item));
+        return;
+      }
+      append("{\n");
+      for (const [key, child] of Object.entries(item)) {
+        append("	".repeat(depth + 1));
+        if (!Array.isArray(item)) append(`[${JSON.stringify(key)}] = `);
+        await write(child, depth + 1);
+        append(";\n");
+      }
+      append("	".repeat(depth) + "}");
+    };
+    append("return ");
+    await write(value2, 0);
+    append(";\n");
+  } else if (format === "xml") {
+    const escape = (text) => text.split("&").join("&amp;").split("<").join("&lt;").split(">").join("&gt;").split('"').join("&quot;");
+    const write = async (name, item, depth) => {
+      {
+        const t = work.tick();
+        if (t) await t;
+      }
+      work.depth(depth);
+      if (!name || Array.from(name).some((char) => ` <>/	\r
+="'`.includes(char))) throw new MikeError("invalid XML element name");
+      if (Array.isArray(item)) {
+        for (const child of item) await write(name, child, depth);
+        return;
+      }
+      append(`<${name}`);
+      if (mapping(item)) {
+        for (const [key, child] of Object.entries(item)) if (key.startsWith("+@")) append(` ${key.slice(2)}="${escape(primitive(child))}"`);
+      }
+      append(">");
+      if (mapping(item)) {
+        const children = Object.entries(item).filter(([key]) => !key.startsWith("+@") && key !== "+content");
+        if (children.length) append("\n");
+        for (const [key, child] of children) {
+          append(" ".repeat((depth + 1) * 2));
+          await write(key, child, depth + 1);
+        }
+        if (item["+content"] !== void 0) append(escape(primitive(item["+content"])));
+        if (children.length) append(" ".repeat(depth * 2));
+      } else append(escape(primitive(item)));
+      append(`</${name}>
+`);
+    };
+    if (!mapping(value2)) throw new MikeError("XML encoding requires a map");
+    for (const [key, item] of Object.entries(value2)) await write(key, item, 0);
+  } else {
+    if (!mapping(value2)) throw new MikeError(`${format} encoding requires a map`);
+    const flattened = [];
+    const flatten = async (item, path, depth) => {
+      {
+        const t = work.tick();
+        if (t) await t;
+      }
+      work.depth(depth);
+      if (item !== null && typeof item === "object") {
+        for (const [key, child] of Object.entries(item)) await flatten(child, [...path, key], depth + 1);
+      } else flattened.push([path.join(format === "shell" ? "_" : "."), item]);
+    };
+    if (format === "toml" || format === "ini") {
+      const tomlKey = (key) => key && Array.from(key).every((char) => char >= "a" && char <= "z" || char >= "A" && char <= "Z" || char >= "0" && char <= "9" || "_-".includes(char)) ? key : JSON.stringify(key);
+      const tomlValue = async (item, depth) => {
+        {
+          const t = work.tick();
+          if (t) await t;
+        }
+        work.depth(depth);
+        if (item === null) throw new MikeError("TOML cannot encode null");
+        if (Array.isArray(item)) {
+          const items = [];
+          for (const child of item) items.push(await tomlValue(child, depth + 1));
+          return `[${items.join(", ")}]`;
+        }
+        if (mapping(item)) {
+          const entries = [];
+          for (const [key, child] of Object.entries(item)) entries.push(`${tomlKey(key)} = ${await tomlValue(child, depth + 1)}`);
+          return `{ ${entries.join(", ")} }`;
+        }
+        return JSON.stringify(item);
+      };
+      const write = async (item, path, depth) => {
+        {
+          const t = work.tick();
+          if (t) await t;
+        }
+        work.depth(depth);
+        const leaves = Object.entries(item).filter(([, child]) => !mapping(child));
+        const width = Math.max(0, ...leaves.map(([key]) => key.length));
+        if (path.length) append(`[${path.map((key) => format === "toml" ? tomlKey(key) : key).join(".")}]
+`);
+        for (const [key, child] of leaves) append(`${format === "toml" ? tomlKey(key) : key}${format === "ini" ? " ".repeat(width - key.length) : ""} = ${format === "toml" ? await tomlValue(child, depth + 1) : primitive(child)}
+`);
+        for (const [key, child] of Object.entries(item)) if (mapping(child)) {
+          append("\n");
+          await write(child, [...path, key], depth + 1);
+        }
+      };
+      await write(value2, [], 0);
+    } else {
+      await flatten(value2, [], 0);
+      for (const [key, item] of flattened) {
+        if (format === "shell") {
+          if (!key || Array.from(key).some((char, index) => !(char >= "a" && char <= "z" || char >= "A" && char <= "Z" || char === "_" || index > 0 && char >= "0" && char <= "9"))) throw new MikeError("invalid shell variable name");
+          const text = primitive(item);
+          const safe = text && Array.from(text).every((char) => char >= "a" && char <= "z" || char >= "A" && char <= "Z" || char >= "0" && char <= "9" || "_./-".includes(char));
+          append(`${key}=${safe ? text : "'" + text.split("'").join("'\\''") + "'"}
+`);
+        } else append(`${key} = ${primitive(item)}
+`);
+      }
+    }
+  }
+  return chunks.join("");
+}
+
+// packages/safe-bash-command-yq/src/mike.ts
+import { commandRuntimeIdentity, FsError } from "../safe-bash-contracts/index.js";
+
+// packages/safe-bash-command-yq/src/arguments.ts
+init_buffer();
+import { getCommandArguments } from "../safe-bash-contracts/index.js";
+var mikeEvalHelp = `yq is a portable command-line data file processor (https://github.com/mikefarah/yq/) 
+See https://mikefarah.gitbook.io/yq/ for detailed documentation and examples.
+
+## Evaluate Sequence ##
+This command iterates over each yaml document from each given file, applies the 
+expression and prints the result in sequence.
+
+Usage:
+  yq eval [expression] [yaml_file1]... [flags]
+
+Aliases:
+  eval, e
+
+Examples:
+
+# Reads field under the given path for each file
+yq e '.a.b' f1.yml f2.yml 
+
+# Prints out the file
+yq e sample.yaml 
+
+# Pipe from STDIN
+## use '-' as a filename to pipe from STDIN
+cat file2.yml | yq e '.a.b' file1.yml - file3.yml
+
+# Creates a new yaml document
+## Note that editing an empty file does not work.
+yq e -n '.a.b.c = "cat"' 
+
+# Update a file in place
+yq e '.a.b = "cool"' -i file.yaml 
+
+
+Flags:
+  -h, --help   help for eval
+
+Global Flags:
+  -C, --colors                            force print with colors
+      --csv-auto-parse                    parse CSV YAML/JSON values (default true)
+      --csv-separator char                CSV Separator character (default ,)
+      --debug-node-info                   debug node info
+  -e, --exit-status                       set exit status if there are no matches or null or false is returned
+      --expression string                 forcibly set the expression argument. Useful when yq argument detection thinks your expression is a file.
+      --from-file string                  Load expression from specified file.
+  -f, --front-matter string               (extract|process) first input as yaml front-matter. Extract will pull out the yaml content, process will run the expression against the yaml content, leaving the remaining data intact
+      --header-preprocess                 Slurp any header comments and separators before processing expression. (default true)
+  -I, --indent int                        sets indent level for output (default 2)
+      --ini-preserve-quotes               preserve surrounding quotes on INI values during round-trip
+  -i, --inplace                           update the file in place of first file given.
+  -p, --input-format string               [auto|a|yaml|y|kyaml|ky|json|j|props|p|csv|c|tsv|t|xml|x|base64|uri|toml|hcl|h|lua|l|ini|i] parse format for input. (default "auto")
+      --lua-globals                       output keys as top-level global variables
+      --lua-prefix string                 prefix (default "return ")
+      --lua-suffix string                 suffix (default ";\\n")
+      --lua-unquoted                      output unquoted string keys (e.g. {foo="bar"})
+  -M, --no-colors                         force print with no colors
+  -N, --no-doc                            Don't print document separators (---)
+  -0, --nul-output                        Use NUL char to separate values. If unwrap scalar is also set, fail if unwrapped scalar contains NUL char.
+  -n, --null-input                        Don't read input, simply evaluate the expression given. Useful for creating docs from scratch.
+  -o, --output-format string              [auto|a|yaml|y|kyaml|ky|json|j|props|p|csv|c|tsv|t|xml|x|base64|uri|toml|hcl|h|shell|s|lua|l|ini|i] output format type. (default "auto")
+  -P, --prettyPrint                       pretty print, shorthand for '... style = ""'
+      --properties-array-brackets         use [x] in array paths (e.g. for SpringBoot)
+      --properties-separator string       separator to use between keys and values (default " = ")
+      --security-disable-env-ops          Disable env related operations.
+      --security-disable-file-ops         Disable file related operations (e.g. load)
+      --security-enable-system-operator   Enable system operator to allow execution of external commands.
+      --shell-key-separator string        separator for shell variable key paths (default "_")
+  -s, --split-exp string                  print each result (or doc) into a file named (exp). [exp] argument must return a string. You can use $index in the expression as the result counter. The necessary directories will be created.
+      --split-exp-file string             Use a file to specify the split-exp expression.
+      --string-interpolation              Toggles strings interpolation of \\(exp) (default true)
+      --tsv-auto-parse                    parse TSV YAML/JSON values (default true)
+  -r, --unwrapScalar                      unwrap scalar, print the value with no quotes, colours or comments. Defaults to true for yaml (default true)
+  -v, --verbose                           verbose mode
+      --xml-attribute-prefix string       prefix for xml attributes (default "+@")
+      --xml-content-name string           name for xml content (if no attribute name is present). (default "+content")
+      --xml-directive-name string         name for xml directives (e.g. <!DOCTYPE thing cat>) (default "+directive")
+      --xml-keep-namespace                enables keeping namespace after parsing attributes (default true)
+      --xml-proc-inst-prefix string       prefix for xml processing instructions (e.g. <?xml version="1"?>) (default "+p_")
+      --xml-raw-token                     enables using RawToken method instead Token. Commonly disables namespace translations. See https://pkg.go.dev/encoding/xml#Decoder.RawToken for details. (default true)
+      --xml-skip-directives               skip over directives (e.g. <!DOCTYPE thing cat>)
+      --xml-skip-proc-inst                skip over process instructions (e.g. <?xml version="1"?>)
+      --xml-strict-mode                   enables strict parsing of XML. See https://pkg.go.dev/encoding/xml for more details.
+  -c, --yaml-compact-seq-indent           Use compact sequence indentation where '- ' is considered part of the indentation.
+      --yaml-fix-merge-anchor-to-spec     Fix merge anchor to match YAML spec. Will default to true in late 2025
+`;
+var mikeAllHelp = `yq is a portable command-line data file processor (https://github.com/mikefarah/yq/) 
+See https://mikefarah.gitbook.io/yq/ for detailed documentation and examples.
+
+## Evaluate All ##
+This command loads _all_ yaml documents of _all_ yaml files and runs expression once
+Useful when you need to run an expression across several yaml documents or files (like merge).
+Note that it consumes more memory than eval.
+
+Usage:
+  yq eval-all [expression] [yaml_file1]... [flags]
+
+Aliases:
+  eval-all, ea
+
+Examples:
+
+# Merge f2.yml into f1.yml (in place)
+yq eval-all --inplace 'select(fileIndex == 0) * select(fileIndex == 1)' f1.yml f2.yml
+## the same command and expression using shortened names:
+yq ea -i 'select(fi == 0) * select(fi == 1)' f1.yml f2.yml
+
+
+# Merge all given files
+yq ea '. as $item ireduce ({}; . * $item )' file1.yml file2.yml ...
+
+# Pipe from STDIN
+## use '-' as a filename to pipe from STDIN
+cat file2.yml | yq ea '.a.b' file1.yml - file3.yml
+
+
+Flags:
+  -h, --help   help for eval-all
+
+Global Flags:
+  -C, --colors                            force print with colors
+      --csv-auto-parse                    parse CSV YAML/JSON values (default true)
+      --csv-separator char                CSV Separator character (default ,)
+      --debug-node-info                   debug node info
+  -e, --exit-status                       set exit status if there are no matches or null or false is returned
+      --expression string                 forcibly set the expression argument. Useful when yq argument detection thinks your expression is a file.
+      --from-file string                  Load expression from specified file.
+  -f, --front-matter string               (extract|process) first input as yaml front-matter. Extract will pull out the yaml content, process will run the expression against the yaml content, leaving the remaining data intact
+      --header-preprocess                 Slurp any header comments and separators before processing expression. (default true)
+  -I, --indent int                        sets indent level for output (default 2)
+      --ini-preserve-quotes               preserve surrounding quotes on INI values during round-trip
+  -i, --inplace                           update the file in place of first file given.
+  -p, --input-format string               [auto|a|yaml|y|kyaml|ky|json|j|props|p|csv|c|tsv|t|xml|x|base64|uri|toml|hcl|h|lua|l|ini|i] parse format for input. (default "auto")
+      --lua-globals                       output keys as top-level global variables
+      --lua-prefix string                 prefix (default "return ")
+      --lua-suffix string                 suffix (default ";\\n")
+      --lua-unquoted                      output unquoted string keys (e.g. {foo="bar"})
+  -M, --no-colors                         force print with no colors
+  -N, --no-doc                            Don't print document separators (---)
+  -0, --nul-output                        Use NUL char to separate values. If unwrap scalar is also set, fail if unwrapped scalar contains NUL char.
+  -n, --null-input                        Don't read input, simply evaluate the expression given. Useful for creating docs from scratch.
+  -o, --output-format string              [auto|a|yaml|y|kyaml|ky|json|j|props|p|csv|c|tsv|t|xml|x|base64|uri|toml|hcl|h|shell|s|lua|l|ini|i] output format type. (default "auto")
+  -P, --prettyPrint                       pretty print, shorthand for '... style = ""'
+      --properties-array-brackets         use [x] in array paths (e.g. for SpringBoot)
+      --properties-separator string       separator to use between keys and values (default " = ")
+      --security-disable-env-ops          Disable env related operations.
+      --security-disable-file-ops         Disable file related operations (e.g. load)
+      --security-enable-system-operator   Enable system operator to allow execution of external commands.
+      --shell-key-separator string        separator for shell variable key paths (default "_")
+  -s, --split-exp string                  print each result (or doc) into a file named (exp). [exp] argument must return a string. You can use $index in the expression as the result counter. The necessary directories will be created.
+      --split-exp-file string             Use a file to specify the split-exp expression.
+      --string-interpolation              Toggles strings interpolation of \\(exp) (default true)
+      --tsv-auto-parse                    parse TSV YAML/JSON values (default true)
+  -r, --unwrapScalar                      unwrap scalar, print the value with no quotes, colours or comments. Defaults to true for yaml (default true)
+  -v, --verbose                           verbose mode
+      --xml-attribute-prefix string       prefix for xml attributes (default "+@")
+      --xml-content-name string           name for xml content (if no attribute name is present). (default "+content")
+      --xml-directive-name string         name for xml directives (e.g. <!DOCTYPE thing cat>) (default "+directive")
+      --xml-keep-namespace                enables keeping namespace after parsing attributes (default true)
+      --xml-proc-inst-prefix string       prefix for xml processing instructions (e.g. <?xml version="1"?>) (default "+p_")
+      --xml-raw-token                     enables using RawToken method instead Token. Commonly disables namespace translations. See https://pkg.go.dev/encoding/xml#Decoder.RawToken for details. (default true)
+      --xml-skip-directives               skip over directives (e.g. <!DOCTYPE thing cat>)
+      --xml-skip-proc-inst                skip over process instructions (e.g. <?xml version="1"?>)
+      --xml-strict-mode                   enables strict parsing of XML. See https://pkg.go.dev/encoding/xml for more details.
+  -c, --yaml-compact-seq-indent           Use compact sequence indentation where '- ' is considered part of the indentation.
+      --yaml-fix-merge-anchor-to-spec     Fix merge anchor to match YAML spec. Will default to true in late 2025
+`;
+var mikeHelp = `yq is a portable command-line data file processor (https://github.com/mikefarah/yq/) 
+See https://mikefarah.gitbook.io/yq/ for detailed documentation and examples.
+
+Usage:
+  yq [flags]
+  yq [command]
+
+Examples:
+
+# yq tries to auto-detect the file format based off the extension, and defaults to YAML if it's unknown (or piping through STDIN)
+# Use the '-p/--input-format' flag to specify a format type.
+cat file.xml | yq -p xml
+
+# read the "stuff" node from "myfile.yml"
+yq '.stuff' < myfile.yml
+
+# update myfile.yml in place
+yq -i '.stuff = "foo"' myfile.yml
+
+# print contents of sample.json as idiomatic YAML
+yq -P -oy sample.json
+
+
+Available Commands:
+  completion  Generate the autocompletion script for the specified shell
+  eval        (default) Apply the expression to each document in each yaml file in sequence
+  eval-all    Loads _all_ yaml documents of _all_ yaml files and runs expression once
+  help        Help about any command
+
+Flags:
+  -C, --colors                            force print with colors
+      --csv-auto-parse                    parse CSV YAML/JSON values (default true)
+      --csv-separator char                CSV Separator character (default ,)
+      --debug-node-info                   debug node info
+  -e, --exit-status                       set exit status if there are no matches or null or false is returned
+      --expression string                 forcibly set the expression argument. Useful when yq argument detection thinks your expression is a file.
+      --from-file string                  Load expression from specified file.
+  -f, --front-matter string               (extract|process) first input as yaml front-matter. Extract will pull out the yaml content, process will run the expression against the yaml content, leaving the remaining data intact
+      --header-preprocess                 Slurp any header comments and separators before processing expression. (default true)
+  -h, --help                              help for yq
+  -I, --indent int                        sets indent level for output (default 2)
+      --ini-preserve-quotes               preserve surrounding quotes on INI values during round-trip
+  -i, --inplace                           update the file in place of first file given.
+  -p, --input-format string               [auto|a|yaml|y|kyaml|ky|json|j|props|p|csv|c|tsv|t|xml|x|base64|uri|toml|hcl|h|lua|l|ini|i] parse format for input. (default "auto")
+      --lua-globals                       output keys as top-level global variables
+      --lua-prefix string                 prefix (default "return ")
+      --lua-suffix string                 suffix (default ";\\n")
+      --lua-unquoted                      output unquoted string keys (e.g. {foo="bar"})
+  -M, --no-colors                         force print with no colors
+  -N, --no-doc                            Don't print document separators (---)
+  -0, --nul-output                        Use NUL char to separate values. If unwrap scalar is also set, fail if unwrapped scalar contains NUL char.
+  -n, --null-input                        Don't read input, simply evaluate the expression given. Useful for creating docs from scratch.
+  -o, --output-format string              [auto|a|yaml|y|kyaml|ky|json|j|props|p|csv|c|tsv|t|xml|x|base64|uri|toml|hcl|h|shell|s|lua|l|ini|i] output format type. (default "auto")
+  -P, --prettyPrint                       pretty print, shorthand for '... style = ""'
+      --properties-array-brackets         use [x] in array paths (e.g. for SpringBoot)
+      --properties-separator string       separator to use between keys and values (default " = ")
+      --security-disable-env-ops          Disable env related operations.
+      --security-disable-file-ops         Disable file related operations (e.g. load)
+      --security-enable-system-operator   Enable system operator to allow execution of external commands.
+      --shell-key-separator string        separator for shell variable key paths (default "_")
+  -s, --split-exp string                  print each result (or doc) into a file named (exp). [exp] argument must return a string. You can use $index in the expression as the result counter. The necessary directories will be created.
+      --split-exp-file string             Use a file to specify the split-exp expression.
+      --string-interpolation              Toggles strings interpolation of \\(exp) (default true)
+      --tsv-auto-parse                    parse TSV YAML/JSON values (default true)
+  -r, --unwrapScalar                      unwrap scalar, print the value with no quotes, colours or comments. Defaults to true for yaml (default true)
+  -v, --verbose                           verbose mode
+  -V, --version                           Print version information and quit
+      --xml-attribute-prefix string       prefix for xml attributes (default "+@")
+      --xml-content-name string           name for xml content (if no attribute name is present). (default "+content")
+      --xml-directive-name string         name for xml directives (e.g. <!DOCTYPE thing cat>) (default "+directive")
+      --xml-keep-namespace                enables keeping namespace after parsing attributes (default true)
+      --xml-proc-inst-prefix string       prefix for xml processing instructions (e.g. <?xml version="1"?>) (default "+p_")
+      --xml-raw-token                     enables using RawToken method instead Token. Commonly disables namespace translations. See https://pkg.go.dev/encoding/xml#Decoder.RawToken for details. (default true)
+      --xml-skip-directives               skip over directives (e.g. <!DOCTYPE thing cat>)
+      --xml-skip-proc-inst                skip over process instructions (e.g. <?xml version="1"?>)
+      --xml-strict-mode                   enables strict parsing of XML. See https://pkg.go.dev/encoding/xml for more details.
+  -c, --yaml-compact-seq-indent           Use compact sequence indentation where '- ' is considered part of the indentation.
+      --yaml-fix-merge-anchor-to-spec     Fix merge anchor to match YAML spec. Will default to true in late 2025
+
+Use "yq [command] --help" for more information about a command.
+`;
+var mikeUsage = mikeHelp.slice(mikeHelp.indexOf("Usage:")) + "\n";
+var booleans = {
+  v: "verbose",
+  verbose: "verbose",
+  "debug-node-info": "debugNodeInfo",
+  "header-preprocess": "headerPreprocess",
+  n: "nullInput",
+  "null-input": "nullInput",
+  i: "inplace",
+  inplace: "inplace",
+  e: "exitStatus",
+  "exit-status": "exitStatus",
+  r: "unwrap",
+  unwrapScalar: "unwrap",
+  h: "help",
+  help: "help",
+  V: "version",
+  version: "version",
+  N: "noDoc",
+  "no-doc": "noDoc",
+  c: "compactSequence",
+  "yaml-compact-seq-indent": "compactSequence",
+  "yaml-fix-merge-anchor-to-spec": "mergeSpec",
+  "0": "nulOutput",
+  "nul-output": "nulOutput",
+  P: "prettyPrint",
+  prettyPrint: "prettyPrint",
+  "security-disable-env-ops": "disableEnvOps",
+  "security-disable-file-ops": "disableFileOps"
+};
+var values = {
+  "from-file": "fromFile",
+  f: "frontMatter",
+  "front-matter": "frontMatter",
+  s: "splitExpression",
+  "split-exp": "splitExpression",
+  "split-exp-file": "splitFile",
+  p: "input",
+  "input-format": "input",
+  o: "output",
+  "output-format": "output",
+  I: "indent",
+  indent: "indent",
+  expression: "expression"
+};
+function mikeCommandMode(args) {
+  for (let index = 0; index < args.length; index++) {
+    const argument = args[index];
+    if (argument === "--") return index + 1 < args.length ? "eval" : "root";
+    if (!argument.startsWith("-") || argument === "-") return argument === "ea" || argument === "eval-all" ? "eval-all" : "eval";
+    const long = argument.startsWith("--");
+    let remaining = argument.slice(long ? 2 : 1);
+    while (remaining) {
+      const equal = remaining.indexOf("=");
+      const name = long ? equal < 0 ? remaining : remaining.slice(0, equal) : remaining[0];
+      if (Object.hasOwn(values, name)) {
+        if (long ? equal < 0 : remaining.length === 1) index++;
+        break;
+      }
+      if (!Object.hasOwn(booleans, name) && name !== "M" && name !== "no-colors") return "root";
+      if (long || remaining[1] === "=") break;
+      remaining = remaining.slice(1);
+    }
+  }
+  return "root";
+}
+function parseIndent(value2) {
+  const negative = value2.startsWith("-");
+  let digits = value2.startsWith("+") || negative ? value2.slice(1) : value2;
+  let base = 10;
+  let prefixed = false;
+  if (digits.length > 1 && digits[0] === "0") {
+    prefixed = true;
+    const prefix = digits[1].toLowerCase();
+    base = prefix === "x" ? 16 : prefix === "b" ? 2 : 8;
+    digits = digits.slice(prefix === "x" || prefix === "b" || prefix === "o" ? 2 : 1);
+  }
+  if (prefixed && digits.startsWith("_")) digits = digits.slice(1);
+  let invalid = digits.length === 0;
+  let previousDigit = false;
+  let integer = 0n;
+  const maximum = negative ? 9223372036854775808n : 9223372036854775807n;
+  for (const character of digits) {
+    if (character === "_") {
+      if (!previousDigit) invalid = true;
+      previousDigit = false;
+      continue;
+    }
+    const digit = "0123456789abcdef".indexOf(character.toLowerCase());
+    if (digit < 0 || digit >= base) invalid = true;
+    else if (integer <= maximum) integer = integer * BigInt(base) + BigInt(digit);
+    previousDigit = true;
+  }
+  if (!previousDigit) invalid = true;
+  if (invalid || integer > maximum) throw new MikeError(`invalid argument ${JSON.stringify(value2)} for "-I, --indent" flag: strconv.ParseInt: parsing ${JSON.stringify(value2)}: ${invalid ? "invalid syntax" : "value out of range"}`, true);
+  const result = Number(negative ? -integer : integer);
+  if (!Number.isSafeInteger(result)) throw new MikeError("yq limit exceeded: indent");
+  return result;
+}
+function parseMikeArguments(context) {
+  const carrier = getCommandArguments(context);
+  for (let index = 0; index < carrier.args.length; index++) {
+    try {
+      new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(carrier.bytes(index));
+    } catch {
+      throw new MikeError("yq filename/expression bytes must be valid UTF-8");
+    }
+  }
+  const result = {
+    verbose: false,
+    debugNodeInfo: false,
+    all: false,
+    help: false,
+    version: false,
+    nullInput: false,
+    inplace: false,
+    exitStatus: false,
+    input: "auto",
+    output: "auto",
+    indent: 2,
+    unwrap: void 0,
+    noDoc: false,
+    compactSequence: false,
+    mergeSpec: false,
+    disableEnvOps: false,
+    disableFileOps: false,
+    nulOutput: false,
+    prettyPrint: false,
+    expression: void 0,
+    fromFile: void 0,
+    frontMatter: void 0,
+    splitExpression: void 0,
+    splitFile: void 0,
+    headerPreprocess: true,
+    operands: []
+  };
+  let ended = false;
+  for (let index = 0; index < context.args.length; index++) {
+    const argument = context.args[index];
+    if (!ended && argument === "--") {
+      ended = true;
+      continue;
+    }
+    if (!ended && ["eval", "e", "eval-all", "ea"].includes(argument) && result.operands.length === 0) {
+      result.all = argument === "eval-all" || argument === "ea";
+      continue;
+    }
+    if (ended || !argument.startsWith("-") || argument === "-") {
+      result.operands.push(argument);
+      continue;
+    }
+    const long = argument.startsWith("--");
+    let remaining = argument.slice(long ? 2 : 1);
+    while (remaining) {
+      const equal = remaining.indexOf("=");
+      const name = long ? equal < 0 ? remaining : remaining.slice(0, equal) : remaining[0];
+      let attached = long ? equal < 0 ? void 0 : remaining.slice(equal + 1) : remaining.slice(1) || void 0;
+      if (!long && attached?.startsWith("=")) attached = attached.slice(1);
+      const boolean = Object.hasOwn(booleans, name) ? booleans[name] : void 0;
+      if (boolean || name === "M" || name === "no-colors") {
+        const explicit = long ? equal >= 0 : remaining[1] === "=";
+        let enabled = true;
+        if (explicit) {
+          if (["true", "1", "t", "TRUE", "True", "T"].includes(attached)) enabled = true;
+          else if (["false", "0", "f", "FALSE", "False", "F"].includes(attached)) enabled = false;
+          else {
+            const fullName = name === "r" || name === "unwrapScalar" ? "-r, --unwrapScalar" : name === "n" || name === "null-input" ? "-n, --null-input" : `--${name}`;
+            throw new MikeError(`invalid argument ${JSON.stringify(attached)} for "${fullName}" flag: strconv.ParseBool: parsing ${JSON.stringify(attached)}: invalid syntax`, true);
+          }
+        }
+        if (boolean) Object.assign(result, { [boolean]: enabled });
+        remaining = long || explicit ? "" : remaining.slice(1);
+        continue;
+      }
+      const field = Object.hasOwn(values, name) ? values[name] : void 0;
+      if (!field) throw new MikeError(long ? `unknown flag: --${name}` : `unknown shorthand flag: '${name}' in ${argument}`, true);
+      const value2 = attached ?? context.args[++index];
+      if (value2 === void 0) throw new MikeError(long ? `flag needs an argument: --${name}` : `flag needs an argument: '${name}' in ${argument}`, true);
+      if (field === "indent") {
+        result.indent = parseIndent(value2);
+      } else result[field] = value2;
+      remaining = "";
+    }
+  }
+  return result;
+}
+function mikeFormat(value2) {
+  if (value2 === "auto" || value2 === "a" || value2 === "") return "auto";
+  if (value2 === "yaml" || value2 === "y") return "yaml";
+  if (value2 === "json" || value2 === "j") return "json";
+  const formats = { xml: "xml", x: "xml", csv: "csv", c: "csv", tsv: "tsv", t: "tsv", props: "props", p: "props", toml: "toml", ini: "ini", i: "ini", lua: "lua", l: "lua", base64: "base64", uri: "uri", shell: "shell", s: "shell" };
+  if (Object.hasOwn(formats, value2)) return formats[value2];
+  if (["hcl", "h", "kyaml", "ky"].includes(value2)) throw new MikeError(`format '${value2}' is not supported by this bounded yq profile`);
+  throw new MikeError(`unknown format '${value2}' please use [yaml|y|kyaml|ky|json|j|props|p|csv|c|tsv|t|xml|x|base64|uri|toml|hcl|h|shell|s|lua|l|ini|i]`);
+}
+
+// packages/safe-bash-command-yq/src/expression.ts
+init_buffer();
+import { utf8ByteLength as utf8ByteLength4 } from "../safe-bash-query-engine/bytes.js";
+var priorities = { "|": 1, ",": 2, "=": 3, "=c": 3, "|=": 3, "+=": 3, "-=": 3, "*=": 3, "/=": 3, "//": 4, or: 5, and: 6, "==": 7, "!=": 7, ">": 7, "<": 7, ">=": 7, "<=": 7, "+": 8, "-": 8, "*": 9, "/": 9, "%": 9 };
+var functions = /* @__PURE__ */ new Set(["path", "select", "map", "has", "length", "keys", "tag", "type", "kind", "style", "head_comment", "anchor", "alias", "documentIndex", "document_index", "di", "fileIndex", "file_index", "fi", "filename", "env", "strenv", "del", "explode", "not", "sort", "sort_by", "reverse", "to_entries", "from_entries", "with_entries", "pick", "upcase", "downcase", "test", "split"]);
+function compileExpression(source, security = {}) {
+  if (utf8ByteLength4(source) > (security.maxExpressionBytes ?? Infinity)) throw new MikeError("yq limit exceeded: expression bytes");
+  const tokens = [];
+  let offset = 0;
+  while (offset < source.length) {
+    const character = source[offset];
+    if (/\s/u.test(character)) {
+      offset++;
+      continue;
+    }
+    const start = offset;
+    if (source.startsWith("...", offset)) {
+      tokens.push({ text: "...", offset, kind: "symbol" });
+      offset += 3;
+      continue;
+    }
+    if (character === "#") {
+      while (offset < source.length && source[offset] !== "\n") offset++;
+      continue;
+    }
+    if (character === '"') {
+      offset++;
+      let escaped = false;
+      while (offset < source.length) {
+        const next = source[offset++];
+        if (!escaped && next === '"') break;
+        if (!escaped && next === "\\") escaped = true;
+        else escaped = false;
+      }
+      const text = source.slice(start, offset);
+      try {
+        JSON.parse(text);
+      } catch {
+        throw new MikeError("bad expression, please check expression syntax");
+      }
+      tokens.push({ text, offset: start, kind: "string" });
+      continue;
+    }
+    const number = /^(?:[0-9]+(?:\.[0-9]+)?)(?:[eE][+-]?[0-9]+)?/u.exec(source.slice(offset));
+    if (number) {
+      tokens.push({ text: number[0], offset, kind: "number" });
+      offset += number[0].length;
+      continue;
+    }
+    const name = /^[A-Za-z_][A-Za-z_0-9-]*/u.exec(source.slice(offset));
+    if (name) {
+      tokens.push({ text: name[0], offset, kind: "name" });
+      offset += name[0].length;
+      continue;
+    }
+    const symbol = /^(?:\|=|=c|\+=|-=|\*=|\/=|==|!=|>=|<=|\/\/|\.\.|[.[\]{}(),:|+*/%<>=-])/u.exec(source.slice(offset));
+    if (!symbol) throw new MikeError(`1:${offset + 1}: lexer: invalid input text ${JSON.stringify(source.slice(offset))}`);
+    tokens.push({ text: symbol[0], offset, kind: "symbol" });
+    offset += symbol[0].length;
+  }
+  tokens.push({ text: "", offset, kind: "end" });
+  let position = 0;
+  let nesting = 0;
+  const peek = () => tokens[position];
+  const take = () => tokens[position++];
+  const expect = (text) => {
+    if (take().text !== text) throw new MikeError("bad expression, please check expression syntax");
+  };
+  const literal = (value2) => ({ kind: "literal", value: value2 });
+  const parse = (minimum = 0) => {
+    if (++nesting > (security.maxExpressionDepth ?? Infinity)) throw new MikeError("yq limit exceeded: expression depth");
+    const token = take();
+    let result2;
+    if (token.text === ".") {
+      result2 = { kind: "identity" };
+      if (peek().offset === token.offset + 1 && (peek().kind === "name" || peek().kind === "string")) {
+        const key = take();
+        result2 = { kind: "field", base: result2, key: literal(key.kind === "string" ? JSON.parse(key.text) : key.text) };
+      }
+    } else if (token.text === ".." || token.text === "...") result2 = { kind: "recursive", includeKeys: token.text === "..." };
+    else if (token.text === "(") {
+      result2 = { kind: "group", body: parse() };
+      expect(")");
+    } else if (token.text === "[") {
+      result2 = peek().text === "]" ? { kind: "array" } : { kind: "array", body: parse() };
+      expect("]");
+    } else if (token.text === "{") {
+      const fields = [];
+      while (peek().text !== "}") {
+        const key = take();
+        if (key.kind === "name") throw new MikeError(`1:${key.offset + 1}: lexer: invalid input text ${JSON.stringify(source.slice(key.offset))}`);
+        if (key.kind !== "string") throw new MikeError("bad expression, please check expression syntax");
+        expect(":");
+        fields.push({ key: literal(key.kind === "string" ? JSON.parse(key.text) : key.text), value: parse(3) });
+        if (peek().text !== ",") break;
+        take();
+      }
+      expect("}");
+      result2 = { kind: "object", fields };
+    } else if (token.text === "-") {
+      const right = parse(10);
+      result2 = right.kind === "literal" && right.source !== void 0 && (typeof right.value === "number" || typeof right.value === "bigint") ? { kind: "literal", value: -right.value, source: `-${right.source}` } : { kind: "binary", operator: "*", left: literal(-1n), right };
+    } else if (token.kind === "number") result2 = { kind: "literal", value: /[.eE]/u.test(token.text) ? Number(token.text) : BigInt(token.text), source: token.text };
+    else if (token.kind === "string") result2 = literal(JSON.parse(token.text));
+    else if (["true", "false", "null"].includes(token.text)) result2 = literal(JSON.parse(token.text));
+    else if (security.disableEnvOps && ["env", "strenv", "envsubst"].includes(token.text)) throw new MikeError("env operations have been disabled");
+    else if (security.disableFileOps && ["load", "load_str", "load_xml", "load_props", "load_base64"].includes(token.text)) throw new MikeError("file operations have been disabled");
+    else if (functions.has(token.text)) {
+      const args = [];
+      if (peek().text === "(") {
+        take();
+        if (token.text === "env" || token.text === "strenv") args.push(literal(take().text));
+        else if (peek().text !== ")") args.push(parse());
+        expect(")");
+      }
+      const needsArgument = ["select", "map", "has", "env", "strenv", "del", "explode", "sort_by", "with_entries", "pick", "test", "split"].includes(token.text);
+      if (needsArgument && args.length === 0) throw new MikeError(`'${token.text}' expects 1 arg but received none`);
+      if (!needsArgument && args.length) throw new MikeError("bad expression, please check expression syntax");
+      result2 = { kind: "call", name: token.text, args };
+    } else if (token.kind === "end" && tokens.some((item) => item.text === "[")) throw new MikeError("bad expression, could not find matching `]`");
+    else throw new MikeError(`1:${token.offset + 1}: lexer: invalid input text ${JSON.stringify(source.slice(token.offset))}`);
+    while (true) {
+      if (peek().text === ".") {
+        take();
+        const key = take();
+        if (key.kind !== "name" && key.kind !== "string") throw new MikeError("bad expression, please check expression syntax");
+        result2 = { kind: "field", base: result2, key: literal(key.kind === "string" ? JSON.parse(key.text) : key.text) };
+        continue;
+      }
+      if (peek().text === "[") {
+        take();
+        if (peek().text === "]") result2 = { kind: "pipe", operator: "|", left: result2, right: { kind: "iterate" } };
+        else {
+          const start = peek().text === ":" ? literal(0n) : parse();
+          if (peek().text === ":") {
+            take();
+            const end = peek().text === "]" ? { kind: "call", name: "length", args: [] } : parse();
+            result2 = { kind: "slice", base: result2, start, end };
+          } else result2 = { kind: "field", base: result2, key: start };
+        }
+        expect("]");
+        continue;
+      }
+      if ((peek().text === "tag" || peek().text === "style") && minimum <= 3) {
+        result2 = { kind: "pipe", operator: "|", left: result2, right: { kind: "call", name: take().text, args: [] } };
+        continue;
+      }
+      const operator = peek().text;
+      const priority = priorities[operator];
+      if (priority === void 0 || priority < minimum) break;
+      take();
+      if (operator === "//" && peek().text === "=") throw new MikeError("'//' expects 2 args but there is 1");
+      result2 = { kind: operator === "|" ? "pipe" : "binary", operator, left: result2, right: parse(priority + (priority === 3 ? 0 : 1)) };
+    }
+    nesting--;
+    return result2;
+  };
+  if (!source.trim()) return { kind: "identity" };
+  const result = parse();
+  if (peek().kind !== "end") throw new MikeError("bad expression, please check expression syntax");
+  return result;
+}
+
+// packages/safe-bash-command-yq/src/evaluate.ts
+init_buffer();
+import { utf8ByteLength as utf8ByteLength5, utf8Encoder as utf8Encoder3, compareBytes } from "../safe-bash-query-engine/bytes.js";
+import { EreLedger } from "../safe-bash-regex-engine/ere/limits.js";
+import { EreSyntaxError, EreUnsupportedError, EreProfileLimitError } from "../safe-bash-regex-engine/ere/errors.js";
+import { compileEre } from "../safe-bash-regex-engine/ere/syntax.js";
+import { prepareUtf8EreSubject } from "../safe-bash-regex-engine/ere/matcher.js";
+function value(node, yaml) {
+  if (!yaml.isScalar(node)) throw new MikeError("expected a scalar value");
+  const result = node.value;
+  if (result == null) return null;
+  if (typeof result === "string" && node.tag && !node.tag.startsWith("tag:yaml.org,2002:")) {
+    if (/^[+-]?[0-9]+$/u.test(result)) return BigInt(result);
+    if (/^[+-]?0[xX][0-9a-fA-F]+$/u.test(result)) {
+      if (result[0] === "+" || result[0] === "-") throw new MikeError(`strconv.ParseInt: parsing ${JSON.stringify(result)}: invalid syntax`);
+      return BigInt(result);
+    }
+    if (/^[+-]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:[eE][+-]?[0-9]+)?$/u.test(result)) return Number(result);
+  }
+  if (typeof result === "string" && node.tag === "tag:yaml.org,2002:int") {
+    try {
+      return BigInt(result);
+    } catch {
+      throw new MikeError(`invalid integer value ${JSON.stringify(result)}`);
+    }
+  }
+  if (typeof result === "string" && node.tag === "tag:yaml.org,2002:float") return Number(result);
+  if (typeof result === "string" && node.tag === "tag:yaml.org,2002:bool") return result.toLowerCase() === "true";
+  if (["string", "number", "bigint", "boolean"].includes(typeof result)) return result;
+  throw new MikeError("unsupported scalar value");
+}
+function scalarText(node, yaml) {
+  if (!yaml.isScalar(node)) throw new MikeError("expected a scalar value");
+  return node.source ?? String(node.value);
+}
+var Evaluator = class {
+  constructor(yaml, work, mergeSpec = false) {
+    this.yaml = yaml;
+    this.work = work;
+    this.mergeSpec = mergeSpec;
+  }
+  yaml;
+  work;
+  mergeSpec;
+  #warnedMerge = false;
+  #regex;
+  async match(first, pattern) {
+    {
+      const t = this.work.tick(first.length + pattern.length);
+      if (t) await t;
+    }
+    const name = utf8Encoder3.encode(first);
+    const glob = utf8Encoder3.encode(pattern);
+    let nameIndex = 0;
+    let patternIndex = 0;
+    let restartPattern = 0;
+    let restartName = 0;
+    while (patternIndex < glob.length || nameIndex < name.length) {
+      {
+        const t = this.work.tick();
+        if (t) await t;
+      }
+      if (patternIndex < glob.length) {
+        const character = glob[patternIndex];
+        if (character === 42) {
+          restartPattern = patternIndex;
+          restartName = nameIndex + 1;
+          patternIndex++;
+          continue;
+        }
+        if (nameIndex < name.length && (character === 63 || character === name[nameIndex])) {
+          patternIndex++;
+          nameIndex++;
+          continue;
+        }
+      }
+      if (restartName > 0 && restartName <= name.length) {
+        patternIndex = restartPattern;
+        nameIndex = restartName;
+        continue;
+      }
+      return false;
+    }
+    return true;
+  }
+  child(node, parent, collection, slot) {
+    this.work.node();
+    return {
+      node,
+      document: parent.document,
+      isDerived: collection === void 0 || parent.isDerived === true,
+      ...collection === void 0 ? {} : { parent: collection, slot },
+      ...collection === void 0 ? parent.ancestry ? { ancestry: parent.ancestry } : {} : {
+        ancestry: { parent, key: this.yaml.isMap(collection) ? collection.items[slot].key : slot }
+      }
+    };
+  }
+  async toEntries(input) {
+    const yaml = this.yaml;
+    const base = dereference(input, yaml, this.work);
+    if (!yaml.isCollection(base.node)) throw new MikeError(`to_entries only supports maps and arrays, got ${nodeTag(base.node, yaml)}`);
+    this.work.node();
+    const result = new yaml.YAMLSeq();
+    if (base.node.commentBefore !== void 0) result.commentBefore = base.node.commentBefore;
+    if (base.node.comment !== void 0) result.comment = base.node.comment;
+    for (let index = 0; index < base.node.items.length; index++) {
+      {
+        const t = this.work.tick();
+        if (t) await t;
+      }
+      const item = base.node.items[index];
+      const key = yaml.isMap(base.node) ? item.key : scalar(yaml, this.work, BigInt(index));
+      const member = yaml.isMap(base.node) ? item.value : item;
+      this.work.node();
+      const entry = new yaml.YAMLMap();
+      const copiedKey = await cloneNode(key, yaml, this.work);
+      if (index === 0 && yaml.isMap(base.node) && copiedKey.commentBefore !== void 0) {
+        result.commentBefore = copiedKey.commentBefore;
+        delete copiedKey.commentBefore;
+      }
+      entry.items.push(new yaml.Pair(scalar(yaml, this.work, "key"), copiedKey));
+      entry.items.push(new yaml.Pair(scalar(yaml, this.work, "value"), await cloneNode(member, yaml, this.work)));
+      result.items.push(entry);
+    }
+    return result;
+  }
+  async fromEntries(input) {
+    const yaml = this.yaml;
+    const base = dereference(input, yaml, this.work);
+    if (!yaml.isSeq(base.node)) throw new MikeError("from_entries only supports arrays");
+    this.work.node();
+    const result = new yaml.YAMLMap();
+    if (base.node.flow !== void 0) result.flow = base.node.flow;
+    if (base.node.commentBefore !== void 0) result.commentBefore = base.node.commentBefore;
+    if (base.node.comment !== void 0) result.comment = base.node.comment;
+    for (const item of base.node.items) {
+      {
+        const t = this.work.tick();
+        if (t) await t;
+      }
+      if (!yaml.isNode(item)) throw new MikeError("from_entries expects key/value entries");
+      const entry = dereference(this.child(item, base), yaml, this.work);
+      const fields = await this.entries(entry);
+      const key = fields.get("key");
+      const member = fields.get("value");
+      if (!key || !member) throw new MikeError("from_entries expects key/value entries");
+      result.items.push(new yaml.Pair(await cloneNode(key.node, yaml, this.work), await cloneNode(member.node, yaml, this.work)));
+    }
+    return result;
+  }
+  async sort(input, expression, depth) {
+    const yaml = this.yaml;
+    const base = dereference(input, yaml, this.work);
+    if (!yaml.isCollection(base.node)) throw new MikeError(`cannot sort ${nodeTag(base.node, yaml)}, can only sort arrays or maps`);
+    const result = await cloneNode(base.node, yaml, this.work);
+    const members = [];
+    for (const item of result.items) {
+      {
+        const t = this.work.tick();
+        if (t) await t;
+      }
+      const candidate = this.child(yaml.isMap(result) ? item.value : item, base);
+      const keys = await this.run(expression, [candidate], false, depth + 1);
+      this.work.node(keys.length);
+      members.push({ item, keys: keys.map((key) => dereference(key, yaml, this.work).node) });
+    }
+    const compare = async (first, second) => {
+      for (let index = 0; index < Math.min(first.keys.length, second.keys.length); index++) {
+        {
+          const t = this.work.tick();
+          if (t) await t;
+        }
+        const leftNode = first.keys[index];
+        const rightNode = second.keys[index];
+        const left = yaml.isScalar(leftNode) ? value(leftNode, yaml) : "";
+        const right = yaml.isScalar(rightNode) ? value(rightNode, yaml) : "";
+        if (left === null && right === null) continue;
+        if (left === null) return -1;
+        if (right === null) return 1;
+        if (typeof left === "boolean" && typeof right !== "boolean") return -1;
+        if (typeof left !== "boolean" && typeof right === "boolean") return 1;
+        if (typeof left === "boolean" && typeof right === "boolean" || (typeof left === "number" || typeof left === "bigint") && (typeof right === "number" || typeof right === "bigint")) {
+          if (left < right) return -1;
+          if (left > right) return 1;
+        } else {
+          const leftText = yaml.isScalar(leftNode) ? scalarText(leftNode, yaml) : "";
+          const rightText = yaml.isScalar(rightNode) ? scalarText(rightNode, yaml) : "";
+          {
+            const t = this.work.tick(leftText.length + rightText.length);
+            if (t) await t;
+          }
+          const compared = compareBytes(utf8Encoder3.encode(leftText), utf8Encoder3.encode(rightText));
+          if (compared) return compared;
+        }
+      }
+      return first.keys.length - second.keys.length;
+    };
+    for (let width = 1; width < members.length; width *= 2) {
+      for (let start = 0; start < members.length; start += width * 2) {
+        const end = Math.min(start + width * 2, members.length);
+        const middle = Math.min(start + width, end);
+        this.work.node(end - start);
+        const merged = [];
+        let left = start;
+        let right = middle;
+        while (left < middle || right < end) {
+          {
+            const t = this.work.tick();
+            if (t) await t;
+          }
+          merged.push(right >= end || left < middle && await compare(members[left], members[right]) <= 0 ? members[left++] : members[right++]);
+        }
+        for (let index = 0; index < merged.length; index++) {
+          {
+            const t = this.work.tick();
+            if (t) await t;
+          }
+          members[start + index] = merged[index];
+        }
+      }
+    }
+    if (yaml.isMap(result)) result.items = members.map((member) => member.item);
+    else result.items = members.map((member) => member.item);
+    return result;
+  }
+  async sameKey(left, right, depth) {
+    this.work.depth(depth);
+    {
+      const t = this.work.tick();
+      if (t) await t;
+    }
+    if (nodeTag(left, this.yaml) !== nodeTag(right, this.yaml)) return false;
+    if (this.yaml.isScalar(left) && this.yaml.isScalar(right)) return left.value === right.value;
+    if (this.yaml.isSeq(left) && this.yaml.isSeq(right)) {
+      if (left.items.length !== right.items.length) return false;
+      for (let index = 0; index < left.items.length; index++) {
+        if (!await this.sameKey(left.items[index], right.items[index], depth + 1)) return false;
+      }
+      return true;
+    }
+    if (this.yaml.isMap(left) && this.yaml.isMap(right)) {
+      if (left.items.length !== right.items.length) return false;
+      for (let index = 0; index < left.items.length; index++) {
+        const first = left.items[index], second = right.items[index];
+        if (!await this.sameKey(first.key, second.key, depth + 1) || !await this.sameKey(first.value, second.value, depth + 1)) return false;
+      }
+      return true;
+    }
+    return false;
+  }
+  async warnMerge() {
+    if (!this.#warnedMerge) {
+      this.#warnedMerge = true;
+      const now = /* @__PURE__ */ new Date();
+      const offset = now.getTimezoneOffset();
+      const local = new Date(now.getTime() - offset * 6e4).toISOString().slice(0, -1);
+      const zone = offset === 0 ? "Z" : `${offset < 0 ? "+" : "-"}${String(Math.floor(Math.abs(offset) / 60)).padStart(2, "0")}:${String(Math.abs(offset) % 60).padStart(2, "0")}`;
+      await this.work.write(utf8Encoder3.encode(`time=${local}${zone} level=WARN msg="--yaml-fix-merge-anchor-to-spec is false; causing merge anchors to override the existing values which isn't to the yaml spec. This flag will default to true in late 2025. See https://mikefarah.gitbook.io/yq/operators/traverse-read for more details."
+`), true);
+    }
+  }
+  async explode(input, depth = 0, active = /* @__PURE__ */ new Set()) {
+    this.work.depth(depth);
+    {
+      const t = this.work.tick();
+      if (t) await t;
+    }
+    const base = dereference(input, this.yaml, this.work);
+    if (active.has(base.node)) throw new MikeError("cyclic YAML alias");
+    active.add(base.node);
+    try {
+      const node = await cloneNode(base.node, this.yaml, this.work);
+      if ("anchor" in node) delete node.anchor;
+      if (this.yaml.isAlias(input.node)) {
+        if (input.node.comment !== void 0) node.comment = input.node.comment;
+        if (input.node.commentBefore !== void 0) node.commentBefore = input.node.commentBefore;
+        if (input.node.spaceBefore !== void 0) node.spaceBefore = input.node.spaceBefore;
+        const head = this.work.headComments.get(input.node);
+        if (head !== void 0) this.work.headComments.set(node, head);
+      }
+      if (this.yaml.isMap(base.node) && this.yaml.isMap(node)) {
+        for (let index = 0; index < base.node.items.length; index++) {
+          const pair = base.node.items[index];
+          if (this.yaml.isNode(pair.key)) node.items[index].key = await this.explode({ ...base, node: pair.key }, depth + 1, active);
+          if (this.yaml.isNode(pair.value)) node.items[index].value = await this.explode({ ...base, node: pair.value }, depth + 1, active);
+        }
+        const isMerge = (pair) => this.yaml.isScalar(pair.key) && (pair.key.tag === "tag:yaml.org,2002:merge" || pair.key.value === "<<" && pair.key.type === "PLAIN");
+        if (node.items.some(isMerge)) {
+          const pairs = [];
+          const add = async (pair, override) => {
+            for (let index = 0; index < pairs.length; index++) {
+              if (await this.sameKey(pairs[index].key, pair.key, depth + 1)) {
+                if (override) pairs[index] = pair;
+                return;
+              }
+            }
+            pairs.push(pair);
+          };
+          const merge = async (pair) => {
+            const sources = this.yaml.isSeq(pair.value) ? pair.value.items : [pair.value];
+            for (const source of sources) {
+              {
+                const t = this.work.tick();
+                if (t) await t;
+              }
+              if (!this.yaml.isMap(source)) throw new MikeError("merge requires a map or sequence of maps");
+              for (const incoming of source.items) await add(incoming, !this.mergeSpec);
+            }
+          };
+          if (this.mergeSpec) {
+            for (const pair of node.items) if (isMerge(pair)) await merge(pair);
+          }
+          for (const pair of node.items) {
+            {
+              const t = this.work.tick();
+              if (t) await t;
+            }
+            if (!isMerge(pair)) await add(pair, true);
+            else if (!this.mergeSpec) {
+              await this.warnMerge();
+              await merge(pair);
+            }
+          }
+          node.items = pairs;
+        }
+      } else if (this.yaml.isSeq(base.node) && this.yaml.isSeq(node)) {
+        for (let index = 0; index < base.node.items.length; index++) {
+          const child = base.node.items[index];
+          if (this.yaml.isNode(child)) node.items[index] = await this.explode({ ...base, node: child }, depth + 1, active);
+        }
+      }
+      return node;
+    } finally {
+      active.delete(base.node);
+    }
+  }
+  async entries(input, depth = 0) {
+    this.work.depth(depth);
+    {
+      const t = this.work.tick();
+      if (t) await t;
+    }
+    const base = dereference(input, this.yaml, this.work);
+    const entries = /* @__PURE__ */ new Map();
+    if (!this.yaml.isMap(base.node)) return entries;
+    const node = base.node;
+    const isMerge = (key) => this.yaml.isScalar(key) && (key.tag === "tag:yaml.org,2002:merge" || key.value === "<<" && key.type === "PLAIN");
+    const merge = async (incoming) => {
+      const source = dereference({ ...base, node: incoming }, this.yaml, this.work);
+      const values2 = this.yaml.isSeq(source.node) ? source.node.items : [source.node];
+      for (let index = 0; index < values2.length; index++) {
+        const selected = values2[this.mergeSpec ? values2.length - 1 - index : index];
+        if (!this.yaml.isNode(selected)) continue;
+        for (const [key, child] of await this.entries({ ...source, node: selected }, depth + 1)) {
+          {
+            const t = this.work.tick();
+            if (t) await t;
+          }
+          entries.set(key, child);
+        }
+      }
+    };
+    if (this.mergeSpec) for (let index = node.items.length - 1; index >= 0; index--) {
+      const pair = node.items[index];
+      {
+        const t = this.work.tick();
+        if (t) await t;
+      }
+      if (isMerge(pair.key) && this.yaml.isNode(pair.value)) await merge(pair.value);
+    }
+    for (const [slot, pair] of node.items.entries()) {
+      {
+        const t = this.work.tick();
+        if (t) await t;
+      }
+      if (isMerge(pair.key)) {
+        if (!this.mergeSpec) {
+          await this.warnMerge();
+          if (this.yaml.isNode(pair.value)) await merge(pair.value);
+        }
+      } else if (this.yaml.isScalar(pair.key) && this.yaml.isNode(pair.value)) entries.set(String(pair.key.value), this.child(pair.value, base, node, slot));
+    }
+    return entries;
+  }
+  async field(input, key, create, omitMissing = false) {
+    let base = dereference(input, this.yaml, this.work);
+    if (this.yaml.isScalar(base.node) && base.node.value == null && create) {
+      const collection = typeof key === "string" ? new this.yaml.YAMLMap() : new this.yaml.YAMLSeq();
+      await replace(base, collection, this.yaml, this.work);
+    }
+    base = dereference(base, this.yaml, this.work);
+    const node = base.node;
+    if (this.yaml.isMap(node)) {
+      if (key === "<<") for (let slot = node.items.length - 1; slot >= 0; slot--) {
+        {
+          const t = this.work.tick();
+          if (t) await t;
+        }
+        const pair = node.items[slot];
+        if (this.yaml.isScalar(pair.key) && String(pair.key.value) === String(key)) return [this.child(pair.value, base, node, slot)];
+      }
+      const existing = (await this.entries(base)).get(String(key));
+      if (existing) return [existing];
+      if (create) {
+        this.work.node(2);
+        if (!node.items.length) node.flow = false;
+        node.items.push(new this.yaml.Pair(new this.yaml.Scalar(key), new this.yaml.Scalar(null)));
+        return [this.child(node.items.at(-1).value, base, node, node.items.length - 1)];
+      }
+      return omitMissing ? [] : [this.child(scalar(this.yaml, this.work, null), base)];
+    }
+    if (this.yaml.isSeq(node)) {
+      const text = typeof key === "number" && Number.isInteger(key) ? `${key}.0` : String(key);
+      const digits = text[0] === "+" || text[0] === "-" ? text.slice(1) : text;
+      const integer = (typeof key === "bigint" || typeof key === "string") && digits.length > 0 && [...digits].every((character) => character >= "0" && character <= "9");
+      if (!integer) throw new MikeError(`cannot index array with '${text}' (strconv.ParseInt: parsing ${JSON.stringify(text)}: invalid syntax)`);
+      let index = Number(key);
+      if (!Number.isSafeInteger(index)) throw new MikeError(`cannot index array with '${String(key)}' (strconv.ParseInt: parsing ${JSON.stringify(String(key))}: invalid syntax)`);
+      if (index < 0) index += node.items.length;
+      if (index < 0) throw new MikeError(`index [${String(key)}] out of range, array size is ${node.items.length}`);
+      if (index >= node.items.length) {
+        if (!create) return [this.child(scalar(this.yaml, this.work, null), base)];
+        if (index >= this.work.limits.maxNodes) throw new MikeError("yq limit exceeded: maxNodes");
+        if (!node.items.length) node.flow = false;
+        while (node.items.length <= index) {
+          node.items.push(scalar(this.yaml, this.work, null));
+          {
+            const t = this.work.tick();
+            if (t) await t;
+          }
+        }
+      }
+      return [index < node.items.length ? this.child(node.items[index], base, node, index) : this.child(scalar(this.yaml, this.work, null), base)];
+    }
+    if (this.yaml.isScalar(node) && node.value == null && (typeof key === "number" || typeof key === "bigint") && key < 0) {
+      throw new MikeError(`index [${String(key)}] out of range, array size is 0`);
+    }
+    return !omitMissing && this.yaml.isScalar(node) && node.value == null ? [this.child(scalar(this.yaml, this.work, null), base)] : [];
+  }
+  async binary(operator, left, right) {
+    {
+      const t = this.work.tick();
+      if (t) await t;
+    }
+    const yaml = this.yaml;
+    if (operator === "+" && nodeTag(left, yaml) === "!!null") return cloneNode(right, yaml, this.work);
+    if ((operator === "*" || operator === "+") && yaml.isMap(left) && yaml.isMap(right)) {
+      const output = await cloneNode(left, yaml, this.work);
+      for (const pair of right.items) {
+        const key = yaml.isScalar(pair.key) ? String(pair.key.value) : "";
+        const existing = output.items.find((item) => yaml.isScalar(item.key) && String(item.key.value) === key);
+        if (existing) existing.value = operator === "*" && yaml.isMap(existing.value) && yaml.isMap(pair.value) ? await this.binary("*", existing.value, pair.value) : await cloneNode(pair.value, yaml, this.work);
+        else output.items.push(new yaml.Pair(await cloneNode(pair.key, yaml, this.work), await cloneNode(pair.value, yaml, this.work)));
+      }
+      return output;
+    }
+    if (operator === "+" && yaml.isSeq(left)) {
+      const result = await cloneNode(left, yaml, this.work);
+      if (!result.items.length) result.flow = false;
+      const members = yaml.isSeq(right) ? right.items : nodeTag(right, yaml) === "!!null" ? [] : [right];
+      for (const node of members) result.items.push(await cloneNode(node, yaml, this.work));
+      return result;
+    }
+    if (operator === "==" || operator === "!=") {
+      let equal = false;
+      if (nodeTag(left, yaml) === "!!null") equal = nodeTag(right, yaml) === "!!null";
+      else if (yaml.isScalar(left) && yaml.isScalar(right)) {
+        equal = await this.match(scalarText(left, yaml), scalarText(right, yaml));
+      }
+      return scalar(yaml, this.work, operator === "==" ? equal : !equal);
+    }
+    const first = value(left, yaml);
+    const second = value(right, yaml);
+    if (operator === "+" && (typeof first === "string" || typeof second === "string")) {
+      const text = scalarText(left, yaml) + (typeof first === "string" && second === null ? "" : scalarText(right, yaml));
+      const result = scalar(yaml, this.work, text);
+      if (yaml.isScalar(result) && yaml.isScalar(left) && left.type !== void 0) result.type = left.type;
+      return result;
+    }
+    if ([">", "<", ">=", "<="].includes(operator)) {
+      if (first === null || second === null) return scalar(yaml, this.work, false);
+      return scalar(yaml, this.work, operator === ">" ? first > second : operator === "<" ? first < second : operator === ">=" ? first >= second : first <= second);
+    }
+    if (typeof first !== "number" && typeof first !== "bigint" || typeof second !== "number" && typeof second !== "bigint") throw new MikeError(`cannot ${operator} ${nodeTag(left, yaml)} with ${nodeTag(right, yaml)}`);
+    if (typeof first === "bigint" && typeof second === "bigint" && operator !== "/") {
+      if (first !== BigInt.asIntN(64, first) || second !== BigInt.asIntN(64, second)) throw new MikeError("integer arithmetic operand is outside int64 range");
+      if (operator === "+") {
+        const sum = BigInt.asIntN(64, first + second);
+        const result = await cloneNode(left, yaml, this.work);
+        if (yaml.isScalar(result)) {
+          result.value = sum;
+          result.source = sum.toString();
+          const spelling = scalarText(left, yaml);
+          if (spelling.startsWith("0x") || spelling.startsWith("0X")) {
+            result.format = "HEX";
+            result.source = `0x${sum.toString(16).toUpperCase()}`;
+          }
+        }
+        return result;
+      }
+      if (operator === "-") return scalar(yaml, this.work, BigInt.asIntN(64, first - second));
+      if (operator === "*") return scalar(yaml, this.work, BigInt.asIntN(64, first * second));
+      if (operator === "%" && second !== 0n) return scalar(yaml, this.work, first % second);
+    }
+    const firstNumber = Number(first);
+    const secondNumber = Number(second);
+    return scalar(yaml, this.work, operator === "+" ? firstNumber + secondNumber : operator === "-" ? firstNumber - secondNumber : operator === "*" ? firstNumber * secondNumber : operator === "/" ? firstNumber / secondNumber : firstNumber % secondNumber, nodeTag(left, yaml) === "!!float" || nodeTag(right, yaml) === "!!float");
+  }
+  async run(expression, inputs, create = false, depth = 0, omitMissing = false) {
+    this.work.depth(depth);
+    {
+      const t = this.work.tick();
+      if (t) await t;
+    }
+    const next = (body, values2 = inputs, writable = create, readOnly = omitMissing) => this.run(body, values2, writable, depth + 1, readOnly);
+    const yaml = this.yaml;
+    if (expression.kind === "identity") return inputs;
+    if (expression.kind === "group") return next(expression.body);
+    if (expression.kind === "literal") return inputs.map((input) => {
+      const node = scalar(yaml, this.work, expression.value, typeof expression.value === "number");
+      if (yaml.isScalar(node) && expression.source !== void 0) node.source = expression.source;
+      return this.child(node, input);
+    });
+    if (expression.kind === "field") {
+      const output2 = [];
+      for (const base of await next(expression.base)) for (const key of await next(expression.key, [base], false)) output2.push(...await this.field(base, value(key.node, yaml), create, omitMissing));
+      return output2;
+    }
+    if (expression.kind === "slice") {
+      const output2 = [];
+      for (const input of await next(expression.base)) {
+        const base = dereference(input, yaml, this.work);
+        const index = async (bound) => {
+          const matches = await next(bound, [base], false);
+          if (matches.length !== 1) throw new MikeError(`expected to find 1 number, got ${matches.length} instead`);
+          const text = String(value(matches[0].node, yaml));
+          if (!/^[+-]?[0-9]+$/u.test(text)) throw new MikeError(`strconv.ParseInt: parsing ${JSON.stringify(text)}: invalid syntax`);
+          const result = BigInt(text);
+          if (result !== BigInt.asIntN(64, result)) throw new MikeError(`strconv.ParseInt: parsing ${JSON.stringify(text)}: value out of range`);
+          return result;
+        };
+        const start = await index(expression.start);
+        const end = await index(expression.end);
+        const clamp = (offset, length) => {
+          const relative = offset < 0n ? offset + BigInt(length) : offset;
+          return relative < 0n ? 0 : relative > BigInt(length) ? length : Number(relative);
+        };
+        if (yaml.isScalar(base.node) && typeof base.node.value === "string") {
+          let length = 0;
+          for (const character of base.node.value) {
+            {
+              const t = this.work.tick(character.length);
+              if (t) await t;
+            }
+            length++;
+          }
+          const first = clamp(start, length);
+          const last = clamp(end, length);
+          const selected = [];
+          let position = 0;
+          for (const character of base.node.value) {
+            {
+              const t = this.work.tick(character.length);
+              if (t) await t;
+            }
+            if (position >= first && position < last) selected.push(character);
+            position++;
+          }
+          const node = await cloneNode(base.node, yaml, this.work);
+          if (yaml.isScalar(node)) {
+            node.value = selected.join("");
+            node.source = node.value;
+          }
+          output2.push(this.child(node, base));
+        } else {
+          const members = [];
+          if (yaml.isSeq(base.node)) for (const member of base.node.items) {
+            {
+              const t = this.work.tick();
+              if (t) await t;
+            }
+            members.push(member);
+          }
+          else if (yaml.isMap(base.node)) for (const pair of base.node.items) {
+            {
+              const t = this.work.tick();
+              if (t) await t;
+            }
+            members.push(pair.key, pair.value);
+          }
+          this.work.node();
+          const node = new yaml.YAMLSeq();
+          if (base.node.tag || !yaml.isSeq(base.node)) node.tag = base.node.tag ?? `tag:yaml.org,2002:${nodeTag(base.node, yaml).slice(2)}`;
+          for (let position = clamp(start, members.length); position < clamp(end, members.length); position++) node.items.push(await cloneNode(members[position], yaml, this.work));
+          output2.push(this.child(node, base));
+        }
+      }
+      return output2;
+    }
+    if (expression.kind === "iterate" || expression.kind === "recursive") {
+      const output2 = [];
+      for (const input of inputs) {
+        if (expression.kind === "recursive") {
+          output2.push(input);
+          if (yaml.isAlias(input.node)) continue;
+        }
+        const base = dereference(input, yaml, this.work);
+        const children = [];
+        if (yaml.isMap(base.node)) {
+          if (expression.kind === "recursive") base.node.items.forEach((pair, slot) => {
+            if (expression.includeKeys) children.push(this.child(pair.key, base));
+            children.push(this.child(pair.value, base, base.node, slot));
+          });
+          else children.push(...(await this.entries(base)).values());
+        } else if (yaml.isSeq(base.node)) base.node.items.forEach((node, slot) => children.push(this.child(node, base, base.node, slot)));
+        if (expression.kind === "recursive") for (const child of children) output2.push(...await next(expression, [child]));
+        else output2.push(...children);
+      }
+      this.work.node(output2.length);
+      return output2;
+    }
+    if (expression.kind === "pipe") return next(expression.right, await next(expression.left));
+    if (expression.kind === "array") {
+      if (!inputs.length) return [];
+      this.work.node();
+      const node = new yaml.YAMLSeq();
+      if (expression.body) for (const candidate of await next(expression.body, inputs, false)) node.items.push(await cloneNode(candidate.node, yaml, this.work));
+      return [this.child(node, inputs[0])];
+    }
+    if (expression.kind === "object") {
+      const output2 = [];
+      for (const input of inputs) {
+        this.work.node();
+        const node = new yaml.YAMLMap();
+        for (const field of expression.fields) {
+          const key = (await next(field.key, [input], false))[0];
+          const candidate = (await next(field.value, [input], false))[0];
+          if (key && candidate) node.items.push(new yaml.Pair(await cloneNode(key.node, yaml, this.work), await cloneNode(candidate.node, yaml, this.work)));
+        }
+        if (node.items.length || !expression.fields.length) output2.push(this.child(node, input));
+      }
+      return output2;
+    }
+    if (expression.kind === "binary") {
+      const operator = expression.operator;
+      if (operator === ",") {
+        const left2 = await next(expression.left);
+        const right2 = await next(expression.right);
+        this.work.node(left2.length + right2.length);
+        return [...left2, ...right2];
+      }
+      if (["=", "=c", "|=", "+=", "-=", "*=", "/="].includes(operator)) {
+        const attribute = expression.left.kind === "pipe" && expression.left.right.kind === "call" && ["tag", "style"].includes(expression.left.right.name) ? expression.left.right.name : void 0;
+        const lhs = attribute && expression.left.kind === "pipe" ? expression.left.left : expression.left;
+        const targets = await next(lhs, inputs, true);
+        const updates = operator === "|=" ? void 0 : await next(expression.right, inputs, false, true);
+        for (const target of targets) {
+          const candidates = updates ?? (await next(expression.right, [target], false)).slice(0, 1);
+          for (const candidate of candidates) {
+            if (attribute) {
+              const text = String(value(candidate.node, yaml));
+              if (attribute === "tag") {
+                if (!target.node.tag || this.work.implicitTags.has(target.node)) this.work.implicitTags.add(target.node);
+                target.node.tag = text.startsWith("!!") ? `tag:yaml.org,2002:${text.slice(2)}` : text;
+                if (yaml.isScalar(target.node) && text === "!!str") target.node.value = scalarText(target.node, yaml);
+              } else {
+                if (!["", "single", "double", "literal", "folded", "flow", "tagged"].includes(text)) throw new MikeError(`unknown style ${text}`);
+                if (yaml.isScalar(target.node)) target.node.type = text === "single" ? "QUOTE_SINGLE" : text === "double" ? "QUOTE_DOUBLE" : text === "literal" ? "BLOCK_LITERAL" : text === "folded" ? "BLOCK_FOLDED" : "PLAIN";
+                else if (yaml.isCollection(target.node)) target.node.flow = text === "flow";
+              }
+            } else {
+              const updated = operator.length === 2 && operator !== "|=" && operator !== "=c" ? await this.binary(operator[0], target.node, candidate.node) : candidate.node;
+              await replace(target, updated, yaml, this.work, operator === "=c");
+              if (operator === "=c") target.node.tag = `tag:yaml.org,2002:${nodeTag(target.node, yaml).slice(2)}`;
+            }
+          }
+        }
+        return inputs.map((input) => input.isDocumentRoot ? { ...input, node: input.document.doc.contents } : input);
+      }
+      const readOnly = omitMissing || ["+", "==", "!="].includes(operator);
+      const left = await next(expression.left, inputs, false, readOnly);
+      if (operator === "//") {
+        const matches = left.filter((candidate) => truth(candidate.node, yaml));
+        return matches.length ? matches : next(expression.right, inputs, false);
+      }
+      const right = await next(expression.right, inputs, false, readOnly);
+      const output2 = [];
+      if (operator === "+" && (!left.length || !right.length)) return left.length ? left : right;
+      if ((operator === "==" || operator === "!=") && inputs.length && (!left.length || !right.length)) {
+        const candidates = left.length ? left : right.length ? right : [inputs[0]];
+        for (const candidate of candidates) {
+          const equal = !left.length && !right.length || nodeTag(candidate.node, yaml) === "!!null";
+          output2.push(this.child(scalar(yaml, this.work, operator === "==" ? equal : !equal), candidate));
+        }
+        return output2;
+      }
+      for (const first of left) for (const second of right) {
+        const node = operator === "and" || operator === "or" ? scalar(yaml, this.work, operator === "and" ? truth(first.node, yaml) && truth(second.node, yaml) : truth(first.node, yaml) || truth(second.node, yaml)) : await this.binary(operator, first.node, second.node);
+        output2.push(this.child(node, first));
+      }
+      return output2;
+    }
+    if (expression.kind !== "call") throw new MikeError("bad expression, please check expression syntax");
+    const output = [];
+    for (const input of inputs) {
+      const name = expression.name;
+      if (name === "explode") {
+        const targets = await next(expression.args[0], [input], false, true);
+        const expanded = [];
+        for (const target of targets) expanded.push(await this.explode(target));
+        for (let index = 0; index < targets.length; index++) {
+          const target = targets[index];
+          await replace(target, expanded[index], yaml, this.work);
+          if ("anchor" in target.node) delete target.node.anchor;
+          if (target === input) input.node = target.node;
+        }
+        output.push(input.isDocumentRoot ? { ...input, node: input.document.doc.contents } : input);
+        continue;
+      }
+      if (name === "path") {
+        this.work.node();
+        const node = new yaml.YAMLSeq();
+        let candidate = input;
+        while (candidate.ancestry) {
+          {
+            const t = this.work.tick();
+            if (t) await t;
+          }
+          const { parent, key } = candidate.ancestry;
+          node.items.push(typeof key === "number" ? scalar(yaml, this.work, BigInt(key)) : await cloneNode(key, yaml, this.work));
+          candidate = parent;
+        }
+        node.items.reverse();
+        output.push(this.child(node, input));
+        continue;
+      }
+      if (name === "head_comment" || name === "anchor" || name === "alias") {
+        const node = input.node;
+        const text = name === "head_comment" ? this.work.headComments.get(node) ?? "" : name === "anchor" ? "anchor" in node ? node.anchor ?? "" : "" : yaml.isAlias(node) ? node.source : yaml.isScalar(node) ? scalarText(node, yaml) : "";
+        output.push(this.child(scalar(yaml, this.work, text), input));
+        continue;
+      }
+      const base = dereference(input, yaml, this.work);
+      if (name === "sort" || name === "sort_by") {
+        output.push(this.child(await this.sort(base, expression.args[0] ?? { kind: "identity" }, depth), input));
+        continue;
+      }
+      if (name === "reverse") {
+        if (!yaml.isSeq(base.node)) throw new MikeError(`cannot reverse ${nodeTag(base.node, yaml)}, can only reverse arrays`);
+        const node = await cloneNode(base.node, yaml, this.work);
+        {
+          const t = this.work.tick(node.items.length);
+          if (t) await t;
+        }
+        node.items.reverse();
+        output.push(this.child(node, input));
+        continue;
+      }
+      if (name === "to_entries" || name === "from_entries") {
+        if (name === "to_entries" && nodeTag(base.node, yaml) === "!!null") continue;
+        output.push(this.child(name === "to_entries" ? await this.toEntries(base) : await this.fromEntries(base), input));
+        continue;
+      }
+      if (name === "with_entries") {
+        if (nodeTag(base.node, yaml) === "!!null") continue;
+        const entries = this.child(await this.toEntries(base), input);
+        const transformed = new yaml.YAMLSeq();
+        this.work.node();
+        if (entries.node.commentBefore !== void 0) transformed.commentBefore = entries.node.commentBefore;
+        if (entries.node.comment !== void 0) transformed.comment = entries.node.comment;
+        for (const entry of await next({ kind: "iterate" }, [entries], false)) {
+          for (const candidate of await next(expression.args[0], [entry], false)) transformed.items.push(await cloneNode(candidate.node, yaml, this.work));
+        }
+        const node = await this.fromEntries(this.child(transformed, input));
+        output.push(this.child(node, input));
+        continue;
+      }
+      if (name === "pick") {
+        if (!yaml.isCollection(base.node)) throw new MikeError("pick only supports maps and arrays");
+        for (const selected of await next(expression.args[0], [input], false)) {
+          const keys = dereference(selected, yaml, this.work);
+          if (!yaml.isSeq(keys.node)) throw new MikeError("pick expects an array of keys");
+          const node = await cloneNode(base.node, yaml, this.work);
+          node.items = [];
+          for (const key of keys.node.items) {
+            {
+              const t = this.work.tick();
+              if (t) await t;
+            }
+            const requested = value(key, yaml);
+            if (yaml.isMap(base.node) && yaml.isMap(node)) {
+              for (const pair of base.node.items) {
+                {
+                  const t = this.work.tick();
+                  if (t) await t;
+                }
+                if (yaml.isScalar(pair.key) && value(pair.key, yaml) === requested) node.items.push(new yaml.Pair(await cloneNode(pair.key, yaml, this.work), await cloneNode(pair.value, yaml, this.work)));
+              }
+            } else if (yaml.isSeq(base.node) && yaml.isSeq(node)) {
+              const index = nodeTag(key, yaml) === "!!int" ? Number(requested) : NaN;
+              if (Number.isSafeInteger(index) && index >= 0 && index < base.node.items.length) node.items.push(await cloneNode(base.node.items[index], yaml, this.work));
+            }
+          }
+          output.push(this.child(node, input));
+        }
+        continue;
+      }
+      if (name === "upcase" || name === "downcase") {
+        const text = value(base.node, yaml);
+        if (typeof text !== "string") throw new MikeError(`${name} only supports strings`);
+        {
+          const t = this.work.tick(text.length);
+          if (t) await t;
+        }
+        const characters = [];
+        for (const character of text) {
+          {
+            const t = this.work.tick(character.length);
+            if (t) await t;
+          }
+          const converted = name === "upcase" ? character.toUpperCase() : character === "\u0130" ? "i" : character.toLowerCase();
+          characters.push([...converted].length === 1 ? converted : character);
+        }
+        const upper = characters.join("");
+        const node = await cloneNode(base.node, yaml, this.work);
+        if (utf8ByteLength5(upper) > this.work.limits.maxScalarBytes) throw new MikeError("yq limit exceeded: maxScalarBytes");
+        if (yaml.isScalar(node)) {
+          node.value = upper;
+          node.source = upper;
+        }
+        output.push(this.child(node, input));
+        continue;
+      }
+      if (name === "select") {
+        if (!expression.args[0]) throw new MikeError("bad expression, please check expression syntax");
+        if ((await next(expression.args[0], [input], false)).some((candidate) => truth(candidate.node, yaml))) output.push(input);
+        continue;
+      }
+      if (name === "map") {
+        const members = await next({ kind: "iterate" }, [input], false);
+        const node = new yaml.YAMLSeq();
+        this.work.node();
+        for (const member of members) for (const result2 of await next(expression.args[0], [member], false)) node.items.push(await cloneNode(result2.node, yaml, this.work));
+        output.push(this.child(node, input));
+        continue;
+      }
+      if (name === "del") {
+        const slots = /* @__PURE__ */ new Map();
+        for (const candidate of await next(expression.args[0], [input], false)) {
+          {
+            const t = this.work.tick();
+            if (t) await t;
+          }
+          if (!candidate.parent || candidate.slot === void 0) continue;
+          let selected = slots.get(candidate.parent);
+          if (!selected) {
+            selected = /* @__PURE__ */ new Set();
+            slots.set(candidate.parent, selected);
+          }
+          selected.add(candidate.slot);
+        }
+        for (const [parent, selected] of slots) for (const slot of [...selected].sort((left, right) => right - left)) {
+          {
+            const t = this.work.tick();
+            if (t) await t;
+          }
+          parent.items.splice(slot, 1);
+        }
+        output.push(input);
+        continue;
+      }
+      if (name === "env" || name === "strenv") {
+        const key = expression.args[0];
+        if (key?.kind !== "literal") throw new MikeError("bad expression, please check expression syntax");
+        const text = this.work.context.env[String(key.value)] ?? "";
+        if (name === "strenv") output.push(this.child(scalar(yaml, this.work, text), input));
+        else {
+          if (!text) throw new MikeError(`value for env variable '${String(key.value)}' not provided in env()`);
+          const docs = await decodeDocuments(text, "<env>", 0, "yaml", yaml, this.work);
+          output.push(this.child(docs[0].doc.contents, input));
+        }
+        continue;
+      }
+      let result;
+      if (name === "test" || name === "split") {
+        if (nodeTag(base.node, yaml) !== "!!str") throw new MikeError(`cannot ${name} ${nodeTag(base.node, yaml)}, can only ${name} strings`);
+        const text = String(value(base.node, yaml));
+        {
+          const t = this.work.tick(text.length);
+          if (t) await t;
+        }
+        {
+          for (const argument of await next(expression.args[0], [input], false)) {
+            if (nodeTag(argument.node, yaml) !== "!!str") throw new MikeError(`${name} requires a string argument`);
+            const pattern = String(value(argument.node, yaml));
+            {
+              const t = this.work.tick(pattern.length);
+              if (t) await t;
+            }
+            if (name === "split") {
+              const node = new yaml.YAMLSeq();
+              this.work.node();
+              if (!pattern) {
+                for (const part of text) {
+                  {
+                    const t = this.work.tick();
+                    if (t) await t;
+                  }
+                  node.items.push(scalar(yaml, this.work, part));
+                }
+              } else {
+                let start = 0;
+                while (true) {
+                  {
+                    const t = this.work.tick();
+                    if (t) await t;
+                  }
+                  const end = text.indexOf(pattern, start);
+                  node.items.push(scalar(yaml, this.work, text.slice(start, end < 0 ? text.length : end)));
+                  if (end < 0) break;
+                  start = end + pattern.length;
+                }
+              }
+              output.push(this.child(node, input));
+            } else {
+              if (pattern.includes("[") && pattern.includes("\\")) throw new MikeError("unsupported yq regex: brackets combined with escapes");
+              const ledger = this.#regex ??= new EreLedger({ maxExpansionBytes: this.work.limits.maxScalarBytes, maxExpansionFields: this.work.limits.maxNodes }, {
+                patternBytes: Infinity,
+                subjectBytes: Infinity,
+                work: this.work.limits.maxSteps,
+                states: Infinity,
+                allocationUnits: Infinity
+              });
+              const before = ledger.usage.work;
+              try {
+                const program = await compileEre(pattern, ledger, this.work.signal);
+                const subject = await prepareUtf8EreSubject(utf8Encoder3.encode(text), ledger, this.work.signal, true);
+                const matched = await subject(program)(0);
+                output.push(this.child(scalar(yaml, this.work, matched !== void 0), input));
+              } catch (error) {
+                this.work.assertOpen();
+                if (error instanceof EreSyntaxError || error instanceof EreUnsupportedError || error instanceof EreProfileLimitError) throw new MikeError(error.message);
+                throw error;
+              } finally {
+                {
+                  const t = this.work.tick(ledger.usage.work - before);
+                  if (t) await t;
+                }
+              }
+            }
+          }
+          continue;
+        }
+      } else if (name === "tag" || name === "type") result = nodeTag(base.node, yaml);
+      else if (name === "kind") result = yaml.isMap(base.node) ? "map" : yaml.isSeq(base.node) ? "seq" : "scalar";
+      else if (name === "documentIndex" || name === "document_index" || name === "di") result = BigInt(input.document.documentIndex);
+      else if (name === "fileIndex" || name === "file_index" || name === "fi") result = BigInt(input.document.fileIndex);
+      else if (name === "filename") result = input.document.filename;
+      else if (name === "not") result = !truth(base.node, yaml);
+      else if (name === "length") {
+        let length = yaml.isCollection(base.node) ? base.node.items.length : 0;
+        if (yaml.isScalar(base.node) && nodeTag(base.node, yaml) !== "!!null") {
+          const text = scalarText(base.node, yaml);
+          {
+            const t = this.work.tick(text.length);
+            if (t) await t;
+          }
+          length = utf8ByteLength5(text);
+        }
+        result = BigInt(length);
+      } else if (name === "has") {
+        const key = (await next(expression.args[0], [input], false))[0];
+        const keyNode = dereference(key, yaml, this.work).node;
+        result = yaml.isMap(base.node) ? base.node.items.some((pair) => yaml.isScalar(pair.key) && String(pair.key.value) === String(value(key.node, yaml))) : yaml.isSeq(base.node) && nodeTag(keyNode, yaml) === "!!int" && Number(value(keyNode, yaml)) >= 0 && Number(value(keyNode, yaml)) < base.node.items.length;
+      } else if (name === "keys") {
+        if (!yaml.isMap(base.node) && !yaml.isSeq(base.node)) {
+          throw new MikeError(`cannot get keys of ${nodeTag(base.node, yaml)}, keys only works for maps and arrays`);
+        }
+        const node = new yaml.YAMLSeq();
+        this.work.node();
+        if (yaml.isMap(base.node)) for (const pair of base.node.items) {
+          const key = await cloneNode(pair.key, yaml, this.work);
+          delete key.commentBefore;
+          node.items.push(key);
+        }
+        else if (yaml.isSeq(base.node)) base.node.items.forEach((_, index) => node.items.push(scalar(yaml, this.work, BigInt(index))));
+        output.push(this.child(node, input));
+        continue;
+      } else if (name === "style") result = yaml.isScalar(base.node) ? base.node.type === "QUOTE_SINGLE" ? "single" : base.node.type === "QUOTE_DOUBLE" ? "double" : base.node.type === "BLOCK_FOLDED" ? "folded" : base.node.type === "BLOCK_LITERAL" ? "literal" : "" : yaml.isCollection(base.node) && base.node.flow ? "flow" : "";
+      output.push(this.child(scalar(yaml, this.work, result), input));
+    }
+    return output;
+  }
+};
+
+// packages/safe-bash-command-yq/src/mike.ts
+import { writeFileOutputCounted as writeFileOutputCounted2 } from "../safe-bash-contracts/filesystem-output-budget.js";
+
+// packages/safe-bash-command-yq/src/inplace.ts
+init_buffer();
+import { retainFileSystemCleanup } from "@poe-platform/safe-fs/core";
+import { dirname } from "@poe-platform/safe-fs/core";
+import { writeFileOutputCounted } from "../safe-bash-contracts/filesystem-output-budget.js";
+async function captureInPlace(path, work) {
+  const fs = work.context.fs;
+  const resolved = await work.track(fs.realpath(path, { signal: work.signal }));
+  work.assertOpen();
+  const capabilities = fs.capabilitiesFor ? await work.track(fs.capabilitiesFor(resolved, { signal: work.signal })) : fs.capabilities;
+  work.assertOpen();
+  if (!capabilities.atomicFileStaging || !capabilities.atomicStagingAncestry || !fs.createStagedFile || !fs.publishStagedFile || !fs.removeStagedFile) {
+    throw new MikeError("in-place update requires atomic VFS staging and ancestry publication");
+  }
+  const ancestors = [];
+  for (let parent = dirname(resolved); ; parent = dirname(parent)) {
+    const stat = await work.track(fs.lstat(parent, { signal: work.signal }));
+    work.assertOpen();
+    if (stat.type !== "directory") throw new MikeError("in-place target ancestry changed");
+    ancestors.unshift({ path: parent, stat });
+    if (parent === "/") break;
+  }
+  const original = await work.track(fs.lstat(resolved, { signal: work.signal }));
+  work.assertOpen();
+  if (original.type !== "file" || original.nlink !== 1) throw new MikeError("in-place update requires a singly linked regular file");
+  return { path: resolved, original, ancestors };
+}
+async function publishInPlace(target, data, work) {
+  const fs = work.context.fs;
+  const directory = dirname(target.path);
+  const parent = target.ancestors.at(-1).stat;
+  let owned;
+  const cleanup = retainFileSystemCleanup(fs, async (view) => {
+    if (owned) await view.removeStagedFile(owned);
+  }, { maxOperations: 1 });
+  const staging = await work.acquire(async () => {
+    let receipt;
+    try {
+      await writeFileOutputCounted({ signal: work.signal, preserveWriteReceipt: true, ...work.context.registerCleanup ? { registerCleanup: work.context.registerCleanup } : {} }, data, async () => {
+        const token = Array.from(globalThis.crypto.getRandomValues(new Uint8Array(12)), (byte) => byte.toString(16).padStart(2, "0")).join("");
+        receipt = await fs.createStagedFile(`${directory === "/" ? "" : directory}/.yq-${token}`, "file", {
+          type: "file",
+          data
+        }, { parent, mode: target.original.mode & 4095, signal: work.signal });
+        owned = receipt;
+        return data.byteLength;
+      });
+    } catch (error) {
+      await cleanup();
+      throw error;
+    }
+    return receipt;
+  }, cleanup);
+  await work.track(fs.publishStagedFile(staging, target.path, {
+    parent,
+    destination: target.original,
+    ancestors: target.ancestors,
+    signal: work.signal
+  }));
+  work.assertOpen();
+}
+
+// packages/safe-bash-command-yq/src/mike.ts
+async function encodeNodeInfo(candidate, yaml, work) {
+  const node = candidate.node;
+  const kind = yaml.isMap(node) ? "MappingNode" : yaml.isSeq(node) ? "SequenceNode" : yaml.isAlias(node) ? "AliasNode" : "ScalarNode";
+  const styles = { QUOTE_DOUBLE: "DoubleQuotedStyle", QUOTE_SINGLE: "SingleQuotedStyle", BLOCK_LITERAL: "LiteralStyle", BLOCK_FOLDED: "FoldedStyle" };
+  const style = yaml.isScalar(node) ? styles[node.type ?? ""] ?? "" : !yaml.isAlias(node) && node.flow ? "FlowStyle" : "";
+  const location = candidate.isDerived ? void 0 : work.positions.get(node);
+  const info = {
+    kind,
+    style,
+    anchor: "anchor" in node ? node.anchor ?? "" : "",
+    tag: nodeTag(node, yaml),
+    value: yaml.isScalar(node) ? String(node.value ?? "") : yaml.isAlias(node) ? node.source : "",
+    line: location?.line ?? 0,
+    column: location?.column ?? 0
+  };
+  {
+    const t = work.tick();
+    if (t) await t;
+  }
+  work.node(17);
+  return yaml.stringify(info, { singleQuote: true }) + "\n";
+}
+async function writeVerbose(message, work) {
+  const text = `time=${(/* @__PURE__ */ new Date()).toISOString()} level=DEBUG source=safe-bash/yq msg=${JSON.stringify(message)}
+`;
+  work.output(utf8ByteLength6(text));
+  await work.write(utf8Encoder4.encode(text), true);
+}
+function pathOf(context, name) {
+  if (name.includes("\0")) throw new MikeError("path contains NUL");
+  return name.startsWith("/") ? name : `${context.cwd.endsWith("/") ? context.cwd : `${context.cwd}/`}${name}`;
+}
+async function runCommand(context, limits, work) {
+  const commandMode = mikeCommandMode(context.args);
+  try {
+    const options = parseMikeArguments(context);
+    work.capturePositions = options.verbose || options.debugNodeInfo;
+    if (options.help || options.version) {
+      const text = options.help ? commandMode === "eval-all" ? mikeAllHelp : commandMode === "eval" ? mikeEvalHelp : mikeHelp : "yq (safe-bash; bounded Mike Farah v4.53.3 profile)\n";
+      work.output(utf8ByteLength6(text));
+      await work.write(utf8Encoder4.encode(text));
+      return { exitCode: 0 };
+    }
+    const readText = async (filename) => {
+      const path = pathOf(context, filename);
+      const bytes = await work.readFile(path);
+      work.assertOpen();
+      try {
+        return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
+      } catch {
+        throw new MikeError(`bad file '${filename}': invalid UTF-8`);
+      }
+    };
+    let expression = options.fromFile !== void 0 ? await readText(options.fromFile) : options.expression;
+    const splitExpression = options.splitFile !== void 0 ? await readText(options.splitFile) : options.splitExpression;
+    if (options.inplace && splitExpression !== void 0) throw new MikeError("write in place cannot be used with split file");
+    const operands = [...options.operands];
+    if (expression === void 0 && operands.length && operands[0] !== "-") {
+      let exists = false;
+      if (!options.nullInput && !options.inplace && operands.length === 1) {
+        try {
+          exists = (await work.track(context.fs.stat(pathOf(context, operands[0]), { signal: work.signal }))).type !== "directory";
+        } catch (error) {
+          work.assertOpen();
+          if (!(error instanceof FsError)) throw error;
+        }
+      }
+      if (!exists) expression = operands.shift();
+    }
+    expression ??= ".";
+    if (options.inplace && (!operands.length || operands[0] === "-")) throw new MikeError("write in place flag only applicable when giving an expression and at least one file");
+    if (options.nullInput && operands.length) throw new MikeError("cannot pass files in when using null-input flag");
+    const inputOption = mikeFormat(options.input);
+    const outputOption = mikeFormat(options.output);
+    const inferred = operands[0]?.toLowerCase().endsWith(".json") ? "json" : "yaml";
+    const format = inputOption === "auto" ? inferred : inputOption;
+    const output = outputOption === "auto" ? inputOption === "auto" ? inferred : "yaml" : outputOption;
+    const expressionOptions = { ...options, maxExpressionBytes: limits.maxExpressionBytes, maxExpressionDepth: limits.maxExpressionDepth };
+    const program = compileExpression(expression, expressionOptions);
+    if (options.verbose) await writeVerbose(`Compiled expression ${expression}; input=${format}; output=${output}`, work);
+    const splitProgram = splitExpression !== void 0 ? compileExpression(splitExpression, expressionOptions) : void 0;
+    const yaml = await work.track(loadYaml());
+    work.assertOpen();
+    const evaluator = new Evaluator(yaml, work, options.mergeSpec);
+    const results = [];
+    let qualified = false;
+    const frontMatterBodies = /* @__PURE__ */ new Map();
+    let previous;
+    let original;
+    if (options.inplace) {
+      original = await captureInPlace(pathOf(context, operands[0]), work);
+    }
+    const print = async (candidates) => {
+      for (const candidate of candidates) {
+        {
+          const t = work.tick();
+          if (t) await t;
+        }
+        const origin = candidate.isDerived ? { fileIndex: 0, documentIndex: 0 } : candidate.document;
+        const separator = !splitProgram && previous && (previous.fileIndex !== origin.fileIndex || previous.documentIndex !== origin.documentIndex) && output === "yaml" && !options.noDoc ? "---\n" : "";
+        let encoded = options.debugNodeInfo ? await encodeNodeInfo(candidate, yaml, work) : output !== "yaml" && output !== "json" ? await encodeFormat(candidate, output, yaml, work) : await encodeNative(candidate, { format: output, indent: options.indent, unwrap: options.unwrap ?? output === "yaml", compactSequence: options.compactSequence, prettyPrint: options.prettyPrint, preserveDocumentStart: options.headerPreprocess && !options.noDoc }, yaml, work);
+        if (options.verbose) await writeVerbose(`Selected node from ${candidate.document.filename || "stdin"}, document ${candidate.document.documentIndex}: ${await encodeNodeInfo(candidate, yaml, work)}`, work);
+        if (options.nulOutput) {
+          if (encoded.endsWith("\r\n")) encoded = encoded.slice(0, -2);
+          else if (encoded.endsWith("\n") || encoded.endsWith("\r")) encoded = encoded.slice(0, -1);
+          if (encoded.includes("\0")) throw new MikeError("can't serialise value because it contains NUL char and you are using NUL separated output");
+          encoded += "\0";
+        }
+        let text = separator + encoded;
+        const frontMatterBody = frontMatterBodies.get(candidate.document.fileIndex);
+        if (frontMatterBody !== void 0 && options.frontMatter === "process") text = `${text}---
+${frontMatterBody}`;
+        work.output(utf8ByteLength6(text));
+        if (splitProgram) {
+          const names = await evaluator.run(splitProgram, [candidate]);
+          if (names.length !== 1 || !yaml.isScalar(names[0].node) || typeof names[0].node.value !== "string") throw new MikeError("split expression must return a string");
+          const path = pathOf(context, `${names[0].node.value}.${output === "yaml" ? "yml" : output}`);
+          const parent = path.slice(0, path.lastIndexOf("/")) || "/";
+          await work.track(context.fs.mkdir(parent, { recursive: true, signal: work.signal }));
+          work.assertOpen();
+          const data = utf8Encoder4.encode(text);
+          await work.track(writeFileOutputCounted2({ signal: work.signal, ...context.registerCleanup ? { registerCleanup: context.registerCleanup } : {} }, data, async () => {
+            await context.fs.writeFile(path, data, { flag: "w", signal: work.signal });
+            return data.length;
+          }));
+          work.assertOpen();
+        } else if (options.inplace) results.push(text);
+        else await work.write(utf8Encoder4.encode(text));
+        qualified ||= truth(candidate.node, yaml);
+        previous = origin;
+      }
+    };
+    const all = [];
+    if (options.nullInput) {
+      const doc = new yaml.Document();
+      doc.contents = scalar(yaml, work, null);
+      await print(await evaluator.run(program, [root({ doc, filename: "", fileIndex: 0, documentIndex: 0, format: "yaml" })]));
+    } else {
+      for (const [fileIndex, filename] of (operands.length ? operands : ["-"]).entries()) {
+        let bytes;
+        if (filename === "-") bytes = await work.collect(() => context.stdin);
+        else {
+          const path = fileIndex === 0 && original ? original.path : pathOf(context, filename);
+          try {
+            bytes = await work.readFile(path);
+          } catch (error) {
+            work.assertOpen();
+            if (error instanceof FsError) {
+              const description = { ENOENT: "no such file or directory", EACCES: "permission denied", ENOTDIR: "not a directory", EISDIR: "is a directory", ELOOP: "too many levels of symbolic links", EIO: "input/output error" }[error.code];
+              if (description) throw new MikeError(`${error.code === "EISDIR" ? "read" : "open"} ${filename}: ${description}`);
+            }
+            throw error;
+          }
+        }
+        work.assertOpen();
+        let text;
+        try {
+          text = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
+        } catch {
+          throw new MikeError(`bad file '${filename}': invalid UTF-8`);
+        }
+        if (options.frontMatter !== void 0 && fileIndex === 0) {
+          const firstEnd = text.indexOf("\n");
+          let end = firstEnd >= 0 && text.slice(0, firstEnd).trimEnd() === "---" ? firstEnd + 1 : 0;
+          while (end < text.length) {
+            {
+              const t = work.tick();
+              if (t) await t;
+            }
+            const newline = text.indexOf("\n", end);
+            const lineEnd = newline < 0 ? text.length : newline;
+            const line = text.slice(end, lineEnd).trimEnd();
+            if (line === "---" || line === "...") {
+              frontMatterBodies.set(fileIndex, text.slice(newline < 0 ? text.length : newline + 1));
+              text = text.slice(0, end);
+              break;
+            }
+            end = newline < 0 ? text.length : newline + 1;
+          }
+        }
+        await decodeFormat(text, filename, fileIndex, options.frontMatter !== void 0 && fileIndex === 0 ? "yaml" : format, yaml, work, async (document) => {
+          if (options.verbose) await writeVerbose(`Parsed ${filename}, document ${document.documentIndex}`, work);
+          if (options.all) {
+            if (all.length >= limits.maxDocuments) throw new MikeError("yq limit exceeded: maxDocuments");
+            all.push(root(document));
+          } else await print(await evaluator.run(program, [root(document)]));
+        });
+      }
+      if (options.all) await print(await evaluator.run(program, all));
+    }
+    if (options.exitStatus && !qualified) throw new MikeError("no matches found");
+    if (options.inplace) await publishInPlace(original, utf8Encoder4.encode(results.join("")), work);
+    return { exitCode: 0 };
+  } catch (error) {
+    context.signal.throwIfAborted();
+    work.assertOpen();
+    if (error instanceof MikeError) {
+      const selected = commandMode === "eval-all" ? mikeAllHelp : commandMode === "eval" ? mikeEvalHelp : void 0;
+      const usage = selected ? selected.slice(selected.indexOf("Usage:")) + "\n" : mikeUsage;
+      const message = escapeText(`Error: ${error.message}
+${error.usage ? usage : ""}`, "diagnostic");
+      await work.write(utf8Encoder4.encode(message), true);
+      return { exitCode: 1 };
+    }
+    if (error instanceof FsError) {
+      const message = escapeText(error.message, "diagnostic");
+      await work.write(utf8Encoder4.encode(utf8ByteLength6(message) < 65520 ? `Error: ${message}
+` : "Error: yq diagnostic exceeds safety limit\n"), true);
+      return { exitCode: 1 };
+    }
+    throw error;
+  }
+}
+async function execute(context, limits) {
+  const work = new NativeWork(context, limits);
+  let result;
+  let primary;
+  let failed = false;
+  try {
+    result = await runCommand(context, limits, work);
+  } catch (error) {
+    failed = true;
+    primary = error;
+  }
+  try {
+    await work.close();
+  } catch (error) {
+    if (!failed) {
+      failed = true;
+      primary = error;
+    }
+  }
+  context.signal.throwIfAborted();
+  if (failed) throw primary;
+  return result;
+}
+function createMikeYqCommand(options = {}) {
+  if (!options || typeof options !== "object" || Array.isArray(options) || Object.keys(options).some((key) => key !== "limits" && key !== "replace") || options.replace !== void 0 && typeof options.replace !== "boolean") throw new TypeError("invalid yq options");
+  const limits = limitsFor(options.limits);
+  return Object.freeze({ name: "yq", runtimeIdentity: commandRuntimeIdentity, async execute(context) {
+    return execute(context, limits);
+  } });
+}
+function createMikeYqCommands(options = {}) {
+  return Object.freeze([createMikeYqCommand(options)]);
+}
+function mikeYqCommands(options = {}) {
+  const definitions = createMikeYqCommands(options);
+  const replace2 = options.replace ?? false;
+  return Object.freeze({ name: "mike-yq-commands", setup(host) {
+    for (const definition of definitions) host.commands.register(definition, { replace: replace2 });
+  } });
 }
 export {
-  createYqCommand,
-  createYqCommands,
-  yqCommands
+  createMikeYqCommand,
+  createMikeYqCommands,
+  createMikeYqCommand as createYqCommand,
+  createMikeYqCommands as createYqCommands,
+  mikeYqCommands,
+  mikeYqCommands as yqCommands
 };