programasweights 0.2.2.dev1__tar.gz → 0.2.3__tar.gz

programasweights-0.2.3/AGENTS.md

@@ -0,0 +1,173 @@
+# ProgramAsWeights (PAW)
+
+PAW compiles natural language specifications into tiny neural functions that run locally. Each function takes a single text input and returns a single text output. Use it when you need fuzzy text processing — classification, extraction, format repair, search, triage — that regex can't handle but a full LLM is overkill for.
+
+Website: https://programasweights.com
+Docs: https://programasweights.readthedocs.io
+
+## Install
+
+```bash
+pip install programasweights --extra-index-url https://pypi.programasweights.com/simple/
+```
+
+## Usage
+
+```python
+import programasweights as paw
+
+# Use a pre-compiled function (downloads once, runs locally forever)
+# "email-triage" is an official pre-compiled program (slug)
+fn = paw.function("email-triage")
+fn("Urgent: server is down!")  # "immediate"
+fn("Newsletter: spring picnic")  # "wait"
+
+# Compile your own from a description
+program = paw.compile(
+    "Fix malformed JSON: repair missing quotes and trailing commas",
+    compiler="paw-4b-qwen3-0.6b"  # or "paw-4b-gpt2" for smaller/faster
+)
+fn = paw.function(program.id)
+fn("{name: 'Alice',}")  # '{"name": "Alice"}'
+
+# Or compile and load in one step
+fn = paw.compile_and_load("Classify sentiment as positive or negative")
+fn("I love this!")  # "positive"
+```
+
+## Two Compilers
+
+| | Standard (Qwen3 0.6B) | Compact (GPT-2 124M) |
+|---|---|---|
+| Compiler name | `paw-4b-qwen3-0.6b` | `paw-4b-gpt2` |
+| Accuracy | Higher | Lower |
+| Base model size | 594 MB | 105 MB |
+| Program size | ~22 MB | ~5 MB |
+| Inference speed | ~90ms (server) | ~50ms (server) |
+| Runs in browser | No | Yes (must use this compiler) |
+
+Default is Standard. Use Compact for smaller files or browser deployment.
+
+## When to Use PAW
+
+- **Fuzzy search** — typo-tolerant matching, semantic search, near-duplicate detection
+- **Format repair** — fix broken JSON, normalize dates, repair malformed inputs
+- **Classification** — sentiment, urgency, categories defined in your own words
+- **Extraction** — emails, names, dates from messy unstructured text
+- **Log triage** — extract errors from verbose output, filter noise
+- **Intent routing** — map user descriptions to the closest URL, menu item, or setting
+- **Agent preprocessing** — parse tool calls, validate outputs, route tasks
+
+## Writing Good Specs
+
+Description + examples. Use `Input: ... Output: ...` format.
+
+```python
+fn = paw.compile_and_load("""
+Classify user intent. Return ONLY one of: search, create, delete, other.
+
+Input: Find the latest report
+Output: search
+
+Input: Make a new folder
+Output: create
+
+Input: Remove old backups
+Output: delete
+""")
+```
+
+- State output constraints explicitly if any: "Return ONLY one of: X, Y, Z"
+- Each function is stateless: one input, one output. No conversation history.
+- Write a few test inputs with expected outputs, then try different spec phrasings and pick the one that passes the most.
+
+## Browser / JavaScript SDK
+
+Programs compiled with `paw-4b-gpt2` run in the browser via WebAssembly.
+
+```bash
+npm install @programasweights/web
+```
+
+```javascript
+import paw from '@programasweights/web';
+
+const fn = await paw.function('programasweights/email-triage');
+const result = await fn('Urgent: server is down!');
+// result: "immediate"
+```
+
+## Authentication (optional)
+
+Sign in for higher rate limits and program naming. Everything works without it.
+
+```bash
+export PAW_API_KEY=paw_sk_...
+```
+
+Generate API keys at https://programasweights.com/settings.
+
+| | Anonymous | Authenticated |
+|---|---|---|
+| Compile rate limit | 20/hr | 60/hr |
+| Name programs (slugs) | No | Yes |
+
+## CLI
+
+```bash
+paw compile --spec "Classify sentiment" --json
+paw run --program <program_id> --input "I love this!" --json
+paw info <program_id>             # show program metadata
+paw rename <program_id> my-slug   # name a program (requires auth)
+paw login                         # save API key
+```
+
+`--json` gives structured output. Example:
+
+```json
+{"program_id": "a6b454023d41ac9ca845", "slug": null, "status": "ready", "error": null, "timings": {"total_ms": 2800}}
+```
+
+## Full API Reference
+
+```python
+program = paw.compile(
+    spec,                               # natural language specification (str)
+    compiler="paw-4b-qwen3-0.6b",
+    slug=None,                          # URL-safe handle (requires auth)
+    public=True,                        # list on public hub
+)
+# Returns: Program(id, slug, status, timings, error)
+
+fn = paw.function(program)              # accepts Program object, hash ID, or slug
+fn = paw.function("a6b454023d41ac9ca845")
+fn = paw.function("da03/my-classifier")
+
+result: str = fn(input_text: str, max_tokens=512, temperature=0.0)
+
+fn = paw.compile_and_load(spec, compiler="paw-4b-qwen3-0.6b")
+
+programs = paw.list_programs(sort="recent", per_page=20)  # requires auth
+
+paw.login()
+```
+
+## Common Errors
+
+| Error | Cause | Fix |
+|-------|-------|-----|
+| `httpx.HTTPStatusError: 404` on download | Program still uploading to CDN | SDK retries automatically. If persistent, recompile. |
+| `httpx.HTTPStatusError: 422` on compile | Spec too short (<10 chars) | Adjust spec length. |
+| `httpx.HTTPStatusError: 429` | Rate limit exceeded | Wait, or sign in for higher limits. |
+
+## Performance
+
+- **First call** ~500ms (loads base model). Subsequent calls ~50-90ms.
+- **Base model shared** across functions. Each LoRA adapter adds ~22 MB.
+- **Thread-safe** and **blocking**.
+- **Cache**: `~/.cache/programasweights/`. Override with `PAW_CACHE_DIR`.
+- **Offline** after first download.
+
+## Browse Programs
+
+https://programasweights.com/hub

