@bluelibs/runner 3.3.2 → 3.4.0

package/dist/run.js.map

@@ -1 +1 @@
-{"version":3,"file":"run.js","sourceRoot":"","sources":["../src/run.ts"],"names":[],"mappings":";;AAsDA,kBA0DC;AAhHD,oDAAiD;AAUjD,sEAAmE;AACnE,wDAAqD;AACrD,yDAAsD;AACtD,0CAAuC;AACvC,+EAA4E;AAC5E,qCAAkC;AAClC,+DAA4D;AAC5D,4CAAyC;AAqClC,KAAK,UAAU,GAAG,CACvB,QAAyB,EACzB,MAAU;IAEV,MAAM,YAAY,GAAG,IAAI,2BAAY,EAAE,CAAC;IAExC,2FAA2F;IAC3F,MAAM,MAAM,GAAG,IAAI,eAAM,CAAC,YAAY,CAAC,CAAC;IAExC,MAAM,KAAK,GAAG,IAAI,aAAK,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;IAC9C,MAAM,UAAU,GAAG,IAAI,uBAAU,CAAC,KAAK,EAAE,YAAY,EAAE,MAAM,CAAC,CAAC;IAC/D,MAAM,SAAS,GAAG,IAAI,yCAAmB,CACvC,KAAK,EACL,YAAY,EACZ,UAAU,EACV,MAAM,CACP,CAAC;IAEF,+FAA+F;IAC/F,KAAK,CAAC,eAAe,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IACxC,KAAK,CAAC,gBAAgB,CAAC,iCAAe,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IAC5D,KAAK,CAAC,gBAAgB,CAAC,iCAAe,CAAC,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC;IAEpE,kGAAkG;IAClG,MAAM,cAAc,GAAG,KAAK,CAAC,iBAAiB,EAAE,CAAC;IACjD,MAAM,oBAAoB,GAAG,IAAA,mDAAwB,EAAC,cAAc,CAAC,CAAC;IACtE,IAAI,oBAAoB,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC3C,MAAM,eAAM,CAAC,oBAAoB,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC;IACjE,CAAC;IAED,sFAAsF;IACtF,MAAM,KAAK,CAAC,gBAAgB,EAAE,CAAC;IAE/B,iGAAiG;IACjG,MAAM,KAAK,CAAC,sBAAsB,EAAE,CAAC;IACrC,MAAM,SAAS,CAAC,eAAe,EAAE,CAAC;IAClC,MAAM,SAAS,CAAC,sBAAsB,EAAE,CAAC;IAEzC,6DAA6D;IAC7D,MAAM,MAAM,CAAC,KAAK,CAAC,qCAAqC,CAAC,CAAC;IAE1D,mFAAmF;IACnF,iCAAiC;IACjC,MAAM,YAAY,CAAC,IAAI,CAAC,2BAAY,CAAC,UAAU,EAAE,IAAI,EAAE,QAAQ,CAAC,EAAE,CAAC,CAAC;IAEpE,0CAA0C;IAC1C,MAAM,SAAS,CAAC,cAAc,EAAE,CAAC;IAEjC,MAAM,YAAY,CAAC,IAAI,CAAC,2BAAY,CAAC,SAAS,EAAE,IAAI,EAAE,QAAQ,CAAC,EAAE,CAAC,CAAC;IACnE,MAAM,MAAM,CAAC,KAAK,CAAC,qCAAqC,CAAC,CAAC;IAE1D,0CAA0C;IAC1C,KAAK,CAAC,IAAI,EAAE,CAAC;IAEb,OAAO;QACL,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,KAAK;QACvB,OAAO,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,OAAO,EAAE;KAC/B,CAAC;AACJ,CAAC"}
+{"version":3,"file":"run.js","sourceRoot":"","sources":["../src/run.ts"],"names":[],"mappings":";;AAsDA,kBA6DC;AAnHD,oDAAiD;AAUjD,sEAAmE;AACnE,wDAAqD;AACrD,yDAAsD;AACtD,0CAAuC;AACvC,+EAA4E;AAC5E,qCAAqD;AACrD,+DAA4D;AAC5D,4CAAyC;AAqClC,KAAK,UAAU,GAAG,CACvB,QAAiE,EACjE,MAAU;IAKV,MAAM,YAAY,GAAG,IAAI,2BAAY,EAAE,CAAC;IAExC,2FAA2F;IAC3F,MAAM,MAAM,GAAG,IAAI,eAAM,CAAC,YAAY,CAAC,CAAC;IAExC,MAAM,KAAK,GAAG,IAAI,aAAK,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;IAC9C,MAAM,UAAU,GAAG,IAAI,uBAAU,CAAC,KAAK,EAAE,YAAY,EAAE,MAAM,CAAC,CAAC;IAC/D,MAAM,SAAS,GAAG,IAAI,yCAAmB,CACvC,KAAK,EACL,YAAY,EACZ,UAAU,EACV,MAAM,CACP,CAAC;IAEF,+FAA+F;IAC/F,KAAK,CAAC,eAAe,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IACxC,KAAK,CAAC,gBAAgB,CAAC,iCAAe,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IAC5D,KAAK,CAAC,gBAAgB,CAAC,iCAAe,CAAC,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC;IAEpE,kGAAkG;IAClG,MAAM,cAAc,GAAG,KAAK,CAAC,iBAAiB,EAAE,CAAC;IACjD,MAAM,oBAAoB,GAAG,IAAA,mDAAwB,EAAC,cAAc,CAAC,CAAC;IACtE,IAAI,oBAAoB,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC3C,MAAM,IAAI,kCAAyB,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC;IACnE,CAAC;IAED,sFAAsF;IACtF,MAAM,KAAK,CAAC,gBAAgB,EAAE,CAAC;IAE/B,iGAAiG;IACjG,MAAM,KAAK,CAAC,sBAAsB,EAAE,CAAC;IACrC,MAAM,SAAS,CAAC,eAAe,EAAE,CAAC;IAClC,MAAM,SAAS,CAAC,sBAAsB,EAAE,CAAC;IAEzC,6DAA6D;IAC7D,MAAM,MAAM,CAAC,KAAK,CAAC,qCAAqC,CAAC,CAAC;IAE1D,mFAAmF;IACnF,iCAAiC;IACjC,MAAM,YAAY,CAAC,IAAI,CAAC,2BAAY,CAAC,UAAU,EAAE,IAAI,EAAE,QAAQ,CAAC,EAAE,CAAC,CAAC;IAEpE,0CAA0C;IAC1C,MAAM,SAAS,CAAC,cAAc,EAAE,CAAC;IAEjC,MAAM,YAAY,CAAC,IAAI,CAAC,2BAAY,CAAC,SAAS,EAAE,IAAI,EAAE,QAAQ,CAAC,EAAE,CAAC,CAAC;IACnE,MAAM,MAAM,CAAC,KAAK,CAAC,qCAAqC,CAAC,CAAC;IAE1D,0CAA0C;IAC1C,KAAK,CAAC,IAAI,EAAE,CAAC;IAEb,OAAO;QACL,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,KAAK;QACvB,OAAO,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,OAAO,EAAE;KAC/B,CAAC;AACJ,CAAC"}

