@poe-platform/safe-bash 0.1.629 → 0.1.631

package/dist/safe-bash/opt-in/commands/yq/expression.js

@@ -0,0 +1,183 @@
+import { MikeError } from "./native-work.js";
+const 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 };
+const functions = new Set(["select", "map", "has", "length", "keys", "tag", "type", "kind", "style", "documentIndex", "di", "fileIndex", "fi", "filename", "env", "strenv", "del", "not"]);
+export function compileExpression(source) {
+    if (Buffer.byteLength(source) > 8192)
+        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 (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 = (value) => ({ kind: "literal", value });
+    const parse = (minimum = 0) => {
+        if (++nesting > 64)
+            throw new MikeError("yq limit exceeded: expression depth");
+        const token = take();
+        let result;
+        if (token.text === ".") {
+            result = { kind: "identity" };
+            if (peek().kind === "name" || peek().kind === "string") {
+                const key = take();
+                result = { kind: "field", base: result, key: literal(key.kind === "string" ? JSON.parse(key.text) : key.text) };
+            }
+        }
+        else if (token.text === "..")
+            result = { kind: "recursive" };
+        else if (token.text === "(") {
+            result = { kind: "group", body: parse() };
+            expect(")");
+        }
+        else if (token.text === "[") {
+            result = 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("}");
+            result = { kind: "object", fields };
+        }
+        else if (token.text === "-")
+            result = { kind: "binary", operator: "*", left: literal(-1n), right: parse(10) };
+        else if (token.kind === "number")
+            result = literal(/[.eE]/u.test(token.text) ? Number(token.text) : BigInt(token.text));
+        else if (token.kind === "string")
+            result = literal(JSON.parse(token.text));
+        else if (["true", "false", "null"].includes(token.text))
+            result = literal(JSON.parse(token.text));
+        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"].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");
+            result = { 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();
+                result = { kind: "field", base: result, key: literal(key.kind === "string" ? JSON.parse(key.text) : key.text) };
+                continue;
+            }
+            if (peek().text === "[") {
+                take();
+                if (peek().text === "]")
+                    result = { kind: "pipe", operator: "|", left: result, 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();
+                        result = { kind: "slice", base: result, start, end };
+                    }
+                    else
+                        result = { kind: "field", base: result, key: start };
+                }
+                expect("]");
+                continue;
+            }
+            if ((peek().text === "tag" || peek().text === "style") && minimum <= 3) {
+                result = { kind: "pipe", operator: "|", left: result, right: { kind: "call", name: take().text, args: [] } };
+                continue;
+            }
+            const operator = peek().text;
+            const priority = priorities[operator];
+            if (priority === undefined || priority < minimum)
+                break;
+            take();
+            if (operator === "//" && peek().text === "=")
+                throw new MikeError("'//' expects 2 args but there is 1");
+            result = { kind: operator === "|" ? "pipe" : "binary", operator, left: result, right: parse(priority + (priority === 3 ? 0 : 1)) };
+        }
+        nesting--;
+        return result;
+    };
+    if (!source.trim())
+        return { kind: "identity" };
+    const result = parse();
+    if (peek().kind !== "end")
+        throw new MikeError("bad expression, please check expression syntax");
+    return result;
+}

package/dist/safe-bash/opt-in/commands/yq/inplace.js

@@ -0,0 +1,65 @@
+import { randomBytes } from "node:crypto";
+import { retainFileSystemCleanup } from "@poe-platform/safe-fs/core";
+import { FsError } from "@poe-platform/safe-bash/contracts/index";
+import { writeFileOutputCounted } from "@poe-platform/safe-bash/contracts/filesystem-output";
+import { MikeError } from "./native-work.js";
+export async function publishInPlace(path, data, original, work) {
+    const fs = work.context.fs;
+    const parent = path.slice(0, path.lastIndexOf("/")) || "/";
+    const temporary = `${parent === "/" ? "" : parent}/.yq-${randomBytes(12).toString("hex")}`;
+    let created = false;
+    const capabilities = fs.capabilitiesFor ? await work.track(fs.capabilitiesFor(parent, { signal: work.signal })) : fs.capabilities;
+    work.assertOpen();
+    if (!capabilities.write || !capabilities.exclusiveCreate || !capabilities.remove)
+        throw new MikeError("in-place update requires VFS write, exclusive creation and removal capabilities");
+    const outputContext = { signal: work.signal, ...(work.context.registerCleanup ? { registerCleanup: work.context.registerCleanup } : {}) };
+    let settled;
+    const writerDone = new Promise(resolve => { settled = resolve; });
+    work.register(retainFileSystemCleanup(fs, async (cleanup) => {
+        await writerDone;
+        if (created) {
+            try {
+                await cleanup.rm(temporary);
+            }
+            catch (error) {
+                if (!(error instanceof FsError) || error.code !== "ENOENT")
+                    throw error;
+            }
+        }
+    }, { maxOperations: 1 }));
+    try {
+        await work.track(writeFileOutputCounted(outputContext, data, async () => {
+            await fs.writeFile(temporary, data, { flag: "wx", mode: original.mode & 0o7777, signal: work.signal });
+            created = true;
+            return data.byteLength;
+        }));
+    }
+    finally {
+        settled();
+    }
+    work.assertOpen();
+    if (fs.chmod && capabilities.permissions) {
+        await work.track(fs.chmod(temporary, original.mode & 0o7777, { signal: work.signal }));
+        work.assertOpen();
+    }
+    const target = await work.track(fs.lstat(path, { signal: work.signal }));
+    work.assertOpen();
+    if (target.type !== "symlink" && capabilities.rename) {
+        try {
+            await work.track(fs.rename(temporary, path, { signal: work.signal }));
+            created = false;
+            work.assertOpen();
+            return;
+        }
+        catch (error) {
+            work.assertOpen();
+            if (!(error instanceof FsError))
+                throw error;
+        }
+    }
+    await work.track(writeFileOutputCounted(outputContext, data, async () => {
+        await fs.writeFile(path, data, { flag: "w", signal: work.signal });
+        return data.byteLength;
+    }));
+    work.assertOpen();
+}

