lightview 2.2.2 → 2.3.4

package/tests/cdom/fixtures/helpers.cdomc

@@ -4,58 +4,58 @@
     children: [
       // Math
       { div: { id: math, children: [
-        { span: { class: add, children: ["add: ", $+(10, 5)] } },
-        { span: { class: sub, children: ["sub: ", $-(10, 5)] } },
-        { span: { class: mul, children: ["mul: ", $*(10, 5)] } },
-        { span: { class: div, children: ["div: ", $/(10, 5)] } }
+        { span: { class: add, children: ["add: ", =+(10, 5)] } },
+        { span: { class: sub, children: ["sub: ", =-(10, 5)] } },
+        { span: { class: mul, children: ["mul: ", =*(10, 5)] } },
+        { span: { class: div, children: ["div: ", =/(10, 5)] } }
       ]}},
 
       // Logic
       { div: { id: logic, children: [
-        { span: { class: and, children: ["and: ", $&&(true, true)] } },
-        { span: { class: or, children: ["or: ", $||(false, true)] } },
-        { span: { class: not, children: ["not: ", $!(false)] } }
+        { span: { class: and, children: ["and: ", =&&(true, true)] } },
+        { span: { class: or, children: ["or: ", =||(false, true)] } },
+        { span: { class: not, children: ["not: ", =!(false)] } }
       ]}},
 
       // String
       { div: { id: string, children: [
-        { span: { class: upper, children: ["upper: ", $upper('hello')] } },
-        { span: { class: lower, children: ["lower: ", $lower('HELLO')] } },
-        { span: { class: concat, children: ["concat: ", $concat('Hello', ' ', 'World')] } }
+        { span: { class: upper, children: ["upper: ", =upper('hello')] } },
+        { span: { class: lower, children: ["lower: ", =lower('HELLO')] } },
+        { span: { class: concat, children: ["concat: ", =concat('Hello', ' ', 'World')] } }
       ]}},
 
       // Compare
       { div: { id: compare, children: [
-        { span: { class: eq, children: ["eq: ", $==(5, 5)] } },
-        { span: { class: gt, children: ["gt: ", $>(10, 5)] } },
-        { span: { class: lt, children: ["lt: ", $<(5, 10)] } }
+        { span: { class: eq, children: ["eq: ", ===(5, 5)] } },
+        { span: { class: gt, children: ["gt: ", =>(10, 5)] } },
+        { span: { class: lt, children: ["lt: ", =<(5, 10)] } }
       ]}},
 
       // Conditional
       { div: { id: conditional, children: [
-        { span: { class: if-true, children: ["if-true: ", $if(true, 'Yes', 'No')] } },
-        { span: { class: if-false, children: ["if-false: ", $if(false, 'Yes', 'No')] } }
+        { span: { class: if-true, children: ["if-true: ", =if(true, 'Yes', 'No')] } },
+        { span: { class: if-false, children: ["if-false: ", =if(false, 'Yes', 'No')] } }
       ]}},
 
       // Array (using global state data)
       { div: { id: array, children: [
-        { span: { class: join, children: ["join: ", $join(/data/list, '-')] } },
-        { span: { class: len, children: ["len: ", $len(/data/list)] } },
-        { span: { class: first, children: ["first: ", $first(/data/list)] } }
+        { span: { class: join, children: ["join: ", =join(/data/list, '-')] } },
+        { span: { class: len, children: ["len: ", =len(/data/list)] } },
+        { span: { class: first, children: ["first: ", =first(/data/list)] } }
       ]}},
 
       // Stats
       { div: { id: stats, children: [
-        { span: { class: sum, children: ["sum: ", $sum(/data/numbers...)] } },
-        { span: { class: avg, children: ["avg: ", $avg(/data/numbers...)] } },
-        { span: { class: max, children: ["max: ", $max(/data/numbers...)] } },
-        { span: { class: min, children: ["min: ", $min(/data/numbers...)] } }
+        { span: { class: sum, children: ["sum: ", =sum(/data/numbers...)] } },
+        { span: { class: avg, children: ["avg: ", =avg(/data/numbers...)] } },
+        { span: { class: max, children: ["max: ", =max(/data/numbers...)] } },
+        { span: { class: min, children: ["min: ", =min(/data/numbers...)] } }
       ]}},
 
       // Format
       { div: { id: format, children: [
-        { span: { class: currency, children: ["currency: ", $currency(1234.56, 'USD')] } },
-        { span: { class: percent, children: ["percent: ", $percent(0.125)] } }
+        { span: { class: currency, children: ["currency: ", =currency(1234.56, 'USD')] } },
+        { span: { class: percent, children: ["percent: ", =percent(0.125)] } }
       ]}}
     ]
   }

