hammerkit 1.6.0 → 1.7.0

package/dist/docker/package.spec.js

@@ -1,145 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const test_case_1 = require("../testing/test-case");
-describe('docker/package', () => {
-    it('should allow sub paths', async () => {
-        const testCase = (0, test_case_1.createTestCase)('package', {
-            'package.json': '{ "dependencies": { "pg": "^8.7.1" } }',
-            'sub/package.json': '{ "dependencies": { "sub": "file://.." } }',
-            '.hammerkit.yaml': {
-                tasks: {
-                    install: {
-                        image: 'node:20-alpine',
-                        cmds: ['npm install'],
-                        src: ['package.json'],
-                        generates: ['node_modules'],
-                    },
-                },
-            },
-            'sub/.hammerkit.yaml': {
-                tasks: {
-                    install: {
-                        deps: ['sub:install'],
-                        image: 'node:20-alpine',
-                        cmds: ['npm install'],
-                        src: ['package.json'],
-                        generates: ['node_modules'],
-                    },
-                },
-                references: {
-                    sub: '..',
-                },
-                services: {
-                    api: {
-                        deps: ['install'],
-                        image: 'node:20-alpine',
-                        labels: { app: 'api' },
-                        cmd: 'node index.js',
-                        src: ['index.js'],
-                        ports: ['3000'],
-                    },
-                },
-            },
-            'sub/index.js': `console.log('hi')`,
-        });
-        await testCase.cli({ filterLabels: { app: ['api'] } }, async (cli) => {
-            await cli.package({
-                registry: 'localhost:5000',
-                push: false,
-                overrideUser: false,
-                username: null,
-                password: null,
-            });
-        });
-    });
-    it('should package and push', async () => {
-        const testCase = (0, test_case_1.createTestCase)('package', {
-            '.hammerkit.yaml': {
-                tasks: {
-                    install: {
-                        image: 'node:20-alpine',
-                        cmds: ['npm install'],
-                        src: ['package.json'],
-                        generates: ['node_modules'],
-                    },
-                },
-                services: {
-                    postgres: {
-                        image: 'postgres:16-alpine',
-                        envs: {
-                            POSTGRES_USER: 'postgres',
-                            POSTGRES_DB: 'demo',
-                            POSTGRES_PASSWORD: '$POSTGRES_PASSWORD',
-                        },
-                        ports: [':5432'],
-                        volumes: ['postgres-db:/var/lib/postgresql/data'],
-                    },
-                    registry: {
-                        image: 'registry:2',
-                        labels: { app: 'registry' },
-                        ports: ['5500:5000'],
-                    },
-                    api: {
-                        deps: ['install'],
-                        needs: ['postgres'],
-                        image: 'node:20-alpine',
-                        labels: { app: 'api' },
-                        envs: {
-                            DATABASE_URL: '$DATABASE_URL',
-                        },
-                        cmd: 'node index.js',
-                        src: ['index.js'],
-                        ports: ['3000'],
-                    },
-                },
-            },
-            'package.json': '{ "dependencies": { "pg": "^8.7.1" } }',
-            '.env': `POSTGRES_PASSWORD=123456
-DATABASE_URL=postgres://postgres:123456@postgres/demo`,
-            'index.js': `const { Client } = require('pg')
-const { createServer } = require('http')
-
-const client = new Client(process.env.DATABASE_URL)
-
-const server = createServer(async (req, res) => {
-  const result = await client.query('SELECT $1::text as message', ['Hello world!'])
-  res.writeHead(200)
-  res.end(result.rows[0].message)
-})
-
-async function main() {
-  await client.connect()
-  server.listen(3000)
-}
-
-process.on('SIGINT', async function () {
-  server.close()
-  await client.end()
-})
-
-main().catch((err) => {
-  console.error(err)
-  process.exit(1)
-})
-`,
-        });
-        await testCase.cli({ filterLabels: { app: ['registry'] } }, async (cli) => {
-            await cli.runUp({ daemon: true });
-            try {
-                await testCase.cli({ filterLabels: { app: ['api'] } }, async (cli) => {
-                    await cli.package({
-                        registry: 'localhost:5500',
-                        push: true,
-                        overrideUser: true,
-                        username: null,
-                        password: null,
-                    });
-                });
-            }
-            finally {
-                await cli.runDown();
-            }
-        });
-    });
-});
-//# sourceMappingURL=package.spec.js.map

