bonsai-js 0.2.1 → 0.4.0

package/dist/autocomplete/index.mjs

@@ -0,0 +1,1038 @@
+import { i as ExpressionError, n as BonsaiSecurityError, r as BonsaiTypeError, t as BonsaiReferenceError } from "../errors-BONB6P_5.mjs";
+import { i as tokenize, t as BLOCKED_PROPERTIES } from "../execution-context-B-5hQ92X.mjs";
+//#region src/autocomplete/tokenizer.ts
+function tolerantTokenize(expression, cursor, onError) {
+	if (expression.length === 0) return {
+		tokens: [],
+		partial: false,
+		insideString: false
+	};
+	const insideString = isCursorInsideString(expression, cursor);
+	try {
+		return {
+			tokens: tokenize(expression).filter((t) => t.type !== "EOF"),
+			partial: false,
+			insideString
+		};
+	} catch (err) {
+		if (!(err instanceof ExpressionError || err instanceof SyntaxError)) onError?.(err, "tokenize");
+		return {
+			tokens: regexScan(expression, cursor),
+			partial: true,
+			insideString
+		};
+	}
+}
+function isCursorInsideString(expression, cursor) {
+	let inSingle = false;
+	let inDouble = false;
+	let inTemplate = false;
+	let templateDepth = 0;
+	const braceStack = [];
+	let escaped = false;
+	for (let i = 0; i < expression.length && i < cursor; i++) {
+		const ch = expression[i];
+		if (escaped) {
+			escaped = false;
+			continue;
+		}
+		if (ch === "\\" && (inSingle || inDouble || inTemplate)) {
+			escaped = true;
+			continue;
+		}
+		if (!inSingle && !inDouble && !inTemplate) {
+			if (ch === "'") inSingle = true;
+			else if (ch === "\"") inDouble = true;
+			else if (ch === "`") {
+				inTemplate = true;
+				templateDepth = 0;
+				braceStack.length = 0;
+			}
+		} else if (inSingle && ch === "'") inSingle = false;
+		else if (inDouble && ch === "\"") inDouble = false;
+		else if (inTemplate) {
+			if (ch === "`" && templateDepth === 0) inTemplate = false;
+			else if (ch === "$" && i + 1 < expression.length && expression[i + 1] === "{") {
+				templateDepth++;
+				braceStack.push(0);
+				i++;
+			} else if (templateDepth > 0 && ch === "{") braceStack[braceStack.length - 1]++;
+			else if (templateDepth > 0 && ch === "}") if (braceStack.length > 0 && braceStack[braceStack.length - 1] > 0) braceStack[braceStack.length - 1]--;
+			else {
+				braceStack.pop();
+				templateDepth--;
+			}
+		}
+	}
+	return inSingle || inDouble || inTemplate && templateDepth === 0;
+}
+const TOKEN_RE = /\?\.|\.\.\.|\|>|\?\?|&&|\|\||[!=<>]=?|[+\-*/%]|\*\*|[.(){}[\],?:]|"(?:[^"\\]|\\.)*"?|'(?:[^'\\]|\\.)*'?|`(?:[^`\\$]|\\.|\$(?!\{))*`?|\d[\d_]*(?:\.\d[\d_]*)?(?:[eE][+-]?\d+)?|[a-zA-Z_$][\w$]*/gu;
+function regexScan(expression, cursor) {
+	const tokens = [];
+	const text = expression.slice(0, cursor);
+	for (const match of text.matchAll(TOKEN_RE)) {
+		const value = match[0];
+		const start = match.index;
+		const token = classifyToken(value, start, start + value.length);
+		if (token) tokens.push(token);
+	}
+	return tokens;
+}
+function classifyToken(value, start, end) {
+	if (value === "|>") return {
+		type: "Pipe",
+		value,
+		start,
+		end
+	};
+	if (value === "?.") return {
+		type: "OptionalChain",
+		value,
+		start,
+		end
+	};
+	if (value === "??") return {
+		type: "NullishCoalescing",
+		value,
+		start,
+		end
+	};
+	if (value === "...") return {
+		type: "Spread",
+		value,
+		start,
+		end
+	};
+	if (value === "true" || value === "false") return {
+		type: "Boolean",
+		value,
+		start,
+		end
+	};
+	if (value === "null") return {
+		type: "Null",
+		value,
+		start,
+		end
+	};
+	if (value === "undefined") return {
+		type: "Undefined",
+		value,
+		start,
+		end
+	};
+	if (/^[a-zA-Z_$]/u.test(value)) return {
+		type: "Identifier",
+		value,
+		start,
+		end
+	};
+	if (/^\d/u.test(value)) return {
+		type: "Number",
+		value,
+		start,
+		end
+	};
+	if (value.startsWith("\"") || value.startsWith("'")) return {
+		type: "String",
+		value,
+		start,
+		end
+	};
+	if (value.startsWith("`")) return {
+		type: "TemplateLiteral",
+		value,
+		start,
+		end
+	};
+	if (value.length === 1 && "(){}[],:?.".includes(value)) return {
+		type: "Punctuation",
+		value,
+		start,
+		end
+	};
+	if ("+-*/%!=<>&|".includes(value[0]) || value === "**") return {
+		type: "Operator",
+		value,
+		start,
+		end
+	};
+	return null;
+}
+//#endregion
+//#region src/autocomplete/context.ts
+/** Extract prefix from any non-none CursorContext. */
+function getPrefix(ctx) {
+	return ctx.kind !== "none" ? ctx.prefix : "";
+}
+const OPERATOR_TYPES = new Set(["Operator", "NullishCoalescing"]);
+function tokenKey(t) {
+	return t.type === "Punctuation" ? `${t.type}:${t.value}` : t.type;
+}
+const LAMBDA_TRIGGERS = new Set([
+	"Punctuation:(",
+	"Punctuation:,",
+	"Punctuation:?",
+	"Punctuation::"
+]);
+const VALUE_PRODUCERS = new Set([
+	"Identifier",
+	"Number",
+	"String",
+	"Boolean",
+	"Punctuation:)",
+	"Punctuation:]"
+]);
+function classifyCursor(tokens, cursor) {
+	const before = tokens.filter((t) => t.start < cursor);
+	if (before.length === 0) return {
+		kind: "identifier",
+		prefix: ""
+	};
+	const last = before[before.length - 1];
+	const secondLast = before.length >= 2 ? before[before.length - 2] : null;
+	const lastIsPartial = last.type === "Identifier" && last.end >= cursor;
+	if (last.type === "Pipe") return {
+		kind: "pipe-transform",
+		prefix: ""
+	};
+	if (lastIsPartial && secondLast?.type === "Pipe") return {
+		kind: "pipe-transform",
+		prefix: last.value
+	};
+	const state = buildLambdaState(before);
+	const dotToken = lastIsPartial ? secondLast : last;
+	const prefix = lastIsPartial ? last.value : "";
+	if (dotToken && isDot(dotToken)) {
+		const beforeDotIdx = before.indexOf(dotToken);
+		const prevToken = beforeDotIdx > 0 ? before[beforeDotIdx - 1] : null;
+		if (state.depth > 0) {
+			const prevKey = prevToken ? tokenKey(prevToken) : "";
+			if (!prevToken || LAMBDA_TRIGGERS.has(prevKey) || OPERATOR_TYPES.has(prevToken.type)) return {
+				kind: "lambda-start",
+				prefix,
+				depth: state.depth
+			};
+			if (state.lambdaActive[state.depth] && prevToken && VALUE_PRODUCERS.has(tokenKey(prevToken))) return {
+				kind: "lambda-member",
+				prefix,
+				chain: [...state.currentChain],
+				depth: state.depth
+			};
+		}
+		return {
+			kind: "top-level-member",
+			prefix,
+			precedingTokens: before.slice(0, before.indexOf(dotToken))
+		};
+	}
+	if (OPERATOR_TYPES.has(last.type) || last.type === "Punctuation" && "(,".includes(last.value)) return {
+		kind: "identifier",
+		prefix: ""
+	};
+	if (lastIsPartial) {
+		if (!secondLast || OPERATOR_TYPES.has(secondLast.type) || secondLast.type === "Punctuation" && "(,".includes(secondLast.value)) {
+			if (state.depth > 0 && secondLast && (LAMBDA_TRIGGERS.has(tokenKey(secondLast)) || OPERATOR_TYPES.has(secondLast.type))) return {
+				kind: "lambda-start",
+				prefix: last.value,
+				depth: state.depth
+			};
+			return {
+				kind: "identifier",
+				prefix: last.value
+			};
+		}
+	}
+	return { kind: "none" };
+}
+function isDot(t) {
+	return t.type === "Punctuation" && t.value === "." || t.type === "OptionalChain";
+}
+function buildLambdaState(tokens) {
+	let depth = 0;
+	const lambdaActive = {};
+	const currentChain = [];
+	for (let i = 0; i < tokens.length; i++) {
+		const t = tokens[i];
+		if (t.type === "Punctuation" && t.value === "(") {
+			depth++;
+			lambdaActive[depth] = false;
+		} else if (t.type === "Punctuation" && t.value === ")") {
+			delete lambdaActive[depth];
+			depth = Math.max(0, depth - 1);
+		} else if (depth > 0 && isDot(t)) {
+			const prev = i > 0 ? tokens[i - 1] : null;
+			const prevKey = prev ? tokenKey(prev) : "";
+			if (!prev || LAMBDA_TRIGGERS.has(prevKey) || OPERATOR_TYPES.has(prev?.type ?? "")) {
+				lambdaActive[depth] = true;
+				currentChain.length = 0;
+			} else if (lambdaActive[depth] && prev && VALUE_PRODUCERS.has(tokenKey(prev))) {
+				if (prev.type === "Identifier") currentChain.push(prev.value);
+			}
+		}
+	}
+	return {
+		depth,
+		lambdaActive,
+		currentChain
+	};
+}
+//#endregion
+//#region src/autocomplete/catalog.ts
+/** Methods allowed per receiver type. Must stay in sync with isAllowedReceiver in eval-ops.ts. */
+const METHODS_BY_TYPE = {
+	string: [
+		"trim",
+		"trimStart",
+		"trimEnd",
+		"toLowerCase",
+		"toUpperCase",
+		"startsWith",
+		"endsWith",
+		"includes",
+		"indexOf",
+		"lastIndexOf",
+		"slice",
+		"substring",
+		"at",
+		"replace",
+		"replaceAll",
+		"split",
+		"padStart",
+		"padEnd",
+		"charAt",
+		"charCodeAt",
+		"repeat",
+		"concat",
+		"toString"
+	],
+	array: [
+		"filter",
+		"map",
+		"find",
+		"findIndex",
+		"some",
+		"every",
+		"flatMap",
+		"join",
+		"flat",
+		"includes",
+		"indexOf",
+		"lastIndexOf",
+		"slice",
+		"at",
+		"concat",
+		"toReversed",
+		"toSorted",
+		"toSpliced",
+		"with",
+		"toString"
+	],
+	number: ["toFixed", "toString"]
+};
+/** Return type keyed by "receiverType.method" to disambiguate shared method names. */
+const RETURN_TYPES = {
+	"string.trim": "string",
+	"string.trimStart": "string",
+	"string.trimEnd": "string",
+	"string.toLowerCase": "string",
+	"string.toUpperCase": "string",
+	"string.slice": "string",
+	"string.substring": "string",
+	"string.replace": "string",
+	"string.replaceAll": "string",
+	"string.padStart": "string",
+	"string.padEnd": "string",
+	"string.charAt": "string",
+	"string.repeat": "string",
+	"string.concat": "string",
+	"string.split": "array",
+	"string.indexOf": "number",
+	"string.lastIndexOf": "number",
+	"string.charCodeAt": "number",
+	"string.startsWith": "boolean",
+	"string.endsWith": "boolean",
+	"string.includes": "boolean",
+	"string.at": "string",
+	"string.toString": "string",
+	"array.filter": "array",
+	"array.map": "array",
+	"array.flat": "array",
+	"array.flatMap": "array",
+	"array.concat": "array",
+	"array.slice": "array",
+	"array.toReversed": "array",
+	"array.toSorted": "array",
+	"array.toSpliced": "array",
+	"array.find": "unknown",
+	"array.findIndex": "number",
+	"array.some": "boolean",
+	"array.every": "boolean",
+	"array.join": "string",
+	"array.indexOf": "number",
+	"array.lastIndexOf": "number",
+	"array.includes": "boolean",
+	"array.at": "unknown",
+	"array.with": "array",
+	"array.toString": "string",
+	"number.toFixed": "string",
+	"number.toString": "string"
+};
+/** Look up the return type for a method call on a given receiver type. */
+function getMethodReturnType(receiverType, method) {
+	const key = `${receiverType}.${method}`;
+	return key in RETURN_TYPES ? RETURN_TYPES[key] : void 0;
+}
+/** Type guard: narrows an InferredTypeName to MethodReceiverType (types that have method catalogs). */
+function isMethodReceiverType(t) {
+	return t in METHODS_BY_TYPE;
+}
+/** Re-export shared blocked names for use in completion filtering. */
+const BLOCKED_NAMES = BLOCKED_PROPERTIES;
+const KEYWORDS = [
+	"true",
+	"false",
+	"null",
+	"undefined",
+	"in",
+	"not in"
+];
+//#endregion
+//#region src/autocomplete/inference.ts
+function inferType(value) {
+	if (value === null) return "null";
+	if (value === void 0) return "undefined";
+	if (Array.isArray(value)) return "array";
+	const t = typeof value;
+	if (t === "string" || t === "number" || t === "boolean") return t;
+	return "object";
+}
+function resolvePropertyChain(context, chain, policy) {
+	let current = context;
+	for (const key of chain) {
+		if (BLOCKED_PROPERTIES.has(key)) return {
+			found: false,
+			reason: "blocked"
+		};
+		if (policy?.allowedProperties && !policy.allowedProperties.has(key)) return {
+			found: false,
+			reason: "blocked"
+		};
+		if (policy?.deniedProperties?.has(key)) return {
+			found: false,
+			reason: "blocked"
+		};
+		if (current == null || typeof current !== "object") return {
+			found: false,
+			reason: "not-object"
+		};
+		const obj = current;
+		if (!(key in obj)) return {
+			found: false,
+			reason: "not-found"
+		};
+		current = obj[key];
+	}
+	return {
+		found: true,
+		value: current
+	};
+}
+function inferElementType(array) {
+	const first = array.find((el) => el != null);
+	if (first === void 0) return {
+		type: "unknown",
+		properties: [],
+		value: void 0
+	};
+	const type = inferType(first);
+	if (type === "object" && first !== null && typeof first === "object") return {
+		type: "object",
+		properties: Object.keys(first),
+		value: first
+	};
+	if (type === "array") return {
+		type: "array",
+		properties: [],
+		value: first
+	};
+	if (type === "string") return {
+		type: "string",
+		properties: [],
+		value: first
+	};
+	if (type === "number") return {
+		type: "number",
+		properties: [],
+		value: first
+	};
+	if (type === "boolean") return {
+		type: "boolean",
+		properties: [],
+		value: first
+	};
+	return {
+		type: "unknown",
+		properties: [],
+		value: void 0
+	};
+}
+function inferMethodReturnType(receiverType, method) {
+	return getMethodReturnType(receiverType, method) ?? "unknown";
+}
+//#endregion
+//#region src/autocomplete/completions.ts
+const LAMBDA_METHODS = new Set([
+	"filter",
+	"map",
+	"find",
+	"findIndex",
+	"some",
+	"every",
+	"flatMap"
+]);
+const PREVIEW_MAX_LENGTH = 20;
+const METHOD_COMPLETIONS_BY_TYPE = {};
+for (const [type, methods] of Object.entries(METHODS_BY_TYPE)) METHOD_COMPLETIONS_BY_TYPE[type] = methods.filter((m) => !BLOCKED_NAMES.has(m)).map((method) => {
+	const returnType = getMethodReturnType(type, method);
+	const detail = returnType ? `${type} → ${returnType}` : type;
+	const isLambda = LAMBDA_METHODS.has(method);
+	const insert = isLambda ? `${method}(.)` : `${method}()`;
+	return {
+		label: method,
+		kind: "method",
+		detail,
+		insertText: insert,
+		cursorOffset: isLambda ? insert.length - 2 : insert.length - 1,
+		sortPriority: 1
+	};
+});
+function generateCompletions(ctx, env) {
+	const results = [];
+	switch (ctx.kind) {
+		case "top-level-member":
+		case "lambda-member":
+			addPropertyCompletions(results, env);
+			addMethodCompletions(results, env);
+			break;
+		case "lambda-start":
+			addLambdaPropertyCompletions(results, env);
+			break;
+		case "pipe-transform":
+			for (const name of env.transforms) {
+				if (env.pipe?.inputType && env.pipe.transformTypes) {
+					const accepts = env.pipe.transformTypes[name];
+					if (Array.isArray(accepts) && !accepts.includes(env.pipe.inputType)) continue;
+				}
+				results.push({
+					label: name,
+					kind: "transform",
+					sortPriority: 0
+				});
+			}
+			break;
+		case "identifier":
+			addIdentifierCompletions(results, env);
+			break;
+		case "none": break;
+	}
+	return filterAndRank(results, getPrefix(ctx));
+}
+function addPropertyCompletions(results, env) {
+	const value = env.member?.resolvedValue;
+	if (value == null || typeof value !== "object") return;
+	const obj = value;
+	const keys = Object.keys(obj);
+	for (const key of keys) {
+		if (isBlocked(key, env.policy)) continue;
+		const propValue = obj[key];
+		const valueType = inferType(propValue);
+		results.push({
+			label: key,
+			kind: "property",
+			detail: valueType,
+			sortPriority: 0
+		});
+	}
+}
+function addMethodCompletions(results, env) {
+	const type = env.member?.resolvedType;
+	if (!type || !isMethodReceiverType(type)) return;
+	const cached = METHOD_COMPLETIONS_BY_TYPE[type];
+	if (!cached) return;
+	if (env.policy.deniedProperties) {
+		for (const c of cached) if (!env.policy.deniedProperties.has(c.label)) results.push(c);
+	} else for (const c of cached) results.push(c);
+}
+function addLambdaPropertyCompletions(results, env) {
+	if (!env.lambda?.elementProperties) return;
+	for (const prop of env.lambda.elementProperties) {
+		if (isBlocked(prop, env.policy)) continue;
+		const valueType = env.lambda.elementValue ? inferType(env.lambda.elementValue[prop]) : void 0;
+		results.push({
+			label: prop,
+			kind: "property",
+			detail: valueType,
+			sortPriority: 0
+		});
+	}
+}
+function addIdentifierCompletions(results, env) {
+	if (env.identifier) for (const key of env.identifier.contextKeys) {
+		const value = env.identifier.contextValues[key];
+		const valueType = inferType(value);
+		let detail = valueType;
+		if (valueType === "string" && typeof value === "string") detail = value.length > PREVIEW_MAX_LENGTH ? `"${value.slice(0, PREVIEW_MAX_LENGTH)}…"` : `"${value}"`;
+		else if (valueType === "number") detail = String(value);
+		else if (valueType === "boolean") detail = String(value);
+		else if (valueType === "array" && Array.isArray(value)) detail = `array(${value.length})`;
+		results.push({
+			label: key,
+			kind: "variable",
+			detail,
+			sortPriority: 0
+		});
+	}
+	for (const name of env.functions) {
+		const insert = `${name}()`;
+		results.push({
+			label: name,
+			kind: "function",
+			insertText: insert,
+			cursorOffset: insert.length - 1,
+			sortPriority: 1
+		});
+	}
+	for (const kw of KEYWORDS) results.push({
+		label: kw,
+		kind: "keyword",
+		sortPriority: 2
+	});
+}
+function isBlocked(name, policy) {
+	if (BLOCKED_NAMES.has(name)) return true;
+	if (policy.allowedProperties && !policy.allowedProperties.has(name)) return true;
+	if (policy.deniedProperties && policy.deniedProperties.has(name)) return true;
+	return false;
+}
+const EXACT_MATCH_BOOST = 20;
+const PREFIX_MATCH_BOOST = 15;
+const FUZZY_MATCH_BOOST = 5;
+const SCORE_EXACT = 1e3;
+const SCORE_PREFIX_BASE = 500;
+const SCORE_PREFIX_PER_CHAR = 10;
+const SCORE_CONTAINS_BASE = 200;
+const SCORE_CONTAINS_PER_CHAR = 5;
+const SCORE_CHAR_MATCH = 10;
+const SCORE_CONSECUTIVE_BONUS = 15;
+const SCORE_BOUNDARY_BONUS = 10;
+/**
+* Fuzzy match score. Returns 0 for no match, higher = better match.
+* Rewards: consecutive matches, matches at word boundaries (camelCase), matches at start.
+*/
+function fuzzyScore(label, query) {
+	const labelLower = label.toLowerCase();
+	const queryLower = query.toLowerCase();
+	if (label === query) return SCORE_EXACT;
+	if (labelLower.startsWith(queryLower)) return SCORE_PREFIX_BASE + query.length * SCORE_PREFIX_PER_CHAR;
+	if (labelLower.includes(queryLower)) return SCORE_CONTAINS_BASE + query.length * SCORE_CONTAINS_PER_CHAR;
+	let qi = 0;
+	let score = 0;
+	let prevMatchIdx = -2;
+	for (let li = 0; li < label.length && qi < queryLower.length; li++) if (labelLower[li] === queryLower[qi]) {
+		qi++;
+		score += SCORE_CHAR_MATCH;
+		if (li === prevMatchIdx + 1) score += SCORE_CONSECUTIVE_BONUS;
+		if (li === 0 || label[li] === label[li].toUpperCase() && label[li] !== label[li].toLowerCase()) score += SCORE_BOUNDARY_BONUS;
+		prevMatchIdx = li;
+	}
+	if (qi < queryLower.length) return 0;
+	return score;
+}
+function filterAndRank(results, prefix) {
+	if (!prefix) return results.sort(comparator);
+	const scored = [];
+	for (const c of results) {
+		const score = fuzzyScore(c.label, prefix);
+		if (score === 0) continue;
+		let boost = 0;
+		if (score >= SCORE_EXACT) boost = EXACT_MATCH_BOOST;
+		else if (score >= SCORE_PREFIX_BASE) boost = PREFIX_MATCH_BOOST;
+		else if (score >= SCORE_CONTAINS_BASE) boost = FUZZY_MATCH_BOOST;
+		scored.push({
+			completion: {
+				...c,
+				sortPriority: c.sortPriority - boost
+			},
+			score
+		});
+	}
+	scored.sort((a, b) => {
+		if (a.score !== b.score) return b.score - a.score;
+		if (a.completion.sortPriority !== b.completion.sortPriority) return a.completion.sortPriority - b.completion.sortPriority;
+		if (a.completion.label.length !== b.completion.label.length) return a.completion.label.length - b.completion.label.length;
+		if (a.completion.label < b.completion.label) return -1;
+		if (a.completion.label > b.completion.label) return 1;
+		return 0;
+	});
+	return scored.map((s) => s.completion);
+}
+function comparator(a, b) {
+	if (a.sortPriority !== b.sortPriority) return a.sortPriority - b.sortPriority;
+	if (a.label.length !== b.label.length) return a.label.length - b.label.length;
+	if (a.label < b.label) return -1;
+	if (a.label > b.label) return 1;
+	return 0;
+}
+//#endregion
+//#region src/autocomplete/index.ts
+const VALID_IDENTIFIER = /^[a-zA-Z_$][\w$]*$/u;
+/** Check if an error is an expected Bonsai error (syntax, security, type, or reference). */
+function isExpectedError(err) {
+	return err instanceof ExpressionError || err instanceof BonsaiSecurityError || err instanceof BonsaiTypeError || err instanceof BonsaiReferenceError;
+}
+function createAutocomplete(instance, options = {}) {
+	let context = options.context ?? {};
+	const probeCache = /* @__PURE__ */ new Map();
+	const onError = options.onError;
+	const rawPolicy = instance.getPolicy();
+	const policy = {
+		allowedProperties: rawPolicy.allowedProperties ? new Set(rawPolicy.allowedProperties) : void 0,
+		deniedProperties: rawPolicy.deniedProperties ? new Set(rawPolicy.deniedProperties) : void 0
+	};
+	const resolvePolicy = {
+		allowedProperties: policy.allowedProperties,
+		deniedProperties: policy.deniedProperties
+	};
+	return {
+		complete(expression, cursor) {
+			try {
+				return completeInner(expression, cursor);
+			} catch (err) {
+				onError?.(err, "complete");
+				return [];
+			}
+		},
+		setContext(newContext) {
+			context = newContext ?? {};
+		}
+	};
+	function completeInner(expression, cursor) {
+		cursor = Math.max(0, Math.min(cursor, expression.length));
+		if (isCursorInsideString(expression, cursor)) return [];
+		const { tokens } = tolerantTokenize(expression, cursor, onError);
+		const cursorCtx = classifyCursor(tokens, cursor);
+		if (cursorCtx.kind === "none") return [];
+		const env = {
+			transforms: [],
+			functions: [],
+			policy
+		};
+		if (cursorCtx.kind === "pipe-transform") {
+			const transforms = instance.listTransforms();
+			env.transforms = transforms;
+			const inputType = inferPipeInputType(expression, cursor, instance, context, onError);
+			env.pipe = {
+				inputType,
+				transformTypes: options.transformTypes
+			};
+			if (inputType && !options.transformTypes) {
+				const accepted = probeAcceptedTransforms(instance, inputType, probeCache, transforms, onError);
+				env.transforms = transforms.filter((name) => accepted.has(name));
+			}
+		} else if (cursorCtx.kind === "top-level-member") {
+			const chain = extractChainFromTokens(cursorCtx.precedingTokens);
+			if (chain.length > 0) {
+				const result = resolvePropertyChain(context, chain, resolvePolicy);
+				if (result.found) env.member = {
+					resolvedValue: result.value,
+					resolvedType: inferType(result.value)
+				};
+				else if (cursorCtx.prefix === "") {
+					const evalResult = tryEvalPrefix(expression, cursor, instance, context, tokens, onError);
+					if (evalResult !== void 0) env.member = {
+						resolvedValue: evalResult,
+						resolvedType: inferType(evalResult)
+					};
+				} else {
+					const inferred = inferTypeFromTokenChain(cursorCtx.precedingTokens, context, resolvePolicy);
+					if (inferred) env.member = { resolvedType: inferred };
+				}
+			} else if (cursorCtx.prefix === "") {
+				const evalResult = tryEvalPrefix(expression, cursor, instance, context, tokens, onError);
+				if (evalResult !== void 0) env.member = {
+					resolvedValue: evalResult,
+					resolvedType: inferType(evalResult)
+				};
+			}
+		} else if (cursorCtx.kind === "lambda-member") {
+			const arrTokens = extractChainBeforeCall(tokens, cursor);
+			const arrResult = resolvePropertyChain(context, arrTokens, resolvePolicy);
+			if (arrResult.found && Array.isArray(arrResult.value)) {
+				const elemInfo = inferElementType(arrResult.value);
+				if (elemInfo.type === "object") {
+					const resolved = resolvePropertyChain(elemInfo.value, cursorCtx.chain, resolvePolicy);
+					if (resolved.found) env.member = {
+						resolvedValue: resolved.value,
+						resolvedType: inferType(resolved.value)
+					};
+				} else if (elemInfo.type !== "unknown") env.member = { resolvedType: inferType(elemInfo.value) };
+			}
+		} else if (cursorCtx.kind === "lambda-start") {
+			const arrTokens = extractChainBeforeCall(tokens, cursor);
+			let resolved = false;
+			if (arrTokens.length > 0) {
+				const arrResult = resolvePropertyChain(context, arrTokens, resolvePolicy);
+				if (arrResult.found && Array.isArray(arrResult.value)) {
+					const elemInfo = inferElementType(arrResult.value);
+					env.lambda = {
+						elementProperties: elemInfo.properties,
+						elementValue: elemInfo.type === "object" ? elemInfo.value : void 0
+					};
+					resolved = true;
+				}
+			}
+			if (!resolved) {
+				const nestedArr = tryResolveNestedLambdaArray(tokens, cursor, context, resolvePolicy);
+				if (nestedArr) {
+					const elemInfo = inferElementType(nestedArr);
+					env.lambda = {
+						elementProperties: elemInfo.properties,
+						elementValue: elemInfo.type === "object" ? elemInfo.value : void 0
+					};
+				}
+			}
+		} else if (cursorCtx.kind === "identifier") {
+			env.functions = instance.listFunctions();
+			env.identifier = {
+				contextKeys: Object.keys(context),
+				contextValues: context
+			};
+		}
+		return generateCompletions(cursorCtx, env);
+	}
+}
+/**
+* Try to evaluate the expression up to the cursor to get the actual runtime type.
+* This handles method chains like `user.name.trim().` where static resolution can't
+* know that trim() returns a string.
+*/
+function tryEvalPrefix(expression, cursor, instance, context, tokens, onError) {
+	const before = tokens.filter((t) => t.end <= cursor);
+	if (before.length === 0) return void 0;
+	let endIdx = before.length - 1;
+	if (before[endIdx].type === "Punctuation" && before[endIdx].value === "." || before[endIdx].type === "OptionalChain") endIdx--;
+	if (endIdx < 0) return void 0;
+	const exprEnd = before[endIdx].end;
+	const exprText = expression.slice(0, exprEnd);
+	if (!exprText.trim()) return void 0;
+	try {
+		return instance.evaluateSync(exprText, context);
+	} catch (err) {
+		if (!isExpectedError(err)) onError?.(err, "tryEvalPrefix");
+		return;
+	}
+}
+/**
+* Infer the type by walking the token chain and using the return type map.
+* Handles: user.name.trim(). → string (because trim returns string)
+*/
+function inferTypeFromTokenChain(tokens, context, resolveOpts) {
+	let currentType;
+	const chain = [];
+	let i = 0;
+	for (; i < tokens.length; i++) if (tokens[i].type === "Identifier") chain.push(tokens[i].value);
+	else if (tokens[i].type === "Punctuation" && tokens[i].value === "." || tokens[i].type === "OptionalChain") continue;
+	else if (tokens[i].type === "Punctuation" && tokens[i].value === "(") {
+		const methodName = chain.pop();
+		if (!methodName) break;
+		if (currentType === void 0 && chain.length > 0) {
+			const result = resolvePropertyChain(context, chain, resolveOpts);
+			currentType = result.found ? inferType(result.value) : void 0;
+		} else if (currentType !== void 0 && chain.length > 0) currentType = void 0;
+		chain.length = 0;
+		if (currentType && isMethodReceiverType(currentType)) {
+			const returned = inferMethodReturnType(currentType, methodName);
+			currentType = returned === "unknown" ? void 0 : returned;
+		} else currentType = void 0;
+		let depth = 1;
+		i++;
+		while (i < tokens.length && depth > 0) {
+			if (tokens[i].type === "Punctuation" && tokens[i].value === "(") depth++;
+			if (tokens[i].type === "Punctuation" && tokens[i].value === ")") depth--;
+			i++;
+		}
+		i--;
+		continue;
+	} else break;
+	if (currentType !== void 0 && chain.length > 0) return;
+	if (currentType === void 0 && chain.length > 0) {
+		const result = resolvePropertyChain(context, chain, resolveOpts);
+		currentType = result.found ? inferType(result.value) : void 0;
+	}
+	return currentType;
+}
+/**
+* For nested lambdas like `groups.map(.users.filter(.`, resolve the inner array
+* by walking the call stack: find the outermost array from context, get its element,
+* then follow the lambda property chain to find the nested array.
+*/
+function tryResolveNestedLambdaArray(tokens, cursor, context, resolveOpts) {
+	const before = tokens.filter((t) => t.start < cursor);
+	const lambdaChainsByDepth = /* @__PURE__ */ new Map();
+	let depth = 0;
+	let currentChain = [];
+	let inLambda = false;
+	for (let i = 0; i < before.length; i++) {
+		const t = before[i];
+		if (t.type === "Punctuation" && t.value === "(") {
+			if (inLambda && currentChain.length > 0) {
+				const chain = [...currentChain];
+				chain.pop();
+				if (chain.length > 0) lambdaChainsByDepth.set(depth, chain);
+			}
+			depth++;
+			inLambda = false;
+			currentChain = [];
+		} else if (t.type === "Punctuation" && t.value === ")") depth = Math.max(0, depth - 1);
+		else if (depth > 0 && t.type === "Punctuation" && t.value === ".") {
+			const prev = i > 0 ? before[i - 1] : null;
+			if (prev && prev.type === "Punctuation" && (prev.value === "(" || prev.value === ",")) {
+				inLambda = true;
+				currentChain = [];
+			}
+		} else if (inLambda && t.type === "Identifier") currentChain.push(t.value);
+	}
+	if (inLambda && currentChain.length > 0) lambdaChainsByDepth.set(depth, [...currentChain]);
+	let outerParenIdx = -1;
+	for (let i = 0; i < before.length; i++) if (before[i].type === "Punctuation" && before[i].value === "(" && i >= 2) {
+		const prev = before[i - 1];
+		const prevPrev = before[i - 2];
+		if (prev.type === "Identifier" && (prevPrev.type === "Punctuation" && prevPrev.value === "." || prevPrev.type === "OptionalChain" || prevPrev.type === "Pipe")) {
+			outerParenIdx = i;
+			break;
+		}
+	}
+	if (outerParenIdx <= 0) return void 0;
+	const chain = extractChainBeforeOuterCall(before, outerParenIdx);
+	if (chain.length === 0) return void 0;
+	const outerResult = resolvePropertyChain(context, chain, resolveOpts);
+	if (!outerResult.found || !Array.isArray(outerResult.value)) return void 0;
+	let currentValue = outerResult.value;
+	for (let d = 1; d <= depth; d++) {
+		const elemInfo = inferElementType(currentValue);
+		if (elemInfo.type !== "object") return void 0;
+		const lambdaChain = lambdaChainsByDepth.get(d);
+		if (!lambdaChain || lambdaChain.length === 0) return currentValue;
+		const nestedResult = resolvePropertyChain(elemInfo.value, lambdaChain, resolveOpts);
+		if (!nestedResult.found || !Array.isArray(nestedResult.value)) return void 0;
+		currentValue = nestedResult.value;
+	}
+	return Array.isArray(currentValue) ? currentValue : void 0;
+}
+const PROBE_CACHE_MAX = 32;
+const TYPE_SAMPLES = {
+	string: "sample",
+	number: 42,
+	boolean: true,
+	array: [0],
+	object: {}
+};
+function probeAcceptedTransforms(instance, inputType, cache, currentTransforms, onError) {
+	const cacheKey = `${inputType}:${[...currentTransforms].sort().join(",")}`;
+	const cached = cache.get(cacheKey);
+	if (cached) return cached;
+	const sample = TYPE_SAMPLES[inputType];
+	if (sample === void 0) return new Set(currentTransforms);
+	const accepted = /* @__PURE__ */ new Set();
+	for (const name of currentTransforms) {
+		if (!VALID_IDENTIFIER.test(name)) continue;
+		try {
+			instance.evaluateSync(`x |> ${name}`, { x: sample });
+			accepted.add(name);
+		} catch (err) {
+			if (!isExpectedError(err)) onError?.(err, `probeTransform:${name}`);
+		}
+	}
+	if (cache.size >= PROBE_CACHE_MAX) {
+		const first = cache.keys().next();
+		if (!first.done) cache.delete(first.value);
+	}
+	cache.set(cacheKey, accepted);
+	return accepted;
+}
+function inferPipeInputType(expression, cursor, instance, context, onError) {
+	const pipeMatch = expression.slice(0, cursor).match(/^(?<input>.*)\|>\s*\w*\s*$/su);
+	if (!pipeMatch) return void 0;
+	const exprBefore = (pipeMatch.groups?.input ?? "").trim();
+	if (!exprBefore) return void 0;
+	try {
+		const result = instance.evaluateSync(exprBefore, context);
+		if (result === null || result === void 0) return void 0;
+		return inferType(result);
+	} catch (err) {
+		if (!isExpectedError(err)) onError?.(err, "inferPipeInputType");
+		return;
+	}
+}
+/** Extract trailing identifier.dot chain from a token array (walking backward). */
+function extractChainFromTokens(tokens) {
+	const chain = [];
+	for (let i = tokens.length - 1; i >= 0; i--) {
+		const t = tokens[i];
+		if (t.type === "Identifier") chain.unshift(t.value);
+		else if (t.type === "Punctuation" && t.value === "." || t.type === "OptionalChain") continue;
+		else break;
+	}
+	return chain;
+}
+/** Extract the identifier chain before the outermost call's open paren. */
+function extractChainBeforeOuterCall(before, outerParenIdx) {
+	const chain = [];
+	let walkIdx = outerParenIdx - 1;
+	if (walkIdx >= 0 && before[walkIdx].type === "Identifier") walkIdx--;
+	if (walkIdx >= 0) {
+		const sep = before[walkIdx];
+		if (sep.type === "Punctuation" && sep.value === "." || sep.type === "OptionalChain" || sep.type === "Pipe") walkIdx--;
+	}
+	if (walkIdx >= 0 && before[walkIdx].type === "Punctuation" && before[walkIdx].value === ")") {
+		let parenDepth = 1;
+		walkIdx--;
+		while (walkIdx >= 0 && parenDepth > 0) {
+			if (before[walkIdx].type === "Punctuation" && before[walkIdx].value === ")") parenDepth++;
+			if (before[walkIdx].type === "Punctuation" && before[walkIdx].value === "(") parenDepth--;
+			walkIdx--;
+		}
+	}
+	for (let i = walkIdx; i >= 0; i--) if (before[i].type === "Identifier") chain.unshift(before[i].value);
+	else if (before[i].type === "Punctuation" && before[i].value === "." || before[i].type === "OptionalChain") continue;
+	else break;
+	return chain;
+}
+function extractChainBeforeCall(tokens, cursor) {
+	const before = tokens.filter((t) => t.start < cursor);
+	let parenIdx = -1;
+	let depth = 0;
+	for (let i = before.length - 1; i >= 0; i--) {
+		if (before[i].type === "Punctuation" && before[i].value === ")") depth++;
+		if (before[i].type === "Punctuation" && before[i].value === "(") {
+			if (depth === 0) {
+				parenIdx = i;
+				break;
+			}
+			depth--;
+		}
+	}
+	if (parenIdx <= 0) return [];
+	const methodToken = before[parenIdx - 1];
+	if (!methodToken || methodToken.type !== "Identifier") return [];
+	const preMethodIdx = parenIdx - 2;
+	if (preMethodIdx < 0) return [];
+	const preMethodToken = before[preMethodIdx];
+	if (preMethodToken.type === "Punctuation" && preMethodToken.value === "." || preMethodToken.type === "OptionalChain" || preMethodToken.type === "Pipe") return extractChainFromTokens(before.slice(0, preMethodIdx));
+	return [];
+}
+//#endregion
+export { createAutocomplete };
+
+//# sourceMappingURL=index.mjs.map