@jerryan/just-bash 3.5.0

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

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

@@ -0,0 +1,20 @@
+/**
+ * Path-related jq builtins
+ *
+ * Handles path manipulation functions like getpath, setpath, delpaths, paths, 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 IsTruthyFn = (v: QueryValue) => boolean;
+type SetPathFn = (obj: QueryValue, path: (string | number)[], val: QueryValue) => QueryValue;
+type DeletePathFn = (obj: QueryValue, path: (string | number)[]) => QueryValue;
+type ApplyDelFn = (value: QueryValue, expr: AstNode, ctx: EvalContext) => QueryValue;
+type CollectPathsFn = (value: QueryValue, expr: AstNode, ctx: EvalContext, currentPath: (string | number)[], paths: (string | number)[][]) => void;
+/**
+ * Handle path builtins that need evaluate function for arguments.
+ * Returns null if the builtin name is not a path builtin handled here.
+ */
+export declare function evalPathBuiltin(value: QueryValue, name: string, args: AstNode[], ctx: EvalContext, evaluate: EvalFn, isTruthy: IsTruthyFn, setPath: SetPathFn, deletePath: DeletePathFn, applyDel: ApplyDelFn, collectPaths: CollectPathsFn): QueryValue[] | null;
+export {};

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

@@ -0,0 +1,16 @@
+/**
+ * SQL-like jq builtins
+ *
+ * Handles IN, INDEX, and JOIN functions.
+ */
+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 SQL-like builtins that need evaluate function for arguments.
+ * Returns null if the builtin name is not a SQL builtin handled here.
+ */
+export declare function evalSqlBuiltin(value: QueryValue, name: string, args: AstNode[], ctx: EvalContext, evaluate: EvalFn, deepEqual: DeepEqualFn): QueryValue[] | null;
+export {};

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

@@ -0,0 +1,15 @@
+/**
+ * String-related jq builtins
+ *
+ * Handles string manipulation functions like join, split, test, match, gsub, 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 string builtins that need evaluate function for arguments.
+ * Returns null if the builtin name is not a string builtin handled here.
+ */
+export declare function evalStringBuiltin(value: QueryValue, name: string, args: AstNode[], ctx: EvalContext, evaluate: EvalFn): QueryValue[] | null;
+export {};

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

@@ -0,0 +1,11 @@
+/**
+ * Type-related jq builtins
+ *
+ * Handles type checking and type filtering functions like type, numbers, strings, etc.
+ */
+import type { QueryValue } from "../value-operations.js";
+/**
+ * Handle type builtins.
+ * Returns null if the builtin name is not a type builtin handled here.
+ */
+export declare function evalTypeBuiltin(value: QueryValue, name: string): QueryValue[] | null;

package/dist/commands/query-engine/evaluator.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Query expression evaluator
+ *
+ * Evaluates a parsed query AST against any value.
+ * Used by jq, yq, and other query-based commands.
+ */
+import type { FeatureCoverageWriter } from "../../types.js";
+import type { AstNode } from "./parser.js";
+import { type QueryValue } from "./value-operations.js";
+export type { QueryValue } from "./value-operations.js";
+export interface QueryExecutionLimits {
+    maxIterations?: number;
+    maxDepth?: number;
+    maxStringLength?: number;
+    maxOutputSize?: number;
+    maxArrayElements?: number;
+}
+export type ResolvedQueryExecutionLimits = Required<QueryExecutionLimits>;
+export interface EvalContext {
+    vars: Map<string, QueryValue>;
+    limits: ResolvedQueryExecutionLimits;
+    env?: Map<string, string>;
+    /** Named arguments (bare names) exposed via $ARGS.named */
+    namedArgs?: Map<string, QueryValue>;
+    /** Positional arguments (in order) exposed via $ARGS.positional */
+    positionalArgs?: QueryValue[];
+    requireDefenseContext?: boolean;
+    defenseContextChecked?: boolean;
+    /** Original document root for parent/root navigation */
+    root?: QueryValue;
+    /** Current path from root for parent navigation */
+    currentPath?: (string | number)[];
+    funcs?: Map<string, {
+        params: string[];
+        body: AstNode;
+        closure?: Map<string, unknown>;
+    }>;
+    labels?: Set<string>;
+    /** Feature coverage writer for fuzzing instrumentation */
+    coverage?: FeatureCoverageWriter;
+    /** Shared across every recursive evaluation and builtin invocation. */
+    budget: QueryEvaluationBudget;
+}
+export interface QueryEvaluationBudget {
+    operations: number;
+    callDepth: number;
+}
+export declare function chargeQueryWork(ctx: EvalContext, count?: number): void;
+export declare function assertQueryResultCapacity(ctx: EvalContext, current: number, additional?: number): void;
+export interface EvaluateOptions {
+    limits?: QueryExecutionLimits;
+    env?: Map<string, string>;
+    /** Named arguments (bare names) bound to $NAME and exposed via $ARGS.named */
+    namedArgs?: Map<string, QueryValue>;
+    /** Positional arguments (in order) exposed via $ARGS.positional */
+    positionalArgs?: QueryValue[];
+    coverage?: FeatureCoverageWriter;
+    requireDefenseContext?: boolean;
+    /** Reuse across multiple input documents to enforce one command budget. */
+    budget?: QueryEvaluationBudget;
+}
+export declare function evaluate(value: QueryValue, ast: AstNode, ctxOrOptions?: EvalContext | EvaluateOptions): QueryValue[];

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

