stageflow 0.1.0

package/dist/tools/askOperator.js

@@ -0,0 +1,409 @@
+/**
+ * Shared ask-operator prompt/answer vocabulary and tool factory (T2).
+ *
+ * Types, TypeBox schemas, and validators have no Pi or RunStore dependency.
+ * The factory blocks on an injected wait bridge; adapter registration is U3.
+ *
+ * Do not abort the session from inside `execute`: the tool Promise is the
+ * live blocking surface until the operator answers (or stage teardown).
+ */
+import { randomUUID } from "node:crypto";
+import { Type } from "typebox";
+export class AskOperatorError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "AskOperatorError";
+    }
+}
+export const ASK_OPERATOR_KINDS = [
+    "free_text",
+    "confirm",
+    "multi_question",
+    "artifact_backed",
+];
+const subQuestionKindSchema = Type.Union([
+    Type.Literal("free_text"),
+    Type.Literal("confirm"),
+]);
+const multiQuestionItemSchema = Type.Object({
+    kind: subQuestionKindSchema,
+    message: Type.String({ minLength: 1 }),
+    id: Type.Optional(Type.String()),
+});
+export const askOperatorParamsSchema = Type.Union([
+    Type.Object({
+        kind: Type.Literal("free_text"),
+        message: Type.String({ minLength: 1 }),
+        id: Type.Optional(Type.String()),
+    }),
+    Type.Object({
+        kind: Type.Literal("confirm"),
+        message: Type.String({ minLength: 1 }),
+        id: Type.Optional(Type.String()),
+    }),
+    Type.Object({
+        kind: Type.Literal("multi_question"),
+        questions: Type.Array(multiQuestionItemSchema, { minItems: 1 }),
+        id: Type.Optional(Type.String()),
+    }),
+    Type.Object({
+        kind: Type.Literal("artifact_backed"),
+        message: Type.String({ minLength: 1 }),
+        artifacts: Type.Array(Type.String({ minLength: 1 }), { minItems: 1 }),
+        id: Type.Optional(Type.String()),
+    }),
+]);
+const decisionSchema = Type.Union([
+    Type.Literal("accept"),
+    Type.Literal("reject"),
+]);
+const freeTextOrConfirmPayloadSchema = Type.Union([
+    Type.Object({
+        kind: Type.Literal("free_text"),
+        text: Type.String(),
+    }),
+    Type.Object({
+        kind: Type.Literal("confirm"),
+        decision: decisionSchema,
+        text: Type.Optional(Type.String()),
+    }),
+]);
+export const askOperatorAnswerSchema = Type.Union([
+    Type.Object({
+        promptId: Type.String({ minLength: 1 }),
+        kind: Type.Literal("free_text"),
+        text: Type.String(),
+    }),
+    Type.Object({
+        promptId: Type.String({ minLength: 1 }),
+        kind: Type.Literal("confirm"),
+        decision: decisionSchema,
+        text: Type.Optional(Type.String()),
+    }),
+    Type.Object({
+        promptId: Type.String({ minLength: 1 }),
+        kind: Type.Literal("artifact_backed"),
+        decision: decisionSchema,
+        text: Type.Optional(Type.String()),
+    }),
+    Type.Object({
+        promptId: Type.String({ minLength: 1 }),
+        kind: Type.Literal("multi_question"),
+        answers: Type.Record(Type.String(), freeTextOrConfirmPayloadSchema),
+    }),
+]);
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function requireNonEmptyString(value, field) {
+    if (typeof value !== "string" || value.trim() === "") {
+        throw new AskOperatorError(`${field} must be a non-empty string`);
+    }
+    return value;
+}
+function optionalId(value, field) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== "string") {
+        throw new AskOperatorError(`${field} must be a string when present`);
+    }
+    const trimmed = value.trim();
+    return trimmed === "" ? undefined : trimmed;
+}
+function parseDecision(value, field) {
+    if (value !== "accept" && value !== "reject") {
+        throw new AskOperatorError(`${field} must be "accept" or "reject" (decision is required)`);
+    }
+    return value;
+}
+function parseOptionalText(value, field) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== "string") {
+        throw new AskOperatorError(`${field} must be a string when present`);
+    }
+    return value;
+}
+function parseSubQuestion(value, path) {
+    if (!isRecord(value)) {
+        throw new AskOperatorError(`${path} must be an object`);
+    }
+    const kind = value.kind;
+    if (kind !== "free_text" && kind !== "confirm") {
+        if (typeof kind === "string") {
+            throw new AskOperatorError(`${path}: unsupported sub-question kind "${kind}" (allowed: free_text, confirm; nested multi_question and artifact_backed are not allowed)`);
+        }
+        throw new AskOperatorError(`${path}: kind must be "free_text" or "confirm"`);
+    }
+    return {
+        kind,
+        message: requireNonEmptyString(value.message, `${path}.message`),
+        id: optionalId(value.id, `${path}.id`),
+    };
+}
+export function parseAskOperatorParams(value) {
+    if (!isRecord(value)) {
+        throw new AskOperatorError("ask_operator params must be an object");
+    }
+    const kind = value.kind;
+    if (typeof kind !== "string") {
+        throw new AskOperatorError("kind is required");
+    }
+    if (kind !== "free_text" &&
+        kind !== "confirm" &&
+        kind !== "multi_question" &&
+        kind !== "artifact_backed") {
+        throw new AskOperatorError(`unsupported prompt kind "${kind}" (allowed: free_text, confirm, multi_question, artifact_backed)`);
+    }
+    const id = optionalId(value.id, "id");
+    if (kind === "free_text" || kind === "confirm") {
+        return {
+            kind,
+            message: requireNonEmptyString(value.message, "message"),
+            ...(id !== undefined ? { id } : {}),
+        };
+    }
+    if (kind === "artifact_backed") {
+        if (!Array.isArray(value.artifacts)) {
+            throw new AskOperatorError("artifacts must be an array");
+        }
+        if (value.artifacts.length < 1) {
+            throw new AskOperatorError("artifacts must contain at least one path");
+        }
+        const artifacts = value.artifacts.map((item, index) => requireNonEmptyString(item, `artifacts[${index}]`));
+        return {
+            kind,
+            message: requireNonEmptyString(value.message, "message"),
+            artifacts,
+            ...(id !== undefined ? { id } : {}),
+        };
+    }
+    if (!Array.isArray(value.questions)) {
+        throw new AskOperatorError("questions must be an array");
+    }
+    if (value.questions.length < 1) {
+        throw new AskOperatorError("questions must contain at least one item");
+    }
+    const questions = value.questions.map((item, index) => parseSubQuestion(item, `questions[${index}]`));
+    return {
+        kind,
+        questions,
+        ...(id !== undefined ? { id } : {}),
+    };
+}
+function newId() {
+    return randomUUID();
+}
+function resolveId(supplied) {
+    return supplied !== undefined && supplied.trim() !== ""
+        ? supplied.trim()
+        : newId();
+}
+export function normalizePromptIds(params) {
+    const id = resolveId(params.id);
+    if (params.kind === "free_text" || params.kind === "confirm") {
+        return {
+            kind: params.kind,
+            message: params.message,
+            id,
+        };
+    }
+    if (params.kind === "artifact_backed") {
+        return {
+            kind: "artifact_backed",
+            message: params.message,
+            artifacts: params.artifacts,
+            id,
+        };
+    }
+    return {
+        kind: "multi_question",
+        id,
+        questions: params.questions.map((q) => ({
+            kind: q.kind,
+            message: q.message,
+            id: resolveId(q.id),
+        })),
+    };
+}
+function parseFreeTextOrConfirmPayload(value, path) {
+    if (!isRecord(value)) {
+        throw new AskOperatorError(`${path} must be an object`);
+    }
+    const kind = value.kind;
+    if (kind === "free_text") {
+        if (typeof value.text !== "string") {
+            throw new AskOperatorError(`${path}.text must be a string`);
+        }
+        return { kind: "free_text", text: value.text };
+    }
+    if (kind === "confirm") {
+        const decision = parseDecision(value.decision, `${path}.decision`);
+        const text = parseOptionalText(value.text, `${path}.text`);
+        return text !== undefined
+            ? { kind: "confirm", decision, text }
+            : { kind: "confirm", decision };
+    }
+    if (typeof kind === "string") {
+        throw new AskOperatorError(`${path}: unsupported answer kind "${kind}" (allowed: free_text, confirm)`);
+    }
+    throw new AskOperatorError(`${path}: kind must be "free_text" or "confirm"`);
+}
+export function parseAskOperatorAnswer(value) {
+    if (!isRecord(value)) {
+        throw new AskOperatorError("ask_operator answer must be an object");
+    }
+    const promptId = requireNonEmptyString(value.promptId, "promptId");
+    const kind = value.kind;
+    if (typeof kind !== "string") {
+        throw new AskOperatorError("kind is required");
+    }
+    if (kind !== "free_text" &&
+        kind !== "confirm" &&
+        kind !== "multi_question" &&
+        kind !== "artifact_backed") {
+        throw new AskOperatorError(`unsupported answer kind "${kind}" (allowed: free_text, confirm, multi_question, artifact_backed)`);
+    }
+    if (kind === "free_text") {
+        if (typeof value.text !== "string") {
+            throw new AskOperatorError("text must be a string");
+        }
+        return { promptId, kind: "free_text", text: value.text };
+    }
+    if (kind === "confirm" || kind === "artifact_backed") {
+        const decision = parseDecision(value.decision, "decision");
+        const text = parseOptionalText(value.text, "text");
+        return text !== undefined
+            ? { promptId, kind, decision, text }
+            : { promptId, kind, decision };
+    }
+    if (!isRecord(value.answers)) {
+        throw new AskOperatorError("answers must be an object");
+    }
+    const answers = {};
+    for (const [subId, payload] of Object.entries(value.answers)) {
+        answers[subId] = parseFreeTextOrConfirmPayload(payload, `answers[${subId}]`);
+    }
+    return { promptId, kind: "multi_question", answers };
+}
+function assertSubAnswerMatches(question, payload) {
+    if (payload === undefined) {
+        throw new AskOperatorError(`multi_question answer missing response for sub-question id "${question.id}"`);
+    }
+    if (payload.kind !== question.kind) {
+        throw new AskOperatorError(`answer kind "${payload.kind}" does not match sub-question kind "${question.kind}" for id "${question.id}"`);
+    }
+    if (payload.kind === "free_text") {
+        if (typeof payload.text !== "string") {
+            throw new AskOperatorError(`free_text answer for sub-question id "${question.id}" requires text`);
+        }
+        return;
+    }
+    if (payload.decision !== "accept" && payload.decision !== "reject") {
+        throw new AskOperatorError(`confirm answer for sub-question id "${question.id}" requires decision`);
+    }
+}
+export function assertAnswerMatchesPrompt(prompt, answer) {
+    if (answer.promptId !== prompt.id) {
+        throw new AskOperatorError(`answer promptId "${answer.promptId}" does not match prompt id "${prompt.id}"`);
+    }
+    if (answer.kind !== prompt.kind) {
+        throw new AskOperatorError(`answer kind "${answer.kind}" does not match prompt kind "${prompt.kind}"`);
+    }
+    if (prompt.kind === "free_text" && answer.kind === "free_text") {
+        if (typeof answer.text !== "string") {
+            throw new AskOperatorError("free_text answer requires text");
+        }
+        return;
+    }
+    if ((prompt.kind === "confirm" && answer.kind === "confirm") ||
+        (prompt.kind === "artifact_backed" && answer.kind === "artifact_backed")) {
+        if (answer.decision !== "accept" && answer.decision !== "reject") {
+            throw new AskOperatorError(`${prompt.kind} answer requires decision ("accept" or "reject")`);
+        }
+        return;
+    }
+    if (prompt.kind === "multi_question" && answer.kind === "multi_question") {
+        const expectedIds = new Set(prompt.questions.map((q) => q.id));
+        const actualIds = Object.keys(answer.answers);
+        for (const question of prompt.questions) {
+            assertSubAnswerMatches(question, answer.answers[question.id]);
+        }
+        for (const subId of actualIds) {
+            if (!expectedIds.has(subId)) {
+                throw new AskOperatorError(`multi_question answer includes unknown sub-question id "${subId}"`);
+            }
+        }
+        if (actualIds.length !== expectedIds.size) {
+            throw new AskOperatorError(`multi_question answer must cover every sub-question id (expected ${expectedIds.size}, got ${actualIds.length})`);
+        }
+        return;
+    }
+    throw new AskOperatorError("answer does not match prompt");
+}
+export const parsePrompt = parseAskOperatorParams;
+export const parseAnswer = parseAskOperatorAnswer;
+function toolResult(text, details, options) {
+    return {
+        content: [{ type: "text", text }],
+        details,
+        ...(options?.isError ? { isError: true } : {}),
+    };
+}
+function summarizeAnswer(answer) {
+    if (answer.kind === "free_text") {
+        return `Operator answered: ${answer.text}`;
+    }
+    if (answer.kind === "confirm" || answer.kind === "artifact_backed") {
+        return answer.text !== undefined && answer.text !== ""
+            ? `Operator ${answer.decision}: ${answer.text}`
+            : `Operator ${answer.decision}`;
+    }
+    const count = Object.keys(answer.answers).length;
+    return `Operator answered ${count} question${count === 1 ? "" : "s"}`;
+}
+export function createAskOperatorTool(options) {
+    const { requestWait } = options;
+    return {
+        name: "ask_operator",
+        label: "Ask operator",
+        description: "Ask the operator a question and wait for their answer. Supports free_text, confirm, multi_question, and artifact_backed prompts. Does not complete the stage — call emit_stage_envelope when finished.",
+        parameters: askOperatorParamsSchema,
+        execute: async (_toolCallId, params) => {
+            let prompt;
+            try {
+                const parsed = parseAskOperatorParams(params);
+                prompt = normalizePromptIds(parsed);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return toolResult(`Invalid ask_operator params: ${message}`, {
+                    prompt: null,
+                    answer: null,
+                    error: message,
+                }, { isError: true });
+            }
+            const rawAnswer = await requestWait(prompt);
+            let answer;
+            try {
+                answer = parseAskOperatorAnswer(rawAnswer);
+                assertAnswerMatchesPrompt(prompt, answer);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return toolResult(`Invalid operator answer: ${message}`, {
+                    prompt,
+                    answer: null,
+                    error: message,
+                }, { isError: true });
+            }
+            return toolResult(summarizeAnswer(answer), {
+                prompt,
+                answer,
+                error: "",
+            });
+        },
+    };
+}

