@aresdefencelabs/wasm-http-runtime 0.0.3 → 0.0.5

package/dist/abi.d.ts

@@ -1,6 +1,8 @@
 import type { RuntimeState } from "./types";
 export declare function createAresAbiImports<Env>(state: RuntimeState<Env>): {
     env: {
+        alloc(size: number): number;
+        free_mem(ptr: number, size: number): void;
         abi_log(messagePtr: number): void;
         abi_http_get_user_agent_name(): number;
         abi_http_fetch_blocking(requestJsonCstrPtr: number): Promise<number>;

package/dist/abi.js

@@ -1,4 +1,5 @@
 import { encodeUtf8, readCString, utf8ByteLength, writeBytesIntoMemory, writeCString } from "./memory";
+import { getAllocOrThrow, getFreeOrThrow, getMemoryOrThrow } from "./runtime";
 function getInstanceOrThrow(state) {
     if (!state.instance) {
         throw new Error("Wasm instance has not been initialised yet.");
@@ -65,9 +66,20 @@ function getResponseByIdOrEmpty(state, responseId) {
 export function createAresAbiImports(state) {
     return {
         env: {
+            alloc(size) {
+                const instance = getInstanceOrThrow(state);
+                const alloc = getAllocOrThrow(instance);
+                return alloc(size) >>> 0;
+            },
+            free_mem(ptr, size) {
+                const instance = getInstanceOrThrow(state);
+                const free = getFreeOrThrow(instance);
+                free(ptr >>> 0, size >>> 0);
+            },
             abi_log(messagePtr) {
                 const instance = getInstanceOrThrow(state);
-                const message = readCString(instance.exports.memory, messagePtr);
+                const memory = getMemoryOrThrow(instance);
+                const message = readCString(memory, messagePtr);
                 if (state.options.onLog) {
                     state.options.onLog(message);
                 }
@@ -79,11 +91,14 @@ export function createAresAbiImports(state) {
                 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);
+                const memory = getMemoryOrThrow(instance);
+                const alloc = getAllocOrThrow(instance);
+                return writeCString(memory, alloc, userAgent);
             },
             async abi_http_fetch_blocking(requestJsonCstrPtr) {
                 const instance = getInstanceOrThrow(state);
-                const requestJson = readCString(instance.exports.memory, requestJsonCstrPtr);
+                const memory = getMemoryOrThrow(instance);
+                const requestJson = readCString(memory, requestJsonCstrPtr);
                 const outbound = JSON.parse(requestJson);
                 const response = await fetch(outbound.url, {
                     method: outbound.method ?? "GET",
@@ -119,14 +134,16 @@ export function createAresAbiImports(state) {
             },
             abi_http_response_copy_body(responseId, outPtr, maxLen) {
                 const instance = getInstanceOrThrow(state);
+                const memory = getMemoryOrThrow(instance);
                 const bodyText = getResponseByIdOrEmpty(state, responseId).bodyText;
-                return writeBytesIntoMemory(instance.exports.memory, outPtr, encodeUtf8(bodyText), maxLen);
+                return writeBytesIntoMemory(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 memory = getMemoryOrThrow(instance);
+                const key = readCString(memory, keyCstrPtr).toLowerCase();
                 const value = getResponseByIdOrEmpty(state, responseId).headers[key] ?? "";
-                return writeBytesIntoMemory(instance.exports.memory, outPtr, encodeUtf8(value), maxLen);
+                return writeBytesIntoMemory(memory, outPtr, encodeUtf8(value), maxLen);
             },
             abi_http_response_free(responseId) {
                 state.httpResponses.delete(responseId);

package/dist/memory.js

@@ -26,11 +26,14 @@ export function readCString(memory, ptr, maxLen = 10_000_000) {
 }
 export function writeCString(memory, alloc, value) {
     const encoded = encoder.encode(value);
-    const ptr = alloc(encoded.length + 1);
+    const ptr = alloc(encoded.length + 1) >>> 0;
     if (!ptr) {
         throw new Error(`alloc failed for ${encoded.length + 1} bytes`);
     }
     const bytes = new Uint8Array(memory.buffer);
+    if (ptr + encoded.length + 1 > bytes.length) {
+        throw new Error("Allocated CString buffer exceeds wasm memory bounds");
+    }
     bytes.set(encoded, ptr);
     bytes[ptr + encoded.length] = 0;
     return ptr >>> 0;

package/dist/runtime.d.ts

@@ -10,3 +10,12 @@ export declare class AresWorkerRuntime<Env = unknown> {
     private jsonErrorResponse;
     handleFetch(request: Request, env: Env, ctx: WorkerExecutionContext): Promise<Response>;
 }
+export declare function getMemoryOrThrow(instance: WebAssembly.Instance & {
+    exports: Record<string, unknown>;
+}): WebAssembly.Memory;
+export declare function getAllocOrThrow(instance: WebAssembly.Instance & {
+    exports: Record<string, unknown>;
+}): (size: number) => number;
+export declare function getFreeOrThrow(instance: WebAssembly.Instance & {
+    exports: Record<string, unknown>;
+}): (ptr: number, size?: number) => void;

package/dist/runtime.js

@@ -1,8 +1,8 @@
 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_MAX_TOTAL_BRIDGE_BYTES = 8 * 1024 * 1024;
+const DEFAULT_MAX_RESPONSE_BODY_BYTES = 512 * 1024;
 const DEFAULT_RESPONSE_TTL_MS = 30_000;
 const NOOP_LOGGER = (_) => { };
 function withDefaults(options) {
@@ -17,6 +17,24 @@ function withDefaults(options) {
         responseTtlMs: options.responseTtlMs ?? DEFAULT_RESPONSE_TTL_MS
     };
 }
+function safeSetU32(memory, ptr, value) {
+    if (!ptr)
+        return;
+    const start = ptr >>> 0;
+    if (start + 4 > memory.buffer.byteLength)
+        return;
+    new DataView(memory.buffer).setUint32(start, value >>> 0, true);
+}
+function safeSetU64Zero(memory, ptr) {
+    if (!ptr)
+        return;
+    const start = ptr >>> 0;
+    if (start + 8 > memory.buffer.byteLength)
+        return;
+    const view = new DataView(memory.buffer);
+    view.setUint32(start, 0, true);
+    view.setUint32(start + 4, 0, true);
+}
 export class AresWorkerRuntime {
     state;
     constructor(options) {
@@ -37,7 +55,48 @@ export class AresWorkerRuntime {
             return this.state.initPromise;
         }
         this.state.initPromise = (async () => {
-            const imports = createAresAbiImports(this.state);
+            const abiImports = createAresAbiImports(this.state);
+            const imports = {
+                env: {
+                    ...abiImports.env,
+                    emscripten_notify_memory_growth: () => { },
+                    emscripten_date_now: () => Date.now(),
+                    emscripten_get_now: () => performance.now(),
+                    abort: (msg, file, line, col) => {
+                        throw new Error(`abort: ${String(msg)} @ ${String(file)}:${String(line)}:${String(col)}`);
+                    }
+                },
+                wasi_snapshot_preview1: {
+                    fd_write: (_fd, _iovs, _iovsLen, nwritten) => {
+                        const memory = this.state.instance
+                            ? getMemoryOrThrow(this.state.instance)
+                            : null;
+                        if (memory) {
+                            safeSetU32(memory, nwritten, 0);
+                        }
+                        return 0;
+                    },
+                    fd_read: (_fd, _iovs, _iovsLen, nread) => {
+                        const memory = this.state.instance
+                            ? getMemoryOrThrow(this.state.instance)
+                            : null;
+                        if (memory) {
+                            safeSetU32(memory, nread, 0);
+                        }
+                        return 0;
+                    },
+                    fd_seek: (_fd, _offsetLow, _offsetHigh, _whence, newOffset) => {
+                        const memory = this.state.instance
+                            ? getMemoryOrThrow(this.state.instance)
+                            : null;
+                        if (memory) {
+                            safeSetU64Zero(memory, newOffset);
+                        }
+                        return 0;
+                    },
+                    fd_close: (_fd) => 0
+                }
+            };
             const instantiated = await WebAssembly.instantiate(this.state.options.wasm, imports);
             const instance = instantiated &&
                 typeof instantiated === "object" &&
@@ -45,12 +104,8 @@ export class AresWorkerRuntime {
                 ? 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.");
-            }
+            getMemoryOrThrow(instance);
+            getAllocOrThrow(instance);
             if (typeof instance.exports.app_init === "function") {
                 const rc = await Promise.resolve(instance.exports.app_init());
                 if (rc !== 0) {
@@ -75,8 +130,12 @@ export class AresWorkerRuntime {
     freeIfNeeded(ptr, size = 0) {
         if (!ptr)
             return;
-        if (typeof this.instance.exports.free_mem === "function") {
-            this.instance.exports.free_mem(ptr, size);
+        try {
+            const free = getFreeOrThrow(this.instance);
+            free(ptr, size);
+        }
+        catch {
+            // ignore cleanup failures
         }
     }
     jsonErrorResponse(message, status = 500) {
@@ -92,12 +151,15 @@ export class AresWorkerRuntime {
     }
     async handleFetch(request, env, ctx) {
         let requestPtr = 0;
+        let requestSize = 0;
         let responsePtr = 0;
         await this.init();
         this.setRequestContext({ request, env, ctx });
         try {
-            if (typeof this.instance.exports.handle_http_json !== "function") {
-                throw new Error("Wasm export handle_http_json() was not found.");
+            const handleHttp = this.instance.exports.handle_http ??
+                this.instance.exports.handle_http_json;
+            if (typeof handleHttp !== "function") {
+                throw new Error("Wasm export handle_http() / handle_http_json() was not found.");
             }
             const requestBody = await request.text();
             const inboundEnvelope = {
@@ -106,17 +168,21 @@ export class AresWorkerRuntime {
                 headers: headersToObject(request.headers),
                 body: requestBody
             };
-            requestPtr = writeJsonCString(this.instance.exports.memory, this.instance.exports.alloc, inboundEnvelope);
-            const responsePtrOrPromise = this.instance.exports.handle_http_json(requestPtr);
+            const memory = getMemoryOrThrow(this.instance);
+            const alloc = getAllocOrThrow(this.instance);
+            const requestJson = JSON.stringify(inboundEnvelope);
+            requestSize = new TextEncoder().encode(requestJson).length + 1;
+            requestPtr = writeJsonCString(memory, alloc, inboundEnvelope);
+            const responsePtrOrPromise = handleHttp(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 responseJson = readCString(memory, responsePtr);
             const responseEnvelope = JSON.parse(responseJson);
             return new Response(typeof responseEnvelope.body === "string"
                 ? responseEnvelope.body
-                : JSON.stringify(responseEnvelope.body), {
+                : JSON.stringify(responseEnvelope.body ?? ""), {
                 status: responseEnvelope.status || 200,
                 headers: responseEnvelope.headers || {
                     "content-type": "application/json; charset=utf-8"
@@ -128,9 +194,41 @@ export class AresWorkerRuntime {
             return this.jsonErrorResponse(message);
         }
         finally {
-            this.freeIfNeeded(requestPtr);
+            this.freeIfNeeded(requestPtr, requestSize);
             this.freeIfNeeded(responsePtr);
             this.clearRequestContext();
         }
     }
 }
+export function getMemoryOrThrow(instance) {
+    const memory = instance.exports.memory;
+    if (!(memory instanceof WebAssembly.Memory)) {
+        throw new Error("Wasm module does not export memory");
+    }
+    return memory;
+}
+export function getAllocOrThrow(instance) {
+    const candidates = [
+        instance.exports.alloc,
+        instance.exports._alloc,
+        instance.exports.malloc,
+        instance.exports._malloc
+    ];
+    for (const fn of candidates) {
+        if (typeof fn === "function") {
+            return fn;
+        }
+    }
+    throw new Error("Wasm module does not export an allocator (alloc/_alloc/malloc/_malloc)");
+}
+export function getFreeOrThrow(instance) {
+    const freeMem = instance.exports.free_mem ?? instance.exports._free_mem;
+    if (typeof freeMem === "function") {
+        return freeMem;
+    }
+    const free = instance.exports.free ?? instance.exports._free;
+    if (typeof free === "function") {
+        return free;
+    }
+    throw new Error("Wasm module does not export a deallocator (free_mem/_free_mem/free/_free)");
+}

package/dist/types.d.ts

@@ -4,9 +4,16 @@ export interface WorkerExecutionContext {
 }
 export type WasmExports = {
     memory: WebAssembly.Memory;
-    alloc: (size: number) => number;
+    alloc?: (size: number) => number;
+    _alloc?: (size: number) => number;
+    malloc?: (size: number) => number;
+    _malloc?: (size: number) => number;
     free_mem?: (ptr: number, size: number) => void;
+    _free_mem?: (ptr: number, size: number) => void;
+    free?: (ptr: number) => void;
+    _free?: (ptr: number) => void;
     app_init?: () => number | Promise<number>;
+    handle_http?: (requestJsonPtr: number) => number | Promise<number>;
     handle_http_json?: (requestJsonPtr: number) => number | Promise<number>;
 };
 export type WasmInstanceWithExports = WebAssembly.Instance & {

package/package.json

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