hammerkit 1.6.0-alpha.3 → 1.7.0

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-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,42 @@ 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();
+        },
+    };
+}
+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 +71,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 +81,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 +108,43 @@ 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);
                     work.state.set({
                         stateKey: cacheState.stateKey,
                         type: 'completed',
                         cached: false,
                         duration: (0, states_1.getDuration)(started),
+                        missCauses,
                     });
                 }
                 else {

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/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;

package/dist/executer/run-summary.js

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printRunSummary = exports.formatDuration = exports.summarizeRun = void 0;
+const colors_1 = __importDefault(require("colors"));
+const plan_work_tasks_1 = require("../planner/utils/plan-work-tasks");
+const log_1 = require("../log");
+function statusOf(state) {
+    switch (state.type) {
+        case 'completed':
+            return state.skipped ? 'skipped' : state.cached ? 'cached' : 'executed';
+        case 'error':
+        case 'crash':
+            return 'failed';
+        default:
+            // canceled, or never started (pending/starting/ready/running left over from
+            // an aborted run) — all surface as cancelled/skipped.
+            return 'cancelled';
+    }
+}
+// Derive the run summary purely from the final task states already on the work
+// tree — nothing is re-run. Deterministically ordered by task name.
+function summarizeRun(workTree, totalDuration) {
+    const tasks = [];
+    for (const task of (0, plan_work_tasks_1.iterateWorkTasks)(workTree)) {
+        const state = task.state.current;
+        const cause = state.type === 'completed' && state.missCauses?.length ? state.missCauses.join(', ') : undefined;
+        tasks.push({
+            taskId: task.id(),
+            taskName: task.name,
+            status: statusOf(state),
+            duration: state.type === 'completed' ? state.duration : 0,
+            cause,
+        });
+    }
+    tasks.sort((a, b) => a.taskName.localeCompare(b.taskName));
+    const executed = tasks.filter((t) => t.status === 'executed').length;
+    const cached = tasks.filter((t) => t.status === 'cached').length;
+    const skipped = tasks.filter((t) => t.status === 'skipped').length;
+    const failed = tasks.filter((t) => t.status === 'failed').length;
+    const cancelled = tasks.filter((t) => t.status === 'cancelled').length;
+    const ran = executed + cached;
+    return {
+        tasks,
+        executed,
+        cached,
+        skipped,
+        failed,
+        cancelled,
+        cacheHitRatio: ran === 0 ? 0 : cached / ran,
+        totalDuration,
+    };
+}
+exports.summarizeRun = summarizeRun;
+function formatDuration(ms) {
+    if (ms < 1000) {
+        return `${ms}ms`;
+    }
+    return `${(ms / 1000).toFixed(1)}s`;
+}
+exports.formatDuration = formatDuration;
+function colorStatus(status) {
+    const label = status.padEnd(9);
+    switch (status) {
+        case 'executed':
+            return colors_1.default.cyan(label);
+        case 'cached':
+            return colors_1.default.green(label);
+        case 'skipped':
+            return colors_1.default.grey(label);
+        case 'failed':
+            return colors_1.default.red(label);
+        case 'cancelled':
+            return colors_1.default.grey(label);
+    }
+}
+// Bound the name column so a single very long task name cannot blow out the
+// width on large graphs.
+const MAX_NAME_WIDTH = 60;
+function printRunSummary(environment, summary) {
+    (0, log_1.printTitle)(environment, 'Summary');
+    if (summary.tasks.length === 0) {
+        environment.stdout.write('  nothing ran\n');
+        return;
+    }
+    const nameWidth = Math.min(MAX_NAME_WIDTH, summary.tasks.reduce((max, t) => Math.max(max, t.taskName.length), 0));
+    for (const task of summary.tasks) {
+        const name = task.taskName.length > nameWidth ? `${task.taskName.slice(0, nameWidth - 1)}…` : task.taskName.padEnd(nameWidth);
+        const cause = task.cause ? `  ${colors_1.default.grey(task.cause)}` : '';
+        environment.stdout.write(`  ${name}  ${colorStatus(task.status)}  ${colors_1.default.grey(formatDuration(task.duration))}${cause}\n`);
+    }
+    const ratio = Math.round(summary.cacheHitRatio * 100);
+    const skippedSuffix = summary.skipped > 0 ? `, ${summary.skipped} skipped` : '';
+    const failedSuffix = summary.failed > 0 ? `, ${summary.failed} failed` : '';
+    const cancelledSuffix = summary.cancelled > 0 ? `, ${summary.cancelled} cancelled` : '';
+    environment.stdout.write(`  ${summary.executed} executed, ${summary.cached} cached${skippedSuffix}${failedSuffix}${cancelledSuffix} ` +
+        `(${ratio}% cache hit), ${formatDuration(summary.totalDuration)} total\n`);
+}
+exports.printRunSummary = printRunSummary;
+//# sourceMappingURL=run-summary.js.map

package/dist/executer/scheduler/enqueue-next.js

@@ -1,91 +1,46 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkCacheState = void 0;
-const get_work_cache_stats_1 = require("../../optimizer/get-work-cache-stats");
 const work_item_1 = require("../../planner/work-item");
 const get_cache_directory_1 = require("../../optimizer/get-cache-directory");
 const cache_metadata_1 = require("../cache-metadata");
 const work_task_cache_description_1 = require("../../optimizer/work-task-cache-description");
 const log_1 = require("../../log");
-const crypto_1 = require("crypto");
-function resolveEffective(item, fallbackMethod) {
-    const declared = item.data.caching;
-    if (declared.implicit) {
-        return { ...declared, method: fallbackMethod };
-    }
-    return declared;
-}
-// Fold a task's own state key together with the state keys of its dependencies.
-// A change anywhere in the dependency subtree must change the resulting key, so
-// that a downstream task is invalidated when an upstream source changes — even
-// if the downstream task's own sources are untouched.
-function combineStateKeys(ownKey, depKeys) {
-    if (depKeys.length === 0) {
-        return ownKey;
-    }
-    // Sort so the key is independent of dependency declaration order.
-    const sorted = [...depKeys].sort();
-    return (0, crypto_1.createHash)('md5')
-        .update([ownKey, ...sorted].join(','))
-        .digest('hex');
-}
-// Compute an item's effective state key from its source files plus the effective
-// state keys of its dependencies, recursively. This is derived purely from the
-// work tree and the filesystem, so it does not depend on scheduler/run state —
-// important because checkCacheState runs before dependencies are awaited.
-async function resolveEffectiveStateKey(item, defaultCacheMethod, environment, memo) {
-    const existing = memo.get(item.id());
-    if (existing !== undefined) {
-        return existing;
-    }
-    const resolved = resolveEffective(item, defaultCacheMethod);
-    // Always hash with a concrete method; `none` only disables the cache *check*
-    // for that task, its sources still influence what depends on it.
-    const method = resolved.method === 'none' ? defaultCacheMethod : resolved.method;
-    const stats = await (0, get_work_cache_stats_1.getWorkCacheStats)(item.data, environment);
-    const ownKey = (0, get_work_cache_stats_1.getStateKey)(stats, method);
-    const depKeys = [];
-    for (const dep of item.deps) {
-        depKeys.push(await resolveEffectiveStateKey(dep, defaultCacheMethod, environment, memo));
-    }
-    const combined = combineStateKeys(ownKey, depKeys);
-    memo.set(item.id(), combined);
-    return combined;
-}
+const state_key_1 = require("./state-key");
+const work_instance_id_1 = require("../../planner/work-instance-id");
 async function checkCacheState(item, defaultCacheMethod, environment) {
-    const resolved = resolveEffective(item, defaultCacheMethod);
-    const currentStats = await (0, get_work_cache_stats_1.getWorkCacheStats)(item.data, environment);
-    const ownKey = (0, get_work_cache_stats_1.getStateKey)(currentStats, resolved.method === 'none' ? defaultCacheMethod : resolved.method);
-    const memo = new Map();
-    const depKeys = [];
-    for (const dep of item.deps) {
-        depKeys.push(await resolveEffectiveStateKey(dep, defaultCacheMethod, environment, memo));
+    const { stateKey, stats: currentStats, resolved, provable, unmatched, } = await (0, state_key_1.computeStateKey)(item, defaultCacheMethod, environment);
+    for (const src of unmatched) {
+        item.status.write('warn', `src "${src.source}" matches no files`);
     }
-    const stateKey = combineStateKeys(ownKey, depKeys);
     if (resolved.method === 'none') {
         item.status.write('debug', `${item.name} is skipping cache check, because caching is disabled`);
-        return { cached: false, stateKey, resolved };
+        return { cached: false, stateKey, resolved, provable };
+    }
+    if ((0, work_item_1.isWorkTaskItem)(item) && !provable) {
+        item.status.write('debug', `${item.name} always runs, it or one of its dependencies has no src files`);
+        return { cached: false, stateKey, resolved, provable };
     }
     if ((0, work_item_1.isWorkTaskItem)(item)) {
         const runtimeStateKey = await item.runtime.currentStateKey(environment);
         if (runtimeStateKey === stateKey) {
-            return { cached: true, stateKey, resolved };
+            return { cached: true, stateKey, resolved, provable };
         }
         try {
-            const cacheDir = (0, get_cache_directory_1.getCacheDirectory)(item.id());
+            const cacheDir = (0, get_cache_directory_1.getCacheDirectory)((0, work_instance_id_1.getWorkInstanceId)(item));
             const pulled = await resolved.backend.pull(item.id(), stateKey, cacheDir, environment);
             if (pulled) {
                 item.status.write('info', `${item.name} pulled from cache "${resolved.name}" (${resolved.backend.type})`);
                 await item.runtime.restore(environment, cacheDir);
-                await (0, cache_metadata_1.writeCacheMetadata)(environment, item.id(), currentStats, (0, work_task_cache_description_1.getWorkTaskCacheDescription)(item.data));
-                return { cached: true, stateKey, resolved };
+                await (0, cache_metadata_1.writeCacheMetadata)(environment, item, currentStats, (0, work_task_cache_description_1.getWorkTaskCacheDescription)(item));
+                return { cached: true, stateKey, resolved, provable };
             }
         }
         catch (e) {
             item.status.write('warn', `${item.name} failed to pull from cache "${resolved.name}": ${(0, log_1.getErrorMessage)(e)} — continuing with local execution`);
         }
     }
-    return { cached: false, stateKey, resolved };
+    return { cached: false, stateKey, resolved, provable };
 }
 exports.checkCacheState = checkCacheState;
 //# sourceMappingURL=enqueue-next.js.map