package/tests/cdom/helpers.test.js

@@ -62,60 +62,60 @@ describe('cdom Helpers Integration', () => {
         const hydrated = LightviewCDOM.hydrate(parsed);
 
         // Helper to dive into the structure:
-        // div -> children -> [ { div: { id: 'math', children: [ { span: ... } ] } } ]
-        const root = hydrated.div;
+        // { tag: 'div', children: [ { tag: 'div', attributes: { id: 'math' }, children: [...] } ] }
+        const root = hydrated;
         const findSection = (id) => {
-            const section = root.children.find(child => child.div?.id === id);
-            return section.div.children;
+            const section = root.children.find(child => child.attributes?.id === id);
+            return section.children;
         };
 
         // Math
         const math = findSection('math');
         // add: $+(10, 5) -> "add: " + 15
-        expect(math[0].span.children[1].value).toBe(15);
-        expect(math[1].span.children[1].value).toBe(5);
-        expect(math[2].span.children[1].value).toBe(50);
-        expect(math[3].span.children[1].value).toBe(2);
+        expect(math[0].children[1].value).toBe(15);
+        expect(math[1].children[1].value).toBe(5);
+        expect(math[2].children[1].value).toBe(50);
+        expect(math[3].children[1].value).toBe(2);
 
         // Logic
         const logic = findSection('logic');
-        expect(logic[0].span.children[1].value).toBe(true);
-        expect(logic[1].span.children[1].value).toBe(true);
-        expect(logic[2].span.children[1].value).toBe(true);
+        expect(logic[0].children[1].value).toBe(true);
+        expect(logic[1].children[1].value).toBe(true);
+        expect(logic[2].children[1].value).toBe(true);
 
         // String
         const str = findSection('string');
-        expect(str[0].span.children[1].value).toBe('HELLO');
-        expect(str[1].span.children[1].value).toBe('hello');
-        expect(str[2].span.children[1].value).toBe('Hello World');
+        expect(str[0].children[1].value).toBe('HELLO');
+        expect(str[1].children[1].value).toBe('hello');
+        expect(str[2].children[1].value).toBe('Hello World');
 
         // Compare
         const compare = findSection('compare');
-        expect(compare[0].span.children[1].value).toBe(true);
-        expect(compare[1].span.children[1].value).toBe(true);
-        expect(compare[2].span.children[1].value).toBe(true);
+        expect(compare[0].children[1].value).toBe(true);
+        expect(compare[1].children[1].value).toBe(true);
+        expect(compare[2].children[1].value).toBe(true);
 
         // Conditional
         const conditional = findSection('conditional');
-        expect(conditional[0].span.children[1].value).toBe('Yes');
-        expect(conditional[1].span.children[1].value).toBe('No');
+        expect(conditional[0].children[1].value).toBe('Yes');
+        expect(conditional[1].children[1].value).toBe('No');
 
         // Array
         const array = findSection('array');
-        expect(array[0].span.children[1].value).toBe('a-b-c');
-        expect(array[1].span.children[1].value).toBe(3);
-        expect(array[2].span.children[1].value).toBe('a');
+        expect(array[0].children[1].value).toBe('a-b-c');
+        expect(array[1].children[1].value).toBe(3);
+        expect(array[2].children[1].value).toBe('a');
 
         // Stats
         const stats = findSection('stats');
-        expect(stats[0].span.children[1].value).toBe(100);
-        expect(stats[1].span.children[1].value).toBe(25);
-        expect(stats[2].span.children[1].value).toBe(40);
-        expect(stats[3].span.children[1].value).toBe(10);
+        expect(stats[0].children[1].value).toBe(100);
+        expect(stats[1].children[1].value).toBe(25);
+        expect(stats[2].children[1].value).toBe(40);
+        expect(stats[3].children[1].value).toBe(10);
 
         // Format
         const format = findSection('format');
-        expect(format[0].span.children[1].value).toBe('USD1,234.56');
-        expect(format[1].span.children[1].value).toBe('13%');
+        expect(format[0].children[1].value).toBe('USD1,234.56');
+        expect(format[1].children[1].value).toBe('13%');
     });
 });

