hammerkit 1.6.0 → 1.7.0

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

@@ -1,193 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const path_1 = require("path");
-const os_1 = require("os");
-const fs_1 = require("fs");
-const work_runtime_local_1 = require("./work-runtime-local");
-const environment_mock_1 = require("../executer/environment-mock");
-const state_1 = require("../executer/state");
-const mockFindProcess = vi.hoisted(() => vi.fn());
-vi.mock('find-process', () => ({
-    __esModule: true,
-    default: (...args) => mockFindProcess(...args),
-}));
-vi.mock('../executer/local-task', () => ({
-    localTask: vi.fn().mockResolvedValue(undefined),
-}));
-function makeTask(cwd) {
-    return {
-        id: () => 'task-1',
-        name: 'task-1',
-        status: { write: vi.fn() },
-        data: {
-            type: 'local-task',
-            name: 'task-1',
-            cwd,
-            cmds: [],
-            generates: [],
-            src: [],
-            envs: { variables: {}, processEnvs: {} },
-            labels: {},
-            shell: '/bin/sh',
-            continuous: false,
-            caching: {
-                name: 'none',
-                method: 'none',
-                backend: {
-                    type: 'local',
-                    has: async () => false,
-                    pull: async () => false,
-                    push: async () => { },
-                    clear: async () => { },
-                },
-                implicit: true,
-            },
-            description: null,
-            scope: {},
-        },
-        needs: [],
-        deps: [],
-        requiredBy: [],
-    };
-}
-describe('local task pidfile', () => {
-    let cwd;
-    beforeEach(() => {
-        cwd = (0, fs_1.mkdtempSync)((0, path_1.join)((0, os_1.tmpdir)(), 'hammerkit-pidfile-'));
-        mockFindProcess.mockReset();
-    });
-    afterEach(() => {
-        (0, fs_1.rmSync)(cwd, { recursive: true, force: true });
-    });
-    it('writes pidfile during execute and cleans up after', async () => {
-        const task = makeTask(cwd);
-        const runtime = (0, work_runtime_local_1.getLocalWorkRuntime)(task);
-        const env = (0, environment_mock_1.environmentMock)(cwd);
-        const state = new state_1.State({ type: 'pending', stateKey: null });
-        await runtime.execute(env, {
-            stateKey: 'state-1',
-            abort: new AbortController().signal,
-            state,
-            cache: {
-                cached: false,
-                stateKey: 'state-x',
-                resolved: {
-                    name: 'none',
-                    method: 'none',
-                    backend: {
-                        type: 'local',
-                        has: async () => false,
-                        pull: async () => false,
-                        push: async () => { },
-                        clear: async () => { },
-                    },
-                    implicit: true,
-                },
-            },
-            daemon: false,
-        });
-        expect(await env.file.exists((0, path_1.join)(cwd, '.hammerkit', 'task-1.pid'))).toBe(false);
-        expect(await env.file.exists((0, path_1.join)(cwd, '.hammerkit', 'task-1'))).toBe(true);
-    });
-    it('removes a stale pidfile when the process is not alive', async () => {
-        const task = makeTask(cwd);
-        const runtime = (0, work_runtime_local_1.getLocalWorkRuntime)(task);
-        const env = (0, environment_mock_1.environmentMock)(cwd);
-        const state = new state_1.State({ type: 'pending', stateKey: null });
-        await env.file.createDirectory((0, path_1.join)(cwd, '.hammerkit'));
-        (0, fs_1.writeFileSync)((0, path_1.join)(cwd, '.hammerkit', 'task-1.pid'), '999999');
-        mockFindProcess.mockResolvedValueOnce([]);
-        await runtime.execute(env, {
-            stateKey: 'state-2',
-            abort: new AbortController().signal,
-            state,
-            cache: {
-                cached: false,
-                stateKey: 'state-x',
-                resolved: {
-                    name: 'none',
-                    method: 'none',
-                    backend: {
-                        type: 'local',
-                        has: async () => false,
-                        pull: async () => false,
-                        push: async () => { },
-                        clear: async () => { },
-                    },
-                    implicit: true,
-                },
-            },
-            daemon: false,
-        });
-        expect(state.current.type).not.toBe('error');
-        expect(mockFindProcess).toHaveBeenCalledWith('pid', 999999);
-    });
-    it('refuses to run when the pidfile points at a live process', async () => {
-        const task = makeTask(cwd);
-        const runtime = (0, work_runtime_local_1.getLocalWorkRuntime)(task);
-        const env = (0, environment_mock_1.environmentMock)(cwd);
-        const state = new state_1.State({ type: 'pending', stateKey: null });
-        await env.file.createDirectory((0, path_1.join)(cwd, '.hammerkit'));
-        (0, fs_1.writeFileSync)((0, path_1.join)(cwd, '.hammerkit', 'task-1.pid'), '12345');
-        mockFindProcess.mockResolvedValueOnce([{ pid: 12345, name: 'node' }]);
-        await runtime.execute(env, {
-            stateKey: 'state-3',
-            abort: new AbortController().signal,
-            state,
-            cache: {
-                cached: false,
-                stateKey: 'state-x',
-                resolved: {
-                    name: 'none',
-                    method: 'none',
-                    backend: {
-                        type: 'local',
-                        has: async () => false,
-                        pull: async () => false,
-                        push: async () => { },
-                        clear: async () => { },
-                    },
-                    implicit: true,
-                },
-            },
-            daemon: false,
-        });
-        expect(state.current.type).toBe('error');
-        if (state.current.type === 'error') {
-            expect(state.current.errorMessage).toMatch(/already running.*12345/);
-        }
-    });
-    it('does not block when the pidfile contains our own pid', async () => {
-        const task = makeTask(cwd);
-        const runtime = (0, work_runtime_local_1.getLocalWorkRuntime)(task);
-        const env = (0, environment_mock_1.environmentMock)(cwd);
-        const state = new state_1.State({ type: 'pending', stateKey: null });
-        await env.file.createDirectory((0, path_1.join)(cwd, '.hammerkit'));
-        (0, fs_1.writeFileSync)((0, path_1.join)(cwd, '.hammerkit', 'task-1.pid'), `${process.pid}`);
-        await runtime.execute(env, {
-            stateKey: 'state-4',
-            abort: new AbortController().signal,
-            state,
-            cache: {
-                cached: false,
-                stateKey: 'state-x',
-                resolved: {
-                    name: 'none',
-                    method: 'none',
-                    backend: {
-                        type: 'local',
-                        has: async () => false,
-                        pull: async () => false,
-                        push: async () => { },
-                        clear: async () => { },
-                    },
-                    implicit: true,
-                },
-            },
-            daemon: false,
-        });
-        expect(state.current.type).not.toBe('error');
-        expect(mockFindProcess).not.toHaveBeenCalled();
-    });
-});
-//# sourceMappingURL=work-runtime-local.spec.js.map

