devframe 0.0.0 → 0.1.16

package/dist/types/index.d.mts

@@ -0,0 +1,4 @@
+import { $ as DevToolsLogsHost, A as DevToolsViewHost, At as AgentHandle, B as DevToolsTerminalStatus, Bt as EventUnsubscribe, Ct as DevToolsCommandHandle, Dt as DevToolsCommandsHostEvents, Et as DevToolsCommandsHost, F as DevToolsChildProcessTerminalSession, Ft as AgentTool, G as DevToolsLogElementPosition, H as DevToolsRpcClientFunctions, I as DevToolsTerminalHost, It as AgentToolInput, J as DevToolsLogEntryInput, K as DevToolsLogEntry, L as DevToolsTerminalSession, Lt as DevToolsAgentHost, M as PartialWithoutId, Mt as AgentResource, N as Thenable, Nt as AgentResourceContent, Ot as DevToolsServerCommandEntry, P as DevToolsChildProcessExecuteOptions, Pt as AgentResourceInput, Q as DevToolsLogsClient, R as DevToolsTerminalSessionBase, Rt as DevToolsAgentHostEvents, St as DevToolsCommandEntry, Tt as DevToolsCommandShortcutOverrides, U as DevToolsRpcServerFunctions, V as DevToolsDocksUserSettings, Vt as EventsMap, W as DevToolsRpcSharedStates, X as DevToolsLogHandle, Y as DevToolsLogFilePosition, Z as DevToolsLogLevel, _ as RpcSharedStateGetOptions, _t as JsonRenderSpec, a as DevtoolRuntime, at as DevToolsDockEntryCategory, bt as DevToolsClientCommand, c as defineDevtool, ct as DevToolsDockUserEntry, d as DevToolsNodeContext, dt as DevToolsViewCustomRender, et as DevToolsHost, f as DevToolsNodeUtils, ft as DevToolsViewIframe, g as RpcFunctionsHost, gt as JsonRenderElement, h as RpcBroadcastOptions, ht as DevToolsViewLauncherStatus, i as DevtoolDeploymentKind, it as DevToolsDockEntryBase, j as EntriesToObject, jt as AgentManifest, kt as DevToolsServerCommandInput, l as ConnectionMeta, lt as DevToolsViewAction, m as DevToolsNodeRpcSession, mt as DevToolsViewLauncher, n as DevtoolCliOptions, nt as DevToolsDockEntriesGrouped, o as DevtoolSetupInfo, ot as DevToolsDockEntryIcon, p as RemoteConnectionInfo, pt as DevToolsViewJsonRender, q as DevToolsLogEntryFrom, r as DevtoolDefinition, rt as DevToolsDockEntry, s as DevtoolSpaOptions, st as DevToolsDockHost, t as DevtoolBrowserContext, tt as ClientScriptEntry, u as DevToolsCapabilities, ut as DevToolsViewBuiltin, v as RpcSharedStateHost, vt as JsonRenderer, wt as DevToolsCommandKeybinding, xt as DevToolsCommandBase, yt as RemoteDockOptions, z as DevToolsTerminalSessionStreamChunkEvent, zt as EventEmitter } from "../devtool-OJ3QW0ns.mjs";
+import { w as RpcFunctionAgentOptions } from "../index-DvKDO5H8.mjs";
+import { t as DevToolsNodeRpcSessionMeta } from "../ws-server--IuUAaGi.mjs";
+export { AgentHandle, AgentManifest, AgentResource, AgentResourceContent, AgentResourceInput, AgentTool, AgentToolInput, ClientScriptEntry, ConnectionMeta, DevToolsAgentHost, DevToolsAgentHostEvents, DevToolsCapabilities, DevToolsChildProcessExecuteOptions, DevToolsChildProcessTerminalSession, DevToolsClientCommand, DevToolsCommandBase, DevToolsCommandEntry, DevToolsCommandHandle, DevToolsCommandKeybinding, DevToolsCommandShortcutOverrides, DevToolsCommandsHost, DevToolsCommandsHostEvents, DevToolsDockEntriesGrouped, DevToolsDockEntry, DevToolsDockEntryBase, DevToolsDockEntryCategory, DevToolsDockEntryIcon, DevToolsDockHost, DevToolsDockUserEntry, DevToolsDocksUserSettings, DevToolsHost, DevToolsLogElementPosition, DevToolsLogEntry, DevToolsLogEntryFrom, DevToolsLogEntryInput, DevToolsLogFilePosition, DevToolsLogHandle, DevToolsLogLevel, DevToolsLogsClient, DevToolsLogsHost, DevToolsNodeContext, DevToolsNodeRpcSession, DevToolsNodeRpcSessionMeta, DevToolsNodeUtils, DevToolsRpcClientFunctions, DevToolsRpcServerFunctions, DevToolsRpcSharedStates, DevToolsServerCommandEntry, DevToolsServerCommandInput, DevToolsTerminalHost, DevToolsTerminalSession, DevToolsTerminalSessionBase, DevToolsTerminalSessionStreamChunkEvent, DevToolsTerminalStatus, DevToolsViewAction, DevToolsViewBuiltin, DevToolsViewCustomRender, DevToolsViewHost, DevToolsViewIframe, DevToolsViewJsonRender, DevToolsViewLauncher, DevToolsViewLauncherStatus, DevtoolBrowserContext, DevtoolCliOptions, DevtoolDefinition, DevtoolDeploymentKind, DevtoolRuntime, DevtoolSetupInfo, DevtoolSpaOptions, EntriesToObject, EventEmitter, EventUnsubscribe, EventsMap, JsonRenderElement, JsonRenderSpec, JsonRenderer, PartialWithoutId, RemoteConnectionInfo, RemoteDockOptions, RpcBroadcastOptions, RpcFunctionAgentOptions, RpcFunctionsHost, RpcSharedStateGetOptions, RpcSharedStateHost, Thenable, defineDevtool };

