littlewing 1.2.0 → 2.0.0

package/dist/index.d.ts

@@ -1,80 +1,176 @@
 declare namespace exports_ast {
-	export { unaryOp, subtract, program, number, notEquals, negate, multiply, modulo, logicalOr, logicalNot, logicalAnd, lessThan, lessEqual, isUnaryOp, isProgram, isNumberLiteral, isIdentifier, isFunctionCall, isConditionalExpression, isBinaryOp, isAssignment, identifier, greaterThan, greaterEqual, getNodeName, functionCall, exponentiate, equals, divide, conditional, binaryOp, assign, add, UnaryOp, Program, Operator, NumberLiteral, NodeKind, Identifier, FunctionCall, ConditionalExpression, BinaryOp, Assignment, ASTNode };
+	export { unaryOp, subtract, string, rangeExpr, program, number, notEquals, negate, multiply, modulo, logicalOr, logicalNot, logicalAnd, lessThan, lessEqual, isUnaryOp, isStringLiteral, isRangeExpression, isProgram, isNumberLiteral, isIndexAccess, isIfExpression, isIdentifier, isFunctionCall, isForExpression, isBooleanLiteral, isBinaryOp, isAssignment, isArrayLiteral, indexAccess, ifExpr, identifier, greaterThan, greaterEqual, getNodeName, functionCall, forExpr, exponentiate, equals, divide, boolean, binaryOp, assign, array, add, UnaryOp, StringLiteral, RangeExpression, Program, Operator, NumberLiteral, NodeKind, IndexAccess, IfExpression, Identifier2 as Identifier, FunctionCall, ForExpression, BooleanLiteral, BinaryOp, Assignment, ArrayLiteral, ASTNodeBase, ASTNode };
 }
 /**
 * Binary operator types
 */
 type Operator = "+" | "-" | "*" | "/" | "%" | "^" | "==" | "!=" | "<" | ">" | "<=" | ">=" | "&&" | "||";
 /**
+* Base interface for all AST nodes.
+* Optional comment metadata preserved through parse → generate roundtrips.
+*/
+interface ASTNodeBase {
+	readonly leadingComments?: readonly string[];
+	readonly trailingComments?: readonly string[];
+}
+/**
 * AST Node kind discriminator (const enum for zero-cost abstraction)
 */
 declare const enum NodeKind {
 	Program = 0,
 	NumberLiteral = 1,
-	Identifier = 2,
+	Identifier2 = 2,
 	BinaryOp = 3,
 	UnaryOp = 4,
 	FunctionCall = 5,
 	Assignment = 6,
-	ConditionalExpression = 7
+	IfExpression = 7,
+	StringLiteral = 8,
+	BooleanLiteral = 9,
+	ArrayLiteral = 10,
+	ForExpression = 11,
+	IndexAccess = 12,
+	RangeExpression = 13
 }
 /**
 * Program node (multiple statements)
-* Tuple: [kind, statements]
 */
-type Program = readonly [kind: NodeKind.Program, statements: readonly ASTNode[]];
+interface Program extends ASTNodeBase {
+	readonly kind: NodeKind.Program;
+	readonly statements: readonly ASTNode[];
+}
 /**
 * Number literal (123, 45.67)
-* Tuple: [kind, value]
 */
-type NumberLiteral = readonly [kind: NodeKind.NumberLiteral, value: number];
+interface NumberLiteral extends ASTNodeBase {
+	readonly kind: NodeKind.NumberLiteral;
+	readonly value: number;
+}
+/**
+* String literal ("hello")
+*/
+interface StringLiteral extends ASTNodeBase {
+	readonly kind: NodeKind.StringLiteral;
+	readonly value: string;
+}
+/**
+* Boolean literal (true, false)
+*/
+interface BooleanLiteral extends ASTNodeBase {
+	readonly kind: NodeKind.BooleanLiteral;
+	readonly value: boolean;
+}
+/**
+* Array literal ([1, 2, 3])
+*/
+interface ArrayLiteral extends ASTNodeBase {
+	readonly kind: NodeKind.ArrayLiteral;
+	readonly elements: readonly ASTNode[];
+}
 /**
 * Identifier (variable or function name)
-* Tuple: [kind, name]
 */
-type Identifier = readonly [kind: NodeKind.Identifier, name: string];
+interface Identifier2 extends ASTNodeBase {
+	readonly kind: NodeKind.Identifier2;
+	readonly name: string;
+}
 /**
 * Binary operation (a + b, x * y, etc.)
-* Tuple: [kind, left, operator, right]
-* Note: left-to-right reading order
 */
-type BinaryOp = readonly [kind: NodeKind.BinaryOp, left: ASTNode, operator: Operator, right: ASTNode];
+interface BinaryOp extends ASTNodeBase {
+	readonly kind: NodeKind.BinaryOp;
+	readonly left: ASTNode;
+	readonly operator: Operator;
+	readonly right: ASTNode;
+}
 /**
 * Unary operation (-x, !x, etc.)
-* Tuple: [kind, operator, argument]
 */
-type UnaryOp = readonly [kind: NodeKind.UnaryOp, operator: "-" | "!", argument: ASTNode];
+interface UnaryOp extends ASTNodeBase {
+	readonly kind: NodeKind.UnaryOp;
+	readonly operator: "-" | "!";
+	readonly argument: ASTNode;
+}
 /**
 * Function call (NOW(), MAX(a, b), etc.)
-* Tuple: [kind, name, arguments]
 */
-type FunctionCall = readonly [kind: NodeKind.FunctionCall, name: string, arguments: readonly ASTNode[]];
+interface FunctionCall extends ASTNodeBase {
+	readonly kind: NodeKind.FunctionCall;
+	readonly name: string;
+	readonly args: readonly ASTNode[];
+}
 /**
 * Variable assignment (x = 5)
-* Tuple: [kind, name, value]
 */
-type Assignment = readonly [kind: NodeKind.Assignment, name: string, value: ASTNode];
+interface Assignment extends ASTNodeBase {
+	readonly kind: NodeKind.Assignment;
+	readonly name: string;
+	readonly value: ASTNode;
+}
 /**
-* Conditional expression (ternary operator: condition ? consequent : alternate)
-* Returns consequent if condition !== 0, otherwise returns alternate
-* Tuple: [kind, condition, consequent, alternate]
+* If expression (if condition then consequent else alternate)
+* Returns consequent if condition is true, otherwise returns alternate
 */
-type ConditionalExpression = readonly [kind: NodeKind.ConditionalExpression, condition: ASTNode, consequent: ASTNode, alternate: ASTNode];
+interface IfExpression extends ASTNodeBase {
+	readonly kind: NodeKind.IfExpression;
+	readonly condition: ASTNode;
+	readonly consequent: ASTNode;
+	readonly alternate: ASTNode;
+}
+/**
+* For expression (for variable in iterable [when guard] [into name = init] then body)
+* Without `into`: maps over an array or string, optionally filtering with a guard
+* With `into`: reduces/folds into a single value using an accumulator
+*/
+interface ForExpression extends ASTNodeBase {
+	readonly kind: NodeKind.ForExpression;
+	readonly variable: string;
+	readonly iterable: ASTNode;
+	readonly guard: ASTNode | null;
+	readonly accumulator: {
+		readonly name: string;
+		readonly initial: ASTNode;
+	} | null;
+	readonly body: ASTNode;
+}
+/**
+* Index access (arr[0], str[1])
+*/
+interface IndexAccess extends ASTNodeBase {
+	readonly kind: NodeKind.IndexAccess;
+	readonly object: ASTNode;
+	readonly index: ASTNode;
+}
+/**
+* Range expression (1..5, 1..=5)
+*/
+interface RangeExpression extends ASTNodeBase {
+	readonly kind: NodeKind.RangeExpression;
+	readonly start: ASTNode;
+	readonly end: ASTNode;
+	readonly inclusive: boolean;
+}
 /**
 * AST Node - discriminated union of all node types
 */
