toiljs 0.0.68 → 0.0.70

package/test/fixtures/daemon-app.ts

@@ -1,17 +1,14 @@
 // A minimal @daemon fixture for the dev daemon-emulation test. It declares the
-// `daemon.*` / `mstore.*` host imports directly (so it needs no toiljs globals
-// lib) and records its activity into the dev MemoryStore, which the test reads
-// back through `devMemoryStore`. Compiled with `--targetMode cold` by the test.
+// `daemon.*` host imports directly (so it needs no toiljs globals lib) and records
+// its activity into resident daemon wasm memory. Compiled with `--targetMode cold`
+// by the test.
 //
-//   onStart()          -> mstore.incr("started", 1) and stamps the lease epoch
-//   tick()  @scheduled -> mstore.incr("tick:fast", 1)   (1s interval)
-//   sixHourly() cron   -> mstore.incr("tick:cron", 1)   (0 */6 * * *)
+//   onStart()          -> increments `started` and stamps the lease epoch
+//   tick()  @scheduled -> increments `tickFast`   (1s interval)
+//   sixHourly() cron   -> increments `tickCron`   (0 */6 * * *)
 
 // @ts-nocheck — this is AssemblyScript source compiled by toilscript, not TS.
 
-@external("env", "mstore.incr")
-declare function mstoreIncr(keyPtr: i32, keyLen: i32, delta: i64, ttlSecs: i32): i64;
-
 @external("env", "daemon.is_leader")
 declare function daemonIsLeader(): i32;
 
@@ -21,36 +18,43 @@ declare function daemonCurrentEpoch(): i64;
 @external("env", "daemon.task_count")
 declare function daemonTaskCount(): i32;
 
-// Bump the i64 counter stored at the (utf8) `key` by 1. The host reads the key
-// bytes straight out of linear memory (handleless mstore, ttl in seconds).
-function bump(key: string): void {
-    let bytes = String.UTF8.encode(key);
-    mstoreIncr(changetype<i32>(bytes), bytes.byteLength, 1, 0);
-}
+let started: i32 = 0;
+let leaderSeen: i32 = 0;
+let epochNonneg: i32 = 0;
+let taskcount2: i32 = 0;
+let tickFast: i32 = 0;
+let tickCron: i32 = 0;
 
 @daemon
 class Jobs {
     onStart(): void {
         // Prove leader=true and that the epoch import is callable; record both so
         // the test can assert the stubs from outside.
-        bump("started");
-        if (daemonIsLeader() == 1) bump("leader");
+        started += 1;
+        if (daemonIsLeader() == 1) leaderSeen += 1;
         let epoch = daemonCurrentEpoch();
-        if (epoch >= 0) bump("epoch:nonneg");
-        if (daemonTaskCount() == 2) bump("taskcount:2");
+        if (epoch >= 0) epochNonneg += 1;
+        if (daemonTaskCount() == 2) taskcount2 += 1;
     }
 
     @scheduled("1s")
     tick(): void {
-        bump("tick:fast");
+        tickFast += 1;
     }
 
     @scheduled("0 */6 * * *")
     sixHourly(): void {
-        bump("tick:cron");
+        tickCron += 1;
     }
 }
 
+export function startedCount(): i32 { return started; }
+export function leaderCount(): i32 { return leaderSeen; }
+export function epochNonnegCount(): i32 { return epochNonneg; }
+export function taskcount2Count(): i32 { return taskcount2; }
+export function tickFastCount(): i32 { return tickFast; }
+export function tickCronCount(): i32 { return tickCron; }
+
 export function probe(): i32 {
     return 1;
 }

package/test/fixtures/stream-typed.ts