package/dist/docker/remove-container.spec.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const remove_container_1 = require("./remove-container");
-function makeContainer(remove) {
-    return { remove };
-}
-describe('removeContainer', () => {
-    it('removes the container on first try', async () => {
-        const remove = vi.fn().mockResolvedValue(undefined);
-        await (0, remove_container_1.removeContainer)(makeContainer(remove));
-        expect(remove).toHaveBeenCalledTimes(1);
-        expect(remove).toHaveBeenCalledWith({ force: true });
-    });
-    it('swallows 404 (already gone)', async () => {
-        const err = Object.assign(new Error('not found'), { statusCode: 404 });
-        const remove = vi.fn().mockRejectedValueOnce(err);
-        await expect((0, remove_container_1.removeContainer)(makeContainer(remove))).resolves.toBeUndefined();
-        expect(remove).toHaveBeenCalledTimes(1);
-    });
-    it('retries on 409 (conflict)', async () => {
-        const conflict = Object.assign(new Error('conflict'), { statusCode: 409 });
-        const remove = vi.fn().mockRejectedValueOnce(conflict).mockResolvedValueOnce(undefined);
-        await (0, remove_container_1.removeContainer)(makeContainer(remove));
-        expect(remove).toHaveBeenCalledTimes(2);
-    }, 5000);
-    it('rethrows unexpected errors', async () => {
-        const err = Object.assign(new Error('boom'), { statusCode: 500 });
-        const remove = vi.fn().mockRejectedValueOnce(err);
-        await expect((0, remove_container_1.removeContainer)(makeContainer(remove))).rejects.toThrow('boom');
-    });
-});
-//# sourceMappingURL=remove-container.spec.js.map

package/dist/docker/using-container.spec.js

@@ -1,90 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const using_container_1 = require("./using-container");
-function makeContainer(id) {
-    return {
-        id,
-        start: vi.fn().mockResolvedValue(undefined),
-        pause: vi.fn().mockResolvedValue(undefined),
-        remove: vi.fn().mockResolvedValue(undefined),
-    };
-}
-function makeDocker(newContainer, listed = []) {
-    const containersById = { [newContainer.id]: newContainer };
-    for (const entry of listed) {
-        containersById[entry.Id] = makeContainer(entry.Id);
-    }
-    return {
-        docker: {
-            createContainer: vi.fn().mockResolvedValue(newContainer),
-            listContainers: vi.fn().mockResolvedValue(listed),
-            getContainer: vi.fn((id) => containersById[id] ?? makeContainer(id)),
-        },
-        containersById,
-    };
-}
-function makeItem(id) {
-    return {
-        id: () => id,
-        name: id,
-        status: { write: vi.fn() },
-        data: { type: 'container-task', image: 'alpine' },
-        needs: [],
-        deps: [],
-        requiredBy: [],
-    };
-}
-describe('usingContainer', () => {
-    it('pauses the container on success when stateKey is set', async () => {
-        const created = makeContainer('new-cid');
-        const { docker } = makeDocker(created);
-        const item = makeItem('task-1');
-        await (0, using_container_1.usingContainer)(docker, item, {}, 'state-A', async () => true);
-        expect(created.pause).toHaveBeenCalledTimes(1);
-        expect(created.remove).not.toHaveBeenCalled();
-    });
-    it('removes containers with a different stateKey and keeps the current one', async () => {
-        const created = makeContainer('new-cid');
-        const stale = { Id: 'old-cid', Labels: { 'hammerkit-state': 'state-B' } };
-        const same = { Id: 'new-cid', Labels: { 'hammerkit-state': 'state-A' } };
-        const { docker, containersById } = makeDocker(created, [stale, same]);
-        const item = makeItem('task-1');
-        await (0, using_container_1.usingContainer)(docker, item, {}, 'state-A', async () => true);
-        expect(containersById['old-cid'].remove).toHaveBeenCalledTimes(1);
-        expect(created.remove).not.toHaveBeenCalled();
-    });
-    it('removes the container when the callback returns false (cache miss on failure)', async () => {
-        const created = makeContainer('new-cid');
-        const { docker } = makeDocker(created);
-        const item = makeItem('task-1');
-        await (0, using_container_1.usingContainer)(docker, item, {}, 'state-A', async () => false);
-        expect(created.pause).not.toHaveBeenCalled();
-        expect(created.remove).toHaveBeenCalledTimes(1);
-    });
-    it('removes the container when the callback throws', async () => {
-        const created = makeContainer('new-cid');
-        const { docker } = makeDocker(created);
-        const item = makeItem('task-1');
-        await expect((0, using_container_1.usingContainer)(docker, item, {}, 'state-A', async () => {
-            throw new Error('boom');
-        })).rejects.toThrow('boom');
-        expect(created.pause).not.toHaveBeenCalled();
-        expect(created.remove).toHaveBeenCalledTimes(1);
-    });
-    it('always removes the container when no stateKey is given', async () => {
-        const created = makeContainer('new-cid');
-        const { docker } = makeDocker(created);
-        const item = makeItem('task-1');
-        await (0, using_container_1.usingContainer)(docker, item, {}, null, async () => true);
-        expect(created.pause).not.toHaveBeenCalled();
-        expect(created.remove).toHaveBeenCalledTimes(1);
-    });
-    it('propagates the callback return value', async () => {
-        const created = makeContainer('new-cid');
-        const { docker } = makeDocker(created);
-        const item = makeItem('task-1');
-        const result = await (0, using_container_1.usingContainer)(docker, item, {}, null, async () => 'payload');
-        expect(result).toBe('payload');
-    });
-});
-//# sourceMappingURL=using-container.spec.js.map

