@poe-platform/safe-bash 0.1.799 → 0.1.800

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

@@ -0,0 +1,174 @@
+import {
+  createArchive,
+  manifest
+} from "./chunk-WNE7FPVR.js";
+import {
+  readArchive
+} from "./chunk-5T7CRJHW.js";
+import {
+  Reader,
+  autodetected,
+  compressed,
+  recordPadding,
+  recorded
+} from "./chunk-BNOU5YQS.js";
+import {
+  quoteName
+} from "./chunk-C7I25AAL.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-tar/src/modes.ts
+init_buffer();
+import { collectBytes, resolvePath } from "../../safe-bash-contracts/index.js";
+import { decodeBytes, encodeBytes, equalBytes } from "../../safe-bash-io-engine/byte-encoding.js";
+import { bounded, display, fail, fileSource, hasIdentity, maybeStat, operation, publish, sameIdentity, vfsPath } from "../../safe-bash-io-engine/commands/archive/internal.js";
+async function compareArchive(context, options, budget) {
+  let different = false;
+  const input = bounded(options.archive === "-" ? context.stdin : fileSource(context, vfsPath(context.cwd, options.archive), budget.limits), budget.limits.maxArchiveBytes, context.signal, budget.limits.chunkSize);
+  const source = options.compression ? compressed(input, true, context.signal, budget.limits, options.compression) : autodetected(input, context.signal, budget.limits);
+  await readArchive(context, source, options, budget, { async member(entry, reader, selected, root) {
+    const difference = async (message) => {
+      different = true;
+      await budget.output(`${display(entry.name)}: ${message}
+`);
+    };
+    if (!selected) {
+      await reader.discard(entry.size);
+      return;
+    }
+    if (entry.name.split("/").includes("..")) fail(`unsafe parent component in member: ${display(entry.name)}`);
+    const path = resolvePath(root, entry.name);
+    const stat = await maybeStat(context, path);
+    if (!stat) {
+      await difference("File is missing");
+      await reader.discard(entry.size);
+      return;
+    }
+    const wanted = entry.type === "5" ? "directory" : entry.type === "2" ? "symlink" : "file";
+    if (stat.type !== wanted) {
+      await difference("File type differs");
+      await reader.discard(entry.size);
+      return;
+    }
+    const capabilities = await operation(context, () => context.fs.capabilitiesFor?.(path, { signal: context.signal }) ?? context.fs.capabilities);
+    if (capabilities.permissions === false || capabilities.timestamps === false) fail("filesystem lacks metadata required for archive comparison");
+    if ((stat.mode & 4095) !== entry.mode) await difference("Mode differs");
+    if (entry.uid !== void 0) {
+      if (stat.uid === void 0) fail("filesystem lacks ownership required for archive comparison");
+      if (stat.uid !== entry.uid) await difference("Uid differs");
+    }
+    if (entry.gid !== void 0) {
+      if (stat.gid === void 0) fail("filesystem lacks ownership required for archive comparison");
+      if (stat.gid !== entry.gid) await difference("Gid differs");
+    }
+    if (entry.type !== "2" && entry.mtime !== void 0 && Math.floor(stat.mtimeMs / 1e3) !== Math.floor(entry.mtime)) await difference("Mod time differs");
+    if (entry.type === "2") {
+      if (!context.fs.readlink) fail("filesystem lacks readlink required for archive comparison");
+      if (await operation(context, () => context.fs.readlink(path, { signal: context.signal })) !== entry.linkname) await difference("Symlink differs");
+    } else if (entry.type === "1") {
+      if (entry.linkname.split("/").includes("..")) fail("unsafe hardlink target in archive comparison");
+      const target = await maybeStat(context, resolvePath(root, entry.linkname));
+      if (!hasIdentity(stat) || target && !hasIdentity(target)) fail("filesystem lacks identity required for hardlink comparison");
+      if (!target || !sameIdentity(stat, target)) await difference("Not linked to archive target");
+    } else if (entry.type === "0") {
+      if (stat.size !== entry.size) {
+        await difference("Size differs");
+        await reader.discard(entry.size);
+        return;
+      }
+      const actual = new Reader(fileSource(context, path, budget.limits), context.signal);
+      let equal = true;
+      try {
+        for await (const chunk of reader.body(entry.size)) {
+          const bytes = await actual.exact(chunk.length);
+          if (!equalBytes(encodeBytes(chunk), bytes)) equal = false;
+        }
+        if (await actual.take(1)) equal = false;
+      } finally {
+        await actual.close();
+      }
+      if (!equal) await difference("Contents differ");
+      if (options.verbose) await budget.output(`${quoteName(entry.name, options.quotingStyle)}
+`);
+      return;
+    }
+    await reader.discard(entry.size);
+  } });
+  return different ? 1 : 0;
+}
+async function mutateArchive(context, options, budget) {
+  if (options.archive === "-") fail("archive mutation requires a named archive");
+  if (options.compression) fail("cannot modify compressed archives");
+  const path = vfsPath(context.cwd, options.archive);
+  const stat = await maybeStat(context, path);
+  if (!stat || stat.type !== "file") fail("archive mutation requires an existing regular file");
+  if (!hasIdentity(stat)) fail("cannot safely replace an archive with unknown backing identity");
+  const parts = [];
+  let changed = false;
+  let bytes = 1024;
+  const add = (part) => {
+    if (part.length > budget.limits.maxArchiveBytes - bytes) fail("archive byte limit exceeded");
+    bytes += part.length;
+    parts.push(part);
+  };
+  const times = /* @__PURE__ */ new Map();
+  const scan = async (inputPath, deleting) => {
+    const data = await collectBytes(fileSource(context, inputPath, budget.limits), { ...Number.isFinite(budget.limits.maxArchiveBytes) ? { maxBytes: budget.limits.maxArchiveBytes } : {}, signal: context.signal });
+    const prefix = data.subarray(0, 6);
+    if (prefix[0] === 31 && prefix[1] === 139 || decodeBytes(encodeBytes(prefix.subarray(0, 3))) === "BZh" || [253, 55, 122, 88, 90, 0].every((value, index) => prefix[index] === value)) fail("cannot modify compressed archives");
+    await readArchive(context, (async function* () {
+      yield data;
+    })(), deleting ? options : { ...options, mode: "t", operands: [], excludes: [] }, budget, {
+      rejectGlobal: true,
+      async member(entry, reader, selected, _root, start) {
+        const end = reader.position + entry.size + (512 - entry.size % 512) % 512;
+        if (!deleting || !selected) add(data.subarray(start, end));
+        else changed = true;
+        const name = entry.name.endsWith("/") ? entry.name.slice(0, -1) : entry.name;
+        const prior = times.get(name);
+        if (!times.has(name) || entry.mtime === void 0 || prior !== void 0 && entry.mtime > prior) times.set(name, entry.mtime);
+        await reader.discard(entry.size);
+      }
+    });
+  };
+  await scan(path, options.mode === "delete");
+  if (options.mode === "A") {
+    for (const operand of options.operands) {
+      const inputPath = vfsPath(operand.cwd, operand.name);
+      const inputStat = await maybeStat(context, inputPath);
+      if (!inputStat || inputStat.type !== "file") fail("concatenation source must be a regular archive");
+      if (!hasIdentity(inputStat)) fail("concatenation source has unknown backing identity");
+      if (sameIdentity(stat, inputStat)) fail("cannot concatenate an archive to itself");
+      await scan(inputPath, false);
+      changed = true;
+    }
+  } else if (options.mode === "r" || options.mode === "u") {
+    const prepared = await manifest(context, options, budget);
+    const entries = options.mode === "u" ? prepared.entries.filter((source) => {
+      const name = source.entry.name.endsWith("/") ? source.entry.name.slice(0, -1) : source.entry.name;
+      if (!times.has(name)) return true;
+      const archived = times.get(name);
+      if (archived === void 0) fail("archive lacks mtime required for update");
+      return source.stat.mtimeMs / 1e3 > archived;
+    }) : prepared.entries;
+    const created = await collectBytes(createArchive(context, entries, options, budget), { ...Number.isFinite(budget.limits.maxArchiveBytes - bytes + 1024) ? { maxBytes: budget.limits.maxArchiveBytes - bytes + 1024 } : {}, signal: context.signal });
+    add(created.subarray(0, created.length - 1024));
+    changed = entries.length > 0;
+  }
+  if (!changed) return;
+  recordPadding(bytes, options.recordSize, budget.limits.maxArchiveBytes);
+  parts.push(new Uint8Array(1024));
+  const current = await maybeStat(context, path);
+  if (!current || !sameIdentity(stat, current) || current.size !== stat.size || current.mtimeMs !== stat.mtimeMs || current.ctimeMs !== stat.ctimeMs) fail("archive changed during preparation");
+  await operation(context, () => context.fs.rm(path, { signal: context.signal }));
+  await publish(context, path, recorded((async function* () {
+    yield* parts;
+  })(), options, budget), stat.mode & 4095);
+}
+
+export {
+  compareArchive,
+  mutateArchive
+};

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

