just-bash 2.5.5 → 2.7.0

package/dist/commands/awk/ast.d.ts

@@ -82,6 +82,7 @@ export interface AwkGetline {
     type: "getline";
     variable?: string;
     file?: AwkExpr;
+    command?: AwkExpr;
 }
 export interface AwkTuple {
     type: "tuple";

package/dist/commands/awk/interpreter/context.d.ts

@@ -9,6 +9,7 @@ export interface AwkRuntimeContext {
     FS: string;
     OFS: string;
     ORS: string;
+    OFMT: string;
     NR: number;
     NF: number;
     FNR: number;
@@ -20,8 +21,10 @@ export interface AwkRuntimeContext {
     line: string;
     vars: Record<string, AwkValue>;
     arrays: Record<string, Record<string, AwkValue>>;
+    arrayAliases: Map<string, string>;
     ARGC: number;
     ARGV: Record<string, string>;
+    ENVIRON: Record<string, string>;
     functions: Map<string, AwkFunctionDef>;
     lines?: string[];
     lineIndex?: number;
@@ -37,11 +40,17 @@ export interface AwkRuntimeContext {
     loopContinue: boolean;
     returnValue?: AwkValue;
     hasReturn: boolean;
+    inEndBlock: boolean;
     output: string;
     fs?: AwkFileSystem;
     cwd?: string;
     openedFiles: Set<string>;
     random?: () => number;
+    exec?: (cmd: string) => Promise<{
+        stdout: string;
+        stderr: string;
+        exitCode: number;
+    }>;
 }
 export interface CreateContextOptions {
     fieldSep?: RegExp;
@@ -49,5 +58,10 @@ export interface CreateContextOptions {
     maxRecursionDepth?: number;
     fs?: AwkFileSystem;
     cwd?: string;
+    exec?: (cmd: string) => Promise<{
+        stdout: string;
+        stderr: string;
+        exitCode: number;
+    }>;
 }
 export declare function createRuntimeContext(options?: CreateContextOptions): AwkRuntimeContext;

package/dist/commands/awk/interpreter/interpreter.d.ts

@@ -25,6 +25,8 @@ export declare class AwkInterpreter {
     executeLine(line: string): Promise<void>;
     /**
      * Execute all END blocks.
+     * END blocks run even after exit is called, but exit from within
+     * an END block stops further END block execution.
      */
     executeEnd(): Promise<void>;
     /**

package/dist/commands/awk/interpreter/{helpers.d.ts → type-coercion.d.ts}

@@ -6,7 +6,10 @@
 import type { AwkValue } from "./types.js";
 /**
  * Check if a value is truthy in AWK.
- * Numbers are truthy if non-zero, strings if non-empty.
+ * - Numbers: truthy if non-zero
+ * - Empty string: falsy
+ * - String "0": falsy (canonical string representation of zero)
+ * - All other non-empty strings: truthy (including "00", "0.0", etc.)
  */
 export declare function isTruthy(val: AwkValue): boolean;
 /**

package/dist/commands/awk/parser2-print.d.ts

@@ -0,0 +1,35 @@
+/**
+ * AWK Parser Print Context Helpers
+ *
+ * Handles parsing in print/printf context where > and >> are redirection
+ * operators rather than comparison operators.
+ */
+import type { AwkExpr, AwkStmt } from "./ast.js";
+import type { Token, TokenType } from "./lexer.js";
+/**
+ * Interface for parser methods needed by print parsing helpers.
+ * Used to avoid circular dependencies.
+ */
+export interface PrintParserContext {
+    tokens: Token[];
+    pos: number;
+    current(): Token;
+    advance(): Token;
+    match(...types: TokenType[]): boolean;
+    check(type: TokenType): boolean;
+    expect(type: TokenType, message?: string): Token;
+    skipNewlines(): void;
+    parseExpression(): AwkExpr;
+    parseTernary(): AwkExpr;
+    parsePrimary(): AwkExpr;
+    parseAddSub(): AwkExpr;
+    setPos(pos: number): void;
+}
+/**
+ * Parse a print statement.
+ */
+export declare function parsePrintStatement(p: PrintParserContext): AwkStmt;
+/**
+ * Parse a printf statement.
+ */
+export declare function parsePrintfStatement(p: PrintParserContext): AwkStmt;

package/dist/commands/awk/parser2.d.ts

@@ -3,17 +3,19 @@
  *
  * Recursive descent parser that builds an AST from tokens.
  */
-import type { AwkProgram } from "./ast.js";
+import type { AwkExpr, AwkProgram } from "./ast.js";
+import { type Token, TokenType } from "./lexer.js";
 export declare class AwkParser {
-    private tokens;
-    private pos;
+    tokens: Token[];
+    pos: number;
     parse(input: string): AwkProgram;
-    private current;
-    private advance;
-    private match;
-    private check;
-    private expect;
-    private skipNewlines;
+    setPos(newPos: number): void;
+    current(): Token;
+    advance(): Token;
+    match(...types: TokenType[]): boolean;
+    check(type: TokenType): boolean;
+    expect(type: TokenType, message?: string): Token;
+    skipNewlines(): void;
     private skipTerminators;
     private parseProgram;
     private parseFunction;
@@ -24,29 +26,14 @@ export declare class AwkParser {
     private parseWhile;
     private parseDoWhile;
     private parseFor;
-    private parsePrint;
-    /**
-     * Parse a print argument - same as ternary but treats > and >> at the TOP LEVEL
-     * (not inside ternary) as redirection rather than comparison operators.
-     */
-    private parsePrintArg;
-    /**
-     * Look ahead to see if there's a ternary ? operator before the next statement terminator.
-     * This tells us whether > is comparison (in ternary condition) or redirection.
-     */
-    private lookAheadForTernary;
-    private parsePrintOr;
-    private parsePrintAnd;
-    private parsePrintIn;
-    private parsePrintMatch;
+    parseExpression(): AwkExpr;
+    private parseAssignment;
+    parseTernary(): AwkExpr;
     /**
-     * Like parseComparison but doesn't consume > and >> (for print redirection)
+     * Parse command pipe getline: "cmd" | getline [var]
+     * This has lower precedence than logical OR but higher than ternary.
      */
-    private parsePrintComparison;
-    private parsePrintf;
-    private parseExpression;
-    private parseAssignment;
-    private parseTernary;
+    private parsePipeGetline;
     private parseOr;
     /**
      * Continue parsing a logical OR/AND expression from a given left-hand side.
@@ -59,15 +46,36 @@ export declare class AwkParser {
     private parseLogicalAndRest;
     private parseAnd;
     private parseIn;
+    private parseConcatenation;
     private parseMatch;
     private parseComparison;
-    private parseConcatenation;
     private canStartExpression;
-    private isComparisonOrHigherOp;
-    private parseAddSub;
+    /**
+     * Check if the current token terminates a concatenation.
+     * These are tokens that indicate we've reached a higher-level operator
+     * or end of expression.
+     */
+    private isConcatTerminator;
+    parseAddSub(): AwkExpr;
     private parseMulDiv;
     private parseUnary;
     private parsePower;
     private parsePostfix;
-    private parsePrimary;
+    /**
+     * Parse a field index expression. This is like parseUnary but does NOT allow
+     * postfix operators, so that $i++ parses as ($i)++ rather than $(i++).
+     * Allows: $1, $i, $++i, $--i, $(expr), $-1
+     * Does NOT consume postfix ++ or -- (those apply to the field, not the index)
+     */
+    private parseFieldIndex;
+    /**
+     * Parse power expression for field index (no postfix on base)
+     */
+    private parseFieldIndexPower;
+    /**
+     * Parse primary expression for field index - like parsePrimary but returns
+     * without checking for postfix operators
+     */
+    private parseFieldIndexPrimary;
+    parsePrimary(): AwkExpr;
 }

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/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,16 @@
+/**
+ * Worker thread for Python execution via Pyodide.
+ * Keeps Pyodide loaded and handles multiple execution requests.
+ */
+export interface WorkerInput {
+    sharedBuffer: SharedArrayBuffer;
+    pythonCode: string;
+    cwd: string;
+    env: Record<string, string>;
+    args: string[];
+    scriptPath?: string;
+}
+export interface WorkerOutput {
+    success: boolean;
+    error?: string;
+}

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 {};

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

@@ -0,0 +1,15 @@
+/**
+ * Object-related jq builtins
+ *
+ * Handles object manipulation functions like keys, to_entries, from_entries, 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 object builtins that need evaluate function for arguments.
+ * Returns null if the builtin name is not an object builtin handled here.
+ */
+export declare function evalObjectBuiltin(value: QueryValue, name: string, args: AstNode[], ctx: EvalContext, evaluate: EvalFn): QueryValue[] | null;
+export {};