@aresdefencelabs/wasm-http-runtime 0.0.1 → 0.0.3

package/dist/abi.d.ts

@@ -1,7 +1,13 @@
 import type { RuntimeState } from "./types";
 export declare function createAresAbiImports<Env>(state: RuntimeState<Env>): {
-    ares_abi: {
+    env: {
         abi_log(messagePtr: number): void;
         abi_http_get_user_agent_name(): number;
+        abi_http_fetch_blocking(requestJsonCstrPtr: number): Promise<number>;
+        abi_http_response_get_status(responseId: number): number;
+        abi_http_response_get_body_len(responseId: number): number;
+        abi_http_response_copy_body(responseId: number, outPtr: number, maxLen: number): number;
+        abi_http_response_copy_header(responseId: number, keyCstrPtr: number, outPtr: number, maxLen: number): number;
+        abi_http_response_free(responseId: number): void;
     };
 };

package/dist/abi.js

@@ -1,4 +1,4 @@
-import { readCString, writeCString } from "./memory";
+import { encodeUtf8, readCString, utf8ByteLength, writeBytesIntoMemory, writeCString } from "./memory";
 function getInstanceOrThrow(state) {
     if (!state.instance) {
         throw new Error("Wasm instance has not been initialised yet.");
@@ -11,9 +11,60 @@ function getRequestContextOrThrow(state) {
     }
     return state.requestContext;
 }
+function normalizeHeaders(headers) {
+    const out = {};
+    for (const [key, value] of headers.entries()) {
+        out[key.toLowerCase()] = value;
+    }
+    return out;
+}
+function estimateResponseBytes(resp) {
+    let total = utf8ByteLength(resp.bodyText);
+    for (const [k, v] of Object.entries(resp.headers)) {
+        total += utf8ByteLength(k);
+        total += utf8ByteLength(v);
+    }
+    return total >>> 0;
+}
+function sweepExpiredResponses(state) {
+    const now = Date.now();
+    const ttl = state.options.responseTtlMs;
+    for (const [id, entry] of state.httpResponses.entries()) {
+        if (now - entry.createdAtMs > ttl) {
+            state.httpResponses.delete(id);
+        }
+    }
+}
+function getCurrentBridgeBytes(state) {
+    let total = 0;
+    for (const entry of state.httpResponses.values()) {
+        total += entry.estimatedBytes;
+    }
+    return total >>> 0;
+}
+function assertBridgeCapacity(state, nextEntryBytes) {
+    sweepExpiredResponses(state);
+    if (state.httpResponses.size >= state.options.maxHttpResponseHandles) {
+        throw new Error("Too many outstanding HTTP response handles");
+    }
+    const totalAfterInsert = getCurrentBridgeBytes(state) + nextEntryBytes;
+    if (totalAfterInsert > state.options.maxTotalBridgeBytes) {
+        throw new Error("HTTP response bridge memory budget exceeded");
+    }
+}
+function getResponseByIdOrEmpty(state, responseId) {
+    sweepExpiredResponses(state);
+    return (state.httpResponses.get(responseId) ?? {
+        status: 0,
+        bodyText: "",
+        headers: {},
+        createdAtMs: 0,
+        estimatedBytes: 0
+    });
+}
 export function createAresAbiImports(state) {
     return {
-        ares_abi: {
+        env: {
             abi_log(messagePtr) {
                 const instance = getInstanceOrThrow(state);
                 const message = readCString(instance.exports.memory, messagePtr);
@@ -29,6 +80,56 @@ export function createAresAbiImports(state) {
                 const ctx = getRequestContextOrThrow(state);
                 const userAgent = ctx.request.headers.get("user-agent") ?? "Cloudflare-Worker";
                 return writeCString(instance.exports.memory, instance.exports.alloc, userAgent);
+            },
+            async abi_http_fetch_blocking(requestJsonCstrPtr) {
+                const instance = getInstanceOrThrow(state);
+                const requestJson = readCString(instance.exports.memory, requestJsonCstrPtr);
+                const outbound = JSON.parse(requestJson);
+                const response = await fetch(outbound.url, {
+                    method: outbound.method ?? "GET",
+                    headers: outbound.headers,
+                    body: outbound.body ?? undefined
+                });
+                const bodyText = await response.text();
+                const bodyBytes = utf8ByteLength(bodyText);
+                if (bodyBytes > state.options.maxResponseBodyBytes) {
+                    throw new Error(`HTTP response body too large: ${bodyBytes} bytes exceeds maxResponseBodyBytes=${state.options.maxResponseBodyBytes}`);
+                }
+                const headers = normalizeHeaders(response.headers);
+                const estimatedBytes = estimateResponseBytes({
+                    bodyText,
+                    headers
+                });
+                assertBridgeCapacity(state, estimatedBytes);
+                const responseId = state.nextHttpResponseId++;
+                state.httpResponses.set(responseId, {
+                    status: response.status,
+                    bodyText,
+                    headers,
+                    createdAtMs: Date.now(),
+                    estimatedBytes
+                });
+                return responseId >>> 0;
+            },
+            abi_http_response_get_status(responseId) {
+                return getResponseByIdOrEmpty(state, responseId).status >>> 0;
+            },
+            abi_http_response_get_body_len(responseId) {
+                return utf8ByteLength(getResponseByIdOrEmpty(state, responseId).bodyText);
+            },
+            abi_http_response_copy_body(responseId, outPtr, maxLen) {
+                const instance = getInstanceOrThrow(state);
+                const bodyText = getResponseByIdOrEmpty(state, responseId).bodyText;
+                return writeBytesIntoMemory(instance.exports.memory, outPtr, encodeUtf8(bodyText), maxLen);
+            },
+            abi_http_response_copy_header(responseId, keyCstrPtr, outPtr, maxLen) {
+                const instance = getInstanceOrThrow(state);
+                const key = readCString(instance.exports.memory, keyCstrPtr).toLowerCase();
+                const value = getResponseByIdOrEmpty(state, responseId).headers[key] ?? "";
+                return writeBytesIntoMemory(instance.exports.memory, outPtr, encodeUtf8(value), maxLen);
+            },
+            abi_http_response_free(responseId) {
+                state.httpResponses.delete(responseId);
             }
         }
     };

package/dist/memory.d.ts

@@ -1,4 +1,7 @@
-export declare function readCString(memory: WebAssembly.Memory, ptr: number): string;
+export declare function encodeUtf8(value: string): Uint8Array;
+export declare function utf8ByteLength(value: string): number;
+export declare function readCString(memory: WebAssembly.Memory, ptr: number, maxLen?: 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 writeBytesIntoMemory(memory: WebAssembly.Memory, outPtr: number, src: Uint8Array, maxLen: number): number;
 export declare function headersToObject(headers: Headers): Record<string, string>;

package/dist/memory.js

@@ -1,24 +1,58 @@
 const encoder = new TextEncoder();
 const decoder = new TextDecoder();
-export function readCString(memory, ptr) {
+export function encodeUtf8(value) {
+    return encoder.encode(value);
+}
+export function utf8ByteLength(value) {
+    return encoder.encode(value).length >>> 0;
+}
+export function readCString(memory, ptr, maxLen = 10_000_000) {
+    if (!ptr)
+        return "";
     const bytes = new Uint8Array(memory.buffer);
-    let end = ptr;
-    while (bytes[end] !== 0) {
+    const start = ptr >>> 0;
+    if (start >= bytes.length) {
+        throw new Error(`CString pointer out of bounds: ${ptr}`);
+    }
+    let end = start;
+    const limit = Math.min(bytes.length, start + maxLen);
+    while (end < limit && bytes[end] !== 0) {
         end++;
     }
-    return decoder.decode(bytes.subarray(ptr, end));
+    if (end >= limit) {
+        throw new Error("CString terminator not found within safe bounds");
+    }
+    return decoder.decode(bytes.subarray(start, end));
 }
 export function writeCString(memory, alloc, value) {
     const encoded = encoder.encode(value);
     const ptr = alloc(encoded.length + 1);
+    if (!ptr) {
+        throw new Error(`alloc failed for ${encoded.length + 1} bytes`);
+    }
     const bytes = new Uint8Array(memory.buffer);
     bytes.set(encoded, ptr);
     bytes[ptr + encoded.length] = 0;
-    return ptr;
+    return ptr >>> 0;
 }
 export function writeJsonCString(memory, alloc, value) {
     return writeCString(memory, alloc, JSON.stringify(value));
 }
+export function writeBytesIntoMemory(memory, outPtr, src, maxLen) {
+    if (!outPtr || maxLen <= 0)
+        return 0;
+    const bytes = new Uint8Array(memory.buffer);
+    const start = outPtr >>> 0;
+    if (start >= bytes.length) {
+        return 0;
+    }
+    const writeLen = Math.min(src.length, maxLen, bytes.length - start);
+    if (writeLen <= 0) {
+        return 0;
+    }
+    bytes.set(src.subarray(0, writeLen), start);
+    return writeLen >>> 0;
+}
 export function headersToObject(headers) {
     return Object.fromEntries(headers.entries());
 }

package/dist/runtime.d.ts

@@ -6,5 +6,7 @@ export declare class AresWorkerRuntime<Env = unknown> {
     setRequestContext(context: RequestScopedContext<Env>): void;
     clearRequestContext(): void;
     get instance(): WasmInstanceWithExports;
+    private freeIfNeeded;
+    private jsonErrorResponse;
     handleFetch(request: Request, env: Env, ctx: WorkerExecutionContext): Promise<Response>;
 }

package/dist/runtime.js

@@ -1,24 +1,64 @@
 import { createAresAbiImports } from "./abi";
 import { headersToObject, readCString, writeJsonCString } from "./memory";
+const DEFAULT_MAX_HTTP_RESPONSE_HANDLES = 32;
+const DEFAULT_MAX_TOTAL_BRIDGE_BYTES = 8 * 1024 * 1024; // 8 MB total pool
+const DEFAULT_MAX_RESPONSE_BODY_BYTES = 512 * 1024; // 512 KB per response
+const DEFAULT_RESPONSE_TTL_MS = 30_000;
+const NOOP_LOGGER = (_) => { };
+function withDefaults(options) {
+    return {
+        wasm: options.wasm,
+        debug: options.debug ?? false,
+        onLog: options.onLog ?? NOOP_LOGGER,
+        env: options.env,
+        maxHttpResponseHandles: options.maxHttpResponseHandles ?? DEFAULT_MAX_HTTP_RESPONSE_HANDLES,
+        maxTotalBridgeBytes: options.maxTotalBridgeBytes ?? DEFAULT_MAX_TOTAL_BRIDGE_BYTES,
+        maxResponseBodyBytes: options.maxResponseBodyBytes ?? DEFAULT_MAX_RESPONSE_BODY_BYTES,
+        responseTtlMs: options.responseTtlMs ?? DEFAULT_RESPONSE_TTL_MS
+    };
+}
 export class AresWorkerRuntime {
     state;
     constructor(options) {
         this.state = {
             instance: null,
-            options,
-            requestContext: null
+            options: withDefaults(options),
+            requestContext: null,
+            initPromise: null,
+            httpResponses: new Map(),
+            nextHttpResponseId: 1
         };
     }
     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();
+        if (this.state.initPromise) {
+            return this.state.initPromise;
         }
+        this.state.initPromise = (async () => {
+            const imports = createAresAbiImports(this.state);
+            const instantiated = await WebAssembly.instantiate(this.state.options.wasm, imports);
+            const instance = instantiated &&
+                typeof instantiated === "object" &&
+                "instance" in instantiated
+                ? instantiated.instance
+                : instantiated;
+            this.state.instance = instance;
+            if (!(instance.exports.memory instanceof WebAssembly.Memory)) {
+                throw new Error("Wasm export memory was not found.");
+            }
+            if (typeof instance.exports.alloc !== "function") {
+                throw new Error("Wasm export alloc() was not found.");
+            }
+            if (typeof instance.exports.app_init === "function") {
+                const rc = await Promise.resolve(instance.exports.app_init());
+                if (rc !== 0) {
+                    throw new Error(`Wasm app_init() failed with rc=${rc}`);
+                }
+            }
+        })();
+        return this.state.initPromise;
     }
     setRequestContext(context) {
         this.state.requestContext = context;
@@ -32,12 +72,32 @@ export class AresWorkerRuntime {
         }
         return this.state.instance;
     }
+    freeIfNeeded(ptr, size = 0) {
+        if (!ptr)
+            return;
+        if (typeof this.instance.exports.free_mem === "function") {
+            this.instance.exports.free_mem(ptr, size);
+        }
+    }
+    jsonErrorResponse(message, status = 500) {
+        return new Response(JSON.stringify({
+            error: "worker_wasm_failure",
+            message
+        }), {
+            status,
+            headers: {
+                "content-type": "application/json; charset=utf-8"
+            }
+        });
+    }
     async handleFetch(request, env, ctx) {
+        let requestPtr = 0;
+        let responsePtr = 0;
         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.");
+            if (typeof this.instance.exports.handle_http_json !== "function") {
+                throw new Error("Wasm export handle_http_json() was not found.");
             }
             const requestBody = await request.text();
             const inboundEnvelope = {
@@ -46,18 +106,30 @@ export class AresWorkerRuntime {
                 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);
+            requestPtr = writeJsonCString(this.instance.exports.memory, this.instance.exports.alloc, inboundEnvelope);
+            const responsePtrOrPromise = this.instance.exports.handle_http_json(requestPtr);
+            responsePtr = await Promise.resolve(responsePtrOrPromise);
+            if (!responsePtr) {
+                throw new Error("Wasm returned a null response pointer.");
+            }
             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
+                status: responseEnvelope.status || 200,
+                headers: responseEnvelope.headers || {
+                    "content-type": "application/json; charset=utf-8"
+                }
             });
         }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return this.jsonErrorResponse(message);
+        }
         finally {
+            this.freeIfNeeded(requestPtr);
+            this.freeIfNeeded(responsePtr);
             this.clearRequestContext();
         }
     }

package/dist/types.d.ts

@@ -6,8 +6,8 @@ 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;
+    app_init?: () => number | Promise<number>;
+    handle_http_json?: (requestJsonPtr: number) => number | Promise<number>;
 };
 export type WasmInstanceWithExports = WebAssembly.Instance & {
     exports: WasmExports;
@@ -23,11 +23,28 @@ export type ResponseEnvelope = {
     headers: Record<string, string>;
     body: unknown;
 };
+export type OutboundHttpRequestEnvelope = {
+    url: string;
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string | null;
+};
+export type HttpBridgeResponseCache = {
+    status: number;
+    bodyText: string;
+    headers: Record<string, string>;
+    createdAtMs: number;
+    estimatedBytes: number;
+};
 export type RuntimeOptions<Env = unknown> = {
     wasm: WebAssembly.Module;
     debug?: boolean;
     onLog?: (message: string) => void;
     env?: Env;
+    maxHttpResponseHandles?: number;
+    maxTotalBridgeBytes?: number;
+    maxResponseBodyBytes?: number;
+    responseTtlMs?: number;
 };
 export type RequestScopedContext<Env = unknown> = {
     request: Request;
@@ -36,6 +53,9 @@ export type RequestScopedContext<Env = unknown> = {
 };
 export type RuntimeState<Env = unknown> = {
     instance: WasmInstanceWithExports | null;
-    options: RuntimeOptions<Env>;
+    options: Required<Pick<RuntimeOptions<Env>, "wasm" | "debug" | "onLog" | "env" | "maxHttpResponseHandles" | "maxTotalBridgeBytes" | "maxResponseBodyBytes" | "responseTtlMs">>;
     requestContext: RequestScopedContext<Env> | null;
+    initPromise: Promise<void> | null;
+    httpResponses: Map<number, HttpBridgeResponseCache>;
+    nextHttpResponseId: number;
 };

package/dist/worker.js

@@ -4,8 +4,10 @@ export function createAresWorkerHandler(wasm, options) {
         wasm,
         ...options
     });
+    const ready = runtime.init();
     return {
         async fetch(request, env, ctx) {
+            await ready;
             return runtime.handleFetch(request, env, ctx);
         }
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aresdefencelabs/wasm-http-runtime",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Runtime adapter that connects C++ WebAssembly workers to the Cloudflare Workers runtime via an ABI bridge.",
   "type": "module",
   "private": false,