@miden-sdk/miden-sdk 0.15.0-alpha.4 → 0.15.0-alpha.6

package/dist/{index.js → st/index.js}

@@ -1,9 +1,10 @@
 import loadWasm from './wasm.js';
-export { Account, AccountArray, AccountBuilder, AccountBuilderResult, AccountCode, AccountComponent, AccountComponentCode, AccountDelta, AccountFile, AccountHeader, AccountId, AccountIdArray, AccountInterface, AccountProof, AccountReader, AccountStatus, AccountStorage, AccountStorageDelta, AccountStorageMode, AccountStorageRequirements, AccountVaultDelta, Address, AdviceInputs, AdviceMap, AssetVault, AuthFalcon512RpoMultisigConfig, AuthSecretKey, BasicFungibleFaucetComponent, BlockHeader, CodeBuilder, CommittedNote, ConsumableNoteRecord, Endpoint, ExecutedTransaction, Felt, FeltArray, FetchedAccount, FetchedNote, FlattenedU8Vec, ForeignAccount, ForeignAccountArray, FungibleAsset, FungibleAssetDelta, FungibleAssetDeltaItem, GetProceduresResultItem, InputNote, InputNoteRecord, InputNoteState, InputNotes, IntoUnderlyingByteSource, IntoUnderlyingSink, IntoUnderlyingSource, JsAccountUpdate, JsStateSyncUpdate, JsStorageMapEntry, JsStorageSlot, JsVaultAsset, Library, MerklePath, NetworkId, NetworkNoteStatusInfo, NetworkType, Note, NoteAndArgs, NoteAndArgsArray, NoteArray, NoteAssets, NoteAttachment, NoteAttachmentKind, NoteAttachmentScheme, NoteConsumability, NoteConsumptionStatus, NoteDetails, NoteDetailsAndTag, NoteDetailsAndTagArray, NoteExecutionHint, NoteExportFormat, NoteFile, NoteFilter, NoteFilterTypes, NoteHeader, NoteId, NoteIdAndArgs, NoteIdAndArgsArray, NoteInclusionProof, NoteLocation, NoteMetadata, NoteRecipient, NoteRecipientArray, NoteScript, NoteStorage, NoteSyncBlock, NoteSyncInfo, NoteTag, NoteType, OutputNote, OutputNoteArray, OutputNoteRecord, OutputNoteState, OutputNotes, Package, PartialNote, Poseidon2, ProcedureThreshold, Program, ProvenTransaction, PublicKey, RpcClient, Rpo256, SerializedInputNoteData, SerializedOutputNoteData, SerializedTransactionData, Signature, SigningInputs, SigningInputsType, SlotAndKeys, SparseMerklePath, StorageMap, StorageMapEntry, StorageMapEntryJs, StorageMapInfo, StorageMapUpdate, StorageSlot, StorageSlotArray, SyncSummary, TestUtils, TokenSymbol, TransactionArgs, TransactionFilter, TransactionId, TransactionProver, TransactionRecord, TransactionRequest, TransactionRequestBuilder, TransactionResult, TransactionScript, TransactionScriptInputPair, TransactionScriptInputPairArray, TransactionStatus, TransactionStoreUpdate, TransactionSummary, WebClient, WebKeystoreApi, Word, createAuthFalcon512RpoMultisig, exportStore, importStore, initSync, setupLogging } from './Cargo-CVlXCH_2.js';
+export { Account, AccountArray, AccountBuilder, AccountBuilderResult, AccountCode, AccountComponent, AccountComponentCode, AccountDelta, AccountFile, AccountHeader, AccountId, AccountIdArray, AccountInterface, AccountProof, AccountReader, AccountStatus, AccountStorage, AccountStorageDelta, AccountStorageMode, AccountStorageRequirements, AccountVaultDelta, Address, AdviceInputs, AdviceMap, AssetVault, AuthFalcon512RpoMultisigConfig, AuthSecretKey, BasicFungibleFaucetComponent, BlockHeader, CodeBuilder, CommittedNote, ConsumableNoteRecord, Endpoint, ExecutedTransaction, Felt, FeltArray, FetchedAccount, FetchedNote, FlattenedU8Vec, ForeignAccount, ForeignAccountArray, FungibleAsset, FungibleAssetDelta, FungibleAssetDeltaItem, GetProceduresResultItem, InputNote, InputNoteRecord, InputNoteState, InputNotes, IntoUnderlyingByteSource, IntoUnderlyingSink, IntoUnderlyingSource, JsAccountUpdate, JsStateSyncUpdate, JsStorageMapEntry, JsStorageSlot, JsVaultAsset, Library, MerklePath, NetworkId, NetworkNoteStatusInfo, NetworkType, Note, NoteAndArgs, NoteAndArgsArray, NoteArray, NoteAssets, NoteAttachment, NoteAttachmentScheme, NoteConsumability, NoteConsumptionStatus, NoteDetails, NoteDetailsAndTag, NoteDetailsAndTagArray, NoteExecutionHint, NoteExportFormat, NoteFile, NoteFilter, NoteFilterTypes, NoteHeader, NoteId, NoteIdAndArgs, NoteIdAndArgsArray, NoteInclusionProof, NoteLocation, NoteMetadata, NoteRecipient, NoteRecipientArray, NoteScript, NoteStorage, NoteSyncBlock, NoteSyncInfo, NoteTag, NoteType, OutputNote, OutputNoteArray, OutputNoteRecord, OutputNoteState, OutputNotes, Package, PartialNote, Poseidon2, ProcedureThreshold, Program, ProvenTransaction, PublicKey, RpcClient, Rpo256, SerializedInputNoteData, SerializedOutputNoteData, SerializedTransactionData, Signature, SigningInputs, SigningInputsType, SlotAndKeys, SparseMerklePath, StorageMap, StorageMapEntry, StorageMapEntryJs, StorageMapInfo, StorageMapUpdate, StorageSlot, StorageSlotArray, SyncSummary, TestUtils, TokenSymbol, TransactionArgs, TransactionFilter, TransactionId, TransactionProver, TransactionRecord, TransactionRequest, TransactionRequestBuilder, TransactionResult, TransactionScript, TransactionScriptInputPair, TransactionScriptInputPairArray, TransactionStatus, TransactionStoreUpdate, TransactionSummary, WebClient, WebKeystoreApi, Word, createAuthFalcon512RpoMultisig, exportStore, importStore, initSync, sequentialSumBench, setupLogging } from './Cargo-OZMlHpic.js';
 
 const WorkerAction = Object.freeze({
   INIT: "init",
   INIT_MOCK: "initMock",
+  INIT_THREAD_POOL: "initThreadPool",
   CALL_METHOD: "callMethod",
   EXECUTE_CALLBACK: "executeCallback",
 });