package/dist/environment/merge-environment-variables.spec.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const merge_environment_variables_1 = require("./merge-environment-variables");
-describe('mergeEnvironmentVariables', () => {
-    it('copies the base map and stringifies values', () => {
-        expect((0, merge_environment_variables_1.mergeEnvironmentVariables)({ A: 'one', B: 2 }, null)).toEqual({ A: 'one', B: '2' });
-    });
-    it('returns an empty map when both inputs are nullish', () => {
-        expect((0, merge_environment_variables_1.mergeEnvironmentVariables)(null, undefined)).toEqual({});
-    });
-    it('adds extension keys that the base does not define', () => {
-        expect((0, merge_environment_variables_1.mergeEnvironmentVariables)({ A: '1' }, { B: '2' })).toEqual({ A: '1', B: '2' });
-    });
-    it('keeps the base value when both maps define the same key (base wins)', () => {
-        expect((0, merge_environment_variables_1.mergeEnvironmentVariables)({ A: 'base' }, { A: 'override' })).toEqual({ A: 'base' });
-    });
-    it('drops falsy extension values', () => {
-        expect((0, merge_environment_variables_1.mergeEnvironmentVariables)({}, { A: '', B: 0 })).toEqual({});
-    });
-    it('handles an undefined base with an extension', () => {
-        expect((0, merge_environment_variables_1.mergeEnvironmentVariables)(undefined, { A: '1' })).toEqual({ A: '1' });
-    });
-});
-//# sourceMappingURL=merge-environment-variables.spec.js.map

package/dist/environment/replace-env-variables.spec.js

