@spacesprotocol/libveritas 0.0.0-dev.20260326194504 → 0.0.0-dev.20260327173817

package/libveritas.d.ts

@@ -152,7 +152,7 @@ export class QueryContext {
  *
  * ```js
  * const rs = RecordSet.pack([
- *     Record.txt("btc", "bc1qtest"),
+ *     Record.txt("btc", ["bc1qtest"]),
  *     Record.blob("avatar", pngBytes),
  *     Record.unknown(0x10, raw),
  * ]);
@@ -165,6 +165,7 @@ export class Record {
     static blob(key: string, value: Uint8Array): any;
     static seq(version: bigint): any;
     static txt(key: string, value: string): any;
+    static txts(key: string, value: any): any;
     static unknown(rtype: number, rdata: Uint8Array): any;
 }
 
@@ -303,3 +304,154 @@ export function zoneIsBetterThan(a: any, b: any): boolean;
  * Serialize a zone JS object to borsh bytes for storage.
  */
 export function zoneToBytes(zone: any): Uint8Array;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly VERIFY_DEFAULT: () => number;
+    readonly VERIFY_DEV_MODE: () => number;
+    readonly VERIFY_ENABLE_SNARK: () => number;
+    readonly __wbg_anchors_free: (a: number, b: number) => void;
+    readonly __wbg_lookup_free: (a: number, b: number) => void;
+    readonly __wbg_message_free: (a: number, b: number) => void;
+    readonly __wbg_messagebuilder_free: (a: number, b: number) => void;
+    readonly __wbg_offchainrecords_free: (a: number, b: number) => void;
+    readonly __wbg_querycontext_free: (a: number, b: number) => void;
+    readonly __wbg_recordset_free: (a: number, b: number) => void;
+    readonly __wbg_verifiedmessage_free: (a: number, b: number) => void;
+    readonly __wbg_veritas_free: (a: number, b: number) => void;
+    readonly anchors_computeTrustSet: (a: number) => [number, number, number];
+    readonly anchors_from_json: (a: number, b: number) => [number, number, number];
+    readonly createCertificateChain: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+    readonly decodeZone: (a: number, b: number) => [number, number, number];
+    readonly decode_certificate: (a: number, b: number) => [number, number, number];
+    readonly hash_signable_message: (a: number, b: number) => [number, number];
+    readonly lookup_advance: (a: number, b: any) => [number, number, number, number];
+    readonly lookup_expandZones: (a: number, b: any) => [number, number, number];
+    readonly lookup_new: (a: number, b: number) => [number, number, number];
+    readonly lookup_start: (a: number) => [number, number];
+    readonly message_from_bytes: (a: number, b: number) => [number, number, number];
+    readonly message_to_bytes: (a: number) => [number, number];
+    readonly message_update: (a: number, b: any) => [number, number];
+    readonly messagebuilder_addCert: (a: number, b: number, c: number) => [number, number];
+    readonly messagebuilder_addChain: (a: number, b: number, c: number) => [number, number];
+    readonly messagebuilder_addHandle: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+    readonly messagebuilder_addRecords: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+    readonly messagebuilder_addUpdate: (a: number, b: any) => [number, number];
+    readonly messagebuilder_build: (a: number, b: number, c: number) => [number, number, number];
+    readonly messagebuilder_chain_proof_request: (a: number) => [number, number, number];
+    readonly messagebuilder_new: () => number;
+    readonly offchainrecords_from: (a: number, b: number, c: number) => [number, number, number, number];
+    readonly querycontext_add_request: (a: number, b: number, c: number) => [number, number];
+    readonly querycontext_add_zone: (a: number, b: number, c: number) => [number, number];
+    readonly querycontext_new: () => number;
+    readonly record_blob: (a: number, b: number, c: number, d: number) => any;
+    readonly record_seq: (a: bigint) => any;
+    readonly record_txt: (a: number, b: number, c: number, d: number) => any;
+    readonly record_txts: (a: number, b: number, c: any) => any;
+    readonly record_unknown: (a: number, b: number, c: number) => any;
+    readonly recordset_isEmpty: (a: number) => number;
+    readonly recordset_new: (a: number, b: number) => number;
+    readonly recordset_pack: (a: any) => [number, number, number];
+    readonly recordset_signingId: (a: number) => [number, number];
+    readonly recordset_toBytes: (a: number) => [number, number];
+    readonly recordset_unpack: (a: number) => [number, number, number];
+    readonly verifiedmessage_certificates: (a: number) => [number, number];
+    readonly verifiedmessage_message: (a: number) => number;
+    readonly verifiedmessage_message_bytes: (a: number) => [number, number];
+    readonly verifiedmessage_rootId: (a: number) => [number, number];
+    readonly verifiedmessage_zones: (a: number) => [number, number, number];
+    readonly verify_schnorr: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
+    readonly verify_spaces_message: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
+    readonly veritas_computeTrustSet: (a: number) => [number, number, number];
+    readonly veritas_is_finalized: (a: number, b: number) => number;
+    readonly veritas_new: (a: number) => [number, number, number];
+    readonly veritas_newest_anchor: (a: number) => number;
+    readonly veritas_oldest_anchor: (a: number) => number;
+    readonly veritas_sovereignty_for: (a: number, b: number) => [number, number];
+    readonly veritas_verify: (a: number, b: number, c: number) => [number, number, number];
+    readonly veritas_verifyWithOptions: (a: number, b: number, c: number, d: number) => [number, number, number];
+    readonly zoneIsBetterThan: (a: any, b: any) => [number, number, number];
+    readonly zoneToBytes: (a: any) => [number, number, number, number];
+    readonly sys_alloc_aligned: (a: number, b: number) => number;
+    readonly sys_alloc_words: (a: number) => number;
+    readonly sys_argc: () => number;
+    readonly sys_log: (a: number, b: number) => void;
+    readonly sys_argv: (a: number, b: number, c: number) => number;
+    readonly sys_bigint: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly sys_bigint2_1: (a: number, b: number) => void;
+    readonly sys_bigint2_2: (a: number, b: number, c: number) => void;
+    readonly sys_bigint2_3: (a: number, b: number, c: number, d: number) => void;
+    readonly sys_bigint2_4: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly sys_bigint2_5: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly sys_bigint2_6: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly sys_cycle_count: () => bigint;
+    readonly sys_exit: (a: number) => void;
+    readonly sys_fork: () => number;
+    readonly sys_getenv: (a: number, b: number, c: number, d: number) => number;
+    readonly sys_halt: (a: number, b: number) => void;
+    readonly sys_input: (a: number) => number;
+    readonly sys_keccak: (a: number, b: number) => number;
+    readonly sys_pause: (a: number, b: number) => void;
+    readonly sys_pipe: (a: number) => number;
+    readonly sys_poseidon2: (a: number, b: number, c: number, d: number) => void;
+    readonly sys_prove_keccak: (a: number, b: number) => void;
+    readonly sys_rand: (a: number, b: number) => void;
+    readonly sys_read: (a: number, b: number, c: number) => number;
+    readonly sys_sha_buffer: (a: number, b: number, c: number, d: number) => void;
+    readonly sys_sha_compress: (a: number, b: number, c: number, d: number) => void;
+    readonly sys_verify_integrity: (a: number, b: number) => void;
+    readonly sys_write: (a: number, b: number, c: number) => void;
+    readonly syscall_0: (a: number, b: number, c: number, d: number) => void;
+    readonly syscall_0_nr: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly syscall_1: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly syscall_1_nr: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly syscall_2: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly syscall_2_nr: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly syscall_3: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly syscall_3_nr: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+    readonly syscall_4: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+    readonly syscall_4_nr: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
+    readonly syscall_5: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
+    readonly syscall_5_nr: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
+    readonly rustsecp256k1_v0_10_0_context_create: (a: number) => number;
+    readonly rustsecp256k1_v0_10_0_context_destroy: (a: number) => void;
+    readonly rustsecp256k1_v0_10_0_default_error_callback_fn: (a: number, b: number) => void;
+    readonly rustsecp256k1_v0_10_0_default_illegal_callback_fn: (a: number, b: number) => void;
+    readonly sys_panic: (a: number, b: number) => void;
+    readonly sys_verify_integrity2: (a: number, b: number) => void;
+    readonly sys_read_words: (a: number, b: number, c: number) => number;
+    readonly __wbg_record_free: (a: number, b: number) => void;
+    readonly __wbindgen_malloc: (a: number, b: number) => number;
+    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_exn_store: (a: number) => void;
+    readonly __externref_table_alloc: () => number;
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __externref_table_dealloc: (a: number) => void;
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    readonly __externref_drop_slice: (a: number, b: number) => void;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

package/libveritas.js

@@ -1,6 +1,6 @@
 /* @ts-self-types="./libveritas.d.ts" */
 
-class Anchors {
+export class Anchors {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
@@ -37,12 +37,11 @@ class Anchors {
     }
 }
 if (Symbol.dispose) Anchors.prototype[Symbol.dispose] = Anchors.prototype.free;
-exports.Anchors = Anchors;
 
 /**
  * Batched iterative resolver for nested handle names.
  */
-class Lookup {
+export class Lookup {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
@@ -107,12 +106,11 @@ class Lookup {
     }
 }
 if (Symbol.dispose) Lookup.prototype[Symbol.dispose] = Lookup.prototype.free;
-exports.Lookup = Lookup;
 
 /**
  * A message containing chain proofs and handle data.
  */
-class Message {
+export class Message {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
         const obj = Object.create(Message.prototype);
@@ -177,12 +175,11 @@ class Message {
     }
 }
 if (Symbol.dispose) Message.prototype[Symbol.dispose] = Message.prototype.free;
-exports.Message = Message;
 
 /**
  * Builder for constructing messages from update requests and chain proofs.
  */
-class MessageBuilder {
+export class MessageBuilder {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
@@ -303,7 +300,6 @@ class MessageBuilder {
     }
 }
 if (Symbol.dispose) MessageBuilder.prototype[Symbol.dispose] = MessageBuilder.prototype.free;
-exports.MessageBuilder = MessageBuilder;
 
 /**
  * Helpers for constructing OffchainRecords (signed record sets).
@@ -314,7 +310,7 @@ exports.MessageBuilder = MessageBuilder;
  * const bytes = OffchainRecords.from(rs, sig);
  * ```
  */
-class OffchainRecords {
+export class OffchainRecords {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
@@ -345,9 +341,8 @@ class OffchainRecords {
     }
 }
 if (Symbol.dispose) OffchainRecords.prototype[Symbol.dispose] = OffchainRecords.prototype.free;
-exports.OffchainRecords = OffchainRecords;
 
-class QueryContext {
+export class QueryContext {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
@@ -391,20 +386,19 @@ class QueryContext {
     }
 }
 if (Symbol.dispose) QueryContext.prototype[Symbol.dispose] = QueryContext.prototype.free;
-exports.QueryContext = QueryContext;
 
 /**
  * Record constructors for building a RecordSet.
  *
  * ```js
  * const rs = RecordSet.pack([
- *     Record.txt("btc", "bc1qtest"),
+ *     Record.txt("btc", ["bc1qtest"]),
  *     Record.blob("avatar", pngBytes),
  *     Record.unknown(0x10, raw),
  * ]);
  * ```
  */
-class Record {
+export class Record {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
@@ -449,6 +443,17 @@ class Record {
         const ret = wasm.record_txt(ptr0, len0, ptr1, len1);
         return ret;
     }
+    /**
+     * @param {string} key
+     * @param {any} value
+     * @returns {any}
+     */
+    static txts(key, value) {
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.record_txts(ptr0, len0, value);
+        return ret;
+    }
     /**
      * @param {number} rtype
      * @param {Uint8Array} rdata
@@ -462,7 +467,6 @@ class Record {
     }
 }
 if (Symbol.dispose) Record.prototype[Symbol.dispose] = Record.prototype.free;
-exports.Record = Record;
 
 /**
  * SIP-7 record set — wire-format encoded records.
@@ -477,7 +481,7 @@ exports.Record = Record;
  * for (const r of rs.unpack()) { ... }
  * ```
  */
-class RecordSet {
+export class RecordSet {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
         const obj = Object.create(RecordSet.prototype);
@@ -559,39 +563,35 @@ class RecordSet {
     }
 }
 if (Symbol.dispose) RecordSet.prototype[Symbol.dispose] = RecordSet.prototype.free;
-exports.RecordSet = RecordSet;
 
 /**
  * @returns {number}
  */
-function VERIFY_DEFAULT() {
+export function VERIFY_DEFAULT() {
     const ret = wasm.VERIFY_DEFAULT();
     return ret >>> 0;
 }
-exports.VERIFY_DEFAULT = VERIFY_DEFAULT;
 
 /**
  * @returns {number}
  */
-function VERIFY_DEV_MODE() {
+export function VERIFY_DEV_MODE() {
     const ret = wasm.VERIFY_DEV_MODE();
     return ret >>> 0;
 }
-exports.VERIFY_DEV_MODE = VERIFY_DEV_MODE;
 
 /**
  * @returns {number}
  */
-function VERIFY_ENABLE_SNARK() {
+export function VERIFY_ENABLE_SNARK() {
     const ret = wasm.VERIFY_ENABLE_SNARK();
     return ret >>> 0;
 }
-exports.VERIFY_ENABLE_SNARK = VERIFY_ENABLE_SNARK;
 
 /**
  * Result of verifying a message.
  */
-class VerifiedMessage {
+export class VerifiedMessage {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
         const obj = Object.create(VerifiedMessage.prototype);
@@ -660,9 +660,8 @@ class VerifiedMessage {
     }
 }
 if (Symbol.dispose) VerifiedMessage.prototype[Symbol.dispose] = VerifiedMessage.prototype.free;
-exports.VerifiedMessage = VerifiedMessage;
 
-class Veritas {
+export class Veritas {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
@@ -767,7 +766,6 @@ class Veritas {
     }
 }
 if (Symbol.dispose) Veritas.prototype[Symbol.dispose] = Veritas.prototype.free;
-exports.Veritas = Veritas;
 
 /**
  * Create a .spacecert file from a subject name and certificate bytes.
@@ -777,7 +775,7 @@ exports.Veritas = Veritas;
  * @param {Uint8Array[]} cert_bytes_list
  * @returns {Uint8Array}
  */
-function createCertificateChain(subject, cert_bytes_list) {
+export function createCertificateChain(subject, cert_bytes_list) {
     const ptr0 = passStringToWasm0(subject, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
     const ptr1 = passArrayJsValueToWasm0(cert_bytes_list, wasm.__wbindgen_malloc);
@@ -790,14 +788,13 @@ function createCertificateChain(subject, cert_bytes_list) {
     wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
     return v3;
 }
-exports.createCertificateChain = createCertificateChain;
 
 /**
  * Decode stored zone bytes to a plain JS object.
  * @param {Uint8Array} bytes
  * @returns {any}
  */
-function decodeZone(bytes) {
+export function decodeZone(bytes) {
     const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
     const ret = wasm.decodeZone(ptr0, len0);
@@ -806,14 +803,13 @@ function decodeZone(bytes) {
     }
     return takeFromExternrefTable0(ret[0]);
 }
-exports.decodeZone = decodeZone;
 
 /**
  * Decode stored certificate bytes to a JS object.
  * @param {Uint8Array} bytes
  * @returns {any}
  */
-function decode_certificate(bytes) {
+export function decode_certificate(bytes) {
     const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
     const ret = wasm.decode_certificate(ptr0, len0);
@@ -822,7 +818,6 @@ function decode_certificate(bytes) {
     }
     return takeFromExternrefTable0(ret[0]);
 }
-exports.decode_certificate = decode_certificate;
 
 /**
  * Hash a message with the Spaces signed-message prefix (SHA256).
@@ -830,7 +825,7 @@ exports.decode_certificate = decode_certificate;
  * @param {Uint8Array} msg
  * @returns {Uint8Array}
  */
-function hash_signable_message(msg) {
+export function hash_signable_message(msg) {
     const ptr0 = passArray8ToWasm0(msg, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
     const ret = wasm.hash_signable_message(ptr0, len0);
@@ -838,7 +833,6 @@ function hash_signable_message(msg) {
     wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
     return v2;
 }
-exports.hash_signable_message = hash_signable_message;
 
 /**
  * Verify a raw Schnorr signature (no prefix, caller provides the 32-byte message hash).
@@ -846,7 +840,7 @@ exports.hash_signable_message = hash_signable_message;
  * @param {Uint8Array} signature
  * @param {Uint8Array} pubkey
  */
-function verify_schnorr(msg_hash, signature, pubkey) {
+export function verify_schnorr(msg_hash, signature, pubkey) {
     const ptr0 = passArray8ToWasm0(msg_hash, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
     const ptr1 = passArray8ToWasm0(signature, wasm.__wbindgen_malloc);
@@ -858,7 +852,6 @@ function verify_schnorr(msg_hash, signature, pubkey) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
-exports.verify_schnorr = verify_schnorr;
 
 /**
  * Verify a Schnorr signature over a message using the Spaces signed-message prefix.
@@ -866,7 +859,7 @@ exports.verify_schnorr = verify_schnorr;
  * @param {Uint8Array} signature
  * @param {Uint8Array} pubkey
  */
-function verify_spaces_message(msg, signature, pubkey) {
+export function verify_spaces_message(msg, signature, pubkey) {
     const ptr0 = passArray8ToWasm0(msg, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
     const ptr1 = passArray8ToWasm0(signature, wasm.__wbindgen_malloc);
@@ -878,7 +871,6 @@ function verify_spaces_message(msg, signature, pubkey) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
-exports.verify_spaces_message = verify_spaces_message;
 
 /**
  * Compare two zones — returns true if `a` is fresher/better than `b`.
@@ -886,21 +878,20 @@ exports.verify_spaces_message = verify_spaces_message;
  * @param {any} b
  * @returns {boolean}
  */
-function zoneIsBetterThan(a, b) {
+export function zoneIsBetterThan(a, b) {
     const ret = wasm.zoneIsBetterThan(a, b);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
     return ret[0] !== 0;
 }
-exports.zoneIsBetterThan = zoneIsBetterThan;
 
 /**
  * Serialize a zone JS object to borsh bytes for storage.
  * @param {any} zone
  * @returns {Uint8Array}
  */
-function zoneToBytes(zone) {
+export function zoneToBytes(zone) {
     const ret = wasm.zoneToBytes(zone);
     if (ret[3]) {
         throw takeFromExternrefTable0(ret[2]);
@@ -909,7 +900,6 @@ function zoneToBytes(zone) {
     wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
     return v1;
 }
-exports.zoneToBytes = zoneToBytes;
 
 function __wbg_get_imports() {
     const import0 = {
@@ -929,6 +919,10 @@ function __wbg_get_imports() {
             const ret = arg0 === null;
             return ret;
         },
+        __wbg___wbindgen_is_string_7ef6b97b02428fae: function(arg0) {
+            const ret = typeof(arg0) === 'string';
+            return ret;
+        },
         __wbg___wbindgen_is_undefined_52709e72fb9f179c: function(arg0) {
             const ret = arg0 === undefined;
             return ret;
@@ -962,6 +956,10 @@ function __wbg_get_imports() {
             const ret = arg0[arg1 >>> 0];
             return ret;
         },
+        __wbg_isArray_33b91feb269ff46e: function(arg0) {
+            const ret = Array.isArray(arg0);
+            return ret;
+        },
         __wbg_length_b3416cf66a5452c8: function(arg0) {
             const ret = arg0.length;
             return ret;
@@ -986,6 +984,10 @@ function __wbg_get_imports() {
             const ret = new Uint8Array(arg0 >>> 0);
             return ret;
         },
+        __wbg_of_8bf7ed3eca00ea43: function(arg0) {
+            const ret = Array.of(arg0);
+            return ret;
+        },
         __wbg_parse_e9eddd2a82c706eb: function() { return handleError(function (arg0, arg1) {
             const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
             return ret;
@@ -1259,7 +1261,15 @@ function takeFromExternrefTable0(idx) {
 
 let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
 cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
 function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
     return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
 }
 
@@ -1278,8 +1288,95 @@ if (!('encodeInto' in cachedTextEncoder)) {
 
 let WASM_VECTOR_LEN = 0;
 
-const wasmPath = `${__dirname}/libveritas_bg.wasm`;
-const wasmBytes = require('fs').readFileSync(wasmPath);
-const wasmModule = new WebAssembly.Module(wasmBytes);
-let wasm = new WebAssembly.Instance(wasmModule, __wbg_get_imports()).exports;
-wasm.__wbindgen_start();
+let wasmModule, wasm;
+function __wbg_finalize_init(instance, module) {
+    wasm = instance.exports;
+    wasmModule = module;
+    cachedDataViewMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+    wasm.__wbindgen_start();
+    return wasm;
+}
+
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+            } catch (e) {
+                const validResponse = module.ok && expectedResponseType(module.type);
+
+                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else { throw e; }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+        } else {
+            return instance;
+        }
+    }
+
+    function expectedResponseType(type) {
+        switch (type) {
+            case 'basic': case 'cors': case 'default': return true;
+        }
+        return false;
+    }
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module !== undefined) {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({module} = module)
+        } else {
+            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+        }
+    }
+
+    const imports = __wbg_get_imports();
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+    const instance = new WebAssembly.Instance(module, imports);
+    return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module_or_path !== undefined) {
+        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+            ({module_or_path} = module_or_path)
+        } else {
+            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+        }
+    }
+
+    if (module_or_path === undefined) {
+        module_or_path = new URL('libveritas_bg.wasm', import.meta.url);
+    }
+    const imports = __wbg_get_imports();
+
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        module_or_path = fetch(module_or_path);
+    }
+
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+export { initSync, __wbg_init as default };

package/package.json

@@ -1,11 +1,21 @@
 {
   "name": "@spacesprotocol/libveritas",
-  "version": "0.0.0-dev.20260326194504",
+  "type": "module",
+  "version": "0.0.0-dev.20260327173817",
   "files": [
     "libveritas_bg.wasm",
     "libveritas.js",
     "libveritas.d.ts"
   ],
   "main": "libveritas.js",
-  "types": "libveritas.d.ts"
+  "types": "libveritas.d.ts",
+  "sideEffects": [
+    "./snippets/*"
+  ],
+  "exports": {
+    ".": {
+      "node": "./node.js",
+      "default": "./libveritas.js"
+    }
+  }
 }