programasweights 0.4.0__tar.gz → 0.4.1__tar.gz

{programasweights-0.4.0 → programasweights-0.4.1}/AGENTS.md

@@ -5,27 +5,35 @@ PAW compiles natural language specifications into tiny neural functions that run
 Website: https://programasweights.com
 Full documentation: https://programasweights.readthedocs.io
 
+## 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
+
 ## Install
 
 ```bash
 pip install programasweights --extra-index-url https://pypi.programasweights.com/simple/
 ```
 
-## Usage
+## Quickstart
 
 ```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
+    "Fix malformed JSON: repair missing quotes and trailing commas"
 )
 fn = paw.function(program.id)
 fn("{name: 'Alice',}")  # '{"name":"Alice"}'
@@ -35,20 +43,18 @@ fn = paw.compile_and_load("Classify sentiment as positive or negative")
 fn("I love this!")  # "positive"
 ```
 
-## Two Compilers
+If you want the smaller browser-compatible runtime explicitly, pass `compiler="paw-4b-gpt2"`. Otherwise, omit `compiler` and let the server default decide.
+
+## Current Public Compilers
 
-- **Standard** (`paw-4b-qwen3-0.6b`) — higher accuracy, 594 MB base + ~22 MB/program. Default.
+- **Standard** (`paw-4b-qwen3-0.6b`) — higher accuracy, 594 MB base + ~22 MB/program. This is the current server default.
 - **Compact** (`paw-4b-gpt2`) — smaller (134 MB base + ~5 MB/program), runs in browser via WebAssembly.
 
-## When to Use PAW
+Best practice:
 
-- **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
+- For quickstarts and reusable agent workflows, prefer `paw.compile(spec)` with no explicit compiler.
+- If you need to target a specific runtime, pass `compiler="paw-4b-gpt2"` or another supported alias explicitly.
+- If you need to inspect current server-supported compiler names at runtime, call `paw.list_compilers()`.
 
 ## Writing Good Specs
 
@@ -73,58 +79,30 @@ Output: delete
 
 **Spec-tuning tips:**
 
-- Each function is stateless: one text input, one text output. No conversation history.
 - **State output constraints explicitly**: "Return ONLY one of: X, Y, Z". Without this the model may produce free-form text.
 - **Include examples from your actual data**: Examples outperform prose-only descriptions.
 - **Debug failures before sweeping**: Look at specific failing examples and understand WHY before trying many variants.
 
-## Context Window
+## Constraints And Runtime Behavior
 
+- Each PAW function is stateless: one text input, one text output. No conversation history.
 - Spec + input + output share a ~2048 token context window. Inputs that exceed it will error.
 - `max_tokens` defaults to `None`: generation runs until EOS or the context limit.
+- Compile runs on the hosted PAW API. Inference should usually run locally through the SDK.
+- **GPU acceleration** is enabled by default (`n_gpu_layers=-1`). Uses Metal on Mac, CUDA on Linux, and falls back to CPU automatically. If GPU causes issues, set `PAW_GPU_LAYERS=0` or pass `n_gpu_layers=0`.
+- **First call** is usually ~1-5s because it loads the base model. Subsequent calls are typically ~0.05-0.5s depending on input length and GPU availability.
+- **Base model files are shared** across programs on disk. Each Standard LoRA adapter is ~22 MB; each Compact LoRA adapter is ~5 MB.
+- Cache root is `~/.cache/programasweights/`. Override with `PAW_CACHE_DIR`.
+- After the first download, inference works offline.
 