package/dist/tools/emitStageEnvelope.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Custom Pi tool the stage agent must call once when finished.
+ *
+ * Parameter schemas use `typebox` (Pi's `defineTool` TSchema), not
+ * `@sinclair/typebox`. An accepted emit returns `terminate: true` so Pi
+ * ends the turn instead of asking the model to continue.
+ *
+ * Do not abort the session from inside `execute`: providers that bridge tools
+ * (e.g. MCP) may still be waiting for this result, and abort-while-running
+ * deadlocks waitForIdle so later pipeline stages never start.
+ */
+import { Type } from "typebox";
+import type { StageEnvelope } from "../types/envelope.js";
+export type EmitCapture = {
+    envelope?: StageEnvelope;
+    error?: string;
+};
+export declare function createEmitStageEnvelopeTool(capture: EmitCapture, payloadSchema?: unknown): {
+    name: string;
+    label: string;
+    description: string;
+    parameters: Type.TObject<{
+        status: Type.TUnion<[Type.TLiteral<"success">, Type.TLiteral<"failure">]>;
+        summary: Type.TString;
+        artifacts: Type.TArray<Type.TString>;
+        payload: Type.TSchema;
+        stage_id: Type.TOptional<Type.TString>;
+        notes: Type.TOptional<Type.TString>;
+    }>;
+    execute: (_toolCallId: string, params: unknown) => Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: {
+            advancing: boolean;
+            error: string;
+        };
+        isError?: boolean | undefined;
+        terminate?: boolean | undefined;
+    }>;
+};

