@aresdefencelabs/wasm-http-runtime 0.0.1

package/dist/abi.d.ts

@@ -0,0 +1,7 @@
+import type { RuntimeState } from "./types";
+export declare function createAresAbiImports<Env>(state: RuntimeState<Env>): {
+    ares_abi: {
+        abi_log(messagePtr: number): void;
+        abi_http_get_user_agent_name(): number;
+    };
+};

package/dist/abi.js

@@ -0,0 +1,35 @@
+import { readCString, writeCString } from "./memory";
+function getInstanceOrThrow(state) {
+    if (!state.instance) {
+        throw new Error("Wasm instance has not been initialised yet.");
+    }
+    return state.instance;
+}
+function getRequestContextOrThrow(state) {
+    if (!state.requestContext) {
+        throw new Error("No active request context.");
+    }
+    return state.requestContext;
+}
+export function createAresAbiImports(state) {
+    return {
+        ares_abi: {
+            abi_log(messagePtr) {
+                const instance = getInstanceOrThrow(state);
+                const message = readCString(instance.exports.memory, messagePtr);
+                if (state.options.onLog) {
+                    state.options.onLog(message);
+                }
+                else if (state.options.debug) {
+                    console.log("[AresWasm]", message);
+                }
+            },
+            abi_http_get_user_agent_name() {
+                const instance = getInstanceOrThrow(state);
+                const ctx = getRequestContextOrThrow(state);
+                const userAgent = ctx.request.headers.get("user-agent") ?? "Cloudflare-Worker";
+                return writeCString(instance.exports.memory, instance.exports.alloc, userAgent);
+            }
+        }
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./types";
+export * from "./memory";
+export * from "./abi";
+export * from "./runtime";
+export * from "./worker";

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from "./types";
+export * from "./memory";
+export * from "./abi";
+export * from "./runtime";
+export * from "./worker";

package/dist/memory.d.ts

@@ -0,0 +1,4 @@
+export declare function readCString(memory: WebAssembly.Memory, ptr: number): string;
+export declare function writeCString(memory: WebAssembly.Memory, alloc: (size: number) => number, value: string): number;
+export declare function writeJsonCString(memory: WebAssembly.Memory, alloc: (size: number) => number, value: unknown): number;
+export declare function headersToObject(headers: Headers): Record<string, string>;

package/dist/memory.js

@@ -0,0 +1,24 @@
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+export function readCString(memory, ptr) {
+    const bytes = new Uint8Array(memory.buffer);
+    let end = ptr;
+    while (bytes[end] !== 0) {
+        end++;
+    }
+    return decoder.decode(bytes.subarray(ptr, end));
+}
+export function writeCString(memory, alloc, value) {
+    const encoded = encoder.encode(value);
+    const ptr = alloc(encoded.length + 1);
+    const bytes = new Uint8Array(memory.buffer);
+    bytes.set(encoded, ptr);
+    bytes[ptr + encoded.length] = 0;
+    return ptr;
+}
+export function writeJsonCString(memory, alloc, value) {
+    return writeCString(memory, alloc, JSON.stringify(value));
+}
+export function headersToObject(headers) {
+    return Object.fromEntries(headers.entries());
+}

package/dist/runtime.d.ts

@@ -0,0 +1,10 @@
+import type { RequestScopedContext, RuntimeOptions, WasmInstanceWithExports, WorkerExecutionContext } from "./types";
+export declare class AresWorkerRuntime<Env = unknown> {
+    private readonly state;
+    constructor(options: RuntimeOptions<Env>);
+    init(): Promise<void>;
+    setRequestContext(context: RequestScopedContext<Env>): void;
+    clearRequestContext(): void;
+    get instance(): WasmInstanceWithExports;
+    handleFetch(request: Request, env: Env, ctx: WorkerExecutionContext): Promise<Response>;
+}

package/dist/runtime.js

@@ -0,0 +1,64 @@
+import { createAresAbiImports } from "./abi";
+import { headersToObject, readCString, writeJsonCString } from "./memory";
+export class AresWorkerRuntime {
+    state;
+    constructor(options) {
+        this.state = {
+            instance: null,
+            options,
+            requestContext: null
+        };
+    }
+    async init() {
+        if (this.state.instance) {
+            return;
+        }
+        const imports = createAresAbiImports(this.state);
+        const instance = await WebAssembly.instantiate(this.state.options.wasm, imports);
+        this.state.instance = instance;
+        if (instance.exports.app_init) {
+            instance.exports.app_init();
+        }
+    }
+    setRequestContext(context) {
+        this.state.requestContext = context;
+    }
+    clearRequestContext() {
+        this.state.requestContext = null;
+    }
+    get instance() {
+        if (!this.state.instance) {
+            throw new Error("Runtime not initialised. Call init() first.");
+        }
+        return this.state.instance;
+    }
+    async handleFetch(request, env, ctx) {
+        await this.init();
+        this.setRequestContext({ request, env, ctx });
+        try {
+            if (!this.instance.exports.handle_http) {
+                throw new Error("Wasm export handle_http() was not found.");
+            }
+            const requestBody = await request.text();
+            const inboundEnvelope = {
+                url: request.url,
+                method: request.method,
+                headers: headersToObject(request.headers),
+                body: requestBody
+            };
+            const requestPtr = writeJsonCString(this.instance.exports.memory, this.instance.exports.alloc, inboundEnvelope);
+            const responsePtr = this.instance.exports.handle_http(requestPtr);
+            const responseJson = readCString(this.instance.exports.memory, responsePtr);
+            const responseEnvelope = JSON.parse(responseJson);
+            return new Response(typeof responseEnvelope.body === "string"
+                ? responseEnvelope.body
+                : JSON.stringify(responseEnvelope.body), {
+                status: responseEnvelope.status,
+                headers: responseEnvelope.headers
+            });
+        }
+        finally {
+            this.clearRequestContext();
+        }
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,41 @@
+export interface WorkerExecutionContext {
+    waitUntil(promise: Promise<unknown>): void;
+    passThroughOnException?(): void;
+}
+export type WasmExports = {
+    memory: WebAssembly.Memory;
+    alloc: (size: number) => number;
+    free_mem?: (ptr: number, size: number) => void;
+    app_init?: () => number;
+    handle_http?: (requestJsonPtr: number) => number;
+};
+export type WasmInstanceWithExports = WebAssembly.Instance & {
+    exports: WasmExports;
+};
+export type RequestEnvelope = {
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+    body?: string | null;
+};
+export type ResponseEnvelope = {
+    status: number;
+    headers: Record<string, string>;
+    body: unknown;
+};
+export type RuntimeOptions<Env = unknown> = {
+    wasm: WebAssembly.Module;
+    debug?: boolean;
+    onLog?: (message: string) => void;
+    env?: Env;
+};
+export type RequestScopedContext<Env = unknown> = {
+    request: Request;
+    env: Env;
+    ctx: WorkerExecutionContext;
+};
+export type RuntimeState<Env = unknown> = {
+    instance: WasmInstanceWithExports | null;
+    options: RuntimeOptions<Env>;
+    requestContext: RequestScopedContext<Env> | null;
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/worker.d.ts

@@ -0,0 +1,4 @@
+import type { RuntimeOptions, WorkerExecutionContext } from "./types";
+export declare function createAresWorkerHandler<Env = unknown>(wasm: WebAssembly.Module, options?: Omit<RuntimeOptions<Env>, "wasm">): {
+    fetch(request: Request, env: Env, ctx: WorkerExecutionContext): Promise<Response>;
+};

package/dist/worker.js

@@ -0,0 +1,12 @@
+import { AresWorkerRuntime } from "./runtime";
+export function createAresWorkerHandler(wasm, options) {
+    const runtime = new AresWorkerRuntime({
+        wasm,
+        ...options
+    });
+    return {
+        async fetch(request, env, ctx) {
+            return runtime.handleFetch(request, env, ctx);
+        }
+    };
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@aresdefencelabs/wasm-http-runtime",
+  "version": "0.0.1",
+  "description": "Runtime adapter that connects C++ WebAssembly workers to the Cloudflare Workers runtime via an ABI bridge.",
+  "type": "module",
+  "private": false,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Ares-Defence-Labs/wasm-workers-http.git"
+  },
+
+  "homepage": "https://github.com/Ares-Defence-Labs/wasm-workers-http",
+
+  "bugs": {
+    "url": "https://github.com/Ares-Defence-Labs/wasm-workers-http/issues"
+  },
+
+  "author": "Ares Defence Labs",
+  "license": "MIT",
+
+  "keywords": [
+    "cloudflare",
+    "cloudflare-workers",
+    "webassembly",
+    "wasm",
+    "cpp",
+    "wasm-runtime",
+    "workers-runtime",
+    "http-client",
+    "serverless",
+    "edge"
+  ],
+
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": ["dist"]
+}