@robinpath/robinpath 0.30.0

package/dist/modules/Array.d.ts

@@ -0,0 +1,10 @@
+import { BuiltinHandler, FunctionMetadata, ModuleMetadata, ModuleAdapter } from '../index';
+/**
+ * Array module for RobinPath
+ * Provides array manipulation operations
+ */
+export declare const ArrayFunctions: Record<string, BuiltinHandler>;
+export declare const ArrayFunctionMetadata: Record<string, FunctionMetadata>;
+export declare const ArrayModuleMetadata: ModuleMetadata;
+declare const ArrayModule: ModuleAdapter;
+export default ArrayModule;

package/dist/modules/Core.d.ts

@@ -0,0 +1,10 @@
+import { BuiltinHandler, FunctionMetadata, ModuleMetadata, ModuleAdapter } from '../index';
+/**
+ * Core module for RobinPath
+ * Provides core built-in functions like log, obj, array, tag, range, etc.
+ */
+export declare const CoreFunctions: Record<string, BuiltinHandler>;
+export declare const CoreFunctionMetadata: Record<string, FunctionMetadata>;
+export declare const CoreModuleMetadata: ModuleMetadata;
+declare const CoreModule: ModuleAdapter;
+export default CoreModule;

package/dist/modules/Dom.d.ts

@@ -0,0 +1,10 @@
+import { BuiltinHandler, FunctionMetadata, ModuleMetadata, ModuleAdapter } from '../index';
+/**
+ * Dom module for RobinPath
+ * Provides DOM manipulation and event handling operations
+ */
+export declare const DomFunctions: Record<string, BuiltinHandler>;
+export declare const DomFunctionMetadata: Record<string, FunctionMetadata>;
+export declare const DomModuleMetadata: ModuleMetadata;
+declare const DomModule: ModuleAdapter;
+export default DomModule;

package/dist/modules/Fetch.d.ts

@@ -0,0 +1,6 @@
+import { BuiltinHandler, FunctionMetadata, ModuleMetadata, ModuleAdapter } from '../index';
+export declare const FetchFunctions: Record<string, BuiltinHandler>;
+export declare const FetchFunctionMetadata: Record<string, FunctionMetadata>;
+export declare const FetchModuleMetadata: ModuleMetadata;
+declare const FetchModule: ModuleAdapter;
+export default FetchModule;

package/dist/modules/Json.d.ts

@@ -0,0 +1,10 @@
+import { BuiltinHandler, FunctionMetadata, ModuleMetadata, ModuleAdapter } from '../index';
+/**
+ * JSON module for RobinPath
+ * Provides JSON parsing, stringification, and manipulation operations
+ */
+export declare const JsonFunctions: Record<string, BuiltinHandler>;
+export declare const JsonFunctionMetadata: Record<string, FunctionMetadata>;
+export declare const JsonModuleMetadata: ModuleMetadata;
+declare const JsonModule: ModuleAdapter;
+export default JsonModule;

package/dist/modules/Math.d.ts

@@ -0,0 +1,10 @@
+import { BuiltinHandler, FunctionMetadata, ModuleMetadata, ModuleAdapter } from '../index';
+/**
+ * Math module for RobinPath
+ * Provides mathematical operations and functions
+ */
+export declare const MathFunctions: Record<string, BuiltinHandler>;
+export declare const MathFunctionMetadata: Record<string, FunctionMetadata>;
+export declare const MathModuleMetadata: ModuleMetadata;
+declare const MathModule: ModuleAdapter;
+export default MathModule;

package/dist/modules/Object.d.ts

@@ -0,0 +1,10 @@
+import { BuiltinHandler, FunctionMetadata, ModuleMetadata, ModuleAdapter } from '../index';
+/**
+ * Object module for RobinPath
+ * Provides object manipulation operations (get, set, keys, values, entries, merge, clone)
+ */
+export declare const ObjectFunctions: Record<string, BuiltinHandler>;
+export declare const ObjectFunctionMetadata: Record<string, FunctionMetadata>;
+export declare const ObjectModuleMetadata: ModuleMetadata;
+declare const ObjectModule: ModuleAdapter;
+export default ObjectModule;

