edict-lang 1.2.0 → 1.5.0

package/dist/codegen/host-functions.js

@@ -0,0 +1,680 @@
+// =============================================================================
+// Host Function Imports — WASM ↔ Host bridge for Edict runtime
+// =============================================================================
+// All host functions that WASM modules import are defined here.
+// The runner calls `createHostImports()` and passes the result as the
+// import object to `WebAssembly.instantiate()`.
+//
+// Platform-agnostic groups (string, math, array, etc.) use Web Standard APIs.
+// Platform-specific groups (crypto, HTTP, IO) delegate to an EdictHostAdapter.
+import { NodeHostAdapter } from "./node-host-adapter.js";
+/** Typed error thrown when a host-side heap allocation exceeds WASM memory bounds. */
+export class EdictOomError extends Error {
+    heapUsed;
+    heapLimit;
+    constructor(heapUsed, heapLimit) {
+        super("edict_oom: heap exhausted");
+        this.heapUsed = heapUsed;
+        this.heapLimit = heapLimit;
+    }
+}
+// =============================================================================
+// Memory helpers
+// =============================================================================
+function getMemoryBuffer(state) {
+    return state.instance.exports.memory.buffer;
+}
+/**
+ * Centralized heap allocator with bounds checking.
+ * Allocates `size` bytes (8-byte aligned) from the bump allocator,
+ * throwing EdictOomError if the allocation would exceed WASM memory.
+ */
+function allocateHeap(state, size) {
+    const getHeapPtr = state.instance.exports.__get_heap_ptr;
+    const setHeapPtr = state.instance.exports.__set_heap_ptr;
+    const ptr = getHeapPtr();
+    const aligned = Math.ceil(size / 8) * 8;
+    const newPtr = ptr + aligned;
+    const memorySize = getMemoryBuffer(state).byteLength;
+    if (newPtr > memorySize) {
+        throw new EdictOomError(ptr, memorySize);
+    }
+    setHeapPtr(newPtr);
+    return ptr;
+}
+/**
+ * Write a string result into WASM memory at __heap_ptr,
+ * advance __heap_ptr (8-byte aligned), set __str_ret_len, and return ptr.
+ */
+function writeStringResult(state, str, encoder) {
+    const encoded = encoder.encode(str);
+    const resultPtr = allocateHeap(state, encoded.length);
+    const dest = new Uint8Array(getMemoryBuffer(state), resultPtr, encoded.length);
+    dest.set(encoded);
+    const setStrRetLen = state.instance.exports.__set_str_ret_len;
+    setStrRetLen(encoded.length);
+    return resultPtr;
+}
+/**
+ * Allocate a new array on the WASM heap: [length: i32][elem0: i32]...
+ * Advances __heap_ptr (8-byte aligned) and returns the new array pointer.
+ */
+function writeArrayResult(state, elements) {
+    const totalSize = 4 + elements.length * 4; // header + elements
+    const resultPtr = allocateHeap(state, totalSize);
+    const view = new DataView(getMemoryBuffer(state));
+    view.setInt32(resultPtr, elements.length, true); // write length
+    for (let i = 0; i < elements.length; i++) {
+        view.setInt32(resultPtr + 4 + i * 4, elements[i], true);
+    }
+    return resultPtr;
+}
+/**
+ * Allocate a Result value on the WASM heap: [tag: i32][pad(4)][value: i32][pad(4)]
+ * tag=0 means Ok, tag=1 means Err. Total size = 16 bytes (matches enum layout).
+ * Returns the pointer to the Result pair.
+ */
+function writeResultValue(state, tag, value) {
+    const ptr = allocateHeap(state, 16);
+    const view = new DataView(getMemoryBuffer(state));
+    view.setInt32(ptr, tag, true); // tag at offset 0
+    view.setInt32(ptr + 8, value, true); // value at offset 8 (matches EnumVariantLayout)
+    return ptr;
+}
+// =============================================================================
+// Core host functions (print, string_replace)
+// =============================================================================
+function createCoreImports(state) {
+    return {
+        print: (ptr, len) => {
+            const bytes = new Uint8Array(getMemoryBuffer(state), ptr, len);
+            const text = new TextDecoder().decode(bytes);
+            state.outputParts.push(text);
+            return ptr;
+        },
+        string_replace: (hayPtr, hayLen, needlePtr, needleLen, replPtr, replLen) => {
+            const memoryBuffer = getMemoryBuffer(state);
+            const decoder = new TextDecoder();
+            const encoder = new TextEncoder();
+            const haystack = decoder.decode(new Uint8Array(memoryBuffer, hayPtr, hayLen));
+            const needle = decoder.decode(new Uint8Array(memoryBuffer, needlePtr, needleLen));
+            const replacement = decoder.decode(new Uint8Array(memoryBuffer, replPtr, replLen));
+            return writeStringResult(state, haystack.replaceAll(needle, replacement), encoder);
+        },
+    };
+}
+// =============================================================================
+// String builtins
+// =============================================================================
+function createStringImports(state) {
+    return {
+        string_length: (ptr, len) => {
+            const str = new TextDecoder().decode(new Uint8Array(getMemoryBuffer(state), ptr, len));
+            return str.length;
+        },
+        substring: (ptr, len, start, end) => {
+            const str = new TextDecoder().decode(new Uint8Array(getMemoryBuffer(state), ptr, len));
+            return writeStringResult(state, str.substring(start, end), new TextEncoder());
+        },
+        string_concat: (aPtr, aLen, bPtr, bLen) => {
+            const decoder = new TextDecoder();
+            const buf = getMemoryBuffer(state);
+            const a = decoder.decode(new Uint8Array(buf, aPtr, aLen));
+            const b = decoder.decode(new Uint8Array(buf, bPtr, bLen));
+            return writeStringResult(state, a + b, new TextEncoder());
+        },
+        string_indexOf: (hayPtr, hayLen, needlePtr, needleLen) => {
+            const decoder = new TextDecoder();
+            const buf = getMemoryBuffer(state);
+            const haystack = decoder.decode(new Uint8Array(buf, hayPtr, hayLen));
+            const needle = decoder.decode(new Uint8Array(buf, needlePtr, needleLen));
+            return haystack.indexOf(needle);
+        },
+        toUpperCase: (ptr, len) => {
+            const str = new TextDecoder().decode(new Uint8Array(getMemoryBuffer(state), ptr, len));
+            return writeStringResult(state, str.toUpperCase(), new TextEncoder());
+        },
+        toLowerCase: (ptr, len) => {
+            const str = new TextDecoder().decode(new Uint8Array(getMemoryBuffer(state), ptr, len));
+            return writeStringResult(state, str.toLowerCase(), new TextEncoder());
+        },
+        string_trim: (ptr, len) => {
+            const str = new TextDecoder().decode(new Uint8Array(getMemoryBuffer(state), ptr, len));
+            return writeStringResult(state, str.trim(), new TextEncoder());
+        },
+        string_startsWith: (strPtr, strLen, prefixPtr, prefixLen) => {
+            const decoder = new TextDecoder();
+            const buf = getMemoryBuffer(state);
+            const str = decoder.decode(new Uint8Array(buf, strPtr, strLen));
+            const prefix = decoder.decode(new Uint8Array(buf, prefixPtr, prefixLen));
+            return str.startsWith(prefix) ? 1 : 0;
+        },
+        string_endsWith: (strPtr, strLen, suffixPtr, suffixLen) => {
+            const decoder = new TextDecoder();
+            const buf = getMemoryBuffer(state);
+            const str = decoder.decode(new Uint8Array(buf, strPtr, strLen));
+            const suffix = decoder.decode(new Uint8Array(buf, suffixPtr, suffixLen));
+            return str.endsWith(suffix) ? 1 : 0;
+        },
+        string_contains: (hayPtr, hayLen, needlePtr, needleLen) => {
+            const decoder = new TextDecoder();
+            const buf = getMemoryBuffer(state);
+            const haystack = decoder.decode(new Uint8Array(buf, hayPtr, hayLen));
+            const needle = decoder.decode(new Uint8Array(buf, needlePtr, needleLen));
+            return haystack.includes(needle) ? 1 : 0;
+        },
+        string_repeat: (ptr, len, count) => {
+            const str = new TextDecoder().decode(new Uint8Array(getMemoryBuffer(state), ptr, len));
+            return writeStringResult(state, str.repeat(count), new TextEncoder());
+        },
+    };
+}
+// =============================================================================
+// Math builtins
+// =============================================================================
+function createMathImports() {
+    return {
+        abs: (x) => Math.abs(x),
+        min: (a, b) => Math.min(a, b),
+        max: (a, b) => Math.max(a, b),
+        pow: (base, exp) => (Math.pow(base, exp) | 0),
+        sqrt: (x) => Math.sqrt(x),
+        floor: (x) => (Math.floor(x) | 0),
+        ceil: (x) => (Math.ceil(x) | 0),
+        round: (x) => (Math.round(x) | 0),
+    };
+}
+// =============================================================================
+// Type conversion builtins
+// =============================================================================
+function createTypeConversionImports(state) {
+    return {
+        intToString: (value) => writeStringResult(state, String(value), new TextEncoder()),
+        floatToString: (value) => writeStringResult(state, String(value), new TextEncoder()),
+        boolToString: (value) => writeStringResult(state, value ? "true" : "false", new TextEncoder()),
+        floatToInt: (value) => (Math.trunc(value) | 0),
+        intToFloat: (value) => value,
+    };
+}
+// =============================================================================
+// Array builtins — operate on [length: i32][elem0: i32][elem1: i32]...
+// =============================================================================
+function createArrayImports(state) {
+    return {
+        array_length: (arrPtr) => {
+            return new DataView(getMemoryBuffer(state)).getInt32(arrPtr, true);
+        },
+        array_get: (arrPtr, index) => {
+            const view = new DataView(getMemoryBuffer(state));
+            const length = view.getInt32(arrPtr, true);
+            if (index < 0 || index >= length)
+                return 0;
+            return view.getInt32(arrPtr + 4 + index * 4, true);
+        },
+        array_set: (arrPtr, index, value) => {
+            const view = new DataView(getMemoryBuffer(state));
+            const length = view.getInt32(arrPtr, true);
+            const elems = [];
+            for (let i = 0; i < length; i++) {
+                elems.push(i === index ? value : view.getInt32(arrPtr + 4 + i * 4, true));
+            }
+            return writeArrayResult(state, elems);
+        },
+        array_push: (arrPtr, value) => {
+            const view = new DataView(getMemoryBuffer(state));
+            const length = view.getInt32(arrPtr, true);
+            const elems = [];
+            for (let i = 0; i < length; i++) {
+                elems.push(view.getInt32(arrPtr + 4 + i * 4, true));
+            }
+            elems.push(value);
+            return writeArrayResult(state, elems);
+        },
+        array_pop: (arrPtr) => {
+            const view = new DataView(getMemoryBuffer(state));
+            const length = view.getInt32(arrPtr, true);
+            if (length === 0)
+                return writeArrayResult(state, []);
+            const elems = [];
+            for (let i = 0; i < length - 1; i++) {
+                elems.push(view.getInt32(arrPtr + 4 + i * 4, true));
+            }
+            return writeArrayResult(state, elems);
+        },
+        array_concat: (aPtr, bPtr) => {
+            const view = new DataView(getMemoryBuffer(state));
+            const aLen = view.getInt32(aPtr, true);
+            const bLen = view.getInt32(bPtr, true);
+            const elems = [];
+            for (let i = 0; i < aLen; i++) {
+                elems.push(view.getInt32(aPtr + 4 + i * 4, true));
+            }
+            for (let i = 0; i < bLen; i++) {
+                elems.push(view.getInt32(bPtr + 4 + i * 4, true));
+            }
+            return writeArrayResult(state, elems);
+        },
+        array_slice: (arrPtr, start, end) => {
+            const view = new DataView(getMemoryBuffer(state));
+            const length = view.getInt32(arrPtr, true);
+            const s = Math.max(0, Math.min(start, length));
+            const e = Math.max(s, Math.min(end, length));
+            const elems = [];
+            for (let i = s; i < e; i++) {
+                elems.push(view.getInt32(arrPtr + 4 + i * 4, true));
+            }
+            return writeArrayResult(state, elems);
+        },
+        array_isEmpty: (arrPtr) => {
+            return new DataView(getMemoryBuffer(state)).getInt32(arrPtr, true) === 0 ? 1 : 0;
+        },
+        array_contains: (arrPtr, value) => {
+            const view = new DataView(getMemoryBuffer(state));
+            const length = view.getInt32(arrPtr, true);
+            for (let i = 0; i < length; i++) {
+                if (view.getInt32(arrPtr + 4 + i * 4, true) === value)
+                    return 1;
+            }
+            return 0;
+        },
+        array_reverse: (arrPtr) => {
+            const view = new DataView(getMemoryBuffer(state));
+            const length = view.getInt32(arrPtr, true);
+            const elems = [];
+            for (let i = length - 1; i >= 0; i--) {
+                elems.push(view.getInt32(arrPtr + 4 + i * 4, true));
+            }
+            return writeArrayResult(state, elems);
+        },
+    };
+}
+// =============================================================================
+// Option builtins — [tag: i32][value: i32] at 8-byte slots
+// =============================================================================
+function createOptionImports(state) {
+    return {
+        isSome: (ptr) => {
+            return new DataView(getMemoryBuffer(state)).getInt32(ptr, true) === 1 ? 1 : 0;
+        },
+        isNone: (ptr) => {
+            return new DataView(getMemoryBuffer(state)).getInt32(ptr, true) === 0 ? 1 : 0;
+        },
+        unwrap: (ptr) => {
+            const view = new DataView(getMemoryBuffer(state));
+            const tag = view.getInt32(ptr, true);
+            if (tag === 1)
+                return view.getInt32(ptr + 8, true);
+            throw new Error("unwrap called on None");
+        },
+        unwrapOr: (ptr, defaultVal) => {
+            const view = new DataView(getMemoryBuffer(state));
+            const tag = view.getInt32(ptr, true);
+            if (tag === 1)
+                return view.getInt32(ptr + 8, true);
+            return defaultVal;
+        },
+    };
+}
+// =============================================================================
+// Result builtins — [tag: i32][value_or_error: i32] at 8-byte slots
+// Ok = tag 0, Err = tag 1
+// =============================================================================
+function createResultImports(state) {
+    return {
+        isOk: (ptr) => {
+            return new DataView(getMemoryBuffer(state)).getInt32(ptr, true) === 0 ? 1 : 0;
+        },
+        isErr: (ptr) => {
+            return new DataView(getMemoryBuffer(state)).getInt32(ptr, true) === 1 ? 1 : 0;
+        },
+        unwrapOk: (ptr) => {
+            const view = new DataView(getMemoryBuffer(state));
+            const tag = view.getInt32(ptr, true);
+            if (tag === 0)
+                return view.getInt32(ptr + 8, true);
+            throw new Error("unwrapOk called on Err");
+        },
+        unwrapErr: (ptr) => {
+            const view = new DataView(getMemoryBuffer(state));
+            const tag = view.getInt32(ptr, true);
+            if (tag === 1)
+                return view.getInt32(ptr + 8, true);
+            throw new Error("unwrapErr called on Ok");
+        },
+        unwrapOkOr: (ptr, defaultVal) => {
+            const view = new DataView(getMemoryBuffer(state));
+            const tag = view.getInt32(ptr, true);
+            if (tag === 0)
+                return view.getInt32(ptr + 8, true);
+            return defaultVal;
+        },
+        unwrapErrOr: (ptr, defaultVal) => {
+            const view = new DataView(getMemoryBuffer(state));
+            const tag = view.getInt32(ptr, true);
+            if (tag === 1)
+                return view.getInt32(ptr + 8, true);
+            return defaultVal;
+        },
+    };
+}
+// =============================================================================
+// JSON builtins — jsonParse validates JSON, jsonStringify normalizes
+// =============================================================================
+function createJsonImports(state) {
+    const encoder = new TextEncoder();
+    const decoder = new TextDecoder();
+    return {
+        jsonParse: (ptr, len) => {
+            const str = decoder.decode(new Uint8Array(getMemoryBuffer(state), ptr, len));
+            try {
+                JSON.parse(str);
+                // Valid JSON — return Ok(strPtr) with original string
+                const strPtr = writeStringResult(state, str, encoder);
+                return writeResultValue(state, 0, strPtr); // Ok
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : "Invalid JSON";
+                const errPtr = writeStringResult(state, msg, encoder);
+                return writeResultValue(state, 1, errPtr); // Err
+            }
+        },
+        jsonStringify: (ptr, len) => {
+            const str = decoder.decode(new Uint8Array(getMemoryBuffer(state), ptr, len));
+            try {
+                const parsed = JSON.parse(str);
+                return writeStringResult(state, JSON.stringify(parsed), encoder);
+            }
+            catch {
+                // If input is not valid JSON, return it unchanged
+                return writeStringResult(state, str, encoder);
+            }
+        },
+    };
+}
+// =============================================================================
+// Random builtins — randomInt, randomFloat, randomUuid
+// =============================================================================
+function createRandomImports(state) {
+    const encoder = new TextEncoder();
+    return {
+        randomInt: (min, max) => {
+            // Inclusive range [min, max] with rejection sampling to avoid modulo bias
+            const range = max - min + 1;
+            const limit = 0x100000000 - (0x100000000 % range); // largest multiple of range ≤ 2^32
+            const array = new Uint32Array(1);
+            let val;
+            do {
+                crypto.getRandomValues(array);
+                val = array[0];
+            } while (val >= limit);
+            return min + (val % range);
+        },
+        randomFloat: () => {
+            const array = new Uint32Array(1);
+            crypto.getRandomValues(array);
+            return array[0] / 0x100000000; // [0, 1) — divide by 2^32
+        },
+        randomUuid: () => {
+            const uuid = crypto.randomUUID();
+            return writeStringResult(state, uuid, encoder);
+        },
+    };
+}
+// =============================================================================
+// Int64 conversion builtins — widen/narrow between Int and Int64
+// =============================================================================
+function createInt64Imports(state) {
+    const encoder = new TextEncoder();
+    return {
+        intToInt64: (x) => BigInt(x),
+        int64ToInt: (x) => Number(BigInt.asIntN(32, x)),
+        int64ToFloat: (x) => Number(x),
+        int64ToString: (x) => writeStringResult(state, x.toString(), encoder),
+    };
+}
+// =============================================================================
+// Date/time builtins — now, formatDate, parseDate, diffMs
+// =============================================================================
+/**
+ * Format a Date using strftime-style tokens.
+ * Supported: %Y (year), %m (month 01-12), %d (day 01-31),
+ *            %H (hour 00-23), %M (min 00-59), %S (sec 00-59), %% (literal %)
+ */
+function formatDateString(date, fmt) {
+    const pad2 = (n) => String(n).padStart(2, "0");
+    let result = "";
+    let i = 0;
+    while (i < fmt.length) {
+        if (fmt[i] === "%" && i + 1 < fmt.length) {
+            const token = fmt[i + 1];
+            switch (token) {
+                case "Y":
+                    result += String(date.getUTCFullYear());
+                    break;
+                case "m":
+                    result += pad2(date.getUTCMonth() + 1);
+                    break;
+                case "d":
+                    result += pad2(date.getUTCDate());
+                    break;
+                case "H":
+                    result += pad2(date.getUTCHours());
+                    break;
+                case "M":
+                    result += pad2(date.getUTCMinutes());
+                    break;
+                case "S":
+                    result += pad2(date.getUTCSeconds());
+                    break;
+                case "%":
+                    result += "%";
+                    break;
+                default:
+                    result += "%" + token;
+                    break; // unknown token → pass through
+            }
+            i += 2;
+        }
+        else {
+            result += fmt[i];
+            i++;
+        }
+    }
+    return result;
+}
+function createDateTimeImports(state) {
+    const encoder = new TextEncoder();
+    const decoder = new TextDecoder();
+    return {
+        now: () => BigInt(Date.now()),
+        formatDate: (timestamp, fmtPtr, fmtLen) => {
+            const fmt = decoder.decode(new Uint8Array(getMemoryBuffer(state), fmtPtr, fmtLen));
+            const date = new Date(Number(timestamp));
+            return writeStringResult(state, formatDateString(date, fmt), encoder);
+        },
+        parseDate: (strPtr, strLen, _fmtPtr, _fmtLen) => {
+            const str = decoder.decode(new Uint8Array(getMemoryBuffer(state), strPtr, strLen));
+            const ms = Date.parse(str);
+            if (isNaN(ms)) {
+                throw new Error(`parseDate: invalid date string "${str}"`);
+            }
+            return BigInt(ms);
+        },
+        diffMs: (a, b) => a - b,
+    };
+}
+// =============================================================================
+// Regex builtins — regexTest, regexMatch, regexReplace
+// =============================================================================
+function createRegexImports(state) {
+    const encoder = new TextEncoder();
+    const decoder = new TextDecoder();
+    return {
+        regexTest: (patPtr, patLen, inputPtr, inputLen) => {
+            const buf = getMemoryBuffer(state);
+            const pattern = decoder.decode(new Uint8Array(buf, patPtr, patLen));
+            const input = decoder.decode(new Uint8Array(buf, inputPtr, inputLen));
+            try {
+                return new RegExp(pattern).test(input) ? 1 : 0;
+            }
+            catch {
+                return 0; // invalid regex → false
+            }
+        },
+        regexMatch: (patPtr, patLen, inputPtr, inputLen) => {
+            const buf = getMemoryBuffer(state);
+            const pattern = decoder.decode(new Uint8Array(buf, patPtr, patLen));
+            const input = decoder.decode(new Uint8Array(buf, inputPtr, inputLen));
+            try {
+                const m = input.match(new RegExp(pattern));
+                return writeStringResult(state, m ? m[0] : "", encoder);
+            }
+            catch {
+                return writeStringResult(state, "", encoder); // invalid regex → empty string
+            }
+        },
+        regexReplace: (inputPtr, inputLen, patPtr, patLen, replPtr, replLen) => {
+            const buf = getMemoryBuffer(state);
+            const input = decoder.decode(new Uint8Array(buf, inputPtr, inputLen));
+            const pattern = decoder.decode(new Uint8Array(buf, patPtr, patLen));
+            const replacement = decoder.decode(new Uint8Array(buf, replPtr, replLen));
+            try {
+                return writeStringResult(state, input.replace(new RegExp(pattern, "g"), replacement), encoder);
+            }
+            catch {
+                return writeStringResult(state, input, encoder); // invalid regex → unchanged
+            }
+        },
+    };
+}
+// =============================================================================
+// Crypto hashing builtins — delegates to adapter
+// =============================================================================
+function createCryptoImports(state, adapter) {
+    const encoder = new TextEncoder();
+    const decoder = new TextDecoder();
+    return {
+        sha256: (ptr, len) => {
+            const str = decoder.decode(new Uint8Array(getMemoryBuffer(state), ptr, len));
+            return writeStringResult(state, adapter.sha256(str), encoder);
+        },
+        md5: (ptr, len) => {
+            const str = decoder.decode(new Uint8Array(getMemoryBuffer(state), ptr, len));
+            return writeStringResult(state, adapter.md5(str), encoder);
+        },
+        hmac: (algoPtr, algoLen, keyPtr, keyLen, dataPtr, dataLen) => {
+            const buf = getMemoryBuffer(state);
+            const algo = decoder.decode(new Uint8Array(buf, algoPtr, algoLen));
+            const key = decoder.decode(new Uint8Array(buf, keyPtr, keyLen));
+            const data = decoder.decode(new Uint8Array(buf, dataPtr, dataLen));
+            return writeStringResult(state, adapter.hmac(algo, key, data), encoder);
+        },
+    };
+}
+// =============================================================================
+// HTTP client builtins — delegates to adapter
+// =============================================================================
+function createHttpImports(state, adapter) {
+    const encoder = new TextEncoder();
+    const decoder = new TextDecoder();
+    function readStr(ptr, len) {
+        return decoder.decode(new Uint8Array(getMemoryBuffer(state), ptr, len));
+    }
+    function makeResult(fetchResult) {
+        const strPtr = writeStringResult(state, fetchResult.data, encoder);
+        return writeResultValue(state, fetchResult.ok ? 0 : 1, strPtr);
+    }
+    return {
+        httpGet: (urlPtr, urlLen) => {
+            return makeResult(adapter.fetch(readStr(urlPtr, urlLen), "GET"));
+        },
+        httpPost: (urlPtr, urlLen, bodyPtr, bodyLen) => {
+            return makeResult(adapter.fetch(readStr(urlPtr, urlLen), "POST", readStr(bodyPtr, bodyLen)));
+        },
+        httpPut: (urlPtr, urlLen, bodyPtr, bodyLen) => {
+            return makeResult(adapter.fetch(readStr(urlPtr, urlLen), "PUT", readStr(bodyPtr, bodyLen)));
+        },
+        httpDelete: (urlPtr, urlLen) => {
+            return makeResult(adapter.fetch(readStr(urlPtr, urlLen), "DELETE"));
+        },
+    };
+}
+// =============================================================================
+// IO builtins — delegates to adapter
+// =============================================================================
+function createIOImports(state, adapter) {
+    const encoder = new TextEncoder();
+    const decoder = new TextDecoder();
+    function readStr(ptr, len) {
+        return decoder.decode(new Uint8Array(getMemoryBuffer(state), ptr, len));
+    }
+    return {
+        readFile: (pathPtr, pathLen) => {
+            const result = adapter.readFile(readStr(pathPtr, pathLen));
+            if (result.ok) {
+                const strPtr = writeStringResult(state, result.data, encoder);
+                return writeResultValue(state, 0, strPtr);
+            }
+            else {
+                const errPtr = writeStringResult(state, result.error, encoder);
+                return writeResultValue(state, 1, errPtr);
+            }
+        },
+        writeFile: (pathPtr, pathLen, contentPtr, contentLen) => {
+            const result = adapter.writeFile(readStr(pathPtr, pathLen), readStr(contentPtr, contentLen));
+            if (result.ok) {
+                const okPtr = writeStringResult(state, "ok", encoder);
+                return writeResultValue(state, 0, okPtr);
+            }
+            else {
+                const errPtr = writeStringResult(state, result.error, encoder);
+                return writeResultValue(state, 1, errPtr);
+            }
+        },
+        env: (namePtr, nameLen) => {
+            const name = readStr(namePtr, nameLen);
+            return writeStringResult(state, adapter.env(name), encoder);
+        },
+        args: () => {
+            const argsJson = JSON.stringify(adapter.args());
+            return writeStringResult(state, argsJson, encoder);
+        },
+        exit: (code) => {
+            adapter.exit(code);
+        },
+    };
+}
+// =============================================================================
+// Factory — combines all groups into one import object
+// =============================================================================
+/**
+ * Create the complete host import object for WASM instantiation.
+ *
+ * @param state — mutable runtime state shared across all host functions.
+ *                `state.instance` must be set after `WebAssembly.instantiate()`
+ *                but before calling any exported WASM function.
+ * @param adapter — optional platform-specific adapter. Defaults to NodeHostAdapter.
+ */
+export function createHostImports(state, adapter) {
+    const hostAdapter = adapter ?? new NodeHostAdapter(state.sandboxDir);
+    return {
+        host: {
+            ...createCoreImports(state),
+            ...createStringImports(state),
+            ...createMathImports(),
+            ...createTypeConversionImports(state),
+            ...createInt64Imports(state),
+            ...createArrayImports(state),
+            ...createOptionImports(state),
+            ...createResultImports(state),
+            ...createJsonImports(state),
+            ...createRandomImports(state),
+            ...createDateTimeImports(state),
+            ...createRegexImports(state),
+            ...createCryptoImports(state, hostAdapter),
+            ...createHttpImports(state, hostAdapter),
+            ...createIOImports(state, hostAdapter),
+        },
+    };
+}
+//# sourceMappingURL=host-functions.js.map