@livingdata/pipex 0.0.8 → 0.0.10

package/dist/core/event-aggregator.js

@@ -0,0 +1,114 @@
+/**
+ * Reconstructs pipeline session state from a stream of TransportMessages.
+ */
+export class EventAggregator {
+    sessions = new Map();
+    consume(message) {
+        const { event } = message;
+        if (event.event === 'STEP_LOG') {
+            return;
+        }
+        const { jobId } = event;
+        switch (event.event) {
+            case 'PIPELINE_START': {
+                const session = {
+                    workspaceId: event.workspaceId,
+                    jobId,
+                    pipelineName: event.pipelineName,
+                    status: 'running',
+                    startedAt: message.timestamp,
+                    steps: new Map()
+                };
+                for (const step of event.steps) {
+                    session.steps.set(step.id, {
+                        id: step.id,
+                        displayName: step.displayName,
+                        status: 'pending'
+                    });
+                }
+                this.sessions.set(jobId, session);
+                break;
+            }
+            case 'STEP_STARTING': {
+                const step = this.getOrCreateStep(jobId, event.step.id, event.step.displayName);
+                step.status = 'running';
+                break;
+            }
+            case 'STEP_SKIPPED': {
+                const step = this.getOrCreateStep(jobId, event.step.id, event.step.displayName);
+                step.status = 'skipped';
+                if (event.runId) {
+                    step.runId = event.runId;
+                }
+                break;
+            }
+            case 'STEP_FINISHED': {
+                const step = this.getOrCreateStep(jobId, event.step.id, event.step.displayName);
+                step.status = 'finished';
+                if (event.runId) {
+                    step.runId = event.runId;
+                }
+                if (event.durationMs !== undefined) {
+                    step.durationMs = event.durationMs;
+                }
+                if (event.artifactSize !== undefined) {
+                    step.artifactSize = event.artifactSize;
+                }
+                break;
+            }
+            case 'STEP_FAILED': {
+                const step = this.getOrCreateStep(jobId, event.step.id, event.step.displayName);
+                step.status = 'failed';
+                step.exitCode = event.exitCode;
+                break;
+            }
+            case 'PIPELINE_FINISHED': {
+                const session = this.sessions.get(jobId);
+                if (session) {
+                    session.status = 'completed';
+                    session.finishedAt = message.timestamp;
+                }
+                break;
+            }
+            case 'PIPELINE_FAILED': {
+                const session = this.sessions.get(jobId);
+                if (session) {
+                    session.status = 'failed';
+                    session.finishedAt = message.timestamp;
+                }
+                break;
+            }
+            case 'STEP_RETRYING':
+            case 'STEP_WOULD_RUN': {
+                break;
+            }
+        }
+    }
+    getSession(jobId) {
+        return this.sessions.get(jobId);
+    }
+    getAllSessions() {
+        return [...this.sessions.values()];
+    }
+    clear() {
+        this.sessions.clear();
+    }
+    getOrCreateStep(jobId, stepId, displayName) {
+        let session = this.sessions.get(jobId);
+        if (!session) {
+            session = {
+                workspaceId: '',
+                jobId,
+                status: 'running',
+                steps: new Map()
+            };
+            this.sessions.set(jobId, session);
+        }
+        let step = session.steps.get(stepId);
+        if (!step) {
+            step = { id: stepId, displayName, status: 'pending' };
+            session.steps.set(stepId, step);
+        }
+        return step;
+    }
+}

package/dist/core/index.js

@@ -0,0 +1,14 @@
+export { PipelineRunner } from './pipeline-runner.js';
+export { StepRunner } from './step-runner.js';
+export { PipelineLoader } from './pipeline-loader.js';
+export { loadStepFile } from './step-loader.js';
+export { resolveStep, validateStep } from './step-resolver.js';
+export { StateManager } from './state.js';
+export { ConsoleReporter } from './reporter.js';
+export { StreamReporter, CompositeReporter } from './stream-reporter.js';
+export { InMemoryTransport } from './transport.js';
+export { EventAggregator } from './event-aggregator.js';
+export { buildGraph, validateGraph, topologicalLevels, subgraph, leafNodes } from './dag.js';
+export { collectDependencies, buildIgnoreFilter, buildBundle, extractBundle } from './bundle.js';
+export { evaluateCondition } from './condition.js';
+export { dirSize, formatSize, formatDuration } from './utils.js';

