just-binary 2.9.8

package/dist/commands/head/head.d.ts

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

package/dist/commands/help/help.d.ts

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

package/dist/commands/help.d.ts

@@ -0,0 +1,16 @@
+import type { ExecResult } from "../types.js";
+export interface HelpInfo {
+    name: string;
+    summary: string;
+    usage: string;
+    description?: string | string[];
+    options?: string[];
+    examples?: string[];
+    notes?: string[];
+}
+export declare function showHelp(info: HelpInfo): ExecResult;
+export declare function hasHelpFlag(args: string[]): boolean;
+/**
+ * Returns an error result for an unknown option
+ */
+export declare function unknownOption(cmdName: string, option: string): ExecResult;

package/dist/commands/history/history.d.ts

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

package/dist/commands/hostname/hostname.d.ts

@@ -0,0 +1,11 @@
+/**
+ * hostname - show or set the system's host name
+ *
+ * Usage: hostname [NAME]
+ *
+ * In sandboxed environment, always returns "localhost".
+ */
+import type { Command } from "../../types.js";
+export declare const hostname: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/html-to-markdown/html-to-markdown.d.ts

@@ -0,0 +1,9 @@
+/**
+ * html-to-markdown - Convert HTML to Markdown using TurndownService
+ *
+ * This is a non-standard command that converts HTML from stdin to Markdown.
+ */
+import type { Command } from "../../types.js";
+export declare const htmlToMarkdownCommand: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/join/join.d.ts

@@ -0,0 +1,12 @@
+/**
+ * join - join lines of two files on a common field
+ *
+ * Usage: join [OPTION]... FILE1 FILE2
+ *
+ * For each pair of input lines with identical join fields, write a line to
+ * standard output. The default join field is the first, delimited by blanks.
+ */
+import type { Command } from "../../types.js";
+export declare const join: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/jq/jq.d.ts

@@ -0,0 +1,9 @@
+/**
+ * jq - Command-line JSON processor
+ *
+ * Full jq implementation with proper parser and evaluator.
+ */
+import type { Command } from "../../types.js";
+export declare const jqCommand: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/ln/ln.d.ts

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

package/dist/commands/ls/ls.d.ts

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

package/dist/commands/md5sum/checksum.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Shared checksum utilities for md5sum, sha1sum, sha256sum
+ * Uses WebCrypto API for SHA algorithms, pure JS for MD5
+ */
+import type { Command } from "../../types.js";
+export type HashAlgorithm = "md5" | "sha1" | "sha256";
+export declare function createChecksumCommand(name: string, algorithm: HashAlgorithm, summary: string): Command;

package/dist/commands/md5sum/md5sum.d.ts

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

package/dist/commands/md5sum/sha1sum.d.ts

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

package/dist/commands/md5sum/sha256sum.d.ts

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

package/dist/commands/mkdir/mkdir.d.ts

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

package/dist/commands/mv/mv.d.ts

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

package/dist/commands/nl/nl.d.ts

@@ -0,0 +1,12 @@
+/**
+ * nl - number lines of files
+ *
+ * Usage: nl [OPTION]... [FILE]...
+ *
+ * Write each FILE to standard output, with line numbers added.
+ * If no FILE is specified, standard input is read.
+ */
+import type { Command } from "../../types.js";
+export declare const nl: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/od/od.d.ts

@@ -0,0 +1,12 @@
+/**
+ * od - dump files in octal and other formats
+ *
+ * Usage: od [OPTION]... [FILE]...
+ *
+ * Write an unambiguous representation, octal bytes by default,
+ * of FILE to standard output.
+ */
+import type { Command } from "../../types.js";
+export declare const od: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/paste/paste.d.ts

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

