hammerkit 1.5.1 → 1.6.0-alpha.1

package/dist/cli.js

@@ -1,97 +1,127 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCli = exports.isCliService = exports.isCliTask = void 0;
-const plan_work_nodes_1 = require("./planner/utils/plan-work-nodes");
-const create_scheduler_state_1 = require("./executer/create-scheduler-state");
+exports.getCli = exports.Cli = exports.isCliService = exports.isCliTask = void 0;
+const plan_work_tasks_1 = require("./planner/utils/plan-work-tasks");
 const ci_1 = require("./utils/ci");
 const get_logger_1 = require("./console/get-logger");
-const schedule_1 = require("./executer/schedule");
 const event_cache_1 = require("./executer/event-cache");
 const validate_1 = require("./planner/validate");
 const process_manager_1 = require("./executer/process-manager");
-const remove_container_1 = require("./docker/remove-container");
+const update_service_status_1 = require("./service/update-service-status");
+const check_for_loop_1 = require("./executer/scheduler/check-for-loop");
+const state_1 = require("./executer/state");
+const get_scheduler_execute_result_1 = require("./executer/get-scheduler-execute-result");
+const reset_work_tree_1 = require("./executer/reset-work-tree");
+const execute_work_tree_1 = require("./executer/execute-work-tree");
+const package_1 = require("./docker/package");
 const isCliTask = (val) => val.type === 'task';
 exports.isCliTask = isCliTask;
 const isCliService = (val) => val.type === 'service';
 exports.isCliService = isCliService;
