wao 0.41.3 → 0.41.5

package/waosm/src/lib.rs

@@ -0,0 +1,180 @@
+use wasm_bindgen::prelude::*;
+use js_sys::{Uint8Array, SharedArrayBuffer};
+
+#[wasm_bindgen]
+pub struct Waosm {}
+
+#[wasm_bindgen]
+impl Waosm {
+    #[wasm_bindgen(constructor)]
+    pub fn new() -> Self {
+        Self {}
+    }
+
+    fn to_base_256(mut n: usize) -> Vec<u8> {
+        let mut result = Vec::new();
+        while n > 0 {
+            result.insert(0, (n % 256) as u8);
+            n /= 256;
+        }
+        if result.is_empty() {
+            result.push(0);
+        }
+        let mut final_result = vec![result.len() as u8];
+        final_result.extend(result);
+        final_result
+    }
+
+    fn to_10(arr: &[u8]) -> usize {
+        let mut num = 0;
+        for &v in arr {
+            num = num * 256 + v as usize;
+        }
+        num
+    }
+
+    #[wasm_bindgen]
+    pub fn compress(&self, data: &[u8]) -> Uint8Array {
+        let mut arr = Vec::new();
+        let mut _arr = Vec::new();
+        let mut mode = 1;
+        let mut prev: Option<u8> = None;
+
+        for &v in data {
+            if prev.is_none() {
+                _arr.push(v);
+            } else if _arr.len() == 1 {
+                mode = if prev.unwrap() != v { 2 } else { 1 };
+                _arr.push(v);
+            } else {
+                if prev.unwrap() != v && mode == 1 {
+                    Self::_comp(&mut arr, &_arr, mode);
+                    _arr.clear();
+                    _arr.push(v);
+                    mode = 2;
+                } else if prev.unwrap() == v && mode == 2 {
+                    let last = _arr.pop().unwrap();
+                    Self::_comp(&mut arr, &_arr, mode);
+                    _arr.clear();
+                    _arr.extend_from_slice(&[last, v]);
+                    mode = 1;
+                } else {
+                    _arr.push(v);
+                }
+            }
+            prev = Some(v);
+        }
+
+        if !_arr.is_empty() {
+            Self::_comp(&mut arr, &_arr, mode);
+        }
+
+        let result = Uint8Array::new_with_length(arr.len() as u32);
+        result.copy_from(&arr);
+        result
+    }
+
+    fn _comp(arr: &mut Vec<u8>, _arr: &[u8], mode: u8) {
+        let mut _nums: Option<Vec<u8>> = None;
+        let mut _elms: Option<Vec<u8>> = None;
+        let len = _arr.len();
+        let mut flag: u8 = 0;
+
+        if mode == 1 && _arr[0] != 0 {
+            flag += 100;
+            _elms = Some(vec![_arr[0]]);
+        } else if mode == 2 {
+            flag += 200;
+            _elms = Some(_arr.to_vec());
+        }
+
+        if len < 10 {
+            flag += len as u8;
+        } else if len != 10 {
+            let base256 = Self::to_base_256(len);
+            let (elm, nums_slice) = base256.split_at(1);
+            _nums = Some(nums_slice.to_vec());
+            flag += elm[0] * 10;
+            if let Some(ref mut nums_vec) = _nums {
+                if !nums_vec.is_empty() && nums_vec[0] < 10 {
+                    flag += nums_vec.remove(0);
+                }
+            }
+        }
+
+        arr.push(flag);
+        if let Some(nums_vec) = _nums {
+            arr.extend(nums_vec);
+        }
+        if let Some(elms_vec) = _elms {
+            arr.extend(elms_vec);
+        }
+    }
+
+ #[wasm_bindgen]
+    pub fn decompress(&self, data: &[u8], decompressed_size: usize) -> Uint8Array {
+        let mut arr: Vec<u8> = Vec::with_capacity(decompressed_size);
+        let mut flag: Option<u8> = None;
+        let mut elm: i32 = 0;
+        let mut sum: i32 = 0;
+        let mut nums: Vec<u8> = Vec::new();
+        let mut first: Option<u8> = None;
+        let mut second: Option<u8> = None;
+        let mut third: Option<u8> = None;
+
+        for &v in data {
+            if flag.is_none() {
+                flag = Some(v);
+                let flag = v as i32;
+                first = Some((flag / 100) as u8);
+                second = Some(((flag - (flag / 100) * 100) / 10) as u8);
+                third = Some((flag - (flag / 100) * 100 - ((flag - (flag / 100) * 100) / 10) * 10) as u8);
+                nums.clear();
+
+                if second.unwrap() == 0 {
+                    nums.push(if third.unwrap() == 0 { 10 } else { third.unwrap() });
+                    elm = 0;
+                } else if third.unwrap() != 0 {
+                    nums.push(third.unwrap());
+                    elm = second.unwrap() as i32 - 1;
+                } else {
+                    elm = second.unwrap() as i32;
+                }
+            } else if sum == 0 {
+                elm -= 1;
+                nums.push(v);
+            }
+
+            if sum > 0 {
+                if first.unwrap() == 2 {
+                    arr.push(v);
+                } else if first.unwrap() == 1 {
+                    let count = Self::to_10(&nums);
+                    for _ in 0..count {
+                        arr.push(v);
+                    }
+                }
+                sum -= 1;
+                if sum == 0 {
+                    flag = None;
+                }
+            } else if elm == 0 {
+                if first.unwrap() == 0 {
+                    let count = Self::to_10(&nums);
+                    for _ in 0..count {
+                        arr.push(0);
+                    }
+                    flag = None;
+                } else if first.unwrap() == 2 {
+                    sum = Self::to_10(&nums) as i32;
+                } else {
+                    sum = 1;
+                }
+            }
+        }
+
+        let result = Uint8Array::new_with_length(arr.len() as u32);
+        result.copy_from(&arr);
+        result
+    }
+}