package/dist/t1.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/t1.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const define_1 = require("./define");
+const tag = (0, define_1.defineTag)({ id: "usertag" });
+const tag2 = (0, define_1.defineTag)({ id: "usertag2" });
+const tag3 = (0, define_1.defineTag)({ id: "usertag3" });
+// Preserve as a const tuple for type extraction
+const tags = [tag.with({ value: 123 }), tag2];
+// Build runtime meta by spreading the tuple (meta.tags becomes an array)
+const meta = {
+    tags: ["string", tag2, tag3, tag.with({ value: 123 })],
+};
+//# sourceMappingURL=t1.js.map

package/dist/t1.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"t1.js","sourceRoot":"","sources":["../src/t1.ts"],"names":[],"mappings":";;AAAA,qCAAqC;AAgBrC,MAAM,GAAG,GAAG,IAAA,kBAAS,EAA2B,EAAE,EAAE,EAAE,SAAS,EAAE,CAAC,CAAC;AACnE,MAAM,IAAI,GAAG,IAAA,kBAAS,EAAe,EAAE,EAAE,EAAE,UAAU,EAAE,CAAC,CAAC;AACzD,MAAM,IAAI,GAAG,IAAA,kBAAS,EAAa,EAAE,EAAE,EAAE,UAAU,EAAE,CAAC,CAAC;AAEvD,gDAAgD;AAChD,MAAM,IAAI,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,CAAU,CAAC;AAEvD,yEAAyE;AACzE,MAAM,IAAI,GAAG;IACX,IAAI,EAAE,CAAC,QAAQ,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC;CACvC,CAAC"}

