@waaskey/sdk 0.2.0 → 0.2.1

package/dist/index.d.cts

@@ -658,11 +658,21 @@ interface PrimePoolOptions {
     targetSize?: number;
     /** Persistence for the pool. Defaults to an in-memory store. */
     store?: PrimePoolStore;
+    /**
+     * Kick off a refill automatically after every {@link PrimePool.take}. Default `false`:
+     * unless the core generates primes in a Web Worker, wasm prime generation is a
+     * synchronous CPU burn on the calling thread — a "background" refill starves the event
+     * loop and stalls the very keygen ceremony the take() was for (it also freezes a
+     * browser UI). Refill explicitly via {@link PrimePool.ensure} (`wallets.prewarm`) at
+     * boot/idle, or set `true` only when the core is worker-backed.
+     */
+    autoRefill?: boolean;
 }
 declare class PrimePool {
     private readonly core;
     private readonly store;
     private readonly targetSize;
+    private readonly autoRefill;
     /** Per-curve in-flight refill, so concurrent calls don't over-generate. */
     private readonly refilling;
     constructor(core: PrimeGenerator, options?: PrimePoolOptions);
@@ -674,8 +684,9 @@ declare class PrimePool {
     private refill;
     /**
      * Claim a prime for a keygen. Returns a cached one instantly when the pool is warm; otherwise
-     * generates one inline (the slow fallback) so keygen never fails on an empty pool. Either way it
-     * kicks off a background refill so the next wallet is instant.
+     * generates one inline (the slow fallback) so keygen never fails on an empty pool. Refill the
+     * pool for the next wallet via {@link ensure} at idle (or opt into `autoRefill` when the core
+     * is worker-backed).
      */
     take(curve: MpcCurve): Promise<string>;
 }

package/dist/index.d.ts

@@ -658,11 +658,21 @@ interface PrimePoolOptions {
     targetSize?: number;
     /** Persistence for the pool. Defaults to an in-memory store. */
     store?: PrimePoolStore;
+    /**
+     * Kick off a refill automatically after every {@link PrimePool.take}. Default `false`:
+     * unless the core generates primes in a Web Worker, wasm prime generation is a
+     * synchronous CPU burn on the calling thread — a "background" refill starves the event
+     * loop and stalls the very keygen ceremony the take() was for (it also freezes a
+     * browser UI). Refill explicitly via {@link PrimePool.ensure} (`wallets.prewarm`) at
+     * boot/idle, or set `true` only when the core is worker-backed.
+     */
+    autoRefill?: boolean;
 }
 declare class PrimePool {
     private readonly core;
     private readonly store;
     private readonly targetSize;
+    private readonly autoRefill;
     /** Per-curve in-flight refill, so concurrent calls don't over-generate. */
     private readonly refilling;
     constructor(core: PrimeGenerator, options?: PrimePoolOptions);
@@ -674,8 +684,9 @@ declare class PrimePool {
     private refill;
     /**
      * Claim a prime for a keygen. Returns a cached one instantly when the pool is warm; otherwise
-     * generates one inline (the slow fallback) so keygen never fails on an empty pool. Either way it
-     * kicks off a background refill so the next wallet is instant.
+     * generates one inline (the slow fallback) so keygen never fails on an empty pool. Refill the
+     * pool for the next wallet via {@link ensure} at idle (or opt into `autoRefill` when the core
+     * is worker-backed).
      */
     take(curve: MpcCurve): Promise<string>;
 }

package/dist/index.js

@@ -2298,10 +2298,12 @@ var PrimePool = class {
     this.core = core;
     this.store = options.store ?? new MemoryPrimeStore();
     this.targetSize = Math.max(1, options.targetSize ?? 2);
+    this.autoRefill = options.autoRefill ?? false;
   }
   core;
   store;
   targetSize;
+  autoRefill;
   /** Per-curve in-flight refill, so concurrent calls don't over-generate. */
   refilling = /* @__PURE__ */ new Map();
   /**
@@ -2322,13 +2324,14 @@ var PrimePool = class {
   }
   /**
    * Claim a prime for a keygen. Returns a cached one instantly when the pool is warm; otherwise
-   * generates one inline (the slow fallback) so keygen never fails on an empty pool. Either way it
-   * kicks off a background refill so the next wallet is instant.
+   * generates one inline (the slow fallback) so keygen never fails on an empty pool. Refill the
+   * pool for the next wallet via {@link ensure} at idle (or opt into `autoRefill` when the core
+   * is worker-backed).
    */
   async take(curve) {
     const cached = await this.store.take(curve);
     const primes = cached ?? await this.core.pregeneratePrimes(curve);
-    void this.ensure(curve).catch(() => void 0);
+    if (this.autoRefill) void this.ensure(curve).catch(() => void 0);
     return primes;
   }
 };