@@ -0,0 +1,41 @@
+// A TYPED @stream fixture: @stream({ message: ChatMsg }) makes @message receive the DECODED @data
+// (doc 03 2.5), not raw bytes. The hook replies with the decoded text's length, so a host round-trip
+// proves the @data decode ran at runtime (not just compiled). The seed* exports hand the host a real
+// ChatMsg.encode() payload so the test never hand-crafts the @data wire format.
+
+@data
+class ChatMsg {
+  text: string = '';
+}
+
+@stream({ message: ChatMsg })
+class TypedChat {
+  @message
+  onMsg(m: ChatMsg): StreamOutbound {
+    // Reply with the DECODED text length (one byte): "hi" -> 2 proves the decode produced the string.
+    const r = new Uint8Array(1);
+    r[0] = <u8>m.text.length;
+    return StreamOutbound.reply(r);
+  }
+}
+
+// Seed buffer: the guest encodes a ChatMsg the host feeds back, so the host never hand-crafts @data
+// bytes (the encode/decode pair is the wire contract). A StaticArray<u8>'s pointer IS its data start.
+let seedBuf = new StaticArray<u8>(64);
+let seedLen: i32 = 0;
+
+export function seedHi(): void {
+  const m = new ChatMsg();
+  m.text = 'hi';
+  const b = m.encode();
+  seedLen = b.length;
+  for (let i = 0, n = b.length; i < n; i++) seedBuf[i] = b[i];
+}
+
+export function seedOffset(): i32 {
+  return changetype<i32>(seedBuf);
+}
+
+export function seedLength(): i32 {
+  return seedLen;
+}

package/test/rpc-dispatch.test.ts

@@ -0,0 +1,132 @@
+/**
+ * @service / @remote RPC: a real round trip into the example project's toilscript-compiled server
+ * wasm. A `POST /__toil_rpc` carrying the FNV method id in the `toil-rpc` header is dispatched by the
+ * runtime `Rpc` registry (compiler-injected `__rpcDispatch` + `Rpc.register`) to the @remote method,
+ * and the @data/scalar result comes back encoded with the same DataWriter codec the client decodes.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { describe, expect, it } from 'vitest';
+
+import { WasmServerModule } from '../src/devserver/index.js';
+
+const EXAMPLE_WASM = path.resolve(
+    path.dirname(fileURLToPath(import.meta.url)),
+    '../examples/basic/build/server/release.wasm',
+);
+
+/** FNV-1a (the toilscript `dataTypeId`); the client + the parser injection must agree on this. */
+function fnv1a(s: string): number {
+    let h = 0x811c9dc5;
+    for (let i = 0; i < s.length; i++) h = Math.imul(h ^ s.charCodeAt(i), 0x01000193) >>> 0;
+    return h >>> 0;
+}
+
+describe.skipIf(!fs.existsSync(EXAMPLE_WASM))('@service RPC dispatch', () => {
+    const load = (): WasmServerModule => {
+        const m = new WasmServerModule(EXAMPLE_WASM);
+        m.refresh();
+        return m;
+    };
+
+    it('dispatches Server.stats.playerCount() over /__toil_rpc', () => {
+        const id = fnv1a('Stats.playerCount');
+        expect(id).toBe(118912982); // matches the generated __toilRpc client
+        const r = load().dispatch({
+            method: 'POST',
+            path: '/__toil_rpc',
+            headers: [['toil-rpc', String(id)]],
+            body: new Uint8Array(0),
+        });
+        expect(r.unhandled).toBe(false);
+        expect(r.status).toBe(200);
+        // The result is a DataWriter-encoded i32 (the seeded player count = 3).
+        expect(r.body.length).toBe(4);
+        const dv = new DataView(r.body.buffer, r.body.byteOffset, r.body.length);
+        expect(dv.getInt32(0, true)).toBe(3);
+    });
+
+    it('dispatches a free Server.ping(n) over /__toil_rpc', () => {
+        const id = fnv1a('ping');
+        const body = new Uint8Array(4);
+        new DataView(body.buffer).setInt32(0, 41, true); // arg n = 41 (DataWriter writeI32, LE)
+        const r = load().dispatch({
+            method: 'POST',
+            path: '/__toil_rpc',
+            headers: [['toil-rpc', String(id)]],
+            body,
+        });
+        expect(r.status).toBe(200);
+        expect(r.body.length).toBe(4);
+        const dv = new DataView(r.body.buffer, r.body.byteOffset, r.body.length);
+        expect(dv.getInt32(0, true)).toBe(42); // ping(41) = 42
+    });
+
+    it('round-trips a Uint8Array[] arg + result (writeBytes/readBytes loop, the #5 fix)', () => {
+        const id = fnv1a('echoParts');
+        const parts = [Uint8Array.from([1, 2]), Uint8Array.from([3, 4, 5])];
+        const buf: number[] = [];
+        const pushU32 = (v: number) => buf.push(v & 255, (v >> 8) & 255, (v >> 16) & 255, (v >>> 24) & 255);
+        pushU32(parts.length); // u32 count, then per part: u32 len + bytes (DataWriter.writeBytes)
+        for (const p of parts) {
+            pushU32(p.length);
+            for (const b of p) buf.push(b);
+        }
+        const r = load().dispatch({
+            method: 'POST',
+            path: '/__toil_rpc',
+            headers: [['toil-rpc', String(id)]],
+            body: Uint8Array.from(buf),
+        });
+        expect(r.status).toBe(200);
+        const dv = new DataView(r.body.buffer, r.body.byteOffset, r.body.length);
+        let off = 0;
+        const count = dv.getUint32(off, true);
+        off += 4;
+        const out: number[][] = [];
+        for (let i = 0; i < count; i++) {
+            const len = dv.getUint32(off, true);
+            off += 4;
+            out.push([...r.body.subarray(off, off + len)]);
+            off += len;
+        }
+        expect(out).toEqual([
+            [1, 2],
+            [3, 4, 5],
+        ]);
+    });
+
+    it('rejects an @auth @remote with 401 when there is no session', () => {
+        const id = fnv1a('Stats.secretCount');
+        const r = load().dispatch({
+            method: 'POST',
+            path: '/__toil_rpc',
+            headers: [['toil-rpc', String(id)]],
+            body: new Uint8Array(0),
+        });
+        expect(r.status).toBe(401);
+    });
+
+    it('returns 400 for an unknown method id', () => {
+        const r = load().dispatch({
+            method: 'POST',
+            path: '/__toil_rpc',
+            headers: [['toil-rpc', '999999']],
+            body: new Uint8Array(0),
+        });
+        expect(r.status).toBe(400);
+    });
+
+    it('does not intercept a non-RPC request (no toil-rpc header)', () => {
+        const r = load().dispatch({
+            method: 'GET',
+            path: '/json',
+            headers: [['host', 'localhost:3000']],
+            body: new Uint8Array(0),
+        });
+        expect(r.status).toBe(200);
+        expect(Buffer.from(r.body).toString()).toBe('{"hello":"toiljs"}\n');
+    });
+});

