fix: terminate worker threads after block evaluation in policy-service

policy-service/src/policy-engine/blocks/custom-logic-block.ts

@@ -387,18 +387,26 @@ export class CustomLogicBlock {
                                 tablesPack
                             },
                         });
+                    // Terminate the worker after the final 'done' (or on error) so
+                    // the V8 isolate is released. Without this the worker thread
+                    // stays alive after the script body returns, leaking ~30 MB per
+                    // custom-logic invocation.
+                    const cleanup = () => { worker.terminate().catch(() => { /* noop */ }); };
                     worker.on('error', (error) => {
+                        cleanup();
                         reject(error);
                     });
                     worker.on('message', async (data) => {
                         try {
                             if (data?.type === 'done') {
                                 await done(data.result, data.final);
+                                if (data.final) cleanup();
                             }
                             if (data?.type === 'debug') {
                                 ref.debug(data.message);
                             }
                         } catch (error) {
+                            cleanup();
                             reject(error);
                         }
                     });

policy-service/src/policy-engine/blocks/data-transformation-addon.ts

@@ -50,23 +50,32 @@ export class DataTransformationAddon {
                 },
             });
 
+            // Terminate the worker after the final result / on error so the V8
+            // isolate is released. Without this the worker thread stays alive
+            // after the script body returns, leaking ~30 MB per transformation.
+            const cleanup = () => { worker.terminate().catch(() => { /* noop */ }); };
+
             const done = async (result: any | any[], final: boolean) => {
                 if (!result) {
                     if (final) {
+                        cleanup();
                         resolve(null);
                     }
                     return;
                 }
+                if (final) cleanup();
                 resolve(result);
             }
 
             worker.on('error', (error) => {
+                cleanup();
                 reject(error);
             });
             worker.on('message', async (result: any) => {
                 try {
                     await done(result.result, result.final);
                 } catch (error) {
+                    cleanup();
                     reject(error);
                 }
             });

policy-service/src/policy-engine/blocks/math-block.ts

@@ -84,15 +84,21 @@ export class MathBlock {
         return new Promise<IPolicyDocument>(async (resolve, reject) => {
             const workerFile = path.join(path.dirname(filename), '..', 'helpers', 'workers', 'math-worker.js');
             const worker = new Worker(workerFile, { workerData });
+            // Terminate the worker once it finishes so the V8 isolate is released.
+            // Otherwise every formula evaluation leaks a worker thread (~30 MB).
+            const cleanup = () => { worker.terminate().catch(() => { /* noop */ }); };
             worker.on('error', (error) => {
+                cleanup();
                 reject(error);
             });
             worker.on('message', async (data) => {
                 try {
                     if (data?.type === 'done') {
+                        cleanup();
                         resolve(data.result)
                     }
                 } catch (error) {
+                    cleanup();
                     reject(error);
                 }
             });