@atom-workflow-agent/contracts 0.1.0

package/dist/workflows/visualization.d.ts

@@ -0,0 +1,526 @@
+import { z } from "zod";
+export declare const RunGraphNodeOverlaySchema: z.ZodObject<{
+    nodeId: z.ZodString;
+    status: z.ZodEnum<{
+        running: "running";
+        awaiting_signal: "awaiting_signal";
+        awaiting_host: "awaiting_host";
+        succeeded: "succeeded";
+        failed: "failed";
+        cancelled: "cancelled";
+        interrupted: "interrupted";
+        unknown_outcome: "unknown_outcome";
+        ready: "ready";
+        retry_wait: "retry_wait";
+    }>;
+    activationCount: z.ZodNumber;
+    attemptCount: z.ZodNumber;
+    retryCount: z.ZodNumber;
+    activeDurationMs: z.ZodNumber;
+    artifactCount: z.ZodNumber;
+    latestActivation: z.ZodObject<{
+        activationId: z.ZodString;
+        activationIndex: z.ZodNumber;
+        status: z.ZodEnum<{
+            running: "running";
+            awaiting_signal: "awaiting_signal";
+            awaiting_host: "awaiting_host";
+            succeeded: "succeeded";
+            failed: "failed";
+            cancelled: "cancelled";
+            interrupted: "interrupted";
+            unknown_outcome: "unknown_outcome";
+            ready: "ready";
+            retry_wait: "retry_wait";
+        }>;
+        attemptCount: z.ZodDefault<z.ZodNumber>;
+        retryCount: z.ZodDefault<z.ZodNumber>;
+        activeDurationMs: z.ZodDefault<z.ZodNumber>;
+        mapRunId: z.ZodOptional<z.ZodString>;
+        mapIndex: z.ZodOptional<z.ZodNumber>;
+        mapItem: z.ZodOptional<z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+        createdAt: z.ZodOptional<z.ZodString>;
+        startedAt: z.ZodOptional<z.ZodString>;
+        endedAt: z.ZodOptional<z.ZodString>;
+        error: z.ZodOptional<z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodString;
+            retryable: z.ZodBoolean;
+        }, z.core.$strict>>;
+        input: z.ZodOptional<z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+        output: z.ZodOptional<z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+        artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodString;
+            hash: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>;
+    activations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        activationId: z.ZodString;
+        activationIndex: z.ZodNumber;
+        status: z.ZodEnum<{
+            running: "running";
+            awaiting_signal: "awaiting_signal";
+            awaiting_host: "awaiting_host";
+            succeeded: "succeeded";
+            failed: "failed";
+            cancelled: "cancelled";
+            interrupted: "interrupted";
+            unknown_outcome: "unknown_outcome";
+            ready: "ready";
+            retry_wait: "retry_wait";
+        }>;
+        attemptCount: z.ZodDefault<z.ZodNumber>;
+        retryCount: z.ZodDefault<z.ZodNumber>;
+        activeDurationMs: z.ZodDefault<z.ZodNumber>;
+        mapRunId: z.ZodOptional<z.ZodString>;
+        mapIndex: z.ZodOptional<z.ZodNumber>;
+        mapItem: z.ZodOptional<z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+        createdAt: z.ZodOptional<z.ZodString>;
+        startedAt: z.ZodOptional<z.ZodString>;
+        endedAt: z.ZodOptional<z.ZodString>;
+        error: z.ZodOptional<z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodString;
+            retryable: z.ZodBoolean;
+        }, z.core.$strict>>;
+        input: z.ZodOptional<z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+        output: z.ZodOptional<z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+        artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodString;
+            hash: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>>;
+    waitingKind: z.ZodOptional<z.ZodEnum<{
+        signal: "signal";
+        host: "host";
+    }>>;
+}, z.core.$strict>;
+export type RunGraphNodeOverlay = z.infer<typeof RunGraphNodeOverlaySchema>;
+export declare const RunGraphOverlaySchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0">;
+    workflowRevisionId: z.ZodString;
+    irHash: z.ZodString;
+    run: z.ZodObject<{
+        runId: z.ZodString;
+        status: z.ZodEnum<{
+            created: "created";
+            running: "running";
+            awaiting_signal: "awaiting_signal";
+            awaiting_host: "awaiting_host";
+            succeeded: "succeeded";
+            failed: "failed";
+            cancelled: "cancelled";
+            interrupted: "interrupted";
+            unknown_outcome: "unknown_outcome";
+            planning: "planning";
+        }>;
+        goal: z.ZodString;
+        outputs: z.ZodOptional<z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+        error: z.ZodOptional<z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodString;
+            retryable: z.ZodBoolean;
+        }, z.core.$strict>>;
+        createdAt: z.ZodString;
+        startedAt: z.ZodOptional<z.ZodString>;
+        updatedAt: z.ZodString;
+        endedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    lastEventSequence: z.ZodNumber;
+    nodes: z.ZodArray<z.ZodObject<{
+        nodeId: z.ZodString;
+        status: z.ZodEnum<{
+            running: "running";
+            awaiting_signal: "awaiting_signal";
+            awaiting_host: "awaiting_host";
+            succeeded: "succeeded";
+            failed: "failed";
+            cancelled: "cancelled";
+            interrupted: "interrupted";
+            unknown_outcome: "unknown_outcome";
+            ready: "ready";
+            retry_wait: "retry_wait";
+        }>;
+        activationCount: z.ZodNumber;
+        attemptCount: z.ZodNumber;
+        retryCount: z.ZodNumber;
+        activeDurationMs: z.ZodNumber;
+        artifactCount: z.ZodNumber;
+        latestActivation: z.ZodObject<{
+            activationId: z.ZodString;
+            activationIndex: z.ZodNumber;
+            status: z.ZodEnum<{
+                running: "running";
+                awaiting_signal: "awaiting_signal";
+                awaiting_host: "awaiting_host";
+                succeeded: "succeeded";
+                failed: "failed";
+                cancelled: "cancelled";
+                interrupted: "interrupted";
+                unknown_outcome: "unknown_outcome";
+                ready: "ready";
+                retry_wait: "retry_wait";
+            }>;
+            attemptCount: z.ZodDefault<z.ZodNumber>;
+            retryCount: z.ZodDefault<z.ZodNumber>;
+            activeDurationMs: z.ZodDefault<z.ZodNumber>;
+            mapRunId: z.ZodOptional<z.ZodString>;
+            mapIndex: z.ZodOptional<z.ZodNumber>;
+            mapItem: z.ZodOptional<z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+            createdAt: z.ZodOptional<z.ZodString>;
+            startedAt: z.ZodOptional<z.ZodString>;
+            endedAt: z.ZodOptional<z.ZodString>;
+            error: z.ZodOptional<z.ZodObject<{
+                code: z.ZodString;
+                message: z.ZodString;
+                retryable: z.ZodBoolean;
+            }, z.core.$strict>>;
+            input: z.ZodOptional<z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+            output: z.ZodOptional<z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+            artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodString;
+                hash: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>;
+        activations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            activationId: z.ZodString;
+            activationIndex: z.ZodNumber;
+            status: z.ZodEnum<{
+                running: "running";
+                awaiting_signal: "awaiting_signal";
+                awaiting_host: "awaiting_host";
+                succeeded: "succeeded";
+                failed: "failed";
+                cancelled: "cancelled";
+                interrupted: "interrupted";
+                unknown_outcome: "unknown_outcome";
+                ready: "ready";
+                retry_wait: "retry_wait";
+            }>;
+            attemptCount: z.ZodDefault<z.ZodNumber>;
+            retryCount: z.ZodDefault<z.ZodNumber>;
+            activeDurationMs: z.ZodDefault<z.ZodNumber>;
+            mapRunId: z.ZodOptional<z.ZodString>;
+            mapIndex: z.ZodOptional<z.ZodNumber>;
+            mapItem: z.ZodOptional<z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+            createdAt: z.ZodOptional<z.ZodString>;
+            startedAt: z.ZodOptional<z.ZodString>;
+            endedAt: z.ZodOptional<z.ZodString>;
+            error: z.ZodOptional<z.ZodObject<{
+                code: z.ZodString;
+                message: z.ZodString;
+                retryable: z.ZodBoolean;
+            }, z.core.$strict>>;
+            input: z.ZodOptional<z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+            output: z.ZodOptional<z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+            artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodString;
+                hash: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>>;
+        waitingKind: z.ZodOptional<z.ZodEnum<{
+            signal: "signal";
+            host: "host";
+        }>>;
+    }, z.core.$strict>>;
+    controlEdges: z.ZodArray<z.ZodObject<{
+        edgeId: z.ZodString;
+        traversalCount: z.ZodNumber;
+        selected: z.ZodBoolean;
+        lastTraversedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    decisions: z.ZodArray<z.ZodObject<{
+        nodeId: z.ZodString;
+        activationId: z.ZodString;
+        selectedBranch: z.ZodString;
+        matched: z.ZodBoolean;
+        edgeId: z.ZodString;
+        selectedAt: z.ZodString;
+    }, z.core.$strict>>;
+    maps: z.ZodArray<z.ZodObject<{
+        mapRunId: z.ZodString;
+        nodeId: z.ZodString;
+        status: z.ZodEnum<{
+            running: "running";
+            succeeded: "succeeded";
+            failed: "failed";
+        }>;
+        itemCount: z.ZodNumber;
+        completedCount: z.ZodNumber;
+        activeCount: z.ZodNumber;
+    }, z.core.$strict>>;
+    artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        attemptId: z.ZodString;
+        activationId: z.ZodOptional<z.ZodString>;
+        nodeId: z.ZodOptional<z.ZodString>;
+        kind: z.ZodString;
+        hash: z.ZodString;
+        contentKind: z.ZodEnum<{
+            file: "file";
+            inline: "inline";
+            empty: "empty";
+        }>;
+        path: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>>;
+        createdAt: z.ZodString;
+    }, z.core.$strict>>>;
+    pending: z.ZodObject<{
+        signals: z.ZodNumber;
+        hostTasks: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type RunGraphOverlay = z.infer<typeof RunGraphOverlaySchema>;
+export declare const WorkflowGraphViewSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0">;
+    workflowRevisionId: z.ZodString;
+    irHash: z.ZodString;
+    run: z.ZodOptional<z.ZodObject<{
+        runId: z.ZodString;
+        status: z.ZodEnum<{
+            created: "created";
+            running: "running";
+            awaiting_signal: "awaiting_signal";
+            awaiting_host: "awaiting_host";
+            succeeded: "succeeded";
+            failed: "failed";
+            cancelled: "cancelled";
+            interrupted: "interrupted";
+            unknown_outcome: "unknown_outcome";
+            planning: "planning";
+        }>;
+        goal: z.ZodString;
+        outputs: z.ZodOptional<z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+        error: z.ZodOptional<z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodString;
+            retryable: z.ZodBoolean;
+        }, z.core.$strict>>;
+        createdAt: z.ZodString;
+        startedAt: z.ZodOptional<z.ZodString>;
+        updatedAt: z.ZodString;
+        endedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    lastEventSequence: z.ZodNumber;
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            input: "input";
+            output: "output";
+            map: "map";
+            join: "join";
+            atom: "atom";
+            merge: "merge";
+            terminal: "terminal";
+            switch: "switch";
+        }>;
+        label: z.ZodString;
+        atom: z.ZodOptional<z.ZodString>;
+        capability: z.ZodOptional<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"1.0">;
+            hash: z.ZodString;
+            key: z.ZodString;
+            id: z.ZodString;
+            version: z.ZodString;
+            title: z.ZodString;
+            description: z.ZodString;
+            inputSchema: z.ZodRecord<z.ZodString, z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+            outputSchema: z.ZodRecord<z.ZodString, z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+        }, z.core.$strict>>;
+        mapScope: z.ZodOptional<z.ZodString>;
+        runtime: z.ZodOptional<z.ZodObject<{
+            status: z.ZodEnum<{
+                running: "running";
+                awaiting_signal: "awaiting_signal";
+                awaiting_host: "awaiting_host";
+                succeeded: "succeeded";
+                failed: "failed";
+                cancelled: "cancelled";
+                interrupted: "interrupted";
+                unknown_outcome: "unknown_outcome";
+                ready: "ready";
+                retry_wait: "retry_wait";
+            }>;
+            activeDurationMs: z.ZodNumber;
+            attemptCount: z.ZodNumber;
+            retryCount: z.ZodNumber;
+            latestActivation: z.ZodObject<{
+                activationId: z.ZodString;
+                activationIndex: z.ZodNumber;
+                status: z.ZodEnum<{
+                    running: "running";
+                    awaiting_signal: "awaiting_signal";
+                    awaiting_host: "awaiting_host";
+                    succeeded: "succeeded";
+                    failed: "failed";
+                    cancelled: "cancelled";
+                    interrupted: "interrupted";
+                    unknown_outcome: "unknown_outcome";
+                    ready: "ready";
+                    retry_wait: "retry_wait";
+                }>;
+                attemptCount: z.ZodDefault<z.ZodNumber>;
+                retryCount: z.ZodDefault<z.ZodNumber>;
+                activeDurationMs: z.ZodDefault<z.ZodNumber>;
+                mapRunId: z.ZodOptional<z.ZodString>;
+                mapIndex: z.ZodOptional<z.ZodNumber>;
+                mapItem: z.ZodOptional<z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+                createdAt: z.ZodOptional<z.ZodString>;
+                startedAt: z.ZodOptional<z.ZodString>;
+                endedAt: z.ZodOptional<z.ZodString>;
+                error: z.ZodOptional<z.ZodObject<{
+                    code: z.ZodString;
+                    message: z.ZodString;
+                    retryable: z.ZodBoolean;
+                }, z.core.$strict>>;
+                input: z.ZodOptional<z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+                output: z.ZodOptional<z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+                artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    kind: z.ZodString;
+                    hash: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>;
+            activationCount: z.ZodNumber;
+            artifactCount: z.ZodNumber;
+            activations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                activationId: z.ZodString;
+                activationIndex: z.ZodNumber;
+                status: z.ZodEnum<{
+                    running: "running";
+                    awaiting_signal: "awaiting_signal";
+                    awaiting_host: "awaiting_host";
+                    succeeded: "succeeded";
+                    failed: "failed";
+                    cancelled: "cancelled";
+                    interrupted: "interrupted";
+                    unknown_outcome: "unknown_outcome";
+                    ready: "ready";
+                    retry_wait: "retry_wait";
+                }>;
+                attemptCount: z.ZodDefault<z.ZodNumber>;
+                retryCount: z.ZodDefault<z.ZodNumber>;
+                activeDurationMs: z.ZodDefault<z.ZodNumber>;
+                mapRunId: z.ZodOptional<z.ZodString>;
+                mapIndex: z.ZodOptional<z.ZodNumber>;
+                mapItem: z.ZodOptional<z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+                createdAt: z.ZodOptional<z.ZodString>;
+                startedAt: z.ZodOptional<z.ZodString>;
+                endedAt: z.ZodOptional<z.ZodString>;
+                error: z.ZodOptional<z.ZodObject<{
+                    code: z.ZodString;
+                    message: z.ZodString;
+                    retryable: z.ZodBoolean;
+                }, z.core.$strict>>;
+                input: z.ZodOptional<z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+                output: z.ZodOptional<z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+                artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    kind: z.ZodString;
+                    hash: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>>>;
+            waitingKind: z.ZodOptional<z.ZodEnum<{
+                signal: "signal";
+                host: "host";
+            }>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    edges: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodLiteral<"control">;
+        source: z.ZodString;
+        targets: z.ZodArray<z.ZodString>;
+        controlKind: z.ZodString;
+        branch: z.ZodOptional<z.ZodString>;
+        terminal: z.ZodOptional<z.ZodString>;
+        backEdge: z.ZodBoolean;
+        maxTraversals: z.ZodOptional<z.ZodNumber>;
+        runtime: z.ZodOptional<z.ZodObject<{
+            traversalCount: z.ZodNumber;
+            selected: z.ZodBoolean;
+            lastTraversedAt: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodLiteral<"data">;
+        source: z.ZodString;
+        target: z.ZodString;
+        targetPath: z.ZodString;
+        reference: z.ZodString;
+    }, z.core.$strict>], "kind">>;
+    groups: z.ZodObject<{
+        entries: z.ZodArray<z.ZodString>;
+        forks: z.ZodArray<z.ZodObject<{
+            edgeId: z.ZodString;
+            targets: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        joins: z.ZodArray<z.ZodObject<{
+            nodeId: z.ZodString;
+            dependencies: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        maps: z.ZodArray<z.ZodObject<{
+            nodeId: z.ZodString;
+            maxItems: z.ZodNumber;
+            maxConcurrency: z.ZodNumber;
+            bodyNodeIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        switches: z.ZodArray<z.ZodObject<{
+            nodeId: z.ZodString;
+            cases: z.ZodArray<z.ZodString>;
+            hasDefault: z.ZodBoolean;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    decisions: z.ZodArray<z.ZodObject<{
+        nodeId: z.ZodString;
+        activationId: z.ZodString;
+        selectedBranch: z.ZodString;
+        matched: z.ZodBoolean;
+        edgeId: z.ZodString;
+        selectedAt: z.ZodString;
+    }, z.core.$strict>>;
+    maps: z.ZodArray<z.ZodObject<{
+        mapRunId: z.ZodString;
+        nodeId: z.ZodString;
+        status: z.ZodEnum<{
+            running: "running";
+            succeeded: "succeeded";
+            failed: "failed";
+        }>;
+        itemCount: z.ZodNumber;
+        completedCount: z.ZodNumber;
+        activeCount: z.ZodNumber;
+    }, z.core.$strict>>;
+    artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        attemptId: z.ZodString;
+        activationId: z.ZodOptional<z.ZodString>;
+        nodeId: z.ZodOptional<z.ZodString>;
+        kind: z.ZodString;
+        hash: z.ZodString;
+        contentKind: z.ZodEnum<{
+            file: "file";
+            inline: "inline";
+            empty: "empty";
+        }>;
+        path: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>>;
+        createdAt: z.ZodString;
+    }, z.core.$strict>>>;
+    pending: z.ZodObject<{
+        signals: z.ZodNumber;
+        hostTasks: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type WorkflowGraphView = z.infer<typeof WorkflowGraphViewSchema>;
+export declare const WorkflowGraphInvalidationSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0">;
+    runId: z.ZodString;
+    lastEventSequence: z.ZodNumber;
+}, z.core.$strict>;
+export type WorkflowGraphInvalidation = z.infer<typeof WorkflowGraphInvalidationSchema>;
+//# sourceMappingURL=visualization.d.ts.map

package/dist/workflows/visualization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"visualization.d.ts","sourceRoot":"","sources":["../../src/workflows/visualization.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA8BxB,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAW3B,CAAC;AACZ,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAoDvB,CAAC;AACZ,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAIpE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAgCzB,CAAC;AACZ,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,eAAO,MAAM,+BAA+B;;;;kBAIjC,CAAC;AACZ,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC"}

package/dist/workflows/visualization.js

@@ -0,0 +1,132 @@
+import { z } from "zod";
+import { JsonValueSchema } from "../atoms/manifest.js";
+import { AtomCapabilitySchema } from "../atoms/descriptors.js";
+import { AtomArtifactReferenceSchema } from "../atoms/lifecycle.js";
+import { WorkflowNodeRunStatusSchema, WorkflowRunStatusSchema } from "../runtime/records.js";
+import { WorkflowTopologyViewSchema } from "./topology.js";
+const TimestampSchema = z.string().datetime({ offset: true });
+const NodeIdSchema = z.string().trim().min(1);
+const HashSchema = z.string().regex(/^sha256:[a-f0-9]{64}$/);
+const GraphActivationSchema = z.object({
+    activationId: z.string().trim().min(1),
+    activationIndex: z.number().int().nonnegative(),
+    status: WorkflowNodeRunStatusSchema,
+    attemptCount: z.number().int().nonnegative().default(0),
+    retryCount: z.number().int().nonnegative().default(0),
+    activeDurationMs: z.number().int().nonnegative().default(0),
+    mapRunId: z.string().trim().min(1).optional(),
+    mapIndex: z.number().int().nonnegative().optional(),
+    mapItem: JsonValueSchema.optional(),
+    createdAt: TimestampSchema.optional(),
+    startedAt: TimestampSchema.optional(),
+    endedAt: TimestampSchema.optional(),
+    error: z.object({ code: z.string().trim().min(1), message: z.string().trim().min(1), retryable: z.boolean() }).strict().optional(),
+    input: JsonValueSchema.optional(),
+    output: JsonValueSchema.optional(),
+    artifacts: z.array(AtomArtifactReferenceSchema).default([]),
+}).strict();
+export const RunGraphNodeOverlaySchema = z.object({
+    nodeId: NodeIdSchema,
+    status: WorkflowNodeRunStatusSchema,
+    activationCount: z.number().int().nonnegative(),
+    attemptCount: z.number().int().nonnegative(),
+    retryCount: z.number().int().nonnegative(),
+    activeDurationMs: z.number().int().nonnegative(),
+    artifactCount: z.number().int().nonnegative(),
+    latestActivation: GraphActivationSchema,
+    activations: z.array(GraphActivationSchema).default([]),
+    waitingKind: z.enum(["signal", "host"]).optional(),
+}).strict();
+export const RunGraphOverlaySchema = z.object({
+    schemaVersion: z.literal("1.0"),
+    workflowRevisionId: z.string().trim().min(1),
+    irHash: z.string().trim().min(1),
+    run: z.object({
+        runId: z.string().trim().min(1),
+        status: WorkflowRunStatusSchema,
+        goal: z.string(),
+        outputs: JsonValueSchema.optional(),
+        error: z.object({ code: z.string().trim().min(1), message: z.string().trim().min(1), retryable: z.boolean() }).strict().optional(),
+        createdAt: TimestampSchema,
+        startedAt: TimestampSchema.optional(),
+        updatedAt: TimestampSchema,
+        endedAt: TimestampSchema.optional(),
+    }).strict(),
+    lastEventSequence: z.number().int().min(-1),
+    nodes: z.array(RunGraphNodeOverlaySchema),
+    controlEdges: z.array(z.object({
+        edgeId: z.string().trim().min(1),
+        traversalCount: z.number().int().nonnegative(),
+        selected: z.boolean(),
+        lastTraversedAt: TimestampSchema.optional(),
+    }).strict()),
+    decisions: z.array(z.object({
+        nodeId: NodeIdSchema,
+        activationId: z.string().trim().min(1),
+        selectedBranch: z.string().trim().min(1),
+        matched: z.boolean(),
+        edgeId: z.string().trim().min(1),
+        selectedAt: TimestampSchema,
+    }).strict()),
+    maps: z.array(z.object({
+        mapRunId: z.string().trim().min(1),
+        nodeId: NodeIdSchema,
+        status: z.enum(["running", "succeeded", "failed"]),
+        itemCount: z.number().int().nonnegative(),
+        completedCount: z.number().int().nonnegative(),
+        activeCount: z.number().int().nonnegative(),
+    }).strict()),
+    artifacts: z.array(z.object({
+        id: z.string().trim().min(1),
+        attemptId: z.string().trim().min(1),
+        activationId: z.string().trim().min(1).optional(),
+        nodeId: NodeIdSchema.optional(),
+        kind: z.string().trim().min(1),
+        hash: HashSchema,
+        contentKind: z.enum(["inline", "file", "empty"]),
+        path: z.string().trim().min(1).optional(),
+        metadata: z.record(z.string(), JsonValueSchema).default({}),
+        createdAt: TimestampSchema,
+    }).strict()).default([]),
+    pending: z.object({ signals: z.number().int().nonnegative(), hostTasks: z.number().int().nonnegative() }).strict(),
+}).strict();
+const GraphNodeRuntimeSchema = RunGraphNodeOverlaySchema.omit({ nodeId: true });
+export const WorkflowGraphViewSchema = z.object({
+    schemaVersion: z.literal("1.0"),
+    workflowRevisionId: z.string().trim().min(1),
+    irHash: z.string().trim().min(1),
+    run: RunGraphOverlaySchema.shape.run.optional(),
+    lastEventSequence: z.number().int().min(-1),
+    nodes: z.array(z.object({
+        id: NodeIdSchema,
+        kind: z.enum(["atom", "switch", "map", "join", "merge", "input", "output", "terminal"]),
+        label: z.string().trim().min(1),
+        atom: z.string().trim().min(1).optional(),
+        capability: AtomCapabilitySchema.optional(),
+        mapScope: z.string().trim().min(1).optional(),
+        runtime: GraphNodeRuntimeSchema.optional(),
+    }).strict()),
+    edges: z.array(z.discriminatedUnion("kind", [
+        z.object({
+            id: z.string().trim().min(1), kind: z.literal("control"), source: NodeIdSchema,
+            targets: z.array(NodeIdSchema), controlKind: z.string().trim().min(1), branch: z.string().trim().min(1).optional(),
+            terminal: z.string().trim().min(1).optional(), backEdge: z.boolean(), maxTraversals: z.number().int().positive().optional(),
+            runtime: z.object({ traversalCount: z.number().int().nonnegative(), selected: z.boolean(), lastTraversedAt: TimestampSchema.optional() }).strict().optional(),
+        }).strict(),
+        z.object({
+            id: z.string().trim().min(1), kind: z.literal("data"), source: z.string().trim().min(1),
+            target: NodeIdSchema, targetPath: z.string().trim().min(1), reference: z.string().trim().min(1),
+        }).strict(),
+    ])),
+    groups: WorkflowTopologyViewSchema.shape.groups,
+    decisions: RunGraphOverlaySchema.shape.decisions,
+    maps: RunGraphOverlaySchema.shape.maps,
+    artifacts: RunGraphOverlaySchema.shape.artifacts,
+    pending: RunGraphOverlaySchema.shape.pending,
+}).strict();
+export const WorkflowGraphInvalidationSchema = z.object({
+    schemaVersion: z.literal("1.0"),
+    runId: z.string().trim().min(1),
+    lastEventSequence: z.number().int().min(-1),
+}).strict();
+//# sourceMappingURL=visualization.js.map