package/dist/program-commands.spec.js

@@ -1,84 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const test_case_1 = require("./testing/test-case");
-// Fast unit-suite coverage for program.ts: every command that does not actually
-// run a container (ls, validate, clean --cache, init, --file, unknown task).
-// The slow container-running cases (run, package, up/down) live in
-// `program.spec.ts` and run in the integration suite.
-//
-// shell() forwards args to commander via `[env.cwd, ...args]`, and commander's
-// default `from: 'node'` consumes the first two slots as node+script. So args
-// must start with a script-name placeholder (matching how production receives
-// process.argv); the real command starts at index 1.
-const HK = 'hammerkit';
-describe('program commands (fast)', () => {
-    it('ls lists tasks and services without running them', async () => {
-        const t = (0, test_case_1.createTestCase)('cmd-ls', {
-            '.hammerkit.yaml': {
-                services: { api: { image: 'nginx', ports: [] } },
-                tasks: {
-                    build: { cmds: ['true'], description: 'build it', labels: { tier: 'backend' } },
-                },
-            },
-        });
-        await t.shell([HK, 'ls']);
-    });
-    it('ls --filter narrows by label', async () => {
-        const t = (0, test_case_1.createTestCase)('cmd-ls-filter', {
-            '.hammerkit.yaml': {
-                tasks: {
-                    build: { cmds: ['true'], labels: { app: 'web' } },
-                    lint: { cmds: ['true'], labels: { app: 'tool' } },
-                },
-            },
-        });
-        await t.shell([HK, 'ls', '--filter', 'app=web']);
-    });
-    it('validate returns cleanly for a healthy build file', async () => {
-        const t = (0, test_case_1.createTestCase)('cmd-validate-ok', {
-            '.hammerkit.yaml': {
-                tasks: { build: { description: 'build it', cmds: ['true'] } },
-            },
-        });
-        await t.shell([HK, 'validate']);
-    });
-    it('validate exits non-zero when a cycle is detected', async () => {
-        const t = (0, test_case_1.createTestCase)('cmd-validate-cycle', {
-            '.hammerkit.yaml': {
-                tasks: {
-                    a: { description: 'a', cmds: ['true'], deps: ['b'] },
-                    b: { description: 'b', cmds: ['true'], deps: ['a'] },
-                },
-            },
-        });
-        await expect(t.shell([HK, 'validate'])).rejects.toThrow('Detected errors');
-    });
-    it('clean --cache clears the backend cache (no container ops)', async () => {
-        const t = (0, test_case_1.createTestCase)('cmd-clean-cache', {
-            '.hammerkit.yaml': {
-                tasks: { build: { cmds: ['true'] } },
-            },
-        });
-        await t.shell([HK, 'clean', '--cache']);
-    });
-    it('init writes a default .hammerkit.yaml when none exists', async () => {
-        // empty fixture so getBuildFilename finds nothing; only the `init` command is registered then
-        const t = (0, test_case_1.createTestCase)('cmd-init', {});
-        await t.shell([HK, 'init']);
-    });
-    it('errors when the requested task does not exist', async () => {
-        const t = (0, test_case_1.createTestCase)('cmd-unknown-task', {
-            '.hammerkit.yaml': { tasks: { example: { cmds: ['true'] } } },
-        });
-        await expect(t.shell([HK, 'run', 'no-such-task'])).rejects.toThrow('No tasks found');
-    });
-    it('--file selects a non-default build file', async () => {
-        const t = (0, test_case_1.createTestCase)('cmd-file-arg', {
-            'custom.yaml': {
-                tasks: { only: { description: 'only', cmds: ['true'] } },
-            },
-        });
-        await t.shell([HK, '--file', 'custom.yaml', 'ls']);
-    });
-});
-//# sourceMappingURL=program-commands.spec.js.map