@@ -0,0 +1,185 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-zip-engine/src/zip/options.ts
+init_buffer();
+var ZipFailure = class extends Error {
+  constructor(status, label, detail) {
+    super(detail);
+    this.status = status;
+    this.label = label;
+  }
+  status;
+  label;
+};
+var reservedZipShortOptions = /* @__PURE__ */ new Set(["mm"]);
+var zipLongOptions = {
+  "adjust-sfx": "A",
+  fix: "F",
+  fixfix: "FF",
+  "split-size": "s",
+  "split-pause": "sp",
+  "split-verbose": "sv",
+  "split-bell": "sb",
+  fifo: "FI",
+  "DOS-names": "k",
+  regex: "RE",
+  password: "P",
+  encrypt: "e",
+  "difference-archive": "DF",
+  grow: "g",
+  "temp-path": "b",
+  "junk-sfx": "J",
+  "logfile-path": "lf",
+  "log-append": "la",
+  "log-info": "li",
+  "unzip-command": "TT",
+  verbose: "v",
+  version: "version",
+  license: "L",
+  "show-command": "sc",
+  "show-debug": "sd",
+  "show-files": "sf",
+  "show-options": "so",
+  "display-bytes": "db",
+  "display-counts": "dc",
+  "display-dots": "dd",
+  "display-globaldots": "dg",
+  "dot-size": "ds",
+  "display-usize": "du",
+  "display-volume": "dv",
+  "recurse-paths": "r",
+  quiet: "q",
+  "junk-paths": "j",
+  paths: "p",
+  help: "h",
+  "more-help": "h2",
+  "no-dir-entries": "D",
+  symlinks: "y",
+  test: "T",
+  "names-stdin": "@",
+  update: "u",
+  freshen: "f",
+  filesync: "FS",
+  "archive-comment": "z",
+  "entry-comments": "c",
+  "latest-time": "o",
+  move: "m",
+  "to-crlf": "l",
+  "from-crlf": "ll",
+  delete: "d",
+  include: "i",
+  exclude: "x",
+  suffixes: "n",
+  store: "0",
+  "compression-method": "Z",
+  "compress-1": "1",
+  "compress-2": "2",
+  "compress-3": "3",
+  "compress-4": "4",
+  "compress-5": "5",
+  "compress-6": "6",
+  "compress-7": "7",
+  "compress-8": "8",
+  "compress-9": "9",
+  "force-zip64": "fz",
+  "strip-extra": "X",
+  "force-descriptors": "fd",
+  "no-wild": "nw",
+  "wild-stop-dirs": "ws",
+  "recurse-patterns": "R",
+  "from-date": "t",
+  "before-date": "tt",
+  "copy-entries": "U",
+  "output-file": "O",
+  "must-match": "MM"
+};
+var reservedOptions = [
+  "show-unicode",
+  "show-just-unicode"
+];
+function normalizeZipOption(argument) {
+  if (!argument.startsWith("--") || argument === "--") return argument;
+  const equal = argument.indexOf("=");
+  const rawName = argument.slice(2, equal < 0 ? void 0 : equal);
+  const negate = rawName.endsWith("-");
+  const name = negate ? rawName.slice(0, -1) : rawName;
+  const names = [...Object.keys(zipLongOptions), ...reservedOptions];
+  const matches = names.includes(name) ? [name] : names.filter((option) => option.startsWith(name));
+  if (matches.length > 1) throw new ZipFailure(16, "Invalid command arguments", `long option '${name}' ambiguous`);
+  const matched = matches[0];
+  const short = matched === void 0 ? void 0 : zipLongOptions[matched];
+  if (!short) throw new ZipFailure(16, "Invalid command arguments", `unsupported option: --${name}`);
+  if (negate && !zipNegatableOptions.has(short)) throw new ZipFailure(16, "Invalid command arguments", `option ${matched} is not negatable`);
+  if (equal >= 0 && short !== "s" && short !== "P" && short !== "i" && short !== "x" && short !== "n" && short !== "Z" && short !== "t" && short !== "tt" && short !== "O" && short !== "ds" && short !== "b" && short !== "lf" && short !== "TT") {
+    throw new ZipFailure(16, "Invalid command arguments", `option '${matched}' does not allow a value`);
+  }
+  if (short === "version") return "--version";
+  return `-${short}${negate ? "-" : ""}${equal < 0 ? "" : argument.slice(equal)}`;
+}
+var zipNegatableOptions = /* @__PURE__ */ new Set(["FI", "fz", "X", "db", "dc", "dd", "dg", "du", "dv", "sf"]);
+function parseZipDotSize(value) {
+  if (!value) return 10 * 1024 * 1024;
+  let end = 0;
+  while (end < value.length && value[end] >= "0" && value[end] <= "9") end++;
+  const unit = value.slice(end).toLowerCase();
+  const multiplier = { "": 1, k: 1024, m: 1024 ** 2, g: 1024 ** 3, t: 1024 ** 4 }[unit];
+  const size = Number(value.slice(0, end)) * (multiplier ?? 0);
+  if (!end || value.length > 8 || multiplier === void 0 || !Number.isSafeInteger(size)) {
+    throw new ZipFailure(16, "Invalid command arguments", "option -ds (--dot-size) has bad size");
+  }
+  if (size >= 1024 && size < 32 * 1024) throw new ZipFailure(16, "Invalid command arguments", "dot size must be at least 32 KB");
+  return size < 1024 ? size * 1024 ** 2 : size;
+}
+function zipDisplaySize(size) {
+  let unit = 0;
+  while (size >= 10240) {
+    size = Math.floor(size / 1024);
+    unit++;
+  }
+  const number = size >= 1e3 ? (Math.floor(size * 10 / 1024) / 10).toFixed(1) : String(size);
+  if (size >= 1e3) unit++;
+  return `${number}${["", "K", "M", "G", "T"][unit] ?? "T"}`;
+}
+function zipPasswordArgument(value) {
+  if (value.startsWith("--")) {
+    const equal = value.indexOf("=");
+    const name = value.slice(2, equal < 0 ? void 0 : equal);
+    if (name.length >= 3 && "password".startsWith(name)) return equal < 0 ? "separate" : "attached";
+  } else if (value.startsWith("-")) {
+    const password = value.indexOf("P", 1);
+    if (password >= 0) return password === value.length - 1 ? "separate" : "attached";
+  }
+  return void 0;
+}
+function zipPublicText(value) {
+  const lower = value.toLowerCase();
+  if (zipPasswordArgument(value) || lower.includes("password") || lower.includes("token=") || lower.includes("secret=")) return "[redacted]";
+  if (value.includes("://") || ["http:", "https:", "ftp:", "ws:", "wss:"].some((scheme) => lower.includes(scheme))) {
+    try {
+      const url = new URL(value);
+      if (!value.startsWith(`${url.protocol}//`)) return "[redacted URL]";
+      url.username = "";
+      url.password = "";
+      url.search = "";
+      url.hash = "";
+      return url.toString();
+    } catch {
+      return "[redacted URL]";
+    }
+  }
+  return value;
+}
+
+export {
+  ZipFailure,
+  reservedZipShortOptions,
+  zipLongOptions,
+  normalizeZipOption,
+  zipNegatableOptions,
+  parseZipDotSize,
+  zipDisplaySize,
+  zipPasswordArgument,
+  zipPublicText
+};

