@silkline/hasura-sim 0.1.0

package/README.md

@@ -0,0 +1,65 @@
+# @silkline/hasura-sim
+
+An in-memory Hasura GraphQL engine for tests. The real Hasura GraphQL Engine v2
+(Haskell) is compiled to WebAssembly and paired with [pglite](https://pglite.dev)
+(WASM Postgres). Feed it static Hasura metadata and a migrated pglite instance,
+then run GraphQL operations and get back exactly what the real engine returns —
+no Docker, no Postgres server, no network.
+
+## How it works
+
+```
+GraphQL op ─▶ sim_execute (wasm Hasura engine)
+                  │  parse → IR → SQL  (real engine: permissions,
+                  │                     session vars, relationships, …)
+                  ▼
+            pg_exec bridge ──▶ pglite (in-process Postgres)
+                  ▲                │
+                  └──── rows ──────┘
+```
+
+The engine runs the real schema-cache builder and query/mutation translator.
+SQL is executed against pglite over the PostgreSQL wire protocol (`src/wire.mjs`),
+so binary params + OIDs and result formats round-trip faithfully.
+
+## Usage
+
+```js
+import { PGlite } from "@electric-sql/pglite";
+import { createSimulator } from "@silkline/hasura-sim";
+
+const db = new PGlite();
+await db.exec(/* your migrations */);
+
+const sim = await createSimulator({
+  db,
+  metadataJson: {
+    version: 3,
+    sources: [
+      {
+        name: "default",
+        kind: "postgres",
+        configuration: {
+          connection_info: { database_url: "postgres://localhost/db" },
+        },
+        tables: [{ table: { schema: "public", name: "widget" } }],
+      },
+    ],
+  },
+});
+
+const { data, errors } = await sim.execute({
+  query: "query ($id: Int!) { widget(where: { id: { _eq: $id } }) { id name } }",
+  variables: { id: 2 },
+  role: "user", // default "admin"
+  sessionVariables: { "x-hasura-user-id": "42" },
+});
+```
+
+`metadataJson` is consolidated Hasura metadata (`hasura metadata export -o json`).
+The `database_url` is ignored — all SQL is routed to the provided pglite `db`.
+
+## Status
+
+Validated end-to-end: queries (param-free + parameterized) and mutations
+(insert, committing). Remote schemas and actions are out of scope (stubbed).

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@silkline/hasura-sim",
+  "version": "0.1.0",
+  "description": "In-memory Hasura GraphQL Engine (compiled to WebAssembly) + pglite — runs real GraphQL queries/mutations offline for tests and codegen, with no Docker/Postgres/network.",
+  "type": "module",
+  "main": "src/index.mjs",
+  "exports": {
+    ".": "./src/index.mjs"
+  },
+  "files": [
+    "src",
+    "wasm/reactor.wasm",
+    "wasm/reactor.js",
+    "README.md"
+  ],
+  "scripts": {
+    "build:wasm": "./scripts/build-wasm.sh"
+  },
+  "dependencies": {
+    "graphql": "^16.14.0"
+  },
+  "peerDependencies": {
+    "@electric-sql/pglite": ">=0.2.0"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Silkline/hasura-wasm.git",
+    "directory": "packages/hasura-sim"
+  },
+  "license": "Apache-2.0"
+}

package/src/index.mjs

