@fairfox/polly 0.22.0 → 0.24.0

package/dist/src/shared/lib/blob-store-impl.d.ts

@@ -0,0 +1,33 @@
+/**
+ * blob-store-impl — peer-to-peer blob store backed by WebRTC data channels.
+ *
+ * The store piggybacks on an existing MeshWebRTCAdapter. Blob messages ride
+ * on the same data channel as Automerge sync traffic, distinguished by a
+ * "blob-" prefix on the message type field.
+ *
+ * Lifecycle:
+ * - put:  hash-verify → cache plaintext locally → announce blob-have
+ * - get:  check cache → if miss, send blob-request(s) → receive chunks
+ *         → decrypt each chunk as it arrives → reassemble plaintext
+ *         → hash-verify → cache
+ *
+ * Encryption model: chunk-then-encrypt. The sender chunks the plaintext
+ * into 64 KiB pieces, encrypts each chunk independently under the configured
+ * key (with a fresh random nonce per chunk), and sends the sealed envelope.
+ * The receiver decrypts each chunk on arrival. Peak sender memory is ~1
+ * chunk of ciphertext at a time rather than the entire ciphertext blob.
+ *
+ * Per-op keys: callers can override the store's default encryption key per
+ * put/get via BlobTransferOptions.key. This supports per-document keys
+ * without requiring the store to track document ownership.
+ *
+ * Multi-source fetch: the get() flow requests from a single peer initially,
+ * but the re-request timer rotates through peers that have announced
+ * availability of the blob, so a transfer that stalls on one peer recovers
+ * against another.
+ */
+import type { BlobStore, BlobStoreOptions } from "./blob-store";
+import type { MeshWebRTCAdapter } from "./mesh-webrtc-adapter";
+/** Create a blob store that transfers blobs peer-to-peer over a
+ *  MeshWebRTCAdapter's data channels. */
+export declare function createBlobStore(adapter: MeshWebRTCAdapter, options?: BlobStoreOptions): BlobStore;

package/dist/src/shared/lib/blob-store.d.ts

@@ -0,0 +1,87 @@
+/**
+ * blob-store — types and interfaces for Polly's content-addressed blob storage.
+ *
+ * This file contains only type definitions and interfaces. It has no runtime
+ * imports from tweetnacl or other crypto libraries, so peer-only consumers
+ * tree-shake cleanly when importing from @fairfox/polly/mesh.
+ */
+import type { BlobRef } from "./blob-ref";
+export type BlobProgressPhase = "encrypting" | "uploading" | "downloading" | "decrypting";
+export interface BlobProgressEvent {
+    /** Bytes processed so far in the current phase. */
+    loaded: number;
+    /** Total bytes expected. Undefined when unknown (e.g. start of download). */
+    total: number | undefined;
+    /** Current operation phase. */
+    phase: BlobProgressPhase;
+}
+export type BlobProgressCallback = (event: BlobProgressEvent) => void;
+export interface BlobTransferOptions {
+    onProgress?: BlobProgressCallback;
+    signal?: AbortSignal;
+    /** Override the store's default encryption key for this operation.
+     *  Useful for per-document keys: pass the document's key here so the
+     *  blob is encrypted under that key rather than the store default.
+     *  Ignored if the store has no encryption configured. */
+    key?: Uint8Array;
+}
+/** Storage backend for blob bytes. Implementations must store Uint8Array
+ *  values keyed by SHA-256 hex hash without serialisation loss. */
+export interface BlobCache {
+    get(hash: string): Promise<Uint8Array | undefined>;
+    put(hash: string, bytes: Uint8Array): Promise<void>;
+    has(hash: string): Promise<boolean>;
+    delete(hash: string): Promise<void>;
+    dispose(): void;
+    /** Mark a hash as pinned — it will not be evicted until unpinned.
+     *  Applications typically pin blobs referenced by documents they
+     *  currently hold locally. */
+    pin(hash: string): Promise<void>;
+    /** Remove the pinned mark. The blob becomes eligible for eviction. */
+    unpin(hash: string): Promise<void>;
+    /** Total bytes stored in the cache. */
+    size(): Promise<number>;
+    /** Evict unpinned entries in LRU order until total size ≤ maxBytes.
+     *  Returns the number of bytes freed. */
+    evict(maxBytes: number): Promise<number>;
+}
+export interface BlobStore {
+    /** Store bytes locally and announce availability to connected peers.
+     *  Verifies that the hash of `bytes` matches `ref.hash` before storing. */
+    put(ref: BlobRef, bytes: Uint8Array, options?: BlobTransferOptions): Promise<void>;
+    /** Retrieve bytes by hash. Checks local cache first; if not cached,
+     *  requests from connected peers. Returns undefined if unavailable. */
+    get(hash: string, options?: BlobTransferOptions): Promise<Uint8Array | undefined>;
+    /** Return an object URL for rendering (e.g. <img src>). Cached per hash;
+     *  repeated calls with the same hash return the same URL. Returns
+     *  undefined if the blob is not in the local cache. All URLs are revoked
+     *  on dispose(). */
+    url(hash: string): Promise<string | undefined>;
+    /** Pin a blob so it won't be evicted. Applications should pin blobs
+     *  referenced by documents they currently hold. */
+    pin(hash: string): Promise<void>;
+    /** Unpin a blob. Removing a document that references a blob is a
+     *  natural place to unpin. */
+    unpin(hash: string): Promise<void>;
+    /** Total bytes stored in the local cache. */
+    size(): Promise<number>;
+    /** Evict unpinned entries in LRU order until total size ≤ maxBytes.
+     *  Returns bytes freed. */
+    evict(maxBytes: number): Promise<number>;
+    /** Revoke all outstanding object URLs and release resources. */
+    dispose(): void;
+}
+export interface BlobStoreOptions {
+    /** Maximum blob size in bytes. Defaults to 100 MiB. */
+    maxBlobSize?: number;
+    /** Default encryption config. When configured, blobs are encrypted
+     *  with this key unless overridden per-op via BlobTransferOptions.key.
+     *  Omit for plaintext transfer (DTLS only). */
+    encrypt?: {
+        key: Uint8Array;
+    };
+    /** Custom cache implementation. Defaults to MemoryBlobCache (suitable
+     *  for tests and Node). Browser consumers should pass an
+     *  IndexedDBBlobCache instance. */
+    cache?: BlobCache;
+}