package/dist/types/index.mjs

@@ -0,0 +1,6 @@
+//#region src/types/devtool.ts
+function defineDevtool(d) {
+	return d;
+}
+//#endregion
+export { defineDevtool };

package/dist/utils/events.d.mts

@@ -0,0 +1,9 @@
+import { Vt as EventsMap, zt as EventEmitter } from "../devtool-OJ3QW0ns.mjs";
+
+//#region src/utils/events.d.ts
+/**
+ * Create event emitter.
+ */
+declare function createEventEmitter<Events extends EventsMap>(): EventEmitter<Events>;
+//#endregion
+export { createEventEmitter };

package/dist/utils/events.mjs

@@ -0,0 +1,40 @@
+//#region src/utils/events.ts
+/**
+* Create event emitter.
+*/
+function createEventEmitter() {
+	const _listeners = {};
+	function emit(event, ...args) {
+		const callbacks = _listeners[event] || [];
+		for (let i = 0, length = callbacks.length; i < length; i++) {
+			const callback = callbacks[i];
+			if (callback) callback(...args);
+		}
+	}
+	function emitOnce(event, ...args) {
+		emit(event, ...args);
+		delete _listeners[event];
+	}
+	function on(event, cb) {
+		(_listeners[event] ||= []).push(cb);
+		return () => {
+			_listeners[event] = _listeners[event]?.filter((i) => cb !== i);
+		};
+	}
+	function once(event, cb) {
+		const unsubscribe = on(event, ((...args) => {
+			unsubscribe();
+			return cb(...args);
+		}));
+		return unsubscribe;
+	}
+	return {
+		_listeners,
+		emit,
+		emitOnce,
+		on,
+		once
+	};
+}
+//#endregion
+export { createEventEmitter };

package/dist/utils/human-id.d.mts