package/dist/commands/printf/escapes.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Shared escape sequence and formatting utilities
+ * Used by printf command and find -printf
+ */
+/**
+ * Apply width and alignment to a string value
+ * Supports: width (right-justify), -width (left-justify), .precision (truncate)
+ * @param value - The string value to format
+ * @param width - The field width (negative for left-justify)
+ * @param precision - Maximum length (-1 for no limit)
+ */
+export declare function applyWidth(value: string, width: number, precision: number): string;
+/**
+ * Parse a width/precision spec from a format directive
+ * Returns: [width, precision, charsConsumed]
+ * width: positive for right-justify, negative for left-justify
+ * precision: -1 if not specified
+ */
+export declare function parseWidthPrecision(format: string, startIndex: number): [number, number, number];
+/**
+ * Process escape sequences producing Uint8Array directly.
+ * \xHH and \0NNN push raw bytes; \uHHHH/\UHHHHHHHH push UTF-8 encoded bytes;
+ * regular characters are UTF-8 encoded.
+ */
+export declare function processEscapesBytes(str: string): Uint8Array;
+/**
+ * Process escape sequences in a string
+ * Handles: \n, \t, \r, \\, \a, \b, \f, \v, \e, \0NNN (octal), \xHH (hex),
+ *          \uHHHH (unicode), \UHHHHHHHH (unicode)
+ */
+export declare function processEscapes(str: string): string;

package/dist/commands/printf/printf.d.ts

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

package/dist/commands/printf/strftime.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Strftime Formatting Functions
+ *
+ * Handles date/time formatting for printf's %(...)T directive.
+ */
+/**
+ * Format a timestamp using strftime-like format string.
+ */
+export declare function formatStrftime(format: string, timestamp: number, tz?: string): string;

package/dist/commands/pwd/pwd.d.ts

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

package/dist/commands/python3/fs-bridge-handler.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Main thread filesystem bridge handler
+ *
+ * Runs on the main thread and processes filesystem requests from the worker thread.
+ * Uses SharedArrayBuffer + Atomics for synchronization.
+ */
+import type { IFileSystem } from "../../fs/interface.js";
+import type { SecureFetch } from "../../network/fetch.js";
+export interface FsBridgeOutput {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+/**
+ * Handles filesystem requests from the worker thread.
+ */
+export declare class FsBridgeHandler {
+    private fs;
+    private cwd;
+    private secureFetch;
+    private protocol;
+    private running;
+    private output;
+    constructor(sharedBuffer: SharedArrayBuffer, fs: IFileSystem, cwd: string, secureFetch?: SecureFetch | undefined);
+    /**
+     * Run the handler loop until EXIT operation or timeout.
+     */
+    run(timeoutMs: number): Promise<FsBridgeOutput>;
+    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 handleWriteStdout;
+    private handleWriteStderr;
+    private handleExit;
+    private handleHttpRequest;
+    private setErrorFromException;
+}

package/dist/commands/python3/protocol.d.ts

@@ -0,0 +1,138 @@
+/**
+ * SharedArrayBuffer protocol for synchronous filesystem bridge
+ *
+ * This protocol enables synchronous filesystem access from a worker thread
+ * (where Pyodide/Python 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 WRITE_STDOUT: 100;
+    readonly WRITE_STDERR: 101;
+    readonly EXIT: 102;
+    readonly HTTP_REQUEST: 200;
+};
+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;
+};
+/** Create a new SharedArrayBuffer for the protocol */
+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/python3/python3.d.ts

@@ -0,0 +1,11 @@
+/**
+ * python3 - Execute Python code via Pyodide (Python in WebAssembly)
+ *
+ * Runs Python code in an isolated worker thread with access to the
+ * virtual filesystem via SharedArrayBuffer bridge.
+ *
+ * This command is Node.js only (uses worker_threads).
+ */
+import type { Command } from "../../types.js";
+export declare const python3Command: Command;
+export declare const pythonCommand: Command;

package/dist/commands/python3/sync-fs-backend.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Worker-side synchronous filesystem backend
+ *
+ * Runs in the worker thread and makes synchronous calls to the main thread
+ * via SharedArrayBuffer + Atomics.
+ */
+/**
+ * Synchronous filesystem backend for Pyodide worker.
+ */
+export declare class SyncFsBackend {
+    private protocol;
+    constructor(sharedBuffer: SharedArrayBuffer);
+    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;
+    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;
+        url: string;
+    };
+}

