@codehz/json-expr 0.3.0 → 0.5.0

package/dist/index.mjs

@@ -194,6 +194,8 @@ var Parser = class Parser {
 		if (ch === "[") return this.parseArray();
 		if (ch === "{") return this.parseObject();
 		if (ch === "(") {
+			const arrowFunc = this.tryParseArrowFunction();
+			if (arrowFunc) return arrowFunc;
 			this.advance();
 			this.skipWhitespace();
 			const expr = this.parseExpression();
@@ -214,7 +216,11 @@ var Parser = class Parser {
 			type: "Identifier",
 			name: "undefined"
 		};
-		if (this.isIdentifierStart(ch)) return this.parseIdentifier();
+		if (this.isIdentifierStart(ch)) {
+			const arrowFunc = this.tryParseSingleParamArrowFunction();
+			if (arrowFunc) return arrowFunc;
+			return this.parseIdentifier();
+		}
 		throw new Error(`Unexpected character at position ${this.pos}: ${ch}`);
 	}
 	parseNumber() {
@@ -359,6 +365,63 @@ var Parser = class Parser {
 			name
 		};
 	}
+	/**
+	* 尝试解析带括号的箭头函数: (a, b) => expr
+	* 使用回溯机制
+	*/
+	tryParseArrowFunction() {
+		const savedPos = this.pos;
+		try {
+			this.expect("(");
+			this.skipWhitespace();
+			const params = [];
+			while (this.peek() !== ")") {
+				if (!this.isIdentifierStart(this.peek())) throw new Error("Expected identifier");
+				params.push(this.parseIdentifier());
+				this.skipWhitespace();
+				if (this.peek() === ",") {
+					this.advance();
+					this.skipWhitespace();
+				} else break;
+			}
+			this.expect(")");
+			this.skipWhitespace();
+			if (this.source.slice(this.pos, this.pos + 2) !== "=>") throw new Error("Expected =>");
+			this.pos += 2;
+			this.skipWhitespace();
+			return {
+				type: "ArrowFunctionExpr",
+				params,
+				body: this.parseExpression()
+			};
+		} catch {
+			this.pos = savedPos;
+			return null;
+		}
+	}
+	/**
+	* 尝试解析单参数无括号的箭头函数: a => expr
+	* 使用回溯机制
+	*/
+	tryParseSingleParamArrowFunction() {
+		const savedPos = this.pos;
+		try {
+			const param = this.parseIdentifier();
+			this.skipWhitespace();
+			if (this.source.slice(this.pos, this.pos + 2) !== "=>") throw new Error("Expected =>");
+			this.pos += 2;
+			this.skipWhitespace();
+			const body = this.parseExpression();
+			return {
+				type: "ArrowFunctionExpr",
+				params: [param],
+				body
+			};
+		} catch {
+			this.pos = savedPos;
+			return null;
+		}
+	}
 	parseArguments() {
 		const args = [];
 		this.skipWhitespace();
@@ -496,6 +559,27 @@ function generate(node) {
 		case "CallExpr": {
 			const callee = wrapIfNeeded(node.callee, node, "callee");
 			const args = node.arguments.map(generate).join(",");
+			if (node.callee.type === "Identifier" && [
+				"Date",
+				"RegExp",
+				"URL",
+				"URLSearchParams",
+				"Map",
+				"Set",
+				"Int8Array",
+				"Uint8Array",
+				"Uint8ClampedArray",
+				"Int16Array",
+				"Uint16Array",
+				"Int32Array",
+				"Uint32Array",
+				"Float32Array",
+				"Float64Array",
+				"BigInt64Array",
+				"BigUint64Array",
+				"ArrayBuffer",
+				"DataView"
+			].includes(node.callee.name)) return node.optional ? `new ${callee}?.(${args})` : `new ${callee}(${args})`;
 			return node.optional ? `${callee}?.(${args})` : `${callee}(${args})`;
 		}
 		case "ArrayExpr": return `[${node.elements.map(generate).join(",")}]`;
@@ -503,6 +587,13 @@ function generate(node) {
 			if (prop.shorthand) return generate(prop.key);
 			return `${prop.computed ? `[${generate(prop.key)}]` : generate(prop.key)}:${generate(prop.value)}`;
 		}).join(",")}}`;
+		case "ArrowFunctionExpr": {
+			const params = node.params.map((p) => p.name).join(",");
+			let body = generate(node.body);
+			if (node.body.type === "ObjectExpr") body = `(${body})`;
+			if (node.params.length === 1) return `${params}=>${body}`;
+			return `(${params})=>${body}`;
+		}
 		default: {
 			const nodeType = node.type ?? "unknown";
 			throw new Error(`Unknown node type: ${nodeType}`);
@@ -538,190 +629,642 @@ function needsParens(child, parent, position) {
 	return false;
 }
 /**
-* 收集 AST 中所有使用的标识符名称
+* 转换 AST 中的标识符
+* 回调函数可以返回：
+* - string: 替换标识符名称
+* - ASTNode: 内联该 AST 节点（用于子表达式内联）
+*/
+function transformIdentifiers(node, transform) {
+	switch (node.type) {
+		case "Identifier": {
+			const result = transform(node.name);
+			return typeof result === "string" ? {
+				...node,
+				name: result
+			} : result;
+		}
+		case "BinaryExpr": return {
+			...node,
+			left: transformIdentifiers(node.left, transform),
+			right: transformIdentifiers(node.right, transform)
+		};
+		case "UnaryExpr": return {
+			...node,
+			argument: transformIdentifiers(node.argument, transform)
+		};
+		case "ConditionalExpr": return {
+			...node,
+			test: transformIdentifiers(node.test, transform),
+			consequent: transformIdentifiers(node.consequent, transform),
+			alternate: transformIdentifiers(node.alternate, transform)
+		};
+		case "MemberExpr": return {
+			...node,
+			object: transformIdentifiers(node.object, transform),
+			property: node.computed ? transformIdentifiers(node.property, transform) : node.property
+		};
+		case "CallExpr": return {
+			...node,
+			callee: transformIdentifiers(node.callee, transform),
+			arguments: node.arguments.map((arg) => transformIdentifiers(arg, transform))
+		};
+		case "ArrayExpr": return {
+			...node,
+			elements: node.elements.map((el) => transformIdentifiers(el, transform))
+		};
+		case "ObjectExpr": return {
+			...node,
+			properties: node.properties.map((prop) => ({
+				...prop,
+				key: prop.computed ? transformIdentifiers(prop.key, transform) : prop.key,
+				value: transformIdentifiers(prop.value, transform)
+			}))
+		};
+		case "ArrowFunctionExpr": {
+			const paramNames = new Set(node.params.map((p) => p.name));
+			return {
+				...node,
+				body: transformIdentifiers(node.body, (name) => paramNames.has(name) ? name : transform(name))
+			};
+		}
+		default: return node;
+	}
+}
+
+//#endregion
+//#region src/proxy-metadata.ts
+/**
+* 全局 WeakMap 存储
+*/
+const proxyMetadata = /* @__PURE__ */ new WeakMap();
+/**
+* 设置 Proxy 元数据
+*/
+function setProxyMetadata(proxy, metadata) {
+	proxyMetadata.set(proxy, metadata);
+}
+/**
+* 获取 Proxy 元数据
+*/
+function getProxyMetadata(proxy) {
+	return proxyMetadata.get(proxy);
+}
+/**
+* 检查对象是否是 Proxy variable
+*/
+function isProxyVariable(obj) {
+	if (typeof obj !== "object" && typeof obj !== "function" || obj === null) return false;
+	return proxyMetadata.get(obj)?.type === "variable";
+}
+/**
+* 检查对象是否是 Proxy expression
+*/
+function isProxyExpression(obj) {
+	if (typeof obj !== "object" && typeof obj !== "function" || obj === null) return false;
+	return proxyMetadata.get(obj)?.type === "expression";
+}
+/**
+* 检查对象是否是任意 Proxy (variable 或 expression)
 */
-function collectIdentifiers(node) {
-	const identifiers = /* @__PURE__ */ new Set();
-	function visit(n) {
-		switch (n.type) {
-			case "Identifier":
-				identifiers.add(n.name);
-				break;
-			case "BinaryExpr":
-				visit(n.left);
-				visit(n.right);
-				break;
-			case "UnaryExpr":
-				visit(n.argument);
-				break;
-			case "ConditionalExpr":
-				visit(n.test);
-				visit(n.consequent);
-				visit(n.alternate);
-				break;
-			case "MemberExpr":
-				visit(n.object);
-				if (n.computed) visit(n.property);
-				break;
-			case "CallExpr":
-				visit(n.callee);
-				n.arguments.forEach(visit);
-				break;
-			case "ArrayExpr":
-				n.elements.forEach(visit);
-				break;
-			case "ObjectExpr":
-				n.properties.forEach((prop) => {
-					if (prop.computed) visit(prop.key);
-					visit(prop.value);
+function isProxy(obj) {
+	if (typeof obj !== "object" && typeof obj !== "function" || obj === null) return false;
+	return proxyMetadata.has(obj);
+}
+
+//#endregion
+//#region src/proxy-variable.ts
+/**
+* 使用 Symbol.description 生成占位符
+* 用于在表达式源码中标识变量
+*/
+function getVariablePlaceholder$1(id) {
+	return `$$VAR_${id.description}$$`;
+}
+/**
+* 序列化参数为 AST 节点
+* - Proxy Variable/Expression：使用 ast 或占位符标识符
+* - 数组：返回 ArrayExpr 节点
+* - 对象：返回 ObjectExpr 节点
+* - 原始值：返回对应的字面量节点
+* - Date, RegExp, BigInt, URL, URLSearchParams, Map, Set, TypedArray, DataView: 构造函数调用
+*/
+function serializeArgumentToAST(arg) {
+	if ((typeof arg === "object" || typeof arg === "function") && arg !== null) {
+		const meta = getProxyMetadata(arg);
+		if (meta) {
+			if (meta.ast) return meta.ast;
+			if (meta.rootVariable) return {
+				type: "Identifier",
+				name: getVariablePlaceholder$1(meta.rootVariable)
+			};
+		}
+	}
+	if (Array.isArray(arg)) return {
+		type: "ArrayExpr",
+		elements: arg.map(serializeArgumentToAST)
+	};
+	if (typeof arg === "object" && arg !== null) {
+		if (arg instanceof Date) return {
+			type: "CallExpr",
+			callee: {
+				type: "Identifier",
+				name: "Date"
+			},
+			arguments: [{
+				type: "NumberLiteral",
+				value: arg.getTime(),
+				raw: String(arg.getTime())
+			}],
+			optional: false
+		};
+		if (arg instanceof RegExp) {
+			const args = [{
+				type: "StringLiteral",
+				value: arg.source,
+				quote: "\""
+			}];
+			if (arg.flags) args.push({
+				type: "StringLiteral",
+				value: arg.flags,
+				quote: "\""
+			});
+			return {
+				type: "CallExpr",
+				callee: {
+					type: "Identifier",
+					name: "RegExp"
+				},
+				arguments: args,
+				optional: false
+			};
+		}
+		if (typeof URL !== "undefined" && arg instanceof URL) return {
+			type: "CallExpr",
+			callee: {
+				type: "Identifier",
+				name: "URL"
+			},
+			arguments: [{
+				type: "StringLiteral",
+				value: arg.href,
+				quote: "\""
+			}],
+			optional: false
+		};
+		if (typeof URLSearchParams !== "undefined" && arg instanceof URLSearchParams) {
+			const entries = [];
+			arg.forEach((value, key) => {
+				entries.push({
+					type: "ArrayExpr",
+					elements: [{
+						type: "StringLiteral",
+						value: key,
+						quote: "\""
+					}, {
+						type: "StringLiteral",
+						value,
+						quote: "\""
+					}]
 				});
-				break;
+			});
+			return {
+				type: "CallExpr",
+				callee: {
+					type: "Identifier",
+					name: "URLSearchParams"
+				},
+				arguments: [{
+					type: "ArrayExpr",
+					elements: entries
+				}],
+				optional: false
+			};
+		}
+		if (arg instanceof Map) {
+			const entries = [];
+			arg.forEach((value, key) => {
+				entries.push({
+					type: "ArrayExpr",
+					elements: [serializeArgumentToAST(key), serializeArgumentToAST(value)]
+				});
+			});
+			return {
+				type: "CallExpr",
+				callee: {
+					type: "Identifier",
+					name: "Map"
+				},
+				arguments: [{
+					type: "ArrayExpr",
+					elements: entries
+				}],
+				optional: false
+			};
+		}
+		if (arg instanceof Set) {
+			const values = [];
+			arg.forEach((value) => {
+				values.push(serializeArgumentToAST(value));
+			});
+			return {
+				type: "CallExpr",
+				callee: {
+					type: "Identifier",
+					name: "Set"
+				},
+				arguments: [{
+					type: "ArrayExpr",
+					elements: values
+				}],
+				optional: false
+			};
+		}
+		for (const constructorName of [
+			"Int8Array",
+			"Uint8Array",
+			"Uint8ClampedArray",
+			"Int16Array",
+			"Uint16Array",
+			"Int32Array",
+			"Uint32Array",
+			"Float32Array",
+			"Float64Array",
+			"BigInt64Array",
+			"BigUint64Array"
+		]) if (typeof globalThis[constructorName] !== "undefined") {
+			if (arg instanceof globalThis[constructorName]) {
+				const values = [...arg].map((val) => serializeArgumentToAST(val));
+				return {
+					type: "CallExpr",
+					callee: {
+						type: "Identifier",
+						name: constructorName
+					},
+					arguments: [{
+						type: "ArrayExpr",
+						elements: values
+					}],
+					optional: false
+				};
+			}
+		}
+		if (arg instanceof ArrayBuffer) {
+			const uint8Array = new Uint8Array(arg);
+			return {
+				type: "MemberExpr",
+				object: {
+					type: "CallExpr",
+					callee: {
+						type: "Identifier",
+						name: "Uint8Array"
+					},
+					arguments: [{
+						type: "ArrayExpr",
+						elements: Array.from(uint8Array).map((val) => serializeArgumentToAST(val))
+					}],
+					optional: false
+				},
+				property: {
+					type: "Identifier",
+					name: "buffer"
+				},
+				computed: false,
+				optional: false
+			};
 		}
+		if (arg instanceof DataView) return {
+			type: "CallExpr",
+			callee: {
+				type: "Identifier",
+				name: "DataView"
+			},
+			arguments: [serializeArgumentToAST(arg.buffer)],
+			optional: false
+		};
+	}
+	if (typeof arg === "object" && arg !== null) return {
+		type: "ObjectExpr",
+		properties: Object.entries(arg).map(([k, v]) => {
+			return {
+				key: /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(k) ? {
+					type: "Identifier",
+					name: k
+				} : {
+					type: "StringLiteral",
+					value: k,
+					quote: "\""
+				},
+				value: serializeArgumentToAST(v),
+				computed: false,
+				shorthand: false
+			};
+		})
+	};
+	if (arg === null) return { type: "NullLiteral" };
+	if (arg === void 0) return {
+		type: "Identifier",
+		name: "undefined"
+	};
+	if (typeof arg === "boolean") return {
+		type: "BooleanLiteral",
+		value: arg
+	};
+	if (typeof arg === "number") return {
+		type: "NumberLiteral",
+		value: arg,
+		raw: String(arg)
+	};
+	if (typeof arg === "string") return {
+		type: "StringLiteral",
+		value: arg,
+		quote: "\""
+	};
+	if (typeof arg === "bigint") return {
+		type: "CallExpr",
+		callee: {
+			type: "Identifier",
+			name: "BigInt"
+		},
+		arguments: [{
+			type: "StringLiteral",
+			value: arg.toString(),
+			quote: "\""
+		}],
+		optional: false
+	};
+	throw new Error(`Unsupported argument type: ${typeof arg}`);
+}
+/**
+* 从参数中收集依赖的 Symbol
+* 递归遍历数组和对象，收集所有 Proxy 的依赖
+*/
+function collectDepsFromArgs(args, deps) {
+	for (const arg of args) if ((typeof arg === "object" || typeof arg === "function") && arg !== null) {
+		const meta = getProxyMetadata(arg);
+		if (meta?.dependencies) for (const dep of meta.dependencies) deps.add(dep);
+		else if (Array.isArray(arg)) collectDepsFromArgs(arg, deps);
+		else if (typeof arg === "object") collectDepsFromArgs(Object.values(arg), deps);
 	}
-	visit(node);
-	return identifiers;
+}
+/**
+* 创建根 Variable Proxy
+* 拦截属性访问，返回新的 expression proxy
+* 不可直接调用（apply 应该只在链式调用后可用）
+*
+* @param id - 变量的唯一标识 Symbol
+* @returns Proxy 包装的 Variable
+*/
+function createProxyVariable(id) {
+	const deps = new Set([id]);
+	const proxy = new Proxy(function() {}, {
+		get(_target, prop) {
+			if (typeof prop === "symbol") return void 0;
+			return createProxyExpression(id, [String(prop)], deps);
+		},
+		apply() {
+			throw new Error("Variable cannot be called directly");
+		}
+	});
+	setProxyMetadata(proxy, {
+		type: "variable",
+		path: [],
+		rootVariable: id,
+		dependencies: deps
+	});
+	return proxy;
+}
+/**
+* 创建属性访问后的 Proxy
+* 继续拦截属性访问（链式访问）
+* 拦截 apply 进行方法调用
+*
+* @param rootId - 根变量的 Symbol
+* @param path - 属性访问路径
+* @param deps - 依赖集合
+* @returns Proxy 包装的 Expression
+*/
+function createProxyExpression(rootId, path, deps) {
+	let ast = {
+		type: "Identifier",
+		name: getVariablePlaceholder$1(rootId)
+	};
+	for (const prop of path) ast = {
+		type: "MemberExpr",
+		object: ast,
+		property: {
+			type: "Identifier",
+			name: prop
+		},
+		computed: false,
+		optional: false
+	};
+	const proxy = new Proxy(function() {}, {
+		get(_target, prop) {
+			if (typeof prop === "symbol") return void 0;
+			return createProxyExpression(rootId, [...path, String(prop)], deps);
+		},
+		apply(_target, _thisArg, args) {
+			const callAst = {
+				type: "CallExpr",
+				callee: ast,
+				arguments: args.map(serializeArgumentToAST),
+				optional: false
+			};
+			const newDeps = new Set(deps);
+			collectDepsFromArgs(args, newDeps);
+			return createProxyExpressionWithAST(callAst, newDeps);
+		}
+	});
+	setProxyMetadata(proxy, {
+		type: "expression",
+		path,
+		rootVariable: rootId,
+		ast,
+		dependencies: deps
+	});
+	return proxy;
+}
+/**
+* 创建带完整 AST 的 Proxy（方法调用后）
+* 可以继续链式访问和调用
+*
+* @param ast - 完整的表达式 AST
+* @param deps - 依赖集合
+* @returns Proxy 包装的 Expression
+*/
+function createProxyExpressionWithAST(ast, deps) {
+	const proxy = new Proxy(function() {}, {
+		get(_target, prop) {
+			if (typeof prop === "symbol") return void 0;
+			return createProxyExpressionWithAST({
+				type: "MemberExpr",
+				object: ast,
+				property: {
+					type: "Identifier",
+					name: String(prop)
+				},
+				computed: false,
+				optional: false
+			}, deps);
+		},
+		apply(_target, _thisArg, args) {
+			const callAst = {
+				type: "CallExpr",
+				callee: ast,
+				arguments: args.map(serializeArgumentToAST),
+				optional: false
+			};
+			const newDeps = new Set(deps);
+			collectDepsFromArgs(args, newDeps);
+			return createProxyExpressionWithAST(callAst, newDeps);
+		}
+	});
+	setProxyMetadata(proxy, {
+		type: "expression",
+		path: [],
+		ast,
+		dependencies: deps
+	});
+	return proxy;
+}
+
+//#endregion
+//#region src/variable.ts
+/**
+* 跟踪每个 variable 的唯一 Symbol ID
+*/
+const variableIds = /* @__PURE__ */ new WeakMap();
+/**
+* 计数器用于生成唯一变量 ID
+*/
+let variableCounter = 0;
+/**
+* 创建一个类型化变量
+* 返回 Proxy 对象，支持链式属性访问和方法调用
+*
+* @example
+* ```ts
+* const x = variable<number>();
+* const config = variable<{ timeout: number }>();
+* const timeout = config.timeout; // Proxy expression
+* ```
+*/
+function variable() {
+	const id = Symbol(`var_${variableCounter++}`);
+	const proxy = createProxyVariable(id);
+	variableIds.set(proxy, id);
+	return proxy;
+}
+/**
+* 获取 variable 的唯一 Symbol ID
+*/
+function getVariableId(variable) {
+	if (typeof variable !== "object" && typeof variable !== "function" || variable === null) return void 0;
+	return variableIds.get(variable);
+}
+/**
+* 生成变量占位符字符串
+* 格式：$$VAR_var_N$$
+*/
+function getVariablePlaceholder(id) {
+	return `$$VAR_${id.description}$$`;
 }
 
 //#endregion
 //#region src/compile.ts
+const ALLOWED_GLOBALS = new Set([
+	"Math",
+	"JSON",
+	"Date",
+	"RegExp",
+	"Number",
+	"String",
+	"Boolean",
+	"Array",
+	"Object",
+	"undefined",
+	"NaN",
+	"Infinity",
+	"isNaN",
+	"isFinite",
+	"parseInt",
+	"parseFloat",
+	"BigInt",
+	"URL",
+	"URLSearchParams",
+	"Map",
+	"Set",
+	"Int8Array",
+	"Uint8Array",
+	"Uint8ClampedArray",
+	"Int16Array",
+	"Uint16Array",
+	"Int32Array",
+	"Uint32Array",
+	"Float32Array",
+	"Float64Array",
+	"BigInt64Array",
+	"BigUint64Array",
+	"ArrayBuffer",
+	"DataView"
+]);
 /**
-* 将表达式树编译为可序列化的 JSON 结构
+* 将 Proxy Expression 编译为可序列化的 JSON 结构
 *
 * @template TResult - 表达式结果类型
-* @param expression - 根表达式
+* @param expression - Proxy Expression，或包含 Proxy 的对象/数组/原始值
 * @param variables - 所有使用的变量定义
 * @param options - 编译选项
 * @returns 编译后的数据结构 [变量名列表, 表达式1, 表达式2, ...]
 *
-* @throws 如果检测到循环依赖或未定义的变量引用
+* @throws 如果传入无效的表达式或未定义的变量引用
 *
 * @example
 * ```ts