package/dist/modules/Random.d.ts

@@ -0,0 +1,6 @@
+import { BuiltinHandler, FunctionMetadata, ModuleMetadata, ModuleAdapter } from '../index';
+export declare const RandomFunctions: Record<string, BuiltinHandler>;
+export declare const RandomFunctionMetadata: Record<string, FunctionMetadata>;
+export declare const RandomModuleMetadata: ModuleMetadata;
+declare const RandomModule: ModuleAdapter;
+export default RandomModule;

package/dist/modules/String.d.ts

@@ -0,0 +1,10 @@
+import { BuiltinHandler, FunctionMetadata, ModuleMetadata, ModuleAdapter } from '../index';
+/**
+ * String module for RobinPath
+ * Provides string manipulation operations and functions
+ */
+export declare const StringFunctions: Record<string, BuiltinHandler>;
+export declare const StringFunctionMetadata: Record<string, FunctionMetadata>;
+export declare const StringModuleMetadata: ModuleMetadata;
+declare const StringModule: ModuleAdapter;
+export default StringModule;

package/dist/modules/Test.d.ts

@@ -0,0 +1,10 @@
+import { BuiltinHandler, FunctionMetadata, ModuleMetadata, ModuleAdapter } from '../index';
+/**
+ * Test module for RobinPath
+ * Provides testing and assertion functions
+ */
+export declare const TestFunctions: Record<string, BuiltinHandler>;
+export declare const TestFunctionMetadata: Record<string, FunctionMetadata>;
+export declare const TestModuleMetadata: ModuleMetadata;
+declare const TestModule: ModuleAdapter;
+export default TestModule;

package/dist/modules/Time.d.ts

@@ -0,0 +1,10 @@
+import { BuiltinHandler, FunctionMetadata, ModuleMetadata, ModuleAdapter } from '../index';
+/**
+ * Time module for RobinPath
+ * Provides date/time operations and utilities
+ */
+export declare const TimeFunctions: Record<string, BuiltinHandler>;
+export declare const TimeFunctionMetadata: Record<string, FunctionMetadata>;
+export declare const TimeModuleMetadata: ModuleMetadata;
+declare const TimeModule: ModuleAdapter;
+export default TimeModule;

package/dist/parsers/ArrayLiteralParser.d.ts

@@ -0,0 +1,17 @@
+import { TokenStream } from '../classes/TokenStream';
+import { Token } from '../classes/Lexer';
+export interface ArrayLiteralResult {
+    code: string;
+    endToken: Token;
+    startToken: Token;
+}
+export declare class ArrayLiteralParser {
+    /**
+     * Parse an array literal from TokenStream
+     * Expects stream to be positioned at the '[' token
+     *
+     * @param stream - TokenStream positioned at the '[' token
+     * @returns Parsed array literal with code and end token
+     */
+    static parse(stream: TokenStream): ArrayLiteralResult;
+}

package/dist/parsers/AssignmentParser.d.ts

@@ -0,0 +1,37 @@
+import { TokenStream } from '../classes/TokenStream';
+import { Token } from '../classes/Lexer';
+import { Assignment, CodePosition } from '../types/Ast.type';
+export interface AssignmentParserContext {
+    /**
+     * Parse a statement from the stream (for subexpressions)
+     */
+    parseStatement?: (stream: TokenStream) => any;
+    /**
+     * Create code position from tokens
+     */
+    createCodePosition?: (startToken: Token, endToken: Token) => CodePosition;
+}
+export declare class AssignmentParser {
+    /**
+     * Parse a variable assignment statement
+     * Expects stream to be positioned at the variable token
+     *
+     * @param stream - TokenStream positioned at the variable token
+     * @param context - Optional context with helper methods
+     * @returns Assignment AST node
+     */
+    static parse(stream: TokenStream, context?: AssignmentParserContext): Assignment;
+    /**
+     * Parse a simple fallback value (string, number, boolean, null)
+     */
+    private static parseFallbackValue;
+    /**
+     * Parse the value part of an assignment
+     * Returns the assignment data and the end token
+     */
+    /**
+     * Check if there's a binary operator ahead that would indicate we need parseExpression
+     */
+    private static isBinaryOperatorAhead;
+    private static parseAssignmentValue;
+}