@@ -0,0 +1,331 @@
+// @silkline/hasura-sim — in-memory Hasura GraphQL engine (compiled to wasm)
+// paired with pglite. Feed it static Hasura metadata + a migrated pglite
+// instance, then run GraphQL operations and get back exactly what the real
+// engine would return, with no Docker/Postgres/network.
+
+import { WASI } from "node:wasi";
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { PGlite } from "@electric-sql/pglite";
+import {
+  buildClientSchema,
+  buildSchema,
+  getIntrospectionQuery,
+  graphql,
+  introspectionFromSchema,
+  printSchema,
+} from "graphql";
+
+// Build an executable schema from SDL + resolvers using only graphql-js (no
+// @graphql-tools) so there is a single `graphql` instance — mixing two copies
+// trips graphql-js's "Duplicate graphql modules" guard.
+function buildExecutableSchema(sdl, resolvers) {
+  const schema = buildSchema(sdl);
+  for (const [typeName, fieldResolvers] of Object.entries(resolvers ?? {})) {
+    const type = schema.getType(typeName);
+    if (!type || typeof type.getFields !== "function") continue;
+    const fields = type.getFields();
+    for (const [fieldName, resolve] of Object.entries(fieldResolvers)) {
+      if (fields[fieldName]) fields[fieldName].resolve = resolve;
+    }
+  }
+  return schema;
+}
+import {
+  buildExtendedQuery,
+  buildSimpleQuery,
+  decodeResponse,
+} from "./wire.mjs";
+
+// Re-exported so consumers can build/seed a pglite instance without taking
+// their own @electric-sql/pglite dependency.
+export { PGlite } from "@electric-sql/pglite";
+
+const here = dirname(fileURLToPath(import.meta.url));
+
+// Run one Haskell-bridge request against a pglite connection via the raw wire
+// protocol. Exported for tests; normally reached through the global below.
+export async function execOnPglite(db, requestJson) {
+  const req = JSON.parse(requestJson);
+  const params = req.params ?? [];
+  const rfmt = req.rfmt ?? 0;
+  // The extended protocol (Parse/Bind) is the faithful path: it honours the
+  // requested result format (rfmt=1 ⇒ binary), which Hasura's decoders rely on
+  // — e.g. the mutation permission-check boolean must come back as a binary
+  // 0x01/0x00, not text "t"/"f". Its one limitation is that a Parse may carry
+  // only a single statement, so Hasura's multi-statement connection setup
+  // ("SET a; SET b;") falls back to the simple query protocol, whose text-only
+  // results are harmless there (SET returns no data).
+  const extended = decodeResponse(
+    await db.execProtocolRaw(buildExtendedQuery({ sql: req.sql, params, rfmt })),
+  );
+  if (isMultiStatementError(extended)) {
+    return JSON.stringify(
+      decodeResponse(await db.execProtocolRaw(buildSimpleQuery(req.sql))),
+    );
+  }
+  return JSON.stringify(extended);
+}
+
+// The extended protocol rejects a Parse containing more than one statement
+// (SQLSTATE 42601, "cannot insert multiple commands into a prepared statement").
+function isMultiStatementError(res) {
+  return (
+    res.status === "FatalError" &&
+    res.error != null &&
+    /multiple commands/i.test(res.error.message ?? "")
+  );
+}
+
+// Normalise a remote-schema definition to the introspection *response* shape
+// the engine expects ({"data":{"__schema":…}}). Accepts:
+//   - an SDL string (e.g. the contents of server-schema.gql),
+//   - { sdl: "<SDL>" },
+//   - { introspection: <{__schema} or {data:{__schema}}> }.
+export function remoteSchemaToIntrospection(def) {
+  if (typeof def === "string") {
+    return { data: introspectionFromSchema(buildSchema(def)) };
+  }
+  if (def?.sdl) {
+    return { data: introspectionFromSchema(buildSchema(def.sdl)) };
+  }
+  if (def?.introspection) {
+    const i = def.introspection;
+    return i.data ? i : { data: i };
+  }
+  throw new Error(
+    "hasura-sim: remote schema definition must be an SDL string, { sdl }, or { introspection }",
+  );
+}
+
+// ---------------------------------------------------------------------------
+// HTTP bridge: the wasm engine issues all remote-schema and action HTTP through
+// a Manager backed by `js_http_exec` (see server/lib/hasura-wasm-sim's
+// HttpBridge). We get the raw HTTP/1.1 request text and return raw response
+// text; dispatch is by the rewritten URL (host marks kind, path carries name).
+
+function parseHttpRequest(raw) {
+  const sep = raw.indexOf("\r\n\r\n");
+  const head = sep === -1 ? raw : raw.slice(0, sep);
+  const body = sep === -1 ? "" : raw.slice(sep + 4);
+  const lines = head.split("\r\n");
+  const [method, path] = (lines[0] ?? "").split(" ");
+  const headers = {};
+  for (let i = 1; i < lines.length; i++) {
+    const idx = lines[i].indexOf(":");
+    if (idx > 0) {
+      headers[lines[i].slice(0, idx).trim().toLowerCase()] = lines[i]
+        .slice(idx + 1)
+        .trim();
+    }
+  }
+  return { method, path: path ?? "/", headers, body };
+}
+
+function httpResponse(status, bodyObj) {
+  const body = typeof bodyObj === "string" ? bodyObj : JSON.stringify(bodyObj);
+  const len = Buffer.byteLength(body, "utf8");
+  const reason =
+    { 200: "OK", 400: "Bad Request", 404: "Not Found", 500: "Server Error" }[
+      status
+    ] ?? "OK";
+  return (
+    `HTTP/1.1 ${status} ${reason}\r\n` +
+    `content-type: application/json\r\n` +
+    `content-length: ${len}\r\n` +
+    `connection: close\r\n\r\n` +
+    body
+  );
+}
+
+// Build the `js_http_exec` handler from the registered remote schemas + actions.
+function makeHttpHandler({ remotes, actions }) {
+  return async (rawRequest) => {
+    let req;
+    try {
+      req = parseHttpRequest(rawRequest);
+    } catch {
+      return httpResponse(400, { errors: [{ message: "hasura-sim: malformed request" }] });
+    }
+    const host = req.headers["host"] ?? "";
+    const name = decodeURIComponent(req.path.replace(/^\//, ""));
+    try {
+      if (host === "remote.local") {
+        const entry = remotes[name];
+        const gql = req.body ? JSON.parse(req.body) : {};
+        if (entry?.handler) return httpResponse(200, await entry.handler(gql));
+        if (entry?.schema) {
+          const result = await graphql({
+            schema: entry.schema,
+            source: gql.query,
+            variableValues: gql.variables ?? undefined,
+            operationName: gql.operationName ?? undefined,
+          });
+          return httpResponse(200, result);
+        }
+        return httpResponse(200, {
+          errors: [
+            {
+              message: `hasura-sim: no resolvers/handler registered for remote schema "${name}". Pass remoteSchemas["${name}"].resolvers or .handler.`,
+            },
+          ],
+        });
+      }
+      if (host === "action.local") {
+        const payload = req.body ? JSON.parse(req.body) : {};
+        const actionName = name || payload?.action?.name;
+        const handler = actions[actionName];
+        if (!handler) {
+          return httpResponse(400, {
+            message: `hasura-sim: no action handler registered for "${actionName}". Pass actions["${actionName}"].`,
+          });
+        }
+        // Hasura's action webhook `input` field is the action's *arguments*
+        // object (keyed by your action's arg names, e.g. { input: {...} }).
+        // Pass it as the handler's first arg so `({ input }) => …` reads
+        // naturally; session vars + raw payload come as the second arg.
+        const out = await handler(payload.input ?? {}, {
+          sessionVariables: payload.session_variables,
+          payload,
+        });
+        return httpResponse(200, out ?? null);
+      }
+      return httpResponse(404, {
+        errors: [{ message: `hasura-sim: unexpected request host "${host}"` }],
+      });
+    } catch (err) {
+      return httpResponse(500, {
+        errors: [{ message: `hasura-sim handler error: ${err?.message ?? err}` }],
+      });
+    }
+  };
+}
+
+async function instantiateReactor() {
+  const wasmBytes = await readFile(join(here, "..", "wasm", "reactor.wasm"));
+  const wasi = new WASI({
+    version: "preview1",
+    args: ["reactor.wasm"],
+    env: {},
+    preopens: { "/": "/" },
+  });
+  const mod = await WebAssembly.compile(wasmBytes);
+  const exportsBag = {};
+  const glue = (await import(join(here, "..", "wasm", "reactor.js"))).default(
+    exportsBag,
+  );
+  const instance = await WebAssembly.instantiate(mod, {
+    wasi_snapshot_preview1: wasi.wasiImport,
+    ghc_wasm_jsffi: glue,
+  });
+  Object.assign(exportsBag, instance.exports);
+  wasi.initialize(instance);
+  return instance;
+}
+
+/**
+ * Create a simulator.
+ *
+ * @param {object} opts
+ * @param {object|string} [opts.metadataJson] consolidated Hasura metadata; if
+ *   given, the schema cache is built immediately.
+ * @param {PGlite} [opts.db] a pre-migrated pglite instance (else a fresh one).
+ * @returns {Promise<{db, execute, init, version}>}
+ */
+export async function createSimulator({
+  metadataJson,
+  db,
+  remoteSchemas = {},
+  actions = {},
+} = {}) {
+  const pg = db ?? new PGlite();
+  await pg.waitReady;
+
+  // Build executable schemas / handlers for remote-schema *execution* (the
+  // static SDL still feeds schema-cache build via remoteSchemaToIntrospection
+  // in init()). Each remoteSchemas[name] is an SDL string, or
+  // { sdl, resolvers? , handler? }, or { introspection }.
+  const remotes = {};
+  for (const [name, def] of Object.entries(remoteSchemas)) {
+    const entry = {};
+    if (def && typeof def === "object" && !Array.isArray(def)) {
+      if (typeof def.handler === "function") {
+        entry.handler = def.handler;
+      } else if (def.resolvers && def.sdl) {
+        entry.schema = buildExecutableSchema(def.sdl, def.resolvers);
+      }
+    }
+    remotes[name] = entry;
+  }
+
+  // The wasm bridges call these globals. Registered before sim_init so the
+  // introspection / remote / action calls the build + execute issue reach them.
+  globalThis.pg_connect = () => 1; // one in-memory database
+  globalThis.pg_exec = (_connId, requestJson) => execOnPglite(pg, requestJson);
+  globalThis.js_http_exec = makeHttpHandler({ remotes, actions });
+
+  const instance = await instantiateReactor();
+  const { sim_init, sim_execute, sim_version } = instance.exports;
+
+  const init = async (metadata, remotes = {}) => {
+    const metaPayload =
+      typeof metadata === "string" ? metadata : JSON.stringify(metadata);
+    // Static remote-schema definitions: { [remoteSchemaName]: SDL | { sdl } |
+    // { introspection } }. wasm can't introspect over the network, so each is
+    // turned into the introspection response the engine merges into the schema.
+    const introspections = Object.fromEntries(
+      Object.entries(remotes ?? {}).map(([name, def]) => [
+        name,
+        remoteSchemaToIntrospection(def),
+      ]),
+    );
+    return JSON.parse(await sim_init(metaPayload, JSON.stringify(introspections)));
+  };
+
+  if (metadataJson !== undefined) {
+    const result = await init(metadataJson, remoteSchemas ?? {});
+    if (result.error) {
+      throw new Error(`hasura-sim: sim_init failed: ${result.error}`);
+    }
+  }
+
+  return {
+    db: pg,
+    init,
+    async version() {
+      return sim_version();
+    },
+    async execute({ query, variables, role, sessionVariables } = {}) {
+      const raw = await sim_execute(
+        role ?? "admin",
+        JSON.stringify(sessionVariables ?? {}),
+        query,
+        JSON.stringify(variables ?? {}),
+      );
+      return JSON.parse(raw);
+    },
+    // Run the standard GraphQL introspection for a role and return the
+    // introspection result ({ __schema: … }). The schema is role-scoped, so
+    // pass the role (and any session vars the role expects).
+    async introspect({ role, sessionVariables } = {}) {
+      const res = await this.execute({
+        query: getIntrospectionQuery(),
+        role,
+        sessionVariables,
+      });
+      if (res.errors) {
+        throw new Error(
+          `hasura-sim: introspection failed: ${JSON.stringify(res.errors)}`,
+        );
+      }
+      return res.data;
+    },
+    // Role-scoped schema as SDL — suitable as a static codegen base, generated
+    // entirely offline.
+    async schemaSDL({ role, sessionVariables } = {}) {
+      const introspection = await this.introspect({ role, sessionVariables });
+      return printSchema(buildClientSchema(introspection));
+    },
+  };
+}

package/src/wire.mjs

@@ -0,0 +1,230 @@
+// Minimal PostgreSQL extended-query wire-protocol codec.
+//
+// The Haskell pg-client bridge (postgresql-libpq shim) hands us a request of
+// { sql, params: [{oid,fmt,val(base64)}|null], rfmt } and expects back
+// { status, fields: [{name,oid}], rows: [[base64|null]], cmd, error }. To
+// reproduce exactly what a real Postgres would return (binary params in,
+// text/binary results out), we drive pglite via its raw wire protocol rather
+// than its JS-value query() API.
+
+const enc = new TextEncoder();
+
+class Writer {
+  constructor() {
+    this.chunks = [];
+  }
+  u8(n) {
+    this.chunks.push(Uint8Array.of(n & 0xff));
+    return this;
+  }
+  i16(n) {
+    const b = new Uint8Array(2);
+    new DataView(b.buffer).setInt16(0, n);
+    this.chunks.push(b);
+    return this;
+  }
+  i32(n) {
+    const b = new Uint8Array(4);
+    new DataView(b.buffer).setInt32(0, n);
+    this.chunks.push(b);
+    return this;
+  }
+  bytes(u8) {
+    this.chunks.push(u8);
+    return this;
+  }
+  cstr(s) {
+    this.chunks.push(enc.encode(s));
+    this.chunks.push(Uint8Array.of(0));
+    return this;
+  }
+  build() {
+    const len = this.chunks.reduce((a, c) => a + c.length, 0);
+    const out = new Uint8Array(len);
+    let o = 0;
+    for (const c of this.chunks) {
+      out.set(c, o);
+      o += c.length;
+    }
+    return out;
+  }
+}
+
+// A typed frontend message: 1-byte tag + int32 length (covering length + body).
+function frame(tag, bodyWriter) {
+  const body = bodyWriter.build();
+  const w = new Writer();
+  w.u8(tag.charCodeAt(0));
+  w.i32(body.length + 4);
+  w.bytes(body);
+  return w.build();
+}
+
+function concat(arrays) {
+  const len = arrays.reduce((a, c) => a + c.length, 0);
+  const out = new Uint8Array(len);
+  let o = 0;
+  for (const a of arrays) {
+    out.set(a, o);
+    o += a.length;
+  }
+  return out;
+}
+
+// Simple query protocol ('Q'): a single message carrying the SQL text. Unlike
+// the extended protocol it permits multiple statements (e.g. Hasura's
+// "SET a; SET b;" connection setup) and needs no Parse/Bind. Results come back
+// as text, which is what the bridge's rfmt=0 path expects.
+export function buildSimpleQuery(sql) {
+  return frame("Q", new Writer().cstr(sql));
+}
+
+// Build Parse + Bind + Describe(portal) + Execute + Sync for one statement.
+export function buildExtendedQuery({ sql, params, rfmt }) {
+  const parse = frame(
+    "P",
+    new Writer()
+      .cstr("") // unnamed prepared statement
+      .cstr(sql)
+      .i16(params.length)
+      .bytes(
+        concat(
+          params.map((p) => new Writer().i32(p ? p.oid : 0).build()),
+        ),
+      ),
+  );
+
+  const bindBody = new Writer()
+    .cstr("") // unnamed portal
+    .cstr("") // unnamed statement
+    .i16(params.length); // per-param format codes
+  for (const p of params) bindBody.i16(p ? p.fmt : 0);
+  bindBody.i16(params.length); // param values
+  for (const p of params) {
+    if (!p) {
+      bindBody.i32(-1); // SQL NULL
+    } else {
+      const bytes = Buffer.from(p.val, "base64");
+      bindBody.i32(bytes.length).bytes(new Uint8Array(bytes));
+    }
+  }
+  bindBody.i16(1).i16(rfmt); // one result-format code, applied to all columns
+  const bind = frame("B", bindBody);
+
+  const describe = frame("D", new Writer().u8("P".charCodeAt(0)).cstr(""));
+  const execute = frame("E", new Writer().cstr("").i32(0)); // no row limit
+  const sync = frame("S", new Writer());
+
+  return concat([parse, bind, describe, execute, sync]);
+}
+
+// Decode the backend's raw response bytes into the bridge JSON shape.
+export function decodeResponse(buf) {
+  const u8 = buf instanceof Uint8Array ? buf : new Uint8Array(buf);
+  const dv = new DataView(u8.buffer, u8.byteOffset, u8.byteLength);
+  let off = 0;
+
+  let fields = [];
+  const rows = [];
+  let cmd = "";
+  let sawRowDescription = false;
+  let error = null;
+  let empty = false;
+
+  const readCStringFrom = (start) => {
+    let i = start;
+    while (u8[i] !== 0) i++;
+    return [Buffer.from(u8.subarray(start, i)).toString("utf8"), i + 1];
+  };
+
+  while (off + 5 <= u8.length) {
+    const tag = String.fromCharCode(u8[off]);
+    const len = dv.getInt32(off + 1);
+    const bodyStart = off + 5;
+    const bodyEnd = off + 1 + len;
+    off = bodyEnd;
+
+    switch (tag) {
+      case "T": {
+        // RowDescription
+        sawRowDescription = true;
+        let p = bodyStart;
+        const count = dv.getInt16(p);
+        p += 2;
+        fields = [];
+        for (let i = 0; i < count; i++) {
+          const [name, next] = readCStringFrom(p);
+          p = next;
+          // tableOID(4) colAttr(2) typeOID(4) typeLen(2) typeMod(4) fmt(2)
+          const typeOID = dv.getInt32(p + 6);
+          p += 18;
+          fields.push({ name, oid: typeOID });
+        }
+        break;
+      }
+      case "D": {
+        // DataRow
+        let p = bodyStart;
+        const count = dv.getInt16(p);
+        p += 2;
+        const cells = [];
+        for (let i = 0; i < count; i++) {
+          const cellLen = dv.getInt32(p);
+          p += 4;
+          if (cellLen === -1) {
+            cells.push(null);
+          } else {
+            cells.push(
+              Buffer.from(u8.subarray(p, p + cellLen)).toString("base64"),
+            );
+            p += cellLen;
+          }
+        }
+        rows.push(cells);
+        break;
+      }
+      case "C": {
+        // CommandComplete
+        [cmd] = readCStringFrom(bodyStart);
+        break;
+      }
+      case "I": {
+        empty = true;
+        break;
+      }
+      case "E": {
+        // ErrorResponse: fieldCode byte + cstring, terminated by 0 byte.
+        let p = bodyStart;
+        const fieldsMap = {};
+        while (u8[p] !== 0) {
+          const code = String.fromCharCode(u8[p]);
+          p += 1;
+          const [val, next] = readCStringFrom(p);
+          p = next;
+          fieldsMap[code] = val;
+        }
+        error = {
+          sqlstate: fieldsMap.C,
+          message: fieldsMap.M,
+          detail: fieldsMap.D,
+          hint: fieldsMap.H,
+        };
+        break;
+      }
+      default:
+        // ParseComplete(1), BindComplete(2), NoData(n), ReadyForQuery(Z),
+        // ParameterDescription(t), etc. — ignored.
+        break;
+    }
+  }
+
+  let status;
+  if (error) status = "FatalError";
+  else if (empty) status = "EmptyQuery";
+  else if (sawRowDescription) status = "TuplesOk";
+  else status = "CommandOk";
+
+  const result = { status, fields, rows, cmd };
+  if (error) result.error = error;
+  return result;
+}

package/wasm/reactor.js

@@ -0,0 +1,119 @@
+// This file implements the JavaScript runtime logic for Haskell
+// modules that use JSFFI. It is not an ESM module, but the template
+// of one; the post-linker script will copy all contents into a new
+// ESM module.
+
+// Manage a mapping from 32-bit ids to actual JavaScript values.
+class JSValManager {
+  #lastk = 0;
+  #kv = new Map();
+
+  newJSVal(v) {
+    const k = ++this.#lastk;
+    this.#kv.set(k, v);
+    return k;
+  }
+
+  // A separate has() call to ensure we can store undefined as a value
+  // too. Also, unconditionally check this since the check is cheap
+  // anyway, if the check fails then there's a use-after-free to be
+  // fixed.
+  getJSVal(k) {
+    if (!this.#kv.has(k)) {
+      throw new WebAssembly.RuntimeError(`getJSVal(${k})`);
+    }
+    return this.#kv.get(k);
+  }
+
+  // Check for double free as well.
+  freeJSVal(k) {
+    if (!this.#kv.delete(k)) {
+      throw new WebAssembly.RuntimeError(`freeJSVal(${k})`);
+    }
+  }
+}
+
+// The actual setImmediate() to be used. This is a ESM module top
+// level binding and doesn't pollute the globalThis namespace.
+//
+// To benchmark different setImmediate() implementations in the
+// browser, use https://github.com/jphpsf/setImmediate-shim-demo as a
+// starting point.
+const setImmediate = await (async () => {
+  // node, bun, or other scripts might have set this up in the browser
+  if (globalThis.setImmediate) {
+    return globalThis.setImmediate;
+  }
+
+  // deno
+  if (globalThis.Deno) {
+    try {
+      return (await import("node:timers")).setImmediate;
+    } catch {}
+  }
+
+  // https://developer.mozilla.org/en-US/docs/Web/API/Scheduler/postTask
+  if (globalThis.scheduler) {
+    return (cb, ...args) => scheduler.postTask(() => cb(...args));
+  }
+
+  // Cloudflare workers doesn't support MessageChannel
+  if (globalThis.MessageChannel) {
+    // A simple & fast setImmediate() implementation for browsers. It's
+    // not a drop-in replacement for node.js setImmediate() because:
+    // 1. There's no clearImmediate(), and setImmediate() doesn't return
+    //    anything
+    // 2. There's no guarantee that callbacks scheduled by setImmediate()
+    //    are executed in the same order (in fact it's the opposite lol),
+    //    but you are never supposed to rely on this assumption anyway
+    class SetImmediate {
+      #fs = [];
+      #mc = new MessageChannel();
+
+      constructor() {
+        this.#mc.port1.addEventListener("message", () => {
+          this.#fs.pop()();
+        });
+        this.#mc.port1.start();
+      }
+
+      setImmediate(cb, ...args) {
+        this.#fs.push(() => cb(...args));
+        this.#mc.port2.postMessage(undefined);
+      }
+    }
+
+    const sm = new SetImmediate();
+    return (cb, ...args) => sm.setImmediate(cb, ...args);
+  }
+
+  return (cb, ...args) => setTimeout(cb, 0, ...args);
+})();
+
+export default (__exports) => {
+const __ghc_wasm_jsffi_jsval_manager = new JSValManager();
+const __ghc_wasm_jsffi_finalization_registry = globalThis.FinalizationRegistry ? new FinalizationRegistry(sp => __exports.rts_freeStablePtr(sp)) : { register: () => {}, unregister: () => true };
+return {
+newJSVal: (v) => __ghc_wasm_jsffi_jsval_manager.newJSVal(v),
+getJSVal: (k) => __ghc_wasm_jsffi_jsval_manager.getJSVal(k),
+freeJSVal: (k) => __ghc_wasm_jsffi_jsval_manager.freeJSVal(k),
+scheduleWork: () => setImmediate(__exports.rts_schedulerLoop),
+ZC7ZCghczminternalZCGHCziInternalziWasmziPrimziImportsZC: ($1,$2) => ($1.then(res => __exports.rts_promiseResolveWord32($2, res), err => __exports.rts_promiseReject($2, err))),
+ZC17ZCghczminternalZCGHCziInternalziWasmziPrimziImportsZC: ($1,$2) => ($1.then(res => __exports.rts_promiseResolveJSVal($2, res), err => __exports.rts_promiseReject($2, err))),
+ZC18ZCghczminternalZCGHCziInternalziWasmziPrimziImportsZC: ($1,$2) => ($1.then(() => __exports.rts_promiseResolveUnit($2), err => __exports.rts_promiseReject($2, err))),
+ZC0ZCghczminternalZCGHCziInternalziWasmziPrimziConcziInternalZC: async ($1) => (new Promise(res => setTimeout(res, $1 / 1000))),
+ZC0ZCghczminternalZCGHCziInternalziWasmziPrimziTypesZC: ($1) => (`${$1.stack ? $1.stack : $1}`),
+ZC1ZCghczminternalZCGHCziInternalziWasmziPrimziTypesZC: ($1,$2) => ((new TextDecoder('utf-8', {fatal: true})).decode(new Uint8Array(__exports.memory.buffer, $1, $2))),
+ZC2ZCghczminternalZCGHCziInternalziWasmziPrimziTypesZC: ($1,$2,$3) => ((new TextEncoder()).encodeInto($1, new Uint8Array(__exports.memory.buffer, $2, $3)).written),
+ZC3ZCghczminternalZCGHCziInternalziWasmziPrimziTypesZC: ($1) => ($1.length),
+ZC4ZCghczminternalZCGHCziInternalziWasmziPrimziTypesZC: ($1) => {try { __ghc_wasm_jsffi_finalization_registry.unregister($1); } catch {}},
+ZC0ZCpostgresqlzmlibpqzm0zi11zi0zi0zminplaceZCDatabaseziPostgreSQLziLibPQziBridgeZC: async ($1,$2) => (pg_exec($1,$2)),
+ZC1ZCpostgresqlzmlibpqzm0zi11zi0zi0zminplaceZCDatabaseziPostgreSQLziLibPQziBridgeZC: async ($1) => (pg_connect($1)),
+ZC0ZChasurazmwasmzmsimzm1zi0zi0zminplaceZCHasuraziWasmSimziHttpBridgeziFfiZC: async ($1) => (js_http_exec($1)),
+ZC0ZCghczminternalZCGHCziInternalziWasmziPrimziExportsZC: ($1,$2) => ($1.reject(new WebAssembly.RuntimeError($2))),
+ZC18ZCghczminternalZCGHCziInternalziWasmziPrimziExportsZC: ($1,$2) => ($1.resolve($2)),
+ZC20ZCghczminternalZCGHCziInternalziWasmziPrimziExportsZC: ($1) => {$1.throwTo = () => {};},
+ZC21ZCghczminternalZCGHCziInternalziWasmziPrimziExportsZC: ($1,$2) => {$1.throwTo = (err) => __exports.rts_promiseThrowTo($2, err);},
+ZC22ZCghczminternalZCGHCziInternalziWasmziPrimziExportsZC: () => {let res, rej; const p = new Promise((resolve, reject) => { res = resolve; rej = reject; }); p.resolve = res; p.reject = rej; return p;},
+};
+};