-* const x = variable(z.number())
-* const y = variable(z.number())
-* const sum = expr({ x, y })<number>("x + y")
-* const result = expr({ sum })<number>("sum * 2")
+* const x = variable<number>()
+* const y = variable<number>()
+* const sum = expr({ x, y })("x + y")
+* const result = expr({ sum, x })("sum * x")
 * const compiled = compile(result, { x, y })
-* // => [["x", "y"], "($0+$1)*2"]  // 内联优化后
+* // => [["x", "y"], "($0+$1)*$0"]
 * ```
 */
 function compile(expression, variables, options = {}) {
-	const { inline = true, shortCircuit = true } = options;
-	const context = {
-		variableOrder: [],
-		nodeToIndex: /* @__PURE__ */ new Map(),
-		expressions: []
-	};
-	const exprIdMap = /* @__PURE__ */ new WeakMap();
-	function getExprId(expr) {
-		let id = exprIdMap.get(expr);
-		if (id === void 0) {
-			id = Symbol("expr");
-			exprIdMap.set(expr, id);
-		}
-		return id;
+	const { shortCircuit = true } = options;
+	const ast = serializeArgumentToAST(expression);
+	const variableOrder = [];
+	const variableToIndex = /* @__PURE__ */ new Map();
+	for (const name of Object.keys(variables)) if (!variableToIndex.has(name)) {
+		variableToIndex.set(name, variableOrder.length);
+		variableOrder.push(name);
 	}
-	const nodeMap = /* @__PURE__ */ new Map();
-	const variableNodes = /* @__PURE__ */ new Map();
-	const visited = /* @__PURE__ */ new Set();
-	const visiting = /* @__PURE__ */ new Set();
-	for (const [name] of Object.entries(variables)) {
-		const id = Symbol(`var:${name}`);
-		const node = {
-			id,
-			tag: "variable"
-		};
-		nodeMap.set(id, node);
-		variableNodes.set(name, node);
+	const descToName = /* @__PURE__ */ new Map();
+	for (const [name, value] of Object.entries(variables)) {
+		const id = getVariableId(value);
+		if (id && id.description) descToName.set(id.description, name);
 	}
-	const exprNodes = /* @__PURE__ */ new Map();
-	function collectNodes(expr) {
-		const exprId = getExprId(expr);
-		if (visited.has(exprId)) return nodeMap.get(exprId);
-		if (visiting.has(exprId)) throw new Error("Circular dependency detected in expressions");
-		visiting.add(exprId);
-		const contextNodes = {};
-		for (const [key, contextItem] of Object.entries(expr.context)) {
-			const item = contextItem;
-			if (item._tag === "variable") {
-				const varNode = variableNodes.get(key);
-				if (!varNode) throw new Error(`Undefined variable reference: ${key}`);
-				contextNodes[key] = varNode;
-			} else if (item._tag === "expression") contextNodes[key] = collectNodes(item);
+	const undefinedVars = [];
+	const transformed = transformIdentifiers(ast, (name) => {
+		const placeholderMatch = name.match(/^\$\$VAR_(.+)\$\$$/);
+		if (placeholderMatch) {
+			const desc = placeholderMatch[1];
+			const varName = descToName.get(desc);
+			if (!varName) throw new Error(`Unknown variable placeholder: ${name}`);
+			name = varName;
 		}
-		const node = {
-			id: exprId,
-			tag: "expression",
-			context: contextNodes,
-			source: expr.source
-		};
-		nodeMap.set(exprId, node);
-		exprNodes.set(exprId, node);
-		visited.add(exprId);
-		visiting.delete(exprId);
-		return node;
-	}
-	const rootNode = collectNodes(expression);
-	const sortedExprNodes = [];
-	const exprVisited = /* @__PURE__ */ new Set();
-	function topologicalSort(node) {
-		if (exprVisited.has(node.id)) return;
-		exprVisited.add(node.id);
-		if (node.tag === "expression" && node.context) for (const contextNode of Object.values(node.context)) topologicalSort(contextNode);
-		if (node.tag === "expression") sortedExprNodes.push(node);
-	}
-	topologicalSort(rootNode);
-	for (const [name, varNode] of variableNodes.entries()) if (!context.nodeToIndex.has(varNode.id)) {
-		context.nodeToIndex.set(varNode.id, context.variableOrder.length);
-		context.variableOrder.push(name);
-	}
-	const refCount = /* @__PURE__ */ new Map();
-	for (const exprNode of sortedExprNodes) refCount.set(exprNode.id, 0);
-	for (const exprNode of sortedExprNodes) if (exprNode.context) {
-		for (const contextNode of Object.values(exprNode.context)) if (contextNode.tag === "expression") refCount.set(contextNode.id, (refCount.get(contextNode.id) ?? 0) + 1);
-	}
-	function canInline(node) {
-		if (!inline) return false;
-		if (node.id === rootNode.id) return false;
-		return (refCount.get(node.id) ?? 0) === 1;
-	}
-	let exprIndex = 0;
-	for (const exprNode of sortedExprNodes) if (!canInline(exprNode)) {
-		const index = context.variableOrder.length + exprIndex;
-		context.nodeToIndex.set(exprNode.id, index);
-		exprIndex++;
-	}
-	const nodeAstMap = /* @__PURE__ */ new Map();
-	for (const [, varNode] of variableNodes.entries()) {
-		const index = context.nodeToIndex.get(varNode.id);
-		nodeAstMap.set(varNode.id, {
-			type: "Identifier",
-			name: `$${index}`
-		});
-	}
-	for (const exprNode of sortedExprNodes) {
-		if (!exprNode.context || !exprNode.source) throw new Error("Invalid expression node");
-		const usedVariables = extractVariableNames(exprNode.source);
-		for (const varName of usedVariables) if (!(varName in exprNode.context)) throw new Error(`Undefined variable reference: ${varName} (available: ${Object.keys(exprNode.context).join(", ")})`);
-		const transformed = inlineTransform(parse(exprNode.source), (name) => {
-			const contextNode = exprNode.context[name];
-			if (!contextNode) return null;
-			if (contextNode.tag === "variable") return nodeAstMap.get(contextNode.id) ?? null;
-			else if (canInline(contextNode)) return nodeAstMap.get(contextNode.id) ?? null;
-			else return {
-				type: "Identifier",
-				name: `$${context.nodeToIndex.get(contextNode.id)}`
-			};
-		});
-		nodeAstMap.set(exprNode.id, transformed);
-	}
+		const index = variableToIndex.get(name);
+		if (index !== void 0) return `$${index}`;
+		if (!ALLOWED_GLOBALS.has(name)) undefinedVars.push(name);
+		return name;
+	});
+	if (undefinedVars.length > 0) throw new Error(`Undefined variable(s): ${[...new Set(undefinedVars)].join(", ")}`);
+	const expressions = [];
 	if (shortCircuit) {
-		const expressions = [];
-		let nextIndex = context.variableOrder.length;
-		function compileAst(ast) {
-			if (ast.type === "BinaryExpr" && (ast.operator === "||" || ast.operator === "&&" || ast.operator === "??")) return compileShortCircuit(ast);
-			if (ast.type === "ConditionalExpr") return compileConditional(ast);
-			const exprStr = generate(ast);
+		let nextIndex = variableOrder.length;
+		function compileAst(node) {
+			if (node.type === "BinaryExpr" && (node.operator === "||" || node.operator === "&&" || node.operator === "??")) return compileShortCircuit(node);
+			if (node.type === "ConditionalExpr") return compileConditional(node);
+			const exprStr = generate(node);
 			const idx = nextIndex++;
 			expressions.push(exprStr);
 			return idx;
@@ -773,140 +1316,9 @@ function compile(expression, variables, options = {}) {
 			expressions.push(["phi"]);
 			return phiIdx;
 		}
-		for (const exprNode of sortedExprNodes) if (!canInline(exprNode)) compileAst(nodeAstMap.get(exprNode.id));
-		context.expressions = expressions;
-	} else for (const exprNode of sortedExprNodes) if (!canInline(exprNode)) {
-		const ast = nodeAstMap.get(exprNode.id);
-		context.expressions.push(generate(ast));
-	}
-	return [context.variableOrder, ...context.expressions];
-}
-/**
-* 将 AST 中的标识符替换为对应的 AST 节点（用于内联优化）
-*
-* @param node - 要转换的 AST 节点
-* @param getReplacementAst - 根据标识符名称返回替换的 AST 节点，返回 null 表示不替换
-* @returns 转换后的 AST 节点
-*/
-function inlineTransform(node, getReplacementAst) {
-	switch (node.type) {
-		case "Identifier": return getReplacementAst(node.name) ?? node;
-		case "BinaryExpr": return {
-			...node,
-			left: inlineTransform(node.left, getReplacementAst),
-			right: inlineTransform(node.right, getReplacementAst)
-		};
-		case "UnaryExpr": return {
-			...node,
-			argument: inlineTransform(node.argument, getReplacementAst)
-		};
-		case "ConditionalExpr": return {
-			...node,
-			test: inlineTransform(node.test, getReplacementAst),
-			consequent: inlineTransform(node.consequent, getReplacementAst),
-			alternate: inlineTransform(node.alternate, getReplacementAst)
-		};
-		case "MemberExpr": return {
-			...node,
-			object: inlineTransform(node.object, getReplacementAst),
-			property: node.computed ? inlineTransform(node.property, getReplacementAst) : node.property
-		};
-		case "CallExpr": return {
-			...node,
-			callee: inlineTransform(node.callee, getReplacementAst),
-			arguments: node.arguments.map((arg) => inlineTransform(arg, getReplacementAst))
-		};
-		case "ArrayExpr": return {
-			...node,
-			elements: node.elements.map((el) => inlineTransform(el, getReplacementAst))
-		};
-		case "ObjectExpr": return {
-			...node,
-			properties: node.properties.map((prop) => ({
-				...prop,
-				key: prop.computed ? inlineTransform(prop.key, getReplacementAst) : prop.key,
-				value: inlineTransform(prop.value, getReplacementAst)
-			}))
-		};
-		default: return node;
-	}
-}
-/**
-* 允许在表达式中直接使用的全局对象
-* 这些对象不需要在上下文中定义
-*/
-const ALLOWED_GLOBALS = new Set([
-	"Math",
-	"JSON",
-	"Number",
-	"String",
-	"Boolean",
-	"Array",
-	"Object",
-	"Date",
-	"RegExp",
-	"undefined",
-	"NaN",
-	"Infinity",
-	"isNaN",
-	"isFinite",
-	"parseInt",
-	"parseFloat"
-]);
-/**
-* 从表达式源码中提取所有使用的变量名
-* 通过 AST 解析实现精确提取
-* 排除允许的全局对象
-*
-* @param source - 表达式源码字符串
-* @returns 使用的变量名列表（去重，不含全局对象）
-*
-* @example
-* ```ts
-* extractVariableNames("x + y * Math.PI")
-* // => ["x", "y"]  // Math 被排除
-* ```
-*/
-function extractVariableNames(source) {
-	const identifiers = collectIdentifiers(parse(source));
-	return Array.from(identifiers).filter((name) => !ALLOWED_GLOBALS.has(name));
-}
-
-//#endregion
-//#region src/constant.ts
-/**
-* 创建一个编译期常量表达式
-*
-* 这是 `expr({})(JSON.stringify(value))` 的快速路径，
-* 用于在表达式中嵌入静态值，避免在运行时传入或在多处重复编写。
-*
-* @template T - 常量值类型（必须是 JSON 可序列化的）
-* @param value - 要嵌入的常量值
-* @returns 返回一个 Expression 对象，其结果类型为 T
-*
-* @example
-* ```ts
-* // 创建一个数字常量
-* const PI = constant(3.14159)
-*
-* // 创建一个字符串常量
-* const greeting = constant("Hello, World!")
-*
-* // 创建一个对象常量
-* const config = constant({ maxRetries: 3, timeout: 5000 })
-*
-* // 在表达式中使用常量
-* const radius = variable(z.number())
-* const area = expr({ PI, radius })("PI * radius * radius")
-* ```
-*/
-function constant(value) {
-	return {
-		_tag: "expression",
-		context: {},
-		source: JSON.stringify(value),
-		_type: void 0
-	};
+		compileAst(transformed);
+	} else expressions.push(generate(transformed));
+	return [variableOrder, ...expressions];
 }
 
 //#endregion
@@ -1035,11 +1447,12 @@ function buildEvaluatorFunctionBodyV2(expressions, variableCount) {
 //#endregion
 //#region src/expr.ts
 /**
-* 创建一个表达式，支持编译时类型检查和返回类型自动推导
+* 创建表达式
+* 返回 Proxy Expression，可以继续链式调用
 *
-* @template TContext - 表达式上下文类型（Variable 或 Expression 的映射）
-* @param context - 包含 Variable 或 Expression 的上下文对象
-* @returns 返回一个函数，该函数接收表达式源码字符串并返回 Expression 对象
+* @template TContext - 表达式上下文类型
+* @param context - 包含 Variable 或 Proxy Expression 的上下文对象
+* @returns 返回一个函数，该函数接收表达式源码字符串并返回 Proxy Expression
 *
 * 类型系统会：
 * 1. 验证表达式中使用的所有标识符都在 context 中定义
@@ -1047,8 +1460,8 @@ function buildEvaluatorFunctionBodyV2(expressions, variableCount) {
 *
 * @example
 * ```ts