package/waosm/test.js

@@ -0,0 +1,16 @@
+import { Compressor, Decompressor } from "../src/waosm-node.js"
+
+const main = async () => {
+  const compressor = new Compressor()
+  const decompressor = new Decompressor()
+  const memory = new Uint8Array([
+    1, 2, 3, 4, 5, 5, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0,
+  ])
+  console.log(memory)
+  const compressed = compressor.compress(memory)
+  console.log(compressed)
+  const decompressed = decompressor.decompress(compressed)
+  console.log(decompressed)
+}
+main()

package/cjs/workspace/.claude/agents/builder.md

@@ -1,99 +0,0 @@
----
-name: builder
-description: General-purpose builder for WAO applications. Builds features end-to-end including AOS scripts, tests, and iteration. Use proactively when implementing new features or modifying existing ones.
-tools: Read, Edit, Write, Bash, Grep, Glob
-model: inherit
-skills:
-  - create-aos
-memory: project
----
-
-You are a WAO application builder. You build features end-to-end: AOS scripts, JS tests, and iterate until everything passes.
-
-## Reference Docs
-
-Read these before building:
-- **AOS scripts** -> read `docs/aos-lua.md` first (msg object, ao globals, patterns, blueprints)
-- **HyperBEAM features** -> read `docs/hyperbeam-devices.md` first (device catalog, endpoints)
-- **Erlang devices** -> read `docs/hyperbeam-dev.md` first (protocol, templates, Erlang reference)
-- **SDK API** -> read `docs/wao-sdk.md` for all test/deploy patterns
-- **Stuck?** -> read `docs/debug.md` for known issues and fixes
-
-## Stack
-
-- **AOS scripts** in `src/` — AOS process logic using `Handlers.add("Name", "Name", function(msg) ... end)`
-- **JS tests** in `test/` — Node.js built-in `node:test` with `wao/test` for in-memory AOS testing
-- **Deploy** via `scripts/deploy.js` using the `wao` SDK
-- **HyperBEAM devices** in `HyperBEAM/src/` — Erlang modules with `/3` function protocol
-
-## Workflow
-
-0. Read `plan.md` and `tasks.json` if they exist — pick up from the first pending task. If no plan exists, run `/plan` first. Never build without a plan.
-1. Update the current task status to `in_progress` in `tasks.json`.
-2. Read the relevant docs for the task type BEFORE writing code.
-3. Execute the task based on its type:
-   - **aos**: Write AOS scripts in `src/` with input validation
-   - **aos-test**: Write in-memory tests in `test/`, iterate until `yarn test` passes
-   - **aos-integration**: Write HyperBEAM tests, iterate until they pass
-   - **module-lua**: Write standalone Lua module in `custom-lua/`, no AOS framework
-   - **module-wasm**: Write Rust WASM64 module in `custom-wasm/`, `#![no_std]`
-   - **module-test**: Write HyperBEAM integration tests for custom modules
-   - **device**: Write Erlang device + inline eunit tests in same `.erl` file, compile with `rebar3 as genesis_wasm compile`, iterate until `rebar3 eunit` passes
-   - **device-integration**: Write WAO SDK integration tests against running HyperBEAM
-   - **frontend**: Write React components with `wao/web`
-   - **frontend-test**: Write vitest tests, iterate until they pass
-   - **frontend-integration**: Write Playwright E2E tests
-   - **validate**: Run `/validate`, all gates must pass
-4. When the task's "done when" condition is met, update status to `done` in `tasks.json`.
-5. Move to the next pending task. Never skip ahead — task order matters.
-
-## Input Validation
-
-Always validate script inputs:
-- Check required tags are present (`if not msg.Tags.X then ... return end`)
-- Use `pcall(bint, value)` for numeric parsing
-- Validate non-empty strings where appropriate
-- Return clear error messages in Data and Error tag
-
-Update your agent memory as you discover patterns, common failures, and useful approaches.
-
-## Working in Agent Teams
-
-When running as a teammate in an agent team, you own specific files assigned to you. Never edit files owned by other teammates. Communicate findings through the shared task list and messages. If you discover a pattern or gotcha, message the team lead so other teammates benefit.
-
-Report test results when completing tasks, not just "done" — include the test output summary.
-
-## Patterns
-
-### AOS Script
-
-```lua
-State = State or {}
-
-Handlers.add("Action", "Action", function(msg)
-  msg.reply({ Data = "response" })
-end)
-```
-
-### Test
-
-```js
-import assert from "assert"
-import { describe, it } from "node:test"
-import { readFileSync } from "fs"
-import { resolve } from "path"
-import { AO, acc } from "wao/test"
-
-const src_data = readFileSync(
-  resolve(import.meta.dirname, "../src/script.lua"),
-  "utf8"
-)
-
-describe("AOS Script", function () {
-  it("should work", async () => {
-    const ao = await new AO().init(acc[0])
-    const { p } = await ao.deploy({ src_data })
-    assert.equal(await p.d("Action", false), "response")
-  })
-})
-```