@@ -0,0 +1,8 @@
+/**
+ * Shared query engine for jq-style filtering
+ *
+ * Provides parser and evaluator for jq-style queries that can be used
+ * with any data format (JSON, YAML, XML, etc.).
+ */
+export * from "./evaluator.js";
+export * from "./parser.js";

package/dist/commands/query-engine/json-output.d.ts

@@ -0,0 +1,11 @@
+import type { QueryValue } from "./value-operations.js";
+export interface JsonOutputOptions {
+    compact?: boolean;
+    raw?: boolean;
+    sortKeys?: boolean;
+    indent?: number;
+    useTab?: boolean;
+    limitKind?: "output_size" | "string_length";
+}
+/** Serialize query values directly into a bounded builder. */
+export declare function formatJsonValue(value: QueryValue, maxBytes: number, options?: JsonOutputOptions): string;

package/dist/commands/query-engine/parser-types.d.ts

@@ -0,0 +1,171 @@
+/**
+ * Query expression parser types
+ *
+ * AST node types and token types for jq-style filter expressions.
+ */
+export type TokenType = "DOT" | "PIPE" | "COMMA" | "COLON" | "SEMICOLON" | "LPAREN" | "RPAREN" | "LBRACKET" | "RBRACKET" | "LBRACE" | "RBRACE" | "QUESTION" | "PLUS" | "MINUS" | "STAR" | "SLASH" | "PERCENT" | "EQ" | "NE" | "LT" | "LE" | "GT" | "GE" | "AND" | "OR" | "NOT" | "ALT" | "ASSIGN" | "UPDATE_ADD" | "UPDATE_SUB" | "UPDATE_MUL" | "UPDATE_DIV" | "UPDATE_MOD" | "UPDATE_ALT" | "UPDATE_PIPE" | "IDENT" | "NUMBER" | "STRING" | "IF" | "THEN" | "ELIF" | "ELSE" | "END" | "AS" | "TRY" | "CATCH" | "TRUE" | "FALSE" | "NULL" | "REDUCE" | "FOREACH" | "LABEL" | "BREAK" | "DEF" | "DOTDOT" | "EOF";
+export interface Token {
+    type: TokenType;
+    value?: string | number;
+    pos: number;
+}
+export type AstNode = IdentityNode | FieldNode | IndexNode | SliceNode | IterateNode | PipeNode | CommaNode | LiteralNode | ArrayNode | ObjectNode | ParenNode | BinaryOpNode | UnaryOpNode | CondNode | TryNode | CallNode | VarBindNode | VarRefNode | RecurseNode | OptionalNode | StringInterpNode | UpdateOpNode | ReduceNode | ForeachNode | LabelNode | BreakNode | DefNode;
+export interface IdentityNode {
+    type: "Identity";
+}
+export interface FieldNode {
+    type: "Field";
+    name: string;
+    base?: AstNode;
+}
+export interface IndexNode {
+    type: "Index";
+    index: AstNode;
+    base?: AstNode;
+}
+export interface SliceNode {
+    type: "Slice";
+    start?: AstNode;
+    end?: AstNode;
+    base?: AstNode;
+}
+export interface IterateNode {
+    type: "Iterate";
+    base?: AstNode;
+}
+export interface PipeNode {
+    type: "Pipe";
+    left: AstNode;
+    right: AstNode;
+}
+export interface CommaNode {
+    type: "Comma";
+    left: AstNode;
+    right: AstNode;
+}
+export interface LiteralNode {
+    type: "Literal";
+    value: unknown;
+}
+export interface ArrayNode {
+    type: "Array";
+    elements?: AstNode;
+}
+export interface ObjectNode {
+    type: "Object";
+    entries: {
+        key: AstNode | string;
+        value: AstNode;
+    }[];
+}
+export interface ParenNode {
+    type: "Paren";
+    expr: AstNode;
+}
+export interface BinaryOpNode {
+    type: "BinaryOp";
+    op: "+" | "-" | "*" | "/" | "%" | "==" | "!=" | "<" | "<=" | ">" | ">=" | "and" | "or" | "//";
+    left: AstNode;
+    right: AstNode;
+}
+export interface UnaryOpNode {
+    type: "UnaryOp";
+    op: "-" | "not";
+    operand: AstNode;
+}
+export interface CondNode {
+    type: "Cond";
+    cond: AstNode;
+    then: AstNode;
+    elifs: {
+        cond: AstNode;
+        then: AstNode;
+    }[];
+    else?: AstNode;
+}
+export interface TryNode {
+    type: "Try";
+    body: AstNode;
+    catch?: AstNode;
+}
+export interface CallNode {
+    type: "Call";
+    name: string;
+    args: AstNode[];
+}
+export interface VarBindNode {
+    type: "VarBind";
+    name: string;
+    value: AstNode;
+    body: AstNode;
+    pattern?: DestructurePattern;
+    alternatives?: DestructurePattern[];
+}
+export type DestructurePattern = {
+    type: "var";
+    name: string;
+} | {
+    type: "array";
+    elements: DestructurePattern[];
+} | {
+    type: "object";
+    fields: {
+        key: string | AstNode;
+        pattern: DestructurePattern;
+        keyVar?: string;
+    }[];
+};
+export interface VarRefNode {
+    type: "VarRef";
+    name: string;
+}
+export interface RecurseNode {
+    type: "Recurse";
+}
+export interface OptionalNode {
+    type: "Optional";
+    expr: AstNode;
+}
+export interface StringInterpNode {
+    type: "StringInterp";
+    parts: (string | AstNode)[];
+}
+export interface UpdateOpNode {
+    type: "UpdateOp";
+    op: "+=" | "-=" | "*=" | "/=" | "%=" | "//=" | "=" | "|=";
+    path: AstNode;
+    value: AstNode;
+}
+export interface ReduceNode {
+    type: "Reduce";
+    expr: AstNode;
+    varName: string;
+    pattern?: DestructurePattern;
+    init: AstNode;
+    update: AstNode;
+}
+export interface ForeachNode {
+    type: "Foreach";
+    expr: AstNode;
+    varName: string;
+    pattern?: DestructurePattern;
+    init: AstNode;
+    update: AstNode;
+    extract?: AstNode;
+}
+export interface LabelNode {
+    type: "Label";
+    name: string;
+    body: AstNode;
+}
+export interface BreakNode {
+    type: "Break";
+    name: string;
+}
+export interface DefNode {
+    type: "Def";
+    name: string;
+    params: string[];
+    funcBody: AstNode;
+    body: AstNode;
+}