-type ASTNode = Program | NumberLiteral | Identifier | BinaryOp | UnaryOp | FunctionCall | Assignment | ConditionalExpression;
+type ASTNode = Program | NumberLiteral | StringLiteral | BooleanLiteral | ArrayLiteral | Identifier2 | BinaryOp | UnaryOp | FunctionCall | Assignment | IfExpression | ForExpression | IndexAccess | RangeExpression;
 /**
 * Type guard functions for discriminated union narrowing
 */
 declare function isProgram(node: ASTNode): node is Program;
 declare function isNumberLiteral(node: ASTNode): node is NumberLiteral;
-declare function isIdentifier(node: ASTNode): node is Identifier;
+declare function isStringLiteral(node: ASTNode): node is StringLiteral;
+declare function isBooleanLiteral(node: ASTNode): node is BooleanLiteral;
+declare function isArrayLiteral(node: ASTNode): node is ArrayLiteral;
+declare function isIdentifier(node: ASTNode): node is Identifier2;
 declare function isBinaryOp(node: ASTNode): node is BinaryOp;
 declare function isUnaryOp(node: ASTNode): node is UnaryOp;
 declare function isFunctionCall(node: ASTNode): node is FunctionCall;
 declare function isAssignment(node: ASTNode): node is Assignment;
-declare function isConditionalExpression(node: ASTNode): node is ConditionalExpression;
+declare function isIfExpression(node: ASTNode): node is IfExpression;
+declare function isForExpression(node: ASTNode): node is ForExpression;
+declare function isIndexAccess(node: ASTNode): node is IndexAccess;
+declare function isRangeExpression(node: ASTNode): node is RangeExpression;
 /**
 * Builder functions for creating AST nodes manually
 */
@@ -87,9 +183,21 @@ declare function program(statements: readonly ASTNode[]): Program;
 */
 declare function number(value: number): NumberLiteral;
 /**
+* Create a string literal node
+*/
+declare function string(value: string): StringLiteral;
+/**
+* Create a boolean literal node
+*/
+declare function boolean(value: boolean): BooleanLiteral;
+/**
+* Create an array literal node
+*/
+declare function array(elements: readonly ASTNode[]): ArrayLiteral;
+/**
 * Create an identifier node
 */
-declare function identifier(name: string): Identifier;
+declare function identifier(name: string): Identifier2;
 /**
 * Create a binary operation node
 */
@@ -107,81 +215,42 @@ declare function functionCall(name: string, args?: readonly ASTNode[]): Function
 */
 declare function assign(name: string, value: ASTNode): Assignment;
 /**
-* Create a conditional expression node (ternary operator)
+* Create an if expression node (if condition then consequent else alternate)
 */
-declare function conditional(condition: ASTNode, consequent: ASTNode, alternate: ASTNode): ConditionalExpression;
+declare function ifExpr(condition: ASTNode, consequent: ASTNode, alternate: ASTNode): IfExpression;
 /**
-* Convenience functions for common operations
+* Create a for expression node (for variable in iterable [when guard] [into name = init] then body)
 */
+declare function forExpr(variable: string, iterable: ASTNode, guard: ASTNode | null, accumulator: {
+	readonly name: string;
+	readonly initial: ASTNode;
+} | null, body: ASTNode): ForExpression;
 /**
-* Create an addition operation
+* Create an index access node (arr[0], str[1])
 */
-declare function add(left: ASTNode, right: ASTNode): BinaryOp;
+declare function indexAccess(object: ASTNode, index: ASTNode): IndexAccess;
 /**
-* Create a subtraction operation
+* Create a range expression node (1..5, 1..=5)
 */
-declare function subtract(left: ASTNode, right: ASTNode): BinaryOp;
+declare function rangeExpr(start: ASTNode, end: ASTNode, inclusive: boolean): RangeExpression;
 /**
-* Create a multiplication operation
+* Convenience functions for common operations
 */
+declare function add(left: ASTNode, right: ASTNode): BinaryOp;
+declare function subtract(left: ASTNode, right: ASTNode): BinaryOp;
 declare function multiply(left: ASTNode, right: ASTNode): BinaryOp;
-/**
-* Create a division operation
-*/
 declare function divide(left: ASTNode, right: ASTNode): BinaryOp;
-/**
-* Create a modulo operation
-*/
 declare function modulo(left: ASTNode, right: ASTNode): BinaryOp;
-/**
-* Create an exponentiation operation
-*/
 declare function exponentiate(left: ASTNode, right: ASTNode): BinaryOp;
-/**
-* Create a negation operation
-*/
 declare function negate(argument: ASTNode): UnaryOp;
-/**
-* Create a logical NOT operation
-*/
 declare function logicalNot(argument: ASTNode): UnaryOp;
-/**
-* Comparison operator convenience functions
-*/
-/**
-* Create an equality comparison (==)
-*/
 declare function equals(left: ASTNode, right: ASTNode): BinaryOp;
-/**
-* Create a not-equals comparison (!=)
-*/
 declare function notEquals(left: ASTNode, right: ASTNode): BinaryOp;
-/**
-* Create a less-than comparison (<)
-*/
 declare function lessThan(left: ASTNode, right: ASTNode): BinaryOp;
-/**
-* Create a greater-than comparison (>)
-*/
 declare function greaterThan(left: ASTNode, right: ASTNode): BinaryOp;
-/**
-* Create a less-than-or-equal comparison (<=)
-*/
 declare function lessEqual(left: ASTNode, right: ASTNode): BinaryOp;
-/**
-* Create a greater-than-or-equal comparison (>=)
-*/
 declare function greaterEqual(left: ASTNode, right: ASTNode): BinaryOp;
-/**
-* Logical operator convenience functions
-*/
-/**
-* Create a logical AND operation (&&)
-*/
 declare function logicalAnd(left: ASTNode, right: ASTNode): BinaryOp;
-/**
-* Create a logical OR operation (||)
-*/
 declare function logicalOr(left: ASTNode, right: ASTNode): BinaryOp;
 declare function getNodeName(node: ASTNode): string;
 /**
@@ -207,80 +276,33 @@ declare function getNodeName(node: ASTNode): string;
 */
 declare function extractInputVariables(ast: ASTNode): string[];
 /**
-* Generate source code from an AST node
-*/
-declare function generate(node: ASTNode): string;
-/**
-* Options for customizing the humanization output
-*/
-interface HumanizeOptions {
-	/**
-	* Enable HTML output with wrapper tags
-	* @default false
-	*/
-	html?: boolean;
-	/**
-	* CSS classes to apply to different node types when html is true
-	*/
-	htmlClasses?: {
-		number?: string;
-		identifier?: string;
-		operator?: string;
-		function?: string;
-	};
-	/**
-	* Custom phrases for function names
-	* Maps function name to human-readable phrase
-	* Example: { 'MAX': 'the maximum of', 'CUSTOM': 'my custom function with' }
-	*/
-	functionPhrases?: Record<string, string>;
-	/**
-	* Custom phrases for operators
-	* Overrides default operator text
-	*/
-	operatorPhrases?: Partial<Record<Operator, string>>;
-	/**
-	* Use more verbose, descriptive phrasing
-	* @default false
-	*/
-	verbose?: boolean;
-}
-/**
-* Humanize an AST node into human-readable English text
+* Extracts the names of all assigned variables from an AST.
 *
-* @param node - The AST node to humanize
-* @param options - Optional configuration for the output
-* @returns Human-readable English text
+* Walks the AST and collects the left-hand side name from every
+* `Assignment` node. Returns deduplicated names in definition order.
 *
-* @example
-* ```typescript
-* const ast = parse('price * quantity > 100 ? (price * quantity - discount) * (1 + tax_rate) : MAX(price * quantity, 50)')
-* const text = humanize(ast)
-* // "if price times quantity is greater than 100 then (price times quantity minus discount) times (1 plus tax_rate), otherwise the maximum of price times quantity and 50"
-* ```
+* @param ast - The AST to analyze (can be a single statement or Program node)
+* @returns Array of assigned variable names in definition order
 *
 * @example
 * ```typescript
-* // With HTML formatting
-* const text = humanize(ast, {
-*   html: true,
-*   htmlClasses: {
-*     identifier: 'variable',
-*     operator: 'op',
-*     number: 'num'
-*   }
-* })
+* const node = parse('totalTime = hours * 60; hoursRecovered = saved / 60')
+* extractAssignedVariables(node) // ['totalTime', 'hoursRecovered']
 * ```
 */
