@lage-run/scheduler 0.11.4 → 1.0.0

package/CHANGELOG.json

@@ -2,7 +2,58 @@
   "name": "@lage-run/scheduler",
   "entries": [
     {
-      "date": "Wed, 26 Apr 2023 04:56:07 GMT",
+      "date": "Mon, 08 May 2023 22:26:52 GMT",
+      "tag": "@lage-run/scheduler_v1.0.0",
+      "version": "1.0.0",
+      "comments": {
+        "major": [
+          {
+            "author": "kchau@microsoft.com",
+            "package": "@lage-run/scheduler",
+            "commit": "5a132808f166179bc316a279c9e11a13d3a39103",
+            "comment": "Now takes in a TargetHasher as a dep, but retains its own calls to cache provider"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/scheduler",
+            "comment": "Bump @lage-run/target-graph to v0.8.6",
+            "commit": "5a132808f166179bc316a279c9e11a13d3a39103"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/scheduler",
+            "comment": "Bump @lage-run/cache to v1.1.1",
+            "commit": "5a132808f166179bc316a279c9e11a13d3a39103"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/scheduler",
+            "comment": "Bump @lage-run/config to v0.2.1",
+            "commit": "5a132808f166179bc316a279c9e11a13d3a39103"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/scheduler",
+            "comment": "Bump @lage-run/hasher to v1.0.0",
+            "commit": "5a132808f166179bc316a279c9e11a13d3a39103"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/scheduler",
+            "comment": "Bump @lage-run/worker-threads-pool to v0.7.0",
+            "commit": "5a132808f166179bc316a279c9e11a13d3a39103"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/scheduler",
+            "comment": "Bump @lage-run/scheduler-types to v0.3.9",
+            "commit": "5a132808f166179bc316a279c9e11a13d3a39103"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Wed, 26 Apr 2023 04:56:20 GMT",
       "tag": "@lage-run/scheduler_v0.11.4",
       "version": "0.11.4",
       "comments": {
@@ -11,7 +62,7 @@
             "author": "beachball",
             "package": "@lage-run/scheduler",
             "comment": "Bump @lage-run/config to v0.2.0",
-            "commit": "56910ce2ef67d9d3dc99b7a75df007820e9444c8"
+            "commit": "994af55fcc890b448fc2b5cd5e4ba8bca0832997"
           }
         ]
       }

package/CHANGELOG.md

@@ -1,12 +1,26 @@
 # Change Log - @lage-run/scheduler
 
-This log was last generated on Wed, 26 Apr 2023 04:56:07 GMT and should not be manually modified.
+This log was last generated on Mon, 08 May 2023 22:26:52 GMT and should not be manually modified.
 
 <!-- Start content -->
 
+## 1.0.0
+
+Mon, 08 May 2023 22:26:52 GMT
+
+### Major changes
+
+- Now takes in a TargetHasher as a dep, but retains its own calls to cache provider (kchau@microsoft.com)
+- Bump @lage-run/target-graph to v0.8.6
+- Bump @lage-run/cache to v1.1.1
+- Bump @lage-run/config to v0.2.1
+- Bump @lage-run/hasher to v1.0.0
+- Bump @lage-run/worker-threads-pool to v0.7.0
+- Bump @lage-run/scheduler-types to v0.3.9
+
 ## 0.11.4
 
-Wed, 26 Apr 2023 04:56:07 GMT
+Wed, 26 Apr 2023 04:56:20 GMT
 
 ### Patches
 

package/lib/SimpleScheduler.d.ts

@@ -7,6 +7,7 @@ import type { TargetGraph } from "@lage-run/target-graph";
 import type { TargetScheduler, SchedulerRunSummary } from "@lage-run/scheduler-types";
 import type { Pool } from "@lage-run/worker-threads-pool";
 import type { TargetRunnerPickerOptions } from "@lage-run/scheduler-types";
+import type { TargetHasher } from "@lage-run/hasher";
 export interface SimpleSchedulerOptions {
     logger: Logger;
     concurrency: number;
@@ -22,6 +23,7 @@ export interface SimpleSchedulerOptions {
     maxWorkersPerTask: Map<string, number>;
     pool?: Pool;
     workerIdleMemoryLimit: number;
+    hasher: TargetHasher;
 }
 /**
  * Simple scheduler that runs all targets in a promise graph using p-graph library.

package/lib/SimpleScheduler.js

@@ -4,33 +4,48 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "SimpleScheduler", {
     enumerable: true,
-    get: ()=>SimpleScheduler
+    get: function() {
+        return SimpleScheduler;
+    }
 });
-const _workerThreadsPool = require("@lage-run/worker-threads-pool");
-const _formatBytesJs = require("./formatBytes.js");
-const _categorizeTargetRunsJs = require("./categorizeTargetRuns.js");
-const _targetGraph = require("@lage-run/target-graph");
-const _wrappedTargetJs = require("./WrappedTarget.js");
-const _targetRunnerPickerJs = require("./runners/TargetRunnerPicker.js");
-function _checkPrivateRedeclaration(obj, privateCollection) {
+const _workerthreadspool = require("@lage-run/worker-threads-pool");
+const _formatBytes = require("./formatBytes.js");
+const _categorizeTargetRuns = require("./categorizeTargetRuns.js");
+const _targetgraph = require("@lage-run/target-graph");
+const _WrappedTarget = require("./WrappedTarget.js");
+const _TargetRunnerPicker = require("./runners/TargetRunnerPicker.js");
+function _check_private_redeclaration(obj, privateCollection) {
     if (privateCollection.has(obj)) {
         throw new TypeError("Cannot initialize the same private elements twice on an object");
     }
 }
-function _classPrivateMethodGet(receiver, privateSet, fn) {
+function _class_private_method_get(receiver, privateSet, fn) {
     if (!privateSet.has(receiver)) {
         throw new TypeError("attempted to get private field on non-instance");
     }
     return fn;
 }
-function _classPrivateMethodInit(obj, privateSet) {
-    _checkPrivateRedeclaration(obj, privateSet);
+function _class_private_method_init(obj, privateSet) {
+    _check_private_redeclaration(obj, privateSet);
     privateSet.add(obj);
 }
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
 var _generateTargetRunPromise = /*#__PURE__*/ new WeakSet();
 class SimpleScheduler {
     getTargetsByPriority() {
-        return (0, _targetGraph.sortTargetsByPriority)([
+        return (0, _targetgraph.sortTargetsByPriority)([
             ...this.targetRuns.values()
         ].map((run)=>run.target));
     }
@@ -68,17 +83,18 @@ class SimpleScheduler {
                     this.markTargetAndDependentsPending(target.id);
                 }
             } else {
-                targetRun = new _wrappedTargetJs.WrappedTarget({
+                targetRun = new _WrappedTarget.WrappedTarget({
                     target,
                     root,
                     logger,
                     shouldCache,
                     continueOnError,
                     abortController,
-                    pool
+                    pool,
+                    hasher: this.options.hasher
                 });
             }
-            if (target.id === (0, _targetGraph.getStartTargetId)()) {
+            if (target.id === (0, _targetgraph.getStartTargetId)()) {
                 targetRun.status = "success";
             }
             this.targetRuns.set(target.id, targetRun);
@@ -96,12 +112,13 @@ class SimpleScheduler {
             error = e instanceof Error ? e.message : String(e);
         } finally{
             duration = process.hrtime(startTime);
-            targetRunByStatus = (0, _categorizeTargetRunsJs.categorizeTargetRuns)(this.targetRuns.values());
+            targetRunByStatus = (0, _categorizeTargetRuns.categorizeTargetRuns)(this.targetRuns.values());
             if (targetRunByStatus.failed.length + targetRunByStatus.aborted.length + targetRunByStatus.pending.length + targetRunByStatus.running.length === 0) {
                 results = "success";
             }
         }
         const poolStats = pool.stats();
+        await this.options.hasher.cleanup();
         return {
             targetRunByStatus,
             targetRuns: this.targetRuns,
@@ -139,7 +156,7 @@ class SimpleScheduler {
         const readyTargets = new Set();
         for (const target of this.getTargetsByPriority()){
             // Skip the start target
-            if (target.id === (0, _targetGraph.getStartTargetId)()) {
+            if (target.id === (0, _targetgraph.getStartTargetId)()) {
                 continue;
             }
             const targetRun = this.targetRuns.get(target.id);
@@ -149,7 +166,7 @@ class SimpleScheduler {
                 // Target is only ready when all its deps are "successful" or that it is a root target
                 const ready = targetDeps.every((dep)=>{
                     const fromTarget = this.targetRuns.get(dep);
-                    return fromTarget.successful || dep === (0, _targetGraph.getStartTargetId)();
+                    return fromTarget.successful || dep === (0, _targetgraph.getStartTargetId)();
                 });
                 if (ready) {
                     readyTargets.add(targetRun);
@@ -162,7 +179,7 @@ class SimpleScheduler {
     }
     isAllDone() {
         for (const t of this.targetRuns.values()){
-            if (t.status !== "skipped" && t.status !== "success" && t.target.id !== (0, _targetGraph.getStartTargetId)()) {
+            if (t.status !== "skipped" && t.status !== "success" && t.target.id !== (0, _targetgraph.getStartTargetId)()) {
                 return false;
             }
         }
@@ -172,16 +189,16 @@ class SimpleScheduler {
         if (this.isAllDone() || this.abortSignal.aborted) {
             return Promise.resolve();
         }
-        this.options.logger.silly(`Max Worker Memory Usage: ${(0, _formatBytesJs.formatBytes)(this.pool.stats().maxWorkerMemoryUsage)}`);
+        this.options.logger.silly(`Max Worker Memory Usage: ${(0, _formatBytes.formatBytes)(this.pool.stats().maxWorkerMemoryUsage)}`);
         const promises = [];
         for (const nextTarget of this.getReadyTargets()){
-            const runPromise = _classPrivateMethodGet(this, _generateTargetRunPromise, generateTargetRunPromise).call(this, nextTarget);
+            const runPromise = _class_private_method_get(this, _generateTargetRunPromise, generateTargetRunPromise).call(this, nextTarget);
             promises.push(runPromise);
         }
         await Promise.all(promises);
     }
     logProgress() {
-        const targetRunByStatus = (0, _categorizeTargetRunsJs.categorizeTargetRuns)(this.targetRuns.values());
+        const targetRunByStatus = (0, _categorizeTargetRuns.categorizeTargetRuns)(this.targetRuns.values());
         const total = [
             ...this.targetRuns.values()
         ].filter((t)=>!t.target.hidden).length;
@@ -195,7 +212,7 @@ class SimpleScheduler {
         });
     }
     async cleanup() {
-        this.options.logger.silly(`Max Worker Memory Usage: ${(0, _formatBytesJs.formatBytes)(this.pool.stats().maxWorkerMemoryUsage)}`);
+        this.options.logger.silly(`Max Worker Memory Usage: ${(0, _formatBytes.formatBytes)(this.pool.stats().maxWorkerMemoryUsage)}`);
         await this.pool.close();
     }
     /**
@@ -204,14 +221,22 @@ class SimpleScheduler {
         this.abortController.abort();
     }
     constructor(options){
-        _classPrivateMethodInit(this, _generateTargetRunPromise);
+        _class_private_method_init(this, _generateTargetRunPromise);
+        _define_property(this, "options", void 0);
+        _define_property(this, "targetRuns", void 0);
+        _define_property(this, "rerunTargets", void 0);
+        _define_property(this, "abortController", void 0);
+        _define_property(this, "abortSignal", void 0);
+        _define_property(this, "pool", void 0);
+        _define_property(this, "runnerPicker", void 0);
+        _define_property(this, "runPromise", void 0);
         this.options = options;
         this.targetRuns = new Map();
         this.rerunTargets = new Set();
         this.abortController = new AbortController();
         this.abortSignal = this.abortController.signal;
         this.runPromise = Promise.resolve();
-        this.pool = options.pool ?? new _workerThreadsPool.AggregatedPool({
+        this.pool = options.pool ?? new _workerthreadspool.AggregatedPool({
             logger: options.logger,
             maxWorkersByGroup: options.maxWorkersPerTask,
             groupBy: ({ target  })=>target.task,
@@ -228,7 +253,7 @@ class SimpleScheduler {
             },
             workerIdleMemoryLimit: options.workerIdleMemoryLimit
         });
-        this.runnerPicker = new _targetRunnerPickerJs.TargetRunnerPicker(options.workerData.runners);
+        this.runnerPicker = new _TargetRunnerPicker.TargetRunnerPicker(options.workerData.runners);
     }
 }
 async function generateTargetRunPromise(target) {

package/lib/WrappedTarget.d.ts

@@ -3,6 +3,7 @@ import type { Pool } from "@lage-run/worker-threads-pool";
 import type { TargetRun, TargetStatus } from "@lage-run/scheduler-types";
 import type { Target } from "@lage-run/target-graph";
 import type { Logger } from "@lage-run/logger";
+import type { TargetHasher } from "@lage-run/hasher";
 export interface WrappedTargetOptions {
     root: string;
     target: Target;
@@ -11,6 +12,7 @@ export interface WrappedTargetOptions {
     continueOnError: boolean;
     abortController: AbortController;
     pool: Pool;
+    hasher: TargetHasher;
 }
 interface WorkerResult {
     stdoutBuffer: string;

package/lib/WrappedTarget.js

@@ -4,15 +4,30 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "WrappedTarget", {
     enumerable: true,
-    get: ()=>WrappedTarget
+    get: function() {
+        return WrappedTarget;
+    }
 });
-const _bufferTransformJs = require("./bufferTransform.js");
-const _getLageOutputCacheLocationJs = require("./getLageOutputCacheLocation.js");
+const _bufferTransform = require("./bufferTransform.js");
+const _getLageOutputCacheLocation = require("./getLageOutputCacheLocation.js");
 const _logger = require("@lage-run/logger");
-const _fs = /*#__PURE__*/ _interopRequireDefault(require("fs"));
-const _path = /*#__PURE__*/ _interopRequireDefault(require("path"));
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
 const _promises = require("fs/promises");
-function _interopRequireDefault(obj) {
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
@@ -94,7 +109,7 @@ class WrappedTarget {
         }
     }
     async run() {
-        const { target , logger , shouldCache , abortController  } = this.options;
+        const { target , logger , shouldCache , abortController , root  } = this.options;
         const abortSignal = abortController.signal;
         if (abortSignal.aborted) {
             this.onStart(0);
@@ -106,34 +121,29 @@ class WrappedTarget {
             const cacheEnabled = target.cache && shouldCache && result.hash;
             // Save output if cache is enabled & cache is hit
             if (!result.skipped && cacheEnabled) {
-                const outputLocation = (0, _getLageOutputCacheLocationJs.getLageOutputCacheLocation)(this.options.root, result.hash);
+                const outputLocation = (0, _getLageOutputCacheLocation.getLageOutputCacheLocation)(root, result.hash);
                 const outputPath = _path.default.dirname(outputLocation);
                 await (0, _promises.mkdir)(outputPath, {
                     recursive: true
                 });
                 const output = `${result.stdoutBuffer}\n${result.stderrBuffer}`;
                 await (0, _promises.writeFile)(outputLocation, output);
-                this.options.logger.verbose(`>> Saved cache - ${result.hash}`, {
+                logger.verbose(`>> Saved cache - ${result.hash}`, {
                     target
                 });
             }
             if (result.skipped) {
                 const { hash  } = result;
-                const cachedOutputFile = (0, _getLageOutputCacheLocationJs.getLageOutputCacheLocation)(this.options.root, hash ?? "");
-                if (_fs.default.existsSync(cachedOutputFile)) {
-                    const cachedOutput = _fs.default.createReadStream(cachedOutputFile, "utf8");
-                    this.options.logger.verbose(">> Replaying cached output", {
+                const cachedOutputFile = (0, _getLageOutputCacheLocation.getLageOutputCacheLocation)(root, hash ?? "");
+                const shouldShowCachedOutput = _fs.default.existsSync(cachedOutputFile);
+                if (shouldShowCachedOutput) {
+                    const cachedOutput = _fs.default.readFileSync(cachedOutputFile, "utf8");
+                    logger.verbose(">> Replaying cached output", {
                         target
                     });
-                    this.options.logger.stream(_logger.LogLevel.verbose, cachedOutput, {
+                    logger.verbose(cachedOutput.trim(), {
                         target
                     });
-                    return await new Promise((resolve)=>{
-                        cachedOutput.on("close", ()=>{
-                            this.onSkipped(hash);
-                            resolve();
-                        });
-                    });
                 }
                 this.onSkipped(hash);
             } else {
@@ -156,21 +166,28 @@ class WrappedTarget {
         const abortSignal = abortController.signal;
         let releaseStdout;
         let releaseStderr;
-        const bufferStdout = (0, _bufferTransformJs.bufferTransform)();
-        const bufferStderr = (0, _bufferTransformJs.bufferTransform)();
-        let logHandler;
+        const bufferStdout = (0, _bufferTransform.bufferTransform)();
+        const bufferStderr = (0, _bufferTransform.bufferTransform)();
+        let msgHandler;
         this.result = pool.exec({
             target
         }, target.weight ?? 1, (worker, stdout, stderr)=>{
-            logHandler = (data)=>{
+            msgHandler = (data)=>{
                 if (data.type === "log") {
                     logger.log(data.level, data.msg, {
                         target,
                         threadId: worker.threadId
                     });
+                } else if (data.type === "hash") {
+                    this.options.hasher.hash(target).then((hash)=>{
+                        worker.postMessage({
+                            type: "hash",
+                            hash
+                        });
+                    });
                 }
             };
-            worker.on("message", logHandler);
+            worker.on("message", msgHandler);
             const threadId = worker.threadId;
             this.onStart(threadId);
             stdout.pipe(bufferStdout.transform);
@@ -192,7 +209,7 @@ class WrappedTarget {
                 stderr.unpipe(bufferStderr.transform);
             };
         }, (worker)=>{
-            worker.off("message", logHandler);
+            worker.off("message", msgHandler);
             releaseStdout();
             releaseStderr();
         }, abortSignal);
@@ -217,6 +234,14 @@ class WrappedTarget {
         };
     }
     constructor(options){
+        _define_property(this, "options", void 0);
+        _define_property(this, "queueTime", void 0);
+        _define_property(this, "startTime", void 0);
+        _define_property(this, "duration", void 0);
+        _define_property(this, "target", void 0);
+        _define_property(this, "status", void 0);
+        _define_property(this, "threadId", void 0);
+        _define_property(this, "result", void 0);
         this.options = options;
         this.queueTime = [
             0,

package/lib/bufferTransform.js

@@ -4,7 +4,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "bufferTransform", {
     enumerable: true,
-    get: ()=>bufferTransform
+    get: function() {
+        return bufferTransform;
+    }
 });
 const _stream = require("stream");
 function bufferTransform() {

package/lib/cache/createCacheProvider.d.ts

@@ -1,5 +1,5 @@
 import type { CacheOptions } from "@lage-run/cache";
-import { RemoteFallbackCacheProvider, TargetHasher } from "@lage-run/cache";
+import { RemoteFallbackCacheProvider } from "@lage-run/cache";
 import type { Logger } from "@lage-run/logger";
 interface CreateCacheOptions {
     cacheOptions?: CacheOptions;
@@ -8,8 +8,7 @@ interface CreateCacheOptions {
     skipLocalCache: boolean;
     cliArgs: string[];
 }
-export declare function createCache(options: CreateCacheOptions): {
+export declare function createCache(options: CreateCacheOptions): Promise<{
     cacheProvider: RemoteFallbackCacheProvider;
-    hasher: TargetHasher;
-};
+}>;
 export {};

package/lib/cache/createCacheProvider.js

@@ -4,12 +4,14 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "createCache", {
     enumerable: true,
-    get: ()=>createCache
+    get: function() {
+        return createCache;
+    }
 });
 const _cache = require("@lage-run/cache");
-const _isRunningFromCIJs = require("./isRunningFromCI.js");
-function createCache(options) {
-    const { cacheOptions , logger , root , skipLocalCache , cliArgs  } = options;
+const _isRunningFromCI = require("./isRunningFromCI.js");
+async function createCache(options) {
+    const { cacheOptions , logger , root , skipLocalCache  } = options;
     const hasRemoteCacheConfig = !!cacheOptions?.cacheStorageConfig || !!process.env.BACKFILL_CACHE_PROVIDER || !!process.env.BACKFILL_CACHE_PROVIDER_OPTIONS;
     // Create Cache Provider
     const cacheProvider = new _cache.RemoteFallbackCacheProvider({
@@ -33,16 +35,9 @@ function createCache(options) {
             root,
             cacheOptions: cacheOptions ?? {}
         }) : undefined,
-        writeRemoteCache: cacheOptions?.writeRemoteCache === true || String(process.env.LAGE_WRITE_CACHE).toLowerCase() === "true" || _isRunningFromCIJs.isRunningFromCI
-    });
-    const hasher = new _cache.TargetHasher({
-        root,
-        environmentGlob: cacheOptions?.environmentGlob ?? [],
-        cacheKey: cacheOptions?.cacheKey,
-        cliArgs
+        writeRemoteCache: cacheOptions?.writeRemoteCache === true || String(process.env.LAGE_WRITE_CACHE).toLowerCase() === "true" || _isRunningFromCI.isRunningFromCI
     });
     return {
-        cacheProvider,
-        hasher
+        cacheProvider
     };
 }

package/lib/cache/isRunningFromCI.js

@@ -4,6 +4,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "isRunningFromCI", {
     enumerable: true,
-    get: ()=>isRunningFromCI
+    get: function() {
+        return isRunningFromCI;
+    }
 });
 const isRunningFromCI = process.env.NODE_ENV !== "test" && (!!process.env.CI || !!process.env.TF_BUILD);

package/lib/categorizeTargetRuns.js

@@ -4,7 +4,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "categorizeTargetRuns", {
     enumerable: true,
-    get: ()=>categorizeTargetRuns
+    get: function() {
+        return categorizeTargetRuns;
+    }
 });
 function categorizeTargetRuns(targetRuns) {
     const summary = {

package/lib/formatBytes.js

@@ -4,7 +4,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "formatBytes", {
     enumerable: true,
-    get: ()=>formatBytes
+    get: function() {
+        return formatBytes;
+    }
 });
 function formatBytes(bytes) {
     return `${(bytes / 1024 / 1024).toFixed(2)} MB`;

package/lib/getLageOutputCacheLocation.js

@@ -4,11 +4,13 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "getLageOutputCacheLocation", {
     enumerable: true,
-    get: ()=>getLageOutputCacheLocation
+    get: function() {
+        return getLageOutputCacheLocation;
+    }
 });
 const _cache = require("@lage-run/cache");
-const _path = /*#__PURE__*/ _interopRequireDefault(require("path"));
-function _interopRequireDefault(obj) {
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };

package/lib/index.js

@@ -9,14 +9,24 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    NpmScriptRunner: ()=>_npmScriptRunnerJs.NpmScriptRunner,
-    SimpleScheduler: ()=>_simpleSchedulerJs.SimpleScheduler,
-    TargetRunnerPicker: ()=>_targetRunnerPickerJs.TargetRunnerPicker,
-    WorkerRunner: ()=>_workerRunnerJs.WorkerRunner,
-    NoOpRunner: ()=>_noOpRunnerJs.NoOpRunner
+    NpmScriptRunner: function() {
+        return _NpmScriptRunner.NpmScriptRunner;
+    },
+    SimpleScheduler: function() {
+        return _SimpleScheduler.SimpleScheduler;
+    },
+    TargetRunnerPicker: function() {
+        return _TargetRunnerPicker.TargetRunnerPicker;
+    },
+    WorkerRunner: function() {
+        return _WorkerRunner.WorkerRunner;
+    },
+    NoOpRunner: function() {
+        return _NoOpRunner.NoOpRunner;
+    }
 });
-const _npmScriptRunnerJs = require("./runners/NpmScriptRunner.js");
-const _simpleSchedulerJs = require("./SimpleScheduler.js");
-const _targetRunnerPickerJs = require("./runners/TargetRunnerPicker.js");
-const _workerRunnerJs = require("./runners/WorkerRunner.js");
-const _noOpRunnerJs = require("./runners/NoOpRunner.js");
+const _NpmScriptRunner = require("./runners/NpmScriptRunner.js");
+const _SimpleScheduler = require("./SimpleScheduler.js");
+const _TargetRunnerPicker = require("./runners/TargetRunnerPicker.js");
+const _WorkerRunner = require("./runners/WorkerRunner.js");
+const _NoOpRunner = require("./runners/NoOpRunner.js");

package/lib/runners/NoOpRunner.js

@@ -4,7 +4,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "NoOpRunner", {
     enumerable: true,
-    get: ()=>NoOpRunner
+    get: function() {
+        return NoOpRunner;
+    }
 });
 class NoOpRunner {
     async shouldRun() {

package/lib/runners/NpmScriptRunner.js

@@ -4,12 +4,27 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "NpmScriptRunner", {
     enumerable: true,
-    get: ()=>NpmScriptRunner
+    get: function() {
+        return NpmScriptRunner;
+    }
 });
 const _fs = require("fs");
 const _path = require("path");
 const _promises = require("fs/promises");
-const _childProcess = require("child_process");
+const _child_process = require("child_process");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
 class NpmScriptRunner {
     getNpmArgs(task, taskTargs) {
         const extraArgs = taskTargs.length > 0 ? [
@@ -77,7 +92,7 @@ class NpmScriptRunner {
             target.options?.nodeOptions
         ].filter((str)=>str).join(" ");
         await new Promise((resolve, reject)=>{
-            childProcess = (0, _childProcess.spawn)(npmCmd, npmRunArgs, {
+            childProcess = (0, _child_process.spawn)(npmCmd, npmRunArgs, {
                 cwd: target.cwd,
                 stdio: [
                     "inherit",
@@ -127,8 +142,9 @@ class NpmScriptRunner {
         });
     }
     constructor(options){
+        _define_property(this, "options", void 0);
         this.options = options;
         this.validateOptions(options);
     }
 }
-NpmScriptRunner.gracefulKillTimeout = 2500;
+_define_property(NpmScriptRunner, "gracefulKillTimeout", 2500);

package/lib/runners/TargetRunnerPicker.js

@@ -4,19 +4,34 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "TargetRunnerPicker", {
     enumerable: true,
-    get: ()=>TargetRunnerPicker
+    get: function() {
+        return TargetRunnerPicker;
+    }
 });
-const _path = /*#__PURE__*/ _interopRequireDefault(require("path"));
-const _targetGraph = require("@lage-run/target-graph");
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _targetgraph = require("@lage-run/target-graph");
 const _url = require("url");
-function _interopRequireDefault(obj) {
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
 class TargetRunnerPicker {
     async pick(target) {
-        if (target.id === (0, _targetGraph.getStartTargetId)()) {
+        if (target.id === (0, _targetgraph.getStartTargetId)()) {
             return new (await import("./NoOpRunner.js")).NoOpRunner();
         }
         if (!target.type) {
@@ -38,6 +53,7 @@ class TargetRunnerPicker {
         throw new Error(`No runner found for target ${target.id}`);
     }
     constructor(options){
+        _define_property(this, "options", void 0);
         this.options = options;
     }
 }

package/lib/runners/WorkerRunner.js

@@ -4,9 +4,24 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "WorkerRunner", {
     enumerable: true,
-    get: ()=>WorkerRunner
+    get: function() {
+        return WorkerRunner;
+    }
 });
 const _url = require("url");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
 class WorkerRunner {
     async shouldRun(target) {
         const scriptModule = await this.getScriptModule(target);
@@ -42,7 +57,8 @@ class WorkerRunner {
         return await import(importScript);
     }
     constructor(options){
+        _define_property(this, "options", void 0);
         this.options = options;
     }
 }
-WorkerRunner.gracefulKillTimeout = 2500;
+_define_property(WorkerRunner, "gracefulKillTimeout", 2500);

package/lib/workers/targetWorker.js

@@ -2,13 +2,13 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-const _createCacheProviderJs = require("../cache/createCacheProvider.js");
+const _createCacheProvider = require("../cache/createCacheProvider.js");
 const _config = require("@lage-run/config");
-const _workerThreadsPool = require("@lage-run/worker-threads-pool");
-const _targetRunnerPickerJs = require("../runners/TargetRunnerPicker.js");
-const _workerThreads = require("worker_threads");
-const _logger = /*#__PURE__*/ _interopRequireDefault(require("@lage-run/logger"));
-function _interopRequireDefault(obj) {
+const _workerthreadspool = require("@lage-run/worker-threads-pool");
+const _TargetRunnerPicker = require("../runners/TargetRunnerPicker.js");
+const _worker_threads = require("worker_threads");
+const _logger = /*#__PURE__*/ _interop_require_default(require("@lage-run/logger"));
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
@@ -19,41 +19,54 @@ async function setup(options) {
     const logger = (0, _logger.default)();
     logger.addReporter({
         log (entry) {
-            _workerThreads.parentPort.postMessage({
+            _worker_threads.parentPort.postMessage({
                 type: "log",
                 ...entry
             });
         },
         summarize () {}
     });
-    const { cacheProvider , hasher  } = (0, _createCacheProviderJs.createCache)({
+    const { cacheProvider  } = await (0, _createCacheProvider.createCache)({
         root,
         logger,
         cacheOptions: config.cacheOptions,
         cliArgs: options.taskArgs,
         skipLocalCache: options.skipLocalCache
     });
-    const runnerPicker = new _targetRunnerPickerJs.TargetRunnerPicker(runners);
+    const runnerPicker = new _TargetRunnerPicker.TargetRunnerPicker(runners);
     return {
         options,
         runnerPicker,
-        cacheProvider,
-        hasher
+        cacheProvider
     };
 }
 (async ()=>{
-    const { cacheProvider , hasher , runnerPicker , options  } = await setup(_workerThreads.workerData);
+    const { cacheProvider , runnerPicker , options  } = await setup(_worker_threads.workerData);
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    let hashPromiseResolve = (_hash)=>{};
+    // main thread sends hash to worker because it keeps a global memory cache of the hashes
+    _worker_threads.parentPort.on("message", (data)=>{
+        if (data.type === "hash") {
+            hashPromiseResolve(data.hash);
+        }
+    });
     async function getCache(target) {
         const { shouldCache , shouldResetCache  } = options;
         let hash = undefined;
         let cacheHit = false;
-        if (!shouldCache || !target.cache || !cacheProvider || !hasher) {
+        if (!shouldCache || !target.cache || !cacheProvider) {
             return {
                 hash,
                 cacheHit
             };
         }
-        hash = await hasher.hash(target);
+        // using a special pattern in communicating with the main thread to get the hash for the target
+        hash = await new Promise((resolve)=>{
+            hashPromiseResolve = resolve;
+            _worker_threads.parentPort.postMessage({
+                type: "hash"
+            });
+        });
         if (hash && !shouldResetCache) {
             cacheHit = await cacheProvider.fetch(hash, target);
         }
@@ -84,5 +97,5 @@ async function setup(options) {
             hash
         };
     }
-    (0, _workerThreadsPool.registerWorker)(run);
+    (0, _workerthreadspool.registerWorker)(run);
 })();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lage-run/scheduler",
-  "version": "0.11.4",
+  "version": "1.0.0",
   "description": "Scheduler for Lage",
   "repository": {
     "type": "git",
@@ -17,14 +17,15 @@
     "lint": "monorepo-scripts lint"
   },
   "dependencies": {
-    "@lage-run/target-graph": "^0.8.4",
+    "@lage-run/target-graph": "^0.8.6",
     "@lage-run/logger": "^1.3.0",
-    "@lage-run/cache": "^0.5.4",
-    "@lage-run/config": "^0.2.0",
-    "@lage-run/worker-threads-pool": "^0.6.1"
+    "@lage-run/cache": "^1.1.1",
+    "@lage-run/config": "^0.2.1",
+    "@lage-run/hasher": "^1.0.0",
+    "@lage-run/worker-threads-pool": "^0.7.0"
   },
   "devDependencies": {
-    "@lage-run/scheduler-types": "^0.3.8",
+    "@lage-run/scheduler-types": "^0.3.9",
     "monorepo-scripts": "*"
   },
   "publishConfig": {