@firela/pii-redactor 0.1.0 → 0.1.1

package/index-node.cjs

@@ -48,16 +48,20 @@ function processFailure(code, message) {
 // to first use (lazy _exports cache below) so the module is cheap to require.
 const wasmBytes = fs.readFileSync(path.join(__dirname, 'pii_redactor.opt.wasm'));
 
-let _exports;
+// Cache the in-flight instantiation PROMISE (not the resolved value) so
+// concurrent cold-start callers await the SAME instantiate — no parallel
+// instantiation race.
+let _exportsPromise;
 
 /// Lazily instantiate the wasm module ONCE. Cached so the cold-start cost is
 /// paid only on the first parse/detect call. Returns the exports object.
 async function getExports() {
-    if (!_exports) {
-        const { instance } = await WebAssembly.instantiate(wasmBytes, {}); // {} = zero imports
-        _exports = instance.exports;
+    if (!_exportsPromise) {
+        _exportsPromise = WebAssembly.instantiate(wasmBytes, {}).then(({ instance }) => { // {} = zero imports
+            return instance.exports;
+        });
     }
-    return _exports;
+    return _exportsPromise;
 }
 
 function makeParse(ex) {
@@ -103,11 +107,16 @@ function makeParse(ex) {
         }
 
         const resultBytes = Buffer.from(new Uint8Array(ex.memory.buffer, ptr, len));
-        const json = JSON.parse(resultBytes.toString('utf8'));
-
+        const decoded = resultBytes.toString('utf8'); // decode while buffer is valid
         // Free BOTH buffers every cycle (input + result) per the FFI contract.
         ex.free_result(inputPtr, inputLen);
         ex.free_result(ptr, len);
+        let json;
+        try {
+            json = JSON.parse(decoded);
+        } catch (e) {
+            return processFailure('INTERNAL', 'parse returned malformed JSON: ' + ((e && e.message) || String(e)));
+        }
         return json;
     };
 }

package/index-worker.js

@@ -35,14 +35,23 @@ const REQUIRED_EXPORTS = ['alloc', 'parse', 'detect', 'free_result', 'memory'];
 // instantiation; the result is cached so the cold-start cost is paid once). `mod`
 // is a pre-compiled WebAssembly.Module, so instantiate() returns an Instance
 // (unlike the bytes overload, which returns {module, instance}) — handle both.
-let _exports;
+// Cache the in-flight instantiation PROMISE (not the resolved value) so
+// concurrent cold-start callers await the SAME instantiate — no parallel
+// instantiation race. Validates the FFI exports once on first use.
+let _exportsPromise;
 async function getExports() {
-    if (!_exports) {
-        const result = await WebAssembly.instantiate(mod, {}); // {} = zero imports
-        const instance = result.instance || result; // bytes→{instance}, Module→Instance
-        _exports = instance.exports;
+    if (!_exportsPromise) {
+        _exportsPromise = WebAssembly.instantiate(mod, {}).then((result) => { // {} = zero imports
+            const instance = result.instance || result; // bytes→{instance}, Module→Instance
+            const ex = instance.exports;
+            const missing = REQUIRED_EXPORTS.filter((name) => !ex[name]);
+            if (missing.length) {
+                throw new Error('wasm missing required exports: ' + missing.join(', '));
+            }
+            return ex;
+        });
     }
-    return _exports;
+    return _exportsPromise;
 }
 
 function processFailure(code, message) {
@@ -99,11 +108,16 @@ export async function parse(bytes) {
     }
 
     const resultBytes = new Uint8Array(ex.memory.buffer, ptr, len);
-    const json = JSON.parse(new TextDecoder().decode(resultBytes));
-
+    const decoded = new TextDecoder().decode(resultBytes); // decode while buffer is valid
     // Free BOTH buffers every cycle (input + result) per the FFI contract.
     ex.free_result(inputPtr, inputLen);
     ex.free_result(ptr, len);
+    let json;
+    try {
+        json = JSON.parse(decoded);
+    } catch (e) {
+        return processFailure('INTERNAL', 'parse returned malformed JSON: ' + ((e && e.message) || String(e)));
+    }
     return json;
 }
 
@@ -130,5 +144,4 @@ export async function detect(bytes) {
     return conf;
 }
 
-export { parse, detect };
 export default { parse, detect };

package/index.d.ts

@@ -77,7 +77,7 @@ export type ParseResult = ProcessSuccess | ProcessFailure;
  *          `errors` lists the categorized error(s). The host never throws on
  *          parser-level failures — they arrive as `ProcessFailure`.
  */
-export declare function parse(bytes: Uint8Array | Buffer): Promise<ParseResult>;
+export declare function parse(bytes: Uint8Array): Promise<ParseResult>;
 
 /**
  * Detection confidence for the given bytes.
@@ -85,4 +85,4 @@ export declare function parse(bytes: Uint8Array | Buffer): Promise<ParseResult>;
  * @param bytes - Statement bytes to identify.
  * @returns Confidence in {0, 50, 100}: 0 = no match, 50 = partial, 100 = definite.
  */
-export declare function detect(bytes: Uint8Array | Buffer): Promise<number>;
+export declare function detect(bytes: Uint8Array): Promise<number>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@firela/pii-redactor",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "firela parser/sanitizer WASM module — isomorphic Node.js + Cloudflare Worker loader (ADR-0101 compiled-only).",
   "type": "module",
   "main": "./index-node.cjs",