Currently we use a hard-coded limit to ensure we don't pass any args through a Mojo interface that would serialize to a size larger than Mojo's limits.  This has the following issues:

- our limit is based on a hard-coded value that doesn't represent what Mojo may use, which could also be dynamic depending on the case
- our limit uses static_asserts to ensure it's sane
- our checking is done on a single arg and guesses at the overall message size, so we may actually exceed the limit in certain cases
- there are no tests around the boundary conditions

A nice overall solution would be to share the data in some other way rather than being serialized, such as a shared memory segment passed across the Mojo call that's copied in-process for web page access.  This is the solution other systems use to pass large data through Mojo, though most users don't also have the requirement of making that data available to the web page.  If this works, that would be a great way to wrap this up.

If that approach doesn't work, we should investigate splitting/chunking our calls so we avoid hitting the limit in the first place.