-declare function humanize(node: ASTNode, options?: HumanizeOptions): string;
+declare function extractAssignedVariables(ast: ASTNode): string[];
+/**
+* Generate source code from an AST node
+*/
+declare function generate(node: ASTNode): string;
 /**
-* Runtime value type - only numbers
+* Runtime value type - numbers, strings, booleans, dates, times, datetimes, and homogeneous arrays
 */
-type RuntimeValue = number;
+type RuntimeValue = number | string | boolean | Temporal.PlainDate | Temporal.PlainTime | Temporal.PlainDateTime | readonly RuntimeValue[];
 /**
 * Execution context providing global functions and variables
-* Functions must accept zero or more number arguments and return a number
-* Variables must be numbers
+* Functions accept zero or more RuntimeValue arguments and return a RuntimeValue
+* Variables can be any RuntimeValue
 */
 interface ExecutionContext {
 	functions?: Record<string, (...args: RuntimeValue[]) => RuntimeValue>;
@@ -288,306 +310,251 @@ interface ExecutionContext {
 }
 /**
 * Evaluate source code or AST with given context
-* @param input - Either a source code string or an AST node
-* @param context - Optional execution context with variables and functions
-* @returns The evaluated result
 */
 declare function evaluate(input: string | ASTNode, context?: ExecutionContext): RuntimeValue;
 /**
-* Compiled expression that can be executed multiple times
-* Provides faster repeated execution compared to tree-walk interpreter
-*/
-interface CompiledExpression {
-	/**
-	* Execute the compiled expression with optional context
-	* @param context - Execution context with variables and functions
-	* @returns The evaluated result
-	*/
-	execute: (context?: ExecutionContext) => RuntimeValue;
-	/**
-	* Generated JavaScript source code (for debugging and inspection)
-	*/
-	source: string;
-}
-/**
-* Compile source code or AST to a JavaScript function for faster repeated execution
-*
-* JIT compilation trades compilation time for execution speed:
-* - First call: Parse + Optimize + Compile (~10-50µs depending on size)
-* - Subsequent calls: Direct JavaScript execution (~1-5µs, 5-10x faster)
-*
-* The compiler automatically optimizes the AST before code generation:
-* - Constant folding: `2 + 3` → `5` (safe constants only)
-* - Dead code elimination: removes unused variable assignments
-* - Expression simplification: `1 ? x : y` → `x`
-*
-* Optimization is safe because:
-* - Constant folding errors (e.g., division by zero) propagate to compile-time
-* - Variables that could be external are preserved (no unsafe DCE)
-* - The optimizer respects ExecutionContext override semantics
-*
-* The compiler generates optimized JavaScript code:
-* - Uses comma operator instead of IIFEs for better performance
-* - Only initializes variables that are actually used
-* - Pre-declares temporary variables for reuse
-*
-* Best for expressions that are evaluated many times with different contexts.
-*
-* Security: Uses `new Function()` to generate executable code. Safe for trusted
-* input only. For untrusted input, use the tree-walk interpreter instead.
-*
-* @param input - Either a source code string or an AST node
-* @returns Compiled expression that can be executed multiple times
-* @throws {Error} If compilation fails or AST contains invalid operations (e.g., constant division by zero)
-*
-* @example
-* ```typescript
-* const expr = compile('x * 2 + y')
-* expr.execute({ variables: { x: 10, y: 5 } }) // 25
-* expr.execute({ variables: { x: 20, y: 3 } }) // 43
-* ```
-*
-* @example Automatic optimization
-* ```typescript
-* const expr = compile('2 + 3 * 4')  // Automatically optimized to 14
-* expr.execute() // Fast execution of pre-folded constant
-* ```
+* Evaluate source code or AST and return the full variable scope.
 */
-declare function compile(input: string | ASTNode): CompiledExpression;
+declare function evaluateScope(input: string | ASTNode, context?: ExecutionContext): Record<string, RuntimeValue>;
 /**
-* Optimize an AST using constant folding, expression simplification, and dead code elimination.
+* Optimize an AST using constant folding, constant propagation, and dead code elimination.
 *
-* This optimizer performs SAFE optimizations that preserve program semantics:
-* - Constant folding: Evaluates arithmetic with literal operands at compile-time
-* - Function argument pre-evaluation: Simplifies expressions passed to functions
-* - Conditional folding: Evaluates ternary with constant condition
-* - Dead code elimination: Removes unused variable assignments
-*
-* Optimizations that are NOT performed (because they're unsafe with context variables):
-* - Variable propagation: Variables can be overridden by ExecutionContext
-* - Cross-statement analysis: Each statement may affect external state
-*
-* Time complexity: O(n) where n is the number of AST nodes
-* Space complexity: O(d) where d is the max depth (recursion stack)
-*
-* Algorithm properties:
-* - Sound: Preserves program semantics exactly
-* - Safe: No assumptions about variable values
-* - Local: Only optimizes within individual expressions
-*
-* @param node - The AST node to optimize
-* @returns Optimized AST node
+* When `externalVariables` is provided, the optimizer can safely propagate variables
+* that are not in the set — since they cannot be overridden by `ExecutionContext.variables`.
+* Without this parameter, no variables are propagated (backward-compatible behavior).
 */
-declare function optimize(node: ASTNode): ASTNode;
+declare function optimize(node: ASTNode, externalVariables?: ReadonlySet<string>): ASTNode;
 /**
 * Parse source code string into AST
-* Implements Pratt parsing (top-down operator precedence)
-* Uses lazy lexing - calls lexer on-demand instead of receiving all tokens upfront
-*
-* @param source - The source code to parse
-* @returns Parsed AST
 */
 declare function parse(source: string): ASTNode;
-declare namespace exports_datetime {
-	export { START_OF_YEAR, START_OF_WEEK, START_OF_QUARTER, START_OF_MONTH, START_OF_DAY, NOW, IS_WEEKEND, IS_SAME_DAY, IS_LEAP_YEAR, GET_YEAR, GET_WEEKDAY, GET_SECOND, GET_QUARTER, GET_MONTH, GET_MINUTE, GET_MILLISECOND, GET_HOUR, GET_DAY_OF_YEAR, GET_DAY, FROM_YEARS, FROM_WEEKS, FROM_MONTHS, FROM_DAYS, END_OF_YEAR, END_OF_MONTH, END_OF_DAY, DIFFERENCE_IN_YEARS, DIFFERENCE_IN_WEEKS, DIFFERENCE_IN_SECONDS, DIFFERENCE_IN_MONTHS, DIFFERENCE_IN_MINUTES, DIFFERENCE_IN_HOURS, DIFFERENCE_IN_DAYS, DATE, ADD_YEARS, ADD_MONTHS, ADD_DAYS };
+declare namespace array {
+	export { ARR_UNIQUE, ARR_SUM, ARR_SORT, ARR_SLICE, ARR_REVERSE, ARR_PUSH, ARR_MIN, ARR_MAX, ARR_LEN, ARR_JOIN, ARR_FLAT, ARR_CONTAINS };
 }
 /**
-* Date utility functions for working with timestamps
-* All functions work with milliseconds since Unix epoch (numbers only)
-*
-* IMPORTANT: All functions use local timezone to match the user's context.
-* In a browser, this reflects the user's timezone. On a server, this reflects
-* the server's configured timezone. This ensures date calculations align with
-* the user's calendar expectations.
+* Get the length of an array
 */
+declare const ARR_LEN: (a: RuntimeValue) => RuntimeValue;
 /**
-* Get current timestamp (milliseconds since Unix epoch)
+* Append a value to an array, returning a new array
+* Validates homogeneity
 */
-declare const NOW: () => RuntimeValue;
+declare const ARR_PUSH: (a: RuntimeValue, value: RuntimeValue) => RuntimeValue;
 /**
-* Create timestamp from date components (local timezone)
-* Year is required, all other parameters default to minimum values
-* Month is 1-based (1 = January, 12 = December)
-* All parameters are interpreted in local timezone
+* Extract a section of an array (0-based indices)
 */
-declare const DATE: (year: RuntimeValue, month?: number, day?: number, hour?: number, minute?: number, second?: number) => RuntimeValue;
+declare const ARR_SLICE: (a: RuntimeValue, start: RuntimeValue, end?: RuntimeValue) => RuntimeValue;
 /**
-* Convert days to milliseconds
+* Check if an array contains a value (using deep equality)
+* Returns boolean
 */
-declare const FROM_DAYS: (d: RuntimeValue) => RuntimeValue;
+declare const ARR_CONTAINS: (a: RuntimeValue, value: RuntimeValue) => RuntimeValue;
 /**
-* Convert weeks to milliseconds
+* Reverse an array, returning a new array
 */
-declare const FROM_WEEKS: (w: RuntimeValue) => RuntimeValue;
+declare const ARR_REVERSE: (a: RuntimeValue) => RuntimeValue;
 /**
-* Convert months to milliseconds (approximate: 30 days per month)
-* WARNING: This is an approximation. Not all months have 30 days.
-* For accurate month arithmetic, use ADD_MONTHS() instead.
+* Sort an array in ascending order, returning a new array.
+* Numbers sort numerically, strings lexicographically,
+* dates/times/datetimes by temporal comparison.
+* All elements must be the same type.
 */
-declare const FROM_MONTHS: (months: RuntimeValue) => RuntimeValue;
+declare const ARR_SORT: (a: RuntimeValue) => RuntimeValue;
 /**
-* Convert years to milliseconds (approximate: 365 days per year)
-* WARNING: This is an approximation. Leap years have 366 days.
-* For accurate year arithmetic, use ADD_YEARS() instead.
+* Remove duplicate elements using deep equality, preserving first occurrence order.
 */
-declare const FROM_YEARS: (years: RuntimeValue) => RuntimeValue;
+declare const ARR_UNIQUE: (a: RuntimeValue) => RuntimeValue;
 /**
-* Get the year from a timestamp (local timezone)
+* Flatten one level of nested arrays.
+* Each element must be an array. Result is validated for homogeneity.
 */
-declare const GET_YEAR: (timestamp: RuntimeValue) => RuntimeValue;
+declare const ARR_FLAT: (a: RuntimeValue) => RuntimeValue;
 /**
-* Get the month from a timestamp (1-based: 1 = January, 12 = December, local timezone)
+* Join a string array with a separator into a single string.
+* All elements must be strings.
 */
-declare const GET_MONTH: (timestamp: RuntimeValue) => RuntimeValue;
+declare const ARR_JOIN: (a: RuntimeValue, sep: RuntimeValue) => RuntimeValue;
 /**
-* Get the day of month from a timestamp (1-31, local timezone)
+* Sum all elements of a numeric array. Empty array returns 0.
 */
-declare const GET_DAY: (timestamp: RuntimeValue) => RuntimeValue;
+declare const ARR_SUM: (a: RuntimeValue) => RuntimeValue;
 /**
-* Get the hour from a timestamp (0-23, local timezone)
+* Get the minimum element of an array.
+* Supports numbers, strings, dates, times, and datetimes.
+* Throws on empty arrays.
 */
-declare const GET_HOUR: (timestamp: RuntimeValue) => RuntimeValue;
+declare const ARR_MIN: (a: RuntimeValue) => RuntimeValue;
 /**
-* Get the minute from a timestamp (0-59, local timezone)
+* Get the maximum element of an array.
+* Supports numbers, strings, dates, times, and datetimes.
+* Throws on empty arrays.
 */
-declare const GET_MINUTE: (timestamp: RuntimeValue) => RuntimeValue;
+declare const ARR_MAX: (a: RuntimeValue) => RuntimeValue;
+declare namespace core {
+	export { TYPE, STR, NUM };
+}
 /**
-* Get the second from a timestamp (0-59, local timezone)
+* Convert a value to string representation
+* Supports numbers, booleans, and dates. Arrays throw TypeError.
 */
-declare const GET_SECOND: (timestamp: RuntimeValue) => RuntimeValue;
+declare const STR: (v: RuntimeValue) => RuntimeValue;
 /**
-* Get the millisecond component from a timestamp (0-999, local timezone)
+* Convert a value to number
+* Supports strings (via Number()) and booleans (true→1, false→0).
+* Dates and arrays throw TypeError.
 */
-declare const GET_MILLISECOND: (timestamp: RuntimeValue) => RuntimeValue;
+declare const NUM: (v: RuntimeValue) => RuntimeValue;
 /**
-* Get the day of week from a timestamp (0 = Sunday, 6 = Saturday, local timezone)
+* Returns the type name of a value as a string
 */
-declare const GET_WEEKDAY: (timestamp: RuntimeValue) => RuntimeValue;
+declare const TYPE: (v: RuntimeValue) => RuntimeValue;
+declare namespace datetime {
+	export { TODAY, START_OF_YEAR, START_OF_WEEK, START_OF_QUARTER, START_OF_MONTH, IS_WEEKEND, IS_SAME_DAY, IS_LEAP_YEAR, GET_YEAR, GET_WEEKDAY, GET_QUARTER, GET_MONTH, GET_DAY_OF_YEAR, GET_DAY, END_OF_YEAR, END_OF_MONTH, DIFFERENCE_IN_YEARS, DIFFERENCE_IN_WEEKS, DIFFERENCE_IN_MONTHS, DIFFERENCE_IN_DAYS, DATE, ADD_YEARS, ADD_MONTHS, ADD_DAYS };
+}
 /**
-* Get the day of year (1-366) from a timestamp (local timezone)
-* January 1st = 1, December 31st = 365 or 366 (leap year)
+* Date utility functions using Temporal.PlainDate and Temporal.PlainDateTime
+* Most functions accept both PlainDate and PlainDateTime, preserving the input type.
+* TODAY() and DATE() remain PlainDate-only constructors.
 */
-declare const GET_DAY_OF_YEAR: (timestamp: RuntimeValue) => RuntimeValue;
 /**
-* Get the quarter (1-4) from a timestamp (local timezone)
+* Get today's date as a Temporal.PlainDate
 */
-declare const GET_QUARTER: (timestamp: RuntimeValue) => RuntimeValue;
+declare const TODAY: () => RuntimeValue;
 /**
-* Get the absolute difference between two timestamps in seconds (whole seconds)
+* Create a date from year, month (1-based), and day
 */
-declare const DIFFERENCE_IN_SECONDS: (ts1: RuntimeValue, ts2: RuntimeValue) => RuntimeValue;
+declare const DATE: (year: RuntimeValue, month: RuntimeValue, day: RuntimeValue) => RuntimeValue;
 /**
-* Get the absolute difference between two timestamps in minutes (whole minutes)
+* Get the year from a date or datetime
 */
-declare const DIFFERENCE_IN_MINUTES: (ts1: RuntimeValue, ts2: RuntimeValue) => RuntimeValue;
+declare const GET_YEAR: (date: RuntimeValue) => RuntimeValue;
 /**
-* Get the absolute difference between two timestamps in hours (whole hours)
+* Get the month from a date or datetime (1-based: 1 = January, 12 = December)
 */
-declare const DIFFERENCE_IN_HOURS: (ts1: RuntimeValue, ts2: RuntimeValue) => RuntimeValue;
+declare const GET_MONTH: (date: RuntimeValue) => RuntimeValue;
 /**
-* Get the difference in calendar days between two timestamps
-* Counts the number of calendar day boundaries crossed, not 24-hour periods
-* Example: Nov 7 at 11:59 PM to Nov 8 at 12:01 AM = 1 day (different calendar days)
+* Get the day of month from a date or datetime (1-31)
 */
-declare const DIFFERENCE_IN_DAYS: (ts1: RuntimeValue, ts2: RuntimeValue) => RuntimeValue;
+declare const GET_DAY: (date: RuntimeValue) => RuntimeValue;
 /**
-* Get the difference in calendar weeks between two timestamps
-* Counts the number of week boundaries crossed (based on calendar days)
+* Get the day of week from a date or datetime (1 = Monday, 7 = Sunday)
 */
-declare const DIFFERENCE_IN_WEEKS: (ts1: RuntimeValue, ts2: RuntimeValue) => RuntimeValue;
+declare const GET_WEEKDAY: (date: RuntimeValue) => RuntimeValue;
 /**
-* Get the number of full calendar months between two timestamps (local timezone)
-* Counts complete months where the same day-of-month has been reached
-*
-* Examples:
-*   Jan 15 → Feb 14 = 0 months (Feb 15 not reached yet)
-*   Jan 15 → Feb 15 = 1 month
-*   Jan 31 → Feb 28 = 0 months (Feb 31 doesn't exist)
-*   Jan 31 → Mar 31 = 2 months
+* Get the day of year (1-366) from a date or datetime
 */
-declare const DIFFERENCE_IN_MONTHS: (ts1: RuntimeValue, ts2: RuntimeValue) => RuntimeValue;
+declare const GET_DAY_OF_YEAR: (date: RuntimeValue) => RuntimeValue;
 /**
-* Get the number of full calendar years between two timestamps (local timezone)
-* Counts complete years where the same month and day have been reached
-*
-* Examples:
-*   Jan 15, 2020 → Jan 14, 2021 = 0 years (Jan 15 not reached)
-*   Jan 15, 2020 → Jan 15, 2021 = 1 year
-*   Feb 29, 2020 → Feb 28, 2021 = 0 years (Feb 29 doesn't exist)
-*   Feb 29, 2020 → Mar 1, 2021 = 1 year
+* Get the quarter (1-4) from a date or datetime
 */
-declare const DIFFERENCE_IN_YEARS: (ts1: RuntimeValue, ts2: RuntimeValue) => RuntimeValue;
+declare const GET_QUARTER: (date: RuntimeValue) => RuntimeValue;
 /**
-* Get the start of day (00:00:00.000 local time) for a given timestamp
+* Add days to a date or datetime, returning the same type
 */
-declare const START_OF_DAY: (timestamp: RuntimeValue) => RuntimeValue;
+declare const ADD_DAYS: (date: RuntimeValue, days: RuntimeValue) => RuntimeValue;
 /**
-* Get the end of day (23:59:59.999 local time) for a given timestamp
+* Add months to a date or datetime, returning the same type
 */
-declare const END_OF_DAY: (timestamp: RuntimeValue) => RuntimeValue;
+declare const ADD_MONTHS: (date: RuntimeValue, months: RuntimeValue) => RuntimeValue;
 /**
-* Get the start of week (Sunday at 00:00:00.000 local time) for a given timestamp
+* Add years to a date or datetime, returning the same type
 */
-declare const START_OF_WEEK: (timestamp: RuntimeValue) => RuntimeValue;
+declare const ADD_YEARS: (date: RuntimeValue, years: RuntimeValue) => RuntimeValue;
 /**
-* Get the start of month (1st day at 00:00:00.000 local time) for a given timestamp
+* Get the difference in days between two dates or datetimes (same type required)
 */
-declare const START_OF_MONTH: (timestamp: RuntimeValue) => RuntimeValue;
+declare const DIFFERENCE_IN_DAYS: (d1: RuntimeValue, d2: RuntimeValue) => RuntimeValue;
 /**
-* Get the end of month (last day at 23:59:59.999 local time) for a given timestamp
+* Get the difference in weeks between two dates or datetimes (same type, whole weeks)
 */
-declare const END_OF_MONTH: (timestamp: RuntimeValue) => RuntimeValue;
+declare const DIFFERENCE_IN_WEEKS: (d1: RuntimeValue, d2: RuntimeValue) => RuntimeValue;
 /**
-* Get the start of year (Jan 1st at 00:00:00.000 local time) for a given timestamp
+* Get the difference in months between two dates or datetimes (same type, whole months)
 */
-declare const START_OF_YEAR: (timestamp: RuntimeValue) => RuntimeValue;
+declare const DIFFERENCE_IN_MONTHS: (d1: RuntimeValue, d2: RuntimeValue) => RuntimeValue;
 /**
-* Get the end of year (Dec 31st at 23:59:59.999 local time) for a given timestamp
+* Get the difference in years between two dates or datetimes (same type, whole years)
 */
-declare const END_OF_YEAR: (timestamp: RuntimeValue) => RuntimeValue;
+declare const DIFFERENCE_IN_YEARS: (d1: RuntimeValue, d2: RuntimeValue) => RuntimeValue;
 /**
-* Add days to a timestamp (local timezone)
+* Get the first day of the month for a given date or datetime
 */
-declare const ADD_DAYS: (timestamp: RuntimeValue, days: RuntimeValue) => RuntimeValue;
+declare const START_OF_MONTH: (date: RuntimeValue) => RuntimeValue;
 /**
-* Add months to a timestamp (handles variable month lengths correctly, local timezone)
+* Get the last day of the month for a given date or datetime
 */
-declare const ADD_MONTHS: (timestamp: RuntimeValue, months: RuntimeValue) => RuntimeValue;
+declare const END_OF_MONTH: (date: RuntimeValue) => RuntimeValue;
 /**
-* Add years to a timestamp (local timezone)
+* Get the first day of the year for a given date or datetime
 */
-declare const ADD_YEARS: (timestamp: RuntimeValue, years: RuntimeValue) => RuntimeValue;
+declare const START_OF_YEAR: (date: RuntimeValue) => RuntimeValue;
 /**
-* Check if two timestamps are on the same calendar day (local timezone)
-* Returns 1 if true, 0 if false
+* Get the last day of the year for a given date or datetime
 */
-declare const IS_SAME_DAY: (ts1: RuntimeValue, ts2: RuntimeValue) => RuntimeValue;
+declare const END_OF_YEAR: (date: RuntimeValue) => RuntimeValue;
 /**
-* Check if timestamp falls on a weekend (Saturday or Sunday, local timezone)
-* Returns 1 if true, 0 if false
+* Get the first day of the week (Monday) for a given date or datetime
 */
-declare const IS_WEEKEND: (timestamp: RuntimeValue) => RuntimeValue;
+declare const START_OF_WEEK: (date: RuntimeValue) => RuntimeValue;
 /**
-* Check if timestamp is in a leap year (local timezone)
-* Returns 1 if true, 0 if false
+* Get the first day of the quarter for a given date or datetime
 */
-declare const IS_LEAP_YEAR: (timestamp: RuntimeValue) => RuntimeValue;
+declare const START_OF_QUARTER: (date: RuntimeValue) => RuntimeValue;
 /**
-* Get the start of quarter for a given timestamp (local timezone)
+* Check if two dates/datetimes fall on the same calendar day.
+* For PlainDateTime values, only the date portion is compared.
+* Mixed date+datetime is allowed (datetime is converted to date for comparison).
 */
-declare const START_OF_QUARTER: (timestamp: RuntimeValue) => RuntimeValue;
-declare namespace exports_math {
-	export { TAN, SQRT, SIN, ROUND, MIN, MAX, LOG10, LOG, FLOOR, EXP, COS, CLAMP, CEIL, ABS };
+declare const IS_SAME_DAY: (d1: RuntimeValue, d2: RuntimeValue) => RuntimeValue;
+/**
+* Check if a date or datetime falls on a weekend (Saturday or Sunday)
+*/
+declare const IS_WEEKEND: (date: RuntimeValue) => RuntimeValue;
+/**
+* Check if a date or datetime is in a leap year
+*/
+declare const IS_LEAP_YEAR: (date: RuntimeValue) => RuntimeValue;
+declare namespace datetimefull {
+	export { TO_TIME, TO_DATE, START_OF_DAY, NOW, END_OF_DAY, DATETIME, COMBINE };
 }
 /**
-* Math utility functions
-* All functions work with numbers only
+* DateTime construction and conversion functions using Temporal.PlainDateTime
 */
 /**
-* Constrain a value between a minimum and maximum
-* @example CLAMP(value, 0, 100) - Clamps value between 0 and 100
+* Create a PlainDateTime from year, month, day, hour, minute, second
+*/
+declare const DATETIME: (year: RuntimeValue, month: RuntimeValue, day: RuntimeValue, hour: RuntimeValue, minute: RuntimeValue, second: RuntimeValue) => RuntimeValue;
+/**
+* Get the current date and time as a PlainDateTime
+*/
+declare const NOW: () => RuntimeValue;
+/**
+* Extract the PlainDate from a PlainDateTime
+*/
+declare const TO_DATE: (dt: RuntimeValue) => RuntimeValue;
+/**
+* Extract the PlainTime from a PlainDateTime
+*/
+declare const TO_TIME: (dt: RuntimeValue) => RuntimeValue;
+/**
+* Combine a PlainDate and PlainTime into a PlainDateTime
+*/
+declare const COMBINE: (date: RuntimeValue, time: RuntimeValue) => RuntimeValue;
+/**
+* Get midnight (00:00:00) of a PlainDateTime's day
+*/
+declare const START_OF_DAY: (dt: RuntimeValue) => RuntimeValue;
+/**
+* Get the last representable instant (23:59:59.999999999) of a PlainDateTime's day
+*/
+declare const END_OF_DAY: (dt: RuntimeValue) => RuntimeValue;
+declare namespace math {
+	export { TAN, SQRT, SIN, ROUND, MIN, MAX, LOG10, LOG, FLOOR, EXP, COS, CLAMP, CEIL, ABS };
+}
+/**
+* Math utility functions
+* All functions assert number inputs and return numbers
 */
-declare const CLAMP: (value: RuntimeValue, min: RuntimeValue, max: RuntimeValue) => RuntimeValue;
 declare const ABS: (x: RuntimeValue) => RuntimeValue;
 declare const CEIL: (x: RuntimeValue) => RuntimeValue;
 declare const FLOOR: (x: RuntimeValue) => RuntimeValue;
@@ -602,37 +569,174 @@ declare const LOG: (x: RuntimeValue) => RuntimeValue;
 declare const LOG10: (x: RuntimeValue) => RuntimeValue;
 declare const EXP: (x: RuntimeValue) => RuntimeValue;
 /**
+* Constrain a value between a minimum and maximum
+*/
+declare const CLAMP: (value: RuntimeValue, min: RuntimeValue, max: RuntimeValue) => RuntimeValue;
+declare namespace string {
+	export { STR_UPPER, STR_TRIM, STR_STARTS_WITH, STR_SPLIT, STR_SLICE, STR_REPLACE, STR_REPEAT, STR_LOWER, STR_LEN, STR_INDEX_OF, STR_ENDS_WITH, STR_CONTAINS };
+}
+/**
+* Get the length of a string
+*/
+declare const STR_LEN: (s: RuntimeValue) => RuntimeValue;
+/**
+* Convert string to uppercase
+*/
+declare const STR_UPPER: (s: RuntimeValue) => RuntimeValue;
+/**
+* Convert string to lowercase
+*/
+declare const STR_LOWER: (s: RuntimeValue) => RuntimeValue;
+/**
+* Trim whitespace from both ends of a string
+*/
+declare const STR_TRIM: (s: RuntimeValue) => RuntimeValue;
+/**
+* Extract a section of a string (0-based indices)
+*/
+declare const STR_SLICE: (s: RuntimeValue, start: RuntimeValue, end?: RuntimeValue) => RuntimeValue;
+/**
+* Check if a string contains another string
+* Returns boolean
+*/
+declare const STR_CONTAINS: (s: RuntimeValue, search: RuntimeValue) => RuntimeValue;
+/**
+* Find the first index of a substring (-1 if not found)
+*/
+declare const STR_INDEX_OF: (s: RuntimeValue, search: RuntimeValue) => RuntimeValue;
+/**
+* Split a string by a separator into a string array
+*/
+declare const STR_SPLIT: (s: RuntimeValue, sep: RuntimeValue) => RuntimeValue;
+/**
+* Replace the first occurrence of a search string with a replacement
+*/
+declare const STR_REPLACE: (s: RuntimeValue, search: RuntimeValue, replacement: RuntimeValue) => RuntimeValue;
+/**
+* Check if a string starts with a given prefix
+*/
+declare const STR_STARTS_WITH: (s: RuntimeValue, prefix: RuntimeValue) => RuntimeValue;
+/**
+* Check if a string ends with a given suffix
+*/
+declare const STR_ENDS_WITH: (s: RuntimeValue, suffix: RuntimeValue) => RuntimeValue;
+/**
+* Repeat a string n times. Count must be a non-negative integer.
+*/
+declare const STR_REPEAT: (s: RuntimeValue, count: RuntimeValue) => RuntimeValue;
+declare namespace time {
+	export { TIME, NOW_TIME, IS_SAME_TIME, GET_SECOND, GET_MINUTE, GET_MILLISECOND, GET_HOUR, DIFFERENCE_IN_SECONDS, DIFFERENCE_IN_MINUTES, DIFFERENCE_IN_HOURS, ADD_SECONDS, ADD_MINUTES, ADD_HOURS };
+}
+/**
+* Time utility functions using Temporal.PlainTime and Temporal.PlainDateTime
+* Extractor and arithmetic functions accept both PlainTime and PlainDateTime.
+* Difference functions require both arguments to be the same type.
+*/
+/**
+* Create a PlainTime from hour, minute, and second
+*/
+declare const TIME: (hour: RuntimeValue, minute: RuntimeValue, second: RuntimeValue) => RuntimeValue;
+/**
+* Get the current wall-clock time as a PlainTime
+*/
+declare const NOW_TIME: () => RuntimeValue;
+/**
+* Get the hour (0-23) from a time or datetime
+*/
+declare const GET_HOUR: (t: RuntimeValue) => RuntimeValue;
+/**
+* Get the minute (0-59) from a time or datetime
+*/
+declare const GET_MINUTE: (t: RuntimeValue) => RuntimeValue;
+/**
+* Get the second (0-59) from a time or datetime
+*/
+declare const GET_SECOND: (t: RuntimeValue) => RuntimeValue;
+/**
+* Get the millisecond (0-999) from a time or datetime
+*/
+declare const GET_MILLISECOND: (t: RuntimeValue) => RuntimeValue;
+/**
+* Add hours to a time or datetime.
+* PlainTime wraps around at midnight boundaries.
+*/
+declare const ADD_HOURS: (t: RuntimeValue, hours: RuntimeValue) => RuntimeValue;
+/**
+* Add minutes to a time or datetime.
+* PlainTime wraps around at midnight boundaries.
+*/
+declare const ADD_MINUTES: (t: RuntimeValue, minutes: RuntimeValue) => RuntimeValue;
+/**
+* Add seconds to a time or datetime.
+* PlainTime wraps around at midnight boundaries.
+*/
+declare const ADD_SECONDS: (t: RuntimeValue, seconds: RuntimeValue) => RuntimeValue;
+/**
+* Get the absolute difference in hours between two times or datetimes (same type required)
+*/
+declare const DIFFERENCE_IN_HOURS: (t1: RuntimeValue, t2: RuntimeValue) => RuntimeValue;
+/**
+* Get the absolute difference in minutes between two times or datetimes (same type required)
+*/
+declare const DIFFERENCE_IN_MINUTES: (t1: RuntimeValue, t2: RuntimeValue) => RuntimeValue;
+/**
+* Get the absolute difference in seconds between two times or datetimes (same type required)
+*/
+declare const DIFFERENCE_IN_SECONDS: (t1: RuntimeValue, t2: RuntimeValue) => RuntimeValue;
+/**
+* Check if two times/datetimes have the same time-of-day.
+* For PlainDateTime values, only the time portion is compared.
+* Mixed time+datetime is allowed (datetime is converted to time for comparison).
+*/
+declare const IS_SAME_TIME: (t1: RuntimeValue, t2: RuntimeValue) => RuntimeValue;
+/**
 * Default execution context with standard library functions
-* Users can use this as-is or spread it into their own context
-*
-* All functions use UPPERCASE naming convention to avoid collisions with user variables.
-* All date-related functions work with timestamps (milliseconds since Unix epoch)
-* to maintain the language's numbers-only type system.
-*
-* @example
-* // Use as-is
-* execute('ABS(-5)', defaultContext)
-*
-* @example
-* // Spread into custom context
-* execute('NOW() + FROM_MINUTES(5)', {
-*   ...defaultContext,
-*   variables: { customVar: 42 }
-* })
-*
-* @example
-* // Work with timestamps
-* const result = execute('NOW() + FROM_DAYS(7)', defaultContext)
-* const futureDate = new Date(result) // Convert back to Date if needed
-*
-* @example
-* // Calculate time differences
-* const ts1 = Date.now()
-* const ts2 = ts1 + 1000 * 60 * 60 * 3 // 3 hours later
-* execute('DIFFERENCE_IN_HOURS(ts1, ts2)', { ...defaultContext, variables: { ts1, ts2 } })
+* Includes math, string, array, datetime, time, datetimefull, and type conversion functions
 */
 declare const defaultContext: ExecutionContext;
 /**
+* Return the type name of a runtime value
+* Note: PlainDateTime check must precede PlainDate because PlainDateTime is not an
+* instance of PlainDate in the Temporal API, but ordering is kept explicit for clarity.
+*/
+declare function typeOf(value: RuntimeValue): string;
+/**
+* Assert a value is a number, throwing a TypeError if not
+*/
+declare function assertNumber(v: RuntimeValue, context: string, side?: string): asserts v is number;
+/**
+* Assert a value is a boolean, throwing a TypeError if not
+*/
+declare function assertBoolean(v: RuntimeValue, context: string, side?: string): asserts v is boolean;
+/**
+* Assert a value is a string, throwing a TypeError if not
+*/
+declare function assertString(v: RuntimeValue, context: string): asserts v is string;
+/**
+* Assert a value is a Temporal.PlainDate, throwing a TypeError if not
+*/
+declare function assertDate(v: RuntimeValue, context: string): asserts v is Temporal.PlainDate;
+/**
+* Assert a value is a Temporal.PlainTime, throwing a TypeError if not
+*/
+declare function assertTime(v: RuntimeValue, context: string): asserts v is Temporal.PlainTime;
+/**
+* Assert a value is a Temporal.PlainDateTime, throwing a TypeError if not
+*/
+declare function assertDateTime(v: RuntimeValue, context: string): asserts v is Temporal.PlainDateTime;
+/**
+* Assert a value is a Temporal.PlainDate or Temporal.PlainDateTime
+*/
+declare function assertDateOrDateTime(v: RuntimeValue, context: string): asserts v is Temporal.PlainDate | Temporal.PlainDateTime;
+/**
+* Assert a value is a Temporal.PlainTime or Temporal.PlainDateTime
+*/
+declare function assertTimeOrDateTime(v: RuntimeValue, context: string): asserts v is Temporal.PlainTime | Temporal.PlainDateTime;
+/**
+* Assert a value is an array, throwing a TypeError if not
+*/
+declare function assertArray(v: RuntimeValue, context: string): asserts v is readonly RuntimeValue[];
+/**
 * Type-safe visitor pattern for AST traversal.
 *
 * A visitor is an object with handler functions for each AST node type.
@@ -640,133 +744,32 @@ declare const defaultContext: ExecutionContext;
 * - The node (correctly typed based on node.type)
 * - A recurse function to visit child nodes with the same visitor
 *
-* The visitor pattern centralizes AST traversal logic and ensures
-* exhaustive handling of all node types at compile time.
-*
-* Time complexity: O(n) where n is the number of nodes in the AST
-* Space complexity: O(d) where d is the maximum depth (recursion stack)
-*
 * @template T The return type of visitor handlers
-*
-* @example
-* // Count all nodes in an AST
-* const nodeCount = visit(ast, {
-*   Program: (n, recurse) => 1 + n.statements.reduce((sum, stmt) => sum + recurse(stmt), 0),
-*   NumberLiteral: () => 1,
-*   Identifier: () => 1,
-*   BinaryOp: (n, recurse) => 1 + recurse(n.left) + recurse(n.right),
-*   UnaryOp: (n, recurse) => 1 + recurse(n.argument),
-*   FunctionCall: (n, recurse) => 1 + n.arguments.reduce((sum, arg) => sum + recurse(arg), 0),
-*   Assignment: (n, recurse) => 1 + recurse(n.value),
-*   ConditionalExpression: (n, recurse) => 1 + recurse(n.condition) + recurse(n.consequent) + recurse(n.alternate),
-* })
-*
-* @example
-* // Transform AST: constant folding
-* const optimized = visit(ast, {
-*   NumberLiteral: (n) => n,
-*   Identifier: (n) => n,
-*   BinaryOp: (n, recurse) => {
-*     const left = recurse(n.left)
-*     const right = recurse(n.right)
-*     if (isNumberLiteral(left) && isNumberLiteral(right)) {
-*       return ast.number(left.value + right.value)
-*     }
-*     return ast.binaryOp(left, n.operator, right)
-*   },
-*   // ... other handlers
-* })
 */
 type Visitor<T> = {
-	/**
-	* Handle a Program node (multiple statements)
-	*/
 	Program: (node: Program, recurse: (n: ASTNode) => T) => T;
-	/**
-	* Handle a NumberLiteral node
-	*/
 	NumberLiteral: (node: NumberLiteral, recurse: (n: ASTNode) => T) => T;
-	/**
-	* Handle an Identifier node (variable reference)
-	*/
-	Identifier: (node: Identifier, recurse: (n: ASTNode) => T) => T;
-	/**
-	* Handle a BinaryOp node (binary operation)
-	*/
+	StringLiteral: (node: StringLiteral, recurse: (n: ASTNode) => T) => T;
+	BooleanLiteral: (node: BooleanLiteral, recurse: (n: ASTNode) => T) => T;
+	ArrayLiteral: (node: ArrayLiteral, recurse: (n: ASTNode) => T) => T;
+	Identifier2: (node: Identifier2, recurse: (n: ASTNode) => T) => T;
 	BinaryOp: (node: BinaryOp, recurse: (n: ASTNode) => T) => T;
-	/**
-	* Handle a UnaryOp node (unary operation)
-	*/
 	UnaryOp: (node: UnaryOp, recurse: (n: ASTNode) => T) => T;
-	/**
-	* Handle a FunctionCall node
-	*/
 	FunctionCall: (node: FunctionCall, recurse: (n: ASTNode) => T) => T;
-	/**
-	* Handle an Assignment node (variable assignment)
-	*/
 	Assignment: (node: Assignment, recurse: (n: ASTNode) => T) => T;
-	/**
-	* Handle a ConditionalExpression node (ternary operator)
-	*/
-	ConditionalExpression: (node: ConditionalExpression, recurse: (n: ASTNode) => T) => T;
+	IfExpression: (node: IfExpression, recurse: (n: ASTNode) => T) => T;
+	ForExpression: (node: ForExpression, recurse: (n: ASTNode) => T) => T;
+	IndexAccess: (node: IndexAccess, recurse: (n: ASTNode) => T) => T;
+	RangeExpression: (node: RangeExpression, recurse: (n: ASTNode) => T) => T;
 };
 /**
 * Visit an AST node using a visitor object with type-specific handlers.
-*
-* This function implements the visitor pattern for AST traversal.
 * All node types must have handlers (exhaustive by design).
-* TypeScript enforces exhaustiveness at compile time via the switch statement.
-*
-* The visitor pattern provides several benefits:
-* - DRY: Centralizes traversal logic across all modules
-* - Type safety: Handlers receive correctly-typed nodes
-* - Exhaustiveness: Compile-time guarantee that all node types are handled
-* - Flexibility: Supports transform, fold, and walk patterns
 *
 * @template T The return type of visitor handlers
 * @param node The AST node to visit
 * @param visitor Object with handlers for each node type
 * @returns The result of visiting the node
-*
-* @example
-* // Evaluate an AST (fold pattern)
-* const result = visit(ast, {
-*   Program: (n, recurse) => {
-*     let result = 0
-*     for (const stmt of n.statements) {
-*       result = recurse(stmt)
-*     }
-*     return result
-*   },
-*   NumberLiteral: (n) => n.value,
-*   BinaryOp: (n, recurse) => {
-*     const left = recurse(n.left)
-*     const right = recurse(n.right)
-*     return left + right // simplified
-*   },
-*   // ... other handlers
-* })
-*
-* @example
-* // Transform an AST (transform pattern)
-* const transformed = visit(ast, {
-*   NumberLiteral: (n) => ast.number(n.value * 2), // Double all numbers
-*   BinaryOp: (n, recurse) => ast.binaryOp(
-*     recurse(n.left),
-*     n.operator,
-*     recurse(n.right)
-*   ),
-*   // ... other handlers
-* })
-*
-* @example
-* // Walk an AST (walk pattern - side effects)
-* visit(ast, {
-*   NumberLiteral: (n) => { console.log('Number:', n.value) },
-*   Identifier: (n) => { console.log('Variable:', n.name) },
-*   // ... other handlers
-* })
 */
 declare function visit<T>(node: ASTNode, visitor: Visitor<T>): T;
 /**
@@ -776,52 +779,11 @@ declare function visit<T>(node: ASTNode, visitor: Visitor<T>): T;
 * you to handle only specific node types. Unhandled nodes are processed by
 * the default handler.
 *
-* This is useful for:
-* - Analysis passes that only care about certain node types
-* - Transformations that only modify specific nodes
-* - Walking the tree to collect information
-*
 * @template T The return type of visitor handlers
 * @param node The AST node to visit
 * @param visitor Object with optional handlers for node types
 * @param defaultHandler Handler for unhandled node types
 * @returns The result of visiting the node
-*
-* @example
-* // Collect all variable names (only care about Identifier nodes)
-* const variables: string[] = []
-* visitPartial(
-*   ast,
-*   {
-*     Identifier: (n) => {
-*       variables.push(n.name)
-*       return undefined
-*     }
-*   },
-*   (node, recurse) => {
-*     // Default: recurse into children for all other node types
-*     if (node.type === 'BinaryOp') {
-*       recurse(node.left)
-*       recurse(node.right)
-*     }
-*     // ... handle other node types' children
-*     return undefined
-*   }
-* )
-*
-* @example
-* // Transform only BinaryOp nodes, keep everything else as-is
-* const transformed = visitPartial(
-*   ast,
-*   {
-*     BinaryOp: (n, recurse) => ast.binaryOp(
-*       recurse(n.left),
-*       '+', // Force all operators to addition
-*       recurse(n.right)
-*     )
-*   },
-*   (node, recurse) => node // Default: identity (no transformation)
-* )
 */
 declare function visitPartial<T>(node: ASTNode, visitor: Partial<Visitor<T>>, defaultHandler: (node: ASTNode, recurse: (n: ASTNode) => T) => T): T;
-export { visitPartial, visit, parse, optimize, exports_math as math, isUnaryOp, isProgram, isNumberLiteral, isIdentifier, isFunctionCall, isConditionalExpression, isBinaryOp, isAssignment, humanize, generate, extractInputVariables, evaluate, defaultContext, exports_datetime as datetime, compile, exports_ast as ast, Visitor, UnaryOp, RuntimeValue, Program, Operator, NumberLiteral, NodeKind, Identifier, HumanizeOptions, FunctionCall, ExecutionContext, ConditionalExpression, CompiledExpression, BinaryOp, Assignment, ASTNode };
+export { visitPartial, visit, typeOf, time, string, parse, optimize, math, isUnaryOp, isStringLiteral, isRangeExpression, isProgram, isNumberLiteral, isIndexAccess, isIfExpression, isIdentifier, isFunctionCall, isForExpression, isBooleanLiteral, isBinaryOp, isAssignment, isArrayLiteral, generate, extractInputVariables, extractAssignedVariables, evaluateScope, evaluate, defaultContext, datetimefull, datetime, core, exports_ast as ast, assertTimeOrDateTime, assertTime, assertString, assertNumber, assertDateTime, assertDateOrDateTime, assertDate, assertBoolean, assertArray, array, Visitor, UnaryOp, StringLiteral, RuntimeValue, RangeExpression, Program, Operator, NumberLiteral, NodeKind, IndexAccess, IfExpression, Identifier2 as Identifier, FunctionCall, ForExpression, ExecutionContext, BooleanLiteral, BinaryOp, Assignment, ArrayLiteral, ASTNodeBase, ASTNode };