hammerkit 1.6.0 → 1.8.0

package/dist/executer/run-summary.js

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

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

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

package/dist/executer/scheduler/state-key.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeStateKey = exports.combineStateKeys = exports.resolveEffective = void 0;
+const crypto_1 = require("crypto");
+const get_work_cache_stats_1 = require("../../optimizer/get-work-cache-stats");
+// The state-key engine is shared by the scheduler's hit/miss decision
+// (`checkCacheState`) and the read-only cache-explain engine, so a prediction
+// can never diverge from the decision it predicts — there is one implementation.
+function resolveEffective(item, fallbackMethod) {
+    const declared = item.data.caching;
+    if (declared.implicit) {
+        return { ...declared, method: fallbackMethod };
+    }
+    return declared;
+}
+exports.resolveEffective = resolveEffective;
+// A task whose inputs cannot be observed cannot be proven up to date, so it
+// always runs, and so does everything depending on it (specs/task SC-001). That
+// is a task that declares no `src` of its own — the sources it inherits from its
+// dependencies say nothing about the files its own commands read — and a task
+// whose `src` entries all match no file (a typo, a moved path). Services are not
+// affected.
+function isOwnProvable(item, unmatched) {
+    // unmatched ⊆ declared, so this is also false when nothing is declared
+    return unmatched.length < item.data.src.filter((src) => !src.inherited).length;
+}
+// Fold a task's own state key together with the state keys of its dependencies.
+// A change anywhere in the dependency subtree must change the resulting key, so
+// that a downstream task is invalidated when an upstream source changes — even
+// if the downstream task's own sources are untouched.
+function combineStateKeys(ownKey, depKeys) {
+    if (depKeys.length === 0) {
+        return ownKey;
+    }
+    // Sort so the key is independent of dependency declaration order.
+    const sorted = [...depKeys].sort();
+    return (0, crypto_1.createHash)('md5')
+        .update([ownKey, ...sorted].join(','))
+        .digest('hex');
+}
+exports.combineStateKeys = combineStateKeys;
+// `none` only disables the cache *check* for a task; its sources still influence
+// what depends on it, so a concrete method is always used for the hash itself.
+function concreteMethod(resolved, defaultCacheMethod) {
+    return resolved.method === 'none' ? defaultCacheMethod : resolved.method;
+}
+// Compute an item's effective state key from its source files plus the effective
+// state keys of its dependencies, recursively. This is derived purely from the
+// work tree and the filesystem, so it does not depend on scheduler/run state —
+// important because it runs before dependencies are awaited.
+async function resolveEffectiveStateKey(item, defaultCacheMethod, environment, memo) {
+    const existing = memo.get(item.id());
+    if (existing !== undefined) {
+        return existing;
+    }
+    const { stateKey, provable } = await computeStateKey(item, defaultCacheMethod, environment, memo);
+    const effective = { stateKey, provable };
+    memo.set(item.id(), effective);
+    return effective;
+}
+// Compute the combined state key for a single item together with the source
+// stats it was derived from, sharing one filesystem walk with callers that also
+// need the stats (the scheduler, the explain engine).
+async function computeStateKey(item, defaultCacheMethod, environment, memo = new Map()) {
+    const resolved = resolveEffective(item, defaultCacheMethod);
+    const { stats, unmatched } = await (0, get_work_cache_stats_1.getWorkItemCacheStats)(item, environment);
+    const ownKey = (0, get_work_cache_stats_1.getStateKey)(stats, concreteMethod(resolved, defaultCacheMethod));
+    const depKeys = [];
+    let provable = isOwnProvable(item, unmatched);
+    for (const dep of item.deps) {
+        const effective = await resolveEffectiveStateKey(dep, defaultCacheMethod, environment, memo);
+        depKeys.push(effective.stateKey);
+        provable = provable && effective.provable;
+    }
+    return { stateKey: combineStateKeys(ownKey, depKeys), stats, resolved, provable, unmatched };
+}
+exports.computeStateKey = computeStateKey;
+//# sourceMappingURL=state-key.js.map

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