@@ -1,47 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const replace_env_variables_1 = require("./replace-env-variables");
-function env(processEnvs) {
-    return { processEnvs };
-}
-function ctx(envFiles) {
-    return { envFiles };
-}
-describe('replace-env-variables', () => {
-    describe('buildEnvironmentVariables', () => {
-        it('keeps literal values as variables', () => {
-            const result = (0, replace_env_variables_1.buildEnvironmentVariables)({ NODE_ENV: 'production' }, env({}), ctx({}));
-            expect(result.variables).toEqual({ NODE_ENV: 'production' });
-            expect(result.replacements).toEqual([]);
-        });
-        it('resolves $NAME references from processEnvs', () => {
-            const result = (0, replace_env_variables_1.buildEnvironmentVariables)({ TOKEN: '$SECRET' }, env({ SECRET: 'abc' }), ctx({}));
-            expect(result.variables).toEqual({});
-            expect(result.replacements).toEqual([{ key: 'TOKEN', name: 'SECRET', available: true, value: 'abc' }]);
-        });
-        it('falls back to env files when not in processEnvs', () => {
-            const result = (0, replace_env_variables_1.buildEnvironmentVariables)({ TOKEN: '$SECRET' }, env({}), ctx({ '/proj': { SECRET: 'from-file' } }));
-            expect(result.replacements).toEqual([{ key: 'TOKEN', name: 'SECRET', available: true, value: 'from-file' }]);
-        });
-        it('marks unresolved references as unavailable', () => {
-            const result = (0, replace_env_variables_1.buildEnvironmentVariables)({ TOKEN: '$MISSING' }, env({}), ctx({}));
-            expect(result.replacements).toEqual([{ key: 'TOKEN', name: 'MISSING', available: false, value: null }]);
-        });
-    });
-    describe('getEnvironmentVariables', () => {
-        it('merges variables with resolved replacements', () => {
-            const result = (0, replace_env_variables_1.getEnvironmentVariables)({
-                variables: { NODE_ENV: 'production' },
-                replacements: [{ key: 'TOKEN', name: 'SECRET', available: true, value: 'abc' }],
-            });
-            expect(result).toEqual({ NODE_ENV: 'production', TOKEN: 'abc' });
-        });
-        it('throws when a replacement is unavailable', () => {
-            expect(() => (0, replace_env_variables_1.getEnvironmentVariables)({
-                variables: {},
-                replacements: [{ key: 'TOKEN', name: 'SECRET', available: false, value: null }],
-            })).toThrow('missing environment variable SECRET');
-        });
-    });
-});
-//# sourceMappingURL=replace-env-variables.spec.js.map

package/dist/executer/abort.spec.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const abort_1 = require("./abort");
-describe('checkForAbort', () => {
-    it('throws AbortError when the signal is already aborted', () => {
-        const ctrl = new AbortController();
-        ctrl.abort();
-        expect(() => (0, abort_1.checkForAbort)(ctrl.signal)).toThrow(abort_1.AbortError);
-    });
-    it('does nothing when the signal is live', () => {
-        const ctrl = new AbortController();
-        expect(() => (0, abort_1.checkForAbort)(ctrl.signal)).not.toThrow();
-    });
-    it('AbortError extends Error', () => {
-        expect(new abort_1.AbortError()).toBeInstanceOf(Error);
-    });
-});
-//# sourceMappingURL=abort.spec.js.map

package/dist/executer/environment-mock.spec.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const environment_mock_1 = require("./environment-mock");
-describe('environmentMock', () => {
-    it('returns an Environment with the given cwd and silent streams', () => {
-        const env = (0, environment_mock_1.environmentMock)('/tmp/x');
-        expect(env.cwd).toBe('/tmp/x');
-        expect(env.file).toBeDefined();
-        expect(env.console).toBeDefined();
-        expect(env.status).toBeDefined();
-        expect(env.stdout).toBeDefined();
-        expect(env.stderr).toBeDefined();
-        expect(env.abortCtrl).toBeInstanceOf(AbortController);
-        expect(env.processEnvs).toEqual({});
-        expect(env.stdoutColumns).toBe(80);
-        // writing to silent streams must not throw
-        env.stdout.write('hello\n');
-        env.stderr.write('world\n');
-        env.console.info('info');
-    });
-});
-//# sourceMappingURL=environment-mock.spec.js.map

package/dist/executer/execute.spec.js