package/dist/commands/query-engine/parser.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Query expression parser
+ *
+ * Tokenizes and parses jq-style filter expressions into an AST.
+ * Used by jq, yq, and other query-based commands.
+ */
+export type { ArrayNode, AstNode, BinaryOpNode, BreakNode, CallNode, CommaNode, CondNode, DefNode, DestructurePattern, FieldNode, ForeachNode, IdentityNode, IndexNode, IterateNode, LabelNode, LiteralNode, ObjectNode, OptionalNode, ParenNode, PipeNode, RecurseNode, ReduceNode, SliceNode, StringInterpNode, Token, TokenType, TryNode, UnaryOpNode, UpdateOpNode, VarBindNode, VarRefNode, } from "./parser-types.js";
+import type { AstNode } from "./parser-types.js";
+export interface QueryParseLimits {
+    maxDepth?: number;
+    maxTokens?: number;
+    maxSourceLength?: number;
+}
+export declare function parse(input: string, limits?: QueryParseLimits): AstNode;

package/dist/commands/query-engine/path-operations.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Query Path Utilities
+ *
+ * Utility functions for path-based operations on query values.
+ */
+import type { QueryValue } from "./value-operations.js";
+/**
+ * Set a value at a given path within a query value.
+ * Creates intermediate arrays/objects as needed.
+ */
+export declare function setPath(value: QueryValue, path: (string | number)[], newVal: QueryValue): QueryValue;
+/**
+ * Delete a value at a given path within a query value.
+ */
+export declare function deletePath(value: QueryValue, path: (string | number)[]): QueryValue;

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

