@poe-platform/safe-bash 0.1.799 → 0.1.800

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

@@ -0,0 +1,147 @@
+import {
+  parsePredicate
+} from "./chunk-XJXU3VVH.js";
+import {
+  XmlQueryError,
+  XmlQueryLimitError
+} from "./chunk-NXEQ3ESQ.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-xml-engine/src/query.ts
+init_buffer();
+var nameStart = (character) => character >= "a" && character <= "z" || character >= "A" && character <= "Z" || character === "_";
+var namePart = (character) => nameStart(character) || character >= "0" && character <= "9" || character === "-" || character === ".";
+async function parseQuery(source, budget) {
+  const query = await parseSyntax(source, budget);
+  const pending = [{ query, depth: 0 }];
+  while (pending.length) {
+    const current = pending.pop();
+    const programs = current.query.expression ? [current.query.expression] : current.query.paths.flatMap((path) => path.flatMap((step) => step.predicates));
+    for (const program of programs) for (const instruction of program) {
+      if (instruction.kind !== "path") continue;
+      if (current.depth >= budget.limits.maxDepth) throw new XmlQueryLimitError("maxDepth");
+      instruction.query = await parseSyntax(instruction.source, budget);
+      pending.push({ query: instruction.query, depth: current.depth + 1 });
+    }
+  }
+  return query;
+}
+async function parseSyntax(source, budget) {
+  if (source.length > budget.limits.maxSourceBytes || new TextEncoder().encode(source).byteLength > budget.limits.maxSourceBytes)
+    throw new XmlQueryLimitError("maxSourceBytes");
+  for (let offset = 0; offset < source.length; offset += 256)
+    await budget.tick(Math.min(256, source.length - offset));
+  let at = 0;
+  const fail = () => {
+    throw new XmlQueryError(`unsupported XPath syntax at offset ${at}`, 10);
+  };
+  const space = () => {
+    while (source[at] === " " || source[at] === "	" || source[at] === "\r" || source[at] === "\n")
+      at++;
+  };
+  const expect = (value) => {
+    space();
+    if (!source.startsWith(value, at)) fail();
+    at += value.length;
+  };
+  const name = () => {
+    space();
+    const start2 = at;
+    if (!nameStart(source[at] ?? "")) fail();
+    while (namePart(source[at] ?? "")) at++;
+    if (source[at] === ":") fail();
+    return source.slice(start2, at);
+  };
+  space();
+  const start = at;
+  if (nameStart(source[at] ?? "")) {
+    while (namePart(source[at] ?? "")) at++;
+    const selected = source.slice(start, at);
+    space();
+    if (source[at] === "(" && selected !== "text")
+      return { paths: [], expression: parsePredicate(source, budget) };
+  }
+  at = start;
+  const paths = [];
+  let morePaths;
+  do {
+    const steps = [];
+    paths.push(steps);
+    space();
+    do {
+      let descendant = false;
+      if (source[at] === "/") {
+        at++;
+        descendant = source[at] === "/";
+        if (descendant) at++;
+      }
+      space();
+      let kind = "element";
+      if (source[at] === "@") {
+        kind = "attribute";
+        at++;
+      }
+      let selected;
+      if (source[at] === ".") {
+        at++;
+        selected = ".";
+        kind = source[at] === "." ? "parent" : "self";
+        if (kind === "parent") at++;
+      } else if (source[at] === "*") {
+        selected = "*";
+        at++;
+      } else {
+        selected = name();
+        space();
+        if (source[at] === "(") {
+          if (selected !== "text" || kind !== "element") fail();
+          expect("(");
+          expect(")");
+          kind = "text";
+        }
+      }
+      const predicates = [];
+      space();
+      while (source[at] === "[") {
+        at++;
+        space();
+        const start2 = at;
+        let quote = "", depth = 0;
+        while (at < source.length) {
+          const character = source[at];
+          if (quote) {
+            if (character === quote) quote = "";
+          } else if (character === "'" || character === '"') quote = character;
+          else if (character === "[") depth++;
+          else if (character === "]") {
+            if (depth === 0) break;
+            depth--;
+          }
+          at++;
+        }
+        if (at === source.length) fail();
+        predicates.push(parsePredicate(source.slice(start2, at), budget));
+        expect("]");
+        space();
+      }
+      steps.push({ descendant, kind, name: selected, predicates });
+      if ((kind === "attribute" || kind === "text") && source[at] === "/") fail();
+      {
+        const _p = budget.tick();
+        if (_p) await _p;
+      }
+    } while (source[at] === "/");
+    space();
+    morePaths = source[at] === "|";
+    if (morePaths) at++;
+  } while (morePaths);
+  space();
+  if (at !== source.length) fail();
+  return { paths };
+}
+
+export {
+  parseQuery
+};

