@mojir/dvala 0.0.13 → 0.0.15

package/dist/cli/cli.js

@@ -68,6 +68,17 @@ var DvalaError = class DvalaError extends Error {
 	getCodeMarker() {
 		return this.sourceCodeInfo && getCodeMarker(this.sourceCodeInfo);
 	}
+	toJSON() {
+		return {
+			name: this.name,
+			message: this.message,
+			shortMessage: this.shortMessage,
+			line: this.sourceCodeInfo?.position.line,
+			column: this.sourceCodeInfo?.position.column,
+			code: this.sourceCodeInfo?.code,
+			filePath: this.sourceCodeInfo?.filePath
+		};
+	}
 };
 var UserDefinedError = class UserDefinedError extends DvalaError {
 	userMessage;
@@ -466,7 +477,7 @@ function findAllOccurrences(input, pattern) {
 }
 //#endregion
 //#region package.json
-var version = "0.0.13";
+var version = "0.0.15";
 //#endregion
 //#region src/typeGuards/string.ts
 function isString(value, options = {}) {
@@ -5571,7 +5582,7 @@ If all expressions evaluate to truthy values, the value of the last expression i
 		}
 		return value;
 	},
-	getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin, evaluateNode }) => getUndefinedSymbols(node[1][1], contextStack, builtin, evaluateNode)
+	getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin }) => getUndefinedSymbols(node[1][1], contextStack, builtin)
 };
 const condSpecialExpression = {
 	arity: {},
@@ -5614,7 +5625,7 @@ cond
 end ?? "TRUE"`
 		]
 	},
-	getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin, evaluateNode }) => getUndefinedSymbols(node[1][1].flat(), contextStack, builtin, evaluateNode)
+	getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin }) => getUndefinedSymbols(node[1][1].flat(), contextStack, builtin)
 };
 //#endregion
 //#region src/parser/types.ts
@@ -5627,79 +5638,6 @@ const bindingTargetTypes = {
 	wildcard: 16
 };
 //#endregion
-//#region src/utils/maybePromise.ts
-/**
-* Chain a value that might be a Promise. If the value is sync, calls fn synchronously.
-* If it's a Promise, chains with .then().
-*/
-function chain(value, fn) {
-	if (value instanceof Promise) return value.then(fn);
-	return fn(value);
-}
-/**
-* Like Array.map but handles MaybePromise callbacks sequentially.
-* In the sync case, runs as a simple loop. Switches to async only when needed.
-*/
-function mapSequential(arr, fn) {
-	const results = [];
-	for (let i = 0; i < arr.length; i++) {
-		const result = fn(arr[i], i);
-		if (result instanceof Promise) return chainRemainingMap(result, results, arr, fn, i);
-		results.push(result);
-	}
-	return results;
-}
-async function chainRemainingMap(currentPromise, results, arr, fn, startIndex) {
-	results.push(await currentPromise);
-	for (let i = startIndex + 1; i < arr.length; i++) results.push(await fn(arr[i], i));
-	return results;
-}
-/**
-* Like Array.reduce but handles MaybePromise callbacks sequentially.
-* In the sync case, runs as a simple loop. Switches to async only when needed.
-*/
-function reduceSequential(arr, fn, initial) {
-	let result = initial;
-	for (let i = 0; i < arr.length; i++) {
-		const next = fn(result, arr[i], i);
-		if (next instanceof Promise) return chainRemainingReduce(next, arr, fn, i);
-		result = next;
-	}
-	return result;
-}
-async function chainRemainingReduce(currentPromise, arr, fn, startIndex) {
-	let result = await currentPromise;
-	for (let i = startIndex + 1; i < arr.length; i++) result = await fn(result, arr[i], i);
-	return result;
-}
-/**
-* Like Array.forEach but handles MaybePromise callbacks sequentially.
-* In the sync case, runs as a simple loop. Switches to async only when needed.
-*/
-function forEachSequential(arr, fn) {
-	for (let i = 0; i < arr.length; i++) {
-		const result = fn(arr[i], i);
-		if (result instanceof Promise) return chainRemainingForEach(result, arr, fn, i);
-	}
-}
-async function chainRemainingForEach(currentPromise, arr, fn, startIndex) {
-	await currentPromise;
-	for (let i = startIndex + 1; i < arr.length; i++) await fn(arr[i], i);
-}
-/**
-* Try/catch that handles MaybePromise values correctly.
-* If tryFn returns a Promise, catches both sync throws and Promise rejections.
-*/
-function tryCatch(tryFn, catchFn) {
-	try {
-		const result = tryFn();
-		if (result instanceof Promise) return result.catch(catchFn);
-		return result;
-	} catch (error) {
-		return catchFn(error);
-	}
-}
-//#endregion
 //#region src/builtin/bindingNode.ts
 function walkDefaults(bindingTarget, onDefault) {
 	if (bindingTarget[0] === bindingTargetTypes.object) Object.values(bindingTarget[1][0]).forEach((element) => {
@@ -5714,70 +5652,6 @@ function walkDefaults(bindingTarget, onDefault) {
 		walkDefaults(element, onDefault);
 	}
 }
-function evaluateBindingNodeValues(target, value, evaluate) {
-	const sourceCodeInfo = target[2];
-	const record = {};
-	return chain(createRecord(target, value, evaluate, sourceCodeInfo, record), () => record);
-}
-function createRecord(bindingTarget, value, evaluate, sourceCodeInfo, record) {
-	if (bindingTarget[0] === bindingTargetTypes.object) {
-		assertUnknownRecord(value, sourceCodeInfo);
-		const capturedKeys = /* @__PURE__ */ new Set();
-		let restElement;
-		return chain(forEachSequential(Object.entries(bindingTarget[1][0]), ([key, element]) => {
-			if (element[0] === bindingTargetTypes.rest) {
-				restElement = element;
-				return;
-			}
-			capturedKeys.add(key);
-			const existingVal = value[key];
-			return chain(existingVal !== void 0 ? existingVal : element[1][1] ? evaluate(element[1][1]) : null, (resolvedVal) => {
-				const val = resolvedVal ?? null;
-				assertAny(val, sourceCodeInfo);
-				return createRecord(element, val, evaluate, sourceCodeInfo, record);
-			});
-		}), () => {
-			if (restElement) {
-				const restValues = Object.entries(value).filter(([key]) => !capturedKeys.has(key)).reduce((acc, [key, val]) => {
-					acc[key] = asAny(val);
-					return acc;
-				}, {});
-				record[restElement[1][0]] = restValues;
-			}
-		});
-	} else if (bindingTarget[0] === bindingTargetTypes.array) {
-		let restIndex = null;
-		assertArray(value, sourceCodeInfo);
-		const elements = [];
-		for (let index = 0; index < bindingTarget[1][0].length; index += 1) {
-			const element = bindingTarget[1][0][index] ?? null;
-			if (element === null) continue;
-			if (element[0] === bindingTargetTypes.rest) {
-				restIndex = index;
-				break;
-			}
-			elements.push({
-				element,
-				index
-			});
-		}
-		return chain(forEachSequential(elements, ({ element, index }) => {
-			const existingVal = value[index];
-			return chain(existingVal !== void 0 ? existingVal : element[1][1] ? evaluate(element[1][1]) : null, (resolvedVal) => {
-				const val = resolvedVal ?? null;
-				assertAny(val, sourceCodeInfo);
-				return createRecord(element, val, evaluate, sourceCodeInfo, record);
-			});
-		}), () => {
-			if (restIndex !== null) {
-				const restValues = value.slice(restIndex);
-				const restElement = bindingTarget[1][0][restIndex];
-				record[restElement[1][0]] = restValues;
-			}
-		});
-	} else if (bindingTarget[0] === bindingTargetTypes.rest) record[bindingTarget[1][0]] = asAny(value);
-	else record[bindingTarget[1][0][1]] = asAny(value);
-}
 function getAllBindingTargetNames(bindingTarget) {
 	const names = {};
 	getNamesFromBindingTarget(bindingTarget, names);
@@ -5795,98 +5669,6 @@ function getNamesFromBindingTarget(target, names) {
 		names[target[1][0][1]] = true;
 	}
 }
-/**
-* Non-throwing pattern matching. Returns bindings on match, null on mismatch.
-* Used by `switch` pattern matching.
-*/
-function tryMatch(target, value, evaluate) {
-	const record = {};
-	return chain(tryMatchRecord(target, value, evaluate, record), (matched) => {
-		if (!matched) return null;
-		return record;
-	});
-}
-function tryMatchRecord(bindingTarget, value, evaluate, record) {
-	if (bindingTarget[0] === bindingTargetTypes.wildcard) return true;
-	else if (bindingTarget[0] === bindingTargetTypes.literal) {
-		const literalNode = bindingTarget[1][0];
-		return chain(evaluate(literalNode), (literalValue) => {
-			return deepEqual$1(value, literalValue);
-		});
-	} else if (bindingTarget[0] === bindingTargetTypes.symbol) {
-		const symbolNode = bindingTarget[1][0];
-		const defaultNode = bindingTarget[1][1];
-		if (value === void 0 || value === null) {
-			if (defaultNode) return chain(evaluate(defaultNode), (defaultValue) => {
-				record[symbolNode[1]] = asAny(defaultValue);
-				return true;
-			});
-			record[symbolNode[1]] = value ?? null;
-		} else record[symbolNode[1]] = asAny(value);
-		return true;
-	} else if (bindingTarget[0] === bindingTargetTypes.object) {
-		if (!isUnknownRecord(value)) return false;
-		const capturedKeys = /* @__PURE__ */ new Set();
-		let restElement;
-		const entries = Object.entries(bindingTarget[1][0]);
-		let result = true;
-		for (const [key, element] of entries) result = chain(result, (matched) => {
-			if (!matched) return false;
-			if (element[0] === bindingTargetTypes.rest) {
-				restElement = element;
-				return true;
-			}
-			capturedKeys.add(key);
-			const existingVal = value[key];
-			if (existingVal === void 0 && element[0] === bindingTargetTypes.literal) return chain(evaluate(element[1][0]), (literalValue) => {
-				return deepEqual$1(void 0, literalValue);
-			});
-			return chain(existingVal !== void 0 ? existingVal : element[1] && element[1][1] ? evaluate(element[1][1]) : null, (resolvedVal) => {
-				return tryMatchRecord(element, resolvedVal ?? null, evaluate, record);
-			});
-		});
-		return chain(result, (matched) => {
-			if (!matched) return false;
-			if (restElement) {
-				const restValues = Object.entries(value).filter(([key]) => !capturedKeys.has(key)).reduce((acc, [key, val]) => {
-					acc[key] = asAny(val);
-					return acc;
-				}, {});
-				record[restElement[1][0]] = restValues;
-			}
-			return true;
-		});
-	} else {
-		const arrayTarget = bindingTarget;
-		if (!Array.isArray(value)) return false;
-		const elements = arrayTarget[1][0];
-		let restIndex = null;
-		for (let i = 0; i < elements.length; i += 1) {
-			const element = elements[i];
-			if (element !== null && element[0] === bindingTargetTypes.rest) {
-				restIndex = i;
-				break;
-			}
-		}
-		if (restIndex === null && value.length !== elements.length) return false;
-		if (restIndex !== null && value.length < restIndex) return false;
-		let result = true;
-		for (let i = 0; i < elements.length; i += 1) {
-			const element = elements[i];
-			if (element === null) continue;
-			if (element[0] === bindingTargetTypes.rest) {
-				record[element[1][0]] = value.slice(i);
-				break;
-			}
-			const el = element;
-			result = chain(result, (matched) => {
-				if (!matched) return false;
-				return tryMatchRecord(el, asAny(value[i]), evaluate, record);
-			});
-		}
-		return result;
-	}
-}
 const matchSpecialExpression = {
 	arity: {},
 	docs: {
@@ -5946,15 +5728,15 @@ match { role: "admin", name: "Alice" }
 end`
 		]
 	},
-	getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin, evaluateNode }) => {
+	getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin }) => {
 		const result = /* @__PURE__ */ new Set();
-		getUndefinedSymbols([node[1][1]], contextStack, builtin, evaluateNode).forEach((s) => result.add(s));
+		getUndefinedSymbols([node[1][1]], contextStack, builtin).forEach((s) => result.add(s));
 		for (const [pattern, body, guard] of node[1][2]) {
 			const newContext = {};
 			Object.assign(newContext, getAllBindingTargetNames(pattern));
 			const caseContextStack = contextStack.create(newContext);
-			if (guard) getUndefinedSymbols([guard], caseContextStack, builtin, evaluateNode).forEach((s) => result.add(s));
-			getUndefinedSymbols([body], caseContextStack, builtin, evaluateNode).forEach((s) => result.add(s));
+			if (guard) getUndefinedSymbols([guard], caseContextStack, builtin).forEach((s) => result.add(s));
+			getUndefinedSymbols([body], caseContextStack, builtin).forEach((s) => result.add(s));
 		}
 		return result;
 	}
@@ -5975,7 +5757,7 @@ Built-in symbols are always considered defined. For user-defined symbols, checks
 			"defined?(+)"
 		]
 	},
-	getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin, evaluateNode }) => getUndefinedSymbols([node[1][1]], contextStack, builtin, evaluateNode)
+	getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin }) => getUndefinedSymbols([node[1][1]], contextStack, builtin)
 };
 const doSpecialExpression = {
 	arity: {},
@@ -6012,14 +5794,14 @@ with
   case effect(dvala.io.println) then ([msg]) -> null
 end`]
 	},
-	getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin, evaluateNode }) => {
-		const bodyResult = getUndefinedSymbols(node[1][1], contextStack.create({}), builtin, evaluateNode);
+	getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin }) => {
+		const bodyResult = getUndefinedSymbols(node[1][1], contextStack.create({}), builtin);
 		const withHandlers = node[1][2];
 		if (!withHandlers || withHandlers.length === 0) return bodyResult;
 		let withResult = /* @__PURE__ */ new Set();
 		for (const [effectExpr, handlerFn] of withHandlers) {
-			const effectResult = getUndefinedSymbols([effectExpr], contextStack, builtin, evaluateNode);
-			const handlerResult = getUndefinedSymbols([handlerFn], contextStack, builtin, evaluateNode);
+			const effectResult = getUndefinedSymbols([effectExpr], contextStack, builtin);
+			const handlerResult = getUndefinedSymbols([handlerFn], contextStack, builtin);
 			withResult = joinSets(withResult, effectResult, handlerResult);
 		}
 		return joinSets(bodyResult, withResult);
@@ -6029,22 +5811,22 @@ end`]
 //#region src/builtin/specialExpressions/functions.ts
 const lambdaSpecialExpression = {
 	arity: {},
-	getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin, evaluateNode }) => {
+	getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin }) => {
 		const fn = node[1][1];
-		return getFunctionUnresolvedSymbols(fn, contextStack, getUndefinedSymbols, builtin, evaluateNode);
+		return getFunctionUnresolvedSymbols(fn, contextStack, getUndefinedSymbols, builtin);
 	}
 };
-function getFunctionUnresolvedSymbols(fn, contextStack, getUndefinedSymbols, builtin, evaluateNode) {
+function getFunctionUnresolvedSymbols(fn, contextStack, getUndefinedSymbols, builtin) {
 	const result = /* @__PURE__ */ new Set();
 	const newContext = { self: { value: null } };
 	fn[0].forEach((arg) => {
 		Object.assign(newContext, getAllBindingTargetNames(arg));
 		walkDefaults(arg, (defaultNode) => {
-			addToSet(result, getUndefinedSymbols([defaultNode], contextStack, builtin, evaluateNode));
+			addToSet(result, getUndefinedSymbols([defaultNode], contextStack, builtin));
 		});
 	});
 	const newContextStack = contextStack.create(newContext);
-	addToSet(result, getUndefinedSymbols(fn[1], newContextStack, builtin, evaluateNode));
+	addToSet(result, getUndefinedSymbols(fn[1], newContextStack, builtin));
 	return result;
 }
 const ifSpecialExpression = {
@@ -6085,7 +5867,7 @@ end`,
 			"if false then \"TRUE\" end"
 		]
 	},
-	getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin, evaluateNode }) => getUndefinedSymbols(node[1][1].filter((n) => !!n), contextStack, builtin, evaluateNode)
+	getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin }) => getUndefinedSymbols(node[1][1].filter((n) => !!n), contextStack, builtin)
 };
 const unlessSpecialExpression = {
 	arity: {},
@@ -6122,7 +5904,7 @@ end`,
 			"unless false then \"TRUE\" end"
 		]
 	},
-	getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin, evaluateNode }) => getUndefinedSymbols(node[1][1].filter((n) => !!n), contextStack, builtin, evaluateNode)
+	getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin }) => getUndefinedSymbols(node[1][1].filter((n) => !!n), contextStack, builtin)
 };
 const letSpecialExpression = {
 	arity: toFixedArity(0),
@@ -6145,13 +5927,13 @@ let a = 1 + 2 + 3 + 4;
 let b = -> $ * ( $ + 1 );
 b(a)`]
 	},
-	getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin, evaluateNode }) => {
+	getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin }) => {
 		const bindingNode = node[1][1];
 		const target = bindingNode[1][0];
 		const value = bindingNode[1][1];
-		const bindingResult = getUndefinedSymbols([value], contextStack, builtin, evaluateNode);
+		const bindingResult = getUndefinedSymbols([value], contextStack, builtin);
 		walkDefaults(target, (defaultNode) => {
-			addToSet(bindingResult, getUndefinedSymbols([defaultNode], contextStack, builtin, evaluateNode));
+			addToSet(bindingResult, getUndefinedSymbols([defaultNode], contextStack, builtin));
 		});
 		contextStack.addValues(getAllBindingTargetNames(target), target[2]);
 		return bindingResult;
@@ -6188,7 +5970,7 @@ end`, `loop (n = 5, acc = 1) -> do
   end
 end`]
 	},
-	getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin, evaluateNode }) => {
+	getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin }) => {
 		const bindingNodes = node[1][1];
 		const newContext = bindingNodes.reduce((context, bindingNode) => {
 			const names = getAllBindingTargetNames(bindingNode[1][0]);
@@ -6197,30 +5979,30 @@ end`]
 			});
 			return context;
 		}, {});
-		return joinSets(getUndefinedSymbols(bindingNodes.map((bindingNode) => bindingNode[1][1]), contextStack, builtin, evaluateNode), getUndefinedSymbols([node[1][2]], contextStack.create(newContext), builtin, evaluateNode));
+		return joinSets(getUndefinedSymbols(bindingNodes.map((bindingNode) => bindingNode[1][1]), contextStack, builtin), getUndefinedSymbols([node[1][2]], contextStack.create(newContext), builtin));
 	}
 };
 //#endregion
 //#region src/builtin/specialExpressions/loops.ts
-function analyze(loopNode, contextStack, getUndefinedSymbols, builtin, evaluateNode) {
+function analyze(loopNode, contextStack, getUndefinedSymbols, builtin) {
 	const result = /* @__PURE__ */ new Set();
 	const newContext = {};
 	const [, loopBindings, body] = loopNode[1];
 	loopBindings.forEach((loopBindingNode) => {
 		const [bindingNode, letBindings, whenNode, whileNode] = loopBindingNode;
 		const [target, value] = bindingNode[1];
-		getUndefinedSymbols([value], contextStack.create(newContext), builtin, evaluateNode).forEach((symbol) => result.add(symbol));
+		getUndefinedSymbols([value], contextStack.create(newContext), builtin).forEach((symbol) => result.add(symbol));
 		Object.assign(newContext, getAllBindingTargetNames(target));
 		/* v8 ignore next */
 		if (letBindings) letBindings.forEach((letBindingNode) => {
 			const [letTarget, letValue] = letBindingNode[1];
-			getUndefinedSymbols([letValue], contextStack.create(newContext), builtin, evaluateNode).forEach((symbol) => result.add(symbol));
+			getUndefinedSymbols([letValue], contextStack.create(newContext), builtin).forEach((symbol) => result.add(symbol));
 			Object.assign(newContext, getAllBindingTargetNames(letTarget));
 		});
-		if (whenNode) getUndefinedSymbols([whenNode], contextStack.create(newContext), builtin, evaluateNode).forEach((symbol) => result.add(symbol));
-		if (whileNode) getUndefinedSymbols([whileNode], contextStack.create(newContext), builtin, evaluateNode).forEach((symbol) => result.add(symbol));
+		if (whenNode) getUndefinedSymbols([whenNode], contextStack.create(newContext), builtin).forEach((symbol) => result.add(symbol));
+		if (whileNode) getUndefinedSymbols([whileNode], contextStack.create(newContext), builtin).forEach((symbol) => result.add(symbol));
 	});
-	getUndefinedSymbols([body], contextStack.create(newContext), builtin, evaluateNode).forEach((symbol) => result.add(symbol));
+	getUndefinedSymbols([body], contextStack.create(newContext), builtin).forEach((symbol) => result.add(symbol));
 	return result;
 }
 const forSpecialExpression = {
@@ -6279,7 +6061,7 @@ for (
 ) -> ii + j
       `]
 	},
-	getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin, evaluateNode }) => analyze(node, contextStack, getUndefinedSymbols, builtin, evaluateNode)
+	getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin }) => analyze(node, contextStack, getUndefinedSymbols, builtin)
 };
 const doseqSpecialExpression = {
 	arity: toFixedArity(1),
@@ -6329,7 +6111,7 @@ const doseqSpecialExpression = {
 doseq (i in [1, 2, 3]) -> perform(effect(dvala.io.println), i * 2)
       `]
 	},
-	getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin, evaluateNode }) => analyze(node, contextStack, getUndefinedSymbols, builtin, evaluateNode)
+	getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin }) => analyze(node, contextStack, getUndefinedSymbols, builtin)
 };
 const orSpecialExpression = {
 	arity: {},
@@ -6372,7 +6154,7 @@ const orSpecialExpression = {
 		}
 		return value;
 	},
-	getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin, evaluateNode }) => getUndefinedSymbols(node[1][1], contextStack, builtin, evaluateNode)
+	getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin }) => getUndefinedSymbols(node[1][1], contextStack, builtin)
 };
 const qqSpecialExpression = {
 	arity: { min: 1 },
@@ -6420,7 +6202,7 @@ Also works with undefined symbols — if a symbol is undefined, it is treated as
 		}
 		return null;
 	},
-	getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin, evaluateNode }) => getUndefinedSymbols(node[1][1], contextStack, builtin, evaluateNode)
+	getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin }) => getUndefinedSymbols(node[1][1], contextStack, builtin)
 };
 const recurSpecialExpression = {
 	arity: {},
@@ -6459,7 +6241,7 @@ end`
 	evaluateAsNormalExpression: (params) => {
 		throw new RecurSignal(params);
 	},
-	getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin, evaluateNode }) => getUndefinedSymbols(node[1][1], contextStack, builtin, evaluateNode)
+	getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin }) => getUndefinedSymbols(node[1][1], contextStack, builtin)
 };
 const arraySpecialExpression = {
 	arity: {},
@@ -6491,7 +6273,7 @@ const arraySpecialExpression = {
 		for (const param of params) result.push(asAny(param, sourceCodeInfo));
 		return result;
 	},
-	getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin, evaluateNode }) => getUndefinedSymbols(node[1][1], contextStack, builtin, evaluateNode)
+	getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin }) => getUndefinedSymbols(node[1][1], contextStack, builtin)
 };
 const effectSpecialExpression = {
 	arity: {},
@@ -6550,7 +6332,7 @@ let default = {
 		}
 		return result;
 	},