@@ -0,0 +1,10 @@
+//#region ../../../node_modules/.pnpm/human-id@4.1.3/node_modules/human-id/dist/index.d.ts
+interface Options {
+  separator?: string;
+  capitalize?: boolean;
+  adjectiveCount?: number;
+  addAdverb?: boolean;
+}
+declare function humanId(options?: Options | string | boolean): string;
+//#endregion
+export { humanId };

package/dist/utils/human-id.mjs

@@ -0,0 +1,3 @@
+import { t as import_dist } from "../human-id-CHS0s28X.mjs";
+var humanId = import_dist.humanId;
+export { humanId };

package/dist/utils/nanoid.d.mts

@@ -0,0 +1,4 @@
+//#region src/utils/nanoid.d.ts
+declare function nanoid(size?: number): string;
+//#endregion
+export { nanoid };

package/dist/utils/nanoid.mjs

@@ -0,0 +1,10 @@
+//#region src/utils/nanoid.ts
+const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+function nanoid(size = 21) {
+	let id = "";
+	let i = size;
+	while (i--) id += urlAlphabet[Math.random() * 64 | 0];
+	return id;
+}
+//#endregion
+export { nanoid };

package/dist/utils/promise.d.mts

@@ -0,0 +1,8 @@
+//#region src/utils/promise.d.ts
+declare function promiseWithResolver<T>(): {
+  promise: Promise<T>;
+  resolve: (value: T) => void;
+  reject: (error: Error) => void;
+};
+//#endregion
+export { promiseWithResolver };

package/dist/utils/promise.mjs

@@ -0,0 +1,15 @@
+//#region src/utils/promise.ts
+function promiseWithResolver() {
+	let resolve;
+	let reject;
+	return {
+		promise: new Promise((_resolve, _reject) => {
+			resolve = _resolve;
+			reject = _reject;
+		}),
+		resolve,
+		reject
+	};
+}
+//#endregion
+export { promiseWithResolver };

package/dist/utils/shared-state.d.mts

@@ -0,0 +1,2 @@
+import { C as ImmutableSet, D as createSharedState, E as SharedStateOptions, S as ImmutableObject, T as SharedStateEvents, b as ImmutableArray, k as Patch, w as SharedState, x as ImmutableMap, y as Immutable } from "../devtool-OJ3QW0ns.mjs";
+export { Immutable, ImmutableArray, ImmutableMap, ImmutableObject, ImmutableSet, SharedState, SharedStateEvents, SharedStateOptions, Patch as SharedStatePatch, createSharedState };

package/dist/utils/shared-state.mjs

@@ -0,0 +1,36 @@
+import { createEventEmitter } from "./events.mjs";
+import { i as produceWithPatches, n as enablePatches, r as produce, t as applyPatches } from "../immer-HjMAm3b6.mjs";
+import { nanoid } from "./nanoid.mjs";
+//#region src/utils/shared-state.ts
+function createSharedState(options) {
+	const { enablePatches: enablePatches$1 = false } = options;
+	const events = createEventEmitter();
+	let state = options.initialValue;
+	const syncIds = /* @__PURE__ */ new Set();
+	return {
+		on: events.on,
+		value: () => state,
+		patch: (patches, syncId = nanoid()) => {
+			if (syncIds.has(syncId)) return;
+			enablePatches();
+			state = applyPatches(state, patches);
+			syncIds.add(syncId);
+			events.emit("updated", state, void 0, syncId);
+		},
+		mutate: (fn, syncId = nanoid()) => {
+			if (syncIds.has(syncId)) return;
+			syncIds.add(syncId);
+			if (enablePatches$1) {
+				const [newState, patches] = produceWithPatches(state, fn);
+				state = newState;
+				events.emit("updated", state, patches, syncId);
+			} else {
+				state = produce(state, fn);
+				events.emit("updated", state, void 0, syncId);
+			}
+		},
+		syncIds
+	};
+}
+//#endregion
+export { createSharedState };

package/dist/utils/state.d.mts

