@eidos.space/just-bash 3.0.2

package/dist/commands/stat/stat.d.ts

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

package/dist/commands/strings/strings.d.ts

@@ -0,0 +1,12 @@
+/**
+ * strings - print the sequences of printable characters in files
+ *
+ * Usage: strings [OPTION]... [FILE]...
+ *
+ * For each FILE, print the printable character sequences that are at least
+ * MIN characters long. If no FILE is specified, standard input is read.
+ */
+import type { Command } from "../../types.js";
+export declare const strings: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

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

@@ -0,0 +1,11 @@
+/**
+ * tac - concatenate and print files in reverse
+ *
+ * Usage: tac [OPTION]... [FILE]...
+ *
+ * Writes each FILE to standard output, last line first.
+ */
+import type { Command } from "../../types.js";
+export declare const tac: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

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

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

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

@@ -0,0 +1,135 @@
+/**
+ * Tar archive utilities using modern-tar
+ *
+ * Provides helpers for creating and extracting tar archives
+ * with optional gzip, bzip2, and xz compression.
+ */
+import { type ParsedTarEntryWithData, type TarEntry, type TarHeader } from "modern-tar";
+export type { TarEntry, TarHeader, ParsedTarEntryWithData };
+/**
+ * Entry for creating a tar archive
+ */
+export interface TarCreateEntry {
+    name: string;
+    content?: Uint8Array | string;
+    mode?: number;
+    mtime?: Date;
+    isDirectory?: boolean;
+    isSymlink?: boolean;
+    linkTarget?: string;
+    uid?: number;
+    gid?: number;
+}
+/**
+ * Create a tar archive from entries
+ */
+export declare function createArchive(entries: TarCreateEntry[]): Promise<Uint8Array>;
+/**
+ * Create a gzip-compressed tar archive from entries
+ */
+export declare function createCompressedArchive(entries: TarCreateEntry[]): Promise<Uint8Array>;
+/**
+ * Parsed tar entry for extraction
+ */
+export interface ParsedEntry {
+    name: string;
+    mode: number;
+    uid: number;
+    gid: number;
+    size: number;
+    mtime: Date;
+    type: "file" | "directory" | "symlink" | "hardlink" | "other";
+    linkTarget?: string;
+    content: Uint8Array;
+}
+/**
+ * Parse a tar archive and return entries
+ */
+export declare function parseArchive(data: Uint8Array): Promise<{
+    entries: ParsedEntry[];
+    error?: string;
+}>;
+/**
+ * Parse a gzip-compressed tar archive
+ */
+export declare function parseCompressedArchive(data: Uint8Array): Promise<{
+    entries: ParsedEntry[];
+    error?: string;
+}>;
+/**
+ * Check if data is gzip compressed (magic bytes 0x1f 0x8b)
+ */
+export declare function isGzipCompressed(data: Uint8Array): boolean;
+/**
+ * Check if data is bzip2 compressed (magic bytes "BZh")
+ */
+export declare function isBzip2Compressed(data: Uint8Array): boolean;
+/**
+ * Check if data is xz compressed (magic bytes 0xFD 0x37 0x7A 0x58 0x5A 0x00)
+ */
+export declare function isXzCompressed(data: Uint8Array): boolean;
+/**
+ * Create a bzip2-compressed tar archive from entries
+ */
+export declare function createBzip2CompressedArchive(entries: TarCreateEntry[]): 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
+ *   to avoid passing attacker-controlled bytes to native addons (node-liblzma).
+ */
+export declare function createXzCompressedArchive(entries: TarCreateEntry[], options?: {
+    allowNativeCodecs?: boolean;
+}): Promise<Uint8Array>;
+/**
+ * Parse a bzip2-compressed tar archive
+ */
+export declare function parseBzip2CompressedArchive(data: Uint8Array): Promise<{
+    entries: ParsedEntry[];
+    error?: string;
+}>;
+/**
+ * Parse an xz-compressed tar archive.
+ *
+ * @param data - Raw archive bytes
+ * @param options - Options controlling decompression behavior
+ * @param options.allowNativeCodecs - When false (default), rejects xz decompression
+ *   to avoid passing untrusted bytes to native addons (node-liblzma).
+ */
+export declare function parseXzCompressedArchive(data: Uint8Array, options?: {
+    allowNativeCodecs?: boolean;
+}): Promise<{
+    entries: ParsedEntry[];
+    error?: string;
+}>;
+/**
+ * Check if data is zstd compressed (magic number 0x28 0xB5 0x2F 0xFD)
+ */
+export declare function isZstdCompressed(data: Uint8Array): boolean;
+/**
+ * Create a zstd-compressed tar archive from entries.
+ *
+ * @param entries - Archive entries to include
+ * @param options - Options controlling compression behavior
+ * @param options.allowNativeCodecs - When false (default), rejects zstd compression
+ *   to avoid passing attacker-controlled bytes to native addons (@mongodb-js/zstd).
+ */
+export declare function createZstdCompressedArchive(entries: TarCreateEntry[], options?: {
+    allowNativeCodecs?: boolean;
+}): Promise<Uint8Array>;
+/**
+ * Parse a zstd-compressed tar archive.
+ *
+ * @param data - Raw archive bytes
+ * @param options - Options controlling decompression behavior
+ * @param options.allowNativeCodecs - When false (default), rejects zstd decompression
+ *   to avoid passing untrusted bytes to native addons (@mongodb-js/zstd).
+ */
+export declare function parseZstdCompressedArchive(data: Uint8Array, options?: {
+    allowNativeCodecs?: boolean;
+}): Promise<{
+    entries: ParsedEntry[];
+    error?: string;
+}>;

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