@@ -25,20 +26,24 @@ const MethodName = Object.freeze({
   SUBMIT_NEW_TRANSACTION_WITH_PROVER_MOCK: "submitNewTransactionWithProverMock",
   SYNC_STATE: "syncState",
   SYNC_STATE_MOCK: "syncStateMock",
+  SYNC_CHAIN: "syncChain",
+  SYNC_CHAIN_MOCK: "syncChainMock",
+  SYNC_NOTE_TRANSPORT: "syncNoteTransport",
+  SYNC_NOTE_TRANSPORT_MOCK: "syncNoteTransportMock",
 });
 
 /**
  * Sync Lock Module
  *
- * Provides coordination for concurrent syncState() calls using the Web Locks API
- * with an in-process mutex fallback for older browsers.
+ * Coordinates concurrent sync calls using the Web Locks API.
  *
  * Behavior:
- * - Uses "coalescing": if a sync is in progress, subsequent callers wait and receive
- *   the same result
- * - Web Locks for cross-tab coordination (Chrome 69+, Safari 15.4+)
- * - In-process mutex fallback when Web Locks unavailable
- * - Optional timeout support
+ * - Same-method coalescing: if a sync of the same method is in progress,
+ *   subsequent callers share its result promise
+ * - Different-method serialization: different methods (e.g. syncState vs
+ *   syncNoteTransport) wait for each other via the Web Lock, or via an
+ *   in-process per-dbId promise chain when Web Locks are unavailable
+ * - Web Locks also serialize across tabs (Chrome 69+, Safari 15.4+)
  */
 
 /**
@@ -52,195 +57,86 @@ function hasWebLocks() {
   );
 }
 
-/**
- * Internal state for tracking in-progress syncs and waiters per database.
- */
-const syncStates = new Map();
+// Coalesce map keyed by `${dbId}:${methodId}` -> in-flight promise.
+const inFlight = new Map();
 
-/**
- * Get or create sync state for a database.
- */
-function getSyncState(dbId) {
-  let state = syncStates.get(dbId);
-  if (!state) {
-    state = {
-      inProgress: false,
-      result: null,
-      error: null,
-      waiters: [],
-      releaseLock: null,
-      syncGeneration: 0,
-    };
-    syncStates.set(dbId, state);
-  }
-  return state;
-}
+// Per-dbId promise tail used to serialize cross-method calls when Web Locks
+// are unavailable. Each new task chains onto the current tail so different
+// methods on the same dbId run sequentially within the tab.
+const fallbackTails = new Map();
 
 /**
- * Acquire a sync lock for the given database.
- *
- * If a sync is already in progress:
- * - Returns { acquired: false, coalescedResult } after waiting for the result
- *
- * If no sync is in progress:
- * - Returns { acquired: true } and the caller should perform the sync,
- *   then call releaseSyncLock() or releaseSyncLockWithError()
+ * Build the coalesce-map key for an in-flight sync of `(dbId, methodId)`.
  *
- * @param {string} dbId - The database ID to lock
- * @param {number} timeoutMs - Optional timeout in milliseconds (0 = no timeout)
- * @returns {Promise<{acquired: boolean, coalescedResult?: any}>}
+ * @param {string} dbId
+ * @param {string} methodId
+ * @returns {string}
  */