@@ -1,51 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const get_test_suite_1 = require("../testing/get-test-suite");
-const expect_1 = require("../testing/expect");
-describe('execute', () => {
-    const suite = (0, get_test_suite_1.getTestSuite)('hello-world-node', ['.hammerkit.yaml', 'package.json', 'index.js']);
-    afterAll(() => suite.close());
-    // These watch-restart cases are unreliable on Windows hosted runners: the
-    // re-run after a source change either hangs (completed/cached task) or times
-    // out intermittently (crashed task), because file-watching + repeated node
-    // spawns don't settle within the limit there. The watch feature is covered on
-    // Linux and macOS; skip both on win32 until the Windows watch path is fixed.
-    const itExceptWindows = process.platform === 'win32' ? it.skip : it;
-    itExceptWindows('should restart watching task if once completed', async () => {
-        const { cli, environment } = await suite.setup({ taskName: 'api' });
-        const exec = await cli.exec({ watch: true });
-        let count = 0;
-        exec.state.on('test-status', (state) => {
-            if (state.tasks['api'].state.current.type === 'completed') {
-                count++;
-                if (count === 1) {
-                    environment.file.appendFile(`${environment.cwd}/index.js`, '\n');
-                }
-                else if (count === 2) {
-                    environment.abortCtrl.abort();
-                }
-            }
-        });
-        const result = await exec.start();
-        await (0, expect_1.expectSuccessfulResult)(result, environment);
-    });
-    itExceptWindows('should restart watching task if once failed', async () => {
-        const { cli, environment } = await suite.setup({ taskName: 'api_crashing' });
-        const exec = await cli.exec({ watch: true });
-        let count = 0;
-        exec.state.on('test-status', (state) => {
-            if (state.tasks['api_crashing'].state.current.type === 'crash') {
-                count++;
-                if (count === 1) {
-                    environment.file.appendFile(`${environment.cwd}/index.js`, '\n');
-                }
-                else if (count === 2) {
-                    environment.abortCtrl.abort();
-                }
-            }
-        });
-        const result = await exec.start();
-        expect(result.success).toBeFalsy();
-    });
-});
-//# sourceMappingURL=execute.spec.js.map

package/dist/executer/get-service-containers.spec.js

@@ -1,59 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const get_service_containers_1 = require("./get-service-containers");
-const docker_task_1 = require("./docker-task");
-const state_1 = require("./state");
-function makeNeed(name, state) {
-    const service = {
-        id: () => name,
-        name,
-        state: new state_1.State(state),
-    };
-    return { name, service };
-}
-describe('get-service-containers', () => {
-    it('skips needs that are not running', () => {
-        const needs = [
-            makeNeed('db', { type: 'pending', stateKey: null }),
-            makeNeed('api', { type: 'starting', stateKey: null }),
-        ];
-        expect((0, get_service_containers_1.getServiceContainers)(needs)).toEqual({});
-    });
-    it('collects dns for running services', () => {
-        const dns = { containerId: 'abc' };
-        const needs = [makeNeed('db', { type: 'running', stateKey: 'k', remote: null, dns })];
-        expect((0, get_service_containers_1.getServiceContainers)(needs)).toEqual({ db: dns });
-    });
-    it('mixes host and container dns', () => {
-        const containerDns = { containerId: 'cid' };
-        const hostDns = { host: '10.0.0.1' };
-        const needs = [
-            makeNeed('db', { type: 'running', stateKey: 'k1', remote: null, dns: containerDns }),
-            makeNeed('cache', { type: 'running', stateKey: 'k2', remote: null, dns: hostDns }),
-        ];
-        expect((0, get_service_containers_1.getServiceContainers)(needs)).toEqual({ db: containerDns, cache: hostDns });
-    });
-});
-describe('getNeedsNetwork', () => {
-    it('returns empty links and hosts when there are no needs', () => {
-        const result = (0, docker_task_1.getNeedsNetwork)({}, []);
-        expect(result).toEqual({ links: [], hosts: [] });
-    });
-    it('maps container dns to docker Links', () => {
-        const needs = [makeNeed('db', { type: 'running', stateKey: 'k', remote: null, dns: { containerId: 'cid' } })];
-        const result = (0, docker_task_1.getNeedsNetwork)({ db: { containerId: 'cid' } }, needs);
-        expect(result.links).toEqual(['cid:db']);
-        expect(result.hosts).toEqual([]);
-    });
-    it('maps host dns to docker ExtraHosts', () => {
-        const needs = [makeNeed('api', { type: 'running', stateKey: 'k', remote: null, dns: { host: '127.0.0.1' } })];
-        const result = (0, docker_task_1.getNeedsNetwork)({ api: { host: '127.0.0.1' } }, needs);
-        expect(result.hosts).toEqual(['api:127.0.0.1']);
-        expect(result.links).toEqual([]);
-    });
-    it('throws when a container service has no containerId', () => {
-        const needs = [makeNeed('db', { type: 'pending', stateKey: null })];
-        expect(() => (0, docker_task_1.getNeedsNetwork)({ db: { containerId: '' } }, needs)).toThrow(/service db is not running/);
-    });
-});
-//# sourceMappingURL=get-service-containers.spec.js.map

