@poe-platform/safe-bash 0.1.799 → 0.1.801

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

@@ -0,0 +1,63 @@
+import {
+  AwkArray
+} from "./chunk-6BNTBWIK.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-XAFSZDY2.js → chunk-XS72HTMA.js}

@@ -245,6 +245,17 @@ function input(context, name = "-") {
     }
     return readBytes(context.stdin, context.signal);
   }
+  const budget = context.inputBudget;
+  if (budget && Number.isFinite(budget.maxBytes)) {
+    return (async function* () {
+      let total = 0;
+      for await (const bytes of inputFileSlow(context, name)) {
+        total += bytes.byteLength;
+        budget.check(total);
+        yield bytes;
+      }
+    })();
+  }
   const backing = getRuntimeBackingFileSystem(context.fs);
   if (!context.signal.aborted && backing !== void 0 && backing.capabilitiesFor === void 0 && context.fs.readStream && context.fs.capabilities.streamingRead !== false && context.fs.capabilities.read !== false && Object.getPrototypeOf(backing)?.constructor?.name === "MemoryFileSystem" && !Object.prototype.hasOwnProperty.call(backing, "readStream")) {
     const resolvedPath = pathOf(context, name);

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

@@ -0,0 +1,220 @@
+import {
+  colorText,
+  expandTabs
+} from "./chunk-6F4XCVON.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-diff/src/diff-format.ts
+init_buffer();
+function range(start, count) {
+  return count === 0 ? `${start}` : count === 1 ? `${start + 1}` : `${start + 1},${start + count}`;
+}
+function outputLine(prefix, line, options, color) {
+  if (options?.initialTab) prefix = (prefix.length === 2 ? prefix.slice(0, -1) : prefix.trimEnd()) + "	";
+  if (options?.expand) line = expandTabs(line);
+  const text = `${prefix}${line.endsWith("\n") ? line : line + "\n"}`;
+  return (color === void 0 ? text : colorText(text, color, options)) + (line.endsWith("\n") ? "" : "\\n");
+}
+async function normal(changes, budget, append, options) {
+  let scan = 0;
+  let oldPosition = 0;
+  let newPosition = 0;
+  while (scan < changes.length) {
+    budget.step();
+    {
+      const c = budget.checkpoint();
+      if (c) await c;
+    }
+    if (changes[scan].kind === " ") {
+      oldPosition++;
+      newPosition++;
+      scan++;
+      continue;
+    }
+    const start = scan;
+    let oldCount = 0;
+    let newCount = 0;
+    while (scan < changes.length && changes[scan].kind !== " ") {
+      if (changes[scan++].kind === "-") oldCount++;
+      else newCount++;
+      budget.step();
+      {
+        const c = budget.checkpoint();
+        if (c) await c;
+      }
+    }
+    budget.hunk();
+    if (changes[start].ignored) {
+      oldPosition += oldCount;
+      newPosition += newCount;
+      continue;
+    }
+    append(colorText(`${range(oldPosition, oldCount)}${oldCount === 0 ? "a" : newCount === 0 ? "d" : "c"}${range(newPosition, newCount)}
+`, 36, options));
+    for (const kind of ["-", "+"]) {
+      if (kind === "+" && oldCount && newCount) append("---\n");
+      for (let index = start; index < scan; index++) {
+        const edit = changes[index];
+        if (edit.kind === kind) append(outputLine(kind === "-" ? "< " : "> ", edit.line, options, kind === "-" ? 31 : 32));
+        budget.step();
+        {
+          const c = budget.checkpoint();
+          if (c) await c;
+        }
+      }
+    }
+    oldPosition += oldCount;
+    newPosition += newCount;
+  }
+}
+function unifiedRange(start, count) {
+  return count === 0 ? `${start},0` : count === 1 ? `${start + 1}` : `${start + 1},${count}`;
+}
+async function contextSide(changes, start, end, kind, budget, append, options) {
+  let scan = start;
+  while (scan < end) {
+    budget.step();
+    {
+      const c = budget.checkpoint();
+      if (c) await c;
+    }
+    if (changes[scan].kind === " ") {
+      const edit = changes[scan++];
+      append(outputLine("  ", kind === "+" ? edit.newLine ?? edit.line : edit.line, options, kind === "-" ? 31 : 32));
+      continue;
+    }
+    let groupEnd = scan;
+    let removed = false;
+    let added = false;
+    while (groupEnd < end && changes[groupEnd].kind !== " ") {
+      if (changes[groupEnd++].kind === "-") removed = true;
+      else added = true;
+      budget.step();
+      {
+        const c = budget.checkpoint();
+        if (c) await c;
+      }
+    }
+    while (scan < groupEnd) {
+      const edit = changes[scan++];
+      if (edit.kind === kind) append(outputLine(removed && added ? "! " : `${kind} `, edit.line, options, kind === "-" ? 31 : 32));
+      budget.step();
+      {
+        const c = budget.checkpoint();
+        if (c) await c;
+      }
+    }
+  }
+}
+async function contextual(changes, format, oldLabel, newLabel, context, budget, append, options, heading) {
+  context = Math.min(context, changes.length);
+  append(colorText(`${format === "unified" ? "---" : "***"} ${oldLabel}
+`, 1, options));
+  append(colorText(`${format === "unified" ? "+++" : "---"} ${newLabel}
+`, 1, options));
+  let scan = 0;
+  let oldPosition = 0;
+  let newPosition = 0;
+  while (scan < changes.length) {
+    let changed = scan;
+    while (changed < changes.length && changes[changed].kind === " ") {
+      changed++;
+      budget.step();
+      {
+        const c = budget.checkpoint();
+        if (c) await c;
+      }
+    }
+    if (changed === changes.length) break;
+    const start = Math.max(0, changed - context);
+    let lastChange = changed;
+    let end = changed + 1;
+    while (end < changes.length && end - lastChange - 1 <= 2 * context) {
+      if (changes[end].kind !== " ") {
+        if (changes[end].ignored && end - lastChange - 1 >= context) break;
+        lastChange = end;
+      }
+      end++;
+      budget.step();
+      {
+        const c = budget.checkpoint();
+        if (c) await c;
+      }
+    }
+    end = Math.min(changes.length, lastChange + context + 1);
+    while (scan > start) {
+      const edit = changes[--scan];
+      if (edit.kind !== "+") oldPosition--;
+      if (edit.kind !== "-") newPosition--;
+      budget.step();
+      {
+        const c = budget.checkpoint();
+        if (c) await c;
+      }
+    }
+    while (scan < start) {
+      if (changes[scan].kind !== "+") oldPosition++;
+      if (changes[scan++].kind !== "-") newPosition++;
+      budget.step();
+      {
+        const c = budget.checkpoint();
+        if (c) await c;
+      }
+    }
+    let oldCount = 0;
+    let newCount = 0;
+    let removed = false;
+    let added = false;
+    for (let index = start; index < end; index++) {
+      const kind = changes[index].kind;
+      if (kind !== "+") oldCount++;
+      if (kind !== "-") newCount++;
+      if (kind === "-") removed = true;
+      if (kind === "+") added = true;
+      budget.step();
+      {
+        const c = budget.checkpoint();
+        if (c) await c;
+      }
+    }
+    if (!changes.slice(start, end).some((edit) => edit.kind !== " " && !edit.ignored)) {
+      oldPosition += oldCount;
+      newPosition += newCount;
+      scan = end;
+      continue;
+    }
+    budget.hunk();
+    const functionLine = heading ? await heading(oldPosition) : "";
+    if (format === "unified") {
+      append(colorText(`@@ -${unifiedRange(oldPosition, oldCount)} +${unifiedRange(newPosition, newCount)} @@`, 36, options) + `${functionLine ? ` ${functionLine}` : ""}
+`);
+      for (let index = start; index < end; index++) {
+        const edit = changes[index];
+        append(outputLine(edit.kind, edit.line, options, edit.kind === " " ? void 0 : edit.kind === "-" ? 31 : 32));
+        budget.step();
+        {
+          const c = budget.checkpoint();
+          if (c) await c;
+        }
+      }
+    } else {
+      append(`***************${functionLine ? ` ${functionLine}` : ""}
+` + colorText(`*** ${range(oldPosition, oldCount)} ****
+`, 36, options));
+      if (removed) await contextSide(changes, start, end, "-", budget, append, options);
+      append(colorText(`--- ${range(newPosition, newCount)} ----
+`, 36, options));
+      if (added) await contextSide(changes, start, end, "+", budget, append, options);
+    }
+    scan = end;
+    oldPosition += oldCount;
+    newPosition += newCount;
+  }
+}
+
+export {
+  normal,
+  contextual
+};

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

@@ -0,0 +1,43 @@
+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 hostHeaders = request.headers?.filter(([name]) => name.toLowerCase() === "host") ?? [];
+    if (hostHeaders.length > 1 || hostHeaders.some(([, value]) => value.toLowerCase() !== url.host.toLowerCase())) return false;
+    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-YOF7R4OY.js

@@ -0,0 +1,80 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-tar/src/transform.ts
+init_buffer();
+import { checkPath, fail } from "../../safe-bash-io-engine/commands/archive/internal.js";
+import { Budget } from "../../safe-bash-io-engine/commands/text-programs/shared.js";
+import { Pattern, substitute } from "../../safe-bash-regex-engine/text/regex.js";
+function parseTransform(source) {
+  const transforms = [];
+  let offset = 0;
+  while (offset < source.length) {
+    if (source[offset++] !== "s") fail("only substitution transforms are supported");
+    const delimiter = source[offset++];
+    if (!delimiter || delimiter === "\\" || delimiter === "\n") fail("invalid transform delimiter");
+    const field = () => {
+      let value = "";
+      while (offset < source.length) {
+        const character = source[offset++];
+        if (character === delimiter) return value;
+        if (character === "\\") {
+          const next = source[offset++];
+          if (next === void 0) break;
+          value += `\\${next}`;
+        } else value += character;
+      }
+      return fail("unterminated transform expression");
+    };
+    const patternSource = field();
+    if (!patternSource) fail("empty transform pattern is unsupported");
+    const replacement = field();
+    let global = false;
+    let ignoreCase = false;
+    let extended = false;
+    while (offset < source.length && source[offset] !== ";") {
+      const flag = source[offset++];
+      if (flag === "g") global = true;
+      else if (flag === "i") ignoreCase = true;
+      else if (flag === "x") extended = true;
+      else fail(`unsupported transform flag: ${flag}`);
+    }
+    const pattern = new Pattern(patternSource, extended, ignoreCase);
+    for (let index = 0; index < replacement.length; index++) {
+      if (replacement[index] !== "\\") continue;
+      const next = replacement[++index];
+      if (next && "uUlLE".includes(next)) fail("transform replacement case conversion is unsupported");
+      if (next && next >= "1" && next <= "9" && Number(next) > pattern.groupCount) fail("transform references an undefined capture group");
+    }
+    transforms.push({ pattern, replacement, global });
+    if (source[offset] === ";") offset++;
+  }
+  if (!transforms.length) fail("empty transform expression");
+  return transforms;
+}
+var TransformedNames = class {
+  constructor(context, transforms, limits) {
+    this.transforms = transforms;
+    this.limits = limits;
+    this.budget = new Budget(context, {
+      ...Number.isFinite(limits.maxPatternSteps) ? { maxSteps: limits.maxPatternSteps } : {},
+      ...Number.isFinite(limits.maxPathBytes) ? { maxBufferBytes: limits.maxPathBytes } : {}
+    });
+  }
+  transforms;
+  limits;
+  budget;
+  async apply(name) {
+    for (const transform of this.transforms) {
+      name = (await substitute(name, transform.pattern, transform.replacement, this.budget, transform.global)).text;
+      checkPath(name, this.limits);
+    }
+    return name;
+  }
+};
+
+export {
+  parseTransform,
+  TransformedNames
+};

package/dist/safe-bash/command-chunks/{chunk-VZHRZMS7.js → chunk-YOFC45RK.js}

@@ -5,7 +5,7 @@ import {
   outputFailure,
   removeManagedAbortWaiter,
   writeBytes
-} from "./chunk-TYVCKQDH.js";
+} from "./chunk-VXSLJH7G.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

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