package/dist/safe-bash/opt-in/commands/yq/mike.d.ts

@@ -0,0 +1,9 @@
+import { type CommandDefinition, type VirtualShellPlugin } from "@poe-platform/safe-bash/contracts/index";
+import { type MikeLimits } from "./native-work.js";
+export interface MikeYqOptions {
+    readonly limits?: Partial<MikeLimits>;
+    readonly replace?: boolean;
+}
+export declare function createMikeYqCommand(options?: MikeYqOptions): CommandDefinition;
+export declare function createMikeYqCommands(options?: MikeYqOptions): readonly CommandDefinition[];
+export declare function mikeYqCommands(options?: MikeYqOptions): VirtualShellPlugin;

package/dist/safe-bash/opt-in/commands/yq/mike.js

@@ -0,0 +1,192 @@
+import { commandRuntimeIdentity, FsError } from "@poe-platform/safe-bash/contracts/index";
+import { mikeCommandMode, mikeFormat, mikeHelp, mikeUsage, mikeEvalHelp, mikeAllHelp, parseMikeArguments } from "./arguments.js";
+import { compileExpression } from "./expression.js";
+import { Evaluator } from "./evaluate.js";
+import { decodeDocuments, loadYaml, root, scalar, truth } from "./nodes.js";
+import { encodeNative } from "./native-encoder.js";
+import { limitsFor, MikeError, NativeWork } from "./native-work.js";
+import { publishInPlace } from "./inplace.js";
+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);
+        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(Buffer.byteLength(text));
+            await work.write(Buffer.from(text));
+            return { exitCode: 0 };
+        }
+        let expression = options.expression;
+        const operands = [...options.operands];
+        if (expression === undefined && operands.length && operands[0] !== "-") {
+            let exists = false;
+            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 program = compileExpression(expression);
+        const yaml = await work.track(loadYaml());
+        work.assertOpen();
+        const evaluator = new Evaluator(yaml, work, options.mergeSpec);
+        const results = [];
+        let qualified = false;
+        let previous;
+        let original;
+        if (options.inplace) {
+            original = await work.track(context.fs.stat(pathOf(context, operands[0]), { signal: work.signal }));
+            work.assertOpen();
+        }
+        const print = async (candidates) => {
+            for (const candidate of candidates) {
+                await work.tick();
+                const separator = previous && (previous.fileIndex !== candidate.document.fileIndex || previous.documentIndex !== candidate.document.documentIndex) && output === "yaml" && !options.noDoc ? "---\n" : "";
+                const text = separator + await encodeNative(candidate, { format: output, indent: options.indent, unwrap: options.unwrap ?? output === "yaml", compactSequence: options.compactSequence }, yaml, work);
+                work.output(Buffer.byteLength(text));
+                if (options.inplace)
+                    results.push(text);
+                else
+                    await work.write(Buffer.from(text));
+                qualified ||= truth(candidate.node, yaml);
+                previous = candidate.document;
+            }
+        };
+        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 = pathOf(context, filename);
+                    try {
+                        if (context.fs.readStream)
+                            bytes = await work.collect(() => context.fs.readStream(path, { signal: work.signal }));
+                        else {
+                            bytes = await work.track(context.fs.readFile(path, { signal: work.signal, maxBytes: limits.maxInputBytes }));
+                            work.input(bytes.length);
+                        }
+                    }
+                    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`);
+                }
+                await decodeDocuments(text, filename, fileIndex, format, yaml, work, async (document) => {
+                    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(pathOf(context, operands[0]), Buffer.from(results.join("")), original, work);
+        return { exitCode: 0 };
+    }
+    catch (error) {
+        context.signal.throwIfAborted();
+        work.assertOpen();
+        if (error instanceof MikeError) {
+            const selected = commandMode === "eval-all" ? mikeAllHelp : commandMode === "eval" ? mikeEvalHelp : undefined;
+            const usage = selected ? selected.slice(selected.indexOf("Usage:")) + "\n" : mikeUsage;
+            const message = `Error: ${error.message}\n${error.usage ? usage : ""}`;
+            await work.write(Buffer.from(Buffer.byteLength(message) <= 65536 ? message : "Error: yq diagnostic exceeds safety limit\n"), true);
+            return { exitCode: 1 };
+        }
+        if (error instanceof FsError) {
+            await work.write(Buffer.from(Buffer.byteLength(error.message) < 65520 ? `Error: ${error.message}\n` : "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;
+}
+export function createMikeYqCommand(options = {}) {
+    if (!options || typeof options !== "object" || Array.isArray(options) || Object.keys(options).some(key => key !== "limits" && key !== "replace") || options.replace !== undefined && 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); } });
+}
+export function createMikeYqCommands(options = {}) {
+    return Object.freeze([createMikeYqCommand(options)]);
+}
+export function mikeYqCommands(options = {}) {
+    const definitions = createMikeYqCommands(options);
+    const replace = options.replace ?? false;
+    return Object.freeze({ name: "mike-yq-commands", setup(host) {
+            for (const definition of definitions)
+                host.commands.register(definition, { replace });
+        } });
+}

package/dist/safe-bash/opt-in/commands/yq/native-encoder.js

@@ -0,0 +1,165 @@
+import { cloneNode, dereference, inspectNode } from "./nodes.js";
+import { mikeLimits, MikeError } from "./native-work.js";
+export 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 = (text) => {
+        const incoming = Buffer.byteLength(text);
+        if (incoming > work.limits.maxOutputBytes - bytes)
+            throw new MikeError("yq limit exceeded: maxOutputBytes");
+        bytes += incoming;
+        chunks.push(text);
+    };
+    const indent = (depth) => {
+        const count = spacing * depth;
+        if (count > work.limits.maxOutputBytes - bytes)
+            throw new MikeError("yq limit exceeded: maxOutputBytes");
+        append(" ".repeat(count));
+    };
+    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);
+    };
+    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)}\n`;
+    if (options.format === "json") {
+        const write = async (current, depth) => {
+            await work.tick();
+            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`);
+                }
+                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 text = node.value;
+                    if (/^[+-]?[0-9]+$/u.test(text))
+                        append(BigInt(text).toString());
+                    else if (/^[+-]?[0-9]+\.[0-9]+$/u.test(text))
+                        append(JSON.stringify(Number(text)));
+                    else if (["true", "false", "null"].includes(text))
+                        append(text);
+                    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();
+        await work.tick();
+        projected += 32 + depth * Math.max(options.indent, 2) + 6 * Buffer.byteLength(node.comment ?? "") + 6 * Buffer.byteLength(node.commentBefore ?? "");
+        if (yaml.isScalar(node))
+            projected += 6 * Buffer.byteLength(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");
+    }
+    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();
+        await work.tick();
+        if (work.implicitTags.has(node) && node.tag?.startsWith("tag:yaml.org,2002:"))
+            delete node.tag;
+        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) {
+        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("");
+}

package/dist/safe-bash/opt-in/commands/yq/native-work.d.ts

@@ -0,0 +1,44 @@
+import { type ByteSource, type CommandContext, type InvocationCleanup } from "@poe-platform/safe-bash/contracts/index";
+export declare const mikeLimits: Readonly<{
+    maxInputBytes: number;
+    maxDocumentBytes: number;
+    maxScalarBytes: number;
+    maxNodes: 100000;
+    maxParserNodes: 4096;
+    maxDepth: 64;
+    maxAliases: 1024;
+    maxDocuments: 1024;
+    maxOutputBytes: number;
+    maxSteps: 8000000;
+}>;
+export type MikeLimits = {
+    readonly [Key in keyof typeof mikeLimits]: number;
+};
+export declare class MikeError extends Error {
+    readonly usage: boolean;
+    constructor(message: string, usage?: boolean);
+}
+export declare function limitsFor(options?: Partial<MikeLimits>): MikeLimits;
+export declare class NativeWork {
+    #private;
+    readonly context: CommandContext;
+    readonly limits: MikeLimits;
+    readonly implicitTags: WeakSet<object>;
+    readonly controller: AbortController;
+    readonly signal: AbortSignal;
+    constructor(context: CommandContext, limits: MikeLimits);
+    assertOpen(): void;
+    tick(units?: number): Promise<void>;
+    input(bytes: number): void;
+    node(count?: number): void;
+    alias(): void;
+    document(): void;
+    depth(depth: number): void;
+    output(bytes: number): void;
+    register(cleanup: InvocationCleanup): void;
+    track<Value>(promise: Promise<Value>): Promise<Value>;
+    acquire<Value>(start: () => Value | Promise<Value>, release: (value: Value) => void | Promise<void>): Promise<Value>;
+    collect(start: () => ByteSource): Promise<Uint8Array>;
+    write(bytes: Uint8Array, stderr?: boolean): Promise<void>;
+    close(): Promise<void>;
+}