xit-wasm 0.1.0

package/src/host-node.ts

@@ -0,0 +1,388 @@
+/**
+ * Node-fs-backed Host implementation.
+ *
+ * Strategy:
+ *   - Dir handles are i32s mapped to absolute filesystem paths. Handle 0 is
+ *     reserved for the "root" directory provided to NodeHost's constructor;
+ *     all sub-path operations resolve relative to it.
+ *   - File handles are i32s mapped to Node file descriptors (fs.openSync), but
+ *     wrapped with a small extra state object so we can track current position
+ *     (for seek-by) and locked state without re-querying the fs.
+ *   - All ops use Node sync APIs. Plenty fast for spike-grade testing; can
+ *     swap for a Worker-driven async model later if needed.
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as crypto from "node:crypto";
+
+import {
+  KIND_FILE,
+  KIND_DIR,
+  KIND_SYMLINK,
+  KIND_OTHER,
+  OK,
+  ERR_GENERIC,
+  ERR_NOT_FOUND,
+} from "./host.ts";
+import type { Host, StatResult } from "./host.ts";
+
+interface FileEntry {
+  fd: number;
+  position: bigint;
+}
+
+export class NodeHost implements Host {
+  private dirs = new Map<number, string>();
+  private files = new Map<number, FileEntry>();
+  private nextHandle = 100;
+  trace = false;
+
+  constructor(rootPath: string) {
+    this.dirs.set(0, rootPath);
+  }
+
+  private log(...args: unknown[]) {
+    if (this.trace) console.error("[host]", ...args);
+  }
+
+  private resolve(dirHandle: number, sub: string): string {
+    const base = this.dirs.get(dirHandle);
+    if (base === undefined) throw new Error(`unknown dir handle ${dirHandle}`);
+    return path.resolve(base, sub);
+  }
+
+  private allocHandle(): number {
+    return this.nextHandle++;
+  }
+
+  private statToResult(s: fs.Stats): StatResult {
+    let kind = KIND_OTHER;
+    if (s.isFile()) kind = KIND_FILE;
+    else if (s.isDirectory()) kind = KIND_DIR;
+    else if (s.isSymbolicLink()) kind = KIND_SYMLINK;
+    // Node's plain Stats has *Ms (number); promote to ns BigInt by hand. The
+    // bigint variant of Stats has *Ns directly but it forces every access to
+    // BigInt and is hairier to thread through.
+    const msToNs = (ms: number) => BigInt(Math.floor(ms)) * 1_000_000n;
+    return {
+      size: BigInt(s.size),
+      mtimeNs: msToNs(s.mtimeMs),
+      atimeNs: msToNs(s.atimeMs),
+      ctimeNs: msToNs(s.ctimeMs),
+      inode: BigInt(s.ino),
+      kind,
+      modeBits: s.mode & 0o777,
+    };
+  }
+
+  // ----- dir -----
+
+  dirCreateFile(dirHandle: number, sub: string) {
+    const abs = this.resolve(dirHandle, sub);
+    try {
+      const fd = fs.openSync(abs, "w+");
+      const handle = this.allocHandle();
+      this.files.set(handle, { fd, position: 0n });
+      this.log("dirCreateFile", abs, "->", handle);
+      return { code: OK, handle };
+    } catch (err: any) {
+      this.log("dirCreateFile FAIL", abs, err.code);
+      return { code: ERR_GENERIC, handle: -1 };
+    }
+  }
+
+  dirOpenFile(dirHandle: number, sub: string) {
+    const abs = this.resolve(dirHandle, sub);
+    try {
+      const fd = fs.openSync(abs, "r+");
+      const handle = this.allocHandle();
+      this.files.set(handle, { fd, position: 0n });
+      this.log("dirOpenFile", abs, "->", handle);
+      return { code: OK, handle };
+    } catch (err: any) {
+      this.log("dirOpenFile FAIL", abs, err.code);
+      return { code: ERR_NOT_FOUND, handle: -1 };
+    }
+  }
+
+  dirCreateDir(dirHandle: number, sub: string) {
+    try {
+      fs.mkdirSync(this.resolve(dirHandle, sub));
+      return OK;
+    } catch (err: any) {
+      if (err.code === "EEXIST") return ERR_GENERIC; // xit treats this as already-exists
+      return ERR_GENERIC;
+    }
+  }
+
+  dirCreateDirPath(dirHandle: number, sub: string) {
+    const abs = this.resolve(dirHandle, sub);
+    let existed = false;
+    try {
+      fs.statSync(abs);
+      existed = true;
+    } catch {}
+    try {
+      fs.mkdirSync(abs, { recursive: true });
+      return { code: OK, existed };
+    } catch {
+      return { code: ERR_GENERIC, existed: false };
+    }
+  }
+
+  dirCreateDirPathOpen(dirHandle: number, sub: string) {
+    const abs = this.resolve(dirHandle, sub);
+    try {
+      fs.mkdirSync(abs, { recursive: true });
+      const handle = this.allocHandle();
+      this.dirs.set(handle, abs);
+      this.log("dirCreateDirPathOpen", abs, "->", handle);
+      return { code: OK, handle };
+    } catch (err: any) {
+      this.log("dirCreateDirPathOpen FAIL", abs, err.code);
+      return { code: ERR_GENERIC, handle: -1 };
+    }
+  }
+
+  dirOpenDir(dirHandle: number, sub: string) {
+    const abs = this.resolve(dirHandle, sub);
+    try {
+      const s = fs.statSync(abs);
+      if (!s.isDirectory()) return { code: ERR_NOT_FOUND, handle: -1 };
+      const handle = this.allocHandle();
+      this.dirs.set(handle, abs);
+      return { code: OK, handle };
+    } catch {
+      return { code: ERR_NOT_FOUND, handle: -1 };
+    }
+  }
+
+  dirClose(handle: number) {
+    if (handle === 0) return; // never close the root
+    this.dirs.delete(handle);
+  }
+
+  dirDeleteFile(dirHandle: number, sub: string) {
+    const abs = this.resolve(dirHandle, sub);
+    try {
+      fs.unlinkSync(abs);
+      this.log("dirDeleteFile", abs);
+      return OK;
+    } catch (err: any) {
+      this.log("dirDeleteFile FAIL", abs, err.code);
+      return ERR_NOT_FOUND;
+    }
+  }
+
+  dirRename(oldDir: number, oldSub: string, newDir: number, newSub: string) {
+    const oldAbs = this.resolve(oldDir, oldSub);
+    const newAbs = this.resolve(newDir, newSub);
+    try {
+      fs.renameSync(oldAbs, newAbs);
+      this.log("dirRename", oldAbs, "->", newAbs);
+      return OK;
+    } catch (err: any) {
+      this.log("dirRename FAIL", oldAbs, "->", newAbs, err.code);
+      return ERR_GENERIC;
+    }
+  }
+
+  dirStatFile(dirHandle: number, sub: string) {
+    const abs = this.resolve(dirHandle, sub);
+    try {
+      const s = fs.lstatSync(abs);
+      this.log("dirStatFile", abs, "size", s.size);
+      return { code: OK, stat: this.statToResult(s) };
+    } catch (err: any) {
+      this.log("dirStatFile FAIL", abs, err.code);
+      return { code: ERR_NOT_FOUND };
+    }
+  }
+
+  dirReadLink(dirHandle: number, sub: string) {
+    const abs = this.resolve(dirHandle, sub);
+    try {
+      const target = fs.readlinkSync(abs);
+      this.log("dirReadLink", abs, "->", target);
+      return { code: 1, target };
+    } catch (err: any) {
+      if (err.code === "EINVAL") {
+        // not a symlink — xit needs to know this distinction
+        this.log("dirReadLink", abs, "(not a symlink)");
+        return { code: 0 };
+      }
+      this.log("dirReadLink FAIL", abs, err.code);
+      return { code: -1 };
+    }
+  }
+
+  dirAccess(dirHandle: number, sub: string) {
+    const abs = this.resolve(dirHandle, sub);
+    try {
+      fs.accessSync(abs);
+      this.log("dirAccess OK", abs);
+      return OK;
+    } catch {
+      this.log("dirAccess MISSING", abs);
+      return ERR_NOT_FOUND;
+    }
+  }
+
+  // ----- file -----
+
+  fileClose(handle: number) {
+    const entry = this.files.get(handle);
+    if (!entry) return;
+    try {
+      fs.closeSync(entry.fd);
+    } catch {}
+    this.files.delete(handle);
+  }
+
+  fileRead(handle: number, offset: bigint, len: number) {
+    const entry = this.files.get(handle);
+    if (!entry) return { code: ERR_GENERIC, data: new Uint8Array(0) };
+    const buf = Buffer.alloc(len);
+    try {
+      const n = fs.readSync(entry.fd, buf, 0, len, Number(offset));
+      this.log("fileRead", handle, "offset", offset, "len", len, "got", n);
+      return { code: OK, data: new Uint8Array(buf.buffer, buf.byteOffset, n) };
+    } catch (err: any) {
+      this.log("fileRead FAIL", handle, err.code);
+      return { code: ERR_GENERIC, data: new Uint8Array(0) };
+    }
+  }
+
+  fileWriteStream(handle: number, data: Uint8Array) {
+    const entry = this.files.get(handle);
+    if (!entry) return { code: ERR_GENERIC, written: 0 };
+    const buf = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+    try {
+      const n = fs.writeSync(entry.fd, buf, 0, buf.length, Number(entry.position));
+      entry.position += BigInt(n);
+      this.log("fileWriteStream", handle, "wrote", n, "newPos", entry.position);
+      return { code: OK, written: n };
+    } catch (err: any) {
+      this.log("fileWriteStream FAIL", handle, err.code);
+      return { code: ERR_GENERIC, written: 0 };
+    }
+  }
+
+  fileReadStream(handle: number, len: number) {
+    const entry = this.files.get(handle);
+    if (!entry) return { code: ERR_GENERIC, data: new Uint8Array(0) };
+    const buf = Buffer.alloc(len);
+    try {
+      const n = fs.readSync(entry.fd, buf, 0, len, Number(entry.position));
+      entry.position += BigInt(n);
+      this.log("fileReadStream", handle, "got", n, "newPos", entry.position);
+      return { code: OK, data: new Uint8Array(buf.buffer, buf.byteOffset, n) };
+    } catch (err: any) {
+      this.log("fileReadStream FAIL", handle, err.code);
+      return { code: ERR_GENERIC, data: new Uint8Array(0) };
+    }
+  }
+
+  fileWrite(handle: number, offset: bigint, data: Uint8Array) {
+    const entry = this.files.get(handle);
+    if (!entry) return { code: ERR_GENERIC, written: 0 };
+    const buf = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+    try {
+      const n = fs.writeSync(entry.fd, buf, 0, buf.length, Number(offset));
+      this.log("fileWrite", handle, "offset", offset, "len", buf.length, "wrote", n);
+      return { code: OK, written: n };
+    } catch (err: any) {
+      this.log("fileWrite FAIL", handle, err.code);
+      return { code: ERR_GENERIC, written: 0 };
+    }
+  }
+
+  fileStat(handle: number) {
+    const entry = this.files.get(handle);
+    if (!entry) return { code: ERR_GENERIC };
+    try {
+      const s = fs.fstatSync(entry.fd);
+      this.log("fileStat", handle, "size", s.size, "kind", this.statToResult(s).kind);
+      return { code: OK, stat: this.statToResult(s) };
+    } catch (err: any) {
+      this.log("fileStat FAIL", handle, err.code);
+      return { code: ERR_GENERIC };
+    }
+  }
+
+  fileLength(handle: number) {
+    const entry = this.files.get(handle);
+    if (!entry) return { code: ERR_GENERIC, length: 0n };
+    try {
+      const s = fs.fstatSync(entry.fd);
+      this.log("fileLength", handle, "->", s.size);
+      return { code: OK, length: BigInt(s.size) };
+    } catch (err: any) {
+      this.log("fileLength FAIL", handle, err.code);
+      return { code: ERR_GENERIC, length: 0n };
+    }
+  }
+
+  fileSeekTo(handle: number, offset: bigint) {
+    const entry = this.files.get(handle);
+    if (!entry) return ERR_GENERIC;
+    entry.position = offset;
+    return OK;
+  }
+
+  fileSeekBy(handle: number, relative: bigint) {
+    const entry = this.files.get(handle);
+    if (!entry) return ERR_GENERIC;
+    entry.position += relative;
+    return OK;
+  }
+
+  fileLock(_handle: number, _kind: number) {
+    // Spike: no real flock. We're single-process, single-threaded — index/db
+    // mutexes inside one xit run are guaranteed serial via JS event loop.
+    return OK;
+  }
+
+  fileTryLock(_handle: number, _kind: number) {
+    return 1; // always acquired in spike mode
+  }
+
+  fileUnlock(_handle: number) {
+    /* no-op */
+  }
+
+  fileSync(handle: number) {
+    const entry = this.files.get(handle);
+    if (!entry) return ERR_GENERIC;
+    try {
+      fs.fsyncSync(entry.fd);
+      return OK;
+    } catch {
+      return ERR_GENERIC;
+    }
+  }
+
+  fileSetLength(handle: number, length: bigint) {
+    const entry = this.files.get(handle);
+    if (!entry) return ERR_GENERIC;
+    try {
+      fs.ftruncateSync(entry.fd, Number(length));
+      this.log("fileSetLength", handle, "->", length);
+      return OK;
+    } catch (err: any) {
+      this.log("fileSetLength FAIL", handle, err.code);
+      return ERR_GENERIC;
+    }
+  }
+
+  // ----- misc -----
+
+  nowNanos() {
+    return BigInt(Date.now()) * 1_000_000n;
+  }
+
+  random(buf: Uint8Array) {
+    crypto.randomFillSync(buf);
+  }
+}

