hammerkit 1.6.0 → 1.8.0

package/dist/kubernetes/ensure-persistent-data.js

@@ -10,6 +10,7 @@ const sleep_1 = require("../utils/sleep");
 const version_1 = require("../version");
 const log_1 = require("../log");
 const ensure_kubernetes_persistent_volume_claim_exists_1 = require("./ensure-kubernetes-persistent-volume-claim-exists");
+const stream_1 = require("stream");
 // A previous run that crashed between creating an upload/download pod and its
 // `finally` cleanup leaves a pod behind under the same deterministic name. apply()
 // would then patch that stale pod in place — and if it is stuck in a terminal
@@ -17,7 +18,7 @@ const ensure_kubernetes_persistent_volume_claim_exists_1 = require("./ensure-kub
 // and wait for it to disappear before scheduling a fresh one.
 async function removeStalePod(instance, namespace, name) {
     try {
-        await instance.coreApi.deleteNamespacedPod(name, namespace, undefined, undefined, 0);
+        await instance.coreApi.deleteNamespacedPod({ name, namespace, gracePeriodSeconds: 0 });
     }
     catch (e) {
         if ((0, apply_1.statusCodeOf)(e) === 404) {
@@ -27,7 +28,7 @@ async function removeStalePod(instance, namespace, name) {
     }
     for (let attempt = 0; attempt < 30; attempt++) {
         try {
-            await instance.coreApi.readNamespacedPod(name, namespace);
+            await instance.coreApi.readNamespacedPod({ name, namespace });
         }
         catch (e) {
             if ((0, apply_1.statusCodeOf)(e) === 404) {
@@ -100,7 +101,7 @@ async function getPodForPersistence(instance, env, service, persistence, type, f
     }
     finally {
         service.status.console('stdout', `delete pod ${name}`);
-        await instance.coreApi.deleteNamespacedPod(name, env.namespace);
+        await instance.coreApi.deleteNamespacedPod({ name, namespace: env.namespace });
     }
 }
 exports.getPodForPersistence = getPodForPersistence;
@@ -122,12 +123,12 @@ async function ensurePersistentData(instance, env, environment, service, persist
                 continue;
             }
             const fileItem = (0, path_1.basename)(source.localPath);
-            const data = (0, tar_1.create)({
+            const data = stream_1.Readable.from((0, tar_1.create)({
                 cwd: (0, path_1.dirname)(source.localPath),
                 filter(path) {
                     return source.matcher(path, source.localPath);
                 },
-            }, [fileItem]);
+            }, [fileItem]));
             service.status.console('stdout', `upload ${source.localPath}`);
             const targetPath = `/dev/hammerkit/${service.id()}`;
             const res = await instance.exec.exec(env.namespace, name, 'volume', ['tar', 'xf', '-', '-C', targetPath], process.stdout, process.stderr, data, false, (status) => {

package/dist/kubernetes/get-service-ip.js

@@ -4,8 +4,8 @@ exports.getServiceIp = void 0;
 const resources_1 = require("./resources");
 async function getServiceIp(instance, env, workService) {
     const name = (0, resources_1.getResourceName)(workService);
-    const svc = await instance.coreApi.readNamespacedService(name, env.namespace);
-    return svc.body.spec?.clusterIP ?? null;
+    const svc = await instance.coreApi.readNamespacedService({ name, namespace: env.namespace });
+    return svc.spec?.clusterIP ?? null;
 }
 exports.getServiceIp = getServiceIp;
 //# sourceMappingURL=get-service-ip.js.map

package/dist/kubernetes/kubernetes-instance.js

@@ -16,14 +16,10 @@ function createKubernetesInstances(kubernetes) {
         const coreApi = kc.makeApiClient(client_node_1.CoreV1Api);
         const batchApi = kc.makeApiClient(client_node_1.BatchV1Api);
         const appsApi = kc.makeApiClient(client_node_1.AppsV1Api);
-        const networkingApi = kc.makeApiClient(client_node_1.NetworkingV1Api);
         const objectApi = kc.makeApiClient(client_node_1.KubernetesObjectApi);
         const exec = new client_node_1.Exec(kc);
-        const watch = new client_node_1.Watch(kc);
         return {
             objectApi,
-            networkingApi,
-            watch,
             exec,
             appsApi,
             coreApi,

package/dist/kubernetes/remove-persistent-data.js

@@ -2,16 +2,26 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.removePersistentData = void 0;
 async function removePersistentData(instance, kubernetes, task) {
-    const configmaps = await instance.coreApi.listNamespacedConfigMap(kubernetes.namespace, undefined, undefined, undefined, undefined, `hammerkit.dev/id=${task.id()}`);
-    for (const configMap of configmaps.body.items) {
+    const labelSelector = `hammerkit.dev/id=${task.id()}`;
+    const configmaps = await instance.coreApi.listNamespacedConfigMap({ namespace: kubernetes.namespace, labelSelector });
+    for (const configMap of configmaps.items) {
         if (configMap.metadata?.name) {
-            await instance.coreApi.deleteNamespacedConfigMap(configMap.metadata.name, kubernetes.namespace);
+            await instance.coreApi.deleteNamespacedConfigMap({
+                name: configMap.metadata.name,
+                namespace: kubernetes.namespace,
+            });
         }
     }
-    const pvcs = await instance.coreApi.listNamespacedPersistentVolumeClaim(kubernetes.namespace, undefined, undefined, undefined, undefined, `hammerkit.dev/id=${task.id()}`);
-    for (const pvc of pvcs.body.items) {
+    const pvcs = await instance.coreApi.listNamespacedPersistentVolumeClaim({
+        namespace: kubernetes.namespace,
+        labelSelector,
+    });
+    for (const pvc of pvcs.items) {
         if (pvc.metadata?.name) {
-            await instance.coreApi.deleteNamespacedPersistentVolumeClaim(pvc.metadata.name, kubernetes.namespace);
+            await instance.coreApi.deleteNamespacedPersistentVolumeClaim({
+                name: pvc.metadata.name,
+                namespace: kubernetes.namespace,
+            });
         }
     }
 }

package/dist/kubernetes/resolve-pod-name.js

@@ -7,9 +7,9 @@ function formatSelector(matchLabels) {
         .join(',');
 }
 async function findReadyPod(coreApi, namespace, labelSelector) {
-    const pods = await coreApi.listNamespacedPod(namespace, undefined, undefined, undefined, undefined, labelSelector);
-    const ready = pods.body.items.find((p) => p.status?.conditions?.some((c) => c.type === 'Ready' && c.status === 'True'));
-    const pod = ready ?? pods.body.items[0];
+    const pods = await coreApi.listNamespacedPod({ namespace, labelSelector });
+    const ready = pods.items.find((p) => p.status?.conditions?.some((c) => c.type === 'Ready' && c.status === 'True'));
+    const pod = ready ?? pods.items[0];
     if (!pod?.metadata?.name) {
         throw new Error(`no pod found for selector ${labelSelector} in namespace ${namespace}`);
     }
@@ -21,16 +21,16 @@ async function resolvePodName(coreApi, appsApi, namespace, selector) {
         return selector.name;
     }
     if (type === 'service') {
-        const svc = await coreApi.readNamespacedService(selector.name, namespace);
-        const matchLabels = svc.body.spec?.selector;
+        const svc = await coreApi.readNamespacedService({ name: selector.name, namespace });
+        const matchLabels = svc.spec?.selector;
         if (!matchLabels || Object.keys(matchLabels).length === 0) {
             throw new Error(`service ${selector.name} has no selector`);
         }
         return findReadyPod(coreApi, namespace, formatSelector(matchLabels));
     }
     if (type === 'deployment') {
-        const deploy = await appsApi.readNamespacedDeployment(selector.name, namespace);
-        const matchLabels = deploy.body.spec?.selector?.matchLabels;
+        const deploy = await appsApi.readNamespacedDeployment({ name: selector.name, namespace });
+        const matchLabels = deploy.spec?.selector?.matchLabels;
         if (!matchLabels) {
             throw new Error(`deployment ${selector.name} has no matchLabels`);
         }

package/dist/log.js

@@ -109,9 +109,14 @@ async function printWorkTreeResult(schedulerState, env) {
     for (const task of (0, plan_work_tasks_1.iterateWorkTasks)(schedulerState)) {
         let message = `${formatDate(new Date())} ${getType('task')} ${getNodeName(task.name, maxNodeNameLength)} - ${getStateText(task.state.current)}`;
         if (task.state.current.type === 'completed') {
-            message += ` in ${task.state.current.duration}ms`;
-            if (task.state.current.cached) {
-                message += ' [CACHED]';
+            if (task.state.current.skipped) {
+                message += ' [SKIPPED]';
+            }
+            else {
+                message += ` in ${task.state.current.duration}ms`;
+                if (task.state.current.cached) {
+                    message += ' [CACHED]';
+                }
             }
         }
         if (task.state.current.type === 'crash') {
@@ -263,9 +268,14 @@ function writeWorkTreeStatus(schedulerState, env, ticker) {
             }
         }
         else if (task.state.current.type === 'completed') {
-            message += ` in ${task.state.current.duration}ms`;
-            if (task.state.current.cached) {
-                message += ' [CACHED]';
+            if (task.state.current.skipped) {
+                message += ' [SKIPPED]';
+            }
+            else {
+                message += ` in ${task.state.current.duration}ms`;
+                if (task.state.current.cached) {
+                    message += ' [CACHED]';
+                }
             }
         }
         else if (task.state.current.type === 'error') {

package/dist/logging/live-logger.js

@@ -4,11 +4,12 @@ exports.liveLogger = void 0;
 const log_1 = require("../log");
 function liveLogger(state, env) {
     const maxNodeNameLength = (0, log_1.getWorkItemMaxLength)(state.current);
-    env.status.on((log) => {
+    const listener = env.status.on((log) => {
         (0, log_1.writeWorkItemLogToConsole)(env, log, maxNodeNameLength);
     });
     return {
         async complete(evt, env) {
+            listener.close();
             await (0, log_1.printWorkTreeResult)(evt.state, env);
         },
     };

package/dist/optimizer/calculate-checksum.js

@@ -2,9 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.calculateChecksum = void 0;
 const crypto_1 = require("crypto");
+// Hashes the raw bytes: decoding to text first would map every invalid UTF-8
+// sequence to U+FFFD, so two different binary files could share a checksum.
+// For UTF-8 text the result is unchanged.
 async function calculateChecksum(environment, path) {
-    const input = await environment.file.read(path);
-    return (0, crypto_1.createHash)('sha1').update(input).digest('hex');
+    const hash = (0, crypto_1.createHash)('sha1');
+    for await (const chunk of environment.file.readStream(path)) {
+        hash.update(chunk);
+    }
+    return hash.digest('hex');
 }
 exports.calculateChecksum = calculateChecksum;
 //# sourceMappingURL=calculate-checksum.js.map

package/dist/optimizer/get-work-cache-stats.js

@@ -1,45 +1,95 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getStateKey = exports.getWorkCacheStats = void 0;
+exports.getStateKey = exports.getWorkItemCacheStats = exports.getWorkCacheStats = void 0;
 const calculate_checksum_1 = require("./calculate-checksum");
 const path_1 = require("path");
 const crypto_1 = require("crypto");
-async function addWorkCacheStats(result, cwd, path, matcher, context) {
+function isExcluded(path, excluded) {
+    return excluded.some((excludedPath) => path === excludedPath || path.startsWith(excludedPath + path_1.sep));
+}
+async function addWorkCacheStats(result, cwd, path, matcher, context, root, excluded) {
+    if (isExcluded(path, excluded)) {
+        return 0;
+    }
     const exists = await context.file.exists(path);
     if (!exists) {
-        return;
+        return 0;
     }
     const stats = await context.file.stats(path);
     if (stats.type === 'file') {
-        if (matcher(path)) {
-            const checksum = await (0, calculate_checksum_1.calculateChecksum)(context, path);
-            result.files[(0, path_1.relative)(cwd, path)] = { lastModified: stats.lastModified, checksum };
+        if (!matcher(path)) {
+            return 0;
         }
+        const checksum = await (0, calculate_checksum_1.calculateChecksum)(context, path);
+        // '/'-separated on every OS, so a Windows host keys a container task like Linux
+        result.files[(0, path_1.relative)(cwd, path).split(path_1.sep).join(path_1.posix.sep)] = { lastModified: stats.lastModified, checksum };
+        return 1;
     }
     else if (stats.type === 'directory') {
-        const files = await context.file.listFiles(path);
-        for (const file of files) {
-            const subPath = (0, path_1.join)(path, file);
-            if (matcher(subPath)) {
-                await addWorkCacheStats(result, cwd, (0, path_1.join)(path, file), matcher, context);
-            }
+        // A glob such as src/**/*.ts never matches a directory itself, so a
+        // directory is walked when files inside it could match.
+        if (!root && !matcher(path, true)) {
+            return 0;
+        }
+        let matched = 0;
+        for (const file of await context.file.listFiles(path)) {
+            matched += await addWorkCacheStats(result, cwd, (0, path_1.join)(path, file), matcher, context, false, excluded);
         }
+        return matched;
     }
+    return 0;
 }
 async function getWorkCacheStats(work, environment) {
+    return (await collectSourceStats(work, environment, [])).stats;
+}
+exports.getWorkCacheStats = getWorkCacheStats;
+// `excluded` paths are left out of the walk, see getWorkItemCacheStats. A src
+// entry inside an excluded path is represented there, so it is never unmatched.
+async function collectSourceStats(work, environment, excluded) {
     const result = {
         created: new Date(),
         files: {},
     };
+    const unmatched = [];
     for (const src of work.src) {
-        await addWorkCacheStats(result, work.cwd, src.absolutePath, (file) => src.matcher(file, work.cwd), environment);
+        const matcher = (file, partial) => src.matcher(file, work.cwd, partial);
+        const matched = await addWorkCacheStats(result, work.cwd, src.absolutePath, matcher, environment, true, excluded);
+        if (matched === 0 && !src.inherited && !isExcluded(src.absolutePath, excluded)) {
+            unmatched.push(src);
+        }
     }
-    return result;
+    return { stats: result, unmatched };
+}
+// The source stats of a task or service, leaving out everything its (transitive)
+// dependencies generate. Those outputs are already represented by the
+// dependencies' task ids and state keys — and hashing them would key the item
+// differently before and after its dependencies ran, since the key is computed
+// before they do.
+function getWorkItemCacheStats(item, environment) {
+    return collectSourceStats(item.data, environment, dependencyOutputs(item));
+}
+exports.getWorkItemCacheStats = getWorkItemCacheStats;
+function dependencyOutputs(item) {
+    const outputs = new Set();
+    const visited = new Set();
+    const visit = (dep) => {
+        if (visited.has(dep)) {
+            return;
+        }
+        visited.add(dep);
+        for (const generate of dep.data.generates) {
+            outputs.add(generate.path);
+        }
+        dep.deps.forEach(visit);
+    };
+    item.deps.forEach(visit);
+    return [...outputs];
 }
-exports.getWorkCacheStats = getWorkCacheStats;
 function getStateKey(stats, cacheMethod) {
     const contents = [];
-    for (const key of Object.keys(stats.files)) {
+    // Sorted: the walk follows the filesystem's listing order, which differs
+    // between machines (ext4 and overlayfs list in hash order).
+    for (const key of Object.keys(stats.files).sort()) {
         if (cacheMethod === 'checksum') {
             contents.push(`${key}:${stats.files[key].checksum}`);
         }

package/dist/optimizer/work-task-cache-description.js

@@ -1,14 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getWorkTaskCacheDescription = void 0;
+exports.storedCacheDescription = exports.getWorkTaskCacheDescription = void 0;
 const os_1 = require("os");
+const crypto_1 = require("crypto");
 const replace_env_variables_1 = require("../environment/replace-env-variables");
-function getWorkTaskCacheDescription(task) {
+const portable_path_1 = require("../planner/utils/portable-path");
+// Every path is made project-relative (portablePath) so the description, and the
+// task id hashed from it, is identical wherever the project is checked out.
+//
+// `deps` holds the dependencies' task ids, so a change to a dependency's
+// definition (command, env, image, …) gives every task depending on it a new id.
+// The state key only folds in the dependencies' *sources*.
+function getWorkTaskCacheDescription(item) {
+    const task = item.data;
+    const portable = (path) => (0, portable_path_1.portablePath)(task.projectRoot, path);
     const envs = (0, replace_env_variables_1.getEnvironmentVariables)(task.envs);
     return {
         shell: task.shell ?? undefined,
         platform: task.type === 'container-task' ? task.image : (0, os_1.platform)(),
-        generates: task.generates.map((g) => g.path).sort() ?? undefined,
+        // outputs hold native binaries, and docker pulls images for the host
+        // architecture, so container tasks are keyed by it too
+        arch: process.arch,
+        generates: task.generates.map((g) => portable(g.path)).sort() ?? undefined,
         src: task.src.map((s) => s.source).sort() ?? undefined,
         envs: Object.keys(envs)
             .sort()
@@ -16,10 +29,26 @@ function getWorkTaskCacheDescription(task) {
             map[key] = envs[key];
             return map;
         }, {}) ?? undefined,
-        cmds: task.cmds.map((c) => ({ cmd: c.cmd, cwd: c.cwd })),
+        cmds: task.cmds.map((c) => ({ cmd: c.cmd, cwd: portable(c.cwd) })),
         mounts: task.type === 'container-task' ? task.mounts.map((m) => m.mount).sort() : undefined,
-        cwd: task.cwd,
+        cwd: portable(task.cwd),
+        deps: item.deps.length > 0 ? item.deps.map((dep) => dep.id()).sort() : undefined,
     };
 }
 exports.getWorkTaskCacheDescription = getWorkTaskCacheDescription;
+// The form written to disk: description.json in a cache entry (pushed to remote
+// backends, readable by everyone who can pull) and the local explain record.
+// Env is where tokens get passed, so each value is stored as a digest; the task
+// id is still hashed from the values themselves.
+function storedCacheDescription(description) {
+    if (!description.envs) {
+        return description;
+    }
+    const envs = {};
+    for (const [key, value] of Object.entries(description.envs)) {
+        envs[key] = `sha256:${(0, crypto_1.createHash)('sha256').update(value).digest('hex')}`;
+    }
+    return { ...description, envs };
+}
+exports.storedCacheDescription = storedCacheDescription;
 //# sourceMappingURL=work-task-cache-description.js.map

package/dist/planner/project-root.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findProjectRoot = void 0;
+const path_1 = require("path");
+// The project root anchors cache identity: every path that participates in a
+// task or service id is expressed relative to it, so the same checkout yields the
+// same ids wherever it lives (an agent sandbox, a CI runner, a laptop). The git
+// root is used when there is one, so the root does not move with the build file
+// the CLI was invoked with (`-f apps/web/.hammerkit.yaml` vs the repo root);
+// otherwise the directory of the main build file.
+async function findProjectRoot(buildFileDirectory, environment) {
+    let current = buildFileDirectory;
+    for (;;) {
+        // `.git` is a directory in a normal clone and a file in a worktree/submodule
+        if (await environment.file.exists((0, path_1.join)(current, '.git'))) {
+            return current;
+        }
+        const parent = (0, path_1.dirname)(current);
+        if (parent === current) {
+            return buildFileDirectory;
+        }
+        current = parent;
+    }
+}
+exports.findProjectRoot = findProjectRoot;
+//# sourceMappingURL=project-root.js.map

package/dist/planner/utils/append-work-environment.js

@@ -13,7 +13,7 @@ function appendWorkEnvironment(referenced) {
             type: 'kubernetes',
             context: referenced.schema.kubernetes.context,
             kubeConfig: referenced.schema.kubernetes.kubeconfig,
-            ingresses: referenced.schema.kubernetes.ingresses || [],
+            httpRoutes: referenced.schema.kubernetes.httpRoutes || [],
             namespace: referenced.schema.kubernetes.namespace ?? 'default',
         };
     }

package/dist/planner/utils/append-work-service.js

@@ -51,6 +51,7 @@ function parseService(workTree, service, environment, context) {
     const envs = (0, replace_env_variables_1.buildEnvironmentVariables)(service.envs, environment, context);
     const workService = {
         cwd: service.cwd,
+        projectRoot: context.projectRoot,
         name: service.relativeName,
         ports: (0, parse_work_ports_1.parseWorkPorts)(service.schema, envs),
         scope: service.scope,
@@ -94,7 +95,7 @@ function parseService(workTree, service, environment, context) {
                 }
                 : null,
             envs: (0, replace_env_variables_1.buildEnvironmentVariables)(service.envs, environment, context),
-            image: service.schema.image,
+            image: (0, template_value_1.templateValue)(service.schema.image, envs),
             cwd: service.cwd,
             cmd: service.schema.cmd ? (0, parse_work_command_1.parseWorkCommand)(service.cwd, service.schema.cmd, envs) : null,
             volumes: (0, parse_work_volume_1.parseWorkVolumes)(service.cwd, service.schema.volumes, envs),

package/dist/planner/utils/append-work-task.js

@@ -16,11 +16,15 @@ const replace_env_variables_1 = require("../../environment/replace-env-variables
 const lazy_resolver_1 = require("../../executer/lazy-resolver");
 const get_work_runtime_1 = require("./get-work-runtime");
 const resolve_cache_1 = require("../../cache/resolve-cache");
+const units_1 = require("../../utils/units");
 function appendWorkTask(workTree, cwd, referenceTask, environment, context) {
     const task = parseTask(cwd, referenceTask, environment, context);
     if (!workTree.tasks[task.name]) {
         const workItem = {
-            id: (0, lazy_resolver_1.lazyResolver)(() => (0, work_cache_id_1.getWorkTaskId)(task)),
+            // A dependency cycle is rejected before anything runs (checkForLoop), but
+            // the id may be asked for earlier; re-entry yields a placeholder instead of
+            // recursing forever.
+            id: (0, lazy_resolver_1.lazyResolver)(() => (0, work_cache_id_1.getWorkTaskId)(workItem), () => `cycle:${task.name}`),
             name: task.name,
             data: task,
             status: environment.status.from(task),
@@ -53,6 +57,7 @@ function parseTask(cwd, task, environment, context) {
         description: (0, template_value_1.templateValue)(task.schema.description || '', envs).trim(),
         name: task.relativeName,
         cwd,
+        projectRoot: context.projectRoot,
         cmds: (0, parse_work_command_1.parseWorkCommands)(cwd, task.schema.cmds || [], envs),
         src: (0, parse_work_source_1.parseWorkSource)(cwd, task.schema.src, envs),
         generates: (0, parse_work_generate_1.parseWorkGenerate)(cwd, task.schema, envs),
@@ -61,6 +66,7 @@ function parseTask(cwd, task, environment, context) {
         caching: (0, resolve_cache_1.resolveCache)(task.schema.cache ?? null, context.caches, task.relativeName),
         shell: task.schema.shell ? (0, template_value_1.templateValue)(task.schema.shell, envs) : '/bin/sh',
         continuous: task.schema.continuous ?? false,
+        timeout: task.schema.timeout ? (0, units_1.parseDuration)(task.schema.timeout) : null,
     };
     if ((0, build_file_task_schema_1.isBuildFileContainerTaskSchema)(task.schema)) {
         return {

package/dist/planner/utils/get-outputs-to-reset.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOutputsToReset = void 0;
+const path_1 = require("path");
+function contains(parent, path) {
+    const rel = (0, path_1.relative)(parent, path);
+    return rel === '' || (!rel.startsWith('..') && !(0, path_1.isAbsolute)(rel));
+}
+// The outputs a run empties before the task's commands: its own outputs with
+// resetOnChange (the default), except one that is a source or contains one
+// (`package-lock.json` declared both ways) or contains the task's directory.
+// Emptying those would delete what the task reads.
+function getOutputsToReset(task) {
+    return task.generates.filter((generate) => generate.resetOnChange &&
+        !generate.inherited &&
+        !contains(generate.path, task.cwd) &&
+        !task.src.some((src) => contains(generate.path, src.absolutePath)));
+}
+exports.getOutputsToReset = getOutputsToReset;
+//# sourceMappingURL=get-outputs-to-reset.js.map

package/dist/planner/utils/parse-work-generate.js

@@ -24,12 +24,12 @@ function parseWorkGenerate(cwd, schema, envs) {
 exports.parseWorkGenerate = parseWorkGenerate;
 function mapGenerate(generate) {
     if (typeof generate === 'string') {
-        return { path: generate, resetOnChange: false, export: false };
+        return { path: generate, resetOnChange: true, export: false };
     }
     else {
         return {
             path: generate.path,
-            resetOnChange: generate.resetOnChange ?? false,
+            resetOnChange: generate.resetOnChange ?? true,
             export: generate.export ?? false,
         };
     }

package/dist/planner/utils/parse-work-source.js

@@ -15,38 +15,25 @@ function parseWorkSource(cwd, sources, envs) {
         return result;
     }
     for (const source of sources) {
-        const wildcardIndex = source.indexOf('*');
-        if (wildcardIndex >= 0) {
-            if (wildcardIndex === 0) {
-                const absolutePath = cwd;
-                result.push({
-                    matcher: (file, cwd) => {
-                        const matcher = new minimatch_1.Minimatch(source, { dot: true });
-                        return matcher.match(toPosix((0, path_1.relative)(cwd, file)));
-                    },
-                    inherited: null,
-                    source,
-                    absolutePath,
-                    isFile: false,
-                });
-            }
-            else {
-                const prefixSource = source.substring(0, wildcardIndex);
-                const absolutePath = (0, path_1.join)(cwd, (0, template_value_1.templateValue)(prefixSource, envs));
-                result.push({
-                    matcher: (file, cwd) => {
-                        const matcher = new minimatch_1.Minimatch(toPosix((0, path_1.join)(cwd, source)), { dot: true });
-                        return matcher.match(toPosix(file));
-                    },
-                    inherited: null,
-                    source,
-                    absolutePath,
-                    isFile: false,
-                });
-            }
+        // env variables are substituted before matching, so `$DIR/*.ts` globs the
+        // directory the task actually reads; `source` keeps the declared form.
+        const pattern = path_1.posix.normalize(toPosix((0, template_value_1.templateValue)(source, envs)));
+        const matcher = new minimatch_1.Minimatch(pattern, { dot: true });
+        if (isGlob(matcher)) {
+            // Walk from the literal directory prefix and match paths relative to the
+            // declaring task's cwd — which stays correct when the source is inherited
+            // by a dependant in another directory.
+            const prefix = literalPrefix(pattern);
+            result.push({
+                matcher: (file, _cwd, partial) => matcher.match(toPosix((0, path_1.relative)(cwd, file)), partial),
+                inherited: null,
+                source,
+                absolutePath: prefix ? (0, path_1.join)(cwd, prefix) : cwd,
+                isFile: false,
+            });
         }
         else {
-            const absolutePath = (0, path_1.join)(cwd, (0, template_value_1.templateValue)(source, envs));
+            const absolutePath = (0, path_1.join)(cwd, pattern);
             result.push({
                 matcher: (file) => file.startsWith(absolutePath),
                 absolutePath,
@@ -59,6 +46,24 @@ function parseWorkSource(cwd, sources, envs) {
     return result;
 }
 exports.parseWorkSource = parseWorkSource;
+// minimatch parses a literal path into a single set of plain strings; anything
+// else (wildcards, ?, [...], {a,b}, extglobs) is a glob.
+function isGlob(matcher) {
+    return matcher.set.length !== 1 || matcher.set[0].some((part) => typeof part !== 'string');
+}
+// The leading directories of a glob that contain no glob syntax — where the
+// walk for matching files starts.
+function literalPrefix(pattern) {
+    const segments = pattern.split('/');
+    const literal = [];
+    for (const segment of segments.slice(0, -1)) {
+        if (/[*?[\]{}()!+@]/.test(segment)) {
+            break;
+        }
+        literal.push(segment);
+    }
+    return literal.join('/');
+}
 function createSource(absolutePath) {
     return {
         matcher: (file) => file.startsWith(absolutePath),

package/dist/planner/utils/portable-path.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.portablePath = void 0;
+const os_1 = require("os");
+const path_1 = require("path");
+const toPosix = (value) => (path_1.sep === path_1.posix.sep ? value : value.split(path_1.sep).join(path_1.posix.sep));
+function within(base, path) {
+    const rel = (0, path_1.relative)(base, path);
+    if (rel.startsWith('..') || (0, path_1.isAbsolute)(rel)) {
+        return null;
+    }
+    return toPosix(rel);
+}
+// Express an absolute path in a machine-independent form for cache identity:
+// relative to the project root when inside it, relative to the home directory
+// (`~/…`) when inside that, and unchanged otherwise (a fixed system path such as
+// `/var/run/docker.sock` is already the same on every machine).
+function portablePath(projectRoot, path) {
+    const inRoot = within(projectRoot, path);
+    if (inRoot !== null) {
+        return inRoot.length > 0 ? inRoot : '.';
+    }
+    const inHome = within((0, os_1.homedir)(), path);
+    if (inHome !== null) {
+        return inHome.length > 0 ? `~/${inHome}` : '~';
+    }
+    return toPosix(path);
+}
+exports.portablePath = portablePath;
+//# sourceMappingURL=portable-path.js.map

package/dist/planner/work-cache-id.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getWorkTaskId = void 0;
 const crypto_1 = require("crypto");
 const work_task_cache_description_1 = require("../optimizer/work-task-cache-description");
-function getWorkTaskId(task) {
-    const description = (0, work_task_cache_description_1.getWorkTaskCacheDescription)(task);
+function getWorkTaskId(item) {
+    const description = (0, work_task_cache_description_1.getWorkTaskCacheDescription)(item);
     const jsonData = JSON.stringify(description);
     return (0, crypto_1.createHash)('sha1').update(jsonData).digest('hex');
 }