package/tests/cdom/parser.test.js

@@ -1,120 +1,33 @@
 import { describe, it, expect, beforeEach } from 'vitest';
 import Lightview from '../../src/lightview.js';
 import LightviewX from '../../src/lightview-x.js';
-import { resolvePath, parseExpression, registerHelper, parseCDOMC } from '../../jprx/parser.js';
-import { registerMathHelpers } from '../../jprx/helpers/math.js';
-import { registerLogicHelpers } from '../../jprx/helpers/logic.js';
-import { registerStringHelpers } from '../../jprx/helpers/string.js';
-import { registerArrayHelpers } from '../../jprx/helpers/array.js';
-import { registerCompareHelpers } from '../../jprx/helpers/compare.js';
-import { registerConditionalHelpers } from '../../jprx/helpers/conditional.js';
-import { registerDateTimeHelpers } from '../../jprx/helpers/datetime.js';
-import { registerFormatHelpers } from '../../jprx/helpers/format.js';
-import { registerLookupHelpers } from '../../jprx/helpers/lookup.js';
-import { registerStatsHelpers } from '../../jprx/helpers/stats.js';
-import { registerStateHelpers } from '../../jprx/helpers/state.js';
+import { parseCDOMC } from '../../jprx/parser.js';
 import { hydrate } from '../../src/lightview-cdom.js';
 