package/dist/tools/emitStageEnvelope.js

@@ -0,0 +1,61 @@
+/**
+ * Custom Pi tool the stage agent must call once when finished.
+ *
+ * Parameter schemas use `typebox` (Pi's `defineTool` TSchema), not
+ * `@sinclair/typebox`. An accepted emit returns `terminate: true` so Pi
+ * ends the turn instead of asking the model to continue.
+ *
+ * Do not abort the session from inside `execute`: providers that bridge tools
+ * (e.g. MCP) may still be waiting for this result, and abort-while-running
+ * deadlocks waitForIdle so later pipeline stages never start.
+ */
+import { Type } from "typebox";
+import { assertRequiredEnvelope, isAdvancingEnvelope, } from "../envelope/check.js";
+import { assertEnvelopePayload, compilePayloadSchema, } from "../envelope/payloadSchema.js";
+function toolResult(text, details, options) {
+    return {
+        content: [{ type: "text", text }],
+        details,
+        ...(options?.isError ? { isError: true } : {}),
+        ...(options?.terminate ? { terminate: true } : {}),
+    };
+}
+export function createEmitStageEnvelopeTool(capture, payloadSchema) {
+    const compiledPayload = payloadSchema !== undefined
+        ? compilePayloadSchema(payloadSchema)
+        : undefined;
+    return {
+        name: "emit_stage_envelope",
+        label: "Emit stage envelope",
+        description: "Emit the shared stage handoff envelope. Call exactly once when the stage is complete. The pipeline cannot advance until this tool succeeds.",
+        parameters: Type.Object({
+            status: Type.Union([Type.Literal("success"), Type.Literal("failure")]),
+            summary: Type.String({ minLength: 1 }),
+            artifacts: Type.Array(Type.String()),
+            payload: compiledPayload !== undefined
+                ? compiledPayload
+                : Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+            stage_id: Type.Optional(Type.String()),
+            notes: Type.Optional(Type.String()),
+        }),
+        execute: async (_toolCallId, params) => {
+            if (capture.envelope) {
+                return toolResult("Envelope already accepted; later emits are ignored.", { advancing: isAdvancingEnvelope(capture.envelope), error: "" }, { terminate: true });
+            }
+            try {
+                const envelope = assertRequiredEnvelope(params);
+                assertEnvelopePayload(envelope, payloadSchema);
+                capture.envelope = envelope;
+                const advancing = isAdvancingEnvelope(envelope);
+                return toolResult(advancing
+                    ? "Envelope accepted; stage may advance."
+                    : "Envelope accepted with status=failure; pipeline will stop.", { advancing, error: "" }, { terminate: true });
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                capture.error = message;
+                return toolResult(`Invalid envelope: ${message}`, { advancing: false, error: message }, { isError: true });
+            }
+        },
+    };
+}