package/dist/src/shared/lib/blob-transfer.d.ts

@@ -0,0 +1,58 @@
+/**
+ * blob-transfer — chunking, reassembly, and wire format for peer-to-peer
+ * blob transfer over WebRTC data channels.
+ *
+ * Blobs are split into fixed-size chunks (64 KiB) and sent as individual
+ * data channel messages. The wire format reuses the same length-prefixed
+ * header + binary payload layout that MeshWebRTCAdapter uses for Automerge
+ * sync messages. Blob messages are distinguished by a `type` field in the
+ * JSON header that starts with "blob-".
+ *
+ * Three message types:
+ * - blob-chunk:   a single chunk of a blob transfer
+ * - blob-request: ask a peer to send chunks for a specific hash
+ * - blob-have:    announce local availability of a blob
+ */
+/** Default chunk size in bytes: 64 KiB. Stays well within WebRTC SCTP
+ *  message size limits (~256 KiB in most browsers). */
+export declare const BLOB_CHUNK_SIZE = 65536;
+/** High-water mark for RTCDataChannel.bufferedAmount. The sender pauses
+ *  when the buffer exceeds this threshold. */
+export declare const BLOB_BUFFER_HIGH_WATER: number;
+export interface BlobChunkHeader {
+    type: "blob-chunk";
+    hash: string;
+    index: number;
+    total: number;
+}
+export interface BlobRequestHeader {
+    type: "blob-request";
+    hash: string;
+    /** Chunk indices needed. Omit to request all chunks. */
+    missing?: number[];
+}
+export interface BlobHaveHeader {
+    type: "blob-have";
+    hash: string;
+}
+export type BlobMessageHeader = BlobChunkHeader | BlobRequestHeader | BlobHaveHeader;
+/** Split bytes into fixed-size chunks. The last chunk may be smaller. */
+export declare function chunkBlob(bytes: Uint8Array, chunkSize?: number): Uint8Array[];
+/** Reassemble chunks into a single Uint8Array. Throws if any chunk index
+ *  in [0, total) is missing from the map. */
+export declare function reassembleChunks(chunks: Map<number, Uint8Array>, total: number): Uint8Array;
+/** Return the indices of chunks missing from a partial chunk map. */
+export declare function missingChunkIndices(chunks: Map<number, Uint8Array>, total: number): number[];
+/** Serialise a blob message into the shared wire format:
+ *  [4-byte BE header length][JSON header bytes][binary payload].
+ *  Returns an ArrayBuffer-backed Uint8Array usable by RTCDataChannel.send. */
+export declare function serialiseBlobMessage(header: BlobMessageHeader, data?: Uint8Array): Uint8Array<ArrayBuffer>;
+/** Peek at the header of a wire-format message without full
+ *  deserialisation. Returns the parsed header and the data slice,
+ *  or undefined if the bytes are too short or malformed. */
+export declare function parseBlobMessage(bytes: Uint8Array): {
+    header: BlobMessageHeader;
+    data: Uint8Array;
+} | undefined;
+/** Check whether a wire-format message header type starts with "blob-". */
+export declare function isBlobMessageType(bytes: Uint8Array): boolean;

