@thi.ng/wasm-api 0.18.0 → 1.0.0

package/api.d.ts

@@ -1,9 +1,26 @@
-import type { BigType, FloatType, Fn, Fn2, IDeref, ILength, IObjectOf, NumOrString } from "@thi.ng/api";
-import type { Pow2 } from "@thi.ng/binary";
+import type { Fn, IDeref, ILength } from "@thi.ng/api";
 import type { WasmBridge } from "./bridge.js";
-export declare const PKG_NAME = "@thi.ng/wasm-api";
 export declare const EVENT_MEMORY_CHANGED = "memory-changed";
 export declare type BigIntArray = bigint[] | BigInt64Array | BigUint64Array;
+export declare type ReadonlyWasmString = IDeref<string> & ILength & {
+    readonly addr: number;
+};
+export interface WasmTypeBase {
+    /**
+     * Base address in linear WASM memory.
+     */
+    readonly __base: number;
+    /**
+     * Obtain as byte buffer
+     */
+    readonly __bytes: Uint8Array;
+}
+export interface WasmType<T> {
+    readonly align: number;
+    readonly size: number;
+    instance: Fn<number, T>;
+}
+export declare type WasmTypeConstructor<T> = Fn<IWasmMemoryAccess, WasmType<T>>;
 /**
  * Common interface for WASM/JS child APIs which will be used in combination
  * with a parent {@link WasmBridge}.
@@ -157,7 +174,8 @@ export interface IWasmMemoryAccess {
     /**
      * 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
@@ -205,335 +223,12 @@ export interface CoreAPI extends WebAssembly.ModuleImports {
     _printU64Array: (addr: number, len: number) => void;
     _printF32Array: (addr: number, len: number) => void;
     _printF64Array: (addr: number, len: number) => void;
-    _printStr0: (addr: number) => void;
+    printStrZ: (addr: number) => void;
     _printStr: (addr: number, len: number) => void;
+    printHexdump: (addr: number, len: number) => void;
     debug: () => void;
     _panic: (addr: number, len: number) => void;
     timer: () => number;
     epoch: () => bigint;
 }
-export interface WasmTypeBase {
-    /**
-     * Base address in linear WASM memory.
-     */
-    readonly __base: number;
-    /**
-     * Obtain as byte buffer
-     */
-    readonly __bytes: Uint8Array;
-}
-export interface WasmType<T> {
-    readonly align: number;
-    readonly size: number;
-    instance: Fn<number, T>;
-}
-export declare type WasmTypeConstructor<T> = Fn<IWasmMemoryAccess, WasmType<T>>;
-export declare type WasmInt = "i8" | "i16" | "i32" | "i64";
-export declare type WasmUint = "u8" | "u16" | "u32" | "u64";
-export declare type WasmFloat = FloatType;
-export declare type WasmPrim = WasmInt | WasmUint | WasmFloat;
-export declare type WasmPrim32 = Exclude<WasmPrim, BigType>;
-export declare type ReadonlyWasmString = IDeref<string> & ILength & {
-    readonly addr: number;
-};
-export declare type TypeColl = IObjectOf<TopLevelType>;
-export interface TypeInfo {
-    /**
-     * Auto-computed size (in bytes)
-     *
-     * @internal
-     */
-    __size?: number;
-    /**
-     * Auto-computed offset (in bytes) in parent struct.
-     *
-     * @internal
-     */
-    __offset?: number;
-    /**
-     * Auto-computed alignment (in bytes) actually used.
-     *
-     * @internal
-     */
-    __align?: Pow2;
-}
-export interface TopLevelType extends TypeInfo {
-    /**
-     * Type name
-     */
-    name: string;
-    /**
-     * Optional (multi-line) docstring for this type
-     */
-    doc?: string | string[];
-    /**
-     * Type / kind
-     */
-    type: "enum" | "struct" | "union";
-    /**
-     * Optional object of user provided source codes to be injected into the
-     * generated type (after generated fields). Keys of this object are language
-     * IDs (`ts` for {@link TYPESCRIPT}, `zig` for {@link ZIG}).
-     *
-     * @remarks
-     * Currently only supported by the code gens mentioned, ignored otherwise.
-     */
-    body?: IObjectOf<string | string[] | InjectedBody>;
-}
-export interface InjectedBody {
-    decl?: string | string[];
-    impl?: string | string[];
-}
-export interface Struct extends TopLevelType {
-    type: "struct";
-    /**
-     * Array of struct fields (might be re-ordered if {@link Struct.auto} is
-     * enabled).
-     */
-    fields: Field[];
-    /**
-     * If true, struct fields will be re-ordered in descending order based on
-     * their {@link TypeInfo.__align} size. This might result in overall smaller
-     * structs due to minimizing implicit inter-field padding caused by
-     * alignment requirements. **If this option is enabled, then the struct MUST
-     * NOT contain any padding fields!**
-     *
-     * @defaultValue false
-     */
-    auto?: boolean;
-    /**
-     * Optional qualifier for the kind of struct to be emitted (codegen specific
-     * interpretation, currently only used by {@link ZIG}).
-     */
-    tag?: "extern" | "packed";
-    /**
-     * Optional user supplied {@link AlignStrategy}. By default uses
-     * {@link ALIGN_C} or {@link ALIGN_PACKED} (if using "packed" structs).
-     */
-    align?: AlignStrategy;
-}
-export interface Union extends TopLevelType {
-    type: "union";
-    /**
-     * Array of union fields.
-     */
-    fields: Field[];
-    /**
-     * Optional qualifier for the kind of struct to be emitted (codegen specific
-     * interpretation, currently only used by {@link ZIG}).
-     */
-    tag?: "extern" | "packed";
-    /**
-     * Optional user supplied {@link AlignStrategy}. By default uses
-     * {@link ALIGN_C} or {@link ALIGN_PACKED} (if using "packed" union).
-     */
-    align?: AlignStrategy;
-}
-export declare type FieldTag = "scalar" | "array" | "ptr" | "slice" | "vec";
-export interface Field extends TypeInfo {
-    /**
-     * Field name (prefix: "__" is reserved)
-     */
-    name: string;
-    /**
-     * Field docstring (can be multiline, will be formatted)
-     */
-    doc?: string | string[];
-    /**
-     * Field type tag/qualifier (note: `slice` & `vec` are only supported by Zig
-     * & TS).
-     *
-     * @remarks
-     * - Array & vector fields are statically sized (using
-     *   {@link Field.len})
-     * - Pointers are emitted as single-value pointers (where this distinction
-     *   exist), i.e. even if they're pointing to multiple values, there's no
-     *   explicit length encoded/available
-     * - Zig slices are essentially a pointer w/ associated length
-     * - Zig vectors will be processed using SIMD (if enabled in WASM target)
-     *   and therefore will have stricter (larger) alignment requirements.
-     *
-     * @defaultValue "scalar"
-     */
-    tag?: FieldTag;
-    /**
-     * Field base type. If not a {@link WasmPrim}, `string` or `opaque`, the
-     * value is interpreted as another type name in the {@link TypeColl}.
-     *
-     * @remarks
-     * Please see {@link CodeGenOpts.stringType} and consult package readme for
-     * further details re: string handling.
-     *
-     * TODO `opaque` currently unsupported.
-     */
-    type: WasmPrim | "string" | "opaque" | string;
-    /**
-     * Const qualifier (default is true for `string`, false for all other
-     * types). Only used for pointers or slices.
-     */
-    const?: boolean;
-    /**
-     * Currently only supported for {@link ZIG} arrays & slices, otherwise
-     * ignored!
-     */
-    sentinel?: number;
-    /**
-     * Array or vector length (see {@link Field.tag})
-     */
-    len?: number;
-    /**
-     * Currently only supported for {@link ZIG}, otherwise ignored!
-     *
-     * @remarks
-     * The object form allows for different default values per language (in
-     * theory). So if given as object, the keys refer to the lang ID and the
-     * values as the defaults for those languages.
-     */
-    default?: NumOrString | IObjectOf<NumOrString>;
-    /**
-     * If defined and > 0, the field will be considered for padding purposes
-     * only and the value provided is the number of bytes used. All other config
-     * for this field will be ignored!
-     */
-    pad?: number;
-}
-export interface Enum extends TopLevelType {
-    type: "enum";
-    /**
-     * No i64/u64 support, due to Typescript not supporting bigint enum values.
-     * For C compatibility only i32 or u32 is allowed.
-     *
-     * @defaultValue "i32"
-     */
-    tag: Exclude<WasmPrim32, FloatType>;
-    /**
-     * List of possible values/IDs. Use {@link EnumValue}s for more detailed
-     * config.
-     */
-    values: (string | EnumValue)[];
-}
-export interface EnumValue {
-    /**
-     * Enum value name/ID
-     */
-    name: string;
-    /**
-     * Optional associated numeric value
-     */
-    value?: number;
-    /**
-     * Optional docstring for this value
-     */
-    doc?: string;
-}
-export interface AlignStrategy {
-    /**
-     * Returns implementation specific alignment for given struct field.
-     */
-    align: Fn<Field, Pow2>;
-    /**
-     * Returns possibly rounded value for given base size & alignment.
-     */
-    size: Fn2<number, Pow2, number>;
-    /**
-     * Returns possibly rounded value for given base offset & alignment.
-     */
-    offset: Fn2<number, Pow2, number>;
-}
-export interface CodeGenOptsBase {
-    /**
-     * Optional string to be injected before generated type defs (but after
-     * codegen's own prelude, if any)
-     */
-    pre?: string;
-    /**
-     * Optional string to be injected after generated type defs (but before
-     * codegen's own epilogue, if any)
-     */
-    post?: string;
-}
-/**
- * Global/shared code generator options.
- */
-export interface CodeGenOpts extends CodeGenOptsBase {
-    /**
-     * WASM target specification.
-     *
-     * @defaultValue {@link WASM32}
-     */
-    target: WasmTarget;
-    /**
-     * 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";
-    /**
-     * If true (default), forces uppercase enum identifiers.
-     *
-     * @remarks
-     * This option is ignored in {@link ZIG} since it's idiomatic for that
-     * language to only use lowercase/camelCase enum IDs.
-     *
-     * @defaultValue true
-     */
-    uppercaseEnums: boolean;
-    /**
-     * Unless set to false, the generated output will be prefixed with a header
-     * line comment of generator meta data
-     */
-    header: boolean;
-    /**
-     * If true, codegens MAY generate various additional struct & struct field
-     * analysis functions (sizes, alignment, offsets etc.).
-     *
-     * @defaultValue false
-     */
-    debug: boolean;
-    /**
-     * Target line width for word wrapping doc strings
-     *
-     * @defaultValue 80
-     */
-    lineWidth: number;
-}
-export interface ICodeGen {
-    /**
-     * Optional prelude source, to be prepended before any generated type defs.
-     */
-    pre?: Fn<CodeGenOpts, string>;
-    /**
-     * Optional source code to be appended after any generated type defs.
-     */
-    post?: Fn<CodeGenOpts, string>;
-    /**
-     * Docstring codegen
-     */
-    doc: (doc: string | string[], acc: string[], opts: CodeGenOpts, topLevel?: boolean) => void;
-    /**
-     * Codegen for enum types.
-     */
-    enum: (type: Enum, types: TypeColl, acc: string[], opts: CodeGenOpts) => void;
-    /**
-     * Codegen for struct types.
-     */
-    struct: (type: Struct, types: TypeColl, acc: string[], opts: CodeGenOpts) => void;
-    /**
-     * Codegen for union types.
-     */
-    union: (type: Union, types: TypeColl, acc: string[], opts: CodeGenOpts) => void;
-}
-export interface WasmTarget {
-    usize: "u32" | "u64";
-    usizeBytes: number;
-}
-/**
- * WASM32 target spec
- */
-export declare const WASM32: WasmTarget;
-/**
- * WASM64 target spec
- */
-export declare const WASM64: WasmTarget;
 //# sourceMappingURL=api.d.ts.map