-describe('cdom Parser', () => {
+/**
+ * cdom Integration Tests
+ * 
+ * These tests focus on Lightview-specific functionality:
+ * - CDOMC parsing (concise syntax)
+ * - Hydration (converting static objects to reactive structures)
+ * - Event handler conversion
+ * 
+ * Pure JPRX expression tests are in tests/jprx/spec.test.js
+ */
+describe('cdom Integration', () => {
     beforeEach(() => {
-        // Clear registry before each test
         Lightview.registry.clear();
-        // Register standard helpers
-        registerMathHelpers(registerHelper);
-        registerLogicHelpers(registerHelper);
-        registerStringHelpers(registerHelper);
-        registerArrayHelpers(registerHelper);
-        registerCompareHelpers(registerHelper);
-        registerConditionalHelpers(registerHelper);
-        registerDateTimeHelpers(registerHelper);
-        registerFormatHelpers(registerHelper);
-        registerLookupHelpers(registerHelper);
-        registerStatsHelpers(registerHelper);
-        registerStateHelpers((name, fn) => registerHelper(name, fn, { pathAware: true }));
-
-        // Attach to global for the parser to find it
         globalThis.Lightview = Lightview;
     });
 
-    describe('Path Resolution', () => {
-        it('resolves absolute global paths', () => {
-            Lightview.signal('Alice', 'userName');
-            expect(resolvePath('$/userName')).toBe('Alice');
-        });
-
-        it('resolves deep global paths in state', () => {
-            LightviewX.state({ profile: { name: 'Bob' } }, 'user');
-            expect(resolvePath('$/user/profile/name')).toBe('Bob');
-        });
-
-        it('resolves relative paths against context', () => {
-            const context = { age: 30, city: 'London' };
-            expect(resolvePath('./age', context)).toBe(30);
-        });
-
-        it('resolves array indices', () => {
-            const context = { items: ['apple', 'banana'] };
-            expect(resolvePath('./items/1', context)).toBe('banana');
-        });
-    });
-
-    describe('Expression Parsing', () => {
-        it('creates a computed signal for a path', () => {
-            const sig = Lightview.signal(10, 'count');
-            const expr = parseExpression('$/count');
-
-            expect(expr.value).toBe(10);
-
-            sig.value = 20;
-            expect(expr.value).toBe(20);
-        });
-
-        it('supports math helpers', () => {
-            Lightview.signal(5, 'a');
-            Lightview.signal(10, 'b');
-            const expr = parseExpression('$/+(a, b)');
-
-            expect(expr.value).toBe(15);
-        });
-
-        it('supports logical helpers', () => {
-            Lightview.signal(true, 'isVip');
-            const expr = parseExpression('$/if(isVip, "Gold", "Silver")');
-
-            expect(expr.value).toBe('Gold');
-
-            Lightview.get('isVip').value = false;
-            expect(expr.value).toBe('Silver');
-        });
-
-        it('supports the explosion operator (...)', () => {
-            LightviewX.state({ scores: [10, 20, 30] }, 'game');
-            const expr = parseExpression('$/sum(game/scores...)');
-
-            expect(expr.value).toBe(60);
-
-            const scores = Lightview.get('game').scores;
-            scores.push(40);
-            expect(expr.value).toBe(100);
-        });
-
-        it('handles nested navigation with helpers ($/user/upper(name))', () => {
-            LightviewX.state({ user: { name: 'charlie' } }, 'app');
-            // This tests: navigate to app/user, then call upper() on app/user.name
-            const expr = parseExpression('$/app/user/upper(name)');
-
-            expect(expr.value).toBe('CHARLIE');
-        });
-    });
-
     describe('CDOMC Parser', () => {
-        it('parses unquoted $ expressions as strings', () => {
-            const input = '{ button: { onclick: $increment($/count), children: "Click" } }';
+        it('parses unquoted = expressions as strings', () => {
+            const input = '{ button: { onclick: =increment(=/count), children: "Click" } }';
             const result = parseCDOMC(input);
 
             expect(result).toEqual({
                 button: {
-                    onclick: '$increment($/count)',
+                    onclick: '=increment(=/count)',
                     children: 'Click'
                 }
             });
@@ -132,24 +45,23 @@ describe('cdom Parser', () => {
             });
         });
 
-        it('preserves $ prefix in simple paths', () => {
-            const input = '{ input: { cdom-bind: $/user/name } }';
+        it('preserves = prefix in simple paths', () => {
+            const input = '{ input: { cdom-bind: =/user/name } }';
             const result = parseCDOMC(input);
 
             expect(result).toEqual({
                 input: {
-                    'cdom-bind': '$/user/name'
+                    'cdom-bind': '=/user/name'
                 }
             });
         });
     });
 
     describe('Hydration', () => {
-        it('converts event handler $ expressions to functions', () => {
-
+        it('converts event handler = expressions to functions', () => {
             const input = {
                 button: {
-                    onclick: '$increment($/count)',
+                    onclick: '=increment(=/count)',
                     children: ['Click']
                 }
             };
@@ -157,12 +69,11 @@ describe('cdom Parser', () => {
             const result = hydrate(input);
 
             // onclick should now be a function
-            expect(typeof result.button.onclick).toBe('function');
-            expect(result.button.children).toEqual(['Click']);
+            expect(typeof result.attributes.onclick).toBe('function');
+            expect(result.children).toEqual(['Click']);
         });
 
-        it('preserves non-$ event handlers as strings', () => {
-
+        it('preserves non-= event handlers as strings', () => {
             const input = {
                 button: {
                     onclick: 'alert("hello")',
@@ -172,8 +83,22 @@ describe('cdom Parser', () => {
 
             const result = hydrate(input);
 
-            // onclick should remain a string (non-$ expression)
-            expect(result.button.onclick).toBe('alert("hello")');
+            // onclick should remain a string (non-= expression)
+            expect(result.attributes.onclick).toBe('alert("hello")');
+        });
+
+        it('handles escape sequence for literal = strings', () => {
+            // Test escape in children array context
+            const input = {
+                div: {
+                    children: ["'=E=mc²"]
+                }
+            };
+
+            const result = hydrate(input);
+
+            // Should strip the leading ' and keep the rest as literal
+            expect(result.children[0]).toBe('=E=mc²');
         });
     });
 });

package/tests/cdom/reactivity.test.js

@@ -12,7 +12,7 @@ describe('cdom Reactivity', () => {
 
     it('should update DOM-like values when signals change', () => {
         const title = Lightview.signal('Hello', 'pageTitle');
-        const expr = LightviewCDOM.parseExpression('$/pageTitle');
+        const expr = LightviewCDOM.parseExpression('=/pageTitle');
 
         expect(expr.value).toBe('Hello');
 
@@ -26,7 +26,8 @@ describe('cdom Reactivity', () => {
             { id: 2, amount: 200 }
         ], 'bills');
 
-        const totalExpr = LightviewCDOM.parseExpression('$/sum(bills/amount...)');
+        // Correct syntax: =sum() is the function, /bills...amount is the argument
+        const totalExpr = LightviewCDOM.parseExpression('=sum(/bills...amount)');
         expect(totalExpr.value).toBe(300);
 
         // Update an existing item
@@ -44,7 +45,8 @@ describe('cdom Reactivity', () => {
 
     it('should handle conditional logic reactively', () => {
         const user = LightviewX.state({ loggedIn: false, name: 'Guest' }, 'user');
-        const greeting = LightviewCDOM.parseExpression('$/user/if(loggedIn, concat("Welcome, ", ./name), "Please Login")');
+        // Correct syntax: =if() is the function with paths as arguments
+        const greeting = LightviewCDOM.parseExpression('=if(/user/loggedIn, concat("Welcome, ", /user/name), "Please Login")');
 
         expect(greeting.value).toBe('Please Login');
 
@@ -52,6 +54,7 @@ describe('cdom Reactivity', () => {
         user.name = 'Alice';
         expect(greeting.value).toBe('Welcome, Alice');
     });
+
     it('should handle reactivity on multi-level nested objects', () => {
         const settings = LightviewX.state({
             theme: {
@@ -68,9 +71,9 @@ describe('cdom Reactivity', () => {
             }
         }, 'settings');
 
-        const colorExpr = LightviewCDOM.parseExpression('$/settings/theme/colors/primary');
-        const sizeExpr = LightviewCDOM.parseExpression('$/settings/theme/font/size');
-        const deepExpr = LightviewCDOM.parseExpression('$/concat(settings/theme/colors/primary, "-", settings/theme/font/size)');
+        const colorExpr = LightviewCDOM.parseExpression('=/settings/theme/colors/primary');
+        const sizeExpr = LightviewCDOM.parseExpression('=/settings/theme/font/size');
+        const deepExpr = LightviewCDOM.parseExpression('=concat(/settings/theme/colors/primary, "-", /settings/theme/font/size)');
 
         expect(colorExpr.value).toBe('blue');
         expect(sizeExpr.value).toBe('16px');
@@ -115,14 +118,14 @@ describe('cdom Reactivity', () => {
         const cdomcStructure = {
             div: {
                 id: 'profile-card',
-                class: '$/profile/ui/theme', // Bound to ui.theme
+                class: '=/profile/ui/theme', // Bound to ui.theme
                 children: [
                     {
                         div: {
                             class: 'header',
                             children: [
-                                { h1: { children: ['$/profile/user/details/name'] } }, // Bound to user.details.name
-                                { img: { src: '$/profile/user/details/avatar/src', alt: '$/profile/user/details/avatar/alt' } }
+                                { h1: { children: ['=/profile/user/details/name'] } }, // Bound to user.details.name
+                                { img: { src: '=/profile/user/details/avatar/src', alt: '=/profile/user/details/avatar/alt' } }
                             ]
                         }
                     },
@@ -130,8 +133,8 @@ describe('cdom Reactivity', () => {
                         div: {
                             class: 'stats',
                             children: [
-                                { span: { children: ["Posts: ", '$/profile/user/stats/posts'] } }, // Bound to user.stats.posts
-                                { span: { children: ["Followers: ", '$/profile/user/stats/followers'] } }
+                                { span: { children: ["Posts: ", '=/profile/user/stats/posts'] } }, // Bound to user.stats.posts
+                                { span: { children: ["Followers: ", '=/profile/user/stats/followers'] } }
                             ]
                         }
                     },
@@ -140,10 +143,10 @@ describe('cdom Reactivity', () => {
                         div: {
                             class: 'helpers-test',
                             children: [
-                                // Logic + String helpers: "HELLO BOB" or "HELLO USER"
-                                { p: { children: ['$/upper(if(profile/user/details/name, profile/user/details/name, "User"))'] } },
+                                // Correct syntax: =upper() is the function, with nested if() and path
+                                { p: { children: ['=upper(if(/profile/user/details/name, /profile/user/details/name, "User"))'] } },
                                 // Math + Stats helpers: Sum of posts and followers
-                                { p: { children: ['Total interactions: ', '$/sum(profile/user/stats/posts, profile/user/stats/followers)'] } }
+                                { p: { children: ['Total interactions: ', '=sum(/profile/user/stats/posts, /profile/user/stats/followers)'] } }
                             ]
                         }
                     }
@@ -155,19 +158,19 @@ describe('cdom Reactivity', () => {
         const hydrated = LightviewCDOM.hydrate(cdomcStructure);
 
         // 4. Inspect & Assert Initial State
-        const root = hydrated.div;
-        const header = root.children[0].div;
-        const stats = root.children[1].div;
-        const helpers = root.children[2].div;
+        const root = hydrated;
+        const header = root.children[0];
+        const stats = root.children[1];
+        const helpers = root.children[2];
 
-        expect(root.class.value).toBe('dark');
-        expect(header.children[0].h1.children[0].value).toBe('Bob');
-        expect(header.children[1].img.src.value).toBe('img.png');
-        expect(stats.children[0].span.children[1].value).toBe(10);
+        expect(root.attributes.class.value).toBe('dark');
+        expect(header.children[0].children[0].value).toBe('Bob');
+        expect(header.children[1].attributes.src.value).toBe('img.png');
+        expect(stats.children[0].children[1].value).toBe(10);
 
         // Assert Helpers Initial State
-        expect(helpers.children[0].p.children[0].value).toBe('BOB'); // upper('Bob')
-        expect(helpers.children[1].p.children[1].value).toBe(60); // sum(10, 50)
+        expect(helpers.children[0].children[0].value).toBe('BOB'); // upper('Bob')
+        expect(helpers.children[1].children[1].value).toBe(60); // sum(10, 50)
 
         // 5. Trigger Deep Updates
         profile.user.details.name = 'Robert';
@@ -175,12 +178,12 @@ describe('cdom Reactivity', () => {
         profile.user.stats.posts = 20;
 
         // 6. Assert Updates Propagated to cdomC Structure
-        expect(root.class.value).toBe('light'); // Top-level attr
-        expect(header.children[0].h1.children[0].value).toBe('Robert'); // Deep nested text
-        expect(stats.children[0].span.children[1].value).toBe(20); // Deep nested sibling
+        expect(root.attributes.class.value).toBe('light'); // Top-level attr
+        expect(header.children[0].children[0].value).toBe('Robert'); // Deep nested text
+        expect(stats.children[0].children[1].value).toBe(20); // Deep nested sibling
 
         // Assert Helpers Updated State
-        expect(helpers.children[0].p.children[0].value).toBe('ROBERT'); // upper('Robert')
-        expect(helpers.children[1].p.children[1].value).toBe(70); // sum(20, 50)
+        expect(helpers.children[0].children[0].value).toBe('ROBERT'); // upper('Robert')
+        expect(helpers.children[1].children[1].value).toBe(70); // sum(20, 50)
     });
 });

package/tests/jprx/spec.test.js

@@ -0,0 +1,99 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import Lightview from '../../src/lightview.js';
+import LightviewX from '../../src/lightview-x.js';
+import { resolveExpression, registerHelper, registerOperator } from '../../jprx/parser.js';
+import { registerMathHelpers } from '../../jprx/helpers/math.js';
+import { registerLogicHelpers } from '../../jprx/helpers/logic.js';
+import { registerStatsHelpers } from '../../jprx/helpers/stats.js';
+import { registerCompareHelpers } from '../../jprx/helpers/compare.js';
+import { registerStringHelpers } from '../../jprx/helpers/string.js';
+import { registerArrayHelpers } from '../../jprx/helpers/array.js';
+import { registerConditionalHelpers } from '../../jprx/helpers/conditional.js';
+import { registerDateTimeHelpers } from '../../jprx/helpers/datetime.js';
+import { registerFormatHelpers } from '../../jprx/helpers/format.js';
+import { registerLookupHelpers } from '../../jprx/helpers/lookup.js';
+import { registerStateHelpers } from '../../jprx/helpers/state.js';
+import { registerNetworkHelpers } from '../../jprx/helpers/network.js';
+
+// Register standard operators
+const registerStandardOperators = () => {
+    registerOperator('increment', '++', 'prefix', 80);
+    registerOperator('increment', '++', 'postfix', 80);
+    registerOperator('decrement', '--', 'prefix', 80);
+    registerOperator('decrement', '--', 'postfix', 80);
+    registerOperator('toggle', '!!', 'prefix', 80);
+    registerOperator('+', '+', 'infix', 50);
+    registerOperator('-', '-', 'infix', 50);
+    registerOperator('*', '*', 'infix', 60);
+    registerOperator('/', '/', 'infix', 60);
+    registerOperator('gt', '>', 'infix', 40);
+    registerOperator('lt', '<', 'infix', 40);
+    registerOperator('gte', '>=', 'infix', 40);
+    registerOperator('lte', '<=', 'infix', 40);
+    registerOperator('neq', '!=', 'infix', 40);
+};
+
+// Helper to load and run specs
+const runSpec = (specPath) => {
+    const specs = JSON.parse(fs.readFileSync(specPath, 'utf8'));
+
+    describe(path.basename(specPath), () => {
+        beforeEach(() => {
+            // Clear all global reactive state
+            Lightview.registry.clear();
+            Lightview.internals.futureSignals.clear();
+
+            registerMathHelpers(registerHelper);
+            registerLogicHelpers(registerHelper);
+            registerStatsHelpers(registerHelper);
+            registerCompareHelpers(registerHelper);
+            registerStringHelpers(registerHelper);
+            registerArrayHelpers(registerHelper);
+            registerConditionalHelpers(registerHelper);
+            registerDateTimeHelpers(registerHelper);
+            registerFormatHelpers(registerHelper);
+            registerLookupHelpers(registerHelper);
+            registerStateHelpers((name, fn) => registerHelper(name, fn, { pathAware: true }));
+            registerNetworkHelpers(registerHelper);
+
+            registerStandardOperators();
+            globalThis.Lightview = Lightview;
+        });
+
+        specs.forEach((spec) => {
+            it(spec.name || spec.expression, () => {
+                // 1. Setup State
+                if (spec.state) {
+                    Object.entries(spec.state).forEach(([key, value]) => {
+                        if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                            LightviewX.state(value, key);
+                        } else {
+                            Lightview.signal(value, key);
+                        }
+                    });
+                }
+
+                // 2. Evaluate Expression
+                const result = resolveExpression(spec.expression, spec.context);
+
+                // 3. Unwrap if it's a signal
+                const finalValue = (result && typeof result === 'function' && 'value' in result)
+                    ? result.value
+                    : result;
+
+                expect(finalValue).toEqual(spec.expected);
+            });
+        });
+    });
+};
+
+describe('JPRX Shared Specs', () => {
+    const specsDir = path.resolve(__dirname, '../../jprx/specs');
+    const files = fs.readdirSync(specsDir).filter(f => f.endsWith('.json'));
+
+    files.forEach(file => {
+        runSpec(path.join(specsDir, file));
+    });
+});