wao 0.40.2 → 0.41.1

package/esm/aoconnect-base.js

@@ -37,12 +37,11 @@ let onRecovery = {}
 let ongoing = {}
 
 export default ({ AR, scheduler, mu, su, cu, acc, AoLoader, ArMem } = {}) => {
-  return (mem, { cache, log = false, extensions = {}, hb, variant } = {}) => {
+  return (mem, { cache, log = false, extensions = {}, hb, variant, storage, d1, r2, kv, ar_url } = {}) => {
     const isMem = mem?.__type__ === "mem"
     if (!isMem) {
-      let args = { cache }
+      let args = { cache, storage, scheduler, d1, r2, kv, ar_url }
       if (mem?.SU_URL) {
-        args.scheduler = scheduler
         args.variant = variant
         args = mergeLeft(mem, args)
       }
@@ -78,7 +77,9 @@ export default ({ AR, scheduler, mu, su, cu, acc, AoLoader, ArMem } = {}) => {
         scheduler: "Scheduler",
         module: "Module",
       }
-      for (let v of __tags) v.name = cap[v.name] ?? v.name
+      for (let v of __tags) {
+        v.name = cap[v.name] ?? v.name
+      }
       return __tags
     }
 
@@ -168,6 +169,50 @@ export default ({ AR, scheduler, mu, su, cu, acc, AoLoader, ArMem } = {}) => {
         await ar.postItems(item, su.jwk)
       }
 
+      // Remote CU — delegate WASM execution to satellite CU
+      if (opt._cu_url) {
+        const _tags = tags(opt.tags)
+        const ext = _tags.Extension || "WeaveDrive"
+        let p = {
+          _cu_url: opt._cu_url,
+          extension: ext,
+          format,
+          id,
+          epochs: [],
+          module: mod,
+          hash: id,
+          memory: null,
+          owner,
+          height: 0,
+          results: [id],
+        }
+        try {
+          const cuResult = await fetch(`${opt._cu_url}/cu/evaluate`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+              message: id,
+              process: id,
+              data: opt.data ?? "",
+              tags: opt.tags,
+              from: owner,
+              is_spawn: true,
+            }),
+          }).then(r => r.json())
+          const _msg = {
+            ...o(dissoc("signer"), dissoc("memory"))(opt),
+            res: cuResult,
+            msg: null,
+          }
+          await mem.set(_msg, "msgs", id)
+        } catch (e) {
+          console.log("Remote CU spawn error:", e)
+        }
+        await mem.set(p, "env", id)
+        delete ongoing[id]
+        return id
+      }
+
       const now = Date.now
       const t = tags(opt.tags)
       const ext = t.Extension || "WeaveDrive"
@@ -316,6 +361,96 @@ export default ({ AR, scheduler, mu, su, cu, acc, AoLoader, ArMem } = {}) => {
       } else {
         await ar.postItems(item, su.jwk)
       }