@@ -0,0 +1,84 @@
+/**
+ * Check if a key is safe to use for object property access/assignment.
+ * Returns true if the key is safe, false if it could cause prototype pollution.
+ */
+export declare function isSafeKey(key: string): boolean;
+/**
+ * Check if a key is safe using the extended dangerous keys list.
+ * More paranoid version that blocks additional Object.prototype methods.
+ */
+export declare function isSafeKeyStrict(key: string): boolean;
+/**
+ * Safely get a property from an object using hasOwnProperty check.
+ * Returns undefined if the key is dangerous or doesn't exist as own property.
+ */
+export declare function safeGet<T>(obj: Record<string, T>, key: string): T | undefined;
+/**
+ * Safely set a property on an object.
+ * Silently ignores dangerous keys to prevent prototype pollution.
+ */
+export declare function safeSet<T>(obj: Record<string, T>, key: string, value: T): void;
+/**
+ * Safely delete a property from an object.
+ * Ignores dangerous keys.
+ */
+export declare function safeDelete<T>(obj: Record<string, T>, key: string): void;
+/**
+ * Create a safe object from entries, filtering out dangerous keys.
+ */
+export declare function safeFromEntries<T>(entries: Iterable<[string, T]>): Record<string, T>;
+/**
+ * Safely spread/assign properties from source to target.
+ * Only copies own properties and filters dangerous keys.
+ */
+export declare function safeAssign<T>(target: Record<string, T>, source: Record<string, T>): Record<string, T>;
+/**
+ * Create a shallow copy of an object, filtering dangerous keys.
+ */
+export declare function safeCopy<T extends Record<string, unknown>>(obj: T): T;
+/**
+ * Check if object has own property safely (not inherited from prototype).
+ */
+export declare function safeHasOwn(obj: object, key: string): boolean;
+/**
+ * SECURITY: Recursively convert parsed data to null-prototype objects.
+ * Call this on ALL data from untrusted parsers (JSON.parse, YAML.parse, etc.)
+ * to eliminate prototype chain access at the boundary.
+ * All keys (including __proto__, constructor) are preserved as own properties —
+ * the defense is null-prototype, not key filtering.
+ */
+export interface SanitizeParsedDataLimits {
+    maxDepth?: number;
+    maxElements?: number;
+    /** Optional shared counter for aggregate accounting across documents. */
+    elementBudget?: {
+        used: number;
+    };
+}
+export declare function sanitizeParsedData(value: unknown, limits?: SanitizeParsedDataLimits): unknown;
+/**
+ * Type-safe cast from unknown to Record for property access.
+ * Returns null if the value is not a non-array object.
+ */
+export declare function asQueryRecord(value: unknown): Record<string, unknown> | null;
+/**
+ * Create a null-prototype object from a static lookup table literal.
+ * Use this to define Record/dictionary constants that are safe from
+ * prototype pollution (e.g., `__proto__` lookups return `undefined`).
+ *
+ * ```ts
+ * const COLORS = nullPrototype({ red: "#f00", blue: "#00f" });
+ * COLORS["__proto__"]  // undefined (no prototype chain)
+ * ```
+ */
+export declare function nullPrototype<T extends Record<string, unknown>>(obj: T): T;
+/**
+ * Create a null-prototype shallow copy of an object.
+ * This prevents prototype chain lookups without filtering any keys.
+ */
+export declare function nullPrototypeCopy<T extends object>(obj: T): T & Record<string, unknown>;
+/**
+ * Merge multiple objects into a new null-prototype object.
+ * This prevents prototype chain lookups without filtering any keys.
+ */
+export declare function nullPrototypeMerge<T extends object>(...objs: T[]): T & Record<string, unknown>;

