From 11e8bcbed1b6690a92550a3a71f84d19143b561b Mon Sep 17 00:00:00 2001
From: Harshit Kumar <10harshitkumar@gmail.com>
Date: Tue, 2 Jun 2026 01:19:13 +0530
Subject: [PATCH 1/5] feat(logic): decouple compilation for template logic

Signed-off-by: Harshit Kumar <10harshitkumar@gmail.com>
---
 src/TemplateArchiveProcessor.ts       | 135 +++++++++++++-------------
 test/TemplateArchiveProcessor.test.ts |  59 ++++++++---
 2 files changed, 116 insertions(+), 78 deletions(-)

diff --git a/src/TemplateArchiveProcessor.ts b/src/TemplateArchiveProcessor.ts
index 5708205..8e0eb45 100644
--- a/src/TemplateArchiveProcessor.ts
+++ b/src/TemplateArchiveProcessor.ts
@@ -44,6 +44,7 @@ export type InitResponse = {
  */
 export class TemplateArchiveProcessor {
     template: Template;
+    private compiledLogicCache?: Record<string, TwoSlashReturn>;
 
     /**
      * Creates a template archive processor
@@ -82,22 +83,22 @@ export class TemplateArchiveProcessor {
 
     }
 
+
     /**
-     * Trigger the logic of a template
-     * @param {object} request - the request to send to the template logic
-     * @param {object} state - the current state of the template
-     * @param {[string]} currentTime - the current time, defaults to now
-     * @param {[number]} utcOffset - the UTC offset, defaults to zero
-     * @returns {Promise} the response and any events
+     * Compile the logic of a template
+     * @returns {Promise<Record<string, TwoSlashReturn>>} the compiled code for each typescript file
      */
-    async trigger(data: any, request: any, state?: any, currentTime?: string, utcOffset?: number): Promise<TriggerResponse> {
+    async compileLogic(): Promise<Record<string, TwoSlashReturn>> {
+        if (this.compiledLogicCache) {
+            return this.compiledLogicCache;
+        }
+
         const logicManager = this.template.getLogicManager();
         if(logicManager.getLanguage() === 'typescript') {
             const compiledCode:Record<string, TwoSlashReturn> = {};
             const tsFiles:Array<Script> = logicManager.getScriptManager().getScriptsForTarget('typescript');
             for(let n=0; n < tsFiles.length; n++) {
                 const tsFile = tsFiles[n];
-                // console.log(`Compiling ${tsFile.getIdentifier()}`);
 
                 const compiler = new TypeScriptToJavaScriptCompiler(this.template.getModelManager(),
                     this.template.getTemplateModel().getFullyQualifiedName());
@@ -106,29 +107,13 @@ export class TemplateArchiveProcessor {
 
                 // add the runtime type definitions to all ts files??
                 const code = `${Buffer.from(SMART_LEGAL_CONTRACT_BASE64, 'base64').toString()}
-                ${tsFile.getContents()}`
+                ${tsFile.getContents()}`;
 
                 const result = compiler.compile(code);
                 compiledCode[tsFile.getIdentifier()] = result;
             }
-            // console.log(compiledCode['logic/logic.ts'].code);
-            const resolvedTime = currentTime ?? new Date().toISOString();
-            const resolvedOffset = utcOffset ?? 0;
-            const evaluator = new JavaScriptEvaluator();
-            const evalResponse = await evaluator.evalDangerously( {
-                templateLogic: true,
-                verbose: false,
-                functionName: 'trigger',
-                code: compiledCode['logic/logic.ts'].code, // TODO DCS - how to find the code to run?
-                argumentNames: ['data', 'request', 'state'],
-                arguments: [data, request, state, resolvedTime, resolvedOffset]
-            });
-            if(evalResponse.result) {
-                return evalResponse.result;
-            }
-            else {
-                throw new Error('Trigger failed with message: ' + evalResponse.message);
-            }
+            this.compiledLogicCache = compiledCode;
+            return compiledCode;
         }
         else {
             throw new Error('Only TypeScript is supported at this time');
@@ -136,53 +121,69 @@ export class TemplateArchiveProcessor {
     }
 
     /**
-     * Init the logic of a template
+     * Trigger the logic of a template.
+     * WARNING: You must call compileLogic() before executing this method.
+     * @param {object} data - the data for the template
+     * @param {object} request - the request to send to the template logic
+     * @param {object} state - the current state of the template
      * @param {[string]} currentTime - the current time, defaults to now
      * @param {[number]} utcOffset - the UTC offset, defaults to zero
-     * @returns {Promise<InitResponse>} the new state
+     * @returns {Promise<TriggerResponse>} the response and any events
      */
-    async init(data: any, currentTime?: string, utcOffset?: number): Promise<InitResponse> {
-        const logicManager = this.template.getLogicManager();
-        if(logicManager.getLanguage() === 'typescript') {
-            const compiledCode:Record<string, TwoSlashReturn> = {};
-            const tsFiles:Array<Script> = logicManager.getScriptManager().getScriptsForTarget('typescript');
-            for(let n=0; n < tsFiles.length; n++) {
-                const tsFile = tsFiles[n];
-                // console.log(`Compiling ${tsFile.getIdentifier()}`);
-
-                const compiler = new TypeScriptToJavaScriptCompiler(this.template.getModelManager(),
-                    this.template.getTemplateModel().getFullyQualifiedName());
-
-                await compiler.initialize();
+    async trigger(data: any, request: any, state?: any, currentTime?: string, utcOffset?: number): Promise<TriggerResponse> {
+        if (!this.compiledLogicCache) {
+            throw new Error("Logic has not been compiled. You must call compileLogic() before executing init() or trigger().");
+        }
+        const compiledCode = this.compiledLogicCache;
+        const resolvedTime = currentTime ?? new Date().toISOString();
+        const resolvedOffset = utcOffset ?? 0;
+        const evaluator = new JavaScriptEvaluator();
+        const evalResponse = await evaluator.evalDangerously( {
+            templateLogic: true,
+            verbose: false,
+            functionName: 'trigger',
+            code: compiledCode['logic/logic.ts'].code, // TODO DCS - how to find the code to run?
+            argumentNames: ['data', 'request', 'state'],
+            arguments: [data, request, state, resolvedTime, resolvedOffset]
+        });
+        if(evalResponse.result) {
+            return evalResponse.result as TriggerResponse;
+        }
+        else {
+            throw new Error('Trigger failed with message: ' + evalResponse.message);
+        }
+    }
 
-                // add the runtime type definitions to all ts files??
-                const code = `${Buffer.from(SMART_LEGAL_CONTRACT_BASE64, 'base64').toString()}
-                ${tsFile.getContents()}`
 
-                const result = compiler.compile(code);
-                compiledCode[tsFile.getIdentifier()] = result;
-            }
-            // console.log(compiledCode['logic/logic.ts'].code);
-            const resolvedTime = currentTime ?? new Date().toISOString();
-            const resolvedOffset = utcOffset ?? 0;
-            const evaluator = new JavaScriptEvaluator();
-            const evalResponse = await evaluator.evalDangerously( {
-                templateLogic: true,
-                verbose: false,
-                functionName: 'init',
-                code: compiledCode['logic/logic.ts'].code, // TODO DCS - how to find the code to run?
-                argumentNames: ['data'],
-                arguments: [data, resolvedTime, resolvedOffset]
-            });
-            if(evalResponse.result) {
-                return evalResponse.result;
-            }
-            else {
-                throw new Error('Init failed with message: ' + evalResponse.message);
-            }
+    /**
+     * Init the logic of a template.
+     * WARNING: You must call compileLogic() before executing this method.
+     * @param {object} data - the data for the template
+     * @param {[string]} currentTime - the current time, defaults to now
+     * @param {[number]} utcOffset - the UTC offset, defaults to zero
+     * @returns {Promise<InitResponse>} the response and any events
+     */
+    async init(data: any, currentTime?: string, utcOffset?: number): Promise<InitResponse> {
+        if (!this.compiledLogicCache) {
+            throw new Error("Logic has not been compiled. You must call compileLogic() before executing init() or trigger().");
+        }
+        const compiledCode = this.compiledLogicCache;
+        const resolvedTime = currentTime ?? new Date().toISOString();
+        const resolvedOffset = utcOffset ?? 0;
+        const evaluator = new JavaScriptEvaluator();
+        const evalResponse = await evaluator.evalDangerously( {
+            templateLogic: true,
+            verbose: false,
+            functionName: 'init',
+            code: compiledCode['logic/logic.ts'].code, // TODO DCS - how to find the code to run?
+            argumentNames: ['data'],
+            arguments: [data, resolvedTime, resolvedOffset]
+        });
+        if(evalResponse.result) {
+            return evalResponse.result as InitResponse;
         }
         else {
-            throw new Error('Only TypeScript is supported at this time');
+            throw new Error('Init failed with message: ' + evalResponse.message);
         }
     }
 }
diff --git a/test/TemplateArchiveProcessor.test.ts b/test/TemplateArchiveProcessor.test.ts
index c82026b..97391a3 100644
--- a/test/TemplateArchiveProcessor.test.ts
+++ b/test/TemplateArchiveProcessor.test.ts
@@ -1,5 +1,5 @@
 import {Template} from '@accordproject/cicero-core';
-import { TemplateArchiveProcessor } from '../src/TemplateArchiveProcessor';
+import { TemplateArchiveProcessor, InitResponse, TriggerResponse } from '../src/TemplateArchiveProcessor';
 
 describe('template archive processor', () => {
     test('should draft a template', async () => {
@@ -51,12 +51,45 @@ describe('template archive processor', () => {
             "clauseId": "c88e5ed7-c3e0-4249-a99c-ce9278684ac8",
             "$identifier": "c88e5ed7-c3e0-4249-a99c-ce9278684ac8"
         };
-        const response = await templateArchiveProcessor.init(data);
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const payload:any = response.state;
+        await templateArchiveProcessor.compileLogic();
+        const response: InitResponse = await templateArchiveProcessor.init(data);
+        const payload = response.state as { count?: number };
         expect(payload.count).toBe(0);
     });
 
+    test('should compile logic', async () => {
+        const template = await Template.fromDirectory('test/archives/latedeliveryandpenalty-typescript', {offline: true});
+        const templateArchiveProcessor = new TemplateArchiveProcessor(template);
+        const compiledCode = await templateArchiveProcessor.compileLogic();
+        expect(compiledCode['logic/logic.ts']).toBeDefined();
+        expect(compiledCode['logic/logic.ts'].code).toContain('LateDeliveryAndPenalty');
+    });
+
+    test('should throw error if init is called without compileLogic', async () => {
+        const template = await Template.fromDirectory('test/archives/latedeliveryandpenalty-typescript', {offline: true});
+        const templateArchiveProcessor = new TemplateArchiveProcessor(template);
+        const data = {
+            "$class": "io.clause.latedeliveryandpenalty@0.1.0.TemplateModel",
+            "forceMajeure": true,
+            "penaltyDuration": {
+                "$class": "org.accordproject.time@0.3.0.Duration",
+                "amount": 2,
+                "unit": "days"
+            },
+            "penaltyPercentage": 10.5,
+            "capPercentage": 55,
+            "termination": {
+                "$class": "org.accordproject.time@0.3.0.Duration",
+                "amount": 15,
+                "unit": "days"
+            },
+            "fractionalPart": "days",
+            "clauseId": "c88e5ed7-c3e0-4249-a99c-ce9278684ac8",
+            "$identifier": "c88e5ed7-c3e0-4249-a99c-ce9278684ac8"
+        };
+        await expect(templateArchiveProcessor.init(data)).rejects.toThrow("Logic has not been compiled. You must call compileLogic() before executing init() or trigger().");
+    });
+
     test('should trigger a template', async () => {
         const template = await Template.fromDirectory('test/archives/latedeliveryandpenalty-typescript', {offline: true});
         const templateArchiveProcessor = new TemplateArchiveProcessor(template);
@@ -83,21 +116,25 @@ describe('template archive processor', () => {
             goodsValue: 100
         };
 
-        // first we init the template
+        // first we compile the logic
+        await templateArchiveProcessor.compileLogic();
+
+        // then we init the template
         const stateResponse = await templateArchiveProcessor.init(data);
 
         // then we trigger the template
-        const response = await templateArchiveProcessor.trigger(data, request, stateResponse.state);
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const payload:any = response;
+        const response: TriggerResponse = await templateArchiveProcessor.trigger(data, request, stateResponse.state);
 
         // we should have a result
-        expect(payload.result.penalty).toBe(2625);
+        const resultPayload = response.result as { penalty?: number };
+        expect(resultPayload.penalty).toBe(2625);
 
         // the state should have been updated
-        expect(payload.state.count).toBe(1);
+        const statePayload = response.state as { count?: number };
+        expect(statePayload.count).toBe(1);
 
         // the events should have been emitted
-        expect(payload.events[0].penaltyCalculated).toBe(true);
+        const eventPayload = response.events[0] as { penaltyCalculated?: boolean };
+        expect(eventPayload.penaltyCalculated).toBe(true);
     });
 });

From 565db24b243470273e19cefc233653e510fd4d10 Mon Sep 17 00:00:00 2001
From: Harshit Kumar <10harshitkumar@gmail.com>
Date: Tue, 2 Jun 2026 02:08:22 +0530
Subject: [PATCH 2/5] docs(logic): fix JSDoc return description for init()

Signed-off-by: Harshit Kumar <10harshitkumar@gmail.com>
---
 src/TemplateArchiveProcessor.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/TemplateArchiveProcessor.ts b/src/TemplateArchiveProcessor.ts
index 8e0eb45..535f192 100644
--- a/src/TemplateArchiveProcessor.ts
+++ b/src/TemplateArchiveProcessor.ts
@@ -161,7 +161,7 @@ export class TemplateArchiveProcessor {
      * @param {object} data - the data for the template
      * @param {[string]} currentTime - the current time, defaults to now
      * @param {[number]} utcOffset - the UTC offset, defaults to zero
-     * @returns {Promise<InitResponse>} the response and any events
+     * @returns {Promise<InitResponse>} the new state
      */
     async init(data: any, currentTime?: string, utcOffset?: number): Promise<InitResponse> {
         if (!this.compiledLogicCache) {

From d24baab2a29c56907267288224391fb9be01413d Mon Sep 17 00:00:00 2001
From: Harshit Kumar <10harshitkumar@gmail.com>
Date: Tue, 2 Jun 2026 02:12:08 +0530
Subject: [PATCH 3/5] test(logic): use regex for error assertion to improve
 resilience

Signed-off-by: Harshit Kumar <10harshitkumar@gmail.com>
---
 test/TemplateArchiveProcessor.test.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/TemplateArchiveProcessor.test.ts b/test/TemplateArchiveProcessor.test.ts
index 97391a3..491a466 100644
--- a/test/TemplateArchiveProcessor.test.ts
+++ b/test/TemplateArchiveProcessor.test.ts
@@ -87,7 +87,7 @@ describe('template archive processor', () => {
             "clauseId": "c88e5ed7-c3e0-4249-a99c-ce9278684ac8",
             "$identifier": "c88e5ed7-c3e0-4249-a99c-ce9278684ac8"
         };
-        await expect(templateArchiveProcessor.init(data)).rejects.toThrow("Logic has not been compiled. You must call compileLogic() before executing init() or trigger().");
+        await expect(templateArchiveProcessor.init(data)).rejects.toThrow(/must call compileLogic\(\)/);
     });
 
     test('should trigger a template', async () => {

From 40e98abf67dd0a5eba65d2d84d4355c1626df554 Mon Sep 17 00:00:00 2001
From: Harshit Kumar <10harshitkumar@gmail.com>
Date: Wed, 3 Jun 2026 00:19:07 +0530
Subject: [PATCH 4/5] feat(logic): implement lazy compilation with optional
 cache parameter per maintainer request

Signed-off-by: Harshit Kumar <10harshitkumar@gmail.com>
---
 src/TemplateArchiveProcessor.ts       | 27 +++++++++++------------
 test/TemplateArchiveProcessor.test.ts | 31 +--------------------------
 2 files changed, 13 insertions(+), 45 deletions(-)

diff --git a/src/TemplateArchiveProcessor.ts b/src/TemplateArchiveProcessor.ts
index 535f192..c8e0f78 100644
--- a/src/TemplateArchiveProcessor.ts
+++ b/src/TemplateArchiveProcessor.ts
@@ -86,10 +86,11 @@ export class TemplateArchiveProcessor {
 
     /**
      * Compile the logic of a template
+     * @param {boolean} [useCache] - whether to cache the compiled logic for future use
      * @returns {Promise<Record<string, TwoSlashReturn>>} the compiled code for each typescript file
      */
-    async compileLogic(): Promise<Record<string, TwoSlashReturn>> {
-        if (this.compiledLogicCache) {
+    async compileLogic(useCache: boolean = false): Promise<Record<string, TwoSlashReturn>> {
+        if (useCache && this.compiledLogicCache) {
             return this.compiledLogicCache;
         }
 
@@ -112,7 +113,9 @@ export class TemplateArchiveProcessor {
                 const result = compiler.compile(code);
                 compiledCode[tsFile.getIdentifier()] = result;
             }
-            this.compiledLogicCache = compiledCode;
+            if (useCache) {
+                this.compiledLogicCache = compiledCode;
+            }
             return compiledCode;
         }
         else {
@@ -122,19 +125,16 @@ export class TemplateArchiveProcessor {
 
     /**
      * Trigger the logic of a template.
-     * WARNING: You must call compileLogic() before executing this method.
      * @param {object} data - the data for the template
      * @param {object} request - the request to send to the template logic
      * @param {object} state - the current state of the template
      * @param {[string]} currentTime - the current time, defaults to now
      * @param {[number]} utcOffset - the UTC offset, defaults to zero
+     * @param {boolean} [useCache] - whether to use the compiled logic cache
      * @returns {Promise<TriggerResponse>} the response and any events
      */
-    async trigger(data: any, request: any, state?: any, currentTime?: string, utcOffset?: number): Promise<TriggerResponse> {
-        if (!this.compiledLogicCache) {
-            throw new Error("Logic has not been compiled. You must call compileLogic() before executing init() or trigger().");
-        }
-        const compiledCode = this.compiledLogicCache;
+    async trigger(data: any, request: any, state?: any, currentTime?: string, utcOffset?: number, useCache?: boolean): Promise<TriggerResponse> {
+        const compiledCode = await this.compileLogic(useCache);
         const resolvedTime = currentTime ?? new Date().toISOString();
         const resolvedOffset = utcOffset ?? 0;
         const evaluator = new JavaScriptEvaluator();
@@ -157,17 +157,14 @@ export class TemplateArchiveProcessor {
 
     /**
      * Init the logic of a template.
-     * WARNING: You must call compileLogic() before executing this method.
      * @param {object} data - the data for the template
      * @param {[string]} currentTime - the current time, defaults to now
      * @param {[number]} utcOffset - the UTC offset, defaults to zero
+     * @param {boolean} [useCache] - whether to use the compiled logic cache
      * @returns {Promise<InitResponse>} the new state
      */
-    async init(data: any, currentTime?: string, utcOffset?: number): Promise<InitResponse> {
-        if (!this.compiledLogicCache) {
-            throw new Error("Logic has not been compiled. You must call compileLogic() before executing init() or trigger().");
-        }
-        const compiledCode = this.compiledLogicCache;
+    async init(data: any, currentTime?: string, utcOffset?: number, useCache?: boolean): Promise<InitResponse> {
+        const compiledCode = await this.compileLogic(useCache);
         const resolvedTime = currentTime ?? new Date().toISOString();
         const resolvedOffset = utcOffset ?? 0;
         const evaluator = new JavaScriptEvaluator();
diff --git a/test/TemplateArchiveProcessor.test.ts b/test/TemplateArchiveProcessor.test.ts
index 491a466..470622f 100644
--- a/test/TemplateArchiveProcessor.test.ts
+++ b/test/TemplateArchiveProcessor.test.ts
@@ -51,7 +51,6 @@ describe('template archive processor', () => {
             "clauseId": "c88e5ed7-c3e0-4249-a99c-ce9278684ac8",
             "$identifier": "c88e5ed7-c3e0-4249-a99c-ce9278684ac8"
         };
-        await templateArchiveProcessor.compileLogic();
         const response: InitResponse = await templateArchiveProcessor.init(data);
         const payload = response.state as { count?: number };
         expect(payload.count).toBe(0);
@@ -65,31 +64,6 @@ describe('template archive processor', () => {
         expect(compiledCode['logic/logic.ts'].code).toContain('LateDeliveryAndPenalty');
     });
 
-    test('should throw error if init is called without compileLogic', async () => {
-        const template = await Template.fromDirectory('test/archives/latedeliveryandpenalty-typescript', {offline: true});
-        const templateArchiveProcessor = new TemplateArchiveProcessor(template);
-        const data = {
-            "$class": "io.clause.latedeliveryandpenalty@0.1.0.TemplateModel",
-            "forceMajeure": true,
-            "penaltyDuration": {
-                "$class": "org.accordproject.time@0.3.0.Duration",
-                "amount": 2,
-                "unit": "days"
-            },
-            "penaltyPercentage": 10.5,
-            "capPercentage": 55,
-            "termination": {
-                "$class": "org.accordproject.time@0.3.0.Duration",
-                "amount": 15,
-                "unit": "days"
-            },
-            "fractionalPart": "days",
-            "clauseId": "c88e5ed7-c3e0-4249-a99c-ce9278684ac8",
-            "$identifier": "c88e5ed7-c3e0-4249-a99c-ce9278684ac8"
-        };
-        await expect(templateArchiveProcessor.init(data)).rejects.toThrow(/must call compileLogic\(\)/);
-    });
-
     test('should trigger a template', async () => {
         const template = await Template.fromDirectory('test/archives/latedeliveryandpenalty-typescript', {offline: true});
         const templateArchiveProcessor = new TemplateArchiveProcessor(template);
@@ -116,10 +90,7 @@ describe('template archive processor', () => {
             goodsValue: 100
         };
 
-        // first we compile the logic
-        await templateArchiveProcessor.compileLogic();
-
-        // then we init the template
+        // first we init the template
         const stateResponse = await templateArchiveProcessor.init(data);
 
         // then we trigger the template

From e5aaec0b8f8b6df9dbdf30d82b8a914493a5d54f Mon Sep 17 00:00:00 2001
From: Harshit Kumar <10harshitkumar@gmail.com>
Date: Wed, 3 Jun 2026 15:26:37 +0530
Subject: [PATCH 5/5] chore: rename useCache to enableCompiledLogicCache

Signed-off-by: Harshit Kumar <10harshitkumar@gmail.com>
---
 src/TemplateArchiveProcessor.ts | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/TemplateArchiveProcessor.ts b/src/TemplateArchiveProcessor.ts
index c8e0f78..a9facc0 100644
--- a/src/TemplateArchiveProcessor.ts
+++ b/src/TemplateArchiveProcessor.ts
@@ -86,11 +86,11 @@ export class TemplateArchiveProcessor {
 
     /**
      * Compile the logic of a template
-     * @param {boolean} [useCache] - whether to cache the compiled logic for future use
+     * @param {boolean} [enableCompiledLogicCache] - whether to cache the compiled logic for future use
      * @returns {Promise<Record<string, TwoSlashReturn>>} the compiled code for each typescript file
      */
-    async compileLogic(useCache: boolean = false): Promise<Record<string, TwoSlashReturn>> {
-        if (useCache && this.compiledLogicCache) {
+    async compileLogic(enableCompiledLogicCache: boolean = false): Promise<Record<string, TwoSlashReturn>> {
+        if (enableCompiledLogicCache && this.compiledLogicCache) {
             return this.compiledLogicCache;
         }
 
@@ -113,7 +113,7 @@ export class TemplateArchiveProcessor {
                 const result = compiler.compile(code);
                 compiledCode[tsFile.getIdentifier()] = result;
             }
-            if (useCache) {
+            if (enableCompiledLogicCache) {
                 this.compiledLogicCache = compiledCode;
             }
             return compiledCode;
@@ -130,11 +130,11 @@ export class TemplateArchiveProcessor {
      * @param {object} state - the current state of the template
      * @param {[string]} currentTime - the current time, defaults to now
      * @param {[number]} utcOffset - the UTC offset, defaults to zero
-     * @param {boolean} [useCache] - whether to use the compiled logic cache
+     * @param {boolean} [enableCompiledLogicCache] - whether to use the compiled logic cache
      * @returns {Promise<TriggerResponse>} the response and any events
      */
-    async trigger(data: any, request: any, state?: any, currentTime?: string, utcOffset?: number, useCache?: boolean): Promise<TriggerResponse> {
-        const compiledCode = await this.compileLogic(useCache);
+    async trigger(data: any, request: any, state?: any, currentTime?: string, utcOffset?: number, enableCompiledLogicCache?: boolean): Promise<TriggerResponse> {
+        const compiledCode = await this.compileLogic(enableCompiledLogicCache);
         const resolvedTime = currentTime ?? new Date().toISOString();
         const resolvedOffset = utcOffset ?? 0;
         const evaluator = new JavaScriptEvaluator();
@@ -160,11 +160,11 @@ export class TemplateArchiveProcessor {
      * @param {object} data - the data for the template
      * @param {[string]} currentTime - the current time, defaults to now
      * @param {[number]} utcOffset - the UTC offset, defaults to zero
-     * @param {boolean} [useCache] - whether to use the compiled logic cache
+     * @param {boolean} [enableCompiledLogicCache] - whether to use the compiled logic cache
      * @returns {Promise<InitResponse>} the new state
      */
-    async init(data: any, currentTime?: string, utcOffset?: number, useCache?: boolean): Promise<InitResponse> {
-        const compiledCode = await this.compileLogic(useCache);
+    async init(data: any, currentTime?: string, utcOffset?: number, enableCompiledLogicCache?: boolean): Promise<InitResponse> {
+        const compiledCode = await this.compileLogic(enableCompiledLogicCache);
         const resolvedTime = currentTime ?? new Date().toISOString();
         const resolvedOffset = utcOffset ?? 0;
         const evaluator = new JavaScriptEvaluator();