package/src/host.ts

@@ -0,0 +1,262 @@
+/**
+ * Host import surface. The wasm module declares 24 `host.*` extern functions;
+ * a Host implementation provides their JS-side bodies. This module defines:
+ *
+ *   - The Host interface (signatures matching src/host_io.zig).
+ *   - HostStat: byte-layout helper that mirrors the Zig HostStat extern struct.
+ *   - hostImports(): converts a Host into the WebAssembly imports object the
+ *     wasm module expects.
+ *
+ * The wasm passes pointers + lengths into linear memory; Host implementations
+ * take a `WebAssembly.Memory` reference at construction time so they can read
+ * and write into wasm memory directly.
+ */
+
+/** Wire layout matches `HostStat` in src/host_io.zig — 48 bytes, 8-aligned. */
+export const HOST_STAT_BYTES = 48;
+
+export type Kind = "file" | "directory" | "sym_link" | "other";
+
+export const KIND_FILE = 0;
+export const KIND_DIR = 1;
+export const KIND_SYMLINK = 2;
+export const KIND_OTHER = 3;
+
+export const LOCK_NONE = 0;
+export const LOCK_SHARED = 1;
+export const LOCK_EXCLUSIVE = 2;
+
+/** Status codes the Host returns. 0 = success; non-zero values are passed
+ *  through to xit and surface as errors there. Keeping this enum loose for
+ *  now — finer-grained error mapping is a follow-up. */
+export const OK = 0;
+export const ERR_GENERIC = 1;
+export const ERR_NOT_FOUND = 2;
+
+export interface StatResult {
+  size: bigint;
+  mtimeNs: bigint;
+  atimeNs: bigint;
+  ctimeNs: bigint;
+  inode: bigint;
+  kind: number;
+  modeBits: number;
+}
+
+/**
+ * The behavior surface a Host has to provide. Each method takes already-decoded
+ * arguments (paths as strings, handles as numbers) — the wasm-import shims in
+ * hostImports() handle pointer-decoding before calling into the host.
+ *
+ * Handles are opaque i32s; the host owns the mapping (e.g. dir handle 0 is the
+ * "root" the host chose to expose to xit). xit itself only ever passes them
+ * back through the same set of host calls.
+ */
+export interface Host {
+  // dir
+  dirCreateFile(dirHandle: number, path: string): { code: number; handle: number };
+  dirOpenFile(dirHandle: number, path: string): { code: number; handle: number };
+  dirCreateDir(dirHandle: number, path: string): number;
+  dirCreateDirPath(dirHandle: number, path: string): { code: number; existed: boolean };
+  dirCreateDirPathOpen(dirHandle: number, path: string): { code: number; handle: number };
+  dirOpenDir(dirHandle: number, path: string): { code: number; handle: number };
+  dirClose(handle: number): void;
+  dirDeleteFile(dirHandle: number, path: string): number;
+  dirRename(oldDir: number, oldPath: string, newDir: number, newPath: string): number;
+  dirStatFile(dirHandle: number, path: string): { code: number; stat?: StatResult };
+  dirAccess(dirHandle: number, path: string): number;
+  /** Returns:
+   *   - { code: 1+, target } — symlink with target string
+   *   - { code: 0 } — path exists but is not a symlink (xit needs the distinction)
+   *   - { code: -1 } — path does not exist or unreadable
+   */
+  dirReadLink(dirHandle: number, path: string): { code: number; target?: string };
+  // file
+  fileClose(handle: number): void;
+  fileRead(handle: number, offset: bigint, len: number): { code: number; data: Uint8Array };
+  fileWrite(handle: number, offset: bigint, data: Uint8Array): { code: number; written: number };
+  fileWriteStream(handle: number, data: Uint8Array): { code: number; written: number };
+  fileReadStream(handle: number, len: number): { code: number; data: Uint8Array };
+  fileStat(handle: number): { code: number; stat?: StatResult };
+  fileLength(handle: number): { code: number; length: bigint };
+  fileSeekTo(handle: number, offset: bigint): number;
+  fileSeekBy(handle: number, relative: bigint): number;
+  fileLock(handle: number, kind: number): number;
+  /** Returns 1 if acquired, 0 if would-block, negative on error. */
+  fileTryLock(handle: number, kind: number): number;
+  fileUnlock(handle: number): void;
+  fileSync(handle: number): number;
+  fileSetLength(handle: number, length: bigint): number;
+  // misc
+  nowNanos(): bigint;
+  random(buf: Uint8Array): void;
+}
+
+/**
+ * Build the WebAssembly imports object expected by the wasm module. Pointer-
+ * decoding lives here (centralized) so individual Host implementations can stay
+ * focused on their own backing store.
+ */
+export function hostImports(host: Host, getMemory: () => WebAssembly.Memory) {
+  const dec = new TextDecoder();
+  const memU8 = () => new Uint8Array(getMemory().buffer);
+  const memDV = () => new DataView(getMemory().buffer);
+
+  const readStr = (ptr: number, len: number) => dec.decode(memU8().slice(ptr, ptr + len));
+
+  const writeStat = (ptr: number, s: StatResult) => {
+    const dv = memDV();
+    dv.setBigUint64(ptr + 0, s.size, true);
+    dv.setBigInt64(ptr + 8, s.mtimeNs, true);
+    dv.setBigInt64(ptr + 16, s.atimeNs, true);
+    dv.setBigInt64(ptr + 24, s.ctimeNs, true);
+    dv.setBigUint64(ptr + 32, s.inode, true);
+    dv.setUint32(ptr + 40, s.kind, true);
+    dv.setUint32(ptr + 44, s.modeBits, true);
+  };
+
+  return {
+    host: {
+      host_dir_create_file: (dirH: number, p: number, plen: number, outH: number) => {
+        const r = host.dirCreateFile(dirH, readStr(p, plen));
+        if (r.code === OK) memDV().setInt32(outH, r.handle, true);
+        return r.code;
+      },
+      host_dir_open_file: (dirH: number, p: number, plen: number, outH: number) => {
+        const r = host.dirOpenFile(dirH, readStr(p, plen));
+        if (r.code === OK) memDV().setInt32(outH, r.handle, true);
+        return r.code;
+      },
+      host_dir_create_dir: (dirH: number, p: number, plen: number) =>
+        host.dirCreateDir(dirH, readStr(p, plen)),
+      host_dir_create_dir_path: (dirH: number, p: number, plen: number, outExisted: number) => {
+        const r = host.dirCreateDirPath(dirH, readStr(p, plen));
+        if (r.code === OK) memU8()[outExisted] = r.existed ? 1 : 0;
+        return r.code;
+      },
+      host_dir_create_dir_path_open: (dirH: number, p: number, plen: number, outH: number) => {
+        const r = host.dirCreateDirPathOpen(dirH, readStr(p, plen));
+        if (r.code === OK) memDV().setInt32(outH, r.handle, true);
+        return r.code;
+      },
+      host_dir_open_dir: (dirH: number, p: number, plen: number, outH: number) => {
+        const r = host.dirOpenDir(dirH, readStr(p, plen));
+        if (r.code === OK) memDV().setInt32(outH, r.handle, true);
+        return r.code;
+      },
+      host_dir_close: (h: number) => host.dirClose(h),
+      host_dir_delete_file: (dirH: number, p: number, plen: number) =>
+        host.dirDeleteFile(dirH, readStr(p, plen)),
+      host_dir_rename: (
+        oldDir: number,
+        op: number,
+        olen: number,
+        newDir: number,
+        np: number,
+        nlen: number,
+      ) => host.dirRename(oldDir, readStr(op, olen), newDir, readStr(np, nlen)),
+      host_dir_stat_file: (dirH: number, p: number, plen: number, outStat: number) => {
+        const r = host.dirStatFile(dirH, readStr(p, plen));
+        if (r.code === OK && r.stat) writeStat(outStat, r.stat);
+        return r.code;
+      },
+      host_dir_access: (dirH: number, p: number, plen: number) =>
+        host.dirAccess(dirH, readStr(p, plen)),
+      host_dir_read_link: (
+        dirH: number,
+        p: number,
+        plen: number,
+        bufPtr: number,
+        bufLen: number,
+        outSize: number,
+      ) => {
+        const r = host.dirReadLink(dirH, readStr(p, plen));
+        if (r.code > 0 && r.target !== undefined) {
+          const bytes = new TextEncoder().encode(r.target);
+          if (bytes.length > bufLen) return -1;
+          memU8().set(bytes, bufPtr);
+          memDV().setUint32(outSize, bytes.length, true);
+          return bytes.length;
+        }
+        return r.code;
+      },
+
+      host_file_close: (h: number) => host.fileClose(h),
+      host_file_read: (
+        h: number,
+        offset: bigint,
+        bufPtr: number,
+        bufLen: number,
+        outRead: number,
+      ) => {
+        const r = host.fileRead(h, offset, bufLen);
+        if (r.code === OK) {
+          memU8().set(r.data, bufPtr);
+          // out_read is `*usize` which on wasm32 is 4 bytes
+          memDV().setUint32(outRead, r.data.length, true);
+        }
+        return r.code;
+      },
+      host_file_write: (
+        h: number,
+        offset: bigint,
+        bufPtr: number,
+        bufLen: number,
+        outWritten: number,
+      ) => {
+        const data = memU8().slice(bufPtr, bufPtr + bufLen);
+        const r = host.fileWrite(h, offset, data);
+        if (r.code === OK) memDV().setUint32(outWritten, r.written, true);
+        return r.code;
+      },
+      host_file_stat: (h: number, outStat: number) => {
+        const r = host.fileStat(h);
+        if (r.code === OK && r.stat) writeStat(outStat, r.stat);
+        return r.code;
+      },
+      host_file_length: (h: number, outLen: number) => {
+        const r = host.fileLength(h);
+        if (r.code === OK) memDV().setBigUint64(outLen, r.length, true);
+        return r.code;
+      },
+      host_file_write_stream: (
+        h: number,
+        bufPtr: number,
+        bufLen: number,
+        outWritten: number,
+      ) => {
+        const data = memU8().slice(bufPtr, bufPtr + bufLen);
+        const r = host.fileWriteStream(h, data);
+        if (r.code === OK) memDV().setUint32(outWritten, r.written, true);
+        return r.code;
+      },
+      host_file_read_stream: (
+        h: number,
+        bufPtr: number,
+        bufLen: number,
+        outRead: number,
+      ) => {
+        const r = host.fileReadStream(h, bufLen);
+        if (r.code === OK) {
+          memU8().set(r.data, bufPtr);
+          memDV().setUint32(outRead, r.data.length, true);
+        }
+        return r.code;
+      },
+      host_file_seek_to: (h: number, offset: bigint) => host.fileSeekTo(h, offset),
+      host_file_seek_by: (h: number, relative: bigint) => host.fileSeekBy(h, relative),
+      host_file_lock: (h: number, kind: number) => host.fileLock(h, kind),
+      host_file_try_lock: (h: number, kind: number) => host.fileTryLock(h, kind),
+      host_file_unlock: (h: number) => host.fileUnlock(h),
+      host_file_sync: (h: number) => host.fileSync(h),
+      host_file_set_length: (h: number, len: bigint) => host.fileSetLength(h, len),
+
+      host_now_nanos: () => host.nowNanos(),
+      host_random: (bufPtr: number, bufLen: number) => {
+        const buf = new Uint8Array(bufLen);
+        host.random(buf);
+        memU8().set(buf, bufPtr);
+      },
+    },
+  };
+}