@@ -0,0 +1,49 @@
+import { O as Objectish, k as Patch, zt as EventEmitter } from "../devtool-OJ3QW0ns.mjs";
+
+//#region src/utils/state.d.ts
+type ImmutablePrimitive = undefined | null | boolean | string | number | Function;
+type Immutable<T> = T extends ImmutablePrimitive ? T : T extends Array<infer U> ? ImmutableArray<U> : T extends Map<infer K, infer V> ? ImmutableMap<K, V> : T extends Set<infer M> ? ImmutableSet<M> : ImmutableObject<T>;
+type ImmutableArray<T> = ReadonlyArray<Immutable<T>>;
+type ImmutableMap<K, V> = ReadonlyMap<Immutable<K>, Immutable<V>>;
+type ImmutableSet<T> = ReadonlySet<Immutable<T>>;
+type ImmutableObject<T> = { readonly [K in keyof T]: Immutable<T[K]> };
+/**
+ * State host that is immutable by default with explicit mutate.
+ */
+interface SharedState<T> {
+  /**
+   * Get the current state. Immutable.
+   */
+  get: () => Immutable<T>;
+  /**
+   * Subscribe to state changes.
+   */
+  on: EventEmitter<SharedStateEvents<T>>['on'];
+  /**
+   * Mutate the state.
+   */
+  mutate: (fn: (state: T) => void) => void;
+  /**
+   * Apply patches to the state.
+   */
+  patch: (patches: Patch[]) => void;
+}
+interface SharedStateEvents<T> {
+  updated: (state: T) => void;
+  patches: (patches: Patch[]) => void;
+}
+interface SharedStateOptions<T> {
+  /**
+   * Initial state.
+   */
+  initialState: T;
+  /**
+   * Enable patches.
+   *
+   * @default false
+   */
+  enablePatches?: boolean;
+}
+declare function createSharedState<T extends Objectish>(options: SharedStateOptions<T>): SharedState<T>;
+//#endregion
+export { Immutable, ImmutableArray, ImmutableMap, ImmutableObject, ImmutableSet, SharedState, SharedStateEvents, SharedStateOptions, createSharedState };

package/dist/utils/state.mjs

@@ -0,0 +1,26 @@
+import { createEventEmitter } from "./events.mjs";
+import { i as produceWithPatches, r as produce, t as applyPatches } from "../immer-HjMAm3b6.mjs";
+//#region src/utils/state.ts
+function createSharedState(options) {
+	const { enablePatches = false } = options;
+	const events = createEventEmitter();
+	let state = options.initialState;
+	return {
+		on: events.on,
+		get: () => state,
+		patch: (patches) => {
+			state = applyPatches(state, patches);
+			events.emit("updated", state);
+		},
+		mutate: (fn) => {
+			if (enablePatches) {
+				const [newState, patches] = produceWithPatches(state, fn);
+				state = newState;
+				events.emit("patches", patches);
+			} else state = produce(state, fn);
+			events.emit("updated", state);
+		}
+	};
+}
+//#endregion
+export { createSharedState };

package/dist/utils/when.d.mts

@@ -0,0 +1,2 @@
+import { i as resolveContextValue, n as WhenExpression, r as evaluateWhen, t as WhenContext } from "../when-CGLewRtm.mjs";
+export { WhenContext, WhenExpression, evaluateWhen, resolveContextValue };

package/dist/utils/when.mjs

