wao 0.40.2 → 0.41.0

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

@@ -29,7 +29,7 @@ yarn test                          # all tests
 yarn test test/aos.test.js         # specific file
 ```
 
-The test command runs: `node --experimental-wasm-memory64 --test --test-concurrency=1`
+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
 
@@ -59,7 +59,7 @@ Report test results with specifics: which tests pass, which fail, and the error
 ## Common Issues
 
 - **Port already in use**: Kill stale `beam.smp` processes
-- **WASM memory error**: Ensure `--experimental-wasm-memory64` flag is present
+- **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

package/cjs/workspace/.claude/skills/build/SKILL.md

@@ -210,5 +210,5 @@ Never force a task to `done` status with failing tests. The TaskCompleted hook w
 - Verify task statuses — a task stuck as `in_progress` blocks progression
 
 ### Permission denied on yarn test
-- Check `node --version` is 20+
-- Verify `--experimental-wasm-memory64` flag is present in package.json
+- Check `node --version` is 22+ (24+ recommended)
+- On Node 22, set `NODE_OPTIONS=--experimental-wasm-memory64`; on Node 24+ the flag is default-on and is rejected if passed explicitly

package/cjs/workspace/.claude/skills/test/SKILL.md

@@ -51,5 +51,6 @@ yarn test
 - Check `package.json` has `"wao"` in dependencies
 
 ### WASM memory error
-- Ensure `--experimental-wasm-memory64` flag is in the test command
-- Node.js 20+ required
+- Node 24+ enables wasm-memory64 by default — DO NOT pass `--experimental-wasm-memory64` (it's rejected with "bad option")
+- Node 22: set `NODE_OPTIONS=--experimental-wasm-memory64` before running
+- Node.js 22+ required

package/cjs/workspace/CLAUDE.md

@@ -95,7 +95,7 @@ yarn deploy --mainnet                    # remote HyperBEAM (push-1)
 yarn deploy --mainnet --lua              # remote HyperBEAM (Lua mode)
 ```
 
-Runs: `node --experimental-wasm-memory64 --test --test-concurrency=1`
+Runs: `node --test --test-concurrency=1` (Node 24+; on Node 22 prefix with `--experimental-wasm-memory64`)
 
 ## Deployment Targets
 
@@ -109,7 +109,7 @@ Runs: `node --experimental-wasm-memory64 --test --test-concurrency=1`
 - **Remote nodes**: Use `push-1` through `push-10` for full compute. `push.forward.computer` is push-only (no compute).
 - **Lua mode**: Faster but no `receive()` — use `msg.reply()` pattern instead.
 - **Wallet**: Run `yarn keygen` to generate `.wallet.json`.
-- **HyperBEAM fork**: `git clone -b wao-beta3 https://github.com/weavedb/HyperBEAM.git`
+- **HyperBEAM fork**: `git clone -b wao-final https://github.com/weavedb/HyperBEAM.git`
 
 ### Frontend Commands
 

package/cjs/workspace/README.md

@@ -52,7 +52,7 @@ yarn deploy --local-hb --lua src/counter.lua
 
 **Remote nodes**: Use `push-1` through `push-10` for full compute. `push.forward.computer` is push-only (no compute).
 
-**HyperBEAM fork**: `git clone -b wao-beta3 https://github.com/weavedb/HyperBEAM.git && cd HyperBEAM && rebar3 compile`
+**HyperBEAM fork**: `git clone -b wao-final https://github.com/weavedb/HyperBEAM.git && cd HyperBEAM && rebar3 compile`
 
 ---
 

package/cjs/workspace/docs/debug.md