package/cjs/workspace/.claude/agents/device-builder.md

@@ -1,86 +0,0 @@
----
-name: device-builder
-description: Specialized agent for building HyperBEAM Erlang devices. Use when creating custom devices, working with the Erlang device protocol, or compiling HyperBEAM modules.
-tools: Read, Edit, Write, Bash, Grep, Glob
-model: inherit
-skills:
-  - create-device
-memory: project
----
-
-You are a HyperBEAM device builder specializing in Erlang. You build custom devices, compile them, and verify they work.
-
-## Reference Docs
-
-Read these before starting:
-- `docs/hyperbeam-dev.md` — Device protocol, templates, state management, Erlang reference
-- `docs/hyperbeam-devices.md` — Existing device catalog for reference
-- `docs/debug.md` — Known issues and fixes
-
-## Device Protocol
-
-Every device exports functions with arity/3:
-
-```erlang
-function(Msg1, Msg2, Opts) -> {ok, Result} | {error, ErrorMap}
-```
-
-Required: `info/3`, `compute/3`. Optional: `init/3`, `snapshot/3`, `normalize/3`, `get/3`.
-
-## Compilation Loop
-
-1. Write device → `rebar3 compile` → read errors → fix → repeat
-2. Common rebar3 errors:
-   - Missing `-include("include/hb.hrl").`
-   - Wrong arity (must be /3)
-   - Missing `-export` for public functions
-   - Erlang syntax: `end.` at end of module, `end` inside case/if
-3. Always write eunit test alongside device
-
-## Workflow
-
-1. Read `docs/hyperbeam-dev.md` for the device template
-2. Read `docs/hyperbeam-devices.md` if building on existing device patterns
-3. Write the Erlang device module in `HyperBEAM/src/dev_{name}.erl`
-4. Compile: `cd HyperBEAM && rebar3 compile`
-5. If compilation fails, read rebar3 errors carefully — common issues:
-   - Missing `-include("include/hb.hrl").`
-   - Wrong function arity (must be /3)
-   - Missing `-export` for public functions
-   - Erlang syntax: `end.` at end of module, `end` inside case/if
-6. Write JS integration test in `test/{name}.device.test.js`
-7. Run test: `yarn test test/{name}.device.test.js`
-8. Iterate until compilation and tests pass
-
-Update your agent memory with compilation patterns and Erlang gotchas you discover.
-
-## Working in Agent Teams
-
-When running as a teammate in an agent team for cross-layer device development, you own the Erlang side (`HyperBEAM/src/`). Coordinate with the JS test teammate — share the device endpoint paths and expected responses so they can write accurate integration tests. Message compilation results to the team.
-
-Report compilation and test results with specifics, not just "done."
-
-## Key Erlang Modules
-
-- `hb_maps:get/4` — Read request params from M2
-- `hb_private:get/4, set/3` — In-memory private state
-- `hb_cache:write/2, read/2` — Content-addressed persistent storage
-- `hb_message:signers/2` — Extract signer addresses for auth
-- `hb_ao:resolve/3` — Test device via resolution
-
-## State Pattern
-
-```erlang
-load_state(M1, Opts) ->
-    case hb_private:get(<<"state-id">>, M1, not_found, Opts) of
-        not_found -> #{};
-        ID -> case hb_cache:read(ID, Opts) of
-            {ok, State} -> hb_cache:ensure_all_loaded(State, Opts);
-            not_found -> #{}
-        end
-    end.
-
-save_state(M1, State, Opts) ->
-    {ok, ID} = hb_cache:write(State, Opts),
-    hb_private:set(M1, #{<<"state-id">> => ID}, Opts).
-```

