streamfold 0.1.7 → 0.1.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "streamfold",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Protocol-neutral incremental state for structured AI streams",
   "type": "module",
   "license": "MIT",

package/src/index.d.ts

@@ -240,6 +240,9 @@ export function createStructuredStreamPool<Id = string>(
   options?: StructuredStreamPoolOptions,
 ): StructuredStreamPool<Id>;
 
+/** Compile and cache the embedded WebAssembly module before creating scanners. */
+export function prepareStreamfold(): Promise<void>;
+
 export const STREAMFOLD_ENGINE: "rust-wasm";
 export const DEFAULT_STREAM_LIMITS: Readonly<
   Required<

package/src/index.js

@@ -9,6 +9,7 @@ import { applyImmutableChanges, freezeJson } from "./internal/snapshots.js";
 import { annotateError, streamError } from "./internal/errors.js";
 
 export { isStructuredStreamError } from "./internal/errors.js";
+export { prepareWasm as prepareStreamfold } from "./internal/wasm-runtime.js";
 export { defineAdapter } from "./adapter.js";
 export { readStructured } from "./read-structured.js";
 

package/src/internal/wasm-runtime.js

@@ -17,9 +17,11 @@ const PATCH_COMPLETE = 8;
 
 const encoder = new TextEncoder();
 let exports;
+let compiledModule;
+let compiling;
 
-const decodeBase64 = (base64) => {
-  const binary = globalThis.atob(base64);
+const decodeWasmBytes = () => {
+  const binary = globalThis.atob(wasmBinaryBase64);
   const bytes = new Uint8Array(binary.length);
   for (let index = 0; index < binary.length; index++) {
     bytes[index] = binary.charCodeAt(index);
@@ -32,11 +34,39 @@ const getExports = () => {
   if (typeof WebAssembly !== "object") {
     throw new Error("Streamfold requires WebAssembly support");
   }
-  const module = new WebAssembly.Module(decodeBase64(wasmBinaryBase64));
+  const module =
+    compiledModule ?? new WebAssembly.Module(decodeWasmBytes());
   exports = new WebAssembly.Instance(module, {}).exports;
   return exports;
 };
 
+export const prepareWasm = () => {
+  if (exports !== undefined || compiledModule !== undefined)
+    return Promise.resolve();
+  if (compiling !== undefined) return compiling;
+  if (
+    typeof WebAssembly !== "object" ||
+    typeof WebAssembly.compile !== "function"
+  ) {
+    return Promise.reject(new Error("Streamfold requires WebAssembly support"));
+  }
+  try {
+    compiling = WebAssembly.compile(decodeWasmBytes()).then(
+      (module) => {
+        compiledModule = module;
+        compiling = undefined;
+      },
+      (error) => {
+        compiling = undefined;
+        throw error;
+      },
+    );
+  } catch (error) {
+    return Promise.reject(error);
+  }
+  return compiling;
+};
+
 const describeParserError = ({ wasm, handle, maxBytes, maxDepth }, code) => {
   const offset = wasm.streamfold_parser_error_offset(handle) >>> 0;
   const byte = wasm.streamfold_parser_error_byte(handle);
@@ -207,14 +237,16 @@ const pushChunk = (parser, chunk) => {
     );
   }
   const { wasm, handle } = parser;
-  const capacity = chunk.length * 3;
+  const remaining = parser.maxBytes - (wasm.streamfold_parser_bytes_seen(handle) >>> 0);
+  if (chunk.length > remaining) throw parserError(parser, 7);
+  const capacity = Math.min(chunk.length * 3, remaining);
   const pointer = wasm.streamfold_parser_input(handle, capacity);
   let length = 0;
   if (capacity > 0) {
     const input = new Uint8Array(wasm.memory.buffer, pointer, capacity);
     const result = encoder.encodeInto(chunk, input);
     if (result.read !== chunk.length) {
-      throw new Error("Unable to encode the complete stream fragment");
+      throw parserError(parser, 7);
     }
     length = result.written;
   }