hammerkit 1.5.1 → 1.6.0-alpha.1

package/dist/executer/state.spec.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const state_1 = require("./state");
+describe('State', () => {
+    it('exposes the initial value via `current`', () => {
+        const s = new state_1.State(7);
+        expect(s.current).toBe(7);
+    });
+    it('set() updates current and returns the new value', () => {
+        const s = new state_1.State(0);
+        expect(s.set(3)).toBe(3);
+        expect(s.current).toBe(3);
+    });
+    it('notifies every registered listener on set()', () => {
+        const s = new state_1.State(0);
+        const a = vi.fn();
+        const b = vi.fn();
+        s.on('a', a);
+        s.on('b', b);
+        s.set(1);
+        expect(a).toHaveBeenCalledWith(1);
+        expect(b).toHaveBeenCalledWith(1);
+    });
+    it('close() on a listener handle stops further notifications', () => {
+        const s = new state_1.State(0);
+        const cb = vi.fn();
+        const handle = s.on('k', cb);
+        handle.close();
+        s.set(1);
+        expect(cb).not.toHaveBeenCalled();
+    });
+    it('close() on an already-removed listener is a no-op', () => {
+        const s = new state_1.State(0);
+        const handle = s.on('k', vi.fn());
+        handle.close();
+        expect(() => handle.close()).not.toThrow();
+    });
+    it('forwards sub-state changes to its own listeners', () => {
+        const sub = new state_1.State(0);
+        const parent = new state_1.State('p', { subStates: [sub] });
+        const cb = vi.fn();
+        parent.on('any', cb);
+        // emit a 'sub-state-forward' on the sub-state to trigger parent notification
+        sub.set(1); // sub.set notifies its listeners under whatever keys are registered
+        // The parent registered for 'sub-state-forward' on the sub; sub.set calls
+        // notifyListeners which dispatches to all listeners regardless of key, so
+        // the parent's forwarding listener fires and notifies parent listeners.
+        expect(cb).toHaveBeenCalledWith('p');
+    });
+    it('close() runs the onDestroy callback', () => {
+        const onDestroy = vi.fn();
+        const s = new state_1.State(0, { onDestroy });
+        s.close();
+        expect(onDestroy).toHaveBeenCalledTimes(1);
+    });
+    it('close() detaches sub-state forwarders', () => {
+        const sub = new state_1.State(0);
+        const parent = new state_1.State('p', { subStates: [sub] });
+        const cb = vi.fn();
+        parent.on('any', cb);
+        parent.close();
+        sub.set(1);
+        expect(cb).not.toHaveBeenCalled();
+    });
+});
+//# sourceMappingURL=state.spec.js.map

package/dist/executer/states.spec.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const states_1 = require("./states");
+describe('getDuration', () => {
+    it('returns the milliseconds elapsed since the given start date', () => {
+        const started = new Date(Date.now() - 250);
+        const d = (0, states_1.getDuration)(started);
+        expect(d).toBeGreaterThanOrEqual(250);
+    });
+    it('returns 0 (or very small) for a start date that is essentially now', () => {
+        expect((0, states_1.getDuration)(new Date())).toBeGreaterThanOrEqual(0);
+    });
+});
+//# sourceMappingURL=states.spec.js.map