package/dist/src/shared/lib/crdt-specialised.d.ts

@@ -33,7 +33,7 @@
  * and the {@link MigratableState} interface. Variants differ only in the
  * `extractValue` and `applyWrite` hooks they pass.
  */
-import { Counter, type DocHandle } from "@automerge/automerge-repo";
+import { Counter, type DocHandle } from "@automerge/automerge-repo/slim";
 import type { Access } from "./access";
 import { type MigratableState } from "./migrate-primitive";
 import { type PrimitiveKind } from "./primitive-registry";

package/dist/src/shared/lib/crdt-state.d.ts

@@ -22,7 +22,7 @@
  * counters, and lists (which require type-specific operation capture to
  * preserve concurrent-edit semantics) land in Phase 1's crdt-specialised.ts.
  */
-import type { DocHandle } from "@automerge/automerge-repo";
+import type { DocHandle } from "@automerge/automerge-repo/slim";
 import type { Access } from "./access";
 import { type MigratableState } from "./migrate-primitive";
 import { type PrimitiveKind } from "./primitive-registry";

package/dist/src/shared/lib/keyring-storage.d.ts

@@ -0,0 +1,57 @@
+/**
+ * keyring-storage — persistence abstraction for {@link MeshKeyring}.
+ *
+ * The keyring itself is a plain structural object of `Map`s, `Set`s, and a
+ * signing keypair; it is deliberately not coupled to any persistence layer.
+ * This module defines a storage interface that applications implement once
+ * for their runtime (IndexedDB, the filesystem, a keychain, a secret
+ * manager, whatever) and wire into {@link createMeshClient} via its
+ * `keyring.storage` option.
+ *
+ * A canonical JSON-with-base64 serialisation is provided by
+ * {@link serialiseKeyring} and {@link deserialiseKeyring}. It is inspectable
+ * by humans, survives manual edits, and round-trips every field of the
+ * keyring. Storage implementations that write plain strings (files,
+ * localStorage, `kv` stores) can lean on these helpers; storage
+ * implementations that persist structured data (IndexedDB, a keychain API)
+ * can serialise differently if they prefer.
+ */
+import type { MeshKeyring } from "./mesh-network-adapter";
+/**
+ * A load/save pair for a single {@link MeshKeyring}. Implementations are
+ * free to choose where and how the keyring is stored; the factory only
+ * cares that `load()` returns the previously-saved keyring or `null`, and
+ * that `save(keyring)` durably persists it.
+ */
+export interface KeyringStorage {
+    /** Load the previously-saved keyring, or return `null` if none exists.
+     * Implementations may throw for truly exceptional conditions (disk
+     * errors, permission failures); a missing keyring is not exceptional. */
+    load(): Promise<MeshKeyring | null>;
+    /** Durably persist the keyring. Implementations should atomically replace
+     * any existing stored value; partial writes must not leave the store in
+     * an inconsistent state. */
+    save(keyring: MeshKeyring): Promise<void>;
+}
+/**
+ * In-memory storage. Useful for tests, ephemeral tools, and the first-run
+ * bootstrap path where the keyring only lives for the duration of the
+ * process. Calling `save` holds the keyring in a closed-over variable;
+ * `load` returns it on subsequent calls within the same process.
+ */
+export declare function memoryKeyringStorage(): KeyringStorage;
+/**
+ * Encode a {@link MeshKeyring} to a canonical JSON string. Every
+ * `Uint8Array` field (identity keys, public keys, document keys) is
+ * base64-encoded; `Map`s and `Set`s become plain objects and arrays. The
+ * output is pretty-printed so a human operator can eyeball or hand-edit
+ * the file on disk.
+ */
+export declare function serialiseKeyring(keyring: MeshKeyring): string;
+/**
+ * Decode a keyring from the format produced by {@link serialiseKeyring}.
+ * Throws with a descriptive message when the input is malformed, so
+ * corrupt storage surfaces as an actionable error rather than a silent
+ * downgrade.
+ */
+export declare function deserialiseKeyring(text: string): MeshKeyring;