-function getCli(workTree, environment) {
-    return {
-        execWatch(options) {
-            const processManager = new process_manager_1.ProcessManager(environment, options?.workers ?? 0);
-            const state = (0, create_scheduler_state_1.createSchedulerState)({
-                services: workTree.services,
-                nodes: workTree.nodes,
-                watch: options?.watch ?? false,
-                logMode: options?.logMode ?? ci_1.isCI ? 'live' : 'interactive',
-                cacheMethod: options?.cacheDefault ?? 'checksum',
-            });
-            const logMode = options?.logMode ?? (ci_1.isCI ? 'live' : 'interactive');
-            const logger = (0, get_logger_1.getLogger)(logMode, state, environment);
-            return {
-                state,
-                processManager,
-                start: async () => {
-                    const result = await (0, schedule_1.schedule)(processManager, state, environment);
-                    await logger.complete(result, environment);
-                    return result;
-                },
-            };
-        },
-        async shutdown() {
-            for (const node of (0, plan_work_nodes_1.iterateWorkNodes)(workTree.nodes)) {
-                const containers = await environment.docker.listContainers({
-                    all: true,
-                    filters: {
-                        label: [`hammerkit-id=${node.id}`],
-                    },
-                });
-                for (const container of containers) {
-                    await (0, remove_container_1.removeContainer)(environment.docker.getContainer(container.Id));
-                }
-            }
-            for (const service of (0, plan_work_nodes_1.iterateWorkServices)(workTree.services)) {
-                const containers = await environment.docker.listContainers({
-                    all: true,
-                    filters: {
-                        label: [`hammerkit-id=${service.id}`],
-                    },
-                });
-                for (const container of containers) {
-                    await (0, remove_container_1.removeContainer)(environment.docker.getContainer(container.Id));
+class Cli {
+    constructor(workTree, environment) {
+        this.workTree = workTree;
+        this.environment = environment;
+    }
+    setup(type, options) {
+        const processManager = new process_manager_1.ProcessManager(options?.workers ?? 0);
+        const logMode = options?.logMode ?? (ci_1.isCI ? 'live' : 'interactive');
+        const workTree = (0, reset_work_tree_1.resetWorkTree)(this.workTree, type);
+        const processWorkTree = new state_1.State(workTree, {
+            subStates: [
+                ...Object.values(workTree.services).map((s) => s.state),
+                ...Object.values(workTree.tasks).map((s) => s.state),
+            ],
+        });
+        const logger = (0, get_logger_1.getLogger)(logMode, processWorkTree, this.environment);
+        return {
+            state: processWorkTree,
+            start: async () => {
+                (0, check_for_loop_1.checkForLoop)(workTree);
+                if (!(0, plan_work_tasks_1.hasError)(workTree)) {
+                    await (0, update_service_status_1.updateServiceStatus)(workTree);
+                    await (0, execute_work_tree_1.executeWorkTree)(workTree, this.environment, {
+                        daemon: options?.daemon ?? false,
+                        watch: options?.watch ?? false,
+                        logMode,
+                        cacheDefault: options?.cacheDefault ?? 'checksum',
+                        workers: options?.workers ?? 0,
+                        processManager,
+                        type,
+                    });
                 }
-            }
-        },
-        async exec(options) {
-            return this.execWatch(options).start();
-        },
-        async clean(options) {
-            await (0, event_cache_1.cleanCache)(workTree, environment, {
-                service: options?.service ?? false,
-            });
-        },
-        async restore(path) {
-            await (0, event_cache_1.restoreCache)(path, workTree, environment);
-        },
-        async store(path) {
-            await (0, event_cache_1.storeCache)(path, workTree, environment);
-        },
-        ls() {
-            return [
-                ...Array.from((0, plan_work_nodes_1.iterateWorkServices)(workTree.services)).map((item) => ({ item, type: 'service' })),
-                ...Array.from((0, plan_work_nodes_1.iterateWorkNodes)(workTree.nodes)).map((item) => ({ item, type: 'task' })),
-            ];
-        },
-        validate() {
-            return (0, validate_1.validate)(workTree, environment);
-        },
-        node(name) {
-            const node = Object.values(workTree.nodes).find((n) => n.name == name);
-            if (!node) {
-                throw new Error(`unable to find node ${name}`);
-            }
-            return node;
-        },
-    };
+                const result = (0, get_scheduler_execute_result_1.getSchedulerExecuteResult)(workTree);
+                await logger.complete(result, this.environment);
+                return result;
+            },
+        };
+    }
+    up(options) {
+        return this.setup('up', options);
+    }
+    async runUp(options) {
+        const run = this.up(options);
+        return await run.start();
+    }
+    down() {
+        return this.setup('down', {});
+    }
+    async runDown() {
+        const run = await this.down();
+        return await run.start();
+    }
+    exec(options) {
+        return this.setup('execute', options);
+    }
+    async runExec(options) {
+        const run = this.exec(options);
+        return await run.start();
+    }
+    async clean(options) {
+        await (0, event_cache_1.cleanCache)(this.workTree, this.environment, options);
+    }
+    async restore(path) {
+        await (0, event_cache_1.restoreCache)(this.environment, path, this.workTree);
+    }
+    async package(options) {
+        await (0, package_1.packageWorkTree)(this.workTree, this.environment, options);
+    }
+    async store(path) {
+        await (0, event_cache_1.storeCache)(this.environment, path, this.workTree);
+    }
+    services() {
+        return Array.from((0, plan_work_tasks_1.iterateWorkServices)(this.workTree)).map((item) => ({
+            item,
+            type: 'service',
+        }));
+    }
+    tasks() {
+        return Array.from((0, plan_work_tasks_1.iterateWorkTasks)(this.workTree)).map((item) => ({ item, type: 'task' }));
+    }
+    ls() {
+        return [...this.services(), ...this.tasks()];
+    }
+    validate() {
+        return (0, validate_1.validate)(this.workTree, this.environment);
+    }
+    task(name) {
+        const task = this.workTree.tasks[name];
+        if (!task) {
+            throw new Error(`unable to find task ${name}`);
+        }
+        return task;
+    }
+    service(name) {
+        const service = this.workTree.services[name];
+        if (!service) {
+            throw new Error(`unable to find service ${name}`);
+        }
+        return service;
+    }
+}
+exports.Cli = Cli;
+function getCli(workTree, environment) {
+    return new Cli(workTree, environment);
 }
 exports.getCli = getCli;
 //# sourceMappingURL=cli.js.map

package/dist/cli.spec.js

@@ -1,5 +1,23 @@
 "use strict";
-describe('cli', () => {
-    it('should warn about empty cli', () => { });
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const test_case_1 = require("./testing/test-case");
+const program_1 = require("./program");
+// Drives the real parse pipeline (createCli) over an in-memory build file and
+// then exercises Cli lookups against the resulting work tree — a real "not
+// found" situation, no mocking.
+describe('Cli', () => {
+    it('service() throws for an unknown service name', async () => {
+        const testCase = (0, test_case_1.createTestCase)('cli-service', {
+            '.hammerkit.yaml': {
+                services: { api: { image: 'nginx', ports: [] } },
+                tasks: { build: { cmds: ['tsc'], needs: ['api'] } },
+            },
+        });
+        await testCase.setup(async (cwd, environment) => {
+            const cli = await (0, program_1.createCli)((0, path_1.join)(cwd, '.hammerkit.yaml'), environment, { taskName: 'build' });
+            expect(() => cli.service('missing')).toThrow('unable to find service missing');
+        });
+    });
 });
 //# sourceMappingURL=cli.spec.js.map

package/dist/console/get-logger.spec.js

@@ -0,0 +1,23 @@
+"use strict";
+// Verifies getLogger dispatches to the right logger by name and rejects an
+// unknown mode via failNever — the actual loggers are tested elsewhere.
+Object.defineProperty(exports, "__esModule", { value: true });
+vi.mock('../logging/grouped-logger', () => ({ groupedLogger: vi.fn(() => 'grouped-instance') }));
+vi.mock('../logging/live-logger', () => ({ liveLogger: vi.fn(() => 'live-instance') }));
+vi.mock('../logging/interactive-logger', () => ({ interactiveLogger: vi.fn(() => 'interactive-instance') }));
+const get_logger_1 = require("./get-logger");
+describe('getLogger', () => {
+    it('returns the grouped logger for mode "grouped"', () => {
+        expect((0, get_logger_1.getLogger)('grouped', {}, {})).toBe('grouped-instance');
+    });
+    it('returns the live logger for mode "live"', () => {
+        expect((0, get_logger_1.getLogger)('live', {}, {})).toBe('live-instance');
+    });
+    it('returns the interactive logger for mode "interactive"', () => {
+        expect((0, get_logger_1.getLogger)('interactive', {}, {})).toBe('interactive-instance');
+    });
+    it('throws on an unknown mode (failNever)', () => {
+        expect(() => (0, get_logger_1.getLogger)('bogus', {}, {})).toThrow();
+    });
+});
+//# sourceMappingURL=get-logger.spec.js.map

package/dist/docker/get-default-platform.spec.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const package_1 = require("./package");
+describe('docker/getDefaultPlatform', () => {
+    const realArch = process.arch;
+    function setArch(arch) {
+        Object.defineProperty(process, 'arch', { value: arch, configurable: true });
+    }
+    afterEach(() => {
+        Object.defineProperty(process, 'arch', { value: realArch, configurable: true });
+    });
+    it('maps x64 to linux/amd64', () => {
+        setArch('x64');
+        expect((0, package_1.getDefaultPlatform)()).toBe('linux/amd64');
+    });
+    it('maps arm64 to linux/arm64', () => {
+        setArch('arm64');
+        expect((0, package_1.getDefaultPlatform)()).toBe('linux/arm64');
+    });
+    it('maps arm to linux/arm', () => {
+        setArch('arm');
+        expect((0, package_1.getDefaultPlatform)()).toBe('linux/arm');
+    });
+    it('falls back to linux/amd64 for unknown architectures', () => {
+        setArch('mips');
+        expect((0, package_1.getDefaultPlatform)()).toBe('linux/amd64');
+    });
+});
+//# sourceMappingURL=get-default-platform.spec.js.map

package/dist/docker/longest-common-prefix.spec.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const package_1 = require("./package");
+// helper to build OS-correct absolute-ish paths
+const p = (...segs) => path_1.sep + segs.join(path_1.sep);
+describe('longestCommonPrefix (package build context root)', () => {
+    it('returns the directory of a single source, not the file itself', () => {
+        // regression: a single source used to yield the full file path, so the
+        // build-context copy targeted a directory and failed with EISDIR.
+        expect((0, package_1.longestCommonPrefix)([p('a', 'b', 'hello.txt')])).toBe(p('a', 'b'));
+    });
+    it('returns the common parent of files in the same directory', () => {
+        expect((0, package_1.longestCommonPrefix)([p('a', 'x.txt'), p('a', 'y.txt')])).toBe(p('a'));
+    });
+    it('returns the common ancestor across nested directories', () => {
+        expect((0, package_1.longestCommonPrefix)([p('a', 'x.txt'), p('a', 'b', 'y.txt')])).toBe(p('a'));
+    });
+    it('compares per path segment, not per character', () => {
+        expect((0, package_1.longestCommonPrefix)([p('a', 'foo'), p('a', 'foobar')])).toBe(p('a'));
+    });
+    it('returns empty for no sources', () => {
+        expect((0, package_1.longestCommonPrefix)([])).toBe('');
+    });
+});
+//# sourceMappingURL=longest-common-prefix.spec.js.map

package/dist/docker/package.js

@@ -0,0 +1,283 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.longestCommonPrefix = exports.packageWorkTree = exports.getDefaultPlatform = void 0;
+const plan_work_tasks_1 = require("../planner/utils/plan-work-tasks");
+const work_item_1 = require("../planner/work-item");
+const execute_docker_1 = require("../executer/execute-docker");
+const node_os_1 = require("node:os");
+const path_1 = require("path");
+const log_1 = require("../log");
+// Default the build platform to the host architecture so a packaged image runs
+// where it was built unless the caller overrides it with `--platform`. Maps
+// node's `process.arch` to docker's platform arch naming.
+function getDefaultPlatform() {
+    const archByNodeArch = {
+        x64: 'amd64',
+        arm64: 'arm64',
+        arm: 'arm',
+    };
+    const arch = archByNodeArch[process.arch] ?? 'amd64';
+    return `linux/${arch}`;
+}
+exports.getDefaultPlatform = getDefaultPlatform;
+async function packageWorkTree(workTree, environment, options) {
+    if (workTree.environment.type !== 'docker') {
+        throw new Error('only docker environments are supported');
+    }
+    const docker = (0, execute_docker_1.getContainerCli)(workTree.environment);
+    const platform = options.platform ?? getDefaultPlatform();
+    const tag = options.tag ?? 'latest';
+    for (const service of (0, plan_work_tasks_1.iterateWorkServices)(workTree)) {
+        if ((0, work_item_1.isContainerWorkServiceItem)(service)) {
+            environment.console.info(`preparing files for ${service.name}`);
+            const definition = getServiceInstructions(service, options);
+            const buildDir = (0, path_1.join)((0, node_os_1.tmpdir)(), service.id());
+            const dockerFileName = (0, path_1.join)(buildDir, 'Dockerfile');
+            const dockerFileContent = definition.instructions.join('\n');
+            await environment.file.createDirectory(buildDir);
+            await environment.file.writeFile(dockerFileName, dockerFileContent);
+            environment.console.debug(`create dockerfile ${dockerFileName}`);
+            environment.console.debug(`with cwd ${definition.cwd}`);
+            const src = ['Dockerfile'];
+            for (const source of definition.sources) {
+                const path = (0, path_1.relative)(definition.cwd, source.absolutePath);
+                environment.console.debug(`copying ${source.absolutePath} to ${(0, path_1.join)(buildDir, path)}`);
+                await environment.file.copy(source.absolutePath, (0, path_1.join)(buildDir, path));
+                src.push(path);
+            }
+            const imageName = `${options.registry}/${service.name}:${tag}`;
+            environment.console.info(`building image ${imageName} for ${service.name} (${platform})`);
+            const buildStream = await docker.buildImage({
+                src,
+                context: buildDir,
+            }, {
+                t: imageName,
+                platform,
+                abortSignal: environment.abortCtrl.signal,
+            });
+            await new Promise((resolve, reject) => {
+                docker.modem.followProgress(buildStream, (err, res) => {
+                    if (err) {
+                        environment.console.error((0, log_1.getErrorMessage)(err));
+                        reject(err);
+                        return;
+                    }
+                    // followProgress returns every build message in `res`, so a
+                    // non-empty array is normal on success. Only fail when an entry
+                    // actually carries an error.
+                    const failure = (res ?? []).find((i) => 'error' in i && !!i.error);
+                    if (failure && 'error' in failure) {
+                        const detail = failure.errorDetail?.message ?? failure.error ?? 'unknown error';
+                        environment.console.error(detail);
+                        reject(new Error(`build failed: ${detail}`));
+                    }
+                    else {
+                        resolve();
+                    }
+                }, (res) => {
+                    if (res.stream) {
+                        if (res.stream === '\n') {
+                            return;
+                        }
+                        if (res.stream.endsWith('\n')) {
+                            environment.console.info(res.stream.substr(0, res.stream.length - 1));
+                        }
+                        else {
+                            environment.console.info(res.stream);
+                        }
+                    }
+                });
+            });
+            environment.console.info(`generated image ${imageName} for ${service.name}`);
+            if (options.push) {
+                environment.console.info(`pushing image ${imageName} to ${options.registry}`);
+                const img = docker.getImage(imageName);
+                const pushStream = await img.push({
+                    abortSignal: environment.abortCtrl.signal,
+                    authconfig: {
+                        username: options.username || '',
+                        password: options.password || '',
+                        serveraddress: options.registry,
+                    },
+                });
+                await new Promise((resolve, reject) => {
+                    docker.modem.followProgress(pushStream, (err, res) => (err ? reject(err) : resolve(res)), (res) => {
+                        if (res.stream) {
+                            environment.console.info(res.stream);
+                        }
+                    });
+                });
+                environment.console.info(`pushed image ${imageName} to ${options.registry}`);
+            }
+        }
+    }
+}
+exports.packageWorkTree = packageWorkTree;
+function getDependencySources(service, taskIds) {
+    const result = [...service.data.src.filter((s) => !s.inherited)];
+    taskIds.push(service.id());
+    for (const dep of service.deps) {
+        if (taskIds.includes(dep.id())) {
+            continue;
+        }
+        if ((0, work_item_1.isLocalWorkTaskItem)(dep)) {
+            throw new Error(`local tasks (${dep.name}) are not yet supported`);
+        }
+        if ((0, work_item_1.isContainerWorkTaskItem)(dep)) {
+            result.push(...getDependencySources(dep, taskIds));
+        }
+    }
+    return result;
+}
+function getDependencyCwd(cwd, service) {
+    const sources = getDependencySources(service, []);
+    return longestCommonPrefix(sources.map((s) => s.absolutePath));
+}
+// Longest common *directory* of the given (absolute file) paths. Compared per
+// path segment, not per character, so `/a/foo` and `/a/foobar` share `/a`, not
+// `/a/foo`. When every path is identical (e.g. a single source) the shared
+// prefix would be the file itself, so the final segment is dropped to land on
+// its directory — otherwise the build context copy targets a directory and
+// fails with EISDIR.
+function longestCommonPrefix(strs) {
+    if (strs.length === 0) {
+        return '';
+    }
+    const segments = strs.map((s) => s.split(path_1.sep));
+    const minLength = Math.min(...segments.map((s) => s.length));
+    const common = [];
+    for (let i = 0; i < minLength; i++) {
+        const segment = segments[0][i];
+        if (segments.every((s) => s[i] === segment)) {
+            common.push(segment);
+        }
+        else {
+            break;
+        }
+    }
+    if (common.length > 0 && segments.every((s) => s.length === common.length)) {
+        common.pop();
+    }
+    return common.join(path_1.sep);
+}
+exports.longestCommonPrefix = longestCommonPrefix;
+// Root the packaged files under a real directory instead of the image's `/`.
+// Building at `/` breaks tooling that walks up for config and treats the root
+// specially — e.g. `npm install` fails with `Tracker "idealTree" already
+// exists` when WORKDIR is `/` (which happens whenever a task's cwd is the build
+// context root). Paths inside the image become `${CONTAINER_ROOT}/<relative>`.
+const CONTAINER_ROOT = '/hammerkit';
+function toContainerPath(relativePath) {
+    const normalized = relativePath.split(path_1.sep).join('/');
+    return normalized === '' ? CONTAINER_ROOT : `${CONTAINER_ROOT}/${normalized}`;
+}
+function getServiceInstructions(service, options) {
+    const dependencyCwd = getDependencyCwd(service.data.cwd, service);
+    const tasks = {};
+    const deps = getDependencyInstructions(dependencyCwd, service, tasks);
+    // const orderedDeps = Object.entries(tasks).sort(([, a], [, b]) => a.order - b.order)
+    const instructions = [
+        ...Object.values(tasks).flatMap((t) => t.instructions),
+        `FROM ${service.data.image} as service-${service.id()}`,
+        `LABEL hammerkit.dev/id=${service.id()}`,
+        `LABEL hammerkit.dev/name=${service.name}`,
+        ...Object.entries(service.data.envs.variables).map(([key, value]) => `ENV ${key}=${value}`),
+        ...service.data.ports.map((p) => `EXPOSE ${p.containerPort}`),
+        `WORKDIR ${toContainerPath((0, path_1.relative)(dependencyCwd, service.data.cwd))}`,
+        options.overrideUser ? 'RUN (addgroup -g 1000 hammerkit && adduser -u 1000 -G hammerkit -s /bin/sh) || true' : '',
+        ...service.data.src.map((s) => `COPY ${(0, path_1.relative)(dependencyCwd, s.absolutePath)} ${toContainerPath((0, path_1.relative)(dependencyCwd, s.absolutePath))}`),
+        ...deps.flatMap((d) => d.exports),
+        ...(options.overrideUser
+            ? service.data.src
+                .filter((s) => !s.inherited)
+                .map((v) => `RUN chown -R 1000:1000 ${toContainerPath((0, path_1.relative)(dependencyCwd, v.absolutePath))}`)
+            : []),
+        ...service.data.volumes
+            .filter((v) => !v.inherited)
+            .map((v) => `VOLUME ${toContainerPath((0, path_1.relative)(dependencyCwd, v.containerPath))}`),
+        ...(options.overrideUser
+            ? service.data.volumes.map((v) => `RUN chown -R 1000:1000 ${toContainerPath((0, path_1.relative)(dependencyCwd, v.containerPath))}`)
+            : []),
+        options.overrideUser ? 'USER 1000:1000' : '',
+    ];
+    if (service.data.cmd) {
+        instructions.push(`CMD [${[service.data.cmd.parsed.command, ...service.data.cmd.parsed.args].map((p) => `"${p}"`).join(', ')}]`);
+    }
+    return {
+        id: service.id(),
+        instructions,
+        cwd: dependencyCwd,
+        exports: [],
+        deps,
+        order: 0,
+        sources: [
+            ...Object.values(tasks).flatMap((t) => t.sources),
+            ...service.data.src
+                .filter((s) => !s.inherited)
+                .map((s) => ({
+                absolutePath: s.absolutePath,
+                matcher: s.matcher,
+            })),
+        ],
+    };
+}
+function getDependencyInstructions(cwd, task, taskIds) {
+    return task.deps.map((dep) => {
+        if (taskIds[dep.id()]) {
+            return taskIds[dep.id()];
+        }
+        else {
+            const data = dep.data;
+            if (data.type === 'local-task') {
+                throw new Error(`local tasks (${task.name}) are not yet supported`);
+            }
+            return getTaskInstructions(cwd, { ...dep, data }, taskIds);
+        }
+    });
+}
+function resolveRecursiveDependencies(deps, result) {
+    for (const dep of deps) {
+        if (result[dep.id]) {
+            continue;
+        }
+        else {
+            result[dep.id] = dep;
+            resolveRecursiveDependencies(dep.deps, result);
+        }
+    }
+    return Object.values(result);
+}
+function getTaskInstructions(cwd, task, taskIds) {
+    const deps = getDependencyInstructions(cwd, task, taskIds);
+    const deepDeps = resolveRecursiveDependencies(deps, {});
+    const instructions = {
+        id: task.id(),
+        instructions: [
+            `FROM ${task.data.image} as task-${task.id()}`,
+            ...Object.entries(task.data.envs.variables).map(([key, value]) => `ENV ${key}=${value}`),
+            `WORKDIR ${toContainerPath((0, path_1.relative)(cwd, task.data.cwd))}`,
+            ...task.data.mounts.map((m) => `COPY ${(0, path_1.relative)(cwd, m.localPath)} ${toContainerPath((0, path_1.relative)(cwd, m.containerPath))}`),
+            ...deepDeps.flatMap((t) => t.sources.map((s) => `COPY --from=task-${t.id} ${toContainerPath((0, path_1.relative)(cwd, s.absolutePath))} ${toContainerPath((0, path_1.relative)(cwd, s.absolutePath))}`)),
+            ...deepDeps.flatMap((d) => d.exports),
+            ...task.data.src
+                .filter((s) => !s.inherited)
+                .map((s) => `COPY ${(0, path_1.relative)(cwd, s.absolutePath)} ${toContainerPath((0, path_1.relative)(cwd, s.absolutePath))}`),
+            ...task.data.cmds.map((command) => `RUN ${command.cmd}`),
+            '####################',
+        ],
+        cwd,
+        sources: [
+            ...task.data.src.filter((s) => !s.inherited).map((s) => ({ absolutePath: s.absolutePath, matcher: s.matcher })),
+        ],
+        exports: [
+            ...task.data.generates
+                .filter((g) => !g.inherited)
+                .map((generate) => `COPY --from=task-${task.id()} ${toContainerPath((0, path_1.relative)(cwd, generate.path))} ${toContainerPath((0, path_1.relative)(cwd, generate.path))}`),
+        ],
+        deps,
+        order: deps.reduce((acc, dep) => Math.max(acc, dep.order), 0) + 1,
+    };
+    taskIds[task.id()] = instructions;
+    return instructions;
+}
+//# sourceMappingURL=package.js.map