-* const x = variable(z.number())
-* const y = variable(z.number())
+* const x = variable<number>();
+* const y = variable<number>();
 *
 * // 自动推导返回类型为 number
 * const sum = expr({ x, y })("x + y")
@@ -1062,40 +1475,177 @@ function buildEvaluatorFunctionBodyV2(expressions, variableCount) {
 */
 function expr(context) {
 	return (source) => {
-		return {
-			_tag: "expression",
-			context,
-			source,
-			_type: void 0
-		};
+		const deps = /* @__PURE__ */ new Set();
+		const nameToId = /* @__PURE__ */ new Map();
+		for (const [name, value] of Object.entries(context)) {
+			let id = getVariableId(value);
+			if (!id && (typeof value === "object" || typeof value === "function") && value !== null) {
+				const meta = getProxyMetadata(value);
+				if (meta?.type === "variable" && meta.rootVariable) id = meta.rootVariable;
+			}
+			if (id) {
+				deps.add(id);
+				nameToId.set(name, id);
+			} else {
+				const meta = (typeof value === "object" || typeof value === "function") && value !== null ? getProxyMetadata(value) : void 0;
+				if (meta?.dependencies) for (const dep of meta.dependencies) deps.add(dep);
+			}
+		}
+		const nameToExprAST = /* @__PURE__ */ new Map();
+		for (const [name, value] of Object.entries(context)) if ((typeof value === "object" || typeof value === "function") && value !== null) {
+			if (nameToId.has(name)) continue;
+			const meta = getProxyMetadata(value);
+			if (meta?.ast) nameToExprAST.set(name, meta.ast);
+		}
+		return createProxyExpressionWithAST(transformIdentifiers(parse(source), (name) => {
+			const id = nameToId.get(name);
+			if (id) return getVariablePlaceholder(id);
+			const exprAST = nameToExprAST.get(name);
+			if (exprAST) return exprAST;
+			return name;
+		}), deps);
 	};
 }
 
 //#endregion
-//#region src/variable.ts
+//#region src/lambda.ts
 /**
-* 创建一个类型化变量
+* Lambda 参数计数器，用于生成唯一 ID
+*/
+let lambdaParamCounter = 0;
+/**
+* Lambda 参数到索引的映射
+* 用于编译时确定参数位置
+*/
+const lambdaParamIndices = /* @__PURE__ */ new WeakMap();
+/**
+* 创建 lambda 参数代理
+* 生成带特殊标记的 Proxy，用于在表达式中追踪参数
+*
+* @param index - 参数索引（0, 1, 2...）
+* @returns Lambda 参数代理
+*/
+function createLambdaParam(index) {
+	const proxy = createProxyVariable(Symbol(`lambda_param_${lambdaParamCounter++}_${index}`));
+	lambdaParamIndices.set(proxy, index);
+	return proxy;
+}
+/**
+* 创建类型安全的 lambda 表达式
 *
-* @template T - 变量的值类型
-* @returns 返回 Variable 对象，包含 _tag 标记
+* @template Args - 参数类型元组
+* @template R - 返回值类型
+* @param builder - Lambda 构建函数，接收参数代理，返回函数体表达式
+* @returns Lambda 表达式代理
 *
 * @example
 * ```ts
-* const x = variable<number>()
-* const name = variable<string>()
-* const config = variable<{
-*   count: number,
-*   enabled: boolean
-* }>()
+* const add = lambda<[number, number], number>(
+*   (a, b) => expr({ a, b })("a + b")
+* );
+*
+* const numbers = variable<number[]>();
+* const sum = numbers.reduce(add, 0);
 * ```
 */
-function variable() {
-	return {
-		_tag: "variable",
-		_type: void 0
+function lambda(builder) {
+	const paramCount = builder.length;
+	const params = [];
+	const paramSymbols = [];
+	for (let i = 0; i < paramCount; i++) {
+		const param = createLambdaParam(i);
+		params.push(param);
+		const meta = getProxyMetadata(param);
+		if (meta?.rootVariable) paramSymbols.push(meta.rootVariable);
+	}
+	const bodyExpr = builder(...params);
+	let bodyAst;
+	let bodyDeps;
+	const meta = (typeof bodyExpr === "object" || typeof bodyExpr === "function") && bodyExpr !== null ? getProxyMetadata(bodyExpr) : void 0;
+	if (meta?.ast) {
+		bodyAst = meta.ast;
+		bodyDeps = meta.dependencies ?? /* @__PURE__ */ new Set();
+	} else {
+		bodyAst = serializeArgumentToAST(bodyExpr);
+		bodyDeps = /* @__PURE__ */ new Set();
+		collectDepsFromArgs([bodyExpr], bodyDeps);
+	}
+	const transformedBodyAst = transformIdentifiers(bodyAst, (name) => {
+		for (let i = 0; i < paramSymbols.length; i++) {
+			const sym = paramSymbols[i];
+			if (!sym) continue;
+			if (name === `$$VAR_${sym.description}$$`) return `_${i}`;
+		}
+		return name;
+	});
+	const arrowFunctionAst = {
+		type: "ArrowFunctionExpr",
+		params: params.map((_, i) => ({
+			type: "Identifier",
+			name: `_${i}`
+		})),
+		body: transformedBodyAst
+	};
+	const closureDeps = /* @__PURE__ */ new Set();
+	for (const dep of bodyDeps) if (!paramSymbols.includes(dep)) closureDeps.add(dep);
+	const lambdaProxy = createProxyExpressionWithAST(arrowFunctionAst, closureDeps);
+	const existingMeta = getProxyMetadata(lambdaProxy);
+	if (existingMeta) setProxyMetadata(lambdaProxy, {
+		...existingMeta,
+		type: "expression"
+	});
+	return lambdaProxy;
+}
+
+//#endregion
+//#region src/template.ts
+/**
+* Tagged template 函数，用于创建包含变量的字符串表达式
+*
+* @example
+* ```ts
+* const name = variable<string>();
+* const count = variable<number>();
+*
+* const greeting = t`Hello, ${name}!`;
+* const message = t`You have ${count} items.`;
+*
+* const compiled = compile(greeting, { name });
+* const result = evaluate(compiled, { name: "Alice" }); // => "Hello, Alice!"
+* ```
+*/
+function t(strings, ...values) {
+	const deps = /* @__PURE__ */ new Set();
+	collectDepsFromArgs(values, deps);
+	const parts = [];
+	for (let i = 0; i < strings.length; i++) {
+		const str = strings[i];
+		if (str.length > 0) parts.push({
+			type: "StringLiteral",
+			value: str,
+			quote: "\""
+		});
+		if (i < values.length) {
+			const ast = serializeArgumentToAST(values[i]);
+			parts.push(ast);
+		}
+	}
+	if (parts.length === 0) return createProxyExpressionWithAST({
+		type: "StringLiteral",
+		value: "",
+		quote: "\""
+	}, deps);
+	if (parts.length === 1) return createProxyExpressionWithAST(parts[0], deps);
+	let resultAst = parts[0];
+	for (let i = 1; i < parts.length; i++) resultAst = {
+		type: "BinaryExpr",
+		operator: "+",
+		left: resultAst,
+		right: parts[i]
 	};
+	return createProxyExpressionWithAST(resultAst, deps);
 }
 
 //#endregion
-export { compile, constant, evaluate, expr, variable };
+export { compile, evaluate, expr, getVariableId, isProxy, isProxyExpression, isProxyVariable, lambda, t, variable };
 //# sourceMappingURL=index.mjs.map