just-bash 3.1.0 → 3.2.0

package/dist/commands/tac/tac.d.ts

@@ -5,7 +5,7 @@
  *
  * Writes each FILE to standard output, last line first.
  */
-import type { Command } from "../../types.js";
-export declare const tac: Command;
+import type { RuntimeCommand } from "../../types.js";
+export declare const tac: RuntimeCommand;
 import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
 export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/tail/tail.d.ts

@@ -1,4 +1,4 @@
-import type { Command } from "../../types.js";
-export declare const tailCommand: Command;
+import type { RuntimeCommand } from "../../types.js";
+export declare const tailCommand: RuntimeCommand;
 import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
 export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/tar/archive.d.ts

@@ -5,7 +5,20 @@
  * with optional gzip, bzip2, and xz compression.
  */
 import { type ParsedTarEntryWithData, type TarEntry, type TarHeader } from "modern-tar";
+import type { CommandExecutionBudget } from "../../execution-scope.js";
 export type { TarEntry, TarHeader, ParsedTarEntryWithData };
+export interface ArchiveCreationLimits {
+    maxArchiveSize?: number;
+    maxEntries?: number;
+    maxEntrySize?: number;
+    maxCompressedSize?: number;
+    maxExpansionRatio?: number;
+    signal?: AbortSignal;
+    /** Shared live-memory owner supplied by the tar command integration. */
+    executionScope?: CommandExecutionBudget;
+    /** Set false to disable native whole-buffer codecs. */
+    allowTrustedWholeBufferCodecs?: boolean;
+}
 /**
  * Entry for creating a tar archive
  */
