programasweights 0.4.0__tar.gz → 0.4.2__tar.gz

{programasweights-0.4.0 → programasweights-0.4.2}/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.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: programasweights
-Version: 0.4.0
+Version: 0.4.2
 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.2}/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.0 → programasweights-0.4.2}/README.md

@@ -7,7 +7,7 @@ Define what a function should do in plain English. PAW compiles it into a small
 ## Install
 
 ```bash
-pip install programasweights
+pip install programasweights --extra-index-url https://pypi.programasweights.com/simple/
 ```
 
 ## Quick Start
@@ -18,33 +18,44 @@ 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"
+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.id)
-fn("{name: 'Alice',}")  # '{"name": "Alice"}'
+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
+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) |
+| --------------- | --------------------- | -------------------- |
+| Compiler name   | `paw-4b-qwen3-0.6b`   | `paw-4b-gpt2`        |
+| Accuracy        | Higher                | Lower                |
+| Base model size | 594 MB                | 134 MB               |
+| Program size    | ~22 MB                | ~5 MB                |
+| Local inference | ~0.05-0.5s per call   | ~0.03-0.3s per call  |
+| Runs in browser | No                    | Yes (WebAssembly)    |
 
-|                    | 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                    |
+The current server default is Standard (`paw-4b-qwen3-0.6b`). Use Compact (`paw-4b-gpt2`) when you need smaller files or browser deployment.
 
-Default is Standard (Qwen3 0.6B). Use Compact (GPT-2) 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
@@ -53,20 +64,24 @@ 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
 
 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.
+> I want to use ProgramAsWeights (PAW) to create fuzzy text functions that run locally. Read the instructions at [https://programasweights.com/AGENTS.md](https://programasweights.com/AGENTS.md) and help me integrate it.
 
-Or save [`AGENTS.md`](https://programasweights.com/agents) to your project root — agents read it automatically.
+Or save `[AGENTS.md](https://programasweights.com/agents)` to your project root — agents read it automatically.
 
 ## When to Use PAW
 
@@ -110,4 +125,4 @@ paw login
 
 ## License
 
-MIT
+MIT

{programasweights-0.4.0 → programasweights-0.4.2}/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.2}/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.2}/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.2"
 
 from .config import get_api_url, get_api_key, set_api_key
 

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

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