+
+      // Remote CU — delegate WASM execution to satellite CU
+      if (p._cu_url) {
+        try {
+          let evalData = _opt?.data ?? ""
+          let evalTags = _opt?.tags
+          let evalFrom = _opt?.from ?? opt.from
+          if (_opt?.item) {
+            const decoded = base64url.decode(_opt.item.data)
+            evalData = typeof decoded === "string" ? decoded : Buffer.from(decoded).toString("utf-8")
+            evalTags = _opt.item.tags
+            const t = tags(evalTags)
+            if (t["From-Process"]) evalFrom = t["From-Process"]
+            if (!evalFrom) {
+              evalFrom = await arweave.wallets.jwkToAddress({
+                kty: "RSA", n: _opt.item.owner, e: "AQAB",
+              })
+            }
+          }
+          // Cranked messages historically used MU addr as From. But AOS's
+          // msg.reply targets msg.From, so overwriting From to mu.addr
+          // breaks the X-Reference round-trip for Send().receive(). Only
+          // override when no explicit from is supplied by the caller.
+          if (_opt?.for && !_opt?.from) evalFrom = mu.addr
+          const cuResult = await fetch(`${p._cu_url}/cu/evaluate`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+              message: opt.message,
+              process: opt.process,
+              data: evalData,
+              tags: evalTags,
+              from: evalFrom,
+            }),
+          }).then(r => r.json())
+          p.results.push(opt.message)
+          await mem.set(p, "env", opt.process)
+          const _msg = { ...dissoc("signer", _opt), res: cuResult, msg: null }
+          await mem.set(_msg, "msgs", opt.message)
+          // Route outbox from CU response
+          for (const v of cuResult?.Messages ?? []) {
+            const envExists = await mem.get("env", v.Target)
+            if (envExists) {
+              await message({
+                for: opt.message,
+                process: v.Target,
+                tags: v.Tags,
+                data: v.Data,
+                signer: mu.signer,
+                from: opt.process,
+                target: v.Target,
+              })
+            } else if (mem._remote) {
+              // Forward to main AR's MU for routing
+              const fwdTags = buildTags(null, mergeLeft(tags(v.Tags), {
+                "Data-Protocol": "ao",
+                Variant: variant ?? "ao.TN.1",
+                Type: "Message",
+                "From-Process": opt.process,
+                "Pushed-For": opt.message,
+              }))
+              await record({
+                for: opt.message,
+                tags: fwdTags,
+                data: v.Data,
+                signer: mu.signer,
+                from: opt.process,
+                target: v.Target,
+              })
+            }
+          }
+          for (const v of cuResult?.Spawns ?? []) {
+            const __tags = tags(v.Tags)
+            await spawn({
+              for: opt.message,
+              module: __tags.Module,
+              scheduler,
+              tags: v.Tags,
+              data: v.Data,
+              from: __tags["From-Process"],
+              signer: mu.signer,
+            })
+          }
+          return id
+        } catch (e) {
+          console.log("Remote CU assign error:", e)
+          return null
+        }
+      }
+
       try {
         let data = _opt.data ?? ""
         let _tags = _opt.tags
@@ -333,6 +468,13 @@ export default ({ AR, scheduler, mu, su, cu, acc, AoLoader, ArMem } = {}) => {
             })
           }
         }
+        // Cranked messages (inter-process) historically used MU addr as
+        // From for AOS trust. But AOS's msg.reply uses msg.From as Target,
+        // so overwriting From to mu.addr breaks the X-Reference round-trip
+        // needed for Send().receive() coroutine resumption. Preserve the
+        // originating process (passed via _opt.from = opt.process from the
+        // outbox-dispatch loop) so replies land back on it.
+        if (_opt.for && !_opt.from) from = mu.addr
         // check: is owner=mu.addr right?
         const _owner = opt.message_item?.owner
           ? toAddr(opt.message_item.owner)
@@ -352,7 +494,7 @@ export default ({ AR, scheduler, mu, su, cu, acc, AoLoader, ArMem } = {}) => {
             spawn: (await mem.getTx(p.id))?.item,
             module: await mem.getTx(mod),
           })