package/dist/testing.d.ts

@@ -7,7 +7,7 @@ import { EventManager, Logger, Store, TaskRunner } from "./models";
  */
 export declare function createTestResource(root: RegisterableItems, options?: {
     overrides?: Array<IResource | ITask | IMiddleware | IResourceWithConfig>;
-}): IResource<void, ReturnType<typeof buildTestFacade>>;
+}): IResource<void, Promise<ReturnType<typeof buildTestFacade>>>;
 declare function buildTestFacade(deps: {
     taskRunner: TaskRunner;
     store: Store;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bluelibs/runner",
-  "version": "3.3.2",
+  "version": "3.4.0",
   "description": "BlueLibs Runner",
   "main": "dist/index.js",
   "repository": {
@@ -15,7 +15,7 @@
     "coverage": "jest --verbose --coverage",
     "test:clean": "jest --clearCache",
     "testonly": "npm test",
-    "test:ci": "npm run coverage -- --ci --maxWorkers=2  --reporters=default --reporters=jest-junit",
+    "test:ci": "jest --verbose --coverage --ci --maxWorkers=2 --reporters=default --reporters=jest-junit",
     "prepublishOnly": "npm run build",
     "typedoc": "typedoc --options typedoc.json",
     "benchmark": "jest --testMatch=\"**/__tests__/benchmark/benchmark.test.ts\" --testTimeout 10000"

package/src/__tests__/errors.test.ts

@@ -5,7 +5,20 @@ import {
   defineMiddleware,
 } from "../define";
 import { run } from "../run";
-import { Errors } from "../errors";
+import { Errors } from "..";
+
+const {
+  RuntimeError,
+  DuplicateRegistrationError,
+  DependencyNotFoundError,
+  UnknownItemTypeError,
+  CircularDependenciesError,
+  EventNotFoundError,
+  MiddlewareAlreadyGlobalError,
+  LockedError,
+  StoreAlreadyInitializedError,
+  ValidationError,
+} = Errors;
 
 describe("Errors", () => {
   it("should throw duplicateRegistration error", async () => {
@@ -18,7 +31,7 @@ describe("Errors", () => {
     });
 
     await expect(run(app)).rejects.toThrow(
-      Errors.duplicateRegistration("Task", "test.task").message
+      new DuplicateRegistrationError("Task", "test.task").message
     );
   });
 
@@ -38,7 +51,9 @@ describe("Errors", () => {
       },
     });
 
-    await expect(run(app)).rejects.toThrow(Errors.unknownItemType({}).message);
+    await expect(run(app)).rejects.toThrow(
+      new UnknownItemTypeError({}).message
+    );
   });
 
   it("should throw unknown item type error at resource level", async () => {
@@ -52,7 +67,9 @@ describe("Errors", () => {
       async init(_, {}) {},
     });
 
-    await expect(run(app)).rejects.toThrow(Errors.unknownItemType({}).message);
+    await expect(run(app)).rejects.toThrow(
+      new UnknownItemTypeError({}).message
+    );
   });
 
   it("should throw circularDependencies error", async () => {
@@ -91,7 +108,7 @@ describe("Errors", () => {
     });
 
     await expect(run(app)).rejects.toThrow(
-      Errors.eventNotFound("non.existent.event").message
+      new EventNotFoundError("non.existent.event").message
     );
   });
 
@@ -148,7 +165,7 @@ describe("Errors", () => {
     });
 
     await expect(run(app)).rejects.toThrow(
-      Errors.duplicateRegistration("Resource", "res1").message
+      new DuplicateRegistrationError("Resource", "res1").message
     );
   });
 
@@ -169,7 +186,7 @@ describe("Errors", () => {
     });
 
     await expect(run(app)).rejects.toThrow(
-      Errors.duplicateRegistration("Middleware", "middlewarex").message
+      new DuplicateRegistrationError("Middleware", "middlewarex").message
     );
   });
 
@@ -187,7 +204,7 @@ describe("Errors", () => {
     });
 
     await expect(run(app)).rejects.toThrow(
-      Errors.duplicateRegistration("Event", "ev1").message
+      new DuplicateRegistrationError("Event", "ev1").message
     );
   });
 
