@pixagram/pixahash 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pixagram SA
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,191 @@
+# @pixagram/pixahash
+
+A fast, WebAssembly-optimized **non-cryptographic** hash, compiled from Rust.
+Built for fingerprinting medium payloads (≈5–30 kB) — content IDs, deduplication,
+hash tables, bloom filters, checksums.
+
+- **Flexible output** — `uint32`, `uint64`, 128-bit, or a full 256-bit digest, as a
+  number/BigInt, raw bytes, **hex**, or **base58btc** (any bit width 1–256).
+- **Async API** — `await ready()` once, then call synchronously; or use the
+  auto-initializing `*Async` helpers.
+- **Parallel** — an isomorphic worker pool (browser Workers / Node
+  `worker_threads`) for data-parallel hashing across many items.
+- **Tiny & portable** — one ~34 kB `.wasm`, no native addons, runs in browsers,
+  bundlers, and Node ≥18.
+
+> ⚠️ **Not cryptographic.** PixaHash is a *fingerprint*. It is not collision-resistant
+> against an adversary who can choose inputs, and must **never** be used for message
+> authentication, password hashing, key derivation, or any security boundary. For
+> those, use BLAKE3, SHA-3, or Ascon. PixaHash optimizes for speed and distribution
+> quality on *non-adversarial* data.
+
+## Install
+
+```sh
+npm install @pixagram/pixahash
+```
+
+The package ships a prebuilt `.wasm`; no Rust toolchain is needed to consume it.
+
+## Quick start
+
+```js
+import { ready, hash64, hashHex, hashBase58 } from '@pixagram/pixahash';
+
+await ready();                       // load the WASM module once
+
+hash64('hello world');               // 64-bit BigInt
+hashHex(bytes, 0, 128);              // 128-bit hex string
+hashBase58(bytes, 0, 256);          // 256-bit base58btc string
+```
+
+Inputs may be a `string` (hashed as UTF-8), `Uint8Array`, `ArrayBuffer`, any
+`TypedArray`, or a `DataView`. The optional **seed** is a `number` or `bigint`
+and spans the full 64 bits (default `0`).
+
+### Without the init dance
+
+If you don't want to manage `ready()`, the `*Async` variants initialize on first
+use and resolve on the calling thread:
+
+```js
+import { hash64Async } from '@pixagram/pixahash';
+const h = await hash64Async('hello world');
+```
+
+### Streaming
+
+For data you receive in chunks:
+
+```js
+import { ready, createHasher } from '@pixagram/pixahash';
+await ready();
+
+const h = createHasher(/* seed */ 0);
+h.update(chunkA).update(chunkB);
+const id = h.digestBase58(128);
+h.free();                            // release WASM memory (or use `using`)
+```
+
+Streaming output is bit-for-bit identical to the one-shot functions.
+
+## Parallel hashing
+
+```js
+import { createPool } from '@pixagram/pixahash/pool';
+
+const pool = await createPool();                 // size = CPU count
+const ids  = await Promise.all(
+  files.map((bytes) => pool.hashHex(bytes, 0, 256))
+);
+pool.destroy();
+```
+
+Input is **copied** to the worker by default, so your buffers stay intact. For
+large inputs you can move them instead with `createPool({ transfer: true })` —
+faster, but it neuters the caller's `ArrayBuffer`. `hashMany(items, { op })` runs
+a batch on a single worker when you'd rather avoid one message per item.
+
+**When does a pool actually help?** A single 5–30 kB hash takes microseconds, so
+the worker round-trip costs more than the hash. Reach for a pool to (a) keep the
+UI thread responsive during a burst, or (b) parallelize across *many* items. For
+a one-off hash, call the sync/async API directly.
+
+## API
+
+| Function | Returns |
+| --- | --- |
+| `ready()` / `isReady()` | `Promise<void>` / `boolean` |
+| `hash32(data, seed?)` | `number` (u32) |
+| `hash64(data, seed?)` | `bigint` (u64) |
+| `hash128(data, seed?)` | `bigint` (u128) |
+| `hashHex(data, seed?, bits=128)` | hex `string` |
+| `hashBase58(data, seed?, bits=128)` | base58btc `string` |
+| `digest(data, seed?)` | `Uint8Array` (32 bytes) |
+| `*Async(...)` | the same, auto-initialized, as a `Promise` |
+| `createHasher(seed?)` → `Hasher` | streaming: `update`, `digest32/64/128/Hex/Base58/Bytes`, `free` |
+| `createPool(opts?)` → `HashPool` | parallel: same hash methods returning `Promise`s |
+
+`bits` is clamped to `1–256`. Bits beyond 128 come from a finalizer expansion and
+add output **width**, not extra collision resistance (see below).
+
+## Design
+
+Both [rapidhash](https://github.com/Nicoshev/rapidhash) and
+[museair](https://github.com/eternal-io/museair) are excellent modern hashes, and
+both lean on a 64×64→128-bit multiply (`umulh`). On native CPUs that's a single
+instruction — but **WebAssembly has no high-multiply opcode**, so each one lowers
+to four 32×32 multiplies plus carry handling. PixaHash is designed around what
+WASM *does* do in one instruction: 64-bit multiply-low, rotate, xor, and add. That
+puts it in the lineage of xxHash64 rather than the umulh-based designs.
+
+The core borrows the best ideas from each:
+
+- **xxHash64-style bulk loop** — 4 lanes, 32-byte stripes,
+  `round(acc, w) = rotl(acc + w·P2, 31)·P1`, using the xxHash primes. Multiply-low,
+  rotate, add only.
+- **museair-style ring coupling** — after each stripe the lanes are mixed in a ring
+  (`v[i] ^= rotl(v[i+1], 17)`) so every input bit reaches the *whole* state, not just
+  one lane.
+- **rapidhash-style tail + length injection** — short tails fold round-robin into the
+  lanes and the total length is mixed into all of them, killing length-extension-style
+  collisions on similar inputs.
+- **All multipliers are odd constants**, so each multiply is a bijection on `u64`
+  and can never collapse state to zero — museair's "blinding multiplication" failure
+  mode is avoided structurally, without needing its additive workaround.
+- A **Moremur** finalizer avalanches the result; for ≥32-byte inputs (the whole
+  target range) both 64-bit halves carry full entropy, giving a genuine ~128-bit
+  fingerprint. The 256-bit digest extends that width with two more Moremur rounds.
+
+### Quality (measured)
+
+From the native test harness (`cargo run --release --bin quality`):
+
+- **Avalanche** on a 10 kB input: worst single-bit bias **1.3%**, average **0.4%**
+  (well within the 5σ noise band) — flipping any input bit flips ≈half the output bits.
+- **Collisions**: 0 across 5M random 64-bit hashes; 32-bit collisions on 2M
+  structured keys land within ~2% of the ideal birthday-bound rate.
+- **Streaming == one-shot** across thousands of random chunk splits.
+- **Seed sensitivity**: changing the seed flips ≈half the bits.
+- **Throughput**: ≈**9.3 GB/s** on 20 kB inputs natively (algorithmic speed).
+
+> The `.wasm` bundled here is built **without** `wasm-opt` (binaryen wasn't available
+> in the build sandbox). It is correct and passes the full native↔WASM cross-check,
+> but for production you should rebuild with `wasm-opt` enabled (see below) for a
+> smaller, faster module.
+
+## Build from source
+
+Requires the [Rust toolchain](https://rustup.rs), the `wasm32-unknown-unknown`
+target, and [`wasm-pack`](https://rustwasm.github.io/wasm-pack/):
+
+```sh
+rustup target add wasm32-unknown-unknown
+cargo install wasm-pack
+./build.sh          # → pkg/pixahash.js + pkg/pixahash_bg.wasm
+```
+
+To enable size/speed optimization, install `binaryen` and remove the
+`wasm-opt = false` line under `[package.metadata.wasm-pack.profile.release]` in
+`Cargo.toml`, then rebuild.
+
+Run the native correctness/quality suite and the JS cross-check:
+
+```sh
+cargo run --release --no-default-features --bin quality
+node test-node.mjs
+node test-wrapper.mjs
+```
+
+### Threading roadmap
+
+The worker pool is *data parallelism*: many independent items across many threads,
+and it needs no special HTTP headers. **Parallelizing a single hash** (splitting one
+large input across threads via `wasm-bindgen-rayon` + `SharedArrayBuffer`) is on the
+roadmap; that path requires cross-origin isolation (`Cross-Origin-Opener-Policy:
+same-origin` and `Cross-Origin-Embedder-Policy: require-corp`). A `simd128` build of
+the core (identical output, gated behind the `simd` feature) is also planned.
+
+## License
+
+MIT © Pixagram SA

package/index.d.ts

@@ -0,0 +1,137 @@
+// Type definitions for @pixagram/pixahash
+
+/** Anything accepted as hashable input. Strings are hashed as UTF-8. */
+export type HashInput = string | Uint8Array | ArrayBuffer | ArrayBufferView;
+
+/** Seed value. Numbers are truncated to an integer; both wrap mod 2^64. */
+export type Seed = number | bigint;
+
+// ---------------------------------------------------------------- lifecycle
+
+/** Load + instantiate the WASM module. Idempotent and memoized. */
+export function ready(): Promise<void>;
+
+/** True once the WASM module is instantiated and the sync API is usable. */
+export function isReady(): boolean;
+
+// --------------------------------------------------------------- normalizers
+
+/** Coerce supported inputs to a Uint8Array (no copy where possible). */
+export function toBytes(input: HashInput): Uint8Array;
+
+/** Coerce a seed to a u64 BigInt (wraps mod 2^64). Default 0. */
+export function toSeed64(seed?: Seed): bigint;
+
+// ------------------------------------------------------------ sync hash API
+// Require `await ready()` first.
+
+/** 32-bit hash as a number in [0, 2^32). */
+export function hash32(data: HashInput, seed?: Seed): number;
+
+/** 64-bit hash as a BigInt. */
+export function hash64(data: HashInput, seed?: Seed): bigint;
+
+/** 128-bit hash as a BigInt. */
+export function hash128(data: HashInput, seed?: Seed): bigint;
+
+/** Hex string of the first `bits` bits of the digest (1..256, default 128). */
+export function hashHex(data: HashInput, seed?: Seed, bits?: number): string;
+
+/** base58btc string of the first `bits` bits of the digest (1..256, default 128). */
+export function hashBase58(data: HashInput, seed?: Seed, bits?: number): string;
+
+/** The full 32-byte (256-bit) digest. */
+export function digest(data: HashInput, seed?: Seed): Uint8Array;
+
+// --------------------------------------------------- async (auto-init) API
+// Ensure the module is ready, then run on the calling thread.
+
+export function hash32Async(data: HashInput, seed?: Seed): Promise<number>;
+export function hash64Async(data: HashInput, seed?: Seed): Promise<bigint>;
+export function hash128Async(data: HashInput, seed?: Seed): Promise<bigint>;
+export function hashHexAsync(data: HashInput, seed?: Seed, bits?: number): Promise<string>;
+export function hashBase58Async(data: HashInput, seed?: Seed, bits?: number): Promise<string>;
+export function digestAsync(data: HashInput, seed?: Seed): Promise<Uint8Array>;
+
+// ----------------------------------------------------------- streaming API
+
+/**
+ * Incremental hasher. Backed by WASM memory — call `free()` (or use a `using`
+ * declaration) when done. Output methods may be called repeatedly.
+ */
+export class Hasher {
+  constructor(seed?: Seed);
+  update(data: HashInput): this;
+  digest32(): number;
+  digest64(): bigint;
+  digest128(): bigint;
+  digestHex(bits?: number): string;
+  digestBase58(bits?: number): string;
+  digestBytes(bits?: number): Uint8Array;
+  free(): void;
+  [Symbol.dispose](): void;
+}
+
+export function createHasher(seed?: Seed): Hasher;
+export function createHasherAsync(seed?: Seed): Promise<Hasher>;
+
+declare const _default: {
+  ready: typeof ready;
+  isReady: typeof isReady;
+  toBytes: typeof toBytes;
+  toSeed64: typeof toSeed64;
+  hash32: typeof hash32;
+  hash64: typeof hash64;
+  hash128: typeof hash128;
+  hashHex: typeof hashHex;
+  hashBase58: typeof hashBase58;
+  digest: typeof digest;
+  hash32Async: typeof hash32Async;
+  hash64Async: typeof hash64Async;
+  hash128Async: typeof hash128Async;
+  hashHexAsync: typeof hashHexAsync;
+  hashBase58Async: typeof hashBase58Async;
+  digestAsync: typeof digestAsync;
+  Hasher: typeof Hasher;
+  createHasher: typeof createHasher;
+  createHasherAsync: typeof createHasherAsync;
+};
+export default _default;
+
+// ------------------------------------------------------------- worker pool
+// Exposed from '@pixagram/pixahash/pool'.
+
+export interface HashPoolOptions {
+  /** Number of workers. Default: CPU count (navigator.hardwareConcurrency / os.cpus). */
+  size?: number;
+  /**
+   * Move input buffers to the worker instead of copying them. Faster for large
+   * inputs but neuters the caller's ArrayBuffer. Default: false (copy).
+   */
+  transfer?: boolean;
+}
+
+export interface HashManyOptions {
+  /** Which per-item op to run. Default: "hash64". */
+  op?: "hash32" | "hash64" | "hash128" | "hashHex" | "hashBase58" | "digest";
+  seed?: Seed;
+  bits?: number;
+}
+
+export declare class HashPool {
+  constructor(opts?: HashPoolOptions);
+  readonly size: number;
+  /** Spawn the workers. Idempotent; awaited automatically by hash methods. */
+  start(): Promise<void>;
+  hash32(data: HashInput, seed?: Seed): Promise<number>;
+  hash64(data: HashInput, seed?: Seed): Promise<bigint>;
+  hash128(data: HashInput, seed?: Seed): Promise<bigint>;
+  hashHex(data: HashInput, seed?: Seed, bits?: number): Promise<string>;
+  hashBase58(data: HashInput, seed?: Seed, bits?: number): Promise<string>;
+  digest(data: HashInput, seed?: Seed): Promise<Uint8Array>;
+  hashMany(items: HashInput[], opts?: HashManyOptions): Promise<Array<number | bigint | string | Uint8Array>>;
+  destroy(): Promise<void>;
+  terminate(): Promise<void>;
+}
+
+export declare function createPool(opts?: HashPoolOptions): Promise<HashPool>;

package/index.js

@@ -0,0 +1,255 @@
+// @pixagram/pixahash — main entry.
+//
+// PixaHash is a fast, WASM-optimized *non-cryptographic* hash (a fingerprint).
+// It is NOT collision-resistant against an adversary who can choose inputs, and
+// must not be used for message authentication or as a password/KDF. Use it for
+// hash tables, deduplication, content IDs/fingerprints, bloom filters and
+// checksums. For adversarial resistance use BLAKE3 / SHA-3 / Ascon.
+//
+// Three ways to call it:
+//   1. Sync (hot path):     await ready();  hash64(bytes)
+//   2. Async (convenience): await hash64Async(bytes)   // auto-inits, same thread
+//   3. Parallel:            import { createPool } from '@pixagram/pixahash/pool'
+//
+// Inputs accept string | Uint8Array | ArrayBuffer | TypedArray | DataView.
+// Seeds accept number | bigint and span the full 64 bits.
+
+import { loadWasm } from './load.js';
+
+let wasm = null;
+let readyPromise = null;
+
+const TEXT_ENCODER = new TextEncoder();
+
+// ---------------------------------------------------------------- lifecycle
+
+/** Load + instantiate the WASM module. Idempotent and memoized. */
+export function ready() {
+  if (!readyPromise) {
+    readyPromise = loadWasm().then((w) => {
+      wasm = w;
+    });
+  }
+  return readyPromise;
+}
+
+/** True once the WASM module is instantiated and the sync API is usable. */
+export function isReady() {
+  return wasm !== null;
+}
+
+function w() {
+  if (wasm === null) {
+    throw new Error(
+      "pixahash: not initialized. `await ready()` once at startup before " +
+        "calling sync functions, or use the *Async variants / a HashPool."
+    );
+  }
+  return wasm;
+}
+
+// --------------------------------------------------------------- normalizers
+
+/** Coerce supported inputs to a Uint8Array (no copy where possible). */
+export function toBytes(input) {
+  if (typeof input === "string") return TEXT_ENCODER.encode(input);
+  if (input instanceof Uint8Array) return input;
+  if (input instanceof ArrayBuffer) return new Uint8Array(input);
+  if (ArrayBuffer.isView(input)) {
+    return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+  }
+  throw new TypeError(
+    "pixahash: data must be a string, Uint8Array, ArrayBuffer, TypedArray or DataView."
+  );
+}
+
+/** Coerce number|bigint to a u64 seed (wraps mod 2^64). Default 0. */
+export function toSeed64(seed) {
+  if (seed === undefined || seed === null) return 0n;
+  if (typeof seed === "bigint") return BigInt.asUintN(64, seed);
+  if (typeof seed === "number") {
+    if (!Number.isFinite(seed)) {
+      throw new TypeError("pixahash: numeric seed must be finite.");
+    }
+    return BigInt.asUintN(64, BigInt(Math.trunc(seed)));
+  }
+  throw new TypeError("pixahash: seed must be a number or bigint.");
+}
+
+function clampBits(bits) {
+  if (bits === undefined || bits === null) return 128;
+  const b = Math.trunc(Number(bits));
+  if (!Number.isFinite(b) || b < 1) return 1;
+  if (b > 256) return 256;
+  return b;
+}
+
+// little-endian bytes -> BigInt
+function leToBigInt(bytes, start, len) {
+  let v = 0n;
+  for (let i = len - 1; i >= 0; i--) {
+    v = (v << 8n) | BigInt(bytes[start + i]);
+  }
+  return v;
+}
+
+function hexToBytes(hex) {
+  const out = new Uint8Array(hex.length >> 1);
+  for (let i = 0; i < out.length; i++) {
+    out[i] = parseInt(hex.substr(i * 2, 2), 16);
+  }
+  return out;
+}
+
+// ------------------------------------------------------------ sync hash API
+
+/** 32-bit hash as a JS number (0 .. 2^32-1). */
+export function hash32(data, seed) {
+  const m = w();
+  const s = toSeed64(seed);
+  const bytes = toBytes(data);
+  if (s <= 0xffffffffn) {
+    return m.hash32(bytes, Number(s)); // fast path: no BigInt seed marshaling
+  }
+  // Honor seeds wider than 32 bits while matching the native fold exactly.
+  const h0 = m.hash64(bytes, s);
+  return Number(BigInt.asUintN(32, h0 ^ (h0 >> 32n)));
+}
+
+/** 64-bit hash as a BigInt. */
+export function hash64(data, seed) {
+  return w().hash64(toBytes(data), toSeed64(seed));
+}
+
+/** 128-bit hash as a BigInt. */
+export function hash128(data, seed) {
+  const d = w().digest(toBytes(data), toSeed64(seed)); // 32 LE bytes
+  return leToBigInt(d, 0, 16);
+}
+
+/** Hex string of the first `bits` bits of the digest (bits 1..256, default 128). */
+export function hashHex(data, seed, bits) {
+  return w().hashHex(toBytes(data), toSeed64(seed), clampBits(bits));
+}
+
+/** base58btc string of the first `bits` bits of the digest (bits 1..256, default 128). */
+export function hashBase58(data, seed, bits) {
+  return w().hashBase58(toBytes(data), toSeed64(seed), clampBits(bits));
+}
+
+/** The full 32-byte (256-bit) digest as a Uint8Array. */
+export function digest(data, seed) {
+  return w().digest(toBytes(data), toSeed64(seed));
+}
+
+// --------------------------------------------------- async (auto-init) API
+// These ensure the module is ready, then run on the *calling* thread. For true
+// off-main-thread parallelism use a HashPool from '@pixagram/pixahash/pool'.
+
+export async function hash32Async(data, seed) {
+  await ready();
+  return hash32(data, seed);
+}
+export async function hash64Async(data, seed) {
+  await ready();
+  return hash64(data, seed);
+}
+export async function hash128Async(data, seed) {
+  await ready();
+  return hash128(data, seed);
+}
+export async function hashHexAsync(data, seed, bits) {
+  await ready();
+  return hashHex(data, seed, bits);
+}
+export async function hashBase58Async(data, seed, bits) {
+  await ready();
+  return hashBase58(data, seed, bits);
+}
+export async function digestAsync(data, seed) {
+  await ready();
+  return digest(data, seed);
+}
+
+// ----------------------------------------------------------- streaming API
+
+/**
+ * Incremental hasher. Feed data in chunks via `update`, then read any output.
+ * Backed by a WASM object holding native memory — call `free()` (or use a
+ * `using` declaration) when done. Output methods may be called repeatedly.
+ */
+export class Hasher {
+  constructor(seed) {
+    this._h = new (w().Hasher)(toSeed64(seed));
+  }
+
+  /** Absorb a chunk. Returns `this` for chaining. */
+  update(data) {
+    this._h.update(toBytes(data));
+    return this;
+  }
+
+  digest32() {
+    return this._h.digest32();
+  }
+  digest64() {
+    return this._h.digest64();
+  }
+  digest128() {
+    return leToBigInt(hexToBytes(this._h.digestHex(128)), 0, 16);
+  }
+  digestHex(bits) {
+    return this._h.digestHex(clampBits(bits));
+  }
+  digestBase58(bits) {
+    return this._h.digestBase58(clampBits(bits));
+  }
+  /** Raw digest bytes for the first `bits` bits (default 256 → 32 bytes). */
+  digestBytes(bits) {
+    return hexToBytes(this._h.digestHex(clampBits(bits ?? 256)));
+  }
+
+  /** Release the underlying WASM memory. The instance is unusable afterward. */
+  free() {
+    if (this._h) {
+      this._h.free();
+      this._h = null;
+    }
+  }
+  [Symbol.dispose]() {
+    this.free();
+  }
+}
+
+/** Create a streaming `Hasher` (requires `await ready()` first). */
+export function createHasher(seed) {
+  return new Hasher(seed);
+}
+
+/** Create a streaming `Hasher`, ensuring the module is initialized first. */
+export async function createHasherAsync(seed) {
+  await ready();
+  return new Hasher(seed);
+}
+
+export default {
+  ready,
+  isReady,
+  toBytes,
+  toSeed64,
+  hash32,
+  hash64,
+  hash128,
+  hashHex,
+  hashBase58,
+  digest,
+  hash32Async,
+  hash64Async,
+  hash128Async,
+  hashHexAsync,
+  hashBase58Async,
+  digestAsync,
+  Hasher,
+  createHasher,
+  createHasherAsync,
+};

package/load.js

@@ -0,0 +1,27 @@
+// Shared, memoized WASM loader. Works in browsers/bundlers (relative fetch) and
+// in Node (reads the .wasm off disk, since Node's fetch can't load file: URLs).
+import init, * as wasm from './pkg/pixahash.js';
+
+let initPromise = null;
+
+export function loadWasm() {
+  if (initPromise) return initPromise;
+  initPromise = (async () => {
+    const isNode =
+      typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
+    if (isNode) {
+      const { readFile } = await import('node:fs/promises');
+      const { fileURLToPath } = await import('node:url');
+      const url = new URL('./pkg/pixahash_bg.wasm', import.meta.url);
+      const bytes = await readFile(fileURLToPath(url));
+      await init({ module_or_path: bytes });
+    } else {
+      // Browser / bundler: the glue fetches pixahash_bg.wasm next to itself.
+      await init();
+    }
+    return wasm;
+  })();
+  return initPromise;
+}
+
+export { wasm };