@@ -0,0 +1,17 @@
+/**
+ * Pure JavaScript bzip2 compressor.
+ *
+ * Implements the bzip2 compression algorithm (public domain, Julian Seward 1996).
+ * Pipeline: RLE1 → BWT → MTF → RLE2 (RUNA/RUNB) → Huffman → bitstream output.
+ *
+ * This exists because no permissively-licensed JS bzip2 compressor is available
+ * on npm. Decompression uses the MIT-licensed `seek-bzip` package instead.
+ */
+/**
+ * Compress data using bzip2 algorithm.
+ * @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)
+ * @returns Compressed bzip2 data
+ */
+export declare function bzip2Compress(data: Uint8Array, blockSizeLevel?: number, maxSize?: number): Uint8Array;

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

@@ -0,0 +1,37 @@
+/**
+ * Option parsing for tar command
+ */
+import type { ExecResult } from "../../types.js";
+export interface TarOptions {
+    create: boolean;
+    append: boolean;
+    update: boolean;
+    extract: boolean;
+    list: boolean;
+    file: string;
+    autoCompress: boolean;
+    gzip: boolean;
+    bzip2: boolean;
+    xz: boolean;
+    zstd: boolean;
+    verbose: boolean;
+    toStdout: boolean;
+    keepOldFiles: boolean;
+    touch: boolean;
+    directory: string;
+    preserve: boolean;
+    absoluteNames: boolean;
+    strip: number;
+    exclude: string[];
+    filesFrom: string;
+    excludeFrom: string;
+    wildcards: boolean;
+}
+export declare function parseOptions(args: string[]): {
+    ok: true;
+    options: TarOptions;
+    files: string[];
+} | {
+    ok: false;
+    error: ExecResult;
+};

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