package/dist/executer/watch-loop.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.watchLoop = void 0;
+const watch_state_key_1 = require("./watch-state-key");
+const state_1 = require("./state");
+const abort_event_1 = require("../utils/abort-event");
+const state_resolver_1 = require("./state-resolver");
+const abort_1 = require("./abort");
+const enqueue_next_1 = require("./scheduler/enqueue-next");
+async function watchLoop(work, environment, options, factory) {
+    const currentStats = await (0, enqueue_next_1.checkCacheState)(work, options.cacheDefault, environment);
+    (0, abort_1.checkForAbort)(environment.abortCtrl.signal);
+    // continuous lives on container-services and on tasks (both task types); a
+    // kubernetes-service has no such field. Read it wherever it exists.
+    const continuous = 'continuous' in work.data ? work.data.continuous : false;
+    const watchMode = options.watch && !options.daemon && !continuous;
+    const watchState = watchMode
+        ? (0, watch_state_key_1.watchStateKey)(work, currentStats, environment, options)
+        : new state_1.State(currentStats);
+    let currentRun = {
+        abortController: new AbortController(),
+        cacheState: watchState.current,
+    };
+    if (watchMode) {
+        watchState.on('state-key', (cacheState) => {
+            work.status.write('debug', 'sources changed, abort current run');
+            currentRun.abortController.abort();
+            currentRun = {
+                abortController: new AbortController(),
+                cacheState,
+            };
+        });
+    }
+    const abortListener = (0, abort_event_1.listenOnAbort)(environment.abortCtrl.signal, () => {
+        currentRun.abortController.abort();
+        watchState.close();
+    });
+    do {
+        const currentState = watchState.current;
+        try {
+            await factory(currentState, currentRun.abortController.signal, () => {
+                currentRun.abortController.abort();
+            });
+        }
+        catch (e) {
+            if (e instanceof abort_1.AbortError) {
+                work.state.set({
+                    type: 'canceled',
+                    stateKey: currentState.stateKey,
+                });
+            }
+            else {
+                throw e;
+            }
+        }
+        if (!watchMode) {
+            break;
+        }
+        if (currentState.stateKey !== watchState.current.stateKey) {
+            continue;
+        }
+        await (0, state_resolver_1.untilChanged)('watch-source-change', watchState, environment.abortCtrl.signal);
+        work.status.write('debug', 'sources changed');
+    } while (watchMode);
+    abortListener.close();
+}
+exports.watchLoop = watchLoop;
+//# sourceMappingURL=watch-loop.js.map

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.watchStateKey = void 0;
+const debouncer_1 = require("../utils/debouncer");
+const path_1 = require("path");
+const state_1 = require("./state");
+const enqueue_next_1 = require("./scheduler/enqueue-next");
+function watchStateKey(item, cacheStats, environment, options) {
+    const fileWatchers = [];
+    const state = new state_1.State(cacheStats, {
+        onDestroy: () => {
+            for (const fileWatcher of fileWatchers) {
+                fileWatcher.close();
+            }
+            debouncer.clear();
+        },
+    });
+    const debouncer = new debouncer_1.Debouncer(async () => {
+        if (environment.abortCtrl.signal.aborted) {
+            return;
+        }
+        const cacheState = await (0, enqueue_next_1.checkCacheState)(item, options.cacheDefault, environment);
+        if (state.current.stateKey !== cacheState.stateKey) {
+            state.set(cacheState);
+        }
+    }, 100);
+    for (const src of item.data.src) {
+        if (src.inherited) {
+            continue;
+        }
+        item.status.write('debug', `watch ${src.absolutePath} source`);
+        const watcher = environment.file.watch(src.absolutePath, async (fileName) => {
+            const absoluteFileName = (0, path_1.join)(src.absolutePath, fileName);
+            if (src.matcher(absoluteFileName, item.data.cwd)) {
+                item.status.write('debug', `source ${absoluteFileName} change for watched task ${item.name}`);
+                debouncer.bounce();
+            }
+        });
+        fileWatchers.push(watcher);
+    }
+    return state;
+}
+exports.watchStateKey = watchStateKey;
+//# sourceMappingURL=watch-state-key.js.map

package/dist/executer/work-scope.js

@@ -1,10 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isContextTaskFilter = exports.emptyWorkLabelScope = void 0;
-function emptyWorkLabelScope() {
-    return { excludeLabels: {}, filterLabels: {} };
-}
-exports.emptyWorkLabelScope = emptyWorkLabelScope;
+exports.isContextTaskFilter = void 0;
 const isContextTaskFilter = (target) => 'taskName' in target;
 exports.isContextTaskFilter = isContextTaskFilter;
 //# sourceMappingURL=work-scope.js.map

package/dist/file/get-file-context.js

