@thi.ng/wasm-api 0.3.1 → 0.6.0

package/codegen.js

@@ -0,0 +1,116 @@
+import { SIZEOF } from "@thi.ng/api/typedarray";
+import { align } from "@thi.ng/binary/align";
+import { ceilPow2 } from "@thi.ng/binary/pow";
+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";
+const sizeOf = defmulti((x) => x.type, {}, {
+    [DEFAULT]: (field, types) => {
+        if (field.__size)
+            return field.__size;
+        let size = 0;
+        if (field.tag === "ptr") {
+            size = USIZE_SIZE;
+        }
+        else if (field.tag === "slice") {
+            size = USIZE_SIZE * 2;
+        }
+        else {
+            size = isNumeric(field.type)
+                ? SIZEOF[field.type]
+                : sizeOf(types[field.type], types);
+            if (field.tag == "array" || field.tag === "vec") {
+                size *= field.len;
+            }
+        }
+        return (field.__size = align(size, field.__align));
+    },
+    enum: (type) => {
+        if (type.__size)
+            return type.__size;
+        return (type.__size = SIZEOF[type.tag]);
+    },
+    struct: (type, types) => {
+        if (type.__size)
+            return type.__size;
+        const struct = type;
+        let size = 0;
+        for (let f of struct.fields) {
+            size = align(size, f.__align);
+            f.__offset = size;
+            size += sizeOf(f, types);
+        }
+        return (type.__size = align(size, type.__align));
+    },
+});
+const alignOf = defmulti((x) => x.type, {}, {
+    [DEFAULT]: (field, types) => {
+        if (field.__align)
+            return field.__align;
+        let align = isNumeric(field.type)
+            ? SIZEOF[field.type]
+            : alignOf(types[field.type], types);
+        if (field.tag === "vec") {
+            align *= ceilPow2(field.len);
+        }
+        field.__align = align;
+        return align;
+    },
+    enum: (e) => {
+        return (e.__align = SIZEOF[e.tag]);
+    },
+    struct: (type, types) => {
+        const struct = type;
+        let maxAlign = 0;
+        for (let f of struct.fields) {
+            maxAlign = Math.max(maxAlign, alignOf(f, types));
+        }
+        return (type.__align = maxAlign);
+    },
+});
+const prepareType = defmulti((x) => x.type, {}, {
+    [DEFAULT]: (x, types) => {
+        if (x.__align && x.__size)
+            return;
+        alignOf(x, types);
+        sizeOf(x, types);
+    },
+    struct: (x, types) => {
+        if (x.__align && x.__size)
+            return;
+        const struct = x;
+        alignOf(struct, types);
+        if (struct.auto) {
+            struct.fields.sort(compareByKey("__align", compareNumDesc));
+        }
+        for (let f of struct.fields) {
+            if (types[f.type]) {
+                prepareType(types[f.type], types);
+            }
+        }
+        sizeOf(struct, types);
+    },
+});
+export const prepareTypes = (types) => {
+    for (let id in types) {
+        prepareType(types[id], types);
+    }
+};
+export const generateTypes = (types, codegen, opts = {}) => {
+    prepareTypes(types);
+    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, "");
+    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);
+    codegen.post && res.push("", codegen.post);
+    return res.join("\n");
+};

package/include/wasmapi.h

@@ -0,0 +1,60 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stddef.h>
+#include <stdint.h>
+
+#define WASM_IMPORT(MODULE, TYPE, NAME, PREFIX)                     \
+  extern __attribute__((import_module(MODULE), import_name(#NAME))) \
+  TYPE PREFIX##NAME
+#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
+#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); }
+#endif
+
+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)(void* addr, size_t len);
+WASM_IMPORT("wasmapi", void, _printU8Array, wasm)(void* addr, size_t len);
+WASM_IMPORT("wasmapi", void, _printI16Array, wasm)(void* addr, size_t len);
+WASM_IMPORT("wasmapi", void, _printU16Array, wasm)(void* addr, size_t len);
+WASM_IMPORT("wasmapi", void, _printI32Array, wasm)(void* addr, size_t len);
+WASM_IMPORT("wasmapi", void, _printU32Array, wasm)(void* addr, size_t len);
+WASM_IMPORT("wasmapi", void, _printI64Array, wasm)(void* addr, size_t len);
+WASM_IMPORT("wasmapi", void, _printU64Array, wasm)(void* addr, size_t len);
+WASM_IMPORT("wasmapi", void, _printF32Array, wasm)(void* addr, size_t len);
+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);
+
+void wasm_printPtr(void* ptr) { wasm_printU32Hex((size_t)ptr); }
+
+#ifdef __cplusplus
+}
+#endif