@@ -50,8 +50,45 @@ 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 = {
+  dedup: { s: "select", l: "keep-last", S: "sorted" },
+  enum: { c: "column-name", S: "start" },
+  from: { f: "format" },
+  cat: { p: "pad" },
+  split: { S: "size", O: "out-dir", f: "filename", c: "chunks" },
+  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 ["keep-last", "sorted", "keep-duplicates", "pad", "sort-keys", "single-object", "omit", "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 = {
+  dedup: /* @__PURE__ */ new Set([...common, "no-headers", "select", "keep-last", "sorted", "keep-duplicates"]),
+  enum: /* @__PURE__ */ new Set([...common, "no-headers", "column-name", "start"]),
+  transpose: new Set(common),
+  agg: /* @__PURE__ */ new Set([...common, "no-headers"]),
+  groupby: /* @__PURE__ */ new Set([...common, "no-headers"]),
+  to: /* @__PURE__ */ new Set([...common, "no-headers", "nulls", "omit"]),
+  from: /* @__PURE__ */ new Set([...common, "format", "sort-keys", "single-object", "column-name"]),
+  cat: /* @__PURE__ */ new Set([...common, "no-headers", "pad"]),
+  split: /* @__PURE__ */ new Set(["help", "delimiter", "no-headers", "size", "out-dir", "filename", "chunks"]),
+  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 +100,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 +138,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,18 +161,38 @@ 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 (command === "groupby") rightSelection = operands.shift();
+  if (["search", "filter", "rename", "agg", "groupby", "to", "cat"].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" && command !== "cat" && 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);
-  const path = (value) => {
+  const path = (value, input = false) => {
     if (!value || value.includes("\0")) throw new XanError("invalid path");
-    if (/\.(gz|zst|cdx|ndjson|jsonl|vcf|gtf|gff2|sam|bed)$/u.test(value)) throw new XanError(`unsupported in bounded CSV profile: format ${value}`);
+    if (input && command !== "from" && /\.(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, true);
   const output = values.get("output");
   if (output !== void 0) path(output);
   let delimiter;
@@ -168,8 +225,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 +256,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 } : {},