package/dist/program.spec.js

@@ -1,43 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const test_case_1 = require("./testing/test-case");
-describe('program', () => {
-    it('should run when cache is up to date and --no-cache arg is passed', async () => {
-        const testCase = (0, test_case_1.createTestCase)('no-cache', {
-            'package.json': '{ "dependencies": { "hammerkit": "^1.5.0" } }',
-            '.hammerkit.yaml': {
-                tasks: {
-                    example: {
-                        description: 'install npm packages',
-                        image: 'node:16.6.0-alpine',
-                        // On linux hammerkit runs the container as the host uid:gid (see
-                        // get-container-user) so generated files aren't root-owned. That uid
-                        // has no home dir in the image, so npm falls back to the unwritable
-                        // /.npm and fails with EACCES. Point HOME at a writable dir — what a
-                        // real non-root user would do — so the task works regardless of uid
-                        // (it only "passed" elsewhere because those ran the container as root).
-                        envs: { HOME: '/tmp' },
-                        src: ['package.json'],
-                        generates: ['node_modules'],
-                        cmds: ['npm install'],
-                    },
-                },
-            },
-        });
-        await testCase.shell(['run', 'example', '--cache', 'none']);
-    }, 120000);
-    it('should warn about invalid task name', async () => {
-        const testCase = (0, test_case_1.createTestCase)('wrong-name', {
-            '.hammerkit.yaml': {
-                tasks: {
-                    example: {
-                        image: 'node:16.6.0-alpine',
-                        cmds: ['npm ci'],
-                    },
-                },
-            },
-        });
-        await expect(testCase.shell(['run', 'example2'])).rejects.toThrow('No tasks found');
-    });
-});
-//# sourceMappingURL=program.spec.js.map

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

