@chrok/pi-braid 0.1.0

package/dist/src/runtime.js

@@ -0,0 +1,532 @@
+import { compileGraph } from "./validate.js";
+import { GitWorkspaces } from "./workspaces.js";
+import { resolve } from "node:path";
+class RunError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "BraidExecutionError";
+    }
+}
+function describeError(error) {
+    return {
+        code: error instanceof RunError ? error.code : "MODEL_ERROR",
+        message: error instanceof Error
+            ? error.message
+            : typeof error === "string"
+                ? error
+                : "Model runner threw a non-Error value",
+    };
+}
+function validateOptions(options) {
+    if (!options || typeof options.runner !== "function")
+        throw new TypeError("A model runner is required");
+    if (options.cwd !== undefined && (typeof options.cwd !== "string" || !options.cwd.trim()))
+        throw new TypeError("cwd must be a non-empty directory path");
+    if (options.defaultModel !== undefined &&
+        (typeof options.defaultModel !== "string" || !options.defaultModel.trim())) {
+        throw new TypeError("defaultModel must be a non-empty string");
+    }
+    if (options.signal !== undefined &&
+        !(options.signal instanceof AbortSignal)) {
+        throw new TypeError("signal must be an AbortSignal");
+    }
+    if (options.onEvent !== undefined && typeof options.onEvent !== "function") {
+        throw new TypeError("onEvent must be a function");
+    }
+    const concurrency = options.maxConcurrency === undefined ? 4 : options.maxConcurrency;
+    if (!Number.isSafeInteger(concurrency) || concurrency < 1) {
+        throw new TypeError("maxConcurrency must be a positive integer");
+    }
+    for (const key of ["nodeTimeoutMs", "graphTimeoutMs"]) {
+        const value = options[key];
+        if (value !== undefined &&
+            value !== Infinity &&
+            (!Number.isFinite(value) || value <= 0 || value > 2_147_483_647)) {
+            throw new TypeError(`${key} must be Infinity or a positive number no greater than 2147483647`);
+        }
+    }
+}
+function createEventLog(onEvent) {
+    const events = [];
+    let sequence = 0;
+    return {
+        events,
+        emit(payload) {
+            const event = Object.freeze({
+                ...structuredClone(payload),
+                sequence: ++sequence,
+                timestamp: Date.now(),
+            });
+            if ("error" in event)
+                Object.freeze(event.error);
+            if ("usage" in event && event.usage)
+                Object.freeze(event.usage);
+            if ("terminalNodeIds" in event)
+                Object.freeze(event.terminalNodeIds);
+            if ("workspace" in event)
+                Object.freeze(event.workspace);
+            events.push(event);
+            if (onEvent) {
+                try {
+                    // Observe rejections too if a caller supplies an async callback; never await it.
+                    void Promise.resolve(onEvent(event)).catch(() => { });
+                }
+                catch {
+                    // Observers are diagnostic only and must never fail node execution.
+                }
+            }
+        },
+    };
+}
+function edgeState(edge, results) {
+    const source = results.get(edge.from);
+    switch (source.status) {
+        case "completed":
+            return edge.choice === undefined || edge.choice === source.decision
+                ? "active"
+                : "inactive";
+        case "failed":
+            return edge.choice === undefined ? "active" : "blocked";
+        case "skipped":
+            // Failure is not inactivity: a downstream join must not silently lose required input.
+            return source.skipReason === "inactive" ? "inactive" : "blocked";
+        default:
+            return "unresolved";
+    }
+}
+function skip(result, reason, log) {
+    result.status = "skipped";
+    result.skipReason = reason;
+    result.finishedAt = Date.now();
+    log.emit({ type: "node_skipped", nodeId: result.id, reason });
+}
+function resolveDependencies(graph, results, log) {
+    // Topological order propagates arbitrarily long skipped paths in one pass.
+    for (const node of graph.topologicalOrder) {
+        const result = results.get(node.id);
+        if (result.status !== "pending")
+            continue;
+        const incoming = graph.incoming.get(node.id);
+        const states = incoming.map((edge) => edgeState(edge, results));
+        if (states.includes("unresolved"))
+            continue;
+        if (states.includes("blocked"))
+            skip(result, "upstream_failed", log);
+        else if (incoming.length > 0 && !states.includes("active"))
+            skip(result, "inactive", log);
+        else {
+            result.status = "runnable";
+            log.emit({ type: "node_runnable", nodeId: result.id });
+        }
+    }
+}
+function nodeOutput(result) {
+    // Failed predecessors can have no valid response; preserve their error separately.
+    const output = { output: result.output ?? "" };
+    if (result.decision !== undefined)
+        output.decision = result.decision;
+    if (result.model !== undefined)
+        output.model = result.model;
+    return output;
+}
+function predecessorOutputs(graph, id, results) {
+    const activeIds = new Set(graph.incoming
+        .get(id)
+        .filter((edge) => edgeState(edge, results) === "active")
+        .map((edge) => edge.from));
+    // A predecessor appears once even if more than one edge connects the same pair.
+    return [...activeIds].map((nodeId) => ({
+        nodeId,
+        ...nodeOutput(results.get(nodeId)),
+        ...(results.get(nodeId).error ? { error: { ...results.get(nodeId).error } } : {}),
+        ...(results.get(nodeId).workspace ? { workspace: { ...results.get(nodeId).workspace } } : {}),
+    }));
+}
+function checkResponse(response) {
+    if (!response ||
+        typeof response.output !== "string" ||
+        (response.model !== undefined &&
+            (typeof response.model !== "string" || !response.model.trim()))) {
+        throw new RunError("INVALID_RESPONSE", "Runner must return a textual output and an optional model name");
+    }
+    if (response.usage !== undefined &&
+        (!response.usage ||
+            !Number.isSafeInteger(response.usage.inputTokens) ||
+            response.usage.inputTokens < 0 ||
+            !Number.isSafeInteger(response.usage.outputTokens) ||
+            response.usage.outputTokens < 0)) {
+        throw new RunError("INVALID_RESPONSE", "Token usage must contain non-negative integer inputTokens/outputTokens");
+    }
+}
+async function runNode(request, result, runner, timeoutMs, graphSignal, graphDeadline, log, workspaces) {
+    result.status = "running";
+    result.startedAt = Date.now();
+    const started = performance.now();
+    const controller = new AbortController();
+    const signal = AbortSignal.any([graphSignal, controller.signal]);
+    const nodeTimeout = new RunError("NODE_TIMEOUT", `Node '${result.id}' exceeded ${timeoutMs}ms`);
+    const timer = Number.isFinite(timeoutMs)
+        ? setTimeout(() => controller.abort(nodeTimeout), timeoutMs)
+        : undefined;
+    let onAbort;
+    const aborted = new Promise((_, reject) => {
+        onAbort = () => reject(signal.reason);
+        signal.addEventListener("abort", onAbort, { once: true });
+        if (signal.aborted)
+            onAbort();
+    });
+    void aborted.catch(() => { });
+    let acceptingWrites = true;
+    const writes = new Set();
+    let merge;
+    let acceptingDecisions = true;
+    let decision;
+    let decisionError;
+    // Capture choices separately: the runner cannot change the declared tool enum.
+    const choices = request.node.type === "decision" ? [...request.node.choices] : undefined;
+    const invocation = { ...request, signal };
+    invocation.withWorkspaceWrite = async (operation) => {
+        signal.throwIfAborted();
+        if (!acceptingWrites)
+            throw new Error("Node has finished; further writes are unavailable");
+        const pending = Promise.resolve().then(() => {
+            signal.throwIfAborted();
+            return operation();
+        });
+        writes.add(pending);
+        try {
+            return await pending;
+        }
+        finally {
+            writes.delete(pending);
+        }
+    };
+    if (Number.isFinite(timeoutMs) || Number.isFinite(graphDeadline)) {
+        invocation.deadlines = {
+            ...(Number.isFinite(timeoutMs) ? { node: started + timeoutMs } : {}),
+            ...(Number.isFinite(graphDeadline) ? { graph: graphDeadline } : {}),
+        };
+    }
+    if (choices) {
+        invocation.decide = (...values) => {
+            if (!acceptingDecisions || signal.aborted) {
+                throw new RunError("INVALID_DECISION", "decide called after invocation ended");
+            }
+            const choice = values[0];
+            if (values.length !== 1 ||
+                typeof choice !== "string" ||
+                !choices.includes(choice) ||
+                decision !== undefined) {
+                decisionError = new RunError("INVALID_DECISION", "decide must be called exactly once with one declared choice");
+                throw decisionError;
+            }
+            decision = choice;
+        };
+    }
+    function checkDeadline() {
+        signal.throwIfAborted();
+        const now = performance.now();
+        const error = now >= graphDeadline
+            ? new RunError("GRAPH_TIMEOUT", "Graph deadline exceeded")
+            : now - started >= timeoutMs
+                ? nodeTimeout
+                : undefined;
+        if (error) {
+            controller.abort(error);
+            throw error;
+        }
+    }
+    try {
+        checkDeadline();
+        if (request.node.type === "merge") {
+            merge = await workspaces.beginMerge(invocation, request.predecessors.map(value => value.nodeId));
+            invocation.merge = { sources: structuredClone(merge.sources),
+                ...(merge.sourceStatus ? { sourceStatus: structuredClone(merge.sourceStatus) } : {}), finish: merge.finish };
+        }
+        else {
+            invocation.workspace = await workspaces.prepare(invocation);
+        }
+        invocation.workspace = structuredClone(invocation.workspace);
+        if (invocation.workspace?.sourceRoot) {
+            const gitRequest = { ...invocation, node: structuredClone(invocation.node), workspace: structuredClone(invocation.workspace) };
+            invocation.git = (args, input) => workspaces.git(gitRequest, args, input);
+        }
+        // The rejection handler remains attached if a non-cooperative runner finishes late.
+        const response = await Promise.race([
+            aborted,
+            Promise.resolve().then(() => {
+                // Timer callbacks can be starved. Never start a provider call after its deadline.
+                checkDeadline();
+                log.emit({
+                    type: "node_started",
+                    nodeId: result.id,
+                    ...(result.model !== undefined ? { model: result.model } : {}),
+                });
+                for (const predecessor of request.predecessors) {
+                    log.emit({
+                        type: "handoff",
+                        from: predecessor.nodeId,
+                        to: result.id,
+                        output: predecessor.output,
+                        ...(predecessor.decision !== undefined
+                            ? { decision: predecessor.decision }
+                            : {}),
+                    });
+                }
+                checkDeadline();
+                return runner(invocation);
+            }),
+        ]);
+        acceptingDecisions = false;
+        checkDeadline();
+        checkResponse(response);
+        result.output = response.output;
+        if (response.model !== undefined)
+            result.model = response.model;
+        if (response.usage !== undefined)
+            result.usage = { ...response.usage };
+        if (decisionError)
+            throw decisionError;
+        if (choices && decision === undefined) {
+            throw new RunError("DECISION_REQUIRED", `Decision node '${result.id}' did not call decide`);
+        }
+        result.status = "completed";
+    }
+    catch (error) {
+        result.status = "failed";
+        result.error = describeError(error);
+    }
+    finally {
+        acceptingDecisions = false;
+        acceptingWrites = false;
+        await Promise.allSettled(writes);
+        if (merge) {
+            try {
+                await merge.complete(result.status === "completed");
+            }
+            catch (error) {
+                result.status = "failed";
+                result.error = { code: "MERGE_FAILED", message: error instanceof Error ? error.message : String(error) };
+            }
+        }
+        if (decision !== undefined)
+            result.decision = decision;
+        clearTimeout(timer);
+        signal.removeEventListener("abort", onAbort);
+        result.finishedAt = Date.now();
+        result.latencyMs = performance.now() - started;
+        const details = {
+            nodeId: result.id,
+            latencyMs: result.latencyMs,
+            ...(result.output !== undefined ? { output: result.output } : {}),
+            ...(result.decision !== undefined ? { decision: result.decision } : {}),
+            ...(result.model !== undefined ? { model: result.model } : {}),
+            ...(result.usage !== undefined ? { usage: result.usage } : {}),
+        };
+        log.emit(result.error
+            ? { type: "node_failed", ...details, error: result.error }
+            : { type: "node_completed", ...details, output: result.output });
+    }
+}
+/** Submit a complete DAG; core may append a final merge node for pending worktrees. */
+export async function braid(input, options) {
+    validateOptions(options);
+    const graph = compileGraph(input);
+    // Snapshot options as well as the graph before any asynchronous work.
+    const { runner, defaultModel, signal } = options;
+    const log = createEventLog(options.onEvent);
+    const maxConcurrency = options.maxConcurrency ?? 4;
+    const nodeTimeoutMs = options.nodeTimeoutMs ?? 60_000;
+    const graphTimeoutMs = options.graphTimeoutMs ?? 300_000;
+    const startedAt = Date.now();
+    const started = performance.now();
+    const graphDeadline = started + graphTimeoutMs;
+    const runId = crypto.randomUUID();
+    const execution = { runId, rootRunId: runId };
+    const edges = graph.edges;
+    log.emit({
+        type: "graph_created",
+        nodeCount: graph.nodes.length,
+        edgeCount: edges.length,
+    });
+    for (const node of graph.nodes) {
+        const model = node.model ?? defaultModel;
+        log.emit({
+            type: "node_created",
+            nodeId: node.id,
+            nodeType: node.type,
+            ...(model !== undefined ? { model } : {}),
+        });
+    }
+    for (const edge of edges) {
+        log.emit({
+            type: "edge_created",
+            from: edge.from,
+            to: edge.to,
+            ...(edge.choice !== undefined ? { choice: edge.choice } : {}),
+        });
+    }
+    const results = new Map(graph.nodes.map((node) => {
+        const result = { id: node.id, status: "pending" };
+        const model = node.model ?? defaultModel;
+        if (model !== undefined)
+            result.model = model;
+        return [node.id, result];
+    }));
+    const workspaces = new GitWorkspaces(resolve(options.cwd ?? process.cwd()), workspace => {
+        if (workspace.mode === "read-only")
+            return;
+        const node = results.get(workspace.nodeId);
+        if (node)
+            node.workspace = { ...workspace };
+        log.emit({ type: "workspace_updated", workspace: { ...workspace } });
+    });
+    const running = new Map();
+    let automaticMergeAdded = false;
+    let cleanupError;
+    const controller = new AbortController();
+    const graphTimeout = new RunError("GRAPH_TIMEOUT", `Graph exceeded ${graphTimeoutMs}ms`);
+    const onCancel = () => controller.abort(new RunError("CANCELLED", "Graph cancelled by caller"));
+    signal?.addEventListener("abort", onCancel, { once: true });
+    if (signal?.aborted)
+        onCancel();
+    const timer = Number.isFinite(graphTimeoutMs)
+        ? setTimeout(() => controller.abort(graphTimeout), graphTimeoutMs)
+        : undefined;
+    try {
+        while (true) {
+            if (performance.now() >= graphDeadline)
+                controller.abort(graphTimeout);
+            if (controller.signal.aborted) {
+                const reason = describeError(controller.signal.reason).code === "CANCELLED"
+                    ? "cancelled"
+                    : "graph_timeout";
+                for (const result of results.values()) {
+                    if (result.status === "pending" || result.status === "runnable")
+                        skip(result, reason, log);
+                }
+                await Promise.all(running.values());
+                break;
+            }
+            resolveDependencies(graph, results, log);
+            for (const node of graph.topologicalOrder) {
+                if (running.size >= maxConcurrency)
+                    break;
+                const result = results.get(node.id);
+                if (result.status !== "runnable")
+                    continue;
+                // A merge owns the source checkout and may remove predecessors. Let
+                // currently running consumers finish first, and admit no workers during it.
+                if ([...running.keys()].some(id => graph.nodes.find(value => value.id === id)?.type === "merge"))
+                    break;
+                if (node.type === "merge" && running.size > 0)
+                    continue;
+                const predecessors = predecessorOutputs(graph, node.id, results);
+                const request = {
+                    goal: graph.goal,
+                    node: structuredClone(node),
+                    predecessors,
+                    execution: { ...execution },
+                };
+                if (result.model !== undefined)
+                    request.model = result.model;
+                const task = runNode(request, result, runner, nodeTimeoutMs, controller.signal, graphDeadline, log, workspaces).finally(() => {
+                    running.delete(node.id);
+                });
+                running.set(node.id, task);
+            }
+            if (running.size === 0) {
+                const pending = workspaces.pending();
+                if (!automaticMergeAdded && pending.length) {
+                    automaticMergeAdded = true;
+                    let id = "__braid_merge__";
+                    while (results.has(id))
+                        id += "_";
+                    const node = { type: "merge", id, prompt: "Review every remaining node checkpoint, including partial work from failed nodes. Decide whether to integrate each change using git merge, cherry-pick, apply, or another available local operation. Preserve the user's existing changes. Call finish_merge to account for every source." };
+                    graph.nodes.push(node);
+                    graph.topologicalOrder.push(node);
+                    graph.incoming.set(id, pending.map(from => ({ from, to: id })));
+                    graph.outgoing.set(id, []);
+                    for (const edge of graph.incoming.get(id)) {
+                        graph.edges.push(edge);
+                        graph.outgoing.get(edge.from).push(edge);
+                    }
+                    results.set(id, { id, status: "pending", ...(defaultModel ? { model: defaultModel } : {}) });
+                    log.emit({ type: "node_created", nodeId: id, nodeType: "merge", ...(defaultModel ? { model: defaultModel } : {}) });
+                    for (const edge of graph.incoming.get(id))
+                        log.emit({ type: "edge_created", ...edge });
+                    continue;
+                }
+                break;
+            }
+            await Promise.race(running.values());
+        }
+    }
+    finally {
+        clearTimeout(timer);
+        signal?.removeEventListener("abort", onCancel);
+        try {
+            await workspaces.archivePending("Run ended before an agent integrated these changes; recover them from checkpointRef");
+        }
+        catch (error) {
+            cleanupError = { code: "CLEANUP_FAILED", message: error instanceof Error ? error.message : String(error) };
+        }
+        try {
+            await workspaces.close();
+        }
+        catch (error) {
+            cleanupError ??= { code: "CLEANUP_FAILED", message: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    const terminalOutputs = Object.fromEntries(graph.nodes
+        .filter((node) => results.get(node.id).status === "completed" &&
+        !graph.outgoing
+            .get(node.id)
+            .some((edge) => edgeState(edge, results) === "active"))
+        .map((node) => [node.id, nodeOutput(results.get(node.id))]));
+    const usage = { inputTokens: 0, outputTokens: 0 };
+    let usageReportedNodes = 0;
+    for (const result of results.values()) {
+        if (result.usage) {
+            usage.inputTokens += result.usage.inputTokens;
+            usage.outputTokens += result.usage.outputTokens;
+            usageReportedNodes++;
+        }
+    }
+    const error = cleanupError ?? (controller.signal.aborted
+        ? describeError(controller.signal.reason)
+        : [...results.values()].find((result) => result.status === "failed")?.error);
+    const result = {
+        status: error ? "failed" : "completed",
+        terminalOutputs,
+        events: [],
+        nodes: Object.fromEntries(results),
+        ...(Object.values(workspaces.all()).some(value => value.mode !== "read-only") ? { workspaces: workspaces.all() } : {}),
+        metadata: {
+            ...execution,
+            startedAt,
+            finishedAt: Date.now(),
+            latencyMs: performance.now() - started,
+            usage,
+            usageReportedNodes,
+        },
+    };
+    if (error) {
+        result.error = { ...error };
+        log.emit({
+            type: "graph_failed",
+            error: { ...error },
+            terminalNodeIds: Object.keys(terminalOutputs),
+        });
+    }
+    else {
+        log.emit({
+            type: "graph_completed",
+            terminalNodeIds: Object.keys(terminalOutputs),
+        });
+    }
+    result.events = Object.freeze(log.events);
+    return result;
+}

package/dist/src/types.js

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

package/dist/src/validate.js

@@ -0,0 +1,110 @@
+export class GraphValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "GraphValidationError";
+    }
+}
+function requireValid(condition, message) {
+    if (!condition)
+        throw new GraphValidationError(message);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function text(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function fields(value, allowed, label) {
+    for (const key of Object.keys(value)) {
+        requireValid(allowed.includes(key), `${label}: unsupported field '${key}'`);
+    }
+}
+/** Throws before execution for malformed graphs, references, choices, or cycles. */
+export function validateGraph(input) {
+    compileGraph(input);
+}
+export function compileGraph(input) {
+    requireValid(isRecord(input), "Graph must be an object");
+    fields(input, ["goal", "nodes", "edges"], "Graph");
+    requireValid(text(input.goal), "Graph goal must be a non-empty string");
+    requireValid(Array.isArray(input.nodes) && input.nodes.length > 0, "Graph needs at least one node");
+    requireValid(Array.isArray(input.edges), "Graph edges must be an array");
+    const byId = new Map();
+    for (const node of input.nodes) {
+        requireValid(isRecord(node), "Node must be an object");
+        requireValid(node.type === "execute" || node.type === "decision" || node.type === "merge", "Unknown node type");
+        fields(node, node.type === "decision"
+            ? ["type", "id", "prompt", "model", "choices"]
+            : ["type", "id", "prompt", "model"], "Node");
+        requireValid(text(node.id), "Node id must be a non-empty string");
+        requireValid(!byId.has(node.id), `Duplicate node id '${node.id}'`);
+        requireValid(text(node.prompt) || (node.type === "merge" && node.prompt === undefined), `Node '${node.id}' needs a non-empty prompt`);
+        requireValid(node.model === undefined || text(node.model), `Invalid model on '${node.id}'`);
+        const common = {
+            id: node.id,
+            prompt: node.prompt ?? "Review all predecessor changes, decide how to integrate them into the source repository, and account for every source with finish_merge.",
+            ...(node.model !== undefined ? { model: node.model } : {}),
+        };
+        if (node.type === "decision") {
+            requireValid(Array.isArray(node.choices) && node.choices.length > 0, `Decision '${node.id}' needs at least one choice`);
+            const choices = [...node.choices];
+            requireValid(choices.every(text), `Invalid choice on '${node.id}'`);
+            requireValid(new Set(choices).size === choices.length, `Duplicate choices on '${node.id}'`);
+            byId.set(node.id, { type: "decision", ...common, choices });
+        }
+        else {
+            byId.set(node.id, { type: node.type, ...common });
+        }
+    }
+    const edges = [];
+    const incoming = new Map();
+    const outgoing = new Map();
+    const seen = new Set();
+    for (const id of byId.keys()) {
+        incoming.set(id, []);
+        outgoing.set(id, []);
+    }
+    for (const edge of input.edges) {
+        requireValid(isRecord(edge), "Edge must be an object");
+        fields(edge, ["from", "to", "choice"], "Edge");
+        requireValid(text(edge.from) && byId.has(edge.from), `Missing source node '${edge.from}'`);
+        requireValid(text(edge.to) && byId.has(edge.to), `Missing target node '${edge.to}'`);
+        if (edge.choice !== undefined) {
+            const source = byId.get(edge.from);
+            requireValid(source.type === "decision", `Choice edge from non-decision '${edge.from}'`);
+            requireValid(text(edge.choice) && source.choices.includes(edge.choice), `Undeclared edge choice '${edge.choice}' on '${edge.from}'`);
+        }
+        const key = JSON.stringify([edge.from, edge.to, edge.choice ?? null]);
+        requireValid(!seen.has(key), `Duplicate edge '${edge.from}' -> '${edge.to}'`);
+        seen.add(key);
+        const snapshot = {
+            from: edge.from,
+            to: edge.to,
+            ...(edge.choice !== undefined ? { choice: edge.choice } : {}),
+        };
+        edges.push(snapshot);
+        incoming.get(edge.to).push(snapshot);
+        outgoing.get(edge.from).push(snapshot);
+    }
+    // Kahn's algorithm is iterative, including for very deep graphs.
+    const nodes = [...byId.values()];
+    const remaining = new Map(nodes.map((node) => [node.id, incoming.get(node.id).length]));
+    const topologicalOrder = nodes.filter((node) => remaining.get(node.id) === 0);
+    for (let i = 0; i < topologicalOrder.length; i++) {
+        for (const edge of outgoing.get(topologicalOrder[i].id)) {
+            const count = remaining.get(edge.to) - 1;
+            remaining.set(edge.to, count);
+            if (count === 0)
+                topologicalOrder.push(byId.get(edge.to));
+        }
+    }
+    requireValid(topologicalOrder.length === nodes.length, "Graph contains a cycle");
+    return {
+        goal: input.goal,
+        nodes,
+        topologicalOrder,
+        edges,
+        incoming,
+        outgoing,
+    };
+}