@poe-platform/safe-bash 0.1.798 → 0.1.800

package/dist/safe-bash/command-chunks/{chunk-5UA3BEGA.js → chunk-D4OP2BR3.js}

@@ -2,7 +2,7 @@ import {
   JqError,
   JqLimitError,
   wellFormed
-} from "./chunk-AC6X7Q4I.js";
+} from "./chunk-QP4R6GLA.js";
 import {
   utf8ByteLength
 } from "./chunk-PDKXAR4Y.js";
@@ -43,6 +43,17 @@ var precedence = Object.freeze({
 });
 var functions = Object.freeze({
   walk: [1],
+  test: [1, 2],
+  match: [1, 2],
+  in: [1],
+  IN: [1, 2],
+  INDEX: [1, 2],
+  isempty: [1],
+  nth: [1, 2],
+  pick: [1],
+  sqrt: [0],
+  todate: [0],
+  fromdate: [0],
   explode: [0],
   implode: [0],
   utf8bytelength: [0],
@@ -56,7 +67,11 @@ var functions = Object.freeze({
   until: [2],
   fromdateiso8601: [0],
   todateiso8601: [0],
-  scan: [1],
+  strftime: [1],
+  strptime: [1],
+  gmtime: [0],
+  mktime: [0],
+  scan: [1, 2],
   paths: [0, 1],
   getpath: [1],
   flatten: [0, 1],
@@ -94,14 +109,15 @@ var functions = Object.freeze({
   not: [0],
   reverse: [0],
   transpose: [0],
-  combinations: [0],
+  combinations: [0, 1],
   first: [0, 1],
   last: [0, 1],
   limit: [2],
   range: [1, 2, 3],
   join: [1],
   split: [1],
-  splits: [1],
+  splits: [1, 2],
+  sub: [2, 3],
   gsub: [2, 3],
   tostring: [0],
   tonumber: [0],
@@ -251,7 +267,7 @@ function isPath(ast) {
     if (node.kind === "identity" || node.kind === "parameter" || node.kind === "invoke" || node.kind === "descend") continue;
     if (node.kind === "index" || node.kind === "iterate" || node.kind === "slice") pending.push(node.base);
     else if (node.kind === "optional") pending.push(node.operand);
-    else if (node.kind === "bind") pending.push(node.body);
+    else if (node.kind === "bind" || node.kind === "define") pending.push(node.body);
     else if (node.kind === "call" && ["select", "values", "strings", "numbers", "booleans", "arrays", "objects", "nulls", "scalars", "iterables", "empty"].includes(node.name)) continue;
     else if (node.kind === "binary" && (node.operator === "," || node.operator === "|")) pending.push(node.left, node.right);
     else return false;
@@ -393,6 +409,17 @@ jq: 1 compile error`, 3);
   const expression = (minimum = 0, stopComma = false) => {
     if (++nesting > limits.maxAstDepth) throw new JqLimitError("maxAstDepth");
     try {
+      if (peek().text === "def") {
+        const previous = new Map(definitions);
+        try {
+          const entries2 = [];
+          while (accept("def")) entries2.push(definition());
+          return { kind: "define", definitions: entries2, body: expression(0, stopComma) };
+        } finally {
+          definitions.clear();
+          for (const [name, value] of previous) definitions.set(name, value);
+        }
+      }
       let left = primary();
       while (true) {
         const operator = peek().text;
@@ -405,9 +432,9 @@ jq: 1 compile error`, 3);
           const previous = new Map([...names].map((name) => [name, bindings.get(name) ?? 0]));
           for (const [name, count] of previous) bindings.set(name, count + 1);
           try {
-            const body = expression(0, stopComma);
+            const body2 = expression(0, stopComma);
             const single = patterns[0];
-            left = patterns.length === 1 && single.kind === "variable" ? { kind: "bind", source: left, name: single.name, body } : { kind: "destructure", source: left, patterns, names: [...names], body };
+            left = patterns.length === 1 && single.kind === "variable" ? { kind: "bind", source: left, name: single.name, body: body2 } : { kind: "destructure", source: left, patterns, names: [...names], body: body2 };
           } finally {
             for (const [name, count] of previous) {
               if (count) bindings.set(name, count);
@@ -472,8 +499,8 @@ jq: 1 compile error`, 3);
       if (target === void 0) fail(`undefined label $${name.text}`);
       result = { kind: "break", target };
     } else if (token.text === "try") {
-      const body = expression(10);
-      result = { kind: "try", body, handler: accept("catch") ? expression(10) : void 0 };
+      const body2 = expression(10);
+      result = { kind: "try", body: body2, handler: accept("catch") ? expression(10) : void 0 };
     } else if (token.text === "reduce" || token.text === "foreach") {
       const source2 = expression(10);
       expect("as");
@@ -551,10 +578,10 @@ jq: 1 compile error`, 3);
         expect(")");
       }
       if (token.text === "split" && args.length === 2) fail("unsupported function split/2");
-      const definition = definitions.get(`${name}/${args.length}`);
+      const definition2 = definitions.get(`${name}/${args.length}`);
       const parameter = parameters.get(name);
       if (parameter && !args.length) result = parameter;
-      else if (definition?.kind === "invoke") result = { ...definition, args };
+      else if (definition2?.kind === "invoke") result = { ...definition2, args };
       else {
         result = { kind: "call", name, args };
         if (!Object.hasOwn(functions, name) || !functions[name].includes(args.length)) unresolved.set(result, token);
@@ -584,7 +611,12 @@ jq: 1 compile error`, 3);
     return result;
   };
   const bodies = [];
-  while (definitions && accept("def")) {
+  const definition = () => {
+    const previousParameters = new Map(parameters);
+    const previousBindings = new Map(bindings);
+    const previousDefinitions = new Map(definitions);
+    const previousDefining = defining;
+    const names = /* @__PURE__ */ new Set();
     budget.step();
     const name = take();
     if (name.kind !== "name") fail("expected function name");
@@ -594,7 +626,8 @@ jq: 1 compile error`, 3);
       do {
         const value = accept("$");
         const parameter = take();
-        if (parameter.kind !== "name" || parameters.has(parameter.text) || parameters.has(`$${parameter.text}`)) fail("expected unique parameter name");
+        if (parameter.kind !== "name" || names.has(parameter.text)) fail("expected unique parameter name");
+        names.add(parameter.text);
         const node = { kind: "parameter", name: parameter.text };
         parameters.set(value ? `$${parameter.text}` : parameter.text, node);
         formal.push(node);
@@ -605,32 +638,47 @@ jq: 1 compile error`, 3);
       expect(")");
     }
     expect(":");
+    const entry = { kind: "invoke", definition: { parameters: formal, body: { kind: "identity" } }, args: [] };
+    const signature = `${name.text}/${formal.length}`;
+    definitions.set(signature, entry);
     defining = true;
-    let body;
+    let body2;
     try {
-      body = expression();
+      body2 = expression();
     } finally {
-      defining = false;
+      defining = previousDefining;
     }
     expect(";");
     for (let index = formal.length - 1; index >= 0; index--) {
-      if (values[index]) body = { kind: "bind", name: values[index], source: formal[index], body };
+      if (values[index]) body2 = { kind: "bind", name: values[index], source: formal[index], body: body2 };
     }
     parameters.clear();
-    for (const value of values) if (value) bindings.delete(value);
-    definitions.set(`${name.text}/${formal.length}`, { kind: "invoke", parameters: formal, args: [], body });
+    for (const [name2, value] of previousParameters) parameters.set(name2, value);
+    bindings.clear();
+    for (const [name2, value] of previousBindings) bindings.set(name2, value);
+    definitions.clear();
+    for (const [name2, value] of previousDefinitions) definitions.set(name2, value);
+    entry.definition.body = body2;
+    definitions.set(signature, entry);
     budget.collection(definitions.size);
-    bodies.push(body);
-  }
+    bodies.push(body2);
+    return entry.definition;
+  };
+  const entries = [];
+  while (accept("def")) entries.push(definition());
   if (module && peek().kind !== "end") fail("module must contain only imports and definitions");
-  const ast = module ? { kind: "identity" } : expression();
+  const body = module ? { kind: "identity" } : expression();
+  const ast = entries.length && !module ? { kind: "define", definitions: entries, body } : body;
   if (peek().kind !== "end") syntaxError(peek(), true);
   const pending = [ast, ...bodies].map((node) => ({ node, depth: 1 }));
   const errors = [];
   let errorBytes = 0;
+  const visited = /* @__PURE__ */ new Set();
   while (pending.length) {
     budget.step();
     const { node, depth } = pending.pop();
+    if (visited.has(node)) continue;
+    visited.add(node);
     if (depth > limits.maxAstDepth) throw new JqLimitError("maxAstDepth");
     const token = unresolved.get(node);
     if (token && node.kind === "call") {
@@ -641,8 +689,8 @@ jq: 1 compile error`, 3);
       continue;
     }
     const children = [];
-    if (node.kind === "invoke") children.push(node.body, ...node.args);
-    else if (node.kind === "label") children.push(node.body);
+    if (node.kind === "invoke") children.push(...node.args);
+    else if (node.kind === "label" || node.kind === "define") children.push(node.body);
     else if (node.kind === "binary") children.push(node.left, node.right);
     else if (node.kind === "bind") children.push(node.source, node.body);
     else if (node.kind === "destructure") {

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

@@ -0,0 +1,122 @@
+import {
+  Reader
+} from "./chunk-7K6JYKPJ.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-awk/src/awk-pipes.ts
+init_buffer();
+import { createBytePipe } from "../../safe-bash-contracts/index.js";
+import { shellValueByteLength } from "../../safe-bash-contracts/value.js";
+import { ProgramError, bytes } from "../../safe-bash-io-engine/commands/text-programs/shared.js";
+var AwkPipes = class {
+  constructor(context, budget, retention) {
+    this.context = context;
+    this.budget = budget;
+    this.retention = retention;
+    context.registerCleanup?.(() => this.closeAll(true));
+  }
+  context;
+  budget;
+  retention;
+  reads = /* @__PURE__ */ new Map();
+  writes = /* @__PURE__ */ new Map();
+  cleanup;
+  open(command, reading) {
+    if (this.cleanup) throw new ProgramError("awk pipes are closed");
+    const map = reading ? this.reads : this.writes;
+    const existing = map.get(command);
+    if (existing) return existing;
+    if (!this.context.invoke) throw new ProgramError("command pipes require virtual command invocation");
+    if (!command) throw new ProgramError("empty pipe command");
+    if (this.reads.size + this.writes.size >= (this.budget.options.maxGetlineFiles ?? Infinity)) throw new ProgramError("awk open-pipe limit exceeded");
+    this.budget.check(command);
+    const size = shellValueByteLength(command);
+    this.retention.admit(0, size);
+    const abort = new AbortController();
+    const signal = AbortSignal.any([this.context.signal, abort.signal]);
+    const channel = createBytePipe({ highWaterMark: 1, signal });
+    const invoke = this.context.invoke;
+    const done = Promise.resolve().then(() => invoke("sh", ["-c", command], {
+      signal,
+      stdin: reading ? this.context.stdin : channel.endpoints.read.readable,
+      stdout: reading ? { write: async (chunk) => {
+        this.retention.admit(0, chunk.byteLength);
+        try {
+          await channel.writable.write(chunk);
+        } finally {
+          this.retention.release(chunk.byteLength);
+        }
+      } } : this.context.stdout,
+      stderr: this.context.stderr
+    })).then(async (result) => {
+      if (reading) await channel.close();
+      else await channel.endpoints?.read.close();
+      return { status: result.exitCode };
+    }).catch(async (error) => {
+      await channel.abort(error);
+      return { error };
+    });
+    const pipe = { channel, abort, done, ...reading ? { reader: new Reader(channel.endpoints.read.readable, this.budget, this.retention) } : {} };
+    map.set(command, pipe);
+    return pipe;
+  }
+  async read(command, separator) {
+    const pipe = this.open(command, true);
+    return pipe.reader.read(separator);
+  }
+  async write(command, output) {
+    const pipe = this.open(command, false);
+    this.budget.step(output.length);
+    this.retention.admit(0, output.length);
+    try {
+      await pipe.channel.writable.write(bytes(output));
+    } finally {
+      this.retention.release(output.length);
+    }
+  }
+  async close(command) {
+    let status;
+    for (const map of [this.reads, this.writes]) {
+      const pipe = map.get(command);
+      if (!pipe) continue;
+      status = await (pipe.closing ??= this.finish(pipe).finally(() => {
+        map.delete(command);
+        this.retention.release(shellValueByteLength(command));
+      }));
+    }
+    return status;
+  }
+  async finish(pipe) {
+    let failed = false;
+    let failure;
+    try {
+      if (pipe.reader) {
+        await pipe.channel.endpoints.read.close();
+        await pipe.reader.close();
+      } else await pipe.channel.close();
+    } catch (error) {
+      failed = true;
+      failure = error;
+    }
+    const result = await pipe.done;
+    if (failed && !pipe.abort.signal.aborted) throw failure;
+    if ("error" in result) {
+      if (!pipe.abort.signal.aborted) throw result.error;
+      return -1;
+    }
+    return result.status;
+  }
+  closeAll(cancel = false) {
+    if (cancel) for (const pipe of [...this.reads.values(), ...this.writes.values()]) pipe.abort.abort();
+    return this.cleanup ??= (async () => {
+      const results = await Promise.allSettled([.../* @__PURE__ */ new Set([...this.reads.keys(), ...this.writes.keys()])].map((command) => this.close(command)));
+      for (const result of results) if (result.status === "rejected") throw result.reason;
+    })();
+  }
+};
+
+export {
+  AwkPipes
+};

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

@@ -0,0 +1,87 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-patch/src/patch-path.ts
+init_buffer();
+import { ToolError } from "../../safe-bash-diff-engine/shared.js";
+import { encodeBytes } from "../../safe-bash-io-engine/byte-encoding.js";
+function decodeHeaderPath(value) {
+  if (!value.startsWith('"')) return value.split("	", 1)[0];
+  const bytes = [];
+  const escapes = { a: 7, b: 8, t: 9, n: 10, v: 11, f: 12, r: 13, '"': 34, "\\": 92 };
+  let index = 1;
+  while (index < value.length) {
+    const character = value[index++];
+    if (character === '"') {
+      if (index < value.length && value[index] !== "	") throw new ToolError("unexpected text after quoted filename");
+      try {
+        return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(Uint8Array.from(bytes));
+      } catch {
+        throw new ToolError("invalid UTF-8 in quoted filename");
+      }
+    }
+    if (character === "\\") {
+      const escaped = value[index++];
+      if (/[0-7]/u.test(escaped ?? "")) {
+        const octal = value.slice(index - 1, index + 2);
+        if (!/^[0-7]{3}$/u.test(octal) || parseInt(octal, 8) > 255) throw new ToolError("invalid octal filename escape");
+        bytes.push(parseInt(octal, 8));
+        index += 2;
+      } else {
+        const byte = escapes[escaped];
+        if (byte === void 0) throw new ToolError("invalid quoted filename escape");
+        bytes.push(byte);
+      }
+    } else {
+      const point = value.codePointAt(index - 1);
+      const literal = String.fromCodePoint(point);
+      bytes.push(...encodeBytes(literal));
+      index += literal.length - 1;
+    }
+  }
+  throw new ToolError("unterminated quoted filename");
+}
+function safeTarget(path, strip, allowAbsolute = false) {
+  if (path === "/dev/null") return void 0;
+  if (!path || !allowAbsolute && path.startsWith("/") || /[\\\0-\x08\x0a-\x1f\x7f]/u.test(path)) throw new ToolError(`unsafe patch path: ${JSON.stringify(path)}`);
+  const parts = path.split(/\/+/u);
+  if (parts.some((part) => part === ".." || /^[A-Za-z]:/u.test(part))) throw new ToolError(`unsafe patch path: ${JSON.stringify(path)}`);
+  if (path.endsWith("/") || parts.at(-1) === ".") throw new ToolError(`patch path names a directory: ${JSON.stringify(path)}`);
+  const stripped = parts.filter(Boolean).slice(strip).filter((part) => part !== ".").join("/");
+  if (!stripped) throw new ToolError(`strip count removes entire patch path: ${path}`);
+  return allowAbsolute && path.startsWith("/") && strip === 0 ? `/${stripped}` : stripped;
+}
+function isEpochHeader(line) {
+  const separator = line.lastIndexOf("	");
+  if (separator < 0) return false;
+  let timestamp = line.slice(separator + 1).trim();
+  const traditional = /^(?:Sun|Mon|Tue|Wed|Thu|Fri|Sat) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) +([0-9]{1,2}) (\d{2}:\d{2}:\d{2}) (\d{4})(?: (UTC|GMT|[+-]\d{4}))?$/u.exec(timestamp);
+  if (traditional) {
+    const month = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"].indexOf(traditional[1]) + 1;
+    timestamp = `${traditional[4]}-${String(month).padStart(2, "0")}-${traditional[2].padStart(2, "0")} ${traditional[3]} ${traditional[5] ?? "+0000"}`;
+  }
+  const match = /^(\d{4}-\d{2}-\d{2})[ T](\d{2}:\d{2}:\d{2})(?:\.(\d{1,9}))?(?:\s*(Z|UTC|GMT|[+-]\d{2}:?\d{2}))?$/u.exec(timestamp);
+  if (!match) return false;
+  const iso = `${match[1]}T${match[2]}`;
+  const local = Date.parse(`${iso}Z`);
+  if (!Number.isFinite(local) || new Date(local).toISOString().slice(0, 19) !== iso) return false;
+  const zone = match[4];
+  let offset = 0;
+  if (zone && /^[+-]/u.test(zone)) {
+    const digits = zone.slice(1).replace(":", "");
+    const hours = Number(digits.slice(0, 2));
+    const minutes = Number(digits.slice(2));
+    if (hours > 25 || minutes > 59) return false;
+    offset = (hours * 60 + minutes) * 60 * (zone[0] === "+" ? 1 : -1);
+  }
+  const seconds = local / 1e3 - offset;
+  const fractional = match[3] !== void 0 && /[1-9]/u.test(match[3]);
+  return (seconds > -25 * 3600 || seconds === -25 * 3600 && fractional) && seconds < 26 * 3600;
+}
+
+export {
+  decodeHeaderPath,
+  safeTarget,
+  isEpochHeader
+};

package/dist/safe-bash/command-chunks/{chunk-2PX5B7T5.js → chunk-DQAVUDDX.js}

@@ -1,7 +1,7 @@
 import {
   crc32,
   createZipCodec
-} from "./chunk-MKQVQMXO.js";
+} from "./chunk-5LU4UCBR.js";
 import {
   CodecError,
   yieldEventLoop
@@ -13145,7 +13145,7 @@ var PackageView = class {
     if (input == null) throw new InputTypeError("Expected explicit package input.");
     if (settings2.template !== void 0) throw new InputTypeError("A context template conflicts with package input.");
     const admitted2 = await admitDocumentModel(input, settings2);
-    const { ModelStore: ModelStore2 } = await import("./model-store-L35QTZMJ.js");
+    const { ModelStore: ModelStore2 } = await import("./model-store-WPKMRPV4.js");
     const store = new ModelStore2(admitted2.archive, admitted2.settings, admitted2.archive.mainPart, admitted2.source);
     store.package.after_unmarshal();
     return store.package;