package/test/rpc-kinds.test.ts

@@ -0,0 +1,18 @@
+/**
+ * The dev-server RPC DB-kind resolution (audit #2): an `@action` @remote may write; a plain/read-only
+ * @remote (absent from `toildb.rpc_kinds`) defaults to read-only Query, matching the edge host gate.
+ */
+import { describe, expect, it } from 'vitest';
+
+import { rpcKindForId, type RpcKindEntry } from '../src/devserver/db/routeKinds.js';
+import { DbFunctionKind } from '../src/devserver/db/types.js';
+
+describe('rpcKindForId', () => {
+    it('returns the @action kind for a listed id, and read-only Query for an absent one', () => {
+        const methods: RpcKindEntry[] = [{ methodId: 42, kind: DbFunctionKind.Action }];
+        expect(rpcKindForId(methods, 42)).toBe(DbFunctionKind.Action);
+        // An id NOT in rpc_kinds (a plain/read-only @remote) defaults to Query - the safe default.
+        expect(rpcKindForId(methods, 999)).toBe(DbFunctionKind.Query);
+        expect(rpcKindForId([], 42)).toBe(DbFunctionKind.Query);
+    });
+});

package/test/rpc.test.ts

@@ -2,9 +2,14 @@ import { afterEach, describe, expect, it } from 'vitest';
 
 import { Server } from '../src/client/rpc';
 