package/dist/core/pipeline-loader.js

@@ -0,0 +1,81 @@
+import { readFile } from 'node:fs/promises';
+import { extname } from 'node:path';
+import { deburr } from 'lodash-es';
+import { parse as parseYaml } from 'yaml';
+import { ValidationError } from '../errors.js';
+import { buildGraph, validateGraph } from './dag.js';
+import { resolveStep, validateStep } from './step-resolver.js';
+export class PipelineLoader {
+    async load(filePath) {
+        const content = await readFile(filePath, 'utf8');
+        return this.parse(content, filePath);
+    }
+    parse(content, filePath) {
+        const input = parsePipelineFile(content, filePath);
+        if (!input.id && !input.name) {
+            throw new ValidationError('Invalid pipeline: at least one of "id" or "name" must be defined');
+        }
+        const pipelineId = input.id ?? slugify(input.name);
+        if (!Array.isArray(input.steps) || input.steps.length === 0) {
+            throw new ValidationError('Invalid pipeline: steps must be a non-empty array');
+        }
+        const steps = input.steps.map(step => resolveStep(step));
+        for (const step of steps) {
+            validateStep(step);
+        }
+        this.validateUniqueStepIds(steps);
+        const graph = buildGraph(steps);
+        validateGraph(graph, steps);
+        return { id: pipelineId, name: input.name, steps };
+    }
+    validateUniqueStepIds(steps) {
+        const seen = new Set();
+        for (const step of steps) {
+            if (seen.has(step.id)) {
+                throw new ValidationError(`Duplicate step id: '${step.id}'`);
+            }
+            seen.add(step.id);
+        }
+    }
+}
+/** Convert a free-form name into a valid identifier. */
+export function slugify(name) {
+    return deburr(name)
+        .toLowerCase()
+        .replaceAll(/[^\w-]/g, '-')
+        .replaceAll(/-{2,}/g, '-')
+        .replace(/^-/, '')
+        .replace(/-$/, '');
+}
+export function parsePipelineFile(content, filePath) {
+    const ext = extname(filePath).toLowerCase();
+    if (ext === '.yaml' || ext === '.yml') {
+        return parseYaml(content);
+    }
+    return JSON.parse(content);
+}
+export function mergeEnv(kitEnv, userEnv) {
+    if (!kitEnv && !userEnv) {
+        return undefined;
+    }
+    return { ...kitEnv, ...userEnv };
+}
+export function mergeCaches(kitCaches, userCaches) {
+    if (!kitCaches && !userCaches) {
+        return undefined;
+    }
+    const map = new Map();
+    for (const c of kitCaches ?? []) {
+        map.set(c.name, c);
+    }
+    for (const c of userCaches ?? []) {
+        map.set(c.name, c);
+    }
+    return [...map.values()];
+}
+export function mergeMounts(kitMounts, userMounts) {
+    if (!kitMounts && !userMounts) {
+        return undefined;
+    }
+    return [...(kitMounts ?? []), ...(userMounts ?? [])];
+}

package/dist/core/pipeline-runner.js