package/dist/src/shared/lib/mesh-client.d.ts

@@ -0,0 +1,91 @@
+/**
+ * mesh-client — first-class factory for constructing a Polly mesh client.
+ *
+ * The mesh transport stack has five pieces that have to be wired together:
+ * a {@link MeshSignalingClient} talking to the relay server, a
+ * {@link MeshWebRTCAdapter} that owns the per-peer RTCPeerConnections, a
+ * {@link MeshNetworkAdapter} that signs and encrypts every message on the
+ * way through, an Automerge `Repo` that drives sync, and a `MeshKeyring`
+ * that holds the crypto material. Prior to this module, every consuming
+ * application had to assemble the five pieces by hand — and in Node or
+ * Bun had to monkey-patch `globalThis.WebSocket` / `globalThis.RTCPeerConnection`
+ * because the lower-level primitives reached for those globals.
+ *
+ * `createMeshClient` takes options, hands back a `MeshClient`, and also
+ * calls `configureMeshState(client.repo)` so `$meshState` works without
+ * a second setup step. The WebSocket and RTCPeerConnection implementations
+ * are injectable; defaults read from `globalThis` for browser ergonomics.
+ * The companion `@fairfox/polly/mesh/node` subpath provides a CLI bootstrap
+ * helper that wires werift (or `@roamhq/wrtc` if the consumer prefers) and
+ * a file-backed keyring store.
+ */
+import { Repo, type StorageAdapterInterface } from "@automerge/automerge-repo/slim";
+import type { KeyringStorage } from "./keyring-storage";
+import { type MeshKeyring, MeshNetworkAdapter } from "./mesh-network-adapter";
+import { MeshSignalingClient, type MeshSignalingClientOptions } from "./mesh-signaling-client";
+import { MeshWebRTCAdapter, type MeshWebRTCAdapterOptions } from "./mesh-webrtc-adapter";
+/** Options for {@link createMeshClient}. */
+export interface CreateMeshClientOptions {
+    /** Signalling-server configuration. `peerId` must be the same identity
+     * this client's keyring was paired with on other peers. */
+    signaling: {
+        url: string;
+        peerId: string;
+        /** Optional WebSocket ctor override (e.g. `ws` on old Node). Defaults
+         * to `globalThis.WebSocket`. */
+        WebSocket?: MeshSignalingClientOptions["WebSocket"];
+        /** Forwarded error callback for diagnostic UI. */
+        onError?: MeshSignalingClientOptions["onError"];
+    };
+    /** WebRTC configuration. On browsers the defaults are fine; in Node or
+     * Bun pass the `RTCPeerConnection` ctor from `werift` or `@roamhq/wrtc`. */
+    rtc?: {
+        RTCPeerConnection?: MeshWebRTCAdapterOptions["RTCPeerConnection"];
+        iceServers?: RTCIceServer[];
+        dataChannelLabel?: string;
+    };
+    /** The local peer's keyring — either a fully-constructed instance, or a
+     * persistence adapter to load one from. When a storage adapter is given
+     * and `storage.load()` resolves to `null`, the factory throws with a
+     * message pointing at the bootstrap helper in `@fairfox/polly/mesh/node`;
+     * we deliberately do not generate an identity silently. */
+    keyring: MeshKeyring | {
+        storage: KeyringStorage;
+    };
+    /** Optional Automerge-Repo storage adapter. Applications that want
+     * durable local state pass an IndexedDB adapter in browsers or a
+     * filesystem adapter in Node; omitting it keeps the Repo in-memory. */
+    repoStorage?: StorageAdapterInterface;
+    /** When `false`, signs but does not encrypt. Defaults to `true` — the
+     * full $meshState posture where the server is off the data path. */
+    encryptionEnabled?: boolean;
+}
+/** Handle returned by {@link createMeshClient}. */
+export interface MeshClient {
+    /** The Automerge Repo. `$meshState` has already been configured against
+     * this repo, so primitives just work — but the repo is exposed in case
+     * the application needs it directly (server-side cron, bulk exports,
+     * migration tools). */
+    repo: Repo;
+    /** The configured keyring. Exposed so the application can inspect or
+     * mutate it (add authorised peers, apply revocations) and then
+     * re-persist via its storage. */
+    keyring: MeshKeyring;
+    /** The signalling client. Exposed for applications that need to hook
+     * lifecycle events or send custom signalling payloads. */
+    signaling: MeshSignalingClient;
+    /** The WebRTC network adapter. Exposed for advanced use (blob store
+     * wiring, peer-connection introspection). */
+    networkAdapter: MeshNetworkAdapter;
+    /** The underlying WebRTC adapter wrapped by {@link networkAdapter}. */
+    webrtcAdapter: MeshWebRTCAdapter;
+    /** Close the signalling WebSocket, tear down every RTCPeerConnection,
+     * and shut the Repo cleanly. Idempotent. */
+    close(): Promise<void>;
+}
+/**
+ * Construct a fully-wired mesh client. Resolves once the signalling
+ * connection is open and the Repo is ready to mutate documents; WebRTC
+ * peer connections negotiate asynchronously in the background.
+ */
+export declare function createMeshClient(options: CreateMeshClientOptions): Promise<MeshClient>;