package/cjs/workspace/.claude/agents/tester.md

@@ -1,90 +0,0 @@
----
-name: tester
-description: Test specialist for running and fixing WAO tests. Use proactively when tests are failing, when debugging test issues, or after code changes to verify correctness.
-tools: Read, Edit, Bash, Grep, Glob
-model: inherit
-memory: project
----
-
-You are a WAO test specialist. You run tests, diagnose failures, fix issues, and verify correctness.
-
-## Reference Docs
-
-- Read `docs/wao-sdk.md` for all test API patterns (AO, HB, Process handle, get/check)
-- Read `docs/debug.md` for known failure patterns and the common error messages table
-
-## Port Cleanup
-
-Before running tests, kill stale processes:
-
-```bash
-lsof -ti :10000-10010 | xargs -r kill -9 2>/dev/null || true
-pkill -f beam.smp 2>/dev/null || true
-```
-
-## Running Tests
-
-```bash
-yarn test                          # all tests
-yarn test test/aos.test.js         # specific file
-```
-
-The test command runs: `node --test --test-concurrency=1` (Node 24+ enables wasm-memory64 by default and rejects the experimental flag; Node 22 users add `--experimental-wasm-memory64` via NODE_OPTIONS).
-
-## Systematic Debugging
-
-1. Read test output — identify the FIRST failure
-2. Cross-reference with `docs/debug.md` error table
-3. Check: is the failure in Lua source or test code?
-4. Fix the root cause, not the symptom
-5. Re-run the specific test file
-6. Once fixed, run full suite for regressions
-
-## Fixing Failures
-
-1. Read the test output carefully
-2. Cross-reference error messages with `docs/debug.md` common error table
-3. Identify whether the failure is in Lua source or test code
-4. Fix the issue and re-run the specific test
-5. Once passing, run the full suite to check for regressions
-
-Update your agent memory with failure patterns and fixes you discover.
-
-## Working in Agent Teams
-
-When running as a teammate in an agent team, focus on your assigned test scope. If you discover a bug in the Lua source, message the builder teammate with the specific fix needed rather than editing it yourself. Share debug findings through the team — especially gotchas from `docs/debug.md` that could affect other teammates.
-
-Report test results with specifics: which tests pass, which fail, and the error messages.
-
-## Common Issues
-
-- **Port already in use**: Kill stale `beam.smp` processes
-- **WASM memory error**: On Node 22 set `NODE_OPTIONS=--experimental-wasm-memory64`. On Node 24+ the flag is default-on (and rejected if passed explicitly — "bad option: --experimental-wasm-memory64")
-- **Process not found**: Check that `src_data` path is correct
-- **HyperBEAM timeout**: Ensure `hbeam.kill()` is called in `after()`
-- **Send().receive() hangs**: Does NOT work on genesis-wasm — use fire-and-forget `Send()` + separate Handlers.add calls
-- **Action doesn't match**: Must be uppercase `Action`, not `action`
-- **Signature fails**: Don't include `authority` in spawn tags (RFC 9421 conflict)
-- **Multiple matches**: Add nonce/timestamp to messages to avoid duplicate content
-
-## Device Stack Testing
-
-```js
-const { pid } = await hb.spawn({
-  "execution-device": "stack@1.0",
-  "device-stack": ["wao@1.0", "patch@1.0"],
-  "patch-from": "/results",
-  "patch-to": "/cache",
-})
-```
-
-## Payment Testing
-
-```js
-// Simple pay
-const hbeam = await new HyperBEAM({ simple_pay: true, simple_pay_price: 2 }).ready()
-await operator.hb.p("/~simple-pay@1.0/topup", { amount: 15, recipient: user.addr })
-
-// FAFF
-const hbeam = await new HyperBEAM({ faff: [addr1, addr2] }).ready()
-```