{programasweights-0.2.2.dev1 → programasweights-0.2.3}/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.2.2 (2026-03-19)
+
+- Add `paw.compile_and_load()` convenience method (compile + load in one call)
+- `paw.function()` now accepts a `Program` object directly (not just string ID)
+- Add `paw.list_programs()` for authenticated users to list their programs
+- Suppress `llama.cpp` stderr noise by default; use `verbose=True` to enable
+- Rewritten AGENTS.md with spec-writing tips, full API reference, common errors, and performance notes
+
 ## 0.2.0 (2026-04-01)
 
 First public release.

{programasweights-0.2.2.dev1 → programasweights-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: programasweights
-Version: 0.2.2.dev1
+Version: 0.2.3
 Summary: Compile natural language specifications into neural programs that run locally via llama.cpp.
 Project-URL: Homepage, https://programasweights.com
 Project-URL: Repository, https://github.com/programasweights/programasweights-python
@@ -58,6 +58,10 @@ program = paw.compile(
 )
 fn = paw.function(program.slug)    # or paw.function(program.id)
 fn("{name: 'Alice',}")  # '{"name": "Alice"}'
+
+# Or compile and load in one step
+fn = paw.compile_and_load("Classify sentiment as positive or negative")
+fn("I love this!")  # "positive"
 ```
 
 ## Two Compilers

{programasweights-0.2.2.dev1 → programasweights-0.2.3}/PYPI_README.md

@@ -28,6 +28,10 @@ program = paw.compile(
 )
 fn = paw.function(program.slug)    # or paw.function(program.id)
 fn("{name: 'Alice',}")  # '{"name": "Alice"}'
+
+# Or compile and load in one step
+fn = paw.compile_and_load("Classify sentiment as positive or negative")
+fn("I love this!")  # "positive"
 ```
 
 ## Two Compilers

{programasweights-0.2.2.dev1 → programasweights-0.2.3}/docs/api-reference/python-sdk.md

@@ -24,7 +24,7 @@ Loads a compiled program and returns a callable. Downloads the program and base
 
 | Parameter | Description |
 |-----------|-------------|
-| `name_or_id` | Program hash ID (e.g. `a6b454023d41ac9ca845`), slug (e.g. `da03/my-classifier`), or official shorthand (e.g. `email-triage`). |
+| `name_or_id` | A `Program` object, hash ID (e.g. `a6b454023d41ac9ca845`), slug (e.g. `da03/my-classifier`), or official shorthand (e.g. `email-triage`). |
 | `n_ctx` | Context length for the local runtime (default `2048`). |
 | `n_gpu_layers` | GPU layers to offload (`0` = CPU-only, `-1` = all). Set `PAW_GPU_LAYERS` env var as default. |
 | `verbose` | Enable verbose logging (default `False`). |
@@ -76,6 +76,36 @@ Compiles a natural language spec on the server. Returns a `Program` object.
 | `timings` | Timing metadata from the server. |
 | `error` | Error message when compilation fails. |
 
+## `paw.compile_and_load`
+
+```python
+fn = paw.compile_and_load(spec, compiler="paw-4b-qwen3-0.6b", **kwargs)
+```
+
+Convenience method that compiles a spec and immediately loads the result for local inference. Equivalent to `paw.function(paw.compile(spec, ...).id)`. Returns a callable.
+
+Accepts all the same parameters as `paw.compile`.
+
+## `paw.list_programs`
+
+```python
+result = paw.list_programs(sort="recent", per_page=20)
+```
+
+Returns a dict with the authenticated user's compiled programs. Requires authentication.
+
+| Parameter | Description |
+|-----------|-------------|
+| `sort` | Sort order: `"recent"` (default), `"votes"`, `"recommended"`. |
+| `per_page` | Number of results per page (default `20`). |
+
+**Return value** -- dict:
+
+| Key | Description |
+|-----|-------------|
+| `programs` | List of program dicts with `id`, `spec`, `name`, `compiler`, etc. |
+| `total` | Total number of programs. |
+
 ## `paw.login`
 
 ```python

{programasweights-0.2.2.dev1 → programasweights-0.2.3}/programasweights/__init__.py

@@ -21,8 +21,9 @@ API reference:
     paw.api_url                Server URL (default: https://programasweights.com)
     paw.api_key                API key (set via login() or PAW_API_KEY env var)
 """
+from __future__ import annotations
 
-__version__ = "0.2.2.dev1"
+__version__ = "0.2.3"
 
 from .config import get_api_url, get_api_key, set_api_key
 

{programasweights-0.2.2.dev1 → programasweights-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "programasweights"
-version = "0.2.2.dev1"
+version = "0.2.3"
 description = "Compile natural language specifications into neural programs that run locally via llama.cpp."
 readme = "PYPI_README.md"
 requires-python = ">=3.9"

{programasweights-0.2.2.dev1 → programasweights-0.2.3}/server/.env.example

@@ -44,4 +44,3 @@ LOG_FORMAT=json
 # Server
 HOST=0.0.0.0
 PORT=8000
-WORKERS=4

{programasweights-0.2.2.dev1 → programasweights-0.2.3}/server/api/config.py

@@ -50,10 +50,9 @@ class Settings(BaseSettings):
     LOG_LEVEL: str = "INFO"
     LOG_FORMAT: str = "json"
 
-    # Server
+    # Server (single process: sessions and compile jobs are in-memory)
     HOST: str = "0.0.0.0"
     PORT: int = 8000
-    WORKERS: int = 4
 
     # CORS
     CORS_ORIGINS: list[str] = [

{programasweights-0.2.2.dev1 → programasweights-0.2.3}/server/api/main.py

@@ -16,6 +16,8 @@ from redis.asyncio import Redis
 
 from api.config import get_settings
 from api.logging_config import configure_logging, request_id_ctx
+from collections import deque
+
 from api.middleware.rate_limit import (
     RateLimiter,
     identifier_for_request,
@@ -29,6 +31,31 @@ gpu_semaphore = asyncio.Semaphore(1)
 
 _RATE_LIMITED_PATHS = {"/api/v1/compile", "/api/v1/infer", "/api/v1/feedback"}
 
+_FALLBACK_LIMITS = {"compile": 13000, "infer": 5700}
+_FALLBACK_WINDOW = 3600
+
+
+class _FallbackLimiter:
+    """In-memory global rate limiter used when Redis is unavailable."""
+
+    def __init__(self):
+        self._windows: dict[str, deque] = {
+            "compile": deque(),
+            "infer": deque(),
+        }
+
+    def check(self, endpoint: str) -> bool:
+        key = "compile" if "compile" in endpoint else "infer"
+        now = time.time()
+        window = self._windows[key]
+        cutoff = now - _FALLBACK_WINDOW
+        while window and window[0] < cutoff:
+            window.popleft()
+        if len(window) >= _FALLBACK_LIMITS[key]:
+            return False
+        window.append(now)
+        return True
+
 
 def create_app() -> FastAPI:
     settings = get_settings()
@@ -45,13 +72,13 @@ def create_app() -> FastAPI:
         openapi_url="/api/openapi.json",
     )
 
-    # Redis + rate limiter (attached to app state for access in routes)
     redis_client: Redis | None = None
     rate_limiter: RateLimiter | None = None
+    fallback_limiter: _FallbackLimiter | None = None
 
     @app.on_event("startup")
     async def startup_redis():
-        nonlocal redis_client, rate_limiter
+        nonlocal redis_client, rate_limiter, fallback_limiter
         try:
             redis_client = Redis.from_url(
                 settings.REDIS_URL, decode_responses=True, socket_connect_timeout=5,
@@ -60,11 +87,14 @@ def create_app() -> FastAPI:
             rate_limiter = RateLimiter(redis_client)
             app.state.redis = redis_client
             app.state.rate_limiter = rate_limiter
+            app.state.redis_available = True
             logger.info("redis_connected", url=settings.REDIS_URL)
         except Exception:
-            logger.warning("redis_unavailable", url=settings.REDIS_URL)
+            logger.warning("redis_unavailable, using in-memory global fallback limiter", url=settings.REDIS_URL)
             app.state.redis = None
             app.state.rate_limiter = None
+            app.state.redis_available = False
+            fallback_limiter = _FallbackLimiter()
 
     @app.on_event("shutdown")
     async def shutdown_redis():
@@ -90,7 +120,23 @@ def create_app() -> FastAPI:
         token = request_id_ctx.set(rid)
         try:
             # Rate limiting for /compile and /infer
-            if request.method == "POST" and request.url.path in _RATE_LIMITED_PATHS and rate_limiter is not None:
+            if request.method == "POST" and request.url.path in _RATE_LIMITED_PATHS and rate_limiter is None and fallback_limiter is not None:
+                endpoint = "compile" if "compile" in request.url.path else "infer"
+                if not fallback_limiter.check(endpoint):
+                    logger.info("fallback_rate_limited", endpoint=endpoint)
+                    return JSONResponse(
+                        status_code=429,
+                        content={
+                            "error": "rate_limit_exceeded",
+                            "message": "Server is busy. Please try again shortly.",
+                            "request_id": rid,
+                        },
+                        headers={"Retry-After": "10"},
+                    )
+                request.state.has_concurrent_lock = False
+                request.state.rate_limit_result = None
+
+            elif request.method == "POST" and request.url.path in _RATE_LIMITED_PATHS and rate_limiter is not None:
                 from api.dependencies import get_current_user
                 from api.models.database import get_db
 

{programasweights-0.2.2.dev1 → programasweights-0.2.3}/server/api/models/schemas.py

@@ -213,6 +213,7 @@ class HealthResponse(BaseModel):
     gpu_services: dict
     queue_depth: int
     uptime_s: float
+    warnings: list[str] = []
 
 
 # --- Error ---

{programasweights-0.2.2.dev1 → programasweights-0.2.3}/server/api/routes/auth.py

@@ -132,7 +132,6 @@ async def github_callback(code: str, state: str, request: Request, db: AsyncSess
         "email": email,
         "avatar_url": avatar_url,
         "tier": "github",
-        "github_access_token": access_token,
         "created_at": time.time(),
     }
     _sessions[session_token] = user_info

{programasweights-0.2.2.dev1 → programasweights-0.2.3}/server/api/routes/health.py

@@ -4,7 +4,7 @@ Health check endpoint.
 
 import time
 
-from fastapi import APIRouter
+from fastapi import APIRouter, Request
 
 from api.models.schemas import HealthResponse
 
@@ -14,11 +14,16 @@ _start_time = time.time()
 
 
 @router.get("/health", response_model=HealthResponse)
-async def health_check():
+async def health_check(request: Request):
+    warnings = []
+    if not getattr(request.app.state, "redis_available", True):
+        warnings.append("redis_unavailable: using in-memory global rate limit fallback")
+
     return HealthResponse(
-        status="healthy",
+        status="healthy" if not warnings else "degraded",
         version="0.2.0",
         gpu_services={},
         queue_depth=0,
         uptime_s=time.time() - _start_time,
+        warnings=warnings,
     )

{programasweights-0.2.2.dev1 → programasweights-0.2.3}/server/api/routes/programs.py

@@ -146,9 +146,10 @@ async def list_programs(
     if search_term:
         try:
             from redis.asyncio import Redis as AsyncRedis
-            redis = AsyncRedis.from_url("redis://localhost:6379/0", decode_responses=True, socket_connect_timeout=1)
-            queue_depth = int(await redis.get("paw:compile_queue_depth") or 0)
-            await redis.aclose()
+            settings = get_settings()
+            _redis = AsyncRedis.from_url(settings.REDIS_URL, decode_responses=True, socket_connect_timeout=1)
+            queue_depth = int(await _redis.get("paw:compile_queue_depth") or 0)
+            await _redis.aclose()
             server_idle = queue_depth <= 1
         except Exception:
             server_idle = True

{programasweights-0.2.2.dev1 → programasweights-0.2.3}/web-app/frontend/e2e/full.spec.ts

@@ -794,3 +794,68 @@ test.describe('Slug and naming', () => {
     expect(count).toBeGreaterThanOrEqual(0);
   });
 });
+
+// ---------------------------------------------------------------------------
+// Auth and permissions (signed-out)
+// ---------------------------------------------------------------------------
+
+test.describe('Auth: signed-out behavior', () => {
+  test('profile redirects to home when not signed in', async ({ page }) => {
+    await page.goto('/profile');
+    await page.waitForURL('/', { timeout: 10_000 });
+    expect(page.url()).toMatch(/\/$/);
+  });
+
+  test('settings redirects to home when not signed in', async ({ page }) => {
+    await page.goto('/settings');
+    await page.waitForURL('/', { timeout: 10_000 });
+    expect(page.url()).toMatch(/\/$/);
+  });
+
+  test('hub program page does not show slug edit for anonymous users', async ({ page }) => {
+    await page.goto(`/hub/${KNOWN_PROGRAM_ID}`);
+    await waitForPageLoad(page);
+    const pencil = page.locator('button:has(svg.lucide-pencil)');
+    const bookmark = page.locator('button:has(svg.lucide-bookmark)');
+    await expect(pencil).toHaveCount(0);
+    await expect(bookmark).toHaveCount(0);
+  });
+
+  test('case delete buttons not shown for anonymous users', async ({ page }) => {
+    await page.goto(`/hub/${KNOWN_PROGRAM_ID}`);
+    await waitForPageLoad(page);
+    const trash = page.locator('button:has(svg.lucide-trash-2)');
+    await expect(trash).toHaveCount(0);
+  });
+
+  test('header does not flash sign-in button then switch', async ({ page }) => {
+    await page.goto('/');
+    const signIn = page.locator('a[href*="auth/github"]').first();
+    await expect(signIn).toBeVisible({ timeout: 10_000 });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Mobile menu route-change close
+// ---------------------------------------------------------------------------
+
+test.describe('Mobile menu closes on navigation', () => {
+  test.use({ viewport: { width: 375, height: 812 } });
+
+  test('mobile menu closes when navigating via logo', async ({ page }) => {
+    await page.goto('/playground');
+    await waitForPageLoad(page);
+
+    const menuBtn = page.locator('button[aria-label*="menu"]').first();
+    if (await menuBtn.isVisible()) {
+      await menuBtn.click();
+      await page.waitForTimeout(300);
+      const menu = page.locator('nav.space-y-1').first();
+      await expect(menu).toBeVisible();
+
+      await page.locator('a[href="/"]').first().click();
+      await page.waitForTimeout(500);
+      await expect(menu).not.toBeVisible();
+    }
+  });
+});

{programasweights-0.2.2.dev1 → programasweights-0.2.3}/web-app/frontend/index.html

@@ -14,20 +14,20 @@
     
     <!-- App Info -->
     <title>PAW — Define functions in English, run them locally</title>
-    <meta name="description" content="ProgramAsWeights compiles natural language specs into tiny neural programs that run locally. No API calls, no latency, no cost per request." />
+    <meta name="description" content="ProgramAsWeights compiles natural language specs into tiny neural programs that run on your machine. Once compiled, they work as regular Python functions." />
     
     <!-- Open Graph / Social Media -->
     <meta property="og:title" content="PAW — Define functions in English, run them locally" />
-    <meta property="og:description" content="Compile natural language into tiny neural programs. Like spaCy, but you define the function." />
-    <meta property="og:image" content="/paw-192.png" />
+    <meta property="og:description" content="Compile natural language specs into tiny neural programs that run on your machine. Once compiled, they work as regular Python functions." />
+    <meta property="og:image" content="https://programasweights.com/paw-192.png" />
     <meta property="og:type" content="website" />
     <meta property="og:site_name" content="ProgramAsWeights" />
 
     <!-- Twitter Card -->
     <meta name="twitter:card" content="summary_large_image" />
     <meta name="twitter:title" content="PAW — Define functions in English, run them locally" />
-    <meta name="twitter:description" content="Compile natural language into tiny neural programs. Like spaCy, but you define the function." />
-    <meta name="twitter:image" content="/paw-192.png" />
+    <meta name="twitter:description" content="Compile natural language specs into tiny neural programs that run on your machine. Once compiled, they work as regular Python functions." />
+    <meta name="twitter:image" content="https://programasweights.com/paw-192.png" />
     
     <!-- Theme Color -->
     <meta name="theme-color" content="#111827" />

{programasweights-0.2.2.dev1 → programasweights-0.2.3}/web-app/frontend/src/App.tsx

@@ -1,6 +1,8 @@
 import { BrowserRouter as Router, Routes, Route, Navigate, useLocation } from 'react-router-dom';
-import { useEffect } from 'react';
+import { Component, useEffect } from 'react';
+import type { ReactNode } from 'react';
 import { Toaster } from 'react-hot-toast';
+import { AuthProvider } from './contexts/AuthContext';
 import MainInterface from './components/MainInterface';
 import Header from './components/Header';
 import LandingPage from './components/LandingPage';
@@ -26,9 +28,38 @@ function ScrollToTop() {
   return null;
 }
 
+class ErrorBoundary extends Component<{ children: ReactNode }, { hasError: boolean }> {
+  state = { hasError: false };
+  static getDerivedStateFromError() { return { hasError: true }; }
+  componentDidCatch(error: unknown, info: unknown) {
+    console.error('Uncaught render error:', error, info);
+  }
+  render() {
+    if (this.state.hasError) {
+      return (
+        <div className="min-h-screen flex items-center justify-center bg-gray-50">
+          <div className="text-center max-w-md px-6">
+            <h1 className="text-2xl font-bold text-gray-900 mb-3">Something went wrong</h1>
+            <p className="text-gray-600 mb-6">An unexpected error occurred. Please try reloading the page.</p>
+            <button
+              onClick={() => window.location.reload()}
+              className="px-5 py-2.5 bg-gray-900 text-white rounded-lg hover:bg-gray-800 transition-colors text-sm font-medium"
+            >
+              Reload page
+            </button>
+          </div>
+        </div>
+      );
+    }
+    return this.props.children;
+  }
+}
+
 function App() {
   return (
+    <ErrorBoundary>
     <Router>
+    <AuthProvider>
       <ScrollToTop />
       <div className="min-h-screen bg-gray-50">
         <Toaster 
@@ -70,7 +101,9 @@ function App() {
         <Footer />
         <NavigationHelper />
       </div>
+    </AuthProvider>
     </Router>
+    </ErrorBoundary>
   );
 }
 

{programasweights-0.2.2.dev1 → programasweights-0.2.3}/web-app/frontend/src/components/AboutPage.tsx

@@ -1,9 +1,11 @@
 import { Link } from 'react-router-dom';
+import { Helmet } from 'react-helmet-async';
 import { Code, Zap, Shield, Users, BookOpen, Github, ExternalLink, Package, Terminal, Globe } from 'lucide-react';
 
 const AboutPage: React.FC = () => {
   return (
     <div className="max-w-4xl mx-auto space-y-12">
+      <Helmet><title>About — PAW</title></Helmet>
       {/* Hero */}
       <div className="text-center">
         <div className="flex items-center justify-center w-16 h-16 bg-gray-900 rounded-2xl mx-auto mb-6">
@@ -81,7 +83,7 @@ const AboutPage: React.FC = () => {
         </h2>
         <div className="grid md:grid-cols-2 gap-6">
           {[
-            { icon: Shield, title: 'Private by default', desc: 'Everything runs locally. Your data never leaves your machine.' },
+            { icon: Shield, title: 'Private by default', desc: 'Programs run locally after download. Your data stays on your machine during local inference.' },
             { icon: Zap, title: 'Deterministic', desc: 'Greedy decoding means identical input always produces identical output.' },
             { icon: Package, title: 'Tiny programs', desc: 'Programs are small LoRA adapters (5-22 MB). The interpreter is a lightweight pretrained model (105-594 MB, downloaded once).' },
             { icon: Code, title: 'Python-native', desc: 'pip install, import, call. No Docker, no servers, no configuration.' },