@mojir/dvala 0.0.7 → 0.0.10

package/dist/cli/cli.js

@@ -7,7 +7,7 @@ var readline = require('node:readline');
 var os = require('node:os');
 var process$1 = require('node:process');
 
-var version = "0.0.7";
+var version = "0.0.10";
 
 function getCodeMarker(sourceCodeInfo) {
     if (!sourceCodeInfo.position || !sourceCodeInfo.code)
@@ -82,31 +82,6 @@ class UndefinedSymbolError extends DvalaError {
     }
 }
 
-const specialExpressionTypes = {
-    '??': 0,
-    '&&': 1,
-    '||': 2,
-    'array': 3,
-    'cond': 4,
-    'defined?': 5,
-    'block': 6,
-    'doseq': 7,
-    '0_lambda': 8,
-    'for': 9,
-    'if': 10,
-    'let': 11,
-    'loop': 12,
-    'object': 13,
-    'recur': 14,
-    'match': 15,
-    'unless': 16,
-    'import': 17,
-    'effect': 18,
-    'perform': 19,
-    'parallel': 20,
-    'race': 21,
-};
-
 const NodeTypes = {
     Number: 1,
     String: 2,
@@ -185,109 +160,6 @@ function getAssertionError(typeName, value, sourceCodeInfo) {
     return new DvalaError(`Expected ${typeName}, got ${valueToString(value)}.`, getSourceCodeInfo(value, sourceCodeInfo));
 }
 
-function isSymbolNode(node) {
-    const nodeType = node[0];
-    return NodeTypes.UserDefinedSymbol === nodeType
-        || NodeTypes.NormalBuiltinSymbol === nodeType
-        || NodeTypes.SpecialBuiltinSymbol === nodeType;
-}
-function isUserDefinedSymbolNode(node) {
-    return NodeTypes.UserDefinedSymbol === node[0];
-}
-function asUserDefinedSymbolNode(node, sourceCodeInfo) {
-    assertUserDefinedSymbolNode(node, sourceCodeInfo);
-    return node;
-}
-function assertUserDefinedSymbolNode(node, sourceCodeInfo) {
-    if (!isUserDefinedSymbolNode(node))
-        throw getAssertionError('UserDefinedSymbolNode', node, sourceCodeInfo);
-}
-function isNormalBuiltinSymbolNode(node) {
-    return NodeTypes.NormalBuiltinSymbol === node[0];
-}
-function isSpecialBuiltinSymbolNode(node) {
-    return NodeTypes.SpecialBuiltinSymbol === node[0];
-}
-function isNormalExpressionNode(node) {
-    return node[0] === NodeTypes.NormalExpression;
-}
-function isNormalExpressionNodeWithName(node) {
-    if (!isNormalExpressionNode(node)) {
-        return false;
-    }
-    return isSymbolNode(node[1][0]);
-}
-function isSpreadNode(node) {
-    return node[0] === NodeTypes.Spread;
-}
-
-const getUndefinedSymbols = (ast, contextStack, builtin, evaluateNode) => {
-    const nodes = Array.isArray(ast)
-        ? ast
-        : [[NodeTypes.SpecialExpression, [specialExpressionTypes.block, ast.body, undefined]]];
-    const unresolvedSymbols = new Set();
-    for (const subNode of nodes) {
-        findUnresolvedSymbolsInNode(subNode, contextStack, builtin, evaluateNode)
-            ?.forEach(symbol => unresolvedSymbols.add(symbol));
-    }
-    return unresolvedSymbols;
-};
-function findUnresolvedSymbolsInNode(node, contextStack, builtin, evaluateNode) {
-    const nodeType = node[0];
-    switch (nodeType) {
-        case NodeTypes.UserDefinedSymbol: {
-            const symbolNode = node;
-            const lookUpResult = contextStack.lookUp(symbolNode);
-            if (lookUpResult === null)
-                return new Set([symbolNode[1]]);
-            return null;
-        }
-        case NodeTypes.NormalBuiltinSymbol:
-        case NodeTypes.SpecialBuiltinSymbol:
-        case NodeTypes.String:
-        case NodeTypes.Number:
-        case NodeTypes.ReservedSymbol:
-        case NodeTypes.Binding:
-            return null;
-        case NodeTypes.NormalExpression: {
-            const normalExpressionNode = node;
-            const unresolvedSymbols = new Set();
-            if (isNormalExpressionNodeWithName(normalExpressionNode)) {
-                const [, [symbolNode]] = normalExpressionNode;
-                if (isUserDefinedSymbolNode(symbolNode)) {
-                    const lookUpResult = contextStack.lookUp(symbolNode);
-                    if (lookUpResult === null)
-                        unresolvedSymbols.add(symbolNode[1]);
-                }
-            }
-            else {
-                const [, [expressionNode]] = normalExpressionNode;
-                findUnresolvedSymbolsInNode(expressionNode, contextStack, builtin, evaluateNode)?.forEach(symbol => unresolvedSymbols.add(symbol));
-            }
-            for (const subNode of normalExpressionNode[1][1]) {
-                findUnresolvedSymbolsInNode(subNode, contextStack, builtin, evaluateNode)?.forEach(symbol => unresolvedSymbols.add(symbol));
-            }
-            return unresolvedSymbols;
-        }
-        case NodeTypes.SpecialExpression: {
-            const specialExpressionNode = node;
-            const specialExpressionType = specialExpressionNode[1][0];
-            const specialExpression = builtin.specialExpressions[specialExpressionType];
-            const castedGetUndefinedSymbols = specialExpression.getUndefinedSymbols;
-            return castedGetUndefinedSymbols(specialExpressionNode, contextStack, {
-                getUndefinedSymbols,
-                builtin,
-                evaluateNode,
-            });
-        }
-        case NodeTypes.Spread:
-            return findUnresolvedSymbolsInNode(node[1], contextStack, builtin, evaluateNode);
-        /* v8 ignore next 2 */
-        default:
-            throw new DvalaError(`Unhandled node type: ${nodeType}`, node[2]);
-    }
-}
-
 function isNonUndefined(value) {
     return value !== undefined;
 }
@@ -4875,7 +4747,7 @@ function argStrings(reference) {
 
 function getMetaNormalExpression(normalExpressionReference, effectReference) {
     return {
-        doc: {
+        'doc': {
             evaluate: ([value], sourceCodeInfo) => {
                 assertNonUndefined(normalExpressionReference);
                 // Handle effects
@@ -4905,28 +4777,45 @@ function getMetaNormalExpression(normalExpressionReference, effectReference) {
                 args: { value: { type: ['function', 'effect'] } },
                 variants: [{ argumentNames: ['value'] }],
                 description: 'Returns documentation string of the $value. Works on functions and effects.',
-                seeAlso: ['arity'],
+                seeAlso: ['arity', 'with-doc'],
                 examples: [
                     'doc(+)',
                     'doc(effect(dvala.io.println))',
-                    `
-let add = (x, y) -> do
-  """
-  Adds two numbers.
-  Args:
-    x: First number.
-    y: Second number.
-  Returns:
-    Sum of x and y.
-  """;
-  x + y;
-end;
-
-doc(add)`,
+                    'let add = (x, y) -> x + y with-doc "Adds two numbers.";\ndoc(add)',
+                ],
+            },
+        },
+        'with-doc': {
+            evaluate: ([fn, docString], sourceCodeInfo) => {
+                assertFunctionLike(fn, sourceCodeInfo);
+                assertString(docString, sourceCodeInfo);
+                if (!isDvalaFunction(fn) || fn.functionType !== 'UserDefined') {
+                    throw new Error('with-doc can only be used with user-defined functions');
+                }
+                return {
+                    ...fn,
+                    [FUNCTION_SYMBOL]: true,
+                    docString,
+                };
+            },
+            arity: toFixedArity(2),
+            docs: {
+                category: 'meta',
+                returns: { type: 'function' },
+                args: {
+                    a: { type: 'function' },
+                    b: { type: 'string' },
+                },
+                variants: [{ argumentNames: ['a', 'b'] }],
+                description: 'Returns a new function with the documentation string $b attached. The original function is not modified.',
+                seeAlso: ['doc'],
+                examples: [
+                    '((x, y) -> x + y) with-doc "Adds two numbers."',
+                    'let add = (x, y) -> x + y;\nadd with-doc "Adds x and y."',
                 ],
             },
         },
-        arity: {
+        'arity': {
             evaluate: ([value], sourceCodeInfo) => {
                 // Handle effects
                 if (isEffect(value)) {
@@ -6293,6 +6182,31 @@ const raceSpecialExpression = {
     },
 };
 
+const specialExpressionTypes = {
+    '??': 0,
+    '&&': 1,
+    '||': 2,
+    'array': 3,
+    'cond': 4,
+    'defined?': 5,
+    'block': 6,
+    'doseq': 7,
+    '0_lambda': 8,
+    'for': 9,
+    'if': 10,
+    'let': 11,
+    'loop': 12,
+    'object': 13,
+    'recur': 14,
+    'match': 15,
+    'unless': 16,
+    'import': 17,
+    'effect': 18,
+    'perform': 19,
+    'parallel': 20,
+    'race': 21,
+};
+
 const specialExpressions = [
     qqSpecialExpression,
     andSpecialExpression,
@@ -6394,119 +6308,1000 @@ function isSymbolicOperator(operator) {
     return symbolicOperatorSet.has(operator);
 }
 
-function isSymbolToken(token, symbolName) {
-    if (token?.[0] !== 'Symbol') {
-        return false;
+const nonNumberReservedSymbolRecord = {
+    true: true,
+    false: false,
+    null: null,
+    do: null,
+    else: null,
+    case: null,
+    each: null,
+    in: null,
+    when: null,
+    while: null,
+    function: null,
+    as: null,
+    then: null,
+    end: null,
+    with: null,
+    _: null,
+};
+const phi = (1 + Math.sqrt(5)) / 2;
+const numberReservedSymbolRecord = {
+    'E': Math.E,
+    '-E': -Math.E,
+    'ε': Math.E,
+    '-ε': -Math.E,
+    'PI': Math.PI,
+    '-PI': -Math.PI,
+    'π': Math.PI,
+    '-π': -Math.PI,
+    'PHI': phi,
+    '-PHI': -phi,
+    'φ': phi,
+    '-φ': -phi,
+    'POSITIVE_INFINITY': Number.POSITIVE_INFINITY,
+    '∞': Number.POSITIVE_INFINITY,
+    'NEGATIVE_INFINITY': Number.NEGATIVE_INFINITY,
+    '-∞': Number.NEGATIVE_INFINITY,
+    'MAX_SAFE_INTEGER': Number.MAX_SAFE_INTEGER,
+    'MIN_SAFE_INTEGER': Number.MIN_SAFE_INTEGER,
+    'MAX_VALUE': Number.MAX_VALUE,
+    'MIN_VALUE': Number.MIN_VALUE,
+    'NaN': Number.NaN,
+};
+const reservedSymbolRecord = {
+    ...nonNumberReservedSymbolRecord,
+    ...numberReservedSymbolRecord,
+};
+function isNumberReservedSymbol(symbol) {
+    return symbol in numberReservedSymbolRecord;
+}
+
+const illegalSymbolCharacters = [
+    '(',
+    ')',
+    '[',
+    ']',
+    '{',
+    '}',
+    '\'',
+    '"',
+    '`',
+    ',',
+    '.',
+    ';',
+    ' ',
+    '\n',
+    '\r',
+    '\t',
+];
+const illegalFirstSymbolCharacters = [
+    '0',
+    '1',
+    '2',
+    '3',
+    '4',
+    '5',
+    '6',
+    '7',
+    '8',
+    '9',
+    ...illegalSymbolCharacters,
+];
+const illegalSymbolCharacterSet = new Set(illegalSymbolCharacters);
+const illegalFirstSymbolCharacterSet = new Set(illegalFirstSymbolCharacters);
+const whitespaceRegExp = /\s/;
+const NO_MATCH = [0];
+const tokenizeLParen = (input, position) => tokenizeToken('LParen', '(', input, position);
+const tokenizeRParen = (input, position) => tokenizeToken('RParen', ')', input, position);
+const tokenizeLBracket = (input, position) => tokenizeToken('LBracket', '[', input, position);
+const tokenizeRBracket = (input, position) => tokenizeToken('RBracket', ']', input, position);
+const tokenizeLBrace = (input, position) => tokenizeToken('LBrace', '{', input, position);
+const tokenizeRBrace = (input, position) => tokenizeToken('RBrace', '}', input, position);
+const tokenizeString = (input, position) => {
+    if (input[position] !== '"')
+        return NO_MATCH;
+    let value = '"';
+    let length = 1;
+    let char = input[position + length];
+    let escaping = false;
+    while (char && (char !== '"' || escaping)) {
+        length += 1;
+        if (escaping) {
+            escaping = false;
+            value += char;
+        }
+        else {
+            if (char === '\\') {
+                escaping = true;
+            }
+            value += char;
+        }
+        char = input[position + length];
     }
-    if (symbolName && token[1] !== symbolName) {
-        return false;
+    if (!char) {
+        return [length, ['Error', value, undefined, `Unclosed string at position ${position}`]];
     }
-    return true;
-}
-function assertSymbolToken(token, symbolName) {
-    if (!isSymbolToken(token, symbolName)) {
-        throwUnexpectedToken('Symbol', undefined, token);
+    value += '"'; // closing quote
+    return [length + 1, ['string', value]];
+};
+const tokenizeRegexpShorthand = (input, position) => {
+    if (input[position] !== '#')
+        return NO_MATCH;
+    const [stringLength, token] = tokenizeString(input, position + 1);
+    if (!token)
+        return NO_MATCH;
+    if (token[0] === 'Error') {
+        const errorToken = ['Error', `#${token[1]}`, undefined, `Unclosed regexp at position ${position}`];
+        return [stringLength + 1, errorToken];
     }
+    position += stringLength + 1;
+    let length = stringLength + 1;
+    let options = '';
+    while (input[position] === 'g' || input[position] === 'i') {
+        options += input[position];
+        length += 1;
+        position += 1;
+        if (options.includes(input[position])) {
+            return [length, ['Error', `#${token[1]}${options}`, undefined, `Duplicated regexp option "${input[position]}"`]];
+        }
+    }
+    return [length, ['RegexpShorthand', `#${token[1]}${options}`]];
+};
+function tokenizeToken(type, value, input, position) {
+    if (value === input.slice(position, position + value.length))
+        return [value.length, [type, value]];
+    else
+        return NO_MATCH;
 }
-function asSymbolToken(token, symbolName) {
-    assertSymbolToken(token, symbolName);
-    return token;
-}
-function isReservedSymbolToken(token, symbolName) {
-    if (token?.[0] !== 'ReservedSymbol') {
-        return false;
+const tokenizeWhitespace = (input, position) => {
+    let char = input[position];
+    if (!char || !whitespaceRegExp.test(char)) {
+        return NO_MATCH;
     }
-    if (symbolName && token[1] !== symbolName) {
-        return false;
+    let value = char;
+    position += 1;
+    char = input[position];
+    while (char && whitespaceRegExp.test(char)) {
+        value += char;
+        position += 1;
+        char = input[position];
     }
-    return true;
-}
-function assertReservedSymbolToken(token, symbolName) {
-    if (!isReservedSymbolToken(token, symbolName)) {
-        throwUnexpectedToken('ReservedSymbol', symbolName, token);
+    return [value.length, ['Whitespace', value]];
+};
+const decimalNumberRegExp = /\d/;
+const octalNumberRegExp = /[0-7]/;
+const hexNumberRegExp = /[0-9a-f]/i;
+const binaryNumberRegExp = /[01]/;
+const postNumberRegExp = /[\s)\]}(,;]/;
+const tokenizeNumber = (input, position) => {
+    let i;
+    const negate = input[position] === '-';
+    const plusPrefix = input[position] === '+';
+    const start = negate || plusPrefix ? position + 1 : position;
+    let hasDecimalPoint = false;
+    let hasExponent = false;
+    for (i = start; i < input.length; i += 1) {
+        const char = input[i];
+        if (char === '_') {
+            if (!decimalNumberRegExp.test(input[i - 1]) || !decimalNumberRegExp.test(input[i + 1])) {
+                if (i === start) {
+                    return NO_MATCH;
+                }
+                return [i - position + 1, ['Error', input.substring(position, i + 1), undefined, `Invalid number format at position ${i + 1}`]];
+            }
+        }
+        else if (char === '.') {
+            if (i === start) {
+                return NO_MATCH;
+            }
+            if (hasDecimalPoint || hasExponent) {
+                return [i - position + 1, ['Error', input.substring(position, i + 1), undefined, `Invalid number format at position ${i + 1}`]];
+            }
+            hasDecimalPoint = true;
+        }
+        else if (char === 'e' || char === 'E') {
+            if (i === start) {
+                return NO_MATCH;
+            }
+            if (hasExponent) {
+                return [i - position + 1, ['Error', input.substring(position, i + 1), undefined, `Invalid number format at position ${i + 1}`]];
+            }
+            if (input[i - 1] === '.' || input[i - 1] === '+' || input[i - 1] === '-') {
+                return [i - position + 1, ['Error', input.substring(position, i + 1), undefined, `Invalid number format at position ${i + 1}`]];
+            }
+            if (input[i + 1] === '+' || input[i + 1] === '-') {
+                i += 1;
+            }
+            hasExponent = true;
+        }
+        else if (!decimalNumberRegExp.test(char)) {
+            break;
+        }
     }
-}
-function asReservedSymbolToken(token, symbolName) {
-    assertReservedSymbolToken(token, symbolName);
-    return token;
-}
-function isShebangToken(token) {
-    return token?.[0] === 'Shebang';
-}
-function isSingleLineCommentToken(token) {
-    return token?.[0] === 'SingleLineComment';
-}
-function isMultiLineCommentToken(token) {
-    return token?.[0] === 'MultiLineComment';
-}
-function isOperatorToken(token, operatorName) {
-    if (token?.[0] !== 'Operator') {
-        return false;
+    if ((negate || plusPrefix) && i === start) {
+        return NO_MATCH;
     }
-    if (operatorName && token[1] !== operatorName) {
-        return false;
+    const length = i - position;
+    if (length === 0) {
+        return NO_MATCH;
     }
-    return true;
-}
-function assertOperatorToken(token, operatorName) {
-    if (!isOperatorToken(token, operatorName)) {
-        throwUnexpectedToken('Operator', operatorName, token);
+    const nextChar = input[i];
+    if (nextChar && nextChar !== ':' && !postNumberRegExp.test(nextChar)) {
+        return [i - position + 1, ['Error', input.substring(position, i + 1), undefined, `Invalid number format at position ${i + 1}`]];
     }
-}
-function isWhitespaceToken(token) {
-    return token?.[0] === 'Whitespace';
-}
-function isNumberToken(token) {
-    return token?.[0] === 'Number';
-}
-function isBasePrefixedNumberToken(token) {
-    return token?.[0] === 'BasePrefixedNumber';
-}
-function isLParenToken(token) {
-    return token?.[0] === 'LParen';
-}
-function assertLParenToken(token) {
-    if (!isLParenToken(token)) {
-        throwUnexpectedToken('LParen', undefined, token);
+    return [length, ['Number', input.substring(position, i)]];
+};
+const tokenizeBasePrefixedNumber = (input, position) => {
+    if (input[position] !== '0') {
+        return NO_MATCH;
     }
-}
-function isRParenToken(token) {
-    return token?.[0] === 'RParen';
-}
-function assertRParenToken(token) {
-    if (!isRParenToken(token)) {
-        throwUnexpectedToken('RParen', undefined, token);
+    const baseChar = input[position + 1];
+    const type = baseChar === 'b' || baseChar === 'B'
+        ? 'binary'
+        : baseChar === 'o' || baseChar === 'O'
+            ? 'octal'
+            : baseChar === 'x' || baseChar === 'X'
+                ? 'hex'
+                : null;
+    if (type === null) {
+        return NO_MATCH;
     }
-}
-function isLBracketToken(token) {
-    return token?.[0] === 'LBracket';
-}
-function assertLBracketToken(token) {
-    if (!isLBracketToken(token)) {
-        throwUnexpectedToken('LBracket', undefined, token);
+    let i;
+    for (i = position + 2; i < input.length; i += 1) {
+        const char = input[i];
+        if (type === 'binary' && !binaryNumberRegExp.test(char)) {
+            break;
+        }
+        if (type === 'octal' && !octalNumberRegExp.test(char)) {
+            break;
+        }
+        if (type === 'hex' && !hexNumberRegExp.test(char)) {
+            break;
+        }
     }
-}
-function asLBracketToken(token) {
-    assertLBracketToken(token);
-    return token;
-}
-function isRBracketToken(token) {
-    return token?.[0] === 'RBracket';
-}
-function assertRBracketToken(token) {
-    if (!isRBracketToken(token)) {
-        throwUnexpectedToken('RBracket', undefined, token);
+    const length = i - position;
+    if (length <= 2) {
+        return NO_MATCH;
     }
-}
-function isLBraceToken(token) {
-    return token?.[0] === 'LBrace';
-}
-function assertLBraceToken(token) {
-    if (!isLBraceToken(token)) {
-        throwUnexpectedToken('LBrace', undefined, token);
+    const nextChar = input[i];
+    if (nextChar && !postNumberRegExp.test(nextChar)) {
+        return NO_MATCH;
     }
-}
-function asLBraceToken(token) {
+    return [length, ['BasePrefixedNumber', input.substring(position, i)]];
+};
+const tokenizeSymbol = (input, position) => {
+    let value = input[position];
+    if (value === '\'') {
+        let length = 1;
+        let char = input[position + length];
+        let escaping = false;
+        while (char !== '\'' || escaping) {
+            if (char === undefined)
+                return [length, ['Error', value, undefined, `Unclosed quoted symbol at position ${position}`]];
+            length += 1;
+            if (escaping) {
+                escaping = false;
+                value += char;
+            }
+            else {
+                if (char === '\\') {
+                    escaping = true;
+                }
+                value += char;
+            }
+            char = input[position + length];
+        }
+        value += '\''; // closing quote
+        return [length + 1, ['Symbol', value]];
+    }
+    if (!illegalFirstSymbolCharacterSet.has(value)) {
+        const initialPosition = position;
+        position += 1;
+        let char = input[position];
+        while (char && !illegalSymbolCharacterSet.has(char)) {
+            value += char;
+            position += 1;
+            char = input[position];
+        }
+        // : can be used as symbol character, but it must not be the last character
+        return value.endsWith(':')
+            ? [position - initialPosition - 1, ['Symbol', value.slice(0, -1)]]
+            : [position - initialPosition, ['Symbol', value]];
+    }
+    return NO_MATCH;
+};
+const tokenizeReservedSymbolToken = (input, position) => {
+    const symbolMeta = tokenizeSymbol(input, position);
+    if (symbolMeta[0] === 0 || !symbolMeta[1]) {
+        return NO_MATCH;
+    }
+    let symbolName = symbolMeta[1][1];
+    symbolName = symbolName.startsWith('\'') ? symbolName.slice(1, symbolName.length - 1) : symbolName;
+    const info = reservedSymbolRecord[symbolName];
+    if (info === undefined) {
+        return NO_MATCH;
+    }
+    return [symbolMeta[0], ['ReservedSymbol', symbolName]];
+};
+const tokenizeOperator = (input, position) => {
+    const threeChars = input.slice(position, position + 3);
+    if (position + 2 < input.length && isSymbolicOperator(threeChars)) {
+        return [3, ['Operator', threeChars]];
+    }
+    const twoChars = input.slice(position, position + 2);
+    if (position + 1 < input.length && isSymbolicOperator(twoChars)) {
+        return [2, ['Operator', twoChars]];
+    }
+    const oneChar = input[position] ?? '';
+    if (isSymbolicOperator(oneChar)) {
+        return [1, ['Operator', oneChar]];
+    }
+    return NO_MATCH;
+};
+const tokenizeMultiLineComment = (input, position) => {
+    if (input[position] === '/' && input[position + 1] === '*') {
+        let length = 2;
+        let value = '/*';
+        while ((input[position + length] !== '*' || input[position + length + 1] !== '/') && position + length + 1 < input.length) {
+            value += input[position + length];
+            length += 1;
+        }
+        if (position + length + 1 >= input.length) {
+            return [length, ['Error', value, undefined, `Unclosed multi-line comment at position ${position}`]];
+        }
+        value += '*/';
+        length += 2;
+        return [length, ['MultiLineComment', value]];
+    }
+    return NO_MATCH;
+};
+const tokenizeShebang = (input, position) => {
+    if (input[position] === '#' && input[position + 1] === '!') {
+        let length = 2;
+        let value = '#!';
+        while (input[position + length] !== '\n' && position + length < input.length) {
+            value += input[position + length];
+            length += 1;
+        }
+        return [length, ['SingleLineComment', value]];
+    }
+    return NO_MATCH;
+};
+const tokenizeSingleLineComment = (input, position) => {
+    if (input[position] === '/' && input[position + 1] === '/') {
+        let length = 2;
+        let value = '//';
+        while (input[position + length] !== '\n' && position + length < input.length) {
+            value += input[position + length];
+            length += 1;
+        }
+        return [length, ['SingleLineComment', value]];
+    }
+    return NO_MATCH;
+};
+// All tokenizers, order matters!
+const tokenizers = [
+    tokenizeWhitespace,
+    tokenizeMultiLineComment,
+    tokenizeSingleLineComment,
+    tokenizeReservedSymbolToken,
+    tokenizeLParen,
+    tokenizeRParen,
+    tokenizeLBracket,
+    tokenizeRBracket,
+    tokenizeLBrace,
+    tokenizeRBrace,
+    tokenizeString,
+    tokenizeRegexpShorthand,
+    tokenizeBasePrefixedNumber,
+    tokenizeNumber,
+    tokenizeOperator,
+    tokenizeSymbol,
+];
+
+function tokenize(input, debug, filePath) {
+    let position = 0;
+    const tokenStream = {
+        tokens: [],
+        filePath,
+        hasDebugData: debug,
+    };
+    while (position < input.length) {
+        const sourceCodeInfo = debug
+            ? createSourceCodeInfo(input, position, filePath)
+            : undefined;
+        const tokenDescriptor = getCurrentToken(input, position);
+        const [count, token] = tokenDescriptor;
+        position += count;
+        if (token) {
+            if (sourceCodeInfo) {
+                token[2] = sourceCodeInfo;
+            }
+            tokenStream.tokens.push(token);
+        }
+    }
+    return tokenStream;
+}
+function getSourceCodeLine(input, lineNbr) {
+    return input.split(/\r\n|\r|\n/)[lineNbr];
+}
+function createSourceCodeInfo(input, position, filePath) {
+    const lines = input.substring(0, position + 1).split(/\r\n|\r|\n/);
+    const lastLine = lines[lines.length - 1];
+    const code = getSourceCodeLine(input, lines.length - 1);
+    const line = lines.length;
+    const column = lastLine.length;
+    return {
+        code,
+        position: {
+            line,
+            column,
+        },
+        filePath,
+    };
+}
+function getCurrentToken(input, position) {
+    const initialPosition = position;
+    if (position === 0) {
+        const [nbrOfCharacters, token] = tokenizeShebang(input, position);
+        position += nbrOfCharacters;
+        if (nbrOfCharacters > 0) {
+            return [position - initialPosition, token];
+        }
+    }
+    for (const tokenizer of tokenizers) {
+        const [nbrOfCharacters, token] = tokenizer(input, position);
+        position += nbrOfCharacters;
+        if (nbrOfCharacters === 0) {
+            continue;
+        }
+        return [position - initialPosition, token];
+    }
+    return [1, ['Error', input[initialPosition], undefined, 'Unrecognized character']];
+}
+
+const dvalaCommands = new Set([...normalExpressionKeys, ...specialExpressionKeys, ...Object.keys(reservedSymbolRecord)]);
+// TODO: replace with get suggestions function
+class AutoCompleter {
+    originalProgram;
+    originalPosition;
+    prefixProgram = '';
+    suffixProgram = '';
+    searchString = '';
+    suggestions = [];
+    suggestionIndex = null;
+    constructor(originalProgram, originalPosition, params = {}) {
+        this.originalProgram = originalProgram;
+        this.originalPosition = originalPosition;
+        const partialProgram = this.originalProgram.slice(0, this.originalPosition);
+        const tokenStream = tokenize(partialProgram, false, undefined);
+        const lastToken = tokenStream.tokens.at(-1);
+        if (!lastToken) {
+            return;
+        }
+        if (lastToken[0] === 'Error') {
+            return;
+        }
+        this.searchString = lastToken[1];
+        this.prefixProgram = this.originalProgram.slice(0, this.originalPosition - this.searchString.length);
+        this.suffixProgram = this.originalProgram.slice(this.prefixProgram.length + this.searchString.length);
+        this.originalProgram.slice(this.prefixProgram.length + this.searchString.length);
+        this.suggestions = this.generateSuggestions(params);
+    }
+    getNextSuggestion() {
+        return this.getAutoCompleteSuggestionResult(this.getNextSuggestionSymbol());
+    }
+    getPreviousSuggestion() {
+        return this.getAutoCompleteSuggestionResult(this.getPreviousSuggestionSymbol());
+    }
+    getAutoCompleteSuggestionResult(suggestion) {
+        if (suggestion === null) {
+            return null;
+        }
+        return {
+            program: this.prefixProgram + suggestion + this.suffixProgram,
+            position: this.prefixProgram.length + suggestion.length,
+        };
+    }
+    getNextSuggestionSymbol() {
+        if (this.suggestions.length === 0) {
+            return null;
+        }
+        if (this.suggestionIndex === null) {
+            this.suggestionIndex = 0;
+        }
+        else {
+            this.suggestionIndex += 1;
+            if (this.suggestionIndex >= this.suggestions.length) {
+                this.suggestionIndex = 0;
+            }
+        }
+        return this.suggestions[this.suggestionIndex];
+    }
+    getPreviousSuggestionSymbol() {
+        if (this.suggestions.length === 0) {
+            return null;
+        }
+        if (this.suggestionIndex === null) {
+            this.suggestionIndex = this.suggestions.length - 1;
+        }
+        else {
+            this.suggestionIndex -= 1;
+            if (this.suggestionIndex < 0) {
+                this.suggestionIndex = this.suggestions.length - 1;
+            }
+        }
+        return this.suggestions[this.suggestionIndex];
+    }
+    getSuggestions() {
+        return [...this.suggestions];
+    }
+    getSearchString() {
+        return this.searchString;
+    }
+    generateSuggestions(params) {
+        const blacklist = new Set(['0_defn', '0_lambda']);
+        const startsWithCaseSensitive = this.generateWithPredicate(params, suggestion => !blacklist.has(suggestion) && suggestion.startsWith(this.searchString));
+        startsWithCaseSensitive.forEach(suggestion => blacklist.add(suggestion));
+        const startsWithCaseInsensitive = this.generateWithPredicate(params, suggestion => !blacklist.has(suggestion) && suggestion.toLowerCase().startsWith(this.searchString.toLowerCase()));
+        startsWithCaseInsensitive.forEach(suggestion => blacklist.add(suggestion));
+        const includesCaseSensitive = this.generateWithPredicate(params, suggestion => !blacklist.has(suggestion) && suggestion.includes(this.searchString));
+        includesCaseSensitive.forEach(suggestion => blacklist.add(suggestion));
+        const includesCaseInsensitive = this.generateWithPredicate(params, suggestion => !blacklist.has(suggestion) && suggestion.includes(this.searchString.toLowerCase()));
+        includesCaseInsensitive.forEach(suggestion => blacklist.add(suggestion));
+        return [...startsWithCaseSensitive, ...startsWithCaseInsensitive, ...includesCaseSensitive, ...includesCaseInsensitive];
+    }
+    generateWithPredicate(params, shouldInclude) {
+        const suggestions = new Set();
+        dvalaCommands.forEach((suggestion) => {
+            if (shouldInclude(suggestion)) {
+                suggestions.add(suggestion);
+            }
+        });
+        Object.keys(params.bindings ?? {})
+            .filter(shouldInclude)
+            .forEach(suggestion => suggestions.add(suggestion));
+        return [...suggestions].sort((a, b) => a.localeCompare(b));
+    }
+}
+
+function isSymbolNode(node) {
+    const nodeType = node[0];
+    return NodeTypes.UserDefinedSymbol === nodeType
+        || NodeTypes.NormalBuiltinSymbol === nodeType
+        || NodeTypes.SpecialBuiltinSymbol === nodeType;
+}
+function isUserDefinedSymbolNode(node) {
+    return NodeTypes.UserDefinedSymbol === node[0];
+}
+function asUserDefinedSymbolNode(node, sourceCodeInfo) {
+    assertUserDefinedSymbolNode(node, sourceCodeInfo);
+    return node;
+}
+function assertUserDefinedSymbolNode(node, sourceCodeInfo) {
+    if (!isUserDefinedSymbolNode(node))
+        throw getAssertionError('UserDefinedSymbolNode', node, sourceCodeInfo);
+}
+function isNormalBuiltinSymbolNode(node) {
+    return NodeTypes.NormalBuiltinSymbol === node[0];
+}
+function isSpecialBuiltinSymbolNode(node) {
+    return NodeTypes.SpecialBuiltinSymbol === node[0];
+}
+function isNormalExpressionNode(node) {
+    return node[0] === NodeTypes.NormalExpression;
+}
+function isNormalExpressionNodeWithName(node) {
+    if (!isNormalExpressionNode(node)) {
+        return false;
+    }
+    return isSymbolNode(node[1][0]);
+}
+function isSpreadNode(node) {
+    return node[0] === NodeTypes.Spread;
+}
+
+function isContextEntry(value) {
+    return isUnknownRecord(value) && value.value !== undefined;
+}
+
+class ContextStackImpl {
+    _contexts;
+    globalContext;
+    values;
+    modules;
+    valueModules;
+    pure;
+    constructor({ contexts, values: hostValues, modules, valueModules, pure, }) {
+        this.globalContext = asNonUndefined(contexts[0]);
+        this._contexts = contexts;
+        this.values = hostValues;
+        this.modules = modules ?? new Map();
+        this.valueModules = valueModules ?? new Map();
+        this.pure = pure ?? false;
+    }
+    // -- Serialization support (Phase 4) --
+    /** Get the raw context chain for serialization. */
+    getContextsRaw() {
+        return this._contexts;
+    }
+    /** Get host values (plain bindings passed at creation). */
+    getHostValues() {
+        return this.values;
+    }
+    /** Get the top-level module scope as plain key→value bindings. */
+    getModuleScopeBindings() {
+        const scope = this._contexts[0];
+        const result = {};
+        for (const [k, v] of Object.entries(scope))
+            result[k] = v.value;
+        return result;
+    }
+    /**
+     * Find the index of globalContext in the _contexts array.
+     * Returns -1 if not found (should not happen in valid state).
+     */
+    getGlobalContextIndex() {
+        return this._contexts.indexOf(this.globalContext);
+    }
+    /**
+     * Create a ContextStack from deserialized data.
+     * `contexts` is the restored context chain (already resolved).
+     * `globalContextIndex` identifies which element is the globalContext.
+     * Host bindings (`values`, `modules`) come from resume options.
+     */
+    static fromDeserialized(params) {
+        const cs = new ContextStackImpl({
+            contexts: params.contexts,
+            values: params.values,
+            modules: params.modules,
+            pure: params.pure,
+        });
+        if (params.globalContextIndex >= 0 && params.globalContextIndex < params.contexts.length) {
+            cs.globalContext = params.contexts[params.globalContextIndex];
+        }
+        return cs;
+    }
+    /**
+     * Replace the contexts array and globalContext. Used during deserialization
+     * to fill in resolved context data after circular references are handled.
+     */
+    setContextsFromDeserialized(contexts, globalContextIndex) {
+        this._contexts = contexts;
+        if (globalContextIndex >= 0 && globalContextIndex < contexts.length) {
+            this.globalContext = contexts[globalContextIndex];
+        }
+    }
+    getModule(name) {
+        return this.modules.get(name);
+    }
+    getValueModule(name) {
+        if (this.valueModules.has(name)) {
+            return { value: this.valueModules.get(name), found: true };
+        }
+        return { value: undefined, found: false };
+    }
+    registerValueModule(name, value) {
+        this.valueModules.set(name, value);
+    }
+    create(context) {
+        const globalContext = this.globalContext;
+        const contextStack = new ContextStackImpl({
+            contexts: [context, ...this._contexts],
+            values: this.values,
+            modules: this.modules,
+            valueModules: this.valueModules,
+            pure: this.pure,
+        });
+        contextStack.globalContext = globalContext;
+        return contextStack;
+    }
+    new(context) {
+        const contexts = [{}, context];
+        return new ContextStackImpl({ contexts, modules: this.modules, valueModules: this.valueModules, pure: this.pure });
+    }
+    addValues(values, sourceCodeInfo) {
+        const currentContext = this._contexts[0];
+        for (const [name, value] of Object.entries(values)) {
+            if (currentContext[name]) {
+                throw new DvalaError(`Cannot redefine value "${name}"`, sourceCodeInfo);
+            }
+            const shadowedName = getShadowedBuiltinName(name);
+            if (shadowedName) {
+                throw new DvalaError(`Cannot shadow ${shadowedName}`, sourceCodeInfo);
+            }
+            currentContext[name] = { value: toAny(value) };
+        }
+    }
+    getValue(name) {
+        for (const context of this._contexts) {
+            const contextEntry = context[name];
+            if (contextEntry)
+                return contextEntry.value;
+        }
+        return this.values?.[name];
+    }
+    lookUp(node) {
+        const value = node[1];
+        for (const context of this._contexts) {
+            const contextEntry = context[value];
+            if (contextEntry)
+                return contextEntry;
+        }
+        const hostValue = this.values?.[value];
+        if (hostValue !== undefined) {
+            return {
+                value: toAny(hostValue),
+            };
+        }
+        return null;
+    }
+    evaluateSymbol(node) {
+        if (isSpecialBuiltinSymbolNode(node)) {
+            const functionType = node[1];
+            switch (functionType) {
+                case specialExpressionTypes['&&']:
+                case specialExpressionTypes['||']:
+                case specialExpressionTypes.array:
+                case specialExpressionTypes.object:
+                case specialExpressionTypes['defined?']:
+                case specialExpressionTypes.recur:
+                case specialExpressionTypes['??']: {
+                    const specialExpression = asNonUndefined(builtin.specialExpressions[functionType], node[2]);
+                    return {
+                        [FUNCTION_SYMBOL]: true,
+                        functionType: 'SpecialBuiltin',
+                        specialBuiltinSymbolType: functionType,
+                        sourceCodeInfo: node[2],
+                        arity: specialExpression.arity,
+                    };
+                }
+                default:
+                    throw new DvalaError(`Unknown special builtin symbol type: ${functionType}`, node[2]);
+            }
+        }
+        if (isNormalBuiltinSymbolNode(node)) {
+            const type = node[1];
+            const normalExpression = allNormalExpressions[type];
+            const name = normalExpression.name;
+            return {
+                [FUNCTION_SYMBOL]: true,
+                functionType: 'Builtin',
+                normalBuiltinSymbolType: type,
+                sourceCodeInfo: node[2],
+                arity: normalExpression.arity,
+                name,
+            };
+        }
+        const lookUpResult = this.lookUp(node);
+        if (isContextEntry(lookUpResult))
+            return lookUpResult.value;
+        throw new UndefinedSymbolError(node[1], node[2]);
+    }
+}
+function getShadowedBuiltinName(name) {
+    if (specialExpressionKeys.includes(name))
+        return `special expression "${name}"`;
+    if (normalExpressionKeys.includes(name))
+        return `builtin function "${name}"`;
+    if (name === 'self')
+        return `builtin value "${name}"`;
+    return null;
+}
+function assertNotShadowingBuiltin(name) {
+    const shadowedName = getShadowedBuiltinName(name);
+    if (shadowedName) {
+        throw new DvalaError(`Cannot shadow ${shadowedName}`, undefined);
+    }
+}
+function createContextStack(params = {}, modules, pure) {
+    const globalContext = params.globalContext ?? {};
+    // Contexts are checked from left to right
+    const contexts = params.contexts ? [globalContext, ...params.contexts] : [globalContext];
+    let hostValues;
+    if (params.bindings) {
+        for (const [identifier, entry] of Object.entries(params.bindings)) {
+            if (identifier.includes('.')) {
+                throw new DvalaError(`Dots are not allowed in binding keys: "${identifier}"`, undefined);
+            }
+            assertNotShadowingBuiltin(identifier);
+            if (!hostValues) {
+                hostValues = {};
+            }
+            hostValues[identifier] = entry;
+        }
+    }
+    const contextStack = new ContextStackImpl({
+        contexts,
+        values: hostValues,
+        modules,
+        pure,
+    });
+    return params.globalModuleScope ? contextStack : contextStack.create({});
+}
+
+const getUndefinedSymbols$1 = (ast, contextStack, builtin, evaluateNode) => {
+    const nodes = Array.isArray(ast)
+        ? ast
+        : [[NodeTypes.SpecialExpression, [specialExpressionTypes.block, ast.body, undefined]]];
+    const unresolvedSymbols = new Set();
+    for (const subNode of nodes) {
+        findUnresolvedSymbolsInNode(subNode, contextStack, builtin, evaluateNode)
+            ?.forEach(symbol => unresolvedSymbols.add(symbol));
+    }
+    return unresolvedSymbols;
+};
+function findUnresolvedSymbolsInNode(node, contextStack, builtin, evaluateNode) {
+    const nodeType = node[0];
+    switch (nodeType) {
+        case NodeTypes.UserDefinedSymbol: {
+            const symbolNode = node;
+            const lookUpResult = contextStack.lookUp(symbolNode);
+            if (lookUpResult === null)
+                return new Set([symbolNode[1]]);
+            return null;
+        }
+        case NodeTypes.NormalBuiltinSymbol:
+        case NodeTypes.SpecialBuiltinSymbol:
+        case NodeTypes.String:
+        case NodeTypes.Number:
+        case NodeTypes.ReservedSymbol:
+        case NodeTypes.Binding:
+            return null;
+        case NodeTypes.NormalExpression: {
+            const normalExpressionNode = node;
+            const unresolvedSymbols = new Set();
+            if (isNormalExpressionNodeWithName(normalExpressionNode)) {
+                const [, [symbolNode]] = normalExpressionNode;
+                if (isUserDefinedSymbolNode(symbolNode)) {
+                    const lookUpResult = contextStack.lookUp(symbolNode);
+                    if (lookUpResult === null)
+                        unresolvedSymbols.add(symbolNode[1]);
+                }
+            }
+            else {
+                const [, [expressionNode]] = normalExpressionNode;
+                findUnresolvedSymbolsInNode(expressionNode, contextStack, builtin, evaluateNode)?.forEach(symbol => unresolvedSymbols.add(symbol));
+            }
+            for (const subNode of normalExpressionNode[1][1]) {
+                findUnresolvedSymbolsInNode(subNode, contextStack, builtin, evaluateNode)?.forEach(symbol => unresolvedSymbols.add(symbol));
+            }
+            return unresolvedSymbols;
+        }
+        case NodeTypes.SpecialExpression: {
+            const specialExpressionNode = node;
+            const specialExpressionType = specialExpressionNode[1][0];
+            const specialExpression = builtin.specialExpressions[specialExpressionType];
+            const castedGetUndefinedSymbols = specialExpression.getUndefinedSymbols;
+            return castedGetUndefinedSymbols(specialExpressionNode, contextStack, {
+                getUndefinedSymbols: getUndefinedSymbols$1,
+                builtin,
+                evaluateNode,
+            });
+        }
+        case NodeTypes.Spread:
+            return findUnresolvedSymbolsInNode(node[1], contextStack, builtin, evaluateNode);
+        /* v8 ignore next 2 */
+        default:
+            throw new DvalaError(`Unhandled node type: ${nodeType}`, node[2]);
+    }
+}
+
+function isSymbolToken(token, symbolName) {
+    if (token?.[0] !== 'Symbol') {
+        return false;
+    }
+    if (symbolName && token[1] !== symbolName) {
+        return false;
+    }
+    return true;
+}
+function assertSymbolToken(token, symbolName) {
+    if (!isSymbolToken(token, symbolName)) {
+        throwUnexpectedToken('Symbol', undefined, token);
+    }
+}
+function asSymbolToken(token, symbolName) {
+    assertSymbolToken(token, symbolName);
+    return token;
+}
+function isReservedSymbolToken(token, symbolName) {
+    if (token?.[0] !== 'ReservedSymbol') {
+        return false;
+    }
+    if (symbolName && token[1] !== symbolName) {
+        return false;
+    }
+    return true;
+}
+function assertReservedSymbolToken(token, symbolName) {
+    if (!isReservedSymbolToken(token, symbolName)) {
+        throwUnexpectedToken('ReservedSymbol', symbolName, token);
+    }
+}
+function asReservedSymbolToken(token, symbolName) {
+    assertReservedSymbolToken(token, symbolName);
+    return token;
+}
+function isShebangToken(token) {
+    return token?.[0] === 'Shebang';
+}
+function isSingleLineCommentToken(token) {
+    return token?.[0] === 'SingleLineComment';
+}
+function isMultiLineCommentToken(token) {
+    return token?.[0] === 'MultiLineComment';
+}
+function isOperatorToken(token, operatorName) {
+    if (token?.[0] !== 'Operator') {
+        return false;
+    }
+    if (operatorName && token[1] !== operatorName) {
+        return false;
+    }
+    return true;
+}
+function assertOperatorToken(token, operatorName) {
+    if (!isOperatorToken(token, operatorName)) {
+        throwUnexpectedToken('Operator', operatorName, token);
+    }
+}
+function isWhitespaceToken(token) {
+    return token?.[0] === 'Whitespace';
+}
+function isNumberToken(token) {
+    return token?.[0] === 'Number';
+}
+function isBasePrefixedNumberToken(token) {
+    return token?.[0] === 'BasePrefixedNumber';
+}
+function isLParenToken(token) {
+    return token?.[0] === 'LParen';
+}
+function assertLParenToken(token) {
+    if (!isLParenToken(token)) {
+        throwUnexpectedToken('LParen', undefined, token);
+    }
+}
+function isRParenToken(token) {
+    return token?.[0] === 'RParen';
+}
+function assertRParenToken(token) {
+    if (!isRParenToken(token)) {
+        throwUnexpectedToken('RParen', undefined, token);
+    }
+}
+function isLBracketToken(token) {
+    return token?.[0] === 'LBracket';
+}
+function assertLBracketToken(token) {
+    if (!isLBracketToken(token)) {
+        throwUnexpectedToken('LBracket', undefined, token);
+    }
+}
+function asLBracketToken(token) {
+    assertLBracketToken(token);
+    return token;
+}
+function isRBracketToken(token) {
+    return token?.[0] === 'RBracket';
+}
+function assertRBracketToken(token) {
+    if (!isRBracketToken(token)) {
+        throwUnexpectedToken('RBracket', undefined, token);
+    }
+}
+function isLBraceToken(token) {
+    return token?.[0] === 'LBrace';
+}
+function assertLBraceToken(token) {
+    if (!isLBraceToken(token)) {
+        throwUnexpectedToken('LBrace', undefined, token);
+    }
+}
+function asLBraceToken(token) {
     assertLBraceToken(token);
     return token;
 }
@@ -6521,9 +7316,6 @@ function assertRBraceToken(token) {
 function isStringToken(token) {
     return token?.[0] === 'string';
 }
-function isDocStringToken(token) {
-    return token?.[0] === 'DocString';
-}
 function isA_BinaryOperatorToken(token) {
     return token?.[0] === 'Operator' && isBinaryOperator(token[1]);
 }
@@ -6799,49 +7591,9 @@ function parseCond(ctx, token) {
     return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.cond, params]], token[2]);
 }
 
-function parseString(ctx, token) {
-    ctx.advance();
-    const value = token[1].substring(1, token[1].length - 1)
-        .replace(/(\\{2})|(\\")|(\\n)|(\\t)|(\\r)|(\\b)|(\\f)|\\(.)/g, (_, backslash, doubleQuote, newline, tab, carriageReturn, backspace, formFeed, normalChar) => {
-        // If it's a double escape (\\x), return \x
-        if (backslash) {
-            return '\\';
-        }
-        // If it's a special character (\n, \t, \r, \b, \f), return the special character
-        else if (newline) {
-            return '\n';
-        }
-        else if (tab) {
-            return '\t';
-        }
-        else if (carriageReturn) {
-            return '\r';
-        }
-        else if (backspace) {
-            return '\b';
-        }
-        else if (formFeed) {
-            return '\f';
-        }
-        else if (doubleQuote) {
-            return '"';
-        }
-        return normalChar;
-    });
-    return withSourceCodeInfo([NodeTypes.String, value], token[2]);
-}
-
-function parseDo(ctx, allowDocString = false) {
+function parseDo(ctx) {
     const token = asReservedSymbolToken(ctx.tryPeek(), 'do');
     ctx.advance();
-    let docString = '';
-    if (allowDocString && isDocStringToken(ctx.tryPeek())) {
-        docString = parseDocString(ctx);
-        if (!ctx.isAtEnd() && !isReservedSymbolToken(ctx.tryPeek(), 'end') && !isReservedSymbolToken(ctx.tryPeek(), 'with')) {
-            assertOperatorToken(ctx.tryPeek(), ';');
-            ctx.advance();
-        }
-    }
     const expressions = [];
     while (!ctx.isAtEnd() && !isReservedSymbolToken(ctx.tryPeek(), 'end') && !isReservedSymbolToken(ctx.tryPeek(), 'with')) {
         expressions.push(ctx.parseExpression());
@@ -6869,16 +7621,7 @@ function parseDo(ctx, allowDocString = false) {
     }
     assertReservedSymbolToken(ctx.tryPeek(), 'end');
     ctx.advance();
-    return [
-        withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.block, expressions, withHandlers]], token[2]),
-        docString,
-    ];
-}
-function parseDocString(ctx) {
-    const token = ctx.peek();
-    const stringToken = token[2] ? ['string', token[1].slice(2, -2), token[2]] : ['string', token[1].slice(2, -2)];
-    const stringNode = parseString(ctx, stringToken);
-    return smartTrim(stringNode[1]); // Extract the string value from the StringNode
+    return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.block, expressions, withHandlers]], token[2]);
 }
 
 function parseSymbol(ctx) {
@@ -6895,6 +7638,38 @@ function parseSymbol(ctx) {
     }
 }
 
+function parseString(ctx, token) {
+    ctx.advance();
+    const value = token[1].substring(1, token[1].length - 1)
+        .replace(/(\\{2})|(\\")|(\\n)|(\\t)|(\\r)|(\\b)|(\\f)|\\(.)/g, (_, backslash, doubleQuote, newline, tab, carriageReturn, backspace, formFeed, normalChar) => {
+        // If it's a double escape (\\x), return \x
+        if (backslash) {
+            return '\\';
+        }
+        // If it's a special character (\n, \t, \r, \b, \f), return the special character
+        else if (newline) {
+            return '\n';
+        }
+        else if (tab) {
+            return '\t';
+        }
+        else if (carriageReturn) {
+            return '\r';
+        }
+        else if (backspace) {
+            return '\b';
+        }
+        else if (formFeed) {
+            return '\f';
+        }
+        else if (doubleQuote) {
+            return '"';
+        }
+        return normalChar;
+    });
+    return withSourceCodeInfo([NodeTypes.String, value], token[2]);
+}
+
 function parseNumber(ctx) {
     const token = ctx.peek();
     ctx.advance();
@@ -7268,56 +8043,6 @@ function parseRegexpShorthand(ctx) {
     return node;
 }
 
-const nonNumberReservedSymbolRecord = {
-    true: true,
-    false: false,
-    null: null,
-    do: null,
-    else: null,
-    case: null,
-    each: null,
-    in: null,
-    when: null,
-    while: null,
-    function: null,
-    as: null,
-    then: null,
-    end: null,
-    with: null,
-    _: null,
-};
-const phi = (1 + Math.sqrt(5)) / 2;
-const numberReservedSymbolRecord = {
-    'E': Math.E,
-    '-E': -Math.E,
-    'ε': Math.E,
-    '-ε': -Math.E,
-    'PI': Math.PI,
-    '-PI': -Math.PI,
-    'π': Math.PI,
-    '-π': -Math.PI,
-    'PHI': phi,
-    '-PHI': -phi,
-    'φ': phi,
-    '-φ': -phi,
-    'POSITIVE_INFINITY': Number.POSITIVE_INFINITY,
-    '∞': Number.POSITIVE_INFINITY,
-    'NEGATIVE_INFINITY': Number.NEGATIVE_INFINITY,
-    '-∞': Number.NEGATIVE_INFINITY,
-    'MAX_SAFE_INTEGER': Number.MAX_SAFE_INTEGER,
-    'MIN_SAFE_INTEGER': Number.MIN_SAFE_INTEGER,
-    'MAX_VALUE': Number.MAX_VALUE,
-    'MIN_VALUE': Number.MIN_VALUE,
-    'NaN': Number.NaN,
-};
-const reservedSymbolRecord = {
-    ...nonNumberReservedSymbolRecord,
-    ...numberReservedSymbolRecord,
-};
-function isNumberReservedSymbol(symbol) {
-    return symbol in numberReservedSymbolRecord;
-}
-
 function parseReservedSymbol(ctx) {
     const token = asReservedSymbolToken(ctx.tryPeek());
     ctx.advance();
@@ -7369,11 +8094,8 @@ function parseLambdaFunction(ctx) {
         }
         ctx.advance();
         let nodes;
-        let docString = '';
         if (isReservedSymbolToken(ctx.peek(), 'do')) {
-            const parsedDo = parseDo(ctx, true);
-            docString = parsedDo[1];
-            const doNode = parsedDo[0];
+            const doNode = parseDo(ctx);
             const withHandlers = doNode[1][2];
             if (withHandlers && withHandlers.length > 0) {
                 // do...with...end: preserve the full DoNode as a single expression so
@@ -7396,7 +8118,6 @@ function parseLambdaFunction(ctx) {
                     functionArguments,
                     nodes,
                 ],
-                docString,
             ],
         ], firstToken[2]);
     }
@@ -7448,11 +8169,8 @@ function parseShorthandLambdaFunction(ctx) {
     // TODO, do not like this...
     const startPos = ctx.getPosition();
     let nodes;
-    let docString = '';
     if (isReservedSymbolToken(ctx.peek(), 'do')) {
-        const parsedDo = parseDo(ctx, true);
-        docString = parsedDo[1];
-        const doNode = parsedDo[0];
+        const doNode = parseDo(ctx);
         const withHandlers = doNode[1][2];
         if (withHandlers && withHandlers.length > 0) {
             // do...with...end: preserve the full DoNode so the with-handlers are not lost.
@@ -7499,7 +8217,7 @@ function parseShorthandLambdaFunction(ctx) {
     const node = withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes['0_lambda'], [
                 functionArguments,
                 nodes,
-            ], docString]], firstToken[2]);
+            ]]], firstToken[2]);
     return node;
 }
 
@@ -7780,575 +8498,141 @@ function parseMatch(ctx, token) {
             ctx.advance();
             guard = ctx.parseExpression();
         }
-        assertReservedSymbolToken(ctx.tryPeek(), 'then');
-        ctx.advance();
-        const thenExpression = parseImplicitBlock(ctx, ['case', 'end']);
-        params.push([pattern, thenExpression, guard]);
-        if (isReservedSymbolToken(ctx.tryPeek(), 'end')) {
-            break;
-        }
-    }
-    assertReservedSymbolToken(ctx.tryPeek(), 'end');
-    ctx.advance();
-    return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.match, valueExpression, params]], token[2]);
-}
-
-function createParserContext(tokenStream) {
-    const ctx = new ParserContext(tokenStream);
-    ctx.parseExpression = (precedence = 0) => parseExpression(ctx, precedence);
-    return ctx;
-}
-function parseExpression(ctx, precedence = 0) {
-    const token = ctx.tryPeek();
-    let left;
-    if (isSymbolToken(token)) {
-        switch (token[1]) {
-            case 'let':
-                return parseLet(ctx, token);
-            case 'if':
-            case 'unless':
-                left = parseIfOrUnless(ctx, token);
-                break;
-            case 'cond':
-                left = parseCond(ctx, token);
-                break;
-            case 'match':
-                left = parseMatch(ctx, token);
-                break;
-            case 'for':
-            case 'doseq':
-                left = parseForOrDoseq(ctx, token);
-                break;
-            case 'loop':
-                left = parseLoop(ctx, token);
-                break;
-        }
-    }
-    else if (isReservedSymbolToken(token, 'do')) {
-        left = parseDo(ctx)[0];
-    }
-    left ||= parseOperand(ctx);
-    let operator = ctx.tryPeek();
-    while (!isAtExpressionEnd(ctx)) {
-        if (isA_BinaryOperatorToken(operator)) {
-            const name = operator[1];
-            const newPrecedece = getPrecedence(name, operator[2]);
-            if (newPrecedece <= precedence
-                // ^ (exponentiation) is right associative
-                && !(newPrecedece === exponentiationPrecedence && precedence === exponentiationPrecedence)) {
-                break;
-            }
-            const symbol = specialExpressionTypes[name]
-                ? withSourceCodeInfo([NodeTypes.SpecialBuiltinSymbol, specialExpressionTypes[name]], operator[2])
-                : withSourceCodeInfo([NodeTypes.NormalBuiltinSymbol, normalExpressionTypes[name]], operator[2]);
-            ctx.advance();
-            const right = parseExpression(ctx, newPrecedece);
-            left = fromBinaryOperatorToNode(operator, symbol, left, right, operator[2]);
-        }
-        else if (isSymbolToken(operator)) {
-            if (!isFunctionOperator(operator[1])) {
-                break;
-            }
-            const newPrecedence = binaryFunctionalOperatorPrecedence;
-            if (newPrecedence <= precedence) {
-                break;
-            }
-            const operatorSymbol = parseSymbol(ctx);
-            const right = parseExpression(ctx, newPrecedence);
-            if (isSpecialBuiltinSymbolNode(operatorSymbol)) {
-                throw new DvalaError('Special expressions are not allowed in binary functional operators', operatorSymbol[2]);
-            }
-            left = createNamedNormalExpressionNode(operatorSymbol, [left, right], operator[2]);
-        }
-        else if (operator?.[1] === '?') {
-            if (conditionalOperatorPrecedence <= precedence) {
-                break;
-            }
-            ctx.advance();
-            const trueNode = parseExpression(ctx);
-            if (!isOperatorToken(ctx.tryPeek(), ':')) {
-                throw new DvalaError('Expected :', ctx.peekSourceCodeInfo());
-            }
-            ctx.advance();
-            const falseNode = parseExpression(ctx);
-            left = withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.if, [left, trueNode, falseNode]]], left[2]);
-        }
-        else {
-            break;
-        }
-        operator = ctx.tryPeek();
-    }
-    return left;
-}
-
-function parse(tokenStream) {
-    tokenStream.tokens.forEach((token) => {
-        if (token[0] === 'Error') {
-            throw new DvalaError(token[3], token[2]);
-        }
-    });
-    const nodes = [];
-    const ctx = createParserContext(tokenStream);
-    while (!ctx.isAtEnd()) {
-        nodes.push(parseExpression(ctx, 0));
-        if (isOperatorToken(ctx.tryPeek(), ';')) {
-            ctx.advance();
-        }
-        else {
-            if (!ctx.isAtEnd()) {
-                throw new DvalaError('Expected ;', ctx.peekSourceCodeInfo());
-            }
-        }
-    }
-    return nodes;
-}
-
-function minifyTokenStream(tokenStream, { removeWhiteSpace }) {
-    const tokens = tokenStream.tokens
-        .filter((token) => {
-        if (isSingleLineCommentToken(token)
-            || isMultiLineCommentToken(token)
-            || isShebangToken(token)
-            || (removeWhiteSpace && isWhitespaceToken(token))) {
-            return false;
-        }
-        return true;
-    });
-    return { ...tokenStream, tokens };
-}
-
-const illegalSymbolCharacters = [
-    '(',
-    ')',
-    '[',
-    ']',
-    '{',
-    '}',
-    '\'',
-    '"',
-    '`',
-    ',',
-    '.',
-    ';',
-    ' ',
-    '\n',
-    '\r',
-    '\t',
-];
-const illegalFirstSymbolCharacters = [
-    '0',
-    '1',
-    '2',
-    '3',
-    '4',
-    '5',
-    '6',
-    '7',
-    '8',
-    '9',
-    ...illegalSymbolCharacters,
-];
-const illegalSymbolCharacterSet = new Set(illegalSymbolCharacters);
-const illegalFirstSymbolCharacterSet = new Set(illegalFirstSymbolCharacters);
-const whitespaceRegExp = /\s/;
-const NO_MATCH = [0];
-const tokenizeLParen = (input, position) => tokenizeToken('LParen', '(', input, position);
-const tokenizeRParen = (input, position) => tokenizeToken('RParen', ')', input, position);
-const tokenizeLBracket = (input, position) => tokenizeToken('LBracket', '[', input, position);
-const tokenizeRBracket = (input, position) => tokenizeToken('RBracket', ']', input, position);
-const tokenizeLBrace = (input, position) => tokenizeToken('LBrace', '{', input, position);
-const tokenizeRBrace = (input, position) => tokenizeToken('RBrace', '}', input, position);
-const tokenizeDocString = (input, position) => {
-    if (input[position] !== '"' || input[position + 1] !== '"' || input[position + 2] !== '"')
-        return NO_MATCH;
-    let value = '"""';
-    let length = 3;
-    let char = input[position + length];
-    let nextThreeChars = input.slice(position + length, position + length + 3);
-    let escaping = false;
-    while (char && (nextThreeChars !== '"""' || escaping)) {
-        length += 1;
-        if (escaping) {
-            escaping = false;
-            value += char;
-        }
-        else {
-            if (char === '\\') {
-                escaping = true;
-            }
-            value += char;
-        }
-        char = input[position + length];
-        nextThreeChars = input.slice(position + length, position + length + 3);
-    }
-    if (!char) {
-        return [length, ['Error', value, undefined, `Unclosed doc string at position ${position}`]];
-    }
-    value += '"""'; // closing quote
-    return [length + 3, ['DocString', value]];
-};
-const tokenizeString = (input, position) => {
-    if (input[position] !== '"')
-        return NO_MATCH;
-    let value = '"';
-    let length = 1;
-    let char = input[position + length];
-    let escaping = false;
-    while (char && (char !== '"' || escaping)) {
-        length += 1;
-        if (escaping) {
-            escaping = false;
-            value += char;
-        }
-        else {
-            if (char === '\\') {
-                escaping = true;
-            }
-            value += char;
-        }
-        char = input[position + length];
-    }
-    if (!char) {
-        return [length, ['Error', value, undefined, `Unclosed string at position ${position}`]];
-    }
-    value += '"'; // closing quote
-    return [length + 1, ['string', value]];
-};
-const tokenizeRegexpShorthand = (input, position) => {
-    if (input[position] !== '#')
-        return NO_MATCH;
-    const [stringLength, token] = tokenizeString(input, position + 1);
-    if (!token)
-        return NO_MATCH;
-    if (token[0] === 'Error') {
-        const errorToken = ['Error', `#${token[1]}`, undefined, `Unclosed regexp at position ${position}`];
-        return [stringLength + 1, errorToken];
-    }
-    position += stringLength + 1;
-    let length = stringLength + 1;
-    let options = '';
-    while (input[position] === 'g' || input[position] === 'i') {
-        options += input[position];
-        length += 1;
-        position += 1;
-        if (options.includes(input[position])) {
-            return [length, ['Error', `#${token[1]}${options}`, undefined, `Duplicated regexp option "${input[position]}"`]];
-        }
-    }
-    return [length, ['RegexpShorthand', `#${token[1]}${options}`]];
-};
-function tokenizeToken(type, value, input, position) {
-    if (value === input.slice(position, position + value.length))
-        return [value.length, [type, value]];
-    else
-        return NO_MATCH;
-}
-const tokenizeWhitespace = (input, position) => {
-    let char = input[position];
-    if (!char || !whitespaceRegExp.test(char)) {
-        return NO_MATCH;
-    }
-    let value = char;
-    position += 1;
-    char = input[position];
-    while (char && whitespaceRegExp.test(char)) {
-        value += char;
-        position += 1;
-        char = input[position];
-    }
-    return [value.length, ['Whitespace', value]];
-};
-const decimalNumberRegExp = /\d/;
-const octalNumberRegExp = /[0-7]/;
-const hexNumberRegExp = /[0-9a-f]/i;
-const binaryNumberRegExp = /[01]/;
-const postNumberRegExp = /[\s)\]}(,;]/;
-const tokenizeNumber = (input, position) => {
-    let i;
-    const negate = input[position] === '-';
-    const plusPrefix = input[position] === '+';
-    const start = negate || plusPrefix ? position + 1 : position;
-    let hasDecimalPoint = false;
-    let hasExponent = false;
-    for (i = start; i < input.length; i += 1) {
-        const char = input[i];
-        if (char === '_') {
-            if (!decimalNumberRegExp.test(input[i - 1]) || !decimalNumberRegExp.test(input[i + 1])) {
-                if (i === start) {
-                    return NO_MATCH;
-                }
-                return [i - position + 1, ['Error', input.substring(position, i + 1), undefined, `Invalid number format at position ${i + 1}`]];
-            }
-        }
-        else if (char === '.') {
-            if (i === start) {
-                return NO_MATCH;
-            }
-            if (hasDecimalPoint || hasExponent) {
-                return [i - position + 1, ['Error', input.substring(position, i + 1), undefined, `Invalid number format at position ${i + 1}`]];
-            }
-            hasDecimalPoint = true;
-        }
-        else if (char === 'e' || char === 'E') {
-            if (i === start) {
-                return NO_MATCH;
-            }
-            if (hasExponent) {
-                return [i - position + 1, ['Error', input.substring(position, i + 1), undefined, `Invalid number format at position ${i + 1}`]];
-            }
-            if (input[i - 1] === '.' || input[i - 1] === '+' || input[i - 1] === '-') {
-                return [i - position + 1, ['Error', input.substring(position, i + 1), undefined, `Invalid number format at position ${i + 1}`]];
-            }
-            if (input[i + 1] === '+' || input[i + 1] === '-') {
-                i += 1;
-            }
-            hasExponent = true;
-        }
-        else if (!decimalNumberRegExp.test(char)) {
-            break;
-        }
-    }
-    if ((negate || plusPrefix) && i === start) {
-        return NO_MATCH;
-    }
-    const length = i - position;
-    if (length === 0) {
-        return NO_MATCH;
-    }
-    const nextChar = input[i];
-    if (nextChar && nextChar !== ':' && !postNumberRegExp.test(nextChar)) {
-        return [i - position + 1, ['Error', input.substring(position, i + 1), undefined, `Invalid number format at position ${i + 1}`]];
-    }
-    return [length, ['Number', input.substring(position, i)]];
-};
-const tokenizeBasePrefixedNumber = (input, position) => {
-    if (input[position] !== '0') {
-        return NO_MATCH;
-    }
-    const baseChar = input[position + 1];
-    const type = baseChar === 'b' || baseChar === 'B'
-        ? 'binary'
-        : baseChar === 'o' || baseChar === 'O'
-            ? 'octal'
-            : baseChar === 'x' || baseChar === 'X'
-                ? 'hex'
-                : null;
-    if (type === null) {
-        return NO_MATCH;
-    }
-    let i;
-    for (i = position + 2; i < input.length; i += 1) {
-        const char = input[i];
-        if (type === 'binary' && !binaryNumberRegExp.test(char)) {
-            break;
-        }
-        if (type === 'octal' && !octalNumberRegExp.test(char)) {
-            break;
-        }
-        if (type === 'hex' && !hexNumberRegExp.test(char)) {
+        assertReservedSymbolToken(ctx.tryPeek(), 'then');
+        ctx.advance();
+        const thenExpression = parseImplicitBlock(ctx, ['case', 'end']);
+        params.push([pattern, thenExpression, guard]);
+        if (isReservedSymbolToken(ctx.tryPeek(), 'end')) {
             break;
         }
     }
-    const length = i - position;
-    if (length <= 2) {
-        return NO_MATCH;
+    assertReservedSymbolToken(ctx.tryPeek(), 'end');
+    ctx.advance();
+    return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.match, valueExpression, params]], token[2]);
+}
+
+function createParserContext(tokenStream) {
+    const ctx = new ParserContext(tokenStream);
+    ctx.parseExpression = (precedence = 0) => parseExpression(ctx, precedence);
+    return ctx;
+}
+function parseExpression(ctx, precedence = 0) {
+    const token = ctx.tryPeek();
+    let left;
+    if (isSymbolToken(token)) {
+        switch (token[1]) {
+            case 'let':
+                return parseLet(ctx, token);
+            case 'if':
+            case 'unless':
+                left = parseIfOrUnless(ctx, token);
+                break;
+            case 'cond':
+                left = parseCond(ctx, token);
+                break;
+            case 'match':
+                left = parseMatch(ctx, token);
+                break;
+            case 'for':
+            case 'doseq':
+                left = parseForOrDoseq(ctx, token);
+                break;
+            case 'loop':
+                left = parseLoop(ctx, token);
+                break;
+        }
     }
-    const nextChar = input[i];
-    if (nextChar && !postNumberRegExp.test(nextChar)) {
-        return NO_MATCH;
+    else if (isReservedSymbolToken(token, 'do')) {
+        left = parseDo(ctx);
     }
-    return [length, ['BasePrefixedNumber', input.substring(position, i)]];
-};
-const tokenizeSymbol = (input, position) => {
-    let value = input[position];
-    if (value === '\'') {
-        let length = 1;
-        let char = input[position + length];
-        let escaping = false;
-        while (char !== '\'' || escaping) {
-            if (char === undefined)
-                return [length, ['Error', value, undefined, `Unclosed quoted symbol at position ${position}`]];
-            length += 1;
-            if (escaping) {
-                escaping = false;
-                value += char;
-            }
-            else {
-                if (char === '\\') {
-                    escaping = true;
-                }
-                value += char;
+    left ||= parseOperand(ctx);
+    let operator = ctx.tryPeek();
+    while (!isAtExpressionEnd(ctx)) {
+        if (isA_BinaryOperatorToken(operator)) {
+            const name = operator[1];
+            const newPrecedece = getPrecedence(name, operator[2]);
+            if (newPrecedece <= precedence
+                // ^ (exponentiation) is right associative
+                && !(newPrecedece === exponentiationPrecedence && precedence === exponentiationPrecedence)) {
+                break;
             }
-            char = input[position + length];
+            const symbol = specialExpressionTypes[name]
+                ? withSourceCodeInfo([NodeTypes.SpecialBuiltinSymbol, specialExpressionTypes[name]], operator[2])
+                : withSourceCodeInfo([NodeTypes.NormalBuiltinSymbol, normalExpressionTypes[name]], operator[2]);
+            ctx.advance();
+            const right = parseExpression(ctx, newPrecedece);
+            left = fromBinaryOperatorToNode(operator, symbol, left, right, operator[2]);
         }
-        value += '\''; // closing quote
-        return [length + 1, ['Symbol', value]];
-    }
-    if (!illegalFirstSymbolCharacterSet.has(value)) {
-        const initialPosition = position;
-        position += 1;
-        let char = input[position];
-        while (char && !illegalSymbolCharacterSet.has(char)) {
-            value += char;
-            position += 1;
-            char = input[position];
+        else if (isSymbolToken(operator)) {
+            if (!isFunctionOperator(operator[1])) {
+                break;
+            }
+            const newPrecedence = binaryFunctionalOperatorPrecedence;
+            if (newPrecedence <= precedence) {
+                break;
+            }
+            const operatorSymbol = parseSymbol(ctx);
+            const right = parseExpression(ctx, newPrecedence);
+            if (isSpecialBuiltinSymbolNode(operatorSymbol)) {
+                throw new DvalaError('Special expressions are not allowed in binary functional operators', operatorSymbol[2]);
+            }
+            left = createNamedNormalExpressionNode(operatorSymbol, [left, right], operator[2]);
         }
-        // : can be used as symbol character, but it must not be the last character
-        return value.endsWith(':')
-            ? [position - initialPosition - 1, ['Symbol', value.slice(0, -1)]]
-            : [position - initialPosition, ['Symbol', value]];
-    }
-    return NO_MATCH;
-};
-const tokenizeReservedSymbolToken = (input, position) => {
-    const symbolMeta = tokenizeSymbol(input, position);
-    if (symbolMeta[0] === 0 || !symbolMeta[1]) {
-        return NO_MATCH;
-    }
-    let symbolName = symbolMeta[1][1];
-    symbolName = symbolName.startsWith('\'') ? symbolName.slice(1, symbolName.length - 1) : symbolName;
-    const info = reservedSymbolRecord[symbolName];
-    if (info === undefined) {
-        return NO_MATCH;
-    }
-    return [symbolMeta[0], ['ReservedSymbol', symbolName]];
-};
-const tokenizeOperator = (input, position) => {
-    const threeChars = input.slice(position, position + 3);
-    if (position + 2 < input.length && isSymbolicOperator(threeChars)) {
-        return [3, ['Operator', threeChars]];
-    }
-    const twoChars = input.slice(position, position + 2);
-    if (position + 1 < input.length && isSymbolicOperator(twoChars)) {
-        return [2, ['Operator', twoChars]];
-    }
-    const oneChar = input[position] ?? '';
-    if (isSymbolicOperator(oneChar)) {
-        return [1, ['Operator', oneChar]];
-    }
-    return NO_MATCH;
-};
-const tokenizeMultiLineComment = (input, position) => {
-    if (input[position] === '/' && input[position + 1] === '*') {
-        let length = 2;
-        let value = '/*';
-        while ((input[position + length] !== '*' || input[position + length + 1] !== '/') && position + length + 1 < input.length) {
-            value += input[position + length];
-            length += 1;
+        else if (operator?.[1] === '?') {
+            if (conditionalOperatorPrecedence <= precedence) {
+                break;
+            }
+            ctx.advance();
+            const trueNode = parseExpression(ctx);
+            if (!isOperatorToken(ctx.tryPeek(), ':')) {
+                throw new DvalaError('Expected :', ctx.peekSourceCodeInfo());
+            }
+            ctx.advance();
+            const falseNode = parseExpression(ctx);
+            left = withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.if, [left, trueNode, falseNode]]], left[2]);
         }
-        if (position + length + 1 >= input.length) {
-            return [length, ['Error', value, undefined, `Unclosed multi-line comment at position ${position}`]];
+        else {
+            break;
         }
-        value += '*/';
-        length += 2;
-        return [length, ['MultiLineComment', value]];
+        operator = ctx.tryPeek();
     }
-    return NO_MATCH;
-};
-const tokenizeShebang = (input, position) => {
-    if (input[position] === '#' && input[position + 1] === '!') {
-        let length = 2;
-        let value = '#!';
-        while (input[position + length] !== '\n' && position + length < input.length) {
-            value += input[position + length];
-            length += 1;
+    return left;
+}
+
+function parse(tokenStream) {
+    tokenStream.tokens.forEach((token) => {
+        if (token[0] === 'Error') {
+            throw new DvalaError(token[3], token[2]);
         }
-        return [length, ['SingleLineComment', value]];
-    }
-    return NO_MATCH;
-};
-const tokenizeSingleLineComment = (input, position) => {
-    if (input[position] === '/' && input[position + 1] === '/') {
-        let length = 2;
-        let value = '//';
-        while (input[position + length] !== '\n' && position + length < input.length) {
-            value += input[position + length];
-            length += 1;
+    });
+    const nodes = [];
+    const ctx = createParserContext(tokenStream);
+    while (!ctx.isAtEnd()) {
+        nodes.push(parseExpression(ctx, 0));
+        if (isOperatorToken(ctx.tryPeek(), ';')) {
+            ctx.advance();
         }
-        return [length, ['SingleLineComment', value]];
-    }
-    return NO_MATCH;
-};
-// All tokenizers, order matters!
-const tokenizers = [
-    tokenizeWhitespace,
-    tokenizeMultiLineComment,
-    tokenizeSingleLineComment,
-    tokenizeReservedSymbolToken,
-    tokenizeLParen,
-    tokenizeRParen,
-    tokenizeLBracket,
-    tokenizeRBracket,
-    tokenizeLBrace,
-    tokenizeRBrace,
-    tokenizeDocString,
-    tokenizeString,
-    tokenizeRegexpShorthand,
-    tokenizeBasePrefixedNumber,
-    tokenizeNumber,
-    tokenizeOperator,
-    tokenizeSymbol,
-];
-
-function tokenize(input, debug, filePath) {
-    let position = 0;
-    const tokenStream = {
-        tokens: [],
-        filePath,
-        hasDebugData: debug,
-    };
-    while (position < input.length) {
-        const sourceCodeInfo = debug
-            ? createSourceCodeInfo(input, position, filePath)
-            : undefined;
-        const tokenDescriptor = getCurrentToken(input, position);
-        const [count, token] = tokenDescriptor;
-        position += count;
-        if (token) {
-            if (sourceCodeInfo) {
-                token[2] = sourceCodeInfo;
+        else {
+            if (!ctx.isAtEnd()) {
+                throw new DvalaError('Expected ;', ctx.peekSourceCodeInfo());
             }
-            tokenStream.tokens.push(token);
         }
     }
-    return tokenStream;
-}
-function getSourceCodeLine(input, lineNbr) {
-    return input.split(/\r\n|\r|\n/)[lineNbr];
-}
-function createSourceCodeInfo(input, position, filePath) {
-    const lines = input.substring(0, position + 1).split(/\r\n|\r|\n/);
-    const lastLine = lines[lines.length - 1];
-    const code = getSourceCodeLine(input, lines.length - 1);
-    const line = lines.length;
-    const column = lastLine.length;
-    return {
-        code,
-        position: {
-            line,
-            column,
-        },
-        filePath,
-    };
+    return nodes;
 }
-function getCurrentToken(input, position) {
-    const initialPosition = position;
-    if (position === 0) {
-        const [nbrOfCharacters, token] = tokenizeShebang(input, position);
-        position += nbrOfCharacters;
-        if (nbrOfCharacters > 0) {
-            return [position - initialPosition, token];
-        }
-    }
-    for (const tokenizer of tokenizers) {
-        const [nbrOfCharacters, token] = tokenizer(input, position);
-        position += nbrOfCharacters;
-        if (nbrOfCharacters === 0) {
-            continue;
+
+function minifyTokenStream(tokenStream, { removeWhiteSpace }) {
+    const tokens = tokenStream.tokens
+        .filter((token) => {
+        if (isSingleLineCommentToken(token)
+            || isMultiLineCommentToken(token)
+            || isShebangToken(token)
+            || (removeWhiteSpace && isWhitespaceToken(token))) {
+            return false;
         }
-        return [position - initialPosition, token];
-    }
-    return [1, ['Error', input[initialPosition], undefined, 'Unrecognized character']];
+        return true;
+    });
+    return { ...tokenStream, tokens };
 }
 
 /**
@@ -8397,9 +8681,8 @@ function effectNameMatchesPattern(effectName, pattern) {
     return effectName === pattern;
 }
 /**
- * Find all matching handlers for an effect name, in registration order.
- * Returns an array of `[pattern, handler]` pairs — the first entry is
- * the "most specific" by registration order, not by pattern specificity.
+ * Find all matching async handlers for an effect name, in registration order.
+ * Returns an array of `[pattern, handler]` pairs.
  */
 function findMatchingHandlers(effectName, handlers) {
     if (!handlers) {
@@ -8425,6 +8708,8 @@ class SuspensionSignal {
     snapshots;
     nextSnapshotIndex;
     meta;
+    effectName;
+    effectArgs;
     _brand = 'SuspensionSignal';
     constructor(
     /** The captured continuation stack at the point of suspension. */
@@ -8434,11 +8719,17 @@ class SuspensionSignal {
     /** High-water mark for snapshot indices at the point of suspension. */
     nextSnapshotIndex, 
     /** Optional domain metadata passed through to RunResult. */
-    meta) {
+    meta, 
+    /** The effect name being handled when suspend() was called. */
+    effectName, 
+    /** The effect arguments being handled when suspend() was called. */
+    effectArgs) {
         this.k = k;
         this.snapshots = snapshots;
         this.nextSnapshotIndex = nextSnapshotIndex;
         this.meta = meta;
+        this.effectName = effectName;
+        this.effectArgs = effectArgs;
     }
 }
 function isSuspensionSignal(value) {
@@ -8508,217 +8799,6 @@ function getEffectRef(name) {
     return ref;
 }
 
-function isContextEntry(value) {
-    return isUnknownRecord(value) && value.value !== undefined;
-}
-
-class ContextStackImpl {
-    _contexts;
-    globalContext;
-    values;
-    modules;
-    valueModules;
-    pure;
-    constructor({ contexts, values: hostValues, modules, valueModules, pure, }) {
-        this.globalContext = asNonUndefined(contexts[0]);
-        this._contexts = contexts;
-        this.values = hostValues;
-        this.modules = modules ?? new Map();
-        this.valueModules = valueModules ?? new Map();
-        this.pure = pure ?? false;
-    }
-    // -- Serialization support (Phase 4) --
-    /** Get the raw context chain for serialization. */
-    getContextsRaw() {
-        return this._contexts;
-    }
-    /** Get host values (plain bindings passed at creation). */
-    getHostValues() {
-        return this.values;
-    }
-    /**
-     * Find the index of globalContext in the _contexts array.
-     * Returns -1 if not found (should not happen in valid state).
-     */
-    getGlobalContextIndex() {
-        return this._contexts.indexOf(this.globalContext);
-    }
-    /**
-     * Create a ContextStack from deserialized data.
-     * `contexts` is the restored context chain (already resolved).
-     * `globalContextIndex` identifies which element is the globalContext.
-     * Host bindings (`values`, `modules`) come from resume options.
-     */
-    static fromDeserialized(params) {
-        const cs = new ContextStackImpl({
-            contexts: params.contexts,
-            values: params.values,
-            modules: params.modules,
-            pure: params.pure,
-        });
-        if (params.globalContextIndex >= 0 && params.globalContextIndex < params.contexts.length) {
-            cs.globalContext = params.contexts[params.globalContextIndex];
-        }
-        return cs;
-    }
-    /**
-     * Replace the contexts array and globalContext. Used during deserialization
-     * to fill in resolved context data after circular references are handled.
-     */
-    setContextsFromDeserialized(contexts, globalContextIndex) {
-        this._contexts = contexts;
-        if (globalContextIndex >= 0 && globalContextIndex < contexts.length) {
-            this.globalContext = contexts[globalContextIndex];
-        }
-    }
-    getModule(name) {
-        return this.modules.get(name);
-    }
-    getValueModule(name) {
-        if (this.valueModules.has(name)) {
-            return { value: this.valueModules.get(name), found: true };
-        }
-        return { value: undefined, found: false };
-    }
-    registerValueModule(name, value) {
-        this.valueModules.set(name, value);
-    }
-    create(context) {
-        const globalContext = this.globalContext;
-        const contextStack = new ContextStackImpl({
-            contexts: [context, ...this._contexts],
-            values: this.values,
-            modules: this.modules,
-            valueModules: this.valueModules,
-            pure: this.pure,
-        });
-        contextStack.globalContext = globalContext;
-        return contextStack;
-    }
-    new(context) {
-        const contexts = [{}, context];
-        return new ContextStackImpl({ contexts, modules: this.modules, valueModules: this.valueModules, pure: this.pure });
-    }
-    addValues(values, sourceCodeInfo) {
-        const currentContext = this._contexts[0];
-        for (const [name, value] of Object.entries(values)) {
-            if (currentContext[name]) {
-                throw new DvalaError(`Cannot redefine value "${name}"`, sourceCodeInfo);
-            }
-            const shadowedName = getShadowedBuiltinName(name);
-            if (shadowedName) {
-                throw new DvalaError(`Cannot shadow ${shadowedName}`, sourceCodeInfo);
-            }
-            currentContext[name] = { value: toAny(value) };
-        }
-    }
-    getValue(name) {
-        for (const context of this._contexts) {
-            const contextEntry = context[name];
-            if (contextEntry)
-                return contextEntry.value;
-        }
-        return this.values?.[name];
-    }
-    lookUp(node) {
-        const value = node[1];
-        for (const context of this._contexts) {
-            const contextEntry = context[value];
-            if (contextEntry)
-                return contextEntry;
-        }
-        const hostValue = this.values?.[value];
-        if (hostValue !== undefined) {
-            return {
-                value: toAny(hostValue),
-            };
-        }
-        return null;
-    }
-    evaluateSymbol(node) {
-        if (isSpecialBuiltinSymbolNode(node)) {
-            const functionType = node[1];
-            switch (functionType) {
-                case specialExpressionTypes['&&']:
-                case specialExpressionTypes['||']:
-                case specialExpressionTypes.array:
-                case specialExpressionTypes.object:
-                case specialExpressionTypes['defined?']:
-                case specialExpressionTypes.recur:
-                case specialExpressionTypes['??']: {
-                    const specialExpression = asNonUndefined(builtin.specialExpressions[functionType], node[2]);
-                    return {
-                        [FUNCTION_SYMBOL]: true,
-                        functionType: 'SpecialBuiltin',
-                        specialBuiltinSymbolType: functionType,
-                        sourceCodeInfo: node[2],
-                        arity: specialExpression.arity,
-                    };
-                }
-                default:
-                    throw new DvalaError(`Unknown special builtin symbol type: ${functionType}`, node[2]);
-            }
-        }
-        if (isNormalBuiltinSymbolNode(node)) {
-            const type = node[1];
-            const normalExpression = allNormalExpressions[type];
-            const name = normalExpression.name;
-            return {
-                [FUNCTION_SYMBOL]: true,
-                functionType: 'Builtin',
-                normalBuiltinSymbolType: type,
-                sourceCodeInfo: node[2],
-                arity: normalExpression.arity,
-                name,
-            };
-        }
-        const lookUpResult = this.lookUp(node);
-        if (isContextEntry(lookUpResult))
-            return lookUpResult.value;
-        throw new UndefinedSymbolError(node[1], node[2]);
-    }
-}
-function getShadowedBuiltinName(name) {
-    if (specialExpressionKeys.includes(name))
-        return `special expression "${name}"`;
-    if (normalExpressionKeys.includes(name))
-        return `builtin function "${name}"`;
-    if (name === 'self')
-        return `builtin value "${name}"`;
-    return null;
-}
-function assertNotShadowingBuiltin(name) {
-    const shadowedName = getShadowedBuiltinName(name);
-    if (shadowedName) {
-        throw new DvalaError(`Cannot shadow ${shadowedName}`, undefined);
-    }
-}
-function createContextStack(params = {}, modules, pure) {
-    const globalContext = params.globalContext ?? {};
-    // Contexts are checked from left to right
-    const contexts = params.contexts ? [globalContext, ...params.contexts] : [globalContext];
-    let hostValues;
-    if (params.bindings) {
-        for (const [identifier, entry] of Object.entries(params.bindings)) {
-            if (identifier.includes('.')) {
-                throw new DvalaError(`Dots are not allowed in binding keys: "${identifier}"`, undefined);
-            }
-            assertNotShadowingBuiltin(identifier);
-            if (!hostValues) {
-                hostValues = {};
-            }
-            hostValues[identifier] = entry;
-        }
-    }
-    const contextStack = new ContextStackImpl({
-        contexts,
-        values: hostValues,
-        modules,
-        pure,
-    });
-    return params.globalModuleScope ? contextStack : contextStack.create({});
-}
-
 /**
  * Content-addressable hashing for JSON-compatible value trees.
  *
@@ -10239,7 +10319,7 @@ function evaluateFunction(fn, contextStack) {
         });
         return ctx;
     }, {});
-    const undefinedSymbols = getUndefinedSymbols(fn[1], contextStack.new(context), builtin, evaluateNodeRecursive);
+    const undefinedSymbols = getUndefinedSymbols$1(fn[1], contextStack.new(context), builtin, evaluateNodeRecursive);
     undefinedSymbols.forEach((name) => {
         const value = contextStack.getValue(name);
         if (isAny(value)) {
@@ -10642,7 +10722,6 @@ function stepSpecialExpression(node, env, k) {
         // --- lambda (fn / ->) ---
         case specialExpressionTypes['0_lambda']: {
             const fn = node[1][1];
-            const docString = (node[1][2] ?? '');
             const evaluatedFunc = evaluateFunction(fn, env);
             const min = evaluatedFunc[0].filter(arg => arg[0] !== bindingTargetTypes.rest && arg[1][1] === undefined).length;
             const max = evaluatedFunc[0].some(arg => arg[0] === bindingTargetTypes.rest) ? undefined : evaluatedFunc[0].length;
@@ -10654,7 +10733,7 @@ function stepSpecialExpression(node, env, k) {
                 name: undefined,
                 evaluatedfunction: evaluatedFunc,
                 arity,
-                docString,
+                docString: '',
             };
             return { type: 'Value', value: dvalaFunction, k };
         }
@@ -11812,129 +11891,161 @@ function dispatchPerform(effect, args, k, sourceCodeInfo, handlers, signal, snap
  * shape. If no more handlers remain after `next()`, the effect is unhandled.
  *
  * Each handler must call exactly one of `resume`, `suspend`, `fail`, or
- * `next` before its promise resolves.
+ * `next` before its promise resolves (async) or before returning (sync).
  *
  * - `resume(value)` — resolves with a `ValueStep` that continues evaluation.
- * - `suspend(meta?)` — rejects with a `SuspensionSignal`.
+ * - `suspend(meta?)` — throws a `SuspensionSignal`.
  * - `fail(msg?)` — produces an `ErrorStep` routed through `dvala.error`.
  * - `next()` — pass to the next matching handler in the chain.
+ *
+ * Handlers may return `void` (synchronous) or `Promise<void>` (async).
+ * When all handlers in a chain are synchronous, this function returns
+ * a `Step` synchronously, allowing use from the sync trampoline.
  */
 function dispatchHostHandler(effectName, matchingHandlers, args, k, signal, sourceCodeInfo, snapshotState) {
     const effectSignal = signal ?? new AbortController().signal;
     const argsArray = Array.from(args);
+    // If the abort signal already fired before the handler was called, auto-suspend immediately.
+    // This happens when a parallel group aborts (e.g. another branch suspended) before this
+    // branch's dispatchHostHandler runs.
+    if (effectSignal.aborted) {
+        throwSuspension(k, undefined, effectName, argsArray);
+    }
+    function resolveOutcome(o, nextIndex) {
+        switch (o.kind) {
+            case 'step': return o.step;
+            case 'asyncResume': return o.promise.then((v) => ({ type: 'Value', value: v, k }), (e) => ({ type: 'Error', error: e instanceof DvalaError ? e : new DvalaError(e instanceof Error ? e : `${e}`, sourceCodeInfo), k }));
+            case 'throw': throw o.error;
+            case 'next': return tryHandler(nextIndex);
+        }
+    }
     // Recursive helper: try handler at `index`, with `next()` advancing to `index + 1`.
     function tryHandler(index) {
         if (index >= matchingHandlers.length) {
-            // No more handlers — effect is unhandled.
-            // Return rejected Promises (not synchronous throws) so that
-            // next() can propagate via .then(resolve, reject).
             if (effectName === 'dvala.error') {
                 const message = typeof argsArray[0] === 'string' ? argsArray[0] : String(argsArray[0] ?? 'Unknown error');
-                return Promise.reject(new UserDefinedError(message, sourceCodeInfo));
+                throw new UserDefinedError(message, sourceCodeInfo);
             }
-            return Promise.reject(new DvalaError(`Unhandled effect: '${effectName}'`, sourceCodeInfo));
+            // dvala.checkpoint resolves to null when all handlers call next() without resuming.
+            if (effectName === 'dvala.checkpoint') {
+                return { type: 'Value', value: null, k };
+            }
+            throw new DvalaError(`Unhandled effect: '${effectName}'`, sourceCodeInfo);
         }
-        const [, handler] = matchingHandlers[index];
-        return new Promise((resolve, reject) => {
-            let settled = false;
-            function assertNotSettled(operation) {
-                if (settled) {
-                    throw new DvalaError(`Effect handler called ${operation}() after already calling another operation`, sourceCodeInfo);
-                }
-                settled = true;
+        const [pattern, handler] = matchingHandlers[index];
+        // Before trying a "*" catch-all, fall back to standard effects.
+        if (pattern === '*') {
+            const standardHandler = getStandardEffectHandler(effectName);
+            if (standardHandler) {
+                return standardHandler(args, k, sourceCodeInfo);
             }
-            const ctx = {
-                effectName,
-                args: argsArray,
-                signal: effectSignal,
-                resume: (value) => {
-                    assertNotSettled('resume');
-                    if (value instanceof Promise) {
-                        value.then((v) => {
-                            resolve({ type: 'Value', value: v, k });
-                        }, (e) => {
-                            resolve({
-                                type: 'Error',
-                                error: e instanceof DvalaError ? e : new DvalaError(e instanceof Error ? e : `${e}`, sourceCodeInfo),
-                                k,
-                            });
-                        });
-                    }
-                    else {
-                        resolve({ type: 'Value', value, k });
-                    }
-                },
-                fail: (msg) => {
-                    assertNotSettled('fail');
-                    const errorMsg = msg ?? `Effect handler failed for '${effectName}'`;
-                    resolve({
-                        type: 'Error',
-                        error: new DvalaError(errorMsg, sourceCodeInfo),
-                        k,
-                    });
-                },
-                suspend: (meta) => {
-                    assertNotSettled('suspend');
-                    reject(new SuspensionSignal(k, snapshotState ? snapshotState.snapshots : [], snapshotState ? snapshotState.nextSnapshotIndex : 0, meta));
-                },
-                next: () => {
-                    assertNotSettled('next');
-                    // Advance to the next handler in the chain.
-                    tryHandler(index + 1).then(resolve, reject);
-                },
-                get snapshots() { return snapshotState ? [...snapshotState.snapshots] : []; },
-                checkpoint: (meta) => {
-                    if (!snapshotState) {
-                        throw new DvalaError('checkpoint is not available outside effect-enabled execution', sourceCodeInfo);
-                    }
-                    const continuation = serializeToObject(k);
-                    const snapshot = {
-                        continuation,
-                        timestamp: Date.now(),
-                        index: snapshotState.nextSnapshotIndex++,
-                        runId: snapshotState.runId,
-                        ...(meta !== undefined ? { meta } : {}),
-                    };
-                    snapshotState.snapshots.push(snapshot);
-                    if (snapshotState.maxSnapshots !== undefined && snapshotState.snapshots.length > snapshotState.maxSnapshots) {
-                        snapshotState.snapshots.shift();
-                    }
-                    return snapshot;
-                },
-                resumeFrom: (snapshot, value) => {
-                    if (settled) {
-                        throw new DvalaError('Effect handler called resumeFrom() after already calling another operation', sourceCodeInfo);
-                    }
-                    if (!snapshotState) {
-                        throw new DvalaError('resumeFrom is not available outside effect-enabled execution', sourceCodeInfo);
-                    }
-                    const found = snapshotState.snapshots.find(s => s.index === snapshot.index && s.runId === snapshot.runId);
-                    if (!found) {
-                        throw new DvalaError(`Invalid snapshot: no snapshot with index ${snapshot.index} found in current run`, sourceCodeInfo);
-                    }
-                    settled = true;
-                    reject(new ResumeFromSignal(found.continuation, value, found.index));
-                },
-            };
-            handler(ctx).catch((e) => {
+        }
+        let outcome;
+        let settled = false;
+        function assertNotSettled(operation) {
+            if (settled) {
+                throw new DvalaError(`Effect handler called ${operation}() after already calling another operation`, sourceCodeInfo);
+            }
+            settled = true;
+        }
+        const ctx = {
+            effectName,
+            args: argsArray,
+            signal: effectSignal,
+            resume: (value) => {
+                assertNotSettled('resume');
+                if (value instanceof Promise) {
+                    outcome = { kind: 'asyncResume', promise: value };
+                }
+                else {
+                    outcome = { kind: 'step', step: { type: 'Value', value, k } };
+                }
+            },
+            fail: (msg) => {
+                assertNotSettled('fail');
+                const errorMsg = msg ?? `Effect handler failed for '${effectName}'`;
+                outcome = { kind: 'step', step: { type: 'Error', error: new DvalaError(errorMsg, sourceCodeInfo), k } };
+            },
+            suspend: (meta) => {
+                assertNotSettled('suspend');
+                outcome = {
+                    kind: 'throw',
+                    error: new SuspensionSignal(k, snapshotState ? snapshotState.snapshots : [], snapshotState ? snapshotState.nextSnapshotIndex : 0, meta, effectName, argsArray),
+                };
+            },
+            next: () => {
+                assertNotSettled('next');
+                outcome = { kind: 'next' };
+            },
+            get snapshots() { return snapshotState ? [...snapshotState.snapshots] : []; },
+            checkpoint: (meta) => {
+                if (!snapshotState) {
+                    throw new DvalaError('checkpoint is not available outside effect-enabled execution', sourceCodeInfo);
+                }
+                const continuation = serializeToObject(k);
+                const snapshot = {
+                    continuation,
+                    timestamp: Date.now(),
+                    index: snapshotState.nextSnapshotIndex++,
+                    runId: snapshotState.runId,
+                    ...(meta !== undefined ? { meta } : {}),
+                };
+                snapshotState.snapshots.push(snapshot);
+                if (snapshotState.maxSnapshots !== undefined && snapshotState.snapshots.length > snapshotState.maxSnapshots) {
+                    snapshotState.snapshots.shift();
+                }
+                return snapshot;
+            },
+            resumeFrom: (snapshot, value) => {
                 if (settled) {
-                    // Handler already resolved via resume/suspend/fail/next — ignore late errors
-                    return;
+                    throw new DvalaError('Effect handler called resumeFrom() after already calling another operation', sourceCodeInfo);
                 }
-                settled = true;
-                if (isSuspensionSignal(e) || isResumeFromSignal(e)) {
-                    reject(e);
+                if (!snapshotState) {
+                    throw new DvalaError('resumeFrom is not available outside effect-enabled execution', sourceCodeInfo);
                 }
-                else {
-                    // Handler itself threw — produce an ErrorStep so tick() can route
-                    // through dvala.error.
-                    resolve({
-                        type: 'Error',
-                        error: e instanceof DvalaError ? e : new DvalaError(e instanceof Error ? e : `${e}`, sourceCodeInfo),
-                        k,
-                    });
+                const found = snapshotState.snapshots.find(s => s.index === snapshot.index && s.runId === snapshot.runId);
+                if (!found) {
+                    throw new DvalaError(`Invalid snapshot: no snapshot with index ${snapshot.index} found in current run`, sourceCodeInfo);
                 }
-            });
+                settled = true;
+                outcome = { kind: 'throw', error: new ResumeFromSignal(found.continuation, value, found.index) };
+            },
+        };
+        const handlerResult = handler(ctx);
+        if (!(handlerResult instanceof Promise)) {
+            // Synchronous handler — outcome must already be set
+            if (!outcome) {
+                throw new DvalaError(`Effect handler for '${effectName}' did not call resume(), fail(), suspend(), or next()`, sourceCodeInfo);
+            }
+            return resolveOutcome(outcome, index + 1);
+        }
+        // Async handler
+        if (outcome) {
+            // Handler settled synchronously before the async part
+            handlerResult.catch(() => { }); // suppress unhandled rejection
+            return resolveOutcome(outcome, index + 1);
+        }
+        // Not yet settled — wait for the handler's promise
+        return handlerResult.then(() => {
+            if (!outcome) {
+                throw new DvalaError(`Effect handler for '${effectName}' did not call resume(), fail(), suspend(), or next()`, sourceCodeInfo);
+            }
+            return resolveOutcome(outcome, index + 1);
+        }, (e) => {
+            if (outcome) {
+                // Already settled — return that result, ignore the rejection
+                return resolveOutcome(outcome, index + 1);
+            }
+            if (isSuspensionSignal(e) || isResumeFromSignal(e)) {
+                // eslint-disable-next-line ts/no-throw-literal -- SuspensionSignal/ResumeFromSignal is a signaling mechanism
+                throw e;
+            }
+            const errorStep = {
+                type: 'Error',
+                error: e instanceof DvalaError ? e : new DvalaError(e instanceof Error ? e : `${e}`, sourceCodeInfo),
+                k,
+            };
+            return errorStep;
         });
     }
     return tryHandler(0);
@@ -11946,9 +12057,20 @@ function dispatchHostHandler(effectName, matchingHandlers, args, k, signal, sour
  * Throw a SuspensionSignal. Factored out to a helper so ESLint's
  * `only-throw-literal` rule can be suppressed in one place.
  */
-function throwSuspension(k, meta) {
+/** Combine two AbortSignals: aborts when either fires (or already aborted). */
+function combineSignals(a, b) {
+    const controller = new AbortController();
+    if (a.aborted || b.aborted) {
+        controller.abort();
+        return controller.signal;
+    }
+    a.addEventListener('abort', () => controller.abort(), { once: true });
+    b.addEventListener('abort', () => controller.abort(), { once: true });
+    return controller.signal;
+}
+function throwSuspension(k, meta, effectName, effectArgs) {
     // eslint-disable-next-line ts/no-throw-literal -- SuspensionSignal is a signaling mechanism, not an error
-    throw new SuspensionSignal(k, [], 0, meta);
+    throw new SuspensionSignal(k, [], 0, meta, effectName, effectArgs);
 }
 /**
  * Run a single trampoline branch to completion with effect handler support.
@@ -11978,31 +12100,41 @@ async function runBranch(node, env, handlers, signal) {
  *   but errors take priority)
  */
 async function executeParallelBranches(branches, env, k, handlers, signal) {
-    const effectSignal = signal ?? new AbortController().signal;
-    // Run all branches concurrently
-    const branchPromises = branches.map(branch => runBranch(branch, env, handlers, effectSignal));
+    // AbortController for this parallel group — aborted when any branch suspends,
+    // which signals remaining effect handlers to auto-suspend via ctx.signal.
+    const parallelAbort = new AbortController();
+    const effectSignal = signal
+        ? combineSignals(signal, parallelAbort.signal)
+        : parallelAbort.signal;
+    // Run all branches concurrently; abort the group when a branch suspends
+    const branchPromises = branches.map(async (branch, i) => {
+        const result = await runBranch(branch, env, handlers, effectSignal);
+        if (result.type === 'suspended') {
+            parallelAbort.abort();
+        }
+        return { index: i, result };
+    });
     const results = await Promise.allSettled(branchPromises);
     // Collect outcomes
     const completedBranches = [];
     const suspendedBranches = [];
     const errors = [];
-    for (let i = 0; i < results.length; i++) {
-        const result = results[i];
-        if (result.status === 'rejected') {
-            // runEffectLoop should never reject, but handle defensively
-            errors.push(new DvalaError(`${result.reason}`, undefined));
+    for (const settled of results) {
+        if (settled.status === 'rejected') {
+            // branchPromises should never reject, but handle defensively
+            errors.push(new DvalaError(`${settled.reason}`, undefined));
         }
         else {
-            const r = result.value;
-            switch (r.type) {
+            const { index, result } = settled.value;
+            switch (result.type) {
                 case 'completed':
-                    completedBranches.push({ index: i, value: r.value });
+                    completedBranches.push({ index, value: result.value });
                     break;
                 case 'suspended':
-                    suspendedBranches.push({ index: i, snapshot: r.snapshot });
+                    suspendedBranches.push({ index, snapshot: result.snapshot });
                     break;
                 case 'error':
-                    errors.push(r.error);
+                    errors.push(result.error);
                     break;
             }
         }
@@ -12021,9 +12153,9 @@ async function executeParallelBranches(branches, env, k, handlers, signal) {
             suspendedBranches: suspendedBranches.slice(1), // remaining after the first
         };
         const resumeK = [parallelResumeFrame, ...k];
-        // Throw SuspensionSignal with the first suspended branch's meta
+        // Throw SuspensionSignal with the first suspended branch's meta and effect info
         const firstSuspended = suspendedBranches[0];
-        return throwSuspension(resumeK, firstSuspended.snapshot.meta);
+        return throwSuspension(resumeK, firstSuspended.snapshot.meta, firstSuspended.snapshot.effectName, firstSuspended.snapshot.effectArgs);
     }
     // All branches completed — build the result array in original order
     const resultArray = Array.from({ length: branches.length });
@@ -12176,7 +12308,7 @@ function handleParallelResume(step, _handlers, _signal) {
             suspendedBranches: remaining,
         };
         const resumeK = [parallelResumeFrame, ...k];
-        return throwSuspension(resumeK, nextSuspended.snapshot.meta);
+        return throwSuspension(resumeK, nextSuspended.snapshot.meta, nextSuspended.snapshot.effectName, nextSuspended.snapshot.effectArgs);
     }
     // All branches now completed — build the result array in original order
     const resultArray = Array.from({ length: branchCount });
@@ -12441,7 +12573,7 @@ function tick(step, handlers, signal, snapshotState) {
  * Throws if any step produces a Promise (i.e., an async operation was
  * encountered in a synchronous context).
  */
-function runSyncTrampoline(initial) {
+function runSyncTrampoline(initial, effectHandlers) {
     let step = initial;
     for (;;) {
         if (step instanceof Promise) {
@@ -12450,7 +12582,7 @@ function runSyncTrampoline(initial) {
         if (step.type === 'Value' && step.k.length === 0) {
             return step.value;
         }
-        step = tick(step);
+        step = tick(step, effectHandlers);
     }
 }
 /**
@@ -12512,16 +12644,6 @@ function evaluate(ast, contextStack) {
         throw error;
     }
 }
-/**
- * Evaluate an AST using the async trampoline directly.
- * Use this when the caller knows that async operations may be involved
- * (e.g., from Dvala.async.run) to avoid the sync-first-then-retry pattern
- * which can cause side effects to be executed twice.
- */
-function evaluateAsync(ast, contextStack) {
-    const initial = buildInitialStep(ast.body, contextStack);
-    return runAsyncTrampoline(initial);
-}
 /**
  * Evaluate a single AST node using the trampoline.
  * Used as the `evaluateNode` callback passed to `getUndefinedSymbols`
@@ -12563,6 +12685,27 @@ async function evaluateWithEffects(ast, contextStack, handlers, maxSnapshots, de
     const initial = buildInitialStep(ast.body, contextStack);
     return runEffectLoop(initial, handlers, signal, undefined, maxSnapshots, deserializeOptions);
 }
+/**
+ * Evaluate an AST synchronously with effect handler support.
+ *
+ * Uses the sync trampoline with `effectHandlers` threaded through `tick`.
+ * Throws if an async operation is encountered (e.g., an async handler
+ * is used). Handlers may call `resume(value)`, `fail(msg?)`, or `next()`.
+ * Calling `suspend()` will throw a runtime error.
+ */
+function evaluateWithSyncEffects(ast, contextStack, effectHandlers) {
+    const initial = buildInitialStep(ast.body, contextStack);
+    try {
+        return runSyncTrampoline(initial, effectHandlers);
+    }
+    catch (error) {
+        if (error instanceof DvalaError && error.message.includes('Unexpected async operation')) {
+            const freshInitial = buildInitialStep(ast.body, contextStack);
+            return runSyncTrampoline(freshInitial, effectHandlers);
+        }
+        throw error;
+    }
+}
 /**
  * Shared effect trampoline loop used by both `evaluateWithEffects` and
  * `resumeWithEffects`. Runs the trampoline to completion, suspension, or error.
@@ -12580,7 +12723,7 @@ async function runEffectLoop(initial, handlers, signal, initialSnapshotState, ma
         snapshots: [],
         nextSnapshotIndex: 0,
         runId: generateRunId(),
-        ...({}),
+        ...(maxSnapshots !== undefined ? { maxSnapshots } : {}),
     };
     let step = initial;
     for (;;) {
@@ -12628,6 +12771,8 @@ async function runEffectLoop(initial, handlers, signal, initialSnapshotState, ma
                     index: snapshotState.nextSnapshotIndex++,
                     runId: snapshotState.runId,
                     meta: error.meta,
+                    effectName: error.effectName,
+                    effectArgs: error.effectArgs,
                 };
                 return { type: 'suspended', snapshot };
             }
@@ -12639,141 +12784,6 @@ async function runEffectLoop(initial, handlers, signal, initialSnapshotState, ma
     }
 }
 
-function transformSymbolTokens(tokenStram, transformer) {
-    return {
-        ...tokenStram,
-        tokens: tokenStram.tokens.map(token => isSymbolToken(token)
-            ? [token[0], transformer(token[1])]
-            : token),
-    };
-}
-
-function untokenize(tokenStream) {
-    return tokenStream.tokens.reduce((acc, token) => {
-        return `${acc}${token[1]}`;
-    }, '');
-}
-
-const dvalaCommands = new Set([...normalExpressionKeys, ...specialExpressionKeys, ...Object.keys(reservedSymbolRecord)]);
-// TODO: replace with get suggestions function
-class AutoCompleter {
-    originalProgram;
-    originalPosition;
-    prefixProgram = '';
-    suffixProgram = '';
-    searchString = '';
-    suggestions = [];
-    suggestionIndex = null;
-    constructor(originalProgram, originalPosition, dvala, params) {
-        this.originalProgram = originalProgram;
-        this.originalPosition = originalPosition;
-        const partialProgram = this.originalProgram.slice(0, this.originalPosition);
-        const tokenStream = dvala.tokenize(partialProgram);
-        const lastToken = tokenStream.tokens.at(-1);
-        if (!lastToken) {
-            return;
-        }
-        if (lastToken[0] === 'Error') {
-            return;
-        }
-        this.searchString = lastToken[1];
-        this.prefixProgram = this.originalProgram.slice(0, this.originalPosition - this.searchString.length);
-        this.suffixProgram = this.originalProgram.slice(this.prefixProgram.length + this.searchString.length);
-        this.originalProgram.slice(this.prefixProgram.length + this.searchString.length);
-        this.suggestions = this.generateSuggestions(params);
-    }
-    getNextSuggestion() {
-        return this.getAutoCompleteSuggestionResult(this.getNextSuggestionSymbol());
-    }
-    getPreviousSuggestion() {
-        return this.getAutoCompleteSuggestionResult(this.getPreviousSuggestionSymbol());
-    }
-    getAutoCompleteSuggestionResult(suggestion) {
-        if (suggestion === null) {
-            return null;
-        }
-        return {
-            program: this.prefixProgram + suggestion + this.suffixProgram,
-            position: this.prefixProgram.length + suggestion.length,
-        };
-    }
-    getNextSuggestionSymbol() {
-        if (this.suggestions.length === 0) {
-            return null;
-        }
-        if (this.suggestionIndex === null) {
-            this.suggestionIndex = 0;
-        }
-        else {
-            this.suggestionIndex += 1;
-            if (this.suggestionIndex >= this.suggestions.length) {
-                this.suggestionIndex = 0;
-            }
-        }
-        return this.suggestions[this.suggestionIndex];
-    }
-    getPreviousSuggestionSymbol() {
-        if (this.suggestions.length === 0) {
-            return null;
-        }
-        if (this.suggestionIndex === null) {
-            this.suggestionIndex = this.suggestions.length - 1;
-        }
-        else {
-            this.suggestionIndex -= 1;
-            if (this.suggestionIndex < 0) {
-                this.suggestionIndex = this.suggestions.length - 1;
-            }
-        }
-        return this.suggestions[this.suggestionIndex];
-    }
-    getSuggestions() {
-        return [...this.suggestions];
-    }
-    getSearchString() {
-        return this.searchString;
-    }
-    generateSuggestions(params) {
-        const blacklist = new Set(['0_defn', '0_lambda']);
-        const startsWithCaseSensitive = this.generateWithPredicate(params, suggestion => !blacklist.has(suggestion) && suggestion.startsWith(this.searchString));
-        startsWithCaseSensitive.forEach(suggestion => blacklist.add(suggestion));
-        const startsWithCaseInsensitive = this.generateWithPredicate(params, suggestion => !blacklist.has(suggestion) && suggestion.toLowerCase().startsWith(this.searchString.toLowerCase()));
-        startsWithCaseInsensitive.forEach(suggestion => blacklist.add(suggestion));
-        const includesCaseSensitive = this.generateWithPredicate(params, suggestion => !blacklist.has(suggestion) && suggestion.includes(this.searchString));
-        includesCaseSensitive.forEach(suggestion => blacklist.add(suggestion));
-        const includesCaseInsensitive = this.generateWithPredicate(params, suggestion => !blacklist.has(suggestion) && suggestion.includes(this.searchString.toLowerCase()));
-        includesCaseInsensitive.forEach(suggestion => blacklist.add(suggestion));
-        return [...startsWithCaseSensitive, ...startsWithCaseInsensitive, ...includesCaseSensitive, ...includesCaseInsensitive];
-    }
-    generateWithPredicate(params, shouldInclude) {
-        const suggestions = new Set();
-        dvalaCommands.forEach((suggestion) => {
-            if (shouldInclude(suggestion)) {
-                suggestions.add(suggestion);
-            }
-        });
-        Object.keys(params.globalContext ?? {})
-            .filter(shouldInclude)
-            .forEach(suggestion => suggestions.add(suggestion));
-        params.contexts?.forEach((context) => {
-            Object.keys(context)
-                .filter(shouldInclude)
-                .forEach(suggestion => suggestions.add(suggestion));
-        });
-        Object.keys(params.bindings ?? {})
-            .filter(shouldInclude)
-            .forEach(suggestion => suggestions.add(suggestion));
-        return [...suggestions].sort((a, b) => a.localeCompare(b));
-    }
-}
-
-function isDvalaBundle(value) {
-    return (typeof value === 'object'
-        && value !== null
-        && typeof value.program === 'string'
-        && Array.isArray(value.fileModules));
-}
-
 var collectionSource = "{\n  map: (first-coll, ...args) -> do\n    let fn = last(args);\n    let other-colls = slice(args, 0, count(args) - 1);\n    let all-colls = [first-coll, ...other-colls];\n\n    cond\n      case object?(first-coll) then do\n        let expected-keys = keys(first-coll) |> sort;\n        doseq (obj in other-colls) -> do\n          if not(object?(obj)) then\n            perform(effect(dvala.error), \"Expected object\")\n          end;\n          let obj-keys = keys(obj) |> sort;\n          if not(obj-keys == expected-keys) then\n            perform(effect(dvala.error), ++(\n              \"All objects must have the same keys. Expected: \",\n              join(expected-keys, \", \"),\n              \". Found: \",\n              join(obj-keys, \", \")\n            ))\n          end\n        end;\n        reduce(keys(first-coll), (acc, k) -> do\n          let a = for (coll in all-colls) -> coll(k);\n          assoc(acc, k, apply(fn, a))\n        end, {})\n      end\n\n      case string?(first-coll) then do\n        doseq (s in other-colls) -> do\n          if not(string?(s)) then\n            perform(effect(dvala.error), \"Expected string\")\n          end\n        end;\n        let len = reduce(other-colls, (m, s) -> min(m, count(s)), count(first-coll));\n        let mapped = for (i in range(len)) -> do\n          let a = for (coll in all-colls) -> nth(coll, i);\n          apply(fn, a)\n        end;\n        reduce(mapped, (acc, ch) -> do\n          if not(string?(ch)) then\n            perform(effect(dvala.error), \"Expected string\")\n          end;\n          ++(acc, ch)\n        end, \"\")\n      end\n\n      case true then do\n        doseq (x in other-colls) -> do\n          if not(array?(x)) then\n            perform(effect(dvala.error), \"Expected array\")\n          end\n        end;\n        let len = reduce(other-colls, (m, x) -> min(m, count(x)), count(first-coll));\n        for (i in range(len)) -> do\n          let a = for (coll in all-colls) -> nth(coll, i);\n          apply(fn, a)\n        end\n      end\n    end\n  end,\n\n  filter: (coll, fn) -> do\n    cond\n      case array?(coll) then\n        reduce(coll, (acc, elem) -> if fn(elem) then [...acc, elem] else acc end, [])\n\n      case string?(coll) then\n        reduce(coll, (acc, ch) -> if fn(ch) then ++(acc, ch) else acc end, \"\")\n\n      case object?(coll) then\n        reduce(keys(coll), (acc, k) -> do\n          if fn(coll(k)) then\n            assoc(acc, k, coll(k))\n          else\n            acc\n          end\n        end, {})\n\n      case true then\n        perform(effect(dvala.error), \"Expected collection\")\n    end\n  end,\n\n  reduce: (coll, fn, initial) -> do\n    cond\n      case string?(coll) then\n        loop (acc = initial, i = 0) -> do\n          if i >= count(coll) then\n            acc\n          else\n            recur(fn(acc, nth(coll, i)), i + 1)\n          end\n        end\n\n      case array?(coll) then\n        loop (acc = initial, i = 0) -> do\n          if i >= count(coll) then\n            acc\n          else\n            recur(fn(acc, nth(coll, i)), i + 1)\n          end\n        end\n\n      case object?(coll) then do\n        let values = vals(coll);\n        loop (acc = initial, i = 0) -> do\n          if i >= count(values) then\n            acc\n          else\n            recur(fn(acc, nth(values, i)), i + 1)\n          end\n        end\n      end\n\n      case true then\n        perform(effect(dvala.error), \"Expected collection\")\n    end\n  end\n}";
 
 var sequenceSource = "{\n  some: (seq, fn) -> do\n    if null?(seq) then null\n    else do\n      loop (i = 0) -> do\n        if i >= count(seq) then\n          null\n        else do\n          let elem = nth(seq, i);\n          if fn(elem) then elem\n          else recur(i + 1)\n          end\n        end\n        end\n      end\n    end\n    end\n  end,\n\n  take-while: (seq, fn) -> do\n    let is-str = string?(seq);\n    let len = count(seq);\n    let idx = loop (i = 0) -> do\n      if i >= len then\n        len\n      else if fn(nth(seq, i)) then\n        recur(i + 1)\n      else\n        i\n      end\n      end\n    end;\n    slice(seq, 0, idx)\n  end,\n\n  drop-while: (seq, fn) -> do\n    let is-str = string?(seq);\n    let len = count(seq);\n    let idx = loop (i = 0) -> do\n      if i >= len then\n        len\n      else if fn(nth(seq, i)) then\n        recur(i + 1)\n      else\n        i\n      end\n      end\n    end;\n    slice(seq, idx)\n  end,\n\n  sort: (seq, ...args) -> do\n    let cmp = if count(args) == 0 then compare else first(args) end;\n    let is-str = string?(seq);\n    let arr = if is-str then split(seq, \"\") else seq end;\n    let len = count(arr);\n\n    // merge two sorted arrays\n    let merge-arrays = (left, right) -> do\n      let left-len = count(left);\n      let right-len = count(right);\n      loop (result = [], li = 0, ri = 0) -> do\n        if li >= left-len then\n          ++(result, slice(right, ri))\n        else if ri >= right-len then\n          ++(result, slice(left, li))\n        else do\n          let l = nth(left, li);\n          let r = nth(right, ri);\n          if cmp(l, r) <= 0 then\n            recur(push(result, l), li + 1, ri)\n          else\n            recur(push(result, r), li, ri + 1)\n          end\n        end\n        end\n        end\n      end\n    end;\n\n    // recursive merge-sort\n    let merge-sort = (a) -> do\n      let n = count(a);\n      if n <= 1 then a\n      else do\n        let mid = floor(n / 2);\n        let left = merge-sort(slice(a, 0, mid));\n        let right = merge-sort(slice(a, mid));\n        merge-arrays(left, right)\n      end\n      end\n    end;\n\n    let sorted = merge-sort(arr);\n    if is-str then join(sorted, \"\") else sorted end\n  end\n}\n";
@@ -12873,202 +12883,202 @@ class Cache {
     }
 }
 
-class Dvala {
-    astCache;
-    astCacheSize;
-    debug;
-    modules;
-    constructor(config = {}) {
-        initCoreDvalaSources();
-        this.debug = config.debug ?? false;
-        this.astCacheSize = config.astCacheSize ?? null;
-        if (this.astCacheSize) {
-            this.astCache = new Cache(this.astCacheSize);
-            const initialCache = config.initialCache ?? {};
-            for (const cacheEntry of Object.keys(initialCache))
-                this.astCache.set(cacheEntry, initialCache[cacheEntry]);
-        }
-        else {
-            this.astCache = null;
-        }
-        const nsList = config.modules ?? [];
-        this.modules = new Map(nsList.map(ns => [ns.name, ns]));
-    }
-    getRuntimeInfo() {
-        return {
-            astCacheSize: this.astCacheSize,
-            astCache: this.astCache,
-            debug: this.debug,
-        };
-    }
-    async = {
-        run: async (programOrBundle, params = {}) => {
-            assertSerializableBindings(params.bindings);
-            if (isDvalaBundle(programOrBundle)) {
-                return this.runBundle(programOrBundle, params);
-            }
-            const ast = this.generateAst(programOrBundle, params);
-            if (params.handlers) {
-                const contextStack = createContextStack(params, this.modules, params.pure);
-                const result = await evaluateWithEffects(ast, contextStack, params.handlers);
-                if (result.type === 'completed')
-                    return result.value;
-                if (result.type === 'error')
-                    throw result.error;
-                throw new TypeError('Unexpected suspension in Dvala.async.run(). Use the standalone effects API for suspend/resume.');
-            }
-            return this.evaluateAsync(ast, params);
-        },
-        apply: async (fn, fnParams, params = {}) => {
-            return this.apply(fn, fnParams, params);
-        },
-    };
-    run(programOrBundle, params = {}) {
-        assertSerializableBindings(params.bindings);
-        if (isDvalaBundle(programOrBundle)) {
-            return this.runBundle(programOrBundle, params);
-        }
-        const ast = this.generateAst(programOrBundle, params);
-        const result = this.evaluate(ast, params);
-        if (result instanceof Promise) {
-            throw new TypeError('Unexpected async result in synchronous run(). Use dvala.async.run() for async operations.');
-        }
-        return result;
-    }
-    runBundle(bundle, params = {}) {
-        const contextStack = createContextStack(params, this.modules, params.pure);
-        // Evaluate file modules in dependency order and register as value modules.
-        // Each file module is evaluated in its own scope so local bindings don't leak.
-        // File modules are always evaluated in pure mode to ensure deterministic,
-        // side-effect-free initialization regardless of the caller's pure setting.
-        const savedPure = contextStack.pure;
-        contextStack.pure = true;
-        for (const [name, source] of bundle.fileModules) {
-            const ast = this.generateAst(source, params);
-            const moduleContextStack = contextStack.create({});
-            const result = evaluate(ast, moduleContextStack);
-            // TODO: When async functions in file modules are able to mark themselves as pure and
-            // are returning a Promise, uncomment the following check, and make sure a test is verifying the behaviour.
-            // if (result instanceof Promise) {
-            //   throw new TypeError('Unexpected async result in synchronous runBundle(). Use dvala.async.run() for async operations.')
-            // }
-            contextStack.registerValueModule(name, result);
-        }
-        contextStack.pure = savedPure;
-        // Parse and evaluate the main program
-        const ast = this.generateAst(bundle.program, params);
-        const result = evaluate(ast, contextStack);
-        if (result instanceof Promise) {
-            throw new TypeError('Unexpected async result in synchronous runBundle(). Use dvala.async.run() for async operations.');
-        }
-        return result;
-    }
-    getUndefinedSymbols(programOrAst, params = {}) {
-        const ast = typeof programOrAst === 'string' ? this.generateAst(programOrAst, params) : programOrAst;
-        const contextStack = createContextStack(params, this.modules);
-        return getUndefinedSymbols(ast, contextStack, builtin, evaluateNode);
-    }
-    tokenize(program, tokenizeParams = {}) {
-        const tokenStream = tokenize(program, this.debug, tokenizeParams.filePath);
-        return tokenizeParams.minify ? minifyTokenStream(tokenStream, { removeWhiteSpace: false }) : tokenStream;
-    }
-    parse(tokenStream) {
-        tokenStream = minifyTokenStream(tokenStream, { removeWhiteSpace: true });
-        const ast = {
-            body: [],
-            hasDebugData: tokenStream.hasDebugData,
-        };
-        ast.body = parse(tokenStream);
-        return ast;
-    }
-    evaluate(ast, params) {
-        const contextStack = createContextStack(params, this.modules, params.pure);
-        return evaluate(ast, contextStack);
-    }
-    evaluateAsync(ast, params) {
-        const contextStack = createContextStack(params, this.modules, params.pure);
-        return evaluateAsync(ast, contextStack);
-    }
-    transformSymbols(tokenStream, transformer) {
-        return transformSymbolTokens(tokenStream, transformer);
-    }
-    untokenize(tokenStream) {
-        return untokenize(tokenStream);
-    }
-    apply(fn, fnParams, params = {}) {
-        const fnName = 'FN_2eb7b316_471c_5bfa_90cb_d3dfd9164a59';
-        const program = this.generateApplyFunctionCall(fnName, fnParams);
-        const ast = this.generateAst(program, params);
-        const hostValues = fnParams.reduce((result, param, index) => {
-            result[`${fnName}_${index}`] = param;
-            return result;
-        }, { [fnName]: fn });
-        params.bindings = { ...params.bindings, ...hostValues };
-        return this.evaluate(ast, params);
-    }
-    generateApplyFunctionCall(fnName, fnParams) {
-        const paramsString = fnParams
-            .map((_, index) => {
-            return `${fnName}_${index}`;
-        })
-            .join(', ');
-        return `${fnName}(${paramsString})`;
-    }
-    generateAst(program, params) {
-        if (this.astCache) {
-            const cachedAst = this.astCache.get(program);
-            if (cachedAst)
-                return cachedAst;
-        }
-        const tokenStream = this.tokenize(program, {
-            filePath: params.filePath,
-        });
-        const ast = this.parse(tokenStream);
-        this.astCache?.set(program, ast);
-        return ast;
-    }
-    getAutoCompleter(program, position, params = {}) {
-        return new AutoCompleter(program, position, this, params);
-    }
+function isDvalaBundle(value) {
+    return (typeof value === 'object'
+        && value !== null
+        && typeof value.program === 'string'
+        && Array.isArray(value.fileModules));
+}
+
+/**
+ * Standalone tooling functions for tokenizing, parsing, and analysis.
+ *
+ * These are thin wrappers around internal utilities that do not require
+ * a Dvala instance.
+ */
+/**
+ * Get all undefined symbols in a Dvala program.
+ *
+ * @param source - Dvala source code
+ * @param options - optional context to treat as defined
+ * @param options.bindings - host bindings to treat as defined
+ * @param options.modules - modules to treat as available
+ */
+function getUndefinedSymbols(source, options) {
+    const modulesMap = options?.modules
+        ? new Map(options.modules.map(m => [m.name, m]))
+        : undefined;
+    const contextStack = createContextStack({ bindings: options?.bindings }, modulesMap);
+    const tokenStream = tokenize(source, false, undefined);
+    const minified = minifyTokenStream(tokenStream, { removeWhiteSpace: true });
+    const ast = { body: parse(minified), hasDebugData: false };
+    return getUndefinedSymbols$1(ast, contextStack, builtin, evaluateNode);
 }
+
 function assertSerializableBindings(bindings) {
     if (!bindings)
         return;
-    for (const [key, value] of Object.entries(bindings)) {
-        assertSerializable(value, `bindings["${key}"]`);
-    }
+    for (const [key, val] of Object.entries(bindings))
+        assertSerializable(val, `bindings["${key}"]`);
 }
-function assertSerializable(value, path) {
-    if (value === null || value === undefined)
+function assertSerializable(val, path) {
+    if (val === null || val === undefined)
         return;
-    if (typeof value === 'boolean' || typeof value === 'string')
+    if (typeof val === 'boolean' || typeof val === 'string')
         return;
-    if (typeof value === 'number') {
-        if (!Number.isFinite(value))
-            throw new TypeError(`${path} is not serializable (${value})`);
+    if (typeof val === 'number') {
+        if (!Number.isFinite(val))
+            throw new TypeError(`${path} is not serializable (${val})`);
         return;
     }
-    if (typeof value === 'function')
+    if (typeof val === 'function')
         throw new TypeError(`${path} is not serializable (function)`);
-    if (typeof value === 'object') {
-        // Dvala values (functions, regexps, effects) are valid
-        if (FUNCTION_SYMBOL in value) {
+    if (typeof val === 'object') {
+        if (FUNCTION_SYMBOL in val || REGEXP_SYMBOL in val || EFFECT_SYMBOL in val)
             return;
-        }
-        if (REGEXP_SYMBOL in value || EFFECT_SYMBOL in value)
-            return;
-        if (Array.isArray(value)) {
-            value.forEach((item, i) => assertSerializable(item, `${path}[${i}]`));
+        if (Array.isArray(val)) {
+            val.forEach((item, i) => assertSerializable(item, `${path}[${i}]`));
             return;
         }
-        if (Object.getPrototypeOf(value) !== Object.prototype)
+        if (Object.getPrototypeOf(val) !== Object.prototype)
             throw new TypeError(`${path} is not serializable (not a plain object)`);
-        for (const [k, v] of Object.entries(value))
+        for (const [k, v] of Object.entries(val))
             assertSerializable(v, `${path}.${k}`);
         return;
     }
     throw new TypeError(`${path} is not serializable`);
 }
+function createDvala(options) {
+    initCoreDvalaSources();
+    const modules = options?.modules
+        ? new Map(options.modules.map(m => [m.name, m]))
+        : undefined;
+    const factoryBindings = options?.bindings;
+    const factoryEffectHandlers = options?.effectHandlers;
+    const debug = options?.debug ?? false;
+    const cache = options?.cache ? new Cache(options.cache) : null;
+    function buildAst(source, filePath) {
+        if (!filePath && cache) {
+            const cached = cache.get(source);
+            if (cached)
+                return cached;
+        }
+        const tokenStream = tokenize(source, debug, filePath);
+        const minified = minifyTokenStream(tokenStream, { removeWhiteSpace: true });
+        const ast = { body: parse(minified), hasDebugData: debug };
+        if (!filePath)
+            cache?.set(source, ast);
+        return ast;
+    }
+    function mergeBindings(runBindings) {
+        if (!factoryBindings && !runBindings)
+            return undefined;
+        return { ...factoryBindings, ...runBindings };
+    }
+    function mergeEffectHandlers(runEffectHandlers) {
+        if (!factoryEffectHandlers && !runEffectHandlers)
+            return undefined;
+        // Run handlers first (checked first), factory handlers fill in the rest.
+        // For same key, run overrides factory.
+        const result = { ...runEffectHandlers };
+        if (factoryEffectHandlers) {
+            for (const [k, v] of Object.entries(factoryEffectHandlers)) {
+                if (!(k in result))
+                    result[k] = v;
+            }
+        }
+        return result;
+    }
+    function assertNotPureWithHandlers(pure, effectHandlers) {
+        if (!pure)
+            return;
+        const hasEffectHandlers = effectHandlers && Object.keys(effectHandlers).length > 0;
+        if (hasEffectHandlers) {
+            throw new TypeError('Cannot use pure mode with effect handlers');
+        }
+    }
+    return {
+        run(source, runOptions) {
+            assertSerializableBindings(runOptions?.bindings);
+            const bindings = mergeBindings(runOptions?.bindings);
+            const effectHandlers = mergeEffectHandlers(runOptions?.effectHandlers);
+            const pure = runOptions?.pure ?? false;
+            assertNotPureWithHandlers(pure, effectHandlers);
+            const contextStack = createContextStack({ bindings }, modules, pure);
+            if (isDvalaBundle(source)) {
+                const savedPure = contextStack.pure;
+                contextStack.pure = true;
+                for (const [name, fileSource] of source.fileModules) {
+                    const fileAst = buildAst(fileSource);
+                    const moduleContextStack = contextStack.create({});
+                    contextStack.registerValueModule(name, evaluate(fileAst, moduleContextStack));
+                }
+                contextStack.pure = savedPure;
+                const ast = buildAst(source.program);
+                const result = evaluate(ast, contextStack);
+                if (result instanceof Promise)
+                    throw new TypeError('Unexpected async result in run(). Use runAsync() for async operations.');
+                return result;
+            }
+            const ast = buildAst(source, runOptions?.filePath);
+            if (effectHandlers) {
+                return evaluateWithSyncEffects(ast, contextStack, effectHandlers);
+            }
+            const result = evaluate(ast, contextStack);
+            if (result instanceof Promise) {
+                throw new TypeError('Unexpected async result in run(). Use runAsync() for async operations.');
+            }
+            return result;
+        },
+        async runAsync(source, runOptions) {
+            assertSerializableBindings(runOptions?.bindings);
+            const bindings = mergeBindings(runOptions?.bindings);
+            const effectHandlers = mergeEffectHandlers(runOptions?.effectHandlers);
+            const pure = runOptions?.pure ?? false;
+            assertNotPureWithHandlers(pure, effectHandlers);
+            try {
+                const contextStack = createContextStack({ bindings }, modules, pure);
+                if (isDvalaBundle(source)) {
+                    const savedPure = contextStack.pure;
+                    contextStack.pure = true;
+                    for (const [name, fileSource] of source.fileModules) {
+                        const fileAst = buildAst(fileSource);
+                        const moduleContextStack = contextStack.create({});
+                        contextStack.registerValueModule(name, evaluate(fileAst, moduleContextStack));
+                    }
+                    contextStack.pure = savedPure;
+                }
+                const programSource = isDvalaBundle(source) ? source.program : source;
+                const ast = buildAst(programSource);
+                const result = await evaluateWithEffects(ast, contextStack, effectHandlers, runOptions?.maxSnapshots, {
+                    values: bindings,
+                    modules,
+                });
+                if (result.type === 'completed') {
+                    return { ...result, definedBindings: contextStack.getModuleScopeBindings() };
+                }
+                return result;
+            }
+            catch (error) {
+                if (error instanceof DvalaError) {
+                    return { type: 'error', error };
+                }
+                if (error instanceof TypeError) {
+                    throw error;
+                }
+                return { type: 'error', error: new DvalaError(`${error}`, undefined) };
+            }
+        },
+        getUndefinedSymbols(source) {
+            const modulesList = modules ? [...modules.values()] : undefined;
+            return getUndefinedSymbols(source, { bindings: factoryBindings, modules: modulesList });
+        },
+        getAutoCompleter(program, position) {
+            const params = { bindings: factoryBindings };
+            return new AutoCompleter(program, position, params);
+        },
+    };
+}
 
 var assertionModuleSource = "{}";
 
@@ -14448,7 +14458,7 @@ const assertModule = {
     docs: moduleDocs$5,
 };
 
-var gridModuleSource = "do\nlet _transpose = (g) ->\n  map(range(count(first(g))), (i) ->\n    map(range(count(g)), (j) -> nth(nth(g, j), i))\n  );\n{\n  \"cell-every?\": (grid, predicate) -> do\n    let cells = flatten(grid, 1);\n    loop(i = 0) ->\n      cond\n        case i >= count(cells) then true\n        case not(predicate(nth(cells, i))) then false\n        case true then recur(i + 1)\n      end\n  end,\n\n  \"some?\": (grid, predicate) -> do\n    let cells = flatten(grid, 1);\n    loop(i = 0) ->\n      cond\n        case i >= count(cells) then false\n        case predicate(nth(cells, i)) then true\n        case true then recur(i + 1)\n      end\n  end,\n\n  \"every-row?\": (grid, predicate) ->\n    loop(i = 0) ->\n      cond\n        case i >= count(grid) then true\n        case not(predicate(nth(grid, i))) then false\n        case true then recur(i + 1)\n      end,\n\n  \"some-row?\": (grid, predicate) ->\n    loop(i = 0) ->\n      cond\n        case i >= count(grid) then false\n        case predicate(nth(grid, i)) then true\n        case true then recur(i + 1)\n      end,\n\n  \"every-col?\": (grid, predicate) -> do\n    let cols = _transpose(grid);\n    loop(i = 0) ->\n      cond\n        case i >= count(cols) then true\n        case not(predicate(nth(cols, i))) then false\n        case true then recur(i + 1)\n      end\n  end,\n\n  \"some-col?\": (grid, predicate) -> do\n    let cols = _transpose(grid);\n    loop(i = 0) ->\n      cond\n        case i >= count(cols) then false\n        case predicate(nth(cols, i)) then true\n        case true then recur(i + 1)\n      end\n  end,\n\n  \"generate\": (rows, cols, generator) ->\n    map(range(rows), (i) -> map(range(cols), (j) -> generator(i, j))),\n\n  \"cell-map\": (...params) -> do\n    let fn = last(params);\n    let grids = drop-last(params, 1);\n    let rows = count(first(grids));\n    let cols = count(first(first(grids)));\n    map(range(rows), (i) ->\n      map(range(cols), (j) ->\n        apply(fn, map(grids, (g) -> nth(nth(g, i), j)))\n      )\n    )\n  end,\n\n  \"cell-mapi\": (grid, fn) -> do\n    let rows = count(grid);\n    let cols = count(first(grid));\n    map(range(rows), (i) ->\n      map(range(cols), (j) ->\n        fn(nth(nth(grid, i), j), i, j)\n      )\n    )\n  end,\n\n  \"cell-reduce\": (grid, fn, initial-value) ->\n    reduce(flatten(grid, 1), fn, initial-value),\n\n  \"cell-reducei\": (grid, fn, initial-value) -> do\n    let rows = count(grid);\n    let cols = count(first(grid));\n    loop(acc = initial-value, i = 0, j = 0) ->\n      cond\n        case i >= rows then acc\n        case j >= cols then recur(acc, i + 1, 0)\n        case true then recur(fn(acc, nth(nth(grid, i), j), i, j), i, j + 1)\n      end\n  end\n}\nend\n";
+var gridModuleSource = "do\nlet _transpose = (g) ->\n  map(range(count(first(g))), (i) ->\n    map(range(count(g)), (j) -> nth(nth(g, j), i))\n  );\n{\n  \"cell-every?\": (grid, predicate) -> do\n    let cells = flatten(grid, 1);\n    loop(i = 0) ->\n      cond\n        case i >= count(cells) then true\n        case not(predicate(nth(cells, i))) then false\n        case true then recur(i + 1)\n      end\n  end,\n  \"some?\": (grid, predicate) -> do\n    let cells = flatten(grid, 1);\n    loop(i = 0) ->\n      cond\n        case i >= count(cells) then false\n        case predicate(nth(cells, i)) then true\n        case true then recur(i + 1)\n      end\n  end,\n\n  \"every-row?\": (grid, predicate) ->\n    loop(i = 0) ->\n      cond\n        case i >= count(grid) then true\n        case not(predicate(nth(grid, i))) then false\n        case true then recur(i + 1)\n      end,\n\n  \"some-row?\": (grid, predicate) ->\n    loop(i = 0) ->\n      cond\n        case i >= count(grid) then false\n        case predicate(nth(grid, i)) then true\n        case true then recur(i + 1)\n      end,\n\n  \"every-col?\": (grid, predicate) -> do\n    let cols = _transpose(grid);\n    loop(i = 0) ->\n      cond\n        case i >= count(cols) then true\n        case not(predicate(nth(cols, i))) then false\n        case true then recur(i + 1)\n      end\n  end,\n\n  \"some-col?\": (grid, predicate) -> do\n    let cols = _transpose(grid);\n    loop(i = 0) ->\n      cond\n        case i >= count(cols) then false\n        case predicate(nth(cols, i)) then true\n        case true then recur(i + 1)\n      end\n  end,\n\n  \"generate\": (rows, cols, generator) ->\n    map(range(rows), (i) -> map(range(cols), (j) -> generator(i, j))),\n\n  \"cell-map\": (...params) -> do\n    let fn = last(params);\n    let grids = drop-last(params, 1);\n    let rows = count(first(grids));\n    let cols = count(first(first(grids)));\n    map(range(rows), (i) ->\n      map(range(cols), (j) ->\n        apply(fn, map(grids, (g) -> nth(nth(g, i), j)))\n      )\n    )\n  end,\n\n  \"cell-mapi\": (grid, fn) -> do\n    let rows = count(grid);\n    let cols = count(first(grid));\n    map(range(rows), (i) ->\n      map(range(cols), (j) ->\n        fn(nth(nth(grid, i), j), i, j)\n      )\n    )\n  end,\n\n  \"cell-reduce\": (grid, fn, initial-value) ->\n    reduce(flatten(grid, 1), fn, initial-value),\n\n  \"cell-reducei\": (grid, fn, initial-value) -> do\n    let rows = count(grid);\n    let cols = count(first(grid));\n    loop(acc = initial-value, i = 0, j = 0) ->\n      cond\n        case i >= rows then acc\n        case j >= cols then recur(acc, i + 1, 0)\n        case true then recur(fn(acc, nth(nth(grid, i), j), i, j), i, j + 1)\n      end\n  end\n}\nend;";
 
 const moduleDocs$4 = {
     'cell-every?': {
@@ -34681,7 +34691,7 @@ function runTest({ testPath: filePath, testNamePattern }) {
             }
             else {
                 try {
-                    const dvala = new Dvala({ debug: true, modules: allBuiltinModules });
+                    const dvala = createDvala({ debug: true, modules: allBuiltinModules });
                     const bindings = getBindings(includedFilePaths, dvala);
                     dvala.run(testChunkProgram.program, {
                         bindings,
@@ -35156,7 +35166,7 @@ function specialExpressionDocsToReference() {
 }
 const specialExpressionsReference = specialExpressionDocsToReference();
 function isFunctionReference(ref) {
-    return 'returns' in ref && 'args' in ref && 'variants' in ref;
+    return 'returns' in ref && 'args' in ref && 'variants' in ref && !('effect' in ref);
 }
 const normalExpressionReference = {
     // Core categories — all derived from co-located docs
@@ -37064,7 +37074,7 @@ function getArgumentInfo(fmt, reference) {
 }
 
 /* eslint-disable no-console */
-const dvala = new Dvala({ debug: false });
+const dvala = createDvala({ debug: false });
 function getCliFunctionExamples(fmt, reference) {
     const { examples } = reference;
     return examples
@@ -37671,19 +37681,15 @@ const helpRegExp = new RegExp(`^\`help\\s+(${polishSymbolFirstCharacterClass}${p
 const expressions = [...normalExpressionKeys, ...specialExpressionKeys];
 const config = processArguments(process.argv.slice(2));
 const cliModules = getCliModules();
-function createDvala(context, pure) {
-    const _dvala = new Dvala({ debug: true, modules: [...allBuiltinModules, ...cliModules] });
+function makeDvala(bindings, pure) {
+    const runner = createDvala({ debug: true, modules: [...allBuiltinModules, ...cliModules], bindings });
     return {
-        run: (program) => _dvala.run(program, {
-            globalContext: context,
-            globalModuleScope: true,
-            pure,
-        }),
+        run: (program) => runner.run(program, { pure }),
     };
 }
 switch (config.subcommand) {
     case 'run': {
-        const dvala = createDvala(config.context, config.pure);
+        const dvala = makeDvala(config.context, config.pure);
         try {
             const content = fs.readFileSync(config.filename, { encoding: 'utf-8' });
             const result = dvala.run(content);
@@ -37699,7 +37705,7 @@ switch (config.subcommand) {
         break;
     }
     case 'run-bundle': {
-        const dvala = createDvala(config.context, config.pure);
+        const dvala = makeDvala(config.context, config.pure);
         try {
             const content = fs.readFileSync(config.filename, { encoding: 'utf-8' });
             let parsed;
@@ -37727,7 +37733,7 @@ switch (config.subcommand) {
         break;
     }
     case 'eval': {
-        const dvala = createDvala(config.context, config.pure);
+        const dvala = makeDvala(config.context, config.pure);
         try {
             const result = dvala.run(config.expression);
             if (config.printResult) {
@@ -37767,12 +37773,12 @@ switch (config.subcommand) {
     }
     case 'repl': {
         if (config.loadFilename) {
-            const dvala = createDvala(config.context, false);
+            const dvala = makeDvala(config.context, false);
             const content = fs.readFileSync(config.loadFilename, { encoding: 'utf-8' });
             const result = dvala.run(content);
             if (result !== null && typeof result === 'object' && !Array.isArray(result)) {
                 for (const [key, value] of Object.entries(result)) {
-                    config.context[key] = { value: asAny(value) };
+                    config.context[key] = value;
                 }
             }
         }
@@ -37803,13 +37809,12 @@ function runDvalaTest(testPath, testNamePattern) {
     if (!success)
         process.exit(1);
 }
-async function execute(expression, context, readLine) {
-    const _dvala = new Dvala({ debug: true, modules: [...allBuiltinModules, ...cliModules] });
+async function execute(expression, bindings, readLine) {
+    const _dvala = createDvala({ debug: true, modules: [...allBuiltinModules, ...cliModules] });
     try {
-        const result = await _dvala.async.run(expression, {
-            globalContext: context,
-            globalModuleScope: true,
-            handlers: {
+        const runResult = await _dvala.runAsync(expression, {
+            bindings,
+            effectHandlers: {
                 'dvala.io.read-line': async ({ args, resume }) => {
                     const message = typeof args[0] === 'string' ? args[0] : '';
                     const answer = await readLine(message);
@@ -37817,18 +37822,21 @@ async function execute(expression, context, readLine) {
                 },
             },
         });
+        if (runResult.type === 'error')
+            throw runResult.error;
+        const result = runResult.type === 'completed' ? runResult.value : null;
         historyResults.unshift(result);
         if (historyResults.length > 9) {
             historyResults.length = 9;
         }
-        setReplHistoryVariables(context);
+        const newBindings = { ...bindings, ...(runResult.type === 'completed' ? runResult.definedBindings : {}) };
+        setReplHistoryVariables(newBindings);
         console.log(stringifyValue(result, false));
-        return true;
+        return newBindings;
     }
     catch (error) {
         printErrorMessage(`${error}`);
-        context['*e*'] = { value: getErrorMessage(error) };
-        return false;
+        return { ...bindings, '*e*': getErrorMessage(error) };
     }
 }
 function getErrorMessage(error) {
@@ -37836,18 +37844,11 @@ function getErrorMessage(error) {
         return error.message;
     return 'Unknown error';
 }
-function setReplHistoryVariables(context) {
-    delete context['*1*'];
-    delete context['*2*'];
-    delete context['*3*'];
-    delete context['*4*'];
-    delete context['*5*'];
-    delete context['*6*'];
-    delete context['*7*'];
-    delete context['*8*'];
-    delete context['*9*'];
+function setReplHistoryVariables(bindings) {
+    for (let i = 1; i <= 9; i++)
+        delete bindings[`*${i}*`];
     historyResults.forEach((value, i) => {
-        context[`*${i + 1}*`] = { value: asAny(value) };
+        bindings[`*${i + 1}*`] = value;
     });
 }
 function parseOption(args, i) {
@@ -37890,7 +37891,7 @@ function parseContextOptions(args, startIndex) {
                 }
                 try {
                     Object.entries(JSON.parse(parsed.argument)).forEach(([key, value]) => {
-                        options.context[key] = { value: asAny(value) };
+                        options.context[key] = value;
                     });
                 }
                 catch (e) {
@@ -37908,7 +37909,7 @@ function parseContextOptions(args, startIndex) {
                 try {
                     const contextString = fs.readFileSync(parsed.argument, { encoding: 'utf-8' });
                     Object.entries(JSON.parse(contextString)).forEach(([key, value]) => {
-                        options.context[key] = { value: asAny(value) };
+                        options.context[key] = value;
                     });
                 }
                 catch (e) {
@@ -38140,9 +38141,10 @@ function processArguments(args) {
         }
     }
 }
-function runREPL(context) {
+function runREPL(initialBindings) {
     console.log(`Welcome to Dvala v${version}.
 Type ${fmt.italic('`help')} for more information.`);
+    let bindings = initialBindings;
     const rl = createReadlineInterface({
         completer,
         historySize: HIST_SIZE,
@@ -38169,7 +38171,7 @@ Type ${fmt.italic('`help')} for more information.`);
                     printHelp();
                     break;
                 case '`context':
-                    printContext(context);
+                    printContext(bindings);
                     break;
                 case '`quit':
                     rl.close();
@@ -38179,7 +38181,7 @@ Type ${fmt.italic('`help')} for more information.`);
             }
         }
         else if (line) {
-            await execute(line, context, readLine);
+            bindings = await execute(line, bindings, readLine);
         }
         rl.prompt();
     }).on('close', () => {
@@ -38248,14 +38250,14 @@ Global options:
 With no subcommand, starts an interactive REPL.
 `.trim());
 }
-function printContext(context) {
-    const keys = Object.keys(context);
+function printContext(bindings) {
+    const keys = Object.keys(bindings);
     if (keys.length === 0) {
         console.log('[empty]\n');
     }
     else {
         keys.sort().forEach((x) => {
-            console.log(`${x} = ${formatValue(stringifyValue(context[x].value))}`);
+            console.log(`${x} = ${formatValue(stringifyValue(bindings[x]))}`);
         });
         console.log();
     }
@@ -38270,8 +38272,8 @@ function completer(line) {
     if (expressionMatch)
         return [expressions.filter(c => c.startsWith(expressionMatch[2])).map(c => `${expressionMatch[1]}${c} `), line];
     // TODO, add reserved names
-    const context = config.context ?? {};
-    const names = Array.from(new Set([...Object.keys(context)]));
+    const replBindings = config.context ?? {};
+    const names = Array.from(new Set([...Object.keys(replBindings)]));
     const nameMatch = nameRegExp.exec(line);
     if (nameMatch)
         return [names.filter(c => c.startsWith(nameMatch[2])).map(c => `${nameMatch[1]}${c} `), line];