package/dist/src/shared/lib/mesh-network-adapter.d.ts

@@ -39,7 +39,7 @@
  * threading the document context through the network subsystem (which
  * needs upstream support). A follow-up will address this.
  */
-import { type Message, NetworkAdapter, type PeerId, type PeerMetadata } from "@automerge/automerge-repo";
+import { type Message, NetworkAdapter, type PeerId, type PeerMetadata } from "@automerge/automerge-repo/slim";
 import { type SigningKeyPair } from "./signing";
 /** The well-known document id used for the Phase 2 first-cut single-key
  * encryption mode. See the file-level comment for the per-document key

package/dist/src/shared/lib/mesh-signaling-client.d.ts

@@ -41,6 +41,11 @@ export interface MeshSignalingClientOptions {
     /** Optional callback for the open and close lifecycle events. */
     onOpen?: () => void;
     onClose?: () => void;
+    /** WebSocket constructor. Defaults to `globalThis.WebSocket`. Inject a
+     * different implementation (e.g. `ws` package's `WebSocket`) when running
+     * in an environment without a native WebSocket global, or to use a custom
+     * subclass for tests or instrumentation. */
+    WebSocket?: typeof WebSocket;
 }
 /**
  * Thin wrapper around a WebSocket connection to a Polly signalling server.
@@ -61,6 +66,7 @@ export declare class MeshSignalingClient {
     private readonly onClose?;
     private socket;
     private joined;
+    private readonly WebSocketCtor;
     constructor(options: MeshSignalingClientOptions);
     /**
      * Open the WebSocket and send the join message. Resolves once the

package/dist/src/shared/lib/mesh-state.d.ts

@@ -32,7 +32,7 @@
  * RTCDataChannel; for tests and for the early Phase 2 cut, an in-memory
  * loopback adapter pair satisfies the same contract.
  */
-import type { Repo } from "@automerge/automerge-repo";
+import type { Repo } from "@automerge/automerge-repo/slim";
 import type { Access } from "./access";
 import { type SpecialisedPrimitive } from "./crdt-specialised";
 import { type CrdtPrimitive } from "./crdt-state";

package/dist/src/shared/lib/mesh-webrtc-adapter.d.ts

@@ -44,7 +44,7 @@
  * - Disconnect tears down every peer connection and closes the
  *   signalling client.
  */
-import { type Message, NetworkAdapter, type PeerId, type PeerMetadata } from "@automerge/automerge-repo";
+import { type Message, NetworkAdapter, type PeerId, type PeerMetadata } from "@automerge/automerge-repo/slim";
 import type { MeshSignalingClient } from "./mesh-signaling-client";
 /** Standard STUN servers for NAT traversal. In production, callers who
  * need TURN fallback for peers behind symmetric NATs should replace this
@@ -72,6 +72,11 @@ export interface MeshWebRTCAdapterOptions {
      * that share a signalling server between multiple meshes may want
      * distinct labels per mesh. */
     dataChannelLabel?: string;
