@thi.ng/wasm-api 0.3.1 → 0.6.0

package/bridge.d.ts

@@ -1,6 +1,17 @@
+/// <reference types="node" />
 import type { NumericArray } from "@thi.ng/api";
 import type { ILogger } from "@thi.ng/logger";
-import type { BigIntArray, CoreAPI, IWasmAPI, WasmExports } from "./api.js";
+import type { BigIntArray, CoreAPI, IWasmAPI, WasmExports, WasmMemViews } from "./api.js";
+export declare const OutOfMemoryError: {
+    new (msg?: string | undefined): {
+        name: string;
+        message: string;
+        stack?: string | undefined;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function | undefined): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
 /**
  * The main interop API bridge between the JS host environment and a WebAssembly
  * module. This class provides a small core API with various typed accessors and
@@ -17,7 +28,7 @@ import type { BigIntArray, CoreAPI, IWasmAPI, WasmExports } from "./api.js";
  * 64bit integers are handled via JS `BigInt` and hence require the host env to
  * support it. No polyfill is provided.
  */
-export declare class WasmBridge<T extends WasmExports = WasmExports> {
+export declare class WasmBridge<T extends WasmExports = WasmExports> implements WasmMemViews {
     modules: Record<string, IWasmAPI<T>>;
     logger: ILogger;
     i8: Int8Array;
@@ -32,8 +43,9 @@ export declare class WasmBridge<T extends WasmExports = WasmExports> {
     f64: Float64Array;
     utf8Decoder: TextDecoder;
     utf8Encoder: TextEncoder;
-    core: CoreAPI;
+    imports: WebAssembly.Imports;
     exports: T;
+    api: CoreAPI;
     constructor(modules?: Record<string, IWasmAPI<T>>, logger?: ILogger);
     /**
      * Instantiates WASM module from given `src` (and optional provided extra
@@ -57,17 +69,78 @@ export declare class WasmBridge<T extends WasmExports = WasmExports> {
      * @param exports
      */
     init(exports: T): Promise<boolean>;
+    /**
+     * Called automatically. Initializes and/or updates the various typed WASM
+     * memory views (e.g. after growing the WASM memory).
+     */
+    ensureMemory(): void;
     /**
      * Required use for WASM module instantiation to provide JS imports to the
      * module. Returns an object of all WASM imports declared by the bridge core
      * API and any provided bridge API modules.
      *
      * @remarks
-     * Since all declared imports will be merged into a single flat namespace,
-     * it's recommended to use per-module naming prefixes to avoid clashes. If
-     * there're any naming clashes, this function will throw an error.
+     * Since v0.4.0 each API module's imports will be in their own WASM import
+     * object, named using the same key which was assigned to the module when
+     * creating the WASM bridge. The bridge's core API will be named `core` and
+     * is reserved.
+     *
+     * @example
+     * The following creates a bridge with a fictional `custom` API module:
+     *
+     * ```ts
+     * const bridge = new WasmBridge({ custom: new CustomAPI() });
+     *
+     * // get combined imports object
+     * bridge.getImports();
+     * {
+     *   // imports defined by the core API of the bridge itself
+     *   wasmapi: { ... },
+     *   // imports defined by the CustomAPI module
+     *   custom: { ... }
+     * }
+     * ```
+     *
+     * Any related API bindings on the WASM (Zig) side then also need to refer
+     * to these custom import sections (also see `/zig/core.zig`):
+     *
+     * ```zig
+     * pub export "custom" fn foo(x: u32) void;
+     * ```
      */
     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;
+    /**
+     * Attempts to allocate `numBytes` using the exported WASM core API function
+     * {@link WasmExports._wasm_allocate} (implementation specific) and returns
+     * start address of the new memory block. If unsuccessful, throws an
+     * {@link OutOfMemoryError}. If `clear` is true, the allocated region will
+     * be zero-filled.
+     *
+     * @remarks
+     * See {@link WasmExports._wasm_allocate} docs for further details.
+     *
+     * @param numBytes
+     * @param clear
+     */
+    allocate(numBytes: number, clear?: boolean): number;
+    /**
+     * Frees a previous allocated memory region using the exported WASM core API
+     * function {@link WasmExports._wasm_free} (implementation specific). The
+     * `numBytes` value must be the same as previously given to
+     * {@link WasmBridge.allocate}.
+     *
+     * @param addr
+     * @param numBytes
+     */
+    free(addr: number, numBytes: number): void;
     getI8(addr: number): number;
     getU8(addr: number): number;
     getI16(addr: number): number;
@@ -108,7 +181,30 @@ export declare class WasmBridge<T extends WasmExports = WasmExports> {
     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.
+     *
+     * @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;
 }

package/bridge.js

@@ -1,7 +1,9 @@
+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";
 const B32 = BigInt(32);
+export const OutOfMemoryError = defError(() => "Out of memory");
 /**
  * The main interop API bridge between the JS host environment and a WebAssembly
  * module. This class provides a small core API with various typed accessors and
@@ -26,7 +28,7 @@ export class WasmBridge {
         this.utf8Encoder = new TextEncoder();
         const logN = (x) => this.logger.debug(x);
         const logA = (method) => (addr, len) => this.logger.debug(method(addr, len).join(", "));
-        this.core = {
+        this.api = {
             printI8: logN,
             printU8: logN,
             printU8Hex: (x) => this.logger.debug(`0x${U8(x)}`),
@@ -70,14 +72,10 @@ export class WasmBridge {
      */
     async instantiate(src, imports) {
         const $src = await src;
-        const $imports = { ...imports, ...this.getImports() };
-        let wasm;
-        if ($src instanceof Response) {
-            wasm = await WebAssembly.instantiateStreaming($src, $imports);
-        }
-        else {
-            wasm = await WebAssembly.instantiate($src, $imports);
-        }
+        const $imports = { ...this.getImports(), ...imports };
+        const wasm = await ($src instanceof Response
+            ? WebAssembly.instantiateStreaming($src, $imports)
+            : WebAssembly.instantiate($src, $imports));
         return this.init(wasm.instance.exports);
     }
     /**
@@ -89,7 +87,23 @@ export class WasmBridge {
      */
     async init(exports) {
         this.exports = exports;
-        const buf = exports.memory.buffer;
+        this.ensureMemory();
+        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;
+        }
+        return true;
+    }
+    /**
+     * Called automatically. Initializes and/or updates the various typed WASM
+     * memory views (e.g. after growing the WASM memory).
+     */
+    ensureMemory() {
+        const buf = this.exports.memory.buffer;
+        if (this.u8 && this.u8.buffer === buf)
+            return;
         this.i8 = new Int8Array(buf);
         this.u8 = new Uint8Array(buf);
         this.i16 = new Int16Array(buf);
@@ -100,13 +114,6 @@ export class WasmBridge {
         this.u64 = new BigUint64Array(buf);
         this.f32 = new Float32Array(buf);
         this.f64 = new Float64Array(buf);
-        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;
-        }
-        return true;
     }
     /**
      * Required use for WASM module instantiation to provide JS imports to the
@@ -114,23 +121,91 @@ export class WasmBridge {
      * API and any provided bridge API modules.
      *
      * @remarks
-     * Since all declared imports will be merged into a single flat namespace,
-     * it's recommended to use per-module naming prefixes to avoid clashes. If
-     * there're any naming clashes, this function will throw an error.
+     * Since v0.4.0 each API module's imports will be in their own WASM import
+     * object, named using the same key which was assigned to the module when
+     * creating the WASM bridge. The bridge's core API will be named `core` and
+     * is reserved.
+     *
+     * @example
+     * The following creates a bridge with a fictional `custom` API module:
+     *
+     * ```ts
+     * const bridge = new WasmBridge({ custom: new CustomAPI() });
+     *
+     * // get combined imports object
+     * bridge.getImports();
+     * {
+     *   // imports defined by the core API of the bridge itself
+     *   wasmapi: { ... },
+     *   // imports defined by the CustomAPI module
+     *   custom: { ... }
+     * }
+     * ```
+     *
+     * Any related API bindings on the WASM (Zig) side then also need to refer
+     * to these custom import sections (also see `/zig/core.zig`):
+     *
+     * ```zig
+     * pub export "custom" fn foo(x: u32) void;
+     * ```
      */
     getImports() {
-        const env = { ...this.core };
-        for (let id in this.modules) {
-            const imports = this.modules[id].getImports();
-            // check for naming clashes
-            for (let k in imports) {
-                if (env[k] !== undefined) {
-                    illegalArgs(`attempt to redeclare import: ${k} by API module ${id}`);
+        if (!this.imports) {
+            this.imports = { wasmapi: this.api };
+            for (let id in this.modules) {
+                if (this.imports[id] !== undefined) {
+                    illegalArgs(`attempt to redeclare API module ${id}`);
                 }
+                this.imports[id] = this.modules[id].getImports();
             }
-            Object.assign(env, imports);
         }
-        return { env };
+        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();
+    }
+    /**
+     * Attempts to allocate `numBytes` using the exported WASM core API function
+     * {@link WasmExports._wasm_allocate} (implementation specific) and returns
+     * start address of the new memory block. If unsuccessful, throws an
+     * {@link OutOfMemoryError}. If `clear` is true, the allocated region will
+     * be zero-filled.
+     *
+     * @remarks
+     * See {@link WasmExports._wasm_allocate} docs for further details.
+     *
+     * @param numBytes
+     * @param clear
+     */
+    allocate(numBytes, clear = false) {
+        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.ensureMemory();
+        clear && this.u8.fill(0, addr, addr + numBytes);
+        return addr;
+    }
+    /**
+     * Frees a previous allocated memory region using the exported WASM core API
+     * function {@link WasmExports._wasm_free} (implementation specific). The
+     * `numBytes` value must be the same as previously given to
+     * {@link WasmBridge.allocate}.
+     *
+     * @param addr
+     * @param numBytes
+     */
+    free(addr, numBytes) {
+        this.logger.debug(`freeing memory @ 0x${U32(addr)} .. 0x${U32(addr + numBytes - 1)}`);
+        this.exports._wasm_free(addr, numBytes);
     }
     getI8(addr) {
         return this.i8[addr];
@@ -280,13 +355,37 @@ export 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.
+     *
+     * @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) {
         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)) {
+        if (len == null || len >= maxBytes + (terminate ? 0 : 1)) {
             illegalArgs(`error writing string to 0x${U32(addr)}`);
         }
         if (terminate) {

package/codegen/typescript.d.ts

@@ -0,0 +1,22 @@
+import { ICodeGen } from "../api.js";
+export interface TSOpts {
+    /**
+     * Indentation string
+     *
+     * @defaultValue "\t"
+     */
+    indent: string;
+}
+/**
+ * TypeScript code generator. Call with options and then pass to
+ * {@link generateTypes} (see its docs for further usage).
+ *
+ * @remarks
+ * This codegen generates interface and enum definitions for a {@link TypeColl}
+ * given to {@link generateTypes}. For structs it will also generate memory
+ * mapped wrappers with fully typed accessors.
+ *
+ * @param opts
+ */
+export declare const TYPESCRIPT: (opts?: Partial<TSOpts>) => ICodeGen;
+//# sourceMappingURL=typescript.d.ts.map

package/codegen/typescript.js

@@ -0,0 +1,146 @@
+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";
+/**
+ * TypeScript code generator. Call with options and then pass to
+ * {@link generateTypes} (see its docs for further usage).
+ *
+ * @remarks
+ * This codegen generates interface and enum definitions for a {@link TypeColl}
+ * given to {@link generateTypes}. For structs it will also generate memory
+ * mapped wrappers with fully typed accessors.
+ *
+ * @param opts
+ */
+export const TYPESCRIPT = (opts) => {
+    const { indent } = { indent: "\t", ...opts };
+    const I = indent;
+    const I2 = I + I;
+    const I3 = I2 + I;
+    const gen = {
+        pre: `import type { WasmTypeBase, WasmTypeConstructor } from "${PKG_NAME}";`,
+        doc: (doc, indent, acc) => {
+            if (doc.indexOf("\n") !== -1) {
+                acc.push(indent + "/**", prefixLines(indent + " * ", doc), indent + " */");
+            }
+            else {
+                acc.push(`${indent}/** ${doc} */`);
+            }
+        },
+        enum: (type, _, acc) => {
+            const e = type;
+            acc.push(`export enum ${e.name} {`);
+            for (let v of e.values) {
+                var line = indent;
+                if (!isString(v)) {
+                    v.doc && gen.doc(v.doc, indent, acc);
+                    line += v.name;
+                    if (v.value != null)
+                        line += ` = ${v.value}`;
+                }
+                else {
+                    line += v;
+                }
+                acc.push(line + ",");
+            }
+            acc.push("}\n");
+            return acc;
+        },
+        struct: (type, types, acc) => {
+            const struct = type;
+            const returnTypes = {};
+            // interface definition
+            acc.push(`export interface ${struct.name} extends WasmTypeBase {`);
+            for (let f of struct.fields) {
+                f.doc && gen.doc(f.doc, indent, acc);
+                let line = `${indent}${f.name}: `;
+                let rtype = "";
+                if (f.tag == "array" || f.tag == "slice" || f.tag === "vec") {
+                    rtype = isNumeric(f.type)
+                        ? TYPEDARRAY_CTORS[f.type].name
+                        : isBigNumeric(f.type)
+                            ? BIGINT_ARRAY_CTORS[f.type].name
+                            : f.type + "[]";
+                }
+                else if (!f.tag || f.tag === "scalar" || f.tag === "ptr") {
+                    rtype = isBigNumeric(f.type)
+                        ? "bigint"
+                        : isNumeric(f.type)
+                            ? "number"
+                            : f.type;
+                }
+                returnTypes[f.name] = rtype;
+                acc.push(line + rtype + ";");
+            }
+            acc.push("}\n");
+            // type implementation
+            acc.push(`export const $${struct.name}: WasmTypeConstructor<${struct.name}> = (mem) => ({`, `${I}get align() { return ${struct.__align}; },`, `${I}get size() { return ${struct.__size}; },`, `${I}instance: (base) => ({`, `${I2}get __base() { return base; },`, `${I2}get __bytes() { return mem.u8.subarray(base, base + ${struct.__size}); },`);
+            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);
+                if (f.tag === "ptr") {
+                    acc.push(prim
+                        ? `${I3}return mem.${f.type}[${__ptrShift(offset, f.type)}];`
+                        : `${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(struct, 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(struct, f, I3, f.len)}`);
+                }
+                else {
+                    let setter;
+                    if (prim) {
+                        const addr = __mem(f.type, f.__offset);
+                        acc.push(`${I3}return ${addr};`);
+                        setter = `${addr} = x`;
+                    }
+                    else if (types[f.type].type === "enum") {
+                        const tag = types[f.type].tag;
+                        const addr = __mem(tag, f.__offset);
+                        acc.push(`${I3}return ${addr};`);
+                        setter = `${addr} = x`;
+                    }
+                    else {
+                        acc.push(`${I3}return $${f.type}(mem).instance(${__addr(offset)});`);
+                        setter = `mem.u8.set(x.__bytes, ${__addr(offset)})`;
+                    }
+                    // close getter
+                    acc.push(`${I2}},`);
+                    // setter
+                    acc.push(`${I2}set ${f.name}(x: ${returnTypes[f.name]}) {`, `${I3}${setter};`);
+                }
+                // close field accessor
+                acc.push(`${I2}},`);
+            }
+            acc.push(`${I}})\n});\n`);
+            return acc;
+        },
+    };
+    return gen;
+};
+/** @internal */
+const __shift = (type) => BIT_SHIFTS[type];
+/** @internal */
+const __addr = (offset) => (offset > 0 ? `(base + ${offset})` : "base");
+/** @internal */
+const __addrShift = (offset, shift) => __addr(offset) + " >>> " + __shift(shift);
+/** @internal */
+const __ptr = (offset) => `mem.${USIZE}[${__addrShift(offset, USIZE)}]`;
+/** @internal */
+const __ptrShift = (offset, shift) => __ptr(offset) + " >>> " + __shift(shift);
+const __mem = (type, offset) => `mem.${type}[${__addrShift(offset, type)}]`;
+/** @internal */
+const __mapArray = (struct, f, indent, len = "len") => prefixLines(indent, `const inst = $${f.type}(mem);
+const slice: ${f.type}[] = [];
+for(let i = 0; i < ${len}; i++) slice.push(inst.instance(addr + i * ${struct.__size}));
+return slice;`);

package/codegen/utils.d.ts

@@ -0,0 +1,5 @@
+export declare const isNumeric: (x: string) => boolean;
+export declare const isBigNumeric: (x: string) => boolean;
+export declare const isPrim: (x: string) => boolean;
+export declare const prefixLines: (prefix: string, str: string) => string;
+//# sourceMappingURL=utils.d.ts.map

package/codegen/utils.js

@@ -0,0 +1,7 @@
+export const isNumeric = (x) => /^([iu](8|16|32))|(f(32|64))$/.test(x);
+export const isBigNumeric = (x) => /^[iu]64$/.test(x);
+export const isPrim = (x) => isNumeric(x) || isBigNumeric(x);
+export const prefixLines = (prefix, str) => str
+    .split("\n")
+    .map((line) => prefix + line)
+    .join("\n");

package/codegen/zig.d.ts

@@ -0,0 +1,22 @@
+import type { ICodeGen } from "../api.js";
+export interface ZigOpts {
+    /**
+     * If true, generates various struct & struct field analysis functions
+     * (sizes, alignment, offsets etc.).
+     *
+     * @defaultValue false
+     */
+    debug: boolean;
+}
+/**
+ * Zig code generator. Call with options and then pass to {@link generateTypes}
+ * (see its docs for further usage).
+ *
+ * @remarks
+ * This codegen generates struct and enum definitions for a {@link TypeColl}
+ * given to {@link generateTypes}.
+ *
+ * @param opts
+ */
+export declare const ZIG: (opts?: Partial<ZigOpts>) => ICodeGen;
+//# sourceMappingURL=zig.d.ts.map

package/codegen/zig.js

@@ -0,0 +1,75 @@
+import { isString } from "@thi.ng/checks/is-string";
+import { prefixLines } from "./utils.js";
+/**
+ * Zig code generator. Call with options and then pass to {@link generateTypes}
+ * (see its docs for further usage).
+ *
+ * @remarks
+ * This codegen generates struct and enum definitions for a {@link TypeColl}
+ * given to {@link generateTypes}.
+ *
+ * @param opts
+ */
+export const ZIG = (opts) => {
+    const { debug } = { debug: false, ...opts };
+    const gen = {
+        doc: (doc, indent, acc, topLevel = false) => {
+            acc.push(prefixLines(topLevel ? "//! " : indent + "/// ", doc));
+        },
+        enum: (e, _, acc) => {
+            acc.push(`pub const ${e.name} = enum(${e.tag}) {`);
+            for (let v of e.values) {
+                let line = `    `;
+                if (!isString(v)) {
+                    v.doc && gen.doc(v.doc, "    ", acc);
+                    line += v.name;
+                    if (v.value != null)
+                        line += ` = ${v.value}`;
+                }
+                else {
+                    line += v;
+                }
+                acc.push(line + ",");
+            }
+            acc.push("};\n");
+        },
+        struct: (struct, _, acc) => {
+            const name = struct.name;
+            acc.push(`pub const ${name} = struct {`);
+            const ftypes = {};
+            for (let f of struct.fields) {
+                f.doc && gen.doc(f.doc, "    ", acc);
+                var ftype;
+                switch (f.tag) {
+                    case "array":
+                        ftype = `[${f.len}]${f.type}`;
+                        break;
+                    case "slice":
+                        ftype = `[]${f.type}`;
+                        break;
+                    case "vec":
+                        ftype = `@Vector(${f.len}, ${f.type})`;
+                        break;
+                    case "ptr":
+                        ftype = `*${f.len ? `[${f.len}]` : ""}${f.type}`;
+                        break;
+                    case "scalar":
+                    default:
+                        ftype = f.type;
+                }
+                ftypes[f.name] = ftype;
+                acc.push(`    ${f.name}: ${ftype},`);
+            }
+            acc.push("};\n");
+            if (!debug)
+                return;
+            const fn = (fname, body) => `export fn ${name}_${fname}() usize { return ${body}; }`;
+            acc.push(fn("align", `@alignOf(${name})`), fn("size", `@sizeOf(${name})`));
+            for (let f of struct.fields) {
+                acc.push(fn(f.name + "_align", `@alignOf(${ftypes[f.name]})`), fn(f.name + "_offset", `@offsetOf(${name}, "${f.name}")`), fn(f.name + "_size", `@sizeOf(${ftypes[f.name]})`));
+            }
+            acc.push("");
+        },
+    };
+    return gen;
+};

package/codegen.d.ts

@@ -0,0 +1,16 @@
+import { ICodeGen, TypeColl } from "./api.js";
+export interface CodeGenOpts {
+    /**
+     * 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;
+}
+export declare const prepareTypes: (types: TypeColl) => void;
+export declare const generateTypes: (types: TypeColl, codegen: ICodeGen, opts?: Partial<CodeGenOpts>) => string;
+//# sourceMappingURL=codegen.d.ts.map