-async function acquireSyncLock(dbId, timeoutMs = 0) {
-  const state = getSyncState(dbId);
-
-  // If a sync is already in progress, wait for it to complete (coalescing)
-  if (state.inProgress) {
-    return new Promise((resolve, reject) => {
-      let timeoutId;
-      if (timeoutMs > 0) {
-        timeoutId = setTimeout(() => {
-          const idx = state.waiters.findIndex((w) => w.resolve === onResult);
-          if (idx !== -1) {
-            state.waiters.splice(idx, 1);
-          }
-          reject(new Error("Sync lock acquisition timed out"));
-        }, timeoutMs);
-      }
-
-      const onResult = (result) => {
-        /* v8 ignore next 1 -- timeoutId only set when timeoutMs>0 AND another sync is in progress; combo rare in tests */
-        if (timeoutId) clearTimeout(timeoutId);
-        resolve({ acquired: false, coalescedResult: result });
-      };
-
-      const onError = (error) => {
-        if (timeoutId) clearTimeout(timeoutId);
-        reject(error);
-      };
-
-      state.waiters.push({ resolve: onResult, reject: onError });
-    });
-  }
-
-  // Mark sync as in progress and increment generation
-  state.inProgress = true;
-  state.result = null;
-  state.error = null;
-  state.syncGeneration++;
-  const currentGeneration = state.syncGeneration;
-
-  // Try to acquire Web Lock if available
-  if (hasWebLocks()) {
-    const lockName = `miden-sync-${dbId}`;
-
-    return new Promise((resolve, reject) => {
-      let timeoutId;
-      let timedOut = false;
-
-      if (timeoutMs > 0) {
-        timeoutId = setTimeout(() => {
-          timedOut = true;
-          if (state.syncGeneration === currentGeneration) {
-            state.inProgress = false;
-            const error = new Error("Sync lock acquisition timed out");
-            for (const waiter of state.waiters) {
-              waiter.reject(error);
-            }
-            state.waiters = [];
-          }
-          reject(new Error("Sync lock acquisition timed out"));
-        }, timeoutMs);
-      }
-
-      navigator.locks
-        .request(lockName, { mode: "exclusive" }, async () => {
-          /* v8 ignore next 3 -- race: lock granted after timeout or newer generation */
-          if (timedOut || state.syncGeneration !== currentGeneration) {
-            return;
-          }
-
-          if (timeoutId) clearTimeout(timeoutId);
-
-          return new Promise((releaseLock) => {
-            state.releaseLock = releaseLock;
-            resolve({ acquired: true });
-          });
-        })
-        .catch((err) => {
-          /* v8 ignore next 5 -- catch path requires Web Locks rejection combined with
-             optional timeout; tested via "rejects when Web Locks request rejects" but
-             the timeoutId-set branch needs Web Locks + timeout simultaneously */
-          if (timeoutId) clearTimeout(timeoutId);
-          if (state.syncGeneration === currentGeneration) {
-            state.inProgress = false;
-          }
-          reject(err instanceof Error ? err : new Error(String(err)));
-        });
-    });
-  } else {
-    // Fallback: no Web Locks, just use in-process state
-    return { acquired: true };
-  }
+function coalesceKey(dbId, methodId) {
+  return `${dbId}:${methodId}`;
 }
 
 /**
- * Release the sync lock with a successful result.
+ * Run `fn` while holding the per-db Web Lock. When Web Locks are unavailable,
+ * serializes `fn` against any other in-flight call on the same `dbId` via an
+ * in-process promise chain — the wasm-bindgen `WebClient` uses a synchronous
+ * `RefCell` for interior mutability in the browser, so overlapping
+ * cross-method borrows would throw "recursive use of an object detected
+ * which would lead to unsafe aliasing in rust".
  *
- * This notifies all waiting callers with the result and releases the lock.
- *
- * @param {string} dbId - The database ID
- * @param {any} result - The sync result to pass to waiters
+ * @param {string} dbId
+ * @param {() => Promise<T>} fn
+ * @returns {Promise<T>}
+ * @template T
  */
-function releaseSyncLock(dbId, result) {
-  const state = getSyncState(dbId);
-
-  if (!state.inProgress) {
-    console.warn("releaseSyncLock called but no sync was in progress");
-    return;
-  }
-
-  state.result = result;
-  state.inProgress = false;
-
-  for (const waiter of state.waiters) {
-    waiter.resolve(result);
-  }
-  state.waiters = [];
-
-  if (state.releaseLock) {
-    state.releaseLock();
-    state.releaseLock = null;
+function runUnderLock(dbId, fn) {
+  if (!hasWebLocks()) {
+    const prev = fallbackTails.get(dbId) ?? Promise.resolve();
+    const next = prev.catch(() => {}).then(fn);
+    const guarded = next.catch(() => {});
+    fallbackTails.set(dbId, guarded);
+    guarded.then(() => {
+      // Drop the slot only if no successor chained onto this tail.
+      if (fallbackTails.get(dbId) === guarded) fallbackTails.delete(dbId);
+    });
+    return next;
   }
+  return navigator.locks.request(
+    `miden-sync-${dbId}`,
+    { mode: "exclusive" },
+    fn
+  );
 }
 
 /**
- * Release the sync lock due to an error.
+ * Run `fn` under the sync lock for (dbId, methodId).
  *
- * This notifies all waiting callers that the sync failed.
+ * Concurrent calls with the same (dbId, methodId) share the same promise
+ * (coalescing). Concurrent calls on the same dbId with different methodIds
+ * serialize via the Web Lock.
  *
- * @param {string} dbId - The database ID
- * @param {Error} error - The error to pass to waiters
+ * @param {string} dbId - Database ID
+ * @param {string} methodId - Method identifier (see MethodName constants)
+ * @param {() => Promise<T>} fn - Work to run under the lock
+ * @returns {Promise<T>}
  */
-function releaseSyncLockWithError(dbId, error) {
-  const state = getSyncState(dbId);
-
-  if (!state.inProgress) {
-    console.warn("releaseSyncLockWithError called but no sync was in progress");
-    return;
-  }
-
-  state.error = error;
-  state.inProgress = false;
-
-  for (const waiter of state.waiters) {
-    waiter.reject(error);
-  }
-  state.waiters = [];
-
-  if (state.releaseLock) {
-    state.releaseLock();
-    state.releaseLock = null;
-  }
+function withSyncLock(dbId, methodId, fn) {
+  const key = coalesceKey(dbId, methodId);
+
+  let work = inFlight.get(key);
+  if (!work) {
+    work = runUnderLock(dbId, fn);
+    inFlight.set(key, work);
+    // Swallow on the derived promise so a rejection here doesn't surface as
+    // an unhandled rejection; the caller still sees the error through `work`.
+    work
+      .finally(() => {
+        if (inFlight.get(key) === work) inFlight.delete(key);
+      })
+      .catch(() => {});
+  }
+
+  return work;
 }
 
 /**
@@ -504,6 +400,7 @@ class AccountsResource {
       return await this.#inner.newFaucet(
         storageMode,
         type === 1 || type === "NonFungibleFaucet",
+        opts.name ?? opts.symbol,
         opts.symbol,
         opts.decimals,
         BigInt(opts.maxSupply),
@@ -536,11 +433,9 @@ class AccountsResource {
     if (!opts.auth)
       throw new Error("Contract creation requires an 'auth' (AuthSecretKey)");
 
-    // Default to immutable when type is omitted (safer for contracts)
-    const mutable = opts.type === "MutableContract" || opts.type === 3;
-    const accountTypeEnum = mutable
-      ? wasm.AccountType.RegularAccountUpdatableCode
-      : wasm.AccountType.RegularAccountImmutableCode;
+    // The 0.15 protocol has no code-mutability distinction, so the `type`
+    // ("ImmutableContract" / "MutableContract") only steers routing here; the
+    // account's on-chain visibility is set entirely by `storageMode`.
     const storageMode = resolveStorageMode(opts.storage ?? "public", wasm);
     const authComponent =
       wasm.AccountComponent.createAuthComponentFromSecretKey(opts.auth);
@@ -555,7 +450,6 @@ class AccountsResource {
     }
 
     let builder = new wasm.AccountBuilder(opts.seed)
-      .accountType(accountTypeEnum)
       .storageMode(storageMode)
       .withAuthComponent(authComponent);
 
@@ -866,6 +760,72 @@ class TransactionsResource {
     return { txId, result };
   }
 
+  /** Create a partial-swap (PSWAP) note. See {@link PswapCreateOptions}. */
+  async pswapCreate(opts) {
+    this.#client.assertNotTerminated();
+    const wasm = await this.#getWasm();
+    const { accountId, request } = await this.#buildPswapCreateRequest(
+      opts,
+      wasm
+    );
+
+    const { txId, result } = await this.#submitOrSubmitWithProver(
+      accountId,
+      request,
+      opts.prover
+    );
+
+    if (opts.waitForConfirmation) {
+      await this.waitFor(txId.toHex(), { timeout: opts.timeout });
+    }
+
+    return { txId, result };
+  }
+
+  /** Consume (fully or partially fill) a PSWAP note. See {@link PswapConsumeOptions}. */
+  async pswapConsume(opts) {
+    this.#client.assertNotTerminated();
+    const wasm = await this.#getWasm();
+    const { accountId, request } = await this.#buildPswapConsumeRequest(
+      opts,
+      wasm
+    );
+
+    const { txId, result } = await this.#submitOrSubmitWithProver(
+      accountId,
+      request,
+      opts.prover
+    );
+
+    if (opts.waitForConfirmation) {
+      await this.waitFor(txId.toHex(), { timeout: opts.timeout });
+    }
+
+    return { txId, result };
+  }
+
+  /** Cancel a PSWAP note as its creator and reclaim the offered asset. See {@link PswapCancelOptions}. */
+  async pswapCancel(opts) {
+    this.#client.assertNotTerminated();
+    const wasm = await this.#getWasm();
+    const { accountId, request } = await this.#buildPswapCancelRequest(
+      opts,
+      wasm
+    );
+
+    const { txId, result } = await this.#submitOrSubmitWithProver(
+      accountId,
+      request,
+      opts.prover
+    );
+
+    if (opts.waitForConfirmation) {
+      await this.waitFor(txId.toHex(), { timeout: opts.timeout });
+    }
+
+    return { txId, result };
+  }
+
   async preview(opts) {
     this.#client.assertNotTerminated();
     const wasm = await this.#getWasm();
@@ -890,6 +850,27 @@ class TransactionsResource {
         ({ accountId, request } = await this.#buildSwapRequest(opts, wasm));
         break;
       }
+      case "pswapCreate": {
+        ({ accountId, request } = await this.#buildPswapCreateRequest(
+          opts,
+          wasm
+        ));
+        break;
+      }
+      case "pswapConsume": {
+        ({ accountId, request } = await this.#buildPswapConsumeRequest(
+          opts,
+          wasm
+        ));
+        break;
+      }
+      case "pswapCancel": {
+        ({ accountId, request } = await this.#buildPswapCancelRequest(
+          opts,
+          wasm
+        ));
+        break;
+      }
       case "custom": {
         accountId = resolveAccountRef(opts.account, wasm);
         request = opts.request;
@@ -1042,7 +1023,10 @@ class TransactionsResource {
       }
 
       try {
-        await this.#inner.syncStateWithTimeout(0);
+        // Chain-only sync is sufficient: confirmation only needs on-chain
+        // state, and skipping NTL keeps polling alive when the note
+        // transport endpoint is unavailable.
+        await this.#inner.syncChain();
       } catch {
         // Sync may fail transiently; continue polling
       }
@@ -1176,6 +1160,53 @@ class TransactionsResource {
     return { accountId, request };
   }
 
+  async #buildPswapCreateRequest(opts, wasm) {
+    const accountId = resolveAccountRef(opts.account, wasm);
+    const offeredFaucetId = resolveAccountRef(opts.offer.token, wasm);
+    const requestedFaucetId = resolveAccountRef(opts.request.token, wasm);
+    const noteType = resolveNoteType(opts.type, wasm);
+    const paybackNoteType = resolveNoteType(
+      opts.paybackType ?? opts.type,
+      wasm
+    );
+
+    const request = await this.#inner.newPswapCreateTransactionRequest(
+      accountId,
+      offeredFaucetId,
+      BigInt(opts.offer.amount),
+      requestedFaucetId,
+      BigInt(opts.request.amount),
+      noteType,
+      paybackNoteType
+    );
+    return { accountId, request };
+  }
+
+  async #buildPswapConsumeRequest(opts, wasm) {
+    const accountId = resolveAccountRef(opts.account, wasm);
+    const note = await this.#resolveNoteInput(opts.note);
+    const noteFillAmount = opts.noteFillAmount ?? 0n;
+
+    const request = await this.#inner.newPswapConsumeTransactionRequest(
+      note,
+      accountId,
+      BigInt(opts.fillAmount),
+      BigInt(noteFillAmount)
+    );
+    return { accountId, request };
+  }
+
+  async #buildPswapCancelRequest(opts, wasm) {
+    const accountId = resolveAccountRef(opts.account, wasm);
+    const note = await this.#resolveNoteInput(opts.note);
+
+    const request = await this.#inner.newPswapCancelTransactionRequest(
+      note,
+      accountId
+    );
+    return { accountId, request };
+  }
+
   async #resolveNoteInput(input) {
     if (typeof input === "string") {
       const record = await this.#inner.getInputNote(input);
@@ -1565,6 +1596,80 @@ class MidenClient {
     this.keystore = new KeystoreResource(inner, this);
   }
 
+  /**
+   * Escape hatch: runs `fn` with exclusive access to the proxied JS
+   * WebClient that backs this MidenClient.
+   *
+   * The proxy forwards missing properties to the underlying wasm-bindgen
+   * `WebClient`, so `fn` can reach lower-level methods like
+   * `executeTransaction`, `proveTransaction[WithProver]`,
+   * `submitProvenTransaction`, `applyTransaction`,
+   * `newSendTransactionRequest`, `newConsumeTransactionRequest`, etc.
+   *
+   * Intended for advanced consumers that need to split the bundled
+   * execute → prove → submit → apply pipeline across contexts — for example,
+   * a Chrome MV3 extension that runs `executeTransaction` in its service
+   * worker, dispatches the prove step to a `chrome.offscreen` document
+   * (where wasm-bindgen-rayon can spawn a real thread pool), then runs
+   * `submitProvenTransaction` + `applyTransaction` back in the SW.
+   *
+   * The callback runs inside `_serializeWasmCall`, so the WASM RefCell is
+   * held for the duration of `fn`. Concurrent SDK calls (sync, other
+   * transactions, etc.) queue on the same chain and run after `fn`
+   * settles. Without this serialization, raw inner-client access would
+   * race the proxy's chain and trip wasm-bindgen's "recursive use of an
+   * object detected" panic.
+   *
+   * Re-entrancy: while `fn` is running, the underlying client's
+   * `_withInnerLockDepth` counter is bumped so that `_serializeWasmCall`
+   * invocations made BY `fn` (or any proxy-dispatched method it calls)
+   * run inline rather than enqueuing on the chain. Without this, every
+   * `await inner.X(...)` inside `fn` would enqueue behind the outer
+   * `_withInnerWebClient` slot which is itself awaiting `fn` —
+   * a classic re-entrant-lock deadlock. The depth counter restores the
+   * intent of the docstring above: the lock is held for the duration
+   * of `fn`, and inner-client calls "borrow" that already-held lock
+   * instead of trying to re-acquire it.
+   *
+   * SAFETY CONTRACT for re-entrancy: callers MUST hold an external
+   * mutex preventing concurrent access to this same client instance
+   * via other code paths during `fn`. The chain still serializes
+   * against external callers — they queue behind the outer slot — but
+   * if an external task runs during one of `fn`'s awaits and calls
+   * into the SDK, it will see `_withInnerLockDepth > 0` and run
+   * inline, racing wasm-bindgen's borrow check. The wallet pattern
+   * (own outer mutex around `_withInnerWebClient`) satisfies this.
+   *
+   * Stability: marked `@internal`. The shape of the proxied client is
+   * intentionally not part of the documented public API and may change
+   * between SDK versions. If you depend on this method, pin the SDK
+   * version and test the lower-level surface carefully on each upgrade.
+   * If your use case is common enough to warrant a stable public API,
+   * file an issue.
+   *
+   * @internal
+   * @template T
+   * @param {(inner: object) => Promise<T>} fn - Async callback receiving
+   *   the proxied JS WebClient. Must not return references that escape
+   *   the callback's lifetime (the lock is released on settle).
+   * @returns {Promise<T>} The resolved value of `fn`.
+   */
+  _withInnerWebClient(fn) {
+    this.assertNotTerminated();
+    if (typeof fn !== "function") {
+      throw new TypeError("_withInnerWebClient: fn must be a function");
+    }
+    const inner = this.#inner;
+    return inner._serializeWasmCall(async () => {
+      inner._withInnerLockDepth = (inner._withInnerLockDepth || 0) + 1;
+      try {
+        return await fn(inner);
+      } finally {
+        inner._withInnerLockDepth--;
+      }
+    });
+  }
+
   /**
    * Creates and initializes a new MidenClient.
    *
@@ -1593,6 +1698,13 @@ class MidenClient {
     const rpcUrl = resolveRpcUrl(options?.rpcUrl);
     const noteTransportUrl = resolveNoteTransportUrl(options?.noteTransportUrl);
 
+    // `useWorker: false` opts out of the Web Worker shim that wraps every
+    // WASM call. The shim exists to keep the main thread responsive in
+    // browser/extension contexts, but it serializes the prover via
+    // `TransactionProver.serialize()` — a format that has no encoding for
+    // `newCallbackProver(jsFn)` and silently downgrades it to `"local"`.
+    // Mobile/Tauri/native-prover consumers must pass `useWorker: false`.
+    const useWorker = options?.useWorker;
     let inner;
     if (options?.keystore) {
       inner = await WebClientClass.createClientWithExternalKeystore(
@@ -1603,7 +1715,8 @@ class MidenClient {
         options.keystore.getKey,
         options.keystore.insertKey,
         options.keystore.sign,
-        options?.debugMode
+        options?.debugMode,
+        useWorker
       );
     } else {
       inner = await WebClientClass.createClient(
@@ -1611,7 +1724,8 @@ class MidenClient {
         noteTransportUrl,
         seed,
         options?.storeName,
-        options?.debugMode
+        options?.debugMode,
+        useWorker
       );
     }
 
@@ -1668,6 +1782,32 @@ class MidenClient {
     });
   }
 
+  /**
+   * Resolves once the WASM module is initialized and safe to use.
+   *
+   * Idempotent and shared across callers: the underlying loader memoizes the
+   * in-flight promise, so concurrent `ready()` calls await the same
+   * initialization and post-init callers resolve immediately from a cached
+   * module. Safe to call from `MidenProvider`, tutorial helpers, and any
+   * other consumer simultaneously.
+   *
+   * Useful on the `/lazy` entry (e.g. Next.js / Capacitor), where no
+   * top-level await runs at import time. On the default (eager) entry this
+   * is redundant — importing the module already awaits WASM — but calling it
+   * is still harmless.
+   *
+   * @returns {Promise<void>} Resolves when WASM is initialized.
+   */
+  static async ready() {
+    const getWasm = MidenClient._getWasmOrThrow;
+    if (!getWasm) {
+      throw new Error(
+        "MidenClient not initialized. Import from the SDK package entry point."
+      );
+    }
+    await getWasm();
+  }
+
   /**
    * Creates a mock client for testing.
    *
@@ -1703,15 +1843,34 @@ class MidenClient {
   }
 
   /**
-   * Syncs the client state with the Miden node.
+   * Syncs the client: fetches private notes from the Note Transport Layer, then syncs on-chain
+   * state with the Miden node. Fails fast on either.
    *
-   * @param {object} [opts] - Sync options.
-   * @param {number} [opts.timeout] - Timeout in milliseconds (0 = no timeout).
    * @returns {Promise<SyncSummary>} The sync summary.
    */
-  async sync(opts) {
+  async sync() {
     this.assertNotTerminated();
-    return await this.#inner.syncStateWithTimeout(opts?.timeout ?? 0);
+    return await this.#inner.syncState();
+  }
+
+  /**
+   * Syncs on-chain state only (no NTL fetch).
+   *
+   * @returns {Promise<SyncSummary>}
+   */
+  async syncChain() {
+    this.assertNotTerminated();
+    return await this.#inner.syncChain();
+  }
+
+  /**
+   * Fetches private notes from the Note Transport Layer.
+   *
+   * @returns {Promise<void>}
+   */
+  async syncNoteTransport() {
+    this.assertNotTerminated();
+    return await this.#inner.syncNoteTransport();
   }
 
   /**
@@ -1724,6 +1883,61 @@ class MidenClient {
     return await this.#inner.getSyncHeight();
   }
 
+  /**
+   * Resolves once every serialized WASM call that was already on the
+   * internal `_serializeWasmCall` chain when `waitForIdle()` was called
+   * (execute, submit, prove, apply, sync, or account creation) has
+   * settled. Use this from callers that need to perform a non-WASM-side
+   * action — e.g. clearing an in-memory auth key on wallet lock — after
+   * the kernel finishes, so its auth callback doesn't race with the key
+   * being cleared.
+   *
+   * Does NOT wait for calls enqueued after `waitForIdle()` returns —
+   * intentional, so a caller can drain and proceed without being blocked
+   * indefinitely by concurrent workload.
+   *
+   * Caveat for `syncState`: `syncStateWithTimeout` awaits the sync lock
+   * (`acquireSyncLock`, which uses Web Locks) BEFORE putting its WASM
+   * call onto the chain, so a `syncState` that is queued on the sync
+   * lock — but has not yet begun its WASM phase — is not visible to
+   * `waitForIdle` and will not be awaited. Other methods (`newWallet`,
+   * `executeTransaction`, etc.) route through the chain synchronously
+   * on call and are always observed.
+   *
+   * Safe to call at any time; returns immediately if nothing was in
+   * flight.
+   *
+   * @returns {Promise<void>}
+   */
+  async waitForIdle() {
+    this.assertNotTerminated();
+    await this.#inner.waitForIdle();
+  }
+
+  /**
+   * Returns the raw JS value that the most recent sign-callback invocation
+   * threw, or `null` if the last sign call succeeded (or no call has
+   * happened yet).
+   *
+   * Useful for recovering structured metadata (e.g. a `reason: 'locked'`
+   * property) that the kernel-level `auth::request` diagnostic would
+   * otherwise erase. Call immediately after catching a failed
+   * `transactions.submit` / `transactions.send` / `transactions.consume`.
+   *
+   * Meaningful only with `useWorker: false`: under the worker shim the
+   * sign callback fires against the worker's WASM keystore, while this
+   * accessor reads the main-thread instance — which never signed — so it
+   * returns `null`. Consumers that need this signal (e.g. external
+   * keystores with lock-aware sign callbacks) already require
+   * `useWorker: false` for the callback to be reachable at all.
+   *
+   * @returns {any} The raw thrown value, or `null`.
+   */
+  lastAuthError() {
+    this.assertNotTerminated();
+    return this.#inner.lastAuthError();
+  }
+
   /**
    * Terminates the underlying Web Worker. After this, all method calls will throw.
    */
@@ -2319,7 +2533,6 @@ const NoteVisibility = Object.freeze({
 const StorageMode = Object.freeze({
   Public: "public",
   Private: "private",
-  Network: "network",
 });
 
 const Linking = Object.freeze({
@@ -2513,6 +2726,15 @@ class WebClient {
    * @param {string | undefined} [logLevel] - Optional log verbosity level
    *   ("error", "warn", "info", "debug", "trace", "off", or "none").
    *   When set, Rust tracing output is routed to the browser console.
+   * @param {boolean} [useWorker=true] - When `false`, skip the Web Worker shim
+   *   and call the wasm-bindgen `WebClient` directly on the current thread.
+   *   The worker exists to keep the main thread responsive during WASM work
+   *   in browser/extension contexts, but it serializes the prover argument
+   *   via `TransactionProver.serialize()` — a format that has no encoding
+   *   for `newCallbackProver(jsFn)` and silently downgrades it to `"local"`.
+   *   Consumers that hand a `CallbackProver` (e.g. native iOS/Android plug-in
+   *   provers in Capacitor apps, or any other JS-side prover bridge) need
+   *   `useWorker: false` so the prover handle reaches the WASM binding intact.
    */
   constructor(
     rpcUrl,
@@ -2522,7 +2744,8 @@ class WebClient {
     getKeyCb,
     insertKeyCb,
     signCb,
-    logLevel
+    logLevel,
+    useWorker = true
   ) {
     this.rpcUrl = rpcUrl;
     this.noteTransportUrl = noteTransportUrl;
@@ -2532,9 +2755,12 @@ class WebClient {
     this.insertKeyCb = insertKeyCb;
     this.signCb = signCb;
     this.logLevel = logLevel;
+    this.useWorker = useWorker !== false;
 
-    // Check if Web Workers are available.
-    if (typeof Worker !== "undefined") {
+    // Check if Web Workers are available AND the caller didn't opt out via
+    // `useWorker: false`. The opt-out is load-bearing for `CallbackProver`
+    // consumers — see the constructor doc above.
+    if (this.useWorker && typeof Worker !== "undefined") {
       console.log("WebClient: Web Workers are available.");
       // Pick between the module and classic worker variants at runtime — see
       // `WebClient.workerMode` below. Both branches keep the
@@ -2575,10 +2801,19 @@ class WebClient {
         this.loadedResolver = resolve;
       });
 
-      // Create a promise that resolves when the worker signals that it is fully initialized.
-      this.ready = new Promise((resolve) => {
+      // Create a promise that resolves when the worker signals that it is
+      // fully initialized, and rejects if initialization fails. Every
+      // worker-forwarded method awaits `ready` first, so an init failure must
+      // reject it — otherwise those calls would await a promise that never
+      // settles and hang forever.
+      this.ready = new Promise((resolve, reject) => {
         this.readyResolver = resolve;
+        this.readyRejecter = reject;
       });
+      // Init can fail before any caller awaits `ready`; this no-op handler
+      // suppresses the unhandledrejection event without consuming the
+      // rejection for real awaiters.
+      this.ready.catch(() => {});
 
       // Listen for messages from the worker.
       this.worker.addEventListener("message", async (event) => {
@@ -2642,14 +2877,33 @@ class WebClient {
           } else {
             resolve(result);
           }
+          return;
+        }
+
+        // An error with no request attached comes from worker initialization
+        // (INIT is the only requestId-less action that can fail). Reject
+        // `ready` so queued and future method calls fail with the real cause
+        // instead of awaiting forever.
+        if (error && !requestId) {
+          const workerError =
+            error instanceof Error ? error : deserializeError(error);
+          console.error(
+            "WebClient: worker initialization failed:",
+            workerError
+          );
+          this.readyRejecter(workerError);
         }
       });
 
       // Once the worker script has loaded, initialize the worker.
       this.loaded.then(() => this.initializeWorker());
     } else {
-      console.log("WebClient: Web Workers are not available.");
-      // Worker not available; set up fallback values.
+      console.log(
+        this.useWorker
+          ? "WebClient: Web Workers are not available."
+          : "WebClient: Web Worker shim disabled by caller (useWorker=false)."
+      );
+      // Worker not available or explicitly disabled; set up fallback values.
       this.worker = null;
       this.pendingRequests = null;
       this.loaded = Promise.resolve();
@@ -2665,25 +2919,99 @@ class WebClient {
     // would panic with "recursive use of an object detected" due to
     // wasm-bindgen's internal RefCell.
     this._wasmCallChain = Promise.resolve();
+    // Depth counter for `_withInnerWebClient` re-entrancy. While > 0,
+    // `_serializeWasmCall` runs its callback inline instead of queueing
+    // it on the chain — see the comment on `_serializeWasmCall` for the
+    // safety contract.
+    this._withInnerLockDepth = 0;
   }
 
   /**
    * Serialize a WASM call that requires exclusive (&mut self) access.
    * Concurrent calls are queued and executed one at a time.
    *
+   * Wraps both the direct (in-thread) path and the worker-dispatched path.
+   * On the worker path this is redundant with the worker's own message queue,
+   * but harmless (the chain resolves immediately on the main thread once the
+   * worker's postMessage returns). On the direct path it is load-bearing —
+   * without it, concurrent main-thread callers would panic with
+   * "recursive use of an object detected" (wasm-bindgen's internal RefCell).
+   *
+   * Re-entrancy: when invoked from inside a `_withInnerWebClient(fn)`
+   * callback — detected via `_withInnerLockDepth > 0` — `fn` runs inline
+   * (no chain enqueue). The outer `_withInnerWebClient` invocation
+   * already holds the chain via its own wrapping `_serializeWasmCall`,
+   * so enqueueing the inner call would deadlock (the inner queues
+   * behind the outer; the outer awaits the inner). The inline run is
+   * safe because the chain still serializes against external callers
+   * — they queue behind the outer call's chain slot, which only resolves
+   * after `fn` (including all inline re-entries) settles. Callers of
+   * `_withInnerWebClient` MUST hold an external mutex preventing
+   * concurrent access via other code paths on this same instance during
+   * the callback; without that, an external task running between two
+   * awaits inside `fn` would race wasm-bindgen's borrow check.
+   *
    * @param {() => Promise<any>} fn - The async function to execute.
    * @returns {Promise<any>} The result of fn.
    */
   _serializeWasmCall(fn) {
+    if (this._withInnerLockDepth > 0) {
+      return Promise.resolve().then(fn);
+    }
     const result = this._wasmCallChain.catch(() => {}).then(fn);
     this._wasmCallChain = result.catch(() => {});
     return result;
   }
 
+  /**
+   * Returns a promise that resolves once every serialized WASM call that
+   * was already on `_wasmCallChain` when `waitForIdle()` was called has
+   * settled. Use this from callers that need to perform a non-WASM-side
+   * action (e.g. clear an in-memory auth key) AFTER any in-flight
+   * execute / submit / sync has completed, so the WASM kernel's auth
+   * callback doesn't race with the key being cleared.
+   *
+   * Does NOT wait for calls enqueued after `waitForIdle()` returns —
+   * this is intentional, so a caller can drain and then proceed without
+   * being blocked indefinitely by a concurrent workload.
+   *
+   * Caveat for `syncState`: `syncStateWithTimeout` awaits
+   * `acquireSyncLock` (Web Locks) BEFORE wrapping its WASM call in
+   * `_serializeWasmCall`, so a sync that is queued on the sync lock but
+   * has not yet reached its WASM phase is not on the chain and will not
+   * be awaited. Every other serialized method (`executeTransaction`,
+   * `newWallet`, `submitNewTransaction`, `proveTransaction`,
+   * `applyTransaction`, and the proxy-fallback reads) routes through
+   * the chain synchronously on call and is always observed.
+   *
+   * @returns {Promise<void>}
+   */
+  async waitForIdle() {
+    // Chain on `_wasmCallChain`; by the time this resolves, any in-flight
+    // serialized call has settled. Catch so the chain state doesn't leak.
+    await this._wasmCallChain.catch(() => {});
+  }
+
   // TODO: This will soon conflict with some changes in main.
   // More context here:
   // https://github.com/0xMiden/miden-client/pull/1645?notification_referrer_id=NT_kwHOA1yg7NoAJVJlcG9zaXRvcnk7NjU5MzQzNzAyO0lzc3VlOzM3OTY4OTU1Nzk&notifications_query=is%3Aunread#discussion_r2696075480
   initializeWorker() {
+    // Pass `numThreads` to the worker so it can call `wasm.initThreadPool(n)`
+    // inside its OWN WASM instance — the SDK worker's instance is separate
+    // from the main thread's, and rayon's global pool is per-instance.
+    // Default: navigator.hardwareConcurrency (or 1 if unavailable for any
+    // reason — e.g. the page isn't crossOriginIsolated, in which case the
+    // worker will skip pool init and parallelism falls back to sequential).
+    let numThreads = 1;
+    try {
+      if (
+        typeof self !== "undefined" &&
+        self.crossOriginIsolated &&
+        navigator?.hardwareConcurrency
+      ) {
+        numThreads = navigator.hardwareConcurrency;
+      }
+    } catch {}
     this.worker.postMessage({
       action: WorkerAction.INIT,
       args: [
@@ -2695,6 +3023,7 @@ class WebClient {
         !!this.insertKeyCb,
         !!this.signCb,
         this.logLevel,
+        numThreads,
       ],
     });
   }
@@ -2723,9 +3052,19 @@ class WebClient {
    * @param {string} seed - The seed for the account.
    * @param {string | undefined} network - Optional name for the store. Setting this allows multiple clients to be used in the same browser.
    * @param {string | undefined} logLevel - Optional log verbosity level ("error", "warn", "info", "debug", "trace", "off", or "none").
+   * @param {boolean} [useWorker=true] - When `false`, bypass the Web Worker shim
+   *   and run WASM calls on the current thread. Required for `CallbackProver`
+   *   consumers (the worker path serializes the prover and loses the callback).
    * @returns {Promise<WebClient>} The fully initialized WebClient.
    */
-  static async createClient(rpcUrl, noteTransportUrl, seed, network, logLevel) {
+  static async createClient(
+    rpcUrl,
+    noteTransportUrl,
+    seed,
+    network,
+    logLevel,
+    useWorker = true
+  ) {
     // Construct the instance (synchronously).
     const instance = new WebClient(
       rpcUrl,
@@ -2735,7 +3074,8 @@ class WebClient {
       undefined,
       undefined,
       undefined,
-      logLevel
+      logLevel,
+      useWorker
     );
 
     // Set up logging on the main thread before creating the client.
@@ -2766,6 +3106,9 @@ class WebClient {
    * @param {Function | undefined} insertKeyCb - The insert key callback.
    * @param {Function | undefined} signCb - The sign callback.
    * @param {string | undefined} logLevel - Optional log verbosity level ("error", "warn", "info", "debug", "trace", "off", or "none").
+   * @param {boolean} [useWorker=true] - When `false`, bypass the Web Worker shim
+   *   and run WASM calls on the current thread. Required for `CallbackProver`
+   *   consumers (the worker path serializes the prover and loses the callback).
    * @returns {Promise<WebClient>} The fully initialized WebClient.
    */
   static async createClientWithExternalKeystore(
@@ -2776,7 +3119,8 @@ class WebClient {
     getKeyCb,
     insertKeyCb,
     signCb,
-    logLevel
+    logLevel,
+    useWorker = true
   ) {
     // Construct the instance (synchronously).
     const instance = new WebClient(
@@ -2787,7 +3131,8 @@ class WebClient {
       getKeyCb,
       insertKeyCb,
       signCb,
-      logLevel
+      logLevel,
+      useWorker
     );
 
     // Set up logging on the main thread before creating the client.
@@ -2852,6 +3197,7 @@ class WebClient {
   async newFaucet(
     storageMode,
     nonFungible,
+    tokenName,
     tokenSymbol,
     decimals,
     maxSupply,
@@ -2862,6 +3208,7 @@ class WebClient {
       return await wasmWebClient.newFaucet(
         storageMode,
         nonFungible,
+        tokenName,
         tokenSymbol,
         decimals,
         maxSupply,
@@ -3029,7 +3376,7 @@ class WebClient {
   }
 
   /**
-   * Syncs the client state with the node.
+   * Syncs the client (NTL followed by chain sync, failing fast on either).
    *
    * This method coordinates concurrent sync calls using the Web Locks API when available,
    * with an in-process mutex fallback for older browsers. If a sync is already in progress,
@@ -3038,58 +3385,76 @@ class WebClient {
    * @returns {Promise<SyncSummary>} The sync summary
    */
   async syncState() {
-    return this.syncStateWithTimeout(0);
+    const dbId = this.storeName || "default";
+    const methodId = MethodName.SYNC_STATE;
+
+    try {
+      return await withSyncLock(dbId, methodId, async () => {
+        if (!this.worker) {
+          const wasmWebClient = await this.getWasmWebClient();
+          return await wasmWebClient.syncStateImpl();
+        }
+        const wasm = await getWasmOrThrow();
+        const serializedSyncSummaryBytes =
+          await this.callMethodWithWorker(methodId);
+        return wasm.SyncSummary.deserialize(
+          new Uint8Array(serializedSyncSummaryBytes)
+        );
+      });
+    } catch (error) {
+      console.error("INDEX.JS: Error in syncState:", error);
+      throw error;
+    }
   }
 
   /**
-   * Syncs the client state with the node with an optional timeout.
-   *
-   * This method coordinates concurrent sync calls using the Web Locks API when available,
-   * with an in-process mutex fallback for older browsers. If a sync is already in progress,
-   * subsequent callers will wait and receive the same result (coalescing behavior).
+   * Fetches private notes from the Note Transport Layer.
    *
-   * @param {number} timeoutMs - Timeout in milliseconds (0 = no timeout)
-   * @returns {Promise<SyncSummary>} The sync summary
+   * @returns {Promise<void>}
    */
-  async syncStateWithTimeout(timeoutMs = 0) {
-    // Use storeName as the database ID for lock coordination
+  async syncNoteTransport() {
     const dbId = this.storeName || "default";
+    const methodId = MethodName.SYNC_NOTE_TRANSPORT;
 
     try {
-      // Acquire the sync lock (coordinates concurrent calls)
-      const lockHandle = await acquireSyncLock(dbId, timeoutMs);
-
-      if (!lockHandle.acquired) {
-        // We're coalescing - return the result from the in-progress sync
-        return lockHandle.coalescedResult;
-      }
-
-      // We acquired the lock - perform the sync
-      try {
-        let result;
+      await withSyncLock(dbId, methodId, async () => {
         if (!this.worker) {
           const wasmWebClient = await this.getWasmWebClient();
-          result = await wasmWebClient.syncStateImpl();
+          await wasmWebClient.syncNoteTransportImpl();
         } else {
-          const wasm = await getWasmOrThrow();
-          const serializedSyncSummaryBytes = await this.callMethodWithWorker(
-            MethodName.SYNC_STATE
-          );
-          result = wasm.SyncSummary.deserialize(
-            new Uint8Array(serializedSyncSummaryBytes)
-          );
+          await this.callMethodWithWorker(methodId);
         }
+      });
+    } catch (error) {
+      console.error("INDEX.JS: Error in syncNoteTransport:", error);
+      throw error;
+    }
+  }
 
-        // Release the lock with the result
-        releaseSyncLock(dbId, result);
-        return result;
-      } catch (error) {
-        // Release the lock with the error
-        releaseSyncLockWithError(dbId, error);
-        throw error;
-      }
+  /**
+   * Syncs on-chain state only (no NTL fetch).
+   *
+   * @returns {Promise<SyncSummary>}
+   */
+  async syncChain() {
+    const dbId = this.storeName || "default";
+    const methodId = MethodName.SYNC_CHAIN;
+
+    try {
+      return await withSyncLock(dbId, methodId, async () => {
+        if (!this.worker) {
+          const wasmWebClient = await this.getWasmWebClient();
+          return await wasmWebClient.syncChainImpl();
+        }
+        const wasm = await getWasmOrThrow();
+        const serializedSyncSummaryBytes =
+          await this.callMethodWithWorker(methodId);
+        return wasm.SyncSummary.deserialize(
+          new Uint8Array(serializedSyncSummaryBytes)
+        );
+      });
     } catch (error) {
-      console.error("INDEX.JS: Error in syncState:", error);
+      console.error("INDEX.JS: Error in syncChain:", error);
       throw error;
     }
   }
@@ -3125,9 +3490,23 @@ class MockWebClient extends WebClient {
   }
 
   initializeWorker() {
+    // Pass `numThreads` exactly like the real INIT path: every prove runs
+    // inside the worker's own WASM instance, and rayon's pool is
+    // per-instance — without this, mock-client proving (including the
+    // integration suite) silently runs single-threaded.
+    let numThreads = 1;
+    try {
+      if (
+        typeof self !== "undefined" &&
+        self.crossOriginIsolated &&
+        navigator?.hardwareConcurrency
+      ) {
+        numThreads = navigator.hardwareConcurrency;
+      }
+    } catch {}
     this.worker.postMessage({
       action: WorkerAction.INIT_MOCK,
-      args: [this.seed, this.logLevel],
+      args: [this.seed, this.logLevel, numThreads],
     });
   }
 
@@ -3178,59 +3557,119 @@ class MockWebClient extends WebClient {
    * @returns {Promise<SyncSummary>} The sync summary
    */
   async syncState() {
-    return this.syncStateWithTimeout(0);
+    const dbId = this.storeName || "mock";
+    const methodId = MethodName.SYNC_STATE;
+
+    try {
+      return await withSyncLock(dbId, methodId, async () => {
+        const wasmWebClient = await this.getWasmWebClient();
+
+        if (!this.worker) {
+          return await wasmWebClient.syncStateImpl();
+        }
+
+        const serializedMockChain = (await wasmWebClient.serializeMockChain())
+          .buffer;
+        const serializedMockNoteTransportNode = (
+          await wasmWebClient.serializeMockNoteTransportNode()
+        ).buffer;
+
+        const wasm = await getWasmOrThrow();
+        const serializedSyncSummaryBytes = await this.callMethodWithWorker(
+          MethodName.SYNC_STATE_MOCK,
+          serializedMockChain,
+          serializedMockNoteTransportNode
+        );
+        return wasm.SyncSummary.deserialize(
+          new Uint8Array(serializedSyncSummaryBytes)
+        );
+      });
+    } catch (error) {
+      console.error("INDEX.JS: Error in syncState:", error);
+      throw error;
+    }
   }
 
   /**
-   * Syncs the mock client state with an optional timeout.
+   * Syncs only the on-chain mock state (no note transport fetch).
    *
-   * @param {number} timeoutMs - Timeout in milliseconds (0 = no timeout)
-   * @returns {Promise<SyncSummary>} The sync summary
+   * In worker mode, the main-thread mock chain + note-transport-node state
+   * is serialized and shipped to the worker before the sync, so a prior
+   * `proveBlock()` on the main thread is reflected in the worker's WASM
+   * client. The no-worker path uses the main-thread WASM client directly.
+   *
+   * @returns {Promise<SyncSummary>}
    */
-  async syncStateWithTimeout(timeoutMs = 0) {
+  async syncChain() {
     const dbId = this.storeName || "mock";
+    const methodId = MethodName.SYNC_CHAIN;
 
     try {
-      const lockHandle = await acquireSyncLock(dbId, timeoutMs);
+      return await withSyncLock(dbId, methodId, async () => {
+        const wasmWebClient = await this.getWasmWebClient();
 
-      if (!lockHandle.acquired) {
-        return lockHandle.coalescedResult;
-      }
+        if (!this.worker) {
+          return await wasmWebClient.syncChainImpl();
+        }
 
-      try {
-        let result;
+        const serializedMockChain = (await wasmWebClient.serializeMockChain())
+          .buffer;
+        const serializedMockNoteTransportNode = (
+          await wasmWebClient.serializeMockNoteTransportNode()
+        ).buffer;
+
+        const wasm = await getWasmOrThrow();
+        const serializedSyncSummaryBytes = await this.callMethodWithWorker(
+          MethodName.SYNC_CHAIN_MOCK,
+          serializedMockChain,
+          serializedMockNoteTransportNode
+        );
+        return wasm.SyncSummary.deserialize(
+          new Uint8Array(serializedSyncSummaryBytes)
+        );
+      });
+    } catch (error) {
+      console.error("INDEX.JS: Error in syncChain:", error);
+      throw error;
+    }
+  }
+
+  /**
+   * Syncs only the mock note-transport state (no chain fetch).
+   *
+   * Mirrors {@link MockWebClient#syncChain}: in worker mode, the
+   * main-thread mock chain + note-transport-node state is serialized
+   * and shipped to the worker first.
+   *
+   * @returns {Promise<void>}
+   */
+  async syncNoteTransport() {
+    const dbId = this.storeName || "mock";
+    const methodId = MethodName.SYNC_NOTE_TRANSPORT;
+
+    try {
+      await withSyncLock(dbId, methodId, async () => {
         const wasmWebClient = await this.getWasmWebClient();
 
         if (!this.worker) {
-          result = await wasmWebClient.syncStateImpl();
-        } else {
-          let serializedMockChain = (await wasmWebClient.serializeMockChain())
-            .buffer;
-          let serializedMockNoteTransportNode = (
-            await wasmWebClient.serializeMockNoteTransportNode()
-          ).buffer;
-
-          const wasm = await getWasmOrThrow();
-
-          const serializedSyncSummaryBytes = await this.callMethodWithWorker(
-            MethodName.SYNC_STATE_MOCK,
-            serializedMockChain,
-            serializedMockNoteTransportNode
-          );
-
-          result = wasm.SyncSummary.deserialize(
-            new Uint8Array(serializedSyncSummaryBytes)
-          );
+          await wasmWebClient.syncNoteTransportImpl();
+          return;
         }
 
-        releaseSyncLock(dbId, result);
-        return result;
-      } catch (error) {
-        releaseSyncLockWithError(dbId, error);
-        throw error;
-      }
+        const serializedMockChain = (await wasmWebClient.serializeMockChain())
+          .buffer;
+        const serializedMockNoteTransportNode = (
+          await wasmWebClient.serializeMockNoteTransportNode()
+        ).buffer;
+
+        await this.callMethodWithWorker(
+          MethodName.SYNC_NOTE_TRANSPORT_MOCK,
+          serializedMockChain,
+          serializedMockNoteTransportNode
+        );
+      });
     } catch (error) {
-      console.error("INDEX.JS: Error in syncState:", error);
+      console.error("INDEX.JS: Error in syncNoteTransport:", error);
       throw error;
     }
   }
@@ -3368,5 +3807,5 @@ MidenClient._MockWasmWebClient = MockWebClient;
 MidenClient._getWasmOrThrow = getWasmOrThrow;
 _setWebClient(WebClient);
 
-export { AccountType, AuthScheme, CompilerResource, Linking, MidenArrays, MidenClient, MockWebClient as MockWasmWebClient, MockWebClient, NoteVisibility, StorageMode, StorageResult, StorageView, WebClient as WasmWebClient, buildSwapTag, createP2IDENote, createP2IDNote, getWasmOrThrow, wordToBigInt };
+export { AccountType, AuthScheme, CompilerResource, Linking, MidenArrays, MidenClient, MockWebClient as MockWasmWebClient, MockWebClient, NoteVisibility, StorageMode, StorageResult, StorageView, WebClient as WasmWebClient, buildSwapTag, createP2IDENote, createP2IDNote, getWasmOrThrow, withSyncLock, wordToBigInt };
 //# sourceMappingURL=index.js.map