+    /** RTCPeerConnection constructor. Defaults to
+     * `globalThis.RTCPeerConnection`. Inject a different implementation
+     * (e.g. `werift` or `@roamhq/wrtc`) when running outside a browser, or
+     * to use a custom subclass for tests or instrumentation. */
+    RTCPeerConnection?: typeof RTCPeerConnection;
 }
 /**
  * Automerge-Repo NetworkAdapter backed by real WebRTC data channels.
@@ -83,9 +88,14 @@ export declare class MeshWebRTCAdapter extends NetworkAdapter {
     readonly iceServers: RTCIceServer[];
     readonly dataChannelLabel: string;
     readonly knownPeerIds: string[];
+    private readonly RTCPeerConnectionCtor;
     private readonly slots;
     private ready;
     private readyResolver;
+    /** Callback for incoming blob messages. Set by the blob store.
+     *  Called with the sender's peer ID, the raw header object, and the
+     *  binary payload (chunk data). */
+    onBlobMessage?: (peerId: string, header: Record<string, unknown>, data: Uint8Array) => void;
     constructor(options: MeshWebRTCAdapterOptions);
     isReady(): boolean;
     whenReady(): Promise<void>;
@@ -120,6 +130,15 @@ export declare class MeshWebRTCAdapter extends NetworkAdapter {
     private wireConnection;
     private wireDataChannel;
     private dispatchMessage;
+    /** Peer IDs with an open data channel, suitable for blob requests. */
+    get connectedPeerIds(): string[];
+    /** Send a pre-serialised blob message to a specific peer. Returns false
+     *  if the peer is not connected or the send buffer is above the high-water
+     *  mark (caller should retry after a delay). */
+    sendBlobMessage(peerId: string, bytes: Uint8Array<ArrayBuffer>): boolean;
+    /** Send bytes on a data channel if the buffer is below the high-water
+     *  mark. Returns true if sent, false if backpressure applies. */
+    private trySendOnChannel;
     /** Pack an Automerge Message into binary for transmission over the
      * data channel. The format mirrors MeshNetworkAdapter's internal
      * serialisation: a length-prefixed JSON header followed by the raw

package/dist/src/shared/lib/peer-relay-adapter.d.ts

@@ -25,7 +25,7 @@
  * // connectionState is a Signal<"connecting" | "connected" | "disconnected">
  * ```
  */
-import { Repo } from "@automerge/automerge-repo";
+import { Repo } from "@automerge/automerge-repo/slim";
 import { WebSocketClientAdapter } from "@automerge/automerge-repo-network-websocket";
 import { type Signal } from "@preact/signals";
 import { type MeshKeyring } from "./mesh-network-adapter";

package/dist/src/shared/lib/peer-repo-server.d.ts

@@ -34,7 +34,7 @@
  * await server.close();
  * ```
  */
-import { Repo } from "@automerge/automerge-repo";
+import { Repo } from "@automerge/automerge-repo/slim";
 import { WebSocketServerAdapter } from "@automerge/automerge-repo-network-websocket";
 import { NodeFSStorageAdapter } from "@automerge/automerge-repo-storage-nodefs";
 import * as ws from "ws";

package/dist/src/shared/lib/peer-state.d.ts

@@ -33,7 +33,7 @@
  * via the same configuration path; Phase 2's mesh adapter does the same for
  * $meshState.
  */
-import type { Repo } from "@automerge/automerge-repo";
+import type { Repo } from "@automerge/automerge-repo/slim";
 import type { Access } from "./access";
 import { type SpecialisedPrimitive } from "./crdt-specialised";
 import { type CrdtPrimitive } from "./crdt-state";

package/dist/src/shared/lib/wasm-init.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Eagerly initialise Automerge's WebAssembly runtime by pointing the library
+ * at the raw `.wasm` file shipped in `@automerge/automerge`.
+ *
+ * The `import.meta.url` pattern below is recognised by every modern bundler
+ * (Bun, Vite, webpack 5+, esbuild) as an asset reference: the `.wasm` gets
+ * copied into the consumer's output alongside the JavaScript, and the URL is
+ * rewritten to point at the copied file. `initializeWasm` then fetches and
+ * instantiates it at runtime. That keeps the WebAssembly out of the JavaScript
+ * bundle entirely — no megabyte-scale base64 string inlined per subpath — and
+ * lets the browser parse the JS and stream-compile the `.wasm` in parallel.
+ *
+ * The top-level `await` makes this module async so any consumer that
+ * transitively imports it inherits the "wait for WASM" behaviour through the
+ * import graph, without needing an explicit init call.
+ */
+export {};