hammerkit 1.5.1 → 1.6.0-alpha.1

package/dist/schema/build-file-kubernetes-service-selector-schema.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFileKubernetesServiceSelectorSchema = void 0;
+const zod_1 = require("zod");
+exports.buildFileKubernetesServiceSelectorSchema = (0, zod_1.object)({
+    type: (0, zod_1.string)(),
+    name: (0, zod_1.string)(),
+});
+//# sourceMappingURL=build-file-kubernetes-service-selector-schema.js.map

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFileLocalPlatformSchema = void 0;
+const zod_1 = require("zod");
+exports.buildFileLocalPlatformSchema = (0, zod_1.object)({
+    os: (0, zod_1.union)([(0, zod_1.literal)('win'), (0, zod_1.literal)('macos'), (0, zod_1.literal)('linux')]).optional(),
+    arch: (0, zod_1.union)([(0, zod_1.literal)('arm64'), (0, zod_1.literal)('arm')]).optional(),
+});
+//# sourceMappingURL=build-file-local-platform-schema.js.map

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFileLocalTaskSchema = void 0;
+const build_file_base_task_schema_1 = require("./build-file-base-task-schema");
+const build_file_local_platform_schema_1 = require("./build-file-local-platform-schema");
+exports.buildFileLocalTaskSchema = build_file_base_task_schema_1.buildFileBaseTaskSchema
+    .extend({
+    platform: build_file_local_platform_schema_1.buildFileLocalPlatformSchema.optional(),
+})
+    .strict()
+    .describe('local task');
+//# sourceMappingURL=build-file-local-task-schema.js.map

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFileNeedSchema = void 0;
+const zod_1 = require("zod");
+exports.buildFileNeedSchema = (0, zod_1.union)([
+    (0, zod_1.string)(),
+    (0, zod_1.object)({
+        service: (0, zod_1.string)(),
+        name: (0, zod_1.string)(),
+    }),
+]);
+//# sourceMappingURL=build-file-need-schema.js.map

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFileSchema = void 0;
+const zod_1 = require("zod");
+const envs_schema_1 = require("./envs-schema");
+const build_file_service_schema_1 = require("./build-file-service-schema");
+const build_file_environment_schema_1 = require("./build-file-environment-schema");
+const build_file_task_schema_1 = require("./build-file-task-schema");
+const labels_schema_1 = require("./labels-schema");
+const cache_schema_1 = require("./cache-schema");
+exports.buildFileSchema = (0, zod_1.object)({
+    envs: envs_schema_1.envsSchema.optional(),
+    tasks: (0, zod_1.record)(build_file_task_schema_1.buildFileTaskSchema).optional(),
+    services: (0, zod_1.record)(build_file_service_schema_1.buildFileServiceSchema).optional(),
+    references: (0, zod_1.record)((0, zod_1.string)()).optional(),
+    includes: (0, zod_1.record)((0, zod_1.string)()).optional(),
+    environments: (0, zod_1.record)(build_file_environment_schema_1.buildFileEnvironmentSchema).optional(),
+    caches: (0, zod_1.record)(cache_schema_1.buildFileCacheSchema).optional(),
+    labels: labels_schema_1.labelsSchema.optional(),
+})
+    .strict()
+    .describe('Build file with support for containerization\nhttps://no0dles.gitbook.io/hammerkit/build-file');
+//# sourceMappingURL=build-file-schema.js.map

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

