@poe-platform/safe-bash 0.1.800 → 0.1.802

package/dist/safe-bash/command-chunks/{chunk-WB5SVIG7.js → chunk-C5YYCQHW.js}

@@ -2,17 +2,26 @@ import {
   parseSelection,
   resolveSelection
 } from "./chunk-LCF3OB7P.js";
+import {
+  Writer
+} from "./chunk-VM2ZMWHQ.js";
+import {
+  observe,
+  outputOperation,
+  preflight,
+  publish
+} from "./chunk-JDYXY44P.js";
 import {
   checkedAdd,
   inferDelimiter,
   unsigned
-} from "./chunk-QI7LGHJJ.js";
+} from "./chunk-Z45N42QC.js";
 import {
   boundedSort
 } from "./chunk-HEYKESED.js";
 import {
   Scanner
-} from "./chunk-QUENU6GM.js";
+} from "./chunk-E55UKBIE.js";
 import {
   XanError
 } from "./chunk-QOKBZFFD.js";
@@ -23,6 +32,484 @@ import {
 // packages/safe-bash-command-xan/src/commands.ts
 init_buffer();
 
+// packages/safe-bash-command-xan/src/extended.ts
+init_buffer();
+import { resolvePath } from "../../safe-bash-contracts/path.js";
+
+// packages/safe-bash-command-xan/src/cells.ts
+init_buffer();
+async function* emitted(bytes, budget) {
+  try {
+    yield bytes;
+  } finally {
+    budget.release(bytes.length);
+  }
+}
+async function* textRow(values, writer, budget) {
+  const owned = [];
+  budget.hold(values.length * 32);
+  try {
+    const cells = [];
+    for (const value of values) {
+      if (typeof value === "string") {
+        const bytes = await budget.encode(value);
+        owned.push(bytes);
+        cells.push(bytes);
+      } else cells.push(value);
+    }
+    yield* emitted(await writer.values(cells), budget);
+  } finally {
+    for (const bytes of owned) budget.release(bytes.length);
+    budget.release(values.length * 32);
+  }
+}
+async function compareBytes(left, right, budget) {
+  for (let i = 0; i < Math.min(left.length, right.length); i++) {
+    budget.work();
+    if (left[i] !== right[i]) return left[i] < right[i] ? -1 : 1;
+    if ((i & 1023) === 0) {
+      const c = budget.checkpoint();
+      if (c) await c;
+    }
+  }
+  return Math.sign(left.length - right.length);
+}
+function cellText(bytes, budget) {
+  budget.work(bytes.length);
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    throw new XanError("cell is not valid UTF-8");
+  }
+}
+function decimalNumber(text, budget) {
+  let offset = text[0] === "+" || text[0] === "-" ? 1 : 0;
+  let digits = 0;
+  while (offset < text.length && text[offset] >= "0" && text[offset] <= "9") {
+    offset++;
+    digits++;
+    budget.work();
+  }
+  if (text[offset] === ".") {
+    offset++;
+    while (offset < text.length && text[offset] >= "0" && text[offset] <= "9") {
+      offset++;
+      digits++;
+      budget.work();
+    }
+  }
+  if (!digits) return void 0;
+  if (text[offset] === "e" || text[offset] === "E") {
+    offset++;
+    if (text[offset] === "+" || text[offset] === "-") offset++;
+    const start = offset;
+    while (offset < text.length && text[offset] >= "0" && text[offset] <= "9") {
+      offset++;
+      budget.work();
+    }
+    if (offset === start) return void 0;
+  }
+  if (offset !== text.length) return void 0;
+  const value = Number(text);
+  return Number.isFinite(value) ? value : void 0;
+}
+
+// packages/safe-bash-command-xan/src/extended.ts
+async function select(text, header, args, budget) {
+  budget.hold((header?.width ?? 0) * 32);
+  try {
+    return await resolveSelection(await parseSelection(text, budget), header?.cells.map((cell) => cell.decoded.view()) ?? [], args.noHeaders, budget);
+  } finally {
+    budget.release((header?.width ?? 0) * 32);
+  }
+}
+async function key(row, selected, budget) {
+  const size = selected.reduce((n, i) => n + row.cells[i].decoded.length * 2 + 32, 0);
+  budget.hold(size);
+  let result = "";
+  for (const index of selected) {
+    const bytes = row.cells[index].decoded.view();
+    result += `${bytes.length}:`;
+    for (const byte of bytes) {
+      budget.work();
+      result += String.fromCharCode(byte);
+      const cp = budget.checkpoint();
+      if (cp) await cp;
+    }
+  }
+  return { identity: result, size };
+}
+async function aggregates(text, header, args, budget) {
+  const result = [];
+  let at = 0;
+  const whitespace2 = () => {
+    while (at < text.length && " \n\r	".includes(text[at])) at++;
+  };
+  while (at < text.length) {
+    whitespace2();
+    const begin = at;
+    while (at < text.length && text[at] !== "(") at++;
+    const name = text.slice(begin, at).trim().toLowerCase();
+    if (!["count", "sum", "mean", "avg", "min", "max", "first", "last"].includes(name) || at === text.length) throw new XanError("expected an aggregate call");
+    const start = ++at;
+    let quote = "";
+    while (at < text.length) {
+      const ch = text[at];
+      if (quote) {
+        if (ch === quote) quote = "";
+      } else if (ch === '"' || ch === "'") quote = ch;
+      else if (ch === ")") break;
+      at++;
+    }
+    if (at === text.length) throw new XanError("unterminated aggregate call");
+    const column = text.slice(start, at).trim();
+    at++;
+    let label = text.slice(begin, at).trim();
+    whitespace2();
+    if (text.slice(at, at + 2).toLowerCase() === "as" && " 	\n".includes(text[at + 2] ?? "")) {
+      at += 2;
+      whitespace2();
+      const quote2 = text[at] === '"' || text[at] === "'" ? text[at++] : void 0;
+      const start2 = at;
+      while (at < text.length && (quote2 ? text[at] !== quote2 : text[at] !== ",")) at++;
+      label = text.slice(start2, at).trim();
+      if (quote2) {
+        if (text[at++] !== quote2) throw new XanError("unterminated aggregate alias");
+        whitespace2();
+      }
+    }
+    if (at < text.length && text[at++] !== ",") throw new XanError("expected comma between aggregate calls");
+    let field;
+    if (column && column !== "*") {
+      const fields = await select(column, header, args, budget);
+      try {
+        if (fields.length !== 1) throw new XanError("aggregate requires one column");
+        field = fields[0];
+      } finally {
+        budget.release(fields.length * 8);
+      }
+    } else if (name !== "count") throw new XanError(`${name} requires a column`);
+    budget.hold(128 + label.length * 2);
+    result.push({ name, label, ...field === void 0 ? {} : { field } });
+  }
+  if (!result.length) throw new XanError("expected an aggregate call");
+  return result;
+}
+async function* extendedRows(args, scope, budget, writer) {
+  if (args.command === "from") {
+    yield* from(args, scope, budget, writer);
+    return;
+  }
+  if (args.command === "cat") {
+    yield* concatenate(args, scope, budget, writer);
+    return;
+  }
+  const scanner = scope.open(args.inputs[0], args);
+  const header = await scanner.next();
+  if (header) scope.own(header.free);
+  const retained = [];
+  scope.own(() => {
+    for (const row of retained) row.free();
+    budget.release(retained.length * 32);
+  });
+  async function* rows2() {
+    let row = args.noHeaders ? header : await scanner.next();
+    try {
+      while (row) {
+        if (row.width !== header?.width) throw new XanError("CSV error: inconsistent field count");
+        yield row;
+        row = await scanner.next();
+      }
+    } finally {
+      row?.free();
+    }
+  }
+  if (args.command === "enum") {
+    if (!args.noHeaders && header) yield* textRow([args.options.get("column-name") ?? "index", ...header.cells.map((cell) => cell.decoded.view())], writer, budget);
+    let index = args.start;
+    for await (const row of rows2()) {
+      try {
+        yield* textRow([String(index++), ...row.cells.map((cell) => cell.decoded.view())], writer, budget);
+      } finally {
+        row.free();
+      }
+    }
+    return;
+  }
+  if (args.command === "dedup") {
+    const selected = await select(args.selection, header, args, budget);
+    const seen = /* @__PURE__ */ new Map();
+    scope.own(() => {
+      for (const entry of seen.values()) entry.row.free();
+    });
+    if (!args.noHeaders && header) yield* emitted(await writer.row(header.cells), budget);
+    for await (const row of rows2()) {
+      const { identity, size } = await key(row, selected, budget), existing = seen.get(identity);
+      if (existing) {
+        budget.release(size);
+        existing.count++;
+        if (args.options.has("keep-last")) {
+          existing.row.free();
+          existing.row = row;
+        } else row.free();
+      } else {
+        budget.hold(96);
+        seen.set(identity, { row, count: 1 });
+      }
+    }
+    for (const entry of seen.values()) if (!args.options.has("keep-duplicates") || entry.count > 1) yield* emitted(await writer.row(entry.row.cells), budget);
+    return;
+  }
+  if (args.command === "agg" || args.command === "groupby") {
+    const selected = args.command === "groupby" ? await select(args.rightSelection ?? "", header, args, budget) : [];
+    const specs = await aggregates(args.operand, header, args, budget);
+    const groups = /* @__PURE__ */ new Map();
+    const make = (row) => {
+      budget.hold(specs.length * 128 + selected.length * 32 + 64);
+      return { keys: selected.map((index) => {
+        const bytes = row.cells[index].decoded.view();
+        budget.hold(bytes.length);
+        return bytes.slice();
+      }), states: specs.map(() => ({ count: 0, sum: 0, min: Infinity, max: -Infinity })) };
+    };
+    if (args.command === "agg") groups.set("", make());
+    yield* textRow([...selected.map((index) => args.noHeaders ? String(index) : header.cells[index].decoded.view()), ...specs.map((spec) => spec.label)], writer, budget);
+    for await (const row of rows2()) {
+      try {
+        const { identity, size } = selected.length ? await key(row, selected, budget) : { identity: "", size: 0 };
+        let group = groups.get(identity);
+        if (!group) {
+          group = make(row);
+          groups.set(identity, group);
+        } else budget.release(size);
+        for (let i = 0; i < specs.length; i++) {
+          budget.work();
+          const spec = specs[i], state = group.states[i];
+          const bytes = spec.field === void 0 ? void 0 : row.cells[spec.field].decoded.view();
+          if (spec.name === "count") {
+            if (!bytes || bytes.length) state.count++;
+            continue;
+          }
+          if (!bytes?.length) continue;
+          state.count++;
+          if (spec.name === "first" || spec.name === "last") {
+            if (spec.name === "first" && state.first) continue;
+            const previous = spec.name === "first" ? state.first : state.last;
+            if (previous) budget.release(previous.length);
+            budget.hold(bytes.length);
+            if (spec.name === "first") state.first = bytes.slice();
+            else state.last = bytes.slice();
+          } else {
+            budget.hold(bytes.length * 4);
+            let value;
+            try {
+              value = decimalNumber(cellText(bytes, budget), budget);
+            } finally {
+              budget.release(bytes.length * 4);
+            }
+            if (value === void 0) throw new XanError(`${spec.name} requires numeric values`);
+            state.sum += value;
+            state.min = Math.min(state.min, value);
+            state.max = Math.max(state.max, value);
+          }
+        }
+      } finally {
+        row.free();
+      }
+    }
+    for (const group of groups.values()) yield* textRow([...group.keys, ...specs.map((spec, i) => {
+      const state = group.states[i];
+      if (spec.name === "first") return state.first ?? "";
+      if (spec.name === "last") return state.last ?? "";
+      if (spec.name === "count") return String(state.count);
+      if (spec.name === "sum") return String(state.sum);
+      if (!state.count) return "";
+      return String(spec.name === "min" ? state.min : spec.name === "max" ? state.max : state.sum / state.count);
+    })], writer, budget);
+    return;
+  }
+  if (args.command === "transpose" && !args.noHeaders && header) {
+    budget.hold(32);
+    retained.push(header);
+  }
+  for await (const row of rows2()) {
+    budget.hold(32);
+    retained.push(row);
+  }
+  if (args.command === "transpose") {
+    for (let i = 0; i < (header?.width ?? 0); i++) yield* textRow(retained.map((row) => row.cells[i].decoded.view()), writer, budget);
+  } else if (args.command === "split") {
+    const options = args.options;
+    let size = Number(await unsigned(options.get("size") ?? "4096", "--size", budget));
+    if (options.has("chunks")) {
+      const chunks = Number(await unsigned(options.get("chunks"), "--chunks", budget));
+      if (!chunks) throw new XanError("chunks must be positive");
+      size = Math.max(1, Math.ceil(retained.length / chunks));
+    }
+    if (!Number.isSafeInteger(size) || size <= 0) throw new XanError("size must be positive");
+    const directory = resolvePath(scope.context.cwd, options.get("out-dir") ?? ".");
+    const template = options.get("filename") ?? "{}.csv";
+    if (template.split("{}").length !== 2 || template.includes("/") || template.includes("\\") || template.includes("\0")) throw new XanError("filename must contain one {} and no path separators");
+    await observe(() => scope.context.fs.mkdir(directory, { recursive: true, signal: budget.signal }), budget.signal);
+    for (let start = 0; start < Math.max(1, retained.length); start += size) {
+      budget.work();
+      const output = resolvePath(directory, template.replace("{}", String(options.has("chunks") ? start / size : start)));
+      const destination = await preflight(scope.context, { ...args, output }, budget);
+      const operation = outputOperation(scope.context, true);
+      const chunks = async function* () {
+        const chunkWriter = new Writer(writer.delimiter, budget);
+        if (!args.noHeaders && header) yield* emitted(await chunkWriter.row(header.cells), budget);
+        for (let i = start; i < Math.min(start + size, retained.length); i++) yield* emitted(await chunkWriter.row(retained[i].cells), budget);
+      };
+      try {
+        await publish(scope.context, destination, chunks(), operation, budget);
+      } finally {
+        await operation.close();
+      }
+    }
+  } else if (args.command === "to") {
+    const format = args.operand;
+    if (!["json", "jsonl", "ndjson", "txt"].includes(format)) throw new XanError(`unsupported output format: ${format}`);
+    const names = header?.cells.map((cell, index) => args.noHeaders ? String(index) : cellText(cell.decoded.view(), budget)) ?? [];
+    const numeric = names.map((_, column) => retained.every((row) => {
+      const text = cellText(row.cells[column].decoded.view(), budget);
+      return !text || decimalNumber(text, budget) !== void 0;
+    }));
+    if (format === "json") yield* emitted(await writer.text("["), budget);
+    for (let i = 0; i < retained.length; i++) {
+      const row = retained[i];
+      const temporary = row.cells.reduce((n, cell) => n + cell.decoded.length * 12 + 64, 0);
+      budget.hold(temporary);
+      try {
+        const values = row.cells.map((cell) => cellText(cell.decoded.view(), budget));
+        if (format === "txt") {
+          yield* emitted(await writer.text(values.join("\n") + "\n"), budget);
+          continue;
+        }
+        const record = Object.fromEntries(values.flatMap((value, column) => !value && args.options.has("omit") ? [] : [[names[column], !value ? args.options.has("nulls") ? null : "" : numeric[column] ? Number(value) : value]]));
+        yield* emitted(await writer.text((format === "json" && i ? "," : "") + JSON.stringify(record) + (format === "json" ? "" : "\n")), budget);
+      } finally {
+        budget.release(temporary);
+      }
+    }
+    if (format === "json") yield* emitted(await writer.text("]\n"), budget);
+  }
+}
+async function* from(args, scope, budget, writer) {
+  const path = args.inputs[0], format = args.options.get("format") ?? path.slice(path.lastIndexOf(".") + 1);
+  if (!["json", "jsonl", "ndjson", "txt", "text", "lines", "raw"].includes(format)) throw new XanError(`unsupported input format: ${format}`);
+  const scanner = scope.open(path, args), chunks = [];
+  let size = 0;
+  for await (const chunk of scanner.raw(false)) {
+    budget.hold(chunk.length + 32);
+    chunks.push(chunk.slice());
+    size += chunk.length;
+  }
+  budget.hold(size * 64);
+  const bytes = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.length;
+    budget.work(chunk.length);
+    const cp = budget.checkpoint();
+    if (cp) await cp;
+  }
+  const text = cellText(bytes, budget);
+  if (["raw", "txt", "text", "lines"].includes(format)) {
+    yield* textRow([args.options.get("column-name") ?? "text"], writer, budget);
+    const lines = format === "raw" ? [text] : text.split("\n");
+    if (format !== "raw" && lines.at(-1) === "") lines.pop();
+    for (const line of lines) {
+      budget.add("maxRecords", 1);
+      const value = line.endsWith("\r") && format !== "raw" ? line.slice(0, -1) : line;
+      const bytes2 = await budget.textSize(value);
+      budget.bound("maxCellBytes", bytes2);
+      budget.bound("maxRecordBytes", bytes2);
+      yield* textRow([value], writer, budget);
+    }
+    return;
+  }
+  let data2;
+  try {
+    data2 = format === "json" ? JSON.parse(text) : text.split("\n").filter((line) => line.trim()).map((line) => JSON.parse(line));
+  } catch {
+    throw new XanError("invalid JSON input");
+  }
+  const rows2 = Array.isArray(data2) ? data2 : args.options.has("single-object") ? [data2] : typeof data2 === "object" && data2 !== null ? Object.entries(data2).map(([key2, value]) => ({ key: key2, value })) : [];
+  const names = /* @__PURE__ */ new Set();
+  for (const row of rows2) {
+    budget.add("maxRecords", 1);
+    if (!row || typeof row !== "object" || Array.isArray(row)) throw new XanError("JSON records must be objects");
+    for (const name of Object.keys(row)) {
+      budget.work();
+      names.add(name);
+      budget.bound("maxColumns", names.size);
+    }
+  }
+  const columns = [...names];
+  if (args.options.has("sort-keys")) columns.sort();
+  if (columns.length) yield* textRow(columns, writer, budget);
+  for (const row of rows2) {
+    const values = [];
+    let recordBytes = 0;
+    for (const name of columns) {
+      const value = row[name];
+      const text2 = value === null || value === void 0 ? "" : typeof value === "object" ? JSON.stringify(value) : String(value);
+      const bytes2 = await budget.textSize(text2);
+      budget.bound("maxCellBytes", bytes2);
+      recordBytes += bytes2;
+      budget.bound("maxRecordBytes", recordBytes);
+      values.push(text2);
+    }
+    yield* textRow(values, writer, budget);
+  }
+}
+async function* concatenate(args, scope, budget, writer) {
+  if (!["rows", "cols", "columns"].includes(args.operand)) throw new XanError("cat requires rows or columns");
+  if (args.operand === "rows") {
+    let width2;
+    let headerEmitted = false;
+    for (let input = 0; input < args.inputs.length; input++) {
+      const scanner = scope.open(args.inputs[input], args);
+      let first = true;
+      for (; ; ) {
+        const row = await scanner.next();
+        if (!row) break;
+        try {
+          width2 ??= row.width;
+          if (row.width !== width2) throw new XanError("CSV error: inconsistent field count");
+          if (!(first && headerEmitted && !args.noHeaders)) yield* emitted(await writer.row(row.cells), budget);
+          headerEmitted = true;
+        } finally {
+          row.free();
+        }
+        first = false;
+      }
+      await scanner.close();
+    }
+  } else {
+    const scanners = args.inputs.map((path) => scope.open(path, args)), widths = [];
+    for (; ; ) {
+      const rows2 = [];
+      try {
+        for (const scanner of scanners) rows2.push(await scanner.next());
+        if (rows2.every((row) => !row) || !args.options.has("pad") && rows2.some((row) => !row)) break;
+        const values = [];
+        for (let i = 0; i < rows2.length; i++) {
+          const row = rows2[i];
+          widths[i] ??= row?.width ?? 0;
+          if (row && row.width !== widths[i]) throw new XanError("CSV error: inconsistent field count");
+          values.push(...row ? row.cells.map((cell) => cell.decoded.view()) : Array(widths[i]).fill(""));
+        }
+        yield* textRow(values, writer, budget);
+      } finally {
+        for (const row of rows2) row?.free();
+      }
+    }
+  }
+}
+
 // packages/safe-bash-command-xan/src/condition.ts
 init_buffer();
 async function condition(expression, headers, noHeaders, budget, scope) {
@@ -123,84 +610,6 @@ async function condition(expression, headers, noHeaders, budget, scope) {
 // packages/safe-bash-command-xan/src/transform.ts
 init_buffer();
 
-// packages/safe-bash-command-xan/src/cells.ts
-init_buffer();
-async function* emitted(bytes, budget) {
-  try {
-    yield bytes;
-  } finally {
-    budget.release(bytes.length);
-  }
-}
-async function* textRow(values, writer, budget) {
-  const owned = [];
-  budget.hold(values.length * 32);
-  try {
-    const cells = [];
-    for (const value of values) {
-      if (typeof value === "string") {
-        const bytes = await budget.encode(value);
-        owned.push(bytes);
-        cells.push(bytes);
-      } else cells.push(value);
-    }
-    yield* emitted(await writer.values(cells), budget);
-  } finally {
-    for (const bytes of owned) budget.release(bytes.length);
-    budget.release(values.length * 32);
-  }
-}
-async function compareBytes(left, right, budget) {
-  for (let i = 0; i < Math.min(left.length, right.length); i++) {
-    budget.work();
-    if (left[i] !== right[i]) return left[i] < right[i] ? -1 : 1;
-    if ((i & 1023) === 0) {
-      const c = budget.checkpoint();
-      if (c) await c;
-    }
-  }
-  return Math.sign(left.length - right.length);
-}
-function cellText(bytes, budget) {
-  budget.work(bytes.length);
-  try {
-    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
-  } catch {
-    throw new XanError("cell is not valid UTF-8");
-  }
-}
-function decimalNumber(text, budget) {
-  let offset = text[0] === "+" || text[0] === "-" ? 1 : 0;
-  let digits = 0;
-  while (offset < text.length && text[offset] >= "0" && text[offset] <= "9") {
-    offset++;
-    digits++;
-    budget.work();
-  }
-  if (text[offset] === ".") {
-    offset++;
-    while (offset < text.length && text[offset] >= "0" && text[offset] <= "9") {
-      offset++;
-      digits++;
-      budget.work();
-    }
-  }
-  if (!digits) return void 0;
-  if (text[offset] === "e" || text[offset] === "E") {
-    offset++;
-    if (text[offset] === "+" || text[offset] === "-") offset++;
-    const start = offset;
-    while (offset < text.length && text[offset] >= "0" && text[offset] <= "9") {
-      offset++;
-      budget.work();
-    }
-    if (offset === start) return void 0;
-  }
-  if (offset !== text.length) return void 0;
-  const value = Number(text);
-  return Number.isFinite(value) ? value : void 0;
-}
-
 // packages/safe-bash-command-xan/src/summary.ts
 init_buffer();
 async function* summarize(args, rows2, first, selected, budget, writer) {
@@ -238,21 +647,21 @@ async function* summarize(args, rows2, first, selected, budget, writer) {
           if (args.command === "freq") {
             if (!bytes.length && options.has("no-extra")) continue;
             hold(bytes.length * 4 + 64);
-            let key = "";
+            let key2 = "";
             for (let i = 0; i < bytes.length; i++) {
               budget.work();
-              key += String.fromCharCode(bytes[i]);
+              key2 += String.fromCharCode(bytes[i]);
               if ((i & 1023) === 0) {
                 const c = budget.checkpoint();
                 if (c) await c;
               }
             }
-            const existing = state.frequencies.get(key);
+            const existing = state.frequencies.get(key2);
             if (existing) {
               existing.count++;
               budget.release(bytes.length * 4 + 64);
               held -= bytes.length * 4 + 64;
-            } else state.frequencies.set(key, { bytes: bytes.slice(), count: 1 });
+            } else state.frequencies.set(key2, { bytes: bytes.slice(), count: 1 });
             continue;
           }
           if (!bytes.length) {
@@ -577,7 +986,7 @@ async function* join(args, left, first, leftKeys, scope, budget, writer) {
     budget.hold(bytes);
     held += bytes;
   };
-  const key = async (row, columns) => {
+  const key2 = async (row, columns) => {
     let result = "", nonempty = false;
     for (const i of columns) {
       const bytes = row.cells[i].decoded.view();
@@ -612,7 +1021,7 @@ async function* join(args, left, first, leftKeys, scope, budget, writer) {
         hold(row.cells.reduce((n, cell) => n + cell.decoded.length * 8 + 64, 128));
         rows2.push(row);
         retained = true;
-        const value = await key(row, rightKeys);
+        const value = await key2(row, rightKeys);
         if (value !== void 0) {
           const group = index.get(value);
           if (group) group.push(row);
@@ -627,7 +1036,7 @@ async function* join(args, left, first, leftKeys, scope, budget, writer) {
         budget.hold(row.cells.reduce((n, cell) => n + cell.decoded.length * 8 + 64, 0));
         let value;
         try {
-          value = await key(row, leftKeys);
+          value = await key2(row, leftKeys);
           const matches = options.has("cross") ? rows2 : value === void 0 ? [] : index.get(value) ?? [];
           if (semi) {
             if (options.has("anti") ? !matches.length : matches.length) yield* output(row, void 0);
@@ -667,7 +1076,8 @@ function width(row, expected) {
   if (row.width !== expected) throw new XanError(`CSV error: record ${row.number} (byte: ${row.offset}): found record with ${row.width} fields, but the previous record has ${expected} fields`);
 }
 async function prepareRows(args, selection, scope, budget, writer) {
-  if (args.help) return emitted2(await writer.text("xan: CSV tools for virtual files and byte streams\nCommands: headers (h), count, select, slice, head, tail, sort, search,\n          filter, reverse, rename, drop, stats, freq (frequency), join\nCommon: -h --help, -d --delimiter BYTE, -o --output PATH\nheaders: -j --just-names, --csv, -s --start N, --color auto|never\ncount/select/slice: -n --no-headers\ncount: -H/--human-readable, -c/--check-alignment, -a/--approx, -p/--parallel, -t/--threads N\nselect: literal selection or -e/--evaluate COLUMN, -f/--evaluate-file PATH;\nslice: -s/--start, --skip, -e/--end, -l/--len, -i/--index, -I/--indices, -L/--last\nslice bytes: -B/--byte-offset N, --end-byte N, --raw\nslice conditions: -S/--start-condition EXPR, -E/--end-condition EXPR\nConditions: named column comparisons with string/number literals.\nhead/tail: -l/--limit N (default 10)\nsort: -s/--select COLUMNS, -N/--numeric, -R/--reverse, -u/--uniq\nsearch: PATTERN; -s/--select, -e/--exact, -i/--ignore-case, -v/--invert-match\nfilter: COLUMN comparison LITERAL; -v/--invert-match\nrename: NAMES; -s/--select COLUMNS; drop: SELECTION\nstats/freq: -s/--select COLUMNS; freq: -l/--limit N, -A/--all, -N/--no-extra\njoin: COLUMNS LEFT [RIGHT_COLUMNS] RIGHT; --left/--right/--full/--semi/--anti/--cross\n      --drop-key none|left|right|both, --nulls, -i/--ignore-case\nSearch uses literal substrings; filter supports the comparisons above.\nAdvanced expressions, formats and forced color are unsupported.\nCount execution options use exact sequential counting.\n"), budget);
+  if (args.help) return emitted2(await writer.text("xan: CSV tools for virtual files and byte streams\nCommands: headers (h), count, select, slice, head, tail, sort, search,\n          filter, reverse, rename, drop, stats, freq (frequency), join,\n          dedup, enum, transpose, agg, groupby, to, from, cat, split\nCommon: -h --help, -d --delimiter BYTE, -o --output PATH\nheaders: -j --just-names, --csv, -s --start N, --color auto|never\ncount/select/slice: -n --no-headers\ncount: -H/--human-readable, -c/--check-alignment, -a/--approx, -p/--parallel, -t/--threads N\nselect: literal selection or -e/--evaluate COLUMN, -f/--evaluate-file PATH;\nslice: -s/--start, --skip, -e/--end, -l/--len, -i/--index, -I/--indices, -L/--last\nslice bytes: -B/--byte-offset N, --end-byte N, --raw\nslice conditions: -S/--start-condition EXPR, -E/--end-condition EXPR\nConditions: named column comparisons with string/number literals.\nhead/tail: -l/--limit N (default 10)\nsort: -s/--select COLUMNS, -N/--numeric, -R/--reverse, -u/--uniq\nsearch: PATTERN; -s/--select, -e/--exact, -i/--ignore-case, -v/--invert-match\nfilter: COLUMN comparison LITERAL; -v/--invert-match\nrename: NAMES; -s/--select COLUMNS; drop: SELECTION\nstats/freq: -s/--select COLUMNS; freq: -l/--limit N, -A/--all, -N/--no-extra\njoin: COLUMNS LEFT [RIGHT_COLUMNS] RIGHT; --left/--right/--full/--semi/--anti/--cross\n      --drop-key none|left|right|both, --nulls, -i/--ignore-case\nSearch uses literal substrings; filter supports the comparisons above.\nagg/groupby: aggregate calls (count, sum, mean, min, max, first, last) with optional AS names.\nto: json, jsonl, ndjson, txt; from: -f json, jsonl, ndjson, txt, raw.\ncat: rows or cols [--pad]; split: -S SIZE, -O DIRECTORY, -f TEMPLATE.\nOther expressions, formats and forced color are unsupported.\nCount execution options use exact sequential counting.\n"), budget);
+  if (["dedup", "enum", "transpose", "agg", "groupby", "to", "from", "cat", "split"].includes(args.command)) return extendedRows(args, scope, budget, writer);
   if (!["headers", "count", "select", "drop", "slice"].includes(args.command)) return transformRows(args, scope, budget, writer);
   if (args.command === "headers") return prepareHeaders(args, scope, budget, writer);
   if (args.command === "slice" && !args.raw && args.noHeaders && args.last === 0) return emitted2(new Uint8Array(0), budget);