@thi.ng/wasm-api 0.7.0 → 0.10.0

package/bridge.js

@@ -1,7 +1,10 @@
+import { __decorate } from "tslib";
+import { INotifyMixin } from "@thi.ng/api/mixins/inotify";
 import { defError } from "@thi.ng/errors/deferror";
 import { illegalArgs } from "@thi.ng/errors/illegal-arguments";
 import { U16, U32, U64HL, U8 } from "@thi.ng/hex";
 import { ConsoleLogger } from "@thi.ng/logger/console";
+import { EVENT_MEMORY_CHANGED, } from "./api.js";
 const B32 = BigInt(32);
 export const OutOfMemoryError = defError(() => "Out of memory");
 /**
@@ -20,7 +23,7 @@ export const OutOfMemoryError = defError(() => "Out of memory");
  * 64bit integers are handled via JS `BigInt` and hence require the host env to
  * support it. No polyfill is provided.
  */
-export class WasmBridge {
+let WasmBridge = class WasmBridge {
     constructor(modules = {}, logger = new ConsoleLogger("wasm")) {
         this.modules = modules;
         this.logger = logger;
@@ -55,6 +58,9 @@ export class WasmBridge {
             _printF64Array: logA(this.getF64Array.bind(this)),
             _printStr0: (addr) => this.logger.debug(this.getString(addr, 0)),
             _printStr: (addr, len) => this.logger.debug(this.getString(addr, len)),
+            debug: () => {
+                debugger;
+            },
         };
     }
     /**
@@ -83,24 +89,34 @@ export class WasmBridge {
      * then initializes all declared bridge child API modules. Returns false if
      * any of the module initializations failed.
      *
+     * @remarks
+     * Emits the {@link EVENT_MEMORY_CHANGED} event just before returning (and
+     * AFTER all child API modules have been initialized).
+     *
      * @param exports
      */
     async init(exports) {
         this.exports = exports;
-        this.ensureMemory();
+        this.ensureMemory(false);
         for (let id in this.modules) {
             this.logger.debug(`initializing API module: ${id}`);
             const status = await this.modules[id].init(this);
             if (!status)
                 return false;
         }
+        this.notify({ id: EVENT_MEMORY_CHANGED, value: this.exports.memory });
         return true;
     }
     /**
-     * Called automatically. Initializes and/or updates the various typed WASM
-     * memory views (e.g. after growing the WASM memory).
+     * Called automatically during initialization. Initializes and/or updates
+     * the various typed WASM memory views (e.g. after growing the WASM memory
+     * and the previous buffer becoming detached). Unless `notify` is false,
+     * the {@link EVENT_MEMORY_CHANGED} event will be emitted if the memory
+     * views had to be updated.
+     *
+     * @param notify
      */
-    ensureMemory() {
+    ensureMemory(notify = true) {
         const buf = this.exports.memory.buffer;
         if (this.u8 && this.u8.buffer === buf)
             return;
@@ -114,6 +130,11 @@ export class WasmBridge {
         this.u64 = new BigUint64Array(buf);
         this.f32 = new Float32Array(buf);
         this.f64 = new Float64Array(buf);
+        notify &&
+            this.notify({
+                id: EVENT_MEMORY_CHANGED,
+                value: this.exports.memory,
+            });
     }
     /**
      * Required use for WASM module instantiation to provide JS imports to the
@@ -189,7 +210,7 @@ export class WasmBridge {
         const addr = this.exports._wasm_allocate(numBytes);
         if (!addr)
             throw new OutOfMemoryError(`unable to allocate: ${numBytes}`);
-        this.logger.debug(`allocated ${numBytes} bytes @ 0x${U32(addr)}`);
+        this.logger.debug(`allocated ${numBytes} bytes @ 0x${U32(addr)} .. 0x${U32(addr + numBytes - 1)}`);
         this.ensureMemory();
         clear && this.u8.fill(0, addr, addr + numBytes);
         return addr;
@@ -200,6 +221,10 @@ export class WasmBridge {
      * `numBytes` value must be the same as previously given to
      * {@link WasmBridge.allocate}.
      *
+     * @remarks
+     * This function always succeeds, regardless of presence of an active
+     * allocator on the WASM side or validity of given arguments.
+     *
      * @param addr
      * @param numBytes
      */
@@ -370,7 +395,8 @@ export class WasmBridge {
     /**
      * Encodes given string as UTF-8 and writes it to WASM memory starting at
      * `addr`. By default the string will be zero-terminated and only `maxBytes`
-     * will be written. Returns the number of bytes written.
+     * will be written. Returns the number of bytes written (excluding final
+     * sentinel, if any).
      *
      * @remarks
      * An error will be thrown if the encoded string doesn't fully fit into the
@@ -386,11 +412,10 @@ export class WasmBridge {
         maxBytes = Math.min(maxBytes, this.u8.length - addr);
         const len = this.utf8Encoder.encodeInto(str, this.u8.subarray(addr, addr + maxBytes)).written;
         if (len == null || len >= maxBytes + (terminate ? 0 : 1)) {
-            illegalArgs(`error writing string to 0x${U32(addr)}`);
+            illegalArgs(`error writing string to 0x${U32(addr)} (max. ${maxBytes} bytes, got at least ${str.length})`);
         }
         if (terminate) {
             this.u8[addr + len] = 0;
-            return len + 1;
         }
         return len;
     }
@@ -400,4 +425,17 @@ export class WasmBridge {
         el == null && illegalArgs(`missing DOM element #${id}`);
         return el;
     }
-}
+    /** {@inheritDoc @thi.ng/api#INotify.addListener} */
+    // @ts-ignore: mixin
+    addListener(id, fn, scope) { }
+    /** {@inheritDoc @thi.ng/api#INotify.removeListener} */
+    // @ts-ignore: mixin
+    removeListener(id, fn, scope) { }
+    /** {@inheritDoc @thi.ng/api#INotify.notify} */
+    // @ts-ignore: mixin
+    notify(event) { }
+};
+WasmBridge = __decorate([
+    INotifyMixin
+], WasmBridge);
+export { WasmBridge };

package/cli.js

@@ -6,7 +6,7 @@ import { ConsoleLogger } from "@thi.ng/logger";
 import { resolve } from "path";
 import { generateTypes } from "./codegen.js";
 import { TYPESCRIPT } from "./codegen/typescript.js";
-import { isPrim } from "./codegen/utils.js";
+import { isWasmPrim, isWasmString } from "./codegen/utils.js";
 import { ZIG } from "./codegen/zig.js";
 const GENERATORS = { ts: TYPESCRIPT, zig: ZIG };
 const argOpts = {
@@ -72,7 +72,7 @@ const validateTypeRefs = (coll) => {
         if (spec.type !== "struct")
             continue;
         for (let f of spec.fields) {
-            if (!(isPrim(f.type) || coll[f.type])) {
+            if (!(isWasmPrim(f.type) || isWasmString(f.type) || coll[f.type])) {
                 invalidSpec(spec.__path, `structfield ${spec.name}.${f.name} of unknown type: ${f.type}`);
             }
         }

package/codegen/typescript.d.ts

@@ -1,4 +1,7 @@
 import { ICodeGen } from "../api.js";
+/**
+ * TypeScript code generator options.
+ */
 export interface TSOpts {
     /**
      * Indentation string
@@ -8,8 +11,14 @@ export interface TSOpts {
     indent: string;
     /**
      * If true (default), forces uppercase enums
+     *
+     * @defaultValue true
      */
     uppercaseEnums: boolean;
+    /**
+     * Same as {@link CodeGenOpts.stringType}.
+     */
+    stringType: "slice" | "ptr";
 }
 /**
  * TypeScript code generator. Call with options and then pass to

package/codegen/typescript.js

@@ -1,7 +1,7 @@
 import { BIGINT_ARRAY_CTORS, BIT_SHIFTS, TYPEDARRAY_CTORS, } from "@thi.ng/api/typedarray";
 import { isString } from "@thi.ng/checks/is-string";
-import { PKG_NAME, USIZE, } from "../api.js";
-import { isBigNumeric, isNumeric, isPrim, prefixLines } from "./utils.js";
+import { PKG_NAME, USIZE, USIZE_SIZE, } from "../api.js";
+import { isBigNumeric, isNumeric, isWasmPrim, isWasmString, prefixLines, } from "./utils.js";
 /**
  * TypeScript code generator. Call with options and then pass to
  * {@link generateTypes} (see its docs for further usage).
@@ -14,8 +14,9 @@ import { isBigNumeric, isNumeric, isPrim, prefixLines } from "./utils.js";
  * @param opts
  */
 export const TYPESCRIPT = (opts) => {
-    const { indent, uppercaseEnums } = {
+    const { indent, stringType, uppercaseEnums } = {
         indent: "\t",
+        stringType: "slice",
         uppercaseEnums: true,
         ...opts,
     };
@@ -36,7 +37,7 @@ export const TYPESCRIPT = (opts) => {
             const e = type;
             acc.push(`export enum ${e.name} {`);
             for (let v of e.values) {
-                var line = indent;
+                let line = indent;
                 if (!isString(v)) {
                     v.doc && gen.doc(v.doc, indent, acc);
                     line += uppercaseEnums ? v.name.toUpperCase() : v.name;
@@ -83,31 +84,60 @@ export const TYPESCRIPT = (opts) => {
             for (let f of struct.fields) {
                 const offset = f.__offset || 0;
                 acc.push(`${I2}get ${f.name}(): ${returnTypes[f.name]} {`);
-                const prim = isPrim(f.type);
+                const isPrim = isWasmPrim(f.type);
+                const isStr = isWasmString(f.type);
                 if (f.tag === "ptr") {
-                    acc.push(prim
-                        ? `${I3}return mem.${f.type}[${__ptrShift(offset, f.type)}];`
-                        : `${I3}return $${f.type}.instance(${__ptr(offset)});`);
+                    if (isPrim) {
+                        acc.push(`${I3}return mem.${f.type}[${__ptrShift(offset, f.type)}];`);
+                    }
+                    else if (isStr) {
+                        acc.push(
+                        // double deref
+                        stringType === "slice"
+                            ? `${I3}return mem.getString(mem.${USIZE}[${__ptr(offset)} >>> ${USIZE_SIZE}])`
+                            : `${I3}return mem.getString(${__ptr(offset)})`);
+                    }
+                    else {
+                        acc.push(`${I3}return $${f.type}.instance(${__ptr(offset)});`);
+                    }
                 }
                 else if (f.tag === "slice") {
-                    acc.push(`${I3}const len = ${__ptr(offset + 4)};`, prim
-                        ? `${I3}const addr = ${__ptrShift(offset, f.type)};
-${I3}return mem.${f.type}.subarray(addr, addr + len);`
-                        : `${I3}const addr = ${__ptr(offset)};\n${__mapArray(f, I3)}`);
+                    acc.push(`${I3}const len = ${__ptr(offset + 4)};`);
+                    if (isPrim) {
+                        acc.push(`${I3}const addr = ${__ptrShift(offset, f.type)};`, `${I3}return mem.${f.type}.subarray(addr, addr + len);`);
+                    }
+                    else if (isStr) {
+                        acc.push(`${I3}const addr = ${__ptr(offset)};`, __mapStringArray(I3, stringType));
+                    }
+                    else {
+                        acc.push(`${I3}const addr = ${__ptr(offset)};`, __mapArray(f, I3));
+                    }
                 }
                 else if (f.tag === "array" || f.tag === "vec") {
-                    acc.push(prim
-                        ? `${I3}const addr = ${__addrShift(offset, f.type)};
-${I3}return mem.${f.type}.subarray(addr, addr + ${f.len});`
-                        : `${I3}const addr = ${__addr(offset)};\n${__mapArray(f, I3, f.len)}`);
+                    if (isPrim) {
+                        acc.push(`${I3}const addr = ${__addrShift(offset, f.type)};`, `${I3}return mem.${f.type}.subarray(addr, addr + ${f.len});`);
+                    }
+                    else if (isStr) {
+                        acc.push(`${I3}const addr = ${__addr(offset)};`, __mapStringArray(I3, stringType, f.len));
+                    }
+                    else {
+                        acc.push(`${I3}const addr = ${__addr(offset)};`, __mapArray(f, I3, f.len));
+                    }
                 }
                 else {
                     let setter;
-                    if (prim) {
+                    if (isPrim) {
                         const addr = __mem(f.type, f.__offset);
                         acc.push(`${I3}return ${addr};`);
                         setter = `${addr} = x`;
                     }
+                    else if (isStr) {
+                        acc.push(`${I3}return mem.getString(${__ptr(offset)})`);
+                        setter =
+                            stringType === "slice"
+                                ? `mem.setString(x, ${__ptr(offset)}, ${__ptr(offset + 4)} + 1, true);`
+                                : `throw new Error("unsupported for raw string pointers")`;
+                    }
                     else if (types[f.type].type === "enum") {
                         const tag = types[f.type].tag;
                         const addr = __mem(tag, f.__offset);
@@ -151,3 +181,9 @@ const __mapArray = (f, indent, len = "len") => prefixLines(indent, `const inst =
 const slice: ${f.type}[] = [];
 for(let i = 0; i < ${len}; i++) slice.push(inst.instance(addr + i * ${f.__size}));
 return slice;`);
+/** @internal */
+const __mapStringArray = (indent, type, len = "len") => prefixLines(indent, [
+    "const slice: string[] = [];",
+    `for(let i = 0; i < ${len}; i++) slice.push(mem.getString(mem.${USIZE}[(addr + i * ${USIZE_SIZE * (type === "slice" ? 2 : 1)}) >>> ${__shift(USIZE)}]));`,
+    "return slice;",
+]);

package/codegen/utils.d.ts

@@ -17,13 +17,14 @@ export declare const isBigNumeric: (x: string) => x is BigType;
  *
  * @param x
  */
-export declare const isPrim: (x: string) => x is WasmPrim;
+export declare const isWasmPrim: (x: string) => x is WasmPrim;
+export declare const isWasmString: (x: string) => x is "string";
 /**
- * Splits given string into lines, prefixes each with given `prefix` and then
- * returns rejoined result.
+ * Takes an array of strings or splits given string into lines, prefixes each
+ * line with given `prefix` and then returns rejoined result.
  *
  * @param prefix
  * @param str
  */
-export declare const prefixLines: (prefix: string, str: string) => string;
+export declare const prefixLines: (prefix: string, str: string | string[]) => string;
 //# sourceMappingURL=utils.d.ts.map

package/codegen/utils.js

@@ -1,3 +1,4 @@
+import { isString } from "@thi.ng/checks/is-string";
 /**
  * Returns true iff `x` is a {@link WasmPrim32}.
  *
@@ -15,15 +16,15 @@ export const isBigNumeric = (x) => /^[iu]64$/.test(x);
  *
  * @param x
  */
-export const isPrim = (x) => isNumeric(x) || isBigNumeric(x);
+export const isWasmPrim = (x) => isNumeric(x) || isBigNumeric(x);
+export const isWasmString = (x) => x === "string";
 /**
- * Splits given string into lines, prefixes each with given `prefix` and then
- * returns rejoined result.
+ * Takes an array of strings or splits given string into lines, prefixes each
+ * line with given `prefix` and then returns rejoined result.
  *
  * @param prefix
  * @param str
  */
-export const prefixLines = (prefix, str) => str
-    .split("\n")
+export const prefixLines = (prefix, str) => (isString(str) ? str.split("\n") : str)
     .map((line) => prefix + line)
     .join("\n");

package/codegen/zig.d.ts

@@ -1,4 +1,7 @@
 import type { ICodeGen } from "../api.js";
+/**
+ * Zig code generator options.
+ */
 export interface ZigOpts {
     /**
      * If true, generates various struct & struct field analysis functions

package/codegen/zig.js

@@ -39,23 +39,22 @@ export const ZIG = (opts) => {
             const ftypes = {};
             for (let f of struct.fields) {
                 f.doc && gen.doc(f.doc, "    ", acc);
-                var ftype;
+                let ftype = f.type === "string" ? "[]const u8" : f.type;
                 switch (f.tag) {
                     case "array":
-                        ftype = `[${f.len}]${f.type}`;
+                        ftype = `[${f.len}]${ftype}`;
                         break;
                     case "slice":
-                        ftype = `[]${f.type}`;
+                        ftype = `[]${ftype}`;
                         break;
                     case "vec":
-                        ftype = `@Vector(${f.len}, ${f.type})`;
+                        ftype = `@Vector(${f.len}, ${ftype})`;
                         break;
                     case "ptr":
-                        ftype = `*${f.len ? `[${f.len}]` : ""}${f.type}`;
+                        ftype = `*${f.len ? `[${f.len}]` : ""}${ftype}`;
                         break;
                     case "scalar":
                     default:
-                        ftype = f.type;
                 }
                 ftypes[f.name] = ftype;
                 acc.push(`    ${f.name}: ${ftype},`);

package/codegen.d.ts

@@ -1,4 +1,7 @@
 import { ICodeGen, TypeColl } from "./api.js";
+/**
+ * Global/shared code generator options.
+ */
 export interface CodeGenOpts {
     /**
      * Optional string to be injected before generated type defs (but after
@@ -10,7 +13,41 @@ export interface CodeGenOpts {
      * codegen's own epilogue, if any)
      */
     post: string;
+    /**
+     * Identifier how strings are stored on WASM side, e.g. in Zig string
+     * literals are slices (8 bytes), in C just plain pointers (4 bytes).
+     *
+     * @defaultValue "slice"
+     */
+    stringType: "slice" | "ptr";
 }
-export declare const prepareTypes: (types: TypeColl) => void;
+/**
+ * Takes a type collection and analyzes each analyzed to compute individual
+ * alignments and sizes.
+ *
+ * @remarks
+ * This function is idempotent and called automatically by
+ * {@link generateTypes}. Only exported for dev/debug purposes.
+ *
+ * @param types
+ *
+ * @internal
+ */
+export declare const prepareTypes: (types: TypeColl, opts: CodeGenOpts) => void;
+/**
+ * Code generator main entry point. Takes an object of {@link TopLevelType}
+ * definitions, an actual code generator implementation for a single target
+ * language and (optional) global codegen options. Returns generated source code
+ * for all given types as a single string.
+ *
+ * @remarks
+ * Before actual code generation the types are first analyzed to compute their
+ * alignments and sizes. This is only ever done once (idempotent), even if
+ * `generateTypes()` is called multiple times for different target langs.
+ *
+ * @param types
+ * @param codegen
+ * @param opts
+ */
 export declare const generateTypes: (types: TypeColl, codegen: ICodeGen, opts?: Partial<CodeGenOpts>) => string;
 //# sourceMappingURL=codegen.d.ts.map

package/codegen.js

@@ -5,9 +5,9 @@ import { compareByKey } from "@thi.ng/compare/keys";
 import { compareNumDesc } from "@thi.ng/compare/numeric";
 import { DEFAULT, defmulti } from "@thi.ng/defmulti/defmulti";
 import { PKG_NAME, USIZE_SIZE, } from "./api.js";
-import { isNumeric } from "./codegen/utils.js";
+import { isNumeric, isWasmString } from "./codegen/utils.js";
 const sizeOf = defmulti((x) => x.type, {}, {
-    [DEFAULT]: (field, types) => {
+    [DEFAULT]: (field, types, opts) => {
         if (field.__size)
             return field.__size;
         let size = 0;
@@ -20,7 +20,9 @@ const sizeOf = defmulti((x) => x.type, {}, {
         else {
             size = isNumeric(field.type)
                 ? SIZEOF[field.type]
-                : sizeOf(types[field.type], types);
+                : isWasmString(field.type)
+                    ? USIZE_SIZE * (opts.stringType === "slice" ? 2 : 1)
+                    : sizeOf(types[field.type], types, opts);
             if (field.tag == "array" || field.tag === "vec") {
                 size *= field.len;
             }
@@ -32,7 +34,7 @@ const sizeOf = defmulti((x) => x.type, {}, {
             return type.__size;
         return (type.__size = SIZEOF[type.tag]);
     },
-    struct: (type, types) => {
+    struct: (type, types, opts) => {
         if (type.__size)
             return type.__size;
         const struct = type;
@@ -40,7 +42,7 @@ const sizeOf = defmulti((x) => x.type, {}, {
         for (let f of struct.fields) {
             size = align(size, f.__align);
             f.__offset = size;
-            size += sizeOf(f, types);
+            size += sizeOf(f, types, opts);
         }
         return (type.__size = align(size, type.__align));
     },
@@ -51,7 +53,9 @@ const alignOf = defmulti((x) => x.type, {}, {
             return field.__align;
         let align = isNumeric(field.type)
             ? SIZEOF[field.type]
-            : alignOf(types[field.type], types);
+            : isWasmString(field.type)
+                ? USIZE_SIZE
+                : alignOf(types[field.type], types);
         if (field.tag === "vec") {
             align *= ceilPow2(field.len);
         }
@@ -71,13 +75,13 @@ const alignOf = defmulti((x) => x.type, {}, {
     },
 });
 const prepareType = defmulti((x) => x.type, {}, {
-    [DEFAULT]: (x, types) => {
+    [DEFAULT]: (x, types, opts) => {
         if (x.__align && x.__size)
             return;
         alignOf(x, types);
-        sizeOf(x, types);
+        sizeOf(x, types, opts);
     },
-    struct: (x, types) => {
+    struct: (x, types, opts) => {
         if (x.__align && x.__size)
             return;
         const struct = x;
@@ -87,30 +91,58 @@ const prepareType = defmulti((x) => x.type, {}, {
         }
         for (let f of struct.fields) {
             if (types[f.type]) {
-                prepareType(types[f.type], types);
+                prepareType(types[f.type], types, opts);
             }
         }
-        sizeOf(struct, types);
+        sizeOf(struct, types, opts);
     },
 });
-export const prepareTypes = (types) => {
+/**
+ * Takes a type collection and analyzes each analyzed to compute individual
+ * alignments and sizes.
+ *
+ * @remarks
+ * This function is idempotent and called automatically by
+ * {@link generateTypes}. Only exported for dev/debug purposes.
+ *
+ * @param types
+ *
+ * @internal
+ */
+export const prepareTypes = (types, opts) => {
     for (let id in types) {
-        prepareType(types[id], types);
+        prepareType(types[id], types, opts);
     }
 };
+/**
+ * Code generator main entry point. Takes an object of {@link TopLevelType}
+ * definitions, an actual code generator implementation for a single target
+ * language and (optional) global codegen options. Returns generated source code
+ * for all given types as a single string.
+ *
+ * @remarks
+ * Before actual code generation the types are first analyzed to compute their
+ * alignments and sizes. This is only ever done once (idempotent), even if
+ * `generateTypes()` is called multiple times for different target langs.
+ *
+ * @param types
+ * @param codegen
+ * @param opts
+ */
 export const generateTypes = (types, codegen, opts = {}) => {
-    prepareTypes(types);
+    const $opts = { stringType: "slice", ...opts };
+    prepareTypes(types, $opts);
     const res = [];
     codegen.doc(`Generated by ${PKG_NAME} at ${new Date().toISOString()} - DO NOT EDIT!`, "", res, true);
     res.push("");
     codegen.pre && res.push(codegen.pre, "");
-    opts.pre && res.push(opts.pre, "");
+    $opts.pre && res.push($opts.pre, "");
     for (let id in types) {
         const type = types[id];
         type.doc && codegen.doc(type.doc, "", res);
         codegen[type.type](type, types, res);
     }
-    opts.post && res.push("", opts.post);
+    $opts.post && res.push("", $opts.post);
     codegen.post && res.push("", codegen.post);
     return res.join("\n");
 };

package/include/wasmapi.h

@@ -7,21 +7,26 @@ extern "C" {
 #include <stddef.h>
 #include <stdint.h>
 
+// Declares an imported symbol from named import module
+// The prefix is only used for the C side, NOT for exported name
 #define WASM_IMPORT(MODULE, TYPE, NAME, PREFIX)                     \
   extern __attribute__((import_module(MODULE), import_name(#NAME))) \
   TYPE PREFIX##NAME
+
+// Same as EMSCRIPTEN_KEEP_ALIVE, ensures symbol will be exported
 #define WASM_KEEP __attribute__((used))
 
-// Generate stubs only if explicitly disabled by defining this symbol
-#ifdef WASMAPI_NO_MALLOC
-size_t WASM_KEEP _wasm_allocate(size_t num_bytes) { return 0; }
-void WASM_KEEP _wasm_free(size_t addr) {}
-#else
+// Generate malloc/free wrappers only if explicitly enabled by defining this
+// symbol. If undefined some function stubs are exported.
+#ifdef WASMAPI_MALLOC
 #include <stdlib.h>
 size_t WASM_KEEP _wasm_allocate(size_t numBytes) {
   return (size_t)malloc(numBytes);
 }
 void WASM_KEEP _wasm_free(size_t addr) { free((void*)addr); }
+#else
+size_t WASM_KEEP _wasm_allocate(size_t num_bytes) { return 0; }
+void WASM_KEEP _wasm_free(size_t addr) {}
 #endif
 
 WASM_IMPORT("wasmapi", void, printI8, wasm_)(int8_t x);
@@ -53,6 +58,8 @@ WASM_IMPORT("wasmapi", void, _printF64Array, wasm)(void* addr, size_t len);
 WASM_IMPORT("wasmapi", void, _printStr0, wasm)(void* addr);
 WASM_IMPORT("wasmapi", void, _printStr, wasm)(void* addr, size_t len);
 
+WASM_IMPORT("wasmapi", void, debug, wasm_)(void);
+
 void wasm_printPtr(void* ptr) { wasm_printU32Hex((size_t)ptr); }
 
 #ifdef __cplusplus