@@ -1,61 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const build_file_schema_1 = require("./build-file-schema");
-function parse(input) {
-    return build_file_schema_1.buildFileSchema.safeParseAsync(input);
-}
-describe('buildFileSchema', () => {
-    describe('container services', () => {
-        it('accepts a service without ports (reachable via needs/DNS)', async () => {
-            const result = await parse({
-                services: { postgres: { image: 'postgres:12-alpine', healthcheck: { cmd: 'pg_isready -U postgres' } } },
-            });
-            expect(result.success).toBe(true);
-        });
-        it('accepts a service with numeric and string ports', async () => {
-            const result = await parse({ services: { api: { image: 'node:alpine', ports: [':3000', 8080] } } });
-            expect(result.success).toBe(true);
-        });
-        it('rejects a service that is neither a container nor a kubernetes service', async () => {
-            const result = await parse({ services: { broken: { ports: [80] } } });
-            expect(result.success).toBe(false);
-        });
-    });
-    describe('kubernetes services', () => {
-        it('accepts a service with a selector', async () => {
-            const result = await parse({
-                services: { db: { selector: { type: 'deployment', name: 'db' }, ports: [5432] } },
-            });
-            expect(result.success).toBe(true);
-        });
-    });
-    describe('continuous tasks', () => {
-        it('accepts a container task marked continuous', async () => {
-            const result = await parse({ tasks: { serve: { image: 'node:16', continuous: true, cmds: ['ng serve'] } } });
-            expect(result.success).toBe(true);
-        });
-        it('accepts a local task marked continuous', async () => {
-            const result = await parse({ tasks: { serve: { continuous: true, cmds: ['ng serve'] } } });
-            expect(result.success).toBe(true);
-        });
-        it('rejects a non-boolean continuous', async () => {
-            const result = await parse({ tasks: { serve: { continuous: 'yes', cmds: ['x'] } } });
-            expect(result.success).toBe(false);
-        });
-    });
-    describe('strictness', () => {
-        it('rejects unknown top-level keys', async () => {
-            const result = await parse({ bogus: true });
-            expect(result.success).toBe(false);
-        });
-        it('rejects unknown task keys', async () => {
-            const result = await parse({ tasks: { build: { cmds: ['x'], bogus: 1 } } });
-            expect(result.success).toBe(false);
-        });
-        it('accepts an empty build file', async () => {
-            const result = await parse({});
-            expect(result.success).toBe(true);
-        });
-    });
-});
-//# sourceMappingURL=build-file-schema.spec.js.map

package/dist/schema/doc-build-files.spec.js

