@firela/hk-hsbc-credit 0.1.0 → 0.1.2

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, 'hk_hsbc_credit.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-node.mjs

@@ -0,0 +1,19 @@
+// ESM entry for Node.js consumers (Phase 74 UAT gap-closure, test 8).
+//
+// Why this exists: the isomorphic loaders branch ONLY at module-load. The CJS
+// loader (index-node.cjs) reads the wasm via fs + WebAssembly.instantiate(bytes);
+// the Worker loader (index-worker.js) does a static `import mod from '*.wasm'`,
+// which is valid only under a Cloudflare Worker bundler — Node ESM `import` of
+// the Worker entry throws ERR_UNKNOWN_FILE_EXTENSION. package.json routes Node
+// ESM resolution here via exports.node.import.
+//
+// We bridge to the PROVEN CJS loader with createRequire instead of duplicating
+// the FFI cycle — index-node.cjs locates the wasm via path.join(__dirname, ...),
+// and __dirname inside that .cjs is its own directory, so the wasm resolves
+// correctly regardless of how the .cjs was required. The parse/detect contract
+// is therefore byte-identical to the CommonJS path (no second implementation).
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+
+export const { parse, detect } = require('./index-node.cjs');

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/hk-hsbc-credit",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "firela parser/sanitizer WASM module — isomorphic Node.js + Cloudflare Worker loader (ADR-0101 compiled-only).",
   "type": "module",
   "main": "./index-node.cjs",
@@ -8,7 +8,8 @@
   "exports": {
     ".": {
       "node": {
-        "require": "./index-node.cjs"
+        "require": "./index-node.cjs",
+        "import": "./index-node.mjs"
       },
       "worker": "./index-worker.js",
       "default": "./index-worker.js"
@@ -17,6 +18,7 @@
   },
   "files": [
     "index-node.cjs",
+    "index-node.mjs",
     "index-worker.js",
     "index.d.ts",
     "hk_hsbc_credit.opt.wasm"