@@ -5,6 +5,8 @@ const fs_1 = require("fs");
 const path_1 = require("path");
 const chokidar_1 = require("chokidar");
 function handleCallback(callback) {
+    //function handleCallback(callback: (cb: (err: Error | null) => void) => void): Promise<void>
+    //function handleCallback(callback: (cb: (err: Error | null, value?: any) => void) => void): Promise<any> {
     return new Promise((resolve, reject) => {
         callback((err, value) => {
             if (err) {
@@ -61,6 +63,9 @@ function getFileContext(cwd) {
                     .on('close', () => resolve());
             });
         },
+        createWriteStream(path) {
+            return (0, fs_1.createWriteStream)(path);
+        },
         listFiles(path) {
             return handleCallback((cb) => (0, fs_1.readdir)(getAbsolutePath(cwd, path), cb));
         },
@@ -116,11 +121,27 @@ function getFileContext(cwd) {
         async remove(path) {
             const absolutePath = getAbsolutePath(cwd, path);
             if (await this.exists(absolutePath)) {
-                return handleCallback((cb) => (0, fs_1.rm)(absolutePath, { recursive: true }, cb));
+                // On Windows a file/dir can briefly stay locked after a watcher or
+                // process releases it, making rmdir fail with EBUSY/EPERM. Node's
+                // built-in retry handles exactly those transient errors.
+                return handleCallback((cb) => (0, fs_1.rm)(absolutePath, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 }, cb));
             }
         },
         watch(path, callback) {
-            const watcher = (0, chokidar_1.watch)(getAbsolutePath(cwd, path));
+            // Native fs events are unreliable on virtual filesystems and frequently
+            // miss single-file changes. This bites two platforms:
+            //   - Windows CI, and
+            //   - macOS + Docker Desktop, whose gRPC-FUSE/virtiofs share does not emit
+            //     host FSEvents for files a *container* writes through a bind mount.
+            // The latter silently breaks --watch cascades between container tasks (a
+            // dependency regenerates an output but the dependent's watcher never
+            // fires). Poll on both so changes are detected deterministically regardless
+            // of who wrote the file. HAMMERKIT_WATCH_POLLING=true|false overrides the
+            // default (e.g. to force native events on a fast local FS).
+            const usePolling = process.env.HAMMERKIT_WATCH_POLLING !== undefined
+                ? process.env.HAMMERKIT_WATCH_POLLING === 'true'
+                : process.platform === 'win32' || process.platform === 'darwin';
+            const watcher = (0, chokidar_1.watch)(getAbsolutePath(cwd, path), { usePolling });
             watcher.on('add', (fileName) => {
                 callback(fileName);
             });
@@ -132,7 +153,7 @@ function getFileContext(cwd) {
             });
             return {
                 close() {
-                    watcher.close();
+                    return watcher.close();
                 },
             };
         },

package/dist/file/get-file-context.spec.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const os_1 = require("os");
+const fs_1 = require("fs");
+const stream_1 = require("stream");
+const get_file_context_1 = require("./get-file-context");
+describe('getFileContext', () => {
+    let cwd;
+    beforeEach(() => {
+        cwd = (0, fs_1.mkdtempSync)((0, path_1.join)((0, os_1.tmpdir)(), 'hammerkit-fc-'));
+    });
+    afterEach(() => {
+        // maxRetries handles Windows' transient ENOTEMPTY/EBUSY when a handle is
+        // released a beat after the test ends (mirrors getFileContext.remove). The
+        // stream tests below also await 'close' so this is only a safety net.
+        (0, fs_1.rmSync)(cwd, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+    });
+    describe('stats', () => {
+        it('reports type "directory" for a directory', async () => {
+            const fc = (0, get_file_context_1.getFileContext)(cwd);
+            expect((await fc.stats('.')).type).toBe('directory');
+        });
+        it('reports type "file" with lastModified for a regular file', async () => {
+            (0, fs_1.writeFileSync)((0, path_1.join)(cwd, 'a.txt'), 'x');
+            const fc = (0, get_file_context_1.getFileContext)(cwd);
+            const s = await fc.stats('a.txt');
+            expect(s.type).toBe('file');
+            if (s.type === 'file') {
+                expect(s.lastModified).toBeGreaterThan(0);
+            }
+        });
+        it('rejects when the path does not exist', async () => {
+            const fc = (0, get_file_context_1.getFileContext)(cwd);
+            await expect(fc.stats('missing')).rejects.toThrow();
+        });
+        it('reports type "other" for non-file non-directory entries (symlink to missing)', async () => {
+            const link = (0, path_1.join)(cwd, 'link');
+            try {
+                (0, fs_1.symlinkSync)('/no/such/target', link);
+            }
+            catch {
+                // symlink may not be permitted on this platform — accept either outcome
+                return;
+            }
+            // statSync (used by stats()) follows symlinks; if the target is missing it errors.
+            // That is the existing behavior; we cover the rejection path here.
+            const fc = (0, get_file_context_1.getFileContext)(cwd);
+            await expect(fc.stats('link')).rejects.toThrow();
+        });
+    });
+    describe('exists', () => {
+        it('resolves true for an existing path and false otherwise', async () => {
+            const fc = (0, get_file_context_1.getFileContext)(cwd);
+            expect(await fc.exists('.')).toBe(true);
+            expect(await fc.exists('nope')).toBe(false);
+        });
+    });
+    describe('writeFile / read / appendFile', () => {
+        it('writes, reads, and appends file content', async () => {
+            const fc = (0, get_file_context_1.getFileContext)(cwd);
+            await fc.writeFile('f.txt', 'hello');
+            expect(await fc.read('f.txt')).toBe('hello');
+            await fc.appendFile('f.txt', ' world');
+            expect(await fc.read('f.txt')).toBe('hello world');
+        });
+        it('read rejects on missing file', async () => {
+            const fc = (0, get_file_context_1.getFileContext)(cwd);
+            await expect(fc.read('missing.txt')).rejects.toThrow();
+        });
+    });
+    describe('listFiles', () => {
+        it('returns the entries in a directory', async () => {
+            (0, fs_1.writeFileSync)((0, path_1.join)(cwd, 'a'), '');
+            (0, fs_1.writeFileSync)((0, path_1.join)(cwd, 'b'), '');
+            const fc = (0, get_file_context_1.getFileContext)(cwd);
+            expect((await fc.listFiles('.')).sort()).toEqual(['a', 'b']);
+        });
+    });
+    describe('createDirectory / remove', () => {
+        it('creates a directory recursively and removes it', async () => {
+            const fc = (0, get_file_context_1.getFileContext)(cwd);
+            await fc.createDirectory((0, path_1.join)('deep', 'inner'));
+            expect(await fc.exists((0, path_1.join)('deep', 'inner'))).toBe(true);
+            await fc.remove('deep');
+            expect(await fc.exists('deep')).toBe(false);
+        });
+        it('remove on a missing path is a no-op', async () => {
+            const fc = (0, get_file_context_1.getFileContext)(cwd);
+            await expect(fc.remove('nope')).resolves.toBeUndefined();
+        });
+    });
+    describe('copy', () => {
+        it('copies a file, creating the destination directory if needed', async () => {
+            const fc = (0, get_file_context_1.getFileContext)(cwd);
+            await fc.writeFile('src.txt', 'data');
+            await fc.copy('src.txt', (0, path_1.join)('dest', 'src.txt'));
+            expect((0, fs_1.readFileSync)((0, path_1.join)(cwd, 'dest', 'src.txt'), 'utf8')).toBe('data');
+        });
+        it('copies a directory recursively', async () => {
+            const fc = (0, get_file_context_1.getFileContext)(cwd);
+            (0, fs_1.mkdirSync)((0, path_1.join)(cwd, 'src', 'sub'), { recursive: true });
+            (0, fs_1.writeFileSync)((0, path_1.join)(cwd, 'src', 'a.txt'), 'a');
+            (0, fs_1.writeFileSync)((0, path_1.join)(cwd, 'src', 'sub', 'b.txt'), 'b');
+            await fc.copy('src', 'dest');
+            expect((0, fs_1.readFileSync)((0, path_1.join)(cwd, 'dest', 'a.txt'), 'utf8')).toBe('a');
+            expect((0, fs_1.readFileSync)((0, path_1.join)(cwd, 'dest', 'sub', 'b.txt'), 'utf8')).toBe('b');
+        });
+        it('copy of a missing source is a no-op', async () => {
+            const fc = (0, get_file_context_1.getFileContext)(cwd);
+            await expect(fc.copy('nope', 'dest')).resolves.toBeUndefined();
+            expect((0, fs_1.statSync)((0, path_1.join)(cwd))).toBeDefined(); // cwd still exists
+        });
+        it('copy preserves the destination directory when it already exists', async () => {
+            const fc = (0, get_file_context_1.getFileContext)(cwd);
+            await fc.writeFile('src.txt', 'x');
+            (0, fs_1.mkdirSync)((0, path_1.join)(cwd, 'dest'));
+            await fc.copy('src.txt', (0, path_1.join)('dest', 'src.txt'));
+            expect((0, fs_1.readFileSync)((0, path_1.join)(cwd, 'dest', 'src.txt'), 'utf8')).toBe('x');
+        });
+    });
+    describe('streams', () => {
+        it('writeStream pipes a Readable into a file', async () => {
+            const fc = (0, get_file_context_1.getFileContext)(cwd);
+            const target = (0, path_1.join)(cwd, 'out.bin');
+            await fc.writeStream(target, stream_1.Readable.from(['part-a', 'part-b']));
+            expect((0, fs_1.readFileSync)(target, 'utf8')).toBe('part-apart-b');
+        });
+        it('createWriteStream returns a writable stream', async () => {
+            const fc = (0, get_file_context_1.getFileContext)(cwd);
+            const target = (0, path_1.join)(cwd, 'wstream.txt');
+            const ws = fc.createWriteStream(target);
+            // Wait for 'close' (fd released), not just the end/'finish' callback (data
+            // flushed): on Windows an open write handle locks the file, so the afterEach
+            // rmSync would race it and fail with ENOTEMPTY.
+            await new Promise((resolve, reject) => {
+                ws.on('error', reject);
+                ws.on('close', () => resolve());
+                ws.end('payload');
+            });
+            expect((0, fs_1.readFileSync)(target, 'utf8')).toBe('payload');
+        });
+        it('readStream reads back what writeStream wrote', async () => {
+            const fc = (0, get_file_context_1.getFileContext)(cwd);
+            const target = (0, path_1.join)(cwd, 'r.txt');
+            (0, fs_1.writeFileSync)(target, 'abc');
+            const chunks = [];
+            await new Promise((resolve, reject) => {
+                const rs = fc.readStream(target);
+                rs.on('data', (c) => chunks.push(c));
+                rs.on('error', reject);
+                // 'close' (fd released) fires after 'end'; wait for it so an open read
+                // handle can't block the afterEach cleanup on Windows.
+                rs.on('close', resolve);
+            });
+            expect(Buffer.concat(chunks).toString()).toBe('abc');
+        });
+    });
+    describe('watch', () => {
+        it('returns a handle whose close() is callable; the polling override is honored', async () => {
+            const previous = process.env.HAMMERKIT_WATCH_POLLING;
+            process.env.HAMMERKIT_WATCH_POLLING = 'false';
+            try {
+                const fc = (0, get_file_context_1.getFileContext)(cwd);
+                const handle = fc.watch('.', () => undefined);
+                // close() returns a Promise on chokidar; await it
+                await Promise.resolve(handle.close());
+            }
+            finally {
+                if (previous === undefined)
+                    delete process.env.HAMMERKIT_WATCH_POLLING;
+                else
+                    process.env.HAMMERKIT_WATCH_POLLING = previous;
+            }
+        });
+    });
+});
+//# sourceMappingURL=get-file-context.spec.js.map

package/dist/file/move-files.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.moveFiles = void 0;
-async function moveFiles(node, context, folder) {
+async function moveFiles(item, context, folder) {
     const foldersToCopy = [];
     const addFolder = async (from, to) => {
         if (!(await context.file.exists(from))) {
@@ -19,7 +19,7 @@ async function moveFiles(node, context, folder) {
         if (await context.file.exists(folder.to)) {
             await context.file.remove(folder.to);
         }
-        context.status.task(node).write('debug', `copy ${folder.from} to ${folder.to}`);
+        item.status.write('debug', `copy ${folder.from} to ${folder.to}`);
         await context.file.copy(folder.from, folder.to);
     }
 }

package/dist/file/move-files.spec.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const move_files_1 = require("./move-files");
+function context(existing) {
+    const remove = vi.fn(async () => undefined);
+    const copy = vi.fn(async () => undefined);
+    const env = {
+        file: {
+            exists: vi.fn(async (p) => existing.includes(p)),
+            remove,
+            copy,
+        },
+    };
+    return { env, remove, copy };
+}
+const item = { status: { write: vi.fn() } };
+function* once(from, to) {
+    yield { from, to };
+}
+describe('move-files', () => {
+    it('copies an existing folder and removes a pre-existing target first', async () => {
+        const { env, remove, copy } = context(['/a', '/out/a']);
+        await (0, move_files_1.moveFiles)(item, env, () => once('/a', '/out/a'));
+        expect(remove).toHaveBeenCalledWith('/out/a');
+        expect(copy).toHaveBeenCalledWith('/a', '/out/a');
+    });
+    it('does not remove the target when it does not exist yet', async () => {
+        const { env, remove, copy } = context(['/a']);
+        await (0, move_files_1.moveFiles)(item, env, () => once('/a', '/out/a'));
+        expect(remove).not.toHaveBeenCalled();
+        expect(copy).toHaveBeenCalledWith('/a', '/out/a');
+    });
+    it('skips folders whose source does not exist', async () => {
+        const { env, copy } = context([]);
+        await (0, move_files_1.moveFiles)(item, env, () => once('/missing', '/out/m'));
+        expect(copy).not.toHaveBeenCalled();
+    });
+    it('dedupes identical from/to pairs', async () => {
+        const { env, copy } = context(['/a']);
+        function* twice() {
+            yield { from: '/a', to: '/out/a' };
+            yield { from: '/a', to: '/out/a' };
+        }
+        await (0, move_files_1.moveFiles)(item, env, twice);
+        expect(copy).toHaveBeenCalledTimes(1);
+    });
+});
+//# sourceMappingURL=move-files.spec.js.map

package/dist/index.js

@@ -1,27 +1,26 @@
 #!/usr/bin/env node
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const program_1 = require("./program");
 const log_1 = require("./log");
 const get_file_context_1 = require("./file/get-file-context");
-const work_node_status_1 = require("./planner/work-node-status");
-const execute_docker_1 = require("./executer/execute-docker");
+const work_item_status_1 = require("./planner/work-item-status");
 const empty_writable_1 = require("./utils/empty-writable");
+const run_program_1 = require("./run-program");
 const abortCtrl = new AbortController();
 process.on('SIGINT', function () {
     abortCtrl.abort();
 });
-(0, program_1.getProgram)({
+(0, run_program_1.runProgram)({
     cwd: process.cwd(),
     abortCtrl,
     processEnvs: process.env,
     file: (0, get_file_context_1.getFileContext)(process.cwd()),
     console: (0, log_1.consoleContext)(process.stdout),
-    status: (0, work_node_status_1.statusConsole)((0, empty_writable_1.emptyWritable)()),
-    docker: (0, execute_docker_1.getContainerCli)(),
+    status: (0, work_item_status_1.statusConsole)((0, empty_writable_1.emptyWritable)()),
     stdout: process.stdout,
+    stderr: process.stderr,
     stdoutColumns: process.stdout.columns,
-}, process.argv).then(({ program, args }) => {
-    return program.parseAsync(args);
+}, process.argv, false).catch(() => {
+    process.exit(1);
 });
 //# sourceMappingURL=index.js.map

package/dist/json-schema.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const zod_to_json_schema_1 = __importDefault(require("zod-to-json-schema"));
+const fs_1 = require("fs");
+const path_1 = require("path");
+const build_file_schema_1 = require("./schema/build-file-schema");
+const jsonSchema = (0, zod_to_json_schema_1.default)(build_file_schema_1.buildFileSchema, 'hammerkit');
+(0, fs_1.writeFileSync)((0, path_1.join)(process.cwd(), 'build.schema.gen.json'), JSON.stringify(jsonSchema, null, 2));
+//# sourceMappingURL=json-schema.js.map

package/dist/kubernetes/apply.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apply = exports.statusCodeOf = void 0;
+function statusCodeOf(e) {
+    const err = e;
+    return err?.statusCode ?? err?.response?.statusCode ?? err?.body?.code;
+}
+exports.statusCodeOf = statusCodeOf;
+async function apply(instance, spec) {
+    try {
+        await instance.objectApi.read(spec);
+        const response = await instance.objectApi.patch(spec);
+        return response.body;
+    }
+    catch (e) {
+        try {
+            const response = await instance.objectApi.create(spec);
+            return response.body;
+        }
+        catch (createError) {
+            // Two work items can apply the same object concurrently (e.g. a volume
+            // shared between a task and a service that inherits its generates). If we
+            // 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;
+            }
+            throw createError;
+        }
+    }
+}
+exports.apply = apply;
+//# sourceMappingURL=apply.js.map

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

@@ -0,0 +1,71 @@
+"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.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();
+            }
+        });
+    });
+}
+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();
+            }
+        });
+    });
+}
+exports.awaitDeployRunningState = awaitDeployRunningState;
+//# sourceMappingURL=await-running-state.js.map