hammerkit 1.6.0 → 1.8.0

package/dist/executer/dry-run.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printDryRun = exports.planDryRun = void 0;
+const colors_1 = __importDefault(require("colors"));
+const validate_1 = require("../planner/validate");
+const explain_1 = require("../cache/explain");
+const log_1 = require("../log");
+// Deterministic topological order (dependencies before dependents). Visited-set
+// guards against runaway recursion; a real cycle is reported separately.
+function topoOrder(workTree) {
+    const visited = new Set();
+    const order = [];
+    const visit = (task) => {
+        if (visited.has(task.id())) {
+            return;
+        }
+        visited.add(task.id());
+        for (const dep of [...task.deps].sort((a, b) => a.name.localeCompare(b.name))) {
+            visit(dep);
+        }
+        order.push(task);
+    };
+    for (const task of Object.values(workTree.tasks).sort((a, b) => a.name.localeCompare(b.name))) {
+        visit(task);
+    }
+    return order;
+}
+// Compute the ordered execution plan with a predicted cache decision per task,
+// reusing the cache-explain engine — no command runs, no container/service
+// starts, no cache push/pull occurs.
+async function planDryRun(workTree, defaultCacheMethod, environment) {
+    for (const task of Object.values(workTree.tasks)) {
+        const path = (0, validate_1.hasDependencyCycle)(task, []);
+        if (path && path.length > 0) {
+            return { entries: [], cycle: path.map((n) => n.name) };
+        }
+    }
+    const explanations = await (0, explain_1.explainWorkTree)(workTree, defaultCacheMethod, environment);
+    const byName = new Map(explanations.map((e) => [e.taskName, e]));
+    const entries = [];
+    for (const task of topoOrder(workTree)) {
+        const explanation = byName.get(task.name);
+        entries.push({
+            taskId: task.id(),
+            taskName: task.name,
+            status: explanation?.status ?? 'miss',
+            causes: explanation?.causes ?? [],
+        });
+    }
+    return { entries, cycle: null };
+}
+exports.planDryRun = planDryRun;
+function printDryRun(environment, plan) {
+    (0, log_1.printTitle)(environment, 'Dry run (no commands executed)');
+    if (plan.entries.length === 0) {
+        environment.stdout.write('  no tasks in scope\n');
+        return;
+    }
+    plan.entries.forEach((entry, index) => {
+        const label = entry.status === 'hit'
+            ? colors_1.default.green('cache hit')
+            : entry.status === 'uncacheable'
+                ? colors_1.default.grey('uncacheable')
+                : colors_1.default.yellow('cache miss');
+        const causes = entry.causes.length > 0 ? colors_1.default.grey(` (${entry.causes.map(explain_1.describeCause).join(', ')})`) : '';
+        environment.stdout.write(`  ${index + 1}. ${entry.taskName}: ${label}${causes}\n`);
+    });
+}
+exports.printDryRun = printDryRun;
+//# sourceMappingURL=dry-run.js.map

package/dist/executer/event-cache.js

@@ -5,9 +5,10 @@ const plan_work_tasks_1 = require("../planner/utils/plan-work-tasks");
 const get_cache_directory_1 = require("../optimizer/get-cache-directory");
 const path_1 = require("path");
 const move_files_1 = require("../file/move-files");