package/dist/tools/writeStageArtifact.d.ts

@@ -0,0 +1,26 @@
+import { Type } from "typebox";
+export type WriteStageArtifactOptions = {
+    runWorkspaceDir: string;
+    stageId: string;
+    attempt: number;
+};
+export declare function createWriteStageArtifactTool(options: WriteStageArtifactOptions): {
+    name: string;
+    label: string;
+    description: string;
+    parameters: Type.TObject<{
+        path: Type.TString;
+        content: Type.TString;
+    }>;
+    execute: (_toolCallId: string, params: unknown) => Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: {
+            path: string;
+            error: string;
+        };
+        isError?: boolean | undefined;
+    }>;
+};

package/dist/tools/writeStageArtifact.js

@@ -0,0 +1,103 @@
+/**
+ * Custom Pi tool for writing factory stage artifact files under the run
+ * workspace. Paths are relative to
+ * `stages/<stageId>/attempts/<attempt>/artifacts/` and must resolve inside
+ * that directory.
+ *
+ * Parameter schemas use `typebox` (Pi's `defineTool` TSchema), not
+ * `@sinclair/typebox`. Unlike emit, this tool does not terminate the turn.
+ */
+import { randomBytes } from "node:crypto";
+import { lstat, realpath, rename, unlink, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { Type } from "typebox";
+import { ensureRealArtifactsDir, isInsideDir, resolveArtifactTarget, resolveContainedParent, } from "../runstore/workspaceLayout.js";
+function toolResult(text, details, options) {
+    return {
+        content: [{ type: "text", text }],
+        details,
+        ...(options?.isError ? { isError: true } : {}),
+    };
+}
+async function assertSafeWriteTarget(targetPath) {
+    try {
+        const st = await lstat(targetPath);
+        if (st.isSymbolicLink()) {
+            throw new Error("path escapes the stage artifacts directory");
+        }
+        if (st.nlink > 1) {
+            throw new Error("refusing to overwrite hard-linked file");
+        }
+    }
+    catch (err) {
+        if (err.code !== "ENOENT") {
+            throw err;
+        }
+    }
+}
+async function writeContainedArtifact(runWorkspaceDir, artifactsDirectory, absolutePath, content) {
+    const { realArtifacts } = await ensureRealArtifactsDir(runWorkspaceDir, artifactsDirectory);
+    const relativeToArtifacts = path.relative(artifactsDirectory, absolutePath);
+    const parent = await resolveContainedParent(realArtifacts, relativeToArtifacts);
+    const baseName = path.basename(absolutePath);
+    const targetPath = path.join(parent, baseName);
+    await assertSafeWriteTarget(targetPath);
+    const tmpName = `.sf-artifact-${randomBytes(8).toString("hex")}.tmp`;
+    const tmpPath = path.join(parent, tmpName);
+    try {
+        await writeFile(tmpPath, content, "utf8");
+        await rename(tmpPath, targetPath);
+    }
+    catch (err) {
+        try {
+            await unlink(tmpPath);
+        }
+        catch {
+            // best-effort cleanup
+        }
+        throw err;
+    }
+    const realWritten = await realpath(targetPath);
+    if (!isInsideDir(realWritten, realArtifacts)) {
+        throw new Error("path escapes the stage artifacts directory");
+    }
+}
+export function createWriteStageArtifactTool(options) {
+    const { runWorkspaceDir, stageId, attempt } = options;
+    return {
+        name: "write_stage_artifact",
+        label: "Write stage artifact",
+        description: "Write a factory artifact file under this stage attempt's artifacts directory in the run workspace. Pass a path relative to stages/<stageId>/attempts/<attempt>/artifacts/ and the file content. Returns the run-relative path to include in emit_stage_envelope artifacts.",
+        parameters: Type.Object({
+            path: Type.String({ minLength: 1 }),
+            content: Type.String(),
+        }),
+        execute: async (_toolCallId, params) => {
+            try {
+                if (params === null || typeof params !== "object") {
+                    throw new Error("parameters must be an object");
+                }
+                const record = params;
+                if (typeof record.path !== "string") {
+                    throw new Error("path must be a string");
+                }
+                if (typeof record.content !== "string") {
+                    throw new Error("content must be a string");
+                }
+                const { absolutePath, runRelativePath, artifactsDir } = resolveArtifactTarget(runWorkspaceDir, stageId, attempt, record.path);
+                await writeContainedArtifact(runWorkspaceDir, artifactsDir, absolutePath, record.content);
+                return toolResult(`Wrote artifact: ${runRelativePath}`, {
+                    path: runRelativePath,
+                    error: "",
+                });
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return toolResult(`Failed to write artifact: ${message}`, {
+                    path: "",
+                    error: message,
+                }, { isError: true });
+            }
+        },
+    };
+}

package/dist/types/envelope.d.ts

@@ -0,0 +1,12 @@
+export type EnvelopeStatus = "success" | "failure";
+export type StageEnvelope = {
+    status: EnvelopeStatus;
+    summary: string;
+    artifacts: string[];
+    payload?: Record<string, unknown>;
+    stage_id?: string;
+    notes?: string;
+};
+export declare class EnvelopeError extends Error {
+    constructor(message: string);
+}

package/dist/types/envelope.js

@@ -0,0 +1,6 @@
+export class EnvelopeError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "EnvelopeError";
+    }
+}

package/dist/types/pipeline.d.ts

@@ -0,0 +1,25 @@
+export type PipelineConfig = {
+    id: string;
+    stages: string[];
+};
+export type PipelineStageRef = {
+    id: string;
+    needs?: string;
+};
+export type PipelineStageYamlEntry = string | PipelineStageRef;
+export type ResolvedPipelineStageNode = {
+    id: string;
+    needs: string | null;
+    ancestors: string[];
+    stageIndex: number;
+};
+export type ResolvedPipelineDag = {
+    nodes: ResolvedPipelineStageNode[];
+    roots: string[];
+    childrenOf: Record<string, string[]>;
+};
+export type LoadedPipeline = {
+    pipeline: PipelineConfig;
+    stages: import("./stage.js").StageConfig[];
+    dag: ResolvedPipelineDag;
+};

package/dist/types/pipeline.js

@@ -0,0 +1 @@
+export {};