package/dist/executer/get-service-env-hints.spec.js

@@ -1,65 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const get_service_env_hints_1 = require("./get-service-env-hints");
-const state_1 = require("./state");
-function makeNeed(name, state, ports = []) {
-    const service = {
-        id: () => name,
-        name,
-        data: { ports },
-        state: new state_1.State(state),
-    };
-    return { name, service };
-}
-describe('getServiceEnvHints', () => {
-    it('returns nothing for non-running needs', () => {
-        const needs = [makeNeed('db', { type: 'pending', stateKey: null })];
-        expect((0, get_service_env_hints_1.getServiceEnvHints)(needs)).toEqual({});
-    });
-    it('emits a localhost host hint for docker container services', () => {
-        const needs = [
-            makeNeed('db', { type: 'running', stateKey: 'k', remote: null, dns: { containerId: 'abc' } }, [
-                { hostPort: 5432, containerPort: 5432 },
-            ]),
-        ];
-        expect((0, get_service_env_hints_1.getServiceEnvHints)(needs)).toEqual({
-            HAMMERKIT_DB_HOST: '127.0.0.1',
-            HAMMERKIT_DB_PORT: '5432',
-            HAMMERKIT_DB_PORT_5432: '5432',
-        });
-    });
-    it('uses the dns host for host-style services', () => {
-        const needs = [
-            makeNeed('api', { type: 'running', stateKey: 'k', remote: null, dns: { host: '10.0.0.7' } }, [
-                { hostPort: null, containerPort: 8080 },
-            ]),
-        ];
-        expect((0, get_service_env_hints_1.getServiceEnvHints)(needs)).toEqual({
-            HAMMERKIT_API_HOST: '10.0.0.7',
-            HAMMERKIT_API_PORT: '8080',
-            HAMMERKIT_API_PORT_8080: '8080',
-        });
-    });
-    it('exposes every published port under its container-port suffix', () => {
-        const needs = [
-            makeNeed('web', { type: 'running', stateKey: 'k', remote: null, dns: { containerId: 'x' } }, [
-                { hostPort: 8080, containerPort: 80 },
-                { hostPort: 8443, containerPort: 443 },
-            ]),
-        ];
-        const env = (0, get_service_env_hints_1.getServiceEnvHints)(needs);
-        expect(env).toEqual({
-            HAMMERKIT_WEB_HOST: '127.0.0.1',
-            HAMMERKIT_WEB_PORT: '8080',
-            HAMMERKIT_WEB_PORT_80: '8080',
-            HAMMERKIT_WEB_PORT_443: '8443',
-        });
-    });
-    it('sanitizes weird names into env-safe keys', () => {
-        const needs = [
-            makeNeed('my.service:1', { type: 'running', stateKey: 'k', remote: null, dns: { containerId: 'x' } }, []),
-        ];
-        expect((0, get_service_env_hints_1.getServiceEnvHints)(needs)).toEqual({ HAMMERKIT_MY_SERVICE_1_HOST: '127.0.0.1' });
-    });
-});
-//# sourceMappingURL=get-service-env-hints.spec.js.map

package/dist/executer/label-values.spec.js

