jprx 1.1.1 → 1.2.1

package/README.md

@@ -1,4 +1,4 @@
-# JPRX (JSON Reactive Path eXpressions)
+# JPRX (JSON Path Reactive eXpressions)
 
 **JPRX** is a declarative, reactive expression syntax designed for JSON-based data structures. It extends [JSON Pointer (RFC 6901)](https://www.rfc-editor.org/rfc/rfc6901) with reactivity, relative paths, operator syntax, and a rich library of helper functions.
 
@@ -26,16 +26,18 @@ JPRX extends the base JSON Pointer syntax with:
 
 | Feature | Syntax | Description |
 |---------|--------|-------------|
-| **Global Path** | `$/user/name` | Access global state via an absolute path. |
+| **Global Path** | `=/user/name` | Access global state via an absolute path. |
 | **Relative Path** | `./count` | Access properties relative to the current context. |
 | **Parent Path** | `../id` | Traverse up the state hierarchy (UP-tree search). |
-| **Functions** | `$sum(/items...price)` | Call registered core helpers. |
+| **Functions** | `=sum(/items...price)` | Call registered core helpers. |
 | **Explosion** | `/items...name` | Extract a property from every object in an array (spread). |
-| **Operators** | `$++/count`, `$/a + $/b` | Familiar JS-style prefix, postfix, and infix operators. |
+| **Operators** | `=++/count`, `=/a + =/b` | Familiar JS-style prefix, postfix, and infix operators. |
 | **Placeholders** | `_` (item), `$this`, `$event` | Context-aware placeholders for iteration and interaction. |
-| **Two-Way Binding**| `$bind(/user/name)`| Create a managed, two-way reactive link for inputs. |
+| **Two-Way Binding**| `=bind(/user/name)`| Create a managed, two-way reactive link for inputs. |
+| **DOM Patches**    | `=move(target, loc)`| Decentralized layout: Move/replace host element into a target. |
+
+Once inside a JPRX expression, the `=` prefix is only needed at the start of the expression for paths or function names.
 
-Once inside a JPRX expression, the `$` prefix is only needed at the start of the expression for paths or function names.
 
 ## State Management
 
@@ -46,9 +48,9 @@ States can be attached to specific scopes (such as a DOM node or Component insta
 - **Up-tree Resolution**: When resolving a path, JPRX walks up the provided scope chain looking for the nearest owner of that name.
 - **Future Signals**: JPRX allows subscription to a named signal *before* it is initialized. The system will automatically "hook up" once the state is created via `$state` or `$signal`.
 
-### The `$state` and `$signal` Helpers
-- `$state(value, { name: 'user', schema: 'UserProfile', scope: event.target })`
-- `$signal(0, { name: 'count', schema: 'auto' })`
+### The `=state` and `=signal` Helpers
+- `=state(value, { name: 'user', schema: 'UserProfile', scope: event.target })`
+- `=signal(0, { name: 'count', schema: 'auto' })`
 
 ## Schema Registry & Validation
 
@@ -64,10 +66,10 @@ jprx.registerSchema('UserProfile', {
 });
 
 // 2. Reference the registered schema by name (Scoped)
-const user = $state({}, { name: 'user', schema: 'UserProfile', scope: $this });
+const user = =state({}, { name: 'user', schema: 'UserProfile', scope: $this });
 
 // 3. Use the 'polymorphic' shorthand for auto-coercion
-const settings = $state({ volume: 50 }, { name: 'settings', schema: 'polymorphic' });
+const settings = =state({ volume: 50 }, { name: 'settings', schema: 'polymorphic' });
 // Result: settings.volume = "60" will automatically coerce to the number 60.
 ```
 
@@ -91,19 +93,59 @@ Schemas can define transformations that occur during state updates, ensuring dat
   }
 }
 ```
-*Note: The `$bind` helper uses these transformations to automatically clean data as the user types.*
+*Note: The `=bind` helper uses these transformations to automatically clean data as the user types.*
 
-## Two-Way Binding with `$bind`
+## Two-Way Binding with `=bind`
 
-The `$bind(path)` helper creates a managed, two-way link between the UI and a state path.
+The `=bind(path)` helper creates a managed, two-way link between the UI and a state path.
 
 ### Strictness
-To ensure unambiguous data flow, `$bind` only accepts direct paths. It cannot be used directly with computed expressions like `$bind(upper(/name))`.
+To ensure unambiguous data flow, `=bind` only accepts direct paths. It cannot be used directly with computed expressions like `=bind(upper(/name))`.
 
 ### Handling Transformations
 If you need to transform data during a two-way binding, there are two primary approaches:
-1. **Event-Based**: Use a manual `oninput` handler to apply the transformation, e.g., `$set(/name, upper($event/target/value))`.
-2. **Schema-Based**: Define a `transform` or `pattern` in the schema for the path. The `$bind` helper will respect the schema rules during the write-back phase.
+1. **Event-Based**: Use a manual `oninput` handler to apply the transformation, e.g., `=set(/name, upper($event/target/value))`.
+2. **Schema-Based**: Define a `transform` or `pattern` in the schema for the path. The `=bind` helper will respect the schema rules during the write-back phase.
+
+---
+
+## DOM Patches & Decentralized Layouts
+
+One of the most powerful features of JPRX in UI environments (like Lightview) is the ability to perform **Decentralized DOM Patches** via the `=move(target, location)` helper.
+
+### The Problem: LLM Streaming & Layouts
+When an LLM streams UI components, it often knows *what* it is creating before it knows exactly *where* that item belongs in a complex dashboard, or it may need to update an existing element that was created minutes ago.
+
+### The Solution: `=move`
+The `=move` helper allows a component to "place itself" into the document upon mounting. 
+
+```json
+{
+  "tag": "div",
+  "id": "weather-widget",
+  "onmount": "=move('#dashboard-sidebar', 'afterbegin')",
+  "content": "Sunny, 75°F"
+}
+```
+
+**Key Behaviors:**
+1. **Teleportation**: The host element is physically moved from the "Stream Container" (where it was born) to the specified `target` (e.g., `#dashboard-sidebar`).
+2. **Idempotent Updates**: If the moving element has an `id` (e.g., `weather-widget`) and an element with that same ID already exists at the destination, the existing element is **replaced**. This allows the LLM to "patch" the UI simply by streaming the updated version of the component.
+3. **Flicker-Free**: By rendering the stream in a hidden container, the element is moved and appears in its final destination instantly.
+
+### The Delivery Vehicle: `=mount`
+The `=mount(url, options?)` helper is the primary mechanism for fetching these decentralized updates.
+
+1. **Arrival**: `=mount` fetches the content and "lands" it at the end of the `document.body` (by default).
+2. **Mounting**: The content is hydrated and added to the DOM, triggering its `onmount` hook.
+3. **Teleportation**: If the content contains `=move`, it immediately relocates itself to its destination.
+
+This separation of concerns makes the system incredibly robust: `=mount` handles the **delivery**, while `=move` handles the **logic** of where the content belongs.
+
+### Why Decentralized?
+- **Low Overhead**: The LLM doesn't need to maintain a map of the entire DOM; it just needs to know the ID or Selector of where it wants to "push" its content.
+- **Independence**: Components are self-contained. A "Notification" component knows how to display itself AND where notification stacks live.
+- **Context Preservation**: In Lightview, moved elements retain their original reactive context ("backpack"), allowing them to stay linked to the stream that created them.
 
 ---
 
@@ -114,12 +156,12 @@ A modern, lifecycle-based reactive counter:
 ```json
 {
   "div": {
-    "onmount": $state({ count: 0 }, { name: 'counter', schema: 'auto', scope: $this }),
+    "onmount": "=state({ count: 0 }, { name: 'counter', schema: 'auto', scope: $this })",
     "children": [
       { "h2": "Modern JPRX Counter" },
-      { "p": ["Current Count: ", $/counter/count] },
-      { "button": { "onclick": $++/counter/count, "children": ["+"] } },
-      { "button": { "onclick": $--/counter/count, "children": ["-"] } }
+      { "p": ["Current Count: ", "=/counter/count"] },
+      { "button": { "onclick": "=++/counter/count", "children": ["+"] } },
+      { "button": { "onclick": "=--/counter/count", "children": ["-"] } }
     ]
   }
 }

package/helpers/calc.js

@@ -0,0 +1,82 @@
+/**
+ * JPRX CALC HELPER
+ * Safe expression evaluation using expr-eval.
+ * Uses the global $ helper for reactive path lookups.
+ */
+
+import { Parser } from 'expr-eval';
+import { resolvePath, unwrapSignal } from '../parser.js';
+
+/**
+ * Evaluates a mathematical expression string.
+ * Supports $() for reactive path lookups within the expression.
+ * 
+ * @param {string} expression - The expression to evaluate (e.g., "$('/price') * 1.08")
+ * @param {object} context - The JPRX context for path resolution
+ * @returns {number|string} - The result of the evaluation
+ * 
+ * @example
+ * =calc("$('/width') * $('/height')")
+ * =calc("5 + 3 * 2")
+ * =calc("($('/subtotal') + $('/tax')) * 0.9")
+ */
+export const calc = (expression, context) => {
+    if (typeof expression !== 'string') {
+        return expression;
+    }
+
+    let processedExpression = expression;
+    try {
+        const pathResolver = (path) => {
+            let currentPath = path;
+            let value;
+            let depth = 0;
+
+            // Recursively resolve if the value is another path string (e.g., "/c/display")
+            while (typeof currentPath === 'string' && (currentPath.startsWith('/') || currentPath.startsWith('=/')) && depth < 5) {
+                const normalizedPath = currentPath.startsWith('/') ? '=' + currentPath : currentPath;
+                const resolved = resolvePath(normalizedPath, context);
+                value = unwrapSignal(resolved);
+
+                // If the new value is a different path string, keep going
+                if (typeof value === 'string' && (value.startsWith('/') || value.startsWith('=/')) && value !== currentPath) {
+                    currentPath = value;
+                    depth++;
+                } else {
+                    break;
+                }
+            }
+
+            if (typeof value === 'number') return value;
+            if (typeof value === 'string') {
+                const num = parseFloat(value);
+                if (!isNaN(num) && isFinite(Number(value))) return num;
+                return value === '' ? 0 : `"${value.replace(/"/g, '\\"')}"`;
+            }
+            return value === undefined || value === null ? 0 : value;
+        };
+
+        const pathRegex = /\$\(\s*['"](.*?)['"]\s*\)/g;
+        processedExpression = expression.replace(pathRegex, (match, path) => {
+            const val = pathResolver(path);
+            return val;
+        });
+
+        const parser = new Parser();
+        const parsed = parser.parse(processedExpression);
+        return parsed.evaluate();
+
+    } catch (error) {
+        console.error('JPRX calc error:', error.message);
+        console.error('Original expression:', expression);
+        console.error('Processed expression:', processedExpression);
+        return NaN;
+    }
+};
+
+/**
+ * Register the calc helper.
+ */
+export const registerCalcHelpers = (register) => {
+    register('calc', calc, { pathAware: true });
+};

