hammerkit 1.7.0 → 1.8.0

package/README.md

@@ -1,6 +1,6 @@
 # About
 
-<figure><img src="docs/hammerkit-small.png" width="144" alt=""><figcaption></figcaption></figure>
+<img src="website/public/logo.png" width="144" alt="hammerkit">
 
 ## What is hammerkit?
 
@@ -9,7 +9,7 @@ Hammerkit is a build tool intended to build software projects in **containers**
 * the build tools come from the container image, so they are the same across all machines.
 * the build process is isolated since every file in the container has to be declared as a source or an output. Therefore, side effects can be reduced.
 
-For a fuller pitch — including how it compares to Make, npm scripts, Taskfile and Earthly — see [Why hammerkit](docs/why-hammerkit.md).
+For a fuller pitch — including how it compares to Make, npm scripts, Taskfile and Earthly — see [Why hammerkit](https://hammerkit.dev/docs/why-hammerkit).
 
 There are a lot of containerized CI systems that allow writing containerized builds today, but they have shortcomings that hammerkit tries to address:
 
@@ -23,4 +23,4 @@ Hammerkit, on the other hand, knows the source and output files of each build st
 
 ## Where to go next?
 
-Check out the [docs](https://no0dles.gitbook.io/hammerkit/) for more info about how hammerkit can be used.
+Check out the [docs on hammerkit.dev](https://hammerkit.dev) for more info about how hammerkit can be used.

package/build.schema.json

@@ -12,7 +12,7 @@
               "number"
             ]
           },
-          "description": "Environment values for the current build task\nhttps://no0dles.gitbook.io/hammerkit/build-file/environment-variables"
+          "description": "Environment values for the current build task\nhttps://hammerkit.dev/docs/build-file/environment-variables"
         },
         "tasks": {
           "type": "object",
@@ -61,7 +61,7 @@
                   },
                   "envs": {
                     "$ref": "#/definitions/hammerkit/properties/envs",
-                    "description": "Environment values for the current build task\nhttps://no0dles.gitbook.io/hammerkit/build-file/environment-variables"
+                    "description": "Environment values for the current build task\nhttps://hammerkit.dev/docs/build-file/environment-variables"
                   },
                   "labels": {
                     "type": "object",
@@ -280,7 +280,7 @@
                   },
                   "envs": {
                     "$ref": "#/definitions/hammerkit/properties/envs",
-                    "description": "Environment values for the current build task\nhttps://no0dles.gitbook.io/hammerkit/build-file/environment-variables"
+                    "description": "Environment values for the current build task\nhttps://hammerkit.dev/docs/build-file/environment-variables"
                   },
                   "mounts": {
                     "type": "array",
@@ -431,18 +431,11 @@
                       "kubeconfig": {
                         "type": "string"
                       },
-                      "ingresses": {
+                      "httpRoutes": {
                         "type": "array",
                         "items": {
                           "type": "object",
                           "properties": {
-                            "kind": {
-                              "type": "string",
-                              "enum": [
-                                "ingress",
-                                "httproute"
-                              ]
-                            },
                             "host": {
                               "type": "string"
                             },
@@ -464,10 +457,14 @@
                           },
                           "required": [
                             "host",
-                            "service"
+                            "service",
+                            "gateway"
                           ],
                           "additionalProperties": false
                         }
+                      },
+                      "ingresses": {
+                        "not": {}
                       }
                     },
                     "required": [
@@ -608,7 +605,7 @@
         }
       },
       "additionalProperties": false,
-      "description": "Build file with support for containerization\nhttps://no0dles.gitbook.io/hammerkit/build-file"
+      "description": "Build file with support for containerization\nhttps://hammerkit.dev/docs/build-file"
     }
   },
   "$schema": "http://json-schema.org/draft-07/schema#"

package/dist/docker/using-container.js