package/dist/commands/python3/worker.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Worker thread for Python execution via Pyodide.
+ * Keeps Pyodide loaded and handles multiple execution requests.
+ *
+ * Defense-in-depth activates AFTER Pyodide loads (WASM init needs unrestricted JS).
+ * User Python code runs with dangerous globals blocked.
+ */
+import { type WorkerDefenseStats } from "../../security/index.js";
+export interface WorkerInput {
+    sharedBuffer: SharedArrayBuffer;
+    pythonCode: string;
+    cwd: string;
+    env: Record<string, string>;
+    args: string[];
+    scriptPath?: string;
+}
+export interface WorkerOutput {
+    success: boolean;
+    error?: string;
+    /** Defense-in-depth stats if enabled */
+    defenseStats?: WorkerDefenseStats;
+}

package/dist/commands/query-engine/builtins/array-builtins.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Array-related jq builtins
+ *
+ * Handles array manipulation functions like sort, sort_by, group_by, max, min, add, etc.
+ */
+import type { EvalContext } from "../evaluator.js";
+import type { AstNode } from "../parser.js";
+import type { QueryValue } from "../value-operations.js";
+type EvalFn = (value: QueryValue, ast: AstNode, ctx: EvalContext) => QueryValue[];
+type EvalWithPartialFn = (value: QueryValue, ast: AstNode, ctx: EvalContext) => QueryValue[];
+type CompareFn = (a: QueryValue, b: QueryValue) => number;
+type IsTruthyFn = (v: QueryValue) => boolean;
+type ContainsDeepFn = (a: QueryValue, b: QueryValue) => boolean;
+type ExecutionLimitErrorClass = new (message: string, kind: "recursion" | "commands" | "iterations") => Error;
+/**
+ * Handle array builtins that need evaluate function for arguments.
+ * Returns null if the builtin name is not an array builtin handled here.
+ */
+export declare function evalArrayBuiltin(value: QueryValue, name: string, args: AstNode[], ctx: EvalContext, evaluate: EvalFn, evaluateWithPartialResults: EvalWithPartialFn, compareJq: CompareFn, isTruthy: IsTruthyFn, containsDeep: ContainsDeepFn, ExecutionLimitError: ExecutionLimitErrorClass): QueryValue[] | null;
+export {};

package/dist/commands/query-engine/builtins/control-builtins.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Control flow jq builtins
+ *
+ * Handles first, last, nth, range, limit, isempty, isvalid, skip, until, while, repeat.
+ */
+import type { EvalContext } from "../evaluator.js";
+import type { AstNode } from "../parser.js";
+import type { QueryValue } from "../value-operations.js";
+type EvalFn = (value: QueryValue, ast: AstNode, ctx: EvalContext) => QueryValue[];
+type EvalWithPartialFn = (value: QueryValue, ast: AstNode, ctx: EvalContext) => QueryValue[];
+type IsTruthyFn = (v: QueryValue) => boolean;
+type ExecutionLimitErrorClass = new (message: string, kind: "recursion" | "commands" | "iterations") => Error;
+/**
+ * Handle control flow builtins.
+ * Returns null if the builtin name is not a control builtin handled here.
+ */
+export declare function evalControlBuiltin(value: QueryValue, name: string, args: AstNode[], ctx: EvalContext, evaluate: EvalFn, evaluateWithPartialResults: EvalWithPartialFn, isTruthy: IsTruthyFn, ExecutionLimitError: ExecutionLimitErrorClass): QueryValue[] | null;
+export {};

package/dist/commands/query-engine/builtins/date-builtins.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Date/time-related jq builtins
+ *
+ * Handles date and time functions like now, gmtime, mktime, strftime, strptime, etc.
+ */
+import type { EvalContext } from "../evaluator.js";
+import type { AstNode } from "../parser.js";
+import type { QueryValue } from "../value-operations.js";
+type EvalFn = (value: QueryValue, ast: AstNode, ctx: EvalContext) => QueryValue[];
+/**
+ * Handle date builtins that need evaluate function for arguments.
+ * Returns null if the builtin name is not a date builtin handled here.
+ */
+export declare function evalDateBuiltin(value: QueryValue, name: string, args: AstNode[], ctx: EvalContext, evaluate: EvalFn): QueryValue[] | null;
+export {};