@@ -216,7 +233,7 @@ describe("Errors", () => {
     });
 
     await expect(run(app)).rejects.toThrow(
-      Errors.dependencyNotFound("Task test.off.the.grid").message
+      new DependencyNotFoundError("Task test.off.the.grid").message
     );
   });
 
@@ -244,7 +261,7 @@ describe("Errors", () => {
     });
 
     await expect(run(app)).rejects.toThrow(
-      Errors.dependencyNotFound("Resource test.off.the.grid").message
+      new DependencyNotFoundError("Resource test.off.the.grid").message
     );
   });
 
@@ -254,7 +271,71 @@ describe("Errors", () => {
       run: async () => {},
     }).everywhere();
     expect(() => first.everywhere()).toThrow(
-      Errors.middlewareAlreadyGlobal("x").message
+      new MiddlewareAlreadyGlobalError("x").message
     );
   });
+
+  describe("Error Classes", () => {
+    it("should have correct error names and inheritance", () => {
+      // Test base RuntimeError
+      const baseError = new RuntimeError("test");
+      expect(baseError.name).toBe("RuntimeError");
+      expect(baseError).toBeInstanceOf(Error);
+      expect(baseError).toBeInstanceOf(RuntimeError);
+
+      // Test DuplicateRegistrationError
+      const dupError = new DuplicateRegistrationError("Task", "test");
+      expect(dupError.name).toBe("DuplicateRegistrationError");
+      expect(dupError).toBeInstanceOf(Error);
+      expect(dupError).toBeInstanceOf(RuntimeError);
+      expect(dupError).toBeInstanceOf(DuplicateRegistrationError);
+
+      // Test DependencyNotFoundError
+      const depError = new DependencyNotFoundError("test");
+      expect(depError.name).toBe("DependencyNotFoundError");
+      expect(depError).toBeInstanceOf(RuntimeError);
+
+      // Test UnknownItemTypeError
+      const unknownError = new UnknownItemTypeError("test");
+      expect(unknownError.name).toBe("UnknownItemTypeError");
+      expect(unknownError).toBeInstanceOf(RuntimeError);
+
+      // Test CircularDependenciesError
+      const circularError = new CircularDependenciesError(["a", "b"]);
+      expect(circularError.name).toBe("CircularDependenciesError");
+      expect(circularError).toBeInstanceOf(RuntimeError);
+
+      // Test EventNotFoundError
+      const eventError = new EventNotFoundError("test");
+      expect(eventError.name).toBe("EventNotFoundError");
+      expect(eventError).toBeInstanceOf(RuntimeError);
+
+      // Test MiddlewareAlreadyGlobalError
+      const middlewareError = new MiddlewareAlreadyGlobalError("test");
+      expect(middlewareError.name).toBe("MiddlewareAlreadyGlobalError");
+      expect(middlewareError).toBeInstanceOf(RuntimeError);
+
+      // Test LockedError
+      const lockedError = new LockedError("test");
+      expect(lockedError.name).toBe("LockedError");
+      expect(lockedError).toBeInstanceOf(RuntimeError);
+
+      // Test StoreAlreadyInitializedError
+      const storeError = new StoreAlreadyInitializedError();
+      expect(storeError.name).toBe("StoreAlreadyInitializedError");
+      expect(storeError).toBeInstanceOf(RuntimeError);
+
+      // Test ValidationError with Error object
+      const validationErrorWithError = new ValidationError("Task input", "test-task", new Error("Required field missing"));
+      expect(validationErrorWithError.name).toBe("ValidationError");
+      expect(validationErrorWithError.message).toBe("Task input validation failed for test-task: Required field missing");
+      expect(validationErrorWithError).toBeInstanceOf(RuntimeError);
+
+      // Test ValidationError with string
+      const validationErrorWithString = new ValidationError("Resource config", Symbol("test-resource"), "Invalid configuration");
+      expect(validationErrorWithString.name).toBe("ValidationError");
+      expect(validationErrorWithString.message).toBe("Resource config validation failed for Symbol(test-resource): Invalid configuration");
+      expect(validationErrorWithString).toBeInstanceOf(RuntimeError);
+    });
+  });
 });

package/src/__tests__/models/EventManager.test.ts

@@ -4,7 +4,6 @@ import {
   symbolEvent,
   symbolFilePath,
 } from "../../defs";