package/{zig/core.zig → include/wasmapi.zig}

@@ -1,51 +1,93 @@
 //! JavaScript externals for https://thi.ng/wasm-api
 
+const std = @import("std");
+const root = @import("root");
+
+/// Initialize the allocator to be exposed to the WASM host env
+/// (via `_wasm_allocate()` and `_wasm_free()`).
+/// If the user defines a public `WASM_ALLOCATOR` in their root file
+/// then this allocator will be used, otherwise the implementation
+/// falls back to using GPA.
+/// Note: The type for this var is purposefully chosen as an optional,
+/// effectively disabling allocations from the WASM host side if
+/// `WASM_ALLOCATOR` is set to null.
+pub const allocator: ?std.mem.Allocator = alloc: {
+    if (@hasDecl(root, "WASM_ALLOCATOR")) {
+        break :alloc root.WASM_ALLOCATOR;
+    } else {
+        var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+        break :alloc gpa.allocator();
+    }
+};
+
+/// Attempts to allocate memory using configured `allocator` and if
+/// successful returns address of new chunk or zero if failed
+/// Note: For SIMD compatibility all allocations are aligned to 16 bytes
+pub export fn _wasm_allocate(numBytes: usize) usize {
+    if (allocator) |alloc| {
+        var mem = alloc.alignedAlloc(u8, 16, numBytes) catch return 0;
+        return @ptrToInt(mem.ptr);
+    }
+    return 0;
+}
+
+/// Frees chunk of heap memory (previously allocated using `_wasm_allocate()`)
+/// starting at given address and of given byte length.
+/// Note: This is a no-op if the allocator is explicitly disabled (see `setAllocator()`),
+pub export fn _wasm_free(addr: usize, numBytes: usize) void {
+    if (allocator) |alloc| {
+        var mem = [2]usize{ addr, numBytes };
+        printFmt("{d}", .{@ptrCast(*[]u8, &mem).*});
+        alloc.free(@ptrCast(*[]u8, &mem).*);
+    }
+}
+
 /// Prints number using configured JS logger
-pub extern fn printI8(x: i8) void;
+pub extern "wasmapi" fn printI8(x: i8) void;
 /// Prints number using configured JS logger
-pub extern fn printU8(x: u8) void;
+pub extern "wasmapi" fn printU8(x: u8) void;
 /// Prints hex number using configured JS logger
-pub extern fn printU8Hex(x: u8) void;
+pub extern "wasmapi" fn printU8Hex(x: u8) void;
 
 /// Prints number using configured JS logger
-pub extern fn printI16(x: i16) void;
+pub extern "wasmapi" fn printI16(x: i16) void;
 /// Prints number using configured JS logger
-pub extern fn printU16(x: u16) void;
+pub extern "wasmapi" fn printU16(x: u16) void;
 /// Prints hex number using configured JS logger
-pub extern fn printU16Hex(x: u16) void;
+pub extern "wasmapi" fn printU16Hex(x: u16) void;
 
 /// Prints number using configured JS logger
-pub extern fn printI32(x: i32) void;
+pub extern "wasmapi" fn printI32(x: i32) void;
 /// Prints number using configured JS logger
-pub extern fn printU32(x: u32) void;
+pub extern "wasmapi" fn printU32(x: u32) void;
 /// Prints hex number using configured JS logger
-pub extern fn printU32Hex(x: u32) void;
+pub extern "wasmapi" fn printU32Hex(x: u32) void;
 
 /// Prints decomposed i64 number using configured JS logger
-pub extern fn _printI64(hi: i32, lo: i32) void;
+pub extern "wasmapi" fn _printI64(hi: i32, lo: i32) void;
 /// Convenience wrapper for _printI64(), accepting an i64
 pub fn printI64(x: i64) void {
     _printI64(@truncate(i32, x >> 32), @truncate(i32, x));
 }
 
 /// Prints decomposed u64 number using configured JS logger
