Documentation

// Spawn the protected payload as a worker
const vaultWorker = new Worker('/path/to/payload_protected.js');

// 1. Listen for live telemetry (Safe Side-Channel)
const telemetryChannel = new BroadcastChannel('tp_telemetry');
telemetryChannel.onmessage = (e) => {
    console.log(`Progress: ${e.data.progress}%`);
};

// 2. Listen for the final calculated results
vaultWorker.addEventListener('message', (e) => {
  if (e.data && e.data.type === 'SUCCESS') {
    console.log("Result:", e.data.payload);
    telemetryChannel.close();
    vaultWorker.terminate(); 
  } 
  else if (e.data && e.data.type === 'ERROR') {
    console.error("Execution failed:", e.data.error);
    telemetryChannel.close();
    vaultWorker.terminate();
  }
  else if (e.data && e.data.status === 'error') {
    console.error("Thorn Prime Security Lockout:", e.data.message);
    telemetryChannel.close();
    vaultWorker.terminate();
  }
});

// Trigger the execution - MUST match the worker's guard condition!
vaultWorker.postMessage({ trigger: 'runMyAlgorithm', inputData: "ACGTACGTACGT" });

// ========================================
// 1. TOP CONFIGURATION (Optional for Local Testing)
var Module = typeof Module !== 'undefined' ? Module : {};
Module.locateFile = function(path) {
  if (path.endsWith('.wasm')) return '/path/to/your/module/' + path;
  return path;
};

// ===========
// 2. UNTOUCHED EMSCRIPTEN GLUE
// (Paste your generated emcc glue code here. DO NOT use -s MODULARIZE=1)

// ===========
// 3. WORKER MESSAGE LISTENER & WASM LOGIC
self.addEventListener('message', async (e) => {
  // A. FLEXIBLE GUARD CONDITION: Must match frontend's postMessage!
  if (e.data && (e.data.trigger === 'runMyAlgorithm' || e.data.inputData !== undefined)) {
    try {
      // B. WASM READY CHECK (Deadlock-proof initialization)
      await new Promise(resolve => {
          if (typeof Module !== 'undefined' && (Module.calledRun || Module._malloc)) {
              resolve();
          } else if (typeof Module !== 'undefined') {
              Module.onRuntimeInitialized = resolve;
              const interval = setInterval(() => {
                  if (typeof Module !== 'undefined' && (Module.calledRun || Module._malloc)) {
                      clearInterval(interval);
                      resolve();
                  }
              }, 50);
          }
      });

      // Optional: Setup Telemetry Broadcast (No proprietary data!)
      const telemetry = new BroadcastChannel('tp_telemetry');

      // C. *** PLACE YOUR CUSTOM WASM EXECUTION LOGIC HERE ***
      const inputData = e.data.inputData || "";
      const byteCount = Module.lengthBytesUTF8 ? Module.lengthBytesUTF8(inputData) + 1 : lengthBytesUTF8(inputData) + 1;
      const mallocFn = Module._malloc || _malloc;
      const freeFn = Module._free || _free;
      const stringToUTF8Fn = Module.stringToUTF8 || stringToUTF8;

      const inputPtr = mallocFn(byteCount);
      if (!inputPtr) throw new Error("WASM Heap Allocation Failed.");

      stringToUTF8Fn(inputData, inputPtr, byteCount);

      // Example: Emit safe telemetry metadata during heavy loops
      // telemetry.postMessage({ progress: 50 });

      // Call exported C function across memory chunks if necessary
      const alignFn = Module._align_chunk || _align_chunk;
      alignFn(inputPtr, byteCount - 1);

      // D. Safely pull accumulated results directly from Emscripten Heap
      const getCountFn = Module._get_mutation_count || _get_mutation_count;
      const getPtrFn = Module._get_buffer_ptr || _get_buffer_ptr;
      const rawCount = getCountFn ? getCountFn() : 0;

      // Safety Cap: Cap maximum returned objects to protect V8 postMessage cloning
      const safeCount = Math.min(rawCount, 50000);
      const ptr = getPtrFn ? getPtrFn() : 0;

      let heapView = null;
      if (typeof HEAPU32 !== 'undefined') {
          heapView = HEAPU32;
      } else if (Module.HEAPU32) {
          heapView = Module.HEAPU32;
      } else if (typeof HEAP8 !== 'undefined') {
          heapView = new Uint32Array(HEAP8.buffer);
      } else if (Module.HEAP8) {
          heapView = new Uint32Array(Module.HEAP8.buffer);
      }

      const results = [];
      if (heapView && ptr) {
          for (let i = 0; i < safeCount; i++) {
              results.push({
                  position: heapView[(ptr >> 2) + (i * 3)],
                  ncbiReference: String.fromCharCode(heapView[(ptr >> 2) + (i * 3) + 1]),
                  user: String.fromCharCode(heapView[(ptr >> 2) + (i * 3) + 2])
              });
          }
      }

      // E. Free Heap Memory (Crucial to prevent WebWorker OOM)
      freeFn(inputPtr);

      // F. Send single standardized response envelope back to frontend
      self.postMessage({ 
          type: 'SUCCESS', 
          payload: { status: "complete", result: results } 
      });
      
      telemetry.close();

    } catch (error) {
      self.postMessage({ 
          type: 'ERROR', 
          error: error.message || error.toString() 
      });
    }
  }
});