-          mem.env[opt.process].handle = p.handle
+          if (mem.env[opt.process]) mem.env[opt.process].handle = p.handle
         }
         if (p.compressed) {
           const start = Date.now()
@@ -486,6 +628,25 @@ export default ({ AR, scheduler, mu, su, cu, acc, AoLoader, ArMem } = {}) => {
               } catch (e) {
                 console.log(e)
               }
+            } else if (mem._remote) {
+              // Remote mode: forward to main AR's MU for routing
+              try {
+                const di = await ar.dataitem({
+                  data: v.Data ?? "",
+                  signer: mu.signer,
+                  tags: mergeLeft(tags(v.Tags), {
+                    "Data-Protocol": "ao",
+                    Variant: variant ?? "ao.TN.1",
+                    Type: "Message",
+                    "From-Process": opt.process,
+                    "Pushed-For": opt.message,
+                  }),
+                  target: v.Target,
+                })
+                await mem._remote.postMU(di.item.getRaw())
+              } catch (e) {
+                console.log("Remote MU forward error:", e)
+              }
             } else {
               await record({
                 for: opt.message,
@@ -608,7 +769,7 @@ export default ({ AR, scheduler, mu, su, cu, acc, AoLoader, ArMem } = {}) => {
               spawn: (await mem.getTx(p.id))?.item,
               module: await mem.getTx(mod),
             })
-            mem.env[opt.process].handle = p.handle
+            if (mem.env[opt.process]) mem.env[opt.process].handle = p.handle
           }
           if (p.compressed) {
             const start = Date.now()
@@ -738,6 +899,92 @@ export default ({ AR, scheduler, mu, su, cu, acc, AoLoader, ArMem } = {}) => {
       return { recovered: count, pid, success }
     }
 
+    // Satellite CU evaluate: WASM execution only, no DataItem creation or AR posting.
+    // Used by cu_post_evaluate on remote CU workers.
+    const evaluate = async ({
+      message: msgId,
+      process: pid,
+      data,
+      tags: msgTags,
+      from,
+      is_spawn,
+      module: modId,
+      scheduler: sch,
+    }) => {
+      if (is_spawn) {
+        const mod = modId || tags(msgTags || []).Module
+        if (!mod) throw Error("module missing for evaluate spawn")
+        const { mod: resolvedMod, wasm, format } = await mem.getWasm(mod)
+        const _tags = tags(msgTags || [])
+        const ext = _tags.Extension || "WeaveDrive"
+        const wdrive = extensions[ext]
+        const spawnTx = await mem.getTx(pid)
+        const moduleTx = await mem.getTx(resolvedMod)
+        const handle = await AoLoader(wasm, {
+          format,
+          WeaveDrive: wdrive,
+          spawn: spawnTx?.item ?? spawnTx ?? null,
+          module: moduleTx,
+        })
+        const owner = from || mu.addr
+        let p = {
+          extension: ext,
+          format,
+          id: pid,
+          epochs: [],
+          handle,
+          module: resolvedMod,
+          hash: pid,
+          memory: null,
+          owner,
+          height: 0,
+          results: [pid],
+        }
+        let bootData = ""
+        if (_tags["On-Boot"] === "Data") bootData = data ?? ""
+        else bootData = data ?? ""
+        const msg = await genMsg(pid, p, bootData, msgTags || [], owner, owner, true)
+        const _env = await genEnv({ pid, owner, module: resolvedMod })
+        const res = await handle(null, msg, _env)
+        p.memory = res.Memory
+        delete res.Memory
+        await mem.set({ tags: msgTags, data, res, msg }, "msgs", pid)
+        await mem.set(p, "env", pid)
+        return res
+      }
+
+      // Message evaluation with state update
+      const p = await mem.get("env", pid)
+      if (!p) throw Error(`process ${pid} not found on satellite CU`)
+      if (!p.handle) {
+        const { format, mod, wasm } = await mem.getWasm(p.module)
+        const wdrive = extensions[p.extension]
+        const spawnTx = await mem.getTx(p.id)
+        const moduleTx = await mem.getTx(mod)
+        p.handle = await AoLoader(wasm, {
+          format,
+          WeaveDrive: wdrive,
+          spawn: spawnTx?.item ?? spawnTx ?? null,
+          module: moduleTx,
+        })
+      }
+      if (p.compressed) {
+        p.memory = mem.decompress(p.memory, p.original_size)
+        p.compressed = false
+      }
+      p.height += 1
+      const owner = from || mu.addr
+      const msg = await genMsg(msgId, p, data ?? "", msgTags || [], owner, owner)
+      const _env = await genEnv({ pid, owner: p.owner, module: p.module })
+      const res = await p.handle(p.memory, msg, _env)
+      p.memory = res.Memory
+      delete res.Memory
+      p.results.push(msgId)
+      await mem.set(p, "env", pid)
+      await mem.set({ tags: msgTags, data, from, res, msg }, "msgs", msgId)
+      return res
+    }
+
     const result = async opt => {
       return (await mem.get("msgs", opt.message))?.res
     }
@@ -828,7 +1075,7 @@ export default ({ AR, scheduler, mu, su, cu, acc, AoLoader, ArMem } = {}) => {
               spawn: (await mem.getTx(p.id)).item,
               module: await mem.getTx(mod),
             })
-            mem.env[opt.process].handle = p.handle
+            if (mem.env[opt.process]) mem.env[opt.process].handle = p.handle
           }
           if (p.compressed) {
             const start = Date.now()
@@ -844,6 +1091,7 @@ export default ({ AR, scheduler, mu, su, cu, acc, AoLoader, ArMem } = {}) => {
         return null
       },
       recover,
+      evaluate,
       mem,
     }
   }

