jac-client 0.2.3__py3-none-any.whl → 0.2.5__py3-none-any.whl

jac_client/tests/test_it.py

@@ -2,18 +2,30 @@
 
 from __future__ import annotations
 
+import gc
 import json
 import os
 import shutil
 import socket
 import tempfile
 import time
-from subprocess import Popen, run
+from http.client import RemoteDisconnected
+from subprocess import PIPE, Popen, run
 from urllib.error import HTTPError, URLError
 from urllib.request import Request, urlopen
 
 import pytest
 
+from jaclang.pycore.runtime import JacRuntime as Jac
+
+
+@pytest.fixture(autouse=True)
+def reset_jac_machine():
+    """Reset Jac machine before and after each test."""
+    Jac.reset_machine()
+    yield
+    Jac.reset_machine()
+
 
 def _wait_for_port(
     host: str,
@@ -44,10 +56,68 @@ def _wait_for_port(
     )
 
 
+def _wait_for_endpoint(
+    url: str,
+    timeout: float = 120.0,
+    poll_interval: float = 2.0,
+    request_timeout: float = 30.0,
+) -> bytes:
+    """Block until an HTTP endpoint returns a successful response or timeout.
+
+    Retries on 503 Service Unavailable (temporary) and connection errors.
+    Fails immediately on 500 Internal Server Error (permanent errors like compilation failures).
+
+    Returns:
+        The response body as bytes.
+
+    Raises:
+        TimeoutError: if the endpoint does not return success within timeout.
+        HTTPError: if the endpoint returns a non-retryable error (e.g., 500).
+    """
+    deadline = time.time() + timeout
+    last_err: Exception | None = None
+
+    while time.time() < deadline:
+        try:
+            with urlopen(url, timeout=request_timeout) as resp:
+                return resp.read()
+        except HTTPError as exc:
+            if exc.code == 503:
+                # Service Unavailable - retry (temporary condition, e.g., compilation in progress)
+                # Close the underlying response to release the socket
+                exc.close()
+                last_err = exc
+                print(f"[DEBUG] Endpoint {url} returned 503, retrying...")
+                time.sleep(poll_interval)
+            elif exc.code == 500:
+                # Internal Server Error - do not retry (permanent error, e.g., compilation failure)
+                # Close the underlying response to release the socket
+                exc.close()
+                # Re-raise immediately - 500 indicates a permanent error that won't resolve by retrying
+                raise
+            else:
+                # Other HTTP errors should not be retried
+                raise
+        except URLError as exc:
+            # Connection errors - retry
+            last_err = exc
+            print(f"[DEBUG] Endpoint {url} connection error: {exc}, retrying...")
+            time.sleep(poll_interval)
+        except RemoteDisconnected as exc:
+            # Server closed connection - retry
+            last_err = exc
+            print(f"[DEBUG] Endpoint {url} remote disconnected: {exc}, retrying...")
+            time.sleep(poll_interval)
+
+    raise TimeoutError(
+        f"Timed out waiting for {url} to become available. Last error: {last_err}"
+    )
+
+
 def test_all_in_one_app_endpoints() -> None:
-    """Create a Jac app, copy @all-in-one into it, run npm install, then verify endpoints."""
+    """Create a Jac app, copy @all-in-one into it, install packages from jac.toml, then verify endpoints."""
     print(
-        "[DEBUG] Starting test_all_in_one_app_endpoints using jac create_jac_app + @all-in-one"
+        "[DEBUG] Starting test_all_in_one_app_endpoints using jac create --cl + @all-in-one"
     )
 
     # Resolve the path to jac_client/examples/all-in-one relative to this test file.
@@ -68,33 +138,33 @@ def test_all_in_one_app_endpoints() -> None:
             print(f"[DEBUG] Changed working directory to {temp_dir}")
 
             # 1. Create a new Jac app via CLI (requires jac + jac-client plugin installed)
-            print(f"[DEBUG] Running 'jac create_jac_app {app_name}'")
-            create_result = run(
-                ["jac", "create_jac_app", app_name],
-                capture_output=True,
+            print(f"[DEBUG] Running 'jac create --cl {app_name}'")
+            process = Popen(
+                ["jac", "create", "--cl", app_name],
+                stdin=PIPE,
+                stdout=PIPE,
+                stderr=PIPE,
                 text=True,
             )
+            stdout, stderr = process.communicate()
+            returncode = process.returncode
+
             print(
-                "[DEBUG] 'jac create_jac_app' completed "
-                f"returncode={create_result.returncode}\n"
-                f"STDOUT:\n{create_result.stdout}\n"
-                f"STDERR:\n{create_result.stderr}\n"
+                "[DEBUG] 'jac create --cl' completed "
+                f"returncode={returncode}\n"
+                f"STDOUT:\n{stdout}\n"
+                f"STDERR:\n{stderr}\n"
             )
 
-            # If the currently installed `jac` CLI does not support `create_jac_app`,
-            # skip this integration test instead of failing the whole suite.
-            if (
-                create_result.returncode != 0
-                and "invalid choice: 'create_jac_app'" in create_result.stderr
-            ):
-                pytest.skip(
-                    "Skipping: installed `jac` CLI does not support `create_jac_app`."
+            # If the currently installed `jac` CLI does not support `create --cl`,
+            # fail the test instead of skipping it.
+            if returncode != 0 and "unrecognized arguments: --cl" in stderr:
+                pytest.fail(
+                    "Test failed: installed `jac` CLI does not support `create --cl`."
                 )
 
-            assert create_result.returncode == 0, (
-                "jac create_jac_app failed\n"
-                f"STDOUT:\n{create_result.stdout}\n"
-                f"STDERR:\n{create_result.stderr}\n"
+            assert returncode == 0, (
+                f"jac create --cl failed\nSTDOUT:\n{stdout}\nSTDERR:\n{stderr}\n"
             )
 
             project_path = os.path.join(temp_dir, app_name)
@@ -114,37 +184,40 @@ def test_all_in_one_app_endpoints() -> None:
                 else:
                     shutil.copy2(src, dst)
 
-            # 3. Run `npm install` inside the project directory so the frontend can build.
-            print("[DEBUG] Running 'npm install' in created Jac app")
-            npm_result = run(
-                ["npm", "install"],
+            # 3. Install packages from jac.toml using `jac add --cl`
+            # This reads packages from jac.toml, generates package.json, and runs npm install
+            print("[DEBUG] Running 'jac add --cl' to install packages from jac.toml")
+            jac_add_result = run(
+                ["jac", "add", "--cl"],
                 cwd=project_path,
                 capture_output=True,
                 text=True,
             )
             print(
-                "[DEBUG] 'npm install' completed "
-                f"returncode={npm_result.returncode}\n"
-                f"STDOUT (truncated to 2000 chars):\n{npm_result.stdout[:2000]}\n"
-                f"STDERR (truncated to 2000 chars):\n{npm_result.stderr[:2000]}\n"
+                "[DEBUG] 'jac add --cl' completed "
+                f"returncode={jac_add_result.returncode}\n"
+                f"STDOUT (truncated to 2000 chars):\n{jac_add_result.stdout[:2000]}\n"
+                f"STDERR (truncated to 2000 chars):\n{jac_add_result.stderr[:2000]}\n"
             )
 
-            if npm_result.returncode != 0:
-                pytest.skip(
-                    "Skipping: npm install failed or npm is not available in PATH."
+            if jac_add_result.returncode != 0:
+                pytest.fail(
+                    f"Test failed: jac add --cl failed or npm is not available in PATH.\n"
+                    f"STDOUT:\n{jac_add_result.stdout}\n"
+                    f"STDERR:\n{jac_add_result.stderr}\n"
                 )
 
-            app_jac_path = os.path.join(project_path, "app.jac")
-            assert os.path.isfile(app_jac_path), "all-in-one app.jac file missing"
+            app_jac_path = os.path.join(project_path, "src", "app.jac")
+            assert os.path.isfile(app_jac_path), "all-in-one src/app.jac file missing"
 
-            # 4. Start the server: `jac serve app.jac`
+            # 4. Start the server: `jac serve src/app.jac`
             # NOTE: We don't use text mode here, so `Popen` defaults to bytes.
             # Use `Popen[bytes]` in the type annotation to keep mypy happy.
             server: Popen[bytes] | None = None
             try:
-                print("[DEBUG] Starting server with 'jac serve app.jac'")
+                print("[DEBUG] Starting server with 'jac serve src/app.jac'")
                 server = Popen(
-                    ["jac", "serve", "app.jac"],
+                    ["jac", "serve", "src/app.jac"],
                     cwd=project_path,
                 )
 
@@ -169,28 +242,50 @@ def test_all_in_one_app_endpoints() -> None:
                         assert resp_root.status == 200
                         assert '"Jac API Server"' in root_body
                         assert '"endpoints"' in root_body
+
+                        # Verify custom headers from jac.toml are present
+                        assert (
+                            resp_root.headers.get("Cross-Origin-Opener-Policy")
+                            == "same-origin"
+                        ), (
+                            "Expected Cross-Origin-Opener-Policy header to be 'same-origin'"
+                        )
+                        assert (
+                            resp_root.headers.get("Cross-Origin-Embedder-Policy")
+                            == "require-corp"
+                        ), (
+                            "Expected Cross-Origin-Embedder-Policy header to be 'require-corp'"
+                        )
+                        print(
+                            "[DEBUG] Custom headers verified: COOP and COEP are present"
+                        )
                 except (URLError, HTTPError) as exc:
                     print(f"[DEBUG] Error while requesting root endpoint: {exc}")
                     pytest.fail(f"Failed to GET root endpoint: {exc}")
 
                 # "/page/app" – main page is loading
+                # Note: This endpoint may return 503 (temporary) while the page is being compiled,
+                # or 500 (permanent) if there's a compilation error. We use _wait_for_endpoint
+                # to retry on 503 until it's ready, but it will fail immediately on 500.
                 try:
-                    print("[DEBUG] Sending GET request to /page/app endpoint")
-                    with urlopen(
+                    print(
+                        "[DEBUG] Sending GET request to /page/app endpoint (with retry)"
+                    )
+                    page_bytes = _wait_for_endpoint(
                         "http://127.0.0.1:8000/page/app",
-                        timeout=200,
-                    ) as resp_page:
-                        page_body = resp_page.read().decode("utf-8", errors="ignore")
-                        print(
-                            "[DEBUG] Received response from /page/app endpoint\n"
-                            f"Status: {resp_page.status}\n"
-                            f"Body (truncated to 500 chars):\n{page_body[:500]}"
-                        )
-                        assert resp_page.status == 200
-                        assert "<html" in page_body.lower()
-                except (URLError, HTTPError) as exc:
+                        timeout=120.0,
+                        poll_interval=2.0,
+                        request_timeout=30.0,
+                    )
+                    page_body = page_bytes.decode("utf-8", errors="ignore")
+                    print(
+                        "[DEBUG] Received response from /page/app endpoint\n"
+                        f"Body (truncated to 500 chars):\n{page_body[:500]}"
+                    )
+                    assert "<html" in page_body.lower()
+                except (URLError, HTTPError, TimeoutError, RemoteDisconnected) as exc:
                     print(f"[DEBUG] Error while requesting /page/app endpoint: {exc}")
-                    pytest.fail("Failed to GET /page/app endpoint")
+                    pytest.fail(f"Failed to GET /page/app endpoint: {exc}")
 
                 # "/page/app#/nested" – relative paths / nested route
                 # (hash fragment is client-side only but server should still serve the app shell)
@@ -217,23 +312,26 @@ def test_all_in_one_app_endpoints() -> None:
                     pytest.fail("Failed to GET /page/app#/nested endpoint")
 
                 # "/static/main.css" – CSS compiled and serving
+                # Note: CSS may be compiled asynchronously, so we retry if it's not ready
                 try:
-                    print("[DEBUG] Sending GET request to /static/main.css")
-                    with urlopen(
+                    print(
+                        "[DEBUG] Sending GET request to /static/main.css (with retry)"
+                    )
+                    css_bytes = _wait_for_endpoint(
                         "http://127.0.0.1:8000/static/main.css",
-                        timeout=20,
-                    ) as resp_css:
-                        css_body = resp_css.read().decode("utf-8", errors="ignore")
-                        print(
-                            "[DEBUG] Received response from /static/main.css\n"
-                            f"Status: {resp_css.status}\n"
-                            f"Body (truncated to 500 chars):\n{css_body[:500]}"
-                        )
-                        assert resp_css.status == 200
-                        assert len(css_body.strip()) > 0
-                except (URLError, HTTPError) as exc:
+                        timeout=60.0,
+                        poll_interval=2.0,
+                        request_timeout=20.0,
+                    )
+                    css_body = css_bytes.decode("utf-8", errors="ignore")
+                    print(
+                        "[DEBUG] Received response from /static/main.css\n"
+                        f"Body (truncated to 500 chars):\n{css_body[:500]}"
+                    )
+                    assert len(css_body.strip()) > 0, "CSS file should not be empty"
+                except (URLError, HTTPError, TimeoutError, RemoteDisconnected) as exc:
                     print(f"[DEBUG] Error while requesting /static/main.css: {exc}")
-                    pytest.fail("Failed to GET /static/main.css")
+                    pytest.fail(f"Failed to GET /static/main.css after retries: {exc}")
 
                 # "/static/assets/burger.png" – static files are loading
                 try:
@@ -259,6 +357,34 @@ def test_all_in_one_app_endpoints() -> None:
                     )
                     pytest.fail("Failed to GET /static/assets/burger.png")
 
+                # "/workers/worker.js" – worker script is served
+                try:
+                    print(
+                        "[DEBUG] Sending GET request to /workers/worker.js (with retry)"
+                    )
+                    worker_js_bytes = _wait_for_endpoint(
+                        "http://127.0.0.1:8000/workers/worker.js",
+                        timeout=60.0,
+                        poll_interval=2.0,
+                        request_timeout=20.0,
+                    )
+                    worker_js_body = worker_js_bytes.decode("utf-8", errors="ignore")
+                    print(
+                        "[DEBUG] Received response from /workers/worker.js\n"
+                        f"Body (truncated to 500 chars):\n{worker_js_body[:500]}"
+                    )
+                    assert len(worker_js_body.strip()) > 0, (
+                        "Worker JS should not be empty"
+                    )
+                    assert (
+                        "postMessage" in worker_js_body or "onmessage" in worker_js_body
+                    ), "Worker JS should contain a message handler"
+                except (URLError, HTTPError, TimeoutError, RemoteDisconnected) as exc:
+                    print(f"[DEBUG] Error while requesting /workers/worker.js: {exc}")
+                    pytest.fail(
+                        f"Failed to GET /workers/worker.js after retries: {exc}"
+                    )
+
                 # "/walker/get_server_message" – walkers are integrated and up and running
                 try:
                     print("[DEBUG] Sending GET request to /walker/get_server_message")
@@ -312,6 +438,153 @@ def test_all_in_one_app_endpoints() -> None:
                     print(f"[DEBUG] Error while requesting /walker/create_todo: {exc}")
                     pytest.fail("Failed to POST /walker/create_todo")
 
+                # POST /user/register – register a new user
+                test_username = "test_user"
+                test_password = "test_password_123"
+                try:
+                    print("[DEBUG] Sending POST request to /user/register endpoint")
+                    register_payload = {
+                        "username": test_username,
+                        "password": test_password,
+                    }
+                    req_register = Request(
+                        "http://127.0.0.1:8000/user/register",
+                        data=json.dumps(register_payload).encode("utf-8"),
+                        headers={"Content-Type": "application/json"},
+                        method="POST",
+                    )
+                    with urlopen(req_register, timeout=20) as resp_register:
+                        register_body = resp_register.read().decode(
+                            "utf-8", errors="ignore"
+                        )
+                        print(
+                            "[DEBUG] Received response from /user/register\n"
+                            f"Status: {resp_register.status}\n"
+                            f"Body (truncated to 500 chars):\n{register_body[:500]}"
+                        )
+                        assert resp_register.status == 201
+                        register_data = json.loads(register_body)
+                        assert "username" in register_data
+                        assert "token" in register_data
+                        assert "root_id" in register_data
+                        assert register_data["username"] == test_username
+                        assert len(register_data["token"]) > 0
+                        assert len(register_data["root_id"]) > 0
+                        print(
+                            f"[DEBUG] Successfully registered user: {test_username}\n"
+                            f"Token: {register_data['token'][:20]}...\n"
+                            f"Root ID: {register_data['root_id']}"
+                        )
+                except (URLError, HTTPError) as exc:
+                    print(f"[DEBUG] Error while requesting /user/register: {exc}")
+                    pytest.fail("Failed to POST /user/register")
+
+                # POST /user/login – login with registered credentials
+                try:
+                    print("[DEBUG] Sending POST request to /user/login endpoint")
+                    login_payload = {
+                        "username": test_username,
+                        "password": test_password,
+                    }
+                    req_login = Request(
+                        "http://127.0.0.1:8000/user/login",
+                        data=json.dumps(login_payload).encode("utf-8"),
+                        headers={"Content-Type": "application/json"},
+                        method="POST",
+                    )
+                    with urlopen(req_login, timeout=20) as resp_login:
+                        login_body = resp_login.read().decode("utf-8", errors="ignore")
+                        print(
+                            "[DEBUG] Received response from /user/login\n"
+                            f"Status: {resp_login.status}\n"
+                            f"Body (truncated to 500 chars):\n{login_body[:500]}"
+                        )
+                        assert resp_login.status == 200
+                        login_data = json.loads(login_body)
+                        assert "token" in login_data
+                        assert len(login_data["token"]) > 0
+                        print(
+                            f"[DEBUG] Successfully logged in user: {test_username}\n"
+                            f"Token: {login_data['token'][:20]}..."
+                        )
+                except (URLError, HTTPError) as exc:
+                    print(f"[DEBUG] Error while requesting /user/login: {exc}")
+                    pytest.fail("Failed to POST /user/login")
+
+                # POST /user/login – test login with invalid credentials
+                try:
+                    print(
+                        "[DEBUG] Sending POST request to /user/login with invalid credentials"
+                    )
+                    invalid_login_payload = {
+                        "username": "nonexistent_user",
+                        "password": "wrong_password",
+                    }
+                    req_invalid_login = Request(
+                        "http://127.0.0.1:8000/user/login",
+                        data=json.dumps(invalid_login_payload).encode("utf-8"),
+                        headers={"Content-Type": "application/json"},
+                        method="POST",
+                    )
+                    try:
+                        with urlopen(req_invalid_login, timeout=20) as resp_invalid:
+                            # If we get here, the request succeeded but should have failed
+                            invalid_body = resp_invalid.read().decode(
+                                "utf-8", errors="ignore"
+                            )
+                            print(
+                                "[DEBUG] Received response from /user/login (invalid creds)\n"
+                                f"Status: {resp_invalid.status}\n"
+                                f"Body: {invalid_body}"
+                            )
+                            # Login should fail with invalid credentials
+                            assert (
+                                resp_invalid.status != 200
+                                or "error" in invalid_body.lower()
+                            )
+                    except HTTPError as http_err:
+                        # Expected: login should fail with 401 or similar
+                        print(
+                            f"[DEBUG] Expected error for invalid login: {http_err.code} {http_err.reason}"
+                        )
+                        # Close the underlying response to release the socket
+                        http_err.close()
+                        assert http_err.code in (400, 401, 403), (
+                            f"Expected 400/401/403 for invalid login, got {http_err.code}"
+                        )
+                except URLError as exc:
+                    print(
+                        f"[DEBUG] Unexpected error while testing invalid login: {exc}"
+                    )
+                    pytest.fail("Unexpected error testing invalid login")
+
+                # Verify TypeScript component is working - check that page loads with TS component
+                # The /page/app endpoint should serve the app which includes the TypeScript Card component
+                try:
+                    print("[DEBUG] Verifying TypeScript component integration")
+                    # The page should load successfully (already tested above)
+                    # TypeScript components are compiled and included in the bundle
+                    # We verify this by checking the page loads without errors
+                    assert "<html" in page_body.lower(), "Page should contain HTML"
+                except Exception as exc:
+                    print(f"[DEBUG] Error verifying TypeScript component: {exc}")
+                    pytest.fail("Failed to verify TypeScript component integration")
+
+                # Verify nested folder imports are working - /page/app#/nested route
+                # This route uses nested folder imports (components.button and button)
+                try:
+                    print(
+                        "[DEBUG] Verifying nested folder imports via /page/app#/nested"
+                    )
+                    # The nested route should load successfully (already tested above)
+                    # Nested imports are compiled and included in the bundle
+                    assert "<html" in nested_body.lower(), (
+                        "Nested route should contain HTML"
+                    )
+                except Exception as exc:
+                    print(f"[DEBUG] Error verifying nested folder imports: {exc}")
+                    pytest.fail("Failed to verify nested folder imports")
+
             finally:
                 if server is not None:
                     print("[DEBUG] Terminating server process")
@@ -324,6 +597,13 @@ def test_all_in_one_app_endpoints() -> None:
                             "[DEBUG] Server did not terminate cleanly, killing process"
                         )
                         server.kill()
+                        server.wait(timeout=5)
+                    # Allow time for sockets to fully close and run garbage collection
+                    # to clean up any lingering socket objects before temp dir cleanup
+                    time.sleep(1)
+                    gc.collect()
         finally:
             print(f"[DEBUG] Restoring original working directory to {original_cwd}")
             os.chdir(original_cwd)
+            # Final garbage collection to ensure all resources are released
+            gc.collect()

{jac_client-0.2.3.dist-info → jac_client-0.2.5.dist-info}/METADATA

@@ -1,24 +1,20 @@
 Metadata-Version: 2.4
 Name: jac-client
-Version: 0.2.3
+Version: 0.2.5
 Summary: Build full-stack web applications with Jac - one language for frontend and backend.
-License: MIT
-Keywords: jac,jaclang,jaseci,frontend,full-stack,web-development
-Author: Jason Mars
-Author-email: jason@mars.ninja
-Maintainer: Jason Mars
-Maintainer-email: jason@mars.ninja
-Requires-Python: >=3.12.0,<4.0.0
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3.14
-Requires-Dist: jaclang (==0.9.3)
-Project-URL: Documentation, https://jac-lang.org
-Project-URL: Homepage, https://jaseci.org
+Author-email: Jason Mars <jason@mars.ninja>
+Maintainer-email: Jason Mars <jason@mars.ninja>
+License-Expression: MIT
 Project-URL: Repository, https://github.com/Jaseci-Labs/jaseci
+Project-URL: Homepage, https://jaseci.org
+Project-URL: Documentation, https://jac-lang.org
+Keywords: jac,jaclang,jaseci,frontend,full-stack,web-development
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
+Requires-Dist: jaclang==0.9.5
+Provides-Extra: dev
+Requires-Dist: python-dotenv==1.0.1; extra == "dev"
+Requires-Dist: pytest==8.3.5; extra == "dev"
 
 # Jac Client
 
@@ -28,7 +24,7 @@ Jac Client enables you to write React-like components, manage state, and build i
 
 ---
 
-## ✨ Features
+## Features
 
 - **Single Language**: Write frontend and backend in Jac
 - **No HTTP Client**: Use `jacSpawn()` instead of fetch/axios
@@ -40,7 +36,7 @@ Jac Client enables you to write React-like components, manage state, and build i
 
 ---
 
-## 🚀 Quick Start
+## Quick Start
 
 ### Installation
 
@@ -51,16 +47,18 @@ pip install jac-client
 ### Create a New App
 
 ```bash
-jac create_jac_app my-app
+jac create --cl my-app
 cd my-app
-jac serve app.jac
+jac serve src/app.jac
 ```
 
 Visit `http://localhost:8000/page/app` to see your app!
 
+> **Note**: The `--cl` flag creates a client-side project with an organized folder structure. Without `--cl`, `jac create` creates a standard Jac project.
+
 ---
 
-## 📚 Documentation
+## Documentation
 
 For detailed guides and tutorials, see the **[docs folder](jac_client/docs/)**:
 
@@ -72,7 +70,7 @@ For detailed guides and tutorials, see the **[docs folder](jac_client/docs/)**:
 
 ---
 
-## 💡 Example
+## Example
 
 ### Simple Counter with React Hooks
 
@@ -81,7 +79,7 @@ cl import from react { useState, useEffect }
 
 cl {
     def Counter() -> any {
-        let [count, setCount] = useState(0);
+        [count, setCount] = useState(0);
 
         useEffect(lambda -> None {
             console.log("Count changed:", count);
@@ -132,7 +130,7 @@ walker read_todos {
 # Frontend: React component
 cl {
     def app() -> any {
-        let [todos, setTodos] = useState([]);
+        [todos, setTodos] = useState([]);
 
         useEffect(lambda -> None {
             async def loadTodos() -> None {
@@ -154,7 +152,7 @@ cl {
 
 ---
 
-## 🔧 Requirements
+## Requirements
 
 - Python: 3.12+
 - Node.js: For npm and Vite
@@ -162,9 +160,10 @@ cl {
 
 ---
 
-## 🛠️ How It Works
+## ️ How It Works
 
 Jac Client is a plugin that:
+
 1. Compiles your `.jac` client code to JavaScript
 2. Bundles dependencies with Vite for optimal performance
 3. Provides a runtime for reactive state and components
@@ -172,7 +171,7 @@ Jac Client is a plugin that:
 
 ---
 
-## 📖 Learn More
+## Learn More
 
 - **Full Documentation**: See [docs/](jac_client/docs/) for comprehensive guides
 - **Examples**: Check `jac_client/examples/` for working examples
@@ -180,11 +179,10 @@ Jac Client is a plugin that:
 
 ---
 
-## 📄 License
+## License
 
 MIT License - see [LICENSE](../LICENSE) file.
 
 ---
 
-**Happy coding with Jac!** 🎉
-
+**Happy coding with Jac!**