testeranto 0.173.0 → 0.189.0

package/dist/module/src/lib/BaseSuite.js

@@ -1,17 +1,21 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
 import { beforeAllProxy, afterAllProxy } from "./pmProxy";
 export class BaseSuite {
+    addArtifact(path) {
+        console.log("Suite addArtifact", path);
+        const normalizedPath = path.replace(/\\/g, "/"); // Normalize path separators
+        this.artifacts.push(normalizedPath);
+    }
     constructor(name, index, givens = {}) {
+        this.artifacts = [];
         const suiteName = name || "testSuite"; // Ensure name is never undefined
         if (!suiteName) {
             throw new Error("BaseSuite requires a non-empty name");
         }
-        console.log("[DEBUG] BaseSuite constructor - name:", suiteName, "index:", index);
         this.name = suiteName;
         this.index = index;
         this.givens = givens;
         this.fails = 0;
-        console.log("[DEBUG] BaseSuite initialized:", this.name, this.index);
-        console.log("[DEBUG] BaseSuite givens:", Object.keys(givens).toString());
     }
     features() {
         try {
@@ -21,11 +25,10 @@ export class BaseSuite {
                 .filter((value, index, array) => {
                 return array.indexOf(value) === index;
             });
-            console.debug("[DEBUG] Features extracted:", features.toString());
             return features || [];
         }
         catch (e) {
-            console.error("[ERROR] Failed to extract features:", e);
+            console.error("[ERROR] Failed to extract features:", JSON.stringify(e));
             return [];
         }
     }
@@ -53,10 +56,10 @@ export class BaseSuite {
         // tLog("test resources: ", JSON.stringify(testResourceConfiguration));
         const suiteArtifactory = (fPath, value) => artifactory(`suite-${this.index}-${this.name}/${fPath}`, value);
         // console.log("\nSuite:", this.index, this.name);
-        tLog("\nSuite:", this.index, this.name);
+        // tLog("\nSuite:", this.index, this.name);
         const sNdx = this.index;
-        // const sName = this.name;
-        const subject = await this.setup(input, suiteArtifactory, testResourceConfiguration, beforeAllProxy(pm, sNdx.toString()));
+        const proxiedPm = beforeAllProxy(pm, sNdx.toString(), this);
+        const subject = await this.setup(input, suiteArtifactory, testResourceConfiguration, proxiedPm);
         for (const [gKey, g] of Object.entries(this.givens)) {
             const giver = this.givens[gKey];
             this.store = await giver
@@ -64,15 +67,15 @@ export class BaseSuite {
                 .catch((e) => {
                 this.failed = true;
                 this.fails = this.fails + 1;
-                // console.error("Given error 1:", e.toString());
                 throw e;
             });
         }
         try {
-            this.afterAll(this.store, artifactory, afterAllProxy(pm, sNdx.toString()));
+            const afterAllPm = afterAllProxy(pm, sNdx.toString(), this);
+            this.afterAll(this.store, artifactory, afterAllPm);
         }
         catch (e) {
-            console.error(e);
+            console.error(JSON.stringify(e));
             // this.fails.push(this);
             // return this;
         }

package/dist/module/src/lib/BaseSuite.test/mock.js

@@ -17,11 +17,8 @@ export class MockGiven extends BaseGiven {
 }
 export class MockWhen extends BaseWhen {
     async andWhen(store, whenCB, testResource, pm) {
-        console.log("[DEBUG] MockWhen - andWhen - input store:", JSON.stringify(store));
         const newStore = Object.assign(Object.assign({}, store), { testSelection: true });
-        console.log("[DEBUG] MockWhen - andWhen - calling whenCB");
         const result = await whenCB(newStore);
-        console.log("[DEBUG] MockWhen - andWhen - result:", JSON.stringify(result));
         return result;
     }
     addArtifact(name, content) {
@@ -31,10 +28,6 @@ export class MockWhen extends BaseWhen {
 }
 export class MockThen extends BaseThen {
     async butThen(store, thenCB, testResourceConfiguration, pm) {
-        console.log("[DEBUG] MockThen - butThen - input store:", JSON.stringify(store));
-        if (!store) {
-            throw new Error("Store is undefined in butThen");
-        }
         // Create test selection with explicit type
         const testSelection = {
             name: store.name,
@@ -42,10 +35,8 @@ export class MockThen extends BaseThen {
             testSelection: store.testSelection || false,
             error: store.error ? true : undefined,
         };
-        console.log("[DEBUG] MockThen - passing testSelection:", JSON.stringify(testSelection));
         try {
             const result = await thenCB(testSelection);
-            console.log("[DEBUG] MockThen - received result:", JSON.stringify(result));
             if (!result || typeof result.testSelection === "undefined") {
                 throw new Error(`Invalid test selection result: ${JSON.stringify(result)}`);
             }
@@ -62,13 +53,11 @@ export class MockSuite extends BaseSuite {
         if (!name) {
             throw new Error("MockSuite requires a non-empty name");
         }
-        console.log("[DEBUG] Creating MockSuite with name:", name, "index:", index);
         const suiteName = name || "testSuite"; // Ensure name is never undefined
         super(suiteName, index, {
             testGiven: new MockGiven("testGiven", ["testFeature"], [new MockWhen("testWhen", () => Promise.resolve({ testStore: true }))], [
                 new MockThen("testThen", async () => Promise.resolve({ testSelection: true })),
             ]),
         });
-        console.log("[DEBUG] MockSuite created:", this.name, this.index);
     }
 }

package/dist/module/src/lib/BaseSuite.test/test.js

@@ -52,7 +52,6 @@ export const implementation = {
     givens: {
         Default: () => {
             const suite = new MockSuite("testSuite", 0);
-            console.log("[DEBUG] Created test suite:", suite.name, suite.index);
             return suite;
         },
     },
@@ -70,7 +69,6 @@ export const implementation = {
             return suite;
         },
         RunSuite: () => async (suite) => {
-            console.log("[DEBUG] Running RunSuite");
             const mockConfig = {
                 name: "test",
                 fs: "/tmp",
@@ -115,21 +113,20 @@ export const implementation = {
         },
     },
     thens: {
-        SuiteNameMatches: (expectedName) => (suite) => {
-            console.log("[DEBUG] SuiteNameMatches - expected:", expectedName, "actual:", suite === null || suite === void 0 ? void 0 : suite.name);
-            if (!(suite === null || suite === void 0 ? void 0 : suite.name)) {
+        SuiteNameMatches: (expectedName) => (selection) => {
+            if (!selection.name) {
                 throw new Error(`Suite name is undefined. Expected: ${expectedName}`);
             }
-            if (suite.name !== expectedName) {
-                throw new Error(`Expected suite name '${expectedName}', got '${suite.name}'`);
+            if (selection.name !== expectedName) {
+                throw new Error(`Expected suite name '${expectedName}', got '${selection.name}'`);
             }
-            return suite;
+            return selection;
         },
-        SuiteIndexMatches: (expectedIndex) => (suite) => {
-            if (suite.index !== expectedIndex) {
-                throw new Error(`Expected suite index ${expectedIndex}, got ${suite.index}`);
+        SuiteIndexMatches: (expectedIndex) => (selection) => {
+            if (selection.index !== expectedIndex) {
+                throw new Error(`Expected suite index ${expectedIndex}, got ${selection.index}`);
             }
-            return suite;
+            return selection;
         },
         FeaturesIncludes: (feature) => (suite) => {
             if (!suite.features().includes(feature)) {
@@ -210,17 +207,11 @@ export const implementation = {
 // 5. Fully typed Test Adapter
 export const testAdapter = {
     beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
-        console.log("[DEBUG] Running beforeEach with subject:", subject);
         try {
             const suite = await initializer();
             if (!suite) {
                 throw new Error("Initializer returned undefined suite");
             }
-            console.log("[DEBUG] beforeEach result:", {
-                name: suite.name,
-                index: suite.index,
-                store: suite.store,
-            });
             return Object.assign({ name: suite.name, index: suite.index, testStore: true, testSelection: false }, (suite.store || {}));
         }
         catch (e) {
@@ -230,16 +221,14 @@ export const testAdapter = {
     },
     andWhen: async (store, whenCB, testResource, pm) => whenCB(store, pm),
     butThen: async (store, thenCB, testResource, pm) => {
-        console.log("[DEBUG] butThen - input store:", JSON.stringify(store, null, 2));
-        // Create test selection from store
         const testSelection = {
             testSelection: store.testSelection || false,
             error: store.error ? true : undefined,
+            name: store.name,
+            index: store.index,
         };
-        console.log("[DEBUG] butThen - created testSelection:", JSON.stringify(testSelection, null, 2));
         try {
             const result = await thenCB(testSelection);
-            console.log("[DEBUG] butThen - result:", JSON.stringify(result, null, 2));
             if (!result || typeof result.testSelection === "undefined") {
                 throw new Error(`Invalid test selection result: ${JSON.stringify(result)}`);
             }

package/dist/module/src/lib/Sidecar.js

@@ -1,2 +1,3 @@
+// Do not add logging to this file as it is used by the pure runtime.
 export class Sidecar {
 }

package/dist/module/src/lib/abstractBase.js

@@ -3,10 +3,9 @@
 import { afterEachProxy, andWhenProxy, beforeEachProxy, butThenProxy, } from "./pmProxy.js";
 export class BaseGiven {
     addArtifact(path) {
-        console.log(`[Artifact] Adding to ${this.constructor.name}:`, path);
-        // console.log("mark111");
-        // process.exit();
-        this.artifacts.push(path);
+        console.log("Given addArtifact", path);
+        const normalizedPath = path.replace(/\\/g, "/"); // Normalize path separators
+        this.artifacts.push(normalizedPath);
     }
     constructor(name, features, whens, thens, givenCB, initialValues) {
         this.artifacts = [];
@@ -27,7 +26,7 @@ export class BaseGiven {
             whens: this.whens.map((w) => {
                 if (w && w.toObj)
                     return w.toObj();
-                console.error("w is not as expected!", w.toString());
+                console.error("w is not as expected!", JSON.stringify(w));
                 return {};
             }),
             thens: this.thens.map((t) => t.toObj()),
@@ -51,15 +50,14 @@ export class BaseGiven {
             tLog(e.stack);
         });
         try {
-            const proxiedPm = beforeEachProxy(pm, suiteNdx.toString());
-            console.log(`[Given] Setting currentStep for beforeEach:`, this.name);
-            proxiedPm.currentStep = this;
+            const proxiedPm = beforeEachProxy(pm, suiteNdx.toString(), this.addArtifact.bind(this));
             this.store = await this.givenThat(subject, testResourceConfiguration, givenArtifactory, this.givenCB, this.initialValues, proxiedPm);
         }
         catch (e) {
-            console.error("Given failure: ", e.toString());
-            this.error = e;
-            throw e;
+            // console.error("Given failure: ", e.stack);
+            this.failed = true;
+            this.error = e.stack;
+            // throw e;
         }
         try {
             // tLog(`\n Given this.store`, this.store);
@@ -69,22 +67,21 @@ export class BaseGiven {
             for (const [thenNdx, thenStep] of this.thens.entries()) {
                 const t = await thenStep.test(this.store, testResourceConfiguration, tLog, pm, `suite-${suiteNdx}/given-${key}/then-${thenNdx}`);
                 tester(t);
-                // ((t) => {
-                //   return tester(t);
-                // })();
             }
         }
         catch (e) {
+            this.error = e.stack;
             this.failed = true;
-            tLog(e.stack);
-            throw e;
+            // tLog(e.stack);
+            // throw e;
         }
         finally {
             try {
-                await this.afterEach(this.store, this.key, givenArtifactory, afterEachProxy(pm, suiteNdx.toString(), key));
+                const proxiedPm = afterEachProxy(pm, suiteNdx.toString(), key, this.addArtifact.bind(this));
+                // (proxiedPm as any).currentStep = this;
+                await this.afterEach(this.store, this.key, givenArtifactory, proxiedPm);
             }
             catch (e) {
-                console.error("afterEach failed!", e.toString());
                 this.failed = e;
                 throw e;
                 // this.error = e.message;
@@ -94,36 +91,33 @@ export class BaseGiven {
     }
 }
 export class BaseWhen {
+    addArtifact(path) {
+        console.log("When addArtifact", path);
+        const normalizedPath = path.replace(/\\/g, "/"); // Normalize path separators
+        this.artifacts.push(normalizedPath);
+    }
     constructor(name, whenCB) {
         this.artifacts = [];
         this.name = name;
         this.whenCB = whenCB;
     }
     toObj() {
-        console.log("toObj error", this.error);
-        if (this.error) {
-            return {
-                name: this.name,
-                error: this.error && this.error.name + this.error.stack,
-                artifacts: this.artifacts,
-            };
-        }
-        else {
-            return {
-                name: this.name,
-                artifacts: this.artifacts,
-            };
-        }
+        const obj = {
+            name: this.name,
+            error: this.error
+                ? `${this.error.name}: ${this.error.message}\n${this.error.stack}`
+                : null,
+            artifacts: this.artifacts || [],
+        };
+        console.log(`[TOOBJ] Serializing ${this.constructor.name} with artifacts:`, obj.artifacts);
+        return obj;
     }
     async test(store, testResourceConfiguration, tLog, pm, filepath) {
         try {
-            tLog(" When:", this.name);
-            console.debug("[DEBUG] Executing When step:", this.name.toString());
-            const proxiedPm = andWhenProxy(pm, filepath);
-            console.log(`[When] Setting currentStep for andWhen:`, this.name);
-            proxiedPm.currentStep = this;
+            // tLog(" When:", this.name);
+            const proxiedPm = andWhenProxy(pm, filepath, this.addArtifact.bind(this));
+            // (proxiedPm as any).currentStep = this;
             const result = await this.andWhen(store, this.whenCB, testResourceConfiguration, proxiedPm);
-            console.debug("[DEBUG] When step completed:", this.name.toString());
             return result;
         }
         catch (e) {
@@ -139,27 +133,37 @@ export class BaseThen {
         this.name = name;
         this.thenCB = thenCB;
         this.error = false;
+        this.artifacts = [];
+    }
+    addArtifact(path) {
+        console.log("Then addArtifact", path);
+        const normalizedPath = path.replace(/\\/g, "/"); // Normalize path separators
+        this.artifacts.push(normalizedPath);
     }
     toObj() {
-        return {
+        const obj = {
             name: this.name,
             error: this.error,
             artifacts: this.artifacts,
         };
+        return obj;
     }
     async test(store, testResourceConfiguration, tLog, pm, filepath) {
-        const proxiedPm = butThenProxy(pm, filepath);
-        console.log(`[Then] Setting currentStep for butThen:`, this.name);
-        proxiedPm.currentStep = this;
+        const proxiedPm = butThenProxy(pm, filepath, this.addArtifact.bind(this));
         return this.butThen(store, async (s) => {
-            if (typeof this.thenCB === "function") {
-                return await this.thenCB(s, proxiedPm);
+            try {
+                if (typeof this.thenCB === "function") {
+                    return await this.thenCB(s, proxiedPm);
+                }
+                else {
+                    return this.thenCB;
+                }
             }
-            else {
-                return this.thenCB;
+            catch (e) {
+                console.error(e.stack);
             }
-        }, testResourceConfiguration, butThenProxy(pm, filepath)).catch((e) => {
-            this.error = e.toString();
+        }, testResourceConfiguration, proxiedPm).catch((e) => {
+            this.error = e.stack;
             // throw e;
         });
     }

package/dist/module/src/lib/baseBuilder.test/baseBuilder.test.adapter.js

@@ -1,13 +1,7 @@
 export const testAdapter = {
     beforeAll: async (input, testResource, pm) => input,
     beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
-        console.log("Initializing test with:", {
-            subject,
-            initializer,
-            initialValues,
-        });
         const result = initializer();
-        console.log("Initialization result:", result.toString());
         return result;
     },
     andWhen: async (store, whenCB, testResource, utils) => {

package/dist/module/src/lib/baseBuilder.test/baseBuilder.test.implementation.js

@@ -68,10 +68,12 @@ export const implementation = {
             }
             return builder;
         },
-        "it tracks artifacts": () => (builder) => {
+        "it tracks artifacts": () => (builder, utils) => {
             if (!Array.isArray(builder.artifacts)) {
                 throw new Error("Artifacts array not initialized");
             }
+            // Verify we can write artifacts
+            utils.writeFileSync("artifact_test.txt", "test");
             return builder;
         },
         resourceRequirementsSet: () => (builder) => {

package/dist/module/src/lib/baseBuilder.test/baseBuilder.test.mock.js

@@ -10,22 +10,33 @@ export class MockBaseBuilder extends BaseBuilder {
     /**
      * Simplified version for testing that doesn't actually run tests
      */
-    testRun(puppetMaster) {
-        this.summary = {
-            [puppetMaster.testResourceConfiguration.name]: {
-                typeErrors: 0,
-                staticErrors: 0,
-                runTimeError: "",
-                prompt: "",
-                failingFeatures: {},
-            },
-        };
-        return Promise.resolve({
-            failed: false,
-            fails: 0,
-            artifacts: [],
-            // logPromise: Promise.resolve(),
-            features: [],
-        });
+    async testRun(puppetMaster) {
+        try {
+            this.summary = {
+                [puppetMaster.testResourceConfiguration.name]: {
+                    typeErrors: 0,
+                    staticErrors: 0,
+                    runTimeError: "",
+                    prompt: "",
+                    failingFeatures: {},
+                },
+            };
+            return {
+                failed: false,
+                fails: 0,
+                artifacts: this.artifacts,
+                features: [],
+            };
+        }
+        catch (error) {
+            console.error("Test run failed:", error);
+            return {
+                failed: true,
+                fails: 1,
+                artifacts: this.artifacts,
+                features: [],
+                error: error.message
+            };
+        }
     }
 }

package/dist/module/src/lib/baseBuilder.test/baseBuilder.test.pure.js

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-empty-object-type */
-import Testeranto from "../../Web";
+import Testeranto from "../../Pure";
 import { specification } from "./baseBuilder.test.specification";
 import { implementation } from "./baseBuilder.test.implementation";
 import { testAdapter } from "./baseBuilder.test.adapter";

package/dist/module/src/lib/basebuilder.js

@@ -15,10 +15,15 @@ export class BaseBuilder {
         this.specs = testSpecification(this.Suites(), this.Given(), this.When(), this.Then());
         this.testJobs = this.specs.map((suite) => {
             const suiteRunner = (suite) => async (puppetMaster, tLog) => {
-                const x = await suite.run(input, puppetMaster.testResourceConfiguration, (fPath, value) => puppetMaster.testArtiFactoryfileWriter(tLog, (p) => {
-                    this.artifacts.push(p);
-                })(puppetMaster.testResourceConfiguration.fs + "/" + fPath, value), tLog, puppetMaster);
-                return x;
+                try {
+                    const x = await suite.run(input, puppetMaster.testResourceConfiguration, (fPath, value) => puppetMaster.testArtiFactoryfileWriter(tLog, (p) => {
+                        this.artifacts.push(p);
+                    })(puppetMaster.testResourceConfiguration.fs + "/" + fPath, value), tLog, puppetMaster);
+                    return x;
+                }
+                catch (e) {
+                    console.error(e.stack);
+                }
             };
             const runner = suiteRunner(suite);
             return {
@@ -28,35 +33,37 @@ export class BaseBuilder {
                 },
                 runner,
                 receiveTestResourceConfig: async function (puppetMaster) {
-                    // const logFilePath = "logs.txt";
-                    // const access: number = await puppetMaster.createWriteStream(
-                    //   logFilePath
-                    // );
                     // deprecated?
                     const tLog = async (...l) => {
                         //
                     };
-                    const suiteDone = await runner(puppetMaster, tLog);
+                    try {
+                        const suiteDone = await runner(puppetMaster, tLog);
+                        const fails = suiteDone.fails;
+                        await puppetMaster.writeFileSync([
+                            `tests.json`,
+                            JSON.stringify(this.toObj(), null, 2),
+                        ]);
+                        return {
+                            failed: fails > 0,
+                            fails,
+                            artifacts: this.artifacts || [],
+                            features: suiteDone.features(),
+                        };
+                    }
+                    catch (e) {
+                        console.error(e.stack);
+                        return {
+                            failed: true,
+                            fails: -1,
+                            artifacts: this.artifacts || [],
+                            features: [],
+                        };
+                    }
                     // const logPromise = new Promise(async (res) => {
                     //   await puppetMaster.end(access);
                     //   res(true);
                     // });
-                    const fails = suiteDone.fails;
-                    await puppetMaster.writeFileSync([
-                        `bdd_errors.txt`,
-                        fails.toString(),
-                    ]);
-                    await puppetMaster.writeFileSync([
-                        `tests.json`,
-                        JSON.stringify(this.toObj(), null, 2),
-                    ]);
-                    return {
-                        failed: fails > 0,
-                        fails,
-                        artifacts: this.artifacts || [],
-                        // logPromise,
-                        features: suiteDone.features(),
-                    };
                 },
             };
         });

package/dist/module/src/lib/classBuilder.js

@@ -1,3 +1,5 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { BaseBuilder } from "./basebuilder.js";
 export class ClassBuilder extends BaseBuilder {
     constructor(testImplementation, testSpecification, input, suiteKlasser, givenKlasser, whenKlasser, thenKlasser, testResourceRequirement) {

package/dist/module/src/lib/core.test/MockCore.js

@@ -6,19 +6,6 @@ import TesterantoCore from "../core";
  */
 export class MockCore extends TesterantoCore {
     constructor(input, testSpecification, testImplementation, testResourceRequirement = { ports: [] }, testAdapter, uberCatcher = (cb) => cb()) {
-        console.log("[DEBUG] MockCore constructor starting...");
-        if (!testImplementation) {
-            throw new Error("testImplementation is required");
-        }
-        if (!testSpecification) {
-            console.warn("[WARN] testSpecification is null/undefined - tests may fail");
-        }
-        console.log("[DEBUG] MockCore constructor called with:");
-        console.log("- input:", JSON.stringify(input, null, 2));
-        console.log("- testSpecification keys:", Object.keys(testSpecification));
-        console.log("- testImplementation keys:", Object.keys(testImplementation));
-        console.log("- testResourceRequirement:", JSON.stringify(testResourceRequirement));
-        console.log("- testAdapter keys:", Object.keys(testAdapter));
         // Validate required implementation methods
         const requiredMethods = ["suites", "givens", "whens", "thens"];
         requiredMethods.forEach((method) => {
@@ -26,7 +13,6 @@ export class MockCore extends TesterantoCore {
                 throw new Error(`Missing required implementation method: ${method}`);
             }
         });
-        console.log("[DEBUG] Validation passed, calling super...");
         // this.testResourceRequirement = testResourceRequirement;
         // this.testAdapter = testAdapter;
         super(input, testSpecification, testImplementation, testResourceRequirement, testAdapter, uberCatcher);

package/dist/module/src/lib/core.test/core.test.adapter.js

@@ -2,25 +2,18 @@ import { MockCore } from "./MockCore";
 export const testAdapter = {
     beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
         var _a;
-        console.log('[DEBUG] BeforeEach - subject:', subject);
-        console.log('[DEBUG] BeforeEach - initialValues:', initialValues);
-        console.log('[DEBUG] BeforeEach called with:');
-        console.log('- subject type:', typeof subject);
-        console.log('- testResource:', JSON.stringify(testResource, null, 2));
-        console.log('- initialValues:', initialValues);
         try {
             const result = await initializer();
             if (!result) {
-                throw new Error('Initializer returned undefined');
+                throw new Error("Initializer returned undefined");
             }
             if (!(result instanceof MockCore)) {
                 throw new Error(`Initializer returned ${(_a = result === null || result === void 0 ? void 0 : result.constructor) === null || _a === void 0 ? void 0 : _a.name}, expected MockCore`);
             }
-            console.log('[DEBUG] BeforeEach initialized MockCore successfully');
             return result;
         }
         catch (e) {
-            console.error('[ERROR] BeforeEach failed:', e);
+            console.error("[ERROR] BeforeEach failed:", e);
             throw e;
         }
     },

package/dist/module/src/lib/core.test/core.test.implementation.js

@@ -6,18 +6,14 @@ export const implementation = {
     },
     givens: {
         Default: () => {
-            console.log('[DEBUG] Creating Default MockCore instance');
             const input = { debug: true };
             const resourceReq = { ports: [3000] };
-            console.log('[DEBUG] Default Given - input:', input);
-            console.log('[DEBUG] Default Given - resourceReq:', resourceReq);
             try {
                 const instance = new MockCore(input, specification, implementation, resourceReq, testAdapter, (cb) => cb());
-                console.log('[DEBUG] MockCore instance created successfully:', instance);
                 return instance;
             }
             catch (e) {
-                console.error('[ERROR] Failed to create MockCore:', e);
+                console.error("[ERROR] Failed to create MockCore:", e);
                 throw e;
             }
         },
@@ -42,9 +38,9 @@ export const implementation = {
         },
         modifySpecs: (modifier) => (builder) => {
             var _a;
-            console.log('Modifying specs - current count:', (_a = builder.specs) === null || _a === void 0 ? void 0 : _a.length);
+            console.log("Modifying specs - current count:", (_a = builder.specs) === null || _a === void 0 ? void 0 : _a.length);
             const newSpecs = modifier(builder.specs || []);
-            console.log('Modifying specs - new count:', newSpecs.length);
+            console.log("Modifying specs - new count:", newSpecs.length);
             builder.specs = newSpecs;
             return builder;
         },

package/dist/module/src/lib/index.js

@@ -1,3 +1,5 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
 export const BaseAdapter = () => ({
     beforeAll: async (s) => s,
     beforeEach: async function (subject, initialValues, x, testResource, pm) {