@aresdefencelabs/wasm-http-runtime 0.1.2 → 0.1.4

package/dist/abi.d.ts

@@ -9,7 +9,7 @@ export declare function createAresAbiImports<Env>(state: RuntimeState<Env>): {
         free_mem(ptr: number, size: number): void;
         abi_log(messagePtr: number): void;
         abi_http_get_user_agent_name(): number;
-        abi_http_fetch_blocking_async: (requestJsonCstrPtr: number) => Promise<number>;
+        abi_http_fetch_blocking_async(requestJsonCstrPtr: number): 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;

package/dist/abi.js

@@ -101,46 +101,52 @@ export function createAresAbiImports(state) {
                 const alloc = getAllocOrThrow(instance);
                 return writeCString(memory, alloc, userAgent);
             },
-            abi_http_fetch_blocking_async: async (requestJsonCstrPtr) => {
-                const instance = getInstanceOrThrow(state);
-                const memory = getMemoryOrThrow(instance);
-                try {
-                    const requestJson = readCString(memory, requestJsonCstrPtr);
-                    const outbound = JSON.parse(requestJson);
-                    if (state.options.debug) {
-                        console.log("[AresWasm] abi_http_fetch_blocking outbound =", outbound);
+            abi_http_fetch_blocking_async(requestJsonCstrPtr) {
+                const Asyncify = globalThis.Asyncify;
+                if (!Asyncify?.handleAsync) {
+                    throw new Error("Asyncify.handleAsync is not available in this runtime");
+                }
+                return Asyncify.handleAsync(async () => {
+                    const instance = getInstanceOrThrow(state);
+                    const memory = getMemoryOrThrow(instance);
+                    try {
+                        const requestJson = readCString(memory, requestJsonCstrPtr);
+                        const outbound = JSON.parse(requestJson);
+                        if (state.options.debug) {
+                            console.log("[AresWasm] abi_http_fetch_blocking outbound =", outbound);
+                        }
+                        const response = await fetch(outbound.url, {
+                            method: outbound.method ?? "GET",
+                            headers: outbound.headers,
+                            body: outbound.body ?? undefined
+                        });
+                        console.log("[AresWasm] abi_http_fetch_blocking fetch completed, status =", response.status);
+                        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;
                     }
-                    const response = await fetch(outbound.url, {
-                        method: outbound.method ?? "GET",
-                        headers: outbound.headers,
-                        body: outbound.body ?? undefined
-                    });
-                    console.log("[AresWasm] abi_http_fetch_blocking fetch completed, status =", response.status);
-                    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}`);
+                    catch (error) {
+                        console.error("[AresWasm] abi_http_fetch_blocking failed:", error);
+                        return 0;
                     }
-                    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;
-                }
-                catch (error) {
-                    console.error("[AresWasm] abi_http_fetch_blocking failed:", error);
-                    return 0;
-                }
+                });
             },
             abi_http_response_get_status(responseId) {
                 return getResponseByIdOrEmpty(state, responseId).status >>> 0;

package/emscripten/ares_abi_library.js

@@ -0,0 +1,59 @@
+addToLibrary({
+    abi_log__deps: ['$UTF8ToString'],
+    abi_log: function (messagePtr) {
+        if (typeof Module.__aresAbiLog !== 'function') {
+            throw new Error('Module.__aresAbiLog is not set');
+        }
+        Module.__aresAbiLog(messagePtr);
+    },
+
+    abi_http_get_user_agent_name: function () {
+        if (typeof Module.__aresAbiHttpGetUserAgentName !== 'function') {
+            throw new Error('Module.__aresAbiHttpGetUserAgentName is not set');
+        }
+        return Module.__aresAbiHttpGetUserAgentName() >>> 0;
+    },
+
+    abi_http_response_get_status: function (responseId) {
+        if (typeof Module.__aresAbiHttpResponseGetStatus !== 'function') {
+            throw new Error('Module.__aresAbiHttpResponseGetStatus is not set');
+        }
+        return Module.__aresAbiHttpResponseGetStatus(responseId) >>> 0;
+    },
+
+    abi_http_response_get_body_len: function (responseId) {
+        if (typeof Module.__aresAbiHttpResponseGetBodyLen !== 'function') {
+            throw new Error('Module.__aresAbiHttpResponseGetBodyLen is not set');
+        }
+        return Module.__aresAbiHttpResponseGetBodyLen(responseId) >>> 0;
+    },
+
+    abi_http_response_copy_body: function (responseId, outPtr, maxLen) {
+        if (typeof Module.__aresAbiHttpResponseCopyBody !== 'function') {
+            throw new Error('Module.__aresAbiHttpResponseCopyBody is not set');
+        }
+        return Module.__aresAbiHttpResponseCopyBody(responseId, outPtr, maxLen) >>> 0;
+    },
+
+    abi_http_response_copy_header: function (responseId, keyPtr, outPtr, maxLen) {
+        if (typeof Module.__aresAbiHttpResponseCopyHeader !== 'function') {
+            throw new Error('Module.__aresAbiHttpResponseCopyHeader is not set');
+        }
+        return Module.__aresAbiHttpResponseCopyHeader(responseId, keyPtr, outPtr, maxLen) >>> 0;
+    },
+
+    abi_http_response_free: function (responseId) {
+        if (typeof Module.__aresAbiHttpResponseFree !== 'function') {
+            throw new Error('Module.__aresAbiHttpResponseFree is not set');
+        }
+        Module.__aresAbiHttpResponseFree(responseId);
+    },
+
+    abi_http_fetch_blocking_async__async: 'auto',
+    abi_http_fetch_blocking_async: async function (requestJsonCstrPtr) {
+        if (typeof Module.__aresAbiHttpFetchBlockingAsync !== 'function') {
+            throw new Error('Module.__aresAbiHttpFetchBlockingAsync is not set');
+        }
+        return (await Module.__aresAbiHttpFetchBlockingAsync(requestJsonCstrPtr)) >>> 0;
+    },
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aresdefencelabs/wasm-http-runtime",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Runtime adapter that connects C++ WebAssembly workers to the Cloudflare Workers runtime via an ABI bridge.",
   "type": "module",
   "private": false,
@@ -36,5 +36,5 @@
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "files": ["dist"]
+  "files": ["dist", "emscripten"]
 }