@@ -39,6 +39,18 @@ async function usingContainer(docker, item, createOptions, stateKey, callback) {
                 if (container) {
                     await (0, remove_container_1.removeContainer)(container);
                 }
+                // A task run that failed has written into the outputs an earlier run's
+                // container still vouches for (its state label is what currentStateKey
+                // reads), so that record goes too.
+                if (stateKey) {
+                    const containers = await docker.listContainers({
+                        all: true,
+                        filters: { label: [`hammerkit-id=${(0, work_instance_id_1.getWorkInstanceId)(item)}`] },
+                    });
+                    for (const old of containers) {
+                        await (0, remove_container_1.removeContainer)(docker.getContainer(old.Id));
+                    }
+                }
             }
         }
         catch (e) {

package/dist/executer/docker-task.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.dockerTask = exports.getNeedsNetwork = void 0;
+exports.dockerTask = exports.buildCreateOptions = exports.getNeedsNetwork = void 0;
 const service_dns_1 = require("./service-dns");
 const execute_docker_1 = require("./execute-docker");
 const abort_1 = require("./abort");
@@ -13,6 +13,7 @@ const replace_env_variables_1 = require("../environment/replace-env-variables");
 const get_container_binds_1 = require("./get-container-binds");
 const get_service_containers_1 = require("./get-service-containers");
 const work_instance_id_1 = require("../planner/work-instance-id");
+const get_outputs_to_reset_1 = require("../planner/utils/get-outputs-to-reset");
 function getNeedsNetwork(serviceContainers, needs) {
     const links = [];
     const hosts = [];
@@ -35,13 +36,17 @@ function buildCreateOptions(item, stateKey, serviceContainers, environment) {
     const network = getNeedsNetwork(serviceContainers, item.needs);
     const binds = (0, get_container_binds_1.getContainerBinds)(item);
     const envs = (0, replace_env_variables_1.getEnvironmentVariables)(item.data.envs);
+    // Running as the host's uid (Linux), the user has no home in the image and
+    // Docker sets HOME=/, which isn't writable: tools then fail to create their
+    // caches. Set on the container only, so it's not part of the cache key.
+    const home = item.data.user && !('HOME' in envs) ? { HOME: '/tmp' } : {};
     return {
         abortSignal: environment.abortCtrl.signal,
         Image: item.data.image,
         Tty: true,
         Entrypoint: [item.data.shell],
         Cmd: ['-c', 'sleep 3600'],
-        Env: Object.entries(envs).map(([key, value]) => `${key}=${value}`),
+        Env: Object.entries({ ...envs, ...home }).map(([key, value]) => `${key}=${value}`),
         WorkingDir: (0, execute_docker_1.convertToPosixPath)(item.data.cwd),
         Labels: {
             app: 'hammerkit',
@@ -58,9 +63,15 @@ function buildCreateOptions(item, stateKey, serviceContainers, environment) {
         },
     };
 }
+exports.buildCreateOptions = buildCreateOptions;
 async function dockerTask(docker, item, environment, options) {
     item.status.write('info', `execute ${item.name} in container`);
     try {
+        const outputsToReset = (0, get_outputs_to_reset_1.getOutputsToReset)(item.data);
+        // outputs on the host: file outputs (bind mounts) and exported directories
+        for (const generate of outputsToReset.filter((g) => g.isFile || g.export)) {
+            await environment.file.remove(generate.path);
+        }
         await (0, execution_steps_1.prepareMounts)(item, environment);
         (0, abort_1.checkForAbort)(options.abort);
         await (0, execution_steps_1.pullImage)(item, docker);
@@ -72,6 +83,9 @@ async function dockerTask(docker, item, environment, options) {
         (0, print_container_options_1.printContainerOptions)(item.status, containerOptions);
         await (0, using_container_1.usingContainer)(docker, item, containerOptions, options.stateKey, async (container) => {
             await (0, execution_steps_1.setUserPermissions)(item, container, environment);
+            for (const generate of outputsToReset.filter((g) => !g.isFile)) {
+                await (0, execute_docker_1.clearContainerDirectory)(item.status, environment, container, generate.path);
+            }
             for (const cmd of item.data.cmds) {
                 (0, abort_1.checkForAbort)(options.abort);
                 item.status.write('info', `execute cmd "${cmd.cmd}" in container`);

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-task.js

@@ -51,6 +51,15 @@ function withDeadline(parent, timeout) {
         },
     };
 }
+// 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)
@@ -139,12 +148,13 @@ dependents = null) {
                 if (work.state.current.type === 'running') {
                     work.status.write('debug', 'completed for state key ' + cacheState.stateKey);
                     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,
+                        missCauses: cached ? undefined : missCauses,
                     });
                 }
                 else {
@@ -170,6 +180,11 @@ dependents = null) {
                 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/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/index.js

@@ -10,6 +10,16 @@ const abortCtrl = new AbortController();
 process.on('SIGINT', function () {
     abortCtrl.abort();
 });
+let settled = false;
+// A run that never settles (a task waiting on something that can't happen)
+// lets the event loop drain, and Node then exits 0: CI would report success
+// for a build that never finished. Fail loudly instead.
+process.on('beforeExit', () => {
+    if (!settled) {
+        process.stderr.write('hammerkit stopped before the run finished\n');
+        process.exitCode = 1;
+    }
+});
 (0, run_program_1.runProgram)({
     cwd: process.cwd(),
     abortCtrl,
@@ -20,7 +30,10 @@ process.on('SIGINT', function () {
     stdout: process.stdout,
     stderr: process.stderr,
     stdoutColumns: process.stdout.columns,
-}, process.argv, false).catch(() => {
+}, process.argv, false).then(() => {
+    settled = true;
+}, () => {
+    settled = true;
     process.exit(1);
 });
 //# sourceMappingURL=index.js.map

package/dist/kubernetes/apply.js

@@ -1,21 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.apply = exports.statusCodeOf = void 0;
+// The client throws an ApiException carrying the HTTP status as `code`; watch
+// errors carry it as `statusCode`.
 function statusCodeOf(e) {
     const err = e;
-    return err?.statusCode ?? err?.response?.statusCode ?? err?.body?.code;
+    return typeof err?.code === 'number' ? err.code : err?.statusCode;
 }
 exports.statusCodeOf = statusCodeOf;
 async function apply(instance, spec) {
     try {
         await instance.objectApi.read(spec);
-        const response = await instance.objectApi.patch(spec);
-        return response.body;
+        return await instance.objectApi.patch(spec);
     }
     catch (e) {
         try {
-            const response = await instance.objectApi.create(spec);
-            return response.body;
+            return await instance.objectApi.create(spec);
         }
         catch (createError) {
             // Two work items can apply the same object concurrently (e.g. a volume
@@ -23,8 +23,7 @@ async function apply(instance, spec) {
             // lost the create race, the object now exists — read it back instead of
             // failing the whole item.
             if (statusCodeOf(createError) === 409) {
-                const response = await instance.objectApi.read(spec);
-                return response.body;
+                return await instance.objectApi.read(spec);
             }
             throw createError;
         }

package/dist/kubernetes/await-running-state.js

@@ -4,25 +4,21 @@ exports.deleteJobAndWait = exports.awaitDeployRunningState = exports.deleteJob =
 const abort_1 = require("../executer/abort");
 const abort_event_1 = require("../utils/abort-event");
 const apply_1 = require("./apply");
-function awaitRunningState(instance, env, name, phase) {
-    return new Promise((resolve, reject) => {
-        const req = instance.watch.watch(`/api/v1/namespaces/${env.namespace}/pods`, {}, (type, obj) => {
-            if (obj.metadata.name === name && obj.metadata.namespace === env.namespace && obj.status.phase === phase) {
-                req.then((r) => r.abort());
-                resolve();
-            }
-        }, (err) => {
-            if (err.message === 'aborted') {
-                return;
-            }
-            if (err) {
-                reject(err);
-            }
-            else {
-                resolve();
-            }
-        });
-    });
+const sleep_1 = require("../utils/sleep");
+// The waits below poll instead of using the client's Watch: Watch aborts every
+// request after 30s, which a pod or deployment still pulling its image outlasts.
+async function awaitRunningState(instance, env, name, phase, pollInterval = 1000) {
+    for (;;) {
+        const pod = await instance.coreApi.readNamespacedPod({ name, namespace: env.namespace });
+        const current = pod.status?.phase;
+        if (current === phase) {
+            return;
+        }
+        if (current === 'Succeeded' || current === 'Failed') {
+            throw new Error(`pod ${name} ended in phase ${current} before reaching ${phase}`);
+        }
+        await (0, sleep_1.sleep)(pollInterval);
+    }
 }
 exports.awaitRunningState = awaitRunningState;
 // Wait for a job to finish by polling its status: resolves once it succeeded,
@@ -35,8 +31,8 @@ async function awaitJobCompletion(instance, env, name, abort, pollInterval = 100
             await deleteJob(instance, env, name);
             throw new abort_1.AbortError();
         }
-        const job = await instance.batchApi.readNamespacedJobStatus(name, env.namespace);
-        const status = job.body.status;
+        const job = await instance.batchApi.readNamespacedJobStatus({ name, namespace: env.namespace });
+        const status = job.status;
         if (status?.succeeded) {
             return;
         }
@@ -66,7 +62,12 @@ function sleep(ms, abort) {
 }
 async function deleteJob(instance, env, name) {
     try {
-        await instance.batchApi.deleteNamespacedJob(name, env.namespace, undefined, undefined, 0, undefined, 'Background');
+        await instance.batchApi.deleteNamespacedJob({
+            name,
+            namespace: env.namespace,
+            gracePeriodSeconds: 0,
+            propagationPolicy: 'Background',
+        });
     }
     catch (e) {
         if ((0, apply_1.statusCodeOf)(e) !== 404) {
@@ -75,29 +76,14 @@ async function deleteJob(instance, env, name) {
     }
 }
 exports.deleteJob = deleteJob;
-function awaitDeployRunningState(instance, env, name) {
-    return new Promise((resolve, reject) => {
-        const req = instance.watch.watch(`/apis/apps/v1/namespaces/${env.namespace}/deployments`, {}, (type, obj) => {
-            if ((obj &&
-                obj.metadata?.name === name &&
-                obj.metadata?.namespace === env.namespace &&
-                obj.status?.readyReplicas) ??
-                0 > 0) {
-                req.then((r) => r.abort());
-                resolve();
-            }
-        }, (err) => {
-            if (err && err.message === 'aborted') {
-                return;
-            }
-            if (err) {
-                reject(err);
-            }
-            else {
-                resolve();
-            }
-        });
-    });
+async function awaitDeployRunningState(instance, env, name, pollInterval = 1000) {
+    for (;;) {
+        const deployment = await instance.appsApi.readNamespacedDeployment({ name, namespace: env.namespace });
+        if ((deployment.status?.readyReplicas ?? 0) > 0) {
+            return;
+        }
+        await (0, sleep_1.sleep)(pollInterval);
+    }
 }
 exports.awaitDeployRunningState = awaitDeployRunningState;
 // Delete a job and wait until it is gone: its name is reused for the task's next
@@ -107,7 +93,7 @@ async function deleteJobAndWait(instance, env, name, abort, pollInterval = 500)
     await deleteJob(instance, env, name);
     for (;;) {
         try {
-            await instance.batchApi.readNamespacedJob(name, env.namespace);
+            await instance.batchApi.readNamespacedJob({ name, namespace: env.namespace });
         }
         catch (e) {
             if ((0, apply_1.statusCodeOf)(e) === 404) {

package/dist/kubernetes/ensure-http-route.js

@@ -5,15 +5,12 @@ const apply_1 = require("./apply");
 const resources_1 = require("./resources");
 exports.HTTP_ROUTE_API_VERSION = 'gateway.networking.k8s.io/v1';
 exports.HTTP_ROUTE_KIND = 'HTTPRoute';
-async function ensureHttpRoute(instance, env, ingress, service) {
-    if (!ingress.gateway) {
-        throw new Error(`httproute for ${ingress.host} requires a "gateway" (the parent Gateway name)`);
-    }
+async function ensureHttpRoute(instance, env, route, service) {
     const resource = {
         apiVersion: exports.HTTP_ROUTE_API_VERSION,
         kind: exports.HTTP_ROUTE_KIND,
         metadata: {
-            name: ingress.host,
+            name: route.host,
             namespace: env.namespace,
             labels: {
                 'hammerkit.dev/id': service.id(),
@@ -22,25 +19,25 @@ async function ensureHttpRoute(instance, env, ingress, service) {
         spec: {
             parentRefs: [
                 {
-                    name: ingress.gateway,
-                    ...(ingress.gatewayNamespace ? { namespace: ingress.gatewayNamespace } : {}),
+                    name: route.gateway,
+                    ...(route.gatewayNamespace ? { namespace: route.gatewayNamespace } : {}),
                 },
             ],
-            hostnames: [ingress.host],
+            hostnames: [route.host],
             rules: [
                 {
                     matches: [
                         {
                             path: {
                                 type: 'PathPrefix',
-                                value: ingress.path ?? '/',
+                                value: route.path ?? '/',
                             },
                         },
                     ],
                     backendRefs: [
                         {
                             name: (0, resources_1.getResourceName)(service),
-                            port: ingress.servicePort ?? service.data.ports[0].containerPort,
+                            port: route.servicePort ?? service.data.ports[0].containerPort,
                         },
                     ],
                 },

package/dist/kubernetes/ensure-namespace.js

@@ -1,10 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureNamespace = void 0;
-function statusCodeOf(e) {
-    const err = e;
-    return err?.statusCode ?? err?.response?.statusCode ?? err?.body?.code;
-}
+const apply_1 = require("./apply");
 /**
  * Idempotently make sure `namespace` exists. hammerkit does not otherwise
  * create namespaces — deployments/services/jobs are applied straight into
@@ -16,25 +13,27 @@ function statusCodeOf(e) {
  */
 async function ensureNamespace(instance, namespace) {
     try {
-        await instance.coreApi.readNamespace(namespace);
+        await instance.coreApi.readNamespace({ name: namespace });
         return;
     }
     catch (e) {
-        if (statusCodeOf(e) !== 404) {
+        if ((0, apply_1.statusCodeOf)(e) !== 404) {
             throw e;
         }
     }
     try {
         await instance.coreApi.createNamespace({
-            metadata: {
-                name: namespace,
-                labels: { 'hammerkit.dev/managed': 'true' },
+            body: {
+                metadata: {
+                    name: namespace,
+                    labels: { 'hammerkit.dev/managed': 'true' },
+                },
             },
         });
     }
     catch (e) {
         // another worker created it between our read and create
-        if (statusCodeOf(e) !== 409) {
+        if ((0, apply_1.statusCodeOf)(e) !== 409) {
             throw e;
         }
     }

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/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/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/work-runtime-docker.js

@@ -12,6 +12,7 @@ const path_1 = require("path");
 const tar_1 = require("tar");
 const plan_work_volume_1 = require("./utils/plan-work-volume");
 const work_instance_id_1 = require("./work-instance-id");
+const stream_1 = require("stream");
 function dockerTaskRuntime(task, workEnvironment) {
     const docker = (0, execute_docker_1.getContainerCli)(workEnvironment);
     return {
@@ -132,6 +133,9 @@ async function restoreContainer(docker, environment, item, path) {
     }, null, async (container) => {
         for (const generate of (0, event_cache_1.getArchivePaths)(item.data, path)) {
             if (await environment.file.exists(generate.filename)) {
+                // a cache hit means exactly the stored outputs: whatever a failed or
+                // older run left in the volume goes first
+                await (0, execute_docker_1.clearContainerDirectory)(item.status, environment, container, generate.path);
                 await container.putArchive(environment.file.readStream(generate.filename), {
                     path: (0, path_1.dirname)(generate.path),
                 });
@@ -142,6 +146,7 @@ async function restoreContainer(docker, environment, item, path) {
         const onHost = new Set(item.data.generates.filter((g) => !g.inherited && isOnHost(g)).map((g) => g.path));
         for (const generate of (0, event_cache_1.getArchivePaths)(item.data, path)) {
             if (onHost.has(generate.path) && (await environment.file.exists(generate.filename))) {
+                await environment.file.remove(generate.path);
                 await (0, tar_1.extract)({ file: generate.filename, cwd: (0, path_1.dirname)(generate.path) });
             }
         }
@@ -251,7 +256,7 @@ async function archiveContainer(docker, environment, item, path) {
         for (const generatedArchive of (0, event_cache_1.getArchivePaths)(item.data, path)) {
             // a file output is a bind mount of a host file, so archive it from the host
             const readable = hostFiles.has(generatedArchive.path)
-                ? (0, tar_1.create)({ cwd: (0, path_1.dirname)(generatedArchive.path) }, [(0, path_1.basename)(generatedArchive.path)])
+                ? stream_1.Readable.from((0, tar_1.create)({ cwd: (0, path_1.dirname)(generatedArchive.path) }, [(0, path_1.basename)(generatedArchive.path)]))
                 : await container.getArchive({
                     path: generatedArchive.path,
                 });

package/dist/planner/work-runtime-kubernetes.js

@@ -16,7 +16,6 @@ const ensure_persistent_data_1 = require("../kubernetes/ensure-persistent-data")
 const await_running_state_1 = require("../kubernetes/await-running-state");
 const volumes_1 = require("../kubernetes/volumes");
 const resources_1 = require("../kubernetes/resources");
-const ensure_ingress_1 = require("../kubernetes/ensure-ingress");
 const ensure_http_route_1 = require("../kubernetes/ensure-http-route");
 const find_process_1 = __importDefault(require("find-process"));
 const log_1 = require("../log");
@@ -24,13 +23,12 @@ const version_1 = require("../version");
 const restore_kubernetes_data_1 = require("../kubernetes/restore-kubernetes-data");
 const store_kubernetes_data_1 = require("../kubernetes/store-kubernetes-data");
 const remove_persistent_data_1 = require("../kubernetes/remove-persistent-data");
-function statusCodeOf(e) {
-    const err = e;
-    return err?.statusCode ?? err?.response?.statusCode ?? err?.body?.code;
-}
 async function listJobNames(instance, kubernetes, task) {
-    const jobs = await instance.batchApi.listNamespacedJob(kubernetes.namespace, undefined, undefined, undefined, undefined, `hammerkit.dev/id=${task.id()}`);
-    return jobs.body.items.flatMap((job) => (job.metadata?.name ? [job.metadata.name] : []));
+    const jobs = await instance.batchApi.listNamespacedJob({
+        namespace: kubernetes.namespace,
+        labelSelector: `hammerkit.dev/id=${task.id()}`,
+    });
+    return jobs.items.flatMap((job) => (job.metadata?.name ? [job.metadata.name] : []));
 }
 function kubernetesTaskRuntime(task, kubernetes) {
     const instance = (0, kubernetes_instance_1.createKubernetesInstances)(kubernetes);
@@ -128,22 +126,34 @@ function kubernetesTaskRuntime(task, kubernetes) {
             }
         },
         async stop() {
-            const jobs = await instance.batchApi.listNamespacedJob(kubernetes.namespace, undefined, undefined, undefined, undefined, `hammerkit.dev/id=${task.id()}`);
-            for (const pod of jobs.body.items) {
+            const jobs = await instance.batchApi.listNamespacedJob({
+                namespace: kubernetes.namespace,
+                labelSelector: `hammerkit.dev/id=${task.id()}`,
+            });
+            for (const pod of jobs.items) {
                 if (pod.metadata?.name) {
-                    await instance.batchApi.deleteNamespacedJob(pod.metadata.name, kubernetes.namespace);
+                    await instance.batchApi.deleteNamespacedJob({ name: pod.metadata.name, namespace: kubernetes.namespace });
                 }
             }
-            const deployments = await instance.appsApi.listNamespacedDeployment(kubernetes.namespace, undefined, undefined, undefined, undefined, `hammerkit.dev/id=${task.id()}`);
-            for (const deploy of deployments.body.items) {
+            const deployments = await instance.appsApi.listNamespacedDeployment({
+                namespace: kubernetes.namespace,
+                labelSelector: `hammerkit.dev/id=${task.id()}`,
+            });
+            for (const deploy of deployments.items) {
                 if (deploy.metadata?.name) {
-                    await instance.appsApi.deleteNamespacedDeployment(deploy.metadata.name, kubernetes.namespace);
+                    await instance.appsApi.deleteNamespacedDeployment({
+                        name: deploy.metadata.name,
+                        namespace: kubernetes.namespace,
+                    });
                 }
             }
-            const pods = await instance.coreApi.listNamespacedPod(kubernetes.namespace, undefined, undefined, undefined, undefined, `hammerkit.dev/id=${task.id()}`);
-            for (const pod of pods.body.items) {
+            const pods = await instance.coreApi.listNamespacedPod({
+                namespace: kubernetes.namespace,
+                labelSelector: `hammerkit.dev/id=${task.id()}`,
+            });
+            for (const pod of pods.items) {
                 if (pod.metadata?.name) {
-                    await instance.coreApi.deleteNamespacedPod(pod.metadata.name, kubernetes.namespace);
+                    await instance.coreApi.deleteNamespacedPod({ name: pod.metadata.name, namespace: kubernetes.namespace });
                 }
             }
         },
@@ -152,8 +162,11 @@ function kubernetesTaskRuntime(task, kubernetes) {
             await (0, remove_persistent_data_1.removePersistentData)(instance, kubernetes, task);
         },
         async currentStateKey() {
-            const jobs = await instance.batchApi.listNamespacedJob(kubernetes.namespace, undefined, undefined, undefined, undefined, `hammerkit.dev/id=${task.id()}`);
-            const completedStates = jobs.body.items
+            const jobs = await instance.batchApi.listNamespacedJob({
+                namespace: kubernetes.namespace,
+                labelSelector: `hammerkit.dev/id=${task.id()}`,
+            });
+            const completedStates = jobs.items
                 .filter((j) => j.status?.succeeded && j.metadata?.labels?.['hammerkit.dev/state'])
                 .map((j) => j.metadata.labels['hammerkit.dev/state']);
             const stateKey = completedStates[completedStates.length - 1] ?? null;
@@ -163,11 +176,14 @@ function kubernetesTaskRuntime(task, kubernetes) {
             // outputs live in the task's claim; without it the finished job left
             // nothing to reuse
             try {
-                const claim = await instance.coreApi.readNamespacedPersistentVolumeClaim((0, volumes_1.getVolumeName)(task), kubernetes.namespace);
-                return claim.body.metadata?.deletionTimestamp ? null : stateKey;
+                const claim = await instance.coreApi.readNamespacedPersistentVolumeClaim({
+                    name: (0, volumes_1.getVolumeName)(task),
+                    namespace: kubernetes.namespace,
+                });
+                return claim.metadata?.deletionTimestamp ? null : stateKey;
             }
             catch (e) {
-                if (statusCodeOf(e) === 404) {
+                if ((0, apply_1.statusCodeOf)(e) === 404) {
                     return null;
                 }
                 throw e;
@@ -189,10 +205,16 @@ function kubernetesServiceRuntime(service, kubernetes) {
             await (0, store_kubernetes_data_1.storeKubernetesData)(service, kubernetes, instance, environment, path);
         },
         async stop() {
-            const deployments = await instance.appsApi.listNamespacedDeployment(kubernetes.namespace, undefined, undefined, undefined, undefined, `hammerkit.dev/id=${service.id()}`);
-            for (const deployment of deployments.body.items) {
+            const deployments = await instance.appsApi.listNamespacedDeployment({
+                namespace: kubernetes.namespace,
+                labelSelector: `hammerkit.dev/id=${service.id()}`,
+            });
+            for (const deployment of deployments.items) {
                 if (deployment.metadata?.name) {
-                    await instance.appsApi.deleteNamespacedDeployment(deployment.metadata.name, kubernetes.namespace);
+                    await instance.appsApi.deleteNamespacedDeployment({
+                        name: deployment.metadata.name,
+                        namespace: kubernetes.namespace,
+                    });
                 }
             }
         },
@@ -209,29 +231,16 @@ function kubernetesServiceRuntime(service, kubernetes) {
                 stateKey: options.stateKey,
                 remote: null,
             });
-            const ingresses = kubernetes.ingresses.filter((i) => i.service === service.name);
-            for (const ingress of ingresses) {
-                if (ingress.kind === 'httproute') {
-                    await (0, ensure_http_route_1.ensureHttpRoute)(instance, kubernetes, ingress, service);
-                }
-                else {
-                    await (0, ensure_ingress_1.ensureIngress)(instance, kubernetes, ingress, service);
-                }
+            for (const route of kubernetes.httpRoutes.filter((r) => r.service === service.name)) {
+                await (0, ensure_http_route_1.ensureHttpRoute)(instance, kubernetes, route, service);
             }
         },
         async remove() {
-            const ingresses = await instance.networkingApi.listNamespacedIngress(kubernetes.namespace, undefined, undefined, undefined, undefined, `hammerkit.dev/id=${service.id()}`);
-            for (const ingress of ingresses.body.items) {
-                if (ingress.metadata?.name) {
-                    await instance.networkingApi.deleteNamespacedIngress(ingress.metadata.name, kubernetes.namespace);
-                }
-            }
             // HTTPRoutes are a CRD, so they are deleted by name through the generic
             // objectApi rather than listed (a list would error on clusters without the
-            // Gateway API CRDs even when none are declared). Only entries this service
-            // declared as httproute are removed; a missing route (404) is fine.
-            const httpRoutes = kubernetes.ingresses.filter((i) => i.kind === 'httproute' && i.service === service.name);
-            for (const route of httpRoutes) {
+            // Gateway API CRDs even when none are declared). Only the routes this
+            // service declares are removed; a missing route (404) is fine.
+            for (const route of kubernetes.httpRoutes.filter((r) => r.service === service.name)) {
                 try {
                     await instance.objectApi.delete({
                         apiVersion: ensure_http_route_1.HTTP_ROUTE_API_VERSION,
@@ -240,23 +249,32 @@ function kubernetesServiceRuntime(service, kubernetes) {
                     });
                 }
                 catch (e) {
-                    if (statusCodeOf(e) !== 404) {
+                    if ((0, apply_1.statusCodeOf)(e) !== 404) {
                         throw e;
                     }
                 }
             }
-            const services = await instance.coreApi.listNamespacedService(kubernetes.namespace, undefined, undefined, undefined, undefined, `hammerkit.dev/id=${service.id()}`);
-            for (const service of services.body.items) {
+            const services = await instance.coreApi.listNamespacedService({
+                namespace: kubernetes.namespace,
+                labelSelector: `hammerkit.dev/id=${service.id()}`,
+            });
+            for (const service of services.items) {
                 if (service.metadata?.name) {
-                    await instance.coreApi.deleteNamespacedService(service.metadata.name, kubernetes.namespace);
+                    await instance.coreApi.deleteNamespacedService({
+                        name: service.metadata.name,
+                        namespace: kubernetes.namespace,
+                    });
                 }
             }
             await this.stop();
             await (0, remove_persistent_data_1.removePersistentData)(instance, kubernetes, service);
         },
         async currentStateKey() {
-            const deployments = await instance.appsApi.listNamespacedDeployment(kubernetes.namespace, undefined, undefined, undefined, undefined, `hammerkit.dev/id=${service.id()}`);
-            const deployment = deployments.body.items[0];
+            const deployments = await instance.appsApi.listNamespacedDeployment({
+                namespace: kubernetes.namespace,
+                labelSelector: `hammerkit.dev/id=${service.id()}`,
+            });
+            const deployment = deployments.items[0];
             return deployment?.metadata?.labels?.['hammerkit.dev/state'] ?? null;
         },
     };

package/dist/planner/work-runtime-local.js

@@ -8,7 +8,9 @@ const tar_1 = require("tar");
 const path_1 = require("path");
 const local_task_1 = require("../executer/local-task");
 const event_cache_1 = require("../executer/event-cache");
+const get_outputs_to_reset_1 = require("./utils/get-outputs-to-reset");
 const find_process_1 = __importDefault(require("find-process"));
+const stream_1 = require("stream");
 function getStateFilename(task) {
     return (0, path_1.join)(task.data.cwd, '.hammerkit', `${task.id()}`);
 }
@@ -56,8 +58,21 @@ function getLocalWorkRuntime(task) {
             const pidFile = getPidFilename(task);
             await environment.file.writeFile(pidFile, `${process.pid}`);
             try {
+                // The record says "the outputs belong to this state key". A run that
+                // fails overwrites outputs, so the previous record goes first, and only
+                // a run that succeeded writes a new one.
+                const stateFile = getStateFilename(task);
+                if (await environment.file.exists(stateFile)) {
+                    await environment.file.remove(stateFile);
+                }
+                for (const generate of (0, get_outputs_to_reset_1.getOutputsToReset)(task.data)) {
+                    await environment.file.remove(generate.path);
+                }
                 await (0, local_task_1.localTask)(task, environment, options);
-                await environment.file.writeFile(getStateFilename(task), options.stateKey);
+                const failed = ['crash', 'error', 'canceled'].includes(options.state.current.type);
+                if (!failed) {
+                    await environment.file.writeFile(stateFile, options.stateKey);
+                }
             }
             finally {
                 if (await environment.file.exists(pidFile)) {
@@ -96,15 +111,17 @@ function getLocalWorkRuntime(task) {
 exports.getLocalWorkRuntime = getLocalWorkRuntime;
 async function archiveLocal(environment, task, path) {
     for (const generatedArchive of (0, event_cache_1.getArchivePaths)(task.data, path)) {
-        await environment.file.writeStream(generatedArchive.filename, (0, tar_1.create)({
-            cwd: task.data.cwd,
-            gzip: true,
-        }, [(0, path_1.relative)(task.data.cwd, generatedArchive.path)]));
+        await environment.file.writeStream(generatedArchive.filename, 
+        // tar's stream is a Minipass stream; Readable.from adapts it to a Node one
+        stream_1.Readable.from((0, tar_1.create)({ cwd: task.data.cwd, gzip: true }, [(0, path_1.relative)(task.data.cwd, generatedArchive.path)])));
     }
 }
 async function restoreLocal(environment, task, path) {
     for (const generate of (0, event_cache_1.getArchivePaths)(task, path)) {
         if (await environment.file.exists(generate.filename)) {
+            // a cache hit means exactly the stored outputs: whatever a failed or
+            // older run left in the folder goes first
+            await environment.file.remove(generate.path);
             await (0, tar_1.extract)({
                 file: generate.filename,
                 cwd: task.cwd,

package/dist/schema/build-file-environment-schema-http-route.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFileEnvironmentSchemaHttpRoute = void 0;
+const zod_1 = require("zod");
+// A Gateway API HTTPRoute exposing a service of the environment under a hostname.
+exports.buildFileEnvironmentSchemaHttpRoute = (0, zod_1.object)({
+    host: (0, zod_1.string)(),
+    service: (0, zod_1.string)(),
+    servicePort: (0, zod_1.number)().optional(),
+    path: (0, zod_1.string)().optional(),
+    // the parent Gateway the route attaches to
+    gateway: (0, zod_1.string)(),
+    gatewayNamespace: (0, zod_1.string)().optional(),
+}).strict();
+//# sourceMappingURL=build-file-environment-schema-http-route.js.map

package/dist/schema/build-file-environment-schema.js

@@ -2,12 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildFileEnvironmentSchema = exports.buildFileDockerEnvironmentSchema = exports.buildFileKubernetesEnvironmentSchema = void 0;
 const zod_1 = require("zod");
-const build_file_environment_schema_ingress_1 = require("./build-file-environment-schema-ingress");
+const build_file_environment_schema_http_route_1 = require("./build-file-environment-schema-http-route");
 exports.buildFileKubernetesEnvironmentSchema = (0, zod_1.object)({
     namespace: (0, zod_1.string)().optional(),
     context: (0, zod_1.string)(),
     kubeconfig: (0, zod_1.string)().optional(),
-    ingresses: (0, zod_1.array)(build_file_environment_schema_ingress_1.buildFileEnvironmentSchemaIngress).optional(),
+    httpRoutes: (0, zod_1.array)(build_file_environment_schema_http_route_1.buildFileEnvironmentSchemaHttpRoute).optional(),
+    // Ingress support was removed in 1.8.0. Fail instead of dropping the routes.
+    ingresses: (0, zod_1.never)({
+        errorMap: () => ({
+            message: 'ingresses were removed in 1.8.0: declare Gateway API routes under httpRoutes, each with a gateway',
+        }),
+    }).optional(),
 });
 exports.buildFileDockerEnvironmentSchema = (0, zod_1.object)({
     host: (0, zod_1.string)().optional(),

package/dist/schema/build-file-schema.js

@@ -19,5 +19,5 @@ exports.buildFileSchema = (0, zod_1.object)({
     labels: labels_schema_1.labelsSchema.optional(),
 })
     .strict()
-    .describe('Build file with support for containerization\nhttps://no0dles.gitbook.io/hammerkit/build-file');
+    .describe('Build file with support for containerization\nhttps://hammerkit.dev/docs/build-file');
 //# sourceMappingURL=build-file-schema.js.map

package/dist/schema/envs-schema.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.envsSchema = void 0;
 const zod_1 = require("zod");
-exports.envsSchema = (0, zod_1.record)((0, zod_1.union)([(0, zod_1.string)(), (0, zod_1.number)()])).describe('Environment values for the current build task\nhttps://no0dles.gitbook.io/hammerkit/build-file/environment-variables');
+exports.envsSchema = (0, zod_1.record)((0, zod_1.union)([(0, zod_1.string)(), (0, zod_1.number)()])).describe('Environment values for the current build task\nhttps://hammerkit.dev/docs/build-file/environment-variables');
 //# sourceMappingURL=envs-schema.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hammerkit",
   "description": "Containerized build tool with incremental caching that runs the same build file locally, in Docker and on Kubernetes.",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "keywords": [
     "build",
     "build-tool",
@@ -12,7 +12,7 @@
     "monorepo",
     "task-runner"
   ],
-  "homepage": "https://no0dles.gitbook.io/hammerkit/",
+  "homepage": "https://hammerkit.dev",
   "bin": "dist/index.js",
   "files": [
     "dist",
@@ -47,15 +47,15 @@
   },
   "dependencies": {
     "@aws-sdk/client-s3": "^3.470.0",
-    "@kubernetes/client-node": "^0.20.0",
-    "chokidar": "^3.5.3",
+    "@kubernetes/client-node": "^2.0.0",
+    "chokidar": "^3.6.0",
     "colors": "^1.4.0",
     "commander": "^11.1.0",
-    "dockerode": "^4.0.2",
+    "dockerode": "^4.0.12",
     "find-process": "^1.4.7",
-    "minimatch": "^6.1.5",
-    "tar": "^6.2.0",
-    "yaml": "^2.3.4",
+    "minimatch": "^6.2.3",
+    "tar": "^7.5.22",
+    "yaml": "^2.9.1",
     "zod": "^3.22.4"
   },
   "devDependencies": {
@@ -64,7 +64,7 @@
     "@types/dockerode": "^3.3.23",
     "@types/minimatch": "^5.1.2",
     "@types/node": "^24.0.0",
-    "@types/tar": "^6.1.3",
+    "@types/ws": "^8.18.2",
     "@typescript-eslint/eslint-plugin": "^6.16.0",
     "@typescript-eslint/parser": "^6.16.0",
     "@vitest/coverage-istanbul": "^2.1.8",

package/dist/kubernetes/ensure-ingress.js

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ensureIngress = void 0;
-const apply_1 = require("./apply");
-const resources_1 = require("./resources");
-async function ensureIngress(instance, env, ingress, service) {
-    const resource = {
-        kind: 'Ingress',
-        apiVersion: 'networking.k8s.io/v1',
-        metadata: {
-            name: ingress.host,
-            namespace: env.namespace,
-            annotations: {
-                'cert-manager.io/cluster-issuer': 'hammerkit-issuer',
-            },
-            labels: {
-                'hammerkit.dev/id': service.id(),
-            },
-        },
-        spec: {
-            ingressClassName: 'nginx',
-            rules: [
-                {
-                    host: ingress.host,
-                    http: {
-                        paths: [
-                            {
-                                path: ingress.path ?? '/',
-                                pathType: 'Prefix',
-                                backend: {
-                                    service: {
-                                        name: (0, resources_1.getResourceName)(service),
-                                        port: {
-                                            number: ingress.servicePort ?? service.data.ports[0].containerPort,
-                                        },
-                                    },
-                                },
-                            },
-                        ],
-                    },
-                },
-            ],
-            tls: [
-                {
-                    secretName: `${ingress.host}-tls`,
-                    hosts: [ingress.host],
-                },
-            ],
-        },
-    };
-    return await (0, apply_1.apply)(instance, resource);
-}
-exports.ensureIngress = ensureIngress;
-//# sourceMappingURL=ensure-ingress.js.map

package/dist/schema/build-file-environment-schema-ingress.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildFileEnvironmentSchemaIngress = void 0;
-const zod_1 = require("zod");
-exports.buildFileEnvironmentSchemaIngress = (0, zod_1.object)({
-    kind: zod_1.z.enum(['ingress', 'httproute']).optional(),
-    host: (0, zod_1.string)(),
-    service: (0, zod_1.string)(),
-    servicePort: (0, zod_1.number)().optional(),
-    path: (0, zod_1.string)().optional(),
-    gateway: (0, zod_1.string)().optional(),
-    gatewayNamespace: (0, zod_1.string)().optional(),
-}).strict();
-//# sourceMappingURL=build-file-environment-schema-ingress.js.map