package/dist/parsers/BracketParser.d.ts

@@ -0,0 +1,31 @@
+import { TokenStream } from '../classes/TokenStream';
+import { Token } from '../classes/Lexer';
+import { CodePosition, Statement } from '../types/Ast.type';
+export interface BracketParserContext {
+    /**
+     * Parse a statement from the stream
+     */
+    parseStatement: (stream: TokenStream) => Statement | null;
+    /**
+     * Create code position from tokens
+     */
+    createCodePosition: (startToken: Token, endToken: Token) => CodePosition;
+}
+export declare class BracketParser {
+    /**
+     * Parse a parenthesized block from TokenStream
+     * Expects stream to be positioned at the '(' token
+     * Syntax: ( ... )
+     *
+     * @param stream - TokenStream positioned at the '(' token
+     * @param context - Context with helper methods
+     * @returns Array of statements inside the parentheses
+     */
+    static parse(stream: TokenStream, context: BracketParserContext): Statement[];
+    /**
+     * Check if the current token is the start of a bracket
+     * @param stream - TokenStream to check
+     * @returns true if current token is LPAREN
+     */
+    static isBracket(stream: TokenStream): boolean;
+}

package/dist/parsers/BreakParser.d.ts

@@ -0,0 +1,15 @@
+import { TokenStream } from '../classes/TokenStream';
+import { Token } from '../classes/Lexer';
+import { BreakStatement, CodePosition } from '../types/Ast.type';
+export interface BreakParserContext {
+    createCodePosition: (start: Token, end: Token) => CodePosition;
+}
+/**
+ * Parse a break statement
+ * Syntax: break [comment]
+ *
+ * @param stream - TokenStream positioned at the 'break' keyword
+ * @param context - Context with helper methods
+ * @returns Parsed BreakStatement
+ */
+export declare function parseBreak(stream: TokenStream, context: BreakParserContext): BreakStatement;

package/dist/parsers/CellBlockParser.d.ts

@@ -0,0 +1,11 @@
+import { TokenStream } from '../classes/TokenStream';
+import { CellBlock } from '../types/Ast.type';
+/**
+ * Parse a cell block from the current position
+ *
+ * @param stream - Token stream positioned at the cell open fence
+ * @param source - Full source code string
+ * @param parseStatement - Function to parse statements (for code cells)
+ * @returns CellBlock if parsed, null otherwise
+ */
+export declare function parseCellBlock(stream: TokenStream, source: string, _parseStatement: (stream: TokenStream) => any): Promise<CellBlock | null>;

package/dist/parsers/ChunkMarkerParser.d.ts

@@ -0,0 +1,12 @@
+import { TokenStream } from '../classes/TokenStream';
+import { ChunkMarkerStatement } from '../types/Ast.type';
+/**
+ * Parse a chunk marker from the current line
+ *
+ * Syntax: --- chunk:<id> [key:value ...] ---
+ *
+ * @param stream - Token stream positioned at the start of a potential chunk marker
+ * @param source - Full source code string for extracting raw line
+ * @returns ChunkMarkerStatement if parsed, null otherwise
+ */
+export declare function parseChunkMarker(stream: TokenStream, source: string): ChunkMarkerStatement | null;

package/dist/parsers/CommandParser.d.ts