package/dist/commands/query-engine/builtins/format-builtins.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Format-related jq builtins (@ prefixed)
+ *
+ * Handles encoding/formatting functions like @base64, @uri, @csv, @json, etc.
+ */
+import type { QueryValue } from "../value-operations.js";
+/**
+ * Handle format builtins (those starting with @).
+ * Returns null if the builtin name is not a format builtin handled here.
+ */
+export declare function evalFormatBuiltin(value: QueryValue, name: string, maxDepth?: number): QueryValue[] | null;

package/dist/commands/query-engine/builtins/index-builtins.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Index-related jq builtins
+ *
+ * Handles index, rindex, and indices functions for finding positions in arrays/strings.
+ */
+import type { EvalContext } from "../evaluator.js";
+import type { AstNode } from "../parser.js";
+import type { QueryValue } from "../value-operations.js";
+type EvalFn = (value: QueryValue, ast: AstNode, ctx: EvalContext) => QueryValue[];
+type DeepEqualFn = (a: QueryValue, b: QueryValue) => boolean;
+/**
+ * Handle index builtins that need evaluate function for arguments.
+ * Returns null if the builtin name is not an index builtin handled here.
+ */
+export declare function evalIndexBuiltin(value: QueryValue, name: string, args: AstNode[], ctx: EvalContext, evaluate: EvalFn, deepEqual: DeepEqualFn): QueryValue[] | null;
+export {};

package/dist/commands/query-engine/builtins/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * jq builtin functions index
+ *
+ * Re-exports all builtin handlers from category-specific modules.
+ */
+export { evalArrayBuiltin } from "./array-builtins.js";
+export { evalControlBuiltin } from "./control-builtins.js";
+export { evalDateBuiltin } from "./date-builtins.js";
+export { evalFormatBuiltin } from "./format-builtins.js";
+export { evalIndexBuiltin } from "./index-builtins.js";
+export { evalMathBuiltin } from "./math-builtins.js";
+export { evalNavigationBuiltin } from "./navigation-builtins.js";
+export { evalObjectBuiltin } from "./object-builtins.js";
+export { evalPathBuiltin } from "./path-builtins.js";
+export { evalSqlBuiltin } from "./sql-builtins.js";
+export { evalStringBuiltin } from "./string-builtins.js";
+export { evalTypeBuiltin } from "./type-builtins.js";

package/dist/commands/query-engine/builtins/math-builtins.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Math-related jq builtins
+ *
+ * Handles mathematical functions like abs, pow, exp, trig functions, etc.
+ */
+import type { EvalContext } from "../evaluator.js";
+import type { AstNode } from "../parser.js";
+import type { QueryValue } from "../value-operations.js";
+type EvalFn = (value: QueryValue, ast: AstNode, ctx: EvalContext) => QueryValue[];
+/**
+ * Handle math builtins that need evaluate function for arguments.
+ * Returns null if the builtin name is not a math builtin handled here.
+ */
+export declare function evalMathBuiltin(value: QueryValue, name: string, args: AstNode[], ctx: EvalContext, evaluate: EvalFn): QueryValue[] | null;
+export {};

package/dist/commands/query-engine/builtins/navigation-builtins.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Navigation and traversal jq builtins
+ *
+ * Handles recurse, recurse_down, walk, transpose, combinations, parent, parents, root.
+ */
+import type { EvalContext } from "../evaluator.js";
+import type { AstNode } from "../parser.js";
+import type { QueryValue } from "../value-operations.js";
+type EvalFn = (value: QueryValue, ast: AstNode, ctx: EvalContext) => QueryValue[];
+type IsTruthyFn = (v: QueryValue) => boolean;
+type GetValueAtPathFn = (obj: QueryValue, path: (string | number)[]) => QueryValue;
+type EvalBuiltinFn = (value: QueryValue, name: string, args: AstNode[], ctx: EvalContext) => QueryValue[];
+/**
+ * Handle navigation builtins that need evaluate function for arguments.
+ * Returns null if the builtin name is not a navigation builtin handled here.
+ */
+export declare function evalNavigationBuiltin(value: QueryValue, name: string, args: AstNode[], ctx: EvalContext, evaluate: EvalFn, isTruthy: IsTruthyFn, getValueAtPath: GetValueAtPathFn, evalBuiltin: EvalBuiltinFn): QueryValue[] | null;
+export {};