@poe-platform/safe-bash 0.1.630 → 0.1.632

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

@@ -0,0 +1,188 @@
+import { createOutputOperation } from "@poe-platform/safe-bash/contracts/index";
+import { yieldTurn } from "@poe-platform/safe-bash/contracts/yield";
+export const mikeLimits = Object.freeze({
+    maxInputBytes: 8 * 1024 * 1024, maxDocumentBytes: 1024 * 1024,
+    maxScalarBytes: 256 * 1024, maxNodes: 100_000, maxParserNodes: 4096,
+    maxDepth: 64, maxAliases: 1024, maxDocuments: 1024,
+    maxOutputBytes: 16 * 1024 * 1024, maxSteps: 8_000_000,
+});
+export class MikeError extends Error {
+    usage;
+    constructor(message, usage = false) {
+        super(message);
+        this.usage = usage;
+    }
+}
+export function limitsFor(options = {}) {
+    if (!options || typeof options !== "object" || Array.isArray(options))
+        throw new TypeError("invalid yq limits");
+    const limits = { ...mikeLimits };
+    for (const [name, value] of Object.entries(options)) {
+        if (!Object.hasOwn(limits, name) || !Number.isSafeInteger(value) || value < 1 || value > mikeLimits[name]) {
+            throw new TypeError(`invalid yq limit: ${name}`);
+        }
+        limits[name] = value;
+    }
+    return Object.freeze(limits);
+}
+export class NativeWork {
+    context;
+    limits;
+    implicitTags = new WeakSet();
+    controller = new AbortController();
+    signal = this.controller.signal;
+    #cleanup = [];
+    #pending = new Set();
+    #closing;
+    #open = true;
+    #steps = 0;
+    #yieldAt = 1024;
+    #input = 0;
+    #nodes = 0;
+    #aliases = 0;
+    #output = 0;
+    #documents = 0;
+    constructor(context, limits) {
+        this.context = context;
+        this.limits = limits;
+        context.registerCleanup?.(() => this.close());
+        const abort = () => this.controller.abort(context.signal.reason);
+        if (context.signal.aborted)
+            abort();
+        else
+            context.signal.addEventListener("abort", abort, { once: true });
+        this.#cleanup.push(() => { context.signal.removeEventListener("abort", abort); });
+    }
+    assertOpen() {
+        this.context.signal.throwIfAborted();
+        this.signal.throwIfAborted();
+        if (!this.#open)
+            throw new MikeError("yq invocation is closed");
+    }
+    async 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;
+            await yieldTurn(this.signal);
+            this.assertOpen();
+        }
+    }
+    input(bytes) {
+        this.assertOpen();
+        if (bytes > this.limits.maxInputBytes - this.#input)
+            throw new MikeError("yq limit exceeded: maxInputBytes");
+        this.#input += bytes;
+    }
+    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) { 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 value = await this.track(Promise.resolve().then(() => { this.assertOpen(); return start(); }));
+            resource = { value };
+            settled();
+            this.assertOpen();
+            return value;
+        }
+        catch (error) {
+            settled();
+            await dispose();
+            throw error;
+        }
+    }
+    async collect(start) {
+        const iterator = await this.acquire(() => start()[Symbol.asyncIterator](), async (value) => { await value.return?.(); });
+        const chunks = [];
+        let size = 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;
+            }
+            await this.tick();
+        }
+        const result = new Uint8Array(size);
+        let offset = 0;
+        for (const chunk of chunks) {
+            result.set(chunk, offset);
+            offset += chunk.length;
+            await this.tick();
+        }
+        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.#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.#closing.catch(() => { });
+        return this.#closing;
+    }
+}