-## Chaining Functions
-
-Multiple PAW functions can be composed for multi-step tasks:
-
-```python
-classifier = paw.compile_and_load("Classify the bug type. Return ONLY one of: off-by-one, type-error, other")
-fixer = paw.compile_and_load("Fix the bug described in the first line. Return only the corrected code.")
-
-label = classifier(code_snippet)
-if label != "other":
-    fix = fixer(f"{label}: {code_snippet}")
-```
-
-Chain them with regular Python logic.
-
-## Log Monitoring
-
-PAW functions can classify log output. Compile once with examples from your specific logs, then reuse the function locally forever:
-
-```python
-program = paw.compile("""
-Classify log lines. Return ONLY one word: ALERT or QUIET.
-
-Input: [step 100] loss=0.05 lr=0.0001
-Output: QUIET
-
-Input: [Checkpoint] Saved model at step 1000
-Output: ALERT
-
-Input: Traceback (most recent call last):
-Output: ALERT
-
-Input: Training complete. Final loss: 0.11
-Output: ALERT
-""")
-
-fn = paw.function(program.id)  # reuse with saved program.id
-fn("[step 200] loss=0.04")           # "QUIET"
-fn("[Checkpoint] Saved model")       # "ALERT"
-```
+## Common Errors
 
-Full tool with file watching, truncation, and stall detection: [examples/paw_monitor.py](https://github.com/programasweights/programasweights-python/blob/main/examples/paw_monitor.py)
+| Error | Cause | Fix |
+|-------|-------|-----|
+| `RuntimeError: assets not ready` on download | Program is still generating after compile | The SDK polls automatically for up to 30s. If it still fails, retry shortly or recompile. |
+| `httpx.HTTPStatusError: 422` on compile | Spec too short (<10 chars) or request validation failed | Adjust spec length or request shape. |
+| `httpx.HTTPStatusError: 429` | Hosted compile API limit exceeded | Wait, or sign in for higher compile limits. |
+| GPU/Metal errors on load | GPU backend not available or incompatible | Set `PAW_GPU_LAYERS=0` or pass `n_gpu_layers=0` to force CPU. |
 
 ## Browser / JavaScript SDK
 
@@ -137,11 +115,13 @@ npm install @programasweights/web
 ```javascript
 import paw from '@programasweights/web';
 
-const fn = await paw.function('programasweights/email-triage');
+const fn = await paw.function('email-triage-browser');
 const result = await fn('Urgent: server is down!');
 // result: "immediate"
 ```
 
+The browser SDK resolves slugs through the PAW API, then downloads browser assets from Hugging Face and runs inference client-side. If you load by program ID, browser inference stays independent of the PAW API at runtime.
+
 ## Authentication (optional)
 
 Sign in for higher rate limits and program naming. Everything works without it.
@@ -155,8 +135,11 @@ Generate API keys at https://programasweights.com/settings.
 | | Anonymous | Authenticated |
 |---|---|---|
 | Compile rate limit | 20/hr | 60/hr |
+| Concurrent compile requests | 1 | 2 |
 | Name programs (slugs) | No | Yes |
 
+Hosted API limits apply to compile requests. Most inference should run locally through the SDK.
+
 ## CLI
 
 Commands: `paw compile --spec "..." --json`, `paw run --program <id> --input "..."`, `paw info <id>`, `paw rename <id> <slug>`, `paw login`. All support `--json` for structured output.
@@ -175,14 +158,14 @@ fn = paw.function("da03/word-counter@v1")  # pinned to v1
 versions = paw.list_versions("da03/word-counter")  # all versions
 ```
 
-Pinned versions (`@v1`) are immutable and cached locally forever. Bare slugs always check the server for the latest main version (falls back to cache if offline).
+Pinned versions (`@v1`) are immutable and cached locally forever. Bare slugs always check the server for the latest main version and fall back to cache if offline.
 
 ## Full API Reference
 
 ```python
 program = paw.compile(
     spec,                               # natural language specification (str)
-    compiler="paw-4b-qwen3-0.6b",
+    compiler=None,                      # omit to use the current server default (today: paw-4b-qwen3-0.6b)
     slug=None,                          # URL-safe handle (requires auth)
     public=True,                        # list on public hub
 )
@@ -196,30 +179,57 @@ fn = paw.function("da03/my-classifier", offline=True)  # skip server check
 
 result: str = fn(input_text: str, max_tokens=None, temperature=0.0)
 
-fn = paw.compile_and_load(spec, compiler="paw-4b-qwen3-0.6b")
+fn = paw.compile_and_load(spec)
 
 versions = paw.list_versions("da03/my-classifier")  # version history
 programs = paw.list_programs(sort="recent", per_page=20)  # requires auth
+compilers = paw.list_compilers()  # discover available compilers at runtime
 
 paw.login()
 ```
 
-## Common Errors
+## Chaining Functions
 
-| Error | Cause | Fix |
-|-------|-------|-----|
-| `RuntimeError: assets not ready` on download | Program still generating after compile | SDK polls automatically for up to 30s. 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. |
-| GPU/Metal errors on load | GPU backend not available or incompatible | Set `PAW_GPU_LAYERS=0` or pass `n_gpu_layers=0` to force CPU. |
+Multiple PAW functions can be composed for multi-step tasks:
+
+```python
+classifier = paw.compile_and_load("Classify the bug type. Return ONLY one of: off-by-one, type-error, other")
+fixer = paw.compile_and_load("Fix the bug described in the first line. Return only the corrected code.")
 
-## Performance
+label = classifier(code_snippet)
+if label != "other":
+    fix = fixer(f"{label}: {code_snippet}")
+```
+
+Chain them with regular Python logic.
 
-- **GPU acceleration** enabled by default (`n_gpu_layers=-1`). Uses Metal on Mac, CUDA on Linux, falls back to CPU automatically. If GPU causes issues, set `PAW_GPU_LAYERS=0` or pass `n_gpu_layers=0`.
-- **First call** ~1-5s (loads base model). Subsequent calls ~0.05-0.5s depending on input length and GPU availability.
-- **Base model shared** across functions on disk. Each LoRA adapter adds ~22 MB.
-- **Cache**: `~/.cache/programasweights/`. Override with `PAW_CACHE_DIR`.
-- **Offline** after first download.
+## Worked Example: Log Monitoring
+
+PAW functions can classify log output. Compile once with examples from your specific logs, then reuse the function locally forever:
+
+```python
+program = paw.compile("""
+Classify log lines. Return ONLY one word: ALERT or QUIET.
+
+Input: [step 100] loss=0.05 lr=0.0001
+Output: QUIET
+
+Input: [Checkpoint] Saved model at step 1000
+Output: ALERT
+
+Input: Traceback (most recent call last):
+Output: ALERT
+
+Input: Training complete. Final loss: 0.11
+Output: ALERT
+""")
+
+fn = paw.function(program.id)  # reuse with saved program.id
+fn("[step 200] loss=0.04")           # "QUIET"
+fn("[Checkpoint] Saved model")       # "ALERT"
+```
+
+Full tool with file watching, truncation, and stall detection: [examples/paw_monitor.py](https://github.com/programasweights/programasweights-python/blob/main/examples/paw_monitor.py)
 
 ## Case Studies
 

{programasweights-0.4.0 → programasweights-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: programasweights
-Version: 0.4.0
+Version: 0.4.1
 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
@@ -53,7 +53,6 @@ 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
     slug="json-fixer"              # optional: creates username/json-fixer handle
 )
 fn = paw.function(program.slug)    # or paw.function(program.id)
@@ -64,7 +63,9 @@ fn = paw.compile_and_load("Classify sentiment as positive or negative")
 fn("I love this!")  # "positive"
 ```
 
-## Two Compilers
+If you specifically want the smaller browser-compatible runtime, pass `compiler="paw-4b-gpt2"`. Otherwise, omit `compiler` and let the server default decide.
+
+## Current Public Compilers
 
 
 |                 | Standard (Qwen3 0.6B) | Compact (GPT-2 124M) |
@@ -76,13 +77,15 @@ fn("I love this!")  # "positive"
 | Local inference | ~0.05-0.5s per call   | ~0.03-0.3s per call  |
 | Runs in browser | No                    | Yes (WebAssembly)    |
 
-Default is Standard (Qwen3 0.6B). Use Compact (GPT-2) when you need smaller files or browser deployment.
+The current server default is Standard (`paw-4b-qwen3-0.6b`). Use Compact (`paw-4b-gpt2`) when you need smaller files or browser deployment.
+
+If you need to inspect available compiler aliases programmatically, use `paw.list_compilers()`.
 
 GPU acceleration is enabled by default (Metal on Mac, CUDA on Linux, falls back to CPU). Set `PAW_GPU_LAYERS=0` to force CPU if GPU causes issues.
 
 ## Browser SDK
 
-Programs compiled with GPT-2 also run entirely in the browser via WebAssembly — no server needed, data never leaves the user's device.
+Programs compiled with GPT-2 also run in the browser via WebAssembly. The initial model and program assets download automatically; inference then runs client-side.
 
 ```bash
 npm install @programasweights/web
@@ -91,11 +94,15 @@ npm install @programasweights/web
 ```javascript
 import paw from '@programasweights/web';
 
-const fn = await paw.function('programasweights/email-triage');
+const fn = await paw.function('email-triage-browser');
 const result = await fn('Urgent: the server is down!');
 // result: "immediate"
 ```
 
+If you load by program ID, browser inference only depends on Hugging Face-hosted assets. Slugs still need one PAW API lookup.
+
+New browser-compatible programs are uploaded to Hugging Face asynchronously after compile. They are usually ready within a minute or two, but under load can take a few minutes, so a freshly compiled browser program may need a short wait before the JS SDK can load it.
+
 See the [browser SDK repo](https://github.com/programasweights/programasweights-js) for full documentation.
 
 ## Use with AI Agents

{programasweights-0.4.0 → programasweights-0.4.1}/PYPI_README.md

@@ -23,7 +23,6 @@ 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
     slug="json-fixer"              # optional: creates username/json-fixer handle
 )
 fn = paw.function(program.slug)    # or paw.function(program.id)
@@ -34,7 +33,9 @@ fn = paw.compile_and_load("Classify sentiment as positive or negative")
 fn("I love this!")  # "positive"
 ```
 
-## Two Compilers
+If you specifically want the smaller browser-compatible runtime, pass `compiler="paw-4b-gpt2"`. Otherwise, omit `compiler` and let the server default decide.
+
+## Current Public Compilers
 
 
 |                 | Standard (Qwen3 0.6B) | Compact (GPT-2 124M) |
@@ -46,13 +47,15 @@ fn("I love this!")  # "positive"
 | Local inference | ~0.05-0.5s per call   | ~0.03-0.3s per call  |
 | Runs in browser | No                    | Yes (WebAssembly)    |
 
-Default is Standard (Qwen3 0.6B). Use Compact (GPT-2) when you need smaller files or browser deployment.
+The current server default is Standard (`paw-4b-qwen3-0.6b`). Use Compact (`paw-4b-gpt2`) when you need smaller files or browser deployment.
+
+If you need to inspect available compiler aliases programmatically, use `paw.list_compilers()`.
 
 GPU acceleration is enabled by default (Metal on Mac, CUDA on Linux, falls back to CPU). Set `PAW_GPU_LAYERS=0` to force CPU if GPU causes issues.
 
 ## Browser SDK
 
-Programs compiled with GPT-2 also run entirely in the browser via WebAssembly — no server needed, data never leaves the user's device.
+Programs compiled with GPT-2 also run in the browser via WebAssembly. The initial model and program assets download automatically; inference then runs client-side.
 
 ```bash
 npm install @programasweights/web
@@ -61,11 +64,15 @@ npm install @programasweights/web
 ```javascript
 import paw from '@programasweights/web';
 
-const fn = await paw.function('programasweights/email-triage');
+const fn = await paw.function('email-triage-browser');
 const result = await fn('Urgent: the server is down!');
 // result: "immediate"
 ```
 
+If you load by program ID, browser inference only depends on Hugging Face-hosted assets. Slugs still need one PAW API lookup.
+
+New browser-compatible programs are uploaded to Hugging Face asynchronously after compile. They are usually ready within a minute or two, but under load can take a few minutes, so a freshly compiled browser program may need a short wait before the JS SDK can load it.
+
 See the [browser SDK repo](https://github.com/programasweights/programasweights-js) for full documentation.
 
 ## Use with AI Agents

programasweights-0.4.1/README.md

@@ -0,0 +1,186 @@
+# ProgramAsWeights
+
+Programs as small weight blobs; a fixed interpreter runs them.
+
+## Development
+
+```
+pip install -e .
+```
+
+```
+python test_compile.py
+```
+
+```
+python test_execute.py
+```
+
+
+## Quickstart
+
+```bash
+pip install programasweights
+```
+
+```python
+import programasweights
+f = programasweights.function("/path/to/weights")
+print(f("Hello"))
+```
+
+- weights = programs; base model = interpreter.
+- Deterministic by default (greedy generation).
+
+## 🌐 Web Interface
+
+ProgramAsWeights includes a modern web interface for easy interaction with the system. The web app provides a user-friendly way to compile specifications, test neural programs, and manage models without writing code.
+
+### Features
+
+- **Interactive Model Selection**: Choose from available compiler and interpreter models
+- **Natural Language Specifications**: Describe your program in plain English
+- **GPT-Powered Examples**: Auto-generate test data using OpenAI's API
+- **Real-time Compilation**: Compile specs into neural programs instantly
+- **Interactive Testing**: Test compiled programs with custom inputs
+- **Model Downloads**: Download compiled models as `.tgz` files
+- **Community Sharing**: Publish and discover programs on the leaderboard
+
+### Quick Start
+
+1. **Prerequisites**: Ensure you have Python 3.8+, Node.js 16+, and npm installed
+
+2. **Start the application**:
+   ```bash
+   cd web-app
+   ./start.sh
+   ```
+
+3. **Access the interface**:
+   - **Web App**: http://localhost:5173
+   - **API Docs**: http://localhost:8000/docs
+
+The startup script automatically:
+- Installs Python and Node.js dependencies
+- Starts the FastAPI backend server
+- Starts the React frontend development server
+
+### Manual Setup (Alternative)
+
+If you prefer manual setup:
+
+```bash
+# Backend
+cd web-app/backend
+pip install -r requirements.txt
+python run_server.py
+
+# Frontend (in another terminal)
+cd web-app/frontend  
+npm install
+npm run dev
+```
+
+### Configuration
+
+Create `web-app/backend/.env` with:
+```bash
+OPENAI_API_KEY=your_openai_api_key_here  # Optional: for GPT test generation
+CHECKPOINT_DIR=../../outputs_1spec/prefix_kv  # Path to trained models
+```
+
+### Example Workflow
+
+1. Select "Qwen 2.5 Coder 0.5B" as compiler and "PAW Interpreter" as interpreter
+2. Enter specification: *"Parse a string like '(A) cat (B) dog' into a JSON list"*
+3. Generate examples with GPT or add manually
+4. Click "Compile" to create your neural program
+5. Test with input: *"(A) red apple (B) green banana"*
+6. Download or publish your compiled model
+
+For detailed documentation, see [`web-app/README.md`](web-app/README.md).
+
+## Train a compiler→KV prefix→interpreter (defaults)
+
+```bash
+# installs training extras
+pip install -e .[train]
+
+# trains on data/samples_train.jsonl with Qwen defaults
+paw-train
+```
+
+- Produces checkpoint under `outputs/prefix_kv/checkpoint/`.
+
+## Compile then run (qualitative eval)
+
+```bash
+# compile a prompt into a KV-prefix artifact
+paw-eval
+```
+
+Or programmatically:
+
+```python
+import programasweights as paw
+
+prompt = (
+    "Parse a string like '(A) ... (B) ... (C) ...' into a JSON list of options. "
+    "Be robust to noise: extra spaces, bullets, and phrases like 'both (A) and (B)'."
+)
+
+artifact_dir = paw.compile(
+    out_dir="outputs/prefix_kv/demo_program",
+    spec=prompt,
+    checkpoint_dir="outputs/prefix_kv/checkpoint",
+)
+
+f = paw.function(artifact_dir, interpreter_name="Qwen/Qwen2.5-Coder-0.5B-Instruct", max_new_tokens=128)
+print(f("(A) cat  (B) dog  (C) both (A) and (B) are possible"))
+```
+
+- The dummy compiler is still available as `compile_dummy` for tests and demos.
+
+## API
+
+```python
+import programasweights
+parse_func = programasweights.function(
+    "/path/to/weights.safetensors",
+    interpreter_name="google/flan-t5-small",
+    max_new_tokens=128,
+)
+output = parse_func("input string")
+```
+
+- Accepts `str` or `List[str]` and returns the same shape.
+- Aliasing works: `import programasweights as paw`.
+
+## Local development
+
+```bash
+pip install -e .[test]
+pytest -q
+```
+
+```bash
+# smoke check
+python -c "import programasweights as paw; print(paw.__version__)"
+```
+
+- `pip install -e .` installs in editable mode so code changes are picked up without reinstalling.
+- If you do not need editable mode: `pip install .` (you must reinstall after changes).
+
+## Notes
+
+- MVP runtime uses a single in-process interpreter (loads the base model once and stays warm).
+- Program artifact can be a prompt/prefix (text file) or a KV-prefix directory with `program.json` and `kv_prefix.pt`.
+- Device selection: CUDA if available, else CPU. Override with env var `PROGRAMASWEIGHTS_DEVICE`.
+- Simple global lock around `generate()` for thread safety.
+
+## Roadmap
+
+- Compiler: spec → weights
+- LoRA support
+- JSON-constrained decoding
+- Server mode (multi-tenant)

{programasweights-0.4.0 → programasweights-0.4.1}/docs/guide/browser-inference.md

@@ -1,6 +1,6 @@
 # Browser Inference
 
-Run PAW programs directly in the browser via WebAssembly. No server, no API key, no setup.
+Run PAW programs directly in the browser via WebAssembly. No custom server, no API key, no build setup.
 
 Programs compiled with the compact interpreter (GPT-2 124M) run entirely client-side. The base model (134 MB) downloads once and is cached; each program adds ~12 MB total (~5 MB adapter + ~7 MB prefix cache).
 
@@ -12,7 +12,7 @@ Programs compiled with the compact interpreter (GPT-2 124M) run entirely client-
 <script type="module">
   import paw from 'https://cdn.jsdelivr.net/npm/@programasweights/web';
 
-  const fn = await paw.function('email-triage');
+  const fn = await paw.function('email-triage-browser');
   const result = await fn('Urgent: server is down!');
   console.log(result); // "immediate"
 </script>
@@ -27,7 +27,7 @@ npm install @programasweights/web
 ```javascript
 import paw from '@programasweights/web';
 
-const fn = await paw.function('email-triage', {
+const fn = await paw.function('email-triage-browser', {
   onProgress: ({ loaded, total, stage }) => {
     console.log(`${stage}: ${Math.round(loaded/total*100)}%`);
   },
@@ -42,13 +42,15 @@ await fn.free();
 
 ## How It Works
 
-1. **Base model** — Compact interpreter (GPT-2 124M, 134 MB) downloads from HuggingFace CDN and is cached in the browser after first load.
+1. **Base model** — Compact interpreter (GPT-2 124M, 134 MB) downloads from Hugging Face CDN and is cached in the browser after first load.
 2. **LoRA adapter** — Each program is a ~5 MB Q4_0 GGUF LoRA adapter that specializes the base model for a specific task.
 3. **Prefix cache** — A precomputed KV cache (~7 MB) eliminates the prompt prefill step, making the first inference call fast.
 4. **Inference** — Runs via WebAssembly (llama.cpp compiled to WASM with SIMD). ~200ms per call on Chrome.
 
 Multiple programs share the cached base model. Loading a second program only downloads ~12 MB (adapter + prefix cache).
 
+If you want browser inference to stay independent of the PAW API at runtime, load by program ID rather than slug. Slugs still need one API call for resolution.
+
 ## API Reference
 
 ### `paw.function(slugOrId, options?)`
@@ -57,7 +59,7 @@ Load a program and return a callable function.
 
 | Parameter | Type | Default | Description |
 |-----------|------|---------|-------------|
-| `slugOrId` | `string` | required | Program slug (e.g., `"programasweights/email-triage"`) or program ID hash |
+| `slugOrId` | `string` | required | Program slug (for example `"programasweights/email-triage-browser"`) or program ID hash |
 | `options.onProgress` | `function` | — | Progress callback: `({ loaded, total, stage }) => void` |
 | `options.maxTokens` | `number` | `512` | Maximum output tokens |
 | `options.temperature` | `number` | `0` | Sampling temperature (0 = greedy) |

{programasweights-0.4.0 → programasweights-0.4.1}/docs/index.md

@@ -60,12 +60,12 @@ At runtime, the SDK loads a quantized base model (Q6_K ~594 MB for Qwen3, Q8_0 ~
 
 ## Browser Inference
 
-Programs compiled with the compact interpreter (GPT-2 124M) also run directly in the browser via WebAssembly -- no server needed:
+Programs compiled with the compact interpreter (GPT-2 124M) also run directly in the browser via WebAssembly -- no custom server needed for inference:
 
 ```html
 <script type="module">
   import paw from '@programasweights/web';
-  const fn = await paw.function('email-triage');
+  const fn = await paw.function('email-triage-browser');
   const result = await fn('Urgent: server is down!');
 </script>
 ```

{programasweights-0.4.0 → programasweights-0.4.1}/programasweights/__init__.py

@@ -27,7 +27,7 @@ try:
     from importlib.metadata import version as _meta_version
     __version__ = _meta_version("programasweights")
 except Exception:
-    __version__ = "0.4.0"
+    __version__ = "0.4.1"
 
 from .config import get_api_url, get_api_key, set_api_key
 

{programasweights-0.4.0 → programasweights-0.4.1}/pyproject.toml

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

programasweights-0.4.0/README.md

@@ -1,113 +0,0 @@
-# ProgramAsWeights
-
-**Compile natural language specs into tiny neural functions that run locally.**
-
-Define what a function should do in plain English. PAW compiles it into a small neural program that runs on your machine — no API keys at runtime, no internet needed after setup, fully deterministic.
-
-## Install
-
-```bash
-pip install programasweights
-```
-
-## Quick Start
-
-```python
-import programasweights as paw
-
-# Use a pre-compiled function (downloads once, runs locally forever)
-fn = paw.function("email-triage")
-fn("Urgent: the server is down!")        # "immediate"
-fn("Newsletter: spring picnic")          # "can 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"}'
-```
-
-## 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                    |
-
-Default is Standard (Qwen3 0.6B). Use Compact (GPT-2) when you need smaller files or browser deployment.
-
-## Browser SDK
-
-Programs compiled with GPT-2 also run entirely in the browser via WebAssembly — no server needed, data never leaves the user's device.
-
-```bash
-npm install @programasweights/web
-```
-
-```javascript
-import paw from '@programasweights/web';
-
-const fn = await paw.function('programasweights/email-triage');
-const result = await fn('Urgent: the server is down!');
-// result: "immediate"
-```
-
-See the [browser SDK repo](https://github.com/programasweights/programasweights-js) for full documentation.
-
-## Use with AI Agents
-
-PAW works with Cursor, Claude, Codex, and other AI coding assistants. Paste this into your agent's chat:
-
-> I want to use ProgramAsWeights (PAW) to create fuzzy text functions that run locally. Read the instructions at https://programasweights.com/agents and help me integrate it.
-
-Or save [`AGENTS.md`](https://programasweights.com/agents) to your project root — agents read it automatically.
-
-## 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
-
-## Authentication
-
-```bash
-# Option 1: environment variable (recommended)
-export PAW_API_KEY=paw_sk_...
-
-# Option 2: CLI login (opens browser to generate key)
-paw login
-```
-
-Generate API keys at [programasweights.com/settings](https://programasweights.com/settings). Authenticated users get higher rate limits.
-
-## CLI
-
-```bash
-paw compile --spec "Extract error lines from logs" --json
-paw run --program <program_id> --input "[ERROR] timeout" --json
-paw login
-```
-
-`--json` gives structured output for programmatic use.
-
-## Links
-
-- **Website**: [programasweights.com](https://programasweights.com)
-- **Documentation**: [programasweights.readthedocs.io](https://programasweights.readthedocs.io)
-- **Python SDK**: [github.com/programasweights/programasweights-python](https://github.com/programasweights/programasweights-python)
-- **Browser SDK**: [github.com/programasweights/programasweights-js](https://github.com/programasweights/programasweights-js)
-- **Program Hub**: [programasweights.com/hub](https://programasweights.com/hub)
-
-## License
-
-MIT