@@ -0,0 +1,10 @@
+/**
+ * tar - manipulate tape archives
+ *
+ * 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 { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

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

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

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

@@ -0,0 +1,27 @@
+import type { Command } from "../../types.js";
+/**
+ * time - time command execution
+ *
+ * Usage: time [-f FORMAT] [-o FILE] [-a] [-v] [-p] command [arguments...]
+ *
+ * Times the execution of a command and outputs timing statistics.
+ *
+ * Options:
+ *   -f FORMAT    Use FORMAT for output (GNU time format specifiers)
+ *   -o FILE      Write timing output to FILE
+ *   -a           Append to output file (with -o)
+ *   -v           Verbose output
+ *   -p           POSIX portable output format
+ *
+ * Format specifiers:
+ *   %e    Elapsed real time in seconds
+ *   %M    Maximum resident set size (KB)
+ *   %S    System CPU time (seconds)
+ *   %U    User CPU time (seconds)
+ *
+ * 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;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,6 @@
+import type { Command } from "../../types.js";
+export declare const trueCommand: Command;
+export declare const falseCommand: Command;
+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

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

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

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

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

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

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

@@ -0,0 +1,11 @@
+/**
+ * whoami - print effective user name
+ *
+ * Usage: whoami
+ *
+ * In sandboxed environment, always returns "user".
+ */
+import type { Command } from "../../types.js";
+export declare const whoami: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/worker-bridge/bridge-handler.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Main thread bridge handler
+ *
+ * Runs on the main thread and processes filesystem, I/O, HTTP, and exec
+ * requests from a worker thread via SharedArrayBuffer + Atomics.
+ */
+import type { IFileSystem } from "../../fs/interface.js";
+import type { SecureFetch } from "../../network/fetch.js";
+import type { CommandExecOptions, ExecResult } from "../../types.js";
+export interface BridgeOutput {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+/**
+ * Handles requests from a worker thread.
+ */
+export declare class BridgeHandler {
+    private fs;
+    private cwd;
+    private commandName;
+    private secureFetch;
+    private maxOutputSize;
+    private exec;
+    private invokeTool;
+    private protocol;
+    private running;
+    private output;
+    private outputLimitExceeded;
+    private startTime;
+    private timeoutMs;
+    constructor(sharedBuffer: SharedArrayBuffer, fs: IFileSystem, cwd: string, commandName: string, secureFetch?: SecureFetch | undefined, maxOutputSize?: number, exec?: ((command: string, options: CommandExecOptions) => Promise<ExecResult>) | undefined, invokeTool?: ((path: string, argsJson: string) => Promise<string>) | undefined);
+    /**
+     * Returns remaining milliseconds before the overall execution deadline.
+     */
+    private remainingMs;
+    /**
+     * Races a promise against the remaining execution deadline.
+     * If the deadline expires first, sets `this.running = false` and rejects.
+     */
+    private raceDeadline;
+    /**
+     * Run the handler loop until EXIT operation or timeout.
+     */
+    run(timeoutMs: number): Promise<BridgeOutput>;
+    stop(): void;
+    private handleOperation;
+    private resolvePath;
+    private handleReadFile;
+    private handleWriteFile;
+    private handleStat;
+    private handleLstat;
+    private handleReaddir;
+    private handleMkdir;
+    private handleRm;
+    private handleExists;
+    private handleAppendFile;
+    private handleSymlink;
+    private handleReadlink;
+    private handleChmod;
+    private handleRealpath;
+    private handleRename;
+    private handleCopyFile;
+    private handleWriteStdout;
+    private handleWriteStderr;
+    private handleExit;
+    private tryAppendOutput;
+    private appendOutputLimitError;
+    private handleHttpRequest;
+    private handleExecCommand;
+    private handleInvokeTool;
+    private setErrorFromException;
+}

package/dist/commands/worker-bridge/protocol.d.ts

@@ -0,0 +1,141 @@
+/**
+ * SharedArrayBuffer protocol for synchronous worker bridge
+ *
+ * This protocol enables synchronous filesystem and I/O access from a worker thread
+ * (where CPython/Python or QuickJS runs) to the main thread (which has async IFileSystem).
+ */
+declare global {
+    interface Atomics {
+        waitAsync(typedArray: Int32Array, index: number, value: number, timeout?: number): {
+            async: false;
+            value: "not-equal" | "timed-out";
+        } | {
+            async: true;
+            value: Promise<"ok" | "timed-out">;
+        };
+    }
+}
+/** Operation codes */
+export declare const OpCode: {
+    readonly NOOP: 0;
+    readonly READ_FILE: 1;
+    readonly WRITE_FILE: 2;
+    readonly STAT: 3;
+    readonly READDIR: 4;
+    readonly MKDIR: 5;
+    readonly RM: 6;
+    readonly EXISTS: 7;
+    readonly APPEND_FILE: 8;
+    readonly SYMLINK: 9;
+    readonly READLINK: 10;
+    readonly LSTAT: 11;
+    readonly CHMOD: 12;
+    readonly REALPATH: 13;
+    readonly RENAME: 14;
+    readonly COPY_FILE: 15;
+    readonly WRITE_STDOUT: 100;
+    readonly WRITE_STDERR: 101;
+    readonly EXIT: 102;
+    readonly HTTP_REQUEST: 200;
+    readonly EXEC_COMMAND: 300;
+    readonly INVOKE_TOOL: 400;
+};
+export type OpCodeType = (typeof OpCode)[keyof typeof OpCode];
+/** Status codes for synchronization */
+export declare const Status: {
+    readonly PENDING: 0;
+    readonly READY: 1;
+    readonly SUCCESS: 2;
+    readonly ERROR: 3;
+};
+export type StatusType = (typeof Status)[keyof typeof Status];
+/** Error codes */
+export declare const ErrorCode: {
+    readonly NONE: 0;
+    readonly NOT_FOUND: 1;
+    readonly IS_DIRECTORY: 2;
+    readonly NOT_DIRECTORY: 3;
+    readonly EXISTS: 4;
+    readonly PERMISSION_DENIED: 5;
+    readonly INVALID_PATH: 6;
+    readonly IO_ERROR: 7;
+    readonly TIMEOUT: 8;
+    readonly NETWORK_ERROR: 9;
+    readonly NETWORK_NOT_CONFIGURED: 10;
+};
+export type ErrorCodeType = (typeof ErrorCode)[keyof typeof ErrorCode];
+/** Flags for operations */
+export declare const Flags: {
+    readonly NONE: 0;
+    readonly RECURSIVE: 1;
+    readonly FORCE: 2;
+    readonly MKDIR_RECURSIVE: 1;
+};
+export declare function createSharedBuffer(): SharedArrayBuffer;
+/**
+ * Helper class for reading/writing protocol data
+ */
+export declare class ProtocolBuffer {
+    private int32View;
+    private uint8View;
+    private dataView;
+    constructor(buffer: SharedArrayBuffer);
+    getOpCode(): OpCodeType;
+    setOpCode(code: OpCodeType): void;
+    getStatus(): StatusType;
+    setStatus(status: StatusType): void;
+    getPathLength(): number;
+    setPathLength(length: number): void;
+    getDataLength(): number;
+    setDataLength(length: number): void;
+    getResultLength(): number;
+    setResultLength(length: number): void;
+    getErrorCode(): ErrorCodeType;
+    setErrorCode(code: ErrorCodeType): void;
+    getFlags(): number;
+    setFlags(flags: number): void;
+    getMode(): number;
+    setMode(mode: number): void;
+    getPath(): string;
+    setPath(path: string): void;
+    getData(): Uint8Array;
+    setData(data: Uint8Array): void;
+    getDataAsString(): string;
+    setDataFromString(str: string): void;
+    getResult(): Uint8Array;
+    setResult(data: Uint8Array): void;
+    getResultAsString(): string;
+    setResultFromString(str: string): void;
+    encodeStat(stat: {
+        isFile: boolean;
+        isDirectory: boolean;
+        isSymbolicLink: boolean;
+        mode: number;
+        size: number;
+        mtime: Date;
+    }): void;
+    decodeStat(): {
+        isFile: boolean;
+        isDirectory: boolean;
+        isSymbolicLink: boolean;
+        mode: number;
+        size: number;
+        mtime: Date;
+    };
+    waitForReady(timeout?: number): "ok" | "timed-out" | "not-equal";
+    waitForReadyAsync(timeout?: number): {
+        async: false;
+        value: "not-equal" | "timed-out";
+    } | {
+        async: true;
+        value: Promise<"ok" | "timed-out">;
+    };
+    /**
+     * Wait for status to become READY.
+     * Returns immediately if status is already READY, or waits until it changes.
+     */
+    waitUntilReady(timeout: number): Promise<boolean>;
+    waitForResult(timeout?: number): "ok" | "timed-out" | "not-equal";
+    notify(): number;
+    reset(): void;
+}

package/dist/commands/worker-bridge/sync-backend.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Worker-side synchronous backend
+ *
+ * Runs in the worker thread and makes synchronous calls to the main thread
+ * via SharedArrayBuffer + Atomics.
+ */
+/**
+ * Synchronous backend for worker threads.
+ */
+export declare class SyncBackend {
+    private protocol;
+    private operationTimeoutMs;
+    constructor(sharedBuffer: SharedArrayBuffer, operationTimeoutMs?: number);
+    private execSync;
+    readFile(path: string): Uint8Array;
+    writeFile(path: string, data: Uint8Array): void;
+    stat(path: string): {
+        isFile: boolean;
+        isDirectory: boolean;
+        isSymbolicLink: boolean;
+        mode: number;
+        size: number;
+        mtime: Date;
+    };
+    lstat(path: string): {
+        isFile: boolean;
+        isDirectory: boolean;
+        isSymbolicLink: boolean;
+        mode: number;
+        size: number;
+        mtime: Date;
+    };
+    readdir(path: string): string[];
+    mkdir(path: string, recursive?: boolean): void;
+    rm(path: string, recursive?: boolean, force?: boolean): void;
+    exists(path: string): boolean;
+    appendFile(path: string, data: Uint8Array): void;
+    symlink(target: string, linkPath: string): void;
+    readlink(path: string): string;
+    chmod(path: string, mode: number): void;
+    realpath(path: string): string;
+    rename(oldPath: string, newPath: string): void;
+    copyFile(src: string, dest: string): void;
+    writeStdout(data: string): void;
+    writeStderr(data: string): void;
+    exit(code: number): void;
+    /**
+     * Make an HTTP request through the main thread's secureFetch.
+     * Returns the response as a parsed object.
+     */
+    httpRequest(url: string, options?: {
+        method?: string;
+        headers?: Record<string, string>;
+        body?: string;
+    }): {
+        status: number;
+        statusText: string;
+        headers: Record<string, string>;
+        body: string;
+        bodyBase64: string;
+        url: string;
+    };
+    /**
+     * Execute a shell command through the main thread's exec function.
+     * Returns the result as { stdout, stderr, exitCode }.
+     */
+    execCommand(command: string, stdin?: string): {
+        stdout: string;
+        stderr: string;
+        exitCode: number;
+    };
+    /**
+     * Execute a shell command with structured args (shell-escaped on the main thread).
+     * Prevents command injection from unsanitized args.
+     */
+    execCommandArgs(command: string, args: string[]): {
+        stdout: string;
+        stderr: string;
+        exitCode: number;
+    };
+    /**
+     * Invoke a tool through the main thread's invokeTool hook.
+     * Returns the JSON-serialized result.
+     */
+    invokeTool(path: string, argsJson: string): string;
+}

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

@@ -0,0 +1,20 @@
+/**
+ * Aggregation functions for xan command
+ */
+import { type EvaluateOptions } from "../query-engine/index.js";
+import { type CsvData, type CsvRow } from "./csv.js";
+/** Aggregation specification from parsed expression */
+export interface AggSpec {
+    func: string;
+    expr: string;
+    alias: string;
+}
+/**
+ * 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[];
+/** Compute aggregation on data */
+export declare function computeAgg(data: CsvData, spec: AggSpec, evalOptions?: EvaluateOptions): number | string | boolean | null;
+/** Build aggregation result row */
+export declare function buildAggRow(data: CsvData, specs: AggSpec[], evalOptions?: EvaluateOptions): CsvRow;

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

@@ -0,0 +1,19 @@
+/**
+ * Shared utilities for xan subcommands
+ */
+import type { AstNode } from "../query-engine/parser.js";
+/**
+ * Parse a moonblade expression and transform to jq AST
+ */
+export declare function parseMoonbladeExpr(expr: string): AstNode;
+/**
+ * Parse column specification which can include:
+ * - Column names (e.g., "name,email")
+ * - Column indices (e.g., "0,2")
+ * - Numeric ranges (e.g., "0-2" means columns 0, 1, 2)
+ * - Column name ranges (e.g., "name:email" means columns from name to email)
+ * - Glob patterns (e.g., "vec_*", "*_count")
+ * - Negation (e.g., "!name" excludes column)
+ * Returns an array of column names
+ */
+export declare function parseColumnSpec(spec: string, headers: string[]): string[];