@@ -0,0 +1,424 @@
+//#region ../../../node_modules/.pnpm/whenexpr@0.1.2/node_modules/whenexpr/dist/index.mjs
+const OPS = [
+	"===",
+	"!==",
+	"==",
+	"!=",
+	"<=",
+	">=",
+	"&&",
+	"||",
+	"<",
+	">",
+	"+",
+	"-",
+	"*",
+	"/",
+	"%",
+	"!"
+];
+const IDENT_START = /[a-z_$]/i;
+const IDENT_CONT = /[\w$.:]/;
+const DIGIT = /\d/;
+const WHITESPACE = /\s/;
+function tokenize(input) {
+	const tokens = [];
+	let i = 0;
+	while (i < input.length) {
+		const c = input[i];
+		if (WHITESPACE.test(c)) {
+			i++;
+			continue;
+		}
+		if (c === "(") {
+			tokens.push({ type: "lparen" });
+			i++;
+			continue;
+		}
+		if (c === ")") {
+			tokens.push({ type: "rparen" });
+			i++;
+			continue;
+		}
+		let matched = false;
+		for (const op of OPS) if (input.startsWith(op, i)) {
+			tokens.push({
+				type: "op",
+				value: op
+			});
+			i += op.length;
+			matched = true;
+			break;
+		}
+		if (matched) continue;
+		if (DIGIT.test(c)) {
+			let j = i;
+			while (j < input.length && DIGIT.test(input[j])) j++;
+			if (input[j] === "." && j + 1 < input.length && DIGIT.test(input[j + 1])) {
+				j++;
+				while (j < input.length && DIGIT.test(input[j])) j++;
+			}
+			tokens.push({
+				type: "number",
+				value: Number(input.slice(i, j))
+			});
+			i = j;
+			continue;
+		}
+		if (c === "\"" || c === "'") {
+			const quote = c;
+			let j = i + 1;
+			let value = "";
+			while (j < input.length && input[j] !== quote) if (input[j] === "\\" && j + 1 < input.length) {
+				const nx = input[j + 1];
+				value += nx === "n" ? "\n" : nx === "t" ? "	" : nx;
+				j += 2;
+			} else {
+				value += input[j];
+				j++;
+			}
+			if (j >= input.length) throw new Error(`Unterminated string literal at position ${i}`);
+			j++;
+			tokens.push({
+				type: "string",
+				value
+			});
+			i = j;
+			continue;
+		}
+		if (IDENT_START.test(c)) {
+			let j = i;
+			while (j < input.length && IDENT_CONT.test(input[j])) j++;
+			const name = input.slice(i, j);
+			if (name === "true") tokens.push({
+				type: "bool",
+				value: true
+			});
+			else if (name === "false") tokens.push({
+				type: "bool",
+				value: false
+			});
+			else tokens.push({
+				type: "ident",
+				value: name
+			});
+			i = j;
+			continue;
+		}
+		throw new Error(`Unexpected character "${c}" at position ${i}`);
+	}
+	tokens.push({ type: "eof" });
+	return tokens;
+}
+/**
+* Parse a when-clause expression string into an AST.
+*
+* Grammar (lowest to highest precedence):
+* - `||` — logical OR
+* - `&&` — logical AND
+* - `==`, `!=`, `===`, `!==` — equality
+* - `<`, `>`, `<=`, `>=` — relational
+* - `+`, `-` — additive
+* - `*`, `/`, `%` — multiplicative
+* - `!`, `-`, `+` — unary
+* - primary: literals (number, string, boolean), identifiers, `( … )`
+*
+* `==` and `!=` follow VS Code-style semantics: the right-hand side is a
+* simple value literal or bare identifier (treated as an implicit string),
+* not a full expression. Use `===` / `!==` for JS-style strict equality with
+* full expressions on both sides.
+*/
+function parse(expression) {
+	const tokens = tokenize(expression);
+	let pos = 0;
+	const peek = () => tokens[pos];
+	const consume = () => tokens[pos++];
+	const isOp = (op) => {
+		const t = peek();
+		return t.type === "op" && t.value === op;
+	};
+	const consumeOp = () => {
+		const t = consume();
+		if (t.type !== "op") throw new Error(`internal: expected operator token, got ${tokenLabel(t)}`);
+		return t.value;
+	};
+	function parseOr() {
+		let left = parseAnd();
+		while (isOp("||")) {
+			consume();
+			left = {
+				type: "binary",
+				op: "||",
+				left,
+				right: parseAnd()
+			};
+		}
+		return left;
+	}
+	function parseAnd() {
+		let left = parseEquality();
+		while (isOp("&&")) {
+			consume();
+			left = {
+				type: "binary",
+				op: "&&",
+				left,
+				right: parseEquality()
+			};
+		}
+		return left;
+	}
+	function parseEquality() {
+		let left = parseRelational();
+		while (isOp("===") || isOp("!==") || isOp("==") || isOp("!=")) {
+			const op = consumeOp();
+			const right = op === "==" || op === "!=" ? parseValueRhs() : parseRelational();
+			left = {
+				type: "binary",
+				op,
+				left,
+				right
+			};
+		}
+		return left;
+	}
+	function parseRelational() {
+		let left = parseAdditive();
+		while (isOp("<=") || isOp(">=") || isOp("<") || isOp(">")) left = {
+			type: "binary",
+			op: consumeOp(),
+			left,
+			right: parseAdditive()
+		};
+		return left;
+	}
+	function parseAdditive() {
+		let left = parseMultiplicative();
+		while (isOp("+") || isOp("-")) left = {
+			type: "binary",
+			op: consumeOp(),
+			left,
+			right: parseMultiplicative()
+		};
+		return left;
+	}
+	function parseMultiplicative() {
+		let left = parseUnary();
+		while (isOp("*") || isOp("/") || isOp("%")) left = {
+			type: "binary",
+			op: consumeOp(),
+			left,
+			right: parseUnary()
+		};
+		return left;
+	}
+	function parseUnary() {
+		if (isOp("!") || isOp("-") || isOp("+")) return {
+			type: "unary",
+			op: consumeOp(),
+			operand: parseUnary()
+		};
+		return parsePrimary();
+	}
+	function parsePrimary() {
+		const t = peek();
+		if (t.type === "number" || t.type === "string" || t.type === "bool") {
+			consume();
+			return {
+				type: "literal",
+				value: t.value
+			};
+		}
+		if (t.type === "ident") {
+			consume();
+			return {
+				type: "key",
+				key: t.value
+			};
+		}
+		if (t.type === "lparen") {
+			consume();
+			const node = parseOr();
+			const close = peek();
+			if (close.type !== "rparen") throw new Error(`Expected ")" but got ${tokenLabel(close)}`);
+			consume();
+			return node;
+		}
+		throw new Error(`Unexpected token: ${tokenLabel(t)}`);
+	}
+	function parseValueRhs() {
+		const t = peek();
+		if (t.type === "string") {
+			consume();
+			return {
+				type: "literal",
+				value: t.value
+			};
+		}
+		if (t.type === "number") {
+			consume();
+			return {
+				type: "literal",
+				value: String(t.value)
+			};
+		}
+		if (t.type === "bool") {
+			consume();
+			return {
+				type: "literal",
+				value: String(t.value)
+			};
+		}
+		if (t.type === "ident") {
+			consume();
+			return {
+				type: "literal",
+				value: t.value
+			};
+		}
+		throw new Error(`Expected value literal or identifier on right side of equality, got ${tokenLabel(t)}`);
+	}
+	const node = parseOr();
+	const end = peek();
+	if (end.type !== "eof") throw new Error(`Unexpected token: ${tokenLabel(end)}`);
+	return node;
+}
+function tokenLabel(t) {
+	switch (t.type) {
+		case "eof": return "end of expression";
+		case "lparen": return "\"(\"";
+		case "rparen": return "\")\"";
+		case "op":
+		case "ident":
+		case "string": return `"${t.value}"`;
+		case "number":
+		case "bool": return `"${String(t.value)}"`;
+	}
+}
+/**
+* Evaluate a parsed when-clause AST against a context object.
+*
+* With `{ strict: true }`, referencing an unknown context key throws.
+* Short-circuit evaluation still applies — keys not reached are not checked.
+*/
+function evaluate(node, ctx, options = {}) {
+	const { strict = false } = options;
+	return !!run(node, ctx, strict);
+}
+function run(node, ctx, strict) {
+	switch (node.type) {
+		case "literal": return node.value;
+		case "key": return lookup(node.key, ctx, strict);
+		case "unary": return runUnary(node.op, run(node.operand, ctx, strict));
+		case "binary": return runBinary(node, ctx, strict);
+	}
+}
+function runUnary(op, v) {
+	switch (op) {
+		case "!": return !v;
+		case "-": return -v;
+		case "+": return +v;
+	}
+}
+function runBinary(node, ctx, strict) {
+	const { op } = node;
+	if (op === "&&") {
+		const l = run(node.left, ctx, strict);
+		return l ? run(node.right, ctx, strict) : l;
+	}
+	if (op === "||") return run(node.left, ctx, strict) || run(node.right, ctx, strict);
+	const l = run(node.left, ctx, strict);
+	const r = run(node.right, ctx, strict);
+	switch (op) {
+		case "==": return String(l) === String(r);
+		case "!=": return String(l) !== String(r);
+		case "===": return l === r;
+		case "!==": return l !== r;
+		case "<": return l < r;
+		case ">": return l > r;
+		case "<=": return l <= r;
+		case ">=": return l >= r;
+		case "+": return l + r;
+		case "-": return l - r;
+		case "*": return l * r;
+		case "/": return l / r;
+		case "%": return l % r;
+	}
+}
+/**
+* Evaluate a when-clause expression string against a context object.
+* Equivalent to `evaluate(parse(expression), ctx, options)`.
+*
+* Supports a JS-expression subset:
+* - Literals: booleans, numbers, strings (quoted with `"` or `'`)
+* - Identifiers: bare keys, including namespaced (`vite.mode`, `vite:buildMode`)
+* - Logical: `&&`, `||`, `!`
+* - Equality: `==`, `!=` (string comparison, bare identifier RHS treated as string),
+*             `===`, `!==` (JS strict equality with full expression RHS)
+* - Relational: `<`, `<=`, `>`, `>=`
+* - Arithmetic: `+`, `-`, `*`, `/`, `%`, unary `-` / `+`
+* - Grouping: `(` … `)`
+*
+* When `ctx` has a specific type with known keys, the expression string is
+* **statically validated** — unknown context keys and syntax errors surface
+* as TypeScript errors at the call site. Pass `ctx` typed as
+* `Record<string, unknown>`, or the expression as `string`, to opt out of
+* static checking (e.g. for dynamic expressions).
+*
+* With `{ strict: true }`, referencing an unknown context key at runtime
+* throws. Short-circuit evaluation still applies — keys not reached are not
+* checked.
+*/
+function evaluateWhen(expression, ctx, options) {
+	return evaluate(parse(expression), ctx, options);
+}
+/**
+* Resolve a context value by key. Supports namespaced keys with `.` or `:` separators.
+*
+* Lookup order:
+* 1. Exact match — `ctx['plugin.mode']` or `ctx['plugin:mode']`
+* 2. Nested path — e.g. `plugin.mode` falls back to `ctx.plugin?.mode`
+*
+* Returns `undefined` for unknown keys.
+*/
+function resolveContextValue(key, ctx) {
+	return resolve(key, ctx).value;
+}
+function lookup(key, ctx, strict) {
+	const { found, value } = resolve(key, ctx);
+	if (!found && strict) throw new Error(`Unknown context key: "${key}"`);
+	return value;
+}
+function resolve(key, ctx) {
+	if (key in ctx) return {
+		found: true,
+		value: ctx[key]
+	};
+	const separator = key.includes(".") ? "." : key.includes(":") ? ":" : null;
+	if (separator) {
+		const segments = key.split(separator);
+		let current = ctx;
+		for (const segment of segments) {
+			if (current == null || typeof current !== "object") return {
+				found: false,
+				value: void 0
+			};
+			const obj = current;
+			if (!(segment in obj)) return {
+				found: false,
+				value: void 0
+			};
+			current = obj[segment];
+		}
+		return {
+			found: true,
+			value: current
+		};
+	}
+	return {
+		found: false,
+		value: void 0
+	};
+}
+//#endregion
+export { evaluateWhen, resolveContextValue };