@@ -23,11 +36,11 @@ export interface TarCreateEntry {
 /**
  * Create a tar archive from entries
  */
-export declare function createArchive(entries: TarCreateEntry[]): Promise<Uint8Array>;
+export declare function createArchive(entries: TarCreateEntry[], options?: ArchiveCreationLimits): Promise<Uint8Array>;
 /**
  * Create a gzip-compressed tar archive from entries
  */
-export declare function createCompressedArchive(entries: TarCreateEntry[]): Promise<Uint8Array>;
+export declare function createCompressedArchive(entries: TarCreateEntry[], options?: ArchiveCreationLimits): Promise<Uint8Array>;
 /**
  * Parsed tar entry for extraction
  */
@@ -45,14 +58,14 @@ export interface ParsedEntry {
 /**
  * Parse a tar archive and return entries
  */
-export declare function parseArchive(data: Uint8Array): Promise<{
+export declare function parseArchive(data: Uint8Array, options?: ArchiveCreationLimits): Promise<{
     entries: ParsedEntry[];
     error?: string;
 }>;
 /**
  * Parse a gzip-compressed tar archive
  */
-export declare function parseCompressedArchive(data: Uint8Array): Promise<{
+export declare function parseCompressedArchive(data: Uint8Array, options?: ArchiveCreationLimits): Promise<{
     entries: ParsedEntry[];
     error?: string;
 }>;
@@ -71,22 +84,24 @@ export declare function isXzCompressed(data: Uint8Array): boolean;
 /**
  * Create a bzip2-compressed tar archive from entries
  */
-export declare function createBzip2CompressedArchive(entries: TarCreateEntry[]): Promise<Uint8Array>;
+export declare function createBzip2CompressedArchive(entries: TarCreateEntry[], options?: ArchiveCreationLimits): Promise<Uint8Array>;
 /**
  * Create an xz-compressed tar archive from entries.
  *
  * @param entries - Archive entries to include
  * @param options - Options controlling compression behavior
- * @param options.allowNativeCodecs - When false (default), rejects xz compression
+ * @param options.allowNativeCodecs - Set false to reject xz compression
  *   to avoid passing attacker-controlled bytes to native addons (node-liblzma).
  */
-export declare function createXzCompressedArchive(entries: TarCreateEntry[], options?: {
+export declare function createXzCompressedArchive(entries: TarCreateEntry[], options?: ArchiveCreationLimits & {
     allowNativeCodecs?: boolean;
 }): Promise<Uint8Array>;
 /**
  * Parse a bzip2-compressed tar archive
  */
-export declare function parseBzip2CompressedArchive(data: Uint8Array): Promise<{
+export declare function parseBzip2CompressedArchive(data: Uint8Array, options?: ArchiveCreationLimits & {
+    maxDecompressedSize?: number;
+}): Promise<{
     entries: ParsedEntry[];
     error?: string;
 }>;
@@ -95,10 +110,10 @@ export declare function parseBzip2CompressedArchive(data: Uint8Array): Promise<{
  *
  * @param data - Raw archive bytes
  * @param options - Options controlling decompression behavior
- * @param options.allowNativeCodecs - When false (default), rejects xz decompression
+ * @param options.allowNativeCodecs - Set false to reject xz decompression
  *   to avoid passing untrusted bytes to native addons (node-liblzma).
  */
-export declare function parseXzCompressedArchive(data: Uint8Array, options?: {
+export declare function parseXzCompressedArchive(data: Uint8Array, options?: ArchiveCreationLimits & {
     allowNativeCodecs?: boolean;
 }): Promise<{
     entries: ParsedEntry[];
@@ -113,10 +128,10 @@ export declare function isZstdCompressed(data: Uint8Array): boolean;
  *
  * @param entries - Archive entries to include
  * @param options - Options controlling compression behavior
- * @param options.allowNativeCodecs - When false (default), rejects zstd compression
+ * @param options.allowNativeCodecs - Set false to reject zstd compression
  *   to avoid passing attacker-controlled bytes to native addons (@mongodb-js/zstd).
  */
-export declare function createZstdCompressedArchive(entries: TarCreateEntry[], options?: {
+export declare function createZstdCompressedArchive(entries: TarCreateEntry[], options?: ArchiveCreationLimits & {
     allowNativeCodecs?: boolean;
 }): Promise<Uint8Array>;
 /**
@@ -124,10 +139,10 @@ export declare function createZstdCompressedArchive(entries: TarCreateEntry[], o
  *
  * @param data - Raw archive bytes
  * @param options - Options controlling decompression behavior
- * @param options.allowNativeCodecs - When false (default), rejects zstd decompression
+ * @param options.allowNativeCodecs - Set false to reject zstd decompression
  *   to avoid passing untrusted bytes to native addons (@mongodb-js/zstd).
  */
-export declare function parseZstdCompressedArchive(data: Uint8Array, options?: {
+export declare function parseZstdCompressedArchive(data: Uint8Array, options?: ArchiveCreationLimits & {
     allowNativeCodecs?: boolean;
 }): Promise<{
     entries: ParsedEntry[];

package/dist/commands/tar/bzip2-compress.d.ts

@@ -12,6 +12,7 @@
  * @param data - Input data to compress
  * @param blockSizeLevel - Block size level 1-9 (x 100KB), default 9
  * @param maxSize - Maximum input size in bytes (default 10MB)
+ * @param maxOutputSize - Maximum compressed bytes, enforced while writing
  * @returns Compressed bzip2 data
  */
-export declare function bzip2Compress(data: Uint8Array, blockSizeLevel?: number, maxSize?: number): Uint8Array;
+export declare function bzip2Compress(data: Uint8Array, blockSizeLevel?: number, maxSize?: number, maxOutputSize?: number): Uint8Array;

package/dist/commands/tar/tar.d.ts

@@ -4,7 +4,7 @@
  * Supports creating, extracting, and listing tar archives
  * with optional gzip, bzip2, and xz compression.
  */
-import type { Command } from "../../types.js";
-export declare const tarCommand: Command;
+import type { RuntimeCommand } from "../../types.js";
+export declare const tarCommand: RuntimeCommand;
 import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
 export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/tee/tee.d.ts

@@ -1,4 +1,4 @@
-import type { Command } from "../../types.js";
-export declare const teeCommand: Command;
+import type { RuntimeCommand } from "../../types.js";
+export declare const teeCommand: RuntimeCommand;
 import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
 export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/time/time.d.ts

@@ -1,4 +1,4 @@
-import type { Command } from "../../types.js";
+import type { RuntimeCommand } from "../../types.js";
 /**
  * time - time command execution
  *
@@ -22,6 +22,6 @@ import type { Command } from "../../types.js";
  * Note: In this JavaScript implementation, user/system CPU time and memory
  * metrics are not available, so %M, %S, %U output 0.
  */
-export declare const timeCommand: Command;
+export declare const timeCommand: RuntimeCommand;
 import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
 export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/timeout/timeout.d.ts

@@ -1,4 +1,4 @@
-import type { Command } from "../../types.js";
-export declare const timeoutCommand: Command;
+import type { RuntimeCommand } from "../../types.js";
+export declare const timeoutCommand: RuntimeCommand;
 import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
 export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/touch/touch.d.ts

@@ -1,4 +1,4 @@
-import type { Command } from "../../types.js";
-export declare const touchCommand: Command;
+import type { RuntimeCommand } from "../../types.js";
+export declare const touchCommand: RuntimeCommand;
 import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
 export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/tr/tr.d.ts

@@ -1,4 +1,4 @@
-import type { Command } from "../../types.js";
-export declare const trCommand: Command;
+import type { RuntimeCommand } from "../../types.js";
+export declare const trCommand: RuntimeCommand;
 import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
 export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/tree/tree.d.ts

@@ -1,4 +1,4 @@
-import type { Command } from "../../types.js";
-export declare const treeCommand: Command;
+import type { RuntimeCommand } from "../../types.js";
+export declare const treeCommand: RuntimeCommand;
 import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
 export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/true/true.d.ts

@@ -1,6 +1,6 @@
-import type { Command } from "../../types.js";
-export declare const trueCommand: Command;
-export declare const falseCommand: Command;
+import type { RuntimeCommand } from "../../types.js";
+export declare const trueCommand: RuntimeCommand;
+export declare const falseCommand: RuntimeCommand;
 import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
 export declare const flagsForFuzzing: CommandFuzzInfo;
 export declare const falseFlagsForFuzzing: CommandFuzzInfo;

package/dist/commands/uniq/uniq.d.ts

@@ -1,4 +1,4 @@
-import type { Command } from "../../types.js";
-export declare const uniqCommand: Command;
+import type { RuntimeCommand } from "../../types.js";
+export declare const uniqCommand: RuntimeCommand;
 import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
 export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/wc/wc.d.ts

@@ -1,4 +1,4 @@
-import type { Command } from "../../types.js";
-export declare const wcCommand: Command;
+import type { RuntimeCommand } from "../../types.js";
+export declare const wcCommand: RuntimeCommand;
 import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
 export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/which/which.d.ts

@@ -1,4 +1,4 @@
-import type { Command } from "../../types.js";
-export declare const whichCommand: Command;
+import type { RuntimeCommand } from "../../types.js";
+export declare const whichCommand: RuntimeCommand;
 import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
 export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/whoami/whoami.d.ts

@@ -5,7 +5,7 @@
  *
  * In sandboxed environment, always returns "user".
  */
-import type { Command } from "../../types.js";
-export declare const whoami: Command;
+import type { RuntimeCommand } from "../../types.js";
+export declare const whoami: RuntimeCommand;
 import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
 export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/worker-request-controller.d.ts

@@ -0,0 +1,36 @@
+import type { Worker } from "node:worker_threads";
+type CancelReason = "abort" | "timeout";
+export interface WorkerRequestControllerOptions {
+    commandName: string;
+    timeoutMs: number;
+    signal?: AbortSignal;
+    maxMessageBytes: number;
+}
+/**
+ * Execution-owned lifecycle for a single worker request.  Queue implementations
+ * remain command-specific, but cancellation is armed before enqueueing and all
+ * request-owned listeners/timers are removed exactly once.
+ */
+export declare class WorkerRequestController {
+    private readonly options;
+    readonly protocolToken: string;
+    readonly deadline: number;
+    private readonly cleanups;
+    private cancelHandler;
+    private canceledReason;
+    private closed;
+    constructor(options: WorkerRequestControllerOptions);
+    /** Arm cancellation before the caller makes the request visible in a queue. */
+    arm(onCancel: (reason: CancelReason) => void): void;
+    get isCanceled(): boolean;
+    remainingTimeMs(): number;
+    timeoutMessage(noun?: string): string;
+    abortMessage(): string;
+    assertMessageSize(value: unknown, direction: "request" | "response"): void;
+    terminate(worker: Worker | null | undefined): Promise<boolean>;
+    close(): void;
+    private cancel;
+}
+/** Conservative, allocation-free estimate for structured-clone payloads. */
+export declare function estimateMessageBytes(value: unknown, stopAfter: number): number;
+export {};

package/dist/commands/xan/aggregation.d.ts

@@ -3,6 +3,16 @@
  */
 import { type EvaluateOptions } from "../query-engine/index.js";
 import { type CsvData, type CsvRow } from "./csv.js";
+export interface AggregationLimits {
+    maxArrayElements?: number;
+    maxStringLength?: number;
+    maxIterations?: number;
+    maxDepth?: number;
+    /** Charge command-wide work before performing attacker-sized operations. */
+    consumeWork?: (units?: number) => void;
+}
+/** Conservative comparison work to reserve before allocating a sorted copy. */
+export declare function estimateSortingWork(length: number): number;
 /** Aggregation specification from parsed expression */
 export interface AggSpec {
     func: string;
@@ -13,8 +23,8 @@ export interface AggSpec {
  * Parse aggregation expression: "func(expr) as alias" or "func(expr)"
  * Handles nested parentheses in expressions like sum(add(a, b))
  */
-export declare function parseAggExpr(expr: string): AggSpec[];
+export declare function parseAggExpr(expr: string, limits?: AggregationLimits): AggSpec[];
 /** Compute aggregation on data */
-export declare function computeAgg(data: CsvData, spec: AggSpec, evalOptions?: EvaluateOptions): number | string | boolean | null;
+export declare function computeAgg(data: CsvData, spec: AggSpec, evalOptions?: EvaluateOptions, limits?: AggregationLimits): number | string | boolean | null;
 /** Build aggregation result row */
-export declare function buildAggRow(data: CsvData, specs: AggSpec[], evalOptions?: EvaluateOptions): CsvRow;
+export declare function buildAggRow(data: CsvData, specs: AggSpec[], evalOptions?: EvaluateOptions, limits?: AggregationLimits): CsvRow;

package/dist/commands/xan/bounded-output.d.ts

@@ -0,0 +1,4 @@
+import { BoundedStringBuilder } from "../../bounded-builder.js";
+export declare class XanOutputBuilder extends BoundedStringBuilder {
+    constructor(maxBytes: number);
+}

package/dist/commands/xan/column-selection.d.ts

@@ -2,10 +2,11 @@
  * Shared utilities for xan subcommands
  */
 import type { AstNode } from "../query-engine/parser.js";
+import { type MoonbladeLimits } from "./moonblade-parser.js";
 /**
  * Parse a moonblade expression and transform to jq AST
  */
-export declare function parseMoonbladeExpr(expr: string): AstNode;
+export declare function parseMoonbladeExpr(expr: string, limits?: MoonbladeLimits): AstNode;
 /**
  * Parse column specification which can include:
  * - Column names (e.g., "name,email")

package/dist/commands/xan/csv.d.ts

@@ -1,11 +1,30 @@
 /**
  * CSV parsing and formatting utilities for xan command
  */
-import type { CommandContext, ExecResult } from "../../types.js";
+import type { ExecResult, RuntimeCommandContext } from "../../types.js";
 export interface CsvRow {
     [key: string]: string | number | boolean | null;
 }
 export type CsvData = CsvRow[];
+export type CsvCells = Array<Array<string | number | boolean | null>>;
+export interface CsvParseLimits {
+    maxStringLength?: number;
+    maxArrayElements?: number;
+    maxRows?: number;
+    maxCells?: number;
+}
+/** RuntimeCommand-wide prospective accounting for attacker-amplified CSV results. */
+export declare class DerivedCsvBudget {
+    private readonly ctx;
+    private readonly site;
+    private rows;
+    private cells;
+    constructor(ctx: RuntimeCommandContext, site: string);
+    consumeWork(units?: number): void;
+    addRow(cellCount: number): void;
+    /** Reserve a known result cardinality before constructing any result rows. */
+    addRows(rowCount: number, cellCount: number): void;
+}
 /**
  * Create a null-prototype CsvRow to prevent prototype pollution.
  * User-controlled CSV column names could match dangerous keys like
@@ -23,14 +42,20 @@ export declare function safeSetRow(row: CsvRow, key: string, value: string | num
  */
 export declare function toSafeRow(plainRow: Record<string, unknown>): CsvRow;
 /** Parse CSV input string to array of row objects */
-export declare function parseCsv(input: string): {
+export declare function parseCsv(input: string, limits?: CsvParseLimits): {
     headers: string[];
     data: CsvData;
 };
+/** Parse headerless/ragged CSV incrementally while enforcing aggregate limits. */
+export declare function parseCsvRows(input: string, limits?: CsvParseLimits): CsvCells;
 /** Format array of row objects back to CSV string */
-export declare function formatCsv(headers: string[], data: CsvData): string;
+export declare function formatCsv(headers: string[], data: CsvData, ctx?: RuntimeCommandContext): string;
+/** Format object rows in header order, omitting the header record itself. */
+export declare function formatCsvWithoutHeaders(headers: string[], data: CsvData, ctx: RuntimeCommandContext): string;
+/** Format already-materialized cells without Papa.unparse's unbounded copy. */
+export declare function formatCsvRows(data: readonly (readonly unknown[])[], ctx?: RuntimeCommandContext, headers?: readonly unknown[]): string;
 /** Read CSV input from file or stdin */
-export declare function readCsvInput(args: string[], ctx: CommandContext): Promise<{
+export declare function readCsvInput(args: string[], ctx: RuntimeCommandContext): Promise<{
     headers: string[];
     data: CsvData;
     error?: ExecResult;

package/dist/commands/xan/moonblade-parser.d.ts

@@ -6,6 +6,15 @@
  *
  * Grammar based on xan's grammar.pest
  */
+import type { RuntimeCommandContext } from "../../types.js";
+export interface MoonbladeLimits {
+    maxSourceLength?: number;
+    maxTokens?: number;
+    maxDepth?: number;
+    maxOperations?: number;
+    maxAstNodes?: number;
+}
+export declare function getMoonbladeLimits(ctx: RuntimeCommandContext): MoonbladeLimits;
 export type MoonbladeExpr = {
     type: "int";
     value: number;
@@ -73,8 +82,8 @@ export interface Aggregation {
 /**
  * Parse named expressions like: "expr1, expr2 as name, expr3 as (a, b)"
  */
-export declare function parseNamedExpressions(input: string): NamedExpr[];
+export declare function parseNamedExpressions(input: string, limits?: MoonbladeLimits): NamedExpr[];
 /**
  * Parse a moonblade expression string into AST
  */
-export declare function parseMoonblade(input: string): MoonbladeExpr;
+export declare function parseMoonblade(input: string, limits?: MoonbladeLimits): MoonbladeExpr;

package/dist/commands/xan/moonblade-to-jq.d.ts

@@ -5,8 +5,8 @@
  * to jq AST for evaluation by the shared query engine.
  */
 import type { AstNode } from "../query-engine/parser.js";
-import type { MoonbladeExpr } from "./moonblade-parser.js";
+import type { MoonbladeExpr, MoonbladeLimits } from "./moonblade-parser.js";
 /**
  * Transform moonblade AST to jq AST
  */
-export declare function moonbladeToJq(expr: MoonbladeExpr, rowContext?: boolean): AstNode;
+export declare function moonbladeToJq(expr: MoonbladeExpr, rowContext?: boolean, limits?: MoonbladeLimits): AstNode;

package/dist/commands/xan/moonblade-tokenizer.d.ts

@@ -7,12 +7,19 @@ export interface Token {
     value: string;
     pos: number;
 }
+export interface TokenizerLimits {
+    maxSourceLength?: number;
+    maxTokens?: number;
+}
 export declare class Tokenizer {
     private input;
     private pos;
     private tokens;
-    constructor(input: string);
+    private readonly maxSourceLength;
+    private readonly maxTokens;
+    constructor(input: string, limits?: TokenizerLimits);
     tokenize(): Token[];
+    private assertTokenCapacity;
     private skipWhitespace;
     private nextToken;
     private match;

package/dist/commands/xan/xan-agg.d.ts

@@ -1,8 +1,8 @@
 /**
  * Aggregation commands: agg, groupby, frequency, stats
  */
-import type { CommandContext, ExecResult } from "../../types.js";
-export declare function cmdAgg(args: string[], ctx: CommandContext): Promise<ExecResult>;
-export declare function cmdGroupby(args: string[], ctx: CommandContext): Promise<ExecResult>;
-export declare function cmdFrequency(args: string[], ctx: CommandContext): Promise<ExecResult>;
-export declare function cmdStats(args: string[], ctx: CommandContext): Promise<ExecResult>;
+import type { ExecResult, RuntimeCommandContext } from "../../types.js";
+export declare function cmdAgg(args: string[], ctx: RuntimeCommandContext): Promise<ExecResult>;
+export declare function cmdGroupby(args: string[], ctx: RuntimeCommandContext): Promise<ExecResult>;
+export declare function cmdFrequency(args: string[], ctx: RuntimeCommandContext): Promise<ExecResult>;
+export declare function cmdStats(args: string[], ctx: RuntimeCommandContext): Promise<ExecResult>;

package/dist/commands/xan/xan-columns.d.ts

@@ -1,8 +1,8 @@
 /**
  * Column operation commands: select, drop, rename, enum
  */
-import type { CommandContext, ExecResult } from "../../types.js";
-export declare function cmdSelect(args: string[], ctx: CommandContext): Promise<ExecResult>;
-export declare function cmdDrop(args: string[], ctx: CommandContext): Promise<ExecResult>;
-export declare function cmdRename(args: string[], ctx: CommandContext): Promise<ExecResult>;
-export declare function cmdEnum(args: string[], ctx: CommandContext): Promise<ExecResult>;
+import type { ExecResult, RuntimeCommandContext } from "../../types.js";
+export declare function cmdSelect(args: string[], ctx: RuntimeCommandContext): Promise<ExecResult>;
+export declare function cmdDrop(args: string[], ctx: RuntimeCommandContext): Promise<ExecResult>;
+export declare function cmdRename(args: string[], ctx: RuntimeCommandContext): Promise<ExecResult>;
+export declare function cmdEnum(args: string[], ctx: RuntimeCommandContext): Promise<ExecResult>;

package/dist/commands/xan/xan-core.d.ts

@@ -1,10 +1,10 @@
 /**
  * Core xan commands: headers, count, head, tail, slice, reverse
  */
-import type { CommandContext, ExecResult } from "../../types.js";
-export declare function cmdHeaders(args: string[], ctx: CommandContext): Promise<ExecResult>;
-export declare function cmdCount(args: string[], ctx: CommandContext): Promise<ExecResult>;
-export declare function cmdHead(args: string[], ctx: CommandContext): Promise<ExecResult>;
-export declare function cmdTail(args: string[], ctx: CommandContext): Promise<ExecResult>;
-export declare function cmdSlice(args: string[], ctx: CommandContext): Promise<ExecResult>;
-export declare function cmdReverse(args: string[], ctx: CommandContext): Promise<ExecResult>;
+import type { ExecResult, RuntimeCommandContext } from "../../types.js";
+export declare function cmdHeaders(args: string[], ctx: RuntimeCommandContext): Promise<ExecResult>;
+export declare function cmdCount(args: string[], ctx: RuntimeCommandContext): Promise<ExecResult>;
+export declare function cmdHead(args: string[], ctx: RuntimeCommandContext): Promise<ExecResult>;
+export declare function cmdTail(args: string[], ctx: RuntimeCommandContext): Promise<ExecResult>;
+export declare function cmdSlice(args: string[], ctx: RuntimeCommandContext): Promise<ExecResult>;
+export declare function cmdReverse(args: string[], ctx: RuntimeCommandContext): Promise<ExecResult>;

package/dist/commands/xan/xan-data.d.ts

@@ -2,26 +2,26 @@
  * Data utility commands: transpose, shuffle, fixlengths, split, partition
  * Commands that exist in real xan
  */
-import type { CommandContext, ExecResult } from "../../types.js";
+import type { ExecResult, RuntimeCommandContext } from "../../types.js";
 /**
  * Transpose: swap rows and columns
  * Usage: xan transpose [FILE]
  *   First column becomes header row, first row becomes header column
  */
-export declare function cmdTranspose(args: string[], ctx: CommandContext): Promise<ExecResult>;
+export declare function cmdTranspose(args: string[], ctx: RuntimeCommandContext): Promise<ExecResult>;
 /**
  * Shuffle: randomly reorder rows
  * Usage: xan shuffle [OPTIONS] [FILE]
  *   --seed N    Random seed for reproducibility
  */
-export declare function cmdShuffle(args: string[], ctx: CommandContext): Promise<ExecResult>;
+export declare function cmdShuffle(args: string[], ctx: RuntimeCommandContext): Promise<ExecResult>;
 /**
  * Fixlengths: fix ragged CSV by padding/truncating rows
  * Usage: xan fixlengths [OPTIONS] [FILE]
  *   -l, --length N    Target number of columns (default: max row length)
  *   -d, --default V   Default value for missing fields (default: empty)
  */
-export declare function cmdFixlengths(args: string[], ctx: CommandContext): Promise<ExecResult>;
+export declare function cmdFixlengths(args: string[], ctx: RuntimeCommandContext): Promise<ExecResult>;
 /**
  * Split: split CSV into multiple files by row count
  * Usage: xan split [OPTIONS] FILE
@@ -31,22 +31,22 @@ export declare function cmdFixlengths(args: string[], ctx: CommandContext): Prom
  *
  * In sandbox mode, outputs as JSON with parts as array
  */
-export declare function cmdSplit(args: string[], ctx: CommandContext): Promise<ExecResult>;
+export declare function cmdSplit(args: string[], ctx: RuntimeCommandContext): Promise<ExecResult>;
 /**
  * Partition: split CSV by column value into separate outputs
  * Usage: xan partition COLUMN [OPTIONS] [FILE]
  *   -o, --output DIR  Output directory (default: current)
  */
-export declare function cmdPartition(args: string[], ctx: CommandContext): Promise<ExecResult>;
+export declare function cmdPartition(args: string[], ctx: RuntimeCommandContext): Promise<ExecResult>;
 /**
  * To: convert CSV to other formats
  * Usage: xan to FORMAT [OPTIONS] [FILE]
  *   FORMAT: json
  */
-export declare function cmdTo(args: string[], ctx: CommandContext): Promise<ExecResult>;
+export declare function cmdTo(args: string[], ctx: RuntimeCommandContext): Promise<ExecResult>;
 /**
  * From: convert other formats to CSV
  * Usage: xan from [OPTIONS] [FILE]
  *   -f, --format FORMAT   Input format (json)
  */
-export declare function cmdFrom(args: string[], ctx: CommandContext): Promise<ExecResult>;
+export declare function cmdFrom(args: string[], ctx: RuntimeCommandContext): Promise<ExecResult>;

package/dist/commands/xan/xan-filter.d.ts

@@ -1,8 +1,8 @@
 /**
  * Filter and sort commands: filter, sort, dedup, top
  */
-import type { CommandContext, ExecResult } from "../../types.js";
-export declare function cmdFilter(args: string[], ctx: CommandContext): Promise<ExecResult>;
-export declare function cmdSort(args: string[], ctx: CommandContext): Promise<ExecResult>;
-export declare function cmdDedup(args: string[], ctx: CommandContext): Promise<ExecResult>;
-export declare function cmdTop(args: string[], ctx: CommandContext): Promise<ExecResult>;
+import type { ExecResult, RuntimeCommandContext } from "../../types.js";
+export declare function cmdFilter(args: string[], ctx: RuntimeCommandContext): Promise<ExecResult>;
+export declare function cmdSort(args: string[], ctx: RuntimeCommandContext): Promise<ExecResult>;
+export declare function cmdDedup(args: string[], ctx: RuntimeCommandContext): Promise<ExecResult>;
+export declare function cmdTop(args: string[], ctx: RuntimeCommandContext): Promise<ExecResult>;

package/dist/commands/xan/xan-map.d.ts

@@ -1,11 +1,11 @@
 /**
  * Map command: add computed columns
  */
-import type { CommandContext, ExecResult } from "../../types.js";
-export declare function cmdMap(args: string[], ctx: CommandContext): Promise<ExecResult>;
+import type { ExecResult, RuntimeCommandContext } from "../../types.js";
+export declare function cmdMap(args: string[], ctx: RuntimeCommandContext): Promise<ExecResult>;
 /**
  * Transform command: modify existing columns in-place
  * Usage: xan transform COLUMN EXPR [FILE]
  *   -r, --rename NAME  Rename the column after transformation
  */
-export declare function cmdTransform(args: string[], ctx: CommandContext): Promise<ExecResult>;
+export declare function cmdTransform(args: string[], ctx: RuntimeCommandContext): Promise<ExecResult>;