@poe-platform/safe-bash 0.1.799 → 0.1.800

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

@@ -0,0 +1,735 @@
+import {
+  parseTomlDocument
+} from "../safe-bash/command-chunks/chunk-L22T3H7L.js";
+import {
+  encodeJson,
+  encodeRaw,
+  encodeYaml
+} from "../safe-bash/command-chunks/chunk-6XMBTEUK.js";
+import {
+  parseYamlDocuments
+} from "../safe-bash/command-chunks/chunk-LHIOAFWW.js";
+import {
+  YqLedger,
+  resolveYqLimits,
+  yqCaps
+} from "../safe-bash/command-chunks/chunk-EMPU65ZK.js";
+import {
+  YqError,
+  fromJqLimit
+} from "../safe-bash/command-chunks/chunk-DW2F3N6R.js";
+import {
+  init_buffer
+} from "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-yq/src/query.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);
+    }
+  }
+  finish(bytes) {
+    if (this.#lineBytes > 0) {
+      this.#pendingCr = false;
+      this.#finishLine(this.#offset);
+    }
+    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
+    }));
+  }
+  #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++;
+  }
+};
+var SinkFailure = class {
+  constructor(reason) {
+    this.reason = reason;
+  }
+  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");
+  }
+  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);
+  }
+  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");
+    })();
+    void this.#closePromise.catch(() => {
+    });
+    return this.#closePromise;
+  }
+};
+function cli(code) {
+  return new YqError("cli", code, 2);
+}
+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;
+  }
+  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 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;
+}
+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;
+    }
+    if (!ended && (argument === "-p" || argument.startsWith("-p=") || argument === "--input-format" || argument.startsWith("--input-format="))) {
+      if (inputFormatSeen) throw cli("CLI_DUPLICATE_OPTION");
+      const value = argument.startsWith("-p=") ? argument.slice(3) : 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 (!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;
+    }
+    if (!ended && (argument.startsWith("--output-format=") || argument.startsWith("-o="))) {
+      if (formatSeen) throw cli("CLI_DUPLICATE_OPTION");
+      const value = argument.slice(argument.startsWith("-o=") ? 3 : "--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;
+    }
+    if (!ended && (argument === "-c" || argument === "--compact-output")) {
+      if (compactSeen) throw cli("CLI_DUPLICATE_OPTION");
+      compactSeen = true;
+      compact = true;
+      continue;
+    }
+    if (!ended && (argument === "-r" || argument === "--unwrapScalar")) {
+      if (rawSeen) throw cli("CLI_DUPLICATE_OPTION");
+      rawSeen = true;
+      raw = true;
+      continue;
+    }
+    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}`;
+  }
+  return `yq: ${error.category}: ${error.code}${location}
+`;
+}
+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;
+  };
+  owner.register(async () => {
+    await closeProducer();
+  });
+  let iterator;
+  let returned;
+  owner.register(async () => {
+    if (iterator?.return) {
+      returned ??= Promise.resolve().then(() => iterator.return());
+      await returned;
+    }
+  });
+  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
+    };
+  } }, 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;
+    }
+    return collectSource(context, owner, session, sourceName, source, true, inputFormat);
+  }
+  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);
+  }
+}
+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;
+  };
+  const stderrOperation = () => {
+    stderr ??= createOutputOperation({ signal: context.signal, registerCleanup: (cleanup) => owner.register(cleanup) }, context.stderr);
+    return stderr;
+  };
+  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);
+  };
+  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;
+        }
+        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;
+        }
+      }
+    }
+    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;
+  }
+  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)
+  });
+}
+function createYqCommands(options = {}) {
+  return Object.freeze([createYqCommand(options)]);
+}
+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}`);
+      }
+      for (const definition of definitions) host.commands.register(definition, { replace: replace ?? false });
+    }
+  };
+  return Object.freeze(plugin);
+}
+export {
+  createYqCommand,
+  createYqCommands,
+  yqCommands
+};