package/dist/safe-bash/command-chunks/{chunk-HLBX5IRS.js → chunk-JQ74HC37.js}

@@ -6,14 +6,14 @@ import {
 init_buffer();
 import { utf8ByteLength, filledBytes, concatBytes, bytesFrom } from "../../safe-bash-byte-engine/index.js";
 import { FsError, readBytes, toByteSource, writeBytes } from "../../safe-bash-contracts/index.js";
-import { getLastReadMemoryFileSourceRef, tryReadMemoryFileViewSync, tryResolveMemoryDevicePath } from "@poe-platform/safe-fs/core";
+import { tryReadMemoryFileViewSync, tryResolveMemoryDevicePath } from "@poe-platform/safe-fs/core";
 import { getRuntimeBackingFileSystem } from "../../safe-bash-contracts/runtime-control.js";
 import { pathOf, RESOLVED_EXIT_ZERO } from "../../safe-bash-io-engine/internal.js";
 import { createSyncSingleChunkByteSource } from "../../safe-bash-io-engine/commands/search/requirements.js";
 import { joinPath } from "../../safe-bash-contracts/path.js";
 import { escapeText, writeDiagnostic } from "../../safe-bash-contracts/escaping.js";
 import { Budget, copyObject, interruptible, JqHalt, JqError, JqLimitError, object, put, resolveJqLimits, truth, wellFormed } from "../../safe-bash-query-engine/limits.js";
-import { getLastFastSelectProjectSavedOutBuf, jsonValues, parseJson, rawValues, stringify, tryProcessFlatJsonChunkSync, tryProcessFlatSelectProjectChunkSync, tryWriteCompactSync } from "../../safe-bash-query-engine/input.js";
+import { jsonValues, parseJson, rawValues, stringify, tryProcessFlatJsonChunkSync, tryProcessFlatSelectProjectChunkSync, tryWriteCompactSync } from "../../safe-bash-query-engine/input.js";
 import { Interpreter } from "../../safe-bash-query-engine/interpreter.js";
 import { moduleProgram, parse } from "../../safe-bash-query-engine/parser.js";
 import { sortObjectKeys } from "../../safe-bash-query-engine/values.js";
@@ -176,7 +176,7 @@ function tryExecuteJqFastSync(context, limits) {
   if (absolute === "/dev" || absolute.startsWith("/dev/")) return void 0;
   let rawBytes;
   try {
-    rawBytes = tryReadMemoryFileViewSync(fastMemFs, absolute, void 0, context.signal, true);
+    rawBytes = tryReadMemoryFileViewSync(fastMemFs, absolute, void 0, context.signal);
   } catch {
     return void 0;
   }
@@ -184,7 +184,6 @@ function tryExecuteJqFastSync(context, limits) {
     return void 0;
   }
   let budget = sharedFastBudget;
-  const rawSourceRef = getLastReadMemoryFileSourceRef(rawBytes);
   if (!budget || budget.limits !== limits) {
     budget = sharedFastBudget = new Budget(limits, context.signal);
   } else {
@@ -220,7 +219,7 @@ function tryExecuteJqFastSync(context, limits) {
     budget.inputLocation.line = 0;
     budget.inputLocation.complete = false;
     const spPlan = getFastSelectProjectPlan(cachedAst);
-    const fastPos = spPlan ? tryProcessFlatSelectProjectChunkSync(rawBytes, budget, spPlan.condKey, spPlan.outKeys, spPlan.srcKeys, outBuf, spPlan, rawSourceRef) : -1;
+    const fastPos = spPlan ? tryProcessFlatSelectProjectChunkSync(rawBytes, budget, spPlan.condKey, spPlan.outKeys, spPlan.srcKeys, outBuf, spPlan) : -1;
     if (fastPos >= 0) {
       sharedFastJqOutPos = fastPos;
     } else {
@@ -240,8 +239,7 @@ function tryExecuteJqFastSync(context, limits) {
       sharedFastJqOutPos = 0;
       context.signal.throwIfAborted();
       committing = true;
-      const savedOut = fastPos >= 0 ? getLastFastSelectProjectSavedOutBuf(len) : void 0;
-      const wrote = savedOut !== void 0 && typeof syncSink.writeImmutableSync === "function" ? syncSink.writeImmutableSync(savedOut) : typeof syncSink.writeRangeSync === "function" ? syncSink.writeRangeSync(outBuf, len) : syncSink.writeSync(outBuf.subarray(0, len));
+      const wrote = typeof syncSink.writeRangeSync === "function" ? syncSink.writeRangeSync(outBuf, len) : syncSink.writeSync(outBuf.subarray(0, len));
       if (!wrote) return void 0;
     }
     if (jqAstCache.size < 64) jqAstCache.set(source, cachedAst);
@@ -686,7 +684,7 @@ function inputs(context, options, budget, convert, onValue, onChunkEnd, hasPendi
         if (tickPromise) {
           return (async function* () {
             await tickPromise;
-            yield* inputs(context, options, budget, convert, onValue, onChunkEnd, hasPendingDiagnostics);
+            yield* inputs(context, options, budget, convert, onValue, onChunkEnd, hasPendingDiagnostics, retainValues);
           })();
         }
         context.signal.throwIfAborted();
@@ -880,15 +878,19 @@ async function executeJqAsync(context, limits, convert) {
       }
     };
     const emitRemainingAsync = async (syncResults, startIdx, initialLast) => {
-      let invocationLast = initialLast;
-      for (let idx = startIdx; idx < syncResults.length; idx++) {
-        const r = syncResults[idx];
-        await publishResult(r);
-        invocationLast = r;
-        status = options.exitStatus ? truth(r) ? 0 : 1 : 0;
+      try {
+        let invocationLast = initialLast;
+        for (let idx = startIdx; idx < syncResults.length; idx++) {
+          const r = syncResults[idx];
+          await publishResult(r);
+          invocationLast = r;
+          status = options.exitStatus ? truth(r) ? 0 : 1 : 0;
+        }
+        if (status < 2 && invocationLast !== void 0) lastTruth = truth(invocationLast);
+        if (diagnostics.length) await flush();
+      } finally {
+        interpreter.releaseScratch();
       }
-      if (status < 2 && invocationLast !== void 0) lastTruth = truth(invocationLast);
-      if (diagnostics.length) await flush();
     };
     const emitSyncOrAsync = (input) => {
       if (!diagnostics.length && !options.rawOutput0 && interpreter.run === DEFAULT_INTERPRETER_RUN) {
@@ -917,20 +919,6 @@ async function executeJqAsync(context, limits, convert) {
       if (diagnostics.length) await flush();
       status = options.exitStatus ? lastTruth === void 0 ? 4 : lastTruth ? 0 : 1 : 0;
       let invocationLast;
-      if (!options.rawOutput0 && interpreter.run === DEFAULT_INTERPRETER_RUN) {
-        const syncResults = interpreter.tryRunSync(ast, input);
-        if (syncResults !== void 0) {
-          for (let i = 0; i < syncResults.length; i++) {
-            const result = syncResults[i];
-            if (!tryPublishSync(result)) await publishResult(result);
-            invocationLast = result;
-            status = options.exitStatus ? truth(result) ? 0 : 1 : 0;
-          }
-          if (status < 2 && invocationLast !== void 0) lastTruth = truth(invocationLast);
-          if (diagnostics.length) await flush();
-          return;
-        }
-      }
       const iterator = interpreter.run(ast, input);
       try {
         while (true) {
@@ -960,13 +948,17 @@ async function executeJqAsync(context, limits, convert) {
           status = options.exitStatus ? truth(result) ? 0 : 1 : 0;
         }
       } finally {
-        await iterator.return(void 0);
+        try {
+          await iterator.return(void 0);
+        } finally {
+          interpreter.releaseScratch();
+        }
       }
       if (status < 2 && invocationLast !== void 0) lastTruth = truth(invocationLast);
       if (diagnostics.length) await flush();
     };
     if (options.nullInput) {
-      await emit(null);
+      await emitSyncOrAsync(null);
       if (convert) for await (const value of inputs(context, options, budget, convert)) budget.value(value);
     } else if (options.slurp && !options.rawInput) {
       const values = [];

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

@@ -0,0 +1,216 @@
+import {
+  quoteAwk
+} from "./chunk-EQ4HV54N.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-awk/src/awk-pretty.ts
+init_buffer();
+import { ProgramError } from "../../safe-bash-io-engine/commands/text-programs/shared.js";
+function prettyAwk(program, budget) {
+  let output = "";
+  const emit = (part) => {
+    budget.step(part.length + 1);
+    if (output.length + part.length > budget.maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
+    output += part;
+  };
+  const expression = (node) => {
+    switch (node.kind) {
+      case "number":
+        emit(String(node.value));
+        return;
+      case "string":
+        emit(quoteAwk(node.value, budget));
+        return;
+      case "regex": {
+        emit("/");
+        for (const character of node.source ?? "") emit(character === "/" ? "\\/" : character);
+        emit("/");
+        return;
+      }
+      case "variable":
+        emit(node.name);
+        return;
+      case "field":
+        emit("$");
+        expression(node.index);
+        return;
+      case "array":
+        emit(`${node.name}[`);
+        list(node.indexes);
+        emit("]");
+        return;
+      case "tuple":
+        emit("(");
+        list(node.items);
+        emit(")");
+        return;
+      case "unary":
+        emit("(");
+        if (!node.postfix) emit(node.operator);
+        expression(node.operand);
+        if (node.postfix) emit(node.operator);
+        emit(")");
+        return;
+      case "binary":
+        emit("(");
+        expression(node.left);
+        emit(` ${node.operator} `);
+        expression(node.right);
+        emit(")");
+        return;
+      case "conditional":
+        emit("(");
+        expression(node.condition);
+        emit(" ? ");
+        expression(node.yes);
+        emit(" : ");
+        expression(node.no);
+        emit(")");
+        return;
+      case "getline":
+        emit("(");
+        if (node.pipe) {
+          expression(node.pipe);
+          emit(" | ");
+        }
+        emit("getline ");
+        if (node.target) {
+          expression(node.target);
+          emit(" ");
+        }
+        if (node.file) {
+          emit("< ");
+          expression(node.file);
+        }
+        emit(")");
+        return;
+      case "call":
+        emit(`${node.name}(`);
+        list(node.args);
+        emit(")");
+        return;
+    }
+  };
+  const list = (items) => {
+    items.forEach((item, index) => {
+      if (index) emit(", ");
+      expression(item);
+    });
+  };
+  const controlled = (node, depth) => {
+    emit(`${"	".repeat(depth)}{
+`);
+    statement(node, depth + 1);
+    emit(`${"	".repeat(depth)}}
+`);
+  };
+  const statement = (node, depth) => {
+    const indent = "	".repeat(depth);
+    emit(indent);
+    switch (node.kind) {
+      case "block":
+        emit("{\n");
+        for (const child of node.body) statement(child, depth + 1);
+        emit(`${indent}}
+`);
+        return;
+      case "expression":
+        expression(node.expression);
+        break;
+      case "print":
+        emit(node.formatted ? "printf " : "print ");
+        list(node.args);
+        if (node.redirect) {
+          emit(node.redirect.pipe ? " | " : node.redirect.append ? " >> " : " > ");
+          expression(node.redirect.destination);
+        }
+        break;
+      case "flow":
+        emit(node.flow);
+        if (node.value) {
+          emit(" ");
+          expression(node.value);
+        }
+        break;
+      case "delete":
+        emit("delete ");
+        expression(node.target);
+        break;
+      case "if":
+        emit("if (");
+        expression(node.condition);
+        emit(")\n");
+        controlled(node.yes, depth);
+        if (node.no) {
+          emit(`${indent}else
+`);
+          controlled(node.no, depth);
+        }
+        return;
+      case "while":
+        emit("while (");
+        expression(node.condition);
+        emit(")\n");
+        controlled(node.body, depth);
+        return;
+      case "do":
+        emit("do\n");
+        controlled(node.body, depth);
+        emit(`${indent}while (`);
+        expression(node.condition);
+        emit(")\n");
+        return;
+      case "for":
+        emit("for (");
+        if (node.initial) expression(node.initial);
+        emit("; ");
+        if (node.condition) expression(node.condition);
+        emit("; ");
+        if (node.update) expression(node.update);
+        emit(")\n");
+        controlled(node.body, depth);
+        return;
+      case "foreach":
+        emit(`for (${node.variable} in ${node.array})
+`);
+        controlled(node.body, depth);
+        return;
+    }
+    emit("\n");
+  };
+  for (const [name, fn] of program.functions) {
+    emit(`function ${name}(${fn.parameters.join(", ")})
+`);
+    statement(fn.body, 0);
+    emit("\n");
+  }
+  for (const node of program.begin) {
+    emit("BEGIN ");
+    statement(node, 0);
+    emit("\n");
+  }
+  for (const rule of program.rules) {
+    if (rule.pattern) {
+      expression(rule.pattern);
+      if (rule.end) {
+        emit(", ");
+        expression(rule.end);
+      }
+      emit(" ");
+    }
+    statement(rule.action, 0);
+    emit("\n");
+  }
+  for (const node of program.end) {
+    emit("END ");
+    statement(node, 0);
+    emit("\n");
+  }
+  return output;
+}
+
+export {
+  prettyAwk
+};

package/dist/safe-bash/command-chunks/{chunk-G4PNVO6Z.js → chunk-KP7AO66M.js}

@@ -1,7 +1,7 @@
 import {
   digit,
   letter
-} from "./chunk-2ENZ6JGA.js";
+} from "./chunk-KEV7C3KH.js";
 import {
   unicodeWhitespace
 } from "./chunk-QHZUIOJQ.js";

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

@@ -0,0 +1,25 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-network-engine/src/deadline.ts
+init_buffer();
+function scheduleNetworkDeadline(milliseconds, expire) {
+  const deadline = performance.now() + milliseconds;
+  let timer;
+  let closed = false;
+  const arm = () => {
+    if (closed || !Number.isFinite(deadline)) return;
+    const remaining = deadline - performance.now();
+    timer = setTimeout(remaining > 2147483647 ? arm : expire, Math.max(0, Math.min(remaining, 2147483647)));
+  };
+  arm();
+  return () => {
+    closed = true;
+    clearTimeout(timer);
+  };
+}
+
+export {
+  scheduleNetworkDeadline
+};

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

@@ -0,0 +1,41 @@
+import {
+  privateHostname
+} from "./chunk-MDH5T4OS.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-network-engine/src/authorizer.ts
+init_buffer();
+function createOriginAuthorizer(allowlist = "*", options = {}) {
+  const denyPrivateNetworks = options.denyPrivateNetworks === true;
+  const origins = /* @__PURE__ */ new Set();
+  const hosts = /* @__PURE__ */ new Set();
+  for (const entry of allowlist === "*" ? [] : allowlist) {
+    const value = entry.trim();
+    if (!value) throw new TypeError("Origin allowlist entries must not be empty");
+    if (value.includes("://")) {
+      const url = new URL(value);
+      if (url.pathname !== "/" || url.search || url.hash || url.username || url.password) {
+        throw new TypeError(`Origin allowlist entry must be an origin: ${entry}`);
+      }
+      origins.add(url.origin);
+    } else {
+      if (value.includes("/") || value.includes("@")) throw new TypeError(`Invalid hostname allowlist entry: ${entry}`);
+      hosts.add(value.toLowerCase().replace(/\.$/u, ""));
+    }
+  }
+  return (request) => {
+    const url = new URL(request.url);
+    const hostname = url.hostname.toLowerCase().replace(/\.$/u, "");
+    if (denyPrivateNetworks) {
+      request.requirePrivateNetworkDeny?.();
+      if (privateHostname(hostname)) return false;
+    }
+    return allowlist === "*" || origins.has(url.origin) || hosts.has(hostname);
+  };
+}
+
+export {
+  createOriginAuthorizer
+};

package/dist/safe-bash/command-chunks/{chunk-C7IHMJEW.js → chunk-KZC5UWFF.js}

@@ -1,7 +1,7 @@
 import {
   bareAutolink,
   filterGfmHtml
-} from "./chunk-G4PNVO6Z.js";
+} from "./chunk-KP7AO66M.js";
 import {
   asciiPunctuation,
   decodeSyntax,
@@ -14,7 +14,7 @@ import {
   readLabel,
   readTitle,
   whitespace
-} from "./chunk-2ENZ6JGA.js";
+} from "./chunk-KEV7C3KH.js";
 import {
   unicodePunctuation,
   unicodeWhitespace