diff --git a/.github/workflows/test-jaseci.yml b/.github/workflows/test-jaseci.yml
index 02f075a098..811d99d0df 100644
--- a/.github/workflows/test-jaseci.yml
+++ b/.github/workflows/test-jaseci.yml
@@ -43,12 +43,15 @@ jobs:
         pip install -e jac-streamlit
         pip install pytest
         pip install pytest-asyncio
+        pip install pytest-xdist
 
     - name: Set environment for testing
       run: |
         echo "TEST_ENV=true" >> $GITHUB_ENV
     - name: Run tests
-      run: pytest -x jac jac-cloud jac-byllm jac-streamlit
+      run: |
+        pytest -x jac -n auto
+        pytest -x jac-cloud jac-byllm jac-streamlit
     - name: Run jac-cloud tests with DB
       run: pytest -x jac-cloud
       env:
diff --git a/.gitignore b/.gitignore
index 867915271a..e640b5bf14 100644
--- a/.gitignore
+++ b/.gitignore
@@ -36,6 +36,7 @@ MANIFEST
 .coverage
 .session
 *.session.db
+*.session.*.json
 .DS_Store
 .vscode
 build
diff --git a/README.md b/README.md
index 1f8e31dd6a..22540d2bd1 100644
--- a/README.md
+++ b/README.md
@@ -25,7 +25,7 @@
 <!-- =======
   [jac-lang.org] | [Getting Started] | [Contributing]
 
-  [jac-lang.org]: https://www.jac-lang.org/
+  [jac-lang.org]: https://www.jaseci.org/
   [Getting Started]: https://www.jac-lang.org/learn/getting_started/
   [Contributing]: https://www.jac-lang.org/internals/contrib/ -->
 </div>
diff --git a/docs/docs/communityhub/release_notes.md b/docs/docs/communityhub/release_notes.md
index eeb47befe9..6b9b8e2ab0 100644
--- a/docs/docs/communityhub/release_notes.md
+++ b/docs/docs/communityhub/release_notes.md
@@ -5,6 +5,7 @@ This document provides a summary of new features, improvements, and bug fixes in
 
 ## jaclang 0.8.10 / jac-cloud 0.2.10 / byllm 0.4.5 (Unreleased)
 
+- **Frontend + Backend with `cl` Keyword (Experimental)**: Introduced a major experimental feature enabling unified frontend and backend development in a single Jac codebase. The new `cl` (client) keyword marks declarations for client-side compilation, creating a dual compilation pipeline that generates both Python (server) and pure JavaScript (client) code. Includes full JSX language integration for building modern web UIs, allowing developers to write React-style components directly in Jac with seamless interoperability between server and client code.
 - **Parser Performance Optimization**: Refactored parser node tracking to use O(N) complexity instead of O(N²), drastically reducing parsing time for large files by replacing list membership checks with set-based ID lookups.
 - **OPath Designation for Object Spatial Paths**: Moved Path designation for object spatial paths to OPath to avoid conflicts with Python's standard library `pathlib.Path`. This change ensures better interoperability when using Python's path utilities alongside Jac's object-spatial programming features.
 - **byLLM Lazy Loading**: Refactored byLLM to support lazy loading by moving all exports to `byllm.lib` module. Users should now import from `byllm.lib` in Python (e.g., `from byllm.lib import Model, by`) and use `import from byllm.lib { Model }` in Jac code. This improves startup performance and reduces unnecessary module loading.
diff --git a/docs/docs/internals/jsx_client_serv_design.md b/docs/docs/internals/jsx_client_serv_design.md
new file mode 100644
index 0000000000..052c30a5f9
--- /dev/null
+++ b/docs/docs/internals/jsx_client_serv_design.md
@@ -0,0 +1,406 @@
+# JSX-Based Webpage Generation Design Document
+
+## Overview
+
+This document describes how Jac's `cl` (client) keyword produces browser-ready web experiences. Client-marked declarations compile to JavaScript and ship through `jac serve` as static bundles that execute entirely in the browser. The current implementation is **CSR-only** (Client-Side Rendering): the server returns an empty HTML shell with bootstrapping metadata and a JavaScript bundle that handles all rendering in the browser.
+
+## Architecture Overview
+
+```mermaid
+graph TD
+    subgraph "Development - Compilation"
+        A[Jac source with cl] --> B[Jac Compiler]
+        B --> C[PyAST Gen Pass<br/>pyast_gen_pass.py]
+        B --> D[ESTree Gen Pass<br/>esast_gen_pass.py]
+        C --> E[Python module<br/>.py output]
+        D --> F[JavaScript code<br/>module.gen.js]
+    end
+
+    subgraph "Runtime - Serving"
+        E --> H[JacAPIServer]
+        F --> I[ClientBundleBuilder]
+        H --> J[GET /page/fn]
+        I --> K["/static/client.js"]
+        J --> L[HTML shell + init payload]
+        K --> M[Runtime + Module JS]
+        L --> N[Browser]
+        M --> N
+        N --> O[Hydrate & Execute]
+        O --> P[Render JSX to DOM]
+    end
+```
+
+### CSR Execution Flow
+
+1. **Compilation**: When a `.jac` file is compiled:
+   - The `cl` keyword marks declarations for client-side execution
+   - `pyast_gen_pass.py` skips Python codegen for client-only nodes (via `_should_skip_client`)
+   - `esast_gen_pass.py` generates ECMAScript AST and JavaScript code
+   - Client metadata is collected in `ClientManifest` (exports, globals, params)
+
+2. **Bundle Generation**: `ClientBundleBuilder` creates the browser bundle:
+   - Compiles [client_runtime.jac](../jaclang/runtimelib/client_runtime.jac) to provide JSX and walker runtime
+   - Compiles the application module's client-marked code
+   - Generates registration code that exposes functions globally
+   - Includes polyfills (e.g., `Object.prototype.get()` for dict-like access)
+
+3. **Page Request**: When `GET /page/<function_name>` is requested:
+   - Server returns minimal HTML with empty `<div id="__jac_root"></div>`
+   - Embeds `<script id="__jac_init__">` with JSON payload containing:
+     - Module name and function name to execute
+     - Arguments and their ordering
+     - Global variable values
+   - Links to `<script src="/static/client.js?hash=...">` bundle
+
+4. **Client Execution**: On DOM load, the browser:
+   - Parses the `__jac_init__` payload
+   - Looks up the requested function from the global registry
+   - Restores client global variables
+   - Executes the function with provided arguments
+   - Calls `renderJsxTree()` to render the returned JSX into `__jac_root`
+
+> **Note**: SSR + hydration is not currently implemented. All rendering happens on the client.
+
+## Language Features
+
+### 1. The `cl` (Client) Keyword
+
+The `cl` keyword marks Jac declarations for **client-side compilation**. This enables a single `.jac` file to contain both:
+- **Server-side code** (compiled to Python via `pyast_gen_pass`)
+- **Client-side code** (compiled to JavaScript via `esast_gen_pass`)
+
+When `cl` is present:
+- Node is marked with `is_client_decl = True`
+- Python codegen is skipped for the declaration (via `_should_skip_client()` in [pyast_gen_pass.py:292-294](../jaclang/compiler/passes/main/pyast_gen_pass.py#L292-L294))
+- JavaScript codegen generates ECMAScript AST (in [esast_gen_pass.py](../jaclang/compiler/passes/ecmascript/esast_gen_pass.py))
+- The declaration is tracked in the module's `ClientManifest` (exports, globals, params)
+
+#### Supported Constructs
+
+```jac
+// Client function - executes in browser, can return JSX
+cl def homepage() -> dict {
+    return <div>
+        <h1>Welcome</h1>
+        <button onclick={spawn load_feed()}>Load Feed</button>
+    </div>;
+}
+
+// Client object - available on both client and server
+cl obj ButtonProps {
+    has label: str = "Hello";
+    has count: int = 0;
+}
+
+// Client global - literal value sent to browser
+cl let API_BASE_URL: str = "https://api.example.com";
+```
+
+#### Grammar Definition
+
+From [jac.lark:8-16, 586](../jaclang/compiler/jac.lark#L8-L16):
+
+```lark
+toplevel_stmt: KW_CLIENT? import_stmt
+       | KW_CLIENT? archetype
+       | impl_def
+       | sem_def
+       | KW_CLIENT? ability
+       | KW_CLIENT? global_var
+       | KW_CLIENT? free_code
+       | py_code_block
+       | KW_CLIENT? test
+
+KW_CLIENT: "cl"
+```
+
+### 2. JSX Syntax
+
+JSX is fully supported in Jac with grammar defined in [jac.lark:444-473](../jaclang/compiler/jac.lark#L444-L473). JSX elements are transpiled to `__jacJsx(tag, props, children)` calls by [esast_gen_pass.py:600-701](../jaclang/compiler/passes/ecmascript/esast_gen_pass.py#L600-L701).
+
+#### JSX Features
+
+```jac
+cl def render_example() {
+    // Basic elements
+    let basic = <div>Hello World</div>;
+
+    // Elements with attributes
+    let with_attrs = <button id="submit" class="btn">Click</button>;
+
+    // Expression attributes and children
+    let name = "Alice";
+    let greeting = <h1 data-user={name}>Welcome, {name}!</h1>;
+
+    // Spread attributes
+    let props = {"class": "card", "id": "main"};
+    let with_spread = <div {...props}>Content</div>;
+
+    // Fragment syntax
+    let fragment = <>
+        <div>First</div>
+        <div>Second</div>
+    </>;
+
+    // Component usage (capitalized names)
+    let component = <Button label="Click Me" />;
+
+    return <div>{greeting}{component}</div>;
+}
+```
+
+#### JSX Transpilation
+
+JSX elements compile to function calls:
+- `<div>Hello</div>` → `__jacJsx("div", {}, ["Hello"])`
+- `<Button {...props} />` → `__jacJsx(Button, Object.assign({}, props), [])`
+- Tag names starting with lowercase become string literals
+- Tag names starting with uppercase become identifier references
+- Props merge via `Object.assign()` when spreads are present
+
+## Implementation Details
+
+### Core Components
+
+| Component | Implementation | Key Responsibilities |
+|-----------|----------------|---------------------|
+| **Compiler Passes** | | |
+| [pyast_gen_pass.py](../jaclang/compiler/passes/main/pyast_gen_pass.py) | Python AST generation | Skips Python codegen for `cl`-marked nodes |
+| [esast_gen_pass.py](../jaclang/compiler/passes/ecmascript/esast_gen_pass.py) | ECMAScript AST generation | Generates JavaScript for `cl`-marked nodes, JSX transpilation |
+| [es_unparse.py](../jaclang/compiler/passes/ecmascript/es_unparse.py) | JavaScript code generation | Converts ESTree AST to JavaScript source |
+| **Runtime Components** | | |
+| [client_bundle.py](../jaclang/runtimelib/client_bundle.py) | Bundle builder | Compiles runtime + module, generates registration code |
+| [client_runtime.jac](../jaclang/runtimelib/client_runtime.jac) | Client runtime | JSX rendering (`__jacJsx`, `renderJsxTree`), walker spawning (`__jacSpawn`), auth helpers |
+| [server.py](../jaclang/runtimelib/server.py) | HTTP server | Serves pages (`/page/<fn>`), bundles (`/static/client.js`), walkers |
+| **Data Structures** | | |
+| `ClientManifest` | Metadata container | Stores `exports` (function names), `globals` (var names), `params` (arg order), `globals_values` (literal values) |
+
+### Client Bundle Structure
+
+The bundle generated by `ClientBundleBuilder` contains (in order):
+
+1. **Polyfills** - Browser compatibility shims:
+   ```javascript
+   Object.prototype.get = function(key, defaultValue) {
+       return this.hasOwnProperty(key) ? this[key] : (defaultValue !== undefined ? defaultValue : null);
+   };
+   ```
+
+2. **Client Runtime** - Compiled from [client_runtime.jac](../jaclang/runtimelib/client_runtime.jac):
+   - `__jacJsx(tag, props, children)` - JSX factory function
+   - `renderJsxTree(node, container)` - DOM rendering
+   - `__buildDom(node)` - Recursive DOM builder
+   - `__applyProp(element, key, value)` - Attribute/event handler application
+   - `__jacSpawn(walker, fields)` - Walker invocation via `/walker/<name>` endpoint
+   - Auth helpers: `jacLogin`, `jacLogout`, `jacIsLoggedIn`
+
+3. **Application Module** - Transpiled user code with `cl` declarations
+
+4. **Registration Code** - Exposes module symbols globally:
+   ```javascript
+   (function registerJacClientModule(){
+       const scope = typeof globalThis !== 'undefined' ? globalThis : window;
+       const registry = scope.__jacClient || (scope.__jacClient = { functions: {}, globals: {}, modules: {} });
+
+       // Register functions and globals
+       moduleFunctions["homepage"] = homepage;
+       scope["homepage"] = homepage;
+
+       // Hydration logic - executes on DOMContentLoaded
+       function hydrateJacClient() {
+           const payload = JSON.parse(document.getElementById('__jac_init__').textContent);
+           const target = registry.functions[payload.function];
+           const result = target.apply(scope, orderedArgs);
+           renderJsxTree(result, document.getElementById('__jac_root'));
+       }
+   })();
+   ```
+
+### Server Endpoints
+
+From [server.py](../jaclang/runtimelib/server.py):
+
+| Endpoint | Method | Description | Implementation |
+|----------|--------|-------------|----------------|
+| `/page/<fn>` | GET | Render HTML page for client function | Lines 709-741 |
+| `/static/client.js` | GET | Serve compiled JavaScript bundle | Lines 662-684 |
+| `/walker/<name>` | POST | Spawn walker on node | Lines 914-927 |
+| `/function/<name>` | POST | Call server-side function | Lines 899-912 |
+| `/user/create` | POST | Create new user account | Lines 857-872 |
+| `/user/login` | POST | Authenticate and get token | Lines 874-889 |
+| `/functions` | GET | List available functions | Lines 751-759 |
+| `/walkers` | GET | List available walkers | Lines 761-769 |
+
+#### Page Rendering Flow
+
+When `GET /page/homepage?arg1=value1` is requested:
+
+1. **Parse request** - Extract function name and query params
+2. **Authenticate** - Check auth token, or create guest user
+3. **Load module** - Ensure module is loaded and manifest is available
+4. **Validate function** - Check function is in `client_exports`
+5. **Build payload** - Serialize args, globals, arg order
+6. **Render HTML** - Return shell with embedded payload and script tag
+
+HTML template (from [server.py:343-356](../jaclang/runtimelib/server.py#L343-L356)):
+```html
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="utf-8"/>
+    <title>homepage</title>
+</head>
+<body>
+    <div id="__jac_root"></div>
+    <script id="__jac_init__" type="application/json">{"module":"myapp","function":"homepage","args":{},"globals":{},"argOrder":[]}</script>
+    <script src="/static/client.js?hash=abc123..." defer></script>
+</body>
+</html>
+```
+
+### Client-Side Execution
+
+On page load in the browser:
+
+1. **Wait for DOM** - Registration code waits for `DOMContentLoaded`
+2. **Parse payload** - Extract `__jac_init__` JSON
+3. **Restore globals** - Set global variables from payload
+4. **Lookup function** - Find target function in `__jacClient.functions`
+5. **Order arguments** - Map args dict to positional array using `argOrder`
+6. **Execute function** - Call function with arguments
+7. **Handle result** - If Promise, await; otherwise render immediately
+8. **Render JSX** - Call `renderJsxTree(result, __jac_root)`
+
+From [client_bundle.py:262-279](../jaclang/runtimelib/client_bundle.py#L262-L279):
+```javascript
+const result = target.apply(scope, orderedArgs);
+if (result && typeof result.then === 'function') {
+    result.then(applyRender).catch((err) => {
+        console.error('[Jac] Error resolving client function promise', err);
+    });
+} else {
+    applyRender(result);
+}
+```
+
+### JSX Rendering
+
+The `renderJsxTree` function ([client_runtime.jac:9-11](../jaclang/runtimelib/client_runtime.jac#L9-L11)) calls `__buildDom` to recursively build DOM:
+
+1. **Null/undefined** → Empty text node
+2. **Primitive values** → Text node with `String(value)`
+3. **Object with callable `tag`** → Execute component function, recurse
+4. **Object with string `tag`** → Create element:
+   - Apply props (attributes, event listeners, styles)
+   - Recursively build and append children
+5. **Return DOM node** → Attach to container
+
+Event handlers are bound in `__applyProp` ([client_runtime.jac:53-68](../jaclang/runtimelib/client_runtime.jac#L53-L68)):
+- Props starting with `on` become `addEventListener(event, handler)`
+- `onclick` → `click`, `onsubmit` → `submit`, etc.
+- `class` and `className` set `element.className`
+- `style` objects are applied to `element.style[key]`
+
+## Example Usage
+
+### Complete Application
+
+```jac
+// Server-side data model
+node User {
+    has name: str;
+    has email: str;
+}
+
+// Client-side global configuration
+cl let API_URL: str = "/api";
+
+// Client-side component
+cl obj CardProps {
+    has title: str = "Untitled";
+    has content: str = "";
+}
+
+// Client page - renders in browser
+cl def homepage() {
+    return <div class="app">
+        <header>
+            <h1>Welcome to Jac</h1>
+        </header>
+        <main>
+            <p>Full-stack web development in one language!</p>
+            <button onclick={spawn load_users()}>Load Users</button>
+        </main>
+    </div>;
+}
+
+// Server-side walker - called from client via spawn
+walker LoadUsers {
+    has users: list = [];
+
+    can process with `root entry {
+        # Fetch users from database
+        self.users = [{"name": "Alice"}, {"name": "Bob"}];
+        report self.users;
+    }
+}
+```
+
+### Running the Application
+
+```bash
+# Compile the Jac file
+jac myapp.jac
+
+# Start the server
+jac serve myapp.jac
+
+# Access the page
+# Browser: http://localhost:8000/page/homepage
+```
+
+### Client-Server Interaction
+
+When the user clicks "Load Users":
+
+1. **Client**: `spawn load_users()` triggers `__jacSpawn("LoadUsers", {})`
+2. **HTTP**: `POST /walker/LoadUsers` with `{"nd": "root"}`
+3. **Server**: Spawns `LoadUsers` walker on root node
+4. **Server**: Walker executes, generates reports
+5. **HTTP**: Returns `{"result": {...}, "reports": [...]}`
+6. **Client**: Receives walker results (could update UI)
+
+## Test Coverage
+
+| Test Suite | Location | Coverage |
+|------------|----------|----------|
+| **Client codegen tests** | [test_client_codegen.py](../jaclang/compiler/tests/test_client_codegen.py) | `cl` keyword detection, manifest generation |
+| **ESTree generation tests** | [test_esast_gen_pass.py](../jaclang/compiler/passes/ecmascript/tests/test_esast_gen_pass.py) | JavaScript AST generation |
+| **JavaScript generation tests** | [test_js_generation.py](../jaclang/compiler/passes/ecmascript/tests/test_js_generation.py) | JS code output from ESTree |
+| **Client bundle tests** | [test_client_bundle.py](../jaclang/runtimelib/tests/test_client_bundle.py) | Bundle building, caching |
+| **Server endpoint tests** | [test_serve.py](../jaclang/runtimelib/tests/test_serve.py) | HTTP endpoints, page rendering |
+| **JSX rendering tests** | [test_jsx_render.py](../jaclang/runtimelib/tests/test_jsx_render.py) | JSX parsing and rendering |
+
+### Example Test Fixtures
+
+- [client_jsx.jac](../jaclang/compiler/passes/ecmascript/tests/fixtures/client_jsx.jac) - Comprehensive client syntax examples
+- [jsx_elements.jac](../examples/reference/jsx_elements.jac) - JSX feature demonstrations
+
+## Known Limitations
+
+1. **No SSR/Hydration** - All rendering happens on the client; no server-side pre-rendering
+2. **No Type Checking in JS** - Type annotations are stripped during transpilation
+3. **Limited Walker Integration** - `spawn` from client requires server round-trip
+4. **No React Ecosystem** - Custom JSX runtime, not compatible with React components
+5. **Bundle Size** - Runtime included in every bundle (no code splitting)
+
+## Future Enhancements
+
+Potential improvements for this system:
+
+1. **Server-Side Rendering** - Pre-render initial HTML on server, hydrate on client
+2. **Code Splitting** - Separate runtime from application code, lazy load modules
+3. **Hot Module Replacement** - Live reload during development
+4. **TypeScript Generation** - Optionally emit `.d.ts` files for client code
+5. **React Compatibility** - Support importing and using React components
+6. **WebSocket Support** - Real-time walker updates without polling
diff --git a/docs/jac_syntax_highlighter.py b/docs/jac_syntax_highlighter.py
index 999f28d0bc..725d937991 100644
--- a/docs/jac_syntax_highlighter.py
+++ b/docs/jac_syntax_highlighter.py
@@ -113,6 +113,7 @@ def fstring_rules(ttype):
             (r"#.*$", Comment.Single),
             (r"\\\n", Text),
             (r"\\", Text),
+            include("jsx"),
             include("keywords"),
             include("soft-keywords"),
             (r"(static\s+can)((?:\s|\\\s)+)", bygroups(Keyword, Text), "funcname"),
@@ -158,6 +159,81 @@ def fstring_rules(ttype):
             ),
             include("expr"),
         ],
+        "jsx": [
+            # JSX Fragment: <>...</>
+            (r"(<>)", Punctuation, "jsx-fragment"),
+            # JSX opening tag: <Component or <div
+            (
+                r"(<)([A-Z][A-Za-z0-9_]*(?:\.[A-Z][A-Za-z0-9_]*)*)",
+                bygroups(Punctuation, Name.Class),
+                "jsx-tag",
+            ),
+            (r"(<)([a-z][A-Za-z0-9_\-]*)", bygroups(Punctuation, Name.Tag), "jsx-tag"),
+        ],
+        "jsx-fragment": [
+            (r"(</>)", Punctuation, "#pop"),
+            include("jsx-children"),
+        ],
+        "jsx-tag": [
+            # Self-closing tag end: />
+            (r"(/>)", Punctuation, "#pop"),
+            # Opening tag end: >
+            (r"(>)", Punctuation, "jsx-children-tag"),
+            # Attributes
+            (r"\s+", Whitespace),
+            # Attribute name (including hyphenated names like data-id, aria-label)
+            (
+                r"([A-Za-z_][-A-Za-z0-9_]*)(=)",
+                bygroups(Name.Attribute, Operator),
+                "jsx-attr-value",
+            ),
+            # Attribute without value
+            (r"[A-Za-z_][-A-Za-z0-9_]*", Name.Attribute),
+            # Spread attribute: {...}
+            (r"(\{)(\.\.\.)", bygroups(Punctuation, Operator), "jsx-spread"),
+        ],
+        "jsx-attr-value": [
+            # String values
+            (r'"[^"]*"', String, "#pop"),
+            (r"'[^']*'", String, "#pop"),
+            # Expression values: {expr}
+            (r"\{", Punctuation, "jsx-expr-attr"),
+        ],
+        "jsx-spread": [
+            (r"\}", Punctuation, "#pop"),
+            include("expr"),
+        ],
+        "jsx-expr-attr": [
+            (r"\}", Punctuation, "#pop:2"),
+            include("expr"),
+        ],
+        "jsx-children-tag": [
+            # Closing tag: </Component>
+            (
+                r"(</)([A-Z][A-Za-z0-9_]*(?:\.[A-Z][A-Za-z0-9_]*)*)(>)",
+                bygroups(Punctuation, Name.Class, Punctuation),
+                "#pop:2",
+            ),
+            (
+                r"(</)([a-z][A-Za-z0-9_\-]*)(>)",
+                bygroups(Punctuation, Name.Tag, Punctuation),
+                "#pop:2",
+            ),
+            include("jsx-children"),
+        ],
+        "jsx-children": [
+            # Nested JSX elements
+            include("jsx"),
+            # JSX expressions: {expr}
+            (r"\{", Punctuation, "jsx-expr-child"),
+            # Text content (anything except < > { })
+            (r"[^<>{}\n]+", String),
+            (r"\n", Whitespace),
+        ],
+        "jsx-expr-child": [
+            (r"\}", Punctuation, "#pop"),
+            include("expr"),
+        ],
         "expr": [
             # raw f-strings
             (
@@ -341,6 +417,7 @@ def fstring_rules(ttype):
                         "raise",
                         "nonlocal",
                         "return",
+                        "report",
                         "try",
                         "while",
                         "yield",
@@ -366,6 +443,7 @@ def fstring_rules(ttype):
                         "protect",
                         "has",
                         "check",
+                        "cl",
                     ),
                     suffix=r"\b",
                 ),
diff --git a/docs/mkdocs.yml b/docs/mkdocs.yml
index 4570625001..09d67f93b1 100644
--- a/docs/mkdocs.yml
+++ b/docs/mkdocs.yml
@@ -138,6 +138,7 @@ nav:
     - Edge references (OSP): "learn/jac_ref/edge_references_(osp).md"
     - Filter and assign comprehensions: "learn/jac_ref/filter_and_assign_comprehensions.md"
     - Names and references: "learn/jac_ref/names_and_references.md"
+    - Jsx elements: "learn/jac_ref/jsx_elements.md"
     - Builtin types: "learn/jac_ref/builtin_types.md"
     - f-string tokens: "learn/jac_ref/f_string_tokens.md"
     - Lexer Tokens: "learn/jac_ref/lexer_tokens.md"
@@ -152,6 +153,7 @@ nav:
         - "communityhub/fun/static_fx.md"
       - Content Pieces: "communityhub/content_pieces.md"
     - Internals:
+      - JSX 'Project OneLang' Design Doc: "internals/jsx_client_serv_design.md"
       - Lang Ref Coverage: "internals/refs_coverage_report.md"
       - Roadmap: "communityhub/roadmap.md"
       - Design Docs and Guides:
diff --git a/jac/examples/littleX/littleX_single_nodeps.jac b/jac/examples/littleX/littleX_single_nodeps.jac
index 3a985affed..58a836cfed 100644
--- a/jac/examples/littleX/littleX_single_nodeps.jac
+++ b/jac/examples/littleX/littleX_single_nodeps.jac
@@ -225,3 +225,438 @@ walker load_feed(visit_profile) {
         report self.results ;
     }
 }
+
+
+# Client-side UI Components (marked with 'cl' for browser execution)
+# ===================================================================
+
+# Client-side router state - using a global object to hold state
+cl let appState: dict = {
+    "current_route": "login",
+    "tweets": [],
+    "loading": False
+};
+
+# Router helper functions
+cl def navigate_to(route: str) -> None {
+    console.log("Navigating to:", route);
+    appState["current_route"] = route;
+    window.history.pushState({}, "", "#" + route);
+    # Call render_app asynchronously
+    render_app();  # Fire and forget - browser will handle the async
+}
+
+cl def render_app() -> None {
+    console.log("render_app called, route:", appState.get("current_route", "unknown"));
+    root_element = document.getElementById("__jac_root");
+    if root_element {
+        component = App();
+        console.log("Rendering component to root");
+        renderJsxTree(component, root_element);
+        console.log("Render complete");
+    }
+}
+
+cl def get_current_route() -> str {
+    return appState.get("current_route", "login");
+}
+
+# Handle browser back/forward buttons
+cl def handle_popstate(event: any) -> None {
+    hash = window.location.hash;
+    if hash {
+        appState["current_route"] = hash[1:];  # Remove the '#'
+    } else {
+        appState["current_route"] = "login";
+    }
+    render_app();
+}
+
+# Initialize route from URL hash
+cl def init_router() -> None {
+    hash = window.location.hash;
+    if hash {
+        appState["current_route"] = hash[1:];  # Remove the '#'
+    } else {
+        if jacIsLoggedIn() {
+            appState["current_route"] = "home";
+        } else {
+            appState["current_route"] = "login";
+        }
+    }
+    window.addEventListener("popstate", handle_popstate);
+}
+
+# Shared data model for client/server
+cl obj ClientTweet {
+    has username: str = "";
+    has id: str = "";
+    has content: str = "";
+    has likes: list = [];
+    has comments: list = [];
+}
+
+cl obj ClientProfile {
+    has username: str = "";
+    has id: str = "";
+}
+
+# UI Components - Render a single tweet card
+cl def TweetCard(tweet: ClientTweet) -> any {
+    return <div class="tweet-card" style={{"border": "1px solid #e1e8ed", "padding": "15px", "margin": "10px 0", "borderRadius": "8px"}}>
+        <div class="tweet-header" style={{"fontWeight": "bold", "marginBottom": "8px"}}>
+            @{tweet.username}
+        </div>
+        <div class="tweet-content" style={{"marginBottom": "12px"}}>
+            {tweet.content}
+        </div>
+        <div class="tweet-actions" style={{"display": "flex", "gap": "15px"}}>
+            <button
+                onclick={spawn like_tweet_action(tweet.id)}
+                style={{"padding": "5px 10px", "cursor": "pointer"}}
+            >
+                Like ({tweet.likes.length})
+            </button>
+            <button style={{"padding": "5px 10px"}}>
+                Comment ({tweet.comments.length})
+            </button>
+        </div>
+    </div>;
+}
+
+# Handle liking a tweet - calls server walker
+cl async def like_tweet_action(tweet_id: str) -> any {
+    try {
+        result = await __jacSpawn("like_tweet", {"nd": tweet_id});
+        print("Tweet liked:", result);
+        # Re-render feed after like
+        window.location.reload();
+    } except Exception as e {
+        print("Error liking tweet:", e);
+    }
+}
+
+# Render the main feed view
+cl def FeedView(tweets: list) -> any {
+    return <div class="feed-container" style={{"maxWidth": "600px", "margin": "0 auto", "fontFamily": "sans-serif"}}>
+        <div class="feed-header" style={{"padding": "20px", "borderBottom": "1px solid #e1e8ed"}}>
+            <h1 style={{"margin": "0"}}>LittleX Feed</h1>
+        </div>
+        <div class="feed-content">
+            {[TweetCard(tweet) for tweet in tweets]}
+        </div>
+    </div>;
+}
+
+# Render login form
+cl def LoginForm() -> any {
+    return <div class="login-container" style={{"maxWidth": "400px", "margin": "50px auto", "padding": "20px", "border": "1px solid #e1e8ed", "borderRadius": "8px", "fontFamily": "sans-serif"}}>
+        <h2 style={{"marginTop": "0"}}>Login to LittleX</h2>
+        <form onsubmit={handle_login}>
+            <div style={{"marginBottom": "15px"}}>
+                <label style={{"display": "block", "marginBottom": "5px"}}>Username:</label>
+                <input
+                    type="text"
+                    id="username"
+                    style={{"width": "100%", "padding": "8px", "boxSizing": "border-box"}}
+                />
+            </div>
+            <div style={{"marginBottom": "15px"}}>
+                <label style={{"display": "block", "marginBottom": "5px"}}>Password:</label>
+                <input
+                    type="password"
+                    id="password"
+                    style={{"width": "100%", "padding": "8px", "boxSizing": "border-box"}}
+                />
+            </div>
+            <button
+                type="submit"
+                style={{"width": "100%", "padding": "10px", "backgroundColor": "#1da1f2", "color": "white", "border": "none", "borderRadius": "4px", "cursor": "pointer"}}
+            >
+                Login
+            </button>
+        </form>
+        <div style={{"marginTop": "15px", "textAlign": "center"}}>
+            <a href="#signup" onclick={go_to_signup} style={{"color": "#1da1f2", "textDecoration": "none", "cursor": "pointer"}}>
+                Don't have an account? Sign up
+            </a>
+        </div>
+    </div>;
+}
+
+# Handle login form submission
+cl async def handle_login(event: any) -> None {
+    event.preventDefault();
+    username = document.getElementById("username").value;
+    password = document.getElementById("password").value;
+
+    success = await jacLogin(username, password);
+    if success {
+        navigate_to("home");
+    } else {
+        alert("Login failed. Please try again.");
+    }
+}
+
+# Render signup form
+cl def SignupForm() -> any {
+    return <div class="signup-container" style={{"maxWidth": "400px", "margin": "50px auto", "padding": "20px", "border": "1px solid #e1e8ed", "borderRadius": "8px", "fontFamily": "sans-serif"}}>
+        <h2 style={{"marginTop": "0"}}>Sign Up for LittleX</h2>
+        <form onsubmit={handle_signup}>
+            <div style={{"marginBottom": "15px"}}>
+                <label style={{"display": "block", "marginBottom": "5px"}}>Username:</label>
+                <input
+                    type="text"
+                    id="signup-username"
+                    required
+                    style={{"width": "100%", "padding": "8px", "boxSizing": "border-box"}}
+                />
+            </div>
+            <div style={{"marginBottom": "15px"}}>
+                <label style={{"display": "block", "marginBottom": "5px"}}>Password:</label>
+                <input
+                    type="password"
+                    id="signup-password"
+                    required
+                    style={{"width": "100%", "padding": "8px", "boxSizing": "border-box"}}
+                />
+            </div>
+            <div style={{"marginBottom": "15px"}}>
+                <label style={{"display": "block", "marginBottom": "5px"}}>Confirm Password:</label>
+                <input
+                    type="password"
+                    id="signup-password-confirm"
+                    required
+                    style={{"width": "100%", "padding": "8px", "boxSizing": "border-box"}}
+                />
+            </div>
+            <button
+                type="submit"
+                style={{"width": "100%", "padding": "10px", "backgroundColor": "#1da1f2", "color": "white", "border": "none", "borderRadius": "4px", "cursor": "pointer"}}
+            >
+                Sign Up
+            </button>
+        </form>
+        <div style={{"marginTop": "15px", "textAlign": "center"}}>
+            <a href="#login" onclick={go_to_login} style={{"color": "#1da1f2", "textDecoration": "none", "cursor": "pointer"}}>
+                Already have an account? Login
+            </a>
+        </div>
+    </div>;
+}
+
+# Navigation helper functions
+cl def go_to_login(event: any) -> None {
+    event.preventDefault();
+    navigate_to("login");
+}
+
+cl def go_to_signup(event: any) -> None {
+    event.preventDefault();
+    navigate_to("signup");
+}
+
+cl def go_to_home(event: any) -> None {
+    event.preventDefault();
+    navigate_to("home");
+}
+
+cl def go_to_profile(event: any) -> None {
+    event.preventDefault();
+    navigate_to("profile");
+}
+
+# Handle signup form submission
+cl async def handle_signup(event: any) -> None {
+    event.preventDefault();
+    username = document.getElementById("signup-username").value;
+    password = document.getElementById("signup-password").value;
+    password_confirm = document.getElementById("signup-password-confirm").value;
+
+    if password != password_confirm {
+        alert("Passwords do not match!");
+        return;
+    }
+
+    if username.length < 3 {
+        alert("Username must be at least 3 characters long.");
+        return;
+    }
+
+    if password.length < 6 {
+        alert("Password must be at least 6 characters long.");
+        return;
+    }
+
+    try {
+        response = await __fetch("/user/create", {
+            "method": "POST",
+            "headers": {"Content-Type": "application/json"},
+            "body": __jsonStringify({"username": username, "password": password})
+        });
+
+        if response.ok {
+            data = __jsonParse(await response.text());
+            token = data.get("token");
+            if token {
+                __setLocalStorage("jac_token", token);
+                alert("Account created successfully! Welcome to LittleX!");
+                navigate_to("home");
+            } else {
+                alert("Signup succeeded but no token received.");
+            }
+        } else {
+            error_text = await response.text();
+            try {
+                error_data = __jsonParse(error_text);
+                error_msg = error_data.get("error", "Signup failed");
+                alert(error_msg);
+            } except Exception {
+                alert("Signup failed: " + error_text);
+            }
+        }
+    } except Exception as e {
+        alert("Error during signup: " + __toString(e));
+    }
+}
+
+# Handle logout
+cl def logout_action() -> None {
+    jacLogout();
+    navigate_to("login");
+}
+
+# Main App component that handles routing
+cl def App() -> any {
+    route = get_current_route();
+    nav_bar = build_nav_bar(route);
+    content_view = get_view_for_route(route);
+
+    return <div class="app-container">
+        {nav_bar}
+        {content_view}
+    </div>;
+}
+
+# Get the view for a given route (handles async)
+cl def get_view_for_route(route: str) -> any {
+    if route == "signup" {
+        return SignupForm();
+    }
+
+    if route == "home" {
+        # For home, return a loading placeholder and load async
+        return HomeViewLoader();
+    }
+
+    if route == "profile" {
+        return ProfileView();
+    }
+
+    # Default to login
+    return LoginForm();
+}
+
+# Loader component for home view that handles async loading
+cl def HomeViewLoader() -> any {
+    # Trigger async load
+    load_home_view();
+
+    # Return loading state
+    return <div style={{"textAlign": "center", "padding": "50px", "fontFamily": "sans-serif"}}>
+        <h2>Loading feed...</h2>
+    </div>;
+}
+
+# Async function to load and render home view
+cl async def load_home_view() -> None {
+    view = await HomeView();
+    root = document.getElementById("__jac_root");
+    if root {
+        renderJsxTree(<div class="app-container">
+            {build_nav_bar("home")}
+            {view}
+        </div>, root);
+    }
+}
+
+# Helper to build navigation bar
+cl def build_nav_bar(route: str) -> any {
+    if not jacIsLoggedIn() or route == "login" or route == "signup" {
+        return None;
+    }
+
+    return <nav style={{"backgroundColor": "#1da1f2", "padding": "15px", "marginBottom": "20px"}}>
+        <div style={{"maxWidth": "600px", "margin": "0 auto", "display": "flex", "gap": "20px", "alignItems": "center"}}>
+            <a href="#home" onclick={go_to_home} style={{"color": "white", "textDecoration": "none", "fontWeight": "bold", "cursor": "pointer"}}>
+                Home
+            </a>
+            <a href="#profile" onclick={go_to_profile} style={{"color": "white", "textDecoration": "none", "fontWeight": "bold", "cursor": "pointer"}}>
+                Profile
+            </a>
+            <button onclick={logout_action} style={{"marginLeft": "auto", "padding": "5px 15px", "backgroundColor": "white", "color": "#1da1f2", "border": "none", "borderRadius": "4px", "cursor": "pointer", "fontWeight": "bold"}}>
+                Logout
+            </button>
+        </div>
+    </nav>;
+}
+
+# Home view (async version of littlex_home)
+cl async def HomeView() -> any {
+    if not jacIsLoggedIn() {
+        navigate_to("login");
+        return <div></div>;
+    }
+
+    try {
+        # Spawn load_feed walker to get tweets
+        result = await __jacSpawn("load_feed", {});
+
+        # Transform walker results to ClientTweet objects
+        tweets = [];
+        if result and result.reports and result.reports.length > 0 {
+            feed_data = result.reports[0];
+            for item in feed_data {
+                if item.Tweet_Info {
+                    tweet_info = item.Tweet_Info;
+                    tweets.append(
+                        ClientTweet(
+                            username=tweet_info.username,
+                            id=tweet_info.id,
+                            content=tweet_info.content,
+                            likes=tweet_info.likes,
+                            comments=tweet_info.comments
+                        )
+                    );
+                }
+            }
+        }
+
+        return FeedView(tweets);
+    } except Exception as e {
+        return <div style={{"padding": "20px", "color": "red"}}>
+            Error loading feed: {__toString(e)}
+        </div>;
+    }
+}
+
+# Profile view
+cl def ProfileView() -> any {
+    if not jacIsLoggedIn() {
+        navigate_to("login");
+        return <div></div>;
+    }
+
+    return <div class="profile-container" style={{"maxWidth": "600px", "margin": "20px auto", "padding": "20px", "fontFamily": "sans-serif"}}>
+        <h1>Profile</h1>
+        <div style={{"padding": "15px", "border": "1px solid #e1e8ed", "borderRadius": "8px"}}>
+            <p>Profile information will be displayed here.</p>
+        </div>
+    </div>;
+}
+
+# Main SPA entry point - this is what gets called when the page loads
+cl def littlex_app() -> any {
+    init_router();
+    return App();
+}
diff --git a/jac/examples/reference/jsx_elements.jac b/jac/examples/reference/jsx_elements.jac
new file mode 100644
index 0000000000..f6745baebb
--- /dev/null
+++ b/jac/examples/reference/jsx_elements.jac
@@ -0,0 +1,109 @@
+# JSX Elements with Contextual Lexing
+# Demonstrates various JSX features supported in Jac
+
+# Simple component function that returns JSX
+def Button(text: str, onclick: str) -> dict {
+    return <button onclick={onclick}>{text}</button>;
+}
+
+# Component with multiple props
+def Card(title: str, content: str, className: str) -> dict {
+    return (
+        <div class={className}>
+            <h2>{title}</h2>
+            <p>{content}</p>
+        </div>
+    );
+}
+
+with entry {
+    # 1. Basic HTML element with text
+    let basic_element = <div>Hello World</div>;
+    print("Basic element:", basic_element);
+
+    # 2. Element with attributes
+    let with_attrs = <div class="container" id="main">Content</div>;
+    print("With attributes:", with_attrs);
+
+    # 3. Self-closing element
+    let self_closing = <img src="image.jpg" alt="Description" />;
+    print("Self-closing:", self_closing);
+
+    # 4. Nested elements
+    let nested = (
+        <div>
+            <h1>Title</h1>
+            <p>Paragraph text</p>
+        </div>
+    );
+    print("Nested elements:", nested);
+
+    # 5. Elements with expression attributes
+    let name = "user123";
+    let age = 25;
+    let user_element = <div id={name} data-age={age}>User Info</div>;
+    print("Expression attributes:", user_element);
+
+    # 6. Elements with expression children
+    let count = 42;
+    let with_expr_child = <div>Count: {count}</div>;
+    print("Expression children:", with_expr_child);
+
+    # 7. Component usage (capitalized names)
+    let button = <Button text="Click Me" onclick="handleClick()" />;
+    print("Component:", button);
+
+    # 8. Spread attributes
+    let props = {"class": "btn", "type": "submit"};
+    let with_spread = <button {...props}>Submit</button>;
+    print("Spread attributes:", with_spread);
+
+    # 9. Mixed attributes and spread
+    let base_props = {"class": "card"};
+    let card = <Card {...base_props} title="Welcome" content="Hello!" className="custom" />;
+    print("Mixed spread:", card);
+
+    # 10. Complex nested structure
+    let app = (
+        <div class="app">
+            <header>
+                <h1>My App</h1>
+                <nav>
+                    <a href="/home">Home</a>
+                    <a href="/about">About</a>
+                </nav>
+            </header>
+            <main>
+                <Card title="Card 1" content="First card" className="card-primary" />
+                <Card title="Card 2" content="Second card" className="card-secondary" />
+            </main>
+            <footer>
+                <p>Footer text</p>
+            </footer>
+        </div>
+    );
+    print("Complex structure:", app);
+
+    # 11. Fragment (no tag name)
+    let fragment = (
+        <>
+            <div>First</div>
+            <div>Second</div>
+        </>
+    );
+    print("Fragment:", fragment);
+
+    # 12. Dynamic list rendering
+    let items = ["Apple", "Banana", "Cherry"];
+    let list_items = [(<li key={i}>{item}</li>) for (i, item) in enumerate(items)];
+    let list_element = <ul>{list_items}</ul>;
+    print("Dynamic list:", list_element);
+
+    # 13. Conditional rendering with expressions
+    let is_logged_in = True;
+    let user_name = "Alice";
+    let greeting = <div>{ f"Welcome, {user_name}!" if is_logged_in else "Please log in" }</div>;
+    print("Conditional:", greeting);
+
+    print("\nAll JSX examples completed successfully!");
+}
diff --git a/jac/examples/reference/jsx_elements.md b/jac/examples/reference/jsx_elements.md
new file mode 100644
index 0000000000..908c7b0bbb
--- /dev/null
+++ b/jac/examples/reference/jsx_elements.md
@@ -0,0 +1,14 @@
+JSX elements with contextual lexing allow embedding HTML-like syntax within Jac code.
+
+**Basic JSX Elements**
+
+JSX (JavaScript XML) syntax in Jac enables writing UI elements in a familiar HTML-like format. The lexer uses contextual lexing to switch between regular Jac syntax and JSX syntax seamlessly.
+
+**Key Features**
+
+- Self-closing tags: `<Component />`
+- Nested elements: `<Parent><Child /></Parent>`
+- Attributes with values: `<div prop="value" />`
+- Dynamic content interpolation
+
+This feature enables more expressive and readable code when working with UI components or templating.
diff --git a/jac/examples/reference/jsx_elements.py b/jac/examples/reference/jsx_elements.py
new file mode 100644
index 0000000000..305db1b141
--- /dev/null
+++ b/jac/examples/reference/jsx_elements.py
@@ -0,0 +1,44 @@
+from __future__ import annotations
+from jaclang.lib import jsx
+
+def Button(text: str, onclick: str) -> dict:
+    return jsx('button', {'onclick': onclick}, [text])
+
+def Card(title: str, content: str, className: str) -> dict:
+    return jsx('div', {'class': className}, [jsx('h2', {}, [title]), jsx('p', {}, [content])])
+basic_element = jsx('div', {}, ['Hello World'])
+print('Basic element:', basic_element)
+with_attrs = jsx('div', {'class': 'container', 'id': 'main'}, ['Content'])
+print('With attributes:', with_attrs)
+self_closing = jsx('img', {'src': 'image.jpg', 'alt': 'Description'}, [])
+print('Self-closing:', self_closing)
+nested = jsx('div', {}, [jsx('h1', {}, ['Title']), jsx('p', {}, ['Paragraph text'])])
+print('Nested elements:', nested)
+name = 'user123'
+age = 25
+user_element = jsx('div', {'id': name, 'data-age': age}, ['User Info'])
+print('Expression attributes:', user_element)
+count = 42
+with_expr_child = jsx('div', {}, ['Count: ', count])
+print('Expression children:', with_expr_child)
+button = jsx(Button, {'text': 'Click Me', 'onclick': 'handleClick()'}, [])
+print('Component:', button)
+props = {'class': 'btn', 'type': 'submit'}
+with_spread = jsx('button', {**{}, **props}, ['Submit'])
+print('Spread attributes:', with_spread)
+base_props = {'class': 'card'}
+card = jsx(Card, {**{**{**{**{}, **base_props}, 'title': 'Welcome'}, 'content': 'Hello!'}, 'className': 'custom'}, [])
+print('Mixed spread:', card)
+app = jsx('div', {'class': 'app'}, [jsx('header', {}, [jsx('h1', {}, ['My App']), jsx('nav', {}, [jsx('a', {'href': '/home'}, ['Home']), jsx('a', {'href': '/about'}, ['About'])])]), jsx('main', {}, [jsx(Card, {'title': 'Card 1', 'content': 'First card', 'className': 'card-primary'}, []), jsx(Card, {'title': 'Card 2', 'content': 'Second card', 'className': 'card-secondary'}, [])]), jsx('footer', {}, [jsx('p', {}, ['Footer text'])])])
+print('Complex structure:', app)
+fragment = jsx(None, {}, [jsx('div', {}, ['First']), jsx('div', {}, ['Second'])])
+print('Fragment:', fragment)
+items = ['Apple', 'Banana', 'Cherry']
+list_items = [jsx('li', {'key': i}, [item]) for i, item in enumerate(items)]
+list_element = jsx('ul', {}, [list_items])
+print('Dynamic list:', list_element)
+is_logged_in = True
+user_name = 'Alice'
+greeting = jsx('div', {}, [f'Welcome, {user_name}!' if is_logged_in else 'Please log in'])
+print('Conditional:', greeting)
+print('\nAll JSX examples completed successfully!')
diff --git a/jac/jaclang/cli/cli.py b/jac/jaclang/cli/cli.py
index c53a10e732..12a446f660 100644
--- a/jac/jaclang/cli/cli.py
+++ b/jac/jaclang/cli/cli.py
@@ -663,6 +663,49 @@ def jac2py(filename: str) -> None:
         exit(1)
 
 
+@cmd_registry.register
+def js(filename: str) -> None:
+    """Convert a Jac file to JavaScript code.
+
+    Translates Jac source code to equivalent JavaScript/ECMAScript code using
+    the ESTree AST specification. This allows Jac programs to run in JavaScript
+    environments like Node.js or web browsers.
+
+    Args:
+        filename: Path to the .jac file to convert
+
+    Examples:
+        jac js myprogram.jac > myprogram.js
+        jac js myprogram.jac
+    """
+    if filename.endswith(".jac"):
+        try:
+            prog = JacProgram()
+            ir = prog.compile(file_path=filename)
+
+            if prog.errors_had:
+                for error in prog.errors_had:
+                    print(f"Error: {error}", file=sys.stderr)
+                exit(1)
+            js_output = ir.gen.js or ""
+            if not js_output.strip():
+                print(
+                    "ECMAScript code generation produced no output.",
+                    file=sys.stderr,
+                )
+                exit(1)
+            print(js_output)
+        except Exception as e:
+            print(f"Error generating JavaScript: {e}", file=sys.stderr)
+            import traceback
+
+            traceback.print_exc()
+            exit(1)
+    else:
+        print("Not a .jac file.", file=sys.stderr)
+        exit(1)
+
+
 # Register core commands first (before plugins load)
 # These can be overridden by plugins with higher priority
 
@@ -739,6 +782,7 @@ def serve(
         module_name=mod,
         session_path=session_path,
         port=port,
+        base_path=base,
     )
 
     try:
diff --git a/jac/jaclang/compiler/codeinfo.py b/jac/jaclang/compiler/codeinfo.py
index 8a30c0764a..fe3cd45450 100644
--- a/jac/jaclang/compiler/codeinfo.py
+++ b/jac/jaclang/compiler/codeinfo.py
@@ -3,12 +3,24 @@
 from __future__ import annotations
 
 import ast as ast3
-from typing import Optional, TYPE_CHECKING
+from dataclasses import dataclass, field
+from typing import Any, Optional, TYPE_CHECKING
 
 if TYPE_CHECKING:
     from jaclang.compiler.unitree import Source, Token
 
 
+@dataclass
+class ClientManifest:
+    """Client-side rendering manifest metadata."""
+
+    exports: list[str] = field(default_factory=list)
+    globals: list[str] = field(default_factory=list)
+    params: dict[str, list[str]] = field(default_factory=dict)
+    globals_values: dict[str, Any] = field(default_factory=dict)
+    has_client: bool = False
+
+
 class CodeGenTarget:
     """Code generation target."""
 
@@ -20,6 +32,7 @@ def __init__(self) -> None:
         self.jac: str = ""
         self.doc_ir: doc.DocType = doc.Text("")
         self.js: str = ""
+        self.client_manifest: ClientManifest = ClientManifest()
         self.py_ast: list[ast3.AST] = []
         self.py_bytecode: Optional[bytes] = None
 
diff --git a/jac/jaclang/compiler/constant.py b/jac/jaclang/compiler/constant.py
index 4ad79a33dd..f43df3286e 100644
--- a/jac/jaclang/compiler/constant.py
+++ b/jac/jaclang/compiler/constant.py
@@ -247,6 +247,7 @@ class Tokens(str, Enum):
     KW_OVERRIDE = "KW_OVERRIDE"
     KW_MATCH = "KW_MATCH"
     KW_CASE = "KW_CASE"
+    KW_CLIENT = "KW_CLIENT"
     PLUS = "PLUS"
     MINUS = "MINUS"
     STAR_MUL = "STAR_MUL"
@@ -295,6 +296,14 @@ class Tokens(str, Enum):
     RETURN_HINT = "RETURN_HINT"
     NULL_OK = "NULL_OK"
     DECOR_OP = "DECOR_OP"
+    JSX_TEXT = "JSX_TEXT"
+    JSX_OPEN_START = "JSX_OPEN_START"
+    JSX_SELF_CLOSE = "JSX_SELF_CLOSE"
+    JSX_TAG_END = "JSX_TAG_END"
+    JSX_CLOSE_START = "JSX_CLOSE_START"
+    JSX_FRAG_OPEN = "JSX_FRAG_OPEN"
+    JSX_FRAG_CLOSE = "JSX_FRAG_CLOSE"
+    JSX_NAME = "JSX_NAME"
     COMMENT = "COMMENT"
     WS = "WS"
     F_DQ_START = "F_DQ_START"
diff --git a/jac/jaclang/compiler/jac.lark b/jac/jaclang/compiler/jac.lark
index f9cd2b6b59..59cd9f7f1f 100644
--- a/jac/jaclang/compiler/jac.lark
+++ b/jac/jaclang/compiler/jac.lark
@@ -5,15 +5,15 @@ module: (toplevel_stmt (tl_stmt_with_doc | toplevel_stmt)*)?
        | STRING        (tl_stmt_with_doc | toplevel_stmt)*
 
 tl_stmt_with_doc: STRING toplevel_stmt
-toplevel_stmt: import_stmt
-       | archetype
+toplevel_stmt: KW_CLIENT? import_stmt
+       | KW_CLIENT? archetype
        | impl_def
        | sem_def
-       | ability
-       | global_var
-       | free_code
+       | KW_CLIENT? ability
+       | KW_CLIENT? global_var
+       | KW_CLIENT? free_code
        | py_code_block
-       | test
+       | KW_CLIENT? test
 
 // [Heading]: Import/Include Statements.
 import_stmt: KW_IMPORT KW_FROM from_path LBRACE import_items RBRACE
@@ -328,6 +328,7 @@ atom: named_ref
     | atom_collection
     | atom_literal
     | type_ref
+    | jsx_element
 
 atom_literal: builtin_type
             | NULL
@@ -439,6 +440,37 @@ special_ref: KW_INIT
             | KW_HERE
             | KW_VISITOR
 
+// [Heading]: JSX Elements.
+jsx_element: jsx_self_closing
+           | jsx_fragment
+           | jsx_opening_closing
+
+jsx_self_closing: JSX_OPEN_START jsx_element_name jsx_attributes? JSX_SELF_CLOSE
+jsx_opening_closing: jsx_opening_element jsx_children? jsx_closing_element
+jsx_fragment: JSX_FRAG_OPEN jsx_children? JSX_FRAG_CLOSE
+
+jsx_opening_element: JSX_OPEN_START jsx_element_name jsx_attributes? JSX_TAG_END
+jsx_closing_element: JSX_CLOSE_START jsx_element_name JSX_TAG_END
+
+jsx_element_name: JSX_NAME (DOT JSX_NAME)*
+
+jsx_attributes: jsx_attribute+
+jsx_attribute: jsx_spread_attribute | jsx_normal_attribute
+
+jsx_spread_attribute: LBRACE ELLIPSIS expression RBRACE
+jsx_normal_attribute: JSX_NAME (EQ jsx_attr_value)?
+
+jsx_attr_value: STRING
+              | LBRACE expression RBRACE
+
+jsx_children: jsx_child+
+jsx_child: jsx_element
+         | jsx_expression
+         | jsx_text
+
+jsx_expression: LBRACE expression RBRACE
+jsx_text: JSX_TEXT
+
 // [Heading]: Builtin types.
 builtin_type: TYP_TYPE
             | TYP_ANY
@@ -551,6 +583,7 @@ KW_STATIC: "static"
 KW_OVERRIDE: "override"
 KW_MATCH: "match"
 KW_CASE: "case"
+KW_CLIENT: "cl"
 
 KW_INIT: "init"
 KW_POST_INIT: "postinit"
@@ -689,6 +722,34 @@ PIPE_BKWD: "<|"
 DOT_FWD: ".>"
 DOT_BKWD: "<."
 
+// JSX Contextual Tokens --------------------------------------------------- //
+
+// JSX opening tag start: < followed by identifier or uppercase
+// Using lower priority so it doesn't interfere with LT operator
+JSX_OPEN_START.2: /<(?=[A-Z_a-z])/
+
+// JSX self-closing end: />
+JSX_SELF_CLOSE: /\/>/
+
+// JSX tag end: > (used for both opening and closing)
+JSX_TAG_END: />/
+
+// JSX closing tag start: </
+JSX_CLOSE_START: /<\//
+
+// JSX fragment open: <>
+JSX_FRAG_OPEN: /<>/
+
+// JSX fragment close: </>
+JSX_FRAG_CLOSE: /<\/>/
+
+// JSX identifier (NAME in JSX context) - allows hyphens for attributes like data-age, aria-label
+JSX_NAME: /[A-Z_a-z][A-Z_a-z0-9\-]*/
+
+// JSX text content (anything except < > { } and must not start/end with whitespace-only)
+// Using negative priority so it's only matched as last resort within JSX
+JSX_TEXT.-1: /[^<>{}\n]+/
+
 
 // ************************************************************************* //
 // Comments and Whitespace                                                   //
diff --git a/jac/jaclang/compiler/larkparse/jac_parser.py b/jac/jaclang/compiler/larkparse/jac_parser.py
index f17c041c9b..9fa79e546f 100644
--- a/jac/jaclang/compiler/larkparse/jac_parser.py
+++ b/jac/jaclang/compiler/larkparse/jac_parser.py
@@ -3431,11 +3431,11 @@ class PythonIndenter(Indenter):
 
 import pickle, zlib, base64
 DATA = (
-b'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'
+b'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'
 )
 DATA = pickle.loads(zlib.decompress(base64.b64decode(DATA)))
 MEMO = (
-b'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'
+b'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'
 )
 MEMO = pickle.loads(zlib.decompress(base64.b64decode(MEMO)))
 Shift = 0
diff --git a/jac/jaclang/compiler/parser.py b/jac/jaclang/compiler/parser.py
index 82fc14160e..e00e84ba69 100644
--- a/jac/jaclang/compiler/parser.py
+++ b/jac/jaclang/compiler/parser.py
@@ -414,15 +414,22 @@ def tl_stmt_with_doc(self, _: None) -> uni.ElementStmt:
         def toplevel_stmt(self, _: None) -> uni.ElementStmt:
             """Grammar rule.
 
-            toplevel_stmt: import_stmt
-                | archetype
-                | ability
-                | global_var
-                | free_code
+            toplevel_stmt: KW_CLIENT? import_stmt
+                | KW_CLIENT? archetype
+                | impl_def
+                | sem_def
+                | KW_CLIENT? ability
+                | KW_CLIENT? global_var
+                | KW_CLIENT? free_code
                 | py_code_block
-                | test
+                | KW_CLIENT? test
             """
-            return self.consume(uni.ElementStmt)
+            client_tok = self.match_token(Tok.KW_CLIENT)
+            element = self.consume(uni.ElementStmt)
+            if client_tok and isinstance(element, uni.ClientFacingNode):
+                element.is_client_decl = True
+                element.add_kids_left([client_tok])
+            return element
 
         def global_var(self, _: None) -> uni.GlobalVars:
             """Grammar rule.
@@ -2159,6 +2166,7 @@ def atom(self, _: None) -> uni.Expr:
                  | atom_collection
                  | atom_literal
                  | type_ref
+                 | jsx_element
             """
             if self.match_token(Tok.LPAREN):
                 value = self.match(uni.Expr) or self.consume(uni.YieldExpr)
@@ -2631,6 +2639,270 @@ def type_ref(self, kid: list[uni.UniNode]) -> uni.TypeRef:
                 kid=self.cur_nodes,
             )
 
+        def jsx_element(self, _: None) -> uni.JsxElement:
+            """Grammar rule.
+
+            jsx_element: jsx_self_closing
+                       | jsx_fragment
+                       | jsx_opening_closing
+            """
+            return self.consume(uni.JsxElement)
+
+        def jsx_self_closing(self, _: None) -> uni.JsxElement:
+            """Grammar rule.
+
+            jsx_self_closing: JSX_OPEN_START jsx_element_name jsx_attributes? JSX_SELF_CLOSE
+            """
+            open_tok = self.consume_token(Tok.JSX_OPEN_START)
+            name = self.consume(uni.JsxElementName)
+            # jsx_attributes is optional and returns a list when present
+            attrs_list = self.match(
+                list
+            )  # Will match jsx_attributes which returns a list
+            attrs = attrs_list if attrs_list else []
+            close_tok = self.consume_token(Tok.JSX_SELF_CLOSE)
+
+            # Build kid list manually with proper flattening
+            kid = [open_tok, name]
+            if attrs:
+                kid.extend(attrs)  # Flatten the attributes list
+            kid.append(close_tok)
+
+            return uni.JsxElement(
+                name=name,
+                attributes=attrs,
+                children=None,
+                is_self_closing=True,
+                is_fragment=False,
+                kid=kid,
+            )
+
+        def jsx_opening_closing(self, _: None) -> uni.JsxElement:
+            """Grammar rule.
+
+            jsx_opening_closing: jsx_opening_element jsx_children? jsx_closing_element
+            """
+            opening = self.consume(uni.JsxElement)  # From jsx_opening_element
+            # jsx_children is optional and returns a list when present
+            children_list = self.match(
+                list
+            )  # Will match jsx_children which returns a list
+            children = children_list if children_list else []
+            closing = self.consume(
+                uni.JsxElement
+            )  # From jsx_closing_element (closing tag)
+
+            # Build kid list with proper flattening
+            kid = list(opening.kid)  # Start with opening tag's kids
+            if children:
+                kid.extend(children)  # Add children
+            kid.extend(closing.kid)  # Add closing tag's kids
+
+            # Merge opening and closing into single element
+            return uni.JsxElement(
+                name=opening.name,
+                attributes=opening.attributes,
+                children=children if children else None,
+                is_self_closing=False,
+                is_fragment=False,
+                kid=kid,
+            )
+
+        def jsx_fragment(self, _: None) -> uni.JsxElement:
+            """Grammar rule.
+
+            jsx_fragment: JSX_FRAG_OPEN jsx_children? JSX_FRAG_CLOSE
+            """
+            open_tok = self.consume_token(Tok.JSX_FRAG_OPEN)
+            # jsx_children is optional and returns a list when present
+            children_list = self.match(
+                list
+            )  # Will match jsx_children which returns a list
+            children = children_list if children_list else []
+            close_tok = self.consume_token(Tok.JSX_FRAG_CLOSE)
+
+            # Build kid list with proper flattening
+            kid = [open_tok]
+            if children:
+                kid.extend(children)  # Flatten children
+            kid.append(close_tok)
+
+            return uni.JsxElement(
+                name=None,
+                attributes=None,
+                children=children if children else None,
+                is_self_closing=False,
+                is_fragment=True,
+                kid=kid,
+            )
+
+        def jsx_opening_element(self, _: None) -> uni.JsxElement:
+            """Grammar rule.
+
+            jsx_opening_element: JSX_OPEN_START jsx_element_name jsx_attributes? JSX_TAG_END
+            """
+            open_tok = self.consume_token(Tok.JSX_OPEN_START)
+            name = self.consume(uni.JsxElementName)
+            # jsx_attributes is optional and returns a list when present
+            attrs_list = self.match(
+                list
+            )  # Will match jsx_attributes which returns a list
+            attrs = attrs_list if attrs_list else []
+            end_tok = self.consume_token(Tok.JSX_TAG_END)
+
+            # Build kid list manually with proper flattening
+            kid = [open_tok, name]
+            if attrs:
+                kid.extend(attrs)  # Flatten the attributes list
+            kid.append(end_tok)
+
+            # Return partial element (will be completed in jsx_opening_closing)
+            return uni.JsxElement(
+                name=name,
+                attributes=attrs,
+                children=None,
+                is_self_closing=False,
+                is_fragment=False,
+                kid=kid,
+            )
+
+        def jsx_closing_element(self, _: None) -> uni.JsxElement:
+            """Grammar rule.
+
+            jsx_closing_element: JSX_CLOSE_START jsx_element_name JSX_TAG_END
+            """
+            self.consume_token(Tok.JSX_CLOSE_START)
+            name = self.consume(uni.JsxElementName)
+            self.consume_token(Tok.JSX_TAG_END)
+            # Return stub element with just closing info
+            return uni.JsxElement(
+                name=name,
+                attributes=None,
+                children=None,
+                is_self_closing=False,
+                is_fragment=False,
+                kid=self.cur_nodes,
+            )
+
+        def jsx_element_name(self, _: None) -> uni.JsxElementName:
+            """Grammar rule.
+
+            jsx_element_name: JSX_NAME (DOT JSX_NAME)*
+            """
+            parts = [self.consume_token(Tok.JSX_NAME)]
+            while self.match_token(Tok.DOT):
+                parts.append(self.consume_token(Tok.JSX_NAME))
+            return uni.JsxElementName(
+                parts=parts,
+                kid=self.cur_nodes,
+            )
+
+        def jsx_attributes(self, _: None) -> list[uni.JsxAttribute]:
+            """Grammar rule.
+
+            jsx_attributes: jsx_attribute+
+            """
+            return self.consume_many(uni.JsxAttribute)
+
+        def jsx_attribute(self, _: None) -> uni.JsxAttribute:
+            """Grammar rule.
+
+            jsx_attribute: jsx_spread_attribute | jsx_normal_attribute
+            """
+            return self.consume(uni.JsxAttribute)
+
+        def jsx_spread_attribute(self, _: None) -> uni.JsxSpreadAttribute:
+            """Grammar rule.
+
+            jsx_spread_attribute: LBRACE ELLIPSIS expression RBRACE
+            """
+            self.consume_token(Tok.LBRACE)
+            self.consume_token(Tok.ELLIPSIS)
+            expr = self.consume(uni.Expr)
+            self.consume_token(Tok.RBRACE)
+            return uni.JsxSpreadAttribute(
+                expr=expr,
+                kid=self.cur_nodes,
+            )
+
+        def jsx_normal_attribute(self, _: None) -> uni.JsxNormalAttribute:
+            """Grammar rule.
+
+            jsx_normal_attribute: JSX_NAME (EQ jsx_attr_value)?
+            """
+            name = self.consume_token(Tok.JSX_NAME)
+            value = None
+            if self.match_token(Tok.EQ):
+                value = self.consume(uni.Expr)
+            return uni.JsxNormalAttribute(
+                name=name,
+                value=value,
+                kid=self.cur_nodes,
+            )
+
+        def jsx_attr_value(self, _: None) -> uni.String | uni.Expr:
+            """Grammar rule.
+
+            jsx_attr_value: STRING | LBRACE expression RBRACE
+            """
+            if string := self.match(uni.String):
+                return string
+            self.consume_token(Tok.LBRACE)
+            expr = self.consume(uni.Expr)
+            self.consume_token(Tok.RBRACE)
+            return expr
+
+        def jsx_children(self, _: None) -> list[uni.JsxChild]:
+            """Grammar rule.
+
+            jsx_children: jsx_child+
+            """
+            # The grammar already produces a list of children
+            # Just collect all JsxChild nodes from cur_nodes
+            children = []
+            while self.node_idx < len(self.cur_nodes):
+                if isinstance(
+                    self.cur_nodes[self.node_idx], (uni.JsxChild, uni.JsxElement)
+                ):
+                    children.append(self.cur_nodes[self.node_idx])  # type: ignore[arg-type]
+                    self.node_idx += 1
+                else:
+                    break
+            return children
+
+        def jsx_child(self, _: None) -> uni.JsxChild:
+            """Grammar rule.
+
+            jsx_child: jsx_element | jsx_expression
+            """
+            if jsx_elem := self.match(uni.JsxElement):
+                return jsx_elem  # type: ignore[return-value]
+            return self.consume(uni.JsxChild)
+
+        def jsx_expression(self, _: None) -> uni.JsxExpression:
+            """Grammar rule.
+
+            jsx_expression: LBRACE expression RBRACE
+            """
+            self.consume_token(Tok.LBRACE)
+            expr = self.consume(uni.Expr)
+            self.consume_token(Tok.RBRACE)
+            return uni.JsxExpression(
+                expr=expr,
+                kid=self.cur_nodes,
+            )
+
+        def jsx_text(self, _: None) -> uni.JsxText:
+            """Grammar rule.
+
+            jsx_text: JSX_TEXT
+            """
+            text = self.consume_token(Tok.JSX_TEXT)
+            return uni.JsxText(
+                value=text,
+                kid=self.cur_nodes,
+            )
+
         def edge_ref_chain(self, _: None) -> uni.EdgeRefTrailer:
             """Grammar rule.
 
diff --git a/jac/jaclang/compiler/passes/ecmascript/__init__.py b/jac/jaclang/compiler/passes/ecmascript/__init__.py
new file mode 100644
index 0000000000..98a31ebee7
--- /dev/null
+++ b/jac/jaclang/compiler/passes/ecmascript/__init__.py
@@ -0,0 +1,25 @@
+"""ECMAScript/JavaScript AST generation for Jac.
+
+This package provides ECMAScript AST generation capabilities following the ESTree
+specification, allowing Jac code to be transpiled to JavaScript/ECMAScript.
+"""
+
+from jaclang.compiler.passes.ecmascript.esast_gen_pass import EsastGenPass
+from jaclang.compiler.passes.ecmascript.estree import (
+    Declaration,
+    Expression,
+    Pattern,
+    Program,
+    Statement,
+    es_node_to_dict,
+)
+
+__all__ = [
+    "EsastGenPass",
+    "Expression",
+    "Declaration",
+    "Pattern",
+    "Program",
+    "Statement",
+    "es_node_to_dict",
+]
diff --git a/jac/jaclang/compiler/passes/ecmascript/es_unparse.py b/jac/jaclang/compiler/passes/ecmascript/es_unparse.py
new file mode 100644
index 0000000000..31849ec49a
--- /dev/null
+++ b/jac/jaclang/compiler/passes/ecmascript/es_unparse.py
@@ -0,0 +1,576 @@
+"""ECMAScript/JavaScript code generation from ESTree AST.
+
+This module provides functionality to convert ESTree AST nodes back to
+JavaScript source code (unparsing).
+"""
+
+from __future__ import annotations
+
+from jaclang.compiler.passes.ecmascript import estree as es
+from jaclang.utils.helpers import pascal_to_snake
+
+
+class JSCodeGenerator:
+    """Generate JavaScript code from ESTree AST."""
+
+    def __init__(self, indent: str = "  ") -> None:
+        """Initialize the code generator."""
+        self.indent_str = indent
+        self.indent_level = 0
+
+    def indent(self) -> str:
+        """Get current indentation."""
+        return self.indent_str * self.indent_level
+
+    def generate(self, node: es.Node) -> str:
+        """Generate JavaScript code for a node."""
+        method_name = f"gen_{pascal_to_snake(node.type)}"
+        method = getattr(self, method_name, None)
+        if method:
+            return method(node)
+        else:
+            return f"/* Unsupported node type: {node.type} */"
+
+    # Program and Statements
+    # ======================
+
+    def gen_program(self, node: es.Program) -> str:
+        """Generate program."""
+        return "\n".join(self.generate(stmt) for stmt in node.body)
+
+    def gen_expression_statement(self, node: es.ExpressionStatement) -> str:
+        """Generate expression statement."""
+        return f"{self.indent()}{self.generate(node.expression)};"
+
+    def gen_block_statement(self, node: es.BlockStatement) -> str:
+        """Generate block statement."""
+        if not node.body:
+            return "{}"
+        self.indent_level += 1
+        body = "\n".join(self.generate(stmt) for stmt in node.body)
+        self.indent_level -= 1
+        return f"{{\n{body}\n{self.indent()}}}"
+
+    def gen_empty_statement(self, node: es.EmptyStatement) -> str:
+        """Generate empty statement."""
+        return f"{self.indent()};"
+
+    def gen_return_statement(self, node: es.ReturnStatement) -> str:
+        """Generate return statement."""
+        if node.argument:
+            return f"{self.indent()}return {self.generate(node.argument)};"
+        return f"{self.indent()}return;"
+
+    def gen_if_statement(self, node: es.IfStatement) -> str:
+        """Generate if statement."""
+        test = self.generate(node.test)
+        consequent = self.generate(node.consequent)
+        result = f"{self.indent()}if ({test}) {consequent}"
+        if node.alternate:
+            if isinstance(node.alternate, es.IfStatement):
+                # else if
+                result += f" else {self.generate(node.alternate).lstrip()}"
+            else:
+                result += f" else {self.generate(node.alternate)}"
+        return result
+
+    def gen_while_statement(self, node: es.WhileStatement) -> str:
+        """Generate while statement."""
+        test = self.generate(node.test)
+        body = self.generate(node.body)
+        return f"{self.indent()}while ({test}) {body}"
+
+    def gen_do_while_statement(self, node: es.DoWhileStatement) -> str:
+        """Generate do-while statement."""
+        body = self.generate(node.body)
+        test = self.generate(node.test)
+        return f"{self.indent()}do {body} while ({test});"
+
+    def gen_for_statement(self, node: es.ForStatement) -> str:
+        """Generate for statement."""
+        init = self.generate(node.init) if node.init else ""
+        test = self.generate(node.test) if node.test else ""
+        update = self.generate(node.update) if node.update else ""
+        body = self.generate(node.body)
+        return f"{self.indent()}for ({init}; {test}; {update}) {body}"
+
+    def gen_for_in_statement(self, node: es.ForInStatement) -> str:
+        """Generate for-in statement."""
+        left = self.generate(node.left)
+        right = self.generate(node.right)
+        body = self.generate(node.body)
+        return f"{self.indent()}for ({left} in {right}) {body}"
+
+    def gen_for_of_statement(self, node: es.ForOfStatement) -> str:
+        """Generate for-of statement."""
+        await_str = "await " if node.await_ else ""
+        if isinstance(node.left, es.VariableDeclaration):
+            declarators = ", ".join(
+                self.generate(decl) for decl in node.left.declarations
+            )
+            left = f"{node.left.kind} {declarators}"
+        else:
+            left = self.generate(node.left)
+        right = self.generate(node.right)
+        body = self.generate(node.body)
+        return f"{self.indent()}for {await_str}({left} of {right}) {body}"
+
+    def gen_break_statement(self, node: es.BreakStatement) -> str:
+        """Generate break statement."""
+        if node.label:
+            return f"{self.indent()}break {self.generate(node.label)};"
+        return f"{self.indent()}break;"
+
+    def gen_continue_statement(self, node: es.ContinueStatement) -> str:
+        """Generate continue statement."""
+        if node.label:
+            return f"{self.indent()}continue {self.generate(node.label)};"
+        return f"{self.indent()}continue;"
+
+    def gen_throw_statement(self, node: es.ThrowStatement) -> str:
+        """Generate throw statement."""
+        return f"{self.indent()}throw {self.generate(node.argument)};"
+
+    def gen_try_statement(self, node: es.TryStatement) -> str:
+        """Generate try statement."""
+        result = f"{self.indent()}try {self.generate(node.block)}"
+        if node.handler:
+            result += f" {self.generate(node.handler)}"
+        if node.finalizer:
+            result += f" finally {self.generate(node.finalizer)}"
+        return result
+
+    def gen_catch_clause(self, node: es.CatchClause) -> str:
+        """Generate catch clause."""
+        if node.param:
+            return f"catch ({self.generate(node.param)}) {self.generate(node.body)}"
+        return f"catch {self.generate(node.body)}"
+
+    def gen_switch_statement(self, node: es.SwitchStatement) -> str:
+        """Generate switch statement."""
+        discriminant = self.generate(node.discriminant)
+        self.indent_level += 1
+        cases = "\n".join(self.generate(case) for case in node.cases)
+        self.indent_level -= 1
+        return f"{self.indent()}switch ({discriminant}) {{\n{cases}\n{self.indent()}}}"
+
+    def gen_switch_case(self, node: es.SwitchCase) -> str:
+        """Generate switch case."""
+        if node.test:
+            result = f"{self.indent()}case {self.generate(node.test)}:\n"
+        else:
+            result = f"{self.indent()}default:\n"
+        self.indent_level += 1
+        for stmt in node.consequent:
+            result += f"{self.generate(stmt)}\n"
+        self.indent_level -= 1
+        return result.rstrip()
+
+    # Declarations
+    # ============
+
+    def gen_function_declaration(self, node: es.FunctionDeclaration) -> str:
+        """Generate function declaration."""
+        async_str = "async " if node.async_ else ""
+        generator_str = "*" if node.generator else ""
+        name = self.generate(node.id) if node.id else ""
+        params = ", ".join(self.generate(p) for p in node.params)
+        body = self.generate(node.body)
+        return (
+            f"{self.indent()}{async_str}function{generator_str} {name}({params}) {body}"
+        )
+
+    def gen_variable_declaration(self, node: es.VariableDeclaration) -> str:
+        """Generate variable declaration."""
+        declarators = ", ".join(self.generate(d) for d in node.declarations)
+        return f"{self.indent()}{node.kind} {declarators};"
+
+    def gen_variable_declarator(self, node: es.VariableDeclarator) -> str:
+        """Generate variable declarator."""
+        id_str = self.generate(node.id)
+        if node.init:
+            return f"{id_str} = {self.generate(node.init)}"
+        return id_str
+
+    def gen_class_declaration(self, node: es.ClassDeclaration) -> str:
+        """Generate class declaration."""
+        name = self.generate(node.id) if node.id else ""
+        extends = (
+            f" extends {self.generate(node.superClass)}" if node.superClass else ""
+        )
+        body = self.generate(node.body)
+        return f"{self.indent()}class {name}{extends} {body}"
+
+    def gen_class_expression(self, node: es.ClassExpression) -> str:
+        """Generate class expression."""
+        name = self.generate(node.id) if node.id else ""
+        extends = (
+            f" extends {self.generate(node.superClass)}" if node.superClass else ""
+        )
+        body = self.generate(node.body)
+        return f"class {name}{extends} {body}"
+
+    def gen_class_body(self, node: es.ClassBody) -> str:
+        """Generate class body."""
+        if not node.body:
+            return "{}"
+        self.indent_level += 1
+        methods = "\n".join(self.generate(m) for m in node.body)
+        self.indent_level -= 1
+        return f"{{\n{methods}\n{self.indent()}}}"
+
+    def gen_method_definition(self, node: es.MethodDefinition) -> str:
+        """Generate method definition."""
+        static_str = "static " if node.static else ""
+        key = self.generate(node.key)
+        value = self.generate(node.value)
+
+        # Extract function parts
+        if isinstance(node.value, es.FunctionExpression):
+            async_str = "async " if node.value.async_ else ""
+            params = ", ".join(self.generate(p) for p in node.value.params)
+            body = self.generate(node.value.body)
+
+            if node.kind == "constructor":
+                return f"{self.indent()}constructor({params}) {body}"
+            elif node.kind == "get":
+                return f"{self.indent()}{static_str}get {key}() {body}"
+            elif node.kind == "set":
+                return f"{self.indent()}{static_str}set {key}({params}) {body}"
+            else:
+                return f"{self.indent()}{static_str}{async_str}{key}({params}) {body}"
+
+        return f"{self.indent()}{static_str}{key}{value}"
+
+    def gen_property_definition(self, node: es.PropertyDefinition) -> str:
+        """Generate class field definition."""
+        static_str = "static " if node.static else ""
+        key = self.generate(node.key) if node.key else ""
+        if node.computed:
+            key = f"[{key}]"
+        value = f" = {self.generate(node.value)}" if node.value else ""
+        return f"{self.indent()}{static_str}{key}{value};"
+
+    def gen_static_block(self, node: es.StaticBlock) -> str:
+        """Generate static initialization block."""
+        block = self.generate(es.BlockStatement(body=node.body))
+        return f"{self.indent()}static {block}"
+
+    # Expressions
+    # ===========
+
+    def gen_identifier(self, node: es.Identifier) -> str:
+        """Generate identifier."""
+        return node.name
+
+    def gen_private_identifier(self, node: es.PrivateIdentifier) -> str:
+        """Generate private identifier."""
+        return f"#{node.name}"
+
+    def gen_literal(self, node: es.Literal) -> str:
+        """Generate literal."""
+        if node.raw:
+            return node.raw
+        if isinstance(node.value, str):
+            return f'"{node.value}"'
+        elif node.value is None:
+            return "null"
+        elif isinstance(node.value, bool):
+            return "true" if node.value else "false"
+        else:
+            return str(node.value)
+
+    def gen_this_expression(self, node: es.ThisExpression) -> str:
+        """Generate this expression."""
+        return "this"
+
+    def gen_array_expression(self, node: es.ArrayExpression) -> str:
+        """Generate array expression."""
+        elements = ", ".join(self.generate(e) if e else "" for e in node.elements)
+        return f"[{elements}]"
+
+    def gen_object_expression(self, node: es.ObjectExpression) -> str:
+        """Generate object expression."""
+        if not node.properties:
+            return "{}"
+        props = ", ".join(self.generate(p) for p in node.properties)
+        return f"{{{props}}}"
+
+    def gen_property(self, node: es.Property) -> str:
+        """Generate property."""
+        key = self.generate(node.key)
+        value = self.generate(node.value)
+
+        if node.shorthand:
+            return key
+        elif node.computed:
+            return f"[{key}]: {value}"
+        elif node.kind == "get":
+            return f"get {key}() {value}"
+        elif node.kind == "set":
+            return f"set {key}({value})"
+        else:
+            return f"{key}: {value}"
+
+    def gen_function_expression(self, node: es.FunctionExpression) -> str:
+        """Generate function expression."""
+        async_str = "async " if node.async_ else ""
+        generator_str = "*" if node.generator else ""
+        name = self.generate(node.id) if node.id else ""
+        params = ", ".join(self.generate(p) for p in node.params)
+        body = self.generate(node.body)
+        return f"{async_str}function{generator_str} {name}({params}) {body}".strip()
+
+    def gen_arrow_function_expression(self, node: es.ArrowFunctionExpression) -> str:
+        """Generate arrow function expression."""
+        async_str = "async " if node.async_ else ""
+        params = ", ".join(self.generate(p) for p in node.params)
+        if len(node.params) == 1:
+            params = self.generate(node.params[0])
+        else:
+            params = f"({params})"
+
+        if node.expression:
+            body = self.generate(node.body)
+            return f"{async_str}{params} => {body}"
+        else:
+            body = self.generate(node.body)
+            return f"{async_str}{params} => {body}"
+
+    def gen_unary_expression(self, node: es.UnaryExpression) -> str:
+        """Generate unary expression."""
+        arg = self.generate(node.argument)
+        if node.prefix:
+            if node.operator in ("typeof", "void", "delete"):
+                return f"{node.operator} {arg}"
+            return f"{node.operator}{arg}"
+        else:
+            return f"{arg}{node.operator}"
+
+    def gen_update_expression(self, node: es.UpdateExpression) -> str:
+        """Generate update expression."""
+        arg = self.generate(node.argument)
+        if node.prefix:
+            return f"{node.operator}{arg}"
+        else:
+            return f"{arg}{node.operator}"
+
+    def gen_binary_expression(self, node: es.BinaryExpression) -> str:
+        """Generate binary expression."""
+        left = self.generate(node.left)
+        right = self.generate(node.right)
+        if isinstance(node.left, es.AssignmentExpression):
+            left = f"({left})"
+        if isinstance(node.right, es.AssignmentExpression):
+            right = f"({right})"
+        return f"{left} {node.operator} {right}"
+
+    def gen_logical_expression(self, node: es.LogicalExpression) -> str:
+        """Generate logical expression."""
+        left = self.generate(node.left)
+        right = self.generate(node.right)
+        return f"{left} {node.operator} {right}"
+
+    def gen_assignment_expression(self, node: es.AssignmentExpression) -> str:
+        """Generate assignment expression."""
+        left = self.generate(node.left)
+        right = self.generate(node.right)
+        return f"{left} {node.operator} {right}"
+
+    def gen_member_expression(self, node: es.MemberExpression) -> str:
+        """Generate member expression."""
+        obj = self.generate(node.object)
+        optional = "?." if node.optional else ""
+        if node.computed:
+            prop = self.generate(node.property)
+            return f"{obj}{optional}[{prop}]"
+        else:
+            prop = self.generate(node.property)
+            if optional:
+                return f"{obj}{optional}{prop}"
+            return f"{obj}.{prop}"
+
+    def gen_conditional_expression(self, node: es.ConditionalExpression) -> str:
+        """Generate conditional expression."""
+        test = self.generate(node.test)
+        consequent = self.generate(node.consequent)
+        alternate = self.generate(node.alternate)
+        return f"{test} ? {consequent} : {alternate}"
+
+    def gen_call_expression(self, node: es.CallExpression) -> str:
+        """Generate call expression."""
+        callee = self.generate(node.callee)
+        optional = "?." if node.optional else ""
+        args = ", ".join(self.generate(arg) for arg in node.arguments)
+        return f"{callee}{optional}({args})"
+
+    def gen_chain_expression(self, node: es.ChainExpression) -> str:
+        """Generate optional chaining expression."""
+        return self.generate(node.expression)
+
+    def gen_new_expression(self, node: es.NewExpression) -> str:
+        """Generate new expression."""
+        callee = self.generate(node.callee)
+        args = ", ".join(self.generate(arg) for arg in node.arguments)
+        return f"new {callee}({args})"
+
+    def gen_import_expression(self, node: es.ImportExpression) -> str:
+        """Generate dynamic import expression."""
+        source = self.generate(node.source) if node.source else ""
+        return f"import({source})"
+
+    def gen_sequence_expression(self, node: es.SequenceExpression) -> str:
+        """Generate sequence expression."""
+        exprs = ", ".join(self.generate(e) for e in node.expressions)
+        return f"({exprs})"
+
+    def gen_yield_expression(self, node: es.YieldExpression) -> str:
+        """Generate yield expression."""
+        delegate = "*" if node.delegate else ""
+        if node.argument:
+            return f"yield{delegate} {self.generate(node.argument)}"
+        return f"yield{delegate}"
+
+    def gen_await_expression(self, node: es.AwaitExpression) -> str:
+        """Generate await expression."""
+        return f"await {self.generate(node.argument)}"
+
+    def gen_template_literal(self, node: es.TemplateLiteral) -> str:
+        """Generate template literal."""
+        parts: list[str] = []
+        for idx, quasi in enumerate(node.quasis):
+            parts.append(self.generate(quasi))
+            if idx < len(node.expressions):
+                parts.append(f"${{{self.generate(node.expressions[idx])}}}")
+        return f"`{''.join(parts)}`"
+
+    def gen_template_element(self, node: es.TemplateElement) -> str:
+        """Generate template element."""
+        value = node.value.get("raw") if node.value else ""
+        return value or ""
+
+    def gen_tagged_template_expression(self, node: es.TaggedTemplateExpression) -> str:
+        """Generate tagged template expression."""
+        tag = self.generate(node.tag)
+        quasi = self.generate(node.quasi)
+        return f"{tag}{quasi}"
+
+    def gen_spread_element(self, node: es.SpreadElement) -> str:
+        """Generate spread element."""
+        return f"...{self.generate(node.argument)}"
+
+    def gen_super(self, node: es.Super) -> str:
+        """Generate super."""
+        return "super"
+
+    def gen_meta_property(self, node: es.MetaProperty) -> str:
+        """Generate meta property (e.g., new.target)."""
+        meta = self.generate(node.meta) if node.meta else ""
+        prop = self.generate(node.property) if node.property else ""
+        return f"{meta}.{prop}"
+
+    # Patterns
+    # ========
+
+    def gen_array_pattern(self, node: es.ArrayPattern) -> str:
+        """Generate array pattern."""
+        elements = ", ".join(self.generate(e) if e else "" for e in node.elements)
+        return f"[{elements}]"
+
+    def gen_object_pattern(self, node: es.ObjectPattern) -> str:
+        """Generate object pattern."""
+        props = ", ".join(self.generate(p) for p in node.properties)
+        return f"{{{props}}}"
+
+    def gen_assignment_pattern(self, node: es.AssignmentPattern) -> str:
+        """Generate assignment pattern."""
+        left = self.generate(node.left)
+        right = self.generate(node.right)
+        return f"{left} = {right}"
+
+    def gen_rest_element(self, node: es.RestElement) -> str:
+        """Generate rest element."""
+        return f"...{self.generate(node.argument)}"
+
+    # Modules
+    # =======
+
+    def gen_import_declaration(self, node: es.ImportDeclaration) -> str:
+        """Generate import declaration."""
+        default_spec: str | None = None
+        namespace_spec: str | None = None
+        named_specs: list[str] = []
+
+        for spec in node.specifiers:
+            if isinstance(spec, es.ImportDefaultSpecifier):
+                default_spec = self.generate(spec)
+            elif isinstance(spec, es.ImportNamespaceSpecifier):
+                namespace_spec = self.generate(spec)
+            elif isinstance(spec, es.ImportSpecifier):
+                named_specs.append(self.generate(spec))
+
+        clause_parts: list[str] = []
+        if default_spec:
+            clause_parts.append(default_spec)
+        if namespace_spec:
+            clause_parts.append(namespace_spec)
+        if named_specs:
+            clause_parts.append("{ " + ", ".join(named_specs) + " }")
+
+        source = self.generate(node.source)
+        if clause_parts:
+            clause = ", ".join(clause_parts)
+            return f"{self.indent()}import {clause} from {source};"
+        return f"{self.indent()}import {source};"
+
+    def gen_import_specifier(self, node: es.ImportSpecifier) -> str:
+        """Generate import specifier."""
+        imported = self.generate(node.imported)
+        local = self.generate(node.local)
+        if imported != local:
+            return f"{imported} as {local}"
+        return imported
+
+    def gen_import_default_specifier(self, node: es.ImportDefaultSpecifier) -> str:
+        """Generate import default specifier."""
+        return self.generate(node.local)
+
+    def gen_import_namespace_specifier(self, node: es.ImportNamespaceSpecifier) -> str:
+        """Generate import namespace specifier."""
+        return f"* as {self.generate(node.local)}"
+
+    def gen_export_named_declaration(self, node: es.ExportNamedDeclaration) -> str:
+        """Generate export named declaration."""
+        if node.declaration:
+            return f"{self.indent()}export {self.generate(node.declaration).lstrip()}"
+        specs = ", ".join(self.generate(s) for s in node.specifiers)
+        if node.source:
+            source = self.generate(node.source)
+            return f"{self.indent()}export {{{specs}}} from {source};"
+        return f"{self.indent()}export {{{specs}}};"
+
+    def gen_export_specifier(self, node: es.ExportSpecifier) -> str:
+        """Generate export specifier."""
+        local = self.generate(node.local)
+        exported = self.generate(node.exported)
+        if local != exported:
+            return f"{local} as {exported}"
+        return local
+
+    def gen_export_default_declaration(self, node: es.ExportDefaultDeclaration) -> str:
+        """Generate export default declaration."""
+        return f"{self.indent()}export default {self.generate(node.declaration)};"
+
+    def gen_export_all_declaration(self, node: es.ExportAllDeclaration) -> str:
+        """Generate export all declaration."""
+        source = self.generate(node.source)
+        if node.exported:
+            exported = self.generate(node.exported)
+            return f"{self.indent()}export * as {exported} from {source};"
+        return f"{self.indent()}export * from {source};"
+
+
+def es_to_js(node: es.Node, indent: str = "  ") -> str:
+    """Convert an ESTree node to JavaScript code."""
+    generator = JSCodeGenerator(indent=indent)
+    return generator.generate(node)
diff --git a/jac/jaclang/compiler/passes/ecmascript/esast_gen_pass.py b/jac/jaclang/compiler/passes/ecmascript/esast_gen_pass.py
new file mode 100644
index 0000000000..fd072cb295
--- /dev/null
+++ b/jac/jaclang/compiler/passes/ecmascript/esast_gen_pass.py
@@ -0,0 +1,2227 @@
+"""ECMAScript AST Generation Pass for the Jac compiler.
+
+This pass transforms the Jac AST into equivalent ECMAScript AST following
+the ESTree specification by:
+
+1. Traversing the Jac AST and generating corresponding ESTree nodes
+2. Handling all Jac language constructs and translating them to JavaScript/ECMAScript equivalents:
+   - Classes, functions, and methods
+   - Control flow statements (if/else, loops, try/catch)
+   - Data structures (arrays, objects)
+   - Special Jac features (walkers, abilities, archetypes) converted to JS classes
+   - Data spatial operations converted to appropriate JS patterns
+
+3. Managing imports and module dependencies
+4. Preserving source location information
+5. Generating valid ECMAScript code that can be executed in JavaScript environments
+
+The output of this pass is a complete ESTree AST representation that can be
+serialized to JavaScript source code or used by JavaScript tooling.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from typing import Any, Iterable, Optional, Sequence, Union
+
+import jaclang.compiler.passes.ecmascript.estree as es
+import jaclang.compiler.unitree as uni
+from jaclang.compiler.constant import Tokens as Tok
+from jaclang.compiler.passes import UniPass
+
+
+@dataclass
+class ScopeInfo:
+    """Track declarations within a lexical scope."""
+
+    node: uni.UniScopeNode
+    declared: set[str] = field(default_factory=set)
+    hoisted: list[es.Statement] = field(default_factory=list)
+
+
+@dataclass
+class AssignmentTargetInfo:
+    """Container for processed assignment targets."""
+
+    node: uni.UniNode
+    left: Union[es.Pattern, es.Expression]
+    reference: Optional[es.Expression]
+    decl_name: Optional[str]
+    pattern_names: list[tuple[str, uni.Name]]
+    is_first: bool
+
+
+class EsastGenPass(UniPass):
+    """Jac to ECMAScript AST transpilation pass."""
+
+    def before_pass(self) -> None:
+        """Initialize the pass."""
+        self.child_passes: list[EsastGenPass] = []
+        for i in self.ir_in.impl_mod + self.ir_in.test_mod:
+            child_pass = EsastGenPass(ir_in=i, prog=self.prog)
+            self.child_passes.append(child_pass)
+        self.imports: list[es.ImportDeclaration] = []
+        self.exports: list[es.ExportNamedDeclaration] = []
+        self.scope_stack: list[ScopeInfo] = []
+        self.scope_map: dict[uni.UniScopeNode, ScopeInfo] = {}
+
+        # Collect client metadata and populate manifest
+        self._prepare_client_artifacts()
+
+    def enter_node(self, node: uni.UniNode) -> None:
+        """Enter node."""
+        if isinstance(node, uni.UniScopeNode):
+            self._push_scope(node)
+        if hasattr(node.gen, "es_ast") and node.gen.es_ast:
+            self.prune()
+            return
+        super().enter_node(node)
+
+    def exit_node(self, node: uni.UniNode) -> None:
+        """Exit node."""
+        super().exit_node(node)
+        if isinstance(node, uni.UniScopeNode):
+            self._pop_scope(node)
+
+    def sync_loc(
+        self, es_node: es.Node, jac_node: Optional[uni.UniNode] = None
+    ) -> es.Node:
+        """Sync source locations from Jac node to ES node."""
+        if not jac_node:
+            jac_node = self.cur_node
+        es_node.loc = es.SourceLocation(
+            start=es.Position(
+                line=jac_node.loc.first_line, column=jac_node.loc.col_start
+            ),
+            end=es.Position(line=jac_node.loc.last_line, column=jac_node.loc.col_end),
+        )
+        return es_node
+
+    def flatten(
+        self, items: list[Union[es.Statement, list[es.Statement], None]]
+    ) -> list[es.Statement]:
+        """Flatten a list of items or lists into a single list."""
+        result: list[es.Statement] = []
+        for item in items:
+            if isinstance(item, list):
+                result.extend(item)
+            elif item is not None:
+                result.append(item)
+        return result
+
+    # Scope helpers
+    # =============
+
+    def _push_scope(self, node: uni.UniScopeNode) -> None:
+        """Enter a new lexical scope."""
+        info = ScopeInfo(node=node)
+        self.scope_stack.append(info)
+        self.scope_map[node] = info
+
+    def _pop_scope(self, node: uni.UniScopeNode) -> None:
+        """Exit a lexical scope."""
+        if self.scope_stack and self.scope_stack[-1].node is node:
+            self.scope_stack.pop()
+        self.scope_map.pop(node, None)
+
+    def _current_scope(self) -> Optional[ScopeInfo]:
+        """Get the scope currently being populated."""
+        return self.scope_stack[-1] if self.scope_stack else None
+
+    def _is_declared_in_current_scope(self, name: str) -> bool:
+        """Check if a name is already declared in the active scope."""
+        scope = self._current_scope()
+        return name in scope.declared if scope else False
+
+    def _register_declaration(self, name: str) -> None:
+        """Mark a name as declared within the current scope."""
+        scope = self._current_scope()
+        if scope:
+            scope.declared.add(name)
+
+    def _ensure_identifier_declared(self, name: str, jac_node: uni.UniNode) -> None:
+        """Hoist a declaration for identifiers introduced mid-expression (e.g., walrus)."""
+        scope = self._current_scope()
+        if not scope or name in scope.declared:
+            return
+        ident = self.sync_loc(es.Identifier(name=name), jac_node=jac_node)
+        declarator = self.sync_loc(
+            es.VariableDeclarator(id=ident, init=None), jac_node=jac_node
+        )
+        decl = self.sync_loc(
+            es.VariableDeclaration(declarations=[declarator], kind="let"),
+            jac_node=jac_node,
+        )
+        scope.hoisted.append(decl)
+        scope.declared.add(name)
+
+    def _prepend_hoisted(
+        self, node: uni.UniScopeNode, statements: list[es.Statement]
+    ) -> list[es.Statement]:
+        """Insert hoisted declarations, if any, ahead of the given statements."""
+        scope = self.scope_map.get(node)
+        if scope and scope.hoisted:
+            hoisted = list(scope.hoisted)
+            scope.hoisted.clear()
+            return hoisted + statements
+        return statements
+
+    # Module and Program
+    # ==================
+
+    def exit_module(self, node: uni.Module) -> None:
+        """Process module node."""
+        body: list[Union[es.Statement, es.ModuleDeclaration]] = []
+
+        # Add imports
+        body.extend(self.imports)
+
+        # Insert hoisted declarations (e.g., walrus-introduced identifiers)
+        scope = self.scope_map.get(node)
+        if scope and scope.hoisted:
+            hoisted = list(scope.hoisted)
+            scope.hoisted.clear()
+            body.extend(hoisted)
+
+        # Process module body
+        clean_body = [i for i in node.body if not isinstance(i, uni.ImplDef)]
+        client_items: list[Union[es.Statement, list[es.Statement]]] = []
+        fallback_items: list[Union[es.Statement, list[es.Statement]]] = []
+        for stmt in clean_body:
+            if hasattr(stmt.gen, "es_ast") and stmt.gen.es_ast:
+                target_list = (
+                    client_items
+                    if getattr(stmt, "is_client_decl", False)
+                    else fallback_items
+                )
+                target_list.append(stmt.gen.es_ast)
+        target_body = client_items if client_items else fallback_items
+        for item in target_body:
+            if isinstance(item, list):
+                body.extend(item)
+            else:
+                body.append(item)
+
+        # Add exports
+        body.extend(self.exports)
+
+        program = self.sync_loc(
+            es.Program(body=body, sourceType="module"), jac_node=node
+        )
+        node.gen.es_ast = program
+
+        # Generate JavaScript code from ES AST
+        node.gen.js = self._generate_module_js(node)
+
+    def exit_sub_tag(self, node: uni.SubTag[uni.T]) -> None:
+        """Process SubTag node."""
+        if hasattr(node.tag.gen, "es_ast"):
+            node.gen.es_ast = node.tag.gen.es_ast
+
+    # Import/Export Statements
+    # ========================
+
+    def exit_import(self, node: uni.Import) -> None:
+        """Process import statement."""
+        if node.from_loc and node.items:
+            source = self.sync_loc(
+                es.Literal(value=node.from_loc.dot_path_str), jac_node=node.from_loc
+            )
+            specifiers: list[
+                Union[
+                    es.ImportSpecifier,
+                    es.ImportDefaultSpecifier,
+                    es.ImportNamespaceSpecifier,
+                ]
+            ] = []
+
+            for item in node.items:
+                if isinstance(item, uni.ModuleItem):
+                    imported = self.sync_loc(
+                        es.Identifier(name=item.name.sym_name), jac_node=item.name
+                    )
+                    local = self.sync_loc(
+                        es.Identifier(
+                            name=(
+                                item.alias.sym_name
+                                if item.alias
+                                else item.name.sym_name
+                            )
+                        ),
+                        jac_node=item.alias if item.alias else item.name,
+                    )
+                    specifiers.append(
+                        self.sync_loc(
+                            es.ImportSpecifier(imported=imported, local=local),
+                            jac_node=item,
+                        )
+                    )
+
+            import_decl = self.sync_loc(
+                es.ImportDeclaration(specifiers=specifiers, source=source),
+                jac_node=node,
+            )
+            self.imports.append(import_decl)
+            node.gen.es_ast = []  # Imports are added to module level
+
+    def exit_module_path(self, node: uni.ModulePath) -> None:
+        """Process module path."""
+        node.gen.es_ast = None
+
+    def exit_module_item(self, node: uni.ModuleItem) -> None:
+        """Process module item."""
+        node.gen.es_ast = None
+
+    # Declarations
+    # ============
+
+    def exit_archetype(self, node: uni.Archetype) -> None:
+        """Process archetype (class) declaration."""
+        body_stmts: list[
+            Union[es.MethodDefinition, es.PropertyDefinition, es.StaticBlock]
+        ] = []
+        has_members: list[uni.ArchHas] = []
+
+        # Process body
+        inner: Sequence[uni.CodeBlockStmt] | None = None
+        if isinstance(node.body, uni.ImplDef) and isinstance(node.body.body, list):
+            inner = node.body.body  # type: ignore
+        elif isinstance(node.body, list):
+            inner = node.body
+
+        if inner:
+            for stmt in inner:
+                if isinstance(stmt, uni.ArchHas):
+                    has_members.append(stmt)
+                    continue
+                if (
+                    hasattr(stmt.gen, "es_ast")
+                    and stmt.gen.es_ast
+                    and isinstance(
+                        stmt.gen.es_ast,
+                        (es.MethodDefinition, es.PropertyDefinition, es.StaticBlock),
+                    )
+                ):
+                    body_stmts.append(stmt.gen.es_ast)
+
+        if node.arch_type.name == Tok.KW_OBJECT and has_members:
+            constructor_stmts: list[es.Statement] = []
+            props_param = self.sync_loc(
+                es.AssignmentPattern(
+                    left=self.sync_loc(es.Identifier(name="props"), jac_node=node),
+                    right=self.sync_loc(
+                        es.ObjectExpression(properties=[]), jac_node=node
+                    ),
+                ),
+                jac_node=node,
+            )
+
+            for arch_has in has_members:
+                if arch_has.is_static:
+                    for var in arch_has.vars:
+                        default_expr = (
+                            var.value.gen.es_ast
+                            if var.value
+                            and hasattr(var.value.gen, "es_ast")
+                            and var.value.gen.es_ast
+                            else self.sync_loc(es.Literal(value=None), jac_node=var)
+                        )
+                        static_prop = self.sync_loc(
+                            es.PropertyDefinition(
+                                key=self.sync_loc(
+                                    es.Identifier(name=var.name.sym_name),
+                                    jac_node=var.name,
+                                ),
+                                value=default_expr,
+                                static=True,
+                            ),
+                            jac_node=var,
+                        )
+                        body_stmts.append(static_prop)
+                    continue
+
+                for var in arch_has.vars:
+                    props_ident = self.sync_loc(
+                        es.Identifier(name="props"), jac_node=var
+                    )
+                    prop_ident = self.sync_loc(
+                        es.Identifier(name=var.name.sym_name), jac_node=var.name
+                    )
+                    this_member = self.sync_loc(
+                        es.MemberExpression(
+                            object=self.sync_loc(es.ThisExpression(), jac_node=var),
+                            property=prop_ident,
+                            computed=False,
+                        ),
+                        jac_node=var,
+                    )
+                    props_access = self.sync_loc(
+                        es.MemberExpression(
+                            object=props_ident,
+                            property=self.sync_loc(
+                                es.Identifier(name=var.name.sym_name),
+                                jac_node=var.name,
+                            ),
+                            computed=False,
+                        ),
+                        jac_node=var,
+                    )
+                    has_call = self.sync_loc(
+                        es.CallExpression(
+                            callee=self.sync_loc(
+                                es.MemberExpression(
+                                    object=props_ident,
+                                    property=self.sync_loc(
+                                        es.Identifier(name="hasOwnProperty"),
+                                        jac_node=var,
+                                    ),
+                                    computed=False,
+                                ),
+                                jac_node=var,
+                            ),
+                            arguments=[
+                                self.sync_loc(
+                                    es.Literal(value=var.name.sym_name),
+                                    jac_node=var.name,
+                                )
+                            ],
+                        ),
+                        jac_node=var,
+                    )
+                    default_expr = (
+                        var.value.gen.es_ast
+                        if var.value
+                        and hasattr(var.value.gen, "es_ast")
+                        and var.value.gen.es_ast
+                        else self.sync_loc(es.Literal(value=None), jac_node=var)
+                    )
+                    conditional = self.sync_loc(
+                        es.ConditionalExpression(
+                            test=has_call,
+                            consequent=props_access,
+                            alternate=default_expr,
+                        ),
+                        jac_node=var,
+                    )
+                    assignment = self.sync_loc(
+                        es.AssignmentExpression(
+                            operator="=", left=this_member, right=conditional
+                        ),
+                        jac_node=var,
+                    )
+                    constructor_stmts.append(
+                        self.sync_loc(
+                            es.ExpressionStatement(expression=assignment),
+                            jac_node=var,
+                        )
+                    )
+
+            if constructor_stmts:
+                constructor_method = self.sync_loc(
+                    es.MethodDefinition(
+                        key=self.sync_loc(
+                            es.Identifier(name="constructor"), jac_node=node
+                        ),
+                        value=self.sync_loc(
+                            es.FunctionExpression(
+                                id=None,
+                                params=[props_param],
+                                body=self.sync_loc(
+                                    es.BlockStatement(body=constructor_stmts),
+                                    jac_node=node,
+                                ),
+                            ),
+                            jac_node=node,
+                        ),
+                        kind="constructor",
+                        static=False,
+                    ),
+                    jac_node=node,
+                )
+                body_stmts.insert(0, constructor_method)
+
+        # Create class body
+        class_body = self.sync_loc(es.ClassBody(body=body_stmts), jac_node=node)
+
+        # Handle base classes
+        super_class: Optional[es.Expression] = None
+        if node.base_classes:
+            base = node.base_classes[0]
+            if hasattr(base.gen, "es_ast") and base.gen.es_ast:
+                super_class = base.gen.es_ast
+
+        # Create class declaration
+        class_id = self.sync_loc(
+            es.Identifier(name=node.name.sym_name), jac_node=node.name
+        )
+
+        class_decl = self.sync_loc(
+            es.ClassDeclaration(id=class_id, superClass=super_class, body=class_body),
+            jac_node=node,
+        )
+
+        node.gen.es_ast = class_decl
+
+    def exit_enum(self, node: uni.Enum) -> None:
+        """Process enum declaration as an object."""
+        properties: list[es.Property] = []
+
+        inner: Sequence[uni.EnumBlockStmt] | None = None
+        if isinstance(node.body, uni.ImplDef) and isinstance(node.body.body, list):
+            inner = node.body.body  # type: ignore
+        elif isinstance(node.body, list):
+            inner = node.body
+
+        if inner:
+            for stmt in inner:
+                if isinstance(stmt, uni.Assignment):
+                    for target in stmt.target:
+                        if isinstance(target, uni.AstSymbolNode):
+                            key = self.sync_loc(
+                                es.Identifier(name=target.sym_name), jac_node=target
+                            )
+                            value: es.Expression
+                            if stmt.value and hasattr(stmt.value.gen, "es_ast"):
+                                value = stmt.value.gen.es_ast
+                            else:
+                                value = self.sync_loc(
+                                    es.Literal(value=None), jac_node=stmt
+                                )
+                            prop = self.sync_loc(
+                                es.Property(key=key, value=value, kind="init"),
+                                jac_node=stmt,
+                            )
+                            properties.append(prop)
+
+        # Create as const variable with object
+        obj_expr = self.sync_loc(
+            es.ObjectExpression(properties=properties), jac_node=node
+        )
+        var_id = self.sync_loc(
+            es.Identifier(name=node.name.sym_name), jac_node=node.name
+        )
+        var_decl = self.sync_loc(
+            es.VariableDeclaration(
+                declarations=[
+                    self.sync_loc(
+                        es.VariableDeclarator(id=var_id, init=obj_expr), jac_node=node
+                    )
+                ],
+                kind="const",
+            ),
+            jac_node=node,
+        )
+
+        node.gen.es_ast = var_decl
+
+    def exit_ability(self, node: uni.Ability) -> None:
+        """Process ability (function/method) declaration."""
+        params: list[es.Pattern] = []
+        if isinstance(node.signature, uni.FuncSignature):
+            for param in node.signature.params:
+                if hasattr(param.gen, "es_ast") and param.gen.es_ast:
+                    params.append(param.gen.es_ast)
+
+        # Process body
+        body_stmts: list[es.Statement] = []
+        inner: Sequence[uni.CodeBlockStmt] | None = None
+        if isinstance(node.body, uni.ImplDef) and isinstance(node.body.body, list):
+            inner = node.body.body  # type: ignore
+        elif isinstance(node.body, list):
+            inner = node.body
+
+        if inner:
+            for stmt in inner:
+                if hasattr(stmt.gen, "es_ast") and stmt.gen.es_ast:
+                    if isinstance(stmt.gen.es_ast, list):
+                        body_stmts.extend(stmt.gen.es_ast)
+                    else:
+                        body_stmts.append(stmt.gen.es_ast)
+
+        body_stmts = self._prepend_hoisted(node, body_stmts)
+        block = self.sync_loc(es.BlockStatement(body=body_stmts), jac_node=node)
+
+        func_id = self.sync_loc(
+            es.Identifier(name=node.name_ref.sym_name), jac_node=node.name_ref
+        )
+
+        # Check if this is a method (has parent archetype)
+        if node.is_method:
+            # Create method definition
+            func_expr = self.sync_loc(
+                es.FunctionExpression(
+                    id=None, params=params, body=block, async_=node.is_async
+                ),
+                jac_node=node,
+            )
+            method_def = self.sync_loc(
+                es.MethodDefinition(
+                    key=func_id, value=func_expr, kind="method", static=node.is_static
+                ),
+                jac_node=node,
+            )
+            node.gen.es_ast = method_def
+        else:
+            # Create function declaration
+            func_decl = self.sync_loc(
+                es.FunctionDeclaration(
+                    id=func_id, params=params, body=block, async_=node.is_async
+                ),
+                jac_node=node,
+            )
+            node.gen.es_ast = func_decl
+
+    def exit_func_signature(self, node: uni.FuncSignature) -> None:
+        """Process function signature."""
+        node.gen.es_ast = None
+
+    def exit_param_var(self, node: uni.ParamVar) -> None:
+        """Process parameter variable."""
+        param_id = self.sync_loc(
+            es.Identifier(name=node.name.sym_name), jac_node=node.name
+        )
+        self._register_declaration(param_id.name)
+        node.gen.es_ast = param_id
+
+    def exit_arch_has(self, node: uni.ArchHas) -> None:
+        """Process class field declarations."""
+        # ES doesn't directly support field declarations in the same way
+        # This could be handled via constructor assignments
+        node.gen.es_ast = None
+
+    def exit_has_var(self, node: uni.HasVar) -> None:
+        """Process has variable."""
+        node.gen.es_ast = None
+
+    # JSX Nodes
+    # =========
+
+    def exit_jsx_element(self, node: uni.JsxElement) -> None:
+        """Process JSX element into __jacJsx(tag, props, children) call."""
+        # Tag expression (string literal for HTML tags, identifier/member for components)
+        if node.is_fragment or not node.name:
+            tag_expr: es.Expression = self.sync_loc(
+                es.Literal(value=None), jac_node=node
+            )
+        else:
+            tag_expr = (
+                node.name.gen.es_ast
+                if hasattr(node.name.gen, "es_ast") and node.name.gen.es_ast
+                else self.sync_loc(es.Literal(value=None), jac_node=node.name)
+            )
+
+        # Props / attributes
+        props_expr: es.Expression
+        attributes = node.attributes or []
+        has_spread = any(
+            isinstance(attr, uni.JsxSpreadAttribute) for attr in attributes
+        )
+        if not attributes:
+            props_expr = self.sync_loc(
+                es.ObjectExpression(properties=[]), jac_node=node
+            )
+        elif has_spread:
+            segments: list[es.Expression] = []
+            for attr in attributes:
+                if isinstance(attr, uni.JsxSpreadAttribute):
+                    exp = getattr(attr.gen, "es_ast", None)
+                    if exp:
+                        segments.append(exp)
+                elif isinstance(attr, uni.JsxNormalAttribute):
+                    prop = getattr(attr.gen, "es_ast", None)
+                    if isinstance(prop, es.Property):
+                        segments.append(
+                            self.sync_loc(
+                                es.ObjectExpression(properties=[prop]), jac_node=attr
+                            )
+                        )
+            if segments:
+                assign_member = self.sync_loc(
+                    es.MemberExpression(
+                        object=self.sync_loc(
+                            es.Identifier(name="Object"), jac_node=node
+                        ),
+                        property=self.sync_loc(
+                            es.Identifier(name="assign"), jac_node=node
+                        ),
+                        computed=False,
+                        optional=False,
+                    ),
+                    jac_node=node,
+                )
+                props_expr = self.sync_loc(
+                    es.CallExpression(
+                        callee=assign_member,
+                        arguments=[
+                            self.sync_loc(
+                                es.ObjectExpression(properties=[]), jac_node=node
+                            ),
+                            *segments,
+                        ],
+                    ),
+                    jac_node=node,
+                )
+            else:
+                props_expr = self.sync_loc(
+                    es.ObjectExpression(properties=[]), jac_node=node
+                )
+        else:
+            properties: list[es.Property] = []
+            for attr in attributes:
+                prop = getattr(attr.gen, "es_ast", None)
+                if isinstance(prop, es.Property):
+                    properties.append(prop)
+            props_expr = self.sync_loc(
+                es.ObjectExpression(properties=properties), jac_node=node
+            )
+
+        # Children
+        children_elements: list[Optional[Union[es.Expression, es.SpreadElement]]] = []
+        for child in node.children or []:
+            child_expr = getattr(child.gen, "es_ast", None)
+            if child_expr is None:
+                continue
+            if isinstance(child_expr, list):
+                children_elements.extend(child_expr)  # type: ignore[arg-type]
+            else:
+                children_elements.append(child_expr)
+        children_expr = self.sync_loc(
+            es.ArrayExpression(elements=children_elements), jac_node=node
+        )
+
+        # __jacJsx(tag, props, children)
+        call_expr = self.sync_loc(
+            es.CallExpression(
+                callee=self.sync_loc(es.Identifier(name="__jacJsx"), jac_node=node),
+                arguments=[tag_expr, props_expr, children_expr],
+            ),
+            jac_node=node,
+        )
+        node.gen.es_ast = call_expr
+
+    def exit_jsx_element_name(self, node: uni.JsxElementName) -> None:
+        """Process JSX element name."""
+        if not node.parts:
+            node.gen.es_ast = self.sync_loc(es.Literal(value=None), jac_node=node)
+            return
+
+        parts = [part.value for part in node.parts]
+        first = parts[0]
+        if first and first[0].isupper():
+            expr: es.Expression = self.sync_loc(
+                es.Identifier(name=first), jac_node=node.parts[0]
+            )
+            for idx, part in enumerate(parts[1:], start=1):
+                expr = self.sync_loc(
+                    es.MemberExpression(
+                        object=expr,
+                        property=self.sync_loc(
+                            es.Identifier(name=part), jac_node=node.parts[idx]
+                        ),
+                        computed=False,
+                        optional=False,
+                    ),
+                    jac_node=node,
+                )
+            node.gen.es_ast = expr
+        else:
+            node.gen.es_ast = self.sync_loc(
+                es.Literal(value=".".join(parts)), jac_node=node
+            )
+
+    def exit_jsx_spread_attribute(self, node: uni.JsxSpreadAttribute) -> None:
+        """Process JSX spread attribute."""
+        expr = (
+            node.expr.gen.es_ast
+            if hasattr(node.expr.gen, "es_ast") and node.expr.gen.es_ast
+            else self.sync_loc(es.ObjectExpression(properties=[]), jac_node=node)
+        )
+        node.gen.es_ast = expr
+
+    def exit_jsx_normal_attribute(self, node: uni.JsxNormalAttribute) -> None:
+        """Process JSX normal attribute."""
+        key_expr = self.sync_loc(es.Literal(value=node.name.value), jac_node=node.name)
+        if node.value is None:
+            value_expr = self.sync_loc(es.Literal(value=True), jac_node=node)
+        elif isinstance(node.value, uni.String):
+            value_expr = self.sync_loc(
+                es.Literal(value=node.value.lit_value), jac_node=node.value
+            )
+        else:
+            value_expr = (
+                node.value.gen.es_ast
+                if hasattr(node.value.gen, "es_ast") and node.value.gen.es_ast
+                else self.sync_loc(es.Literal(value=None), jac_node=node.value)
+            )
+
+        prop = self.sync_loc(
+            es.Property(
+                key=key_expr,
+                value=value_expr,
+                kind="init",
+                method=False,
+                shorthand=False,
+                computed=False,
+            ),
+            jac_node=node,
+        )
+        node.gen.es_ast = prop
+
+    def exit_jsx_text(self, node: uni.JsxText) -> None:
+        """Process JSX text node."""
+        raw_value = node.value.value if hasattr(node.value, "value") else node.value
+        node.gen.es_ast = self.sync_loc(es.Literal(value=str(raw_value)), jac_node=node)
+
+    def exit_jsx_expression(self, node: uni.JsxExpression) -> None:
+        """Process JSX expression child."""
+        expr = (
+            node.expr.gen.es_ast
+            if hasattr(node.expr.gen, "es_ast") and node.expr.gen.es_ast
+            else self.sync_loc(es.Literal(value=None), jac_node=node.expr)
+        )
+        node.gen.es_ast = expr
+
+    # Control Flow Statements
+    # =======================
+
+    def exit_if_stmt(self, node: uni.IfStmt) -> None:
+        """Process if statement."""
+        test = (
+            node.condition.gen.es_ast
+            if hasattr(node.condition.gen, "es_ast")
+            else self.sync_loc(es.Literal(value=True), jac_node=node.condition)
+        )
+
+        consequent_stmts: list[es.Statement] = []
+        if node.body:
+            for stmt in node.body:
+                if hasattr(stmt.gen, "es_ast") and stmt.gen.es_ast:
+                    if isinstance(stmt.gen.es_ast, list):
+                        consequent_stmts.extend(stmt.gen.es_ast)
+                    else:
+                        consequent_stmts.append(stmt.gen.es_ast)
+
+        consequent_stmts = self._prepend_hoisted(node, consequent_stmts)
+        consequent = self.sync_loc(
+            es.BlockStatement(body=consequent_stmts), jac_node=node
+        )
+
+        alternate: Optional[es.Statement] = None
+        if (
+            node.else_body
+            and hasattr(node.else_body.gen, "es_ast")
+            and node.else_body.gen.es_ast
+        ):
+            alternate = node.else_body.gen.es_ast
+
+        if_stmt = self.sync_loc(
+            es.IfStatement(test=test, consequent=consequent, alternate=alternate),
+            jac_node=node,
+        )
+        node.gen.es_ast = if_stmt
+
+    def exit_else_if(self, node: uni.ElseIf) -> None:
+        """Process else-if clause."""
+        test = (
+            node.condition.gen.es_ast
+            if hasattr(node.condition.gen, "es_ast")
+            else self.sync_loc(es.Literal(value=True), jac_node=node.condition)
+        )
+
+        consequent_stmts: list[es.Statement] = []
+        if node.body:
+            for stmt in node.body:
+                if hasattr(stmt.gen, "es_ast") and stmt.gen.es_ast:
+                    if isinstance(stmt.gen.es_ast, list):
+                        consequent_stmts.extend(stmt.gen.es_ast)
+                    else:
+                        consequent_stmts.append(stmt.gen.es_ast)
+
+        consequent_stmts = self._prepend_hoisted(node, consequent_stmts)
+        consequent = self.sync_loc(
+            es.BlockStatement(body=consequent_stmts), jac_node=node
+        )
+
+        alternate: Optional[es.Statement] = None
+        if (
+            node.else_body
+            and hasattr(node.else_body.gen, "es_ast")
+            and node.else_body.gen.es_ast
+        ):
+            alternate = node.else_body.gen.es_ast
+
+        if_stmt = self.sync_loc(
+            es.IfStatement(test=test, consequent=consequent, alternate=alternate),
+            jac_node=node,
+        )
+        node.gen.es_ast = if_stmt
+
+    def exit_else_stmt(self, node: uni.ElseStmt) -> None:
+        """Process else clause."""
+        stmts: list[es.Statement] = []
+        if node.body:
+            for stmt in node.body:
+                if hasattr(stmt.gen, "es_ast") and stmt.gen.es_ast:
+                    if isinstance(stmt.gen.es_ast, list):
+                        stmts.extend(stmt.gen.es_ast)
+                    else:
+                        stmts.append(stmt.gen.es_ast)
+
+        stmts = self._prepend_hoisted(node, stmts)
+        block = self.sync_loc(es.BlockStatement(body=stmts), jac_node=node)
+        node.gen.es_ast = block
+
+    def exit_while_stmt(self, node: uni.WhileStmt) -> None:
+        """Process while statement."""
+        test = (
+            node.condition.gen.es_ast
+            if hasattr(node.condition.gen, "es_ast")
+            else self.sync_loc(es.Literal(value=True), jac_node=node.condition)
+        )
+
+        body_stmts: list[es.Statement] = []
+        if node.body:
+            for stmt in node.body:
+                if hasattr(stmt.gen, "es_ast") and stmt.gen.es_ast:
+                    if isinstance(stmt.gen.es_ast, list):
+                        body_stmts.extend(stmt.gen.es_ast)
+                    else:
+                        body_stmts.append(stmt.gen.es_ast)
+
+        body_stmts = self._prepend_hoisted(node, body_stmts)
+        body = self.sync_loc(es.BlockStatement(body=body_stmts), jac_node=node)
+
+        while_stmt = self.sync_loc(
+            es.WhileStatement(test=test, body=body), jac_node=node
+        )
+        node.gen.es_ast = while_stmt
+
+    def exit_in_for_stmt(self, node: uni.InForStmt) -> None:
+        """Process for-in statement."""
+        left = (
+            node.target.gen.es_ast
+            if hasattr(node.target.gen, "es_ast")
+            else self.sync_loc(es.Identifier(name="item"), jac_node=node.target)
+        )
+        right = (
+            node.collection.gen.es_ast
+            if hasattr(node.collection.gen, "es_ast")
+            else self.sync_loc(
+                es.Identifier(name="collection"), jac_node=node.collection
+            )
+        )
+
+        body_stmts: list[es.Statement] = []
+        if node.body:
+            for stmt in node.body:
+                if hasattr(stmt.gen, "es_ast") and stmt.gen.es_ast:
+                    if isinstance(stmt.gen.es_ast, list):
+                        body_stmts.extend(stmt.gen.es_ast)
+                    else:
+                        body_stmts.append(stmt.gen.es_ast)
+
+        body_stmts = self._prepend_hoisted(node, body_stmts)
+        body = self.sync_loc(es.BlockStatement(body=body_stmts), jac_node=node)
+
+        pattern_nodes = (
+            es.Identifier,
+            es.ArrayPattern,
+            es.ObjectPattern,
+            es.AssignmentPattern,
+            es.RestElement,
+        )
+        if isinstance(left, es.VariableDeclaration):
+            decl = left
+        else:
+            if isinstance(left, pattern_nodes):
+                pattern = left
+            else:
+                pattern = self.sync_loc(
+                    es.Identifier(name="_item"), jac_node=node.target
+                )
+            declarator = self.sync_loc(
+                es.VariableDeclarator(id=pattern, init=None), jac_node=node.target
+            )
+            decl = self.sync_loc(
+                es.VariableDeclaration(
+                    declarations=[declarator],
+                    kind="const",
+                ),
+                jac_node=node.target,
+            )
+
+        # Use for-of for iteration over values
+        for_stmt = self.sync_loc(
+            es.ForOfStatement(left=decl, right=right, body=body, await_=node.is_async),
+            jac_node=node,
+        )
+        node.gen.es_ast = for_stmt
+
+    def exit_try_stmt(self, node: uni.TryStmt) -> None:
+        """Process try statement."""
+        block_stmts: list[es.Statement] = []
+        if node.body:
+            for stmt in node.body:
+                if hasattr(stmt.gen, "es_ast") and stmt.gen.es_ast:
+                    if isinstance(stmt.gen.es_ast, list):
+                        block_stmts.extend(stmt.gen.es_ast)
+                    else:
+                        block_stmts.append(stmt.gen.es_ast)
+
+        block_stmts = self._prepend_hoisted(node, block_stmts)
+        block = self.sync_loc(es.BlockStatement(body=block_stmts), jac_node=node)
+
+        handler: Optional[es.CatchClause] = None
+        if node.excepts:
+            # Take first except clause
+            except_node = node.excepts[0]
+            if hasattr(except_node.gen, "es_ast") and except_node.gen.es_ast:
+                handler = except_node.gen.es_ast
+
+        finalizer: Optional[es.BlockStatement] = None
+        if (
+            node.finally_body
+            and hasattr(node.finally_body.gen, "es_ast")
+            and isinstance(node.finally_body.gen.es_ast, es.BlockStatement)
+        ):
+            finalizer = node.finally_body.gen.es_ast
+
+        try_stmt = self.sync_loc(
+            es.TryStatement(block=block, handler=handler, finalizer=finalizer),
+            jac_node=node,
+        )
+        node.gen.es_ast = try_stmt
+
+    def exit_except(self, node: uni.Except) -> None:
+        """Process except clause."""
+        param: Optional[es.Pattern] = None
+        if node.name:
+            param = self.sync_loc(
+                es.Identifier(name=node.name.sym_name), jac_node=node.name
+            )
+
+        body_stmts: list[es.Statement] = []
+        if node.body:
+            for stmt in node.body:
+                if hasattr(stmt.gen, "es_ast") and stmt.gen.es_ast:
+                    if isinstance(stmt.gen.es_ast, list):
+                        body_stmts.extend(stmt.gen.es_ast)
+                    else:
+                        body_stmts.append(stmt.gen.es_ast)
+
+        body_stmts = self._prepend_hoisted(node, body_stmts)
+        body = self.sync_loc(es.BlockStatement(body=body_stmts), jac_node=node)
+
+        catch_clause = self.sync_loc(
+            es.CatchClause(param=param, body=body), jac_node=node
+        )
+        node.gen.es_ast = catch_clause
+
+    def exit_finally_stmt(self, node: uni.FinallyStmt) -> None:
+        """Process finally clause."""
+        body_stmts: list[es.Statement] = []
+        if node.body:
+            for stmt in node.body:
+                if hasattr(stmt.gen, "es_ast") and stmt.gen.es_ast:
+                    if isinstance(stmt.gen.es_ast, list):
+                        body_stmts.extend(stmt.gen.es_ast)
+                    else:
+                        body_stmts.append(stmt.gen.es_ast)
+
+        body_stmts = self._prepend_hoisted(node, body_stmts)
+        block = self.sync_loc(es.BlockStatement(body=body_stmts), jac_node=node)
+        node.gen.es_ast = block
+
+    def exit_raise_stmt(self, node: uni.RaiseStmt) -> None:
+        """Process raise statement."""
+        argument = (
+            node.cause.gen.es_ast
+            if node.cause and hasattr(node.cause.gen, "es_ast")
+            else self.sync_loc(es.Identifier(name="Error"), jac_node=node)
+        )
+
+        if isinstance(argument, es.CallExpression):
+            callee = argument.callee
+            if isinstance(callee, es.Identifier) and callee.name in {
+                "Exception",
+                "Error",
+            }:
+                new_expr = self.sync_loc(
+                    es.NewExpression(
+                        callee=self.sync_loc(
+                            es.Identifier(name="Error"), jac_node=node
+                        ),
+                        arguments=argument.arguments,
+                    ),
+                    jac_node=node,
+                )
+                argument = new_expr
+
+        throw_stmt = self.sync_loc(es.ThrowStatement(argument=argument), jac_node=node)
+        node.gen.es_ast = throw_stmt
+
+    def exit_assert_stmt(self, node: uni.AssertStmt) -> None:
+        """Process assert statement as if-throw."""
+        test = (
+            node.condition.gen.es_ast
+            if hasattr(node.condition.gen, "es_ast")
+            else self.sync_loc(es.Literal(value=True), jac_node=node.condition)
+        )
+
+        # Negate the test (throw if condition is false)
+        negated_test = self.sync_loc(
+            es.UnaryExpression(operator="!", prefix=True, argument=test), jac_node=node
+        )
+
+        error_msg = "Assertion failed"
+        if (
+            node.error_msg
+            and hasattr(node.error_msg.gen, "es_ast")
+            and isinstance(node.error_msg.gen.es_ast, es.Literal)
+        ):
+            error_msg = str(node.error_msg.gen.es_ast.value)
+
+        throw_stmt = self.sync_loc(
+            es.ThrowStatement(
+                argument=self.sync_loc(
+                    es.NewExpression(
+                        callee=self.sync_loc(
+                            es.Identifier(name="Error"), jac_node=node
+                        ),
+                        arguments=[
+                            self.sync_loc(es.Literal(value=error_msg), jac_node=node)
+                        ],
+                    ),
+                    jac_node=node,
+                )
+            ),
+            jac_node=node,
+        )
+
+        if_stmt = self.sync_loc(
+            es.IfStatement(
+                test=negated_test,
+                consequent=self.sync_loc(
+                    es.BlockStatement(body=[throw_stmt]), jac_node=node
+                ),
+            ),
+            jac_node=node,
+        )
+        node.gen.es_ast = if_stmt
+
+    def exit_return_stmt(self, node: uni.ReturnStmt) -> None:
+        """Process return statement."""
+        argument: Optional[es.Expression] = None
+        if node.expr and hasattr(node.expr.gen, "es_ast"):
+            argument = node.expr.gen.es_ast
+
+        ret_stmt = self.sync_loc(es.ReturnStatement(argument=argument), jac_node=node)
+        node.gen.es_ast = ret_stmt
+
+    def exit_ctrl_stmt(self, node: uni.CtrlStmt) -> None:
+        """Process control statement (break/continue)."""
+        if node.ctrl.name == Tok.KW_BREAK:
+            stmt = self.sync_loc(es.BreakStatement(), jac_node=node)
+        else:  # continue
+            stmt = self.sync_loc(es.ContinueStatement(), jac_node=node)
+        node.gen.es_ast = stmt
+
+    def exit_expr_stmt(self, node: uni.ExprStmt) -> None:
+        """Process expression statement."""
+        expr = (
+            node.expr.gen.es_ast
+            if hasattr(node.expr.gen, "es_ast")
+            else self.sync_loc(es.Literal(value=None), jac_node=node.expr)
+        )
+
+        expr_stmt = self.sync_loc(
+            es.ExpressionStatement(expression=expr), jac_node=node
+        )
+        node.gen.es_ast = expr_stmt
+
+    # Expressions
+    # ===========
+
+    def exit_binary_expr(self, node: uni.BinaryExpr) -> None:
+        """Process binary expression."""
+        left = (
+            node.left.gen.es_ast
+            if hasattr(node.left.gen, "es_ast") and node.left.gen.es_ast
+            else None
+        )
+        if not left:
+            if isinstance(node.left, uni.Name):
+                left = self.sync_loc(
+                    es.Identifier(name=node.left.sym_name), jac_node=node.left
+                )
+            else:
+                left = self.sync_loc(es.Literal(value=0), jac_node=node.left)
+
+        right = (
+            node.right.gen.es_ast
+            if hasattr(node.right.gen, "es_ast") and node.right.gen.es_ast
+            else None
+        )
+        if not right:
+            if isinstance(node.right, uni.Name):
+                right = self.sync_loc(
+                    es.Identifier(name=node.right.sym_name), jac_node=node.right
+                )
+            else:
+                right = self.sync_loc(es.Literal(value=0), jac_node=node.right)
+
+        op_name = getattr(node.op, "name", None)
+
+        if op_name == Tok.KW_SPAWN:
+            spawn_call = self.sync_loc(
+                es.CallExpression(
+                    callee=self.sync_loc(
+                        es.Identifier(name="__jacSpawn"), jac_node=node
+                    ),
+                    arguments=[left, right],
+                ),
+                jac_node=node,
+            )
+            node.gen.es_ast = spawn_call
+            return
+
+        # Map Jac operators to JS operators
+        op_map = {
+            Tok.EE: "===",
+            Tok.NE: "!==",
+            Tok.LT: "<",
+            Tok.GT: ">",
+            Tok.LTE: "<=",
+            Tok.GTE: ">=",
+            Tok.PLUS: "+",
+            Tok.MINUS: "-",
+            Tok.STAR_MUL: "*",
+            Tok.DIV: "/",
+            Tok.MOD: "%",
+            Tok.BW_AND: "&",
+            Tok.BW_OR: "|",
+            Tok.BW_XOR: "^",
+            Tok.LSHIFT: "<<",
+            Tok.RSHIFT: ">>",
+        }
+
+        if op_name == Tok.WALRUS_EQ and isinstance(left, es.Identifier):
+            self._ensure_identifier_declared(left.name, node.left)
+            assign_expr = self.sync_loc(
+                es.AssignmentExpression(operator="=", left=left, right=right),
+                jac_node=node,
+            )
+            node.gen.es_ast = assign_expr
+            return
+
+        operator = op_map.get(op_name, "+")
+
+        # Check if it's a logical operator
+        if op_name in (Tok.KW_AND, Tok.KW_OR):
+            logical_op = "&&" if op_name == Tok.KW_AND else "||"
+            bin_expr = self.sync_loc(
+                es.LogicalExpression(operator=logical_op, left=left, right=right),
+                jac_node=node,
+            )
+        else:
+            bin_expr = self.sync_loc(
+                es.BinaryExpression(operator=operator, left=left, right=right),
+                jac_node=node,
+            )
+
+        node.gen.es_ast = bin_expr
+
+    def exit_bool_expr(self, node: uni.BoolExpr) -> None:
+        """Process boolean expression (and/or)."""
+        # BoolExpr has op and list of values
+        if not node.values or len(node.values) < 2:
+            node.gen.es_ast = self.sync_loc(es.Literal(value=None), jac_node=node)
+            return
+
+        # Get the operator
+        logical_op = "&&" if node.op.name == Tok.KW_AND else "||"
+
+        # Build the logical expression from left to right
+        result = (
+            node.values[0].gen.es_ast
+            if hasattr(node.values[0].gen, "es_ast")
+            else self.sync_loc(es.Literal(value=None), jac_node=node.values[0])
+        )
+
+        for val in node.values[1:]:
+            right = (
+                val.gen.es_ast
+                if hasattr(val.gen, "es_ast")
+                else self.sync_loc(es.Literal(value=None), jac_node=val)
+            )
+            result = self.sync_loc(
+                es.LogicalExpression(operator=logical_op, left=result, right=right),
+                jac_node=node,
+            )
+
+        node.gen.es_ast = result
+
+    def exit_compare_expr(self, node: uni.CompareExpr) -> None:
+        """Process compare expression."""
+        # CompareExpr can have multiple comparisons chained: a < b < c
+        # Need to convert to: a < b && b < c
+
+        op_map = {
+            Tok.EE: "===",
+            Tok.NE: "!==",
+            Tok.LT: "<",
+            Tok.GT: ">",
+            Tok.LTE: "<=",
+            Tok.GTE: ">=",
+            Tok.KW_IN: "in",
+            Tok.KW_NIN: "in",  # Will need negation
+        }
+
+        if not node.rights or not node.ops:
+            # Fallback to simple comparison
+            node.gen.es_ast = self.sync_loc(es.Literal(value=True), jac_node=node)
+            return
+
+        # Build comparisons
+        comparisons: list[es.Expression] = []
+        left = (
+            node.left.gen.es_ast
+            if hasattr(node.left.gen, "es_ast")
+            else self.sync_loc(es.Identifier(name="left"), jac_node=node.left)
+        )
+
+        for _, (op, right_node) in enumerate(zip(node.ops, node.rights)):
+            right = (
+                right_node.gen.es_ast
+                if hasattr(right_node.gen, "es_ast")
+                else self.sync_loc(es.Identifier(name="right"), jac_node=right_node)
+            )
+            operator = op_map.get(op.name, "===")
+
+            # Handle 'not in' operator
+            if op.name == Tok.KW_NIN:
+                bin_expr = self.sync_loc(
+                    es.UnaryExpression(
+                        operator="!",
+                        prefix=True,
+                        argument=self.sync_loc(
+                            es.BinaryExpression(operator="in", left=left, right=right),
+                            jac_node=node,
+                        ),
+                    ),
+                    jac_node=node,
+                )
+            else:
+                bin_expr = self.sync_loc(
+                    es.BinaryExpression(operator=operator, left=left, right=right),
+                    jac_node=node,
+                )
+
+            comparisons.append(bin_expr)
+            left = right  # For chained comparisons
+
+        # Combine with && if multiple comparisons
+        if len(comparisons) == 1:
+            node.gen.es_ast = comparisons[0]
+        else:
+            result = comparisons[0]
+            for comp in comparisons[1:]:
+                result = self.sync_loc(
+                    es.LogicalExpression(operator="&&", left=result, right=comp),
+                    jac_node=node,
+                )
+            node.gen.es_ast = result
+
+    def exit_unary_expr(self, node: uni.UnaryExpr) -> None:
+        """Process unary expression."""
+        operand = (
+            node.operand.gen.es_ast
+            if hasattr(node.operand.gen, "es_ast")
+            else self.sync_loc(es.Literal(value=0), jac_node=node.operand)
+        )
+
+        op_map = {
+            Tok.MINUS: "-",
+            Tok.PLUS: "+",
+            Tok.NOT: "!",
+            Tok.BW_NOT: "~",
+        }
+
+        operator = op_map.get(node.op.name, "!")
+
+        unary_expr = self.sync_loc(
+            es.UnaryExpression(operator=operator, prefix=True, argument=operand),
+            jac_node=node,
+        )
+        node.gen.es_ast = unary_expr
+
+    def _convert_assignment_target(
+        self, target: uni.UniNode
+    ) -> tuple[
+        Union[es.Pattern, es.Expression], Optional[es.Expression], Optional[str]
+    ]:
+        """Convert a Jac assignment target into an ESTree pattern/expression."""
+        if isinstance(target, uni.Name):
+            identifier = self.sync_loc(
+                es.Identifier(name=target.sym_name), jac_node=target
+            )
+            return identifier, identifier, target.sym_name
+
+        if isinstance(target, (uni.TupleVal, uni.ListVal)):
+            elements: list[Optional[es.Pattern]] = []
+            for value in getattr(target, "values", []):
+                if value is None:
+                    elements.append(None)
+                    continue
+                pattern, _, _ = self._convert_assignment_target(value)
+                elements.append(pattern if isinstance(pattern, es.Pattern) else pattern)
+            pattern = self.sync_loc(es.ArrayPattern(elements=elements), jac_node=target)
+            return pattern, None, None
+
+        if isinstance(target, uni.DictVal):
+            properties: list[es.AssignmentProperty] = []
+            for kv in target.kv_pairs:
+                if not isinstance(kv, uni.KVPair) or kv.key is None:
+                    continue
+                key_expr = (
+                    kv.key.gen.es_ast
+                    if hasattr(kv.key.gen, "es_ast") and kv.key.gen.es_ast
+                    else self.sync_loc(es.Identifier(name="key"), jac_node=kv.key)
+                )
+                value_pattern, _, _ = self._convert_assignment_target(kv.value)
+                assignment = self.sync_loc(
+                    es.AssignmentProperty(
+                        key=key_expr,
+                        value=(
+                            value_pattern
+                            if isinstance(value_pattern, es.Pattern)
+                            else value_pattern
+                        ),
+                        shorthand=False,
+                    ),
+                    jac_node=kv,
+                )
+                properties.append(assignment)
+            pattern = self.sync_loc(
+                es.ObjectPattern(properties=properties), jac_node=target
+            )
+            return pattern, None, None
+
+        if isinstance(target, uni.SubTag):
+            return self._convert_assignment_target(target.tag)
+
+        left = (
+            target.gen.es_ast
+            if hasattr(target.gen, "es_ast") and target.gen.es_ast
+            else self.sync_loc(es.Identifier(name="temp"), jac_node=target)
+        )
+        reference = left if isinstance(left, es.Expression) else None
+        return left, reference, None
+
+    def _collect_pattern_names(self, target: uni.UniNode) -> list[tuple[str, uni.Name]]:
+        """Collect identifier names from a (possibly nested) destructuring target."""
+        names: list[tuple[str, uni.Name]] = []
+        if isinstance(target, uni.Name):
+            names.append((target.sym_name, target))
+        elif isinstance(target, (uni.TupleVal, uni.ListVal)):
+            for value in getattr(target, "values", []):
+                names.extend(self._collect_pattern_names(value))
+        elif isinstance(target, uni.DictVal):
+            for kv in target.kv_pairs:
+                if isinstance(kv, uni.KVPair):
+                    names.extend(self._collect_pattern_names(kv.value))
+        elif isinstance(target, uni.SubTag):
+            names.extend(self._collect_pattern_names(target.tag))
+        return names
+
+    def _is_name_first_definition(self, name_node: uni.Name) -> bool:
+        """Determine whether a name node corresponds to the first definition in its scope."""
+        sym = getattr(name_node, "sym", None)
+        if sym and name_node.name_spec in sym.defn:
+            return sym.defn.index(name_node.name_spec) == 0
+        return True
+
+    def exit_assignment(self, node: uni.Assignment) -> None:
+        """Process assignment expression."""
+        if not node.target:
+            node.gen.es_ast = None
+            return
+
+        aug_op_map = {
+            Tok.ADD_EQ: "+=",
+            Tok.SUB_EQ: "-=",
+            Tok.MUL_EQ: "*=",
+            Tok.DIV_EQ: "/=",
+            Tok.MOD_EQ: "%=",
+            Tok.BW_AND_EQ: "&=",
+            Tok.BW_OR_EQ: "|=",
+            Tok.BW_XOR_EQ: "^=",
+            Tok.LSHIFT_EQ: "<<=",
+            Tok.RSHIFT_EQ: ">>=",
+            Tok.STAR_POW_EQ: "**=",
+        }
+
+        value_expr = (
+            node.value.gen.es_ast
+            if node.value
+            and hasattr(node.value.gen, "es_ast")
+            and node.value.gen.es_ast
+            else None
+        )
+
+        if node.aug_op:
+            left, _, _ = self._convert_assignment_target(node.target[0])
+            operator = aug_op_map.get(node.aug_op.name, "=")
+            right = value_expr or self.sync_loc(
+                es.Identifier(name="undefined"), jac_node=node
+            )
+            assign_expr = self.sync_loc(
+                es.AssignmentExpression(operator=operator, left=left, right=right),
+                jac_node=node,
+            )
+            expr_stmt = self.sync_loc(
+                es.ExpressionStatement(expression=assign_expr), jac_node=node
+            )
+            node.gen.es_ast = expr_stmt
+            return
+
+        targets_info: list[AssignmentTargetInfo] = []
+        for target_node in node.target:
+            left, reference, decl_name = self._convert_assignment_target(target_node)
+            pattern_names = self._collect_pattern_names(target_node)
+            first_def = False
+            if isinstance(target_node, uni.Name):
+                first_def = self._is_name_first_definition(target_node)
+            elif pattern_names:
+                first_def = any(
+                    self._is_name_first_definition(name_node)
+                    for _, name_node in pattern_names
+                )
+
+            targets_info.append(
+                AssignmentTargetInfo(
+                    node=target_node,
+                    left=left,
+                    reference=reference,
+                    decl_name=decl_name,
+                    pattern_names=pattern_names,
+                    is_first=first_def,
+                )
+            )
+
+        statements: list[es.Statement] = []
+        current_value = value_expr or self.sync_loc(
+            es.Identifier(name="undefined"), jac_node=node
+        )
+
+        for info in reversed(targets_info):
+            target_node = info.node
+            left = info.left
+            decl_name = info.decl_name
+            pattern_names = info.pattern_names
+            is_first = info.is_first
+
+            should_declare = False
+            if decl_name:
+                should_declare = is_first and not self._is_declared_in_current_scope(
+                    decl_name
+                )
+            elif pattern_names:
+                should_declare = any(
+                    self._is_name_first_definition(name_node)
+                    and not self._is_declared_in_current_scope(name)
+                    for name, name_node in pattern_names
+                )
+
+            if should_declare:
+                declarator = self.sync_loc(
+                    es.VariableDeclarator(
+                        id=left, init=current_value if value_expr is not None else None
+                    ),
+                    jac_node=target_node,
+                )
+                decl_stmt = self.sync_loc(
+                    es.VariableDeclaration(
+                        declarations=[declarator],
+                        kind="let",
+                    ),
+                    jac_node=target_node,
+                )
+                statements.append(decl_stmt)
+
+                if decl_name:
+                    self._register_declaration(decl_name)
+                else:
+                    for name, _ in pattern_names:
+                        self._register_declaration(name)
+            else:
+                assign_expr = self.sync_loc(
+                    es.AssignmentExpression(
+                        operator="=",
+                        left=left,
+                        right=current_value,
+                    ),
+                    jac_node=target_node,
+                )
+                expr_stmt = self.sync_loc(
+                    es.ExpressionStatement(expression=assign_expr),
+                    jac_node=target_node,
+                )
+                statements.append(expr_stmt)
+
+            if isinstance(left, es.Identifier):
+                current_value = self.sync_loc(
+                    es.Identifier(name=left.name), jac_node=target_node
+                )
+            elif isinstance(info.reference, es.Identifier):
+                ref_ident = info.reference
+                current_value = self.sync_loc(
+                    es.Identifier(name=ref_ident.name), jac_node=target_node
+                )
+            else:
+                current_value = info.reference or current_value
+
+        if len(statements) == 1:
+            node.gen.es_ast = statements[0]
+        else:
+            node.gen.es_ast = statements
+
+    def exit_func_call(self, node: uni.FuncCall) -> None:
+        """Process function call."""
+        callee = (
+            node.target.gen.es_ast
+            if hasattr(node.target.gen, "es_ast")
+            else self.sync_loc(es.Identifier(name="func"), jac_node=node.target)
+        )
+
+        args: list[Union[es.Expression, es.SpreadElement]] = []
+        for param in node.params:
+            if hasattr(param.gen, "es_ast") and param.gen.es_ast:
+                args.append(param.gen.es_ast)
+
+        if isinstance(callee, es.MemberExpression) and isinstance(
+            callee.property, es.Identifier
+        ):
+            method_map = {
+                "lower": "toLowerCase",
+                "upper": "toUpperCase",
+                "startswith": "startsWith",
+                "endswith": "endsWith",
+            }
+            replacement = method_map.get(callee.property.name)
+            if replacement:
+                callee = self.sync_loc(
+                    es.MemberExpression(
+                        object=callee.object,
+                        property=self.sync_loc(
+                            es.Identifier(name=replacement), jac_node=node
+                        ),
+                        computed=callee.computed,
+                    ),
+                    jac_node=node,
+                )
+
+        call_expr = self.sync_loc(
+            es.CallExpression(callee=callee, arguments=args), jac_node=node
+        )
+        node.gen.es_ast = call_expr
+
+    def exit_index_slice(self, node: uni.IndexSlice) -> None:
+        """Process index/slice - just store the slice info, actual member access is handled by AtomTrailer."""
+        # IndexSlice doesn't have a target - it's used within an AtomTrailer
+        # Store the slice information for use by the parent AtomTrailer
+        if node.slices and len(node.slices) > 0:
+            first_slice = node.slices[0]
+            if node.is_range:
+                # Store slice info - will be used by AtomTrailer
+                node.gen.es_ast = {
+                    "type": "slice",
+                    "start": (
+                        first_slice.start.gen.es_ast
+                        if first_slice.start
+                        and hasattr(first_slice.start.gen, "es_ast")
+                        else None
+                    ),
+                    "stop": (
+                        first_slice.stop.gen.es_ast
+                        if first_slice.stop and hasattr(first_slice.stop.gen, "es_ast")
+                        else None
+                    ),
+                }
+            else:
+                # Store index info - will be used by AtomTrailer
+                node.gen.es_ast = {
+                    "type": "index",
+                    "value": (
+                        first_slice.start.gen.es_ast
+                        if first_slice.start
+                        and hasattr(first_slice.start.gen, "es_ast")
+                        else self.sync_loc(es.Literal(value=0), jac_node=node)
+                    ),
+                }
+        else:
+            node.gen.es_ast = None
+
+    def exit_atom_trailer(self, node: uni.AtomTrailer) -> None:
+        """Process attribute access."""
+        obj = (
+            node.target.gen.es_ast
+            if hasattr(node.target.gen, "es_ast")
+            else self.sync_loc(es.Identifier(name="obj"), jac_node=node.target)
+        )
+
+        if node.right and hasattr(node.right.gen, "es_ast"):
+            # The right side is already processed (could be a call, etc.)
+            # Check if it's a Name that needs to become a property access
+            if isinstance(node.right, uni.Name):
+                prop = self.sync_loc(
+                    es.Identifier(name=node.right.sym_name), jac_node=node.right
+                )
+                member_expr = self.sync_loc(
+                    es.MemberExpression(object=obj, property=prop, computed=False),
+                    jac_node=node,
+                )
+                node.gen.es_ast = member_expr
+            elif isinstance(node.right, uni.IndexSlice):
+                # Handle index/slice operations
+                slice_info = node.right.gen.es_ast
+                if isinstance(slice_info, dict):
+                    if slice_info.get("type") == "slice":
+                        # Slice operation - convert to .slice() call
+                        start = slice_info.get("start") or self.sync_loc(
+                            es.Literal(value=0), jac_node=node
+                        )
+                        stop = slice_info.get("stop")
+                        args: list[es.Expression] = [start]
+                        if stop is not None:
+                            args.append(stop)
+                        slice_call = self.sync_loc(
+                            es.CallExpression(
+                                callee=self.sync_loc(
+                                    es.MemberExpression(
+                                        object=obj,
+                                        property=self.sync_loc(
+                                            es.Identifier(name="slice"), jac_node=node
+                                        ),
+                                        computed=False,
+                                    ),
+                                    jac_node=node,
+                                ),
+                                arguments=args,
+                            ),
+                            jac_node=node,
+                        )
+                        node.gen.es_ast = slice_call
+                    elif slice_info.get("type") == "index":
+                        # Index operation
+                        idx = slice_info.get("value") or self.sync_loc(
+                            es.Literal(value=0), jac_node=node
+                        )
+                        member_expr = self.sync_loc(
+                            es.MemberExpression(
+                                object=obj, property=idx, computed=True
+                            ),
+                            jac_node=node,
+                        )
+                        node.gen.es_ast = member_expr
+                    else:
+                        node.gen.es_ast = obj
+                else:
+                    node.gen.es_ast = obj
+            else:
+                # If right is a call or other expression, it should already be processed
+                node.gen.es_ast = node.right.gen.es_ast
+
+    def exit_atom_unit(self, node: uni.AtomUnit) -> None:
+        """Process parenthesized atom."""
+        if node.value and hasattr(node.value.gen, "es_ast") and node.value.gen.es_ast:
+            node.gen.es_ast = node.value.gen.es_ast
+        else:
+            node.gen.es_ast = self.sync_loc(es.Literal(value=None), jac_node=node)
+
+    def exit_list_val(self, node: uni.ListVal) -> None:
+        """Process list literal."""
+        elements: list[Optional[Union[es.Expression, es.SpreadElement]]] = []
+        for item in node.values:
+            if hasattr(item.gen, "es_ast") and item.gen.es_ast:
+                elements.append(item.gen.es_ast)
+
+        array_expr = self.sync_loc(es.ArrayExpression(elements=elements), jac_node=node)
+        node.gen.es_ast = array_expr
+
+    def exit_set_val(self, node: uni.SetVal) -> None:
+        """Process set literal as new Set()."""
+        elements: list[Union[es.Expression, es.SpreadElement]] = []
+        for item in node.values:
+            if hasattr(item.gen, "es_ast") and item.gen.es_ast:
+                elements.append(item.gen.es_ast)
+
+        # Create new Set([...])
+        set_expr = self.sync_loc(
+            es.NewExpression(
+                callee=self.sync_loc(es.Identifier(name="Set"), jac_node=node),
+                arguments=[
+                    self.sync_loc(es.ArrayExpression(elements=elements), jac_node=node)
+                ],
+            ),
+            jac_node=node,
+        )
+        node.gen.es_ast = set_expr
+
+    def exit_tuple_val(self, node: uni.TupleVal) -> None:
+        """Process tuple as array."""
+        elements: list[Optional[Union[es.Expression, es.SpreadElement]]] = []
+        for item in node.values:
+            if hasattr(item.gen, "es_ast") and item.gen.es_ast:
+                elements.append(item.gen.es_ast)
+
+        array_expr = self.sync_loc(es.ArrayExpression(elements=elements), jac_node=node)
+        node.gen.es_ast = array_expr
+
+    def exit_dict_val(self, node: uni.DictVal) -> None:
+        """Process dictionary literal."""
+        properties: list[Union[es.Property, es.SpreadElement]] = []
+        for kv_pair in node.kv_pairs:
+            if not isinstance(kv_pair, uni.KVPair) or kv_pair.value is None:
+                continue
+
+            if kv_pair.key is None:
+                if hasattr(kv_pair.value.gen, "es_ast") and kv_pair.value.gen.es_ast:
+                    properties.append(
+                        self.sync_loc(
+                            es.SpreadElement(argument=kv_pair.value.gen.es_ast),
+                            jac_node=kv_pair.value,
+                        )
+                    )
+                continue
+
+            key = (
+                kv_pair.key.gen.es_ast
+                if hasattr(kv_pair.key.gen, "es_ast")
+                else self.sync_loc(es.Literal(value="key"), jac_node=kv_pair.key)
+            )
+            value = (
+                kv_pair.value.gen.es_ast
+                if hasattr(kv_pair.value.gen, "es_ast")
+                else self.sync_loc(es.Literal(value=None), jac_node=kv_pair.value)
+            )
+
+            prop = self.sync_loc(
+                es.Property(key=key, value=value, kind="init"), jac_node=kv_pair
+            )
+            properties.append(prop)
+
+        obj_expr = self.sync_loc(
+            es.ObjectExpression(properties=properties), jac_node=node
+        )
+        node.gen.es_ast = obj_expr
+
+    def exit_k_v_pair(self, node: uni.KVPair) -> None:
+        """Process key-value pair."""
+        # Handled in dict_val
+        pass
+
+    def exit_inner_compr(self, node: uni.InnerCompr) -> None:
+        """Process list comprehension."""
+        # List comprehensions need to be converted to functional style
+        # [x for x in list] -> list.map(x => x)
+        # This is a simplified version
+        node.gen.es_ast = self.sync_loc(es.ArrayExpression(elements=[]), jac_node=node)
+
+    # Literals and Atoms
+    # ==================
+
+    def exit_bool(self, node: uni.Bool) -> None:
+        """Process boolean literal."""
+        value = node.value.lower() == "true"
+        raw_value = "true" if value else "false"
+        bool_lit = self.sync_loc(es.Literal(value=value, raw=raw_value), jac_node=node)
+        node.gen.es_ast = bool_lit
+
+    def exit_int(self, node: uni.Int) -> None:
+        """Process integer literal."""
+        # Use base 0 to auto-detect binary (0b), octal (0o), hex (0x), or decimal
+        int_lit = self.sync_loc(
+            es.Literal(value=int(node.value, 0), raw=node.value), jac_node=node
+        )
+        node.gen.es_ast = int_lit
+
+    def exit_float(self, node: uni.Float) -> None:
+        """Process float literal."""
+        float_lit = self.sync_loc(
+            es.Literal(value=float(node.value), raw=node.value), jac_node=node
+        )
+        node.gen.es_ast = float_lit
+
+    def exit_multi_string(self, node: uni.MultiString) -> None:
+        """Process multi-string literal."""
+        # MultiString can contain multiple string parts (for concatenation)
+        # For now, concatenate them into a single string
+        if not node.strings:
+            null_lit = self.sync_loc(es.Literal(value="", raw='""'), jac_node=node)
+            node.gen.es_ast = null_lit
+            return
+
+        # If single string, just use it
+        if len(node.strings) == 1:
+            string_node = node.strings[0]
+            if hasattr(string_node.gen, "es_ast") and string_node.gen.es_ast:
+                node.gen.es_ast = string_node.gen.es_ast
+            else:
+                # Fallback: process the string directly (String only, not FString)
+                if isinstance(string_node, uni.String):
+                    value = string_node.value
+                    if value.startswith(('"""', "'''")):
+                        value = value[3:-3]
+                    elif value.startswith(('"', "'")):
+                        value = value[1:-1]
+                    str_lit = self.sync_loc(
+                        es.Literal(value=value, raw=string_node.value),
+                        jac_node=string_node,
+                    )
+                    node.gen.es_ast = str_lit
+                else:
+                    # FString should have been processed already
+                    node.gen.es_ast = self.sync_loc(es.Literal(value=""), jac_node=node)
+            return
+
+        # Multiple strings - create a concatenation expression
+        parts = []
+        for string_node in node.strings:
+            if hasattr(string_node.gen, "es_ast") and string_node.gen.es_ast:
+                parts.append(string_node.gen.es_ast)
+            elif isinstance(string_node, uni.String):
+                # Fallback for String nodes only
+                value = string_node.value
+                if value.startswith(('"""', "'''")):
+                    value = value[3:-3]
+                elif value.startswith(('"', "'")):
+                    value = value[1:-1]
+                raw_val = (
+                    json.dumps(value) if isinstance(value, str) else string_node.value
+                )
+                str_lit = self.sync_loc(
+                    es.Literal(value=value, raw=raw_val), jac_node=string_node
+                )
+                parts.append(str_lit)
+            # Skip FString nodes that haven't been processed
+
+        if not parts:
+            node.gen.es_ast = self.sync_loc(es.Literal(value=""), jac_node=node)
+            return
+
+        # Create binary expression for concatenation
+        result = parts[0]
+        for part in parts[1:]:
+            result = self.sync_loc(
+                es.BinaryExpression(operator="+", left=result, right=part),
+                jac_node=node,
+            )
+        node.gen.es_ast = result
+
+    def exit_string(self, node: uni.String) -> None:
+        """Process string literal."""
+        # Remove quotes from the value
+        value = node.value
+        if value.startswith(('"""', "'''")):
+            value = value[3:-3]
+        elif value.startswith(('"', "'")):
+            value = value[1:-1]
+
+        raw_value = node.value
+        if isinstance(value, str):
+            raw_value = json.dumps(value)
+
+        str_lit = self.sync_loc(es.Literal(value=value, raw=raw_value), jac_node=node)
+        node.gen.es_ast = str_lit
+
+    def exit_f_string(self, node: uni.FString) -> None:
+        """Process f-string literal as template literal."""
+        # F-strings need to be converted to template literals (backtick strings) in JS
+        # f"Hello {name}" -> `Hello ${name}`
+
+        # For now, convert to concatenation of strings and expressions
+        # This is a simplified version - proper template literals would be better
+        parts: list[es.Expression] = []
+
+        for part in node.parts:
+            if hasattr(part.gen, "es_ast") and part.gen.es_ast:
+                expr = part.gen.es_ast
+                if isinstance(expr, es.ExpressionStatement):
+                    expr = expr.expression
+                parts.append(expr)
+
+        if not parts:
+            # Empty f-string
+            node.gen.es_ast = self.sync_loc(es.Literal(value=""), jac_node=node)
+        elif len(parts) == 1:
+            # Single part
+            node.gen.es_ast = parts[0]
+        else:
+            # Multiple parts - concatenate with +
+            result = parts[0]
+            for part in parts[1:]:
+                result = self.sync_loc(
+                    es.BinaryExpression(operator="+", left=result, right=part),
+                    jac_node=node,
+                )
+            node.gen.es_ast = result
+
+    def exit_if_else_expr(self, node: uni.IfElseExpr) -> None:
+        """Process ternary expression."""
+        test = (
+            node.condition.gen.es_ast
+            if hasattr(node.condition.gen, "es_ast")
+            else self.sync_loc(es.Identifier(name="condition"), jac_node=node.condition)
+        )
+        consequent = (
+            node.value.gen.es_ast
+            if hasattr(node.value.gen, "es_ast")
+            else self.sync_loc(es.Identifier(name="value"), jac_node=node.value)
+        )
+        alternate = (
+            node.else_value.gen.es_ast
+            if hasattr(node.else_value.gen, "es_ast")
+            else self.sync_loc(
+                es.Identifier(name="alternate"), jac_node=node.else_value
+            )
+        )
+        cond_expr = self.sync_loc(
+            es.ConditionalExpression(
+                test=test, consequent=consequent, alternate=alternate
+            ),
+            jac_node=node,
+        )
+        node.gen.es_ast = cond_expr
+
+    def exit_await_expr(self, node: uni.AwaitExpr) -> None:
+        """Process await expression."""
+        argument = (
+            node.target.gen.es_ast
+            if hasattr(node.target.gen, "es_ast")
+            else self.sync_loc(es.Identifier(name="undefined"), jac_node=node.target)
+        )
+        await_expr = self.sync_loc(es.AwaitExpression(argument=argument), jac_node=node)
+        node.gen.es_ast = await_expr
+
+    def exit_null(self, node: uni.Null) -> None:
+        """Process null/None literal."""
+        null_lit = self.sync_loc(es.Literal(value=None, raw="null"), jac_node=node)
+        node.gen.es_ast = null_lit
+
+    def exit_name(self, node: uni.Name) -> None:
+        """Process name/identifier."""
+        # Map Python/Jac names to JS equivalents
+        name_map = {
+            "None": "null",
+            "True": "true",
+            "False": "false",
+            "self": "this",
+        }
+
+        name = name_map.get(node.sym_name, node.sym_name)
+        identifier = self.sync_loc(es.Identifier(name=name), jac_node=node)
+        node.gen.es_ast = identifier
+
+    # Special Statements
+    # ==================
+
+    def exit_global_vars(self, node: uni.GlobalVars) -> None:
+        """Process global variables."""
+        statements: list[es.Statement] = []
+        for assignment in node.assignments:
+            if hasattr(assignment.gen, "es_ast") and assignment.gen.es_ast:
+                stmt = assignment.gen.es_ast
+                if (
+                    isinstance(stmt, es.VariableDeclaration)
+                    and node.is_frozen
+                    and stmt.kind != "const"
+                ):
+                    stmt.kind = "const"
+                statements.append(stmt)
+        node.gen.es_ast = statements
+
+    def exit_non_local_vars(self, node: uni.NonLocalVars) -> None:
+        """Process non-local variables."""
+        # Non-local doesn't have direct equivalent in ES
+        node.gen.es_ast = []
+
+    def exit_module_code(self, node: uni.ModuleCode) -> None:
+        """Process module code (with entry block)."""
+        # Generate the body statements directly
+        body_stmts: list[es.Statement] = []
+        if node.body:
+            for stmt in node.body:
+                if hasattr(stmt.gen, "es_ast") and stmt.gen.es_ast:
+                    if isinstance(stmt.gen.es_ast, list):
+                        body_stmts.extend(stmt.gen.es_ast)
+                    else:
+                        body_stmts.append(stmt.gen.es_ast)
+
+        # Module code is executed at module level, so just output the statements
+        node.gen.es_ast = body_stmts
+
+    def exit_test(self, node: uni.Test) -> None:
+        """Process test as a function."""
+        # Convert test to a regular function
+        params: list[es.Pattern] = []
+
+        body_stmts: list[es.Statement] = []
+        if node.body:
+            for stmt in node.body:
+                if hasattr(stmt.gen, "es_ast") and stmt.gen.es_ast:
+                    if isinstance(stmt.gen.es_ast, list):
+                        body_stmts.extend(stmt.gen.es_ast)
+                    else:
+                        body_stmts.append(stmt.gen.es_ast)
+
+        body_stmts = self._prepend_hoisted(node, body_stmts)
+        block = self.sync_loc(es.BlockStatement(body=body_stmts), jac_node=node)
+
+        func_id = self.sync_loc(
+            es.Identifier(name=node.name.sym_name), jac_node=node.name
+        )
+
+        func_decl = self.sync_loc(
+            es.FunctionDeclaration(id=func_id, params=params, body=block),
+            jac_node=node,
+        )
+        node.gen.es_ast = func_decl
+
+    # Type and other nodes
+    # ====================
+
+    def exit_token(self, node: uni.Token) -> None:
+        """Process token."""
+        # Tokens are generally not directly converted
+        pass
+
+    def exit_semi(self, node: uni.Semi) -> None:
+        """Process semicolon."""
+        # Semicolons are handled automatically
+        pass
+
+    # Client Element Handling
+    # =======================
+
+    def _prepare_client_artifacts(self) -> None:
+        """Collect client metadata and pre-generate JS for modules."""
+        from jaclang.compiler.codeinfo import ClientManifest
+
+        for module in self._iter_modules(self.ir_in):
+            artifacts = self._collect_client_metadata(module)
+
+            # Populate the typed ClientManifest on module.gen
+            module.gen.client_manifest = ClientManifest(
+                exports=artifacts["exports"],
+                globals=artifacts["globals"],
+                params=artifacts["params"],
+                globals_values=artifacts["globals_values"],
+                has_client=artifacts["has_client"],
+            )
+
+    def _collect_client_metadata(self, module: uni.Module) -> dict[str, Any]:
+        """Collect client metadata from a module."""
+        exports: set[str] = set()
+        globals_set: set[str] = set()
+        params: dict[str, list[str]] = {}
+        globals_values: dict[str, Any] = {}
+        has_client = False
+
+        for node in self._walk_nodes(module):
+            if not getattr(node, "is_client_decl", False):
+                continue
+            has_client = True
+            if isinstance(node, uni.Ability) and not node.is_method:
+                name = node.name_ref.sym_name
+                exports.add(name)
+                if isinstance(node.signature, uni.FuncSignature):
+                    params[name] = [
+                        param.name.sym_name
+                        for param in node.signature.params
+                        if hasattr(param, "name")
+                    ]
+                else:
+                    params[name] = []
+            elif isinstance(node, uni.Archetype):
+                exports.add(node.name.sym_name)
+            elif isinstance(node, uni.GlobalVars):
+                for assignment in node.assignments:
+                    for target in assignment.target:
+                        sym_name = getattr(target, "sym_name", None)
+                        if isinstance(sym_name, str):
+                            globals_set.add(sym_name)
+                            if assignment.value:
+                                lit_val = self._literal_value(assignment.value)
+                                if lit_val is not None:
+                                    globals_values[sym_name] = lit_val
+
+        return {
+            "exports": sorted(exports),
+            "globals": sorted(globals_set),
+            "params": dict(sorted(params.items())),
+            "globals_values": globals_values,
+            "has_client": has_client,
+        }
+
+    def _iter_modules(self, module: uni.Module) -> Iterable[uni.Module]:
+        """Iterate over a module and its nested modules."""
+        yield module
+        for child in getattr(module, "impl_mod", []):
+            if isinstance(child, uni.Module):
+                yield from self._iter_modules(child)
+        for child in getattr(module, "test_mod", []):
+            if isinstance(child, uni.Module):
+                yield from self._iter_modules(child)
+
+    def _walk_nodes(self, node: uni.UniNode) -> Iterable[uni.UniNode]:
+        """Walk all nodes in the tree."""
+        yield node
+        for child in getattr(node, "kid", []):
+            if child:
+                yield from self._walk_nodes(child)
+
+    def _literal_value(self, expr: uni.UniNode | None) -> object | None:
+        """Extract literal value from an expression."""
+        if expr is None:
+            return None
+        literal_attr = "lit_value"
+        if hasattr(expr, literal_attr):
+            return getattr(expr, literal_attr)
+        if isinstance(expr, uni.MultiString):
+            parts: list[str] = []
+            for segment in expr.strings:
+                if hasattr(segment, literal_attr):
+                    parts.append(getattr(segment, literal_attr))
+                else:
+                    return None
+            return "".join(parts)
+        if isinstance(expr, uni.ListVal):
+            values = [self._literal_value(item) for item in expr.values]
+            if all(val is not None for val in values):
+                return values
+        if isinstance(expr, uni.TupleVal):
+            values = [self._literal_value(item) for item in expr.values]
+            if all(val is not None for val in values):
+                return tuple(values)
+        if isinstance(expr, uni.DictVal):
+            items: dict[str, Any] = {}
+            for pair in expr.kv_pairs:
+                if isinstance(pair, uni.KVPair) and pair.key:
+                    key_val = self._literal_value(pair.key)
+                    val_val = self._literal_value(pair.value)
+                    if isinstance(key_val, str) and val_val is not None:
+                        items[key_val] = val_val
+            if items:
+                return items
+        return None
+
+    def _generate_module_js(self, module: uni.Module) -> str:
+        """Generate JavaScript code for the supplied module."""
+        from jaclang.compiler.passes.ecmascript.es_unparse import es_to_js
+
+        es_ast = getattr(module.gen, "es_ast", None)
+        if es_ast:
+            return es_to_js(es_ast)
+        return ""
diff --git a/jac/jaclang/compiler/passes/ecmascript/estree.py b/jac/jaclang/compiler/passes/ecmascript/estree.py
new file mode 100644
index 0000000000..3f17996243
--- /dev/null
+++ b/jac/jaclang/compiler/passes/ecmascript/estree.py
@@ -0,0 +1,972 @@
+"""ESTree AST Node Definitions for ECMAScript.
+
+This module provides a complete implementation of the ESTree specification,
+which defines the standard AST format for JavaScript and ECMAScript.
+
+The ESTree specification represents ECMAScript programs as abstract syntax trees
+that are language-agnostic and can be used for various tools like parsers,
+transpilers, and code analysis tools.
+
+Reference: https://github.com/estree/estree
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Literal as TypingLiteral, Optional, TypeAlias, Union
+
+
+# Literal type aliases for repeated enumerations
+SourceType: TypeAlias = TypingLiteral["script", "module"]  # noqa: F821
+VariableDeclarationKind: TypeAlias = TypingLiteral["var", "let", "const"]  # noqa: F821
+PropertyKind: TypeAlias = TypingLiteral["init", "get", "set"]  # noqa: F821
+MethodDefinitionKind: TypeAlias = TypingLiteral[
+    "constructor", "method", "get", "set"  # noqa: F821
+]
+
+
+# Base Node Types
+# ================
+
+
+@dataclass
+class SourceLocation:
+    """Source location information for a node."""
+
+    source: Optional[str] = None
+    start: Optional["Position"] = None
+    end: Optional["Position"] = None
+
+
+@dataclass
+class Position:
+    """Position in source code."""
+
+    line: int = 0
+    column: int = 0
+
+
+@dataclass
+class Node:
+    """Base class for all ESTree nodes."""
+
+    type: str
+    loc: Optional[SourceLocation] = field(default=None)
+
+
+# Identifier and Literals
+# =======================
+
+
+@dataclass
+class Identifier(Node):
+    """Identifier node."""
+
+    name: str = ""
+    type: TypingLiteral["Identifier"] = field(default="Identifier", init=False)
+
+
+@dataclass
+class PrivateIdentifier(Node):
+    """Private identifier for class members (ES2022)."""
+
+    name: str = ""
+    type: TypingLiteral["PrivateIdentifier"] = field(
+        default="PrivateIdentifier", init=False
+    )
+
+
+@dataclass
+class Literal(Node):
+    """Literal value node (supports BigInt in ES2020)."""
+
+    value: Union[str, bool, None, int, float] = None
+    raw: Optional[str] = None
+    bigint: Optional[str] = None  # ES2020: BigInt represented as string
+    type: TypingLiteral["Literal"] = field(default="Literal", init=False)
+
+
+@dataclass
+class RegExpLiteral(Literal):
+    """Regular expression literal."""
+
+    regex: dict[str, str] = field(default_factory=dict)  # {pattern: str, flags: str}
+    type: TypingLiteral["Literal"] = field(default="Literal", init=False)
+
+
+# Program and Statements
+# ======================
+
+
+@dataclass
+class Program(Node):
+    """Root node of an ESTree."""
+
+    body: list[Union["Statement", "ModuleDeclaration"]] = field(default_factory=list)
+    sourceType: SourceType = "script"  # noqa: N815
+    type: TypingLiteral["Program"] = field(default="Program", init=False)
+
+
+@dataclass
+class ExpressionStatement(Node):
+    """Expression statement."""
+
+    expression: Optional["Expression"] = None
+    type: TypingLiteral["ExpressionStatement"] = field(
+        default="ExpressionStatement", init=False
+    )
+
+
+@dataclass
+class Directive(ExpressionStatement):
+    """Directive (e.g., 'use strict') - ES5."""
+
+    directive: str = ""
+    type: TypingLiteral["ExpressionStatement"] = field(
+        default="ExpressionStatement", init=False
+    )
+
+
+@dataclass
+class BlockStatement(Node):
+    """Block statement."""
+
+    body: list["Statement"] = field(default_factory=list)
+    type: TypingLiteral["BlockStatement"] = field(default="BlockStatement", init=False)
+
+
+@dataclass
+class EmptyStatement(Node):
+    """Empty statement (;)."""
+
+    type: TypingLiteral["EmptyStatement"] = field(default="EmptyStatement", init=False)
+
+
+@dataclass
+class DebuggerStatement(Node):
+    """Debugger statement."""
+
+    type: TypingLiteral["DebuggerStatement"] = field(
+        default="DebuggerStatement", init=False
+    )
+
+
+@dataclass
+class WithStatement(Node):
+    """With statement."""
+
+    object: Optional["Expression"] = None
+    body: Optional["Statement"] = None
+    type: TypingLiteral["WithStatement"] = field(default="WithStatement", init=False)
+
+
+@dataclass
+class ReturnStatement(Node):
+    """Return statement."""
+
+    argument: Optional["Expression"] = None
+    type: TypingLiteral["ReturnStatement"] = field(
+        default="ReturnStatement", init=False
+    )
+
+
+@dataclass
+class LabeledStatement(Node):
+    """Labeled statement."""
+
+    label: Optional[Identifier] = None
+    body: Optional["Statement"] = None
+    type: TypingLiteral["LabeledStatement"] = field(
+        default="LabeledStatement", init=False
+    )
+
+
+@dataclass
+class BreakStatement(Node):
+    """Break statement."""
+
+    label: Optional[Identifier] = None
+    type: TypingLiteral["BreakStatement"] = field(default="BreakStatement", init=False)
+
+
+@dataclass
+class ContinueStatement(Node):
+    """Continue statement."""
+
+    label: Optional[Identifier] = None
+    type: TypingLiteral["ContinueStatement"] = field(
+        default="ContinueStatement", init=False
+    )
+
+
+@dataclass
+class IfStatement(Node):
+    """If statement."""
+
+    test: Optional["Expression"] = None
+    consequent: Optional["Statement"] = None
+    alternate: Optional["Statement"] = None
+    type: TypingLiteral["IfStatement"] = field(default="IfStatement", init=False)
+
+
+@dataclass
+class SwitchStatement(Node):
+    """Switch statement."""
+
+    discriminant: Optional["Expression"] = None
+    cases: list["SwitchCase"] = field(default_factory=list)
+    type: TypingLiteral["SwitchStatement"] = field(
+        default="SwitchStatement", init=False
+    )
+
+
+@dataclass
+class SwitchCase(Node):
+    """Switch case clause."""
+
+    test: Optional["Expression"] = None  # null for default case
+    consequent: list["Statement"] = field(default_factory=list)
+    type: TypingLiteral["SwitchCase"] = field(default="SwitchCase", init=False)
+
+
+@dataclass
+class ThrowStatement(Node):
+    """Throw statement."""
+
+    argument: Optional["Expression"] = None
+    type: TypingLiteral["ThrowStatement"] = field(default="ThrowStatement", init=False)
+
+
+@dataclass
+class TryStatement(Node):
+    """Try statement."""
+
+    block: Optional[BlockStatement] = None
+    handler: Optional["CatchClause"] = None
+    finalizer: Optional[BlockStatement] = None
+    type: TypingLiteral["TryStatement"] = field(default="TryStatement", init=False)
+
+
+@dataclass
+class CatchClause(Node):
+    """Catch clause."""
+
+    param: Optional["Pattern"] = None
+    body: Optional[BlockStatement] = None
+    type: TypingLiteral["CatchClause"] = field(default="CatchClause", init=False)
+
+
+@dataclass
+class WhileStatement(Node):
+    """While statement."""
+
+    test: Optional["Expression"] = None
+    body: Optional["Statement"] = None
+    type: TypingLiteral["WhileStatement"] = field(default="WhileStatement", init=False)
+
+
+@dataclass
+class DoWhileStatement(Node):
+    """Do-while statement."""
+
+    body: Optional["Statement"] = None
+    test: Optional["Expression"] = None
+    type: TypingLiteral["DoWhileStatement"] = field(
+        default="DoWhileStatement", init=False
+    )
+
+
+@dataclass
+class ForStatement(Node):
+    """For statement."""
+
+    init: Optional[Union["VariableDeclaration", "Expression"]] = None
+    test: Optional["Expression"] = None
+    update: Optional["Expression"] = None
+    body: Optional["Statement"] = None
+    type: TypingLiteral["ForStatement"] = field(default="ForStatement", init=False)
+
+
+@dataclass
+class ForInStatement(Node):
+    """For-in statement."""
+
+    left: Optional[Union["VariableDeclaration", "Pattern"]] = None
+    right: Optional["Expression"] = None
+    body: Optional["Statement"] = None
+    type: TypingLiteral["ForInStatement"] = field(default="ForInStatement", init=False)
+
+
+@dataclass
+class ForOfStatement(Node):
+    """For-of statement (ES6)."""
+
+    left: Optional[Union["VariableDeclaration", "Pattern"]] = None
+    right: Optional["Expression"] = None
+    body: Optional["Statement"] = None
+    await_: bool = False
+    type: TypingLiteral["ForOfStatement"] = field(default="ForOfStatement", init=False)
+
+
+# Declarations
+# ============
+
+
+@dataclass
+class FunctionDeclaration(Node):
+    """Function declaration."""
+
+    id: Optional[Identifier] = None
+    params: list["Pattern"] = field(default_factory=list)
+    body: Optional[BlockStatement] = None
+    generator: bool = False
+    async_: bool = False
+    type: TypingLiteral["FunctionDeclaration"] = field(
+        default="FunctionDeclaration", init=False
+    )
+
+
+@dataclass
+class VariableDeclaration(Node):
+    """Variable declaration."""
+
+    declarations: list["VariableDeclarator"] = field(default_factory=list)
+    kind: VariableDeclarationKind = "var"
+    type: TypingLiteral["VariableDeclaration"] = field(
+        default="VariableDeclaration", init=False
+    )
+
+
+@dataclass
+class VariableDeclarator(Node):
+    """Variable declarator."""
+
+    id: Optional["Pattern"] = None
+    init: Optional["Expression"] = None
+    type: TypingLiteral["VariableDeclarator"] = field(
+        default="VariableDeclarator", init=False
+    )
+
+
+# Expressions
+# ===========
+
+
+@dataclass
+class ThisExpression(Node):
+    """This expression."""
+
+    type: TypingLiteral["ThisExpression"] = field(default="ThisExpression", init=False)
+
+
+@dataclass
+class ArrayExpression(Node):
+    """Array expression."""
+
+    elements: list[Optional[Union["Expression", "SpreadElement"]]] = field(
+        default_factory=list
+    )
+    type: TypingLiteral["ArrayExpression"] = field(
+        default="ArrayExpression", init=False
+    )
+
+
+@dataclass
+class ObjectExpression(Node):
+    """Object expression."""
+
+    properties: list[Union["Property", "SpreadElement"]] = field(default_factory=list)
+    type: TypingLiteral["ObjectExpression"] = field(
+        default="ObjectExpression", init=False
+    )
+
+
+@dataclass
+class Property(Node):
+    """Object property."""
+
+    key: Optional[Union["Expression", Identifier, Literal]] = None
+    value: Optional["Expression"] = None
+    kind: PropertyKind = "init"
+    method: bool = False
+    shorthand: bool = False
+    computed: bool = False
+    type: TypingLiteral["Property"] = field(default="Property", init=False)
+
+
+@dataclass
+class FunctionExpression(Node):
+    """Function expression."""
+
+    id: Optional[Identifier] = None
+    params: list["Pattern"] = field(default_factory=list)
+    body: Optional[BlockStatement] = None
+    generator: bool = False
+    async_: bool = False
+    type: TypingLiteral["FunctionExpression"] = field(
+        default="FunctionExpression", init=False
+    )
+
+
+@dataclass
+class ArrowFunctionExpression(Node):
+    """Arrow function expression (ES6)."""
+
+    params: list["Pattern"] = field(default_factory=list)
+    body: Optional[Union[BlockStatement, "Expression"]] = None
+    expression: bool = False
+    async_: bool = False
+    type: TypingLiteral["ArrowFunctionExpression"] = field(
+        default="ArrowFunctionExpression", init=False
+    )
+
+
+@dataclass
+class UnaryExpression(Node):
+    """Unary expression."""
+
+    operator: str = ""  # "-", "+", "!", "~", "typeof", "void", "delete"
+    prefix: bool = True
+    argument: Optional["Expression"] = None
+    type: TypingLiteral["UnaryExpression"] = field(
+        default="UnaryExpression", init=False
+    )
+
+
+@dataclass
+class UpdateExpression(Node):
+    """Update expression."""
+
+    # Allowed operators: ++, --
+    operator: str = "++"
+    argument: Optional["Expression"] = None
+    prefix: bool = True
+    type: TypingLiteral["UpdateExpression"] = field(
+        default="UpdateExpression", init=False
+    )
+
+
+@dataclass
+class BinaryExpression(Node):
+    """Binary expression."""
+
+    # Supported operators align with ESTree spec:
+    # == != === !== < <= > >= << >> >>> + - * / % | ^ & in instanceof
+    operator: str = ""
+    left: Optional["Expression"] = None
+    right: Optional["Expression"] = None
+    type: TypingLiteral["BinaryExpression"] = field(
+        default="BinaryExpression", init=False
+    )
+
+
+@dataclass
+class AssignmentExpression(Node):
+    """Assignment expression."""
+
+    # Supported operators: =, +=, -=, *=, /=, %=, <<=, >>=, >>>=, |=, ^=, &=
+    operator: str = "="
+    left: Optional[Union["Pattern", "Expression"]] = None
+    right: Optional["Expression"] = None
+    type: TypingLiteral["AssignmentExpression"] = field(
+        default="AssignmentExpression", init=False
+    )
+
+
+@dataclass
+class LogicalExpression(Node):
+    """Logical expression."""
+
+    # Supported operators: ||, &&, ??
+    operator: str = "&&"
+    left: Optional["Expression"] = None
+    right: Optional["Expression"] = None
+    type: TypingLiteral["LogicalExpression"] = field(
+        default="LogicalExpression", init=False
+    )
+
+
+@dataclass
+class MemberExpression(Node):
+    """Member expression."""
+
+    object: Optional[Union["Expression", "Super"]] = None
+    property: Optional["Expression"] = None
+    computed: bool = False
+    optional: bool = False
+    type: TypingLiteral["MemberExpression"] = field(
+        default="MemberExpression", init=False
+    )
+
+
+@dataclass
+class ConditionalExpression(Node):
+    """Conditional (ternary) expression."""
+
+    test: Optional["Expression"] = None
+    consequent: Optional["Expression"] = None
+    alternate: Optional["Expression"] = None
+    type: TypingLiteral["ConditionalExpression"] = field(
+        default="ConditionalExpression", init=False
+    )
+
+
+@dataclass
+class CallExpression(Node):
+    """Call expression."""
+
+    callee: Optional[Union["Expression", "Super"]] = None
+    arguments: list[Union["Expression", "SpreadElement"]] = field(default_factory=list)
+    optional: bool = False
+    type: TypingLiteral["CallExpression"] = field(default="CallExpression", init=False)
+
+
+@dataclass
+class ChainExpression(Node):
+    """Optional chaining expression (ES2020)."""
+
+    expression: Optional[Union[CallExpression, MemberExpression]] = None
+    type: TypingLiteral["ChainExpression"] = field(
+        default="ChainExpression", init=False
+    )
+
+
+@dataclass
+class NewExpression(Node):
+    """New expression."""
+
+    callee: Optional["Expression"] = None
+    arguments: list[Union["Expression", "SpreadElement"]] = field(default_factory=list)
+    type: TypingLiteral["NewExpression"] = field(default="NewExpression", init=False)
+
+
+@dataclass
+class SequenceExpression(Node):
+    """Sequence expression."""
+
+    expressions: list["Expression"] = field(default_factory=list)
+    type: TypingLiteral["SequenceExpression"] = field(
+        default="SequenceExpression", init=False
+    )
+
+
+@dataclass
+class YieldExpression(Node):
+    """Yield expression."""
+
+    argument: Optional["Expression"] = None
+    delegate: bool = False
+    type: TypingLiteral["YieldExpression"] = field(
+        default="YieldExpression", init=False
+    )
+
+
+@dataclass
+class AwaitExpression(Node):
+    """Await expression (ES2017)."""
+
+    argument: Optional["Expression"] = None
+    type: TypingLiteral["AwaitExpression"] = field(
+        default="AwaitExpression", init=False
+    )
+
+
+@dataclass
+class TemplateLiteral(Node):
+    """Template literal (ES6)."""
+
+    quasis: list["TemplateElement"] = field(default_factory=list)
+    expressions: list["Expression"] = field(default_factory=list)
+    type: TypingLiteral["TemplateLiteral"] = field(
+        default="TemplateLiteral", init=False
+    )
+
+
+@dataclass
+class TemplateElement(Node):
+    """Template element."""
+
+    tail: bool = False
+    value: dict[str, str] = field(default_factory=dict)  # {cooked: str, raw: str}
+    type: TypingLiteral["TemplateElement"] = field(
+        default="TemplateElement", init=False
+    )
+
+
+@dataclass
+class TaggedTemplateExpression(Node):
+    """Tagged template expression (ES6)."""
+
+    tag: Optional["Expression"] = None
+    quasi: Optional[TemplateLiteral] = None
+    type: TypingLiteral["TaggedTemplateExpression"] = field(
+        default="TaggedTemplateExpression", init=False
+    )
+
+
+@dataclass
+class SpreadElement(Node):
+    """Spread element (ES6)."""
+
+    argument: Optional["Expression"] = None
+    type: TypingLiteral["SpreadElement"] = field(default="SpreadElement", init=False)
+
+
+@dataclass
+class Super(Node):
+    """Super keyword."""
+
+    type: TypingLiteral["Super"] = field(default="Super", init=False)
+
+
+@dataclass
+class MetaProperty(Node):
+    """Meta property (e.g., new.target)."""
+
+    meta: Optional[Identifier] = None
+    property: Optional[Identifier] = None
+    type: TypingLiteral["MetaProperty"] = field(default="MetaProperty", init=False)
+
+
+# Patterns (ES6)
+# ==============
+
+
+@dataclass
+class AssignmentPattern(Node):
+    """Assignment pattern (default parameters)."""
+
+    left: Optional["Pattern"] = None
+    right: Optional["Expression"] = None
+    type: TypingLiteral["AssignmentPattern"] = field(
+        default="AssignmentPattern", init=False
+    )
+
+
+@dataclass
+class ArrayPattern(Node):
+    """Array destructuring pattern."""
+
+    elements: list[Optional["Pattern"]] = field(default_factory=list)
+    type: TypingLiteral["ArrayPattern"] = field(default="ArrayPattern", init=False)
+
+
+@dataclass
+class ObjectPattern(Node):
+    """Object destructuring pattern."""
+
+    properties: list[Union["AssignmentProperty", "RestElement"]] = field(
+        default_factory=list
+    )
+    type: TypingLiteral["ObjectPattern"] = field(default="ObjectPattern", init=False)
+
+
+@dataclass
+class AssignmentProperty(Node):
+    """Assignment property in object pattern."""
+
+    key: Optional[Union["Expression", Identifier, Literal]] = None
+    value: Optional["Pattern"] = None
+    kind: PropertyKind = "init"
+    method: bool = False
+    shorthand: bool = False
+    computed: bool = False
+    type: TypingLiteral["Property"] = field(default="Property", init=False)
+
+
+@dataclass
+class RestElement(Node):
+    """Rest element."""
+
+    argument: Optional["Pattern"] = None
+    type: TypingLiteral["RestElement"] = field(default="RestElement", init=False)
+
+
+# Classes (ES6)
+# =============
+
+
+@dataclass
+class ClassDeclaration(Node):
+    """Class declaration."""
+
+    id: Optional[Identifier] = None
+    superClass: Optional["Expression"] = None  # noqa: N815
+    body: Optional["ClassBody"] = None
+    type: TypingLiteral["ClassDeclaration"] = field(
+        default="ClassDeclaration", init=False
+    )
+
+
+@dataclass
+class ClassExpression(Node):
+    """Class expression."""
+
+    id: Optional[Identifier] = None
+    superClass: Optional["Expression"] = None  # noqa: N815
+    body: Optional["ClassBody"] = None
+    type: TypingLiteral["ClassExpression"] = field(
+        default="ClassExpression", init=False
+    )
+
+
+@dataclass
+class ClassBody(Node):
+    """Class body (ES2022: supports methods, properties, and static blocks)."""
+
+    body: list[Union["MethodDefinition", "PropertyDefinition", "StaticBlock"]] = field(
+        default_factory=list
+    )
+    type: TypingLiteral["ClassBody"] = field(default="ClassBody", init=False)
+
+
+@dataclass
+class MethodDefinition(Node):
+    """Method definition (ES2022: supports private identifiers)."""
+
+    key: Optional[Union["Expression", Identifier, "PrivateIdentifier"]] = None
+    value: Optional[FunctionExpression] = None
+    kind: MethodDefinitionKind = "method"
+    computed: bool = False
+    static: bool = False
+    type: TypingLiteral["MethodDefinition"] = field(
+        default="MethodDefinition", init=False
+    )
+
+
+@dataclass
+class PropertyDefinition(Node):
+    """Class field definition (ES2022)."""
+
+    key: Optional[Union["Expression", Identifier, "PrivateIdentifier"]] = None
+    value: Optional["Expression"] = None
+    computed: bool = False
+    static: bool = False
+    type: TypingLiteral["PropertyDefinition"] = field(
+        default="PropertyDefinition", init=False
+    )
+
+
+@dataclass
+class StaticBlock(Node):
+    """Static initialization block (ES2022)."""
+
+    body: list["Statement"] = field(default_factory=list)
+    type: TypingLiteral["StaticBlock"] = field(default="StaticBlock", init=False)
+
+
+# Modules (ES6)
+# =============
+
+
+@dataclass
+class ImportDeclaration(Node):
+    """Import declaration."""
+
+    specifiers: list[
+        Union["ImportSpecifier", "ImportDefaultSpecifier", "ImportNamespaceSpecifier"]
+    ] = field(default_factory=list)
+    source: Optional[Literal] = None
+    type: TypingLiteral["ImportDeclaration"] = field(
+        default="ImportDeclaration", init=False
+    )
+
+
+@dataclass
+class ImportExpression(Node):
+    """Dynamic import expression (ES2020)."""
+
+    source: Optional["Expression"] = None
+    type: TypingLiteral["ImportExpression"] = field(
+        default="ImportExpression", init=False
+    )
+
+
+@dataclass
+class ImportSpecifier(Node):
+    """Import specifier."""
+
+    imported: Optional[Identifier] = None
+    local: Optional[Identifier] = None
+    type: TypingLiteral["ImportSpecifier"] = field(
+        default="ImportSpecifier", init=False
+    )
+
+
+@dataclass
+class ImportDefaultSpecifier(Node):
+    """Import default specifier."""
+
+    local: Optional[Identifier] = None
+    type: TypingLiteral["ImportDefaultSpecifier"] = field(
+        default="ImportDefaultSpecifier", init=False
+    )
+
+
+@dataclass
+class ImportNamespaceSpecifier(Node):
+    """Import namespace specifier."""
+
+    local: Optional[Identifier] = None
+    type: TypingLiteral["ImportNamespaceSpecifier"] = field(
+        default="ImportNamespaceSpecifier", init=False
+    )
+
+
+@dataclass
+class ExportNamedDeclaration(Node):
+    """Export named declaration."""
+
+    declaration: Optional[Union["Declaration", "Expression"]] = None
+    specifiers: list["ExportSpecifier"] = field(default_factory=list)
+    source: Optional[Literal] = None
+    type: TypingLiteral["ExportNamedDeclaration"] = field(
+        default="ExportNamedDeclaration", init=False
+    )
+
+
+@dataclass
+class ExportSpecifier(Node):
+    """Export specifier."""
+
+    exported: Optional[Identifier] = None
+    local: Optional[Identifier] = None
+    type: TypingLiteral["ExportSpecifier"] = field(
+        default="ExportSpecifier", init=False
+    )
+
+
+@dataclass
+class ExportDefaultDeclaration(Node):
+    """Export default declaration."""
+
+    declaration: Optional[Union["Declaration", "Expression"]] = None
+    type: TypingLiteral["ExportDefaultDeclaration"] = field(
+        default="ExportDefaultDeclaration", init=False
+    )
+
+
+@dataclass
+class ExportAllDeclaration(Node):
+    """Export all declaration."""
+
+    source: Optional[Literal] = None
+    exported: Optional[Identifier] = None
+    type: TypingLiteral["ExportAllDeclaration"] = field(
+        default="ExportAllDeclaration", init=False
+    )
+
+
+# Type Aliases for Union Types
+# ============================
+
+Statement = Union[
+    ExpressionStatement,
+    BlockStatement,
+    EmptyStatement,
+    DebuggerStatement,
+    WithStatement,
+    ReturnStatement,
+    LabeledStatement,
+    BreakStatement,
+    ContinueStatement,
+    IfStatement,
+    SwitchStatement,
+    ThrowStatement,
+    TryStatement,
+    WhileStatement,
+    DoWhileStatement,
+    ForStatement,
+    ForInStatement,
+    ForOfStatement,
+    FunctionDeclaration,
+    VariableDeclaration,
+    ClassDeclaration,
+]
+
+Expression = Union[
+    Identifier,
+    Literal,
+    ThisExpression,
+    ArrayExpression,
+    ObjectExpression,
+    FunctionExpression,
+    ArrowFunctionExpression,
+    UnaryExpression,
+    UpdateExpression,
+    BinaryExpression,
+    AssignmentExpression,
+    LogicalExpression,
+    MemberExpression,
+    ConditionalExpression,
+    CallExpression,
+    ChainExpression,  # ES2020
+    NewExpression,
+    SequenceExpression,
+    YieldExpression,
+    AwaitExpression,
+    TemplateLiteral,
+    TaggedTemplateExpression,
+    ClassExpression,
+    ImportExpression,  # ES2020
+]
+
+Pattern = Union[
+    Identifier,
+    ArrayPattern,
+    ObjectPattern,
+    AssignmentPattern,
+    RestElement,
+]
+
+Declaration = Union[
+    FunctionDeclaration,
+    VariableDeclaration,
+    ClassDeclaration,
+]
+
+ModuleDeclaration = Union[
+    ImportDeclaration,
+    ExportNamedDeclaration,
+    ExportDefaultDeclaration,
+    ExportAllDeclaration,
+]
+
+
+# Utility Functions
+# =================
+
+
+def es_node_to_dict(node: Node) -> dict[str, Any]:
+    """Convert an ESTree node to a dictionary representation."""
+    result: dict[str, Any] = {"type": node.type}
+
+    for key, value in node.__dict__.items():
+        if key in ("type", "loc") or value is None:
+            continue
+        if isinstance(value, Node):
+            result[key] = es_node_to_dict(value)
+        elif isinstance(value, list):
+            result[key] = [
+                es_node_to_dict(item) if isinstance(item, Node) else item
+                for item in value
+            ]
+        else:
+            result[key] = value
+
+    if node.loc:
+        result["loc"] = {
+            "source": node.loc.source,
+            "start": (
+                {"line": node.loc.start.line, "column": node.loc.start.column}
+                if node.loc.start
+                else None
+            ),
+            "end": (
+                {"line": node.loc.end.line, "column": node.loc.end.column}
+                if node.loc.end
+                else None
+            ),
+        }
+
+    return result
diff --git a/jac/jaclang/compiler/passes/ecmascript/tests/__init__.py b/jac/jaclang/compiler/passes/ecmascript/tests/__init__.py
new file mode 100644
index 0000000000..812c41969c
--- /dev/null
+++ b/jac/jaclang/compiler/passes/ecmascript/tests/__init__.py
@@ -0,0 +1 @@
+"""Tests for ECMAScript AST generation."""
diff --git a/jac/jaclang/compiler/passes/ecmascript/tests/fixtures/advanced_language_features.jac b/jac/jaclang/compiler/passes/ecmascript/tests/fixtures/advanced_language_features.jac
new file mode 100644
index 0000000000..d18da5266b
--- /dev/null
+++ b/jac/jaclang/compiler/passes/ecmascript/tests/fixtures/advanced_language_features.jac
@@ -0,0 +1,170 @@
+"""Advanced Jac constructs combined fixture for ECMAScript generator tests."""
+
+# Lambdas and higher-order helpers
+def lambda_examples() -> dict {
+    adder = lambda a: int, b: int : a + b;
+    scaler = lambda value: int, factor: int : value * factor;
+    numbers = [1, 2, 3, 4];
+    doubled = [scaler(n, 2) for n in numbers];
+    filtered = [n for n in numbers if (keep := n % 2 == 0)];
+    return {
+        "sum": adder(2, 5),
+        "doubled": doubled,
+        "filtered": filtered
+    };
+}
+
+# Async / await usage
+async def fetch_value(value: int) -> int {
+    return value;
+}
+
+async def async_pipeline(data: list) -> dict {
+    total = 0;
+    results = [];
+    for item in data {
+        response = await fetch_value(item);
+        total += response;
+        results.append(response);
+    }
+    status = "large" if total > 10 else "small";
+    return {"total": total, "results": results, "status": status};
+}
+
+# Generators
+def generator_examples(limit: int) {
+    index = 0;
+    while index < limit {
+        yield index * 3;
+        index += 1;
+    }
+}
+
+# Spread and rest patterns
+def spread_and_rest_examples() -> dict {
+    base = [1, 2, 3];
+    extras = [4, 5];
+    combined = [*base, *extras, 6];
+
+    defaults = {"mode": "dev", "retries": 1};
+    overrides = {"retries": 3, "timeout": 30};
+    merged = {**defaults, **overrides};
+
+    def collect(label: str, *items: tuple, **options: dict) -> dict {
+        return {"label": label, "items": list(items), "options": options};
+    }
+
+    bag = collect("demo", *combined, limit=10, strict=True);
+    return {"combined": combined, "merged": merged, "bag": bag};
+}
+
+# Pattern matching / switch lowering
+def pattern_matching_examples(code: int, flag: bool) -> str {
+    match code {
+        case 200:
+            return "ok";
+
+        case 404 | 500:
+            return "error";
+
+        case _:
+            if flag {
+                return "fallback";
+            }
+            return "unknown";
+
+        }
+}
+
+# Template literals and complex expressions
+def template_literal_examples(user: str, score: int) -> str {
+    status = "pass" if score >= 60 else "fail";
+    return f"{user} scored {score} which is a {status}";
+}
+
+# Destructuring & rest patterns
+def advanced_destructuring() -> dict {
+    (first, *middle, last) = [10, 20, 30, 40, 50];
+    point = (100, 200);
+    (x, y) = point;
+    settings = {"limits": {"max": 5}};
+    limit = 0;
+    if settings is not None and "limits" in settings {
+        inner = settings["limits"];
+        if inner is not None and "max" in inner {
+            limit = inner["max"];
+        }
+    }
+    return {"first": first, "middle": middle, "last": last, "point": (x, y), "limit": limit};
+}
+
+# Optional access simulations
+def optional_access_examples(payload: dict) -> dict {
+    result = {"value": 0, "mode": "basic"};
+    if payload is not None and "config" in payload {
+        config = payload["config"];
+        if config is not None and "value" in config {
+            result["value"] = config["value"];
+        }
+        if config is not None and "mode" in config {
+            result["mode"] = config["mode"];
+        }
+    }
+    return result;
+}
+
+# Update expression stand-ins
+def update_expression_examples() -> dict {
+    counter = 0;
+    for _ in range(5) {
+        counter += 1;
+    }
+
+    index = 3;
+    index -= 1;
+    return {"counter": counter, "index": index};
+}
+
+# Do-while style loops
+def do_while_simulation(limit: int) -> int {
+    total = 0;
+    current = 0;
+    while True {
+        total += current;
+        current += 1;
+        if not (current < limit) {
+            break;
+        }
+    }
+    return total;
+}
+
+# Combined advanced report
+def build_advanced_report(values: list) -> dict {
+    lambda_data = lambda_examples();
+    spread_data = spread_and_rest_examples();
+    optional = optional_access_examples({"config": {"value": 7, "mode": "strict"}});
+    destructured = advanced_destructuring();
+
+    async def gather_async() -> dict {
+        return await async_pipeline(values);
+    }
+
+    generator_list = [];
+    for item in generator_examples(len(values)) {
+        generator_list.append(item);
+    }
+
+    return {
+        "lambda": lambda_data,
+        "spread": spread_data,
+        "optional": optional,
+        "destructured": destructured,
+        "pattern": pattern_matching_examples(404, False),
+        "template": template_literal_examples("user", 72),
+        "updates": update_expression_examples(),
+        "loop": do_while_simulation(4),
+        "generator": generator_list,
+        "async_helper": gather_async
+    };
+}
diff --git a/jac/jaclang/compiler/passes/ecmascript/tests/fixtures/client_jsx.jac b/jac/jaclang/compiler/passes/ecmascript/tests/fixtures/client_jsx.jac
new file mode 100644
index 0000000000..7a3726ddf7
--- /dev/null
+++ b/jac/jaclang/compiler/passes/ecmascript/tests/fixtures/client_jsx.jac
@@ -0,0 +1,89 @@
+"""Combined JSX fixture covering client declarations and varied JSX patterns."""
+
+cl let API_URL: str = "https://api.example.com";
+
+cl obj ButtonProps {
+    has label: str = "Hello";
+    has count: int = 0;
+}
+
+cl def component() {
+    return <div class="box">
+        <h1>Hello</h1>
+        <p>Welcome!</p>
+    </div>;
+}
+
+def server_only() {
+    return "not included";
+}
+
+with entry {
+    # Common values used across scenarios
+    let name = "World";
+    let age = 30;
+    let count = 42;
+    let props = "dummy_props";
+    let extraProps = "extra_props";
+
+    # Basic JSX shapes
+    let basic_div = <div />;
+    let basic_component = <MyComponent />;
+    let attribute_button = <button id="submit" disabled />;
+    let attr_with_expr = <div id={name} data-age={age}>User Info</div>;
+
+    # Expressions embedded in JSX
+    let greeting = <h1>{"Hello " + name + "!"}</h1>;
+    let button = <button id={name} count={count}>{"Click"}</button>;
+    let computed = <div>{count + 10}</div>;
+
+    # Nested elements and layout
+    let card = <div>
+        <h1>{"Title"}</h1>
+        <p>{"Description"}</p>
+        <button>{"Click"}</button>
+    </div>;
+
+    let layout = <div>
+        <header>
+            <nav>
+                <a>{"Home"}</a>
+                <a>{"About"}</a>
+            </nav>
+        </header>
+        <main>
+            <article>{"Content here"}</article>
+        </main>
+    </div>;
+
+    # Components and namespaces
+    let comp_props = <Button color="blue" size="large">Submit</Button>;
+    let comp_namespaced = <UI.Button />;
+    let comp_deep_namespace = <Form.Input.Text />;
+    let app = <App>
+        <Header />
+        <Main>
+            <Sidebar />
+            <Content />
+        </Main>
+        <Footer />
+    </App>;
+
+    # Fragments
+    let empty_fragment = <></>;
+    let fragment_with_children = <>
+        <h1>{"Title"}</h1>
+        <p>{"Paragraph"}</p>
+    </>;
+    let mixed_fragment = <>
+        {"Some text"}
+        <div>{"Element"}</div>
+        {"More text"}
+        <span>{"Inline"}</span>
+    </>;
+
+    # Spread attributes
+    let spread_div = <div {...props} />;
+    let spread_button = <button {...props} {...extraProps}>{"Click"}</button>;
+    let spread_input = <input type="text" {...props} disabled />;
+}
diff --git a/jac/jaclang/compiler/passes/ecmascript/tests/fixtures/core_language_features.jac b/jac/jaclang/compiler/passes/ecmascript/tests/fixtures/core_language_features.jac
new file mode 100644
index 0000000000..27d8a354cb
--- /dev/null
+++ b/jac/jaclang/compiler/passes/ecmascript/tests/fixtures/core_language_features.jac
@@ -0,0 +1,195 @@
+"""Combined core Jac constructs for ECMAScript generator tests."""
+
+let global_counter: int = 0;
+
+# Basic functions and control flow
+def add(a: int, b: int) -> int {
+    return a + b;
+}
+
+def greet(name: str = "World") -> str {
+    return "Hello, " + name;
+}
+
+def classify_number(value: int) -> str {
+    if value < 0 {
+        return "negative";
+    } elif value == 0 {
+        return "zero";
+    }
+    return "positive";
+}
+
+def fibonacci(n: int) -> int {
+    if n <= 1 {
+        return n;
+    }
+    return fibonacci(n - 1) + fibonacci(n - 2);
+}
+
+def loop_examples(limit: int) -> int {
+    total = 0;
+    for i in range(limit) {
+        if i % 2 == 0 {
+            total += i;
+            continue;
+        }
+        total += i * 2;
+    }
+
+    counter = limit;
+    while counter > 0 {
+        total -= 1;
+        counter -= 1;
+    }
+    return total;
+}
+
+# Data structures and assignments
+def collection_examples() -> dict {
+    numbers = [1, 2, 3, 4];
+    person = {"name": "Alice", "age": 30};
+    matrix = [[1, 2], [3, 4]];
+    history = {"first": numbers[0], "last": numbers[-1]};
+    return {
+        "numbers": numbers,
+        "person": person,
+        "matrix": matrix,
+        "history": history
+    };
+}
+
+def destructuring_examples() -> dict {
+    (x, y) = (10, 20);
+    [a, b, c] = [1, 2, 3];
+    (head, *tail) = [5, 6, 7, 8];
+    result = (size := len(tail)) + x + y + a + b + c;
+    return {
+        "tuple": (x, y),
+        "list": [a, b, c],
+        "tail": tail,
+        "result": result,
+        "size": size
+    };
+}
+
+def assignment_examples(value: int) -> dict {
+    current = value;
+    current += 5;
+    current -= 2;
+    current *= 3;
+    current /= 2;
+    parity = (status := current % 2);
+    return {"current": current, "status": status, "parity": parity};
+}
+
+# Exception handling
+def safe_division(a: int, b: int) -> float {
+    global global_counter;
+    try {
+        return a / b;
+    } except ZeroDivisionError as err {
+        global_counter += 1;
+        return 0.0;
+    } finally {
+        global_counter += 1;
+    }
+}
+
+# Boolean and comparison helpers
+def compare_values(x: int, y: int) -> dict {
+    return {
+        "lt": x < y,
+        "le": x <= y,
+        "eq": x == y,
+        "ne": x != y,
+        "ge": x >= y,
+        "gt": x > y,
+        "logic": (x < y and y < 100) or not (x == y)
+    };
+}
+
+# Object definitions
+obj Person {
+    has name: str;
+    has age: int = 0;
+
+    def describe -> str {
+        return self.name + " (" + str(self.age) + ")";
+    }
+}
+
+obj Employee(Person) {
+    has role: str = "Engineer";
+
+    def describe -> str {
+        return self.name + " - " + self.role;
+    }
+}
+
+obj Calculator {
+    has value: float = 0.0;
+
+    def add(x: float) -> float {
+        self.value += x;
+        return self.value;
+    }
+
+    def subtract(x: float) -> float {
+        self.value -= x;
+        return self.value;
+    }
+
+    def reset {
+        self.value = 0.0;
+    }
+}
+
+obj MathUtils {
+    static def square(x: int) -> int {
+        return x * x;
+    }
+}
+
+# Enumerations
+enum Status {
+    ACTIVE = "active",
+    INACTIVE = "inactive",
+    PENDING = "pending"
+}
+
+enum Priority {
+    LOW = 1,
+    MEDIUM = 2,
+    HIGH = 3
+}
+
+def summarize_status() -> dict {
+    states = [Status.ACTIVE, Status.PENDING];
+    return {
+        "first": states[0],
+        "count": len(states),
+        "names": ["ACTIVE", "PENDING"]
+    };
+}
+
+# Utility demonstrating combined features
+def build_report(data: list) -> dict {
+    processed = [];
+    for item in data {
+        if item is None {
+            continue;
+        }
+        processed.append(item * 2);
+    }
+
+    info = collection_examples();
+    stats = compare_values(len(processed), len(info["numbers"]));
+
+    return {
+        "processed": processed,
+        "info": info,
+        "stats": stats,
+        "summary": summarize_status()
+    };
+}
diff --git a/jac/jaclang/compiler/passes/ecmascript/tests/test_esast_gen_pass.py b/jac/jaclang/compiler/passes/ecmascript/tests/test_esast_gen_pass.py
new file mode 100644
index 0000000000..5e7df6c635
--- /dev/null
+++ b/jac/jaclang/compiler/passes/ecmascript/tests/test_esast_gen_pass.py
@@ -0,0 +1,129 @@
+"""Test ECMAScript AST generation using consolidated Jac fixtures."""
+
+import json
+from pathlib import Path
+from typing import Iterable
+
+from jaclang.compiler.passes.ecmascript import EsastGenPass, es_node_to_dict
+from jaclang.compiler.passes.ecmascript import estree as es
+from jaclang.compiler.passes.ecmascript.es_unparse import es_to_js
+from jaclang.compiler.program import JacProgram
+from jaclang.utils.test import TestCase
+
+
+def walk_es_nodes(node: es.Node) -> Iterable[es.Node]:
+    """Yield every ESTree node in a depth-first traversal."""
+    yield node
+    for value in vars(node).values():
+        if isinstance(value, es.Node):
+            yield from walk_es_nodes(value)
+        elif isinstance(value, list):
+            for item in value:
+                if isinstance(item, es.Node):
+                    yield from walk_es_nodes(item)
+
+
+class EsastGenPassTests(TestCase):
+    """Validate ECMAScript AST output from consolidated fixtures."""
+
+    CORE_FIXTURE = "core_language_features.jac"
+    ADVANCED_FIXTURE = "advanced_language_features.jac"
+    CLIENT_FIXTURE = "client_jsx.jac"
+
+    TargetPass = EsastGenPass
+
+    def get_fixture_path(self, filename: str) -> str:
+        """Return absolute path to a fixture file."""
+        fixtures_dir = Path(__file__).parent / "fixtures"
+        return str(fixtures_dir / filename)
+
+    def compile_to_esast(self, filename: str) -> es.Program:
+        """Compile Jac source to an ESTree program."""
+        prog = JacProgram()
+        ir = prog.compile(file_path=filename, no_cgen=True)
+
+        self.assertFalse(
+            prog.errors_had,
+            f"Compilation errors in {filename}: {[str(e) for e in prog.errors_had]}",
+        )
+
+        es_pass = EsastGenPass(ir, prog)
+        es_ir = es_pass.ir_out
+
+        self.assertTrue(hasattr(es_ir.gen, "es_ast"), "es_ast attribute missing")
+        self.assertIsInstance(es_ir.gen.es_ast, es.Program)
+        return es_ir.gen.es_ast
+
+    def test_core_fixture_ast_shape(self) -> None:
+        """Core fixture should expose fundamental declarations in the ESTree."""
+        es_ast = self.compile_to_esast(self.get_fixture_path(self.CORE_FIXTURE))
+
+        func_decls = [
+            node for node in es_ast.body if isinstance(node, es.FunctionDeclaration)
+        ]
+        func_names = {func.id.name for func in func_decls if func.id}
+        self.assertTrue({"add", "greet", "fibonacci"}.issubset(func_names))
+
+        class_decls = [
+            node for node in es_ast.body if isinstance(node, es.ClassDeclaration)
+        ]
+        class_names = {cls.id.name for cls in class_decls if cls.id}
+        self.assertIn("Person", class_names)
+        self.assertIn("Employee", class_names)
+
+        var_decls = [
+            node for node in es_ast.body if isinstance(node, es.VariableDeclaration)
+        ]
+        self.assertGreaterEqual(len(var_decls), 2, "Expected const enums and globals")
+
+        ast_json = json.dumps(es_node_to_dict(es_ast))
+        self.assertIn("TryStatement", ast_json, "Expected try/except in core fixture")
+        self.assertIn(
+            "BinaryExpression",
+            ast_json,
+            "Binary expressions should appear in core fixture",
+        )
+
+    def test_advanced_fixture_contains_async_and_spread_nodes(self) -> None:
+        """Advanced fixture should surface async, await, and spread constructs."""
+        es_ast = self.compile_to_esast(self.get_fixture_path(self.ADVANCED_FIXTURE))
+
+        func_names = {
+            node.id.name
+            for node in es_ast.body
+            if isinstance(node, es.FunctionDeclaration) and node.id
+        }
+        self.assertIn("lambda_examples", func_names)
+        self.assertIn("build_advanced_report", func_names)
+
+        node_types = {type(node).__name__ for node in walk_es_nodes(es_ast)}
+        self.assertIn("AwaitExpression", node_types)
+        self.assertIn("SpreadElement", node_types)
+        self.assertIn("ConditionalExpression", node_types)
+
+        ast_json = json.dumps(es_node_to_dict(es_ast))
+        self.assertIn("CallExpression", ast_json)
+        self.assertIn("ReturnStatement", ast_json)
+
+    def test_client_fixture_generates_client_bundle(self) -> None:
+        """Client fixture should retain JSX lowering behaviour."""
+        es_ast = self.compile_to_esast(self.get_fixture_path(self.CLIENT_FIXTURE))
+        js_code = es_to_js(es_ast)
+
+        self.assertIn(
+            'const API_URL = "https://api.example.com";',
+            js_code,
+            "Client global should remain const.",
+        )
+        self.assertIn("function component()", js_code)
+        self.assertIn("__jacJsx", js_code)
+        self.assertNotIn("server_only", js_code)
+
+    def test_es_ast_serializes_to_json(self) -> None:
+        """ESTree should serialize cleanly to JSON for downstream tooling."""
+        es_ast = self.compile_to_esast(self.get_fixture_path(self.CORE_FIXTURE))
+        ast_dict = es_node_to_dict(es_ast)
+
+        serialized = json.dumps(ast_dict)
+        self.assertIn('"type": "Program"', serialized)
+        self.assertGreater(len(serialized), 1000)
diff --git a/jac/jaclang/compiler/passes/ecmascript/tests/test_js_generation.py b/jac/jaclang/compiler/passes/ecmascript/tests/test_js_generation.py
new file mode 100644
index 0000000000..a1a360e0bc
--- /dev/null
+++ b/jac/jaclang/compiler/passes/ecmascript/tests/test_js_generation.py
@@ -0,0 +1,180 @@
+"""Test JavaScript code generation using consolidated Jac fixtures."""
+
+import os
+import subprocess
+import tempfile
+from pathlib import Path
+
+from jaclang.compiler.passes.ecmascript import EsastGenPass
+from jaclang.compiler.passes.ecmascript.es_unparse import es_to_js
+from jaclang.compiler.program import JacProgram
+from jaclang.utils.test import TestCase
+
+
+class JavaScriptGenerationTests(TestCase):
+    """Validate JavaScript generation for core and advanced Jac fixtures."""
+
+    CORE_FIXTURE = "core_language_features.jac"
+    ADVANCED_FIXTURE = "advanced_language_features.jac"
+    CLIENT_FIXTURE = "client_jsx.jac"
+
+    def get_fixture_path(self, filename: str) -> str:
+        """Return absolute path to a fixture file."""
+        fixtures_dir = Path(__file__).parent / "fixtures"
+        return str(fixtures_dir / filename)
+
+    def compile_fixture_to_js(self, fixture_name: str) -> str:
+        """Compile a Jac fixture to JavaScript and return the emitted source."""
+        fixture_path = fixture_name
+        if not Path(fixture_path).exists():
+            fixture_path = self.get_fixture_path(fixture_name)
+        prog = JacProgram()
+        ir = prog.compile(file_path=fixture_path, no_cgen=True)
+
+        self.assertFalse(
+            prog.errors_had,
+            f"Compilation errors in {fixture_name}: {[str(e) for e in prog.errors_had]}",
+        )
+
+        es_pass = EsastGenPass(ir, prog)
+        es_ir = es_pass.ir_out
+
+        self.assertTrue(hasattr(es_ir.gen, "es_ast"), "es_ast attribute missing")
+        self.assertIsNotNone(es_ir.gen.es_ast, "es_ast should not be None")
+
+        return es_to_js(es_ir.gen.es_ast)
+
+    def assert_balanced_syntax(self, js_code: str, fixture_name: str) -> None:
+        """Ensure generated JavaScript has balanced delimiters."""
+        pairs = [("{", "}"), ("(", ")"), ("[", "]")]
+        for open_char, close_char in pairs:
+            self.assertEqual(
+                js_code.count(open_char),
+                js_code.count(close_char),
+                f"{fixture_name} produced unbalanced {open_char}{close_char} pairs",
+            )
+
+    def assert_no_jac_keywords(self, js_code: str, fixture_name: str) -> None:
+        """Verify Jac-specific keywords are absent from generated JavaScript."""
+        jac_keywords = [
+            "can ",
+            "has ",
+            "obj ",
+            "walker ",
+            "node ",
+            "edge ",
+            "visit ",
+            "spawn ",
+            "disengage ",
+            "here ",
+            "root ",
+        ]
+
+        for keyword in jac_keywords:
+            self.assertNotIn(
+                keyword,
+                js_code,
+                f"Jac keyword '{keyword.strip()}' leaked into JavaScript for {fixture_name}",
+            )
+
+    def test_core_fixture_emits_expected_constructs(self) -> None:
+        """Core fixture should cover fundamental language constructs."""
+        js_code = self.compile_fixture_to_js(self.CORE_FIXTURE)
+
+        self.assertIn("const global_counter = 0;", js_code)
+        self.assertIn("function add", js_code)
+        self.assertIn("function greet", js_code)
+        self.assertIn("function fibonacci", js_code)
+        self.assertIn("for (const i of range(limit))", js_code)
+        self.assertIn("while (counter > 0)", js_code)
+
+        # Operators map to JavaScript equivalents
+        self.assertIn("===", js_code)
+        self.assertIn("!==", js_code)
+        self.assertIn("&&", js_code)
+        self.assertIn("||", js_code)
+
+        # Classes and enums materialize as expected
+        self.assertIn("class Person", js_code)
+        self.assertIn("class Employee extends Person", js_code)
+        self.assertIn("class Calculator", js_code)
+        self.assertIn("class MathUtils", js_code)
+        self.assertIn("const Status", js_code)
+        self.assertIn("const Priority", js_code)
+
+        # Exception handling remains intact
+        self.assertIn("try", js_code)
+        self.assertIn("catch (err)", js_code)
+        self.assertIn("finally", js_code)
+
+        self.assert_balanced_syntax(js_code, self.CORE_FIXTURE)
+        self.assert_no_jac_keywords(js_code, self.CORE_FIXTURE)
+        self.assertGreater(len(js_code), 200, "Core fixture generated suspiciously small output")
+
+    def test_advanced_fixture_emits_expected_constructs(self) -> None:
+        """Advanced fixture should exercise higher-level Jac features."""
+        js_code = self.compile_fixture_to_js(self.ADVANCED_FIXTURE)
+
+        self.assertIn("function lambda_examples", js_code)
+        self.assertIn("async function fetch_value", js_code)
+        self.assertIn("await fetch_value", js_code)
+        self.assertIn("async function gather_async", js_code)
+        self.assertIn("function generator_examples", js_code)
+        self.assertIn("function spread_and_rest_examples", js_code)
+        self.assertIn("...defaults", js_code)
+        self.assertIn("function template_literal_examples", js_code)
+        self.assertIn("score >= 60 ? \"pass\" : \"fail\"", js_code)
+        self.assertIn("function do_while_simulation", js_code)
+        self.assertIn("function build_advanced_report", js_code)
+
+        # Ensure pattern matching lowered into a callable
+        self.assertIn("function pattern_matching_examples", js_code)
+
+        self.assert_balanced_syntax(js_code, self.ADVANCED_FIXTURE)
+        self.assert_no_jac_keywords(js_code, self.ADVANCED_FIXTURE)
+        self.assertGreater(len(js_code), 150, "Advanced fixture output unexpectedly small")
+
+    def test_client_fixture_generates_client_bundle(self) -> None:
+        """Client-focused fixture should emit JSX-flavoured JavaScript."""
+        js_code = self.compile_fixture_to_js(self.CLIENT_FIXTURE)
+
+        self.assertIn('const API_URL = "https://api.example.com";', js_code)
+        self.assertIn("function component()", js_code)
+        self.assertIn('__jacJsx("div"', js_code)
+        self.assertIn("class ButtonProps", js_code)
+        self.assertIn("constructor(props", js_code)
+        self.assertNotIn("server_only", js_code, "Server-only code leaked into client bundle")
+
+        self.assert_balanced_syntax(js_code, self.CLIENT_FIXTURE)
+
+    def test_cli_js_command_outputs_js(self) -> None:
+        """jac js CLI should emit JavaScript for the core fixture."""
+        fixture_path = self.get_fixture_path(self.CORE_FIXTURE)
+        env = os.environ.copy()
+        project_root = str(Path(__file__).resolve().parents[4])
+        existing = env.get("PYTHONPATH", "")
+        env["PYTHONPATH"] = f"{project_root}:{existing}" if existing else project_root
+
+        result = subprocess.run(
+            ["python3", "-m", "jaclang.cli.cli", "js", fixture_path],
+            capture_output=True,
+            text=True,
+            env=env,
+        )
+
+        self.assertEqual(result.returncode, 0, f"CLI command failed: {result.stderr}")
+        self.assertGreater(len(result.stdout), 0, "CLI produced no output")
+        self.assertIn("function add", result.stdout)
+
+    def test_empty_file_generates_minimal_js(self) -> None:
+        """Ensure an empty Jac file generates a minimal JavaScript stub."""
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".jac", delete=False) as tmp:
+            tmp.write('"""Empty file for smoke testing."""\n')
+            temp_path = tmp.name
+
+        try:
+            js_code = self.compile_fixture_to_js(temp_path)
+            self.assertLess(len(js_code), 100, "Empty file produced unexpectedly large output")
+            self.assert_balanced_syntax(js_code, temp_path)
+        finally:
+            os.unlink(temp_path)
diff --git a/jac/jaclang/compiler/passes/main/pyast_gen_pass.py b/jac/jaclang/compiler/passes/main/pyast_gen_pass.py
index 47fd999c30..f9591068d4 100644
--- a/jac/jaclang/compiler/passes/main/pyast_gen_pass.py
+++ b/jac/jaclang/compiler/passes/main/pyast_gen_pass.py
@@ -90,25 +90,6 @@
 class PyastGenPass(UniPass):
     """Jac blue transpilation to python pass."""
 
-    # Builtins that should be imported from jaclang.runtimelib.builtin
-    KNOWN_BUILTINS = {
-        "abstractmethod",
-        "ClassVar",
-        "override",
-        "printgraph",
-        "jid",
-        "jobj",
-        "grant",
-        "revoke",
-        "allroots",
-        "save",
-        "commit",
-        "NoPerm",
-        "ReadPerm",
-        "ConnectPerm",
-        "WritePerm",
-    }
-
     def before_pass(self) -> None:
         self.child_passes: list[PyastGenPass] = []
         for i in self.ir_in.impl_mod + self.ir_in.test_mod:
@@ -131,6 +112,12 @@ def before_pass(self) -> None:
 
     def enter_node(self, node: uni.UniNode) -> None:
         """Enter node."""
+        if self._should_skip_client(node):
+            node.gen.py_ast = []
+            if hasattr(node.gen, "py"):
+                node.gen.py = ""  # type: ignore[attr-defined]
+            self.prune()
+            return
         if node.gen.py_ast:
             self.prune()
             return
@@ -138,13 +125,12 @@ def enter_node(self, node: uni.UniNode) -> None:
 
     def exit_node(self, node: uni.UniNode) -> None:
         """Exit node."""
+        if self._should_skip_client(node):
+            node.gen.py_ast = []
+            if hasattr(node.gen, "py"):
+                node.gen.py = ""  # type: ignore[attr-defined]
+            return
         super().exit_node(node)
-        # for i in node.gen.py_ast:  # Internal validation
-        #     self.node_compilable_test(i)
-
-        # TODO: USE THIS TO SYNC
-        #     if isinstance(i, ast3.AST):
-        #         i.jac_link = node
 
     def jaclib_obj(self, obj_name: str) -> ast3.Name:
         """Return the object from jaclib as ast node based on the import config."""
@@ -303,6 +289,10 @@ def flatten(self, body: list[T | list[T] | None]) -> list[T]:
                 new_body.append(item)
         return new_body
 
+    def _should_skip_client(self, node: uni.UniNode) -> bool:
+        """Check if node is a client-facing declaration that should skip Python codegen."""
+        return isinstance(node, uni.ClientFacingNode) and node.is_client_decl
+
     def sync(
         self, py_node: T, jac_node: Optional[uni.UniNode] = None, deep: bool = False
     ) -> T:
@@ -709,18 +699,17 @@ def exit_archetype(self, node: uni.Archetype) -> None:
         if node.arch_type.name != Tok.KW_CLASS:
             base_classes.append(self.jaclib_obj(node.arch_type.value.capitalize()))
 
-        node.gen.py_ast = [
-            self.sync(
-                ast3.ClassDef(
-                    name=node.name.sym_name,
-                    bases=[cast(ast3.expr, i) for i in base_classes],
-                    keywords=[],
-                    body=[cast(ast3.stmt, i) for i in body],
-                    decorator_list=[cast(ast3.expr, i) for i in decorators],
-                    type_params=[],
-                )
+        class_def = self.sync(
+            ast3.ClassDef(
+                name=node.name.sym_name,
+                bases=[cast(ast3.expr, i) for i in base_classes],
+                keywords=[],
+                body=[cast(ast3.stmt, i) for i in body],
+                decorator_list=[cast(ast3.expr, i) for i in decorators],
+                type_params=[],
             )
-        ]
+        )
+        node.gen.py_ast = [class_def]
 
     def enter_enum(self, node: uni.Enum) -> None:
         if isinstance(node.body, uni.ImplDef):
@@ -745,18 +734,17 @@ def exit_enum(self, node: uni.Enum) -> None:
 
         base_classes = [cast(ast3.expr, i.gen.py_ast[0]) for i in node.base_classes]
         base_classes.append(self.builtin_name("Enum"))
-        node.gen.py_ast = [
-            self.sync(
-                ast3.ClassDef(
-                    name=node.name.sym_name,
-                    bases=[cast(ast3.expr, i) for i in base_classes],
-                    keywords=[],
-                    body=[cast(ast3.stmt, i) for i in body],
-                    decorator_list=[cast(ast3.expr, i) for i in decorators],
-                    type_params=[],
-                )
+        class_def = self.sync(
+            ast3.ClassDef(
+                name=node.name.sym_name,
+                bases=[cast(ast3.expr, i) for i in base_classes],
+                keywords=[],
+                body=[cast(ast3.stmt, i) for i in body],
+                decorator_list=[cast(ast3.expr, i) for i in decorators],
+                type_params=[],
             )
-        ]
+        )
+        node.gen.py_ast = [class_def]
 
     def enter_ability(self, node: uni.Ability) -> None:
         if isinstance(node.body, uni.ImplDef):
@@ -970,36 +958,35 @@ def exit_ability(self, node: uni.Ability) -> None:
         if isinstance(node.signature, uni.FuncSignature) and node.signature.return_type:
             ast_returns = cast(ast3.expr, node.signature.return_type.gen.py_ast[0])
 
-        node.gen.py_ast = [
-            self.sync(
-                func_type(
-                    name=node.name_ref.sym_name,
-                    args=(
-                        cast(ast3.arguments, node.signature.gen.py_ast[0])
-                        if node.signature
-                        else self.sync(
-                            ast3.arguments(
-                                posonlyargs=[],
-                                args=(
-                                    [self.sync(ast3.arg(arg="self", annotation=None))]
-                                    if node.is_method
-                                    else []
-                                ),
-                                vararg=None,
-                                kwonlyargs=[],
-                                kw_defaults=[],
-                                kwarg=None,
-                                defaults=[],
-                            )
+        func_def = self.sync(
+            func_type(
+                name=node.name_ref.sym_name,
+                args=(
+                    cast(ast3.arguments, node.signature.gen.py_ast[0])
+                    if node.signature
+                    else self.sync(
+                        ast3.arguments(
+                            posonlyargs=[],
+                            args=(
+                                [self.sync(ast3.arg(arg="self", annotation=None))]
+                                if node.is_method
+                                else []
+                            ),
+                            vararg=None,
+                            kwonlyargs=[],
+                            kw_defaults=[],
+                            kwarg=None,
+                            defaults=[],
                         )
-                    ),
-                    body=[cast(ast3.stmt, i) for i in body],
-                    decorator_list=[cast(ast3.expr, i) for i in decorator_list],
-                    returns=ast_returns,
-                    type_params=[],
-                )
+                    )
+                ),
+                body=[cast(ast3.stmt, i) for i in body],
+                decorator_list=[cast(ast3.expr, i) for i in decorator_list],
+                returns=ast_returns,
+                type_params=[],
             )
-        ]
+        )
+        node.gen.py_ast = [func_def]
 
     def exit_impl_def(self, node: uni.ImplDef) -> None:
         pass
@@ -3076,7 +3063,9 @@ def exit_token(self, node: uni.Token) -> None:
     def exit_name(self, node: uni.Name) -> None:
         name = node.sym_name
         # Track if this name is a known builtin
-        if name in self.KNOWN_BUILTINS:
+        import jaclang.runtimelib.builtin
+
+        if name in set(jaclang.runtimelib.builtin.__all__):
             self.builtin_imports.add(name)
         node.gen.py_ast = [self.sync(ast3.Name(id=name, ctx=node.py_ctx_func()))]
 
@@ -3103,6 +3092,129 @@ def exit_null(self, node: uni.Null) -> None:
     def exit_ellipsis(self, node: uni.Ellipsis) -> None:
         node.gen.py_ast = [self.sync(ast3.Constant(value=...))]
 
+    def exit_jsx_element(self, node: uni.JsxElement) -> None:
+        """Generate Python AST for JSX elements.
+
+        JSX elements are compiled to function calls:
+        <div>Hello</div> -> jsx('div', {}, ['Hello'])
+        <MyComponent {...props} /> -> jsx(MyComponent, props, [])
+        """
+        # Generate tag argument
+        if node.is_fragment or not node.name:
+            tag_arg: ast3.expr = self.sync(ast3.Constant(value=None), node)
+        else:
+            tag_arg = cast(ast3.expr, node.name.gen.py_ast[0])
+
+        # Generate attributes dict
+        if not node.attributes:
+            attrs_expr = self.sync(ast3.Dict(keys=[], values=[]))
+        elif any(isinstance(attr, uni.JsxSpreadAttribute) for attr in node.attributes):
+            # With spread: build merged dict {**dict1, **dict2, key: val}
+            attrs_expr = self.sync(ast3.Dict(keys=[], values=[]))
+            for attr in node.attributes:
+                attr_ast = cast(ast3.expr, attr.gen.py_ast[0])
+                if isinstance(attr, uni.JsxSpreadAttribute):
+                    attrs_expr = self.sync(
+                        ast3.Dict(keys=[None, None], values=[attrs_expr, attr_ast]),
+                        attr,
+                    )
+                elif isinstance(attr, uni.JsxNormalAttribute):
+                    key_ast, value_ast = attr_ast.elts  # type: ignore
+                    attrs_expr = self.sync(
+                        ast3.Dict(keys=[None, key_ast], values=[attrs_expr, value_ast]),
+                        attr,
+                    )
+        else:
+            # No spreads: simple dict
+            keys: list[ast3.expr | None] = []
+            values: list[ast3.expr] = []
+            for attr in node.attributes:
+                if isinstance(attr, uni.JsxNormalAttribute):
+                    attr_ast = attr.gen.py_ast[0]
+                    key_ast, value_ast = attr_ast.elts  # type: ignore
+                    keys.append(key_ast)
+                    values.append(value_ast)
+            attrs_expr = self.sync(ast3.Dict(keys=keys, values=values))
+
+        # Generate children list
+        children_arg = (
+            self.sync(
+                ast3.List(
+                    elts=[cast(ast3.expr, c.gen.py_ast[0]) for c in node.children],
+                    ctx=ast3.Load(),
+                ),
+                node,
+            )
+            if node.children
+            else self.sync(ast3.List(elts=[], ctx=ast3.Load()))
+        )
+
+        node.gen.py_ast = [
+            self.sync(
+                ast3.Call(
+                    func=self.jaclib_obj("jsx"),
+                    args=[tag_arg, attrs_expr, children_arg],
+                    keywords=[],
+                ),
+                node,
+            )
+        ]
+
+    def exit_jsx_element_name(self, node: uni.JsxElementName) -> None:
+        """Generate Python AST for JSX element names."""
+        name_str = ".".join([part.value for part in node.parts])
+        # Components (capitalized) use identifier, HTML elements use string
+        if node.parts[0].value[0].isupper():
+            node.gen.py_ast = [self.sync(ast3.Name(id=name_str, ctx=ast3.Load()), node)]
+        else:
+            node.gen.py_ast = [self.sync(ast3.Constant(value=name_str), node)]
+
+    def exit_jsx_attribute(self, node: uni.JsxAttribute) -> None:
+        """Bases class for JSX attributes - handled by subclasses."""
+        pass
+
+    def exit_jsx_spread_attribute(self, node: uni.JsxSpreadAttribute) -> None:
+        """Generate Python AST for JSX spread attributes.
+
+        Returns the expression to be spread (the dict merge is handled by parent).
+        """
+        node.gen.py_ast = [cast(ast3.expr, node.expr.gen.py_ast[0])]
+
+    def exit_jsx_normal_attribute(self, node: uni.JsxNormalAttribute) -> None:
+        """Generate Python AST for JSX normal attributes.
+
+        Returns a tuple (key, value) for the attribute.
+        """
+        if not node.name:
+            return
+
+        key_ast = self.sync(ast3.Constant(value=node.name.value), node.name)
+        value_ast = (
+            cast(ast3.expr, node.value.gen.py_ast[0])
+            if node.value
+            else self.sync(ast3.Constant(value=True), node)
+        )
+
+        # Store as a tuple that parent can destructure
+        node.gen.py_ast = [
+            self.sync(
+                ast3.Tuple(elts=[key_ast, value_ast], ctx=ast3.Load()),
+                node,
+            )
+        ]
+
+    def exit_jsx_child(self, node: uni.JsxChild) -> None:
+        """Bases class for JSX children - handled by subclasses."""
+        pass
+
+    def exit_jsx_text(self, node: uni.JsxText) -> None:
+        """Generate Python AST for JSX text nodes."""
+        node.gen.py_ast = [self.sync(ast3.Constant(value=node.value.value), node)]
+
+    def exit_jsx_expression(self, node: uni.JsxExpression) -> None:
+        """Generate Python AST for JSX expression children."""
+        node.gen.py_ast = [cast(ast3.expr, node.expr.gen.py_ast[0])]
+
     def exit_semi(self, node: uni.Semi) -> None:
         pass
 
diff --git a/jac/jaclang/compiler/passes/main/pyjac_ast_link_pass.py b/jac/jaclang/compiler/passes/main/pyjac_ast_link_pass.py
index 5c1bf03ea0..56053c5249 100644
--- a/jac/jaclang/compiler/passes/main/pyjac_ast_link_pass.py
+++ b/jac/jaclang/compiler/passes/main/pyjac_ast_link_pass.py
@@ -27,6 +27,8 @@ def link_jac_py_nodes(
         self, jac_node: uni.UniNode, py_nodes: list[ast3.AST]
     ) -> None:
         """Link jac name ast to py ast nodes."""
+        if isinstance(jac_node, uni.ClientFacingNode) and jac_node.is_client_decl:
+            return
         jac_node.gen.py_ast = py_nodes
         for i in py_nodes:
             if isinstance(i.jac_link, list):  # type: ignore
diff --git a/jac/jaclang/compiler/passes/tool/doc_ir_gen_pass.py b/jac/jaclang/compiler/passes/tool/doc_ir_gen_pass.py
index 2861a7b188..1eecba05ba 100644
--- a/jac/jaclang/compiler/passes/tool/doc_ir_gen_pass.py
+++ b/jac/jaclang/compiler/passes/tool/doc_ir_gen_pass.py
@@ -1754,3 +1754,86 @@ def exit_comment_token(self, node: uni.CommentToken) -> None:
             node.gen.doc_ir = self.group(
                 self.concat([self.text(node.value), self.hard_line()])
             )
+
+    def exit_jsx_element(self, node: uni.JsxElement) -> None:
+        """Generate DocIR for JSX elements."""
+        parts: list[doc.DocType] = []
+
+        if node.is_fragment:
+            # Fragment: <> ... </>
+            parts.append(self.text("<>"))
+            if node.children:
+                for child in node.children:
+                    parts.append(child.gen.doc_ir)
+            parts.append(self.text("</>"))
+        elif node.is_self_closing:
+            # Self-closing: <Foo />
+            parts.append(self.text("<"))
+            if node.name:
+                parts.append(node.name.gen.doc_ir)
+            if node.attributes:
+                for attr in node.attributes:
+                    parts.append(self.space())
+                    parts.append(attr.gen.doc_ir)
+            parts.append(self.space())
+            parts.append(self.text("/>"))
+        else:
+            # Opening and closing: <Foo>...</Foo>
+            parts.append(self.text("<"))
+            if node.name:
+                parts.append(node.name.gen.doc_ir)
+            if node.attributes:
+                for attr in node.attributes:
+                    parts.append(self.space())
+                    parts.append(attr.gen.doc_ir)
+            parts.append(self.text(">"))
+            if node.children:
+                for child in node.children:
+                    parts.append(child.gen.doc_ir)
+            parts.append(self.text("</"))
+            if node.name:
+                parts.append(node.name.gen.doc_ir)
+            parts.append(self.text(">"))
+
+        node.gen.doc_ir = self.group(self.concat(parts))
+
+    def exit_jsx_element_name(self, node: uni.JsxElementName) -> None:
+        """Generate DocIR for JSX element names."""
+        parts: list[doc.DocType] = []
+        for i, part in enumerate(node.parts):
+            parts.append(part.gen.doc_ir)
+            if i < len(node.parts) - 1:
+                parts.append(self.text("."))
+        node.gen.doc_ir = self.concat(parts)
+
+    def exit_jsx_spread_attribute(self, node: uni.JsxSpreadAttribute) -> None:
+        """Generate DocIR for JSX spread attributes."""
+        node.gen.doc_ir = self.concat(
+            [self.text("{..."), node.expr.gen.doc_ir, self.text("}")]
+        )
+
+    def exit_jsx_normal_attribute(self, node: uni.JsxNormalAttribute) -> None:
+        """Generate DocIR for JSX normal attributes."""
+        parts: list[doc.DocType] = []
+        if node.name:
+            parts.append(node.name.gen.doc_ir)
+        if node.value:
+            parts.append(self.text("="))
+            if isinstance(node.value, uni.String):
+                parts.append(node.value.gen.doc_ir)
+            else:
+                # Expression in braces
+                parts.append(self.text("{"))
+                parts.append(node.value.gen.doc_ir)
+                parts.append(self.text("}"))
+        node.gen.doc_ir = self.concat(parts)
+
+    def exit_jsx_text(self, node: uni.JsxText) -> None:
+        """Generate DocIR for JSX text."""
+        node.gen.doc_ir = node.value.gen.doc_ir
+
+    def exit_jsx_expression(self, node: uni.JsxExpression) -> None:
+        """Generate DocIR for JSX expressions."""
+        node.gen.doc_ir = self.concat(
+            [self.text("{"), node.expr.gen.doc_ir, self.text("}")]
+        )
diff --git a/jac/jaclang/compiler/program.py b/jac/jaclang/compiler/program.py
index 82f6d9edde..1f2c28f447 100644
--- a/jac/jaclang/compiler/program.py
+++ b/jac/jaclang/compiler/program.py
@@ -5,10 +5,11 @@
 import ast as py_ast
 import marshal
 import types
-from typing import Optional, TYPE_CHECKING
+from typing import Any, Optional, TYPE_CHECKING
 
 import jaclang.compiler.unitree as uni
 from jaclang.compiler.parser import JacParser
+from jaclang.compiler.passes.ecmascript import EsastGenPass
 from jaclang.compiler.passes.main import (
     Alert,
     CFGBuildPass,
@@ -33,14 +34,10 @@
 )
 from jaclang.runtimelib.utils import read_file_with_encoding
 from jaclang.settings import settings
-from jaclang.utils.log import logging
 
 if TYPE_CHECKING:
     from jaclang.compiler.type_system.type_evaluator import TypeEvaluator
 
-
-logger = logging.getLogger(__name__)
-
 ir_gen_sched = [
     SymTabBuildPass,
     DeclImplMatchPass,
@@ -52,6 +49,7 @@
     TypeCheckPass,
 ]
 py_code_gen = [
+    EsastGenPass,
     PyastGenPass,
     PyJacAstLinkPass,
     PyBytecodeGenPass,
@@ -62,7 +60,10 @@
 class JacProgram:
     """JacProgram to handle the Jac program-related functionalities."""
 
-    def __init__(self, main_mod: Optional[uni.ProgramModule] = None) -> None:
+    def __init__(
+        self,
+        main_mod: Optional[uni.ProgramModule] = None,
+    ) -> None:
         """Initialize the JacProgram object."""
         self.mod: uni.ProgramModule = main_mod if main_mod else uni.ProgramModule()
         self.py_raise_map: dict[str, str] = {}
@@ -86,6 +87,27 @@ def get_bytecode(self, full_target: str) -> Optional[types.CodeType]:
         result = self.compile(file_path=full_target)
         return marshal.loads(result.gen.py_bytecode) if result.gen.py_bytecode else None
 
+    def get_client_manifest(self, mod_path: str) -> dict[str, Any]:
+        """Get the client manifest for a specific module.
+
+        Args:
+            mod_path: The module path to get the manifest for
+
+        Returns:
+            Dictionary containing client metadata (exports, globals, params, etc.)
+        """
+        module = self.mod.hub.get(mod_path)
+        if module and hasattr(module.gen, "client_manifest"):
+            manifest = module.gen.client_manifest
+            return {
+                "exports": manifest.exports,
+                "globals": manifest.globals,
+                "params": manifest.params,
+                "globals_values": manifest.globals_values,
+                "has_client": manifest.has_client,
+            }
+        return {}
+
     def parse_str(self, source_str: str, file_path: str) -> uni.Module:
         """Convert a Jac file to an AST."""
         had_error = False
diff --git a/jac/jaclang/compiler/tests/test_client_codegen.py b/jac/jaclang/compiler/tests/test_client_codegen.py
new file mode 100644
index 0000000000..8d87c85f53
--- /dev/null
+++ b/jac/jaclang/compiler/tests/test_client_codegen.py
@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from jaclang.compiler.program import JacProgram
+
+
+FIXTURE_DIR = Path(__file__).resolve().parent.parent / "passes" / "ecmascript" / "tests" / "fixtures"
+
+
+def test_js_codegen_generates_js_and_manifest() -> None:
+    fixture = FIXTURE_DIR / "client_jsx.jac"
+    prog = JacProgram()
+    module = prog.compile(str(fixture))
+
+    assert module.gen.js.strip(), "Expected JavaScript output for client declarations"
+    assert "function component" in module.gen.js
+    assert "__jacJsx(" in module.gen.js
+
+    # Client Python code should be omitted in js_only mode
+    assert "def component" not in module.gen.py
+
+    # Metadata should be stored in JacProgram, not in generated Python
+    assert "__jac_client_manifest__" not in module.gen.py
+    manifest = prog.get_client_manifest(module.loc.mod_path)
+    assert manifest, "Client manifest should be available in JacProgram"
+    assert "component" in manifest.get("exports", [])
+    assert "ButtonProps" in manifest.get("exports", [])
+    assert "API_URL" in manifest.get("globals", [])
+
+    # Module.gen.client_manifest should have the metadata
+    assert "component" in module.gen.client_manifest.exports
+    assert "ButtonProps" in module.gen.client_manifest.exports
+    assert "API_URL" in module.gen.client_manifest.globals
+    assert module.gen.client_manifest.params.get("component", []) == []
+    assert "ButtonProps" not in module.gen.client_manifest.params
+
+
+def test_compilation_skips_python_stubs() -> None:
+    fixture = FIXTURE_DIR / "client_jsx.jac"
+    prog = JacProgram()
+    module = prog.compile(str(fixture))
+
+    assert module.gen.js.strip(), "Expected JavaScript output when emitting both"
+    assert "function component" in module.gen.js
+    assert "__jacJsx(" in module.gen.js
+
+    # Client Python definitions are intentionally omitted
+    assert "def component" not in module.gen.py
+    assert "__jac_client__" not in module.gen.py
+    assert "class ButtonProps" not in module.gen.py
+
+    # Manifest data should be in JacProgram, not in generated Python
+    assert "__jac_client_manifest__" not in module.gen.py
+    manifest = prog.get_client_manifest(module.loc.mod_path)
+    assert manifest, "Client manifest should be available in JacProgram"
+    assert "component" in manifest.get("exports", [])
+    assert "ButtonProps" in manifest.get("exports", [])
+    assert "API_URL" in manifest.get("globals", [])
+
+    # Module.gen.client_manifest should have the metadata
+    assert "component" in module.gen.client_manifest.exports
+    assert "ButtonProps" in module.gen.client_manifest.exports
+    assert "API_URL" in module.gen.client_manifest.globals
+    assert module.gen.client_manifest.params.get("component", []) == []
diff --git a/jac/jaclang/compiler/tests/test_parser.py b/jac/jaclang/compiler/tests/test_parser.py
index 1edc15f183..99fb9fa770 100644
--- a/jac/jaclang/compiler/tests/test_parser.py
+++ b/jac/jaclang/compiler/tests/test_parser.py
@@ -4,6 +4,7 @@
 import io
 import os
 import sys
+from pathlib import Path
 
 from jaclang import JacMachineInterface as Jac
 from jaclang.compiler import jac_lark as jl
@@ -215,12 +216,12 @@ def test_multiple_syntax_errors(self) -> None:
                 }
             """,
             """
-            Missing SEMI
+            Unexpected token 'bar'
+                with entry {
                     foo = Foo(;
                     func(foo bar)
+                             ^^^
                     foo.bar;
-                    ^^^
-                }
             """
         ]
         for idx, alrt in enumerate(prog.errors_had):
@@ -229,4 +230,54 @@ def test_multiple_syntax_errors(self) -> None:
                 line = line.strip()
                 self.assertIn(line, pretty)
 
+    def _load_combined_jsx_fixture(self) -> tuple[str, JacParser]:
+        """Parse the consolidated JSX fixture once for downstream assertions."""
+        fixture_path = (
+            Path(__file__)
+            .resolve()
+            .parent
+            .parent
+            / "passes"
+            / "ecmascript"
+            / "tests"
+            / "fixtures"
+            / "client_jsx.jac"
+        )
+        source_text = fixture_path.read_text(encoding="utf-8")
+        prse = JacParser(
+            root_ir=Source(source_text, mod_path=str(fixture_path)),
+            prog=JacProgram(),
+        )
+        self.assertFalse(
+            prse.errors_had,
+            f"Parser reported errors for JSX fixture: {[str(e) for e in prse.errors_had]}",
+        )
+        return source_text, prse
+
+    def test_jsx_comprehensive_fixture(self) -> None:
+        """Ensure the consolidated JSX fixture exercises varied grammar shapes."""
+        source_text, prse = self._load_combined_jsx_fixture()
+        tree_repr = prse.ir_out.pp()
+
+        expected_snippets = {
+            "self_closing": "<div />",
+            "attribute_binding": 'id={name}',
+            "namespaced_component": "<Form.Input.Text />",
+            "fragment": "<>",
+            "spread_attribute": "{...props}",
+            "expression_child": '{"Hello " + name + "!"}',
+        }
+        for label, snippet in expected_snippets.items():
+            with self.subTest(label=label):
+                self.assertIn(snippet, source_text)
+
+        ast_markers = {
+            "JsxElement": "JsxElement" in tree_repr,
+            "FragmentTokens": "Token - <>" in tree_repr and "Token - </>" in tree_repr,
+            "JsxSpreadAttribute": "JsxSpreadAttribute" in tree_repr,
+        }
+        for label, present in ast_markers.items():
+            with self.subTest(node=label):
+                self.assertTrue(present, f"{label} missing from AST pretty print")
+
 TestLarkParser.self_attach_micro_tests()
diff --git a/jac/jaclang/compiler/unitree.py b/jac/jaclang/compiler/unitree.py
index 9e45851d5c..edb5ee84af 100644
--- a/jac/jaclang/compiler/unitree.py
+++ b/jac/jaclang/compiler/unitree.py
@@ -18,6 +18,7 @@
     Sequence,
     Type,
     TypeVar,
+    Union,
 )
 
 
@@ -575,6 +576,13 @@ def access_type(self) -> SymbolAccess:
 T = TypeVar("T", bound=UniNode)
 
 
+class ClientFacingNode:
+    """Mixin for nodes that can be marked as client-facing declarations."""
+
+    def __init__(self, is_client_decl: bool = False) -> None:
+        self.is_client_decl = is_client_decl
+
+
 class AstDocNode(UniNode):
     """Nodes that have access."""
 
@@ -1002,7 +1010,7 @@ def __init__(self, main_mod: Optional[Module] = None) -> None:
         self.hub: dict[str, Module] = {self.loc.mod_path: main_mod} if main_mod else {}
 
 
-class GlobalVars(ElementStmt, AstAccessNode):
+class GlobalVars(ClientFacingNode, ElementStmt, AstAccessNode):
     """GlobalVars node type for Jac Ast."""
 
     def __init__(
@@ -1018,6 +1026,7 @@ def __init__(
         UniNode.__init__(self, kid=kid)
         AstAccessNode.__init__(self, access=access)
         AstDocNode.__init__(self, doc=doc)
+        ClientFacingNode.__init__(self)
 
     def normalize(self, deep: bool = False) -> bool:
         res = True
@@ -1029,6 +1038,8 @@ def normalize(self, deep: bool = False) -> bool:
         new_kid: list[UniNode] = []
         if self.doc:
             new_kid.append(self.doc)
+        if self.is_client_decl:
+            new_kid.append(self.gen_token(Tok.KW_CLIENT))
         if self.is_frozen:
             new_kid.append(self.gen_token(Tok.KW_LET))
         else:
@@ -1043,7 +1054,7 @@ def normalize(self, deep: bool = False) -> bool:
         return res
 
 
-class Test(AstSymbolNode, ElementStmt, UniScopeNode):
+class Test(ClientFacingNode, AstSymbolNode, ElementStmt, UniScopeNode):
     """Test node type for Jac Ast."""
 
     TEST_COUNT = 0
@@ -1089,6 +1100,7 @@ def __init__(
         )
         AstDocNode.__init__(self, doc=doc)
         UniScopeNode.__init__(self, name=self.sym_name)
+        ClientFacingNode.__init__(self)
 
     def normalize(self, deep: bool = False) -> bool:
         res = True
@@ -1100,6 +1112,8 @@ def normalize(self, deep: bool = False) -> bool:
         new_kid: list[UniNode] = []
         if self.doc:
             new_kid.append(self.doc)
+        if self.is_client_decl:
+            new_kid.append(self.gen_token(Tok.KW_CLIENT))
         new_kid.append(self.gen_token(Tok.KW_TEST))
         new_kid.append(self.name)
         new_kid.append(self.gen_token(Tok.LBRACE))
@@ -1110,7 +1124,7 @@ def normalize(self, deep: bool = False) -> bool:
         return res
 
 
-class ModuleCode(ElementStmt, ArchBlockStmt, EnumBlockStmt):
+class ModuleCode(ClientFacingNode, ElementStmt, ArchBlockStmt, EnumBlockStmt):
     """ModuleCode node type for Jac Ast."""
 
     def __init__(
@@ -1126,6 +1140,7 @@ def __init__(
         UniNode.__init__(self, kid=kid)
         AstDocNode.__init__(self, doc=doc)
         EnumBlockStmt.__init__(self, is_enum_stmt=is_enum_stmt)
+        ClientFacingNode.__init__(self)
 
     def normalize(self, deep: bool = False) -> bool:
         res = True
@@ -1137,6 +1152,8 @@ def normalize(self, deep: bool = False) -> bool:
         new_kid: list[UniNode] = []
         if self.doc:
             new_kid.append(self.doc)
+        if self.is_client_decl:
+            new_kid.append(self.gen_token(Tok.KW_CLIENT))
         new_kid.append(self.gen_token(Tok.KW_WITH))
         new_kid.append(self.gen_token(Tok.KW_ENTRY))
         if self.name:
@@ -1179,7 +1196,7 @@ def normalize(self, deep: bool = False) -> bool:
         return res
 
 
-class Import(ElementStmt, CodeBlockStmt):
+class Import(ClientFacingNode, ElementStmt, CodeBlockStmt):
     """Import node type for Jac Ast."""
 
     def __init__(
@@ -1197,6 +1214,7 @@ def __init__(
         UniNode.__init__(self, kid=kid)
         AstDocNode.__init__(self, doc=doc)
         CodeBlockStmt.__init__(self)
+        ClientFacingNode.__init__(self)
 
     @property
     def is_py(self) -> bool:
@@ -1250,6 +1268,8 @@ def normalize(self, deep: bool = False) -> bool:
         new_kid: list[UniNode] = []
         if self.doc:
             new_kid.append(self.doc)
+        if self.is_client_decl:
+            new_kid.append(self.gen_token(Tok.KW_CLIENT))
         if self.is_absorb:
             new_kid.append(self.gen_token(Tok.KW_INCLUDE))
         else:
@@ -1378,6 +1398,7 @@ def normalize(self, deep: bool = False) -> bool:
 
 
 class Archetype(
+    ClientFacingNode,
     ArchSpec,
     AstAccessNode,
     ArchBlockStmt,
@@ -1419,6 +1440,7 @@ def __init__(
         ArchSpec.__init__(self, decorators=decorators)
         UniScopeNode.__init__(self, name=self.sym_name)
         CodeBlockStmt.__init__(self)
+        ClientFacingNode.__init__(self)
 
     @property
     def is_abstract(self) -> bool:
@@ -1455,6 +1477,8 @@ def normalize(self, deep: bool = False) -> bool:
         new_kid: list[UniNode] = []
         if self.doc:
             new_kid.append(self.doc)
+        if self.is_client_decl:
+            new_kid.append(self.gen_token(Tok.KW_CLIENT))
         if self.decorators:
             new_kid.append(self.gen_token(Tok.DECOR_OP))
             for idx, dec in enumerate(self.decorators):
@@ -1646,7 +1670,14 @@ def normalize(self, deep: bool = False) -> bool:
         return res
 
 
-class Enum(ArchSpec, AstAccessNode, AstImplNeedingNode, ArchBlockStmt, UniScopeNode):
+class Enum(
+    ClientFacingNode,
+    ArchSpec,
+    AstAccessNode,
+    AstImplNeedingNode,
+    ArchBlockStmt,
+    UniScopeNode,
+):
     """Enum node type for Jac Ast."""
 
     def __init__(
@@ -1673,6 +1704,7 @@ def __init__(
         AstDocNode.__init__(self, doc=doc)
         ArchSpec.__init__(self, decorators=decorators)
         UniScopeNode.__init__(self, name=self.sym_name)
+        ClientFacingNode.__init__(self)
 
     def normalize(self, deep: bool = False) -> bool:
         res = True
@@ -1700,6 +1732,8 @@ def normalize(self, deep: bool = False) -> bool:
                     new_kid.append(self.gen_token(Tok.DECOR_OP))
         if self.doc:
             new_kid.append(self.doc)
+        if self.is_client_decl:
+            new_kid.append(self.gen_token(Tok.KW_CLIENT))
         new_kid.append(self.gen_token(Tok.KW_ENUM))
         if self.access:
             new_kid.append(self.access)
@@ -1730,6 +1764,7 @@ def normalize(self, deep: bool = False) -> bool:
 
 
 class Ability(
+    ClientFacingNode,
     AstAccessNode,
     ElementStmt,
     AstAsyncNode,
@@ -1774,6 +1809,7 @@ def __init__(
         AstAsyncNode.__init__(self, is_async=is_async)
         UniScopeNode.__init__(self, name=self.sym_name)
         CodeBlockStmt.__init__(self)
+        ClientFacingNode.__init__(self)
 
     @property
     def is_method(self) -> bool:
@@ -1845,6 +1881,8 @@ def normalize(self, deep: bool = False) -> bool:
         new_kid: list[UniNode] = []
         if self.doc:
             new_kid.append(self.doc)
+        if self.is_client_decl:
+            new_kid.append(self.gen_token(Tok.KW_CLIENT))
         if self.decorators:
             new_kid.append(self.gen_token(Tok.DECOR_OP))
             for idx, dec in enumerate(self.decorators):
@@ -4081,6 +4119,206 @@ def normalize(self, deep: bool = False) -> bool:
         return res
 
 
+# JSX Nodes
+# ---------
+
+
+class JsxElement(AtomExpr):
+    """JsxElement node type for Jac Ast."""
+
+    def __init__(
+        self,
+        name: Optional["JsxElementName"],
+        attributes: Optional[Sequence["JsxAttribute"]],
+        children: Optional[Sequence["JsxChild"]],
+        is_self_closing: bool,
+        is_fragment: bool,
+        kid: Sequence[UniNode],
+    ) -> None:
+        self.name = name
+        self.attributes = list(attributes) if attributes else []
+        self.children = list(children) if children else []
+        self.is_self_closing = is_self_closing
+        self.is_fragment = is_fragment
+        UniNode.__init__(self, kid=kid)
+        Expr.__init__(self)
+        AstSymbolStubNode.__init__(self, sym_type=SymbolType.OBJECT_ARCH)
+
+    def normalize(self, deep: bool = False) -> bool:
+        """Normalize JSX element by recursively normalizing children.
+
+        Unlike most normalize methods, JSX elements don't need to rebuild
+        their kid structure since the parser already creates it correctly.
+        We just need to normalize child nodes if deep=True.
+        """
+        res = True
+        if deep:
+            if self.name:
+                res = res and self.name.normalize(deep)
+            if self.attributes:
+                for attr in self.attributes:
+                    res = res and attr.normalize(deep)
+            if self.children:
+                for child in self.children:
+                    res = res and child.normalize(deep)
+        return res
+
+
+class JsxElementName(UniNode):
+    """JsxElementName node type for Jac Ast."""
+
+    def __init__(
+        self,
+        parts: Sequence[Name],
+        kid: Sequence[UniNode],
+    ) -> None:
+        self.parts = list(parts)
+        UniNode.__init__(self, kid=kid)
+
+    def normalize(self, deep: bool = False) -> bool:
+        res = True
+        if deep:
+            for part in self.parts:
+                res = res and part.normalize(deep)
+        new_kid: list[UniNode] = []
+        for i, part in enumerate(self.parts):
+            new_kid.append(part)
+            if i < len(self.parts) - 1:
+                new_kid.append(self.gen_token(Tok.DOT))
+        self.set_kids(nodes=new_kid)
+        return res
+
+
+class JsxAttribute(UniNode):
+    """JsxAttribute node type for Jac Ast (base class)."""
+
+    def __init__(self, kid: Sequence[UniNode]) -> None:
+        UniNode.__init__(self, kid=kid)
+
+    def normalize(self, deep: bool = False) -> bool:
+        """Normalize the node (base implementation)."""
+        # Base class normalize - subclasses should override if needed
+        return True
+
+
+class JsxSpreadAttribute(JsxAttribute):
+    """JsxSpreadAttribute node type for Jac Ast."""
+
+    def __init__(
+        self,
+        expr: Expr,
+        kid: Sequence[UniNode],
+    ) -> None:
+        self.expr = expr
+        JsxAttribute.__init__(self, kid=kid)
+
+    def normalize(self, deep: bool = False) -> bool:
+        res = True
+        if deep:
+            res = self.expr.normalize(deep)
+        new_kid: list[UniNode] = [
+            self.gen_token(Tok.LBRACE),
+            self.gen_token(Tok.ELLIPSIS),
+            self.expr,
+            self.gen_token(Tok.RBRACE),
+        ]
+        self.set_kids(nodes=new_kid)
+        return res
+
+
+class JsxNormalAttribute(JsxAttribute):
+    """JsxNormalAttribute node type for Jac Ast."""
+
+    def __init__(
+        self,
+        name: Name,
+        value: Optional[Union[String, Expr]],
+        kid: Sequence[UniNode],
+    ) -> None:
+        self.name = name
+        self.value = value
+        JsxAttribute.__init__(self, kid=kid)
+
+    def normalize(self, deep: bool = False) -> bool:
+        res = True
+        if deep:
+            res = self.name.normalize(deep)
+            if self.value:
+                res = res and self.value.normalize(deep)
+        new_kid: list[UniNode] = [self.name]
+        if self.value:
+            new_kid.append(self.gen_token(Tok.EQ))
+            if isinstance(self.value, String):
+                new_kid.append(self.value)
+            else:  # Expression in braces
+                new_kid.extend(
+                    [
+                        self.gen_token(Tok.LBRACE),
+                        self.value,
+                        self.gen_token(Tok.RBRACE),
+                    ]
+                )
+        self.set_kids(nodes=new_kid)
+        return res
+
+
+class JsxChild(UniNode):
+    """JsxChild node type for Jac Ast (base class)."""
+
+    def __init__(self, kid: Sequence[UniNode]) -> None:
+        UniNode.__init__(self, kid=kid)
+
+    def normalize(self, deep: bool = False) -> bool:
+        """Normalize the node (base implementation)."""
+        # Base class normalize - subclasses should override if needed
+        return True
+
+
+class JsxText(JsxChild):
+    """JsxText node type for Jac Ast."""
+
+    def __init__(
+        self,
+        value: str,
+        kid: Sequence[UniNode],
+    ) -> None:
+        self.value = value
+        JsxChild.__init__(self, kid=kid)
+
+    def normalize(self, deep: bool = False) -> bool:
+        # JSX text is represented as a token
+        if isinstance(self.value, Token):
+            new_kid: list[UniNode] = [self.value]
+        else:
+            new_kid = [self.gen_token(Tok.JSX_TEXT, value=str(self.value))]
+        self.set_kids(nodes=new_kid)
+        return True
+
+
+class JsxExpression(JsxChild):
+    """JsxExpression node type for Jac Ast."""
+
+    def __init__(
+        self,
+        expr: Expr,
+        kid: Sequence[UniNode],
+    ) -> None:
+        self.expr = expr
+        JsxChild.__init__(self, kid=kid)
+
+    def normalize(self, deep: bool = False) -> bool:
+        res = True
+        if deep:
+            res = self.expr.normalize(deep)
+        new_kid: list[UniNode] = [
+            self.gen_token(Tok.LBRACE),
+            self.expr,
+            self.gen_token(Tok.RBRACE),
+        ]
+        self.set_kids(nodes=new_kid)
+        return res
+
+
 # Match Nodes
 # ------------
 
diff --git a/jac/jaclang/langserve/tests/test_server.py b/jac/jaclang/langserve/tests/test_server.py
index b7e3d860f4..51f7030a26 100644
--- a/jac/jaclang/langserve/tests/test_server.py
+++ b/jac/jaclang/langserve/tests/test_server.py
@@ -54,22 +54,6 @@ def test_impl_auto_discover(self) -> None:
             lsp.get_hover_info(circle_impl_file, pos).contents.value.replace("'", ""),
         )
 
-    @pytest.mark.xfail(reason="TODO: Fix when we have the type checker")
-    def test_show_type_impl(self) -> None:
-        """Test that the server doesn't run if there is a syntax error."""
-        lsp = JacLangServer()
-        # Set up the workspace path to "fixtures/"
-        workspace_path = self.fixture_abs_path("")
-        workspace = Workspace(workspace_path, lsp)
-        lsp.lsp._workspace = workspace
-        target = uris.from_fs_path(self.examples_abs_path("guess_game/guess_game4.jac"))
-        lsp.deep_check(target)
-        pos = lspt.Position(43, 18)
-        self.assertIn(
-            "attempts: int",
-            lsp.get_hover_info(target, pos).contents.value,
-        )
-
     def test_outline_symbols(self) -> None:
         """Test that the outline symbols are correct."""
         lsp = JacLangServer()
@@ -97,24 +81,6 @@ def test_go_to_definition(self) -> None:
             str(lsp.get_definition(circle_file, lspt.Position(20, 16))),
         )
 
-    @pytest.mark.xfail(
-        reason="Incorrect handling of 'self' in DefUsePass.TODO: Fix chain_use_lookup."
-    )
-    def test_go_to_definition_method(self) -> None:
-        """Test that the go to definition is correct."""
-        lsp = JacLangServer()
-        workspace_path = self.fixture_abs_path("")
-        workspace = Workspace(workspace_path, lsp)
-        lsp.lsp._workspace = workspace
-        guess_game_file = uris.from_fs_path(
-            self.examples_abs_path("guess_game/guess_game3.impl.jac")
-        )
-        lsp.deep_check(guess_game_file)
-        self.assertIn(
-            "guess_game3.jac:16:8-16:21",
-            str(lsp.get_definition(guess_game_file, lspt.Position(15, 17))),
-        )
-
     def test_go_to_definition_method_manual_impl(self) -> None:
         """Test that the go to definition is correct."""
         lsp = JacLangServer()
@@ -135,56 +101,6 @@ def test_go_to_definition_method_manual_impl(self) -> None:
             str(lsp.get_definition(decldef_file, lspt.Position(2, 20))),
         )
 
-    @pytest.mark.xfail(
-        reason="TODO: Fix the go to definition for imports[ abs_path is not set]"
-    )
-    def test_test_annex(self) -> None:
-        """Test that the server doesn't run if there is a syntax error."""
-        lsp = JacLangServer()
-        # Set up the workspace path to "fixtures/"
-        workspace_path = self.fixture_abs_path("")
-        workspace = Workspace(workspace_path, lsp)
-        lsp.lsp._workspace = workspace
-        circle_file = uris.from_fs_path(self.fixture_abs_path("circle_pure.test.jac"))
-        lsp.deep_check(circle_file)
-        pos = lspt.Position(13, 21)
-        self.assertIn(
-            "shape_type: circle_pure.ShapeType",
-            lsp.get_hover_info(circle_file, pos).contents.value,
-        )
-
-    @pytest.mark.xfail(
-        reason="TODO: Fix the go to definition for imports[ abs_path is not set]"
-    )
-    def test_go_to_definition_import(self) -> None:
-        """Test that the go to definition is correct."""
-        lsp = JacLangServer()
-        workspace_path = self.fixture_abs_path("")
-        workspace = Workspace(workspace_path, lsp)
-        lsp.lsp._workspace = workspace
-        import_file = uris.from_fs_path(
-            self.fixture_abs_path("import_include_statements.jac")
-        )
-        lsp.deep_check(import_file)
-        positions = [
-            (0, 12, "tdlib/os/__init__.pyi:0:0-0:0"),
-            (1, 18, "stdlib/math.pyi:0:0-0:0"),
-            (2, 24, "datetime.pyi:0:0-0:0"),
-            (3, 17, "base_module_structure.jac:0:0-0:0"),
-            (3, 87, "base_module_structure.jac:23:5-23:14"),
-            (5, 65, "py_import.py:0:0-0:0"),
-            (5, 35, "py_import.py:0:0-0:0"),
-            # (5, 65, "py_import.py:12:0-20:5"),  # TODO : Should work after 'from' import files are raised
-            # (5, 35, "py_import.py:3:0-4:5"),
-        ]
-
-        for line, char, expected in positions:
-            with self.subTest(line=line, char=char):
-                self.assertIn(
-                    expected,
-                    str(lsp.get_definition(import_file, lspt.Position(line, char))),
-                )
-
     def test_go_to_definition_md_path(self) -> None:
         """Test that the go to definition is correct."""
         lsp = JacLangServer()
@@ -209,7 +125,7 @@ def test_go_to_definition_md_path(self) -> None:
             (14, 34, "compiler/type_system/__init__.py:0:0-0:0"),
             (14, 55, "compiler/type_system/types.py:143:0-226:8"),
             (15, 34, "compiler/unitree.py:0:0-0:0"),
-            (15, 48, "compiler/unitree.py:302:0-502:11"),
+            (15, 48, "compiler/unitree.py:303:0-503:11"),
             (17, 22, "langserve/tests/fixtures/circle.jac:8:5-8:8"),
             (18, 38, "vendor/pygls/uris.py:0:0-0:0"),
             (19, 52, "vendor/pygls/server.py:351:0-615:13"),
@@ -273,100 +189,7 @@ def test_missing_mod_warning(self) -> None:
                 str(lsp.warnings_had[idx]),
             )
 
-    @pytest.mark.xfail(
-        reason="TODO: Fix the go to definition for imports[ abs_path is not set]"
-    )
-    def test_go_to_definition_foolme(self) -> None:
-        """Test that the go to definition is correct."""
-        lsp = JacLangServer()
-        workspace_path = self.fixture_abs_path("")
-        workspace = Workspace(workspace_path, lsp)
-        lsp.lsp._workspace = workspace
-        import_file = uris.from_fs_path(
-            self.fixture_abs_path(
-                "../../../../jaclang/compiler/passes/main/tests/fixtures/py_imp_test.jac"
-            )
-        )
-        lsp.deep_check(import_file)
-        positions = [
-            (6, 39, "/pygame_mock/__init__.pyi:2:0-2:0"),
-            (6, 45, "/pygame_mock/constants.py:3:0-4:1"),
-            (7, 31, "/pygame_mock/__init__.pyi:2:0-2:0"),
-            (7, 35, "/pygame_mock/constants.py:3:0-4:1"),
-            (20, 51, "/py_imp_test.jac:6:4-6:11"),
-            (20, 64, "/pygame_mock/constants.py:4:3-4:15"),
-            (21, 48, "/py_imp_test.jac:10:4-10:6"),
-            (21, 58, "/py_imp_test.jac:11:8-11:15"),
-            (21, 68, "/pygame_mock/constants.py:4:3-4:15"),
-            (23, 58, "/pygame_mock/constants.py:4:3-4:15"),
-        ]
-
-        for line, char, expected in positions:
-            with self.subTest(line=line, char=char):
-                self.assertIn(
-                    expected,
-                    str(lsp.get_definition(import_file, lspt.Position(line, char))),
-                )
-
-    @pytest.mark.xfail(reason="TODO: Fix the go to definition")
-    def test_go_to_definition_index_expr(self) -> None:
-        """Test that the go to definition is correct."""
-        lsp = JacLangServer()
-        workspace_path = self.fixture_abs_path("")
-        workspace = Workspace(workspace_path, lsp)
-        lsp.lsp._workspace = workspace
-        import_file = uris.from_fs_path(
-            self.fixture_abs_path("../../../../jaclang/tests/fixtures/index_slice.jac")
-        )
-        lsp.deep_check(import_file)
-        positions = [
-            (23, 20, "index_slice.jac:2:8-2:13"),
-            (24, 24, "index_slice.jac:2:8-2:13"),
-            (27, 33, "index_slice.jac:2:8-2:13"),
-        ]
-
-        for line, char, expected in positions:
-            with self.subTest(line=line, char=char):
-                print(str(lsp.get_definition(import_file, lspt.Position(line, char))))
-                self.assertIn(
-                    expected,
-                    str(lsp.get_definition(import_file, lspt.Position(line, char))),
-                )
-
-    @pytest.mark.xfail(reason="TODO: Fix when we have the type checker")
-    def test_sem_tokens(self) -> None:
-        """Test that the Semantic Tokens are generated correctly."""
-        lsp = JacLangServer()
-        workspace_path = self.fixture_abs_path("")
-        workspace = Workspace(workspace_path, lsp)
-        lsp.lsp._workspace = workspace
-        circle_file = uris.from_fs_path(self.fixture_abs_path("circle.jac"))
-        lsp.deep_check(circle_file)
-        sem_list = lsp.get_semantic_tokens(circle_file).data
-        expected_counts = [
-            ("<JacSemTokenType.VARIABLE: 8>, <JacSemTokenModifier.READONLY: 4>", 12),
-            (
-                "<JacSemTokenType.PROPERTY: 9>, <JacSemTokenModifier.DEFINITION: 2>,",
-                21,
-            ),
-            (
-                "<JacSemTokenType.PARAMETER: 7>, <JacSemTokenModifier.DECLARATION: 1>,",
-                5,
-            ),
-            (
-                "<JacSemTokenType.FUNCTION: 12>, <JacSemTokenModifier.DECLARATION: 1>,",
-                8,
-            ),
-            ("<JacSemTokenType.METHOD: 13>, <JacSemTokenModifier.DECLARATION: 1>", 6),
-            ("<JacSemTokenType.ENUM: 3>, <JacSemTokenModifier.DECLARATION: 1>,", 4),
-            ("<JacSemTokenType.CLASS: 2>, <JacSemTokenModifier.DECLARATION: ", 12),
-            (
-                "<JacSemTokenType.NAMESPACE: 0>, <JacSemTokenModifier.DEFINITION: 2>,",
-                3,
-            ),
-        ]
-        for token_type, expected_count in expected_counts:
-            self.assertEqual(str(sem_list).count(token_type), expected_count)
+  
 
     def test_completion(self) -> None:
         """Test that the completions are correct."""
@@ -417,167 +240,4 @@ def test_go_to_reference(self) -> None:
             for expected in expected_refs:
                 self.assertIn(expected, references)
 
-    @pytest.mark.xfail(reason="TODO: Fix when we have the type checker")
-    def test_py_type__definition(self) -> None:
-        """Test that the go to definition is correct for pythoon imports."""
-        lsp = JacLangServer()
-        workspace_path = self.fixture_abs_path("")
-        workspace = Workspace(workspace_path, lsp)
-        lsp.lsp._workspace = workspace
-        import_file = uris.from_fs_path(
-            self.fixture_abs_path(
-                "../../../../jaclang/compiler/passes/main/tests/fixtures/py_imp_test.jac"
-            )
-        )
-        lsp.deep_check(import_file)
-        positions = [
-            (19, 29, "pygame_mock/color.py:0:0-2:4"),
-            (3, 17, "/pygame_mock/__init__.py:0:0-0:0"),
-            (20, 45, "pygame_mock/color.py:0:0-2:4"),
-            (19, 77, "mock/constants.py:4:3-4:15"),
-            (26, 28, "mock/display.py:0:0-1:7"),
-            (24, 22, "vendor/mypy/typeshed/stdlib/argparse.pyi:125:0-256:13"),
-            (19, 74, "pygame_mock/constants.py:4:3-4:15"),
-            # TODO: Need to properly support this
-            # (27, 17, "/stdlib/os/__init__.pyi:50:0-50:3"),
-        ]
-
-        for line, char, expected in positions:
-            with self.subTest(line=line, char=char):
-                self.assertIn(
-                    expected,
-                    str(lsp.get_definition(import_file, lspt.Position(line, char))),
-                    msg=positions.index((line, char, expected)) + 1,
-                )
-
-    @pytest.mark.xfail(reason="TODO: Fix when we have the type checker")
-    def test_py_type__references(self) -> None:
-        """Test that the go to definition is correct for pythoon imports."""
-        lsp = JacLangServer()
-        workspace_path = self.fixture_abs_path("")
-        workspace = Workspace(workspace_path, lsp)
-        lsp.lsp._workspace = workspace
-
-        circle_file = uris.from_fs_path(
-            self.fixture_abs_path(
-                "../../../../jaclang/compiler/passes/main/tests/fixtures/py_imp_test.jac"
-            )
-        )
-        lsp.deep_check(circle_file)
-        test_cases = [
-            (
-                2,
-                21,
-                [
-                    ":6:21-6:32",
-                    ":7:11-7:22",
-                    ":11:25-11:36",
-                    ":12:15-12:26",
-                    ":18:33-18:44",
-                    "19:46-19:57",
-                    ":19:8-19:19",
-                    ":19:46-19:57",
-                    ":20:8-20:19",
-                    "21:8-21:19,",
-                    "23:8-23:19",
-                    ":26:4-26:15",
-                ],
-            ),
-            (
-                19,
-                63,
-                [
-                    "6:33-6:42",
-                    "7:23-7:32",
-                    "18:45-18:54",
-                    "19:58-19:67",
-                    "11:37-11:46",
-                    "12:27-12:36",
-                ],
-            ),
-            (
-                24,
-                53,
-                [
-                    "24:42-24:56",
-                    "24:16-24:30",
-                    "argparse.pyi:358:21-358:35",
-                    "argparse.pyi:164:29-164:43",
-                    "argparse.pyi:32:52-32:66",
-                ],
-            ),
-        ]
-        for line, char, expected_refs in test_cases:
-            references = str(lsp.get_references(circle_file, lspt.Position(line, char)))
-            for expected in expected_refs:
-                self.assertIn(expected, references)
-
-    @pytest.mark.xfail(reason="TODO: Fix when we have the type checker")
-    def test_rename_symbol(self) -> None:
-        """Test that the rename is correct."""
-        lsp = JacLangServer()
-        workspace_path = self.fixture_abs_path("")
-        workspace = Workspace(workspace_path, lsp)
-        lsp.lsp._workspace = workspace
 
-        circle_file = uris.from_fs_path(self.fixture_abs_path("circle.jac"))
-        lsp.deep_check(circle_file)
-        test_cases = [
-            (
-                20,
-                14,
-                "ShapeKind",
-                "27:20-27:29,",
-                "36:19-36:28",
-                "75:26-75:35",
-                "20:5-20:14",
-            ),
-            (12, 34, "circleRadius", "12:21-12:27", "12:30-12:36", "11:19-11:25"),
-            (62, 14, "target_area", "65:43-65:56", "70:32-70:45", "62:5-62:18"),
-            (57, 33, "type_of_shape", "75:12-75:22", "27:8-27:18,", "57:23-57:33"),
-        ]
-        for tup in test_cases:
-            line, char, new_name, *expected_refs = tup
-            references = str(
-                lsp.rename_symbol(circle_file, lspt.Position(line, char), new_name)
-            )
-            for expected in expected_refs:
-                self.assertIn(expected, references)
-
-    @pytest.mark.xfail(reason="TODO: Fix when we have the type checker")
-    def test_rename_uses(self) -> None:
-        """Test that the rename is correct."""
-        lsp = JacLangServer()
-        workspace_path = self.fixture_abs_path("")
-        workspace = Workspace(workspace_path, lsp)
-        lsp.lsp._workspace = workspace
-
-        circle_file = uris.from_fs_path(self.fixture_abs_path("rename.jac"))
-        lsp.deep_check(circle_file)
-        # fmt: off
-        test_cases = [
-            (0, 7, "func", "25:4-25:7", "0:4-0:7", "4:5-4:8",),
-            (4, 8, "func", "25:4-25:7", "0:4-0:7", "4:5-4:8",),
-            (25, 6, "func", "25:4-25:7", "0:4-0:7", "4:5-4:8",),
-            (10, 10, "canBar", "27:8-27:11", "10:8-10:11"),
-            (27, 9, "canBar", "27:8-27:11", "10:8-10:11"),
-            (9, 6, "canBar", "26:10-26:13", "28:4-28:7", "16:5-16:8", "9:4-9:7"),
-            (26, 11, "canBar", "26:10-26:13", "28:4-28:7", "16:5-16:8", "9:4-9:7"),
-            (16, 8, "canBar", "26:10-26:13", "28:4-28:7", "16:5-16:8", "9:4-9:7"),
-            (28, 6, "canBar", "26:10-26:13", "28:4-28:7", "16:5-16:8", "9:4-9:7"),
-            (11, 10, "canBar", "11:8-11:11", "16:9-16:12", "28:11-28:14"),
-            (16, 12, "canBar", "11:8-11:11", "16:9-16:12", "28:11-28:14"),
-            (28, 13, "canBar", "11:8-11:11", "16:9-16:12", "28:11-28:14"),
-            (12, 10, "canBaz", "12:8-12:11", "20:9-20:12"),
-            (20, 12, "canBaz", "12:8-12:11", "20:9-20:12"),
-            (26, 6, "count", "27:4-27:7", "26:4-26:7"),
-            (27, 5, "count", "27:4-27:7", "26:4-26:7"),
-        ]
-        # fmt: on
-        for tup in test_cases:
-            line, char, new_name, *expected_refs = tup
-            references = str(
-                lsp.rename_symbol(circle_file, lspt.Position(line, char), new_name)
-            )
-            for expected in expected_refs:
-                self.assertIn(expected, references)
diff --git a/jac/jaclang/runtimelib/client_bundle.py b/jac/jaclang/runtimelib/client_bundle.py
new file mode 100644
index 0000000000..ca30dadc0c
--- /dev/null
+++ b/jac/jaclang/runtimelib/client_bundle.py
@@ -0,0 +1,291 @@
+"""Client bundle generation utilities for Jac web front-ends."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from types import ModuleType
+from typing import Any, Iterable, Sequence
+
+from jaclang.compiler.program import JacProgram
+
+
+class ClientBundleError(RuntimeError):
+    """Raised when the client bundle cannot be generated."""
+
+
+@dataclass(slots=True)
+class ClientBundle:
+    """Container for a compiled client bundle."""
+
+    module_name: str
+    code: str
+    client_functions: list[str]
+    client_globals: list[str]
+    hash: str
+
+
+@dataclass(slots=True)
+class _CachedBundle:
+    signature: str
+    bundle: ClientBundle
+
+
+class ClientBundleBuilder:
+    """Compile Jac modules and runtime support into a browser-ready bundle."""
+
+    def __init__(self, runtime_path: Path | None = None) -> None:
+        """Initialise the builder with an optional override for the runtime path."""
+        self.runtime_path = runtime_path or Path(__file__).with_name(
+            "client_runtime.jac"
+        )
+        self._cache: dict[str, _CachedBundle] = {}
+
+    def build(self, module: ModuleType, force: bool = False) -> ClientBundle:
+        """Build (or reuse) a client bundle for the supplied module."""
+        # Derive source path from module __file__ (replace .py with .jac)
+        if not hasattr(module, "__file__") or not module.__file__:
+            raise ClientBundleError(
+                f"Module '{module.__name__}' has no __file__ attribute"
+            )
+        module_path = module.__file__.replace(".py", ".jac")
+
+        source_path = Path(module_path).resolve()
+        runtime_path = self.runtime_path.resolve()
+        signature = self._signature([source_path, runtime_path])
+
+        cached = self._cache.get(module.__name__)
+        if not force and cached and cached.signature == signature:
+            return cached.bundle
+
+        bundle = self._compile_bundle(module, source_path, runtime_path)
+        self._cache[module.__name__] = _CachedBundle(signature=signature, bundle=bundle)
+        return bundle
+
+    def _compile_bundle(
+        self,
+        module: ModuleType,
+        module_path: Path,
+        runtime_path: Path,
+    ) -> ClientBundle:
+        """Compile bundle pieces and stitch them together."""
+        runtime_js = self._compile_to_js(runtime_path)
+
+        # Get manifest from JacProgram instead of module attribute
+        from jaclang.runtimelib.machine import JacMachine as Jac
+
+        manifest = Jac.program.get_client_manifest(str(module_path)) or {}
+        manifest_exports = manifest.get("exports", [])
+        manifest_globals = manifest.get("globals", [])
+        manifest_globals_values = manifest.get("globals_values", {})
+        module_js = self._compile_to_js(module_path)
+
+        client_exports = list(manifest_exports)
+
+        client_globals_list = list(manifest_globals) if manifest_globals else []
+
+        client_globals_map: dict[str, Any] = {}
+        for name in client_globals_list:
+            if name in manifest_globals_values:
+                client_globals_map[name] = manifest_globals_values[name]
+            elif hasattr(module, name):
+                client_globals_map[name] = getattr(module, name)
+            else:
+                client_globals_map[name] = None
+
+        client_exports = sorted(dict.fromkeys(client_exports))
+        client_globals_map = {
+            key: client_globals_map[key] for key in sorted(client_globals_map)
+        }
+
+        registration_js = self._generate_registration_js(
+            module.__name__, client_exports, client_globals_map
+        )
+
+        # Add Object.prototype.get polyfill for Python dict-like behavior
+        polyfill_js = (
+            "// Polyfill: Add .get() method to objects for Python dict-like behavior\n"
+            "if (!Object.prototype.get) {\n"
+            "  Object.prototype.get = function(key, defaultValue) {\n"
+            "    return this.hasOwnProperty(key) ? this[key] : (defaultValue !== undefined ? defaultValue : null);\n"
+            "  };\n"
+            "}\n"
+        )
+
+        bundle_pieces = [
+            polyfill_js,
+            "// Jac client runtime",
+            runtime_js,
+            "",
+            f"// Client module: {module.__name__}",
+            module_js,
+            "",
+            registration_js,
+        ]
+        bundle_code = "\n".join(piece for piece in bundle_pieces if piece is not None)
+        bundle_hash = hashlib.sha256(bundle_code.encode("utf-8")).hexdigest()
+
+        return ClientBundle(
+            module_name=module.__name__,
+            code=bundle_code,
+            client_functions=client_exports,
+            client_globals=list(client_globals_map.keys()),
+            hash=bundle_hash,
+        )
+
+    def _compile_to_js(self, source_path: Path) -> str:
+        """Compile the provided Jac file into JavaScript."""
+        program = JacProgram()
+        mod = program.compile(str(source_path))
+        if program.errors_had:
+            formatted = "\n".join(str(err) for err in program.errors_had)
+            raise ClientBundleError(
+                f"Failed to compile '{source_path}' for client bundle:\n{formatted}"
+            )
+        return mod.gen.js or ""
+
+    @staticmethod
+    def _signature(paths: Iterable[Path]) -> str:
+        """Compute a cache signature based on file modification times."""
+        parts: list[str] = []
+        for path in paths:
+            try:
+                stat = path.stat()
+                parts.append(f"{path}:{stat.st_mtime_ns}")
+            except FileNotFoundError:
+                parts.append(f"{path}:missing")
+        return hashlib.sha256("|".join(parts).encode("utf-8")).hexdigest()
+
+    @staticmethod
+    def _generate_registration_js(
+        module_name: str,
+        client_functions: Sequence[str],
+        client_globals: dict[str, Any],
+    ) -> str:
+        """Generate registration code that exposes client symbols globally."""
+        lines: list[str] = [
+            "(function registerJacClientModule(){",
+            "  const scope = typeof globalThis !== 'undefined' ? globalThis : window;",
+            "  const registry = scope.__jacClient || (scope.__jacClient ="
+            " { functions: {}, globals: {}, modules: {} });",
+            "  const moduleFunctions = {};",
+            "  const moduleGlobals = {};",
+        ]
+
+        for name in client_functions:
+            lines.append(f"  moduleFunctions[{json.dumps(name)}] = {name};")
+            lines.append(f"  scope[{json.dumps(name)}] = {name};")
+        for name, value in client_globals.items():
+            identifier = json.dumps(name)
+            try:
+                value_literal = json.dumps(value)
+            except TypeError:
+                value_literal = "null"
+            lines.append(f"  if (typeof {name} !== 'undefined') {{")
+            lines.append(f"    moduleGlobals[{identifier}] = {name};")
+            lines.append(f"    scope[{identifier}] = {name};")
+            lines.append("  } else {")
+            lines.append(f"    moduleGlobals[{identifier}] = {value_literal};")
+            lines.append(f"    scope[{identifier}] = {value_literal};")
+            lines.append("  }")
+
+        lines.append(f"  registry.modules[{json.dumps(module_name)}] = {{")
+        lines.append(f"    functions: {json.dumps(list(client_functions))},")
+        lines.append(f"    globals: {json.dumps(list(client_globals.keys()))}")
+        lines.append("  };")
+        lines.append("  registry.state = registry.state || {};")
+        lines.append("  registry.state.globals = registry.state.globals || {};")
+        lines.append("  Object.assign(registry.functions, moduleFunctions);")
+        lines.append("  Object.assign(registry.globals, moduleGlobals);")
+        lines.append("  Object.assign(scope, moduleGlobals);")
+        lines.append("  function hydrateJacClient(){")
+        lines.append("    if (typeof document === 'undefined') { return; }")
+        lines.append("    const initEl = document.getElementById('__jac_init__');")
+        lines.append("    const rootEl = document.getElementById('__jac_root');")
+        lines.append(
+            "    if (!initEl || !rootEl || initEl.dataset.jacHydrated === 'true') { return; }"
+        )
+        lines.append("    initEl.dataset.jacHydrated = 'true';")
+        lines.append("    let payload;")
+        lines.append("    try {")
+        lines.append("      payload = JSON.parse(initEl.textContent || '{}');")
+        lines.append("    } catch (err) {")
+        lines.append(
+            "      console.error('[Jac] Failed to parse hydration payload', err);"
+        )
+        lines.append("      return;")
+        lines.append("    }")
+        lines.append("    if (!payload || !payload.function) { return; }")
+        lines.append(
+            f"    const moduleName = payload.module || {json.dumps(module_name)};"
+        )
+        lines.append(
+            "    const argsOrder = Array.isArray(payload.argOrder) ? payload.argOrder : [];"
+        )
+        lines.append("    const argsDict = payload.args || {};")
+        lines.append("    const orderedArgs = argsOrder.map((name) => argsDict[name]);")
+        lines.append("    const targetName = payload.function;")
+        lines.append(
+            "    const target = moduleFunctions[targetName] || registry.functions[targetName];"
+        )
+        lines.append("    if (typeof target !== 'function') {")
+        lines.append(
+            "      console.error('[Jac] Client function not found:', targetName);"
+        )
+        lines.append("      return;")
+        lines.append("    }")
+        lines.append("    registry.state.globals[moduleName] = payload.globals || {};")
+        lines.append(
+            "    for (const [gName, gValue] of Object.entries(payload.globals || {})) {"
+        )
+        lines.append("      scope[gName] = gValue;")
+        lines.append("    }")
+        lines.append("    const applyRender = (node) => {")
+        lines.append(
+            "      const renderer = scope.renderJsxTree || "
+            "(typeof renderJsxTree === 'function' ? renderJsxTree : null);"
+        )
+        lines.append("      if (!renderer) {")
+        lines.append(
+            "        console.warn('[Jac] renderJsxTree is not available in client bundle');"
+        )
+        lines.append("        return;")
+        lines.append("      }")
+        lines.append("      try {")
+        lines.append("        renderer(node, rootEl);")
+        lines.append("      } catch (err) {")
+        lines.append("        console.error('[Jac] Failed to render JSX tree', err);")
+        lines.append("      }")
+        lines.append("    };")
+        lines.append("    let result;")
+        lines.append("    try {")
+        lines.append("      result = target.apply(scope, orderedArgs);")
+        lines.append("    } catch (err) {")
+        lines.append(
+            "      console.error('[Jac] Error executing client function', targetName, err);"
+        )
+        lines.append("      return;")
+        lines.append("    }")
+        lines.append("    if (result && typeof result.then === 'function') {")
+        lines.append("      result.then(applyRender).catch((err) => {")
+        lines.append(
+            "        console.error('[Jac] Error resolving client function promise', err);"
+        )
+        lines.append("      });")
+        lines.append("    } else {")
+        lines.append("      applyRender(result);")
+        lines.append("    }")
+        lines.append("  }")
+        lines.append("  if (typeof document !== 'undefined') {")
+        lines.append("    if (document.readyState === 'loading') {")
+        lines.append(
+            "      document.addEventListener('DOMContentLoaded', hydrateJacClient, { once: true });"
+        )
+        lines.append("    } else {")
+        lines.append("      hydrateJacClient();")
+        lines.append("    }")
+        lines.append("  }")
+        lines.append("})();")
+        return "\n".join(lines)
diff --git a/jac/jaclang/runtimelib/client_runtime.jac b/jac/jaclang/runtimelib/client_runtime.jac
new file mode 100644
index 0000000000..7bdefa7a35
--- /dev/null
+++ b/jac/jaclang/runtimelib/client_runtime.jac
@@ -0,0 +1,186 @@
+"""Client-side runtime for Jac JSX and walker interactions."""
+
+# JSX factory function
+cl def __jacJsx(tag: any, props: dict = {}, children: list = []) -> dict {
+    return {"tag": tag, "props": props, "children": children};
+}
+
+# DOM rendering function
+cl def renderJsxTree(node: any, container: any) -> None {
+    container.replaceChildren(__buildDom(node));
+}
+
+# Internal: Build DOM from JSX tree
+cl def __buildDom(node: any) -> any {
+    if node == None {
+        return __createTextNode("");
+    }
+
+    if not __isObject(node) {
+        return __createTextNode(__toString(node));
+    }
+
+    # Handle component functions
+    tag = node.get("tag");
+    if __isFunction(tag) {
+        props = node.get("props", {});
+        return __buildDom(tag(props));
+    }
+
+    # Create element
+    element = __createElement(tag if tag else "div");
+
+    # Apply properties
+    props = node.get("props", {});
+    for key in __objectKeys(props) {
+        value = props.get(key);
+        __applyProp(element, key, value);
+    }
+
+    # Render children
+    children = node.get("children", []);
+    for child in children {
+        childDom = __buildDom(child);
+        if childDom {
+            element.appendChild(childDom);
+        }
+    }
+
+    return element;
+}
+
+# Internal: Apply property to DOM element
+cl def __applyProp(element: any, key: str, value: any) -> None {
+    if key.startswith("on") {
+        # Event handler: onclick -> click
+        event = key[2:].lower();
+        element.addEventListener(event, value);
+    } elif key == "className" or key == "class" {
+        element.className = value;
+    } elif key == "style" and __isObject(value) {
+        # Style object
+        for styleKey in __objectKeys(value) {
+            element.style[styleKey] = value.get(styleKey);
+        }
+    } elif key != "children" {
+        element.setAttribute(key, __toString(value));
+    }
+}
+
+# Walker spawn function
+cl async def __jacSpawn(walker: str, fields: dict = {}) -> any {
+    token = __getLocalStorage("jac_token");
+
+    response = await __fetch(
+        f"/walker/{walker}",
+        {
+            "method": "POST",
+            "headers": {
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {token}" if token else ""
+            },
+            "body": __jsonStringify({"nd": "root", **fields})
+        }
+    );
+
+    if not response.ok {
+        error_text = await response.text();
+        raise Exception(f"Walker {walker} failed: {error_text}");
+    }
+
+    return __jsonParse(await response.text());
+}
+
+# Authentication helpers
+cl async def jacLogin(username: str, password: str) -> bool {
+    response = await __fetch(
+        "/user/login",
+        {
+            "method": "POST",
+            "headers": {"Content-Type": "application/json"},
+            "body": __jsonStringify({"username": username, "password": password})
+        }
+    );
+
+    if response.ok {
+        data = __jsonParse(await response.text());
+        token = data.get("token");
+        if token {
+            __setLocalStorage("jac_token", token);
+            return True;
+        }
+    }
+    return False;
+}
+
+cl def jacLogout() -> None {
+    __removeLocalStorage("jac_token");
+}
+
+cl def jacIsLoggedIn() -> bool {
+    token = __getLocalStorage("jac_token");
+    return token != None and token != "";
+}
+
+# Browser API shims
+cl async def __fetch(url: str, options: dict = {}) -> any {
+    fetch_opts = options if options else {};
+    return await fetch(url, fetch_opts);
+}
+
+cl def __getLocalStorage(key: str) -> str {
+    storage = globalThis.localStorage;
+    return storage.getItem(key) if storage else "";
+}
+
+cl def __setLocalStorage(key: str, value: str) -> None {
+    storage = globalThis.localStorage;
+    if storage {
+        storage.setItem(key, value);
+    }
+}
+
+cl def __removeLocalStorage(key: str) -> None {
+    storage = globalThis.localStorage;
+    if storage {
+        storage.removeItem(key);
+    }
+}
+
+cl def __jsonStringify(obj: any) -> str {
+    return JSON.stringify(obj);
+}
+
+cl def __jsonParse(text: str) -> any {
+    return JSON.parse(text);
+}
+
+cl def __createElement(tag: str) -> any {
+    return document.createElement(tag);
+}
+
+cl def __createTextNode(text: str) -> any {
+    return document.createTextNode(text);
+}
+
+cl def __isObject(value: any) -> bool {
+    if value == None {
+        return False;
+    }
+    return Object.prototype.toString.call(value) == "[object Object]";
+}
+
+cl def __isFunction(value: any) -> bool {
+    return Object.prototype.toString.call(value) == "[object Function]";
+}
+
+cl def __toString(value: any) -> str {
+    return String(value);
+}
+
+cl def __objectKeys(obj: any) -> list {
+    if obj == None {
+        return [];
+    }
+    return Object.keys(obj);
+}
diff --git a/jac/jaclang/runtimelib/machine.py b/jac/jaclang/runtimelib/machine.py
index bc32c1a326..605ef33970 100644
--- a/jac/jaclang/runtimelib/machine.py
+++ b/jac/jaclang/runtimelib/machine.py
@@ -10,6 +10,7 @@
 import tempfile
 import types
 from collections import OrderedDict
+from collections.abc import Mapping, Sequence
 from concurrent.futures import Future, ThreadPoolExecutor
 from dataclasses import MISSING, dataclass, field
 from functools import wraps
@@ -1105,6 +1106,30 @@ def test_deco() -> None:
 
         return test_deco
 
+    @staticmethod
+    def jsx(
+        tag: object,
+        attributes: Mapping[str, object] | None = None,
+        children: Sequence[object] | None = None,
+    ) -> dict[str, object]:
+        """JSX interface for creating elements.
+
+        Args:
+            tag: Element tag (string for HTML elements, callable for components)
+            attributes: Element attributes/props
+            children: Child elements
+
+        Returns:
+            JSX element representation (implementation-defined)
+        """
+        props: dict[str, object] = dict(attributes) if attributes else {}
+        child_list = list(children) if children else []
+        return {
+            "tag": tag,
+            "props": props,
+            "children": child_list,
+        }
+
     @staticmethod
     def run_test(
         filepath: str,
diff --git a/jac/jaclang/runtimelib/server.py b/jac/jaclang/runtimelib/server.py
index 6872e79458..1c51236327 100644
--- a/jac/jaclang/runtimelib/server.py
+++ b/jac/jaclang/runtimelib/server.py
@@ -1,6 +1,7 @@
 """REST API Server for Jac Programs."""
 
 import hashlib
+import html
 import inspect
 import json
 import os
@@ -8,8 +9,9 @@
 from contextlib import suppress
 from http.server import BaseHTTPRequestHandler, HTTPServer
 from typing import Any, Callable, Optional, get_type_hints
-from urllib.parse import urlparse
+from urllib.parse import parse_qs, urlparse
 
+from jaclang.runtimelib.client_bundle import ClientBundleBuilder, ClientBundleError
 from jaclang.runtimelib.constructs import (
     Archetype,
     NodeArchetype,
@@ -202,7 +204,14 @@ def __init__(
         port: int = 8000,
         base_path: str | None = None,
     ) -> None:
-        """Initialize the API server."""
+        """Initialize the API server.
+
+        Args:
+            module_name: Name of the module to serve
+            session_path: Path to session storage
+            port: Port to listen on
+            base_path: Base path for module imports
+        """
         self.module_name = module_name
         self.session_path = session_path
         self.port = port
@@ -211,6 +220,14 @@ def __init__(
         self.module = None
         self._function_cache: dict[str, Callable] = {}
         self._walker_cache: dict[str, type[WalkerArchetype]] = {}
+        self._client_functions: dict[str, Callable] = {}
+        self._client_exports: list[str] = []
+        self._client_globals: dict[str, Any] = {}
+        self._client_manifest: dict[str, Any] = {}
+        self._client_params: dict[str, list[str]] = {}
+        self._client_bundle_builder = ClientBundleBuilder()
+        self._client_bundle = None
+        self._client_bundle_error: Optional[str] = None
 
     def load_module(self, force_reload: bool = False) -> None:
         """Load the target module if necessary and refresh caches."""
@@ -236,8 +253,20 @@ def load_module(self, force_reload: bool = False) -> None:
             or (not self._function_cache and not self._walker_cache)
         ):
             self.module = module
+            # Get manifest from JacProgram instead of module attribute
+            mod_path = getattr(module, "__file__", None)
+            if mod_path:
+                manifest = Jac.program.get_client_manifest(mod_path)
+            else:
+                manifest = {}
+            self._client_manifest = manifest
+            self._client_exports = list(manifest.get("exports", []))
+            self._client_params = manifest.get("params", {})
             self._function_cache = self._collect_functions()
             self._walker_cache = self._collect_walkers()
+            self._client_globals = self._collect_client_globals()
+            self._client_bundle = None
+            self._client_bundle_error = None
 
     def get_functions(self) -> dict[str, Callable]:
         """Get all functions from the module."""
@@ -251,11 +280,107 @@ def get_walkers(self) -> dict[str, type[WalkerArchetype]]:
             self.load_module()
         return dict(self._walker_cache)
 
+    def get_client_functions(self) -> dict[str, Callable]:
+        """Return functions marked for client rendering."""
+        if not self._client_functions:
+            self.load_module()
+        return dict(self._client_functions)
+
+    def render_client_page(
+        self,
+        function_name: str,
+        args: dict[str, Any],
+        username: str,
+    ) -> dict[str, Any]:
+        """Render a client-marked function to HTML (non-HTTP helper).
+
+        Args:
+            function_name: Name of the client function to render
+            args: Arguments to pass to the function
+            username: Username for authentication context
+        """
+        self.load_module()
+        available_exports = set(self._client_exports) or set(
+            self.get_client_functions().keys()
+        )
+        if function_name not in available_exports:
+            raise ValueError(f"Client function '{function_name}' not found")
+
+        html_body = ""  # Client renders everything in CSR mode
+        arg_order = list(self._client_params.get(function_name, []))
+
+        bundle_hash = self._ensure_client_bundle()
+        if not bundle_hash or not self._client_bundle:
+            error_msg = (
+                self._client_bundle_error
+                if self._client_bundle_error
+                else "Client bundle not available"
+            )
+            raise RuntimeError(error_msg)
+
+        module_name = self.module.__name__ if self.module else self.module_name
+        globals_payload = {
+            name: serialize_for_response(value)
+            for name, value in self._client_globals.items()
+        }
+        raw_args = {key: serialize_for_response(value) for key, value in args.items()}
+        initial_state = {
+            "module": module_name,
+            "function": function_name,
+            "args": raw_args,
+            "globals": globals_payload,
+            "argOrder": arg_order,
+        }
+        try:
+            initial_json = json.dumps(initial_state)
+        except TypeError:
+            serializable_args = {
+                key: serialize_for_response(value) for key, value in raw_args.items()
+            }
+            initial_state["args"] = serializable_args
+            initial_json = json.dumps(initial_state)
+        safe_initial_json = initial_json.replace("</", "<\\/")
+        page = (
+            "<!DOCTYPE html>"
+            '<html lang="en">'
+            "<head>"
+            '<meta charset="utf-8"/>'
+            f"<title>{html.escape(function_name)}</title>"
+            "</head>"
+            "<body>"
+            f'<div id="__jac_root">{html_body}</div>'
+            f'<script id="__jac_init__" type="application/json">{safe_initial_json}</script>'
+            f'<script src="/static/client.js?hash={self._client_bundle.hash}" defer></script>'
+            "</body>"
+            "</html>"
+        )
+
+        return {
+            "html": page,
+            "bundle_hash": self._client_bundle.hash,
+            "bundle_code": self._client_bundle.code,
+        }
+
+    def get_client_bundle_code(self) -> str:
+        """Return the current client bundle JavaScript."""
+        self.load_module()
+        bundle_hash = self._ensure_client_bundle()
+        if not bundle_hash or not self._client_bundle:
+            error_msg = (
+                self._client_bundle_error
+                if self._client_bundle_error
+                else "Client bundle not available"
+            )
+            raise RuntimeError(error_msg)
+        return self._client_bundle.code
+
     def _collect_functions(self) -> dict[str, Callable]:
         """Collect callable functions from the module."""
         if not self.module:
             return {}
         functions = {}
+        client_functions: dict[str, Callable] = {}
+        export_names = set(self._client_exports)
         for name, obj in inspect.getmembers(self.module):
             if (
                 inspect.isfunction(obj)
@@ -263,6 +388,17 @@ def _collect_functions(self) -> dict[str, Callable]:
                 and obj.__module__ == self.module.__name__
             ):
                 functions[name] = obj
+                should_include = name in export_names
+                if should_include:
+                    client_functions[name] = obj
+
+        # Ensure manifest-defined exports exist in the client function map
+        for name in export_names:
+            if name not in client_functions and hasattr(self.module, name):
+                attr = getattr(self.module, name)
+                if callable(attr):
+                    client_functions[name] = attr
+        self._client_functions = client_functions
         return functions
 
     def _collect_walkers(self) -> dict[str, type[WalkerArchetype]]:
@@ -280,6 +416,22 @@ def _collect_walkers(self) -> dict[str, type[WalkerArchetype]]:
                 walkers[name] = obj
         return walkers
 
+    def _collect_client_globals(self) -> dict[str, Any]:
+        """Collect client-exposed global values."""
+        if not self.module:
+            return {}
+        result: dict[str, Any] = {}
+        names = self._client_manifest.get("globals") or []
+        values_map = self._client_manifest.get("globals_values", {})
+        for name in names:
+            if name in values_map:
+                result[name] = values_map[name]
+            elif hasattr(self.module, name):
+                result[name] = getattr(self.module, name)
+            else:
+                result[name] = None
+        return result
+
     def introspect_callable(self, func: Callable) -> dict[str, Any]:
         """Introspect a callable and return its signature."""
         try:
@@ -344,6 +496,22 @@ def introspect_walker(self, walker_cls: type[WalkerArchetype]) -> dict[str, Any]
 
         return {"fields": fields}
 
+    def _ensure_client_bundle(self) -> Optional[str]:
+        """Ensure a client bundle is available and return the bundle hash."""
+        if not self.module:
+            return None
+        if self._client_bundle:
+            return self._client_bundle.hash
+        try:
+            bundle = self._client_bundle_builder.build(self.module)
+        except ClientBundleError as exc:
+            self._client_bundle = None
+            self._client_bundle_error = str(exc)
+            return None
+        self._client_bundle = bundle
+        self._client_bundle_error = None
+        return bundle.hash
+
     def call_function(
         self,
         func: Callable,
@@ -443,6 +611,25 @@ def _send_json_response(self, status_code: int, data: dict) -> None:
                 self.end_headers()
                 self.wfile.write(json.dumps(data).encode())
 
+            def _send_html_response(
+                self,
+                status_code: int,
+                body: str,
+                content_type: str = "text/html; charset=utf-8",
+            ) -> None:
+                """Send an HTML response."""
+                payload = body.encode("utf-8")
+                self.send_response(status_code)
+                self.send_header("Content-Type", content_type)
+                self.send_header("Content-Length", str(len(payload)))
+                self.send_header("Access-Control-Allow-Origin", "*")
+                self.send_header("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
+                self.send_header(
+                    "Access-Control-Allow-Headers", "Content-Type, Authorization"
+                )
+                self.end_headers()
+                self.wfile.write(payload)
+
             def _get_auth_token(self) -> Optional[str]:
                 """Extract auth token from Authorization header."""
                 auth_header = self.headers.get("Authorization")
@@ -472,6 +659,30 @@ def do_GET(self) -> None:  # noqa: N802
                 parsed_path = urlparse(self.path)
                 path = parsed_path.path
 
+                if path == "/static/client.js":
+                    try:
+                        bundle_code = server.get_client_bundle_code()
+                    except RuntimeError as exc:
+                        self._send_json_response(503, {"error": str(exc)})
+                        return
+                    payload = bundle_code.encode("utf-8")
+                    self.send_response(200)
+                    self.send_header(
+                        "Content-Type", "application/javascript; charset=utf-8"
+                    )
+                    self.send_header("Content-Length", str(len(payload)))
+                    self.send_header("Cache-Control", "no-cache")
+                    self.send_header("Access-Control-Allow-Origin", "*")
+                    self.send_header(
+                        "Access-Control-Allow-Methods", "GET, POST, OPTIONS"
+                    )
+                    self.send_header(
+                        "Access-Control-Allow-Headers", "Content-Type, Authorization"
+                    )
+                    self.end_headers()
+                    self.wfile.write(payload)
+                    return
+
                 # Public endpoints
                 if path == "/":
                     self._send_json_response(
@@ -487,11 +698,48 @@ def do_GET(self) -> None:  # noqa: N802
                                 "GET /walker/<name>": "Get walker fields",
                                 "POST /function/<name>": "Call a function",
                                 "POST /walker/<name>": "Spawn a walker",
+                                "GET /page/<function_name>": "Render HTML page for a client function",
+                                "GET /static/client.js": "Retrieve the compiled client bundle",
                             },
                         },
                     )
                     return
 
+                # Handle /page/ endpoints (may be public or protected)
+                if path.startswith("/page/"):
+                    func_name = path.split("/")[-1]
+                    query_params = parse_qs(parsed_path.query, keep_blank_values=True)
+
+                    # Build args dict excluding the 'mode' parameter
+                    args: dict[str, Any] = {
+                        key: values[0] if len(values) == 1 else values
+                        for key, values in query_params.items()
+                        if key != "mode"
+                    }
+
+                    # Try to authenticate, but allow unauthenticated access
+                    # Client pages will use a guest user if not authenticated
+                    username = self._authenticate()
+                    if not username:
+                        # Create or use guest user for unauthenticated requests
+                        username = "__guest__"
+                        if username not in server.user_manager.users:
+                            server.user_manager.create_user(username, "__no_password__")
+
+                    try:
+                        render_payload = server.render_client_page(
+                            func_name, args, username
+                        )
+                    except ValueError as exc:
+                        self._send_json_response(404, {"error": str(exc)})
+                        return
+                    except RuntimeError as exc:
+                        self._send_json_response(503, {"error": str(exc)})
+                        return
+
+                    self._send_html_response(200, render_payload["html"])
+                    return
+
                 # Protected endpoints require authentication
                 username = self._authenticate()
                 if not username:
@@ -560,6 +808,30 @@ def do_GET(self) -> None:  # noqa: N802
                         )
                     return
 
+                elif path.startswith("/page/"):
+                    func_name = path.split("/")[-1]
+                    query_params = parse_qs(parsed_path.query, keep_blank_values=True)
+
+                    # Build args dict excluding the 'mode' parameter
+                    pargs: dict[str, Any] = {
+                        key: values[0] if len(values) == 1 else values
+                        for key, values in query_params.items()
+                        if key != "mode"
+                    }
+                    try:
+                        render_payload = server.render_client_page(
+                            func_name, pargs, username
+                        )
+                    except ValueError as exc:
+                        self._send_json_response(404, {"error": str(exc)})
+                        return
+                    except RuntimeError as exc:
+                        self._send_json_response(503, {"error": str(exc)})
+                        return
+
+                    self._send_html_response(200, render_payload["html"])
+                    return
+
                 self._send_json_response(404, {"error": "Not found"})
 
             def do_POST(self) -> None:  # noqa: N802
diff --git a/jac/jaclang/runtimelib/tests/fixtures/client_app.jac b/jac/jaclang/runtimelib/tests/fixtures/client_app.jac
new file mode 100644
index 0000000000..2d8f1d8910
--- /dev/null
+++ b/jac/jaclang/runtimelib/tests/fixtures/client_app.jac
@@ -0,0 +1,18 @@
+"""Sample Jac module containing client-side declarations."""
+
+cl let API_LABEL: str = "Runtime Test";
+
+cl obj ButtonProps {
+    has label: str = "Tap Me";
+    has color: str = "primary";
+}
+
+cl def client_page() {
+    let props = ButtonProps(label="Tap Me", color="primary");
+    return <div class="app">
+        <h1>{API_LABEL}</h1>
+        <button class={props.color} data-id="button">
+            {props.label}
+        </button>
+    </div>;
+}
diff --git a/jac/jaclang/runtimelib/tests/fixtures/serve_api.jac b/jac/jaclang/runtimelib/tests/fixtures/serve_api.jac
index 478d7d0ead..590c8b88f9 100644
--- a/jac/jaclang/runtimelib/tests/fixtures/serve_api.jac
+++ b/jac/jaclang/runtimelib/tests/fixtures/serve_api.jac
@@ -64,3 +64,12 @@ def add_numbers(a: int, b: int) -> int {
 def greet(name: str = "World") -> str {
     return "Hello, " + name + "!";
 }
+
+cl let WELCOME_TITLE: str = "Runtime Test";
+
+cl def client_page() {
+    return <section class="welcome">
+        <h1>{WELCOME_TITLE}</h1>
+        <p>{greet()}</p>
+    </section>;
+}
diff --git a/jac/jaclang/runtimelib/tests/test_client_bundle.py b/jac/jaclang/runtimelib/tests/test_client_bundle.py
new file mode 100644
index 0000000000..a225f030ca
--- /dev/null
+++ b/jac/jaclang/runtimelib/tests/test_client_bundle.py
@@ -0,0 +1,49 @@
+"""Tests for client bundle generation."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from jaclang.runtimelib.client_bundle import ClientBundleBuilder
+from jaclang.runtimelib.machine import JacMachine as Jac
+from jaclang.utils.test import TestCase
+
+
+class ClientBundleBuilderTests(TestCase):
+    """Validate client bundle compilation."""
+
+    def setUp(self) -> None:
+        Jac.reset_machine()
+        return super().setUp()
+
+    def tearDown(self) -> None:
+        Jac.reset_machine()
+        return super().tearDown()
+
+    def test_build_bundle_for_module(self) -> None:
+        """Compile a Jac module and ensure client bundle metadata is emitted."""
+        fixtures_dir = Path(__file__).parent / "fixtures"
+        (module,) = Jac.jac_import("client_app", str(fixtures_dir))
+
+        builder = ClientBundleBuilder()
+        bundle = builder.build(module)
+
+        self.assertIn("function __jacJsx", bundle.code)
+        self.assertIn('moduleFunctions["client_page"] = client_page;', bundle.code)
+        self.assertIn('moduleFunctions["ButtonProps"] = ButtonProps;', bundle.code)
+        self.assertIn('scope["client_page"] = client_page;', bundle.code)
+        self.assertIn('scope["ButtonProps"] = ButtonProps;', bundle.code)
+        self.assertIn('moduleGlobals["API_LABEL"] = API_LABEL;', bundle.code)
+        self.assertIn('scope["API_LABEL"] = API_LABEL;', bundle.code)
+        self.assertIn("hydrateJacClient", bundle.code)
+        self.assertIn("document.getElementById('__jac_init__')", bundle.code)
+        self.assertIn("Object.assign(scope, moduleGlobals);", bundle.code)
+        self.assertIn("for (const [gName, gValue] of Object.entries(payload.globals", bundle.code)
+        self.assertIn("client_page", bundle.client_functions)
+        self.assertIn("ButtonProps", bundle.client_functions)
+        self.assertIn("API_LABEL", bundle.client_globals)
+        self.assertGreater(len(bundle.hash), 10)
+
+        cached = builder.build(module)
+        self.assertEqual(bundle.hash, cached.hash)
+        self.assertEqual(bundle.code, cached.code)
diff --git a/jac/jaclang/runtimelib/tests/test_client_render.py b/jac/jaclang/runtimelib/tests/test_client_render.py
new file mode 100644
index 0000000000..72e059dd83
--- /dev/null
+++ b/jac/jaclang/runtimelib/tests/test_client_render.py
@@ -0,0 +1,63 @@
+"""Offline tests for client page rendering without sockets."""
+
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+
+from jaclang.runtimelib.machine import JacMachine as Jac
+from jaclang.runtimelib.server import JacAPIServer
+from jaclang.utils.test import TestCase
+
+
+class ClientRenderTests(TestCase):
+    """Validate client bundle helpers without opening sockets."""
+
+    def setUp(self) -> None:
+        Jac.reset_machine()
+        super().setUp()
+
+    def tearDown(self) -> None:
+        Jac.reset_machine()
+        super().tearDown()
+
+    def _make_server(self) -> JacAPIServer:
+        fixtures_dir = Path(__file__).parent / "fixtures"
+        Jac.jac_import("client_app", str(fixtures_dir))
+        server = JacAPIServer(
+            module_name="client_app", session_path=str(self.fixture_abs_path("client.session"))
+        )
+        server.load_module()
+        return server
+
+    def test_render_client_page_returns_html(self) -> None:
+        server = self._make_server()
+        server.user_manager.create_user("tester", "pass")
+        html_bundle = server.render_client_page("client_page", {}, "tester")
+
+        self.assertIn("<!DOCTYPE html>", html_bundle["html"])
+        self.assertIn('<div id="__jac_root"></div>', html_bundle["html"])
+        self.assertIn("/static/client.js?hash=", html_bundle["html"])
+
+        init_match = re.search(
+            r'<script id="__jac_init__" type="application/json">([^<]*)</script>',
+            html_bundle["html"],
+        )
+        self.assertIsNotNone(init_match)
+        payload = json.loads(init_match.group(1)) if init_match else {}
+        self.assertEqual(payload.get("module"), "client_app")
+        self.assertEqual(payload.get("function"), "client_page")
+        self.assertEqual(payload.get("globals", {}).get("API_LABEL"), "Runtime Test")
+        self.assertEqual(payload.get("argOrder"), [])
+
+        bundle_code = server.get_client_bundle_code()
+        self.assertIn("function __jacJsx", bundle_code)
+        self.assertEqual(bundle_code, html_bundle["bundle_code"])
+
+    def test_render_unknown_page_raises(self) -> None:
+        server = self._make_server()
+        server.user_manager.create_user("tester", "pass")
+
+        with self.assertRaises(ValueError):
+            server.render_client_page("missing", {}, "tester")
diff --git a/jac/jaclang/runtimelib/tests/test_serve.py b/jac/jaclang/runtimelib/tests/test_serve.py
index a595ea311c..62b2ed1751 100644
--- a/jac/jaclang/runtimelib/tests/test_serve.py
+++ b/jac/jaclang/runtimelib/tests/test_serve.py
@@ -33,7 +33,11 @@ def setUp(self) -> None:
         self.server_thread = None
         self.httpd = None
         # Use dynamically allocated free port for each test
-        self.port = get_free_port()
+        try:
+            self.port = get_free_port()
+        except PermissionError:
+            self.skipTest("Socket operations are not permitted in this environment")
+            return
         self.base_url = f"http://localhost:{self.port}"
         # Use unique session file for each test
         test_name = self._testMethodName
@@ -117,15 +121,25 @@ def run_server():
         max_attempts = 50
         for _ in range(max_attempts):
             try:
-                self._request("GET", "/")
+                self._request("GET", "/", timeout=10)
                 break
             except Exception:
                 time.sleep(0.1)
 
     def _request(
-        self, method: str, path: str, data: dict = None, token: str = None
+        self, method: str, path: str, data: dict = None, token: str = None, timeout: int = 5
     ) -> dict:
         """Make HTTP request to server."""
+        status, payload, _ = self._request_raw(method, path, data=data, token=token, timeout=timeout)
+        try:
+            return json.loads(payload)
+        except json.JSONDecodeError as exc:  # pragma: no cover - sanity guard
+            raise AssertionError(f"Expected JSON response, got: {payload}") from exc
+
+    def _request_raw(
+        self, method: str, path: str, data: dict = None, token: str = None, timeout: int = 5
+    ) -> tuple[int, str, dict[str, str]]:
+        """Make an HTTP request and return status, body, and headers."""
         url = f"{self.base_url}{path}"
         headers = {"Content-Type": "application/json"}
 
@@ -136,10 +150,12 @@ def _request(
         request = Request(url, data=body, headers=headers, method=method)
 
         try:
-            with urlopen(request, timeout=5) as response:
-                return json.loads(response.read().decode())
+            with urlopen(request, timeout=timeout) as response:
+                payload = response.read().decode()
+                return response.status, payload, dict(response.headers)
         except HTTPError as e:
-            return json.loads(e.read().decode())
+            payload = e.read().decode()
+            return e.code, payload, dict(e.headers)
 
     def test_user_manager_creation(self) -> None:
         """Test UserManager creates users with unique roots."""
@@ -523,6 +539,37 @@ def test_server_invalid_walker(self) -> None:
 
         self.assertIn("error", result)
 
+    def test_client_page_and_bundle_endpoints(self) -> None:
+        """Render a client page and fetch the bundled JavaScript."""
+        self._start_server()
+
+        create_result = self._request(
+            "POST",
+            "/user/create",
+            {"username": "pageuser", "password": "pass"}
+        )
+        token = create_result["token"]
+
+        # Use longer timeout for page requests (they trigger bundle building)
+        status, html_body, headers = self._request_raw(
+            "GET",
+            "/page/client_page",
+            token=token,
+            timeout=15
+        )
+
+        self.assertEqual(status, 200)
+        self.assertIn("text/html", headers.get("Content-Type", ""))
+        self.assertIn("<div id=\"__jac_root\">", html_body)
+        self.assertIn("Runtime Test", html_body)
+        self.assertIn("/static/client.js?hash=", html_body)
+
+        # Bundle should be cached from page request, but use longer timeout for CI safety
+        status_js, js_body, js_headers = self._request_raw("GET", "/static/client.js", timeout=15)
+        self.assertEqual(status_js, 200)
+        self.assertIn("application/javascript", js_headers.get("Content-Type", ""))
+        self.assertIn("function __jacJsx", js_body)
+
     def test_server_root_endpoint(self) -> None:
         """Test root endpoint returns API information."""
         self._start_server()
@@ -585,6 +632,108 @@ def test_module_loading_and_introspection(self) -> None:
 
         mach.close()
 
+    def test_csr_mode_empty_root(self) -> None:
+        """Test CSR mode returns empty __jac_root for client-side rendering."""
+        self._start_server()
+
+        # Create user
+        create_result = self._request(
+            "POST",
+            "/user/create",
+            {"username": "csruser", "password": "pass"}
+        )
+        token = create_result["token"]
+
+        # Request page in CSR mode using query parameter (longer timeout for bundle building)
+        status, html_body, headers = self._request_raw(
+            "GET",
+            "/page/client_page?mode=csr",
+            token=token,
+            timeout=15
+        )
+
+        self.assertEqual(status, 200)
+        self.assertIn("text/html", headers.get("Content-Type", ""))
+
+        # In CSR mode, __jac_root should be empty (no SSR)
+        self.assertIn('<div id="__jac_root"></div>', html_body)
+
+        # But __jac_init__ and client.js should still be present
+        self.assertIn('<script id="__jac_init__" type="application/json">', html_body)
+        self.assertIn("/static/client.js?hash=", html_body)
+
+        # __jac_init__ should still contain the function name and args
+        self.assertIn('"function": "client_page"', html_body)
+
+    def test_default_page_is_csr(self) -> None:
+        """Requesting a page without mode parameter returns empty CSR shell."""
+        self._start_server()
+
+        # Create user
+        create_result = self._request(
+            "POST",
+            "/user/create",
+            {"username": "ssruser", "password": "pass"}
+        )
+        token = create_result["token"]
+
+        # Request page without specifying mode (CSR-only, longer timeout for bundle building)
+        status, html_body, headers = self._request_raw(
+            "GET",
+            "/page/client_page",
+            token=token,
+            timeout=15
+        )
+
+        self.assertEqual(status, 200)
+        self.assertIn("text/html", headers.get("Content-Type", ""))
+
+        # CSR shell should be empty; client renders later
+        self.assertIn('<div id="__jac_root"></div>', html_body)
+
+        # __jac_init__ and client.js should still be present for hydration
+        self.assertIn('<script id="__jac_init__" type="application/json">', html_body)
+        self.assertIn("/static/client.js?hash=", html_body)
+
+    def test_csr_mode_with_server_default(self) -> None:
+        """render_client_page returns an empty shell when called directly."""
+        # Load module
+        base, mod, mach = cli.proc_file_sess(
+            self.fixture_abs_path("serve_api.jac"), ""
+        )
+        Jac.set_base_path(base)
+        Jac.jac_import(
+            target=mod,
+            base_path=base,
+            override_name="__main__",
+            lng="jac",
+        )
+
+        # Create server
+        server = JacAPIServer(
+            module_name="__main__",
+            session_path=self.session_file,
+            port=9998,
+        )
+        server.load_module()
+
+        # Create a test user
+        server.user_manager.create_user("testuser", "testpass")
+
+        # Call render_client_page (always CSR)
+        result = server.render_client_page(
+            function_name="client_page",
+            args={},
+            username="testuser",
+        )
+
+        # Should have empty HTML body (CSR mode)
+        self.assertIn("html", result)
+        html_content = result["html"]
+        self.assertIn('<div id="__jac_root"></div>', html_content)
+
+        mach.close()
+
     def test_root_data_persistence_across_server_restarts(self) -> None:
         """Test that user data and graph persist across server restarts.
 
@@ -696,3 +845,120 @@ def test_root_data_persistence_across_server_restarts(self) -> None:
             token=new_token
         )
         self.assertIn("result", complete_result)
+
+    def test_client_bundle_has_object_get_polyfill(self) -> None:
+        """Test that client bundle includes Object.prototype.get polyfill."""
+        self._start_server()
+
+        # Pre-warm the bundle by requesting a page first (triggers bundle build)
+        # This ensures the bundle is cached before we test it directly
+        try:
+            self._request("GET", "/")
+        except Exception:
+            pass  # Ignore errors, we just want to trigger bundle building
+
+        # Fetch the client bundle with longer timeout for CI environments
+        # Bundle building can be slow on CI runners with limited resources
+        status, js_body, headers = self._request_raw("GET", "/static/client.js", timeout=15)
+
+        self.assertEqual(status, 200)
+        self.assertIn("application/javascript", headers.get("Content-Type", ""))
+
+        # Verify the polyfill is at the beginning of the bundle
+        self.assertIn("Object.prototype.get", js_body)
+        self.assertIn("function(key, defaultValue)", js_body)
+        self.assertIn("this.hasOwnProperty(key)", js_body)
+
+        # Verify the polyfill appears before the runtime code
+        polyfill_pos = js_body.find("Object.prototype.get")
+        runtime_pos = js_body.find("// Jac client runtime")
+        self.assertGreater(runtime_pos, polyfill_pos)
+
+    def test_login_form_renders_with_correct_elements(self) -> None:
+        """Test that client page renders with correct HTML elements via HTTP endpoint."""
+        self._start_server()
+
+        # Create user
+        create_result = self._request(
+            "POST",
+            "/user/create",
+            {"username": "formuser", "password": "pass"}
+        )
+        token = create_result["token"]
+
+        # Request the client_page endpoint (longer timeout for bundle building)
+        status, html_body, headers = self._request_raw(
+            "GET",
+            "/page/client_page",
+            token=token,
+            timeout=15
+        )
+
+        self.assertEqual(status, 200)
+        self.assertIn("text/html", headers.get("Content-Type", ""))
+
+        # Check basic HTML structure
+        self.assertIn("<!DOCTYPE html>", html_body)
+        self.assertIn('<div id="__jac_root">', html_body)
+        self.assertIn('<script id="__jac_init__"', html_body)
+        self.assertIn("/static/client.js?hash=", html_body)
+
+        # Verify __jac_init__ contains the right function and global
+        self.assertIn('"function": "client_page"', html_body)
+        self.assertIn('"WELCOME_TITLE": "Runtime Test"', html_body)  # Global variable
+
+        # Fetch and verify the bundle (should be cached from page request, but use longer timeout for CI)
+        status_js, js_body, _ = self._request_raw("GET", "/static/client.js", timeout=15)
+        self.assertEqual(status_js, 200)
+
+        # Verify the bundle has the polyfill
+        self.assertIn("Object.prototype.get", js_body)
+
+        # Verify the function is in the bundle
+        self.assertIn("function client_page", js_body)
+
+    def test_default_page_is_csr(self) -> None:
+        """Test that the default page response is CSR (client-side rendering)."""
+        self._start_server()
+
+        # Create user
+        create_result = self._request(
+            "POST",
+            "/user/create",
+            {"username": "csrdefaultuser", "password": "pass"}
+        )
+        token = create_result["token"]
+
+        # Request page WITHOUT specifying mode (should use default, longer timeout for bundle building)
+        status, html_body, headers = self._request_raw(
+            "GET",
+            "/page/client_page",
+            token=token,
+            timeout=15
+        )
+
+        self.assertEqual(status, 200)
+        self.assertIn("text/html", headers.get("Content-Type", ""))
+
+        # In CSR mode (default), __jac_root should be empty
+        self.assertIn('<div id="__jac_root"></div>', html_body)
+
+        # Should NOT contain pre-rendered content
+        # (The content will be rendered on the client side)
+        # Note: We check that the root div is completely empty
+        import re
+        root_match = re.search(r'<div id="__jac_root">(.*?)</div>', html_body)
+        self.assertIsNotNone(root_match)
+        root_content = root_match.group(1)
+        self.assertEqual(root_content, "")  # Should be empty string
+
+        # Verify that explicitly requesting SSR mode is ignored (still CSR, longer timeout for bundle building)
+        status_ssr, html_ssr, _ = self._request_raw(
+            "GET",
+            "/page/client_page?mode=ssr",
+            token=token,
+            timeout=15
+        )
+        self.assertEqual(status_ssr, 200)
+
+        self.assertIn('<div id="__jac_root"></div>', html_ssr)
diff --git a/jac/jaclang/tests/test_language.py b/jac/jaclang/tests/test_language.py
index 4d24f6593c..8720f986d6 100644
--- a/jac/jaclang/tests/test_language.py
+++ b/jac/jaclang/tests/test_language.py
@@ -1610,39 +1610,4 @@ def test_attr_pattern_case(self) -> None:
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue().split("\n")
         self.assertIn("Matched a.b.c Hello Jaseci!", stdout_value[0])
-        
-    def test_known_builtins_matches_actual(self) -> None:
-        """Test that KNOWN_BUILTINS in PyastGenPass matches actual builtins."""
-        from jaclang.compiler.passes.main.pyast_gen_pass import PyastGenPass
-        import jaclang.runtimelib.builtin as builtin_module
-
-        # Get actual builtins from the module (excluding private members)
-        actual_builtins = {
-            name for name in builtin_module.__all__
-            if not name.startswith('_')
-        }
-
-        # Exceptions: builtins that are imported from other sources
-        # - Enum: imported via needs_enum() from standard library's enum module
-        exceptions = {'Enum'}
-        actual_builtins_to_check = actual_builtins - exceptions
-
-        # Get the KNOWN_BUILTINS set from PyastGenPass
-        known_builtins = PyastGenPass.KNOWN_BUILTINS
-
-        # Find missing and extra builtins
-        missing = actual_builtins_to_check - known_builtins
-        extra = known_builtins - actual_builtins_to_check
-
-        # Build error message
-        error_msg = []
-        if missing:
-            error_msg.append(f"Missing from KNOWN_BUILTINS: {sorted(missing)}")
-        if extra:
-            error_msg.append(f"Extra in KNOWN_BUILTINS (not in builtin module): {sorted(extra)}")
-
-        # Assert they match
-        self.assertEqual(
-            known_builtins, actual_builtins_to_check,
-            "\n".join(error_msg) if error_msg else ""
-        )
+        
\ No newline at end of file
diff --git a/jac/jaclang/tests/test_reference.py b/jac/jaclang/tests/test_reference.py
index e2522175a7..51ff116367 100644
--- a/jac/jaclang/tests/test_reference.py
+++ b/jac/jaclang/tests/test_reference.py
@@ -66,6 +66,12 @@ def execute_and_capture_output(code: str | bytes, filename: str = "") -> str:
                 )
             return f.getvalue()
 
+        def normalize_function_addresses(text: str) -> str:
+            """Normalize function memory addresses in output for consistent comparison."""
+            import re
+            # Replace <function Name at 0xADDRESS> with <function Name at 0x...>
+            return re.sub(r'<function (\w+) at 0x[0-9a-f]+>', r'<function \1 at 0x...>', text)
+
         try:
             if "tests.jac" in filename or "check_statements.jac" in filename:
                 return
@@ -86,6 +92,10 @@ def execute_and_capture_output(code: str | bytes, filename: str = "") -> str:
                 code_content = file.read()
             output_py = execute_and_capture_output(code_content, filename=filename)
 
+            # Normalize function addresses before comparison
+            output_jac = normalize_function_addresses(output_jac)
+            output_py = normalize_function_addresses(output_py)
+
             print(f"\nJAC Output:\n{output_jac}")
             print(f"\nPython Output:\n{output_py}")
 
diff --git a/jac/jaclang/tests/test_typecheck.py b/jac/jaclang/tests/test_typecheck.py
deleted file mode 100644
index 337274d0aa..0000000000
--- a/jac/jaclang/tests/test_typecheck.py
+++ /dev/null
@@ -1,542 +0,0 @@
-"""Test Jac language generally."""
-
-import io
-import os
-import sys
-import unittest
-import sysconfig
-import tempfile
-from unittest.mock import patch
-
-from jaclang import JacMachineInterface as Jac, JacMachine
-from jaclang.cli import cli
-from jaclang.compiler.program import JacProgram
-from jaclang.utils.lang_tools import AstTool
-from jaclang.utils.test import TestCase
-
-
-@unittest.skip("Skipping typecheck tests")
-class JacTypeCheckTests(TestCase):
-    """Test pass module."""
-
-    def setUp(self) -> None:
-        """Set up test."""
-        self.mach = JacMachine(self.fixture_abs_path("./"))
-        Jac.attach_program(
-            self.mach,
-            JacProgram(),
-        )
-        return super().setUp()
-
-    def tearDown(self) -> None:
-        """Tear down test."""
-        return super().tearDown()
-
-    def test_multi_dim_arr_slice(self) -> None:
-        """Parse micro jac file."""
-        captured_output = io.StringIO()
-        sys.stdout = captured_output
-        cli.tool(
-            "ir",
-            [
-                "ast",
-                self.fixture_abs_path("multi_dim_array_split.jac"),
-            ],
-        )
-        sys.stdout = sys.__stdout__
-        stdout_value = captured_output.getvalue()
-
-        expected_outputs = [
-            "+-- AtomTrailer - Type: builtins.list[builtins.int]",
-            "    +-- Name - arr - Type: builtins.list[builtins.list[builtins.int]],  SymbolTable: list",
-            "+-- IndexSlice - [IndexSlice] - Type: builtins.list[builtins.list[builtins.int]],  SymbolTable: None",
-            "        +-- Token - [, ",
-            "        +-- Int - 1 - Type: Literal[1]?,  SymbolTable: None",
-            "        +-- Token - :, ",
-            "        +-- Int - 3 - Type: Literal[3]?,  SymbolTable: None",
-            "        +-- Token - ,, ",
-            "        +-- Int - 1 - Type: Literal[1]?,  SymbolTable: None",
-            "        +-- Token - :, ",
-            "        +-- Token - :, ",
-            "        +-- Int - 2 - Type: Literal[2]?,  SymbolTable: None",
-            "        +-- Token - ], ",
-        ]
-
-        for expected in expected_outputs:
-            self.assertIn(expected, stdout_value)
-
-    def test_needs_import_1(self) -> None:
-        """Test py ast to Jac ast conversion output."""
-        file_name = self.fixture_abs_path("pyfunc_1.py")
-
-        from jaclang.compiler.passes.main.pyast_load_pass import PyastBuildPass
-        import ast as py_ast
-        import jaclang.compiler.unitree as uni
-
-        with open(file_name, "r") as f:
-            file_source = f.read()
-            parsed_ast = py_ast.parse(file_source)
-            try:
-                py_ast_build_pass = PyastBuildPass(
-                    ir_in=uni.PythonModuleAst(
-                        parsed_ast, orig_src=uni.Source(file_source, file_name)
-                    ),
-                    prog=JacProgram(),
-                ).ir_out
-            except Exception as e:
-                return f"Error While Jac to Py AST conversion: {e}"
-
-        (prog := JacProgram()).build(
-            use_str=py_ast_build_pass.unparse(),
-            file_path=file_name[:-3] + ".jac",
-        )
-
-        archetype_count = 0
-        for mod in prog.mod.hub.values():
-            if mod.name == "builtins":
-                continue
-            archetype_count += len(mod.get_all_sub_nodes(uni.Archetype))
-
-        self.assertEqual(archetype_count, 24)
-        captured_output = io.StringIO()
-        sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "needs_import_1", base_path=self.fixture_abs_path("./")
-        )
-        sys.stdout = sys.__stdout__
-        stdout_value = captured_output.getvalue()
-        self.assertIn("pyfunc_1 imported", stdout_value)
-
-    def test_needs_import_2(self) -> None:
-        """Test py ast to Jac ast conversion output."""
-        file_name = self.fixture_abs_path("pyfunc_2.py")
-
-        from jaclang.compiler.passes.main.pyast_load_pass import PyastBuildPass
-        import ast as py_ast
-        import jaclang.compiler.unitree as uni
-
-        with open(file_name, "r") as f:
-            file_source = f.read()
-            parsed_ast = py_ast.parse(file_source)
-            try:
-                py_ast_build_pass = PyastBuildPass(
-                    ir_in=uni.PythonModuleAst(
-                        parsed_ast,
-                        orig_src=uni.Source(file_source, file_name),
-                    ),
-                    prog=JacProgram(),
-                ).ir_out
-            except Exception as e:
-                return f"Error While Jac to Py AST conversion: {e}"
-
-            (prog := JacProgram()).build(
-                use_str=py_ast_build_pass.unparse(),
-                file_path=file_name[:-3] + ".jac",
-            )
-
-        archetype_count = 0
-        for mod in prog.mod.hub.values():
-            if mod.name == "builtins":
-                continue
-            archetype_count += len(mod.get_all_sub_nodes(uni.Archetype))
-
-        self.assertEqual(archetype_count, 30)  # Because of the Archetype from math
-        captured_output = io.StringIO()
-        sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "needs_import_2", base_path=self.fixture_abs_path("./")
-        )
-        sys.stdout = sys.__stdout__
-        stdout_value = captured_output.getvalue()
-        self.assertIn("pyfunc_2 imported", stdout_value)
-        self.assertEqual(stdout_value.count("<class 'bytes'>"), 3)
-
-    def test_needs_import_3(
-        self,
-    ) -> None:  # TODO : Pyfunc_3 has a bug in conversion in matchmapping node
-        """Test py ast to Jac ast conversion output."""
-        file_name = self.fixture_abs_path("pyfunc_3.py")
-        import jaclang.compiler.unitree as uni
-
-        with open(file_name, "r") as f:
-            file_source = f.read()
-        (prog := JacProgram()).build(use_str=file_source, file_path=file_name)
-
-        archetype_count = sum(
-            len(mod.get_all_sub_nodes(uni.Archetype))
-            for mod in prog.mod.hub.values()
-            if mod.name != "builtins"
-        )
-        self.assertEqual(
-            archetype_count, 58
-        )  # Fixed duplication of 'case' module (previously included 3 times, added 20 extra Archetypes; 75 → 55)
-        builtin_mod = next(
-            (mod for name, mod in prog.mod.hub.items() if "builtins" in name),
-            None,
-        )
-        self.assertEqual(len(builtin_mod.get_all_sub_nodes(uni.Archetype)), 109)
-        captured_output = io.StringIO()
-        sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "needs_import_3", base_path=self.fixture_abs_path("./")
-        )
-        sys.stdout = sys.__stdout__
-        stdout_value = captured_output.getvalue()
-        self.assertIn("pyfunc_3 imported", stdout_value)
-
-    def test_type_fuse_expr(self) -> None:
-        """Basic test for pass."""
-        captured_output = io.StringIO()
-        sys.stdout = captured_output
-        cli.tool(
-            "ir",
-            [
-                "ast",
-                self.examples_abs_path("reference/collection_values.jac"),
-            ],
-        )
-
-        sys.stdout = sys.__stdout__
-        stdout_value = captured_output.getvalue()
-        self.assertIn(
-            "builtins.dict[builtins.int, builtins.int]",
-            stdout_value,
-        )
-        self.assertIn(
-            "typing.Generator[builtins.int, None, None]",
-            stdout_value,
-        )
-
-    def test_random_check(self) -> None:
-        """Test py ast to Jac ast conversion output."""
-        from jaclang.settings import settings
-
-        module_paths = ["random", "ast"]
-        for module_path in module_paths:
-            stdlib_dir = sysconfig.get_paths()["stdlib"]
-            file_path = os.path.join(
-                stdlib_dir,
-                module_path + ".py",
-            )
-            settings.print_py_raised_ast = True
-            with open(file_path) as f:
-                file_source = f.read()
-            ir = JacProgram().build(
-                use_str=file_source,
-                file_path=file_path,
-            )
-            gen_ast = ir.pp()
-            if module_path == "random":
-                self.assertIn("ModulePath - statistics -", gen_ast)
-            else:
-                self.assertIn("+-- Name - NodeTransformer - Type: No", gen_ast)
-
-    def test_deep_convert(self) -> None:
-        """Test py ast to Jac ast conversion output."""
-        file_name = self.fixture_abs_path("pyfunc_1.py")
-
-        import jaclang.compiler.unitree as uni
-        from jaclang.settings import settings
-
-        settings.print_py_raised_ast = True
-        with open(file_name, "r") as f:
-            file_source = f.read()
-        ir = (prog := JacProgram()).build(use_str=file_source, file_path=file_name)
-        jac_ast = ir.pp()
-        self.assertIn(" |   +-- String - 'Loop completed normally{}'", jac_ast)
-        sub_node_list_count = 0
-        for i in prog.mod.hub.values():
-            if i.name == "builtins":
-                continue
-            sub_node_list_count += len(i.get_all_sub_nodes(uni.SubNodeList))
-        self.assertEqual(sub_node_list_count, 623)
-        captured_output = io.StringIO()
-        sys.stdout = captured_output
-        Jac.jac_import(self.mach, "deep_convert", base_path=self.fixture_abs_path("./"))
-        sys.stdout = sys.__stdout__
-        stdout_value = captured_output.getvalue()
-        self.assertIn("Deep convo is imported", stdout_value)
-
-    def test_ds_type_check_pass(self) -> None:
-        """Test conn assign on edges."""
-        (mypass := JacProgram()).build(
-            self.examples_abs_path("micro/simple_walk.jac"),
-        )
-        self.assertEqual(len(mypass.errors_had), 0)
-        self.assertEqual(len(mypass.warnings_had), 0)
-
-    def test_ds_type_check_pass2(self) -> None:
-        """Test conn assign on edges."""
-        (mypass := JacProgram()).build(
-            self.examples_abs_path("guess_game/guess_game5.jac"),
-        )
-        self.assertEqual(len(mypass.errors_had), 0)
-        self.assertEqual(len(mypass.warnings_had), 0)
-
-    def test_circle_override1_type_check_pass(self) -> None:
-        """Test conn assign on edges."""
-        (mypass := JacProgram()).build(
-            self.examples_abs_path("manual_code/circle.jac"),
-        )
-        self.assertEqual(len(mypass.errors_had), 0)
-        # FIXME: Figure out what to do with warning.
-        # self.assertEqual(len(mypass.warnings_had), 0)
-
-    def test_expr_types(self) -> None:
-        """Testing for print AstTool."""
-        captured_output = io.StringIO()
-        sys.stdout = captured_output
-
-        cli.tool("ir", ["ast", f"{self.fixture_abs_path('expr_type.jac')}"])
-
-        sys.stdout = sys.__stdout__
-        stdout_value = captured_output.getvalue()
-
-        self.assertRegex(
-            stdout_value, r"4\:9 \- 4\:14.*BinaryExpr \- Type\: builtins.int"
-        )
-        self.assertRegex(
-            stdout_value, r"7\:9 \- 7\:17.*FuncCall \- Type\: builtins.float"
-        )
-        self.assertRegex(
-            stdout_value, r"9\:6 \- 9\:11.*CompareExpr \- Type\: builtins.bool"
-        )
-        self.assertRegex(
-            stdout_value, r"10\:6 - 10\:15.*BinaryExpr \- Type\: builtins.str"
-        )
-        self.assertRegex(
-            stdout_value, r"11\:5 \- 11\:13.*AtomTrailer \- Type\: builtins.int"
-        )
-        self.assertRegex(
-            stdout_value, r"12\:5 \- 12\:14.*UnaryExpr \- Type\: builtins.bool"
-        )
-        self.assertRegex(
-            stdout_value, r"13\:5 \- 13\:25.*IfElseExpr \- Type\: Literal\['a']\?"
-        )
-        self.assertRegex(
-            stdout_value,
-            r"14\:5 \- 14\:27.*ListCompr - \[ListCompr] \- Type\: builtins.list\[builtins.int]",
-        )
-
-    def test_type_check(self) -> None:
-        """Testing for print AstTool."""
-        captured_output = io.StringIO()
-        sys.stdout = captured_output
-        cli.check(f"{self.fixture_abs_path('game1.jac')}")
-        sys.stdout = sys.__stdout__
-        stdout_value = captured_output.getvalue()
-        self.assertIn("Errors: 0, Warnings: 1", stdout_value)
-
-    def test_type_errors(self) -> None:
-        """Basic test for pass."""
-        (type_checked := JacProgram()).build(
-            file_path=self.fixture_abs_path("func.jac"),
-        )
-
-        errs = "\n".join([i.msg for i in type_checked.warnings_had])
-        files = "\n".join([i.loc.mod_path for i in type_checked.warnings_had])
-
-        for i in [
-            "func2.jac",
-            "func.jac",
-            '(got "int", expected "str")',
-            '(got "str", expected "int")',
-        ]:
-            self.assertIn(i, errs + files)
-
-    def test_imported_module_typecheck(self) -> None:
-        """Basic test for pass."""
-        (type_checked := JacProgram()).build(
-            file_path=self.fixture_abs_path("game1.jac"),
-        )
-
-        errs = "\n".join([i.msg for i in type_checked.warnings_had])
-        files = "\n".join([i.loc.mod_path for i in type_checked.warnings_had])
-
-        for i in [
-            'Argument 2 to "is_pressed" of "Button" has incompatible type "int"; expected "str"',
-        ]:
-            self.assertIn(i, errs + files)
-
-    def test_type_coverage(self) -> None:
-        """Testing for type info coverage in sym_tab via ast."""
-        out = AstTool().ir(["ast", f"{self.fixture_abs_path('type_info.jac')}"])
-        lis = [
-            "introduce - Type: None",
-            "25:30 - 25:37\t        |   |   |           +-- Name - species - Type: None",  # AtomTrailer
-        ]
-        self.assertIn("HasVar - species - Type: builtins.str", out)
-        self.assertIn("myDog - Type: type_info.Dog", out)
-        self.assertIn("Body - Type: type_info.Dog.Body", out)
-        self.assertEqual(out.count("Type: builtins.str"), 35)
-        for i in lis:
-            self.assertNotIn(i, out)
-
-    def test_data_spatial_type_info(self) -> None:
-        """Testing for type info for dataspatial constructs."""
-        out = AstTool().ir(
-            ["ast", f"{self.fixture_abs_path('data_spatial_types.jac')}"]
-        )
-        self.assertRegex(
-            out,
-            r"129:22 - 129:26.*SpecialVarRef - root \- Type\: jaclang.runtimelib.archetype.Root",
-        )
-        self.assertRegex(out, r"129:11 - 129:27.*FuncCall \- Type\: builtins\.str")
-        self.assertRegex(
-            out,
-            r"129:13 - 129:21.*Name \- node_dot \- Type\: builtins.str",
-        )
-
-        self.assertRegex(
-            out,
-            r"128:5 - 128:25.*BinaryExpr \- Type\: "
-            + r"Union\[jaclang.runtimelib.archetype.WalkerArchetype, concurrent.futures._base.Future\[Any\]\]",
-        )
-
-        self.assertRegex(
-            out,
-            r"48:11 - 48:28.*EdgeRefTrailer \- Type\: builtins.list\[jaclang.runtimelib.archetype.Archetype\]",
-        )
-
-        self.assertRegex(out, r"24:5 - 24:25.*BinaryExpr \- Type\: builtins.bool", out)
-
-    def test_type_info(self) -> None:
-        """Testing for type info inside the ast tool."""
-        captured_output = io.StringIO()
-        sys.stdout = captured_output
-        cli.tool("ir", ["ast", f"{self.fixture_abs_path('type_info.jac')}"])
-        sys.stdout = sys.__stdout__
-        stdout_value = captured_output.getvalue()
-        self.assertEqual(stdout_value.count("type_info.ServerWrapper"), 5)
-        self.assertEqual(stdout_value.count("builtins.int"), 3)
-        self.assertEqual(stdout_value.count("builtins.str"), 10)
-        self.assertIn("Literal['test_server']", stdout_value)
-        self.assertIn("Literal['1']", stdout_value)
-
-    def test_base_class_complex_expr(self) -> None:
-        """Testing for print AstTool."""
-        from jaclang.settings import settings
-
-        # settings.ast_symbol_info_detailed = True
-        captured_output = io.StringIO()
-        sys.stdout = captured_output
-
-        cli.tool(
-            "ir", ["ast", f"{self.fixture_abs_path('base_class_complex_expr.jac')}"]
-        )
-
-        sys.stdout = sys.__stdout__
-        stdout_value = captured_output.getvalue()
-        settings.ast_symbol_info_detailed = False
-
-        self.assertRegex(
-            stdout_value,
-            r"36\:9 \- 36\:13.*Name \- Kiwi \- Type\: base_class_complex_expr.Kiwi,  SymbolTable\: Kiwi",
-        )
-
-    def test_import_all(self) -> None:
-        """Testing for print AstTool."""
-        from jaclang.settings import settings
-
-        settings.ast_symbol_info_detailed = True
-        captured_output = io.StringIO()
-        sys.stdout = captured_output
-
-        cli.tool("ir", ["ast", f"{self.fixture_abs_path('import_all.jac')}"])
-
-        sys.stdout = sys.__stdout__
-        stdout_value = captured_output.getvalue()
-        settings.ast_symbol_info_detailed = False
-
-        self.assertRegex(
-            stdout_value,
-            r"6\:25 - 6\:30.*Name - floor -.*SymbolPath: math.floor",
-        )
-        self.assertRegex(
-            stdout_value,
-            r"5\:25 - 5\:27.*Name - pi -.*SymbolPath: math.pi",
-        )
-
-    def test_import_mod_abs_path(self) -> None:
-        """Testing for print AstTool."""
-        captured_output = io.StringIO()
-        sys.stdout = captured_output
-
-        cli.tool("ir", ["ast", f"{self.fixture_abs_path('import.jac')}"])
-
-        sys.stdout = sys.__stdout__
-        stdout_value = captured_output.getvalue().replace("\\", "/")
-        self.assertRegex(
-            stdout_value,
-            r"1.*ModulePath - os - abs_path\:.*typeshed/stdlib/os/__init__.pyi",
-        )
-        self.assertRegex(
-            stdout_value,
-            r"2.*ModulePath - sys - abs_path\:.*typeshed/stdlib/sys/__init__.pyi",
-        )
-        self.assertRegex(
-            stdout_value,
-            r"3.*ModulePath - pyfunc - abs_path\:.*fixtures/pyfunc.py",
-        )
-        self.assertRegex(
-            stdout_value,
-            r"4.*ModulePath - pygame_mock - abs_path\:.*fixtures/pygame_mock/inner/__init__.py",
-        )
-        self.assertRegex(
-            stdout_value,
-            r"6.*ModulePath - math - abs_path\:.*typeshed/stdlib/math.pyi",
-        )
-        self.assertRegex(
-            stdout_value,
-            r"7.*ModulePath - argparse - abs_path\:.*typeshed/stdlib/argparse.pyi",
-        )
-        self.assertRegex(
-            stdout_value,
-            r"8.*ModulePath - pygame_mock - abs_path\:.*fixtures/pygame_mock/__init__.py",
-        )
-        self.assertRegex(
-            stdout_value,
-            r"8.*ModuleItem - color - abs_path\:.*fixtures/pygame_mock/color.py",
-        )
-        self.assertRegex(
-            stdout_value,
-            r"8.*ModuleItem - display - abs_path\:.*fixtures/pygame_mock/display.py",
-        )
-
-    def test_sub_class_symbol_table_fix_1(self) -> None:
-        """Testing for print AstTool."""
-        from jaclang.settings import settings
-
-        settings.ast_symbol_info_detailed = True
-        captured_output = io.StringIO()
-        sys.stdout = captured_output
-
-        cli.tool("ir", ["ast", f"{self.fixture_abs_path('base_class1.jac')}"])
-
-        sys.stdout = sys.__stdout__
-        stdout_value = captured_output.getvalue()
-        settings.ast_symbol_info_detailed = False
-
-        self.assertRegex(
-            stdout_value,
-            r"10:7 - 10:12.*Name - start - Type.*SymbolPath: base_class1.B.start",
-        )
-
-    def test_sub_class_symbol_table_fix_2(self) -> None:
-        """Testing for print AstTool."""
-        from jaclang.settings import settings
-
-        settings.ast_symbol_info_detailed = True
-        captured_output = io.StringIO()
-        sys.stdout = captured_output
-
-        cli.tool("ir", ["ast", f"{self.fixture_abs_path('base_class2.jac')}"])
-
-        sys.stdout = sys.__stdout__
-        stdout_value = captured_output.getvalue()
-        settings.ast_symbol_info_detailed = False
-
-        self.assertRegex(
-            stdout_value,
-            r"10:7 - 10:12.*Name - start - Type.*SymbolPath: base_class2.B.start",
-        )
diff --git a/jac/jaclang/utils/lang_tools.py b/jac/jaclang/utils/lang_tools.py
index b5dce000e4..02f0ba8fe4 100644
--- a/jac/jaclang/utils/lang_tools.py
+++ b/jac/jaclang/utils/lang_tools.py
@@ -181,7 +181,7 @@ def ir(self, args: List[str]) -> str:
         """Generate a AST, SymbolTable tree for .jac file, or Python AST for .py file."""
         error = (
             "Usage: ir <choose one of (sym / sym. / ast / ast. / docir / "
-            "pyast / py / unparse)> <.py or .jac file_path>"
+            "pyast / py / unparse / esast / es)> <.py or .jac file_path>"
         )
         if len(args) != 2:
             return error
@@ -263,6 +263,29 @@ def ir(self, args: List[str]) -> str:
                         if isinstance(ir.gen.py[0], str)
                         else "Compile failed."
                     )
+                case "esast":
+                    from jaclang.compiler.passes.ecmascript import (
+                        EsastGenPass,
+                        es_node_to_dict,
+                    )
+                    import json
+
+                    esast_pass = EsastGenPass(ir, prog)
+                    es_ir = esast_pass.ir_out
+                    if hasattr(es_ir.gen, "es_ast") and es_ir.gen.es_ast:
+                        return f"\n{json.dumps(es_node_to_dict(es_ir.gen.es_ast), indent=2)}"
+                    else:
+                        return "ECMAScript AST generation failed."
+                case "es":
+                    from jaclang.compiler.passes.ecmascript import EsastGenPass
+                    from jaclang.compiler.passes.ecmascript.es_unparse import es_to_js
+
+                    esast_pass = EsastGenPass(ir, prog)
+                    es_ir = esast_pass.ir_out
+                    if hasattr(es_ir.gen, "es_ast") and es_ir.gen.es_ast:
+                        return f"\n{es_to_js(es_ir.gen.es_ast)}"
+                    else:
+                        return "ECMAScript code generation failed."
                 case _:
                     return f"Invalid key: {error}"
         else:
diff --git a/jac/support/vscode_ext/jac/syntaxes/jac.tmLanguage.json b/jac/support/vscode_ext/jac/syntaxes/jac.tmLanguage.json
index b76892e700..086455d60f 100644
--- a/jac/support/vscode_ext/jac/syntaxes/jac.tmLanguage.json
+++ b/jac/support/vscode_ext/jac/syntaxes/jac.tmLanguage.json
@@ -339,9 +339,189 @@
 				},
 				{
 					"include": "#string"
+				},
+				{
+					"include": "#jsx"
+				}
+			]
+		},
+		"jsx": {
+			"patterns": [
+				{
+					"include": "#jsx-tag-fragment"
+				},
+				{
+					"include": "#jsx-tag"
+				}
+			]
+		},
+		"jsx-tag-fragment": {
+			"name": "meta.jsx.fragment.jac",
+			"begin": "(<>)",
+			"end": "(</>)",
+			"beginCaptures": {
+				"1": {
+					"name": "punctuation.definition.tag.jsx.jac"
+				}
+			},
+			"endCaptures": {
+				"1": {
+					"name": "punctuation.definition.tag.jsx.jac"
+				}
+			},
+			"patterns": [
+				{
+					"include": "#jsx-children"
+				}
+			]
+		},
+		"jsx-tag": {
+			"name": "meta.jsx.jac",
+			"begin": "(?x)\n  (<)\n  (?:\n    ([_$[:alpha:]][-_$[:alnum:]]*(?:\\.[_$[:alpha:]][-_$[:alnum:]]*)*)\n  )\n",
+			"end": "(/?>)",
+			"beginCaptures": {
+				"1": {
+					"name": "punctuation.definition.tag.begin.jsx.jac"
+				},
+				"2": {
+					"name": "entity.name.tag.jsx.jac"
+				}
+			},
+			"endCaptures": {
+				"1": {
+					"name": "punctuation.definition.tag.end.jsx.jac"
+				}
+			},
+			"patterns": [
+				{
+					"include": "#jsx-tag-attributes"
+				},
+				{
+					"include": "#jsx-tag-in-expression"
 				}
 			]
 		},
+		"jsx-tag-attributes": {
+			"patterns": [
+				{
+					"include": "#jsx-tag-attribute-name"
+				},
+				{
+					"include": "#jsx-tag-attribute-assignment"
+				},
+				{
+					"include": "#jsx-spread-attribute"
+				},
+				{
+					"include": "#jsx-string-double-quoted"
+				},
+				{
+					"include": "#jsx-string-single-quoted"
+				},
+				{
+					"include": "#jsx-evaluated-code"
+				}
+			]
+		},
+		"jsx-tag-attribute-name": {
+			"name": "entity.other.attribute-name.jsx.jac",
+			"match": "(?x)\n  [_$[:alpha:]][-_$[:alnum:]]*\n"
+		},
+		"jsx-tag-attribute-assignment": {
+			"name": "keyword.operator.assignment.jsx.jac",
+			"match": "="
+		},
+		"jsx-spread-attribute": {
+			"begin": "(\\{)(\\.\\.\\.)",
+			"end": "(\\})",
+			"beginCaptures": {
+				"1": {
+					"name": "punctuation.section.embedded.begin.jsx.jac"
+				},
+				"2": {
+					"name": "keyword.operator.spread.jsx.jac"
+				}
+			},
+			"endCaptures": {
+				"1": {
+					"name": "punctuation.section.embedded.end.jsx.jac"
+				}
+			},
+			"patterns": [
+				{
+					"include": "#general"
+				}
+			]
+		},
+		"jsx-string-double-quoted": {
+			"name": "string.quoted.double.jsx.jac",
+			"begin": "\"",
+			"end": "\"",
+			"patterns": [
+				{
+					"include": "#string-content"
+				}
+			]
+		},
+		"jsx-string-single-quoted": {
+			"name": "string.quoted.single.jsx.jac",
+			"begin": "'",
+			"end": "'",
+			"patterns": [
+				{
+					"include": "#string-content"
+				}
+			]
+		},
+		"jsx-evaluated-code": {
+			"name": "meta.embedded.expression.jsx.jac",
+			"begin": "\\{",
+			"end": "\\}",
+			"beginCaptures": {
+				"0": {
+					"name": "punctuation.section.embedded.begin.jsx.jac"
+				}
+			},
+			"endCaptures": {
+				"0": {
+					"name": "punctuation.section.embedded.end.jsx.jac"
+				}
+			},
+			"patterns": [
+				{
+					"include": "#general"
+				}
+			]
+		},
+		"jsx-tag-in-expression": {
+			"begin": "(?<=(?:^|>))",
+			"end": "(?=</)",
+			"patterns": [
+				{
+					"include": "#jsx-children"
+				}
+			]
+		},
+		"jsx-children": {
+			"patterns": [
+				{
+					"include": "#jsx-tag-fragment"
+				},
+				{
+					"include": "#jsx-tag"
+				},
+				{
+					"include": "#jsx-evaluated-code"
+				},
+				{
+					"include": "#jsx-text"
+				}
+			]
+		},
+		"jsx-text": {
+			"name": "string.unquoted.jsx.jac",
+			"match": "[^<>{}\n]+"
+		},
 		"comments": {
 			"patterns": [
 				{
@@ -622,7 +802,7 @@
 				},
 				{
 					"name": "storage.modifier.declaration.jac",
-					"match": "(?x)\n  \\b(?<!\\.)(\n    priv|protect|pub|static|override|let|abs|glob|global|nonlocal\n  )\\b\n"
+					"match": "(?x)\n  \\b(?<!\\.)(\n    priv|protect|pub|static|override|let|abs|glob|global|nonlocal|cl\n  )\\b\n"
 				},
 				{
 					"name": "storage.type.class.jac",