package/cjs/workspace/.claude/mcp/dashboard/server.js

@@ -1,128 +0,0 @@
-#!/usr/bin/env node
-
-// MCP server for WAO Dashboard — JSON-RPC over stdio
-// Provides get_progress and open_dashboard tools to Claude Code
-
-import { readFileSync, existsSync } from "node:fs"
-import { join } from "node:path"
-import { createInterface } from "node:readline"
-
-const ROOT = join(import.meta.dirname, "../../..")
-
-const TOOLS = [
-  {
-    name: "get_progress",
-    description: "Get current build progress from tasks.json — returns feature name, tracks, task list with status, and current step.",
-    inputSchema: { type: "object", properties: {}, required: [] },
-  },
-  {
-    name: "open_dashboard",
-    description: "Get the URLs to open the WAO build progress dashboard.",
-    inputSchema: { type: "object", properties: {}, required: [] },
-  },
-]
-
-function readProgress() {
-  const tasksPath = join(ROOT, "tasks.json")
-  if (!existsSync(tasksPath)) return { feature: null, tasks: [], tracks: [], current_step: 0 }
-  try {
-    return JSON.parse(readFileSync(tasksPath, "utf8"))
-  } catch {
-    return { feature: null, tasks: [], tracks: [], current_step: 0 }
-  }
-}
-
-function handleRequest(msg) {
-  const { id, method, params } = msg
-
-  if (method === "initialize") {
-    return {
-      jsonrpc: "2.0", id,
-      result: {
-        protocolVersion: "2024-11-05",
-        capabilities: { tools: {} },
-        serverInfo: { name: "wao-dashboard", version: "1.0.0" },
-      },
-    }
-  }
-
-  if (method === "notifications/initialized") return null // no response needed
-
-  if (method === "ping") {
-    return { jsonrpc: "2.0", id, result: {} }
-  }
-
-  if (method === "tools/list") {
-    return { jsonrpc: "2.0", id, result: { tools: TOOLS } }
-  }
-
-  if (method === "tools/call") {
-    const toolName = params?.name
-    if (toolName === "get_progress") {
-      const data = readProgress()
-      return {
-        jsonrpc: "2.0", id,
-        result: {
-          content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
-        },
-      }
-    }
-    if (toolName === "open_dashboard") {
-      return {
-        jsonrpc: "2.0", id,
-        result: {
-          content: [{
-            type: "text",
-            text: [
-              "WAO Dashboard URLs:",
-              "  Dev server:  http://localhost:5174",
-              "  API server:  http://localhost:3333",
-              "",
-              "Start both with: yarn start",
-              "Start API only:  yarn start:api",
-            ].join("\n"),
-          }],
-        },
-      }
-    }
-    return {
-      jsonrpc: "2.0", id,
-      error: { code: -32601, message: `Unknown tool: ${toolName}` },
-    }
-  }
-
-  // Unknown method
-  if (id !== undefined) {
-    return {
-      jsonrpc: "2.0", id,
-      error: { code: -32601, message: `Method not found: ${method}` },
-    }
-  }
-  return null
-}
-
-// --- stdio transport ---
-const rl = createInterface({ input: process.stdin })
-let buffer = ""
-
-process.stdin.on("data", (chunk) => {
-  buffer += chunk.toString()
-  let newlineIdx
-  while ((newlineIdx = buffer.indexOf("\n")) !== -1) {
-    const line = buffer.slice(0, newlineIdx).trim()
-    buffer = buffer.slice(newlineIdx + 1)
-    if (!line) continue
-    try {
-      const msg = JSON.parse(line)
-      const response = handleRequest(msg)
-      if (response) {
-        process.stdout.write(JSON.stringify(response) + "\n")
-      }
-    } catch {
-      // ignore malformed JSON
-    }
-  }
-})
-
-// Keep process alive
-process.stdin.resume()