-	getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin, evaluateNode }) => getUndefinedSymbols(node[1][1], contextStack, builtin, evaluateNode)
+	getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin }) => getUndefinedSymbols(node[1][1], contextStack, builtin)
 };
 const importSpecialExpression = {
 	arity: toFixedArity(1),
@@ -6580,8 +6362,8 @@ const parallelSpecialExpression = {
 		description: "Evaluates all branch expressions concurrently and returns an array of results in order. Each branch runs as an independent trampoline invocation. If any branch suspends, the entire `parallel` suspends with a composite blob. On resume, branches are resumed one at a time. Only available in async mode (`run()`). Requires at least one branch.",
 		examples: []
 	},
-	getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin, evaluateNode }) => {
-		return joinSets(...node[1][1].map((branch) => getUndefinedSymbols([branch], contextStack, builtin, evaluateNode)));
+	getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin }) => {
+		return joinSets(...node[1][1].map((branch) => getUndefinedSymbols([branch], contextStack, builtin)));
 	}
 };
 const performSpecialExpression = {
@@ -6612,9 +6394,9 @@ end
 `],
 		seeAlso: ["effect?"]
 	},
-	getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin, evaluateNode }) => {
+	getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin }) => {
 		const [, effectExpr, argExprs] = node[1];
-		return joinSets(getUndefinedSymbols([effectExpr], contextStack, builtin, evaluateNode), getUndefinedSymbols(argExprs, contextStack, builtin, evaluateNode));
+		return joinSets(getUndefinedSymbols([effectExpr], contextStack, builtin), getUndefinedSymbols(argExprs, contextStack, builtin));
 	}
 };
 const raceSpecialExpression = {
@@ -6630,8 +6412,8 @@ const raceSpecialExpression = {
 		description: "Races all branch expressions concurrently. The first branch to complete wins — its value becomes the result. Losing branches are cancelled via AbortSignal. Errored branches are silently dropped. If all branches error, throws an aggregate error. If no branch completes but some suspend, the race suspends. On resume, the host provides the winner value directly. Only available in async mode (`run()`). Requires at least one branch.",
 		examples: []
 	},
-	getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin, evaluateNode }) => {
-		return joinSets(...node[1][1].map((branch) => getUndefinedSymbols([branch], contextStack, builtin, evaluateNode)));
+	getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin }) => {
+		return joinSets(...node[1][1].map((branch) => getUndefinedSymbols([branch], contextStack, builtin)));
 	}
 };
 //#endregion
@@ -6697,6 +6479,9 @@ function isFunctionDocs(docs) {
 	return "args" in docs && "variants" in docs;
 }
 //#endregion
+//#region src/builtin/modules/assertion/assertion.dvala
+var assertion_default = "{\n  assert-fails: (fn, ...args) -> do\n    let message = first(args);\n    assert(function?(fn), \"First argument must be a function\");\n    if not(null?(message)) then assert(string?(message), \"Second argument must be a string\") end;\n    let failed-sentinel = effect(dvala.assertion.failed);\n    let result = do fn() with case effect(dvala.error) then ([msg]) -> failed-sentinel end;\n    if effect?(result) && result == failed-sentinel then\n      null\n    else\n      assert(false, message ?? \"Expected function to fail\")\n    end\n  end,\n\n  assert-fails-with: (fn, expected-error, ...args) -> do\n    let message = first(args);\n    assert(function?(fn), \"First argument must be a function\");\n    assert(string?(expected-error), \"Second argument must be a string\");\n    if not(null?(message)) then assert(string?(message), \"Third argument must be a string\") end;\n    let failed-sentinel = effect(dvala.assertion.failed);\n    let result = do fn() with case effect(dvala.error) then ([msg]) -> [failed-sentinel, msg] end;\n    if array?(result) && first(result) == failed-sentinel then do\n      let actual-error = second(result);\n      if actual-error == expected-error then\n        null\n      else\n        assert(false, message ?? (\"Expected function to fail with \\\"\" ++ expected-error ++ \"\\\" but got \\\"\" ++ actual-error ++ \"\\\"\"))\n      end\n    end\n    else\n      assert(false, message ?? (\"Expected function to fail with \\\"\" ++ expected-error ++ \"\\\"\"))\n    end\n  end,\n\n  assert-succeeds: (fn, ...args) -> do\n    let message = first(args);\n    assert(function?(fn), \"First argument must be a function\");\n    if not(null?(message)) then assert(string?(message), \"Second argument must be a string\") end;\n    let failed-sentinel = effect(dvala.assertion.failed);\n    let result = do fn() with case effect(dvala.error) then ([msg]) -> failed-sentinel end;\n    if effect?(result) && result == failed-sentinel then\n      assert(false, message ?? \"Expected function to succeed\")\n    else\n      null\n    end\n  end\n}\n";
+//#endregion
 //#region src/builtin/modules/assertion/docs.ts
 const moduleDocs$5 = {
 	"assert!=": {
@@ -6974,22 +6759,22 @@ const moduleDocs$5 = {
 		seeAlso: ["assertion.assert-truthy", "assertion.assert-falsy"],
 		hideOperatorForm: true
 	},
-	"assert-throws": {
+	"assert-fails": {
 		category: "assertion",
-		description: "If $fun does not throw, it throws `AssertionError`.",
+		description: "If $fun does not fail (perform `dvala.error`), it throws `AssertionError`.",
 		returns: { type: "null" },
 		args: {
 			fun: { type: "function" },
 			message: { type: "string" }
 		},
 		variants: [{ argumentNames: ["fun"] }, { argumentNames: ["fun", "message"] }],
-		examples: ["let { assert-throws } = import(assertion);\nassert-throws(-> perform(effect(dvala.error), \"Error\"))", "let { assert-throws } = import(assertion);\ndo assert-throws(-> identity(\"Error\")) with case effect(dvala.error) then ([msg]) -> msg end"],
-		seeAlso: ["assertion.assert-throws-error", "assertion.assert-not-throws"],
+		examples: ["let { assert-fails } = import(assertion);\nassert-fails(-> perform(effect(dvala.error), \"Error\"))", "let { assert-fails } = import(assertion);\ndo assert-fails(-> identity(\"Error\")) with case effect(dvala.error) then ([msg]) -> msg end"],
+		seeAlso: ["assertion.assert-fails-with", "assertion.assert-succeeds"],
 		hideOperatorForm: true
 	},
-	"assert-throws-error": {
+	"assert-fails-with": {
 		category: "assertion",
-		description: "If $fun does not throw $error-message, it throws `AssertionError`.",
+		description: "If $fun does not fail with $error-message, it throws `AssertionError`.",
 		returns: { type: "null" },
 		args: {
 			"fun": { type: "function" },
@@ -7001,21 +6786,21 @@ const moduleDocs$5 = {
 			"error-message",
 			"message"
 		] }],
-		examples: ["let { assert-throws-error } = import(assertion);\ndo assert-throws-error(-> perform(effect(dvala.error), \"Error\"), \"Error\") with case effect(dvala.error) then ([msg]) -> msg end", "let { assert-throws-error } = import(assertion);\ndo assert-throws-error(-> identity(\"Error\"), \"Error\") with case effect(dvala.error) then ([msg]) -> msg end"],
-		seeAlso: ["assertion.assert-throws", "assertion.assert-not-throws"],
+		examples: ["let { assert-fails-with } = import(assertion);\ndo assert-fails-with(-> perform(effect(dvala.error), \"Error\"), \"Error\") with case effect(dvala.error) then ([msg]) -> msg end", "let { assert-fails-with } = import(assertion);\ndo assert-fails-with(-> identity(\"Error\"), \"Error\") with case effect(dvala.error) then ([msg]) -> msg end"],
+		seeAlso: ["assertion.assert-fails", "assertion.assert-succeeds"],
 		hideOperatorForm: true
 	},
-	"assert-not-throws": {
+	"assert-succeeds": {
 		category: "assertion",
-		description: "If $fun throws, it throws `AssertionError`.",
+		description: "If $fun fails (performs `dvala.error`), it throws `AssertionError`.",
 		returns: { type: "null" },
 		args: {
 			fun: { type: "function" },
 			message: { type: "string" }
 		},
 		variants: [{ argumentNames: ["fun"] }, { argumentNames: ["fun", "message"] }],
-		examples: ["let { assert-not-throws } = import(assertion);\ndo assert-not-throws(-> identity(\"Error\")) with case effect(dvala.error) then ([msg]) -> msg end", "let { assert-not-throws } = import(assertion);\ndo assert-not-throws(-> perform(effect(dvala.error), \"Error\")) with case effect(dvala.error) then ([msg]) -> msg end"],
-		seeAlso: ["assertion.assert-throws", "assertion.assert-throws-error"],
+		examples: ["let { assert-succeeds } = import(assertion);\ndo assert-succeeds(-> identity(\"OK\")) with case effect(dvala.error) then ([msg]) -> msg end", "let { assert-succeeds } = import(assertion);\ndo assert-succeeds(-> perform(effect(dvala.error), \"Error\")) with case effect(dvala.error) then ([msg]) -> msg end"],
+		seeAlso: ["assertion.assert-fails", "assertion.assert-fails-with"],
 		hideOperatorForm: true
 	},
 	"assert-array": {
@@ -7404,57 +7189,22 @@ const assertNormalExpression = {
 			max: 2
 		}
 	},
-	"assert-throws": {
-		evaluate: ([func, message], sourceCodeInfo, contextStack, { executeFunction }) => {
-			if (message !== void 0) {
-				assertString(message, sourceCodeInfo);
-				message = ` ${message}`;
-			}
-			message ??= "";
-			assertFunctionLike(func, sourceCodeInfo);
-			return tryCatch(() => chain(executeFunction(func, [], contextStack, sourceCodeInfo), () => {
-				throw new AssertionError(`Expected function to throw.${message}`, sourceCodeInfo);
-			}), () => null);
-		},
+	"assert-fails": {
+		evaluate: () => null,
 		arity: {
 			min: 1,
 			max: 2
 		}
 	},
-	"assert-throws-error": {
-		evaluate: ([func, throwMessage, message], sourceCodeInfo, contextStack, { executeFunction }) => {
-			if (message !== void 0) {
-				assertString(message, sourceCodeInfo);
-				message = ` ${message}`;
-			}
-			message ??= "";
-			assertString(throwMessage, sourceCodeInfo);
-			assertFunctionLike(func, sourceCodeInfo);
-			return tryCatch(() => chain(executeFunction(func, [], contextStack, sourceCodeInfo), () => {
-				throw new AssertionError(`Expected function to throw "${throwMessage}".${message}`, sourceCodeInfo);
-			}), (error) => {
-				const errorMessage = error.shortMessage;
-				if (errorMessage !== throwMessage) throw new AssertionError(`Expected function to throw "${throwMessage}", but thrown "${errorMessage}".${message}`, sourceCodeInfo);
-				return null;
-			});
-		},
+	"assert-fails-with": {
+		evaluate: () => null,
 		arity: {
 			min: 2,
 			max: 3
 		}
 	},
-	"assert-not-throws": {
-		evaluate: ([func, message], sourceCodeInfo, contextStack, { executeFunction }) => {
-			if (message !== void 0) {
-				assertString(message, sourceCodeInfo);
-				message = ` ${message}`;
-			}
-			message ??= "";
-			assertFunctionLike(func, sourceCodeInfo);
-			return tryCatch(() => chain(executeFunction(func, [], contextStack, sourceCodeInfo), () => null), () => {
-				throw new AssertionError(`Expected function not to throw.${message}`, sourceCodeInfo);
-			});
-		},
+	"assert-succeeds": {
+		evaluate: () => null,
 		arity: {
 			min: 1,
 			max: 2
@@ -7662,7 +7412,7 @@ if (assertNormalExpression[key]) assertNormalExpression[key].docs = docs;
 const assertModule = {
 	name: "assertion",
 	functions: assertNormalExpression,
-	source: "{}",
+	source: assertion_default,
 	docs: moduleDocs$5
 };
 //#endregion
@@ -17203,6 +16953,9 @@ const moduleDocs$1 = {
 	}
 };
 //#endregion
+//#region src/builtin/modules/number-theory/number-theory.dvala
+var number_theory_default = "do\n  // Helper predicates\n  let is-prime = (n) ->\n    if n < 2 then false\n    else if n == 2 then true\n    else if n % 2 == 0 then false\n    else loop (i = 3) ->\n      if i * i > n then true\n      else if n % i == 0 then false\n      else recur(i + 2) end\n      end\n    end\n    end\n    end;\n\n  let is-perfect-square = (n) ->\n    if n < 0 then false\n    else do\n      let s = floor(sqrt(n));\n      s * s == n\n    end end;\n\n  let is-perfect-cube = (n) -> do\n    let c = round(sign(n) * (abs(n) ^ (1 / 3)));\n    c * c * c == n\n  end;\n\n  let sum-proper-divisors = (n) ->\n    if n <= 1 then 0\n    else loop (i = 2, acc = 1) ->\n      if i * i > n then acc\n      else if n % i == 0 then\n        if i * i == n then recur(i + 1, acc + i)\n        else recur(i + 1, acc + i + n / i) end\n      else recur(i + 1, acc) end\n      end end;\n\n  let is-abundant = (n) -> n > 0 && sum-proper-divisors(n) > n;\n  let is-deficient = (n) -> n > 0 && sum-proper-divisors(n) < n;\n  let is-composite = (n) -> n > 1 && not(is-prime(n));\n\n  let is-happy = (n) -> do\n    let sum-of-squared-digits = (x) ->\n      loop (num = x, acc = 0) ->\n        if num == 0 then acc\n        else do\n          let d = num % 10;\n          recur(floor(num / 10), acc + d * d)\n        end end;\n    loop (slow = n, fast = sum-of-squared-digits(n)) ->\n      if fast == 1 then true\n      else if slow == fast then false\n      else recur(sum-of-squared-digits(slow), sum-of-squared-digits(sum-of-squared-digits(fast))) end\n      end\n  end;\n\n  let count-bits = (n) ->\n    loop (x = n, acc = 0) ->\n      if x == 0 then acc\n      else recur(floor(x / 2), acc + x % 2) end;\n\n  let is-perfect-power = (n) ->\n    if n == 1 then true\n    else if n < 2 then false\n    else loop (k = 2) ->\n      if 2 ^ k > n then false\n      else do\n        let b = round(n ^ (1 / k));\n        if b ^ k == n then true\n        else recur(k + 1) end\n      end\n    end end end;\n\n  let binom = (n, k) ->\n    if k == 0 || k == n then 1\n    else loop (i = 0, k2 = min(k, n - k), acc = 1) ->\n      if i >= k2 then acc\n      else recur(i + 1, k2, acc * (n - i) / (i + 1)) end\n    end;\n\n  let bell-numbers = [1, 2, 5, 15, 52, 203, 877, 4140, 21147, 115975, 678570, 4213597, 27644437, 190899322, 1382958545, 10480142147, 82864869804, 682076806159, 5832742205057, 51724158235372, 474869816156751, 4506715738447323];\n\n  let catalan-numbers = [1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845, 35357670, 129644790, 477638700, 1767263190, 6564120420, 24466267020, 91482563640, 343059613650, 1289904147324, 4861946401452, 18367353072152, 69533550916004, 263747951750360, 1002242216651368, 3814986502092304];\n\n  let mersenne-numbers = [3, 7, 31, 127, 2047, 8191, 131071, 524287, 2147483647];\n\n  let perfect-numbers = [6, 28, 496, 8128, 33550336, 8589869056, 137438691328];\n\n  let sylvester-numbers = [2, 6, 42, 1806, 3263442, 10650056950806];\n\n  let lucky-numbers = [1, 3, 7, 9, 13, 15, 21, 25, 31, 33, 37, 43, 49, 51, 63, 67, 69, 73, 75, 79, 87, 93, 99, 105, 111, 115, 127, 129, 133, 135, 141, 151, 159, 163, 169, 171, 189, 193, 195, 201, 205, 211, 219, 223, 231, 235, 237, 241, 259, 261, 267, 273, 283, 285, 289, 297, 303, 307, 319, 321, 327, 331, 339, 349, 357, 361, 367, 385, 391, 393, 399, 409, 415, 421, 427, 429, 433, 451, 463, 475, 477, 483, 487, 489, 495, 511, 517, 519, 529, 535, 537, 541, 553, 559, 577, 579, 583, 591, 601, 613, 615, 619, 621, 631, 639, 643, 645, 651, 655, 673, 679, 685, 693, 699, 717, 723, 727, 729, 735, 739, 741, 745, 769, 777, 781, 787, 801, 805, 819, 823, 831, 841, 855, 867, 873, 883, 885, 895, 897, 903, 925, 927, 931, 933, 937, 957, 961, 975, 979, 981, 991, 993, 997, 1009, 1011, 1021, 1023, 1029, 1039, 1041, 1053, 1057, 1087, 1093, 1095, 1101, 1105, 1107, 1117, 1123, 1147, 1155, 1167, 1179, 1183, 1189, 1197, 1201, 1203, 1209, 1219, 1231, 1233, 1245, 1249, 1251, 1261, 1263, 1275, 1281, 1285, 1291, 1303, 1309, 1323, 1329, 1339, 1357, 1365, 1369, 1387, 1389, 1395, 1401, 1417, 1419, 1435, 1441, 1455, 1459, 1471, 1473, 1485, 1491, 1495, 1497, 1501, 1503, 1519, 1533, 1543, 1545, 1563, 1567, 1575, 1579, 1585, 1587, 1597, 1599, 1611, 1639, 1641, 1645, 1659, 1663, 1675, 1693, 1701, 1705, 1711, 1723, 1731, 1737, 1749, 1765, 1767, 1771, 1773, 1777, 1797, 1801, 1809, 1819, 1827, 1831, 1833, 1839, 1857, 1869, 1879, 1893, 1899, 1915, 1921, 1923, 1933, 1941, 1945, 1959, 1963, 1965, 1977, 1983, 1987, 1995, 2001, 2019, 2023, 2031, 2053, 2059, 2065, 2067, 2079, 2083, 2085, 2095, 2113, 2115, 2121, 2125, 2127, 2133, 2163, 2173, 2187, 2209, 2211, 2215, 2217, 2221, 2239, 2251, 2253, 2257, 2271, 2277, 2281, 2283, 2301, 2311, 2317, 2323, 2335, 2343, 2355, 2365, 2379, 2395, 2403, 2407, 2409, 2415, 2419, 2427, 2439, 2445, 2461, 2467, 2473, 2479, 2491, 2493, 2505, 2511, 2523, 2527, 2545, 2557, 2563, 2571, 2575, 2587, 2589, 2593, 2599, 2607, 2625, 2635, 2647, 2649, 2653, 2661, 2667, 2671, 2689, 2697, 2715, 2725, 2755, 2763, 2773, 2781, 2785, 2787, 2797, 2815, 2817, 2821, 2823, 2827, 2835, 2841, 2845, 2851, 2877, 2887, 2899, 2901, 2905, 2913, 2923, 2943, 2953, 2961, 2971, 2973, 2977, 2983, 3003, 3007, 3027, 3031, 3037, 3039, 3049, 3055, 3073, 3075, 3091, 3097, 3099, 3109, 3111, 3121, 3123, 3133, 3153, 3163, 3171, 3175, 3183, 3187, 3199, 3213, 3223, 3229, 3235, 3243, 3259, 3261, 3289, 3297, 3301, 3307, 3313, 3325, 3339, 3351, 3355, 3363, 3381, 3403, 3405, 3409, 3411, 3427, 3433, 3439, 3451, 3453, 3465, 3477, 3481, 3487, 3489, 3495, 3499, 3507, 3559, 3565, 3571, 3579, 3595, 3597, 3603, 3607, 3613, 3621, 3625, 3633, 3655, 3661, 3663, 3669, 3675, 3685, 3687, 3697, 3709, 3717, 3721, 3727, 3747, 3753, 3763, 3771, 3781, 3789, 3793, 3795, 3811, 3843, 3847, 3849, 3865, 3873, 3879, 3889, 3891, 3897, 3909, 3915, 3931, 3943, 3951, 3955, 3969, 3975, 3981, 3991, 3999, 4003, 4015, 4023, 4033, 4035, 4041, 4045, 4063, 4069, 4081, 4095, 4105, 4107, 4129, 4131, 4161, 4165, 4173, 4179, 4189, 4195, 4201, 4203, 4207, 4227, 4237, 4251, 4255, 4257, 4263, 4269, 4285, 4287, 4315, 4321, 4329, 4335, 4363, 4377, 4383, 4389, 4399, 4413, 4431, 4441, 4443, 4455, 4461, 4465, 4483, 4485, 4495, 4509, 4519, 4521, 4539, 4551, 4561, 4567, 4569, 4573, 4587, 4609, 4611, 4621, 4623, 4629, 4645, 4647, 4653, 4663, 4671, 4675, 4695, 4699, 4713, 4717, 4725, 4741, 4761, 4767, 4773, 4797, 4801, 4809, 4813, 4819, 4833, 4837, 4839, 4843, 4851, 4863, 4867, 4881, 4887, 4893, 4929, 4951, 4963, 4965, 4969, 4977, 4987, 4989, 4993, 4999, 5001, 5007, 5019, 5029, 5041, 5043, 5049, 5053, 5089, 5103, 5127, 5137, 5139, 5149, 5151, 5157, 5169, 5179, 5181, 5191, 5211, 5217, 5229, 5233, 5235, 5253, 5259, 5277, 5283, 5293, 5295, 5299, 5325, 5335, 5341, 5343, 5371, 5377, 5379, 5385, 5409, 5419, 5427, 5433, 5449, 5455, 5463, 5473, 5487, 5491, 5503, 5515, 5527, 5547, 5551, 5559, 5569, 5577, 5587, 5589, 5593, 5599, 5613, 5617, 5637, 5641, 5649, 5655, 5661, 5671, 5673, 5679, 5691, 5701, 5707, 5713, 5719, 5737, 5755, 5763, 5767, 5769, 5803, 5809, 5817, 5827, 5833, 5839, 5851, 5869, 5883, 5889, 5893, 5901, 5905, 5911, 5913, 5923, 5959, 5965, 5967, 5971, 5973, 5977, 5991, 5997, 6009, 6019, 6031, 6049, 6055, 6061, 6079, 6093, 6111, 6115, 6123, 6141, 6147, 6159, 6163, 6175, 6177, 6195, 6211, 6229, 6237, 6243, 6249, 6253, 6271, 6273, 6279, 6301, 6309, 6331, 6345, 6351, 6355, 6363, 6367, 6369, 6373, 6379, 6385, 6399, 6411, 6415, 6427, 6433, 6435, 6447, 6463, 6471, 6475, 6477, 6501, 6505, 6523, 6531, 6535, 6541, 6553, 6559, 6567, 6573, 6601, 6621, 6625, 6631, 6661, 6663, 6667, 6669, 6679, 6687, 6693, 6715, 6723, 6733, 6741, 6745, 6747, 6753, 6757, 6763, 6765, 6783, 6787, 6789, 6841, 6849, 6867, 6871, 6883, 6891, 6909, 6915, 6921, 6931, 6933, 6937, 6951, 6981, 6985, 6999, 7003, 7009, 7035, 7041, 7045, 7047, 7069, 7077, 7081, 7087, 7101, 7111, 7129, 7135, 7153, 7167, 7171, 7173, 7183, 7191, 7195, 7197, 7207, 7215, 7231, 7233, 7237, 7245, 7249, 7279, 7293, 7299, 7311, 7321, 7333, 7339, 7341, 7345, 7357, 7359, 7371, 7377, 7395, 7401, 7405, 7419, 7435, 7437, 7443, 7447, 7459, 7471, 7489, 7501, 7503, 7507, 7531, 7533, 7549, 7551, 7563, 7567, 7575, 7585, 7591, 7593, 7603, 7609, 7629, 7633, 7639, 7645, 7677, 7687, 7689, 7701, 7711, 7717, 7737, 7755, 7779, 7791, 7795, 7801, 7803, 7813, 7827, 7833, 7837, 7855, 7881, 7885, 7897, 7899, 7909, 7917, 7921, 7929, 7939, 7947, 7951, 7963, 7969, 7971, 8001, 8005, 8007, 8013, 8037, 8047, 8071, 8073, 8085, 8089, 8107, 8109, 8127, 8131, 8139, 8151, 8161, 8169, 8173, 8175, 8191, 8193, 8221, 8223, 8227, 8233, 8253, 8257, 8263, 8269, 8283, 8289, 8299, 8325, 8331, 8347, 8359, 8365, 8367, 8379, 8409, 8413, 8421, 8445, 8449, 8467, 8473, 8475, 8479, 8487, 8493, 8515, 8535, 8539, 8551, 8553, 8575, 8577, 8583, 8589, 8601, 8605, 8611, 8617, 8635, 8637, 8641, 8647, 8655, 8661, 8673, 8683, 8719, 8757, 8769, 8773, 8787, 8793, 8805, 8809, 8827, 8829, 8833, 8835, 8841, 8869, 8871, 8895, 8913, 8931, 8937, 8947, 8955, 8961, 8977, 8979, 8989, 8995, 8997, 9009, 9031, 9033, 9061, 9063, 9073, 9075, 9081, 9085, 9115, 9117, 9121, 9123, 9135, 9139, 9145, 9151, 9177, 9181, 9211, 9213, 9223, 9231, 9235, 9249, 9253, 9267, 9273, 9277, 9285, 9291, 9303, 9315, 9331, 9339, 9349, 9373, 9387, 9399, 9403, 9409, 9421, 9423, 9429, 9441, 9451, 9457, 9471, 9475, 9481, 9483, 9487, 9501, 9535, 9537, 9543, 9547, 9549, 9555, 9561, 9567, 9613, 9621, 9625, 9631, 9643, 9649, 9661, 9663, 9675, 9687, 9691, 9703, 9727, 9733, 9751, 9753, 9775, 9787, 9789, 9795, 9801, 9807, 9811, 9813, 9837, 9841, 9883, 9895, 9915, 9927, 9937, 9957, 9961, 9979, 9985, 9987, 9997, 9999, 10003, 10009, 10017, 10041, 10051, 10059, 10069, 10071, 10083, 10087, 10089, 10095, 10111, 10117, 10125, 10131, 10143, 10147, 10149, 10153, 10173, 10191, 10195, 10197, 10221, 10239, 10255, 10261, 10275, 10279, 10291, 10311, 10315, 10317, 10321, 10341, 10363, 10365, 10387, 10399, 10411, 10417, 10431, 10441, 10443, 10459, 10461, 10471, 10501, 10507, 10509, 10525, 10531, 10533, 10555, 10563, 10569, 10575, 10585, 10587, 10597, 10599, 10605, 10609, 10635, 10651, 10653, 10659, 10671, 10683, 10723, 10725, 10731, 10747, 10753, 10755, 10759, 10773, 10785, 10789, 10797, 10809, 10843, 10849, 10873, 10881, 10891, 10903, 10909, 10911, 10921, 10923, 10945, 10953, 10965, 10975, 10977, 11005, 11011, 11017, 11047, 11055, 11059, 11073, 11077, 11089, 11091, 11097, 11113, 11137, 11157, 11163, 11173, 11181, 11193, 11197, 11205, 11217, 11223, 11227, 11239, 11245, 11247, 11259, 11263, 11269, 11283, 11289, 11301, 11323, 11341, 11343, 11371, 11373, 11377, 11389, 11391, 11395, 11407, 11419, 11425, 11427, 11437, 11439, 11475, 11479, 11487, 11491, 11521, 11529, 11535, 11539, 11541, 11577, 11581, 11583, 11599, 11617, 11623, 11629, 11641, 11643, 11659, 11667, 11677, 11679, 11707, 11721, 11725, 11731, 11769, 11781, 11797, 11803, 11811, 11815, 11823, 11827, 11833, 11835, 11845, 11847, 11853, 11865, 11877, 11887, 11911, 11923, 11929, 11943, 11953, 11959, 11961, 11991, 11995, 12007, 12015, 12025, 12049, 12057, 12063, 12069, 12079, 12097, 12103, 12117, 12121, 12133, 12139, 12141, 12151, 12159, 12163, 12165, 12193, 12201, 12207, 12223, 12237, 12243, 12265, 12267, 12285, 12295, 12301, 12307, 12315, 12319, 12321, 12333, 12337, 12357, 12363, 12373, 12379, 12391, 12399, 12411, 12417, 12427, 12435, 12457, 12481, 12487, 12495, 12499, 12519, 12543, 12547, 12553, 12567, 12579, 12589, 12607, 12609, 12621, 12631, 12645, 12649, 12651, 12673, 12679, 12699, 12709, 12711, 12729, 12735, 12741, 12759, 12763, 12777, 12781, 12799, 12801, 12813, 12819, 12861, 12867, 12877, 12885, 12903, 12907, 12925, 12937, 12951, 12957, 12961, 12969, 12991, 12999, 13009, 13011, 13021, 13027, 13029, 13053, 13057, 13063, 13077, 13083, 13113, 13117, 13119, 13125, 13129, 13135, 13141, 13167, 13177, 13179, 13203, 13209, 13215, 13219, 13243, 13245, 13267, 13273, 13279, 13281, 13285, 13293, 13309, 13317, 13323, 13327, 13335, 13345, 13347, 13359, 13363, 13371, 13387, 13419, 13441, 13443, 13465, 13473, 13485, 13489, 13513, 13515, 13519, 13527, 13531, 13533, 13537, 13551, 13567, 13575, 13581, 13587, 13599, 13609, 13633, 13657, 13677, 13681, 13693, 13695, 13707, 13723, 13725, 13737, 13741, 13743, 13759, 13801, 13803, 13821, 13831, 13833, 13849, 13851, 13861, 13873, 13893, 13897, 13929, 13947, 13953, 13957, 13995, 14007, 14017, 14031, 14035, 14037, 14041, 14049, 14053, 14059, 14073, 14079, 14091, 14095, 14113, 14115, 14119, 14137, 14163, 14179, 14181, 14185, 14199, 14205, 14209, 14211, 14217, 14229, 14245, 14247, 14253, 14281, 14287, 14293, 14307, 14313, 14317, 14331, 14347, 14349, 14353, 14367, 14395, 14407, 14419, 14427, 14437, 14439, 14443, 14449, 14457, 14461, 14473, 14491, 14493, 14505, 14521, 14523, 14539, 14541, 14565, 14587, 14595, 14599, 14601, 14607, 14625, 14661, 14667, 14689, 14691, 14713, 14715, 14721, 14731, 14749, 14751, 14755, 14775, 14779, 14785, 14793, 14797, 14817, 14841, 14875, 14881, 14883, 14899, 14905, 14919, 14923, 14931, 14935, 14943, 14947, 14973, 14977, 14997, 15003, 15007, 15009, 15025, 15031, 15049, 15057, 15063, 15069, 15073, 15081, 15103, 15109, 15121, 15129, 15133, 15141, 15165, 15169, 15175, 15183, 15187, 15189, 15193, 15205, 15213, 15217, 15229, 15231, 15235, 15237, 15247, 15255, 15259, 15261, 15271, 15291, 15301, 15313, 15333, 15355, 15379, 15381, 15385, 15397, 15417, 15445, 15457, 15469, 15471, 15481, 15487, 15489, 15511, 15519, 15523, 15531, 15543, 15547, 15567, 15573, 15577, 15585, 15597, 15609, 15645, 15655, 15661, 15673, 15675, 15693, 15697, 15717, 15735, 15763, 15771, 15783, 15793, 15805, 15817, 15819, 15835, 15843, 15847, 15855, 15879, 15883, 15891, 15901, 15907, 15919, 15927, 15939, 15955, 15969, 15975, 15981, 15993, 16003, 16009, 16023, 16045, 16047, 16053, 16057, 16077, 16081, 16095, 16101, 16135, 16153, 16191, 16195, 16197, 16203, 16213, 16227, 16237, 16245, 16255, 16267, 16275, 16279, 16287, 16297, 16309, 16329, 16333, 16341, 16353, 16359, 16365, 16381, 16387, 16389, 16393, 16395, 16413, 16417, 16429, 16431, 16447, 16449, 16467, 16473, 16479, 16491, 16507, 16521, 16539, 16557, 16573, 16591, 16611, 16615, 16617, 16621, 16635, 16639, 16657, 16665, 16677, 16701, 16707, 16725, 16747, 16765, 16771, 16773, 16791, 16795, 16825, 16827, 16845, 16863, 16867, 16893, 16915, 16917, 16921, 16933, 16939, 16947, 16953, 16957, 16959, 16969, 16971, 16981, 16995, 17001, 17011, 17017, 17019, 17035, 17047, 17053, 17061, 17083, 17085, 17103, 17115, 17119, 17125, 17127, 17151, 17157, 17173, 17181, 17209, 17211, 17215, 17221, 17223, 17229, 17251, 17253, 17283, 17287, 17305, 17313, 17329, 17335, 17341, 17355, 17359, 17367, 17389, 17391, 17401, 17409, 17431, 17433, 17455, 17463, 17467, 17473, 17485, 17497, 17517, 17527, 17535, 17545, 17547, 17563, 17565, 17581, 17589, 17619, 17625, 17671, 17677, 17689, 17695, 17703, 17713, 17725, 17733, 17737, 17749, 17767, 17769, 17775, 17781, 17787, 17797, 17811, 17829, 17851, 17875, 17883, 17893, 17913, 17925, 17935, 17943, 17947, 17965, 17977, 17991, 17997, 18001, 18007, 18019, 18025, 18043, 18049, 18055, 18067, 18085, 18087, 18123, 18127, 18145, 18147, 18151, 18153, 18169, 18175, 18181, 18187, 18189, 18195, 18207, 18211, 18237, 18253, 18261, 18279, 18283, 18285, 18295, 18303, 18315, 18333, 18375, 18381, 18397, 18399, 18403, 18409, 18441, 18445, 18451, 18459, 18465, 18469, 18475, 18493, 18495, 18501, 18513, 18523, 18535, 18543, 18589, 18591, 18597, 18615, 18619, 18621, 18633, 18639, 18655, 18661, 18681, 18693, 18715, 18717, 18723, 18745, 18747, 18757, 18759, 18765, 18775, 18777, 18783, 18787, 18817, 18819, 18825, 18837, 18849, 18853, 18871, 18873, 18879, 18915, 18937, 18943, 18951, 18967, 18969, 18975, 18979, 18987, 19009, 19015, 19017, 19033, 19051, 19081, 19113, 19119, 19125, 19131, 19153, 19155, 19159, 19161, 19173, 19195, 19197, 19207, 19225, 19237, 19261, 19263, 19269, 19285, 19309, 19323, 19327, 19329, 19333, 19341, 19347, 19351, 19357, 19363, 19365, 19371, 19389, 19395, 19405, 19411, 19417, 19435, 19455, 19467, 19477, 19479, 19503, 19521, 19533, 19543, 19551, 19579, 19581, 19603, 19609, 19615, 19627, 19629, 19657, 19659, 19687, 19693, 19705, 19707, 19711, 19719, 19723, 19725, 19731, 19735, 19755, 19767, 19771, 19773, 19783, 19791, 19807, 19825, 19851, 19861, 19869, 19875, 19893, 19917, 19921, 19929, 19939, 19963, 19981, 19993, 20005, 20013, 20017, 20043, 20067, 20071, 20077, 20085, 20089, 20101, 20103, 20121, 20133, 20149, 20151, 20169, 20181, 20185, 20197, 20203, 20215, 20227, 20253, 20257, 20271, 20295, 20307, 20319, 20341, 20349, 20353, 20355, 20359, 20371, 20379, 20385, 20397, 20403, 20425, 20445, 20449, 20455, 20461, 20475, 20485, 20487, 20509, 20511, 20539, 20551, 20563, 20581, 20583, 20587, 20605, 20611, 20613, 20649, 20665, 20679, 20697, 20713, 20731, 20733, 20739, 20757, 20763, 20769, 20773, 20793, 20797, 20805, 20811, 20821, 20823, 20833, 20835, 20839, 20845, 20859, 20875, 20887, 20889, 20899, 20905, 20923, 20937, 20941, 20953, 20959, 20965, 20991, 21013, 21015, 21021, 21027, 21043, 21049, 21051, 21055, 21073, 21075, 21111, 21115, 21129, 21139, 21147, 21153, 21169, 21175, 21177, 21189, 21193, 21199, 21205, 21211, 21223, 21231, 21253, 21255, 21307, 21309, 21315, 21327, 21331, 21337, 21345, 21373, 21381, 21405, 21409, 21411, 21421, 21433, 21445, 21451, 21453, 21469, 21471, 21475, 21499, 21505, 21529, 21531, 21537, 21549, 21567, 21571, 21591, 21597, 21609, 21613, 21615, 21621, 21655, 21663, 21687, 21693, 21703, 21709, 21717, 21721, 21735, 21739, 21751, 21757, 21759, 21771, 21787, 21819, 21841, 21847, 21867, 21885, 21891, 21897, 21913, 21915, 21925, 21927, 21931, 21933, 21957, 21967, 21987, 21993, 22009, 22017, 22035, 22039, 22075, 22087, 22093, 22095, 22099, 22113, 22119, 22125, 22147, 22155, 22165, 22167, 22177, 22185, 22197, 22225, 22227, 22231, 22269, 22281, 22305, 22327, 22333, 22339, 22369, 22371, 22377, 22381, 22399, 22401, 22411, 22417, 22431, 22437, 22461, 22471, 22473, 22479, 22503, 22507, 22521, 22525, 22527, 22533, 22555, 22569, 22585, 22587, 22591, 22597, 22603, 22617, 22627, 22629, 22651, 22683, 22687, 22689, 22701, 22711, 22743, 22779, 22789, 22791, 22795, 22807, 22827, 22839, 22843, 22851, 22855, 22869, 22879, 22881, 22885, 22893, 22911, 22921, 22941, 22947, 22953, 22957, 22965, 22969, 22975, 22981, 22987, 22999, 23007, 23031, 23037, 23041, 23061, 23067, 23083, 23089, 23095, 23101, 23109, 23137, 23145, 23163, 23169, 23173, 23191, 23193, 23199, 23205, 23269, 23271, 23293, 23295, 23311, 23323, 23341, 23343, 23353, 23355, 23361, 23365, 23373, 23377, 23397, 23419, 23421, 23427, 23445, 23449, 23451, 23457, 23469, 23479, 23499, 23515, 23523, 23529, 23533, 23551, 23563, 23565, 23569, 23571, 23577, 23607, 23613, 23649, 23671, 23677, 23689, 23701, 23709, 23721, 23767, 23775, 23781, 23799, 23805, 23815, 23829, 23835, 23851, 23857, 23881, 23889, 23893, 23913, 23919, 23925, 23929, 23943, 23953, 23955, 23961, 23965, 23971, 23973, 23991, 24013, 24015, 24025, 24033, 24037, 24069, 24073, 24117, 24121, 24129, 24133, 24145, 24151, 24181, 24183, 24213, 24217, 24237, 24247, 24255, 24261, 24277, 24285, 24289, 24301, 24309, 24321, 24327, 24331, 24333, 24343, 24363, 24381, 24387, 24397, 24403, 24405, 24423, 24429, 24447, 24451, 24481, 24499, 24523, 24531, 24571, 24573, 24585, 24591, 24603, 24619, 24633, 24637, 24639, 24643, 24645, 24649, 24663, 24669, 24709, 24711, 24727, 24729, 24733, 24739, 24741, 24759, 24763, 24771, 24783, 24789, 24805, 24811, 24829, 24831, 24843, 24855, 24865, 24873, 24877, 24895, 24907, 24909, 24933, 24951, 24957, 24963, 24985, 24991, 25015, 25017, 25021, 25033, 25057, 25063, 25095, 25099, 25107, 25117, 25119, 25129, 25147, 25153, 25159, 25167, 25171, 25185, 25189, 25201, 25213, 25215, 25225, 25237, 25255, 25263, 25285, 25287, 25293, 25309, 25317, 25335, 25341, 25347, 25377, 25389, 25413, 25425, 25431, 25441, 25455, 25461, 25477, 25483, 25489, 25497, 25503, 25525, 25549, 25561, 25567, 25569, 25581, 25591, 25593, 25611, 25621, 25623, 25645, 25647, 25657, 25671, 25677, 25687, 25737, 25753, 25759, 25771, 25773, 25803, 25815, 25819, 25821, 25833, 25837, 25845, 25855, 25861, 25875, 25893, 25909, 25917, 25923, 25929, 25939, 25959, 25963, 25971, 25977, 25987, 26005, 26007, 26011, 26025, 26035, 26041, 26071, 26085, 26103, 26107, 26115, 26119, 26149, 26155, 26167, 26169, 26179, 26209, 26215, 26217, 26221, 26229, 26251, 26263, 26281, 26293, 26295, 26301, 26313, 26319, 26343, 26347, 26359, 26365, 26385, 26397, 26409, 26413, 26431, 26445, 26467, 26505, 26523, 26529, 26533, 26547, 26553, 26565, 26595, 26599, 26617, 26629, 26641, 26649, 26655, 26659, 26665, 26683, 26695, 26697, 26703, 26719, 26721, 26727, 26733, 26749, 26755, 26757, 26781, 26797, 26805, 26841, 26845, 26847, 26881, 26883, 26893, 26905, 26907, 26913, 26923, 26925, 26935, 26943, 26997, 27001, 27007, 27009, 27013, 27027, 27031, 27033, 27037, 27039, 27061, 27063, 27075, 27079, 27091, 27093, 27097, 27105, 27141, 27157, 27189, 27195, 27199, 27201, 27205, 27207, 27217, 27237, 27265, 27271, 27283, 27301, 27309, 27315, 27321, 27325, 27331, 27333, 27349, 27357, 27363, 27387, 27393, 27409, 27415, 27417, 27427, 27435, 27453, 27457, 27469, 27475, 27477, 27483, 27489, 27493, 27501, 27511, 27531, 27541, 27561, 27585, 27595, 27597, 27603, 27639, 27663, 27667, 27691, 27693, 27705, 27711, 27741, 27751, 27757, 27765, 27783, 27793, 27805, 27807, 27813, 27829, 27831, 27847, 27855, 27859, 27871, 27879, 27913, 27915, 27951, 27961, 27963, 27975, 28021, 28023, 28027, 28039, 28069, 28071, 28083, 28087, 28089, 28101, 28105, 28119, 28123, 28129, 28131, 28141, 28161, 28167, 28191, 28195, 28203, 28233, 28239, 28245, 28293, 28311, 28321, 28329, 28339, 28351, 28359, 28365, 28375, 28393, 28405, 28417, 28429, 28435, 28437, 28459, 28467, 28483, 28509, 28513, 28525, 28563, 28569, 28581, 28593, 28605, 28633, 28639, 28677, 28689, 28701, 28707, 28735, 28759, 28765, 28771, 28791, 28797, 28801, 28803, 28815, 28825, 28827, 28837, 28843, 28855, 28857, 28867, 28869, 28887, 28891, 28905, 28921, 28923, 28933, 28951, 28963, 28969, 28987, 28989, 28993, 28995, 29005, 29025, 29031, 29035, 29049, 29055, 29065, 29089, 29091, 29095, 29113, 29121, 29127, 29137, 29143, 29149, 29157, 29175, 29185, 29193, 29203, 29205, 29239, 29253, 29281, 29283, 29287, 29295, 29311, 29317, 29319, 29329, 29341, 29349, 29371, 29391, 29413, 29437, 29451, 29457, 29467, 29473, 29485, 29487, 29493, 29497, 29515, 29517, 29521, 29533, 29535, 29563, 29577, 29589, 29595, 29599, 29611, 29613, 29623, 29625, 29653, 29659, 29661, 29665, 29677, 29689, 29697, 29709, 29715, 29721, 29751, 29757, 29779, 29781, 29787, 29791, 29805, 29815, 29829, 29845, 29847, 29851, 29865, 29877, 29893, 29905, 29913, 29925, 29949, 29959, 29971, 29973, 29989, 29995, 30013, 30021, 30061, 30067, 30073, 30075, 30087, 30103, 30115, 30121, 30159, 30163, 30181, 30207, 30225, 30229, 30231, 30241, 30243, 30253, 30261, 30265, 30273, 30289, 30291, 30303, 30313, 30327, 30337, 30367, 30369, 30373, 30387, 30397, 30409, 30411, 30429, 30439, 30465, 30471, 30475, 30477, 30495, 30499, 30505, 30523, 30529, 30537, 30541, 30543, 30547, 30559, 30565, 30567, 30589, 30601, 30643, 30651, 30681, 30687, 30727, 30747, 30753, 30765, 30775, 30777, 30789, 30793, 30807, 30817, 30837, 30849, 30861, 30871, 30873, 30877, 30885, 30901, 30915, 30919, 30943, 30945, 30949, 30969, 30997, 30999, 31003, 31021, 31029, 31033, 31039, 31051, 31069, 31071, 31081, 31093, 31095, 31107, 31135, 31137, 31143, 31147, 31189, 31191, 31207, 31221, 31231, 31237, 31239, 31249, 31251, 31255, 31261, 31263, 31293, 31303, 31311, 31315, 31335, 31341, 31363, 31381, 31383, 31387, 31389, 31395, 31405, 31411, 31425, 31429];\n\n  let partition-numbers = [1, 2, 3, 5, 7, 11, 15, 22, 30, 42, 56, 77, 101, 135, 176, 231, 297, 385, 490, 627, 792, 1002, 1255, 1575, 1958, 2436, 3010, 3718, 4565, 5604, 6842, 8349, 10143, 12310, 14883, 17977, 21637, 26015, 31185, 37338, 44583, 53174, 63261, 75175, 89134, 105558, 124754, 147273, 173525, 204226, 239943, 281589, 329931, 386155, 451276, 526823, 614154, 715220, 831820, 966467, 1121505, 1300156, 1505499, 1741630, 2012558, 2323520, 2679689, 3087735, 3554345, 4087968, 4697205, 5392783, 6185689, 7089500, 8118264, 9289091, 10619863, 12132164, 13848650, 15796476, 18004327, 20506255, 23338469, 26543660, 30167357, 34262962, 38887673, 44108109, 49995925, 56634173, 64112359, 72533807, 82010177, 92669720, 104651419, 118114304, 133230930, 150198136, 169229875, 190569292, 214481126, 241265379, 271248950, 304801365, 342325709, 384276336, 431149389, 483502844, 541946240, 607163746, 679903203, 761002156, 851376628, 952050665, 1064144451, 1188908248, 1327710076, 1482074143, 1653668665, 1844349560, 2056148051, 2291320912, 2552338241, 2841940500, 3163127352, 3519222692, 3913864295, 4351078600, 4835271870, 5371315400, 5964539504, 6620830889, 7346629512, 8149040695, 9035836076, 10015581680, 11097645016, 12292341831, 13610949895, 15065878135, 16670689208, 18440293320, 20390982757, 22540654445, 24908858009, 27517052599, 30388671978, 33549419497, 37027355200, 40853235313, 45060624582, 49686288421, 54770336324, 60356673280, 66493182097, 73232243759, 80630964769, 88751778802, 97662728555, 107438159466, 118159068427, 129913904637, 142798995930, 156919475295, 172389800255, 189334822579, 207890420102, 228204732751, 250438925115, 274768617130, 301384802048, 330495499613, 362326859895, 397125074750, 435157697830, 476715857290, 522115831195, 571701605655, 625846753120, 684957390936, 749474411781, 819876908323, 896684817527, 980462880430, 1071823774337, 1171432692373, 1280011042268, 1398341745571, 1527273599625, 1667727404093, 1820701100652, 1987276856363, 2168627105469, 2366022741845, 2580840212973, 2814570987591, 3068829878530, 3345365983698, 3646072432125, 3972999029388, 4328363658647, 4714566886083, 5134205287973, 5590088317495, 6085253859260, 6622987708040, 7206841706490, 7840656226137, 8528581302375, 9275102575355, 10085065885767, 10963707205259, 11916681236278, 12950095925895, 14070545699287, 15285151248481, 16601598107914, 18028182516671, 19573856161145, 21248279009367, 23061871173849, 25025873760111, 27152408925615, 29454549941750, 31946390696157, 34643126322519, 37561133582570, 40718063627362, 44132934884255, 47826239745920, 51820051838712, 56138148670947, 60806135438329, 65851585970275, 71304185514919, 77195892663512, 83561103925871, 90436839668817, 97862933703585, 105882246722733, 114540884553038, 123888443077259, 133978259344888, 144867692496445, 156618412527946, 169296722391554, 182973889854026, 197726516681672, 213636919820625, 230793554364681, 249291451168559, 269232701252579, 290726957916112, 313891991306665, 338854264248680, 365749566870782, 394723676655357, 425933084409356, 459545750448675, 495741934760846, 534715062908609, 576672674947168, 621837416509615, 670448123060170, 722760953690372, 779050629562167, 839611730366814, 904760108316360, 974834369944625, 1050197489931117, 1131238503938606, 1218374349844333, 1312051800816215, 1412749565173450, 1520980492851175, 1637293969337171, 1762278433057269, 1896564103591584, 2040825852575075, 2195786311682516, 2362219145337711, 2540952590045698, 2732873183547535, 2938929793929555, 3160137867148997, 3397584011986773, 3652430836071053, 3925922161489422, 4219388528587095, 4534253126900886, 4872038056472084, 5234371069753672, 5622992691950605, 6039763882095515, 6486674127079088, 6965850144195831, 7479565078510584, 8030248384943040, 8620496275465025];\n\n  {\n    // =========================================================================\n    // FINITE SEQUENCES — generate inline\n    // =========================================================================\n\n    fibonacci-take-while: (fn) -> do\n      loop (result = [], a = 0, b = 1, i = 0) ->\n        if fn(a, i) then recur(push(result, a), b, a + b, i + 1)\n        else result end\n    end,\n\n    tribonacci-take-while: (fn) -> do\n      loop (result = [], a = 0, b = 1, c = 1, i = 0) ->\n        if fn(a, i) then recur(push(result, a), b, c, a + b + c, i + 1)\n        else result end\n    end,\n\n    lucas-take-while: (fn) -> do\n      loop (result = [], a = 2, b = 1, i = 0) ->\n        if fn(a, i) then recur(push(result, a), b, a + b, i + 1)\n        else result end\n    end,\n\n    pell-take-while: (fn) -> do\n      loop (result = [], a = 1, b = 2, i = 0) ->\n        if fn(a, i) then recur(push(result, a), b, 2 * b + a, i + 1)\n        else result end\n    end,\n\n    padovan-take-while: (fn) -> do\n      loop (result = [], a = 1, b = 1, c = 1, i = 0) ->\n        if fn(a, i) then recur(push(result, a), b, c, a + b, i + 1)\n        else result end\n    end,\n\n    factorial-take-while: (fn) -> do\n      loop (result = [], fact = 1, i = 0) ->\n        if fn(fact, i) then recur(push(result, fact), fact * (i + 1), i + 1)\n        else result end\n    end,\n\n\n\n    // =========================================================================\n    // PREDICATE SEQUENCES — use inline predicates\n    // =========================================================================\n\n    prime-take-while: (fn) -> do\n      loop (result = [], n = 2) ->\n        if is-prime(n) then\n          if fn(n, count(result)) then recur(push(result, n), n + 1)\n          else result end\n        else recur(result, n + 1) end\n    end,\n\n    composite-take-while: (fn) -> do\n      loop (result = [], n = 4) ->\n        if is-composite(n) then\n          if fn(n, count(result)) then recur(push(result, n), n + 1)\n          else result end\n        else recur(result, n + 1) end\n    end,\n\n    abundant-take-while: (fn) -> do\n      loop (result = [], n = 12) ->\n        if is-abundant(n) then\n          if fn(n, count(result)) then recur(push(result, n), n + 1)\n          else result end\n        else recur(result, n + 1) end\n    end,\n\n    deficient-take-while: (fn) -> do\n      loop (result = [], n = 1) ->\n        if is-deficient(n) then\n          if fn(n, count(result)) then recur(push(result, n), n + 1)\n          else result end\n        else recur(result, n + 1) end\n    end,\n\n    perfect-square-take-while: (fn) -> do\n      loop (result = [], i = 1) -> do\n        let val = i * i;\n        if fn(val, i - 1) then recur(push(result, val), i + 1)\n        else result end\n      end\n    end,\n\n    perfect-cube-take-while: (fn) -> do\n      loop (result = [], i = 1) -> do\n        let val = i * i * i;\n        if fn(val, i - 1) then recur(push(result, val), i + 1)\n        else result end\n      end\n    end,\n\n    happy-take-while: (fn) -> do\n      loop (result = [], n = 1) ->\n        if is-happy(n) then\n          if fn(n, count(result)) then recur(push(result, n), n + 1)\n          else result end\n        else recur(result, n + 1) end\n    end,\n\n    // =========================================================================\n    // PARAMETERIZED SEQUENCES\n    // =========================================================================\n\n    arithmetic-take-while: (start, step, fn) -> do\n      loop (result = [], i = 0) -> do\n        let val = start + i * step;\n        if fn(val, i) then recur(push(result, val), i + 1)\n        else result end\n      end\n    end,\n\n    geometric-take-while: (start, ratio, fn) -> do\n      loop (result = [], i = 0) -> do\n        let val = start * (ratio ^ i);\n        if fn(val, i) then recur(push(result, val), i + 1)\n        else result end\n      end\n    end,\n\n    polygonal-take-while: (sides, fn) -> do\n      loop (result = [], n = 1) -> do\n        let val = (sides - 2) * n * (n - 1) / 2 + n;\n        if fn(val, n - 1) then recur(push(result, val), n + 1)\n        else result end\n      end\n    end,\n\n    look-and-say-take-while: (fn) -> do\n      let next-term = (s) -> do\n        loop (result = \"\", i = 0) ->\n          if i >= count(s) then result\n          else do\n            let ch = nth(s, i);\n            let cnt = loop (c = 1, j = i + 1) ->\n              if j < count(s) && nth(s, j) == ch then recur(c + 1, j + 1)\n              else c end;\n            recur(++(result, str(cnt), ch), i + cnt)\n          end\n          end\n      end;\n      loop (result = [], term = \"1\", idx = 0) ->\n        if fn(term, idx) then recur(push(result, term), next-term(term), idx + 1)\n        else result end\n    end,\n\n    // =========================================================================\n    // FINITE SEQUENCES — iterate precomputed arrays\n    // =========================================================================\n\n    bell-take-while: (fn) -> do\n      loop (result = [], i = 0) ->\n        if i >= count(bell-numbers) then result\n        else if fn(nth(bell-numbers, i), i) then recur(push(result, nth(bell-numbers, i)), i + 1)\n        else result end\n      end\n    end,\n\n    catalan-take-while: (fn) -> do\n      loop (result = [], i = 0) ->\n        if i >= count(catalan-numbers) then result\n        else if fn(nth(catalan-numbers, i), i) then recur(push(result, nth(catalan-numbers, i)), i + 1)\n        else result end\n      end\n    end,\n\n    mersenne-take-while: (fn) -> do\n      loop (result = [], i = 0) ->\n        if i >= count(mersenne-numbers) then result\n        else if fn(nth(mersenne-numbers, i), i) then recur(push(result, nth(mersenne-numbers, i)), i + 1)\n        else result end\n      end\n    end,\n\n    partition-take-while: (fn) -> do\n      loop (result = [], i = 0) ->\n        if i >= count(partition-numbers) then result\n        else if fn(nth(partition-numbers, i), i) then recur(push(result, nth(partition-numbers, i)), i + 1)\n        else result end\n      end\n    end,\n\n    perfect-take-while: (fn) -> do\n      loop (result = [], i = 0) ->\n        if i >= count(perfect-numbers) then result\n        else if fn(nth(perfect-numbers, i), i) then recur(push(result, nth(perfect-numbers, i)), i + 1)\n        else result end\n      end\n    end,\n\n    sylvester-take-while: (fn) -> do\n      loop (result = [], i = 0) ->\n        if i >= count(sylvester-numbers) then result\n        else if fn(nth(sylvester-numbers, i), i) then recur(push(result, nth(sylvester-numbers, i)), i + 1)\n        else result end\n      end\n    end,\n\n    // =========================================================================\n    // DYNAMIC SEQUENCES — generate on-the-fly\n    // =========================================================================\n\n    bernoulli-take-while: (fn) -> do\n      // b-arr accumulates all Bernoulli numbers computed so far; B(0)=1 is always included\n      loop (b-arr = [1], n = 1) -> do\n        let bn = if n > 1 && n % 2 == 1 then 0\n          else do\n            let s = loop (k = 0, acc = 0) ->\n              if k >= n then acc\n              else recur(k + 1, acc + binom(n + 1, k) * nth(b-arr, k)) end;\n            (0 - s) / (n + 1)\n          end end;\n        if fn(bn, n) then recur(push(b-arr, bn), n + 1)\n        else b-arr end\n      end\n    end,\n\n    golomb-take-while: (fn) -> do\n      // g-arr is 0-indexed: g-arr[i] = g(i+1). g(1)=1, g(n)=1+g(n-g(g(n-1)))\n      if not(fn(1, 0)) then []\n      else do\n        loop (g-arr = [1], n = 2) -> do\n          let gn1 = nth(g-arr, n - 2);\n          let ggn1 = nth(g-arr, gn1 - 1);\n          let gval = 1 + nth(g-arr, n - 1 - ggn1);\n          if fn(gval, n - 1) then recur(push(g-arr, gval), n + 1)\n          else g-arr end\n        end\n      end\n      end\n    end,\n\n    lucky-take-while: (fn) -> do\n      loop (result = [], i = 0) ->\n        if i >= count(lucky-numbers) then result\n        else if fn(nth(lucky-numbers, i), i) then recur(push(result, nth(lucky-numbers, i)), i + 1)\n        else result end\n      end\n    end,\n\n    perfect-power-take-while: (fn) -> do\n      loop (result = [], n = 1) ->\n        if is-perfect-power(n) then\n          if fn(n, count(result)) then recur(push(result, n), n + 1)\n          else result end\n        else recur(result, n + 1) end\n    end,\n\n    recaman-take-while: (fn) -> do\n      let in-arr = (arr, val) ->\n        loop (i = 0) ->\n          if i >= count(arr) then false\n          else if nth(arr, i) == val then true\n          else recur(i + 1) end\n        end;\n      if not(fn(0, 0)) then []\n      else do\n        loop (result = [0], n = 1) -> do\n          let prev = nth(result, n - 1);\n          let backward = prev - n;\n          let nxt = if backward > 0 && not(in-arr(result, backward)) then backward\n            else prev + n end;\n          if fn(nxt, n) then recur(push(result, nxt), n + 1)\n          else result end\n        end\n      end\n      end\n    end,\n\n    thue-morse-take-while: (fn) -> do\n      loop (result = [], i = 0) -> do\n        let val = count-bits(i) % 2;\n        if fn(val, i) then recur(push(result, val), i + 1)\n        else result end\n      end\n    end\n  }\nend\n";
+//#endregion
 //#region src/builtin/modules/number-theory/binomialCefficient.ts
 function binomialCoefficient(n, k) {
 	if (k === 0 || k === n) return 1;
@@ -17921,19 +17674,7 @@ const abundantSequence = {
 		}
 		return abundants;
 	},
-	"abundant?": (n) => isAbundant(n),
-	"abundant-take-while": (takeWhile) => {
-		const abundants = [];
-		function loop(i) {
-			if (!isAbundant(i)) return loop(i + 1);
-			return chain(takeWhile(i, abundants.length), (keep) => {
-				if (!keep) return abundants;
-				abundants.push(i);
-				return loop(i + 1);
-			});
-		}
-		return loop(2);
-	}
+	"abundant?": (n) => isAbundant(n)
 };
 //#endregion
 //#region src/builtin/modules/number-theory/sequences/arithmetic.ts
@@ -17966,23 +17707,8 @@ const arithmeticNormalExpressions = {
 		arity: toFixedArity(3)
 	},
 	"arithmetic-take-while": {
-		evaluate: ([start, step, fn], sourceCodeInfo, contextStack, { executeFunction }) => {
-			assertNumber(start, sourceCodeInfo, { finite: true });
-			assertNumber(step, sourceCodeInfo, { finite: true });
-			assertFunctionLike(fn, sourceCodeInfo);
-			const s = start;
-			const d = step;
-			const f = fn;
-			const arithmetic = [];
-			function loop(i) {
-				const value = s + i * d;
-				return chain(executeFunction(f, [value, i], contextStack, sourceCodeInfo), (keep) => {
-					if (!keep) return arithmetic;
-					arithmetic.push(value);
-					return loop(i + 1);
-				});
-			}
-			return loop(0);
+		evaluate: () => {
+			throw new Error("unreachable: overridden by dvalaImpl");
 		},
 		arity: toFixedArity(3)
 	},
@@ -18045,25 +17771,6 @@ function getBernoulliSeq(length) {
 	}
 	return bernoulli;
 }
-/**
-* Generates Bernoulli numbers as long as the predicate function returns true
-* @param predicate - Function that takes a Bernoulli number and its index and returns true if generation should continue
-* @returns Array of Bernoulli numbers generated until predicate returns false
-*/
-function generateBernoulli(predicate) {
-	const bernoulli = [1];
-	function loop(n) {
-		let sum = 0;
-		for (let k = 0; k < n; k++) sum += binomialCoefficient(n + 1, k) * bernoulli[k];
-		const newValue = n > 1 && n % 2 === 1 ? 0 : -sum / (n + 1);
-		return chain(predicate(newValue, n), (keep) => {
-			if (!keep) return bernoulli;
-			bernoulli.push(newValue);
-			return loop(n + 1);
-		});
-	}
-	return loop(1);
-}
 const bernoulliNormalExpressions = {
 	"bernoulli-seq": {
 		evaluate: ([length], sourceCodeInfo) => {
@@ -18086,10 +17793,8 @@ const bernoulliNormalExpressions = {
 		arity: toFixedArity(1)
 	},
 	"bernoulli-take-while": {
-		evaluate: ([fn], sourceCodeInfo, contextStack, { executeFunction }) => {
-			assertFunctionLike(fn, sourceCodeInfo);
-			const f = fn;
-			return generateBernoulli((value, index) => chain(executeFunction(f, [value, index], contextStack), (val) => !!val));
+		evaluate: () => {
+			throw new Error("unreachable: overridden by dvalaImpl");
 		},
 		arity: toFixedArity(1)
 	}
@@ -18141,7 +17846,8 @@ const collatzSequence = {
 		}
 		return collatz;
 	},
-	"noNth": true
+	"noNth": true,
+	"noTakeWhile": true
 };
 //#endregion
 //#region src/builtin/modules/number-theory/sequences/prime.ts
@@ -18162,19 +17868,7 @@ const primeSequence = {
 		}
 		return primes;
 	},
-	"prime?": (n) => isPrime(n),
-	"prime-take-while": (takeWhile) => {
-		const primes = [];
-		function loop(i) {
-			if (!isPrime(i)) return loop(i + 1);
-			return chain(takeWhile(i, primes.length), (keep) => {
-				if (!keep) return primes;
-				primes.push(i);
-				return loop(i + 1);
-			});
-		}
-		return loop(2);
-	}
+	"prime?": (n) => isPrime(n)
 };
 //#endregion
 //#region src/builtin/modules/number-theory/sequences/composite.ts
@@ -18192,19 +17886,7 @@ const compositeSequence = {
 		}
 		return composites;
 	},
-	"composite?": (n) => isComposite(n),
-	"composite-take-while": (takeWhile) => {
-		const composites = [];
-		function loop(i) {
-			if (!isComposite(i)) return loop(i + 1);
-			return chain(takeWhile(i, composites.length), (keep) => {
-				if (!keep) return composites;
-				composites.push(i);
-				return loop(i + 1);
-			});
-		}
-		return loop(4);
-	}
+	"composite?": (n) => isComposite(n)
 };
 //#endregion
 //#region src/builtin/modules/number-theory/sequences/deficient.ts
@@ -18221,19 +17903,7 @@ const deficientSequence = {
 		}
 		return deficients;
 	},
-	"deficient?": (n) => isDeficient(n),
-	"deficient-take-while": (takeWhile) => {
-		const deficients = [];
-		function loop(i) {
-			if (!isDeficient(i)) return loop(i + 1);
-			return chain(takeWhile(i, deficients.length), (keep) => {
-				if (!keep) return deficients;
-				deficients.push(i);
-				return loop(i + 1);
-			});
-		}
-		return loop(1);
-	}
+	"deficient?": (n) => isDeficient(n)
 };
 //#endregion
 //#region src/builtin/modules/number-theory/sequences/fibonacci.ts
@@ -18360,23 +18030,8 @@ const geometricNormalExpressions = {
 		arity: toFixedArity(3)
 	},
 	"geometric-take-while": {
-		evaluate: ([start, ratio, fn], sourceCodeInfo, contextStack, { executeFunction }) => {
-			assertNumber(start, sourceCodeInfo, { finite: true });
-			assertNumber(ratio, sourceCodeInfo, { finite: true });
-			assertFunctionLike(fn, sourceCodeInfo);
-			const s = start;
-			const r = ratio;
-			const f = fn;
-			const geometric = [];
-			function loop(i) {
-				const value = s * r ** i;
-				return chain(executeFunction(f, [value, i], contextStack, sourceCodeInfo), (keep) => {
-					if (!keep) return geometric;
-					geometric.push(value);
-					return loop(i + 1);
-				});
-			}
-			return loop(0);
+		evaluate: () => {
+			throw new Error("unreachable: overridden by dvalaImpl");
 		},
 		arity: toFixedArity(3)
 	},
@@ -18409,25 +18064,9 @@ function getGolombSeq(n) {
 	for (let i = 2; i <= n; i += 1) golomb.push(1 + golomb[i - golomb[golomb[i - 1]]]);
 	return golomb.slice(1);
 }
-function generateGolombSeq(pred) {
-	const golomb = [0, 1];
-	return chain(pred(1, 0), (keepFirst) => {
-		if (!keepFirst) return [];
-		function loop(i) {
-			const golombNumber = 1 + golomb[i - golomb[golomb[i - 1]]];
-			return chain(pred(golombNumber, i - 1), (keep) => {
-				if (!keep) return golomb.slice(1);
-				golomb.push(golombNumber);
-				return loop(i + 1);
-			});
-		}
-		return loop(2);
-	});
-}
 const golombSequence = {
 	"golomb-seq": (length) => getGolombSeq(length),
-	"golomb?": () => true,
-	"golomb-take-while": (takeWhile) => generateGolombSeq(takeWhile)
+	"golomb?": () => true
 };
 //#endregion
 //#region src/builtin/modules/number-theory/sequences/happy.ts
@@ -18463,19 +18102,7 @@ const happySequence = {
 		}
 		return happyNumbers;
 	},
-	"happy?": (n) => isHappyNumber(n),
-	"happy-take-while": (takeWhile) => {
-		const happyNumbers = [];
-		function loop(i) {
-			if (!isHappyNumber(i)) return loop(i + 1);
-			return chain(takeWhile(i, happyNumbers.length), (keep) => {
-				if (!keep) return happyNumbers;
-				happyNumbers.push(i);
-				return loop(i + 1);
-			});
-		}
-		return loop(1);
-	}
+	"happy?": (n) => isHappyNumber(n)
 };
 //#endregion
 //#region src/builtin/modules/number-theory/sequences/juggler.ts
@@ -18489,7 +18116,8 @@ const jugglerSequence = {
 		}
 		return juggler;
 	},
-	"noNth": true
+	"noNth": true,
+	"noTakeWhile": true
 };
 //#endregion
 //#region src/builtin/modules/number-theory/sequences/lookAndSay.ts
@@ -18535,22 +18163,6 @@ const lookAndSaySequence = {
 		for (let i = 1; i < length; i += 1) lookAndSay[i] = lookAndSay[i - 1].replace(/(\d)\1*/g, (match) => `${match.length}${match[0]}`);
 		return lookAndSay;
 	},
-	"look-and-say-take-while": (takeWhile) => {
-		const lookAndSay = [];
-		return chain(takeWhile("1", 0), (keepFirst) => {
-			if (!keepFirst) return lookAndSay;
-			lookAndSay.push("1");
-			function loop(i) {
-				const next = lookAndSay[i - 1].replace(/(\d)\1*/g, (match) => `${match.length}${match[0]}`);
-				return chain(takeWhile(next, i), (keep) => {
-					if (!keep) return lookAndSay;
-					lookAndSay.push(next);
-					return loop(i + 1);
-				});
-			}
-			return loop(1);
-		});
-	},
 	"look-and-say?": (n) => isLookAndSay(n)
 };
 //#endregion
@@ -18635,6 +18247,16 @@ const lucasNumbers = [
 	7639424778862807
 ];
 //#endregion
+//#region src/utils/maybePromise.ts
+/**
+* Chain a value that might be a Promise. If the value is sync, calls fn synchronously.
+* If it's a Promise, chains with .then().
+*/
+function chain(value, fn) {
+	if (value instanceof Promise) return value.then(fn);
+	return fn(value);
+}
+//#endregion
 //#region src/builtin/modules/number-theory/sequences/lucky.ts
 /**
 * Generates lucky numbers while the predicate function returns true.
@@ -18711,8 +18333,7 @@ function getLuckyNumbers(count) {
 }
 const luckySequence = {
 	"lucky-seq": (length) => getLuckyNumbers(length),
-	"lucky?": (n) => generateLuckyNumbers((l) => l <= n).includes(n),
-	"lucky-take-while": (takeWhile) => generateLuckyNumbers(takeWhile)
+	"lucky?": (n) => generateLuckyNumbers((l) => l <= n).includes(n)
 };
 //#endregion
 //#region src/builtin/modules/number-theory/sequences/mersenne.ts
@@ -18815,37 +18436,7 @@ const padovanSequence = {
 		for (let i = 3; i < length; i += 1) padovan[i] = padovan[i - 2] + padovan[i - 3];
 		return padovan.slice(0, length);
 	},
-	"padovan?": (n) => isPadovan(n),
-	"padovan-take-while": (takeWhile) => {
-		const padovan = [];
-		return chain(takeWhile(1, 0), (keep0) => {
-			if (!keep0) return padovan;
-			padovan.push(1);
-			return chain(takeWhile(1, 1), (keep1) => {
-				if (!keep1) return padovan;
-				padovan.push(1);
-				return chain(takeWhile(1, 2), (keep2) => {
-					if (!keep2) return padovan;
-					padovan.push(1);
-					let a = 1;
-					let b = 1;
-					let c = 1;
-					function loop(i) {
-						const temp = a + b;
-						a = b;
-						b = c;
-						c = temp;
-						return chain(takeWhile(c, i), (keep) => {
-							if (!keep) return padovan;
-							padovan.push(c);
-							return loop(i + 1);
-						});
-					}
-					return loop(4);
-				});
-			});
-		});
-	}
+	"padovan?": (n) => isPadovan(n)
 };
 //#endregion
 //#region src/builtin/modules/number-theory/sequences/pell.ts
@@ -18912,19 +18503,7 @@ const perfectCubeSequence = {
 		for (let i = 1; i <= length; i++) perfectcubes.push(i ** 3);
 		return perfectcubes;
 	},
-	"perfect-cube?": (n) => n > 0 && Number.isInteger(Math.cbrt(n)),
-	"perfect-cube-take-while": (takeWhile) => {
-		const perfectcubes = [];
-		function loop(i) {
-			const value = i ** 3;
-			return chain(takeWhile(value, i), (keep) => {
-				if (!keep) return perfectcubes;
-				perfectcubes.push(value);
-				return loop(i + 1);
-			});
-		}
-		return loop(1);
-	}
+	"perfect-cube?": (n) => n > 0 && Number.isInteger(Math.cbrt(n))
 };
 //#endregion
 //#region src/builtin/modules/number-theory/sequences/perfectPower.ts
@@ -18954,19 +18533,7 @@ const perfectPowerSequence = {
 		for (let i = 1; perfectPowers.length < length; i++) if (perfectPower(i)) perfectPowers.push(i);
 		return perfectPowers;
 	},
-	"perfect-power?": (n) => perfectPower(n) !== null,
-	"perfect-power-take-while": (takeWhile) => {
-		const perfectPowers = [];
-		function loop(i) {
-			if (!perfectPower(i)) return loop(i + 1);
-			return chain(takeWhile(i, perfectPowers.length), (keep) => {
-				if (!keep) return perfectPowers;
-				perfectPowers.push(i);
-				return loop(i + 1);
-			});
-		}
-		return loop(1);
-	}
+	"perfect-power?": (n) => perfectPower(n) !== null
 };
 //#endregion
 //#region src/builtin/modules/number-theory/sequences/perfectSquare.ts
@@ -18976,19 +18543,7 @@ const perfectSquareSequence = {
 		for (let i = 1; i <= length; i++) perfectSquares.push(i ** 2);
 		return perfectSquares;
 	},
-	"perfect-square?": (n) => n > 0 && Number.isInteger(Math.sqrt(n)),
-	"perfect-square-take-while": (takeWhile) => {
-		const perfectSquares = [];
-		function loop(i) {
-			const value = i ** 2;
-			return chain(takeWhile(value, i), (keep) => {
-				if (!keep) return perfectSquares;
-				perfectSquares.push(value);
-				return loop(i + 1);
-			});
-		}
-		return loop(1);
-	}
+	"perfect-square?": (n) => n > 0 && Number.isInteger(Math.sqrt(n))
 };
 //#endregion
 //#region src/builtin/modules/number-theory/sequences/poligonal.ts
@@ -19010,24 +18565,8 @@ const poligonalNormalExpressions = {
 		arity: toFixedArity(2)
 	},
 	"polygonal-take-while": {
-		evaluate: ([sides, fn], sourceCodeInfo, contextStack, { executeFunction }) => {
-			assertNumber(sides, sourceCodeInfo, {
-				integer: true,
-				gte: 3
-			});
-			assertFunctionLike(fn, sourceCodeInfo);
-			const s = sides;
-			const f = fn;
-			const polygonal = [];
-			function loop(i) {
-				const value = (i * i * (s - 2) - i * (s - 4)) / 2;
-				return chain(executeFunction(f, [value, i], contextStack, sourceCodeInfo), (keep) => {
-					if (!keep) return polygonal;
-					polygonal.push(value);
-					return loop(i + 1);
-				});
-			}
-			return loop(1);
+		evaluate: () => {
+			throw new Error("unreachable: overridden by dvalaImpl");
 		},
 		arity: toFixedArity(2)
 	},
@@ -19088,25 +18627,6 @@ function generateRecamanSequence(n) {
 }
 const recamanSequence = {
 	"recaman-seq": (length) => generateRecamanSequence(length),
-	"recaman-take-while": (takeWhile) => {
-		const sequence = [];
-		const seen = new Set([0]);
-		return chain(takeWhile(0, 0), (keepFirst) => {
-			if (!keepFirst) return sequence;
-			sequence.push(0);
-			function loop(i) {
-				let next = sequence[i - 1] - i;
-				if (next <= 0 || seen.has(next)) next = sequence[i - 1] + i;
-				return chain(takeWhile(next, i), (keep) => {
-					if (!keep) return sequence;
-					sequence.push(next);
-					seen.add(next);
-					return loop(i + 1);
-				});
-			}
-			return loop(1);
-		});
-	},
 	"recaman?": () => true
 };
 //#endregion
@@ -19127,18 +18647,6 @@ const thueMorseSequence = {
 		for (let i = 0; i < length; i += 1) thueMorse[i] = countSetBits(i) % 2;
 		return thueMorse;
 	},
-	"thue-morse-take-while": (takeWhile) => {
-		const thueMorse = [];
-		function loop(i) {
-			const value = countSetBits(i) % 2;
-			return chain(takeWhile(value, i), (keep) => {
-				if (!keep) return thueMorse;
-				thueMorse.push(value);
-				return loop(i + 1);
-			});
-		}
-		return loop(0);
-	},
 	"thue-morse?": (n) => n === 1 || n === 0
 };
 function countSetBits(num) {
@@ -19260,16 +18768,7 @@ function addNormalExpressions$1(normalExpressions) {
 function getFiniteNumberSequence(name, sequence) {
 	return {
 		[`${name}-seq`]: createSeqNormalExpression((length) => sequence.slice(0, length), sequence.length),
-		[`${name}-take-while`]: createTakeWhileNormalExpression((takeWhile) => {
-			function loop(i) {
-				if (i >= sequence.length) return sequence.slice(0, i);
-				return chain(takeWhile(sequence[i], i), (keep) => {
-					if (!keep) return sequence.slice(0, i);
-					return loop(i + 1);
-				});
-			}
-			return loop(0);
-		}, sequence.length),
+		[`${name}-take-while`]: createTakeWhileNormalExpression(sequence.length),
 		[`${name}-nth`]: createNthNormalExpression(() => sequence, sequence.length),
 		[`${name}?`]: createNumberPredNormalExpression((n) => sequence.includes(n))
 	};
@@ -19281,8 +18780,8 @@ function addSequence(sequence) {
 		if (key.endsWith("seq")) {
 			sequenceNormalExpressions[key] = createSeqNormalExpression(value, sequence.maxLength);
 			if (!sequence.noNth) sequenceNormalExpressions[key.replace(/seq$/, "nth")] = createNthNormalExpression(value, sequence.maxLength);
-		} else if (key.endsWith("take-while")) sequenceNormalExpressions[key] = createTakeWhileNormalExpression(value, sequence.maxLength);
-		else if (key.endsWith("?")) if (sequence.string) sequenceNormalExpressions[key] = createStringPredNormalExpression(value);
+			if (!sequence.noTakeWhile) sequenceNormalExpressions[key.replace(/seq$/, "take-while")] = createTakeWhileNormalExpression(sequence.maxLength);
+		} else if (key.endsWith("?")) if (sequence.string) sequenceNormalExpressions[key] = createStringPredNormalExpression(value);
 		else sequenceNormalExpressions[key] = createNumberPredNormalExpression(value);
 	}
 }
@@ -19305,18 +18804,10 @@ function createSeqNormalExpression(seqFunction, maxLength) {
 		arity: typeof maxLength === "number" ? { max: 1 } : toFixedArity(1)
 	};
 }
-function createTakeWhileNormalExpression(takeWhileFunction, maxLength) {
+function createTakeWhileNormalExpression(maxLength) {
 	return {
-		evaluate: (params, sourceCodeInfo, contextStack, { executeFunction }) => {
-			const fn = params[0];
-			assertFunctionLike(fn, sourceCodeInfo);
-			return chain(takeWhileFunction((value, index) => chain(executeFunction(fn, [value, index], contextStack), (val) => !!val), sourceCodeInfo), (resolved) => {
-				if (typeof resolved[0] === "number") {
-					/* v8 ignore next 3 */
-					if (resolved.some((n) => n > Number.MAX_SAFE_INTEGER)) throw new DvalaError("Result exceeds maximum safe integer", sourceCodeInfo);
-				}
-				return resolved;
-			});
+		evaluate: () => {
+			throw new Error("unreachable: overridden by dvalaImpl");
 		},
 		arity: typeof maxLength === "number" ? { max: 1 } : toFixedArity(1)
 	};
@@ -19732,7 +19223,7 @@ if (combinatoricalNormalExpression[key]) combinatoricalNormalExpression[key].doc
 const numberTheoryModule = {
 	name: "number-theory",
 	functions: combinatoricalNormalExpression,
-	source: "{}",
+	source: number_theory_default,
 	docs: moduleDocs$1
 };
 //#endregion
@@ -24880,7 +24371,7 @@ function printlnHandler(args, k) {
 		k
 	};
 }
-function generateUUID() {
+function generateUUID$1() {
 	return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (char) => {
 		const random = Math.random() * 16 | 0;
 		return (char === "x" ? random : random & 3 | 8).toString(16);
@@ -25056,7 +24547,7 @@ const standardEffects = {
 		handler: (_args, k) => {
 			return {
 				type: "Value",
-				value: generateUUID(),
+				value: generateUUID$1(),
 				k
 			};
 		},
@@ -26605,57 +26096,416 @@ function createContextStack(params = {}, modules, pure) {
 	return params.globalModuleScope ? contextStack : contextStack.create({});
 }
 //#endregion
-//#region src/getUndefinedSymbols/index.ts
-const getUndefinedSymbols$1 = (ast, contextStack, builtin, evaluateNode) => {
-	const nodes = Array.isArray(ast) ? ast : [[NodeTypes.SpecialExpression, [
-		specialExpressionTypes.block,
-		ast.body,
-		void 0
-	]]];
-	const unresolvedSymbols = /* @__PURE__ */ 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;
-			if (contextStack.lookUp(symbolNode) === 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 = /* @__PURE__ */ new Set();
-			if (isNormalExpressionNodeWithName(normalExpressionNode)) {
-				const [, [symbolNode]] = normalExpressionNode;
-				if (isUserDefinedSymbolNode(symbolNode)) {
-					if (contextStack.lookUp(symbolNode) === 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;
+//#region src/builtin/bindingSlot.ts
+/**
+* Validate that the root value matches the expected binding target structure.
+*
+* For array destructuring (`let [a, b] = value`), value must be an array.
+* For object destructuring (`let {a, b} = value`), value must be an object.
+* For symbol binding (`let x = value`), no validation needed.
+*/
+function validateBindingRootType(target, value, sourceCodeInfo) {
+	switch (target[0]) {
+		case bindingTargetTypes.array:
+			assertArray(value, sourceCodeInfo);
+			break;
+		case bindingTargetTypes.object:
+			assertUnknownRecord(value, sourceCodeInfo);
+			break;
+	}
+}
+/**
+* Flatten a binding pattern into a linear list of slots.
+*
+* Example: `{a = 1, b: {c = 2}}`
+* Produces: [
+*   { name: 'a', path: [{type: 'key', key: 'a'}], defaultNode: <1> },
+*   { name: 'c', path: [{type: 'key', key: 'b'}, {type: 'key', key: 'c'}], defaultNode: <2> }
+* ]
+*/
+function flattenBindingPattern(target) {
+	const slots = [];
+	flattenTarget(target, [], slots);
+	return slots;
+}
+function flattenTarget(target, path, slots) {
+	const sourceCodeInfo = target[2];
+	switch (target[0]) {
+		case bindingTargetTypes.symbol: {
+			const symbolNode = target[1][0];
+			const defaultNode = target[1][1];
+			slots.push({
+				name: symbolNode[1],
+				path: [...path],
+				defaultNode,
+				sourceCodeInfo
+			});
+			break;
 		}
-		case NodeTypes.SpecialExpression: {
-			const specialExpressionNode = node;
-			const specialExpressionType = specialExpressionNode[1][0];
-			const castedGetUndefinedSymbols = builtin.specialExpressions[specialExpressionType].getUndefinedSymbols;
-			return castedGetUndefinedSymbols(specialExpressionNode, contextStack, {
-				getUndefinedSymbols: getUndefinedSymbols$1,
-				builtin,
-				evaluateNode
+		case bindingTargetTypes.rest: {
+			const name = target[1][0];
+			const defaultNode = target[1][1];
+			slots.push({
+				name,
+				path: [...path],
+				defaultNode,
+				isRest: true,
+				sourceCodeInfo
 			});
+			break;
 		}
-		case NodeTypes.Spread: return findUnresolvedSymbolsInNode(node[1], contextStack, builtin, evaluateNode);
+		case bindingTargetTypes.object: {
+			const entries = target[1][0];
+			const capturedKeys = /* @__PURE__ */ new Set();
+			for (const [key, element] of Object.entries(entries)) {
+				if (element[0] === bindingTargetTypes.rest) continue;
+				capturedKeys.add(key);
+				const newPath = [...path, {
+					type: "key",
+					key
+				}];
+				const hasDefault = element[1][1] !== void 0;
+				const isCompound = element[0] === bindingTargetTypes.object || element[0] === bindingTargetTypes.array;
+				if (hasDefault && isCompound) slots.push({
+					name: `_intermediate_${slots.length}`,
+					path: newPath,
+					defaultNode: element[1][1],
+					nestedTarget: element,
+					sourceCodeInfo: element[2]
+				});
+				else flattenTarget(element, newPath, slots);
+			}
+			for (const [_key, element] of Object.entries(entries)) if (element[0] === bindingTargetTypes.rest) {
+				const name = element[1][0];
+				slots.push({
+					name,
+					path: [...path],
+					isRest: true,
+					restKeys: capturedKeys,
+					sourceCodeInfo: element[2]
+				});
+				break;
+			}
+			break;
+		}
+		case bindingTargetTypes.array: {
+			const elements = target[1][0];
+			for (let i = 0; i < elements.length; i++) {
+				const element = elements[i];
+				if (element === null || element === void 0) continue;
+				if (element[0] === bindingTargetTypes.rest) {
+					const name = element[1][0];
+					slots.push({
+						name,
+						path: [...path],
+						isRest: true,
+						restIndex: i,
+						sourceCodeInfo: element[2]
+					});
+					break;
+				}
+				const newPath = [...path, {
+					type: "index",
+					index: i
+				}];
+				const hasDefault = element[1][1] !== void 0;
+				const isCompound = element[0] === bindingTargetTypes.object || element[0] === bindingTargetTypes.array;
+				if (hasDefault && isCompound) slots.push({
+					name: `_intermediate_${slots.length}`,
+					path: newPath,
+					defaultNode: element[1][1],
+					nestedTarget: element,
+					sourceCodeInfo: element[2]
+				});
+				else flattenTarget(element, newPath, slots);
+			}
+			break;
+		}
+		case bindingTargetTypes.literal:
+		case bindingTargetTypes.wildcard: break;
+	}
+}
+/**
+* Extract a value from a nested structure by following a path.
+*
+* Returns undefined if the path cannot be followed (missing key/index).
+*/
+function extractValueByPath(rootValue, path, sourceCodeInfo) {
+	let current = rootValue;
+	for (const step of path) {
+		if (current === null || current === void 0) return;
+		if (step.type === "key") {
+			assertUnknownRecord(current, sourceCodeInfo);
+			current = current[step.key];
+		} else {
+			assertArray(current, sourceCodeInfo);
+			current = current[step.index];
+		}
+	}
+	return current;
+}
+/**
+* Extract rest values for an object rest binding.
+* Returns an object with all keys except those in restKeys.
+*/
+function extractObjectRest(value, restKeys, sourceCodeInfo) {
+	assertUnknownRecord(value, sourceCodeInfo);
+	const result = {};
+	for (const [key, val] of Object.entries(value)) if (!restKeys.has(key)) result[key] = asAny(val);
+	return result;
+}
+/**
+* Extract rest values for an array rest binding.
+* Returns elements from restIndex onwards.
+*/
+function extractArrayRest(value, restIndex, sourceCodeInfo) {
+	assertArray(value, sourceCodeInfo);
+	return value.slice(restIndex);
+}
+//#endregion
+//#region src/builtin/matchSlot.ts
+/**
+* Flatten a binding pattern into a linear list of match slots.
+* Returns slots in order they should be processed.
+*
+* Type checks come first (to fail fast on type mismatch).
+* Then binding/literal slots in depth-first order.
+*/
+function flattenMatchPattern(target) {
+	const slots = [];
+	flattenMatchTarget(target, [], slots);
+	return slots;
+}
+function flattenMatchTarget(target, path, slots) {
+	switch (target[0]) {
+		case bindingTargetTypes.wildcard:
+			slots.push({
+				kind: "wildcard",
+				path: [...path]
+			});
+			break;
+		case bindingTargetTypes.literal: {
+			const literalNode = target[1][0];
+			slots.push({
+				kind: "literal",
+				path: [...path],
+				literalNode,
+				sourceCodeInfo: target[2]
+			});
+			break;
+		}
+		case bindingTargetTypes.symbol: {
+			const name = target[1][0][1];
+			const defaultNode = target[1][1];
+			slots.push({
+				kind: "bind",
+				name,
+				path: [...path],
+				defaultNode,
+				sourceCodeInfo: target[2]
+			});
+			break;
+		}
+		case bindingTargetTypes.rest: {
+			const name = target[1][0];
+			const defaultNode = target[1][1];
+			slots.push({
+				kind: "rest",
+				name,
+				path: [...path],
+				defaultNode,
+				sourceCodeInfo: target[2]
+			});
+			break;
+		}
+		case bindingTargetTypes.object: {
+			if (path.length > 0) slots.push({
+				kind: "typeCheck",
+				path: [...path],
+				requiredType: "object",
+				sourceCodeInfo: target[2]
+			});
+			const entries = target[1][0];
+			const capturedKeys = /* @__PURE__ */ new Set();
+			let restElement;
+			for (const [key, element] of Object.entries(entries)) {
+				if (element[0] === bindingTargetTypes.rest) {
+					restElement = element;
+					continue;
+				}
+				capturedKeys.add(key);
+				flattenMatchTarget(element, [...path, {
+					type: "key",
+					key
+				}], slots);
+			}
+			if (restElement) slots.push({
+				kind: "rest",
+				name: restElement[1][0],
+				path: [...path],
+				restKeys: capturedKeys,
+				sourceCodeInfo: restElement[2]
+			});
+			break;
+		}
+		case bindingTargetTypes.array: {
+			if (path.length > 0) slots.push({
+				kind: "typeCheck",
+				path: [...path],
+				requiredType: "array",
+				sourceCodeInfo: target[2]
+			});
+			const elements = target[1][0];
+			for (let i = 0; i < elements.length; i++) {
+				const element = elements[i];
+				if (element === null || element === void 0) continue;
+				if (element[0] === bindingTargetTypes.rest) {
+					slots.push({
+						kind: "rest",
+						name: element[1][0],
+						path: [...path],
+						restIndex: i,
+						sourceCodeInfo: element[2]
+					});
+					break;
+				}
+				flattenMatchTarget(element, [...path, {
+					type: "index",
+					index: i
+				}], slots);
+			}
+			break;
+		}
+	}
+}
+/**
+* Extract a value from a nested structure by following a path.
+* Returns undefined if path cannot be followed.
+*/
+function extractMatchValueByPath(rootValue, path) {
+	let current = rootValue;
+	for (const step of path) {
+		if (current === null || current === void 0) return;
+		if (step.type === "key") {
+			if (!isUnknownRecord(current)) return void 0;
+			current = current[step.key];
+		} else {
+			if (!Array.isArray(current)) return void 0;
+			current = current[step.index];
+		}
+	}
+	return current;
+}
+/**
+* Check if value matches required type at path.
+*/
+function checkTypeAtPath(rootValue, path, requiredType) {
+	const value = path.length > 0 ? extractMatchValueByPath(rootValue, path) : rootValue;
+	if (value === null || value === void 0) return false;
+	if (requiredType === "object") return isUnknownRecord(value);
+	else return Array.isArray(value);
+}
+/**
+* Extract rest values for object rest.
+*/
+function extractMatchObjectRest(value, path, restKeys) {
+	const obj = path.length > 0 ? extractMatchValueByPath(value, path) : value;
+	if (!isUnknownRecord(obj)) return {};
+	const result = {};
+	for (const [key, val] of Object.entries(obj)) if (!restKeys.has(key)) result[key] = asAny(val);
+	return result;
+}
+/**
+* Extract rest values for array rest.
+*/
+function extractMatchArrayRest(value, path, restIndex) {
+	const arr = path.length > 0 ? extractMatchValueByPath(value, path) : value;
+	if (!Array.isArray(arr)) return [];
+	return arr.slice(restIndex).map((v) => asAny(v));
+}
+/**
+* Check array length constraints at pattern root.
+* For patterns like [a, b, c] - exact match required.
+* For patterns like [a, b, ...rest] - minimum match required.
+*/
+function checkArrayLengthConstraint(target, value) {
+	if (target[0] !== bindingTargetTypes.array) return true;
+	if (!Array.isArray(value)) return false;
+	const elements = target[1][0];
+	let hasRest = false;
+	let nonRestCount = 0;
+	for (const element of elements) {
+		if (element === null) {
+			nonRestCount++;
+			continue;
+		}
+		if (element[0] === bindingTargetTypes.rest) {
+			hasRest = true;
+			break;
+		}
+		nonRestCount++;
+	}
+	if (hasRest) return value.length >= nonRestCount;
+	else return value.length === nonRestCount;
+}
+/**
+* Check object exists at pattern root.
+*/
+function checkObjectTypeConstraint(target, value) {
+	if (target[0] !== bindingTargetTypes.object) return true;
+	return isUnknownRecord(value);
+}
+//#endregion
+//#region src/getUndefinedSymbols/index.ts
+const getUndefinedSymbols$1 = (ast, contextStack, builtin) => {
+	const nodes = Array.isArray(ast) ? ast : [[NodeTypes.SpecialExpression, [
+		specialExpressionTypes.block,
+		ast.body,
+		void 0
+	]]];
+	const unresolvedSymbols = /* @__PURE__ */ new Set();
+	for (const subNode of nodes) findUnresolvedSymbolsInNode(subNode, contextStack, builtin)?.forEach((symbol) => unresolvedSymbols.add(symbol));
+	return unresolvedSymbols;
+};
+function findUnresolvedSymbolsInNode(node, contextStack, builtin) {
+	const nodeType = node[0];
+	switch (nodeType) {
+		case NodeTypes.UserDefinedSymbol: {
+			const symbolNode = node;
+			if (contextStack.lookUp(symbolNode) === 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 = /* @__PURE__ */ new Set();
+			if (isNormalExpressionNodeWithName(normalExpressionNode)) {
+				const [, [symbolNode]] = normalExpressionNode;
+				if (isUserDefinedSymbolNode(symbolNode)) {
+					if (contextStack.lookUp(symbolNode) === null) unresolvedSymbols.add(symbolNode[1]);
+				}
+			} else {
+				const [, [expressionNode]] = normalExpressionNode;
+				findUnresolvedSymbolsInNode(expressionNode, contextStack, builtin)?.forEach((symbol) => unresolvedSymbols.add(symbol));
+			}
+			for (const subNode of normalExpressionNode[1][1]) findUnresolvedSymbolsInNode(subNode, contextStack, builtin)?.forEach((symbol) => unresolvedSymbols.add(symbol));
+			return unresolvedSymbols;
+		}
+		case NodeTypes.SpecialExpression: {
+			const specialExpressionNode = node;
+			const specialExpressionType = specialExpressionNode[1][0];
+			const castedGetUndefinedSymbols = builtin.specialExpressions[specialExpressionType].getUndefinedSymbols;
+			return castedGetUndefinedSymbols(specialExpressionNode, contextStack, {
+				getUndefinedSymbols: getUndefinedSymbols$1,
+				builtin
+			});
+		}
+		case NodeTypes.Spread: return findUnresolvedSymbolsInNode(node[1], contextStack, builtin);
 		default: throw new DvalaError(`Unhandled node type: ${nodeType}`, node[2]);
 	}
 }
@@ -27793,7 +27643,7 @@ const SUSPENDED_MESSAGE = "Program suspended";
 * Generate a UUID for identifying a run() or resume() call.
 * Uses crypto.randomUUID() when available, falls back to a simple generator.
 */
-function generateRunId() {
+function generateUUID() {
 	if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") return crypto.randomUUID();
 	return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
 		const r = Math.random() * 16 | 0;
@@ -27801,6 +27651,15 @@ function generateRunId() {
 	});
 }
 /**
+* Create a Snapshot with a freshly generated unique `id`.
+*/
+function createSnapshot(fields) {
+	return {
+		id: generateUUID(),
+		...fields
+	};
+}
+/**
 * Test whether a handler pattern key matches a given effect name.
 *
 * Rules:
@@ -28258,6 +28117,28 @@ function serializeSuspensionBlob(k, snapshots, nextSnapshotIndex, meta) {
 	return base;
 }
 /**
+* Create a terminal snapshot for completed or errored program states.
+* The continuation is empty (cannot resume), but checkpoints are preserved
+* for time travel debugging.
+*/
+function serializeTerminalSnapshot(snapshots, nextSnapshotIndex) {
+	const base = {
+		version: SUSPENSION_VERSION,
+		contextStacks: [],
+		k: []
+	};
+	if (snapshots.length > 0) {
+		base.snapshots = snapshots;
+		const roots = [];
+		for (const snapshot of snapshots) roots.push(snapshot);
+		const { roots: dedupedRoots, pool } = dedupSubTrees(roots, DEFAULT_DEDUP_THRESHOLD);
+		for (let i = 0; i < base.snapshots.length; i++) base.snapshots[i] = dedupedRoots[i];
+		if (Object.keys(pool).length > 0) base.pool = pool;
+	}
+	base.nextSnapshotIndex = nextSnapshotIndex;
+	return base;
+}
+/**
 * Deserialize a plain object (as produced by `serializeToObject`) back into
 * a continuation stack and metadata.
 *
@@ -28324,7 +28205,7 @@ function deserializeFromObject(blobData, options) {
 	};
 }
 //#endregion
-//#region src/evaluator/trampoline.ts
+//#region src/evaluator/trampoline-evaluator.ts
 /**
 * Trampoline evaluator — explicit-stack evaluation engine.
 *
@@ -28342,292 +28223,10 @@ function deserializeFromObject(blobData, options) {
 * - `stepNode` is always synchronous and returns `Step`.
 * - `applyFrame` may return `Step | Promise<Step>` when normal expressions
 *   or compound function types produce async results.
-* - Normal built-in expressions are called directly with pre-evaluated args
-*   (they may still use the old recursive `evaluateNode` internally for
-*   higher-order callbacks — suspension through them is deferred).
-* - Binding utilities (`evaluateBindingNodeValues`, `tryMatch`) are called
-*   with a recursive `evaluateNode` helper. This is acceptable for Phase 1.
+* - Normal built-in expressions are called directly with pre-evaluated args.
+* - All binding and pattern matching use frame-based slot processing.
 * - All state lives in frames (no JS closures) — enabling serialization later.
 */
-function evaluateNodeRecursive(node, contextStack) {
-	switch (node[0]) {
-		case NodeTypes.Number: return node[1];
-		case NodeTypes.String: return node[1];
-		case NodeTypes.NormalBuiltinSymbol:
-		case NodeTypes.SpecialBuiltinSymbol:
-		case NodeTypes.UserDefinedSymbol: return contextStack.evaluateSymbol(node);
-		case NodeTypes.ReservedSymbol: return evaluateReservedSymbol(node);
-		case NodeTypes.NormalExpression: return chain(evaluateNormalExpressionRecursive(node, contextStack), (resolved) => {
-			if (typeof resolved === "number" && Number.isNaN(resolved)) throw new DvalaError("Number is NaN", node[2]);
-			return annotate(resolved);
-		});
-		case NodeTypes.SpecialExpression: {
-			const initial = {
-				type: "Eval",
-				node,
-				env: contextStack,
-				k: []
-			};
-			try {
-				return annotate(runSyncTrampoline(initial));
-			} catch (error) {
-				/* v8 ignore next 4 */
-				if (error instanceof DvalaError && error.message.includes("Unexpected async operation")) return runAsyncTrampoline({
-					type: "Eval",
-					node,
-					env: contextStack,
-					k: []
-				}).then((r) => annotate(r));
-				throw error;
-			}
-		}
-		default: throw new DvalaError(`${getNodeTypeName(node[0])}-node cannot be evaluated`, node[2]);
-	}
-}
-function evaluateParamsRecursive(paramNodes, contextStack) {
-	const params = [];
-	const placeholders = [];
-	return chain(forEachSequential(paramNodes, (paramNode, index) => {
-		if (isSpreadNode(paramNode))
- /* v8 ignore start */
-		return chain(evaluateNodeRecursive(paramNode[1], contextStack), (spreadValue) => {
-			if (Array.isArray(spreadValue)) params.push(...spreadValue);
-			else throw new DvalaError(`Spread operator requires an array, got ${valueToString(paramNode)}`, paramNode[2]);
-		});
-		else if (paramNode[0] === NodeTypes.ReservedSymbol && paramNode[1] === "_") placeholders.push(index);
-		else return chain(evaluateNodeRecursive(paramNode, contextStack), (value) => {
-			params.push(value);
-		});
-	}), () => ({
-		params,
-		placeholders
-	}));
-}
-function evaluateNormalExpressionRecursive(node, contextStack) {
-	const sourceCodeInfo = node[2];
-	return chain(evaluateParamsRecursive(node[1][1], contextStack), ({ params, placeholders }) => {
-		if (isNormalExpressionNodeWithName(node)) {
-			const nameSymbol = node[1][0];
-			if (placeholders.length > 0) return chain(evaluateNodeRecursive(nameSymbol, contextStack), (resolvedFn) => {
-				return {
-					[FUNCTION_SYMBOL]: true,
-					function: asFunctionLike(resolvedFn, sourceCodeInfo),
-					functionType: "Partial",
-					params,
-					placeholders,
-					sourceCodeInfo,
-					arity: toFixedArity(placeholders.length)
-				};
-			});
-			if (isNormalBuiltinSymbolNode(nameSymbol)) {
-				const type = nameSymbol[1];
-				const normalExpression = builtin.allNormalExpressions[type];
-				if (contextStack.pure && normalExpression.pure === false) throw new DvalaError(`Cannot call impure function '${normalExpression.name}' in pure mode`, node[2]);
-				/* v8 ignore next 3 */
-				if (normalExpression.dvalaImpl) return executeUserDefinedRecursive(normalExpression.dvalaImpl, params, contextStack, node[2]);
-				return normalExpression.evaluate(params, node[2], contextStack, { executeFunction: executeFunctionRecursive });
-			} else {
-				const fn = contextStack.getValue(nameSymbol[1]);
-				if (fn !== void 0) return executeFunctionRecursive(asFunctionLike(fn, sourceCodeInfo), params, contextStack, sourceCodeInfo);
-				/* v8 ignore next 1 */
-				throw new UndefinedSymbolError(nameSymbol[1], node[2]);
-			}
-		} else {
-			const fnNode = node[1][0];
-			/* v8 ignore start */
-			return chain(evaluateNodeRecursive(fnNode, contextStack), (resolvedFn) => {
-				const fn = asFunctionLike(resolvedFn, sourceCodeInfo);
-				if (placeholders.length > 0) return {
-					[FUNCTION_SYMBOL]: true,
-					function: fn,
-					functionType: "Partial",
-					params,
-					placeholders,
-					sourceCodeInfo,
-					arity: toFixedArity(placeholders.length)
-				};
-				return executeFunctionRecursive(fn, params, contextStack, sourceCodeInfo);
-			});
-		}
-	});
-}
-function executeFunctionRecursive(fn, params, contextStack, sourceCodeInfo) {
-	if (isDvalaFunction(fn)) return executeDvalaFunctionRecursive(fn, params, contextStack, sourceCodeInfo);
-	if (Array.isArray(fn)) return evaluateArrayAsFunction(fn, params, sourceCodeInfo);
-	if (isObj(fn)) return evaluateObjectAsFunction(fn, params, sourceCodeInfo);
-	if (typeof fn === "string") return evaluateStringAsFunction(fn, params, sourceCodeInfo);
-	if (isNumber(fn)) return evaluateNumberAsFunction(fn, params, sourceCodeInfo);
-	/* v8 ignore next 1 */
-	throw new DvalaError("Unexpected function type", sourceCodeInfo);
-}
-/**
-* Execute a DvalaFunction recursively. This is the old-style executor
-* used as a fallback for normal expression callbacks.
-*/
-function executeDvalaFunctionRecursive(fn, params, contextStack, sourceCodeInfo) {
-	switch (fn.functionType) {
-		case "UserDefined": return executeUserDefinedRecursive(fn, params, contextStack, sourceCodeInfo);
-		case "Partial": return executePartialRecursive(fn, params, contextStack, sourceCodeInfo);
-		case "Comp": return executeCompRecursive(fn, params, contextStack, sourceCodeInfo);
-		case "Constantly": return fn.value;
-		case "Juxt": return executeJuxtRecursive(fn, params, contextStack, sourceCodeInfo);
-		case "Complement": return chain(executeFunctionRecursive(fn.function, params, contextStack, sourceCodeInfo), (result) => !result);
-		case "EveryPred": return executeEveryPredRecursive(fn, params, contextStack, sourceCodeInfo);
-		case "SomePred": return executeSomePredRecursive(fn, params, contextStack, sourceCodeInfo);
-		case "Fnull": return executeFnullRecursive(fn, params, contextStack, sourceCodeInfo);
-		case "EffectMatcher": return executeEffectMatcherRecursive(fn, params, sourceCodeInfo);
-		case "Builtin": {
-			const normalExpression = builtin.allNormalExpressions[fn.normalBuiltinSymbolType];
-			if (normalExpression.dvalaImpl) return executeUserDefinedRecursive(normalExpression.dvalaImpl, params, contextStack, sourceCodeInfo);
-			return executeBuiltinRecursive(fn, params, contextStack, sourceCodeInfo);
-		}
-		case "SpecialBuiltin": return executeSpecialBuiltinRecursive(fn, params, contextStack, sourceCodeInfo);
-		case "Module": return executeModuleRecursive(fn, params, contextStack, sourceCodeInfo);
-	}
-}
-function executeUserDefinedRecursive(fn, params, contextStack, sourceCodeInfo) {
-	function setupAndExecute(currentParams) {
-		if (!arityAcceptsMin(fn.arity, currentParams.length)) throw new DvalaError(`Expected ${fn.arity} arguments, got ${currentParams.length}.`, sourceCodeInfo);
-		const evaluatedFunction = fn.evaluatedfunction;
-		const args = evaluatedFunction[0];
-		const nbrOfNonRestArgs = args.filter((arg) => arg[0] !== bindingTargetTypes.rest).length;
-		const newContextStack = contextStack.create(fn.evaluatedfunction[2]);
-		const newContext = { self: { value: fn } };
-		const rest = [];
-		let paramSetup = void 0;
-		for (let i = 0; i < currentParams.length; i += 1) if (i < nbrOfNonRestArgs) {
-			const paramIndex = i;
-			paramSetup = chain(paramSetup, () => {
-				const param = toAny(currentParams[paramIndex]);
-				return chain(evaluateBindingNodeValues(args[paramIndex], param, (node) => evaluateNodeRecursive(node, newContextStack.create(newContext))), (valueRecord) => {
-					Object.entries(valueRecord).forEach(([key, value]) => {
-						newContext[key] = { value };
-					});
-				});
-			});
-		} else rest.push(toAny(currentParams[i]));
-		let defaultSetup = void 0;
-		for (let i = currentParams.length; i < nbrOfNonRestArgs; i++) {
-			const argIndex = i;
-			defaultSetup = chain(defaultSetup, () => {
-				const arg = args[argIndex];
-				return chain(evaluateNodeRecursive(arg[1][1], contextStack.create(newContext)), (defaultValue) => {
-					return chain(evaluateBindingNodeValues(arg, defaultValue, (node) => evaluateNodeRecursive(node, contextStack.create(newContext))), (valueRecord) => {
-						Object.entries(valueRecord).forEach(([key, value]) => {
-							newContext[key] = { value };
-						});
-					});
-				});
-			});
-		}
-		return chain(paramSetup, () => chain(defaultSetup, () => {
-			const restArgument = args.find((arg) => arg[0] === bindingTargetTypes.rest);
-			return chain(restArgument !== void 0 ? chain(evaluateBindingNodeValues(restArgument, rest, (node) => evaluateNodeRecursive(node, contextStack.create(newContext))), (valueRecord) => {
-				Object.entries(valueRecord).forEach(([key, value]) => {
-					newContext[key] = { value };
-				});
-			}) : void 0, () => {
-				const newContextStack2 = newContextStack.create(newContext);
-				const bodyResult = reduceSequential(evaluatedFunction[1], (_acc, node) => evaluateNodeRecursive(node, newContextStack2), null);
-				/* v8 ignore start */
-				if (bodyResult instanceof Promise) return bodyResult.catch((error) => {
-					if (error instanceof RecurSignal) return setupAndExecute(error.params);
-					throw error;
-				});
-				/* v8 ignore stop */
-				return bodyResult;
-			});
-		}));
-	}
-	for (;;) try {
-		return setupAndExecute(params);
-	} catch (error) {
-		if (error instanceof RecurSignal) {
-			params = error.params;
-			continue;
-		}
-		throw error;
-	}
-}
-function executePartialRecursive(fn, params, contextStack, sourceCodeInfo) {
-	const actualParams = [...fn.params];
-	/* v8 ignore next 3 */
-	if (params.length !== fn.placeholders.length) throw new DvalaError(`(partial) expects ${fn.placeholders.length} arguments, got ${params.length}.`, sourceCodeInfo);
-	const paramsCopy = [...params];
-	for (const placeholderIndex of fn.placeholders) actualParams.splice(placeholderIndex, 0, paramsCopy.shift());
-	return executeFunctionRecursive(fn.function, actualParams, contextStack, sourceCodeInfo);
-}
-function executeCompRecursive(fn, params, contextStack, sourceCodeInfo) {
-	const { params: f } = fn;
-	if (f.length === 0) {
-		if (params.length !== 1) throw new DvalaError(`(comp) expects one argument, got ${valueToString(params.length)}.`, sourceCodeInfo);
-		return asAny(params[0], sourceCodeInfo);
-	}
-	let result = params;
-	for (let i = f.length - 1; i >= 0; i--) {
-		const fun = f[i];
-		result = chain(result, (currentParams) => chain(executeFunctionRecursive(asFunctionLike(fun, sourceCodeInfo), currentParams, contextStack, sourceCodeInfo), (r) => [r]));
-	}
-	return chain(result, (finalArr) => asAny(finalArr[0], sourceCodeInfo));
-}
-function executeJuxtRecursive(fn, params, contextStack, sourceCodeInfo) {
-	return mapSequential(fn.params, (fun) => executeFunctionRecursive(asFunctionLike(fun, sourceCodeInfo), params, contextStack, sourceCodeInfo));
-}
-function executeEveryPredRecursive(fn, params, contextStack, sourceCodeInfo) {
-	const checks = [];
-	for (const f of fn.params) for (const param of params) checks.push(() => executeFunctionRecursive(asFunctionLike(f, sourceCodeInfo), [param], contextStack, sourceCodeInfo));
-	return reduceSequential(checks, (acc, check) => {
-		if (!acc) return false;
-		return chain(check(), (result) => !!result);
-	}, true);
-}
-function executeSomePredRecursive(fn, params, contextStack, sourceCodeInfo) {
-	const checks = [];
-	for (const f of fn.params) for (const param of params) checks.push(() => executeFunctionRecursive(asFunctionLike(f, sourceCodeInfo), [param], contextStack, sourceCodeInfo));
-	return reduceSequential(checks, (acc, check) => {
-		if (acc) return true;
-		return chain(check(), (result) => !!result);
-	}, false);
-}
-function executeFnullRecursive(fn, params, contextStack, sourceCodeInfo) {
-	const fnulledParams = params.map((param, index) => param === null ? toAny(fn.params[index]) : param);
-	return executeFunctionRecursive(asFunctionLike(fn.function, sourceCodeInfo), fnulledParams, contextStack, sourceCodeInfo);
-}
-function executeEffectMatcherRecursive(fn, params, sourceCodeInfo) {
-	assertNumberOfParams({
-		min: 1,
-		max: 1
-	}, params.length, fn.sourceCodeInfo ?? sourceCodeInfo);
-	const effectRef = params[0];
-	assertEffect(effectRef, sourceCodeInfo);
-	const effectName = effectRef.name;
-	if (fn.matchType === "string") return effectNameMatchesPattern(effectName, fn.pattern);
-	return new RegExp(fn.pattern, fn.flags).test(effectName);
-}
-function executeBuiltinRecursive(fn, params, contextStack, sourceCodeInfo) {
-	const normalExpression = asNonUndefined(builtin.allNormalExpressions[fn.normalBuiltinSymbolType], sourceCodeInfo);
-	/* v8 ignore next 6 */
-	if (contextStack.pure && normalExpression.pure === false) throw new DvalaError(`Cannot call impure function '${fn.name}' in pure mode`, sourceCodeInfo);
-	if (normalExpression.dvalaImpl) return executeUserDefinedRecursive(normalExpression.dvalaImpl, params, contextStack, sourceCodeInfo);
-	return normalExpression.evaluate(params, sourceCodeInfo, contextStack, { executeFunction: executeFunctionRecursive });
-}
-/* v8 ignore start */
-function executeSpecialBuiltinRecursive(fn, params, contextStack, sourceCodeInfo) {
-	const specialExpression = asNonUndefined(builtin.specialExpressions[fn.specialBuiltinSymbolType], sourceCodeInfo);
-	if (specialExpression.evaluateAsNormalExpression) return specialExpression.evaluateAsNormalExpression(params, sourceCodeInfo, contextStack, { executeFunction: executeFunctionRecursive });
-	throw new DvalaError(`Special builtin function ${fn.specialBuiltinSymbolType} is not supported as normal expression.`, sourceCodeInfo);
-}
-function executeModuleRecursive(fn, params, contextStack, sourceCodeInfo) {
-	const dvalaModule = contextStack.getModule(fn.moduleName);
-	if (!dvalaModule) throw new DvalaError(`Module '${fn.moduleName}' not found.`, sourceCodeInfo);
-	const expression = dvalaModule.functions[fn.functionName];
-	if (!expression) throw new DvalaError(`Function '${fn.functionName}' not found in module '${fn.moduleName}'.`, sourceCodeInfo);
-	if (contextStack.pure && expression.pure === false) throw new DvalaError(`Cannot call impure function '${fn.functionName}' in pure mode`, sourceCodeInfo);
-	assertNumberOfParams(expression.arity, params.length, sourceCodeInfo);
-	if (expression.dvalaImpl) return executeUserDefinedRecursive(expression.dvalaImpl, params, contextStack, sourceCodeInfo);
-	return expression.evaluate(params, sourceCodeInfo, contextStack, { executeFunction: executeFunctionRecursive });
-}
-/* v8 ignore stop */
 function evaluateObjectAsFunction(fn, params, sourceCodeInfo) {
 	if (params.length !== 1) throw new DvalaError("Object as function requires one string parameter.", sourceCodeInfo);
 	const key = params[0];
@@ -28675,7 +28274,7 @@ function evaluateFunction(fn, contextStack) {
 		});
 		return ctx;
 	}, {});
-	getUndefinedSymbols$1(fn[1], contextStack.new(context), builtin, evaluateNodeRecursive).forEach((name) => {
+	getUndefinedSymbols$1(fn[1], contextStack.new(context), builtin).forEach((name) => {
 		const value = contextStack.getValue(name);
 		if (isAny(value)) functionContext[name] = { value };
 	});
@@ -28948,26 +28547,34 @@ function stepSpecialExpression(node, env, k) {
 			const nodes = node[1][1];
 			const withHandlerNodes = node[1][2];
 			const newEnv = env.create({});
-			let bodyK = k;
-			if (withHandlerNodes && withHandlerNodes.length > 0) bodyK = [{
-				type: "TryWith",
-				handlers: withHandlerNodes.map(([effectExpr, handlerNode]) => ({
-					effectRef: evaluateNodeRecursive(effectExpr, env),
-					handlerNode
-				})),
-				env,
-				sourceCodeInfo
-			}, ...k];
+			if (withHandlerNodes && withHandlerNodes.length > 0) {
+				const effectRefFrame = {
+					type: "EffectRef",
+					handlerNodes: withHandlerNodes,
+					evaluatedHandlers: [],
+					index: 0,
+					bodyNodes: nodes,
+					bodyEnv: newEnv,
+					env,
+					sourceCodeInfo
+				};
+				return {
+					type: "Eval",
+					node: withHandlerNodes[0][0],
+					env,
+					k: [effectRefFrame, ...k]
+				};
+			}
 			if (nodes.length === 0) return {
 				type: "Value",
 				value: null,
-				k: bodyK
+				k
 			};
 			if (nodes.length === 1) return {
 				type: "Eval",
 				node: nodes[0],
 				env: newEnv,
-				k: bodyK
+				k
 			};
 			const frame = {
 				type: "Sequence",
@@ -28980,7 +28587,7 @@ function stepSpecialExpression(node, env, k) {
 				type: "Eval",
 				node: nodes[0],
 				env: newEnv,
-				k: [frame, ...bodyK]
+				k: [frame, ...k]
 			};
 		}
 		case specialExpressionTypes.let: {
@@ -29335,7 +28942,7 @@ function dispatchCall(frame, k) {
 			if (env.pure && normalExpression.pure === false) throw new DvalaError(`Cannot call impure function '${normalExpression.name}' in pure mode`, sourceCodeInfo);
 			/* v8 ignore next 3 */
 			if (normalExpression.dvalaImpl) return setupUserDefinedCall(normalExpression.dvalaImpl, params, env, sourceCodeInfo, k);
-			return wrapMaybePromiseAsStep(normalExpression.evaluate(params, sourceCodeInfo, env, { executeFunction: executeFunctionRecursive }), k);
+			return wrapMaybePromiseAsStep(normalExpression.evaluate(params, sourceCodeInfo, env), k);
 		}
 		const fn = env.getValue(nameSymbol[1]);
 		if (fn !== void 0) return dispatchFunction(asFunctionLike(fn, sourceCodeInfo), params, placeholders, env, sourceCodeInfo, k);
@@ -29396,79 +29003,219 @@ function dispatchFunction(fn, params, placeholders, env, sourceCodeInfo, k) {
 }
 /**
 * Dispatch a DvalaFunction. User-defined functions are set up with frames;
-* compound function types (Comp, Juxt, etc.) use the recursive executor.
+* some compound function types still use the recursive executor for iteration.
 */
 function dispatchDvalaFunction(fn, params, env, sourceCodeInfo, k) {
 	switch (fn.functionType) {
 		case "UserDefined": return setupUserDefinedCall(fn, params, env, sourceCodeInfo, k);
-		case "Partial":
-		case "Comp":
-		case "Constantly":
-		case "Juxt":
-		case "Complement":
-		case "EveryPred":
-		case "SomePred":
-		case "Fnull":
-		case "EffectMatcher":
-		case "SpecialBuiltin": return wrapMaybePromiseAsStep(executeDvalaFunctionRecursive(fn, params, env, sourceCodeInfo), k);
-		case "Module": {
-			const expression = env.getModule(fn.moduleName)?.functions[fn.functionName];
-			if (expression?.dvalaImpl) {
-				assertNumberOfParams(expression.arity, params.length, sourceCodeInfo);
-				return setupUserDefinedCall(expression.dvalaImpl, params, env, sourceCodeInfo, k);
-			}
-			return wrapMaybePromiseAsStep(executeDvalaFunctionRecursive(fn, params, env, sourceCodeInfo), k);
+		case "Constantly": return {
+			type: "Value",
+			value: fn.value,
+			k
+		};
+		case "EffectMatcher": {
+			assertNumberOfParams({
+				min: 1,
+				max: 1
+			}, params.length, fn.sourceCodeInfo ?? sourceCodeInfo);
+			const effectRef = params[0];
+			assertEffect(effectRef, sourceCodeInfo);
+			const effectName = effectRef.name;
+			if (fn.matchType === "string") return {
+				type: "Value",
+				value: effectNameMatchesPattern(effectName, fn.pattern),
+				k
+			};
+			return {
+				type: "Value",
+				value: new RegExp(fn.pattern, fn.flags).test(effectName),
+				k
+			};
 		}
-		case "Builtin": {
+		case "Partial": {
+			const actualParams = [...fn.params];
+			if (params.length !== fn.placeholders.length) throw new DvalaError(`(partial) expects ${fn.placeholders.length} arguments, got ${params.length}.`, sourceCodeInfo);
+			const paramsCopy = [...params];
+			for (const placeholderIndex of fn.placeholders) actualParams.splice(placeholderIndex, 0, paramsCopy.shift());
+			return dispatchFunction(fn.function, actualParams, [], env, sourceCodeInfo, k);
+		}
+		case "Fnull": {
+			const fnulledParams = params.map((param, index) => param === null ? toAny(fn.params[index]) : param);
+			return dispatchFunction(fn.function, fnulledParams, [], env, sourceCodeInfo, k);
+		}
+		case "Complement": {
+			const frame = {
+				type: "Complement",
+				sourceCodeInfo
+			};
+			return dispatchFunction(fn.function, params, [], env, sourceCodeInfo, [frame, ...k]);
+		}
+		case "Comp": {
+			const fns = fn.params;
+			if (fns.length === 0) {
+				if (params.length !== 1) throw new DvalaError(`(comp) expects one argument, got ${valueToString(params.length)}.`, sourceCodeInfo);
+				return {
+					type: "Value",
+					value: asAny(params[0], sourceCodeInfo),
+					k
+				};
+			}
+			const startIndex = fns.length - 1;
+			const frame = {
+				type: "Comp",
+				fns,
+				index: startIndex - 1,
+				env,
+				sourceCodeInfo
+			};
+			return dispatchFunction(asFunctionLike(fns[startIndex], sourceCodeInfo), params, [], env, sourceCodeInfo, [frame, ...k]);
+		}
+		case "Juxt": {
+			const fns = fn.params;
+			if (fns.length === 0) return {
+				type: "Value",
+				value: [],
+				k
+			};
+			const frame = {
+				type: "Juxt",
+				fns,
+				params,
+				index: 1,
+				results: [],
+				env,
+				sourceCodeInfo
+			};
+			return dispatchFunction(asFunctionLike(fns[0], sourceCodeInfo), params, [], env, sourceCodeInfo, [frame, ...k]);
+		}
+		case "EveryPred": {
+			const checks = [];
+			for (const f of fn.params) for (const p of params) checks.push({
+				fn: asFunctionLike(f, sourceCodeInfo),
+				param: p
+			});
+			if (checks.length === 0) return {
+				type: "Value",
+				value: true,
+				k
+			};
+			const frame = {
+				type: "EveryPred",
+				checks,
+				index: 1,
+				env,
+				sourceCodeInfo
+			};
+			const firstCheck = checks[0];
+			return dispatchFunction(firstCheck.fn, [firstCheck.param], [], env, sourceCodeInfo, [frame, ...k]);
+		}
+		case "SomePred": {
+			const checks = [];
+			for (const f of fn.params) for (const p of params) checks.push({
+				fn: asFunctionLike(f, sourceCodeInfo),
+				param: p
+			});
+			if (checks.length === 0) return {
+				type: "Value",
+				value: false,
+				k
+			};
+			const frame = {
+				type: "SomePred",
+				checks,
+				index: 1,
+				env,
+				sourceCodeInfo
+			};
+			const firstCheck = checks[0];
+			return dispatchFunction(firstCheck.fn, [firstCheck.param], [], env, sourceCodeInfo, [frame, ...k]);
+		}
+		case "SpecialBuiltin": {
+			const specialExpression = asNonUndefined(builtin.specialExpressions[fn.specialBuiltinSymbolType], sourceCodeInfo);
+			if (specialExpression.evaluateAsNormalExpression) return wrapMaybePromiseAsStep(specialExpression.evaluateAsNormalExpression(params, sourceCodeInfo, env), k);
+			throw new DvalaError(`Special builtin function ${fn.specialBuiltinSymbolType} is not supported as normal expression.`, sourceCodeInfo);
+		}
+		case "Module": {
+			const dvalaModule = env.getModule(fn.moduleName);
+			if (!dvalaModule) throw new DvalaError(`Module '${fn.moduleName}' not found.`, sourceCodeInfo);
+			const expression = dvalaModule.functions[fn.functionName];
+			if (!expression) throw new DvalaError(`Function '${fn.functionName}' not found in module '${fn.moduleName}'.`, sourceCodeInfo);
+			if (env.pure && expression.pure === false) throw new DvalaError(`Cannot call impure function '${fn.functionName}' in pure mode`, sourceCodeInfo);
+			assertNumberOfParams(expression.arity, params.length, sourceCodeInfo);
+			if (expression.dvalaImpl) return setupUserDefinedCall(expression.dvalaImpl, params, env, sourceCodeInfo, k);
+			return wrapMaybePromiseAsStep(expression.evaluate(params, sourceCodeInfo, env), k);
+		}
+		case "Builtin": {
 			const normalExpression = builtin.allNormalExpressions[fn.normalBuiltinSymbolType];
+			if (env.pure && normalExpression.pure === false) throw new DvalaError(`Cannot call impure function '${normalExpression.name}' in pure mode`, sourceCodeInfo);
 			if (normalExpression.dvalaImpl) return setupUserDefinedCall(normalExpression.dvalaImpl, params, env, sourceCodeInfo, k);
-			return wrapMaybePromiseAsStep(executeDvalaFunctionRecursive(fn, params, env, sourceCodeInfo), k);
+			return wrapMaybePromiseAsStep(normalExpression.evaluate(params, sourceCodeInfo, env), k);
 		}
 	}
 }
 /**
 * Set up a user-defined function call: bind params, push FnBodyFrame.
 *
-* For Phase 1, parameter binding (including destructuring defaults) is done
-* synchronously via evaluateBindingNodeValues with the recursive evaluator.
-* This will be converted to use frames in a later phase.
+* Uses frame-based binding slots for all argument binding, enabling
+* suspension/serialization at any point during destructuring.
 */
 function setupUserDefinedCall(fn, params, env, sourceCodeInfo, k) {
 	if (!arityAcceptsMin(fn.arity, params.length)) throw new DvalaError(`Expected ${fn.arity} arguments, got ${params.length}.`, sourceCodeInfo);
+	const nbrOfNonRestArgs = fn.evaluatedfunction[0].filter((arg) => arg[0] !== bindingTargetTypes.rest).length;
+	return continueArgSlotBinding(fn, params, 0, nbrOfNonRestArgs, { self: { value: fn } }, env, sourceCodeInfo, k);
+}
+/**
+* Continue binding function arguments using slot-based binding.
+* Handles provided args, defaults, rest, then proceeds to body.
+*/
+function continueArgSlotBinding(fn, params, argIndex, nbrOfNonRestArgs, context, outerEnv, sourceCodeInfo, k) {
 	const evaluatedFunc = fn.evaluatedfunction;
 	const args = evaluatedFunc[0];
-	const nbrOfNonRestArgs = args.filter((arg) => arg[0] !== bindingTargetTypes.rest).length;
-	const newContextStack = env.create(fn.evaluatedfunction[2]);
-	const newContext = { self: { value: fn } };
-	const rest = [];
-	for (let i = 0; i < params.length; i += 1) if (i < nbrOfNonRestArgs) {
-		const param = toAny(params[i]);
-		const valueRecord = evaluateBindingNodeValues(args[i], param, (n) => evaluateNodeRecursive(n, newContextStack.create(newContext)));
-		if (valueRecord instanceof Promise) return wrapMaybePromiseAsStep(executeUserDefinedRecursive(fn, params, env, sourceCodeInfo), k);
-		Object.entries(valueRecord).forEach(([key, value]) => {
-			newContext[key] = { value };
-		});
-	} else rest.push(toAny(params[i]));
-	for (let i = params.length; i < nbrOfNonRestArgs; i++) {
-		const arg = args[i];
-		const defaultValue = evaluateNodeRecursive(arg[1][1], newContextStack.create(newContext));
-		if (defaultValue instanceof Promise) return wrapMaybePromiseAsStep(executeUserDefinedRecursive(fn, params, env, sourceCodeInfo), k);
-		const valueRecord = evaluateBindingNodeValues(arg, defaultValue, (n) => evaluateNodeRecursive(n, newContextStack.create(newContext)));
-		if (valueRecord instanceof Promise) return wrapMaybePromiseAsStep(executeUserDefinedRecursive(fn, params, env, sourceCodeInfo), k);
-		Object.entries(valueRecord).forEach(([key, value]) => {
-			newContext[key] = { value };
-		});
+	const closureContext = evaluatedFunc[2];
+	const bindingEnv = outerEnv.create(closureContext).create(context);
+	if (argIndex < params.length && argIndex < nbrOfNonRestArgs) {
+		const param = toAny(params[argIndex]);
+		const argTarget = args[argIndex];
+		return startBindingSlots(argTarget, param, bindingEnv, sourceCodeInfo, [{
+			type: "FnArgSlotComplete",
+			fn,
+			params,
+			argIndex,
+			nbrOfNonRestArgs,
+			context,
+			outerEnv,
+			sourceCodeInfo
+		}, ...k]);
 	}
+	if (argIndex < nbrOfNonRestArgs) return continueBindingArgs(fn, params, argIndex, nbrOfNonRestArgs, context, outerEnv, sourceCodeInfo, k);
+	return handleRestArgAndBody(fn, params, nbrOfNonRestArgs, context, outerEnv, sourceCodeInfo, k);
+}
+/**
+* Handle rest argument binding and proceed to body evaluation.
+*/
+function handleRestArgAndBody(fn, params, nbrOfNonRestArgs, context, outerEnv, sourceCodeInfo, k) {
+	const evaluatedFunc = fn.evaluatedfunction;
+	const args = evaluatedFunc[0];
+	const closureContext = evaluatedFunc[2];
+	const bindingEnv = outerEnv.create(closureContext).create(context);
+	const rest = params.slice(nbrOfNonRestArgs).map(toAny);
 	const restArgument = args.find((arg) => arg[0] === bindingTargetTypes.rest);
-	if (restArgument) {
-		const valueRecord = evaluateBindingNodeValues(restArgument, rest, (n) => evaluateNodeRecursive(n, newContextStack.create(newContext)));
-		if (valueRecord instanceof Promise) return wrapMaybePromiseAsStep(executeUserDefinedRecursive(fn, params, env, sourceCodeInfo), k);
-		Object.entries(valueRecord).forEach(([key, value]) => {
-			newContext[key] = { value };
-		});
-	}
-	const bodyNodes = evaluatedFunc[1];
-	const bodyEnv = newContextStack.create(newContext);
+	if (restArgument) return startBindingSlots(restArgument, rest, bindingEnv, sourceCodeInfo, [{
+		type: "FnRestArgComplete",
+		fn,
+		context,
+		outerEnv,
+		sourceCodeInfo
+	}, ...k]);
+	return proceedToFnBody(fn, context, outerEnv, sourceCodeInfo, k);
+}
+/**
+* Start evaluating function body.
+*/
+function proceedToFnBody(fn, context, outerEnv, sourceCodeInfo, k) {
+	const closureContext = fn.evaluatedfunction[2];
+	const bodyEnv = outerEnv.create(closureContext).create(context);
+	const bodyNodes = fn.evaluatedfunction[1];
 	if (bodyNodes.length === 0) return {
 		type: "Value",
 		value: null,
@@ -29479,15 +29226,9 @@ function setupUserDefinedCall(fn, params, env, sourceCodeInfo, k) {
 		fn,
 		bodyIndex: 1,
 		env: bodyEnv,
-		outerEnv: env,
+		outerEnv,
 		sourceCodeInfo
 	};
-	if (bodyNodes.length === 1) return {
-		type: "Eval",
-		node: bodyNodes[0],
-		env: bodyEnv,
-		k: [fnBodyFrame, ...k]
-	};
 	return {
 		type: "Eval",
 		node: bodyNodes[0],
@@ -29511,10 +29252,15 @@ function applyFrame(frame, value, k) {
 		case "ArrayBuild": return applyArrayBuild(frame, value, k);
 		case "ObjectBuild": return applyObjectBuild(frame, value, k);
 		case "LetBind": return applyLetBind(frame, value, k);
+		case "LetBindComplete": return applyLetBindComplete(frame, value, k);
 		case "LoopBind": return applyLoopBind(frame, value, k);
+		case "LoopBindComplete": return applyLoopBindComplete(frame, value, k);
 		case "LoopIterate": return applyLoopIterate(frame, value, k);
 		case "ForLoop": return applyForLoop(frame, value, k);
+		case "ForElementBindComplete": return applyForElementBindComplete(frame, value, k);
+		case "ForLetBind": return applyForLetBind(frame, value, k);
 		case "Recur": return applyRecur(frame, value, k);
+		case "RecurLoopRebind": return applyRecurLoopRebind(frame, value, k);
 		case "PerformArgs": return applyPerformArgs(frame, value, k);
 		case "TryWith": return applyTryWith(value, k);
 		case "EffectResume": return applyEffectResume(frame, value, k);
@@ -29522,7 +29268,22 @@ function applyFrame(frame, value, k) {
 		case "EvalArgs": return applyEvalArgs(frame, value, k);
 		case "CallFn": return applyCallFn(frame, value, k);
 		case "FnBody": return applyFnBody(frame, value, k);
-		case "BindingDefault": return applyBindingDefault(frame, value, k);
+		case "FnArgBind": return applyFnArgBind(frame, value, k);
+		case "FnArgSlotComplete": return applyFnArgSlotComplete(frame, value, k);
+		case "FnRestArgComplete": return applyFnRestArgComplete(frame, value, k);
+		case "BindingSlot": return applyBindingSlot(frame, value, k);
+		case "MatchSlot": return applyMatchSlot(frame, value, k);
+		case "EffectRef": return applyEffectRef(frame, value, k);
+		case "HandlerInvoke": return applyHandlerInvoke(frame, value, k);
+		case "Complement": return {
+			type: "Value",
+			value: !value,
+			k
+		};
+		case "Comp": return applyComp(frame, value, k);
+		case "Juxt": return applyJuxt(frame, value, k);
+		case "EveryPred": return applyEveryPred(frame, value, k);
+		case "SomePred": return applySomePred(frame, value, k);
 		case "NanCheck": return applyNanCheck(frame, value, k);
 		case "DebugStep": return applyDebugStep(frame, value, k);
 		case "ImportMerge": {
@@ -29658,44 +29419,17 @@ function applyMatch(frame, value, k) {
 }
 /**
 * Process match cases starting from `frame.index`.
-* Uses recursive tryMatch with evaluateNodeRecursive for pattern matching.
+* Uses frame-based slot processing for pattern matching.
 */
 function processMatchCase(frame, k) {
 	const { matchValue, cases, index, env, sourceCodeInfo } = frame;
-	for (let i = index; i < cases.length; i++) {
-		const [pattern, body, guard] = cases[i];
-		const bindings = tryMatch(pattern, matchValue, (n) => evaluateNodeRecursive(n, env));
-		if (bindings instanceof Promise) throw new DvalaError("Async pattern matching not supported in trampoline yet", sourceCodeInfo);
-		if (bindings === null) continue;
-		if (guard) {
-			const context = {};
-			for (const [name, val] of Object.entries(bindings)) context[name] = { value: val };
-			return {
-				type: "Eval",
-				node: guard,
-				env: env.create(context),
-				k: [{
-					...frame,
-					phase: "guard",
-					index: i,
-					bindings
-				}, ...k]
-			};
-		}
-		const context = {};
-		for (const [name, val] of Object.entries(bindings)) context[name] = { value: val };
-		return {
-			type: "Eval",
-			node: body,
-			env: env.create(context),
-			k
-		};
-	}
-	return {
+	if (index >= cases.length) return {
 		type: "Value",
 		value: null,
 		k
 	};
+	const [pattern] = cases[index];
+	return startMatchSlots(pattern, matchValue, frame, env, sourceCodeInfo, k);
 }
 function applyAnd(frame, value, k) {
 	if (!value) return {
@@ -29892,50 +29626,74 @@ function applyObjectBuild(frame, value, k) {
 }
 function applyLetBind(frame, value, k) {
 	const { target, env, sourceCodeInfo } = frame;
-	return chain(evaluateBindingNodeValues(target, value, (n) => evaluateNodeRecursive(n, env)), (br) => {
-		env.addValues(br, sourceCodeInfo);
-		return {
-			type: "Value",
-			value,
-			k
-		};
-	});
+	return startBindingSlots(target, value, env, sourceCodeInfo, [{
+		type: "LetBindComplete",
+		originalValue: value,
+		env,
+		sourceCodeInfo
+	}, ...k]);
+}
+function applyLetBindComplete(frame, record, k) {
+	const { originalValue, env, sourceCodeInfo } = frame;
+	env.addValues(record, sourceCodeInfo);
+	return {
+		type: "Value",
+		value: originalValue,
+		k
+	};
 }
 function applyLoopBind(frame, value, k) {
 	const { bindingNodes, index, context, body, env, sourceCodeInfo } = frame;
 	const target = bindingNodes[index][1][0];
-	return chain(evaluateBindingNodeValues(target, value, (n) => evaluateNodeRecursive(n, env.create(context))), (vr) => {
-		Object.entries(vr).forEach(([name, val]) => {
-			context[name] = { value: val };
-		});
-		const nextIndex = index + 1;
-		if (nextIndex >= bindingNodes.length) {
-			const loopEnv = env.create(context);
-			return {
-				type: "Eval",
-				node: body,
-				env: loopEnv,
-				k: [{
-					type: "LoopIterate",
-					bindingNodes,
-					bindingContext: context,
-					body,
-					env: loopEnv,
-					sourceCodeInfo
-				}, ...k]
-			};
-		}
-		const newFrame = {
-			...frame,
-			index: nextIndex
-		};
+	const completeFrame = {
+		type: "LoopBindComplete",
+		bindingNodes,
+		index,
+		context,
+		body,
+		env,
+		sourceCodeInfo
+	};
+	return startBindingSlots(target, value, env.create(context), sourceCodeInfo, [completeFrame, ...k]);
+}
+function applyLoopBindComplete(frame, record, k) {
+	const { bindingNodes, index, context, body, env, sourceCodeInfo } = frame;
+	Object.entries(record).forEach(([name, val]) => {
+		context[name] = { value: val };
+	});
+	const nextIndex = index + 1;
+	if (nextIndex >= bindingNodes.length) {
+		const loopEnv = env.create(context);
 		return {
 			type: "Eval",
-			node: bindingNodes[nextIndex][1][1],
-			env: env.create(context),
-			k: [newFrame, ...k]
+			node: body,
+			env: loopEnv,
+			k: [{
+				type: "LoopIterate",
+				bindingNodes,
+				bindingContext: context,
+				body,
+				env: loopEnv,
+				sourceCodeInfo
+			}, ...k]
 		};
-	});
+	}
+	const newFrame = {
+		type: "LoopBind",
+		phase: "value",
+		bindingNodes,
+		index: nextIndex,
+		context,
+		body,
+		env,
+		sourceCodeInfo
+	};
+	return {
+		type: "Eval",
+		node: bindingNodes[nextIndex][1][1],
+		env: env.create(context),
+		k: [newFrame, ...k]
+	};
 }
 function applyLoopIterate(_frame, value, k) {
 	return {
@@ -29945,7 +29703,7 @@ function applyLoopIterate(_frame, value, k) {
 	};
 }
 function applyForLoop(frame, value, k) {
-	const { returnResult, bindingNodes, result, env, sourceCodeInfo, context } = frame;
+	const { returnResult, bindingNodes, result, env, sourceCodeInfo } = frame;
 	const { asColl, isSeq } = getCollectionUtils();
 	switch (frame.phase) {
 		case "evalCollection": {
@@ -29957,21 +29715,19 @@ function applyForLoop(frame, value, k) {
 				collection: seq,
 				index: 0
 			};
-			const binding = bindingNodes[frame.bindingLevel];
-			const targetNode = binding[0][1][0];
+			const targetNode = bindingNodes[frame.bindingLevel][0][1][0];
 			const element = seq[0];
-			return chain(evaluateBindingNodeValues(targetNode, asAny(element, sourceCodeInfo), (n) => evaluateNodeRecursive(n, env)), (vr) => {
-				Object.entries(vr).forEach(([name, val]) => {
-					context[name] = { value: val };
-				});
-				const letBindings = binding[1];
-				if (letBindings.length > 0) return processForLetBindings(frame, levelStates, letBindings, 0, k);
-				return processForGuards(frame, levelStates, k);
-			});
+			return startBindingSlots(targetNode, asAny(element, sourceCodeInfo), env, sourceCodeInfo, [{
+				type: "ForElementBindComplete",
+				forFrame: {
+					...frame,
+					levelStates
+				},
+				levelStates,
+				env,
+				sourceCodeInfo
+			}, ...k]);
 		}
-		case "evalLet":
- /* v8 ignore next 1 */
-		throw new DvalaError("ForLoop evalLet should not reach applyFrame", sourceCodeInfo);
 		case "evalWhen": {
 			if (!value) return advanceForElement(frame, k);
 			const whileNode = bindingNodes[frame.bindingLevel][3];
@@ -30002,14 +29758,7 @@ function applyForLoop(frame, value, k) {
 		case "evalBody":
 			if (returnResult) result.push(value);
 			return advanceForElement(frame, k);
-		case "evalElement": throw new DvalaError(`Unexpected ForLoop phase: ${frame.phase}`, sourceCodeInfo);
 	}
-	/* v8 ignore next 1 */
-	return {
-		type: "Value",
-		value: null,
-		k
-	};
 }
 /** Handle for-loop abort: no more elements at the outermost level. */
 function handleForAbort(frame, k) {
@@ -30021,7 +29770,7 @@ function handleForAbort(frame, k) {
 }
 /** Advance to the next element at the current binding level. */
 function advanceForElement(frame, k) {
-	const { bindingNodes, env, sourceCodeInfo, context } = frame;
+	const { bindingNodes, env, sourceCodeInfo } = frame;
 	const levelStates = [...frame.levelStates];
 	const currentLevel = frame.bindingLevel;
 	const currentState = levelStates[currentLevel];
@@ -30037,47 +29786,71 @@ function advanceForElement(frame, k) {
 		...currentState,
 		index: nextElementIndex
 	};
-	const binding = bindingNodes[currentLevel];
-	const targetNode = binding[0][1][0];
+	const targetNode = bindingNodes[currentLevel][0][1][0];
 	const element = currentState.collection[nextElementIndex];
-	return chain(evaluateBindingNodeValues(targetNode, asAny(element, sourceCodeInfo), (n) => evaluateNodeRecursive(n, env)), (vr) => {
-		Object.entries(vr).forEach(([name, val]) => {
-			context[name] = { value: val };
-		});
-		const letBindings = binding[1];
-		if (letBindings.length > 0) return processForLetBindings({
+	return startBindingSlots(targetNode, asAny(element, sourceCodeInfo), env, sourceCodeInfo, [{
+		type: "ForElementBindComplete",
+		forFrame: {
 			...frame,
 			levelStates,
 			bindingLevel: currentLevel
-		}, levelStates, letBindings, 0, k);
-		return processForGuards({
-			...frame,
-			levelStates,
-			bindingLevel: currentLevel
-		}, levelStates, k);
+		},
+		levelStates,
+		env,
+		sourceCodeInfo
+	}, ...k]);
+}
+/** Handle completion of for-loop element binding. */
+function applyForElementBindComplete(frame, record, k) {
+	const { forFrame, levelStates, env, sourceCodeInfo } = frame;
+	Object.entries(record).forEach(([name, val]) => {
+		forFrame.context[name] = { value: val };
 	});
+	const letBindings = forFrame.bindingNodes[forFrame.bindingLevel][1];
+	if (letBindings.length > 0) return startForLetBindings(forFrame, levelStates, letBindings, 0, env, sourceCodeInfo, k);
+	return processForGuards(forFrame, levelStates, k);
 }
-/** Process let-bindings at the current for-loop level. */
-function processForLetBindings(frame, levelStates, letBindings, letIndex, k) {
-	const { env, context } = frame;
-	let result = void 0;
-	for (let i = letIndex; i < letBindings.length; i++) {
-		const bindingIndex = i;
-		result = chain(result, () => {
-			const [target, bindingValue] = letBindings[bindingIndex][1];
-			return chain(evaluateNodeRecursive(bindingValue, env), (v) => {
-				return chain(evaluateBindingNodeValues(target, v, (n) => evaluateNodeRecursive(n, env)), (vr) => {
-					Object.entries(vr).forEach(([name, value]) => {
-						context[name] = { value };
-					});
-				});
-			});
-		});
+/** Start processing let-bindings at the current for-loop level. */
+function startForLetBindings(forFrame, levelStates, letBindings, letIndex, env, sourceCodeInfo, k) {
+	return {
+		type: "Eval",
+		node: letBindings[letIndex][1][1],
+		env,
+		k: [{
+			type: "ForLetBind",
+			phase: "evalValue",
+			forFrame,
+			levelStates,
+			letBindings,
+			letIndex,
+			env,
+			sourceCodeInfo
+		}, ...k]
+	};
+}
+/** Handle continuation after evaluating a for-loop let-binding value or destructuring. */
+function applyForLetBind(frame, value, k) {
+	const { phase, forFrame, levelStates, letBindings, letIndex, env, sourceCodeInfo } = frame;
+	if (phase === "evalValue") {
+		const target = letBindings[letIndex][1][0];
+		return startBindingSlots(target, value, env, sourceCodeInfo, [{
+			type: "ForLetBind",
+			phase: "destructure",
+			forFrame,
+			levelStates,
+			letBindings,
+			letIndex,
+			currentValue: value,
+			env,
+			sourceCodeInfo
+		}, ...k]);
 	}
-	return chain(result, () => processForGuards({
-		...frame,
-		levelStates
-	}, levelStates, k));
+	Object.entries(value).forEach(([name, val]) => {
+		forFrame.context[name] = { value: val };
+	});
+	const nextIndex = letIndex + 1;
+	if (nextIndex >= letBindings.length) return processForGuards(forFrame, levelStates, k);
+	return startForLetBindings(forFrame, levelStates, letBindings, nextIndex, env, sourceCodeInfo, k);
 }
 /** Process when/while guards at the current level. */
 function processForGuards(frame, levelStates, k) {
@@ -30182,8 +29955,7 @@ function applyRecur(frame, value, k) {
 /**
 * Handle recur by searching the continuation stack for the nearest
 * LoopIterateFrame or FnBodyFrame, rebinding parameters, and restarting.
-* This replaces the exception-based RecurSignal approach from the recursive
-* evaluator with proper continuation-based control flow.
+* Uses frame-based slot binding for proper suspension support.
 */
 function handleRecur(params, k, sourceCodeInfo) {
 	for (let i = 0; i < k.length; i++) {
@@ -30192,30 +29964,7 @@ function handleRecur(params, k, sourceCodeInfo) {
 			const { bindingNodes, bindingContext, body, env } = frame;
 			const remainingK = k.slice(i + 1);
 			if (params.length !== bindingNodes.length) throw new DvalaError(`recur expected ${bindingNodes.length} parameters, got ${params.length}`, sourceCodeInfo);
-			return chain(forEachSequential(bindingNodes, (bindingNode, j) => {
-				const target = bindingNode[1][0];
-				return chain(evaluateBindingNodeValues(target, toAny(params[j]), (n) => evaluateNodeRecursive(n, env)), (valueRecord) => {
-					Object.entries(valueRecord).forEach(([name, val]) => {
-						bindingContext[name] = { value: val };
-					});
-				});
-			}), () => {
-				const innermostContext = env.getContextsRaw()[0];
-				if (innermostContext !== bindingContext) for (const [name, entry] of Object.entries(bindingContext)) innermostContext[name] = entry;
-				return {
-					type: "Eval",
-					node: body,
-					env,
-					k: [{
-						type: "LoopIterate",
-						bindingNodes,
-						bindingContext,
-						body,
-						env,
-						sourceCodeInfo: frame.sourceCodeInfo
-					}, ...remainingK]
-				};
-			});
+			return startRecurLoopRebind(bindingNodes, 0, params, bindingContext, body, env, remainingK, sourceCodeInfo);
 		}
 		if (frame.type === "FnBody") {
 			const { fn, outerEnv } = frame;
@@ -30225,6 +29974,51 @@ function handleRecur(params, k, sourceCodeInfo) {
 	}
 	throw new DvalaError("recur called outside of loop or function body", sourceCodeInfo);
 }
+/**
+* Start rebinding loop variables during recur using slot-based binding.
+*/
+function startRecurLoopRebind(bindingNodes, bindingIndex, params, bindingContext, body, env, remainingK, sourceCodeInfo) {
+	if (bindingIndex >= bindingNodes.length) {
+		const innermostContext = env.getContextsRaw()[0];
+		if (innermostContext !== bindingContext) for (const [name, entry] of Object.entries(bindingContext)) innermostContext[name] = entry;
+		return {
+			type: "Eval",
+			node: body,
+			env,
+			k: [{
+				type: "LoopIterate",
+				bindingNodes,
+				bindingContext,
+				body,
+				env,
+				sourceCodeInfo
+			}, ...remainingK]
+		};
+	}
+	const target = bindingNodes[bindingIndex][1][0];
+	return startBindingSlots(target, toAny(params[bindingIndex]), env, sourceCodeInfo, [{
+		type: "RecurLoopRebind",
+		bindingNodes,
+		bindingIndex,
+		params,
+		bindingContext,
+		body,
+		env,
+		remainingK,
+		sourceCodeInfo
+	}, ...remainingK]);
+}
+/**
+* Handle completion of one loop binding during recur rebinding.
+*/
+function applyRecurLoopRebind(frame, value, _k) {
+	const { bindingNodes, bindingIndex, params, bindingContext, body, env, remainingK, sourceCodeInfo } = frame;
+	const record = value;
+	Object.entries(record).forEach(([name, val]) => {
+		bindingContext[name] = { value: val };
+	});
+	return startRecurLoopRebind(bindingNodes, bindingIndex + 1, params, bindingContext, body, env, remainingK, sourceCodeInfo);
+}
 function applyTryWith(_value, k) {
 	return {
 		type: "Value",
@@ -30262,6 +30056,7 @@ function applyPerformArgs(frame, value, k) {
 	if (index >= argNodes.length) {
 		const effectRef = params[0];
 		assertEffect(effectRef, frame.sourceCodeInfo);
+		if (env.pure) throw new DvalaError(`Cannot perform effect '${effectRef.name}' in pure mode`, frame.sourceCodeInfo);
 		return {
 			type: "Perform",
 			effect: effectRef,
@@ -30312,9 +30107,9 @@ function applyPerformArgs(frame, value, k) {
 function handlerMatchesEffect(handler, effect, env, sourceCodeInfo) {
 	if (isEffect(handler.effectRef)) return handler.effectRef.name === effect.name;
 	if (isDvalaFunction(handler.effectRef)) {
-		const result = executeFunctionRecursive(handler.effectRef, [effect], env, sourceCodeInfo);
-		if (result instanceof Promise) throw new DvalaError("Effect handler predicates must be synchronous", sourceCodeInfo);
-		return !!result;
+		const step = dispatchFunction(handler.effectRef, [effect], [], env, sourceCodeInfo, []);
+		if (step instanceof Promise) throw new DvalaError("Effect handler predicates must be synchronous", sourceCodeInfo);
+		return !!runSyncTrampoline(step);
 	}
 	return false;
 }
@@ -30325,12 +30120,23 @@ function handlerMatchesEffect(handler, effect, env, sourceCodeInfo) {
 function invokeMatchedHandler(handler, frame, args, k, frameIndex, sourceCodeInfo) {
 	const resumeK = k;
 	const outerK = k.slice(frameIndex + 1);
-	const handlerK = [{
-		type: "EffectResume",
-		resumeK,
+	const handlerInvokeFrame = {
+		type: "HandlerInvoke",
+		args,
+		handlerK: [{
+			type: "EffectResume",
+			resumeK,
+			sourceCodeInfo
+		}, ...outerK],
+		handlerEnv: frame.env,
 		sourceCodeInfo
-	}, ...outerK];
-	return dispatchFunction(asFunctionLike(evaluateNodeRecursive(handler.handlerNode, frame.env), frame.sourceCodeInfo), [args], [], frame.env, sourceCodeInfo, handlerK);
+	};
+	return {
+		type: "Eval",
+		node: handler.handlerNode,
+		env: frame.env,
+		k: [handlerInvokeFrame, ...outerK]
+	};
 }
 function dispatchPerform(effect, args, k, sourceCodeInfo, handlers, signal, snapshotState) {
 	const standardDef = getStandardEffectDefinition(effect.name);
@@ -30338,14 +30144,14 @@ function dispatchPerform(effect, args, k, sourceCodeInfo, handlers, signal, snap
 	if (effect.name === "dvala.checkpoint" && snapshotState) {
 		const message = args[0];
 		const meta = args[1];
-		const snapshot = {
+		const snapshot = createSnapshot({
 			continuation: serializeToObject(k),
 			timestamp: Date.now(),
 			index: snapshotState.nextSnapshotIndex++,
-			runId: snapshotState.runId,
+			executionId: snapshotState.executionId,
 			message,
 			...meta !== void 0 ? { meta } : {}
-		};
+		});
 		snapshotState.snapshots.push(snapshot);
 		if (snapshotState.maxSnapshots !== void 0 && snapshotState.snapshots.length > snapshotState.maxSnapshots) snapshotState.snapshots.shift();
 	}
@@ -30495,14 +30301,14 @@ function dispatchHostHandler(effectName, matchingHandlers, args, k, signal, sour
 			},
 			checkpoint: (message, meta) => {
 				if (!snapshotState) throw new DvalaError("checkpoint is not available outside effect-enabled execution", sourceCodeInfo);
-				const snapshot = {
+				const snapshot = createSnapshot({
 					continuation: serializeToObject(k),
 					timestamp: Date.now(),
 					index: snapshotState.nextSnapshotIndex++,
-					runId: snapshotState.runId,
+					executionId: snapshotState.executionId,
 					message,
 					...meta !== void 0 ? { meta } : {}
-				};
+				});
 				snapshotState.snapshots.push(snapshot);
 				if (snapshotState.maxSnapshots !== void 0 && snapshotState.snapshots.length > snapshotState.maxSnapshots) snapshotState.snapshots.shift();
 				return snapshot;
@@ -30510,7 +30316,7 @@ function dispatchHostHandler(effectName, matchingHandlers, args, k, signal, sour
 			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);
+				const found = snapshotState.snapshots.find((s) => s.index === snapshot.index && s.executionId === snapshot.executionId);
 				if (!found) throw new DvalaError(`Invalid snapshot: no snapshot with index ${snapshot.index} found in current run`, sourceCodeInfo);
 				settled = true;
 				outcome = {
@@ -30818,16 +30624,492 @@ function applyFnBody(frame, value, k) {
 		k: [newFrame, ...k]
 	};
 }
-function applyBindingDefault(frame, value, k) {
-	const { target, record, env, sourceCodeInfo } = frame;
-	const valueRecord = evaluateBindingNodeValues(target, value, (n) => evaluateNodeRecursive(n, env));
-	if (valueRecord instanceof Promise) throw new DvalaError("Async binding default evaluation not supported in trampoline yet", sourceCodeInfo);
-	Object.assign(record, valueRecord);
+/**
+* Handle function argument binding after a default value is evaluated.
+* Binds the value to the current argument using slots, then continues with remaining args.
+*/
+function applyFnArgBind(frame, value, k) {
+	const { fn, params, argIndex, context, outerEnv, sourceCodeInfo } = frame;
+	const evaluatedFunc = fn.evaluatedfunction;
+	const args = evaluatedFunc[0];
+	const nbrOfNonRestArgs = args.filter((arg) => arg[0] !== bindingTargetTypes.rest).length;
+	const arg = args[argIndex];
+	const closureContext = evaluatedFunc[2];
+	return startBindingSlots(arg, value, outerEnv.create(closureContext).create(context), sourceCodeInfo, [{
+		type: "FnArgSlotComplete",
+		fn,
+		params,
+		argIndex,
+		nbrOfNonRestArgs,
+		context,
+		outerEnv,
+		sourceCodeInfo
+	}, ...k]);
+}
+/**
+* Handle completion of slot-based binding for a function argument.
+* Merges the binding record into context and continues with next arg.
+*/
+function applyFnArgSlotComplete(frame, value, k) {
+	const { fn, params, argIndex, nbrOfNonRestArgs, context, outerEnv, sourceCodeInfo } = frame;
+	const record = value;
+	Object.entries(record).forEach(([key, val]) => {
+		context[key] = { value: val };
+	});
+	return continueArgSlotBinding(fn, params, argIndex + 1, nbrOfNonRestArgs, context, outerEnv, sourceCodeInfo, k);
+}
+/**
+* Handle completion of rest argument slot-based binding.
+* Merges bindings into context and proceeds to body evaluation.
+*/
+function applyFnRestArgComplete(frame, value, k) {
+	const { fn, context, outerEnv, sourceCodeInfo } = frame;
+	const record = value;
+	Object.entries(record).forEach(([key, val]) => {
+		context[key] = { value: val };
+	});
+	return proceedToFnBody(fn, context, outerEnv, sourceCodeInfo, k);
+}
+/**
+* Continue binding function arguments starting from argIndex.
+* Handles only the default evaluation phase - rest handling moved to handleRestArgAndBody.
+*/
+function continueBindingArgs(fn, params, argIndex, nbrOfNonRestArgs, context, outerEnv, sourceCodeInfo, k) {
+	const evaluatedFunc = fn.evaluatedfunction;
+	const args = evaluatedFunc[0];
+	const closureContext = evaluatedFunc[2];
+	const bindingEnv = outerEnv.create(closureContext).create(context);
+	for (let i = argIndex; i < nbrOfNonRestArgs; i++) {
+		const defaultNode = args[i][1][1];
+		if (!defaultNode) throw new DvalaError(`Missing required argument ${i}`, sourceCodeInfo);
+		return {
+			type: "Eval",
+			node: defaultNode,
+			env: bindingEnv,
+			k: [{
+				type: "FnArgBind",
+				phase: "default",
+				fn,
+				params,
+				argIndex: i,
+				context,
+				outerEnv,
+				sourceCodeInfo
+			}, ...k]
+		};
+	}
+	return handleRestArgAndBody(fn, params, nbrOfNonRestArgs, context, outerEnv, sourceCodeInfo, k);
+}
+/**
+* Start processing a binding pattern using linearized slots.
+* This is the entry point for frame-based destructuring.
+* @internal Exported for testing/incremental migration
+*/
+function startBindingSlots(target, rootValue, env, sourceCodeInfo, k) {
+	validateBindingRootType(target, rootValue, sourceCodeInfo);
+	return continueBindingSlots([{
+		slots: flattenBindingPattern(target),
+		index: 0,
+		rootValue
+	}], {}, env, sourceCodeInfo, k);
+}
+/**
+* Continue processing binding slots using the context stack.
+* Handles extracting values, evaluating defaults, and nested binding targets.
+*/
+function continueBindingSlots(contexts, record, env, sourceCodeInfo, k) {
+	while (contexts.length > 0) {
+		const ctx = contexts[contexts.length - 1];
+		if (ctx.index >= ctx.slots.length) {
+			contexts.pop();
+			continue;
+		}
+		const slot = ctx.slots[ctx.index];
+		if (slot.isRest) {
+			if (slot.restKeys !== void 0) {
+				const parentValue = slot.path.length > 0 ? extractValueByPath(ctx.rootValue, slot.path, sourceCodeInfo) ?? null : ctx.rootValue;
+				record[slot.name] = extractObjectRest(parentValue, slot.restKeys, sourceCodeInfo);
+			} else if (slot.restIndex !== void 0) {
+				const parentValue = slot.path.length > 0 ? extractValueByPath(ctx.rootValue, slot.path, sourceCodeInfo) ?? null : ctx.rootValue;
+				record[slot.name] = extractArrayRest(parentValue, slot.restIndex, sourceCodeInfo);
+			} else {
+				const value = slot.path.length > 0 ? extractValueByPath(ctx.rootValue, slot.path, sourceCodeInfo) ?? null : ctx.rootValue;
+				record[slot.name] = value;
+			}
+			ctx.index++;
+			continue;
+		}
+		const value = extractValueByPath(ctx.rootValue, slot.path, sourceCodeInfo);
+		if (value === void 0 && slot.defaultNode) {
+			const frame = {
+				type: "BindingSlot",
+				contexts: contexts.map((c) => ({ ...c })),
+				record,
+				env,
+				sourceCodeInfo
+			};
+			return {
+				type: "Eval",
+				node: slot.defaultNode,
+				env,
+				k: [frame, ...k]
+			};
+		}
+		const resolvedValue = value ?? null;
+		if (slot.nestedTarget) {
+			const nestedSlots = flattenBindingPatternWithoutDefault(slot.nestedTarget);
+			validateBindingRootType(slot.nestedTarget, resolvedValue, slot.sourceCodeInfo);
+			contexts.push({
+				slots: nestedSlots,
+				index: 0,
+				rootValue: resolvedValue
+			});
+			ctx.index++;
+			continue;
+		}
+		record[slot.name] = resolvedValue;
+		ctx.index++;
+	}
 	return {
 		type: "Value",
-		value,
+		value: record,
+		k
+	};
+}
+/**
+* Flatten a binding pattern without using its top-level default.
+* Used when we've already resolved the default and need to process the nested structure.
+*/
+function flattenBindingPatternWithoutDefault(target) {
+	return flattenBindingPattern([
+		target[0],
+		[target[1][0], void 0],
+		target[2]
+	]);
+}
+/**
+* Handle continuation after evaluating a binding slot's default value.
+*/
+function applyBindingSlot(frame, value, k) {
+	const { contexts, record, env, sourceCodeInfo } = frame;
+	const ctx = contexts[contexts.length - 1];
+	const slot = ctx.slots[ctx.index];
+	const resolvedValue = value ?? null;
+	if (slot.nestedTarget) {
+		const nestedSlots = flattenBindingPatternWithoutDefault(slot.nestedTarget);
+		validateBindingRootType(slot.nestedTarget, resolvedValue, slot.sourceCodeInfo);
+		contexts.push({
+			slots: nestedSlots,
+			index: 0,
+			rootValue: resolvedValue
+		});
+		ctx.index++;
+	} else {
+		record[slot.name] = resolvedValue;
+		ctx.index++;
+	}
+	return continueBindingSlots(contexts, record, env, sourceCodeInfo, k);
+}
+/**
+* Start pattern matching with slot-based processing.
+* Returns Step to continue matching, or moves to next case on failure.
+*/
+function startMatchSlots(pattern, matchValue, matchFrame, env, sourceCodeInfo, k) {
+	if (!checkObjectTypeConstraint(pattern, matchValue)) return tryNextMatchCase(matchFrame, k);
+	if (!checkArrayLengthConstraint(pattern, matchValue)) return tryNextMatchCase(matchFrame, k);
+	const slots = flattenMatchPattern(pattern);
+	if (slots.length === 0) return matchSucceeded({}, matchFrame, k);
+	return continueMatchSlots([{
+		slots,
+		index: 0,
+		rootValue: matchValue
+	}], {}, matchFrame, env, sourceCodeInfo, k);
+}
+/**
+* Continue processing match slots.
+* Returns Step for next action (eval, success, or try next case).
+*/
+function continueMatchSlots(contexts, record, matchFrame, env, sourceCodeInfo, k) {
+	while (contexts.length > 0) {
+		const ctx = contexts[contexts.length - 1];
+		if (ctx.index >= ctx.slots.length) {
+			contexts.pop();
+			continue;
+		}
+		const slot = ctx.slots[ctx.index];
+		switch (slot.kind) {
+			case "wildcard":
+				ctx.index++;
+				continue;
+			case "typeCheck":
+				if (!slot.requiredType || !checkTypeAtPath(ctx.rootValue, slot.path, slot.requiredType)) return tryNextMatchCase(matchFrame, k);
+				ctx.index++;
+				continue;
+			case "literal": {
+				const frame = {
+					type: "MatchSlot",
+					contexts: contexts.map((c) => ({ ...c })),
+					record: { ...record },
+					matchFrame,
+					phase: "literal",
+					currentSlot: slot,
+					env,
+					sourceCodeInfo
+				};
+				return {
+					type: "Eval",
+					node: slot.literalNode,
+					env,
+					k: [frame, ...k]
+				};
+			}
+			case "rest":
+				if (slot.restKeys !== void 0) record[slot.name] = extractMatchObjectRest(ctx.rootValue, slot.path, slot.restKeys);
+				else if (slot.restIndex !== void 0) record[slot.name] = extractMatchArrayRest(ctx.rootValue, slot.path, slot.restIndex);
+				else {
+					const value = slot.path.length > 0 ? extractMatchValueByPath(ctx.rootValue, slot.path) ?? null : ctx.rootValue;
+					record[slot.name] = value;
+				}
+				ctx.index++;
+				continue;
+			case "bind": {
+				const value = extractMatchValueByPath(ctx.rootValue, slot.path);
+				if (value === void 0 || value === null) {
+					if (slot.defaultNode) {
+						const frame = {
+							type: "MatchSlot",
+							contexts: contexts.map((c) => ({ ...c })),
+							record: { ...record },
+							matchFrame,
+							phase: "default",
+							currentSlot: slot,
+							env,
+							sourceCodeInfo
+						};
+						return {
+							type: "Eval",
+							node: slot.defaultNode,
+							env,
+							k: [frame, ...k]
+						};
+					}
+					record[slot.name] = value ?? null;
+				} else record[slot.name] = value;
+				ctx.index++;
+				continue;
+			}
+		}
+	}
+	return matchSucceeded(record, matchFrame, k);
+}
+/**
+* Handle continuation after evaluating a match slot value.
+*/
+function applyMatchSlot(frame, value, k) {
+	const { contexts, record, matchFrame, phase, currentSlot, env, sourceCodeInfo } = frame;
+	const ctx = contexts[contexts.length - 1];
+	if (phase === "literal") {
+		if (!deepEqual$1(extractMatchValueByPath(ctx.rootValue, currentSlot.path), value)) return tryNextMatchCase(matchFrame, k);
+		ctx.index++;
+	} else {
+		record[currentSlot.name] = value ?? null;
+		ctx.index++;
+	}
+	return continueMatchSlots(contexts, record, matchFrame, env, sourceCodeInfo, k);
+}
+/**
+* Pattern matching succeeded — proceed to guard or body.
+*/
+function matchSucceeded(bindings, matchFrame, k) {
+	const { cases, index, env } = matchFrame;
+	const [, body, guard] = cases[index];
+	const context = {};
+	for (const [name, val] of Object.entries(bindings)) context[name] = { value: val };
+	if (guard) return {
+		type: "Eval",
+		node: guard,
+		env: env.create(context),
+		k: [{
+			...matchFrame,
+			phase: "guard",
+			bindings
+		}, ...k]
+	};
+	return {
+		type: "Eval",
+		node: body,
+		env: env.create(context),
+		k
+	};
+}
+/**
+* Current pattern didn't match — try next case.
+*/
+function tryNextMatchCase(matchFrame, k) {
+	return processMatchCase({
+		...matchFrame,
+		index: matchFrame.index + 1
+	}, k);
+}
+/**
+* Handles continuation after evaluating an effect reference expression.
+* Stores the evaluated ref, then either evaluates the next ref or starts the body.
+*/
+function applyEffectRef(frame, value, k) {
+	const { handlerNodes, evaluatedHandlers, index, bodyNodes, bodyEnv, env, sourceCodeInfo } = frame;
+	const currentHandler = handlerNodes[index];
+	evaluatedHandlers.push({
+		effectRef: value,
+		handlerNode: currentHandler[1]
+	});
+	const nextIndex = index + 1;
+	if (nextIndex < handlerNodes.length) {
+		const nextFrame = {
+			type: "EffectRef",
+			handlerNodes,
+			evaluatedHandlers,
+			index: nextIndex,
+			bodyNodes,
+			bodyEnv,
+			env,
+			sourceCodeInfo
+		};
+		return {
+			type: "Eval",
+			node: handlerNodes[nextIndex][0],
+			env,
+			k: [nextFrame, ...k]
+		};
+	}
+	const bodyK = [{
+		type: "TryWith",
+		handlers: evaluatedHandlers,
+		env,
+		sourceCodeInfo
+	}, ...k];
+	if (bodyNodes.length === 0) return {
+		type: "Value",
+		value: null,
+		k: bodyK
+	};
+	if (bodyNodes.length === 1) return {
+		type: "Eval",
+		node: bodyNodes[0],
+		env: bodyEnv,
+		k: bodyK
+	};
+	const sequenceFrame = {
+		type: "Sequence",
+		nodes: bodyNodes,
+		index: 1,
+		env: bodyEnv,
+		sourceCodeInfo
+	};
+	return {
+		type: "Eval",
+		node: bodyNodes[0],
+		env: bodyEnv,
+		k: [sequenceFrame, ...bodyK]
+	};
+}
+/**
+* Handler expression has been evaluated — dispatch the handler function.
+*/
+function applyHandlerInvoke(frame, value, _k) {
+	return dispatchFunction(asFunctionLike(value, frame.sourceCodeInfo), [frame.args], [], frame.handlerEnv, frame.sourceCodeInfo, frame.handlerK);
+}
+/**
+* Comp iteration — chain to the next function in the composition.
+* Result from previous function is wrapped in array and passed to next.
+*/
+function applyComp(frame, value, k) {
+	const { fns, index, env, sourceCodeInfo } = frame;
+	const nextParams = [value];
+	if (index < 0) return {
+		type: "Value",
+		value: asAny(value, sourceCodeInfo),
+		k
+	};
+	const nextFrame = {
+		type: "Comp",
+		fns,
+		index: index - 1,
+		env,
+		sourceCodeInfo
+	};
+	return dispatchFunction(asFunctionLike(fns[index], sourceCodeInfo), nextParams, [], env, sourceCodeInfo, [nextFrame, ...k]);
+}
+/**
+* Juxt iteration — collect result and call next function.
+*/
+function applyJuxt(frame, value, k) {
+	const { fns, params, index, results, env, sourceCodeInfo } = frame;
+	const newResults = [...results, value];
+	if (index >= fns.length) return {
+		type: "Value",
+		value: newResults,
+		k
+	};
+	const nextFrame = {
+		type: "Juxt",
+		fns,
+		params,
+		index: index + 1,
+		results: newResults,
+		env,
+		sourceCodeInfo
+	};
+	return dispatchFunction(asFunctionLike(fns[index], sourceCodeInfo), params, [], env, sourceCodeInfo, [nextFrame, ...k]);
+}
+/**
+* EveryPred iteration — short-circuit on falsy, continue on truthy.
+*/
+function applyEveryPred(frame, value, k) {
+	const { checks, index, env, sourceCodeInfo } = frame;
+	if (!value) return {
+		type: "Value",
+		value: false,
+		k
+	};
+	if (index >= checks.length) return {
+		type: "Value",
+		value: true,
 		k
 	};
+	const nextFrame = {
+		type: "EveryPred",
+		checks,
+		index: index + 1,
+		env,
+		sourceCodeInfo
+	};
+	const check = checks[index];
+	return dispatchFunction(check.fn, [check.param], [], env, sourceCodeInfo, [nextFrame, ...k]);
+}
+/**
+* SomePred iteration — short-circuit on truthy, continue on falsy.
+*/
+function applySomePred(frame, value, k) {
+	const { checks, index, env, sourceCodeInfo } = frame;
+	if (value) return {
+		type: "Value",
+		value: true,
+		k
+	};
+	if (index >= checks.length) return {
+		type: "Value",
+		value: false,
+		k
+	};
+	const nextFrame = {
+		type: "SomePred",
+		checks,
+		index: index + 1,
+		env,
+		sourceCodeInfo
+	};
+	const check = checks[index];
+	return dispatchFunction(check.fn, [check.param], [], env, sourceCodeInfo, [nextFrame, ...k]);
 }
 function applyNanCheck(frame, value, k) {
 	if (typeof value === "number" && Number.isNaN(value)) throw new DvalaError("Number is NaN", frame.sourceCodeInfo);
@@ -30996,7 +31278,7 @@ function tick(step, handlers, signal, snapshotState) {
 function runSyncTrampoline(initial, effectHandlers) {
 	let step = initial;
 	for (;;) {
-		if (step instanceof Promise) throw new DvalaError("Unexpected async operation in synchronous context. Use async.run() for async operations.", void 0);
+		if (step instanceof Promise) throw new DvalaError("Unexpected async operation in synchronous context.", void 0);
 		if (step.type === "Value" && step.k.length === 0) return step.value;
 		step = tick(step, effectHandlers);
 	}
@@ -31056,30 +31338,6 @@ function evaluate(ast, contextStack) {
 	}
 }
 /**
-* Evaluate a single AST node using the trampoline.
-* Used as the `evaluateNode` callback passed to `getUndefinedSymbols`
-* and other utilities.
-*/
-function evaluateNode(node, contextStack) {
-	const initial = {
-		type: "Eval",
-		node,
-		env: contextStack,
-		k: []
-	};
-	try {
-		return runSyncTrampoline(initial);
-	} catch (error) {
-		if (error instanceof DvalaError && error.message.includes("Unexpected async operation")) return runAsyncTrampoline({
-			type: "Eval",
-			node,
-			env: contextStack,
-			k: []
-		});
-		throw error;
-	}
-}
-/**
 * Evaluate an AST with full effect handler support.
 *
 * Uses the async trampoline loop, passing `handlers` and `signal` to `tick`
@@ -31130,18 +31388,42 @@ async function runEffectLoop(initial, handlers, signal, initialSnapshotState, ma
 	const snapshotState = {
 		snapshots: initialSnapshotState ? initialSnapshotState.snapshots : [],
 		nextSnapshotIndex: initialSnapshotState ? initialSnapshotState.nextSnapshotIndex : 0,
-		runId: generateRunId(),
+		executionId: generateUUID(),
 		...maxSnapshots !== void 0 ? { maxSnapshots } : {},
 		...autoCheckpoint ? { autoCheckpoint } : {}
 	};
 	let step = initial;
+	function createTerminalSnapshot(options) {
+		if (!snapshotState.autoCheckpoint) return;
+		const continuation = serializeTerminalSnapshot(snapshotState.snapshots, snapshotState.nextSnapshotIndex);
+		const meta = {};
+		if (options?.error) meta.error = options.error.toJSON();
+		if (options?.result !== void 0) meta.result = options.result;
+		const message = options?.error ? "Run failed with error" : "Run completed successfully";
+		return createSnapshot({
+			continuation,
+			timestamp: Date.now(),
+			index: snapshotState.nextSnapshotIndex,
+			executionId: snapshotState.executionId,
+			message,
+			terminal: true,
+			...Object.keys(meta).length > 0 ? { meta } : {}
+		});
+	}
 	for (;;) try {
 		for (;;) {
 			if (step instanceof Promise) step = await step;
-			if (step.type === "Value" && step.k.length === 0) return {
-				type: "completed",
-				value: step.value
-			};
+			if (step.type === "Value" && step.k.length === 0) {
+				const snapshot = createTerminalSnapshot({ result: step.value });
+				return snapshot ? {
+					type: "completed",
+					value: step.value,
+					snapshot
+				} : {
+					type: "completed",
+					value: step.value
+				};
+			}
 			if (debugMode && step.type === "Eval" && step.node[2]) {
 				const nodeType = step.node[0];
 				if (nodeType === NodeTypes.NormalExpression || nodeType === NodeTypes.SpecialExpression) {
@@ -31173,24 +31455,37 @@ async function runEffectLoop(initial, handlers, signal, initialSnapshotState, ma
 		}
 		if (isSuspensionSignal(error)) return {
 			type: "suspended",
-			snapshot: {
+			snapshot: createSnapshot({
 				continuation: serializeSuspensionBlob(error.k, error.snapshots, error.nextSnapshotIndex, error.meta),
 				timestamp: Date.now(),
 				index: snapshotState.nextSnapshotIndex++,
-				runId: snapshotState.runId,
+				executionId: snapshotState.executionId,
 				message: SUSPENDED_MESSAGE,
 				meta: error.meta,
 				effectName: error.effectName,
 				effectArgs: error.effectArgs
-			}
+			})
 		};
-		if (error instanceof DvalaError) return {
+		if (error instanceof DvalaError) {
+			const snapshot = createTerminalSnapshot({ error });
+			return snapshot ? {
+				type: "error",
+				error,
+				snapshot
+			} : {
+				type: "error",
+				error
+			};
+		}
+		const snapshot = createTerminalSnapshot();
+		const dvalaError = new DvalaError(`${error}`, void 0);
+		return snapshot ? {
 			type: "error",
-			error
-		};
-		return {
+			error: dvalaError,
+			snapshot
+		} : {
 			type: "error",
-			error: new DvalaError(`${error}`, void 0)
+			error: dvalaError
 		};
 	}
 }
@@ -31298,7 +31593,7 @@ function getUndefinedSymbols(source, options) {
 	return getUndefinedSymbols$1({
 		body: parse(minifyTokenStream(tokenize(source, false, void 0), { removeWhiteSpace: true })),
 		hasDebugData: false
-	}, contextStack, builtin, evaluateNode);
+	}, contextStack, builtin);
 }
 //#endregion
 //#region src/createDvala.ts
@@ -31331,6 +31626,7 @@ function createDvala(options) {
 	const modules = options?.modules ? new Map(options.modules.map((m) => [m.name, m])) : void 0;
 	const factoryBindings = options?.bindings;
 	const factoryEffectHandlers = options?.effectHandlers;
+	const factoryDisableTimeTravel = options?.disableAutoCheckpoint ?? false;
 	const debug = options?.debug ?? false;
 	const cache = options?.cache ? new Cache(options.cache) : null;
 	function buildAst(source, filePath) {
@@ -31406,10 +31702,12 @@ function createDvala(options) {
 					}
 					contextStack.pure = savedPure;
 				}
-				const result = await evaluateWithEffects(buildAst(isDvalaBundle(source) ? source.program : source), contextStack, effectHandlers, runOptions?.maxSnapshots, {
+				const ast = buildAst(isDvalaBundle(source) ? source.program : source);
+				const disableAutoCheckpoint = runOptions?.disableAutoCheckpoint ?? factoryDisableTimeTravel;
+				const result = await evaluateWithEffects(ast, contextStack, effectHandlers, runOptions?.maxSnapshots, {
 					values: bindings,
 					modules
-				}, runOptions?.autoCheckpoint);
+				}, !disableAutoCheckpoint);
 				if (result.type === "completed") return {
 					...result,
 					definedBindings: contextStack.getModuleScopeBindings()