package/dist/safe-bash/command-chunks/{chunk-2FUAW6GO.js → chunk-QI7LGHJJ.js}

@@ -50,8 +50,31 @@ function inferDelimiter(path) {
 }
 var shortOptions = { B: "byte-offset", S: "start-condition", E: "end-condition", H: "human-readable", c: "check-alignment", a: "approx", p: "parallel", t: "threads", h: "help", o: "output", d: "delimiter", n: "no-headers", j: "just-names", s: "start", e: "end", l: "len", i: "index", I: "indices", L: "last" };
 var switches = /* @__PURE__ */ new Set(["help", "no-headers", "just-names", "csv", "human-readable", "check-alignment", "approx", "parallel", "raw", "evaluate", "evaluate-file"]);
+var extraShort = {
+  head: { l: "limit" },
+  tail: { l: "limit" },
+  sort: { s: "select", N: "numeric", R: "reverse", u: "uniq" },
+  search: { s: "select", e: "exact", i: "ignore-case", v: "invert-match", l: "limit" },
+  filter: { v: "invert-match" },
+  rename: { s: "select" },
+  stats: { s: "select" },
+  freq: { s: "select", l: "limit", A: "all", N: "no-extra" },
+  join: { i: "ignore-case" }
+};
+for (const name of ["numeric", "reverse", "uniq", "exact", "ignore-case", "invert-match", "every-column", "all", "no-extra", "inner", "left", "right", "full", "semi", "anti", "cross", "nulls"]) switches.add(name);
 var common = ["help", "output", "delimiter"];
 var allowed = {
+  head: /* @__PURE__ */ new Set([...common, "no-headers", "limit"]),
+  tail: /* @__PURE__ */ new Set([...common, "no-headers", "limit"]),
+  sort: /* @__PURE__ */ new Set([...common, "no-headers", "select", "numeric", "reverse", "uniq"]),
+  search: /* @__PURE__ */ new Set([...common, "no-headers", "select", "exact", "ignore-case", "invert-match", "every-column", "limit"]),
+  filter: /* @__PURE__ */ new Set([...common, "no-headers", "invert-match"]),
+  reverse: /* @__PURE__ */ new Set([...common, "no-headers"]),
+  rename: /* @__PURE__ */ new Set([...common, "no-headers", "select"]),
+  drop: /* @__PURE__ */ new Set([...common, "no-headers"]),
+  stats: /* @__PURE__ */ new Set([...common, "no-headers", "select", "nulls"]),
+  freq: /* @__PURE__ */ new Set([...common, "no-headers", "select", "limit", "all", "no-extra"]),
+  join: /* @__PURE__ */ new Set([...common, "no-headers", "inner", "left", "right", "full", "semi", "anti", "cross", "nulls", "ignore-case", "drop-key"]),
   headers: /* @__PURE__ */ new Set([...common, "just-names", "csv", "start", "color"]),
   count: /* @__PURE__ */ new Set([...common, "no-headers", "human-readable", "check-alignment", "approx", "parallel", "threads"]),
   select: /* @__PURE__ */ new Set([...common, "no-headers", "evaluate", "evaluate-file"]),
@@ -63,12 +86,12 @@ async function parseArguments(args, cwd, budget) {
     const size = await budget.textSize(arg);
     budget.add("maxArgumentBytes", size);
   }
-  const first = args[0] === "h" ? "headers" : args[0];
+  const first = args[0] === "h" ? "headers" : args[0] === "frequency" ? "freq" : args[0];
   if (first === "--help" || first === "-h") {
     if (args.length !== 1) throw new XanError("unexpected argument after help");
     return { command: "headers", inputs: [], noHeaders: false, justNames: false, csv: false, help: true, selection: "", start: 0n };
   }
-  if (!first || !Object.hasOwn(allowed, first)) throw new XanError("expected headers, count, select or slice subcommand");
+  if (!first || !Object.hasOwn(allowed, first)) throw new XanError("expected a CSV subcommand (use xan --help)");
   const command = first;
   const values = /* @__PURE__ */ new Map();
   const operands = [];
@@ -101,7 +124,7 @@ async function parseArguments(args, cwd, budget) {
     } else if (!positional && arg.startsWith("-") && arg !== "-") {
       for (let position = 1; position < arg.length; position++) {
         const letter = arg[position];
-        const name = command === "select" && letter === "e" ? "evaluate" : command === "select" && letter === "f" ? "evaluate-file" : shortOptions[letter];
+        const name = extraShort[command]?.[letter] ?? (command === "select" && letter === "e" ? "evaluate" : command === "select" && letter === "f" ? "evaluate-file" : shortOptions[letter]);
         if (command === "headers" && letter === "n") throw new UsageError(`${headersUsage}Unknown flag: '-n' Use the -h/--help flag for more information.`);
         if (!name || !allowed[command].has(name)) throw new XanError(`unsupported in bounded CSV profile: -${letter}`);
         if (switches.has(name)) put(name, "true");
@@ -124,9 +147,28 @@ async function parseArguments(args, cwd, budget) {
   const help = values.has("help");
   if (!help && (parallel || values.has("approx")) && (!operands.length || operands[0] === "-")) throw new XanError("count execution options require a file path");
   if (values.has("evaluate") && values.has("evaluate-file")) throw new XanError("conflicting expression modes");
-  const selection = command === "select" ? operands.shift() : "";
+  let rightSelection;
+  let operand;
+  if (["search", "filter", "rename"].includes(command)) {
+    operand = operands.shift();
+    if (operand === void 0 && !help) throw new XanError(`${command} requires an argument`);
+  }
+  let selection = command === "select" || command === "drop" ? operands.shift() : values.get("select") ?? "";
+  if (command === "join" && !help) {
+    const modes = ["inner", "left", "right", "full", "semi", "anti", "cross"].filter((name) => values.has(name));
+    if (modes.length > 1) throw new XanError("conflicting join modes");
+    if (values.has("cross")) {
+      if (operands.length !== 2) throw new XanError("cross join requires two inputs");
+    } else {
+      if (operands.length !== 3 && operands.length !== 4) throw new XanError("join requires columns and two inputs");
+      selection = operands.shift();
+      rightSelection = operands.length === 3 ? operands.splice(1, 1)[0] : selection;
+    }
+    if (values.has("drop-key") && !["none", "left", "right", "both"].includes(values.get("drop-key"))) throw new XanError("invalid --drop-key mode");
+  }
+  if (values.has("limit")) await unsigned(values.get("limit"), "--limit", budget);
   if (selection === void 0 && !help) throw new UsageError("Usage:\n    xan select [options] [--] <selection> [<input>]\n    xan select --help\n\nInvalid subcommand or arguments! Use the -h/--help flag for more information.");
-  if (command !== "headers" && operands.length > 1) throw new XanError("too many input files");
+  if (command !== "headers" && command !== "join" && operands.length > 1) throw new XanError("too many input files");
   if (operands.filter((path2) => path2 === "-").length > 1) throw new XanError("stdin may appear only once");
   if (!operands.length) operands.push("-");
   budget.bound("maxInputFiles", operands.length);
@@ -135,7 +177,7 @@ async function parseArguments(args, cwd, budget) {
     if (/\.(gz|zst|cdx|ndjson|jsonl|vcf|gtf|gff2|sam|bed)$/u.test(value)) throw new XanError(`unsupported in bounded CSV profile: format ${value}`);
     return value === "-" ? value : resolvePath(cwd, value);
   };
-  for (const operand of operands) path(operand);
+  for (const operand2 of operands) path(operand2);
   const output = values.get("output");
   if (output !== void 0) path(output);
   let delimiter;
@@ -168,8 +210,8 @@ async function parseArguments(args, cwd, budget) {
   let last;
   if (numbers.has("last")) {
     const value = numbers.get("last");
-    if (value > BigInt(budget.limits.maxLastRows)) budget.bound("maxLastRows", budget.limits.maxLastRows + 1);
     last = Number(value);
+    budget.bound("maxLastRows", last);
   }
   let indices;
   if (values.has("indices")) {
@@ -199,9 +241,16 @@ async function parseArguments(args, cwd, budget) {
     budget.release((indices.length - count) * 8);
     indices.length = count;
   }
-  budget.release(values.size * 32);
+  if (command === "head") end = await unsigned(values.get("limit") ?? "10", "--limit", budget);
+  if (command === "tail") {
+    last = Number(await unsigned(values.get("limit") ?? "10", "--limit", budget));
+    budget.bound("maxLastRows", last);
+  }
   return {
-    command,
+    command: command === "head" || command === "tail" ? "slice" : command,
+    options: values,
+    ...operand !== void 0 ? { operand } : {},
+    ...rightSelection !== void 0 ? { rightSelection } : {},
     raw: values.has("raw"),
     ...byteOffset !== void 0 ? { byteOffset } : {},
     ...endByte !== void 0 ? { endByte } : {},

package/dist/safe-bash/command-chunks/{chunk-6BETHLXZ.js → chunk-QJAFJP2G.js}

@@ -32,7 +32,7 @@ import {
 } from "./chunk-DWFLVJC6.js";
 import {
   createZipCodec
-} from "./chunk-MKQVQMXO.js";
+} from "./chunk-5LU4UCBR.js";
 import {
   CodecError
 } from "./chunk-RDV7UCYZ.js";

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

@@ -0,0 +1,63 @@
+import {
+  AwkArray
+} from "./chunk-V6MSPQLA.js";
+import {
+  quoteAwk
+} from "./chunk-EQ4HV54N.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-awk/src/awk-inspection.ts
+init_buffer();
+import { writeBytes } from "../../safe-bash-contracts/index.js";
+import { writeFileOutput } from "../../safe-bash-contracts/filesystem-output.js";
+import { ProgramError, bytes, virtualPath } from "../../safe-bash-io-engine/commands/text-programs/shared.js";
+var AwkInspection = class {
+  constructor(context, budget, options) {
+    this.context = context;
+    this.budget = budget;
+    this.options = options;
+  }
+  context;
+  budget;
+  options;
+  counts = /* @__PURE__ */ new Map();
+  async observe(statement, phase) {
+    if (this.options.profile !== void 0) this.counts.set(statement.kind, (this.counts.get(statement.kind) ?? 0) + 1);
+    if (this.options.trace) {
+      const entry = `+ safe-bash awk ${phase} ${statement.kind}
+`;
+      await writeBytes(this.context.stderr, bytes(this.budget.check(entry)), this.context.signal);
+    }
+  }
+  async publish(variables) {
+    if (this.options.dump !== void 0) {
+      let output = "";
+      for (const name of [...variables.keys()].sort()) {
+        this.budget.step();
+        const value = variables.get(name);
+        const display = value instanceof AwkArray ? `array, ${value.entries.size} elements` : value.kind === "number" ? String(value.number) : value.kind === "unset" ? '""' : quoteAwk(value.text, this.budget);
+        const entry = `${name}: ${display}
+`;
+        if (output.length + entry.length > this.budget.maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
+        output += entry;
+      }
+      await this.save(this.options.dump, output);
+    }
+    if (this.options.profile !== void 0) {
+      let output = "# safe-bash awk statement profile (aggregate execution counts)\n";
+      for (const [kind, count] of this.counts) output = this.budget.check(output + `${count}	${kind}
+`);
+      await this.save(this.options.profile, this.budget.check(output));
+    }
+  }
+  async save(destination, output) {
+    const path = virtualPath(this.context, destination);
+    await writeFileOutput(this.context, bytes(output), (chunk) => this.context.fs.writeFile(path, chunk, { signal: this.context.signal }));
+  }
+};
+
+export {
+  AwkInspection
+};

package/dist/safe-bash/command-chunks/{chunk-VVI4Z73I.js → chunk-QP4R6GLA.js}

@@ -195,11 +195,13 @@ var Budget = class {
     return this.visitValue(value, 0, 0);
   }
   visitValue(current, depth, bytes) {
+    const startSteps = this.steps;
     this.step();
     if (depth > this.limits.maxDepth) throw new JqLimitError("maxDepth");
     if (current !== null && typeof current === "object" && !(current instanceof Decimal)) {
       const cached = cachedValueMetrics.get(current);
       if (cached !== void 0) {
+        this.step(cached.steps - 1);
         if (depth + cached.maxRelDepth > this.limits.maxDepth) throw new JqLimitError("maxDepth");
         this.collection(cached.maxCol);
         const total = bytes + cached.bytes;
@@ -269,7 +271,7 @@ var Budget = class {
           bytes += 2;
         }
       }
-      cachedValueMetrics.set(current, { bytes: bytes - startBytes, maxRelDepth, maxCol });
+      cachedValueMetrics.set(current, { bytes: bytes - startBytes, maxRelDepth, maxCol, steps: this.steps - startSteps });
     } else {
       if (typeof current === "string") {
         this.step(current.length);
@@ -304,6 +306,7 @@ function objectSize(value) {
   return keyOrders.get(value)?.length ?? Object.keys(value).length;
 }
 function put(value, key, item) {
+  invalidateCachedValueMetrics(value);
   const existing = Object.hasOwn(value, key);
   let keys = keyOrders.get(value);
   if (keys !== void 0) {
@@ -324,6 +327,7 @@ function put(value, key, item) {
 }
 function remove(value, key) {
   if (!Object.hasOwn(value, key)) return;
+  invalidateCachedValueMetrics(value);
   let keys = keyOrders.get(value);
   if (!keys) {
     keys = Object.keys(value);

package/dist/safe-bash/command-chunks/{chunk-LPORMIZS.js → chunk-QWIDNAAK.js}

@@ -1,13 +1,6 @@
 import {
   configuredTable
-} from "./chunk-2WRTLCGK.js";
-import {
-  cell,
-  decode,
-  fields,
-  validateScalar,
-  whitespace
-} from "./chunk-NI7MKJPN.js";
+} from "./chunk-QZF3SINC.js";
 import {
   ColumnInputs,
   diagnostics
@@ -18,6 +11,13 @@ import {
   settings,
   usage
 } from "./chunk-AHEQ2THG.js";
+import {
+  cell,
+  decode,
+  fields,
+  validateScalar,
+  whitespace
+} from "./chunk-NI7MKJPN.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

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

@@ -0,0 +1,35 @@
+import {
+  CurlError
+} from "./chunk-IYPAQ7PH.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-network-engine/src/url.ts
+init_buffer();
+function curlRequestTarget(text) {
+  const scheme = text.indexOf("://");
+  if (scheme < 0) throw new CurlError(3, "Malformed URL; explicit HTTP(S) scheme required");
+  let start = scheme + 3;
+  while (start < text.length && !"/?#".includes(text[start])) {
+    if (text[start] === "\\") throw new CurlError(3, "Malformed URL authority");
+    start++;
+  }
+  const fragment = text.indexOf("#", start);
+  const target = text.slice(start, fragment < 0 ? void 0 : fragment);
+  const queryIndex = target.indexOf("?");
+  const path = queryIndex < 0 ? target : target.slice(0, queryIndex);
+  const query = queryIndex < 0 ? "" : target.slice(queryIndex);
+  const segments = [];
+  for (const segment of (path || "/").split("/")) {
+    if (segment === "..") {
+      if (segments.length > 1) segments.pop();
+    } else if (segment !== ".") segments.push(segment);
+  }
+  if (path.endsWith("/.") || path.endsWith("/..")) segments.push("");
+  return (segments.join("/") || "/") + query;
+}
+
+export {
+  curlRequestTarget
+};