package/cjs/workspace/.claude/rules/deploy.md

@@ -1,45 +0,0 @@
----
-paths:
-  - "scripts/**/*.js"
----
-
-# Deploy Rules
-
-## Deploy Command
-
-```bash
-yarn deploy                              # testnet, all src/*.lua
-yarn deploy src/counter.lua              # testnet, one script
-yarn deploy --mainnet                    # remote HyperBEAM (push-1)
-yarn deploy --mainnet --lua              # remote HyperBEAM with Lua mode
-yarn deploy --local-hb                   # local HyperBEAM (genesis-wasm)
-yarn deploy --local-hb --lua             # local HyperBEAM with Lua mode
-yarn deploy --node https://push-3.forward.computer  # custom node
-```
-
-## Three Deploy Targets
-
-### Testnet (default)
-Uses `new AO().init(jwk)` with aoconnect — spawns process, loads Lua code via Eval message.
-- MU can be flaky (504 errors)
-- `receive()` works via CU polling
-
-### Local HyperBEAM (`--local-hb`)
-Uses `new AO({ hb: "http://localhost:10001" }).init(jwk)` — deploys to a local Erlang node.
-- Default: `genesis_wasm` mode (legacynet compatible)
-- Add `--lua` for Lua mode (faster, no WASM, but no `receive()`)
-- Requires HyperBEAM running locally
-
-### Remote HyperBEAM (`--mainnet`)
-Uses `new AO({ hb: "https://push-1.forward.computer" }).init(jwk)` — production deployment.
-- Uses `push-1` through `push-10` for full compute support
-- **Do NOT use `push.forward.computer`** — it's push-only (no compute)
-- Add `--lua` for Lua mode
-- Add `--node <url>` for a specific push node
-
-## Wallet
-
-- Wallet resolved from `.env.hyperbeam` CWD, or `.wallet.json` in project root
-- Can also specify with `--wallet <path>` flag
-- Generate with `yarn keygen` or `npx wao keygen`
-- **Never commit `.wallet.json`** — it's in `.gitignore`