+const work_instance_id_1 = require("../planner/work-instance-id");
 async function restoreCache(environment, path, workTree) {
     for (const task of (0, plan_work_tasks_1.iterateWorkTasks)(workTree)) {
-        const cachePath = (0, get_cache_directory_1.getCacheDirectory)(task.id());
+        const cachePath = (0, get_cache_directory_1.getCacheDirectory)((0, work_instance_id_1.getWorkInstanceId)(task));
         const sourceCacheDir = (0, path_1.join)(path, task.id());
         // TODO move into local runtime
         await (0, move_files_1.moveFiles)(task, environment, function* () {
@@ -17,7 +18,7 @@ async function restoreCache(environment, path, workTree) {
         await task.runtime.restore(environment, sourceCacheDir);
     }
     for (const service of (0, plan_work_tasks_1.iterateWorkServices)(workTree)) {
-        const cachePath = (0, get_cache_directory_1.getCacheDirectory)(service.id());
+        const cachePath = (0, get_cache_directory_1.getCacheDirectory)((0, work_instance_id_1.getWorkInstanceId)(service));
         const sourceCacheDir = (0, path_1.join)(path, service.id());
         // TODO move into local runtime
         await (0, move_files_1.moveFiles)(service, environment, function* () {
@@ -50,7 +51,7 @@ function* getArchivePaths(task, path) {
 exports.getArchivePaths = getArchivePaths;
 async function storeCache(environment, path, workTree) {
     for (const task of (0, plan_work_tasks_1.iterateWorkTasks)(workTree)) {
-        const cachePath = (0, get_cache_directory_1.getCacheDirectory)(task.id());
+        const cachePath = (0, get_cache_directory_1.getCacheDirectory)((0, work_instance_id_1.getWorkInstanceId)(task));
         const sourceCacheDir = (0, path_1.join)(path, task.id());
         await (0, move_files_1.moveFiles)(task, environment, function* () {
             yield { from: (0, path_1.join)(cachePath, 'stats.json'), to: (0, path_1.join)(sourceCacheDir, 'stats.json') };
@@ -60,7 +61,7 @@ async function storeCache(environment, path, workTree) {
         await task.runtime.archive(environment, sourceCacheDir);
     }
     for (const service of (0, plan_work_tasks_1.iterateWorkServices)(workTree)) {
-        const cachePath = (0, get_cache_directory_1.getCacheDirectory)(service.id());
+        const cachePath = (0, get_cache_directory_1.getCacheDirectory)((0, work_instance_id_1.getWorkInstanceId)(service));
         const sourceCacheDir = (0, path_1.join)(path, service.id());
         await (0, move_files_1.moveFiles)(service, environment, function* () {
             yield { from: (0, path_1.join)(cachePath, 'stats.json'), to: (0, path_1.join)(sourceCacheDir, 'stats.json') };
@@ -77,7 +78,7 @@ async function cleanCache(workTree, environment, options) {
         if (options?.cache) {
             await task.data.caching.backend.clear(task.id(), environment);
         }
-        const cachePath = (0, get_cache_directory_1.getCacheDirectory)(task.id());
+        const cachePath = (0, get_cache_directory_1.getCacheDirectory)((0, work_instance_id_1.getWorkInstanceId)(task));
         if (await environment.file.exists(cachePath)) {
             task.status.write('info', `remove cache ${cachePath}`);
             await environment.file.remove(cachePath);

package/dist/executer/execute-command.js

@@ -7,12 +7,21 @@ const log_1 = require("../log");
 const abort_1 = require("./abort");
 const abort_event_1 = require("../utils/abort-event");
 async function executeCommand(status, abortSignal, cwd, command, envs, environment) {
+    const windows = (0, os_1.platform)() === 'win32';
     return new Promise((resolve, reject) => {
-        const ps = (0, child_process_1.exec)(command, {
+        const ps = (0, child_process_1.spawn)(command, {
             env: { ...envs, PATH: environment.processEnvs['PATH'] },
             cwd,
-            shell: (0, os_1.platform)() === 'win32' ? 'powershell.exe' : undefined,
+            shell: windows ? 'powershell.exe' : true,
+            // its own process group, so an abort reaches every process the command
+            // started — the shell may run them as children (dash always does), and
+            // they would keep running and holding the output open
+            detached: !windows,
         });
+        // decode across chunk boundaries, so a multi-byte character split between
+        // two chunks stays intact
+        ps.stdout?.setEncoding('utf8');
+        ps.stderr?.setEncoding('utf8');
         ps.stdout?.on('data', async (data) => {
             for (const log of (0, log_1.getLogs)(data)) {
                 status.console('stdout', log);
@@ -35,7 +44,16 @@ async function executeCommand(status, abortSignal, cwd, command, envs, environme
             resolve(code ?? 0);
         });
         const abortListener = (0, abort_event_1.listenOnAbort)(abortSignal, () => {
-            ps.kill();
+            if (windows || !ps.pid) {
+                ps.kill();
+                return;
+            }
+            try {
+                process.kill(-ps.pid, 'SIGTERM');
+            }
+            catch {
+                // the group is already gone
+            }
         });
     });
 }

package/dist/executer/execute-docker.js

@@ -3,16 +3,22 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.execCommand = exports.convertToPosixPath = exports.startContainer = exports.getContainerCli = void 0;
+exports.clearContainerDirectory = exports.execCommand = exports.convertToPosixPath = exports.startContainer = exports.getContainerCli = exports.createDockerClient = void 0;
 const stream_1 = require("../docker/stream");
 const dockerode_1 = __importDefault(require("dockerode"));
 const path_1 = require("path");
 const os_1 = require("os");
 const abort_event_1 = require("../utils/abort-event");
 let dockerInstance = null;
+// Without options dockerode reads DOCKER_HOST and the TLS variables; passing
+// `{ host: undefined }` would overwrite the host it parsed from DOCKER_HOST.
+function createDockerClient(host) {
+    return host ? new dockerode_1.default({ host }) : new dockerode_1.default();
+}
+exports.createDockerClient = createDockerClient;
 function getContainerCli(workEnvironment) {
     if (!dockerInstance) {
-        dockerInstance = new dockerode_1.default({ host: workEnvironment.host });
+        dockerInstance = createDockerClient(workEnvironment.host);
     }
     return dockerInstance;
 }
@@ -127,4 +133,14 @@ async function execCommand(status, environment, container, cwd, cmd, user, timeo
     });
 }
 exports.execCommand = execCommand;
+// Empty a directory inside a running container, as root. Volumes are emptied
+// this way rather than recreated: Docker refuses to remove a volume while any
+// container (a dependent's paused one, say) still mounts it.
+async function clearContainerDirectory(status, environment, container, path) {
+    const result = await execCommand(status, environment, container, '/', ['sh', '-c', 'rm -rf "$1"/* "$1"/.[!.]* "$1"/..?*', 'sh', convertToPosixPath(path)], null, undefined, environment.abortCtrl.signal);
+    if (result.type !== 'result' || result.result.ExitCode !== 0) {
+        throw new Error(`unable to empty ${path}`);
+    }
+}
+exports.clearContainerDirectory = clearContainerDirectory;
 //# sourceMappingURL=execute-docker.js.map

package/dist/executer/execute-work-service.js

@@ -14,7 +14,11 @@ exports.stopService = stopService;
 async function executeWorkService(work, environment, options) {
     try {
         if (options.type === 'execute') {
-            await (0, await_completed_dependencies_1.awaitRequirement)(work, environment.abortCtrl.signal);
+            const required = await (0, await_completed_dependencies_1.awaitRequirement)(work, environment.abortCtrl.signal, { untilAllDone: !options.watch });
+            if (!required) {
+                work.status.write('debug', `${work.name} not started, no task needing it had to run`);
+                return;
+            }
         }
         work.state.set({
             type: 'starting',
@@ -54,6 +58,11 @@ async function executeWorkService(work, environment, options) {
                 errorMessage: (0, log_1.getErrorMessage)(e),
                 stateKey: null,
             });
+            // fail fast like a failing task: whatever needs this service can never
+            // run, and would otherwise wait for it forever
+            if (!options.watch) {
+                environment.abortCtrl.abort();
+            }
         }
     }
 }

package/dist/executer/execute-work-task.js

@@ -6,20 +6,21 @@ const abort_1 = require("./abort");
 const log_1 = require("../log");
 const await_completed_dependencies_1 = require("./await-completed-dependencies");
 const watch_loop_1 = require("./watch-loop");
-const get_cache_directory_1 = require("../optimizer/get-cache-directory");
-const cache_metadata_1 = require("./cache-metadata");
-const get_work_cache_stats_1 = require("../optimizer/get-work-cache-stats");
-const work_task_cache_description_1 = require("../optimizer/work-task-cache-description");
-async function pushToBackend(work, environment, cacheState) {
-    const { resolved, stateKey } = cacheState;
-    if (resolved.method === 'none') {
+const explain_1 = require("../cache/explain");
+const archive_task_entry_1 = require("./archive-task-entry");
+const units_1 = require("../utils/units");
+const abort_event_1 = require("../utils/abort-event");
+async function pushToBackend(work, environment, cacheState, options) {
+    const { resolved, stateKey, provable } = cacheState;
+    if (resolved.method === 'none' || !provable) {
+        return;
+    }
+    if (options.cacheReadOnly) {
+        work.status.write('debug', `${work.name} not pushed to cache "${resolved.name}" (read-only)`);
         return;
     }
     try {
-        const cacheDir = (0, get_cache_directory_1.getCacheDirectory)(work.id());
-        const stats = await (0, get_work_cache_stats_1.getWorkCacheStats)(work.data, environment);
-        await (0, cache_metadata_1.writeCacheMetadata)(environment, work.id(), stats, (0, work_task_cache_description_1.getWorkTaskCacheDescription)(work.data));
-        await work.runtime.archive(environment, cacheDir);
+        const cacheDir = await (0, archive_task_entry_1.archiveTaskEntry)(work, environment);
         await resolved.backend.push(work.id(), stateKey, cacheDir, environment);
         work.status.write('info', `${work.name} pushed to cache "${resolved.name}" (${resolved.backend.type})`);
     }
@@ -27,8 +28,51 @@ async function pushToBackend(work, environment, cacheState) {
         work.status.write('warn', `${work.name} failed to push to cache "${resolved.name}": ${(0, log_1.getErrorMessage)(e)}`);
     }
 }
-async function executeWorkTask(work, environment, options) {
+// An abort signal that follows `parent` and additionally fires after `timeout`
+// ms, so a task deadline reuses the runtimes' existing abort/cleanup path.
+function withDeadline(parent, timeout) {
+    const controller = new AbortController();
+    let expired = false;
+    const parentListener = (0, abort_event_1.listenOnAbort)(parent, () => controller.abort());
+    const timer = timeout === null
+        ? null
+        : setTimeout(() => {
+            expired = true;
+            controller.abort();
+        }, timeout);
+    return {
+        signal: controller.signal,
+        expired: () => expired,
+        clear() {
+            if (timer) {
+                clearTimeout(timer);
+            }
+            parentListener.close();
+        },
+    };
+}
+// A task without cmds only groups its dependencies (`ci: { deps: [test, build] }`).
+// Having no src of its own it is never a cache hit, so its dependencies are
+// always checked and their outputs restored. When every one of them was a hit,
+// nothing ran: report the group as cached too. Reporting only, the cache
+// decision is untouched.
+function onlyGroupsCacheHits(work) {
+    return (work.data.cmds.length === 0 &&
+        work.deps.every((dep) => dep.state.current.type === 'completed' && dep.state.current.cached));
+}
+async function executeWorkTask(work, environment, options, 
+// when set, the task was not requested and only runs if one of these tasks
+// depending on it misses the cache (see executeWorkTree)
+dependents = null) {
     try {
+        if (dependents) {
+            const needed = await (0, await_completed_dependencies_1.awaitDependentNeed)(dependents, environment.abortCtrl.signal);
+            if (!needed) {
+                work.status.write('debug', `${work.name} skipped, every task depending on it was a cache hit`);
+                work.state.set({ type: 'completed', cached: false, skipped: true, duration: 0, stateKey: '' });
+                return;
+            }
+        }
         work.state.set({
             type: 'starting',
             started: new Date(),
@@ -36,11 +80,6 @@ async function executeWorkTask(work, environment, options) {
         });
         await (0, watch_loop_1.watchLoop)(work, environment, options, async (cacheState, abort) => {
             const started = new Date();
-            work.state.set({
-                type: 'ready',
-                stateKey: cacheState.stateKey,
-                started: new Date(),
-            });
             if (cacheState.cached) {
                 work.status.write('debug', 'completed for cached state key ' + cacheState.stateKey);
                 work.state.set({
@@ -51,6 +90,25 @@ async function executeWorkTask(work, environment, options) {
                 });
                 return;
             }
+            // Only a cache miss is `ready`: needed services start on `ready`, so a
+            // cached task never starts the services it would have needed.
+            work.state.set({
+                type: 'ready',
+                stateKey: cacheState.stateKey,
+                started: new Date(),
+            });
+            // Cache miss: under the explain flag, report why this task is rebuilding,
+            // reusing the cache-explain engine. Captured BEFORE execution overwrites
+            // the last-resolved record, then carried onto the completed state so the
+            // build summary can show the cause column. Reporting only.
+            let missCauses;
+            if (options.explain) {
+                const explanation = await (0, explain_1.explainTask)(work, options.cacheDefault, environment);
+                missCauses = explanation.causes.map(explain_1.describeCause);
+                for (const cause of missCauses) {
+                    work.status.write('info', `cache miss: ${cause}`);
+                }
+            }
             await (0, await_completed_dependencies_1.awaitCompletedDependencies)(work, work.deps, abort);
             await (0, await_completed_dependencies_1.awaitRunningNeeds)(work, work.needs.map((n) => n.service), abort);
             await options.processManager.task(work, async () => {
@@ -59,22 +117,44 @@ async function executeWorkTask(work, environment, options) {
                     stateKey: cacheState.stateKey,
                     started,
                 });
-                await work.runtime.execute(environment, {
-                    cache: cacheState,
-                    abort,
-                    stateKey: cacheState.stateKey,
-                    state: work.state,
-                    daemon: options.daemon,
-                });
+                const timeout = work.data.timeout ?? options.timeout;
+                const deadline = withDeadline(abort, timeout);
+                try {
+                    await work.runtime.execute(environment, {
+                        cache: cacheState,
+                        abort: deadline.signal,
+                        stateKey: cacheState.stateKey,
+                        state: work.state,
+                        daemon: options.daemon,
+                    });
+                }
+                finally {
+                    deadline.clear();
+                }
+                if (deadline.expired() && timeout !== null) {
+                    // the runtime saw an abort and cleaned up; report it as a failure
+                    // (never a cancellation) and stop the run like any failing task
+                    work.state.set({
+                        type: 'error',
+                        stateKey: cacheState.stateKey,
+                        errorMessage: `timed out after ${(0, units_1.formatDuration)(timeout)}`,
+                    });
+                    if (!options.watch) {
+                        environment.abortCtrl.abort();
+                    }
+                    return;
+                }
                 (0, abort_1.checkForAbort)(abort);
                 if (work.state.current.type === 'running') {
                     work.status.write('debug', 'completed for state key ' + cacheState.stateKey);
-                    await pushToBackend(work, environment, cacheState);
+                    await pushToBackend(work, environment, cacheState, options);
+                    const cached = onlyGroupsCacheHits(work);
                     work.state.set({
                         stateKey: cacheState.stateKey,
                         type: 'completed',
-                        cached: false,
+                        cached,
                         duration: (0, states_1.getDuration)(started),
+                        missCauses: cached ? undefined : missCauses,
                     });
                 }
                 else {
@@ -100,6 +180,11 @@ async function executeWorkTask(work, environment, options) {
                 errorMessage: (0, log_1.getErrorMessage)(e),
                 stateKey: null,
             });
+            // Stop the run like a failing command does: dependents wait for this task
+            // to complete, which it now never will.
+            if (!options.watch) {
+                environment.abortCtrl.abort();
+            }
         }
     }
 }

package/dist/executer/execute-work-tree.js

@@ -6,9 +6,10 @@ const execute_work_service_1 = require("./execute-work-service");
 const execute_work_task_1 = require("./execute-work-task");
 async function executeWorkTree(work, environment, options) {
     const itemPromises = [];
+    const dependents = skippableDependents(work, options);
     for (const task of (0, plan_work_tasks_1.iterateWorkTasks)(work)) {
         if (task.state.current.type === 'pending') {
-            itemPromises.push((0, execute_work_task_1.executeWorkTask)(task, environment, options));
+            itemPromises.push((0, execute_work_task_1.executeWorkTask)(task, environment, options, dependents.get(task.name) ?? null));
         }
     }
     for (const service of (0, plan_work_tasks_1.iterateWorkServices)(work)) {
@@ -24,4 +25,28 @@ async function executeWorkTree(work, environment, options) {
     await Promise.all(itemPromises);
 }
 exports.executeWorkTree = executeWorkTree;
+// For every task that may be skipped when nothing needs it, the tasks in this
+// run that depend on it. Requested tasks always run; so does anything a service
+// depends on, and everything in watch mode or with skipping turned off.
+function skippableDependents(work, options) {
+    const result = new Map();
+    if (options.type !== 'execute' || !options.skipDeps || options.watch || !work.requested) {
+        return result;
+    }
+    const neededByService = new Set();
+    for (const service of (0, plan_work_tasks_1.iterateWorkServices)(work)) {
+        for (const dep of service.deps) {
+            neededByService.add(dep.name);
+        }
+    }
+    for (const task of (0, plan_work_tasks_1.iterateWorkTasks)(work)) {
+        for (const dep of task.deps) {
+            if (work.requested.includes(dep.name) || neededByService.has(dep.name)) {
+                continue;
+            }
+            result.set(dep.name, [...(result.get(dep.name) ?? []), task]);
+        }
+    }
+    return result;
+}
 //# sourceMappingURL=execute-work-tree.js.map

package/dist/executer/execution-steps.js

@@ -26,18 +26,13 @@ async function prepareVolume(item, docker) {
         }
     }
     if ((0, work_task_1.isContainerWorkTask)(item.data)) {
+        // a task's outputs are emptied inside its container (see dockerTask)
         for (const generate of item.data.generates) {
             if (generate.isFile) {
                 continue;
             }
-            if (generate.resetOnChange && !generate.inherited) {
-                item.status.write('debug', 'recreate volume');
-                await (0, get_docker_executor_1.recreateVolume)(docker, item.status, generate.volumeName);
-            }
-            else {
-                item.status.write('debug', 'ensure volume exists');
-                await (0, get_docker_executor_1.ensureVolumeExists)(docker, item.status, generate.volumeName);
-            }
+            item.status.write('debug', 'ensure volume exists');
+            await (0, get_docker_executor_1.ensureVolumeExists)(docker, item.status, generate.volumeName);
         }
     }
 }

package/dist/executer/get-container-binds.js

@@ -1,10 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getContainerBinds = void 0;
+const path_1 = require("path");
+function isInside(path, parent) {
+    const rel = (0, path_1.relative)(parent, path);
+    return rel !== '' && !rel.startsWith('..') && !(0, path_1.isAbsolute)(rel);
+}
 function getContainerBinds(item) {
+    const sources = item.data.src.map((s) => s.absolutePath);
     const items = [
         ...item.data.mounts,
-        ...item.data.src.map((s) => ({ localPath: s.absolutePath, containerPath: s.absolutePath })),
+        // A source inside another source (a dependency's `app/app.csproj` under the
+        // task's own `app`) is already visible through the outer bind. Binding it
+        // again would nest bind mounts, which Docker Desktop then refuses to let the
+        // host delete while the paused container exists.
+        ...sources
+            .filter((path) => !sources.some((other) => isInside(path, other)))
+            .map((path) => ({ localPath: path, containerPath: path })),
         ...item.data.generates.filter((g) => !g.isFile).map((v) => ({ localPath: v.volumeName, containerPath: v.path })),
         ...item.data.generates.filter((g) => g.isFile).map((v) => ({ localPath: v.path, containerPath: v.path })),
     ];

package/dist/executer/get-scheduler-execute-result.js

@@ -12,7 +12,10 @@ function getSchedulerExecuteResult(state) {
         }
     }
     for (const service of (0, plan_work_tasks_1.iterateWorkServices)(state)) {
-        if (service.state.current.type === 'canceled') {
+        const current = service.state.current;
+        if (current.type === 'canceled' ||
+            current.type === 'error' ||
+            (current.type === 'end' && current.reason === 'crash')) {
             return {
                 state,
                 success: false,

package/dist/executer/lazy-resolver.js

@@ -1,13 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.lazyResolver = void 0;
-function lazyResolver(factory) {
+// Memoizes factory(). While the factory is still running, a re-entrant call
+// (a cycle) returns onReentry() when given, instead of recursing forever.
+function lazyResolver(factory, onReentry) {
     let value = null;
     let resolved = false;
+    let resolving = false;
     return () => {
         if (!resolved) {
-            value = factory();
-            resolved = true;
+            if (resolving && onReentry) {
+                return onReentry();
+            }
+            resolving = true;
+            try {
+                value = factory();
+                resolved = true;
+            }
+            finally {
+                resolving = false;
+            }
         }
         return value;
     };

package/dist/executer/reset-work-tree.js

@@ -24,6 +24,8 @@ function resetWorkTree(workTree, type) {
             return services;
         }, {}),
         environment: workTree.environment,
+        caches: workTree.caches,
+        requested: workTree.requested,
     };
 }
 exports.resetWorkTree = resetWorkTree;