@@ -0,0 +1,56 @@
+import { TokenStream } from '../classes/TokenStream';
+import { Token } from '../classes/Lexer';
+import { CommandCall, Arg, ScopeBlock, CodePosition } from '../types/Ast.type';
+export interface CommandParserContext {
+    /**
+     * Parse a statement from the stream (for callback blocks)
+     */
+    parseStatement?: (stream: TokenStream) => any;
+    /**
+     * Parse a scope block (do/enddo)
+     */
+    parseScope?: (stream: TokenStream) => ScopeBlock;
+    /**
+     * Create code position from tokens
+     */
+    createCodePosition?: (startToken: Token, endToken: Token) => CodePosition;
+}
+export declare class CommandParser {
+    /**
+     * Parse a command call from TokenStream
+     * Expects stream to be positioned at the command name (identifier or keyword)
+     *
+     * @param stream - TokenStream positioned at the command name
+     * @param context - Optional context for parsing callbacks and creating code positions
+     * @returns Parsed CommandCall
+     */
+    static parse(stream: TokenStream, context?: CommandParserContext): CommandCall;
+    /**
+     * Parse command name (handles module.function syntax)
+     */
+    private static parseCommandName;
+    /**
+     * Parse parenthesized function call: command(...)
+     */
+    private static parseParenthesizedCall;
+    /**
+     * Parse space-separated function call: command arg1 arg2
+     */
+    private static parseSpaceSeparatedCall;
+    /**
+     * Parse a single argument (positional or named)
+     */
+    private static parseArgument;
+    /**
+     * Parse an argument value (handles literals, variables, subexpressions, objects, arrays)
+     */
+    static parseArgumentValue(stream: TokenStream, context?: CommandParserContext): Arg | null;
+    /**
+     * Parse "into $var" syntax
+     */
+    private static parseInto;
+    /**
+     * Parse callback block (with only)
+     */
+    private static parseCallback;
+}

package/dist/parsers/CommentParser.d.ts

@@ -0,0 +1,37 @@
+import { TokenStream } from '../classes/TokenStream';
+import { CommentWithPosition, CommentStatement, Statement } from '../types/Ast.type';
+export declare class CommentParser {
+    /**
+     * Parse comments from the stream and determine if they should be attached to the next statement
+     * or kept as a standalone comment node
+     *
+     * Strategy:
+     * 1. Collect all consecutive comments
+     * 2. After comments, if we hit a newline, check if next token is also newline (blank line)
+     * 3. If blank line -> create standalone comment node
+     * 4. Otherwise -> return comments to attach to next statement
+     *
+     * @param stream - TokenStream positioned at a COMMENT token
+     * @returns Object with:
+     *   - comments: Array of CommentWithPosition for comments to attach
+     *   - commentNode: CommentStatement if comments should be standalone (orphaned)
+     *   - consumed: Whether comments were consumed from the stream
+     */
+    static parseComments(stream: TokenStream): {
+        comments: CommentWithPosition[];
+        commentNode: CommentStatement | null;
+        consumed: boolean;
+    };
+    /**
+     * Parse inline comment from the stream (comment on same line as code)
+     *
+     * @param stream - TokenStream positioned at a COMMENT token
+     * @param statementLine - Line number of the statement (0-based)
+     * @returns CommentWithPosition if inline comment found, null otherwise
+     */
+    static parseInlineComment(stream: TokenStream, statementLine: number): CommentWithPosition | null;
+    /**
+     * Attach comments to a statement
+     */
+    static attachComments(statement: Statement, comments: CommentWithPosition[]): void;
+}

package/dist/parsers/ContinueParser.d.ts

@@ -0,0 +1,15 @@
+import { TokenStream } from '../classes/TokenStream';
+import { Token } from '../classes/Lexer';
+import { ContinueStatement, CodePosition } from '../types/Ast.type';
+export interface ContinueParserContext {
+    createCodePosition: (start: Token, end: Token) => CodePosition;
+}
+/**
+ * Parse a continue statement
+ * Syntax: continue [comment]
+ *
+ * @param stream - TokenStream positioned at the 'continue' keyword
+ * @param context - Context with helper methods
+ * @returns Parsed ContinueStatement
+ */
+export declare function parseContinue(stream: TokenStream, context: ContinueParserContext): ContinueStatement;