-import { Errors } from "../../errors";
 import { EventManager } from "../../models/EventManager";
 
 describe("EventManager", () => {

package/src/__tests__/models/Logger.test.ts

@@ -5,12 +5,25 @@ import { globalEvents } from "../../globals/globalEvents";
 describe("Logger", () => {
   let logger: Logger;
   let mockEventManager: jest.Mocked<EventManager>;
+  let originalEnv: any;
 
   beforeEach(() => {
+    // Save original environment
+    originalEnv = { ...process.env };
+    
+    // Clear environment variables that might affect tests
+    delete process.env.RUNNER_DISABLE_LOGS;
+    delete process.env.RUNNER_LOG_LEVEL;
+    
     mockEventManager = new EventManager() as jest.Mocked<EventManager>;
     logger = new Logger(mockEventManager);
   });
 
+  afterEach(() => {
+    // Restore original environment
+    process.env = originalEnv;
+  });
+
   describe("log method", () => {
     it("should emit a log event with correct data", async () => {
       const testData = "Test log message";
@@ -318,7 +331,7 @@ describe("Logger", () => {
     it("should use bound context in log calls", async () => {
       const boundContext = { source: "testSource", userId: "123" };
       const loggerWithContext = new Logger(mockEventManager, boundContext);
-      
+
       mockEventManager.emit = jest.fn().mockResolvedValue(undefined);
       mockEventManager.hasListeners = jest.fn().mockReturnValue(true);
 
@@ -388,6 +401,70 @@ describe("Logger", () => {
     });
   });
 
+  describe("default print threshold", () => {
+    it("should default to 'info' level when no environment variables are set", () => {
+      const logger = new Logger(mockEventManager);
+      expect(logger.printThreshold).toBe("info");
+    });
+
+    it("should respect RUNNER_DISABLE_LOGS=true to disable logging", () => {
+      process.env.RUNNER_DISABLE_LOGS = "true";
+      const logger = new Logger(mockEventManager);
+      expect(logger.printThreshold).toBeNull();
+    });
+
+    it("should respect RUNNER_DISABLE_LOGS=1 to disable logging", () => {
+      process.env.RUNNER_DISABLE_LOGS = "1";
+      const logger = new Logger(mockEventManager);
+      expect(logger.printThreshold).toBeNull();
+    });
+
+    it("should respect RUNNER_LOG_LEVEL environment variable", () => {
+      process.env.RUNNER_LOG_LEVEL = "error";
+      const logger = new Logger(mockEventManager);
+      expect(logger.printThreshold).toBe("error");
+    });
+
+    it("should ignore invalid RUNNER_LOG_LEVEL and use default", () => {
+      process.env.RUNNER_LOG_LEVEL = "invalid_level";
+      const logger = new Logger(mockEventManager);
+      expect(logger.printThreshold).toBe("info");
+    });
+
+    it("should prioritize RUNNER_DISABLE_LOGS over RUNNER_LOG_LEVEL", () => {
+      process.env.RUNNER_DISABLE_LOGS = "true";
+      process.env.RUNNER_LOG_LEVEL = "debug";
+      const logger = new Logger(mockEventManager);
+      expect(logger.printThreshold).toBeNull();
+    });
+
+    it("should print info level logs by default", () => {
+      const consoleLogSpy = jest.spyOn(console, "log").mockImplementation();
+      
+      const logger = new Logger(mockEventManager);
+      logger.log("info", "This should be printed by default");
+      
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining("This should be printed by default")
+      );
+      
+      consoleLogSpy.mockRestore();
+    });
+
+    it("should not print debug level logs by default", () => {
+      const consoleLogSpy = jest.spyOn(console, "log").mockImplementation();
+      
+      const logger = new Logger(mockEventManager);
+      logger.log("debug", "This should not be printed by default");
+      
+      expect(consoleLogSpy).not.toHaveBeenCalledWith(
+        expect.stringContaining("This should not be printed by default")
+      );
+      
+      consoleLogSpy.mockRestore();
+    });
+  });
+
   it("should auto-print logs based on autoPrintLogsAfter option", () => {
     const autoPrintLevel: LogLevels = "warn";
     logger.setPrintThreshold(autoPrintLevel);
@@ -429,14 +506,14 @@ describe("Logger", () => {
 
   it("should disable auto-printing when setPrintThreshold is set to null", () => {
     const consoleLogSpy = jest.spyOn(console, "log").mockImplementation();
-    
+
     // Set to null to disable auto-printing
     logger.setPrintThreshold(null);
-    
+
     logger.log("error", "Should not be printed");
-    
+
     expect(consoleLogSpy).not.toHaveBeenCalled();
-    
+
     consoleLogSpy.mockRestore();
   });
 });

package/src/__tests__/recursion/c.resource.ts

@@ -15,4 +15,4 @@ export const cResource = defineResource({
     const result: string = await aTask(); // Still benefits of autocompletion
     return `C depends on ${result}`;
   },
-}) as IResource<void, string>; // This is the key change.
+}) as IResource<void, Promise<string>>; // This is the key change.

package/src/__tests__/run.overrides.test.ts

@@ -6,7 +6,7 @@ import {
   defineMiddleware,
   defineOverride,
 } from "../define";
-import { Errors } from "../errors";
+import { DependencyNotFoundError } from "../errors";
 import { run } from "../run";
 
 describe("run.overrides", () => {
@@ -230,7 +230,7 @@ describe("run.overrides", () => {
     });
 
     await expect(run(app)).rejects.toThrowError(
-      Errors.dependencyNotFound("task2").message
+      new DependencyNotFoundError("task2").message
     );
   });
 
@@ -256,7 +256,7 @@ describe("run.overrides", () => {
     });
 
     await expect(run(app)).rejects.toThrowError(
-      Errors.dependencyNotFound("override2").message
+      new DependencyNotFoundError("override2").message
     );
   });
 

package/src/__tests__/typesafety.test.ts

@@ -6,15 +6,12 @@ import {
   defineOverride,
   defineTag,
 } from "../define";
+import { IMeta } from "../defs";
 import {
-  IEventDefinition,
-  IMiddlewareDefinition,
-  IResource,
-  IResourceWithConfig,
-  ITaskDefinition,
-  RegisterableItems,
-} from "../defs";
-import { createTestResource } from "..";
+  EnsureResponseSatisfiesContracts,
+  HasContracts,
+} from "../defs.returnTag";
+import { createTestResource, run } from "..";
 
 // This is skipped because we mostly check typesafety.
 describe.skip("typesafety", () => {
@@ -244,7 +241,7 @@ describe.skip("typesafety", () => {
     const harness = createTestResource(app);
 
     // Types: input must match, override deps must match, output is awaited number
-    const { value: t } = await (await import("../run")).run(harness);
+    const { value: t } = await run(harness);
     const r1: number | undefined = await t.runTask(add, { x: 1 });
     // @ts-expect-error wrong input type
     await t.runTask(add, { z: 1 });
@@ -313,8 +310,114 @@ describe.skip("typesafety", () => {
           tag3,
         ],
       },
+      run: async (input) => {
+        return input;
+      },
     });
 
     expect(true).toBe(true);
   });
+
+  it("should enforce contracts on tasks", async () => {
+    interface IUser {
+      name: string;
+    }
+
+    interface IOther {
+      age: number;
+    }
+
+    const tag = defineTag<{ value: number }, IUser>({ id: "tag" });
+    const tag2 = defineTag<void, IOther>({ id: "tag2" });
+
+    const meta = {
+      tags: [tag.with({ value: 123 }), tag2, "string"],
+    } satisfies IMeta;
+
+    const response = {
+      age: 123,
+      name: "123", // intentional
+    };
+    type TEST = HasContracts<typeof meta>;
+    type TEST2 = EnsureResponseSatisfiesContracts<typeof meta, typeof response>;
+
+    const task = defineTask({
+      id: "task",
+      meta,
+      run: async (input: { name: string }) => {
+        return {
+          age: 123,
+          name: "123",
+        };
+      },
+    });
+    const task2 = defineTask({
+      id: "task",
+      meta,
+      // @ts-expect-error
+      run: async (input: { name: string }) => {
+        return {
+          age: "123",
+        };
+      },
+    });
+
+    const task3 = defineTask({
+      id: "task",
+      meta,
+      // @ts-expect-error
+      run: async (input: { name: string }) => {
+        return {};
+      },
+    });
+  });
+
+  it("should enforce contracts on resources", async () => {
+    interface IUser {
+      name: string;
+    }
+
+    interface IOther {
+      age: number;
+    }
+
+    const tag = defineTag<{ value: number }, IUser>({ id: "tag" });
+    const tag2 = defineTag<void, IOther>({ id: "tag2" });
+
+    const meta = {
+      tags: [tag.with({ value: 123 }), tag2, "string"],
+    } satisfies IMeta;
+
+    const resourceOk = defineResource({
+      id: "resource.ok",
+      meta,
+      init: async () => {
+        return {
+          age: 123,
+          name: "123",
+        };
+      },
+    });
+
+    const resourceBad1 = defineResource({
+      id: "resource.bad1",
+      meta,
+      // @ts-expect-error
+      init: async () => {
+        return {
+          age: "123",
+          name: "123",
+        };
+      },
+    });
+
+    const resourceBad2 = defineResource({
+      id: "resource.bad2",
+      meta,
+      // @ts-expect-error
+      init: async () => {
+        return {};
+      },
+    });
+  });
 });

package/src/__tests__/validation-edge-cases.test.ts

@@ -0,0 +1,111 @@
+import { defineTask, defineResource, defineEvent, defineMiddleware } from "../define";
+import { run } from "../run";
+import { ValidationError } from "../errors";
+import { IValidationSchema } from "../defs";
+
+// Mock validation schema similar to the existing pattern
+class MockValidationSchema<T> implements IValidationSchema<T> {
+  constructor(
+    private validator: (input: unknown) => T,
+  ) {}
+
+  parse(input: unknown): T {
+    return this.validator(input);
+  }
+}
+
+describe("Validation Edge Cases", () => {
+  it("should handle non-Error thrown from task input validation", async () => {
+    const taskSchema = new MockValidationSchema<string>((input: unknown) => {
+      // Throw a non-Error object to trigger the instanceof Error === false branch
+      throw "Non-error string thrown";
+    });
+
+    const task = defineTask({
+      id: "task.nonErrorValidation",
+      inputSchema: taskSchema,
+      run: async (input: string) => "success",
+    });
+
+    const app = defineResource({
+      id: "app",
+      register: [task],
+      dependencies: { task },
+      init: async (_, { task }) => {
+        await task("invalid");
+      },
+    });
+
+    await expect(run(app)).rejects.toThrow(ValidationError);
+    await expect(run(app)).rejects.toThrow("Task input validation failed for task.nonErrorValidation: Non-error string thrown");
+  });
+
+  it("should handle non-Error thrown from resource config validation", async () => {
+    const configSchema = new MockValidationSchema<any>((input: unknown) => {
+      throw "Resource config error string";
+    });
+
+    const resource = defineResource({
+      id: "resource.nonErrorValidation",
+      configSchema: configSchema,
+      init: async (config: any) => "success",
+    });
+
+    expect(() => {
+      resource.with({ invalid: "config" } as any);
+    }).toThrow(ValidationError);
+    expect(() => {
+      resource.with({ invalid: "config" } as any);
+    }).toThrow("Resource config validation failed for resource.nonErrorValidation: Resource config error string");
+  });
+
+  it("should handle non-Error thrown from middleware config validation", async () => {
+    const configSchema = new MockValidationSchema<any>((input: unknown) => {
+      throw "Middleware config error string";
+    });
+
+    const middleware = defineMiddleware({
+      id: "middleware.nonErrorValidation",
+      configSchema: configSchema,
+      run: async ({ next }) => next(),
+    });
+
+    expect(() => {
+      middleware.with({ invalid: "config" } as any);
+    }).toThrow(ValidationError);
+    expect(() => {
+      middleware.with({ invalid: "config" } as any);
+    }).toThrow("Middleware config validation failed for middleware.nonErrorValidation: Middleware config error string");
+  });
+
+  it("should handle non-Error thrown from event payload validation", async () => {
+    const payloadSchema = new MockValidationSchema<any>((input: unknown) => {
+      throw "Event payload error string";
+    });
+
+    const event = defineEvent({
+      id: "event.nonErrorValidation",
+      payloadSchema: payloadSchema,
+    });
+
+    const listenerTask = defineTask({
+      id: "task.listener",
+      on: event,
+      run: async (event) => {
+        // This won't be called because validation will fail
+      },
+    });
+
+    const app = defineResource({
+      id: "app",
+      register: [event, listenerTask],
+      dependencies: { event },
+      init: async (_, { event }) => {
+        await event({ invalid: "payload" });
+      },
+    });
+
+    await expect(run(app)).rejects.toThrow(ValidationError);
+    await expect(run(app)).rejects.toThrow("Event payload validation failed for event.nonErrorValidation: Event payload error string");
+  });
+});