@@ -0,0 +1,61 @@
+"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/build-file-service-container-healthcheck.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFileServiceContainerHealthcheck = void 0;
+const zod_1 = require("zod");
+exports.buildFileServiceContainerHealthcheck = (0, zod_1.object)({
+    cmd: (0, zod_1.string)(),
+});
+//# sourceMappingURL=build-file-service-container-healthcheck.js.map

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBuildFileContainerSchema = exports.isBuildFileKubernetesServiceSchema = exports.buildFileServiceSchema = void 0;
+const zod_1 = require("zod");
+const build_file_container_service_schema_1 = require("./build-file-container-service-schema");
+const build_file_kubernetes_service_schema_1 = require("./build-file-kubernetes-service-schema");
+exports.buildFileServiceSchema = (0, zod_1.union)([
+    build_file_container_service_schema_1.buildFileContainerServiceSchema,
+    build_file_kubernetes_service_schema_1.buildFileKubernetesServiceSchema,
+]).describe('service');
+const isBuildFileKubernetesServiceSchema = (val) => 'selector' in val;
+exports.isBuildFileKubernetesServiceSchema = isBuildFileKubernetesServiceSchema;
+const isBuildFileContainerSchema = (val) => 'image' in val;
+exports.isBuildFileContainerSchema = isBuildFileContainerSchema;
+//# sourceMappingURL=build-file-service-schema.js.map

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFileTaskCommandSchema = void 0;
+const zod_1 = require("zod");
+exports.buildFileTaskCommandSchema = (0, zod_1.union)([
+    (0, zod_1.string)(),
+    (0, zod_1.object)({
+        cmd: (0, zod_1.string)(),
+        path: (0, zod_1.string)().optional(),
+    }),
+]);
+//# sourceMappingURL=build-file-task-command-schema.js.map

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBuildFileLocalTaskSchema = exports.isBuildFileContainerTaskSchema = exports.buildFileTaskSchema = void 0;
+const zod_1 = require("zod");
+const build_file_container_task_schema_1 = require("./build-file-container-task-schema");
+const build_file_local_task_schema_1 = require("./build-file-local-task-schema");
+exports.buildFileTaskSchema = (0, zod_1.union)([build_file_container_task_schema_1.buildFileContainerTaskSchema, build_file_local_task_schema_1.buildFileLocalTaskSchema]);
+const isBuildFileContainerTaskSchema = (val) => 'image' in val;
+exports.isBuildFileContainerTaskSchema = isBuildFileContainerTaskSchema;
+const isBuildFileLocalTaskSchema = (val) => !('image' in val);
+exports.isBuildFileLocalTaskSchema = isBuildFileLocalTaskSchema;
+//# sourceMappingURL=build-file-task-schema.js.map

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFileVolumeSchema = void 0;
+const zod_1 = require("zod");
+exports.buildFileVolumeSchema = (0, zod_1.union)([
+    (0, zod_1.string)(),
+    (0, zod_1.object)({
+        export: (0, zod_1.boolean)().optional(),
+        resetOnChange: (0, zod_1.boolean)().optional(),
+        path: (0, zod_1.string)(),
+        name: (0, zod_1.string)().optional(),
+    }),
+]);
+//# sourceMappingURL=build-file-volume-schema.js.map

package/dist/schema/cache-schema.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cacheSchema = exports.taskCacheRefSchema = exports.buildFileCacheSchema = exports.cacheBackendSchema = exports.cacheBackendS3Schema = exports.cacheBackendLocalSchema = exports.cacheMethodSchema = void 0;
+const zod_1 = require("zod");
+exports.cacheMethodSchema = (0, zod_1.union)([(0, zod_1.literal)('checksum'), (0, zod_1.literal)('modify-date'), (0, zod_1.literal)('none')]);
+exports.cacheBackendLocalSchema = (0, zod_1.object)({
+    type: (0, zod_1.literal)('local'),
+    path: (0, zod_1.string)().optional(),
+}).strict();
+exports.cacheBackendS3Schema = (0, zod_1.object)({
+    type: (0, zod_1.literal)('s3'),
+    bucket: (0, zod_1.string)(),
+    region: (0, zod_1.string)().optional(),
+    endpoint: (0, zod_1.string)().optional(),
+    prefix: (0, zod_1.string)().optional(),
+    forcePathStyle: zod_1.z.boolean().optional(),
+}).strict();
+exports.cacheBackendSchema = (0, zod_1.union)([exports.cacheBackendLocalSchema, exports.cacheBackendS3Schema]);
+exports.buildFileCacheSchema = (0, zod_1.object)({
+    method: exports.cacheMethodSchema,
+    backend: exports.cacheBackendSchema,
+}).strict();
+exports.taskCacheRefSchema = (0, zod_1.union)([
+    exports.cacheMethodSchema,
+    (0, zod_1.object)({
+        name: (0, zod_1.string)(),
+        method: exports.cacheMethodSchema.optional(),
+    }).strict(),
+]);
+exports.cacheSchema = exports.taskCacheRefSchema;
+//# sourceMappingURL=cache-schema.js.map

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

@@ -0,0 +1,223 @@
+"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/envs-schema.js

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

package/dist/schema/labels-schema.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.labelsSchema = void 0;
+const zod_1 = require("zod");
+exports.labelsSchema = (0, zod_1.record)((0, zod_1.union)([(0, zod_1.string)(), (0, zod_1.number)()]));
+//# sourceMappingURL=labels-schema.js.map

package/dist/schema/parse-context.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=parse-context.js.map

package/dist/schema/parse-error.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseError = void 0;
+class ParseError extends Error {
+    constructor(zod, buildFilePath) {
+        super('parse error');
+        this.zod = zod;
+        this.buildFilePath = buildFilePath;
+    }
+}
+exports.ParseError = ParseError;
+//# sourceMappingURL=parse-error.js.map

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

@@ -0,0 +1,18 @@
+"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