package/dist/parsers/DecoratorParser.d.ts

@@ -0,0 +1,29 @@
+import { TokenStream } from '../classes/TokenStream';
+import { Token } from '../classes/Lexer';
+import { DecoratorCall } from '../types/Ast.type';
+export interface DecoratorParserContext {
+    parseStatement: (stream: TokenStream) => any;
+    parseComment: (stream: TokenStream) => any;
+}
+/**
+ * Parse a decorator call
+ * Expects stream to be positioned at the '@' decorator token
+ *
+ * @param stream - TokenStream positioned at the decorator token
+ * @param context - Context with helper methods
+ * @returns Parsed DecoratorCall or null if not a decorator
+ */
+export declare function parseDecorator(stream: TokenStream, context: DecoratorParserContext): DecoratorCall | null;
+/**
+ * Parse multiple decorators that appear before a statement
+ * Decorators must be on consecutive lines (or same line) before the target statement
+ *
+ * @param stream - TokenStream positioned at the first decorator (or the statement if no decorators)
+ * @param context - Context with helper methods
+ * @returns Array of parsed decorators, the position after the last decorator, and the next token
+ */
+export declare function parseDecorators(stream: TokenStream, context: DecoratorParserContext): {
+    decorators: DecoratorCall[];
+    positionAfter: number;
+    nextToken: Token | null;
+};

package/dist/parsers/DefineParser.d.ts

@@ -0,0 +1,18 @@
+import { TokenStream } from '../classes/TokenStream';
+import { Statement, DefineFunction, DecoratorCall } from '../types/Ast.type';
+import { Environment } from '../index';
+export declare class DefineParser {
+    /**
+     * Parse a 'def' function definition block
+     * Expects stream to be positioned at the 'def' keyword
+     *
+     * @param stream - TokenStream positioned at the 'def' keyword
+     * @param parseStatement - Callback to parse a statement from the stream
+     * @param parseComment - Callback to parse a comment from the stream
+     * @param decorators - Optional decorators to attach to this function
+     * @param environment - Optional environment for executing parse decorators
+     * @returns Parsed DefineFunction
+     */
+    static parse(stream: TokenStream, parseStatement: (stream: TokenStream) => Statement | null, _parseComment: (stream: TokenStream) => Statement | null, // eslint-disable-line @typescript-eslint/no-unused-vars
+    decorators?: DecoratorCall[], environment?: Environment | null): Promise<DefineFunction>;
+}

package/dist/parsers/EventParser.d.ts

@@ -0,0 +1,17 @@
+import { TokenStream } from '../classes/TokenStream';
+import { Statement, OnBlock, DecoratorCall } from '../types/Ast.type';
+import { Environment } from '../index';
+export declare class EventParser {
+    /**
+     * Parse an 'on' event handler block
+     * Expects stream to be positioned at the 'on' keyword
+     *
+     * @param stream - TokenStream positioned at the 'on' keyword
+     * @param parseStatement - Callback to parse a statement from the stream
+     * @param parseComment - Callback to parse a comment from the stream
+     * @param decorators - Optional decorators to attach to this event handler
+     * @param environment - Optional environment for executing parse decorators
+     * @returns Parsed OnBlock
+     */
+    static parse(stream: TokenStream, parseStatement: (stream: TokenStream) => Statement | null, parseComment: (stream: TokenStream) => Statement | null, decorators?: DecoratorCall[], environment?: Environment | null): Promise<OnBlock>;
+}

package/dist/parsers/ExpressionParser.d.ts

@@ -0,0 +1,3 @@
+import { TokenStream } from '../classes/TokenStream';
+import { Expression, Statement } from '../types/Ast.type';
+export declare function parseExpression(stream: TokenStream, parseStatement?: (stream: TokenStream) => Statement | null, parseComment?: (stream: TokenStream) => Statement | null): Expression;