package/dist/commands/query-engine/value-operations.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Query Value Utilities
+ *
+ * Utility functions for working with jq/query values.
+ */
+export type QueryValue = unknown;
+/**
+ * Check if a value is truthy in jq semantics.
+ * In jq: false and null are falsy, everything else is truthy.
+ */
+export declare function isTruthy(v: QueryValue): boolean;
+/**
+ * Deep equality check for query values.
+ */
+export declare function deepEqual(a: QueryValue, b: QueryValue): boolean;
+/**
+ * Compare two values for sorting.
+ * Returns negative if a < b, positive if a > b, 0 if equal.
+ */
+export declare function compare(a: QueryValue, b: QueryValue): number;
+/**
+ * Deep merge two objects.
+ * Values from b override values from a, except nested objects are merged recursively.
+ * Filters out dangerous keys (__proto__, constructor, prototype) to prevent prototype pollution.
+ * Uses null-prototype objects to prevent prototype pollution via inherited properties.
+ */
+export declare function deepMerge(a: Record<string, unknown>, b: Record<string, unknown>, options?: {
+    maxDepth?: number;
+    visit?: () => void;
+}): Record<string, unknown>;
+/**
+ * Calculate the nesting depth of a value (array or object).
+ */
+export declare function getValueDepth(value: QueryValue, maxCheck?: number): number;
+/**
+ * Compare two values using jq's comparison semantics.
+ * jq sorts by type first (null < bool < number < string < array < object),
+ * then by value within type.
+ */
+export declare function compareJq(a: QueryValue, b: QueryValue): number;
+/**
+ * Check if value a contains value b using jq's containment semantics.
+ */
+export declare function containsDeep(a: QueryValue, b: QueryValue): boolean;

package/dist/commands/readlink/readlink.d.ts

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

package/dist/commands/registry.d.ts

@@ -0,0 +1,56 @@
+import type { RuntimeCommand } from "../types.js";
+/** All available built-in command names (excludes network commands) */
+export type CommandName = "echo" | "cat" | "printf" | "ls" | "mkdir" | "rmdir" | "touch" | "rm" | "cp" | "mv" | "ln" | "chmod" | "pwd" | "readlink" | "head" | "tail" | "wc" | "stat" | "grep" | "fgrep" | "egrep" | "rg" | "sed" | "awk" | "sort" | "uniq" | "comm" | "cut" | "paste" | "tr" | "rev" | "nl" | "fold" | "expand" | "unexpand" | "strings" | "split" | "column" | "join" | "tee" | "find" | "basename" | "dirname" | "tree" | "du" | "env" | "printenv" | "alias" | "unalias" | "history" | "xargs" | "true" | "false" | "clear" | "bash" | "sh" | "jq" | "base64" | "diff" | "date" | "sleep" | "timeout" | "seq" | "expr" | "md5sum" | "sha1sum" | "sha256sum" | "file" | "html-to-markdown" | "help" | "which" | "tac" | "hostname" | "od" | "gzip" | "gunzip" | "zcat" | "tar" | "yq" | "xan" | "sqlite3" | "time" | "whoami";
+/** Network command names (only available when network is configured) */
+export type NetworkCommandName = "curl";
+/** Python command names (only available when python is explicitly enabled) */
+export type PythonCommandName = "python3" | "python";
+/** JavaScript command names (only available when javascript is explicitly enabled) */
+export type JavaScriptCommandName = "js-exec" | "node";
+/** All command names including network, python, and javascript commands */
+export type AllCommandName = CommandName | NetworkCommandName | PythonCommandName | JavaScriptCommandName;
+/**
+ * Gets all available command names (excludes network commands)
+ */
+export declare function getCommandNames(): string[];
+/**
+ * Gets all network command names
+ */
+export declare function getNetworkCommandNames(): string[];
+/**
+ * Creates all lazy commands for registration (excludes network commands)
+ * @param filter Optional array of command names to include. If not provided, all commands are created.
+ */
+export declare function createLazyCommands(filter?: CommandName[]): RuntimeCommand[];
+/**
+ * Creates network commands for registration (curl, etc.)
+ * These are only registered when network is explicitly configured.
+ */
+export declare function createNetworkCommands(): RuntimeCommand[];
+/**
+ * Gets all python command names
+ */
+export declare function getPythonCommandNames(): string[];
+/**
+ * Creates python commands for registration (python3, python).
+ * These are only registered when python is explicitly enabled.
+ * Note: Python introduces additional security surface (arbitrary code execution).
+ */
+export declare function createPythonCommands(): RuntimeCommand[];
+/**
+ * Gets all javascript command names
+ */
+export declare function getJavaScriptCommandNames(): string[];
+/**
+ * Creates javascript commands for registration (js-exec).
+ * These are only registered when javascript is explicitly enabled.
+ */
+export declare function createJavaScriptCommands(): RuntimeCommand[];
+/**
+ * Clears the command cache (for testing)
+ */
+export declare function clearCommandCache(): void;
+/**
+ * Gets the number of loaded commands (for testing)
+ */
+export declare function getLoadedCommandCount(): number;