@@ -1,223 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs_1 = require("fs");
-const path_1 = require("path");
-const yaml_1 = require("yaml");
-const build_file_schema_1 = require("./build-file-schema");
-/*
- * Documentation coverage: every hammerkit build-file example that ships in the
- * docs must stay valid against the real schema, so the docs cannot silently
- * drift to config the tool would reject.
- *
- * The harness is self-discovering: it walks docs/ at collection time and turns
- * every fenced ```yaml block into its own assertion. A block is treated as a
- * hammerkit build file when it parses to an object whose top-level keys are all
- * part of the schema (envs/tasks/services/...). Anything else (a GitLab/GitHub
- * CI snippet, a design-doc proposal) is "foreign" and must be listed in
- * FOREIGN_BLOCKS with a reason — a foreign block that is NOT listed fails the
- * audit, so a new build-file example is validated rather than quietly ignored,
- * and a typo'd example (unknown key) is surfaced instead of skipped.
- */
-const repoRoot = (0, path_1.join)(__dirname, '..', '..');
-const docsDir = (0, path_1.join)(repoRoot, 'docs');
-const bestPracticesDir = (0, path_1.join)(repoRoot, 'best-practices');
-// Top-level keys the build-file schema understands. Mirrors buildFileSchema's
-// shape; kept here only to classify "is this block a hammerkit build file at all".
-const KNOWN_TOP_KEYS = new Set([
-    'envs',
-    'tasks',
-    'services',
-    'references',
-    'includes',
-    'environments',
-    'caches',
-    'labels',
-]);
-// A doc block can declare itself intentionally invalid by putting this comment
-// on its first line; the harness then asserts the schema REJECTS it.
-const EXPECT_INVALID = '# hammerkit:expect-invalid';
-// Directories that document a specific past version, not the current build-file
-// reference. Their snippets are expected to use the syntax of their release and
-// must not be validated against today's schema.
-const HISTORICAL_DIRS = ['release-blog', 'change-log'];
-// yaml blocks in docs/ that are deliberately NOT hammerkit build files. Each is
-// matched by a unique snippet of its body. Keep the reason — these are the only
-// blocks allowed to be unrecognized.
-const FOREIGN_BLOCKS = [
-    {
-        file: (0, path_1.join)('installation.md'),
-        snippet: 'DOCKER_DRIVER',
-        reason: 'GitLab CI (.gitlab-ci.yml) example, not a hammerkit build file',
-    },
-    {
-        file: (0, path_1.join)('installation.md'),
-        snippet: 'no0dles/hammerkit-github-action',
-        reason: 'GitHub Actions workflow example, not a hammerkit build file',
-    },
-    {
-        file: (0, path_1.join)('cli', 'store-restore.md'),
-        snippet: 'before_script',
-        reason: 'GitLab CI (gitlab-ci.yml) caching example, not a hammerkit build file',
-    },
-    {
-        file: (0, path_1.join)('guides', 'ci-caching.md'),
-        snippet: 'actions/cache@v4',
-        reason: 'GitHub Actions workflow example, not a hammerkit build file',
-    },
-    {
-        file: (0, path_1.join)('contribution', 'secret-managers.md'),
-        snippet: 'secret://vault',
-        reason: 'design-doc proposal for an unimplemented secrets: provider; not valid against the current schema',
-    },
-];
-function walkMarkdown(dir) {
-    const out = [];
-    for (const entry of (0, fs_1.readdirSync)(dir, { withFileTypes: true })) {
-        const full = (0, path_1.join)(dir, entry.name);
-        if (entry.isDirectory()) {
-            out.push(...walkMarkdown(full));
-        }
-        else if (entry.name.endsWith('.md')) {
-            out.push(full);
-        }
-    }
-    return out;
-}
-// Extract the body of every fenced ```yaml / ```yml block. GitBook's
-// `{% code %}` wrappers and `{% hint %}`/`{% tabs %}` around a block are
-// irrelevant — only the fence matters.
-function extractYamlBlocks(content) {
-    const lines = content.split(/\r?\n/);
-    const blocks = [];
-    for (let i = 0; i < lines.length; i++) {
-        if (!/^\s*```ya?ml\s*$/.test(lines[i])) {
-            continue;
-        }
-        const start = i + 1;
-        const body = [];
-        let j = start;
-        while (j < lines.length && !/^\s*```\s*$/.test(lines[j])) {
-            body.push(lines[j]);
-            j++;
-        }
-        blocks.push({ body: body.join('\n'), startLine: start + 1 });
-        i = j;
-    }
-    return blocks;
-}
-function firstNonEmptyLine(body) {
-    for (const line of body.split(/\r?\n/)) {
-        if (line.trim() !== '') {
-            return line.trim();
-        }
-    }
-    return '';
-}
-// A block is a hammerkit build file when it parses to a non-empty object whose
-// top-level keys are all part of the schema.
-function isBuildFileShaped(parsed) {
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        return false;
-    }
-    const keys = Object.keys(parsed);
-    return keys.length > 0 && keys.every((k) => KNOWN_TOP_KEYS.has(k));
-}
-const docFiles = walkMarkdown(docsDir).sort();
-const allBlocks = [];
-for (const file of docFiles) {
-    const relFile = (0, path_1.relative)(docsDir, file);
-    const topDir = relFile.split(/[\\/]/)[0];
-    if (HISTORICAL_DIRS.includes(topDir)) {
-        continue;
-    }
-    extractYamlBlocks((0, fs_1.readFileSync)(file, 'utf8')).forEach((block, index) => {
-        allBlocks.push({ ...block, relFile, index });
-    });
-}
-const foreignMatches = new Set();
-let buildFileBlockCount = 0;
-describe('docs build-file examples', () => {
-    // Group assertions per doc file for readable failures.
-    const byFile = new Map();
-    for (const block of allBlocks) {
-        const list = byFile.get(block.relFile) ?? [];
-        list.push(block);
-        byFile.set(block.relFile, list);
-    }
-    for (const [relFile, blocks] of byFile) {
-        describe(relFile, () => {
-            blocks.forEach((block) => {
-                const label = `yaml block at line ${block.startLine}`;
-                const foreignIndex = FOREIGN_BLOCKS.findIndex((f) => f.file === relFile && block.body.includes(f.snippet));
-                if (foreignIndex >= 0) {
-                    foreignMatches.add(foreignIndex);
-                    it(`${label} is a documented non-hammerkit block`, () => {
-                        // Listed in FOREIGN_BLOCKS with a reason — nothing to validate.
-                        expect(FOREIGN_BLOCKS[foreignIndex].reason).toBeTruthy();
-                    });
-                    return;
-                }
-                if (firstNonEmptyLine(block.body) === EXPECT_INVALID) {
-                    it(`${label} is rejected by the schema (marked expect-invalid)`, async () => {
-                        const parsed = (0, yaml_1.parse)(block.body);
-                        const result = await build_file_schema_1.buildFileSchema.safeParseAsync(parsed);
-                        expect(result.success).toBe(false);
-                    });
-                    buildFileBlockCount++;
-                    return;
-                }
-                it(`${label} is a valid build file`, async () => {
-                    let parsed;
-                    try {
-                        parsed = (0, yaml_1.parse)(block.body);
-                    }
-                    catch (e) {
-                        throw new Error(`${relFile}:${block.startLine} is not valid YAML: ${e.message}`);
-                    }
-                    if (!isBuildFileShaped(parsed)) {
-                        const keys = parsed && typeof parsed === 'object' && !Array.isArray(parsed)
-                            ? Object.keys(parsed).join(', ')
-                            : typeof parsed;
-                        throw new Error(`${relFile}:${block.startLine} is not a recognized hammerkit build file (top-level: ${keys}).\n` +
-                            `If this is intentionally foreign yaml (a CI config, a proposal), add it to FOREIGN_BLOCKS with a reason.\n` +
-                            `Otherwise fix the example so its top-level keys are one of: ${[...KNOWN_TOP_KEYS].join(', ')}.`);
-                    }
-                    const result = await build_file_schema_1.buildFileSchema.safeParseAsync(parsed);
-                    if (!result.success) {
-                        throw new Error(`${relFile}:${block.startLine} fails the build-file schema:\n` +
-                            result.error.issues.map((iss) => `  - ${iss.path.join('.')}: ${iss.message}`).join('\n'));
-                    }
-                });
-                buildFileBlockCount++;
-            });
-        });
-    }
-    // Guard against a regex/discovery regression silently matching nothing, and
-    // against a build-file example dropping out of validation unnoticed.
-    it('discovers the documented build-file examples', () => {
-        expect(buildFileBlockCount).toBeGreaterThanOrEqual(60);
-    });
-    // Every documented exclusion must still match a real block, so stale entries
-    // are removed when the doc changes.
-    it('has no stale FOREIGN_BLOCKS entries', () => {
-        const unmatched = FOREIGN_BLOCKS.filter((_, i) => !foreignMatches.has(i)).map((f) => `${f.file} (${f.snippet})`);
-        expect(unmatched).toEqual([]);
-    });
-});
-describe('best-practices build configs', () => {
-    const files = (0, fs_1.readdirSync)(bestPracticesDir)
-        .filter((f) => f.endsWith('.yaml') || f.endsWith('.yml'))
-        .sort();
-    it('finds the best-practices templates', () => {
-        expect(files.length).toBeGreaterThanOrEqual(10);
-    });
-    it.each(files)('%s is a valid build file', async (name) => {
-        const parsed = (0, yaml_1.parse)((0, fs_1.readFileSync)((0, path_1.join)(bestPracticesDir, name), 'utf8'));
-        const result = await build_file_schema_1.buildFileSchema.safeParseAsync(parsed);
-        if (!result.success) {
-            throw new Error(`best-practices/${name} fails the build-file schema:\n` +
-                result.error.issues.map((iss) => `  - ${iss.path.join('.')}: ${iss.message}`).join('\n'));
-        }
-    });
-});
-//# sourceMappingURL=doc-build-files.spec.js.map

package/dist/schema/parse-error.spec.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const zod_1 = require("zod");
-const parse_error_1 = require("./parse-error");
-describe('ParseError', () => {
-    it('wraps a ZodError with the offending build-file path', () => {
-        const result = zod_1.z.object({ name: zod_1.z.string() }).safeParse({});
-        if (result.success) {
-            throw new Error('precondition: expected the safeParse to fail');
-        }
-        const err = new parse_error_1.ParseError(result.error, '/work/.hammerkit.yaml');
-        expect(err).toBeInstanceOf(Error);
-        expect(err.zod).toBe(result.error);
-        expect(err.buildFilePath).toBe('/work/.hammerkit.yaml');
-        expect(err.message).toBe('parse error');
-    });
-});
-//# sourceMappingURL=parse-error.spec.js.map