package/dist/parsers/FenceClassifier.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Fence Classifier - Classifies fence lines with priority order
+ *
+ * Priority order (to avoid ambiguity):
+ * 1. ---cell ...--- (cell open)
+ * 2. ---end--- (cell close)
+ * 3. --- chunk:... --- (chunk marker)
+ * 4. bare --- (prompt fence open/close)
+ */
+export type FenceClassification = {
+    kind: 'cell_open';
+    cellType: string;
+    meta: Record<string, string>;
+} | {
+    kind: 'cell_end';
+} | {
+    kind: 'chunk_marker';
+    id: string;
+    meta: Record<string, string>;
+} | {
+    kind: 'prompt_fence';
+} | null;
+/**
+ * Classify a fence line according to priority order
+ *
+ * @param line - Raw line string to classify
+ * @returns Classification result or null if not a fence line
+ */
+export declare function classifyFenceLine(line: string): FenceClassification;

package/dist/parsers/ForLoopParser.d.ts

@@ -0,0 +1,17 @@
+import { TokenStream } from '../classes/TokenStream';
+import { Token } from '../classes/Lexer';
+import { ForLoop, Statement, CodePosition, DecoratorCall } from '../types/Ast.type';
+export interface ForLoopParserContext {
+    parseStatement: (stream: TokenStream) => Statement | null;
+    parseComment: (stream: TokenStream) => Statement | null;
+    createCodePosition: (start: Token, end: Token) => CodePosition;
+}
+/**
+ * Parse a 'for' loop from TokenStream
+ *
+ * @param stream - TokenStream positioned at the 'for' keyword
+ * @param context - Context with helper methods
+ * @param decorators - Optional decorators to attach to this for loop
+ * @returns Parsed ForLoop
+ */
+export declare function parseForLoop(stream: TokenStream, context: ForLoopParserContext, decorators?: DecoratorCall[]): ForLoop;

package/dist/parsers/IfBlockParser.d.ts

@@ -0,0 +1,17 @@
+import { TokenStream } from '../classes/TokenStream';
+import { Token } from '../classes/Lexer';
+import { IfBlock, InlineIf, Statement, CodePosition, DecoratorCall } from '../types/Ast.type';
+export interface IfBlockParserContext {
+    parseStatement: (stream: TokenStream) => Statement | null;
+    parseComment: (stream: TokenStream) => Statement | null;
+    createCodePosition: (start: Token, end: Token) => CodePosition;
+}
+/**
+ * Parse an if statement (either inline or block)
+ *
+ * @param stream - TokenStream positioned at the 'if' keyword
+ * @param context - Context with helper methods
+ * @param decorators - Optional decorators to attach to this if block
+ * @returns Parsed IfBlock or InlineIf
+ */
+export declare function parseIf(stream: TokenStream, context: IfBlockParserContext, decorators?: DecoratorCall[]): IfBlock | InlineIf;

package/dist/parsers/ObjectLiteralParser.d.ts

@@ -0,0 +1,17 @@
+import { TokenStream } from '../classes/TokenStream';
+import { Token } from '../classes/Lexer';
+export interface ObjectLiteralResult {
+    code: string;
+    endToken: Token;
+    startToken: Token;
+}
+export declare class ObjectLiteralParser {
+    /**
+     * Parse an object literal from TokenStream
+     * Expects stream to be positioned at the '{' token
+     *
+     * @param stream - TokenStream positioned at the '{' token
+     * @returns Parsed object literal with code and end token
+     */
+    static parse(stream: TokenStream): ObjectLiteralResult;
+}

package/dist/parsers/ParserUtils.d.ts

@@ -0,0 +1,15 @@
+import { Token } from '../classes/Lexer';
+import { CodePosition } from '../types/Ast.type';
+import { TokenStream } from '../classes/TokenStream';
+/**
+ * Create CodePosition from start and end tokens
+ * @param startToken - The token where the node starts
+ * @param endToken - The token where the node ends
+ * @returns 0-indexed CodePosition
+ */
+export declare function createCodePosition(startToken: Token, endToken: Token): CodePosition;
+/**
+ * Skip whitespace and comments on the current line
+ * @param stream - TokenStream to skip in
+ */
+export declare function skipWhitespaceOnLine(stream: TokenStream): void;