package/api.js

@@ -1,16 +1 @@
-export const PKG_NAME = "@thi.ng/wasm-api";
 export const EVENT_MEMORY_CHANGED = "memory-changed";
-/**
- * WASM32 target spec
- */
-export const WASM32 = {
-    usize: "u32",
-    usizeBytes: 4,
-};
-/**
- * WASM64 target spec
- */
-export const WASM64 = {
-    usize: "u64",
-    usizeBytes: 8,
-};

package/bridge.d.ts

@@ -130,13 +130,6 @@ export declare class WasmBridge<T extends WasmExports = WasmExports> implements
      * ```
      */
     getImports(): WebAssembly.Imports;
-    /**
-     * Attempts to grow the WASM memory by an additional `numPages` (64KB/page)
-     * and if successful updates all typed memory views to use the new
-     * underlying buffer.
-     *
-     * @param numPages
-     */
     growMemory(numPages: number): void;
     allocate(numBytes: number, clear?: boolean): MemorySlice;
     free([addr, numBytes]: MemorySlice): void;
@@ -180,31 +173,7 @@ export declare class WasmBridge<T extends WasmExports = WasmExports> implements
     setU64Array(addr: number, buf: BigIntArray): this;
     setF32Array(addr: number, buf: NumericArray): this;
     setF64Array(addr: number, buf: NumericArray): this;
-    /**
-     * Reads UTF-8 encoded string from given address and optional byte length.
-     * The default length is 0, which will be interpreted as a zero-terminated
-     * string. Returns string.
-     *
-     * @param addr
-     * @param len
-     */
     getString(addr: number, len?: number): string;
-    /**
-     * 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 (excluding final
-     * sentinel, if any).
-     *
-     * @remarks
-     * An error will be thrown if the encoded string doesn't fully fit into the
-     * designated memory region (also note that there might need to be space for
-     * the additional sentinel/termination byte).
-     *
-     * @param str
-     * @param addr
-     * @param maxBytes
-     * @param terminate
-     */
     setString(str: string, addr: number, maxBytes: number, terminate?: boolean): number;
     getElementById(addr: number, len?: number): HTMLElement;
     /** {@inheritDoc @thi.ng/api#INotify.addListener} */

package/bridge.js

@@ -3,7 +3,7 @@ import { INotifyMixin } from "@thi.ng/api/mixins/inotify";
 import { topoSort } from "@thi.ng/arrays/topo-sort";
 import { assert } from "@thi.ng/errors/assert";
 import { defError } from "@thi.ng/errors/deferror";
-import { U16, U32, U64BIG, U8 } from "@thi.ng/hex";
+import { hexdumpLines, U16, U32, U64BIG, U8 } from "@thi.ng/hex";
 import { ConsoleLogger } from "@thi.ng/logger/console";
 import { EVENT_MEMORY_CHANGED, } from "./api.js";
 export const Panic = defError(() => "Panic");
@@ -47,6 +47,12 @@ let WasmBridge = class WasmBridge {
             printU16Hex: (x) => this.logger.debug(() => `0x${U16(x)}`),
             printU32Hex: (x) => this.logger.debug(() => `0x${U32(x)}`),
             printU64Hex: (x) => this.logger.debug(() => `0x${U64BIG(x)}`),
+            printHexdump: (addr, len) => {
+                this.ensureMemory();
+                for (let line of hexdumpLines(this.u8, addr, len)) {
+                    this.logger.debug(line);
+                }
+            },
             _printI8Array: logA(this.getI8Array.bind(this)),
             _printU8Array: logA(this.getU8Array.bind(this)),
             _printI16Array: logA(this.getI16Array.bind(this)),
@@ -57,7 +63,7 @@ let WasmBridge = class WasmBridge {
             _printU64Array: logA(this.getU64Array.bind(this)),
             _printF32Array: logA(this.getF32Array.bind(this)),
             _printF64Array: logA(this.getF64Array.bind(this)),
-            _printStr0: (addr) => this.logger.debug(() => this.getString(addr, 0)),
+            printStrZ: (addr) => this.logger.debug(() => this.getString(addr, 0)),
             _printStr: (addr, len) => this.logger.debug(() => this.getString(addr, len)),
             debug: () => {
                 debugger;
@@ -192,13 +198,6 @@ let WasmBridge = class WasmBridge {
         }
         return this.imports;
     }
-    /**
-     * Attempts to grow the WASM memory by an additional `numPages` (64KB/page)
-     * and if successful updates all typed memory views to use the new
-     * underlying buffer.
-     *
-     * @param numPages
-     */
     growMemory(numPages) {
         this.exports.memory.grow(numPages);
         this.ensureMemory();
@@ -364,34 +363,10 @@ let WasmBridge = class WasmBridge {
         this.f64.set(buf, addr >> 3);
         return this;
     }
-    /**
-     * Reads UTF-8 encoded string from given address and optional byte length.
-     * The default length is 0, which will be interpreted as a zero-terminated
-     * string. Returns string.
-     *
-     * @param addr
-     * @param len
-     */
     getString(addr, len = 0) {
         this.ensureMemory();
         return this.utf8Decoder.decode(this.u8.subarray(addr, len > 0 ? addr + len : this.u8.indexOf(0, addr)));
     }
-    /**
-     * 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 (excluding final
-     * sentinel, if any).
-     *
-     * @remarks
-     * An error will be thrown if the encoded string doesn't fully fit into the
-     * designated memory region (also note that there might need to be space for
-     * the additional sentinel/termination byte).
-     *
-     * @param str
-     * @param addr
-     * @param maxBytes
-     * @param terminate
-     */
     setString(str, addr, maxBytes, terminate = true) {
         this.ensureMemory();
         maxBytes = Math.min(maxBytes, this.u8.length - addr);

package/include/wasmapi.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include "wasmapi_types.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -7,70 +9,72 @@ 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) \
+// Declares an extern symbol from named import module
+// The prefix is only used for the C side, _not_ for exported NAME
+#define WASMAPI_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))
+#define WASMAPI_KEEP __attribute__((used))
 
 // 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) {
+size_t WASMAPI_KEEP _wasm_allocate(size_t numBytes) {
   return (size_t)malloc(numBytes);
 }
-void WASM_KEEP _wasm_free(size_t addr, size_t numBytes) {
+void WASMAPI_KEEP _wasm_free(size_t addr, size_t numBytes) {
   free((void*)addr);
 }
 
 #else
 
-size_t WASM_KEEP _wasm_allocate(size_t numBytes) {
+size_t WASMAPI_KEEP _wasm_allocate(size_t numBytes) {
   return 0;
 }
-void WASM_KEEP _wasm_free(size_t addr, size_t numBytes) {
+void WASMAPI_KEEP _wasm_free(size_t addr, size_t numBytes) {
 }
 
 #endif  // WASMAPI_MALLOC
 
-WASM_IMPORT("wasmapi", void, printI8, wasm_)(int8_t x);
-WASM_IMPORT("wasmapi", void, printU8, wasm_)(uint8_t x);
-WASM_IMPORT("wasmapi", void, printU8Hex, wasm_)(uint8_t x);
-WASM_IMPORT("wasmapi", void, printI16, wasm_)(int16_t x);
-WASM_IMPORT("wasmapi", void, printU16, wasm_)(uint16_t x);
-WASM_IMPORT("wasmapi", void, printU16Hex, wasm_)(uint16_t x);
-WASM_IMPORT("wasmapi", void, printI32, wasm_)(int32_t x);
-WASM_IMPORT("wasmapi", void, printU32, wasm_)(uint32_t x);
-WASM_IMPORT("wasmapi", void, printU32Hex, wasm_)(uint32_t x);
-WASM_IMPORT("wasmapi", void, printI64, wasm_)(int64_t x);
-WASM_IMPORT("wasmapi", void, printU64, wasm_)(uint64_t x);
-WASM_IMPORT("wasmapi", void, printU64Hex, wasm_)(uint64_t x);
-WASM_IMPORT("wasmapi", void, printF32, wasm_)(float x);
-WASM_IMPORT("wasmapi", void, printF64, wasm_)(double x);
-
-WASM_IMPORT("wasmapi", void, _printI8Array, wasm)(const int8_t* addr, size_t len);
-WASM_IMPORT("wasmapi", void, _printU8Array, wasm)(const uint8_t* addr, size_t len);
-WASM_IMPORT("wasmapi", void, _printI16Array, wasm)(const int16_t* addr, size_t len);
-WASM_IMPORT("wasmapi", void, _printU16Array, wasm)(const uint16_t* addr, size_t len);
-WASM_IMPORT("wasmapi", void, _printI32Array, wasm)(const int32_t* addr, size_t len);
-WASM_IMPORT("wasmapi", void, _printU32Array, wasm)(const uint32_t* addr, size_t len);
-WASM_IMPORT("wasmapi", void, _printI64Array, wasm)(const int64_t* addr, size_t len);
-WASM_IMPORT("wasmapi", void, _printU64Array, wasm)(const uint64_t* addr, size_t len);
-WASM_IMPORT("wasmapi", void, _printF32Array, wasm)(const float* addr, size_t len);
-WASM_IMPORT("wasmapi", void, _printF64Array, wasm)(const double* addr, size_t len);
-
-WASM_IMPORT("wasmapi", void, _printStr0, wasm)(const char* addr);
-WASM_IMPORT("wasmapi", void, _printStr, wasm)(const char* addr, size_t len);
-
-WASM_IMPORT("wasmapi", void, debug, wasm_)(void);
-WASM_IMPORT("wasmapi", void, panic, wasm_)(const char*, size_t len);
-
-WASM_IMPORT("wasmapi", double, timer, wasm_)(void);
-WASM_IMPORT("wasmapi", uint64_t, epoch, wasm_)(void);
+WASMAPI_IMPORT("wasmapi", void, printI8, wasm_)(int8_t x);
+WASMAPI_IMPORT("wasmapi", void, printU8, wasm_)(uint8_t x);
+WASMAPI_IMPORT("wasmapi", void, printU8Hex, wasm_)(uint8_t x);
+WASMAPI_IMPORT("wasmapi", void, printI16, wasm_)(int16_t x);
+WASMAPI_IMPORT("wasmapi", void, printU16, wasm_)(uint16_t x);
+WASMAPI_IMPORT("wasmapi", void, printU16Hex, wasm_)(uint16_t x);
+WASMAPI_IMPORT("wasmapi", void, printI32, wasm_)(int32_t x);
+WASMAPI_IMPORT("wasmapi", void, printU32, wasm_)(uint32_t x);
+WASMAPI_IMPORT("wasmapi", void, printU32Hex, wasm_)(uint32_t x);
+WASMAPI_IMPORT("wasmapi", void, printI64, wasm_)(int64_t x);
+WASMAPI_IMPORT("wasmapi", void, printU64, wasm_)(uint64_t x);
+WASMAPI_IMPORT("wasmapi", void, printU64Hex, wasm_)(uint64_t x);
+WASMAPI_IMPORT("wasmapi", void, printF32, wasm_)(float x);
+WASMAPI_IMPORT("wasmapi", void, printF64, wasm_)(double x);
+
+WASMAPI_IMPORT("wasmapi", void, printHexdump, wasm_)(const void* addr, size_t len);
+
+WASMAPI_IMPORT("wasmapi", void, _printI8Array, wasm)(const int8_t* addr, size_t len);
+WASMAPI_IMPORT("wasmapi", void, _printU8Array, wasm)(const uint8_t* addr, size_t len);
+WASMAPI_IMPORT("wasmapi", void, _printI16Array, wasm)(const int16_t* addr, size_t len);
+WASMAPI_IMPORT("wasmapi", void, _printU16Array, wasm)(const uint16_t* addr, size_t len);
+WASMAPI_IMPORT("wasmapi", void, _printI32Array, wasm)(const int32_t* addr, size_t len);
+WASMAPI_IMPORT("wasmapi", void, _printU32Array, wasm)(const uint32_t* addr, size_t len);
+WASMAPI_IMPORT("wasmapi", void, _printI64Array, wasm)(const int64_t* addr, size_t len);
+WASMAPI_IMPORT("wasmapi", void, _printU64Array, wasm)(const uint64_t* addr, size_t len);
+WASMAPI_IMPORT("wasmapi", void, _printF32Array, wasm)(const float* addr, size_t len);
+WASMAPI_IMPORT("wasmapi", void, _printF64Array, wasm)(const double* addr, size_t len);
+
+WASMAPI_IMPORT("wasmapi", void, printStrZ, wasm_)(const char* addr);
+WASMAPI_IMPORT("wasmapi", void, _printStr, wasm)(const char* addr, size_t len);
+
+WASMAPI_IMPORT("wasmapi", void, debug, wasm_)(void);
+WASMAPI_IMPORT("wasmapi", void, panic, wasm_)(const char*, size_t len);
+
+WASMAPI_IMPORT("wasmapi", double, timer, wasm_)(void);
+WASMAPI_IMPORT("wasmapi", uint64_t, epoch, wasm_)(void);
 
 void wasm_printPtr(const void* ptr) {
   wasm_printU32Hex((size_t)ptr);

package/include/wasmapi_types.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stddef.h>
+
+typedef char* WASM_StringPtr;
+typedef const char* WASM_ConstStringPtr;
+
+typedef void* WASM_OpaquePtr;
+typedef const void* WASM_ConstOpaquePtr;
+
+// slice-based string
+typedef struct { WASM_StringPtr ptr; size_t len; } WASM_String;
+typedef struct { WASM_ConstStringPtr ptr; size_t len; } WASM_ConstString;
+
+// defines slice wrapper structs for given pointer types
+#define WASMAPI_SLICE(PREFIX, NAME, PTR, CONSTPTR) \
+  typedef struct { PTR* ptr; size_t len;  } PREFIX##NAME##Slice; \
+  typedef struct { CONSTPTR* ptr; size_t len; } PREFIX##Const##NAME##Slice;
+
+// slice of string slices
+WASMAPI_SLICE(WASM_, String, WASM_String, WASM_ConstString)
+
+// slice of string pointers
+WASMAPI_SLICE(WASM_, StringPtr, WASM_StringPtr, WASM_ConstStringPtr)
+
+// slice of opaque pointers
+WASMAPI_SLICE(WASM_, OpaquePtr, WASM_OpaquePtr, WASM_ConstOpaquePtr)
+
+#ifdef __cplusplus
+}
+#endif

package/index.d.ts

@@ -1,10 +1,5 @@
 export * from "./api.js";
 export * from "./bridge.js";
-export * from "./codegen.js";
-export * from "./codegen/c11.js";
-export * from "./codegen/typescript.js";
-export * from "./codegen/utils.js";
-export * from "./codegen/zig.js";
 export * from "./object-index.js";
 export * from "./pointer.js";
 export * from "./string.js";