@@ -1,61 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const label_values_1 = require("./label-values");
-describe('label-values', () => {
-    describe('hasLabels', () => {
-        it('is false for an empty object', () => {
-            expect((0, label_values_1.hasLabels)({})).toBe(false);
-        });
-        it('is true when at least one key is present', () => {
-            expect((0, label_values_1.hasLabels)({ app: ['web'] })).toBe(true);
-        });
-    });
-    describe('matchesAnyLabel', () => {
-        it('matches when a filter value is present in the labels', () => {
-            expect((0, label_values_1.matchesAnyLabel)({ app: ['web'] }, { app: ['web', 'api'] })).toBe(true);
-        });
-        it('does not match when the value is absent', () => {
-            expect((0, label_values_1.matchesAnyLabel)({ app: ['web'] }, { app: ['api'] })).toBe(false);
-        });
-        it('skips label keys that are missing or empty on the value', () => {
-            expect((0, label_values_1.matchesAnyLabel)({ app: ['web'] }, {})).toBe(false);
-            expect((0, label_values_1.matchesAnyLabel)({ app: ['web'] }, { app: [] })).toBe(false);
-        });
-        it('returns false for an empty filter', () => {
-            expect((0, label_values_1.matchesAnyLabel)({}, { app: ['web'] })).toBe(false);
-        });
-    });
-    describe('appliesToLabels', () => {
-        it('applies when there is no filter and no exclude', () => {
-            expect((0, label_values_1.appliesToLabels)({ app: ['web'] }, {})).toBe(true);
-        });
-        it('applies only when the filter matches', () => {
-            expect((0, label_values_1.appliesToLabels)({ app: ['web'] }, { filterLabels: { app: ['web'] } })).toBe(true);
-            expect((0, label_values_1.appliesToLabels)({ app: ['web'] }, { filterLabels: { app: ['api'] } })).toBe(false);
-        });
-        it('does not apply when an exclude matches', () => {
-            expect((0, label_values_1.appliesToLabels)({ app: ['web'] }, { excludeLabels: { app: ['web'] } })).toBe(false);
-        });
-        it('exclude wins over a matching filter', () => {
-            expect((0, label_values_1.appliesToLabels)({ app: ['web'], tier: ['frontend'] }, { filterLabels: { app: ['web'] }, excludeLabels: { tier: ['frontend'] } })).toBe(false);
-        });
-    });
-    describe('mergeLabels', () => {
-        it('coerces scalar values into string arrays', () => {
-            expect((0, label_values_1.mergeLabels)({ app: 'web', port: 8080 })).toEqual({ app: ['web'], port: ['8080'] });
-        });
-        it('keeps array values as-is', () => {
-            expect((0, label_values_1.mergeLabels)({ app: ['web', 'api'] })).toEqual({ app: ['web', 'api'] });
-        });
-        it('merges multiple sources and dedupes values', () => {
-            expect((0, label_values_1.mergeLabels)({ app: 'web' }, { app: ['web', 'api'] }, { tier: 'frontend' })).toEqual({
-                app: ['web', 'api'],
-                tier: ['frontend'],
-            });
-        });
-        it('ignores null and undefined sources', () => {
-            expect((0, label_values_1.mergeLabels)(null, undefined, { app: 'web' })).toEqual({ app: ['web'] });
-        });
-    });
-});
-//# sourceMappingURL=label-values.spec.js.map

package/dist/executer/lazy-resolver.spec.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const lazy_resolver_1 = require("./lazy-resolver");
-describe('lazyResolver', () => {
-    it('calls the factory once and memoizes the result', () => {
-        const factory = vi.fn(() => 'value');
-        const resolve = (0, lazy_resolver_1.lazyResolver)(factory);
-        expect(resolve()).toBe('value');
-        expect(resolve()).toBe('value');
-        expect(factory).toHaveBeenCalledTimes(1);
-    });
-    it('memoizes a falsy result so the factory still runs only once', () => {
-        const factory = vi.fn(() => 0);
-        const resolve = (0, lazy_resolver_1.lazyResolver)(factory);
-        expect(resolve()).toBe(0);
-        expect(resolve()).toBe(0);
-        expect(factory).toHaveBeenCalledTimes(1);
-    });
-});
-//# sourceMappingURL=lazy-resolver.spec.js.map