@@ -1,71 +1,111 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.awaitDeployRunningState = exports.awaitJobState = exports.awaitRunningState = void 0;
-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();
-            }
-        });
-    });
+exports.deleteJobAndWait = exports.awaitDeployRunningState = exports.deleteJob = exports.awaitJobCompletion = exports.awaitRunningState = void 0;
+const abort_1 = require("../executer/abort");
+const abort_event_1 = require("../utils/abort-event");
+const apply_1 = require("./apply");
+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;
-function awaitJobState(instance, env, name) {
-    return new Promise((resolve, reject) => {
-        const req = instance.watch.watch(`/apis/batch/v1/namespaces/${env.namespace}/jobs/${name}`, {}, (type, obj) => {
-            if (obj && obj.metadata?.name === name && obj.metadata?.namespace === env.namespace && obj.status?.succeeded) {
-                req.then((r) => r.abort());
-                resolve();
-            }
-        }, (err) => {
-            if (err && err.message === 'aborted') {
-                return;
-            }
-            if (err) {
-                reject(err);
-            }
-            else {
-                resolve();
-            }
+// Wait for a job to finish by polling its status: resolves once it succeeded,
+// rejects when it failed (its `Failed` condition, i.e. retries are exhausted).
+// On abort the job is deleted — with its pods — and an AbortError is thrown, so
+// a cancelled or timed-out task leaves nothing running on the cluster.
+async function awaitJobCompletion(instance, env, name, abort, pollInterval = 1000) {
+    for (;;) {
+        if (abort.aborted) {
+            await deleteJob(instance, env, name);
+            throw new abort_1.AbortError();
+        }
+        const job = await instance.batchApi.readNamespacedJobStatus({ name, namespace: env.namespace });
+        const status = job.status;
+        if (status?.succeeded) {
+            return;
+        }
+        const failed = status?.conditions?.find((c) => c.type === 'Failed' && c.status === 'True');
+        if (failed) {
+            throw new Error(`job ${name} failed: ${failed.message ?? failed.reason ?? 'unknown reason'}`);
+        }
+        await sleep(pollInterval, abort);
+    }
+}
+exports.awaitJobCompletion = awaitJobCompletion;
+function sleep(ms, abort) {
+    if (abort.aborted) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+        const timer = setTimeout(() => {
+            listener.close();
+            resolve();
+        }, ms);
+        // not aborted yet, so this callback can only fire later, after assignment
+        const listener = (0, abort_event_1.listenOnAbort)(abort, () => {
+            clearTimeout(timer);
+            resolve();
         });
     });
 }
-exports.awaitJobState = awaitJobState;
-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 deleteJob(instance, env, name) {
+    try {
+        await instance.batchApi.deleteNamespacedJob({
+            name,
+            namespace: env.namespace,
+            gracePeriodSeconds: 0,
+            propagationPolicy: 'Background',
         });
-    });
+    }
+    catch (e) {
+        if ((0, apply_1.statusCodeOf)(e) !== 404) {
+            throw e;
+        }
+    }
+}
+exports.deleteJob = deleteJob;
+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
+// command (and the next run with the same state), and creating it while the old
+// one is still being deleted would pick up the old job.
+async function deleteJobAndWait(instance, env, name, abort, pollInterval = 500) {
+    await deleteJob(instance, env, name);
+    for (;;) {
+        try {
+            await instance.batchApi.readNamespacedJob({ name, namespace: env.namespace });
+        }
+        catch (e) {
+            if ((0, apply_1.statusCodeOf)(e) === 404) {
+                return;
+            }
+            throw e;
+        }
+        if (abort.aborted) {
+            throw new abort_1.AbortError();
+        }
+        await sleep(pollInterval, abort);
+    }
+}
+exports.deleteJobAndWait = deleteJobAndWait;
 //# sourceMappingURL=await-running-state.js.map

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