-// `Server` is the runtime behind the generated typed surface. Until the transport
-// is wired, it is a recursive proxy that throws on call.
-describe('Server RPC stub', () => {
+// `Server` is the runtime behind the generated typed surface. The RPC branch surfaces
+// `globalThis.__toilRpc` (attached by the generated `shared/server.ts`); when that client has
+// not loaded, the proxy throws a helpful "client has not loaded" error naming the path.
+describe('Server RPC stub (client not loaded)', () => {
+    afterEach(() => {
+        delete (globalThis as { __toilRpc?: unknown }).__toilRpc;
+    });
+
     it('throws on a direct call, naming the path', () => {
         const s = Server as { ping: () => unknown };
         expect(() => s.ping()).toThrow(/Server\.ping\(\)/);
@@ -13,7 +18,18 @@ describe('Server RPC stub', () => {
     it('throws on a nested service.method call', () => {
         const s = Server as { accounts: { getUser: () => unknown } };
         expect(() => s.accounts.getUser()).toThrow(/Server\.accounts\.getUser\(\)/);
-        expect(() => s.accounts.getUser()).toThrow(/not available yet/);
+        expect(() => s.accounts.getUser()).toThrow(/has not loaded/);
+    });
+
+    it('surfaces the attached RPC client (service method + free remote) once loaded', async () => {
+        const fake = { stats: { playerCount: async () => 3 }, ping: async (n: number) => n + 1 };
+        (globalThis as { __toilRpc?: unknown }).__toilRpc = fake;
+        const s = Server as {
+            stats: { playerCount: () => Promise<number> };
+            ping: (n: number) => Promise<number>;
+        };
+        expect(await s.stats.playerCount()).toBe(3);
+        expect(await s.ping(41)).toBe(42);
     });
 
     it('is not thenable (so it is not mistaken for a promise)', () => {

package/test/stream-emulation.test.ts

@@ -18,6 +18,7 @@ import { afterAll, beforeAll, describe, expect, it } from 'vitest';
 
 import { makeStreamClient } from '../src/client/stream/client.js';
 import { matchStreamRoute, parseStreamCatalog } from '../src/devserver/stream/catalog.js';
+import { buildStreamImports, freshStreamBoxState } from '../src/devserver/stream/host.js';
 import { wireStreams } from '../src/devserver/stream/wire.js';
 import { DevStreamBox } from '../src/devserver/stream/index.js';
 import { StreamDevHost } from '../src/devserver/stream/manager.js';
@@ -38,6 +39,7 @@ let GATE_PATH: string;
 let TRAP_PATH: string;
 let ECHO: Buffer;
 let GATE: Buffer;
+let TYPED: Buffer;
 
 function compile(srcName: string): { path: string; wasm: Buffer } {
     const src = join(here, 'fixtures', srcName);
@@ -62,12 +64,49 @@ beforeAll(() => {
     GATE_PATH = gate.path;
     GATE = gate.wasm;
     TRAP_PATH = compile('stream-trap.ts').path;
+    TYPED = compile('stream-typed.ts').wasm;
 });
 
 afterAll(() => {
     if (tmp) rmSync(tmp, { recursive: true, force: true });
 });
 
+describe('dev stream box: typed @data @message decode (doc 03 2.5)', () => {
+    it('decodes a guest-seeded @data payload at runtime and replies with the decoded field', () => {
+        // Seed a real ChatMsg.encode() from a raw instance (deterministic), so the host feeds VALID
+        // @data bytes without hand-crafting the wire format.
+        const ref: { memory: WebAssembly.Memory | null } = { memory: null };
+        const state = freshStreamBoxState();
+        const seedInst = new WebAssembly.Instance(
+            new WebAssembly.Module(new Uint8Array(TYPED)),
+            buildStreamImports(ref, state),
+        );
+        const sx = seedInst.exports as unknown as {
+            memory: WebAssembly.Memory;
+            seedHi: () => void;
+            seedOffset: () => number;
+            seedLength: () => number;
+        };
+        ref.memory = sx.memory;
+        sx.seedHi();
+        const off = sx.seedOffset() >>> 0;
+        const len = sx.seedLength() >>> 0;
+        expect(len).toBeGreaterThan(0);
+        const payload = Buffer.from(new Uint8Array(sx.memory.buffer, off, len));
+
+        // Drive the typed @message: the guest DECODES ChatMsg{text:"hi"} and replies with text.length.
+        const box = DevStreamBox.load(TYPED);
+        const tid = 0x0000_0000_0000_0011n;
+        expect(box.onConnect(tid, 'localhost', '/').kind).toBe('accept');
+        const out = box.onMessage(tid, payload);
+        expect(out.kind).toBe('reply');
+        if (out.kind === 'reply') {
+            expect(out.frames.length).toBe(1);
+            expect(out.frames[0][0]).toBe(2); // decoded "hi" -> text.length 2
+        }
+    });
+});
+
 describe('dev stream box: the @message ring bridge', () => {
     const id = 0x0000_0007_0000_0005n;
 

package/build/devserver/mstore/store.d.ts

@@ -1,18 +0,0 @@
-export declare class DevMemoryStore {
-    private readonly map;
-    private now;
-    private live;
-    private exp;
-    get(key: string): Buffer | null;
-    set(key: string, value: Buffer, ttlSecs: number): void;
-    delete(key: string): boolean;
-    incr(key: string, delta: bigint, ttlSecs: number): bigint | null;
-    cas(key: string, expect: Buffer | null, next: Buffer, ttlSecs: number): boolean;
-    expire(key: string, ttlSecs: number): boolean;
-    scan(prefix: string, cursor: bigint): {
-        next: bigint;
-        keys: string[];
-    } | null;
-    __reset(): void;
-}
-export declare const devMemoryStore: DevMemoryStore;

package/build/devserver/mstore/store.js

@@ -1,82 +0,0 @@
-export class DevMemoryStore {
-    map = new Map();
-    now() {
-        return Date.now();
-    }
-    live(key) {
-        const e = this.map.get(key);
-        if (e === undefined)
-            return null;
-        if (e.expiresAtMs !== 0 && e.expiresAtMs <= this.now()) {
-            this.map.delete(key);
-            return null;
-        }
-        return e;
-    }
-    exp(ttlSecs) {
-        return ttlSecs > 0 ? this.now() + ttlSecs * 1000 : 0;
-    }
-    get(key) {
-        const e = this.live(key);
-        return e ? e.value : null;
-    }
-    set(key, value, ttlSecs) {
-        this.map.set(key, { value: Buffer.from(value), expiresAtMs: this.exp(ttlSecs) });
-    }
-    delete(key) {
-        return this.map.delete(key);
-    }
-    incr(key, delta, ttlSecs) {
-        const e = this.live(key);
-        let cur = 0n;
-        if (e !== null) {
-            const s = e.value.toString('utf8').trim();
-            if (!/^-?\d+$/.test(s))
-                return null;
-            try {
-                cur = BigInt(s);
-            }
-            catch {
-                return null;
-            }
-        }
-        const next = BigInt.asIntN(64, cur + delta);
-        this.map.set(key, {
-            value: Buffer.from(next.toString(), 'utf8'),
-            expiresAtMs: ttlSecs > 0 ? this.exp(ttlSecs) : (e?.expiresAtMs ?? 0),
-        });
-        return next;
-    }
-    cas(key, expect, next, ttlSecs) {
-        const e = this.live(key);
-        if (expect === null) {
-            if (e !== null)
-                return false;
-        }
-        else if (e === null || !e.value.equals(expect)) {
-            return false;
-        }
-        this.map.set(key, { value: Buffer.from(next), expiresAtMs: this.exp(ttlSecs) });
-        return true;
-    }
-    expire(key, ttlSecs) {
-        const e = this.live(key);
-        if (!e)
-            return false;
-        e.expiresAtMs = this.exp(ttlSecs);
-        return true;
-    }
-    scan(prefix, cursor) {
-        const live = [...this.map.keys()].filter((k) => this.live(k) !== null && k.startsWith(prefix));
-        live.sort();
-        const start = Number(cursor);
-        if (start < 0 || start > live.length)
-            return null;
-        const batch = live.slice(start);
-        return { next: BigInt(live.length), keys: batch };
-    }
-    __reset() {
-        this.map.clear();
-    }
-}
-export const devMemoryStore = new DevMemoryStore();

package/src/devserver/mstore/store.ts

@@ -1,121 +0,0 @@
-/**
- * Dev MemoryStore: a single in-memory `Map` with per-entry TTL, one per process,
- * persisted nowhere (ephemeral by definition). Backs the `mstore.*` host imports
- * (RECONCILIATION Part 4, F2: HANDLELESS, ttl in SECONDS, inline drain). Keys are
- * auto-scoped to host+region; the dev process is one host/region, so the key is
- * used verbatim. Shared by streams (Phase 4) AND the daemon (both reference the
- * same `devMemoryStore` singleton), matching doc 06's "shared across
- * streams/handlers on the same region".
- *
- * TTL is enforced LAZILY on read (no background sweep), mirroring the dev DB's
- * no-background-thread design. The error space is RECONCILIATION Part 3's 0x03xx
- * registry; the host-import layer (daemon/host.ts) maps these results onto the
- * Part 3 negative-return bridge.
- */
-
-interface MStoreEntry {
-    value: Buffer;
-    /** `0` means no TTL; otherwise the epoch-ms the entry expires at. */
-    expiresAtMs: number;
-}
-
-export class DevMemoryStore {
-    private readonly map = new Map<string, MStoreEntry>();
-
-    private now(): number {
-        return Date.now();
-    }
-
-    /** The live entry for `key`, collecting it lazily if its TTL has passed. */
-    private live(key: string): MStoreEntry | null {
-        const e = this.map.get(key);
-        if (e === undefined) return null;
-        if (e.expiresAtMs !== 0 && e.expiresAtMs <= this.now()) {
-            this.map.delete(key);
-            return null;
-        }
-        return e;
-    }
-
-    private exp(ttlSecs: number): number {
-        return ttlSecs > 0 ? this.now() + ttlSecs * 1000 : 0;
-    }
-
-    /** The value, or `null` (=> 0x0301 MSTORE_NOT_FOUND). */
-    get(key: string): Buffer | null {
-        const e = this.live(key);
-        return e ? e.value : null;
-    }
-
-    set(key: string, value: Buffer, ttlSecs: number): void {
-        this.map.set(key, { value: Buffer.from(value), expiresAtMs: this.exp(ttlSecs) });
-    }
-
-    delete(key: string): boolean {
-        return this.map.delete(key);
-    }
-
-    /** Add `delta` to the i64 stored at `key`; `null` => 0x0306 MSTORE_NOT_A_NUMBER. */
-    incr(key: string, delta: bigint, ttlSecs: number): bigint | null {
-        const e = this.live(key);
-        let cur = 0n;
-        if (e !== null) {
-            const s = e.value.toString('utf8').trim();
-            if (!/^-?\d+$/.test(s)) return null;
-            try {
-                cur = BigInt(s);
-            } catch {
-                return null;
-            }
-        }
-        const next = BigInt.asIntN(64, cur + delta);
-        this.map.set(key, {
-            value: Buffer.from(next.toString(), 'utf8'),
-            // An incr on an existing key keeps its TTL unless a new one is given.
-            expiresAtMs: ttlSecs > 0 ? this.exp(ttlSecs) : (e?.expiresAtMs ?? 0),
-        });
-        return next;
-    }
-
-    /** `expect === null` means expect-absent (the dev mapping of `expect_len == 0`).
-     *  Returns `false` => 0x0304 MSTORE_CONFLICT. */
-    cas(key: string, expect: Buffer | null, next: Buffer, ttlSecs: number): boolean {
-        const e = this.live(key);
-        if (expect === null) {
-            if (e !== null) return false; // expect-absent, but present
-        } else if (e === null || !e.value.equals(expect)) {
-            return false; // expect-match failed
-        }
-        this.map.set(key, { value: Buffer.from(next), expiresAtMs: this.exp(ttlSecs) });
-        return true;
-    }
-
-    /** Re-arm the TTL of a live key; `false` => key absent (0x0301). */
-    expire(key: string, ttlSecs: number): boolean {
-        const e = this.live(key);
-        if (!e) return false;
-        e.expiresAtMs = this.exp(ttlSecs);
-        return true;
-    }
-
-    /**
-     * Prefix walk. `cursor` is an opaque resume index; a stale cursor (one that
-     * points past the current live key set after deletions) returns `null`
-     * (=> 0x0307 MSTORE_SCAN_BUSY). Returns the next cursor + the matched keys.
-     */
-    scan(prefix: string, cursor: bigint): { next: bigint; keys: string[] } | null {
-        const live = [...this.map.keys()].filter((k) => this.live(k) !== null && k.startsWith(prefix));
-        live.sort();
-        const start = Number(cursor);
-        if (start < 0 || start > live.length) return null; // stale cursor
-        const batch = live.slice(start);
-        return { next: BigInt(live.length), keys: batch };
-    }
-
-    /** Test-only: drop all entries. */
-    __reset(): void {
-        this.map.clear();
-    }
-}
-
-export const devMemoryStore = new DevMemoryStore();