@@ -0,0 +1,360 @@
+import process from 'node:process';
+import { randomUUID } from 'node:crypto';
+import { cpus } from 'node:os';
+import { cp, writeFile } from 'node:fs/promises';
+import { setTimeout } from 'node:timers/promises';
+import { createWriteStream } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { Workspace } from '../engine/index.js';
+import { ContainerCrashError, PipexError } from '../errors.js';
+import { loadEnvFile } from './env-file.js';
+import { buildGraph, topologicalLevels, subgraph, leafNodes } from './dag.js';
+import { evaluateCondition } from './condition.js';
+import { StateManager } from './state.js';
+import { dirSize, resolveHostPath } from './utils.js';
+/**
+ * Orchestrates pipeline execution with DAG-based parallel execution and caching.
+ */
+export class PipelineRunner {
+    loader;
+    runtime;
+    reporter;
+    workdirRoot;
+    constructor(loader, runtime, reporter, workdirRoot) {
+        this.loader = loader;
+        this.runtime = runtime;
+        this.reporter = reporter;
+        this.workdirRoot = workdirRoot;
+    }
+    async run(pipelineFilePath, options) {
+        const { workspace: workspaceName, force, dryRun, target, concurrency, envFile } = options ?? {};
+        const config = await this.loader.load(pipelineFilePath);
+        const pipelineRoot = dirname(resolve(pipelineFilePath));
+        const workspaceId = workspaceName ?? config.id;
+        let workspace;
+        try {
+            workspace = await Workspace.open(this.workdirRoot, workspaceId);
+        }
+        catch {
+            workspace = await Workspace.create(this.workdirRoot, workspaceId);
+        }
+        await workspace.cleanupStaging();
+        await workspace.cleanupRunning();
+        if (!dryRun) {
+            await this.runtime.check();
+            await this.runtime.cleanupContainers(workspace.id);
+        }
+        const cliEnv = envFile ? await loadEnvFile(resolve(envFile)) : undefined;
+        const state = new StateManager(workspace.root);
+        await state.load();
+        const stepRuns = new Map();
+        let totalArtifactSize = 0;
+        const job = { workspaceId: workspace.id, jobId: randomUUID() };
+        // Build DAG and determine execution scope
+        const graph = buildGraph(config.steps);
+        const targets = target ?? leafNodes(graph);
+        const activeSteps = subgraph(graph, targets);
+        this.reporter.emit({
+            ...job,
+            event: 'PIPELINE_START',
+            pipelineName: config.name ?? config.id,
+            steps: config.steps
+                .filter(s => activeSteps.has(s.id))
+                .map(s => ({ id: s.id, displayName: s.name ?? s.id }))
+        });
+        const levels = topologicalLevels(graph)
+            .map(level => level.filter(id => activeSteps.has(id)))
+            .filter(level => level.length > 0);
+        const stepMap = new Map(config.steps.map(s => [s.id, s]));
+        const failed = new Set();
+        const skipped = new Set();
+        const maxConcurrency = concurrency ?? cpus().length;
+        for (const level of levels) {
+            const tasks = level.map(stepId => async () => {
+                const step = stepMap.get(stepId);
+                const stepRef = { id: step.id, displayName: step.name ?? step.id };
+                // Check if blocked by a failed/skipped required dependency
+                if (this.isDependencyBlocked(step, failed, skipped)) {
+                    skipped.add(step.id);
+                    this.reporter.emit({ ...job, event: 'STEP_SKIPPED', step: stepRef, reason: 'dependency' });
+                    return 0;
+                }
+                // Evaluate condition
+                if (step.if) {
+                    const conditionMet = await evaluateCondition(step.if, { env: process.env });
+                    if (!conditionMet) {
+                        skipped.add(step.id);
+                        this.reporter.emit({ ...job, event: 'STEP_SKIPPED', step: stepRef, reason: 'condition' });
+                        return 0;
+                    }
+                }
+                // Resolve env vars: CLI envFile < step envFile < step inline env
+                const stepFileEnv = step.envFile
+                    ? await loadEnvFile(resolve(pipelineRoot, step.envFile))
+                    : undefined;
+                const resolvedEnv = (cliEnv ?? stepFileEnv ?? step.env)
+                    ? { ...cliEnv, ...stepFileEnv, ...step.env }
+                    : undefined;
+                // Compute fingerprint
+                const inputRunIds = step.inputs
+                    ?.map(i => stepRuns.get(i.step))
+                    .filter((id) => id !== undefined);
+                const resolvedMounts = step.mounts?.map(m => ({
+                    hostPath: resolveHostPath(pipelineRoot, m.host),
+                    containerPath: m.container
+                }));
+                const currentFingerprint = StateManager.fingerprint({
+                    image: step.image,
+                    cmd: step.cmd,
+                    env: resolvedEnv,
+                    inputRunIds,
+                    mounts: resolvedMounts
+                });
+                // Cache check
+                const skipCache = force === true || (Array.isArray(force) && force.includes(step.id));
+                if (!skipCache && await this.tryUseCache({ workspace, state, step, stepRef, currentFingerprint, stepRuns, job })) {
+                    return 0;
+                }
+                // Dry run
+                if (dryRun) {
+                    this.reporter.emit({ ...job, event: 'STEP_WOULD_RUN', step: stepRef });
+                    return 0;
+                }
+                // Execute
+                this.reporter.emit({ ...job, event: 'STEP_STARTING', step: stepRef });
+                return this.executeStep({ workspace, state, step, stepRef, stepRuns, currentFingerprint, resolvedMounts, pipelineRoot, job, resolvedEnv });
+            });
+            const results = await withConcurrency(tasks, maxConcurrency);
+            // Collect results
+            for (const [i, result] of results.entries()) {
+                const stepId = level[i];
+                if (result.status === 'fulfilled') {
+                    totalArtifactSize += result.value;
+                }
+                else if (!failed.has(stepId)) {
+                    // Step threw an error (ContainerCrashError if not allowFailure)
+                    failed.add(stepId);
+                }
+            }
+            await state.save();
+        }
+        if (failed.size > 0) {
+            this.reporter.emit({ ...job, event: 'PIPELINE_FAILED' });
+            // Re-throw the first failure to signal pipeline failure to the CLI
+            const firstFailedId = [...failed][0];
+            throw new ContainerCrashError(firstFailedId, 1);
+        }
+        this.reporter.emit({ ...job, event: 'PIPELINE_FINISHED', totalArtifactSize });
+    }
+    isDependencyBlocked(step, failed, skippedSteps) {
+        if (!step.inputs) {
+            return false;
+        }
+        return step.inputs.some(input => !input.optional && (failed.has(input.step) || skippedSteps.has(input.step)));
+    }
+    async executeStep({ workspace, state, step, stepRef, stepRuns, currentFingerprint, resolvedMounts, pipelineRoot, job, resolvedEnv }) {
+        const runId = workspace.generateRunId();
+        const stagingPath = await workspace.prepareRun(runId);
+        await workspace.markStepRunning(step.id, { startedAt: new Date().toISOString(), pid: process.pid, stepName: step.name });
+        await this.prepareStagingWithInputs(workspace, step, workspace.runStagingArtifactsPath(runId), stepRuns);
+        if (step.caches) {
+            for (const cache of step.caches) {
+                await workspace.prepareCache(cache.name);
+            }
+        }
+        const { inputs, output, caches, mounts } = this.buildMounts(step, runId, stepRuns, pipelineRoot);
+        const stdoutLog = createWriteStream(join(stagingPath, 'stdout.log'));
+        const stderrLog = createWriteStream(join(stagingPath, 'stderr.log'));
+        try {
+            const maxRetries = step.retries ?? 0;
+            const retryDelay = step.retryDelayMs ?? 5000;
+            let result;
+            for (let attempt = 0; attempt <= maxRetries; attempt++) {
+                try {
+                    result = await this.runtime.run(workspace, {
+                        name: `pipex-${workspace.id}-${step.id}-${Date.now()}`,
+                        image: step.image,
+                        cmd: step.cmd,
+                        env: resolvedEnv,
+                        inputs,
+                        output,
+                        caches,
+                        mounts,
+                        sources: step.sources?.map(m => ({
+                            hostPath: resolveHostPath(pipelineRoot, m.host),
+                            containerPath: m.container
+                        })),
+                        network: step.allowNetwork ? 'bridge' : 'none',
+                        timeoutSec: step.timeoutSec
+                    }, ({ stream, line }) => {
+                        if (stream === 'stdout') {
+                            stdoutLog.write(line + '\n');
+                        }
+                        else {
+                            stderrLog.write(line + '\n');
+                        }
+                        this.reporter.emit({ ...job, event: 'STEP_LOG', step: stepRef, stream, line });
+                    });
+                    break;
+                }
+                catch (error) {
+                    if (error instanceof PipexError && error.transient && attempt < maxRetries) {
+                        this.reporter.emit({ ...job, event: 'STEP_RETRYING', step: stepRef, attempt: attempt + 1, maxRetries });
+                        await setTimeout(retryDelay);
+                        continue;
+                    }
+                    throw error;
+                }
+            }
+            await closeStream(stdoutLog);
+            await closeStream(stderrLog);
+            await this.writeRunMeta(stagingPath, { runId, step, stepRuns, resolvedMounts, currentFingerprint, result, resolvedEnv });
+            if (result.exitCode === 0 || step.allowFailure) {
+                await workspace.commitRun(runId);
+                await workspace.linkRun(step.id, runId);
+                stepRuns.set(step.id, runId);
+                state.setStep(step.id, runId, currentFingerprint);
+                const durationMs = result.finishedAt.getTime() - result.startedAt.getTime();
+                const artifactSize = await dirSize(workspace.runArtifactsPath(runId));
+                this.reporter.emit({ ...job, event: 'STEP_FINISHED', step: stepRef, runId, durationMs, artifactSize });
+                return artifactSize;
+            }
+            await workspace.commitRun(runId);
+            await workspace.linkRun(step.id, runId);
+            state.setStep(step.id, runId, '');
+            this.reporter.emit({ ...job, event: 'STEP_FAILED', step: stepRef, exitCode: result.exitCode });
+            throw new ContainerCrashError(step.id, result.exitCode);
+        }
+        catch (error) {
+            await closeStream(stdoutLog);
+            await closeStream(stderrLog);
+            throw error;
+        }
+        finally {
+            await workspace.markStepDone(step.id);
+        }
+    }
+    async writeRunMeta(stagingPath, { runId, step, stepRuns, resolvedMounts, currentFingerprint, result, resolvedEnv }) {
+        const meta = {
+            runId,
+            stepId: step.id,
+            stepName: step.name,
+            startedAt: result.startedAt.toISOString(),
+            finishedAt: result.finishedAt.toISOString(),
+            durationMs: result.finishedAt.getTime() - result.startedAt.getTime(),
+            exitCode: result.exitCode,
+            image: step.image,
+            cmd: step.cmd,
+            env: resolvedEnv,
+            inputs: step.inputs?.map(i => ({
+                step: i.step,
+                runId: stepRuns.get(i.step),
+                mountedAs: `/input/${i.step}`
+            })),
+            mounts: resolvedMounts,
+            caches: step.caches?.map(c => c.name),
+            allowNetwork: step.allowNetwork ?? false,
+            fingerprint: currentFingerprint,
+            status: result.exitCode === 0 ? 'success' : 'failure'
+        };
+        await writeFile(join(stagingPath, 'meta.json'), JSON.stringify(meta, null, 2), 'utf8');
+    }
+    async tryUseCache({ workspace, state, step, stepRef, currentFingerprint, stepRuns, job }) {
+        const cached = state.getStep(step.id);
+        if (cached?.fingerprint === currentFingerprint) {
+            try {
+                const runs = await workspace.listRuns();
+                if (runs.includes(cached.runId)) {
+                    stepRuns.set(step.id, cached.runId);
+                    await workspace.linkRun(step.id, cached.runId);
+                    this.reporter.emit({ ...job, event: 'STEP_SKIPPED', step: stepRef, runId: cached.runId, reason: 'cached' });
+                    return true;
+                }
+            }
+            catch {
+                // Run missing, proceed with execution
+            }
+        }
+        return false;
+    }
+    async prepareStagingWithInputs(workspace, step, stagingArtifactsPath, stepRuns) {
+        if (!step.inputs) {
+            return;
+        }
+        for (const input of step.inputs) {
+            const inputRunId = stepRuns.get(input.step);
+            if (!inputRunId) {
+                if (input.optional) {
+                    continue;
+                }
+                // Non-optional input without a run — this shouldn't happen in DAG mode
+                // but keep the continue for safety (the step may still work with bind mounts)
+                continue;
+            }
+            if (input.copyToOutput) {
+                await cp(workspace.runArtifactsPath(inputRunId), stagingArtifactsPath, { recursive: true });
+            }
+        }
+    }
+    buildMounts(step, outputRunId, stepRuns, pipelineRoot) {
+        const inputs = [];
+        if (step.inputs) {
+            for (const input of step.inputs) {
+                const inputRunId = stepRuns.get(input.step);
+                if (inputRunId) {
+                    inputs.push({
+                        runId: inputRunId,
+                        containerPath: `/input/${input.step}`
+                    });
+                }
+            }
+        }
+        const output = {
+            stagingRunId: outputRunId,
+            containerPath: step.outputPath ?? '/output'
+        };
+        let caches;
+        if (step.caches) {
+            caches = step.caches.map(c => ({
+                name: c.name,
+                containerPath: c.path
+            }));
+        }
+        let mounts;
+        if (step.mounts) {
+            mounts = step.mounts.map(m => ({
+                hostPath: resolveHostPath(pipelineRoot, m.host),
+                containerPath: m.container
+            }));
+        }
+        return { inputs, output, caches, mounts };
+    }
+}
+async function withConcurrency(tasks, limit) {
+    const results = Array.from({ length: tasks.length });
+    let next = 0;
+    async function worker() {
+        while (next < tasks.length) {
+            const i = next++;
+            try {
+                results[i] = { status: 'fulfilled', value: await tasks[i]() };
+            }
+            catch (error) {
+                results[i] = { status: 'rejected', reason: error };
+            }
+        }
+    }
+    await Promise.all(Array.from({ length: Math.min(limit, tasks.length) }, async () => worker()));
+    return results;
+}
+async function closeStream(stream) {
+    if (stream.destroyed) {
+        return;
+    }
+    return new Promise((resolve, reject) => {
+        stream.end(() => {
+            resolve();
+        });
+        stream.on('error', reject);
+    });
+}