@@ -144,13 +144,17 @@ await hb.schedule({
 
 **Problem:** `WebAssembly.Memory` errors or WASM module fails to load.
 
-**Fix:** Ensure the `--experimental-wasm-memory64` flag is present:
+**Fix:** Node 24+ enables wasm-memory64 by default (and rejects the experimental flag at startup with "bad option"). On Node 22 or older, prefix with `--experimental-wasm-memory64`:
 
 ```bash
+# Node 24+: no flag needed
+node --test test/aos.test.js
+
+# Node 22:
 node --experimental-wasm-memory64 --test test/aos.test.js
 ```
 
-The `yarn test` script should already include this flag.
+The `yarn test` script ships without the flag (Node 24+ default); set `NODE_OPTIONS=--experimental-wasm-memory64` if you're on older Node.
 
 ### Genesis-WASM Server
 
@@ -202,7 +206,8 @@ The `yarn test` script should already include this flag.
 | `badarg in list_to_atom` | Atom not pre-registered | Add to preRegisterAtoms |
 | `multiple_matches` | Duplicate message content | Add nonce to messages |
 | `timeout` | Process or server hung | Kill stale processes, increase timeout |
-| `WASM memory error` | Missing memory64 flag | Add `--experimental-wasm-memory64` |
+| `WASM memory error` | Missing memory64 (Node 22) | Set `NODE_OPTIONS=--experimental-wasm-memory64` (Node 22) — Node 24+ has it default-on |
+| `bad option: --experimental-wasm-memory64` | Passing the flag on Node 24+ | Remove the flag — Node 24+ rejects it |
 | `Process not found` | Bad pid or deploy failed | Check deploy result, verify pid |
 | `Insufficient balance` | Payment balance too low | Top up via simple-pay or p4 |
 | `Not signed` | Missing wallet/JWK | Call `.init(jwk)` before operations |
@@ -215,7 +220,7 @@ When tests fail, check in order:
 
 1. **Ports clear?** `lsof -ti :10000-10010 | xargs -r kill -9`
 2. **beam.smp killed?** `pkill -f beam.smp`
-3. **WASM flag?** `--experimental-wasm-memory64` in test command
+3. **WASM flag?** Node 24+ default-on; on Node 22 add `--experimental-wasm-memory64` (and on Node 24+ remove it — it's rejected)
 4. **HyperBEAM dir?** `ls ./HyperBEAM` exists
 5. **Wallet exists?** `.wallet.json` present (auto-generated)
 6. **hbeam.kill() in after()?** Always clean up

package/cjs/workspace/docs/hyperbeam-devices.md

@@ -348,7 +348,7 @@ const result = await hb.computeLegacy({ pid, slot })
 **Limitations:**
 - External CU is single-pass — **`Send().receive()` does NOT work**
 - Auto-starts CU server at port 6363
-- Requires `--experimental-wasm-memory64` Node.js flag
+- Requires wasm-memory64 (Node 24+ default; Node 22 needs `--experimental-wasm-memory64`)
 
 Functions: `init/3`, `compute/3`, `snapshot/3`, `import/3`
 
@@ -540,6 +540,55 @@ Query Arweave via GraphQL from within HyperBEAM.
 
 ---
 
+## v0.9-FINAL Devices (new since beta3)
+
+### location@1.0 — Scheduler-Location Registry
+
+Replaces the old `/~scheduler@1.0/location` endpoint. Stores per-address scheduler-location records (with DNS/IP resolution and a TTL) in a node-local cache, with fallback to the Arweave gateway.
+
+- `POST /~location@1.0/node` — operator generates and registers a record (signed)
+- `POST /~location@1.0/known` — cache a peer's record if newer than the local one
+- Read via `dev_whois` / `dev_location_cache`
+
+### metering@1.0 — Dynamic P4 Pricing
+
+A P4 pricing device that records resource usage per request/response lifecycle.
+
+- `estimate/3` opens a process-local session
+- `consume/3` increments usage during the session
+- `price/3` closes the session and returns the integer charge
+- Operator sets `metering-rates` in node message (resource → AO units per resource unit)
+
+### blacklist@1.0 — Content Moderation by Blacklist
+
+A request hook for filtering. Operator configures `blacklist-providers` (list) in node message; each provider returns a moderation set.
+
+### bundler@1.0 — ANS-104 Bundler Integration
+
+Outbound bundler for posting ANS-104 transactions to upstream Arweave bundlers (e.g. `up.arweave.net`).
+
+### gzip@1.0 — gzip Codec
+
+Compress/decompress message bodies via gzip during processing.
+
+### rate-limit@1.0 — Per-Address Rate Limiting
+
+Operator-configurable per-address rate limits applied as a request hook.
+
+### tx@1.0 — Arweave TX Helpers
+
+Helpers for fetching and validating Arweave transactions inline.
+
+### b32-name@1.0 — Base-32 Name Encoding
+
+Helpers for base-32 name encoding/decoding used by other devices.
+
+### arweave@2.9 — Arweave Block + GraphQL Integration
+
+Renamed in v0.9-FINAL (was `arweave@2.9-pre`). Provides Arweave block cache, offset helpers, and common Arweave protocol primitives.
+
+---
+
 ## Multi-Instance Setup
 
 Running multiple HyperBEAM nodes requires unique ports and Erlang node names:

package/cjs/workspace/package.json

@@ -3,9 +3,9 @@
   "version": "0.0.1",
   "type": "module",
   "scripts": {
-    "test": "node --experimental-wasm-memory64 --test --test-concurrency=1",
-    "test-only": "node --experimental-wasm-memory64 --test-only --test-concurrency=1",
-    "test-all": "node --experimental-wasm-memory64 --test --test-concurrency=1 test/**/*.test.js",
+    "test": "node --test --test-concurrency=1",
+    "test-only": "node --test-only --test-concurrency=1",
+    "test-all": "node --test --test-concurrency=1 test/**/*.test.js",
     "start": "trap 'kill $(jobs -p)' EXIT; node dashboard/server.js & cd dashboard && npx vite",
     "start:api": "node dashboard/server.js",
     "keygen": "node scripts/keygen.js",

package/esm/accounts-web.js

@@ -1,6 +1,7 @@
 import * as WarpArBundles from "warp-arbundles"
 const pkg = WarpArBundles.default ?? WarpArBundles
 const { createData, ArweaveSigner } = pkg
+import { toAddr } from "./utils.js"
 
 function createDataItemSigner(wallet) {
   const signer = async ({ data, tags, target, anchor }) => {
@@ -107,6 +108,19 @@ let mu = {
   addr: "eNaLJLsMiWCSWvQKNbk_YT-9ydeWl9lrWwXxLVp9kcg",
 }
 
+if (globalThis.__WAO_WALLETS__) {
+  const w = globalThis.__WAO_WALLETS__
+  for (let i = 0; i < 3; i++) {
+    if (w[`acc${i}`]) {
+      const jwk = w[`acc${i}`]
+      acc[i] = { jwk, addr: toAddr(jwk.n) }
+    }
+  }
+  if (w.su) su = { jwk: w.su, addr: toAddr(w.su.n) }
+  if (w.cu) cu = { jwk: w.cu, addr: toAddr(w.cu.n) }
+  if (w.mu) mu = { jwk: w.mu, addr: toAddr(w.mu.n) }
+}
+
 for (const v of acc) v.signer = createDataItemSigner(v.jwk)
 mu.signer = createDataItemSigner(mu.jwk)
 su.signer = createDataItemSigner(su.jwk)

package/esm/accounts.js

@@ -1,5 +1,9 @@
 import { createDataItemSigner } from "@permaweb/aoconnect-69"
 import { ArweaveSigner } from "arbundles"
+import { readFileSync } from "fs"
+import { fileURLToPath } from "url"
+import { dirname as pathDirname, resolve } from "path"
+import { toAddr } from "./utils.js"
 const acc = [
   {
     jwk: {
@@ -90,6 +94,29 @@ let mu = {
   addr: "eNaLJLsMiWCSWvQKNbk_YT-9ydeWl9lrWwXxLVp9kcg",
 }
 
+try {
+  const __fn = fileURLToPath(import.meta.url)
+  const __dir = pathDirname(__fn)
+  const walletsDir = resolve(__dir, "../devnet/.wallets")
+  const tryLoadJWK = name => {
+    try {
+      return JSON.parse(readFileSync(resolve(walletsDir, `${name}.json`), "utf-8"))
+    } catch {
+      return null
+    }
+  }
+  for (let i = 0; i < 3; i++) {
+    const jwk = tryLoadJWK(`acc${i}`)
+    if (jwk) acc[i] = { jwk, addr: toAddr(jwk.n) }
+  }
+  const suJwk = tryLoadJWK("su")
+  if (suJwk) su = { jwk: suJwk, addr: toAddr(suJwk.n) }
+  const cuJwk = tryLoadJWK("cu")
+  if (cuJwk) cu = { jwk: cuJwk, addr: toAddr(cuJwk.n) }
+  const muJwk = tryLoadJWK("mu")
+  if (muJwk) mu = { jwk: muJwk, addr: toAddr(muJwk.n) }
+} catch {}
+
 for (const v of acc) v.signer = createDataItemSigner(v.jwk)
 mu.signer = createDataItemSigner(mu.jwk)
 su.signer = createDataItemSigner(su.jwk)

package/esm/adaptor-base.js

@@ -14,13 +14,37 @@ class Adaptor {
     aoconnect,
     log = false,
     db,
+    storage,
     connect,
     GQL,
     cu,
     su,
     mu,
+    d1,
+    r2,
+    kv,
+    network = "ao.DN.1",
   }) {
+    this.network = network
     this.data = {}
+    this._dataTimestamps = {}
+    // Clean up abandoned chunk uploads every 60 seconds.
+    // unref() so this interval doesn't keep the Node event loop alive after
+    // the host server closes — without it, test processes that use Server
+    // (e.g. test/hyperbeam/relay.test.js) hang indefinitely waiting on this
+    // timer even after every other handle is cleaned up.
+    this._chunkCleanupInterval = setInterval(() => {
+      const now = Date.now()
+      for (const key of Object.keys(this._dataTimestamps)) {
+        if (now - this._dataTimestamps[key] > 5 * 60 * 1000) { // 5 min timeout
+          delete this.data[key]
+          delete this._dataTimestamps[key]
+        }
+      }
+    }, 60 * 1000)
+    if (typeof this._chunkCleanupInterval?.unref === "function") {
+      this._chunkCleanupInterval.unref()
+    }
     let hb = null
     if (hb_url) hb = new HB({ url: hb_url })
     const {
@@ -34,13 +58,15 @@ class Adaptor {
       monitor,
       unmonitor,
       recover,
-    } = connect(aoconnect, { log, cache: db, hb })
+      evaluate,
+    } = connect(aoconnect, { log, cache: db, storage, hb, d1, r2, kv })
     this.su_signer = su
     this.cu_signer = cu
     this.mu_signer = mu
     this.recover = recover
     this.monitor = monitor
     this.unmonitor = unmonitor
+    this.evaluate = evaluate
     this.spawn = spawn
     this._ar = _ar
     this.message = message
@@ -48,10 +74,10 @@ class Adaptor {
     this.result = result
     this.results = results
     this.mem = mem
-    this.gql = new GQL({ mem })
+    this.gql = new GQL({ mem, d1: d1 || null })
   }
   async get(req, res) {
-    res(await this[req.device](req))
+    return res(await this[req.device](req))
   }
   async bd(req) {
     return await this[`bd_${req.method.toLowerCase()}`](req)
@@ -189,6 +215,8 @@ class Adaptor {
         return await this.cu_post_result(req)
       case "/dry-run": // not in the AO spec
         return await this.cu_post_dryrun(req)
+      case "/evaluate":
+        return await this.cu_post_evaluate(req)
       default:
         return await this.bad()
     }
@@ -271,7 +299,8 @@ class Adaptor {
 
   async cu_get_state({ query, params, body, headers, method }) {
     const pid = params.pid
-    const memory = this.mem.env[pid]?.memory ?? null
+    const p = await this.mem.get("env", pid)
+    const memory = p?.memory ?? null
     if (!memory) {
       return {
         status: 404,
@@ -293,7 +322,8 @@ class Adaptor {
   async cu_get_results({ query, params, body, headers, method }) {
     const pid = params.pid
     const { from = null, to = null, sort = "ASC", limit = 25 } = query
-    let results = this.mem.env[pid]?.results ?? []
+    const p = await this.mem.get("env", pid)
+    let results = p?.results ?? []
     if (sort === "DESC") results = reverse(results)
     let _res = []
     let i = 1
@@ -301,7 +331,8 @@ class Adaptor {
     let started = isNil(from)
     for (let v of results) {
       if (started) {
-        _res.push({ cursor: v, node: this.mem.msgs[v]?.res })
+        const msg = await this.mem.get("msgs", v)
+        _res.push({ cursor: v, node: msg?.res })
         count++
         if (!isNil(to) && v === to) break
         if (limit <= count) break
@@ -316,20 +347,23 @@ class Adaptor {
     let message = params.mid
     const process = query["process-id"]
     // check if recovery is ongoing and
-    if (isNil(this.mem.env[process])) {
+    let p = await this.mem.get("env", process)
+    if (isNil(p)) {
       const { success } = await this.recover(process)
       if (!success) {
         console.log("process not found:", query["process-id"])
         return { status: 404, error: "not Found" }
       }
+      p = await this.mem.get("env", process)
     }
     const slot = message
     if (!/^[0-9a-zA-Z_-]{43,44}$/.test(message)) {
-      message = this.mem.env[process]?.results?.[slot]
+      message = p?.results?.[slot]
     }
     if (isNil(message)) {
       await this.recover(process)
-      message = this.mem.env[process]?.results?.[slot]
+      p = await this.mem.get("env", process)
+      message = p?.results?.[slot]
       if (isNil(message)) return { status: 404, error: "not Found" }
     }
     const res2 = await this.result({ message, process })
@@ -338,34 +372,57 @@ class Adaptor {
   async cu_post_result(...args) {
     return await this.cu_get_result(...args)
   }
+  async cu_post_evaluate({ query, params, body, headers, method }) {
+    const { message, process, data, tags: msgTags, from, is_spawn } = body
+    if (!process) return { status: 400, json: { error: "process required" } }
+    try {
+      const res = await this.evaluate({
+        message,
+        process,
+        data: data || "",
+        tags: msgTags,
+        from,
+        is_spawn,
+        module: body.module || (msgTags && tags(msgTags)?.Module),
+        scheduler: body.scheduler || (msgTags && tags(msgTags)?.Scheduler),
+      })
+      return { json: res || {} }
+    } catch (e) {
+      console.log("cu_post_evaluate error:", e)
+      return { status: 500, json: { error: e.message } }
+    }
+  }
   async su_get_root({ query, params, body, headers, method }) {
     return {
       json: {
         Unit: "Scheduler",
         Timestamp: Date.now(),
         Address: this.su_signer.addr,
-        Processes: keys(this.mem.env),
+        Processes: await this.mem.getFieldKeys("env"),
       },
     }
   }
 
   async su_get_timestamp({ query, params, body, headers, method }) {
-    return { json: { timestamp: Date.now(), block_height: this.mem.height } }
+    return { json: { timestamp: Date.now(), block_height: await this.mem.get("height") } }
   }
   async su_get_pid({ query, params, body, headers, method }) {
     const pid = params.pid
+    const p = await this.mem.get("env", pid)
     const edges = map(async v => {
       const tx = await this.mem.getTx(v)
       const _tags = tags(v.tags)
       const mid = _tags.Message
       const mtx = await this.mem.getTx(mid)
+      const mtxOwner = await this.mem.get("addrmap", mtx.owner)
+      const txOwner = await this.mem.get("addrmap", tx.owner)
       return {
         cursor: v,
         node: {
           message: {
             id: mtx.id,
             tags: mtx.tags,
-            owner: this.mem.addrmap[mtx.owner],
+            owner: mtxOwner,
             anchor: mtx.anchor ?? null,
             target: pid,
             signature: mtx.signature,
@@ -374,14 +431,14 @@ class Adaptor {
           assignment: {
             id: tx.id,
             tags: tx.tags,
-            owner: this.mem.addrmap[tx.owner],
+            owner: txOwner,
             anchor: tx.anchor ?? null,
             target: null,
             signature: tx.signature,
           },
         },
       }
-    })(reverse(this.mem.env[pid]?.results ?? [])) // need mod
+    })(reverse(p?.results ?? [])) // need mod
     return { json: { page_info: { has_next_page: false }, edges } }
   }
 
@@ -398,23 +455,48 @@ class Adaptor {
     try {
       valid = await DataItem.verify(body)
     } catch (e) {
-      console.log(e)
+      // verification may fail for cross-env items (node→browser); proceed anyway
     }
     let type = null
     let item = null
     if (valid || true) item = new DataItem(body)
     await item.setSignature(item.rawSignature)
     const _tags = tags(item.tags)
+    // Allow both ao.TN.1 (legacy testnet) and ao.DN.1 (WAO Devnet) variants
+    // through the local emulator. The variant is informational here; the
+    // local emulator doesn't actually need to enforce a strict network.
+    const _allowedNetworks = new Set([this.network, "ao.TN.1", "ao.DN.1"])
+    if (_tags.Variant && !_allowedNetworks.has(_tags.Variant)) {
+      return { status: 400, json: { error: `Variant mismatch: expected ${this.network}, got ${_tags.Variant}` } }
+    }
     let err = null
     if (_tags.Type === "Process") {
-      const res = await this.spawn({
-        item,
-        module: _tags.Module,
-        scheduler: _tags.Scheduler,
-      })
-      if (!res) err = "bad requrest"
+      try {
+        const res = await this.spawn({
+          item,
+          module: _tags.Module,
+          scheduler: _tags.Scheduler,
+          _cu_url: _tags["CU-URL"] || undefined,
+        })
+        if (!res) err = "bad requrest"
+      } catch (e) {
+        console.error("MU spawn error:", e.message, e.stack)
+        return { status: 500, json: { error: e.message, stack: (e.stack || "").split("\n").slice(0, 8) } }
+      }
     } else if (_tags.Type === "Message") {
-      await this.message({ item, process: item.target })
+      try {
+        await this.message({ item, process: item.target })
+      } catch (e) {
+        console.error("MU message error:", e.message, e.stack)
+        err = e.message
+      }
+    } else if (_tags.Type === "Scheduler-Location" || _tags.Type === "Scheduler-Transfer") {
+      try {
+        await this._ar.postItems(item, this.su_signer.jwk)
+      } catch (e) {
+        console.error(`MU ${_tags.Type} error:`, e.message, e.stack)
+        err = e.message
+      }
     } else err = true
 
     if (err) return { status: 400, error: err }
@@ -435,8 +517,8 @@ class Adaptor {
       json: {
         version: 1,
         timestamp: Date.now(),
-        height: this.mem.height,
-        network: "wao.LN.1",
+        height: await this.mem.get("height"),
+        network: this.network,
         current: this.mem.getAnchor(),
       },
     }
@@ -459,7 +541,20 @@ class Adaptor {
   async ar_get_id({ query, params, body, headers, method }) {
     const _data = await this._ar.data(params.id)
     if (!_data) return { status: 404, send: null }
-    else return { send: Buffer.from(_data, "base64") }
+    const tx = await this.mem.getTx(params.id)
+    let contentType = tx?._data?.type || ""
+    if (!contentType && tx?.tags) {
+      const ctTag = tx.tags.find(t => t.name === "Content-Type")
+      if (ctTag) contentType = ctTag.value
+    }
+    if (!contentType) contentType = "application/octet-stream"
+    const send = Buffer.isBuffer(_data) || _data instanceof Uint8Array
+      ? _data
+      : Buffer.from(String(_data), "base64")
+    return {
+      send,
+      headers: { "Content-Type": contentType },
+    }
   }
   async ar_get_price({ query, params, body, headers, method }) {
     return { send: "0" }
@@ -468,16 +563,16 @@ class Adaptor {
     try {
       const { query, variables } = body
       const { tar, args } = toGraphObj({ query, variables })
+      const first = args.first ?? 10
       let res2 = null
-      if (tar === "transactions") {
-        res2 = await this.gql.txs({ ...args })
-      } else if (tar === "blocks") {
-        res2 = await this.gql.blocks({ ...args })
-      }
+      const fn = tar === "blocks" ? "blocks" : "txs"
+      res2 = await this.gql[fn]({ ...args, first: first + 1 })
+      const hasNextPage = res2.length > first
+      if (hasNextPage) res2 = res2.slice(0, first)
       const edges = map(v => ({ node: v, cursor: v.cursor }), res2)
       return {
         json: {
-          data: { [tar]: { pageInfo: { hasNextPage: true }, edges } },
+          data: { [tar]: { pageInfo: { hasNextPage }, edges } },
         },
       }
     } catch (e) {
@@ -489,6 +584,7 @@ class Adaptor {
     // id = "tx" | "chunk"
     if (body.chunk) {
       if (this.data[body.data_root]) {
+        this._dataTimestamps[body.data_root] = Date.now()
         this.data[body.data_root].data += body.chunk
         const buf = Buffer.from(body.chunk, "base64")
         if (!this.data[body.data_root].chunks) {
@@ -508,12 +604,14 @@ class Adaptor {
             this.data[body.data_root].chunks.toString("base64")
           await this._ar.postTx(this.data[body.data_root])
           delete this.data[body.data_root]
+          delete this._dataTimestamps[body.data_root]
         }
       }
       return { json: { id: body.id } }
     } else {
       if (body.data_root && body.data === "") {
         this.data[body.data_root] = body
+        this._dataTimestamps[body.data_root] = Date.now()
       } else {
         await this._ar.postTx(body)
       }

package/esm/adaptor-cf.js

@@ -0,0 +1,11 @@
+import { connect } from "./aoconnect-cf.js"
+import { cu, su, mu } from "./accounts-web.js"
+import GQL from "./tgql.js"
+import Base from "./adaptor-base.js"
+
+class Adaptor extends Base {
+  constructor(obj) {
+    super({ ...obj, GQL, cu, su, mu, connect })
+  }
+}
+export default Adaptor

package/esm/ao-loader.js

@@ -24000,7 +24000,7 @@ var require_wasm64_emscripten = __commonJS({
         _emscripten_get_now = () => deterministicNow()
         var growMemory = size => {
           var b = wasmMemory.buffer
-          var pages = (size - b.byteLength + 65535) / 65536
+          var pages = BigInt(Math.ceil((size - b.byteLength) / 65536))
           try {
             wasmMemory.grow(pages)
             updateMemoryViews()

package/esm/ao.js

@@ -99,7 +99,15 @@ class AO {
     if (_hb) {
       this.format = _hb === "ans104" ? _hb : "httpsig"
       const _hbOpt = { format: this.format }
-      if (typeof _hb === "string" && _hb !== "ans104") _hbOpt.url = _hb
+      // `hb` can be "ans104" / "httpsig" (format selector with default URL),
+      // or an actual URL string. Only treat it as a URL when it looks like one.
+      if (
+        typeof _hb === "string" &&
+        _hb !== "ans104" &&
+        _hb !== "httpsig" &&
+        /^(https?:\/\/|\/\/|[a-zA-Z0-9_.-]+:\d+)/.test(_hb)
+      )
+        _hbOpt.url = _hb
       this.hb = new HB(_hbOpt)
       this.mode = mode ?? "legacy"
     }
@@ -679,8 +687,19 @@ class AO {
           mid = (await this.hb.scheduleLegacy(schedArgs)).slot
           try {
             res = await this.hb.computeLegacy({ pid, slot: mid })
+            // v0.9-FINAL's push device can enter long-running recursive loops
+            // for cross-process Send().receive() coroutines. Race the push
+            // call against a 20s timeout so msg() can return rather than
+            // wait forever; the now/results probe below still has a chance
+            // to pick up a partial reply.
+            const _pushTimeoutMs = 20000
             try {
-              await this.hb.get({ path: `/${pid}/push`, slot: mid })
+              await Promise.race([
+                this.hb.get({ path: `/${pid}/push`, slot: mid }),
+                new Promise((_r, rej) =>
+                  setTimeout(() => rej(new Error("push timeout")), _pushTimeoutMs)
+                ),
+              ])
             } catch (_e2) {}
             // Push updates now/ to its recursive resolution result, which may
             // include errors from other processes (cross-process trust errors).