package/esm/aoconnect-cf.js

@@ -0,0 +1,9 @@
+import "./cf-env.js"
+import base from "./aoconnect-base.js"
+import AR from "./car.js"
+import { mu, su, cu, acc } from "./cf.js"
+import AoLoader from "./ao-loader.js"
+import ArMem from "./armem-cf.js"
+const scheduler = "_GQ33BkPtZrqxA84vM8Zk-N2aO0toNNu_C-l-rawrBA"
+
+export const connect = base({ AR, scheduler, mu, su, cu, acc, AoLoader, ArMem })

package/esm/ar-remote.js

@@ -0,0 +1,87 @@
+export default class RemoteAR {
+  constructor(ar_url) {
+    this.url = ar_url.replace(/\/$/, "")
+  }
+
+  async data(id) {
+    const res = await fetch(`${this.url}/ar/${id}`)
+    if (!res.ok) return null
+    return new Uint8Array(await res.arrayBuffer())
+  }
+
+  async getTx(id) {
+    const query = `{ transactions(ids: ["${id}"]) {
+      edges { node { id owner { address key } recipient tags { name value }
+        anchor signature data { size type } block { id height timestamp } } }
+    } }`
+    const res = await fetch(`${this.url}/ar/graphql`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ query }),
+    })
+    const json = await res.json()
+    const node = json?.data?.transactions?.edges?.[0]?.node
+    if (!node) return null
+    return {
+      id: node.id,
+      owner: node.owner?.address,
+      _owner_key: node.owner?.key,
+      recipient: node.recipient,
+      tags: node.tags,
+      anchor: node.anchor,
+      signature: node.signature,
+      _data: node.data,
+      block: node.block?.id,
+    }
+  }
+
+  async postTx(tx) {
+    const res = await fetch(`${this.url}/ar/${tx.id || "tx"}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(tx),
+    })
+    return await res.json()
+  }
+
+  async postMU(rawDataItem) {
+    const res = await fetch(`${this.url}/mu`, {
+      method: "POST",
+      headers: { "Content-Type": "application/octet-stream" },
+      body: rawDataItem,
+    })
+    return await res.json()
+  }
+
+  async getHeight() {
+    const res = await fetch(`${this.url}/ar/`)
+    const json = await res.json()
+    return json.height ?? 0
+  }
+
+  async getAnchor() {
+    const res = await fetch(`${this.url}/ar/tx_anchor`)
+    return await res.text()
+  }
+
+  async graphql(query, variables) {
+    const res = await fetch(`${this.url}/ar/graphql`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ query, variables }),
+    })
+    return await res.json()
+  }
+
+  async findSU(schedulerAddr) {
+    const query = `{ transactions(
+      owners: ["${schedulerAddr}"],
+      tags: [{ name: "Type", values: ["Scheduler-Location"] }],
+      first: 1, sort: HEIGHT_DESC
+    ) { edges { node { tags { name value } } } } }`
+    const json = await this.graphql(query)
+    const tags = json?.data?.transactions?.edges?.[0]?.node?.tags ?? []
+    const urlTag = tags.find(t => t.name === "Url")
+    return urlTag?.value ?? null
+  }
+}