package/dist/parsers/PromptBlockParser.d.ts

@@ -0,0 +1,10 @@
+import { TokenStream } from '../classes/TokenStream';
+import { PromptBlockStatement } from '../types/Ast.type';
+/**
+ * Parse a prompt block from the current position
+ *
+ * @param stream - Token stream positioned at the opening prompt fence
+ * @param source - Full source code string
+ * @returns PromptBlockStatement if parsed, null otherwise
+ */
+export declare function parsePromptBlock(stream: TokenStream, source: string): PromptBlockStatement | null;

package/dist/parsers/ReturnParser.d.ts

@@ -0,0 +1,16 @@
+import { TokenStream } from '../classes/TokenStream';
+import { Token } from '../classes/Lexer';
+import { ReturnStatement, CodePosition, Statement } from '../types/Ast.type';
+export interface ReturnParserContext {
+    createCodePosition: (start: Token, end: Token) => CodePosition;
+    parseStatement?: (stream: TokenStream) => Statement | null;
+}
+/**
+ * Parse a return statement
+ * Syntax: return [value]
+ *
+ * @param stream - TokenStream positioned at the 'return' keyword
+ * @param context - Context with helper methods
+ * @returns Parsed ReturnStatement
+ */
+export declare function parseReturn(stream: TokenStream, context: ReturnParserContext): ReturnStatement;

package/dist/parsers/ScopeParser.d.ts

@@ -0,0 +1,24 @@
+import { TokenStream } from '../classes/TokenStream';
+import { ScopeBlock, Statement, DecoratorCall } from '../types/Ast.type';
+export declare class ScopeParser {
+    /**
+     * Maximum number of iterations allowed before detecting an infinite loop
+     */
+    static readonly MAX_STUCK_ITERATIONS = 100;
+    /**
+     * Debug mode flag - set to true to enable logging
+     * Can be controlled via VITE_DEBUG environment variable or set programmatically
+     */
+    static debug: boolean;
+    /**
+     * Parse a 'do' scope block
+     * Expects stream to be positioned at the 'do' keyword
+     *
+     * @param stream - TokenStream positioned at the 'do' keyword
+     * @param parseStatement - Callback to parse a statement from the stream
+     * @param parseComment - Callback to parse a comment from the stream
+     * @param decorators - Optional decorators to attach to this do block
+     * @returns Parsed ScopeBlock
+     */
+    static parse(stream: TokenStream, parseStatement: (stream: TokenStream) => Statement | null, _parseComment: (stream: TokenStream) => Statement | null, decorators?: DecoratorCall[]): ScopeBlock;
+}

package/dist/parsers/StringTemplateParser.d.ts

@@ -0,0 +1,31 @@
+import { Frame } from '../index';
+import { Value } from '../utils/types';
+export interface StringTemplateParserContext {
+    /**
+     * Resolve a variable by name and path
+     */
+    resolveVariable: (name: string, path?: any[], frameOverride?: Frame) => Value;
+    /**
+     * Get the current frame's last value
+     */
+    getLastValue: (frameOverride?: Frame) => Value;
+    /**
+     * Execute a subexpression code string
+     */
+    executeSubexpression: (code: string, frameOverride?: Frame) => Promise<Value>;
+}
+export declare class StringTemplateParser {
+    /**
+     * Evaluate a template string with variable interpolation and subexpressions
+     *
+     * @param template - The template string content (without backticks, already unescaped)
+     * @param context - Context with methods to resolve variables and execute subexpressions
+     * @param frameOverride - Optional frame override for variable resolution
+     * @returns The evaluated string
+     */
+    static evaluate(template: string, context: StringTemplateParserContext, frameOverride?: Frame): Promise<string>;
+    /**
+     * Convert a value to string representation
+     */
+    private static valueToString;
+}