-pub extern fn _printU64(hi: u32, lo: u32) void;
+pub extern "wasmapi" fn _printU64(hi: u32, lo: u32) void;
 /// Convenience wrapper for _printU64(), accepting an u64
 pub fn printU64(x: u64) void {
     _printU64(@truncate(u32, x >> 32), @truncate(u32, x));
 }
 
 /// Prints decomposed u64 hex number using configured JS logger
-pub extern fn _printU64Hex(hi: u32, lo: u32) void;
+pub extern "wasmapi" fn _printU64Hex(hi: u32, lo: u32) void;
 /// Convenience wrapper for _printU64Hex(), accepting an u64
 pub fn printU64Hex(x: u64) void {
     _printU64Hex(@truncate(u32, x >> 32), @truncate(u32, x));
 }
 
 /// Prints number using configured JS logger
-pub extern fn printF32(x: f32) void;
+pub extern "wasmapi" fn printF32(x: f32) void;
 /// Prints number using configured JS logger
-pub extern fn printF64(x: f64) void;
+pub extern "wasmapi" fn printF64(x: f64) void;
 
 /// Prints pointer as hex number using configured JS logger
 pub fn printPtr(ptr: *const anyopaque) void {
@@ -53,25 +95,25 @@ pub fn printPtr(ptr: *const anyopaque) void {
 }
 
 /// Prints number array using configured JS logger
-pub extern fn _printI8Array(addr: usize, len: usize) void;
+pub extern "wasmapi" fn _printI8Array(addr: usize, len: usize) void;
 /// Prints number array using configured JS logger
-pub extern fn _printU8Array(addr: usize, len: usize) void;
+pub extern "wasmapi" fn _printU8Array(addr: usize, len: usize) void;
 /// Prints number array using configured JS logger
-pub extern fn _printI16Array(addr: usize, len: usize) void;
+pub extern "wasmapi" fn _printI16Array(addr: usize, len: usize) void;
 /// Prints number array using configured JS logger
-pub extern fn _printU16Array(addr: usize, len: usize) void;
+pub extern "wasmapi" fn _printU16Array(addr: usize, len: usize) void;
 /// Prints number array using configured JS logger
-pub extern fn _printI32Array(addr: usize, len: usize) void;
+pub extern "wasmapi" fn _printI32Array(addr: usize, len: usize) void;
 /// Prints number array using configured JS logger
-pub extern fn _printU32Array(addr: usize, len: usize) void;
+pub extern "wasmapi" fn _printU32Array(addr: usize, len: usize) void;
 /// Prints number array using configured JS logger
-pub extern fn _printI64Array(addr: usize, len: usize) void;
+pub extern "wasmapi" fn _printI64Array(addr: usize, len: usize) void;
 /// Prints number array using configured JS logger
-pub extern fn _printU64Array(addr: usize, len: usize) void;
+pub extern "wasmapi" fn _printU64Array(addr: usize, len: usize) void;
 /// Prints number array using configured JS logger
-pub extern fn _printF32Array(addr: usize, len: usize) void;
+pub extern "wasmapi" fn _printF32Array(addr: usize, len: usize) void;
 /// Prints number array using configured JS logger
-pub extern fn _printF64Array(addr: usize, len: usize) void;
+pub extern "wasmapi" fn _printF64Array(addr: usize, len: usize) void;
 
 /// Prints number array using configured JS logger
 pub fn printI8Array(buf: []const i8) void {
@@ -115,10 +157,18 @@ pub fn printF64Array(buf: []const f64) void {
 }
 
 /// Prints a zero-terminated string using configured JS logger
-extern fn _printStr0(addr: usize) void;
+pub extern "wasmapi" fn _printStr0(addr: usize) void;
 /// Prints a string of given length using configured JS logger
-extern fn _printStr(addr: usize, len: usize) void;
+pub extern "wasmapi" fn _printStr(addr: usize, len: usize) void;
 /// Convenience wrapper for _printStr, accepting a slice as arg
 pub fn printStr(msg: []const u8) void {
     _printStr(@ptrToInt(msg.ptr), msg.len);
 }
+
+pub fn printFmt(comptime fmt: []const u8, args: anytype) void {
+    if (allocator) |alloc| {
+        const res = std.fmt.allocPrint(alloc, fmt, args) catch return;
+        defer alloc.free(res);
+        printStr(res);
+    }
+}

package/index.d.ts

@@ -1,4 +1,8 @@
 export * from "./api.js";
 export * from "./bridge.js";
+export * from "./codegen.js";
 export * from "./object-index.js";
+export * from "./codegen/typescript.js";
+export * from "./codegen/zig.js";
+export * from "./codegen/utils.js";
 //# sourceMappingURL=index.d.ts.map

package/index.js

@@ -1,3 +1,7 @@
 export * from "./api.js";
 export * from "./bridge.js";
+export * from "./codegen.js";
 export * from "./object-index.js";
+export * from "./codegen/typescript.js";
+export * from "./codegen/zig.js";
+export * from "./codegen/utils.js";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@thi.ng/wasm-api",
-  "version": "0.3.1",
-  "description": "Modular, extensible API bridge and generic glue code between JS & WebAssembly",
+  "version": "0.6.0",
+  "description": "Generic, modular, extensible API bridge, glue code and bindings code generator for hybrid JS & WebAssembly projects",
   "type": "module",
   "module": "./index.js",
   "typings": "./index.d.ts",
@@ -31,13 +31,18 @@
     "doc:readme": "yarn doc:stats && tools:readme",
     "doc:stats": "tools:module-stats",
     "pub": "yarn npm publish --access public",
-    "test": "testament test"
+    "test": "testament test",
+    "test:build-zig": "zig build-lib -O ReleaseSmall -target wasm32-freestanding -dynamic --strip --pkg-begin wasmapi include/wasmapi.zig --pkg-end test/custom.zig && wasm-dis -o custom.wast custom.wasm && cp custom.wasm test"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.3.9",
+    "@thi.ng/api": "^8.4.0",
+    "@thi.ng/binary": "^3.3.3",
+    "@thi.ng/checks": "^3.2.4",
+    "@thi.ng/compare": "^2.1.10",
+    "@thi.ng/defmulti": "^2.1.12",
     "@thi.ng/errors": "^2.1.10",
     "@thi.ng/hex": "^2.1.9",
-    "@thi.ng/idgen": "^2.1.10",
+    "@thi.ng/idgen": "^2.1.11",
     "@thi.ng/logger": "^1.2.0"
   },
   "devDependencies": {
@@ -50,6 +55,9 @@
   },
   "keywords": [
     "api",
+    "bindings",
+    "c",
+    "codegen",
     "id",
     "logger",
     "memory",
@@ -72,7 +80,8 @@
   "files": [
     "*.js",
     "*.d.ts",
-    "*.zig"
+    "codegen",
+    "include"
   ],
   "exports": {
     ".": {
@@ -84,6 +93,18 @@
     "./bridge": {
       "default": "./bridge.js"
     },
+    "./codegen": {
+      "default": "./codegen.js"
+    },
+    "./codegen/typescript": {
+      "default": "./codegen/typescript.js"
+    },
+    "./codegen/utils": {
+      "default": "./codegen/utils.js"
+    },
+    "./codegen/zig": {
+      "default": "./codegen/zig.js"
+    },
     "./object-index": {
       "default": "./object-index.js"
     }
@@ -92,5 +113,5 @@
     "status": "alpha",
     "year": 2022
   },
-  "gitHead": "01b7a47077d88c2aefe77650ce3340040bae00ee\n"
+  "gitHead": "295e76c6f68ef34ba2117ff77612848e09f5c587\n"
 }

package/dev/custom.zig

@@ -1,12 +0,0 @@
-// Import JS core API
-const js = @import("wasmapi");
-
-/// Fill vec2 with random values
-extern fn custom_randomVec2(addr: usize) void;
-
-export fn test_random_vec2() void {
-    var foo = [2]f32{ 0, 0 };
-    js.printF32Array(foo[0..]);
-    custom_randomVec2(@ptrToInt(&foo));
-    js.printF32Array(foo[0..]);
-}

package/dev/fieldinfo.zig

@@ -1,135 +0,0 @@
-const js = @import("wasmapi");
-const std = @import("std");
-
-const Foo = struct {
-    pos: [2]f32,
-    col: [3]f32,
-    speed: u8,
-    acc: u16,
-};
-
-fn writeU32(buf: [*]u8, i: u32, x: u32) void {
-    buf[i] = @intCast(u8, x & 0xff);
-    buf[i + 1] = @intCast(u8, x >> 8 & 0xff);
-    buf[i + 2] = @intCast(u8, x >> 16 & 0xff);
-    buf[i + 3] = @intCast(u8, x >> 24);
-}
-
-const FieldType = enum(u8) {
-    I8,
-    U8,
-    I16,
-    U16,
-    I32,
-    U32,
-    F32,
-    F64,
-
-    pub fn fromTypeInfo(comptime info: std.builtin.TypeInfo) FieldType {
-        if (info == .Int) {
-            const bits = info.Int.bits;
-            if (!(bits == 8 or bits == 16 or bits == 32)) {
-                @compileError("unsupported int type (only 8, 16, 32)");
-            }
-            if (info.Int.signedness == .signed) {
-                return switch (bits) {
-                    8 => .I8,
-                    16 => .I16,
-                    32 => .I32,
-                    else => unreachable,
-                };
-            } else {
-                return switch (bits) {
-                    8 => .U8,
-                    16 => .U16,
-                    32 => .U32,
-                    else => unreachable,
-                };
-            }
-        } else if (info == .Float) {
-            return switch (info.Float.bits) {
-                32 => .F32,
-                64 => .F64,
-                else => @compileError("unsupported float type (only f32, f64)"),
-            };
-        }
-        @compileError("unsupported field type");
-    }
-};
-
-// int
-// float
-// ptr
-// array
-// slice
-
-// 8
-// 16
-// 32
-// 64
-
-const Field = packed struct {
-    name: [15]u8 = [_]u8{0} ** 15,
-    tag: FieldType = .U8,
-    offset: u32,
-    len: u32 = 0,
-
-    pub fn fromTypeInfo(comptime T: type, comptime field: std.builtin.TypeInfo.StructField) Field {
-        const finfo = @typeInfo(field.field_type);
-        var ftype: FieldType = .U8;
-        var flen = 0;
-        if (!(finfo == .Int or finfo == .Float or finfo == .Array)) {
-            @compileError("unsupported field type: " ++ @typeName(field.field_type));
-        }
-        if (finfo == .Array) {
-            const cinfo = @typeInfo(finfo.Array.child);
-            if (!(cinfo == .Int or cinfo == .Float)) {
-                @compileError("unsupported field array type: " ++ @typeName(field.field_type));
-            }
-            ftype = FieldType.fromTypeInfo(cinfo);
-            flen = finfo.Array.len;
-        } else {
-            ftype = FieldType.fromTypeInfo(finfo);
-        }
-        var res: Field = .{
-            .tag = ftype,
-            .offset = @offsetOf(T, field.name),
-            .len = flen,
-        };
-        const len = @minimum(14, field.name.len);
-        std.mem.copy(u8, res.name[0..len], field.name[0..len]);
-        return res;
-    }
-};
-
-fn writeTypeInfo(comptime T: type) []u8 {
-    const fields = @typeInfo(T).Struct.fields;
-    const fsize = @sizeOf(Field);
-    var buf: [fields.len * fsize + 4]u8 = undefined;
-    var i = 4;
-    writeU32(&buf, 0, fields.len);
-    for (fields) |field| {
-        var f = Field.fromTypeInfo(T, field);
-        std.mem.copy(
-            u8,
-            buf[i .. i + fsize],
-            @ptrCast(*[fsize]u8, &f)[0..],
-        );
-        i += fsize;
-    }
-    return buf[0..];
-}
-
-export var Foo__info = writeTypeInfo(Foo);
-export var Bar__info = writeTypeInfo(struct { x: i16, y: i16 });
-
-export var U64: u64 = 0xdecafbadcafebabe;
-export var I64: i64 = -0x8000000000000000;
-
-export fn foo() void {
-    js.printI64(I64);
-    js.printU64(U64);
-    js.printI64Array(&[_]i64{ I64, I64 });
-    js.printU32(@truncate(u32, U64 >> 32));
-    js.printU32Hex(@truncate(u32, U64 >> 32));
-}

package/dev/hello.zig

@@ -1,9 +0,0 @@
-//! Example Zig application (hello.zig)
-
-/// import externals
-/// see build command for configuration
-const js = @import("wasmapi");
-
-export fn start() void {
-    js.printStr("hello world!");
-}

package/dev/zig-cache/o/0fd683610fe16c12563bf410950c8193/builtin.zig

@@ -1,39 +0,0 @@
-const std = @import("std");
-/// Zig version. When writing code that supports multiple versions of Zig, prefer
-/// feature detection (i.e. with `@hasDecl` or `@hasField`) over version checks.
-pub const zig_version = std.SemanticVersion.parse("0.10.0-dev.3034+6fab6c3e4") catch unreachable;
-pub const zig_backend = std.builtin.CompilerBackend.stage1;
-/// Temporary until self-hosted supports the `cpu.arch` value.
-pub const stage2_arch: std.Target.Cpu.Arch = .wasm32;
-
-pub const output_mode = std.builtin.OutputMode.Lib;
-pub const link_mode = std.builtin.LinkMode.Dynamic;
-pub const is_test = false;
-pub const single_threaded = true;
-pub const abi = std.Target.Abi.musl;
-pub const cpu: std.Target.Cpu = .{
-    .arch = .wasm32,
-    .model = &std.Target.wasm.cpu.generic,
-    .features = std.Target.wasm.featureSet(&[_]std.Target.wasm.Feature{
-    }),
-};
-pub const os = std.Target.Os{
-    .tag = .freestanding,
-    .version_range = .{ .none = {} },
-};
-pub const target = std.Target{
-    .cpu = cpu,
-    .os = os,
-    .abi = abi,
-};
-pub const object_format = std.Target.ObjectFormat.wasm;
-pub const mode = std.builtin.Mode.ReleaseSmall;
-pub const link_libc = false;
-pub const link_libcpp = false;
-pub const have_error_return_tracing = false;
-pub const valgrind_support = false;
-pub const sanitize_thread = false;
-pub const position_independent_code = true;
-pub const position_independent_executable = false;
-pub const strip_debug_info = true;
-pub const code_model = std.builtin.CodeModel.default;

package/dev/zig-cache/o/85202d15b9c43c8c66de01ab98d6eb2c/builtin.zig

@@ -1,39 +0,0 @@
-const std = @import("std");
-/// Zig version. When writing code that supports multiple versions of Zig, prefer
-/// feature detection (i.e. with `@hasDecl` or `@hasField`) over version checks.
-pub const zig_version = std.SemanticVersion.parse("0.10.0-dev.3034+6fab6c3e4") catch unreachable;
-pub const zig_backend = std.builtin.CompilerBackend.stage1;
-/// Temporary until self-hosted supports the `cpu.arch` value.
-pub const stage2_arch: std.Target.Cpu.Arch = .wasm32;
-
-pub const output_mode = std.builtin.OutputMode.Lib;
-pub const link_mode = std.builtin.LinkMode.Dynamic;
-pub const is_test = false;
-pub const single_threaded = true;
-pub const abi = std.Target.Abi.musl;
-pub const cpu: std.Target.Cpu = .{
-    .arch = .wasm32,
-    .model = &std.Target.wasm.cpu.generic,
-    .features = std.Target.wasm.featureSet(&[_]std.Target.wasm.Feature{
-    }),
-};
-pub const os = std.Target.Os{
-    .tag = .freestanding,
-    .version_range = .{ .none = {} },
-};
-pub const target = std.Target{
-    .cpu = cpu,
-    .os = os,
-    .abi = abi,
-};
-pub const object_format = std.Target.ObjectFormat.wasm;
-pub const mode = std.builtin.Mode.ReleaseSmall;
-pub const link_libc = false;
-pub const link_libcpp = false;
-pub const have_error_return_tracing = false;
-pub const valgrind_support = false;
-pub const sanitize_thread = false;
-pub const position_independent_code = true;
-pub const position_independent_executable = false;
-pub const strip_debug_info = true;
-pub const code_model = std.builtin.CodeModel.default;