package/helpers/lookup.js

@@ -2,6 +2,8 @@
  * cdom LOOKUP HELPERS
  */
 
+import { resolvePath, unwrapSignal } from '../parser.js';
+
 export const lookup = (val, searchArr, resultArr) => {
     if (!Array.isArray(searchArr)) return undefined;
     const idx = searchArr.indexOf(val);
@@ -17,9 +19,46 @@ export const vlookup = (val, table, colIdx) => {
 export const index = (arr, idx) => Array.isArray(arr) ? arr[idx] : undefined;
 export const match = (val, arr) => Array.isArray(arr) ? arr.indexOf(val) : -1;
 
+/**
+ * $ - Reactive path lookup helper.
+ * Resolves a JPRX path string and returns the unwrapped value.
+ * 
+ * @param {string} path - The path to resolve (e.g., '/state/count')
+ * @param {object} context - The JPRX context (automatically provided by pathAware)
+ * @returns {any} - The resolved and unwrapped value
+ * 
+ * @example
+ * =calc("$('/price') * 1.08")
+ * =$('/user/name')
+ */
+export const pathRef = (path, context) => {
+    // If path is already a BindingTarget or has a .value property, use it directly
+    if (path && typeof path === 'object' && 'value' in path) {
+        return unwrapSignal(path.value);
+    }
+
+    // Fallback for string paths
+    if (typeof path === 'string') {
+        const normalized = path.startsWith('=') ? path : '=' + path;
+        const resolved = resolvePath(normalized, context);
+        const value = unwrapSignal(resolved);
+        // Convert to number if it looks like a number for calc compatibility
+        if (typeof value === 'number') return value;
+        if (typeof value === 'string' && value !== '' && !isNaN(parseFloat(value)) && isFinite(Number(value))) {
+            return parseFloat(value);
+        }
+        return value;
+    }
+
+    return unwrapSignal(path);
+};
+
 export const registerLookupHelpers = (register) => {
     register('lookup', lookup);
     register('vlookup', vlookup);
     register('index', index);
     register('match', match);
+    register('$', pathRef, { pathAware: true });
+    register('val', pathRef, { pathAware: true });
+    register('indirect', pathRef, { pathAware: true });
 };

package/helpers/math.js

@@ -14,6 +14,8 @@ export const abs = (val) => Math.abs(val);
 export const mod = (a, b) => a % b;
 export const pow = (a, b) => Math.pow(a, b);
 export const sqrt = (val) => Math.sqrt(val);
+export const negate = (val) => -Number(val);
+export const toPercent = (val) => Number(val) / 100;
 
 export const registerMathHelpers = (register) => {
     register('+', add);
@@ -31,4 +33,6 @@ export const registerMathHelpers = (register) => {
     register('mod', mod);
     register('pow', pow);
     register('sqrt', sqrt);
+    register('negate', negate);
+    register('toPercent', toPercent);
 };

package/helpers/state.js

@@ -64,7 +64,7 @@ export const clear = (target) => {
     return set(target, null);
 };
 
-export function $state(val, options) {
+export function state(val, options) {
     if (globalThis.Lightview) {
         const finalOptions = typeof options === 'string' ? { name: options } : options;
         return globalThis.Lightview.state(val, finalOptions);
@@ -72,7 +72,7 @@ export function $state(val, options) {
     throw new Error('JPRX: $state requires a UI library implementation.');
 }
 
-export function $signal(val, options) {
+export function signal(val, options) {
     if (globalThis.Lightview) {
         const finalOptions = typeof options === 'string' ? { name: options } : options;
         return globalThis.Lightview.signal(val, finalOptions);
@@ -80,7 +80,7 @@ export function $signal(val, options) {
     throw new Error('JPRX: $signal requires a UI library implementation.');
 }
 
-export const $bind = (path, options) => ({ __JPRX_BIND__: true, path, options });
+export const bind = (path, options) => ({ __JPRX_BIND__: true, path, options });
 
 export const registerStateHelpers = (register) => {
     const opts = { pathAware: true };
@@ -95,7 +95,7 @@ export const registerStateHelpers = (register) => {
     register('pop', pop, opts);
     register('assign', assign, opts);
     register('clear', clear, opts);
-    register('state', $state);
-    register('signal', $signal);
-    register('bind', $bind);
+    register('state', state);
+    register('signal', signal);
+    register('bind', bind);
 };

package/index.js

@@ -38,6 +38,7 @@ export { registerLookupHelpers } from './helpers/lookup.js';
 export { registerStatsHelpers } from './helpers/stats.js';
 export { registerStateHelpers, set } from './helpers/state.js';
 export { registerNetworkHelpers } from './helpers/network.js';
+export { registerCalcHelpers, calc } from './helpers/calc.js';
 
 // Convenience function to register all standard helpers
 export const registerAllHelpers = (registerFn) => {
@@ -53,6 +54,7 @@ export const registerAllHelpers = (registerFn) => {
     const { registerStatsHelpers } = require('./helpers/stats.js');
     const { registerStateHelpers } = require('./helpers/state.js');
     const { registerNetworkHelpers } = require('./helpers/network.js');
+    const { registerCalcHelpers } = require('./helpers/calc.js');
 
     registerMathHelpers(registerFn);
     registerLogicHelpers(registerFn);
@@ -66,4 +68,5 @@ export const registerAllHelpers = (registerFn) => {
     registerStatsHelpers(registerFn);
     registerStateHelpers((name, fn) => registerFn(name, fn, { pathAware: true }));
     registerNetworkHelpers(registerFn);
+    registerCalcHelpers(registerFn);
 };

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "jprx",
-    "version": "1.1.1",
-    "description": "JSON Reactive Path eXpressions - A reactive expression language for JSON data",
+    "version": "1.2.1",
+    "description": "JSON Path Reactive eXpressions - A reactive expression language for JSON data",
     "main": "index.js",
     "type": "module",
     "keywords": [

package/parser.js

@@ -136,8 +136,8 @@ export const resolvePath = (path, context) => {
     // Current context: .
     if (path === '.') return unwrapSignal(context);
 
-    // Global absolute path: $/something
-    if (path.startsWith('$/')) {
+    // Global absolute path: =/something
+    if (path.startsWith('=/')) {
         const [rootName, ...rest] = path.slice(2).split('/');
         const LV = getLV();
         const root = LV ? LV.get(rootName, { scope: context?.__node__ || context }) : registry?.get(rootName);
@@ -164,7 +164,6 @@ export const resolvePath = (path, context) => {
     const unwrappedContext = unwrapSignal(context);
     if (unwrappedContext && typeof unwrappedContext === 'object') {
         if (path in unwrappedContext || unwrappedContext[path] !== undefined) {
-            // Use traverse with one segment to ensure signal unwrapping if context[path] is a signal
             return traverse(unwrappedContext, [path]);
         }
     }
@@ -184,8 +183,8 @@ export const resolvePathAsContext = (path, context) => {
     // Current context: .
     if (path === '.') return context;
 
-    // Global absolute path: $/something
-    if (path.startsWith('$/')) {
+    // Global absolute path: =/something
+    if (path.startsWith('=/')) {
         const segments = path.slice(2).split(/[/.]/);
         const rootName = segments.shift();
         const LV = getLV();
@@ -304,10 +303,9 @@ const resolveArgument = (arg, context, globalMode = false) => {
         try {
             const data = parseJPRX(arg);
 
-            // Define a recursive resolver for template objects
             const resolveTemplate = (node, context) => {
                 if (typeof node === 'string') {
-                    if (node.startsWith('$')) {
+                    if (node.startsWith('=')) {
                         const res = resolveExpression(node, context);
                         const final = (res instanceof LazyValue) ? res.resolve(context) : res;
                         return unwrapSignal(final);
@@ -340,10 +338,9 @@ const resolveArgument = (arg, context, globalMode = false) => {
                 return node;
             };
 
-            // Check if it contains any reactive parts
             const hasReactive = (obj) => {
                 if (typeof obj === 'string') {
-                    return obj.startsWith('$') || obj.startsWith('_') || obj.startsWith('../');
+                    return obj.startsWith('=') || obj.startsWith('_') || obj.startsWith('../');
                 }
                 if (Array.isArray(obj)) return obj.some(hasReactive);
                 if (obj && typeof obj === 'object') return Object.values(obj).some(hasReactive);
@@ -366,9 +363,9 @@ const resolveArgument = (arg, context, globalMode = false) => {
     if (arg.includes('(')) {
         let nestedExpr = arg;
         if (arg.startsWith('/')) {
-            nestedExpr = '$' + arg;
-        } else if (globalMode && !arg.startsWith('$') && !arg.startsWith('./')) {
-            nestedExpr = `$/${arg}`;
+            nestedExpr = '=' + arg;
+        } else if (globalMode && !arg.startsWith('=') && !arg.startsWith('./')) {
+            nestedExpr = `=/${arg}`;
         }
 
         const val = resolveExpression(nestedExpr, context);
@@ -381,11 +378,11 @@ const resolveArgument = (arg, context, globalMode = false) => {
     // 8. Path normalization
     let normalizedPath;
     if (arg.startsWith('/')) {
-        normalizedPath = '$' + arg;
-    } else if (arg.startsWith('$') || arg.startsWith('./') || arg.startsWith('../')) {
+        normalizedPath = '=' + arg;
+    } else if (arg.startsWith('=') || arg.startsWith('./') || arg.startsWith('../')) {
         normalizedPath = arg;
     } else if (globalMode) {
-        normalizedPath = `$/${arg}`;
+        normalizedPath = `=/${arg}`;
     } else {
         normalizedPath = `./${arg}`;
     }
@@ -483,10 +480,10 @@ const tokenize = (expr) => {
             continue;
         }
 
-        // Special: $ followed immediately by an operator symbol
-        // In expressions like "$++/count", the $ is just the JPRX delimiter
+        // Special: = followed immediately by an operator symbol
+        // In expressions like "=++/count", the = is just the JPRX delimiter
         // and ++ is a prefix operator applied to /count
-        if (expr[i] === '$' && i + 1 < len) {
+        if (expr[i] === '=' && i + 1 < len) {
             // Check if next chars are a PREFIX operator (sort by length to match longest first)
             const prefixOps = [...operators.prefix.keys()].sort((a, b) => b.length - a.length);
             let isPrefixOp = false;
@@ -497,7 +494,7 @@ const tokenize = (expr) => {
                 }
             }
             if (isPrefixOp) {
-                // Skip the $, it's just a delimiter for a prefix operator (e.g., $++/count)
+                // Skip the =, it's just a delimiter for a prefix operator (e.g., =++/count)
                 i++;
                 continue;
             }
@@ -554,7 +551,7 @@ const tokenize = (expr) => {
                     tokens[tokens.length - 1].type === TokenType.LPAREN ||
                     tokens[tokens.length - 1].type === TokenType.COMMA ||
                     tokens[tokens.length - 1].type === TokenType.OPERATOR;
-                const validAfter = /[\s($./'"0-9_]/.test(after) ||
+                const validAfter = /[\s(=./'"0-9_]/.test(after) ||
                     i + op.length >= len ||
                     opSymbols.some(o => expr.slice(i + op.length).startsWith(o));
 
@@ -651,8 +648,8 @@ const tokenize = (expr) => {
             continue;
         }
 
-        // Paths: start with $, ., or /
-        if (expr[i] === '$' || expr[i] === '.' || expr[i] === '/') {
+        // Paths: start with =, ., or /
+        if (expr[i] === '=' || expr[i] === '.' || expr[i] === '/') {
             let path = '';
             // Consume the path, but stop at operators
             while (i < len) {
@@ -734,9 +731,9 @@ const tokenize = (expr) => {
  * Used to determine whether to use Pratt parser or legacy parser.
  * 
  * CONSERVATIVE: Only detect explicit patterns to avoid false positives.
- * - Prefix: $++/path, $--/path, $!!/path (operator immediately after $ before path)
- * - Postfix: $/path++ or $/path-- (operator at end of expression, not followed by ()
- * - Infix with spaces: $/path + $/other (spaces around operator)
+ * - Prefix: =++/path, =--/path, =!!/path (operator immediately after = before path)
+ * - Postfix: =/path++ or =/path-- (operator at end of expression, not followed by ()
+ * - Infix with spaces: =/path + =/other (spaces around operator)
  */
 const hasOperatorSyntax = (expr) => {
     if (!expr || typeof expr !== 'string') return false;
@@ -744,19 +741,19 @@ const hasOperatorSyntax = (expr) => {
     // Skip function calls - they use legacy parser
     if (expr.includes('(')) return false;
 
-    // Check for prefix operator pattern: $++ or $-- followed by /
-    // This catches: $++/counter, $--/value
-    if (/^\$(\+\+|--|!!)\/?/.test(expr)) {
+    // Check for prefix operator pattern: =++ or =-- followed by /
+    // This catches: =++/counter, =--/value
+    if (/^=(\+\+|--|!!)\/?/.test(expr)) {
         return true;
     }
 
     // Check for postfix operator pattern: path ending with ++ or --
-    // This catches: $/counter++, $/value--
+    // This catches: =/counter++, =/value--
     if (/(\+\+|--)$/.test(expr)) {
         return true;
     }
 
-    // Check for infix with explicit whitespace: $/a + $/b
+    // Check for infix with explicit whitespace: =/a + =/b
     // The spaces make it unambiguous that the symbol is an operator, not part of a path
     if (/\s+([+\-*/]|>|<|>=|<=|!=)\s+/.test(expr)) {
         return true;
@@ -1084,19 +1081,19 @@ export const resolveExpression = (expr, context) => {
         const argsStr = expr.slice(funcStart + 1, -1);
 
         const segments = fullPath.split('/');
-        let funcName = segments.pop().replace(/^\$/, '');
+        let funcName = segments.pop().replace(/^=/, '');
 
-        // Handle case where path ends in / (like $/ for division helper)
+        // Handle case where path ends in / (like =/ for division helper)
         if (funcName === '' && (segments.length > 0 || fullPath === '/')) {
             funcName = '/';
         }
 
         const navPath = segments.join('/');
 
-        const isGlobalExpr = expr.startsWith('$/') || expr.startsWith('$');
+        const isGlobalExpr = expr.startsWith('=/') || expr.startsWith('=');
 
         let baseContext = context;
-        if (navPath && navPath !== '$') {
+        if (navPath && navPath !== '=') {
             baseContext = resolvePathAsContext(navPath, context);
         }
 
@@ -1134,7 +1131,7 @@ export const resolveExpression = (expr, context) => {
         let hasLazy = false;
         for (let i = 0; i < argsList.length; i++) {
             const arg = argsList[i];
-            const useGlobalMode = isGlobalExpr && (navPath === '$' || !navPath);
+            const useGlobalMode = isGlobalExpr && (navPath === '=' || !navPath);
             const res = resolveArgument(arg, baseContext, useGlobalMode);
 
             if (res.isLazy) hasLazy = true;
@@ -1299,8 +1296,8 @@ export const parseCDOMC = (input) => {
 
         const word = input.slice(start, i);
 
-        // If word starts with $, preserve it as a string for cDOM expression parsing
-        if (word.startsWith('$')) {
+        // If word starts with =, preserve it as a string for cDOM expression parsing
+        if (word.startsWith('=')) {
             return word;
         }
 
@@ -1476,8 +1473,8 @@ export const parseJPRX = (input) => {
             continue;
         }
 
-        // Handle JPRX expressions starting with $ (MUST come before word handler!)
-        if (char === '$') {
+        // Handle JPRX expressions starting with = (MUST come before word handler!)
+        if (char === '=') {
             let expr = '';
             let parenDepth = 0;
             let braceDepth = 0;
@@ -1514,21 +1511,54 @@ export const parseJPRX = (input) => {
             continue;
         }
 
-        // Handle unquoted property names, identifiers, and paths
-        if (/[a-zA-Z_./]/.test(char)) {
+        // Handle unquoted property names, identifiers, paths, and FUNCTION CALLS
+        if (/[a-zA-Z_$/./]/.test(char)) {
             let word = '';
             while (i < len && /[a-zA-Z0-9_$/.-]/.test(input[i])) {
                 word += input[i];
                 i++;
             }
 
-            // Skip whitespace to check for :
+            // Skip whitespace to check what follows
             let j = i;
             while (j < len && /\s/.test(input[j])) j++;
 
             if (input[j] === ':') {
                 // It's a property name - quote it
                 result += `"${word}"`;
+            } else if (input[j] === '(') {
+                // It's a FUNCTION CALL - capture the entire expression with balanced parens
+                let expr = word;
+                i = j; // move to the opening paren
+                let parenDepth = 0;
+                let inQuote = null;
+
+                while (i < len) {
+                    const c = input[i];
+
+                    // Track quotes to avoid false paren matches inside strings
+                    if (inQuote) {
+                        if (c === inQuote && input[i - 1] !== '\\') inQuote = null;
+                    } else if (c === '"' || c === "'") {
+                        inQuote = c;
+                    } else {
+                        if (c === '(') parenDepth++;
+                        else if (c === ')') {
+                            parenDepth--;
+                            if (parenDepth === 0) {
+                                expr += c;
+                                i++;
+                                break;
+                            }
+                        }
+                    }
+
+                    expr += c;
+                    i++;
+                }
+
+                // Treat the function call as a JPRX expression by prefixing with =
+                result += JSON.stringify('=' + expr);
             } else {
                 // It's a value - check if it's a keyword
                 if (word === 'true' || word === 'false' || word === 'null') {

package/specs/expressions.json

@@ -4,7 +4,7 @@
         "state": {
             "userName": "Alice"
         },
-        "expression": "$/userName",
+        "expression": "=/userName",
         "expected": "Alice"
     },
     {
@@ -16,7 +16,7 @@
                 }
             }
         },
-        "expression": "$/user/profile/name",
+        "expression": "=/user/profile/name",
         "expected": "Bob"
     },
     {
@@ -33,7 +33,7 @@
             "a": 5,
             "b": 10
         },
-        "expression": "$+(/a, /b)",
+        "expression": "=+(/a, /b)",
         "expected": 15
     },
     {
@@ -42,7 +42,7 @@
             "a": 5,
             "b": 10
         },
-        "expression": "$/a + $/b",
+        "expression": "=/a + =/b",
         "expected": 15
     },
     {
@@ -50,7 +50,7 @@
         "state": {
             "isVip": true
         },
-        "expression": "$if(/isVip, \"Gold\", \"Silver\")",
+        "expression": "=if(/isVip, \"Gold\", \"Silver\")",
         "expected": "Gold"
     },
     {
@@ -65,7 +65,7 @@
                 }
             ]
         },
-        "expression": "$sum(/items...p)",
+        "expression": "=sum(/items...p)",
         "expected": 30
     }
 ]

package/specs/helpers.json

@@ -1,102 +1,102 @@
 [
     {
         "name": "Math: Subtraction",
-        "expression": "$-(10, 3)",
+        "expression": "=-(10, 3)",
         "expected": 7
     },
     {
         "name": "Math: Multiplication",
-        "expression": "$*(4, 5)",
+        "expression": "=*(4, 5)",
         "expected": 20
     },
     {
         "name": "Math: Division",
-        "expression": "$/(20, 4)",
+        "expression": "=/(20, 4)",
         "expected": 5
     },
     {
         "name": "Math: Round",
-        "expression": "$round(3.7)",
+        "expression": "=round(3.7)",
         "expected": 4
     },
     {
         "name": "String: Upper",
-        "expression": "$upper('hello')",
+        "expression": "=upper('hello')",
         "expected": "HELLO"
     },
     {
         "name": "String: Lower",
-        "expression": "$lower('WORLD')",
+        "expression": "=lower('WORLD')",
         "expected": "world"
     },
     {
         "name": "String: Concat",
-        "expression": "$concat('Hello', ' ', 'World')",
+        "expression": "=concat('Hello', ' ', 'World')",
         "expected": "Hello World"
     },
     {
         "name": "String: Trim",
-        "expression": "$trim('  spaced  ')",
+        "expression": "=trim('  spaced  ')",
         "expected": "spaced"
     },
     {
         "name": "Logic: And (true)",
-        "expression": "$and(true, true)",
+        "expression": "=and(true, true)",
         "expected": true
     },
     {
         "name": "Logic: And (false)",
-        "expression": "$and(true, false)",
+        "expression": "=and(true, false)",
         "expected": false
     },
     {
         "name": "Logic: Or",
-        "expression": "$or(false, true)",
+        "expression": "=or(false, true)",
         "expected": true
     },
     {
         "name": "Logic: Not",
-        "expression": "$not(false)",
+        "expression": "=not(false)",
         "expected": true
     },
     {
         "name": "Compare: Greater Than",
-        "expression": "$gt(10, 5)",
+        "expression": "=gt(10, 5)",
         "expected": true
     },
     {
         "name": "Compare: Less Than",
-        "expression": "$lt(3, 7)",
+        "expression": "=lt(3, 7)",
         "expected": true
     },
     {
         "name": "Compare: Equal",
-        "expression": "$eq(5, 5)",
+        "expression": "=eq(5, 5)",
         "expected": true
     },
     {
         "name": "Conditional: If (true branch)",
-        "expression": "$if(true, 'Yes', 'No')",
+        "expression": "=if(true, 'Yes', 'No')",
         "expected": "Yes"
     },
     {
         "name": "Conditional: If (false branch)",
-        "expression": "$if(false, 'Yes', 'No')",
+        "expression": "=if(false, 'Yes', 'No')",
         "expected": "No"
     },
     {
         "name": "Stats: Average",
-        "expression": "$avg(10, 20, 30)",
+        "expression": "=avg(10, 20, 30)",
         "expected": 20
     },
     {
         "name": "Stats: Min",
-        "expression": "$min(5, 2, 8)",
+        "expression": "=min(5, 2, 8)",
         "expected": 2
     },
     {
         "name": "Stats: Max",
-        "expression": "$max(5, 2, 8)",
+        "expression": "=max(5, 2, 8)",
         "expected": 8
     },
     {
@@ -108,7 +108,7 @@
                 "c"
             ]
         },
-        "expression": "$len(/items)",
+        "expression": "=len(/items)",
         "expected": 3
     },
     {
@@ -120,7 +120,7 @@
                 "c"
             ]
         },
-        "expression": "$join(/items, '-')",
+        "expression": "=join(/items, '-')",
         "expected": "a-b-c"
     },
     {
@@ -132,7 +132,7 @@
                 "c"
             ]
         },
-        "expression": "$first(/items)",
+        "expression": "=first(/items)",
         "expected": "a"
     },
     {
@@ -144,7 +144,7 @@
                 "c"
             ]
         },
-        "expression": "$last(/items)",
+        "expression": "=last(/items)",
         "expected": "c"
     }
 ]