@lmctl-ai/lmctl 0.2.38 → 0.2.39

package/dist/script/lmscript.d.ts

@@ -1,647 +0,0 @@
-/**
- * LMScript - A lightweight prototype scripting language implemented in TypeScript.
- *
- * Requirements Met:
- * 1. Single file: Self-contained implementation (Lexer, Parser, Static Checker, Interpreter, Host API) with zero dependencies.
- * 2. Scan all and check before execution: In-memory AST validation upfront. Zero intermediate files generated.
- * 3. Language features: Top-level functions, flow control (if/else, while, for, break, continue, return), tuple & destructuring assignment: (a, b) = [1, 2], dot notation (data.key), object literals { key: val }, and negative indexing arr[-1].
- * 4. Predefined functions implemented in TypeScript:
- *    - File I/O: read_file, write_file, append_file, read_lines, read_json, write_json, read_csv, write_csv, file_exists, delete_file, mkdir, rmdir, copy_file, move_file, basename, dirname, path_join, abs_path.
- *    - Data structures:
- *      * List/Array: list, len, push, pop, shift, unshift, insert, remove_at, slice, concat, reverse, sort, contains, index_of, join, unique, flatten, first, last, is_empty, sum, avg.
- *      * Hash/Map: hash, keys, values, entries, from_entries, has_key, get, set, delete_key, merge, clone, clear, size. ("map" is deliberately unimplemented, not an empty-hash constructor -- reserved for a future higher-order array-transform function.)
- *    - JSON processing: data = json(out), json_parse, json_parse_safe, json_stringify, pluck, filter_by, find_by.
- *    - Regex: regex_test/test, regex_match/match/search, regex_find_all/findall, regex_replace, split_regex -- patterns are plain strings compiled via the host RegExp engine.
- *    - Environment & time: env, getenv, set_env, now, timestamp, date, strftime, date_format.
- *    - Null handling: coalesce, if_null, default_to, if_else (expression-level ternary).
- *    - System & Process: system() returning SystemResult, prompt_human() for attended terminal pause/handoff.
- *    - Comprehensive string operations (split, lines, words, join, trim, upper, lower, contains, replace, slice, etc.).
- *    - First-class function values: a bare reference to an already-declared function name (user or host) is a
- *      callable FunctionRef, assignable to a variable (`g = dbl; g(4);`) -- a NAMED reference, not a lexical
- *      closure; calling through a non-identifier expression (e.g. `arr[0](x)`) is not supported.
- * 5. Register new functions: API allowing host TypeScript functions to be registered and checked statically.
- *
- * Security & Authority Model:
- * LMScript executes with full operator authority (no sandbox). File I/O operations (read_file,
- * write_file, etc.) and shell processes (system()) execute with the local permissions and environment
- * of the invoking user. Scripts should only be accepted and run from trusted operator sources.
- */
-export interface SourceLocation {
-    line: number;
-    column: number;
-    file?: string;
-}
-export interface Diagnostic {
-    message: string;
-    line: number;
-    column: number;
-    severity: "error" | "warning";
-    file?: string;
-}
-export declare class LMScriptError extends Error {
-    readonly message: string;
-    readonly line: number;
-    readonly column: number;
-    readonly stage: "LEXER" | "PARSER" | "CHECKER" | "RUNTIME";
-    readonly file?: string;
-    constructor(message: string, line: number, column: number, stage: "LEXER" | "PARSER" | "CHECKER" | "RUNTIME", file?: string);
-}
-export declare class LMScriptExit extends Error {
-    readonly isControlFlow = true;
-    readonly exitCode: number;
-    constructor(exitCode?: number);
-}
-/**
- * Formats a diagnostic with a visual code snippet and caret pointer.
- */
-export declare function formatDiagnostic(diag: Diagnostic, source?: string): string;
-/**
- * Result record returned by `system()`.
- *
- * Invariants & Contract Guarantees:
- * 1. Strict Completion: `system()` is strictly a completion primitive and always awaits
- *    process exit. It does not return running or detached processes.
- * 2. Null-No-Overload: `code: null` strictly denotes abnormal termination (killed by signal
- *    or timed out). `code: null` NEVER means "still running" or "detached".
- * 3. Future Background Decoupling: Any future non-blocking background handle will be a separate
- *    discriminated record (`{ kind: 'process', pid, started_at }`) with dedicated wait/poll
- *    primitives, rather than overloading `SystemResult` with nullable fields. Handles carry
- *    `started_at` timestamp to protect against PID recycling.
- */
-export interface SystemResult {
-    stdout: string;
-    stderr: string;
-    code: number | null;
-    signal: string | null;
-    timed_out: boolean;
-    duration_ms: number;
-    pid: number | null;
-}
-export declare function createSystemResult(stdout: string, stderr: string, code: number | null, signal?: string | null, timedOut?: boolean, durationMs?: number, pid?: number | null): SystemResult;
-export declare function shellQuote(value: any): string;
-export declare function systemSync(cmd: string | any[], timeoutMs?: number): SystemResult;
-/**
- * Safely parses JSON string with preamble and markdown fence recovery.
- * Returns `fallback` (defaulting to null) on parse failure rather than throwing.
- */
-export declare function safeParseJson(raw: any, fallback?: any): any;
-/**
- * Synchronous operator prompt on terminal stdin.
- * Returns the entered string (with trailing newline stripped), or null if stdin is closed/non-interactive.
- */
-export declare function promptHumanSync(question?: any): string | null;
-/**
- * Asynchronous operator prompt on terminal or provided input/output stream.
- * Returns the entered string, or null if stdin is closed or non-interactive without pending data.
- */
-export declare function promptHumanAsync(question?: any, inStream?: any, outStream?: any): Promise<string | null>;
-export declare function parseCsv(text: string, hasHeader?: boolean, delimiter?: string): any[];
-export declare function stringifyCsv(data: any[], delimiter?: string): string;
-export type TokenType = "FN" | "LET" | "IF" | "ELSE" | "WHILE" | "FOR" | "RETURN" | "BREAK" | "CONTINUE" | "TRUE" | "FALSE" | "NULL" | "PARALLEL" | "SYNC" | "IMPORT" | "IDENTIFIER" | "NUMBER" | "STRING" | "FSTRING_START" | "FSTRING_TEXT" | "FSTRING_FIELD_START" | "FSTRING_FIELD_END" | "FSTRING_END" | "PLUS" | "MINUS" | "STAR" | "SLASH" | "PERCENT" | "ASSIGN" | "EQUAL" | "NOT_EQUAL" | "LESS" | "LESS_EQUAL" | "GREATER" | "GREATER_EQUAL" | "AND" | "OR" | "NOT" | "DOT" | "COLON" | "LPAREN" | "RPAREN" | "LBRACE" | "RBRACE" | "LBRACKET" | "RBRACKET" | "COMMA" | "SEMICOLON" | "EOF";
-export interface Token {
-    type: TokenType;
-    value: string;
-    literal?: any;
-    line: number;
-    column: number;
-    offset?: number;
-    endOffset?: number;
-    endLine?: number;
-    endColumn?: number;
-    stringLiteral?: {
-        prefix: string;
-        raw: boolean;
-        triple: boolean;
-        formatted: boolean;
-    };
-}
-export declare class Lexer {
-    readonly diagnostics: Diagnostic[];
-    private formattedDepth;
-    private readonly modes;
-    private readonly source;
-    private readonly length;
-    private readonly file?;
-    private pos;
-    private line;
-    private column;
-    constructor(source: string, file?: string);
-    tokenize(): Token[];
-    private position;
-    private spannedToken;
-    private scanTokens;
-    private readNextToken;
-    private peek;
-    private peekNext;
-    private advance;
-    private match;
-    private isDigit;
-    private isAlpha;
-    private isAlphaNumeric;
-    private skipWhitespaceAndComments;
-    private readNumber;
-    private readString;
-    private consumeStringNewline;
-    private readModernEscape;
-    private readModernString;
-    private readIdentifier;
-}
-export type BinaryOp = "+" | "-" | "*" | "/" | "%" | "==" | "!=" | "<" | "<=" | ">" | ">=" | "&&" | "||";
-export type UnaryOp = "!" | "-";
-export interface NodeBase {
-    line: number;
-    column: number;
-    file?: string;
-}
-export type Expr = LiteralExpr | InterpolatedStringExpr | IdentifierExpr | AssignExpr | IndexAssignExpr | TupleAssignExpr | UnaryExpr | BinaryExpr | CallExpr | ArrayExpr | IndexExpr | GroupingExpr | TupleExpr | ObjectExpr | ParallelExpr;
-export interface ParallelExpr extends NodeBase {
-    kind: "ParallelExpr";
-    tasks: CallExpr[];
-}
-export interface LiteralExpr extends NodeBase {
-    kind: "LiteralExpr";
-    value: any;
-}
-export interface InterpolationField extends NodeBase {
-    expression: Expr;
-    offset?: number;
-    endOffset?: number;
-}
-export interface InterpolatedStringExpr extends NodeBase {
-    kind: "InterpolatedStringExpr";
-    parts: (string | InterpolationField)[];
-}
-export interface IdentifierExpr extends NodeBase {
-    kind: "IdentifierExpr";
-    name: string;
-}
-export interface AssignExpr extends NodeBase {
-    kind: "AssignExpr";
-    target: string;
-    value: Expr;
-}
-export interface IndexAssignExpr extends NodeBase {
-    kind: "IndexAssignExpr";
-    target: Expr;
-    index: Expr;
-    value: Expr;
-}
-export interface TupleAssignExpr extends NodeBase {
-    kind: "TupleAssignExpr";
-    targets: string[];
-    value: Expr;
-}
-export interface UnaryExpr extends NodeBase {
-    kind: "UnaryExpr";
-    operator: UnaryOp;
-    operand: Expr;
-}
-export interface BinaryExpr extends NodeBase {
-    kind: "BinaryExpr";
-    operator: BinaryOp;
-    left: Expr;
-    right: Expr;
-}
-export interface CallExpr extends NodeBase {
-    kind: "CallExpr";
-    callee: string;
-    args: Expr[];
-}
-export interface ArrayExpr extends NodeBase {
-    kind: "ArrayExpr";
-    elements: Expr[];
-}
-export interface IndexExpr extends NodeBase {
-    kind: "IndexExpr";
-    target: Expr;
-    index: Expr;
-}
-export interface GroupingExpr extends NodeBase {
-    kind: "GroupingExpr";
-    expression: Expr;
-}
-export interface TupleExpr extends NodeBase {
-    kind: "TupleExpr";
-    elements: Expr[];
-}
-export interface ObjectProperty {
-    key: string;
-    value: Expr;
-}
-export interface ObjectExpr extends NodeBase {
-    kind: "ObjectExpr";
-    properties: ObjectProperty[];
-}
-export type Stmt = ImportStmt | FunctionDeclStmt | VarDeclStmt | TupleVarDeclStmt | IfStmt | WhileStmt | ForStmt | ReturnStmt | BreakStmt | ContinueStmt | SyncAssignStmt | SyncIndexAssignStmt | SyncCallStmt | ExprStmt | BlockStmt;
-export interface ImportStmt extends NodeBase {
-    kind: "ImportStmt";
-    path: string;
-}
-export interface SyncAssignStmt extends NodeBase {
-    kind: "SyncAssignStmt";
-    target: string;
-    value: Expr;
-}
-export interface SyncIndexAssignStmt extends NodeBase {
-    kind: "SyncIndexAssignStmt";
-    target: Expr;
-    index: Expr;
-    value: Expr;
-}
-export interface SyncCallStmt extends NodeBase {
-    kind: "SyncCallStmt";
-    call: CallExpr;
-}
-export interface FunctionDeclStmt extends NodeBase {
-    kind: "FunctionDeclStmt";
-    name: string;
-    params: string[];
-    body: BlockStmt;
-}
-export interface VarDeclStmt extends NodeBase {
-    kind: "VarDeclStmt";
-    name: string;
-    initializer?: Expr;
-}
-export interface TupleVarDeclStmt extends NodeBase {
-    kind: "TupleVarDeclStmt";
-    names: string[];
-    initializer: Expr;
-}
-export interface IfStmt extends NodeBase {
-    kind: "IfStmt";
-    condition: Expr;
-    thenBranch: Stmt;
-    elseBranch?: Stmt;
-}
-export interface WhileStmt extends NodeBase {
-    kind: "WhileStmt";
-    condition: Expr;
-    body: Stmt;
-}
-export interface ForStmt extends NodeBase {
-    kind: "ForStmt";
-    init?: Stmt;
-    condition?: Expr;
-    update?: Expr;
-    body: Stmt;
-}
-export interface ReturnStmt extends NodeBase {
-    kind: "ReturnStmt";
-    value?: Expr;
-}
-export interface BreakStmt extends NodeBase {
-    kind: "BreakStmt";
-}
-export interface ContinueStmt extends NodeBase {
-    kind: "ContinueStmt";
-}
-export interface ExprStmt extends NodeBase {
-    kind: "ExprStmt";
-    expr: Expr;
-}
-export interface BlockStmt extends NodeBase {
-    kind: "BlockStmt";
-    statements: Stmt[];
-}
-export interface Program extends NodeBase {
-    kind: "Program";
-    statements: Stmt[];
-}
-export declare function attachSourceFile(node: any, file: string): void;
-export declare class Parser {
-    private readonly tokens;
-    private current;
-    private readonly file?;
-    constructor(tokens: Token[], file?: string);
-    parse(): Program;
-    private parseDeclaration;
-    private parseImportStmt;
-    private parseFunctionDecl;
-    private parseVarDecl;
-    private parseStatement;
-    private parseSyncStatement;
-    private parseIfStatement;
-    private parseWhileStatement;
-    private parseForStatement;
-    private parseReturnStatement;
-    private parseBreakStatement;
-    private parseContinueStatement;
-    private parseBlockBody;
-    private parseExpressionStatement;
-    parseExpression(): Expr;
-    private parseAssignment;
-    private parseLogicalOr;
-    private parseLogicalAnd;
-    private parseEquality;
-    private parseRelational;
-    private parseAdditive;
-    private parseMultiplicative;
-    private parseUnary;
-    private parseCallAndIndex;
-    private parsePrimary;
-    private parseFormattedString;
-    private validateFieldExpression;
-    private match;
-    private check;
-    private advance;
-    private isAtEnd;
-    private peek;
-    private previous;
-    private consume;
-    private consumeOptionalSemicolon;
-}
-export declare const STDLIB_SOURCE = "# LMScript Standard Library (std.lms)\n\n# String Utilities\nfn is_blank(s) {\n  if (s == null) {\n    return true;\n  }\n  return len(trim(s)) == 0;\n}\n\n# Array Utilities\nfn chunk(arr, size) {\n  if (size <= 0) {\n    return [];\n  }\n  res = [];\n  current = [];\n  for (i = 0; i < len(arr); i = i + 1) {\n    push(current, arr[i]);\n    if (len(current) == size) {\n      push(res, current);\n      current = [];\n    }\n  }\n  if (len(current) > 0) {\n    push(res, current);\n  }\n  return res;\n}\n\nfn compact(arr) {\n  res = [];\n  for (i = 0; i < len(arr); i = i + 1) {\n    item = arr[i];\n    if (item != null) {\n      push(res, item);\n    }\n  }\n  return res;\n}\n\nfn zip(arr1, arr2) {\n  res = [];\n  limit = len(arr1);\n  if (len(arr2) < limit) {\n    limit = len(arr2);\n  }\n  for (i = 0; i < limit; i = i + 1) {\n    push(res, [arr1[i], arr2[i]]);\n  }\n  return res;\n}\n\nfn enumerate(arr) {\n  res = [];\n  for (i = 0; i < len(arr); i = i + 1) {\n    push(res, [i, arr[i]]);\n  }\n  return res;\n}\n\nfn take(arr, n) {\n  res = [];\n  limit = n;\n  if (limit > len(arr)) {\n    limit = len(arr);\n  }\n  for (i = 0; i < limit; i = i + 1) {\n    push(res, arr[i]);\n  }\n  return res;\n}\n\nfn drop(arr, n) {\n  res = [];\n  start = n;\n  if (start < 0) {\n    start = 0;\n  }\n  for (i = start; i < len(arr); i = i + 1) {\n    push(res, arr[i]);\n  }\n  return res;\n}\n\n# Math Utilities\nfn clamp(val, low, high) {\n  if (val < low) {\n    return low;\n  }\n  if (val > high) {\n    return high;\n  }\n  return val;\n}\n";
-export declare function getStdlibProgram(): Program;
-export interface CheckOptions {
-    /** Inspect literal built-in read paths against the current filesystem. No script evaluation. */
-    checkFiles?: boolean;
-    /** Pre-defined global variable names available without declaration (e.g. args, ARGV) */
-    globals?: string[];
-    /** File path of the script being checked/executed */
-    file?: string;
-    /** Base directory for resolving relative imports (defaults to process.cwd() or path.dirname(file)) */
-    baseDir?: string;
-    /** Disable implicit standard library inclusion */
-    noStdlib?: boolean;
-    /** Custom module resolver for virtual files / test isolation */
-    moduleResolver?: (specifier: string, fromFile?: string) => {
-        path: string;
-        source: string;
-    };
-    /** Custom stderr output writer for runtime error logs */
-    stderr?: (text: string) => void;
-}
-export type CompileOptions = CheckOptions;
-export declare function compileProgram(source: string, options?: CompileOptions): {
-    program: Program;
-    loadedFiles: string[];
-    diagnostics: Diagnostic[];
-};
-export interface FunctionSignature {
-    name: string;
-    paramCount: number;
-    params: string[];
-    isHost: boolean;
-    isStdlib?: boolean;
-    file?: string;
-    line: number;
-    column: number;
-}
-export type HostFunctionArity = number | {
-    min: number;
-    max?: number;
-};
-type CheckableHostFunction = {
-    arity?: HostFunctionArity;
-    readsFile?: boolean;
-    isContainerMutation?: boolean;
-};
-export declare class StaticChecker {
-    private diagnostics;
-    private readonly hostFunctions;
-    private readonly options;
-    private readonly functions;
-    private currentScope;
-    private loopDepth;
-    private inFunction;
-    hasConcurrency: boolean;
-    constructor(hostFunctions: Map<string, CheckableHostFunction>, options?: CheckOptions);
-    check(program: Program): Diagnostic[];
-    private addError;
-    private collectFunction;
-    private checkStmt;
-    private checkReadPath;
-    private checkExpr;
-}
-export declare class ReturnSignal {
-    readonly value: any;
-    constructor(value: any);
-}
-export declare class BreakSignal {
-}
-export declare class ContinueSignal {
-}
-/**
- * First-class function value (operator ruling, 2026-09-29, Rule 2 -- "if it
- * is just how it came out, it is worth fixing": no stated design rationale
- * anywhere separated function names from the variable namespace; it was an
- * omission of scope, not a deliberate tradeoff). A bare reference to an
- * already-declared function name (user `fn` or host) evaluates to one of
- * these, which can be assigned, stored, and called through a variable --
- * `g = dbl; g(4);` now works. Deliberately a NAMED reference, not a true
- * lexical closure over an enclosing scope: nothing in the reported gaps
- * (map/filter/reduce/etc. over top-level named functions) needs closures,
- * and adding them is a materially bigger, separate change.
- */
-export declare class FunctionRef {
-    readonly name: string;
-    constructor(name: string);
-    toString(): string;
-}
-export declare class Environment {
-    private static nextId;
-    readonly id: number;
-    private readonly values;
-    readonly parent?: Environment;
-    /**
-     * True only for the environment a function CALL creates (invokeNamed's
-     * fnEnv) -- never for a plain nested block (if/while/for body). Marks
-     * where `set()`'s upward search for an EXISTING binding must stop.
-     *
-     * Real incident, 2026-09-29 (operator finding): `fn f(x) { outer = 1; }`
-     * silently mutated an outer/global `outer` whenever one already existed,
-     * purely because the name collided -- "dynamic scoping with implicit
-     * global mutation," math's words, and no `local`/`my`/`let` to defend
-     * against it (a *working* `let` already existed in the grammar, but was
-     * entirely undocumented, which is why it went unnoticed). A name that
-     * happens to already exist as a global is not evidence the function
-     * meant to reference it. `set()` now treats a name not yet bound WITHIN
-     * the current function's own scope chain as a fresh function-local,
-     * matching every language cited for comparison (Perl's `my`, JS's
-     * function/`let` scoping, Python's function-scope-by-default) --
-     * without this flag, an if/while/for block's `set()` calls would ALSO
-     * stop at their own Environment, breaking ordinary control flow (e.g.
-     * `if (true) { x = 2; }` updating a `x` declared earlier in the SAME
-     * function must keep working).
-     */
-    readonly isFunctionBoundary: boolean;
-    constructor(parent?: Environment, isFunctionBoundary?: boolean);
-    resolveBinding(name: string): {
-        env: Environment;
-        name: string;
-    } | undefined;
-    define(name: string, value: any): void;
-    get(name: string): any;
-    has(name: string): boolean;
-    set(name: string, value: any): void;
-}
-export declare class AsyncLock {
-    private holderTaskId?;
-    private depth;
-    private readonly waiters;
-    acquire(taskId?: number, timeoutMs?: number): Promise<void>;
-    release(): void;
-    withLock<T>(action: () => Promise<T>, taskId?: number, timeoutMs?: number): Promise<T>;
-}
-export declare class AsyncLockManager {
-    private readonly bindingLocks;
-    private readonly objectLocks;
-    getBindingLock(bindingKey: string): AsyncLock;
-    getObjectLock(target: object): AsyncLock;
-}
-export type HostFunction = (...args: any[]) => any;
-export interface FunctionDoc {
-    name: string;
-    category: string;
-    module?: string;
-    signature: string;
-    description: string;
-    parameters?: Array<{
-        name: string;
-        type: string;
-        description: string;
-    }>;
-    returns?: {
-        type: string;
-        description: string;
-    };
-    example?: string;
-}
-export interface ScriptModule {
-    name: string;
-    description?: string;
-    docs?: FunctionDoc[];
-    register?: (engine: LMScript, context?: any) => void;
-}
-export interface HostFunctionMeta {
-    fn: HostFunction;
-    arity?: HostFunctionArity;
-    description?: string;
-    readsFile?: boolean;
-    isDefault?: boolean;
-    isContainerMutation?: boolean;
-    doc?: FunctionDoc;
-}
-export declare class Interpreter {
-    private globalEnv;
-    private readonly userFunctions;
-    private readonly hostFunctions;
-    private readonly stdout;
-    private readonly stderr?;
-    private readonly lockManager;
-    private readonly isAsync;
-    private nextTaskId;
-    private readonly initialGlobals?;
-    private callDepth;
-    private readonly asyncCallDepth;
-    private readonly recordedErrors;
-    constructor(hostFunctions: Map<string, HostFunctionMeta>, stdout?: (text: string) => void, isAsync?: boolean, initialGlobals?: Map<string, any>, stderr?: (text: string) => void);
-    evaluateProgram(program: Program): any;
-    private execStmt;
-    private evalExpr;
-    /** A call's callee name is normally used directly -- but if it names
-     * neither a declared user function nor a host function, it may be a
-     * variable holding a first-class FunctionRef (`g = dbl; g(4);`), in which
-     * case the actual function to invoke is the ref's name instead. */
-    private resolveCallTarget;
-    private invokeNamed;
-    private resolveIdentifier;
-    private isTruthy;
-    evaluateProgramAsync(program: Program): Promise<any>;
-    private execStmtAsync;
-    private evalExprAsync;
-    private invokeCallAsync;
-    getRecordedErrors(): string[];
-}
-export interface ExecutionResult {
-    success: boolean;
-    value?: any;
-    exitCode?: number;
-    diagnostics: Diagnostic[];
-    output: string[];
-    errors?: string[];
-}
-export declare const LANGUAGE_DOCS: FunctionDoc[];
-export declare const BUILTIN_FUNCTION_DOCS: FunctionDoc[];
-export declare const STDLIB_FUNCTION_DOCS: FunctionDoc[];
-/**
- * Real C/Perl/Python printf-style substitution for sprintf()/printf()
- * (math.lmctl, 2026-09-29, defect B: sprintf/printf were aliased onto
- * format(), which is Python str.format brace syntax -- `sprintf("%s=%s",
- * a, b)` silently returned the literal template unsubstituted, because "%s"
- * is not a brace placeholder. "%s is the ONLY reason anyone reaches for the
- * name sprintf" -- so these two entry points get their OWN real % syntax,
- * format() keeps braces. Deliberately minimal: %s/%d/%f/%%, no width/
- * precision/padding modifiers -- add more only against a concrete need.
- * Extra args with no corresponding %-directive are silently unused,
- * matching real printf (not folded into a "no directives -> space-join"
- * fallback, which would just be a second silently-wrong behavior).
- */
-export declare function printfFormat(template: any, args: any[]): string;
-export declare class LMScript {
-    private readonly hostFunctions;
-    private readonly functionDocs;
-    private readonly registeredModules;
-    private readonly functionOriginModule;
-    private currentRegisteringModule;
-    private outputLogs;
-    isAsyncMode: boolean;
-    constructor();
-    private registerDefaultDocs;
-    registerFunctionDoc(doc: FunctionDoc): this;
-    registerModule(module: ScriptModule, context?: any): this;
-    getModules(): ScriptModule[];
-    getModule(name: string): ScriptModule | undefined;
-    getFunctionsByModule(moduleName: string): FunctionDoc[];
-    getFunctionDocs(): FunctionDoc[];
-    getFunctionDoc(name: string): FunctionDoc | undefined;
-    getFunctionCategories(): string[];
-    getFunctionsByCategory(category: string): FunctionDoc[];
-    /**
-     * Requirement 4: Predefined functions implemented in TypeScript.
-     * Includes File I/O, Lists/Arrays, Hashes/Maps, JSON, Shell, and Strings.
-     */
-    private registerPredefinedFunctions;
-    /**
-     * Requirement 5: Register new TypeScript functions into the runtime.
-     */
-    registerFunction(name: string, fn: HostFunction, arity?: HostFunctionArity, descriptionOrOptions?: string | {
-        description?: string;
-        isDefault?: boolean;
-        isContainerMutation?: boolean;
-        doc?: FunctionDoc;
-        allowOverwrite?: boolean;
-        module?: string;
-    }, isDefault?: boolean, isContainerMutation?: boolean): this;
-    getFunctionOriginModule(name: string): string | undefined;
-    private readonly initialGlobals;
-    setGlobal(name: string, value: any): this;
-    getGlobal(name: string): any;
-    /**
-     * Requirement 2: Scan all and check before execution without generating intermediate files.
-     */
-    scanAndCheck(source: string, options?: CompileOptions): {
-        ast: Program | null;
-        diagnostics: Diagnostic[];
-        hasConcurrency: boolean;
-    };
-    /**
-     * Complete execution pipeline:
-     * 1. Scans and parses source.
-     * 2. Runs static checker upfront.
-     * 3. If any static errors are found, aborts immediately WITHOUT executing.
-     * 4. If checks pass, executes AST in-memory.
-     */
-    run(source: string, options?: CompileOptions): ExecutionResult;
-    /**
-     * Asynchronous execution pipeline supporting parallel tasks and sync statements.
-     */
-    runAsync(source: string, options?: CompileOptions): Promise<ExecutionResult>;
-    private lastRecordedErrors;
-    getRecordedErrors(): string[];
-    hasFunction(name: string): boolean;
-    getRegisteredFunctions(): string[];
-}
-export declare function runDemoSuite(): Promise<boolean>;
-export {};