package/dist/core/reporter.js

@@ -0,0 +1,11 @@
+import pino from 'pino';
+/**
+ * Reporter that outputs structured JSON logs via pino.
+ * Suitable for CI/CD environments and log aggregation.
+ */
+export class ConsoleReporter {
+    logger = pino({ level: 'info' });
+    emit(event) {
+        this.logger.info(event);
+    }
+}

package/dist/core/state.js

@@ -0,0 +1,110 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { createHash } from 'node:crypto';
+/**
+ * Manages caching state for pipeline execution.
+ *
+ * The StateManager computes fingerprints for steps and tracks which
+ * run was produced by each step. This enables cache hits when
+ * a step's configuration hasn't changed.
+ *
+ * ## Fingerprint Algorithm
+ *
+ * A step fingerprint is computed as:
+ * ```
+ * SHA256(image + JSON(cmd) + JSON(sorted env) + JSON(sorted inputRunIds))
+ * ```
+ *
+ * A step is re-executed when:
+ * - The fingerprint changes (image, cmd, env, or inputs modified)
+ * - The run no longer exists (manually deleted)
+ *
+ * ## Cache Propagation
+ *
+ * Changes propagate through dependencies. If step A is modified,
+ * all steps depending on A are invalidated automatically (via inputRunIds).
+ */
+export class StateManager {
+    static fingerprint(config) {
+        const hash = createHash('sha256');
+        hash.update(config.image);
+        hash.update(JSON.stringify(config.cmd));
+        if (config.env) {
+            hash.update(JSON.stringify(Object.entries(config.env).sort((a, b) => a[0].localeCompare(b[0]))));
+        }
+        if (config.inputRunIds) {
+            hash.update(JSON.stringify([...config.inputRunIds].sort((a, b) => a.localeCompare(b))));
+        }
+        if (config.mounts && config.mounts.length > 0) {
+            const sorted = [...config.mounts].sort((a, b) => a.containerPath.localeCompare(b.containerPath));
+            hash.update(JSON.stringify(sorted));
+        }
+        return hash.digest('hex');
+    }
+    state = { steps: {} };
+    path;
+    /**
+     * Creates a state manager for the given workspace.
+     * @param workspaceRoot - Absolute path to workspace directory
+     */
+    constructor(workspaceRoot) {
+        this.path = join(workspaceRoot, 'state.json');
+    }
+    /**
+     * Loads cached state from state.json.
+     * If the file doesn't exist, initializes with empty state.
+     */
+    async load() {
+        try {
+            const content = await readFile(this.path, 'utf8');
+            Object.assign(this.state, JSON.parse(content));
+        }
+        catch {
+            this.state.steps = {};
+        }
+    }
+    /**
+     * Persists current state to state.json.
+     */
+    async save() {
+        await writeFile(this.path, JSON.stringify(this.state, null, 2), 'utf8');
+    }
+    /**
+     * Retrieves cached state for a step.
+     * @param stepId - Step identifier
+     * @returns Cached state if available, undefined otherwise
+     */
+    getStep(stepId) {
+        return this.state.steps[stepId];
+    }
+    /**
+     * Lists all steps with their run IDs (in insertion order).
+     * @returns Array of {stepId, runId} entries
+     */
+    listSteps() {
+        return Object.entries(this.state.steps).map(([stepId, { runId }]) => ({ stepId, runId }));
+    }
+    /**
+     * Returns the set of run IDs currently referenced by state.
+     */
+    activeRunIds() {
+        return new Set(Object.values(this.state.steps).map(s => s.runId));
+    }
+    /**
+     * Updates cached state for a step.
+     * @param stepId - Step identifier
+     * @param runId - Run produced by the step
+     * @param fingerprint - Step configuration fingerprint
+     */
+    setStep(stepId, runId, fingerprint) {
+        this.state.steps[stepId] = { runId, fingerprint };
+    }
+    /**
+     * Removes a step's cached state.
+     * @param stepId - Step identifier
+     */
+    removeStep(stepId) {
+        // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+        delete this.state.steps[stepId];
+    }
+}