@rcrsr/rill 0.7.1 → 0.8.0

package/README.md

@@ -1,6 +1,6 @@
 # @rcrsr/rill
 
-Embeddable, sandboxed scripting runtime for [rill](https://rill.run). Zero dependencies. Browser and Node.js compatible.
+Core runtime for [rill](https://rill.run) — scripting designed for machine-generated code. Zero dependencies. Browser and Node.js compatible.
 
 > **Experimental.** Breaking changes will occur before stabilization.
 

package/dist/ast-nodes.d.ts

@@ -0,0 +1,635 @@
+import type { SourceSpan } from './source-location.js';
+import type { RillTypeName } from './value-types.js';
+interface BaseNode {
+    readonly span: SourceSpan;
+}
+export interface ScriptNode extends BaseNode {
+    readonly type: 'Script';
+    readonly frontmatter: FrontmatterNode | null;
+    /** Statements in the script. May include RecoveryErrorNode when parsed with recoveryMode. */
+    readonly statements: (StatementNode | AnnotatedStatementNode | RecoveryErrorNode)[];
+}
+export interface FrontmatterNode extends BaseNode {
+    readonly type: 'Frontmatter';
+    readonly content: string;
+}
+/**
+ * Closure: |params| body
+ * First-class closure with optional typed parameters and defaults.
+ * Scope rules: captures outer (read-only), local mutable.
+ *
+ * Body can be:
+ * - Simple: |x| $x (postfix-expr)
+ * - Grouped: |x| ($x * 2) (compound expression)
+ * - Block: |x| { $a ↵ $b } (multiple statements)
+ */
+export interface ClosureNode extends BaseNode {
+    readonly type: 'Closure';
+    readonly params: ClosureParamNode[];
+    readonly body: BodyNode;
+}
+/**
+ * Function parameter with optional type and default value.
+ * - (x) { }           -- untyped
+ * - (x: string) { }   -- typed
+ * - (x: string = "hi") { }  -- typed with default
+ * - ^(key: value) (x) { }  -- with parameter annotations
+ */
+export interface ClosureParamNode extends BaseNode {
+    readonly type: 'ClosureParam';
+    readonly name: string;
+    readonly typeName: 'string' | 'number' | 'bool' | null;
+    readonly defaultValue: LiteralNode | null;
+    readonly annotations?: AnnotationArg[] | undefined;
+}
+/**
+ * Statement: a pipe chain expression.
+ * Termination (capture/break/return) is now part of PipeChainNode.
+ */
+export interface StatementNode extends BaseNode {
+    readonly type: 'Statement';
+    readonly expression: PipeChainNode;
+}
+/**
+ * Recovery error node for parse error recovery mode.
+ * Represents unparseable content that was skipped during error recovery.
+ * Only appears in ASTs when parsing with `recoveryMode: true`.
+ */
+export interface RecoveryErrorNode extends BaseNode {
+    readonly type: 'RecoveryError';
+    /** The error message describing what went wrong */
+    readonly message: string;
+    /** The raw source text that could not be parsed */
+    readonly text: string;
+}
+/**
+ * Annotated statement: ^(key: value, ...) statement
+ * Annotations modify operational parameters for statements.
+ * They prefix statements and bind to the immediately following construct.
+ *
+ * Examples:
+ *   ^(limit: 100) $items @ process()
+ *   ^(timeout: 30) fetch($url)
+ *   ^(retry: 3, backoff: 1.5) api_call()
+ */
+export interface AnnotatedStatementNode extends BaseNode {
+    readonly type: 'AnnotatedStatement';
+    readonly annotations: AnnotationArg[];
+    readonly statement: StatementNode;
+}
+/**
+ * Annotation argument: named or spread
+ * Reuses similar structure to dict entries but with spread support.
+ */
+export type AnnotationArg = NamedArgNode | SpreadArgNode;
+/**
+ * Named annotation argument: key: value
+ * Example: limit: 100, timeout: 30
+ */
+export interface NamedArgNode extends BaseNode {
+    readonly type: 'NamedArg';
+    readonly name: string;
+    readonly value: ExpressionNode;
+}
+/**
+ * Spread annotation argument: *expr
+ * Example: *$opts spreads tuple keys as annotations
+ */
+export interface SpreadArgNode extends BaseNode {
+    readonly type: 'SpreadArg';
+    readonly expression: ExpressionNode;
+}
+export interface CaptureNode extends BaseNode {
+    readonly type: 'Capture';
+    readonly name: string;
+    /** Optional explicit type annotation: $name:string */
+    readonly typeName: RillTypeName | null;
+}
+/**
+ * Break: exit loop with current pipe value.
+ * Used as chain terminator: $x -> break
+ * Or bare: break (implicit $ -> break)
+ */
+export interface BreakNode extends BaseNode {
+    readonly type: 'Break';
+}
+/**
+ * Return: exit closure with current pipe value.
+ * Used as chain terminator: $x -> return
+ * Or bare: return (implicit $ -> return)
+ */
+export interface ReturnNode extends BaseNode {
+    readonly type: 'Return';
+}
+/**
+ * Pass: pass through pipe value unchanged.
+ * Used as chain terminator: $x -> pass
+ * Or bare: pass (implicit $ -> pass)
+ */
+export interface PassNode extends BaseNode {
+    readonly type: 'Pass';
+}
+/**
+ * Assert: halt execution if condition is false.
+ * Syntax: assert condition
+ * Or: assert condition "custom error message"
+ */
+export interface AssertNode extends BaseNode {
+    readonly type: 'Assert';
+    readonly condition: ExpressionNode;
+    readonly message: StringLiteralNode | null;
+}
+/**
+ * Error: explicitly raise an error with a message.
+ * Syntax: error "message"
+ * Or: error "interpolated {$var} message"
+ */
+export interface ErrorNode extends BaseNode {
+    readonly type: 'Error';
+    readonly message: StringLiteralNode | null;
+}
+export type ExpressionNode = PipeChainNode;
+/** Chain terminator: capture, break, or return */
+export type ChainTerminator = CaptureNode | BreakNode | ReturnNode;
+export interface PipeChainNode extends BaseNode {
+    readonly type: 'PipeChain';
+    readonly head: ArithHead;
+    /**
+     * Pipe targets and inline captures.
+     * Inline captures act as implicit .set() — store value and return unchanged.
+     * Semantically: "-> $a ->" ≡ "-> $a.set($) ->"
+     */
+    readonly pipes: (PipeTargetNode | CaptureNode)[];
+    /**
+     * Chain terminator: final capture, break, or return.
+     * Examples:
+     *   $x -> $y         terminator = Capture($y)
+     *   $x -> break      terminator = Break
+     *   $x -> return     terminator = Return
+     *   $x -> .method    terminator = null
+     */
+    readonly terminator: ChainTerminator | null;
+}
+export interface PostfixExprNode extends BaseNode {
+    readonly type: 'PostfixExpr';
+    readonly primary: PrimaryNode;
+    readonly methods: (MethodCallNode | InvokeNode)[];
+    readonly defaultValue: BodyNode | null;
+}
+export type PrimaryNode = LiteralNode | VariableNode | HostCallNode | ClosureCallNode | MethodCallNode | ConditionalNode | WhileLoopNode | DoWhileLoopNode | BlockNode | AssertNode | ErrorNode | PassNode | GroupedExprNode | SpreadNode | TypeAssertionNode | TypeCheckNode;
+export type PipeTargetNode = HostCallNode | ClosureCallNode | MethodCallNode | PipeInvokeNode | ConditionalNode | WhileLoopNode | DoWhileLoopNode | BlockNode | ClosureNode | StringLiteralNode | DictNode | TupleNode | GroupedExprNode | ClosureChainNode | DestructureNode | SliceNode | SpreadNode | TypeAssertionNode | TypeCheckNode | EachExprNode | MapExprNode | FoldExprNode | FilterExprNode | PostfixExprNode | VariableNode | AssertNode | ErrorNode;
+/** Invoke pipe value as a closure: -> $() or -> $(arg1, arg2) */
+export interface PipeInvokeNode extends BaseNode {
+    readonly type: 'PipeInvoke';
+    readonly args: ExpressionNode[];
+}
+export type LiteralNode = StringLiteralNode | NumberLiteralNode | BoolLiteralNode | TupleNode | DictNode | ClosureNode;
+export interface StringLiteralNode extends BaseNode {
+    readonly type: 'StringLiteral';
+    readonly parts: (string | InterpolationNode)[];
+    readonly isMultiline: boolean;
+}
+export interface InterpolationNode extends BaseNode {
+    readonly type: 'Interpolation';
+    readonly expression: ExpressionNode;
+}
+export interface NumberLiteralNode extends BaseNode {
+    readonly type: 'NumberLiteral';
+    readonly value: number;
+}
+export interface BoolLiteralNode extends BaseNode {
+    readonly type: 'BoolLiteral';
+    readonly value: boolean;
+}
+export interface TupleNode extends BaseNode {
+    readonly type: 'Tuple';
+    readonly elements: (ExpressionNode | ListSpreadNode)[];
+    readonly defaultValue: BodyNode | null;
+}
+export interface ListSpreadNode extends BaseNode {
+    readonly type: 'ListSpread';
+    readonly expression: ExpressionNode;
+}
+export interface DictNode extends BaseNode {
+    readonly type: 'Dict';
+    readonly entries: DictEntryNode[];
+    readonly defaultValue: BodyNode | null;
+}
+export interface DictKeyVariable {
+    readonly kind: 'variable';
+    readonly variableName: string;
+}
+export interface DictKeyComputed {
+    readonly kind: 'computed';
+    readonly expression: ExpressionNode;
+}
+export interface DictEntryNode extends BaseNode {
+    readonly type: 'DictEntry';
+    readonly key: string | number | boolean | TupleNode | DictKeyVariable | DictKeyComputed;
+    readonly value: ExpressionNode;
+}
+export type BinaryOp = '+' | '-' | '*' | '/' | '%' | '&&' | '||' | '==' | '!=' | '<' | '>' | '<=' | '>=';
+/**
+ * Expression head types for binary/unary expressions.
+ * Includes arithmetic (+, -, *, /, %) and logical (&&, ||, !) operators.
+ */
+export type ArithHead = BinaryExprNode | UnaryExprNode | PostfixExprNode;
+/**
+ * Binary expression: left op right
+ * Arithmetic: ($x + 5), ($a * $b), (2 + 3 * 4)
+ * Logical: ($a && $b), ($x || $y)
+ */
+export interface BinaryExprNode extends BaseNode {
+    readonly type: 'BinaryExpr';
+    readonly op: BinaryOp;
+    readonly left: ArithHead;
+    readonly right: ArithHead;
+}
+/**
+ * Unary expression: -operand or !operand
+ * Examples: (-5), (-$x), (!$ready)
+ */
+export interface UnaryExprNode extends BaseNode {
+    readonly type: 'UnaryExpr';
+    readonly op: '-' | '!';
+    readonly operand: UnaryExprNode | PostfixExprNode;
+}
+/**
+ * Grouped expression: ( expression )
+ * Single-expression block with () delimiters.
+ * Provides scoping — captures inside are local and not visible outside.
+ *
+ * Scoping rules identical to blocks:
+ *   ("hello" -> $local)  — $local is scoped to group, returns "hello"
+ */
+export interface GroupedExprNode extends BaseNode {
+    readonly type: 'GroupedExpr';
+    readonly expression: PipeChainNode;
+}
+/**
+ * Simple body: expression that can follow closure params, conditionals, or loops.
+ * No naked compound expressions — arithmetic/pipes/booleans must be grouped.
+ *
+ * Valid: block, grouped, or postfix-expr (variable, literal, method, function call)
+ * Examples:
+ *   |x| $x           — postfix-expr
+ *   |x| ($x * 2)     — grouped (compound)
+ *   |x| { $a ↵ $b }  — block (multiple statements)
+ */
+export type BodyNode = BlockNode | GroupedExprNode | PostfixExprNode | PipeChainNode;
+export interface VariableNode extends BaseNode {
+    readonly type: 'Variable';
+    readonly name: string | null;
+    readonly isPipeVar: boolean;
+    /** Ordered chain of property accesses: .name, [0], .$var, etc. */
+    readonly accessChain: PropertyAccess[];
+    /**
+     * Default value for null-coalescing: $data.path ?? default
+     * If property access returns null/missing, use this value instead.
+     */
+    readonly defaultValue: BodyNode | null;
+    /**
+     * Existence check on final path element: $data.?path
+     * Returns boolean (true if path exists).
+     * When set, implies safe traversal (no error on missing intermediate paths).
+     */
+    readonly existenceCheck: ExistenceCheck | null;
+}
+/**
+ * Existence check configuration.
+ * For .?path (just exists) or .?path&type (exists AND type matches).
+ */
+export interface ExistenceCheck {
+    /** The final field/index being checked for existence */
+    readonly finalAccess: FieldAccess;
+    /** Optional type check: returns true only if exists AND matches type */
+    readonly typeName: RillTypeName | null;
+}
+/**
+ * Field access element in a property access chain (dot-based).
+ *
+ * Access forms:
+ * - literal: .identifier (string key)
+ * - variable: .$var (variable as key)
+ * - computed: .(expr) (computed expression)
+ * - block: .{block} (block returning key)
+ * - alternatives: .(a || b) (try keys left-to-right)
+ *
+ * Note: Numeric indices use bracket syntax [0], [-1] instead of dot.
+ */
+export type FieldAccess = FieldAccessLiteral | FieldAccessVariable | FieldAccessComputed | FieldAccessBlock | FieldAccessAlternatives | FieldAccessAnnotation;
+/** Literal field access: .identifier */
+export interface FieldAccessLiteral {
+    readonly kind: 'literal';
+    readonly field: string;
+}
+/** Variable as key: .$var or .$ (pipe variable) */
+export interface FieldAccessVariable {
+    readonly kind: 'variable';
+    readonly variableName: string | null;
+}
+/** Computed expression: .(expr) */
+export interface FieldAccessComputed {
+    readonly kind: 'computed';
+    readonly expression: ExpressionNode;
+}
+/** Block returning key: .{block} */
+export interface FieldAccessBlock {
+    readonly kind: 'block';
+    readonly block: BlockNode;
+}
+/** Alternatives (try keys left-to-right): .(a || b) */
+export interface FieldAccessAlternatives {
+    readonly kind: 'alternatives';
+    readonly alternatives: string[];
+}
+/** Annotation reflection: .^key */
+export interface FieldAccessAnnotation {
+    readonly kind: 'annotation';
+    readonly key: string;
+}
+/**
+ * Bracket index access: [expr]
+ * Used for numeric indexing into lists/strings.
+ * Expression can be positive (from start) or negative (from end).
+ */
+export interface BracketAccess {
+    /** Discriminator for the unified PropertyAccess type */
+    readonly accessKind: 'bracket';
+    /** The index expression (evaluates to number) */
+    readonly expression: ExpressionNode;
+    /** Source span from opening [ to closing ] (inclusive) */
+    readonly span: SourceSpan;
+}
+/**
+ * Unified property access type.
+ * Used to maintain order of mixed dot and bracket accesses.
+ * e.g., $data[0].name[1] has accesses: [bracket(0), field(name), bracket(1)]
+ */
+export type PropertyAccess = FieldAccess | BracketAccess;
+export interface HostCallNode extends BaseNode {
+    readonly type: 'HostCall';
+    readonly name: string;
+    readonly args: ExpressionNode[];
+}
+export interface MethodCallNode extends BaseNode {
+    readonly type: 'MethodCall';
+    readonly name: string;
+    readonly args: ExpressionNode[];
+    readonly receiverSpan: SourceSpan | null;
+}
+/** Postfix invocation: expr(args) - calls the result of expr as a closure */
+export interface InvokeNode extends BaseNode {
+    readonly type: 'Invoke';
+    readonly args: ExpressionNode[];
+}
+/** Call a closure stored in a variable: $fn(args) or $obj.method(args) */
+export interface ClosureCallNode extends BaseNode {
+    readonly type: 'ClosureCall';
+    readonly name: string;
+    readonly accessChain: string[];
+    readonly args: ExpressionNode[];
+}
+/**
+ * Conditional: ?($cond) body : else
+ * Body can be any simple-body (block, grouped, or postfix-expr).
+ *
+ * Examples:
+ *   ?($x > 0) "positive" : "negative"    — literals
+ *   ?($x > 0) ($x * 2) : ($x / 2)        — grouped
+ *   ?($x > 0) { complex } : { other }    — blocks
+ */
+export interface ConditionalNode extends BaseNode {
+    readonly type: 'Conditional';
+    readonly input: ExpressionNode | null;
+    readonly condition: BodyNode | null;
+    readonly thenBranch: BodyNode;
+    readonly elseBranch: BodyNode | ConditionalNode | null;
+}
+export interface WhileLoopNode extends BaseNode {
+    readonly type: 'WhileLoop';
+    readonly condition: ExpressionNode;
+    readonly body: BodyNode;
+}
+export interface DoWhileLoopNode extends BaseNode {
+    readonly type: 'DoWhileLoop';
+    readonly input: ExpressionNode | null;
+    readonly body: BodyNode;
+    readonly condition: BodyNode;
+}
+export interface BlockNode extends BaseNode {
+    readonly type: 'Block';
+    readonly statements: (StatementNode | AnnotatedStatementNode)[];
+}
+/**
+ * Collection operator body types.
+ * These are the valid forms for the body of each/map/fold operators.
+ */
+export type IteratorBody = ClosureNode | BlockNode | GroupedExprNode | VariableNode | PostfixExprNode | SpreadNode | HostCallNode;
+/**
+ * Each expression: sequential iteration returning list of all results.
+ *
+ * Syntax forms:
+ *   collection -> each |x| body
+ *   collection -> each { body }
+ *   collection -> each (expr)
+ *   collection -> each $fn
+ *   collection -> each $
+ *
+ * With accumulator:
+ *   collection -> each(init) { body }         -- $@ is accumulator
+ *   collection -> each |x, acc = init| body   -- $acc is accumulator
+ *
+ * Returns: list of all body results (or scan results if accumulator)
+ */
+export interface EachExprNode extends BaseNode {
+    readonly type: 'EachExpr';
+    /** The body to execute for each element */
+    readonly body: IteratorBody;
+    /**
+     * Optional accumulator initial value (for block form with $@ access).
+     * null when using inline closure with accumulator (it's in the closure params)
+     * or when no accumulator is used.
+     */
+    readonly accumulator: ExpressionNode | null;
+}
+/**
+ * Map expression: parallel iteration returning list of all results.
+ *
+ * Syntax forms:
+ *   collection -> map |x| body
+ *   collection -> map { body }
+ *   collection -> map (expr)
+ *   collection -> map $fn
+ *   collection -> map $
+ *
+ * No accumulator (parallel execution has no "previous").
+ * Concurrency limit via ^(limit: N) annotation.
+ *
+ * Returns: list of all body results (order preserved)
+ */
+export interface MapExprNode extends BaseNode {
+    readonly type: 'MapExpr';
+    /** The body to execute for each element (in parallel) */
+    readonly body: IteratorBody;
+}
+/**
+ * Fold expression: sequential reduction returning final result only.
+ *
+ * Syntax forms:
+ *   collection -> fold |x, acc = init| body   -- $acc is accumulator
+ *   collection -> fold(init) { body }         -- $@ is accumulator
+ *   collection -> fold $fn                    -- fn must have accumulator param
+ *
+ * Accumulator is required.
+ *
+ * Returns: final accumulated value only
+ */
+export interface FoldExprNode extends BaseNode {
+    readonly type: 'FoldExpr';
+    /** The body to execute for each element */
+    readonly body: IteratorBody;
+    /**
+     * Accumulator initial value (for block form with $@ access).
+     * null when using inline closure (accumulator is in closure params).
+     */
+    readonly accumulator: ExpressionNode | null;
+}
+/**
+ * Filter expression: parallel filtering returning elements where predicate is truthy.
+ *
+ * Syntax forms:
+ *   collection -> filter |x| body
+ *   collection -> filter { body }
+ *   collection -> filter (expr)
+ *   collection -> filter $fn
+ *
+ * Predicate returns truthy/falsy. Elements where predicate is truthy are kept.
+ *
+ * Returns: list of elements where body was truthy
+ */
+export interface FilterExprNode extends BaseNode {
+    readonly type: 'FilterExpr';
+    /** The predicate body to evaluate for each element */
+    readonly body: IteratorBody;
+}
+/**
+ * Sequential spread: $input -> @$closures
+ * Chains closures where each receives the previous result.
+ *
+ * Equivalent to a fold: $input -> [$f, $g, $h] -> @ { $() }
+ * - With stored closures: the $ is the current closure, $() invokes it
+ * - With inline blocks: $ is the accumulated value directly
+ */
+export interface ClosureChainNode extends BaseNode {
+    readonly type: 'ClosureChain';
+    readonly target: ExpressionNode;
+}
+/**
+ * Destructure operator: *<...>
+ * Extracts elements from tuples/dicts into variables.
+ *
+ * Tuple: [1, 2, 3] -> *<$a, $b, $c>
+ * Dict:  [name: "x"] -> *<name: $n>
+ * Nested: [[1, 2], 3] -> *<*<$a, $b>, $c>
+ */
+export interface DestructureNode extends BaseNode {
+    readonly type: 'Destructure';
+    readonly elements: DestructPatternNode[];
+}
+/**
+ * Element in a destructure pattern.
+ * Can be: typed variable, key-variable pair, skip placeholder, or nested destructure.
+ */
+export interface DestructPatternNode extends BaseNode {
+    readonly type: 'DestructPattern';
+    readonly kind: 'variable' | 'keyValue' | 'skip' | 'nested';
+    /** Variable name (for 'variable' and 'keyValue' kinds) */
+    readonly name: string | null;
+    /** Key name (for 'keyValue' kind - dict destructuring) */
+    readonly key: string | null;
+    /** Type annotation (for 'variable' and 'keyValue' kinds) */
+    readonly typeName: RillTypeName | null;
+    /** Nested destructure pattern (for 'nested' kind) */
+    readonly nested: DestructureNode | null;
+}
+/**
+ * Slice operator: /<start:stop:step>
+ * Extracts a portion of a tuple or string using Python-style slicing.
+ *
+ * Examples:
+ *   $tuple -> /<0:3>       # elements 0, 1, 2
+ *   $tuple -> /<::-1>      # reversed
+ *   "hello" -> /<1:4>      # "ell"
+ */
+export interface SliceNode extends BaseNode {
+    readonly type: 'Slice';
+    /** Start index (null = from beginning) */
+    readonly start: SliceBoundNode | null;
+    /** Stop index (null = to end) */
+    readonly stop: SliceBoundNode | null;
+    /** Step (null = 1) */
+    readonly step: SliceBoundNode | null;
+}
+/** A slice bound: number, variable, or grouped expression */
+export type SliceBoundNode = NumberLiteralNode | VariableNode | GroupedExprNode;
+/**
+ * Spread operator: *expr or -> *
+ * Converts tuple or dict to args type for unpacking at closure invocation.
+ *
+ * Prefix form: *[1, 2, 3], *$tuple, *[x: 1, y: 2]
+ * Pipe target form: [1, 2, 3] -> *
+ *
+ * Creates an args value that unpacks into separate arguments when passed to a closure.
+ */
+export interface SpreadNode extends BaseNode {
+    readonly type: 'Spread';
+    /** The expression to spread (null when used as pipe target: -> *) */
+    readonly operand: ExpressionNode | null;
+}
+/**
+ * Type assertion: expr:type
+ * Asserts that the expression evaluates to the specified type.
+ * Returns the value unchanged if assertion passes, errors on mismatch.
+ *
+ * Examples:
+ *   fetchData():string                # assert result is string
+ *   $val -> :number -> process()      # assert pipe value is number
+ *   "hello":string                    # "hello" (pass)
+ *   "hello":number                    # Error: expected number, got string
+ *
+ * When operand is null, it acts on the implicit $:
+ *   :string ≡ $:string
+ */
+export interface TypeAssertionNode extends BaseNode {
+    readonly type: 'TypeAssertion';
+    /** The expression to assert (null for bare :type which uses $) */
+    readonly operand: PostfixExprNode | null;
+    /** The expected type */
+    readonly typeName: RillTypeName;
+}
+/**
+ * Type check: expr:?type
+ * Checks if the expression evaluates to the specified type.
+ * Returns true if types match, false otherwise.
+ *
+ * Examples:
+ *   fetchData():?string               # is result a string?
+ *   $val -> :?number -> process()     # is pipe value a number?
+ *   "hello":?string                   # true
+ *   "hello":?number                   # false
+ *
+ * When operand is null, it checks the implicit $:
+ *   :?string ≡ $:?string
+ */
+export interface TypeCheckNode extends BaseNode {
+    readonly type: 'TypeCheck';
+    /** The expression to check (null for bare :?type which uses $) */
+    readonly operand: PostfixExprNode | null;
+    /** The type to check for */
+    readonly typeName: RillTypeName;
+}
+export type SimplePrimaryNode = LiteralNode | VariableNode | HostCallNode | MethodCallNode | BlockNode | BinaryExprNode | UnaryExprNode | GroupedExprNode | PostfixExprNode | TypeAssertionNode | TypeCheckNode;
+export type ASTNode = ScriptNode | FrontmatterNode | ClosureNode | ClosureParamNode | StatementNode | CaptureNode | BreakNode | ReturnNode | PassNode | AssertNode | PipeChainNode | PostfixExprNode | MethodCallNode | InvokeNode | HostCallNode | ClosureCallNode | PipeInvokeNode | VariableNode | ConditionalNode | WhileLoopNode | DoWhileLoopNode | BlockNode | StringLiteralNode | InterpolationNode | NumberLiteralNode | BoolLiteralNode | TupleNode | ListSpreadNode | DictNode | DictEntryNode | BinaryExprNode | UnaryExprNode | GroupedExprNode | ClosureChainNode | DestructureNode | DestructPatternNode | SliceNode | SpreadNode | TypeAssertionNode | TypeCheckNode | AnnotatedStatementNode | NamedArgNode | SpreadArgNode | EachExprNode | MapExprNode | FoldExprNode | FilterExprNode | RecoveryErrorNode | ErrorNode;
+export {};
+//# sourceMappingURL=ast-nodes.d.ts.map

package/dist/ast-nodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast-nodes.d.ts","sourceRoot":"","sources":["../src/ast-nodes.ts"],"names":[],"mappings":"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"}

package/dist/ast-nodes.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ast-nodes.js.map

package/dist/ast-nodes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast-nodes.js","sourceRoot":"","sources":["../src/ast-nodes.ts"],"names":[],"mappings":""}

package/dist/ast-unions.d.ts

@@ -0,0 +1,6 @@
+/**
+ * AST Type Unions
+ * String union of all AST node type literals.
+ */
+export type NodeType = 'Script' | 'Frontmatter' | 'Closure' | 'ClosureParam' | 'Statement' | 'PipeChain' | 'PostfixExpr' | 'MethodCall' | 'Invoke' | 'HostCall' | 'ClosureCall' | 'PipeInvoke' | 'Variable' | 'Capture' | 'Conditional' | 'WhileLoop' | 'DoWhileLoop' | 'Block' | 'StringLiteral' | 'Interpolation' | 'NumberLiteral' | 'BoolLiteral' | 'Tuple' | 'ListSpread' | 'Dict' | 'DictEntry' | 'Break' | 'Return' | 'Pass' | 'Assert' | 'BinaryExpr' | 'UnaryExpr' | 'InnerExpr' | 'GroupedExpr' | 'ClosureChain' | 'Destructure' | 'DestructPattern' | 'Slice' | 'Enumerate' | 'Spread' | 'TypeAssertion' | 'TypeCheck' | 'AnnotatedStatement' | 'NamedArg' | 'SpreadArg' | 'EachExpr' | 'MapExpr' | 'FoldExpr' | 'FilterExpr' | 'RecoveryError' | 'Error';
+//# sourceMappingURL=ast-unions.d.ts.map