@wildo-ai/saas-frontend-lib 1.1.10 → 1.1.11

package/dist/esm/core/flows-actors/graph-view.layout.js

@@ -0,0 +1,169 @@
+//===============================================================
+//  LAYERED LAYOUT OF A GRAPH VIEW (#2529)
+//
+// Where each node of a `GraphView` sits, computed by dagre: nodes in ranks along the graph's direction, crossings
+// minimised, cycles broken for ranking rather than collapsed, and every node at the size it is drawn at.
+//
+// It replaces a longest-path layering on fixed 384×120 cells, which never minimised a crossing, put a loop's nodes on
+// one level, and let a tall node overflow its cell.
+//
+// Decided by practice (#2529): React Flow's layouting guide lists dagre as the small option, with dynamic node sizes
+// and sub-flows. elkjs also routes edges, at about 1.45 MB, and is the one to revisit only if routing is needed. A
+// domain model keeps its own grid, since domain models have cycles by nature.
+//===============================================================
+/** Which way a graph's ranks run. The values are dagre's `rankdir`. */
+export var GraphViewLayoutDirection;
+(function (GraphViewLayoutDirection) {
+    /** Ranks run left to right: a flow, a plan. The edge leaves a node's right side and enters the next one's left. */
+    GraphViewLayoutDirection["RIGHT"] = "LR";
+    /** Ranks run top to bottom: a hierarchy, a sequence of rounds read down the page. */
+    GraphViewLayoutDirection["DOWN"] = "TB";
+})(GraphViewLayoutDirection || (GraphViewLayoutDirection = {}));
+export const GRAPH_VIEW_LAYOUT_NODE_SPACING = 40;
+export const GRAPH_VIEW_LAYOUT_RANK_SPACING = 80;
+export const GRAPH_VIEW_LAYOUT_GROUP_PADDING = 16;
+export const GRAPH_VIEW_LAYOUT_GROUP_HEADER = 32;
+/**
+ * The narrowest a group is drawn: room for its title above contents narrower than it. A node is a group only when
+ * something is drawn inside it, so a group is never empty; a round that ran nothing is an ordinary node.
+ */
+export const GRAPH_VIEW_LAYOUT_GROUP_MIN_WIDTH = 160;
+/** The level the graph's top-level nodes are laid out in. */
+const TOP_LEVEL = Symbol('top-level');
+/**
+ * Lay a graph out. Asynchronous because dagre is imported on first use: the library is its own chunk, loaded only by a
+ * surface that draws a graph, whoever imports this module.
+ *
+ * A graph with groups (nodes other nodes name as their `parentId`) is laid out one level at a time, innermost first:
+ * each group's contents on their own, which gives the group its size, then the level holding the group with the group
+ * as one sized node. dagre's own compound mode cannot do this here: it throws on any edge that touches a group, and the
+ * rounds of a choreography are groups joined by edges. An edge between nodes of different groups counts, at each level,
+ * as an edge between the nodes of that level that contain its ends, so a group still ranks after what feeds it.
+ *
+ * A `parentId` naming a node the graph does not hold, or a chain of parents that loops, places the node at the top level.
+ */
+export async function layoutGraphView(graph, options) {
+    const { graphlib, layout } = await import('@dagrejs/dagre');
+    const nodeSpacing = options.nodeSpacing ?? GRAPH_VIEW_LAYOUT_NODE_SPACING;
+    const rankSpacing = options.rankSpacing ?? GRAPH_VIEW_LAYOUT_RANK_SPACING;
+    const groupPadding = options.groupPadding ?? GRAPH_VIEW_LAYOUT_GROUP_PADDING;
+    const groupHeader = options.groupHeader ?? GRAPH_VIEW_LAYOUT_GROUP_HEADER;
+    const nodesById = new Map(graph.nodes.map((node) => [node.id, node]));
+    const containerOf = resolveContainers(graph.nodes, nodesById);
+    const childrenOf = new Map();
+    for (const node of graph.nodes) {
+        const container = containerOf.get(node.id) ?? TOP_LEVEL;
+        childrenOf.set(container, [...(childrenOf.get(container) ?? []), node]);
+    }
+    const isGroup = (id) => childrenOf.has(id);
+    /** The node of `container`'s level that holds `id`: itself, or the ancestor that is a child of `container`. */
+    const representativeIn = (id, container) => {
+        let current = id;
+        const seen = new Set();
+        while (current !== undefined && !seen.has(current)) {
+            seen.add(current);
+            if ((containerOf.get(current) ?? TOP_LEVEL) === container)
+                return current;
+            const parent = containerOf.get(current);
+            current = parent === undefined || parent === TOP_LEVEL ? undefined : parent;
+        }
+        return undefined;
+    };
+    const placements = new Map();
+    const sizes = new Map();
+    /** Lay out one level; returns the extent of what it placed. Groups inside it are laid out first, for their size. */
+    const layOutLevel = (container) => {
+        // Empty only for a graph with no nodes at all: a group is a node something is drawn inside.
+        const members = childrenOf.get(container) ?? [];
+        for (const member of members) {
+            if (!isGroup(member.id)) {
+                sizes.set(member.id, options.nodeSize(member));
+                continue;
+            }
+            // Terminates: `resolveContainers` breaks every loop of parents, so the containers form a tree.
+            const inner = layOutLevel(member.id);
+            sizes.set(member.id, {
+                width: Math.max(GRAPH_VIEW_LAYOUT_GROUP_MIN_WIDTH, inner.width + 2 * groupPadding),
+                height: groupHeader + inner.height + 2 * groupPadding,
+            });
+        }
+        if (members.length === 0)
+            return { width: 0, height: 0 };
+        const g = new graphlib.Graph({ multigraph: true });
+        g.setGraph({ rankdir: options.direction, nodesep: nodeSpacing, ranksep: rankSpacing, marginx: 0, marginy: 0 });
+        g.setDefaultEdgeLabel(() => ({}));
+        for (const member of members)
+            g.setNode(member.id, { ...sizes.get(member.id) });
+        for (const edge of graph.edges) {
+            const source = representativeIn(edge.source, container);
+            const target = representativeIn(edge.target, container);
+            // An edge with an end outside this level, or both ends inside one member, says nothing about this level's order.
+            if (source === undefined || target === undefined || source === target)
+                continue;
+            g.setEdge(source, target, {}, edge.id);
+        }
+        layout(g);
+        let width = 0;
+        let height = 0;
+        const offset = container === TOP_LEVEL ? { x: 0, y: 0 } : { x: groupPadding, y: groupHeader + groupPadding };
+        for (const member of members) {
+            const laidOut = g.node(member.id);
+            const size = sizes.get(member.id);
+            // dagre places a node by its centre; a placement is its top-left corner.
+            const x = laidOut.x - size.width / 2;
+            const y = laidOut.y - size.height / 2;
+            placements.set(member.id, { x: x + offset.x, y: y + offset.y, width: size.width, height: size.height });
+            width = Math.max(width, x + size.width);
+            height = Math.max(height, y + size.height);
+        }
+        return { width, height };
+    };
+    const extent = layOutLevel(TOP_LEVEL);
+    return { placements, parentOf: parentsFrom(containerOf), width: extent.width, height: extent.height };
+}
+/**
+ * The group each node is drawn inside, for every node drawn inside one: its `parentId` when that names a node the graph
+ * holds and the chain of parents does not loop. The layout and every other presentation of a graph (a list of its
+ * steps) nest by this, so a node a malformed `parentId` would hide is shown at the top level by all of them.
+ */
+export function graphViewParentOf(nodes) {
+    return parentsFrom(resolveContainers(nodes, new Map(nodes.map((node) => [node.id, node]))));
+}
+function parentsFrom(containers) {
+    const parentOf = new Map();
+    for (const [id, container] of containers)
+        if (container !== TOP_LEVEL)
+            parentOf.set(id, container);
+    return parentOf;
+}
+/**
+ * Each node's container: the group it is drawn inside, or the top level. A `parentId` the graph does not hold, or one
+ * whose chain of parents loops back, puts the node at the top level rather than nowhere.
+ */
+function resolveContainers(nodes, nodesById) {
+    const containers = new Map();
+    for (const node of nodes) {
+        const parent = node.parentId;
+        if (parent === undefined || !nodesById.has(parent)) {
+            containers.set(node.id, TOP_LEVEL);
+            continue;
+        }
+        // Walk the chain of parents; a revisit means a loop (a node naming itself is the shortest), and a node in a loop is
+        // placed at the top level.
+        const seen = new Set([node.id]);
+        let current = parent;
+        let loops = false;
+        while (current !== undefined) {
+            if (seen.has(current)) {
+                loops = true;
+                break;
+            }
+            seen.add(current);
+            const next = nodesById.get(current)?.parentId;
+            current = next !== undefined && nodesById.has(next) ? next : undefined;
+        }
+        containers.set(node.id, loops ? TOP_LEVEL : parent);
+    }
+    return containers;
+}
+//# sourceMappingURL=graph-view.layout.js.map

package/dist/esm/core/flows-actors/graph-view.layout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-view.layout.js","sourceRoot":"","sources":["../../../../../src/core/flows-actors/graph-view.layout.ts"],"names":[],"mappings":"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","sourcesContent":["import type { GraphView, GraphViewNode } from './graph-view.model';\n\n//===============================================================\n//  LAYERED LAYOUT OF A GRAPH VIEW (#2529)\n//\n// Where each node of a `GraphView` sits, computed by dagre: nodes in ranks along the graph's direction, crossings\n// minimised, cycles broken for ranking rather than collapsed, and every node at the size it is drawn at.\n//\n// It replaces a longest-path layering on fixed 384×120 cells, which never minimised a crossing, put a loop's nodes on\n// one level, and let a tall node overflow its cell.\n//\n// Decided by practice (#2529): React Flow's layouting guide lists dagre as the small option, with dynamic node sizes\n// and sub-flows. elkjs also routes edges, at about 1.45 MB, and is the one to revisit only if routing is needed. A\n// domain model keeps its own grid, since domain models have cycles by nature.\n//===============================================================\n\n/** Which way a graph's ranks run. The values are dagre's `rankdir`. */\nexport enum GraphViewLayoutDirection {\n  /** Ranks run left to right: a flow, a plan. The edge leaves a node's right side and enters the next one's left. */\n  RIGHT = 'LR',\n  /** Ranks run top to bottom: a hierarchy, a sequence of rounds read down the page. */\n  DOWN = 'TB',\n}\n\nexport interface GraphViewSize {\n  readonly width: number;\n  readonly height: number;\n}\n\n/**\n * Where a node sits: its top-left corner and its size. A node drawn inside another (`parentId`) is placed RELATIVE TO\n * ITS PARENT's top-left corner, the convention React Flow uses for a sub-flow; every other node relative to the canvas.\n */\nexport interface GraphViewPlacement extends GraphViewSize {\n  readonly x: number;\n  readonly y: number;\n}\n\nexport interface GraphViewLayoutOptions {\n  readonly direction: GraphViewLayoutDirection;\n  /**\n   * The size a node is drawn at: its measured size once it has rendered, an estimate before. Not asked of a GROUP (a\n   * node other nodes are drawn inside), whose size is what its contents need.\n   */\n  readonly nodeSize: (node: GraphViewNode) => GraphViewSize;\n  /** Space between two nodes of one rank. Default {@link GRAPH_VIEW_LAYOUT_NODE_SPACING}. */\n  readonly nodeSpacing?: number;\n  /** Space between two ranks. Default {@link GRAPH_VIEW_LAYOUT_RANK_SPACING}. */\n  readonly rankSpacing?: number;\n  /** Space between a group's edge and what it holds. Default {@link GRAPH_VIEW_LAYOUT_GROUP_PADDING}. */\n  readonly groupPadding?: number;\n  /** Room at the top of a group for its own title, above what it holds. Default {@link GRAPH_VIEW_LAYOUT_GROUP_HEADER}. */\n  readonly groupHeader?: number;\n}\n\nexport interface GraphViewLayout {\n  /** One placement per node of the graph. */\n  readonly placements: ReadonlyMap<string, GraphViewPlacement>;\n  /**\n   * The group each node was placed inside, for every node placed inside one (its placement is relative to that group).\n   * A renderer reads it rather than `parentId`, which may name a node the graph does not hold or a loop of parents.\n   */\n  readonly parentOf: ReadonlyMap<string, string>;\n  /** The extent of everything placed at the top level. */\n  readonly width: number;\n  readonly height: number;\n}\n\nexport const GRAPH_VIEW_LAYOUT_NODE_SPACING = 40;\nexport const GRAPH_VIEW_LAYOUT_RANK_SPACING = 80;\nexport const GRAPH_VIEW_LAYOUT_GROUP_PADDING = 16;\nexport const GRAPH_VIEW_LAYOUT_GROUP_HEADER = 32;\n/**\n * The narrowest a group is drawn: room for its title above contents narrower than it. A node is a group only when\n * something is drawn inside it, so a group is never empty; a round that ran nothing is an ordinary node.\n */\nexport const GRAPH_VIEW_LAYOUT_GROUP_MIN_WIDTH = 160;\n\n/** The level the graph's top-level nodes are laid out in. */\nconst TOP_LEVEL = Symbol('top-level');\ntype Container = string | typeof TOP_LEVEL;\n\n/**\n * Lay a graph out. Asynchronous because dagre is imported on first use: the library is its own chunk, loaded only by a\n * surface that draws a graph, whoever imports this module.\n *\n * A graph with groups (nodes other nodes name as their `parentId`) is laid out one level at a time, innermost first:\n * each group's contents on their own, which gives the group its size, then the level holding the group with the group\n * as one sized node. dagre's own compound mode cannot do this here: it throws on any edge that touches a group, and the\n * rounds of a choreography are groups joined by edges. An edge between nodes of different groups counts, at each level,\n * as an edge between the nodes of that level that contain its ends, so a group still ranks after what feeds it.\n *\n * A `parentId` naming a node the graph does not hold, or a chain of parents that loops, places the node at the top level.\n */\nexport async function layoutGraphView(graph: GraphView, options: GraphViewLayoutOptions): Promise<GraphViewLayout> {\n  const { graphlib, layout } = await import('@dagrejs/dagre');\n  const nodeSpacing = options.nodeSpacing ?? GRAPH_VIEW_LAYOUT_NODE_SPACING;\n  const rankSpacing = options.rankSpacing ?? GRAPH_VIEW_LAYOUT_RANK_SPACING;\n  const groupPadding = options.groupPadding ?? GRAPH_VIEW_LAYOUT_GROUP_PADDING;\n  const groupHeader = options.groupHeader ?? GRAPH_VIEW_LAYOUT_GROUP_HEADER;\n\n  const nodesById = new Map(graph.nodes.map((node) => [node.id, node] as const));\n  const containerOf = resolveContainers(graph.nodes, nodesById);\n  const childrenOf = new Map<Container, GraphViewNode[]>();\n  for (const node of graph.nodes) {\n    const container = containerOf.get(node.id) ?? TOP_LEVEL;\n    childrenOf.set(container, [...(childrenOf.get(container) ?? []), node]);\n  }\n  const isGroup = (id: string) => childrenOf.has(id);\n\n  /** The node of `container`'s level that holds `id`: itself, or the ancestor that is a child of `container`. */\n  const representativeIn = (id: string, container: Container): string | undefined => {\n    let current: string | undefined = id;\n    const seen = new Set<string>();\n    while (current !== undefined && !seen.has(current)) {\n      seen.add(current);\n      if ((containerOf.get(current) ?? TOP_LEVEL) === container) return current;\n      const parent = containerOf.get(current);\n      current = parent === undefined || parent === TOP_LEVEL ? undefined : parent;\n    }\n    return undefined;\n  };\n\n  const placements = new Map<string, GraphViewPlacement>();\n  const sizes = new Map<string, GraphViewSize>();\n\n  /** Lay out one level; returns the extent of what it placed. Groups inside it are laid out first, for their size. */\n  const layOutLevel = (container: Container): GraphViewSize => {\n    // Empty only for a graph with no nodes at all: a group is a node something is drawn inside.\n    const members = childrenOf.get(container) ?? [];\n    for (const member of members) {\n      if (!isGroup(member.id)) {\n        sizes.set(member.id, options.nodeSize(member));\n        continue;\n      }\n      // Terminates: `resolveContainers` breaks every loop of parents, so the containers form a tree.\n      const inner = layOutLevel(member.id);\n      sizes.set(member.id, {\n        width: Math.max(GRAPH_VIEW_LAYOUT_GROUP_MIN_WIDTH, inner.width + 2 * groupPadding),\n        height: groupHeader + inner.height + 2 * groupPadding,\n      });\n    }\n    if (members.length === 0) return { width: 0, height: 0 };\n\n    const g = new graphlib.Graph({ multigraph: true });\n    g.setGraph({ rankdir: options.direction, nodesep: nodeSpacing, ranksep: rankSpacing, marginx: 0, marginy: 0 });\n    g.setDefaultEdgeLabel(() => ({}));\n    for (const member of members) g.setNode(member.id, { ...sizes.get(member.id)! });\n    for (const edge of graph.edges) {\n      const source = representativeIn(edge.source, container);\n      const target = representativeIn(edge.target, container);\n      // An edge with an end outside this level, or both ends inside one member, says nothing about this level's order.\n      if (source === undefined || target === undefined || source === target) continue;\n      g.setEdge(source, target, {}, edge.id);\n    }\n    layout(g);\n\n    let width = 0;\n    let height = 0;\n    const offset = container === TOP_LEVEL ? { x: 0, y: 0 } : { x: groupPadding, y: groupHeader + groupPadding };\n    for (const member of members) {\n      const laidOut = g.node(member.id);\n      const size = sizes.get(member.id)!;\n      // dagre places a node by its centre; a placement is its top-left corner.\n      const x = laidOut.x - size.width / 2;\n      const y = laidOut.y - size.height / 2;\n      placements.set(member.id, { x: x + offset.x, y: y + offset.y, width: size.width, height: size.height });\n      width = Math.max(width, x + size.width);\n      height = Math.max(height, y + size.height);\n    }\n    return { width, height };\n  };\n\n  const extent = layOutLevel(TOP_LEVEL);\n  return { placements, parentOf: parentsFrom(containerOf), width: extent.width, height: extent.height };\n}\n\n/**\n * The group each node is drawn inside, for every node drawn inside one: its `parentId` when that names a node the graph\n * holds and the chain of parents does not loop. The layout and every other presentation of a graph (a list of its\n * steps) nest by this, so a node a malformed `parentId` would hide is shown at the top level by all of them.\n */\nexport function graphViewParentOf(nodes: readonly GraphViewNode[]): ReadonlyMap<string, string> {\n  return parentsFrom(resolveContainers(nodes, new Map(nodes.map((node) => [node.id, node] as const))));\n}\n\nfunction parentsFrom(containers: ReadonlyMap<string, Container>): ReadonlyMap<string, string> {\n  const parentOf = new Map<string, string>();\n  for (const [id, container] of containers) if (container !== TOP_LEVEL) parentOf.set(id, container);\n  return parentOf;\n}\n\n/**\n * Each node's container: the group it is drawn inside, or the top level. A `parentId` the graph does not hold, or one\n * whose chain of parents loops back, puts the node at the top level rather than nowhere.\n */\nfunction resolveContainers(nodes: readonly GraphViewNode[], nodesById: ReadonlyMap<string, GraphViewNode>): ReadonlyMap<string, Container> {\n  const containers = new Map<string, Container>();\n  for (const node of nodes) {\n    const parent = node.parentId;\n    if (parent === undefined || !nodesById.has(parent)) {\n      containers.set(node.id, TOP_LEVEL);\n      continue;\n    }\n    // Walk the chain of parents; a revisit means a loop (a node naming itself is the shortest), and a node in a loop is\n    // placed at the top level.\n    const seen = new Set<string>([node.id]);\n    let current: string | undefined = parent;\n    let loops = false;\n    while (current !== undefined) {\n      if (seen.has(current)) { loops = true; break; }\n      seen.add(current);\n      const next: string | undefined = nodesById.get(current)?.parentId;\n      current = next !== undefined && nodesById.has(next) ? next : undefined;\n    }\n    containers.set(node.id, loops ? TOP_LEVEL : parent);\n  }\n  return containers;\n}\n"]}

package/dist/esm/core/flows-actors/graph-view.model.d.ts

@@ -0,0 +1,245 @@
+import { FlowsActors_Status, Flow_Node_Type, type ActorSystem_Execution, type FlowActorSystem_FrontendGraph, type ExecutionPlanReadinessStep } from '@wildo-ai/saas-models';
+/** What a node of a graph view stands for. */
+export declare enum GraphViewNodeKind {
+    /** A step of an execution plan, or a build-plan task projected as one (`projectBuildPlanAsExecutionPlanSteps`). */
+    PLAN_STEP = "plan_step",
+    /** A task an actor system works on outside its plan (`standaloneTasks`). */
+    TASK = "task",
+    /** What starts a flow. */
+    FLOW_TRIGGER = "flow_trigger",
+    /** A step of a flow; its own kind (action, branch, switch, parallel…) is `flowStepKind`. */
+    FLOW_STEP = "flow_step",
+    /** Where a flow ends. */
+    FLOW_FINISH = "flow_finish",
+    /** One round of a choreography: a group the playbooks it ran are drawn inside. */
+    CHOREOGRAPHY_ROUND = "choreography_round",
+    /** A playbook a choreography round ran. */
+    PLAYBOOK_RUN = "playbook_run",
+    /** A playbook of a catalog: what may run, drawn with the families it reads, waits for and writes. */
+    PLAYBOOK = "playbook",
+    /** An application specification family a playbook writes, reads or waits for. */
+    SPECIFICATION_FAMILY = "specification_family"
+}
+/** What an edge of a graph view states. */
+export declare enum GraphViewEdgeKind {
+    /**
+     * The target needs the source done first (`FlowsActors_Relation.DEPENDS_ON`), drawn from the dependency to the step
+     * that waits on it. `BLOCKED_BY` is not one: it has no writer and is not read as a dependency
+     * (`selectReadyExecutionPlanSteps`).
+     */
+    DEPENDS_ON = "depends_on",
+    /** A flow goes from the source to the target, as the flow declares it. */
+    FLOW = "flow",
+    /** One choreography round followed another, by the round numbers the trace records. */
+    NEXT_ROUND = "next_round",
+    /** A round began from the same input state as an earlier one (`sameInputStateAsIteration`): a lane not converging. */
+    REPEATS_INPUT_STATE = "repeats_input_state",
+    /** A playbook writes a family: one of its declared outputs. Drawn from the playbook to the family. */
+    PRODUCES = "produces",
+    /** A playbook reads a family: one of its declared inputs. Drawn from the family to the playbook. */
+    READS = "reads",
+    /**
+     * A playbook waits for a family: one of its preconditions names it (the family must exist, be valid, be stale or
+     * decide). Drawn from the family to the playbook. Not a READS: a playbook can wait for a family it never reads, and
+     * read one it does not wait for.
+     */
+    GATES = "gates",
+    /**
+     * A family's DECISION decides whether one of a playbook's preconditions applies: an `artifact_expected` gate's `when`
+     * (#2670). The build decomposition expects a website plan only once the capability composition decided the website is
+     * NEEDED. Drawn from the family to the playbook's gate. Not a GATES: the playbook never waits for this family, which
+     * only decides what it waits for.
+     */
+    CONDITIONS = "conditions",
+    /** A composite playbook runs another as one of its children (`method.choreography.admits`). */
+    ADMITS = "admits"
+}
+/** One end an edge attaches to. A node with several outgoing edges of different meaning has one port per edge. */
+export interface GraphViewPort {
+    readonly id: string;
+}
+export interface GraphViewNode {
+    readonly id: string;
+    readonly kind: GraphViewNodeKind;
+    /** The node's name, from its record (a step's name or topic, a task's title, a playbook's ref): a value, not a UI word. */
+    readonly label: string;
+    /** The status its record carries, when it carries one. */
+    readonly status?: FlowsActors_Status;
+    /**
+     * The nodes this one still waits on: dependencies that are not done. Empty for a node free to start, a node done,
+     * and a node with no dependency.
+     */
+    readonly waitsOn: readonly string[];
+    readonly inPorts: readonly GraphViewPort[];
+    readonly outPorts: readonly GraphViewPort[];
+    /** The node this one is drawn inside: a playbook run's round. */
+    readonly parentId?: string;
+    /** For a flow step, its declared kind (action, branch, switch, parallel…), as the flow carries it. */
+    readonly flowStepKind?: string;
+    /** What the node stands for in its record (a plan-step id, a task id, a flow ref, a playbook ref), for a host's navigation. */
+    readonly sourceRef: string;
+}
+export interface GraphViewEdge {
+    /** Unique in the graph, even for two edges between the same two nodes. */
+    readonly id: string;
+    readonly kind: GraphViewEdgeKind;
+    readonly source: string;
+    readonly sourcePort: string;
+    readonly target: string;
+    readonly targetPort: string;
+}
+/** The decision a run waits on, as its suspension records it. Absent when the run waits on nobody. */
+export interface GraphViewAwaitingDecision {
+    readonly decisionId: string;
+    readonly title: string;
+    readonly requestedAt: string;
+    readonly expiresAt?: string;
+}
+export interface GraphView {
+    readonly nodes: readonly GraphViewNode[];
+    readonly edges: readonly GraphViewEdge[];
+    /** Present when the run this graph draws waits on a person's decision. Said of the run: a suspension names no node. */
+    readonly awaitingDecision?: GraphViewAwaitingDecision;
+}
+/** The port every node has for what comes in, and for what goes out when nothing distinguishes its outgoing edges. */
+export declare const GRAPH_VIEW_IN_PORT = "in";
+export declare const GRAPH_VIEW_OUT_PORT = "out";
+/** A plan step as the plan adapter needs it: identity, dependencies, a name, and the status its record holds. */
+export interface GraphViewPlanStep extends ExecutionPlanReadinessStep {
+    readonly label: string;
+    readonly status?: FlowsActors_Status;
+}
+/**
+ * A plan's steps as a graph: one node per step, one DEPENDS_ON edge per dependency the step declares, drawn from the
+ * dependency to the step that waits on it, and each step's `waitsOn` — its dependencies not done yet.
+ *
+ * What "done" means is the caller's, exactly as for `selectReadyExecutionPlanSteps`: a step row is done when
+ * `COMPLETED`, a build-plan task when its products are committed. A dependency on a step the plan does not hold is
+ * waited on (the predicate has never heard of it) but draws no edge, since there is no node to draw it from.
+ */
+export declare function executionPlanGraph(steps: readonly GraphViewPlanStep[], isStepDone: (planStepId: string) => boolean): GraphView;
+/**
+ * One actor-system run as a graph: its plan's steps (with their dependencies) and its standalone tasks (with theirs),
+ * each node with the status the run records for it — a step's `stepStates` entry over the step's own status, a task's
+ * `standaloneTaskStates` entry over the task's — and the decision the run waits on, when it is suspended.
+ *
+ * The suspension is said of the RUN (`awaitingDecision`), never pinned on a node: it names the run and not a step, and
+ * marking "the current step" would be a guess. A step or task whose own recorded status is `AWAITING_APPROVAL` shows it.
+ */
+export declare function actorSystemExecutionGraph(execution: Pick<ActorSystem_Execution, 'status' | 'suspension' | 'plan' | 'standaloneTasks' | 'standaloneTaskStates'>): GraphView;
+/** What a flow's canvas is given: the same records `AI_FlowExecutionCanvas` takes. */
+export interface GraphViewFlowInput {
+    readonly triggers: readonly {
+        readonly ref: string;
+        readonly displayName: string;
+    }[];
+    readonly steps: readonly {
+        readonly ref: string;
+        readonly kind: string;
+        readonly name: string;
+    }[];
+    readonly finishes: readonly {
+        readonly ref: string;
+        readonly displayName?: string;
+    }[];
+    readonly edges: readonly {
+        readonly from: {
+            readonly type: string;
+            readonly ref: string;
+        };
+        readonly to: {
+            readonly type: string;
+            readonly ref: string;
+        };
+    }[];
+    /** Each node's run status, as a raw value; a value that is not a `FlowsActors_Status` is not shown as one. */
+    readonly nodeStates?: readonly {
+        readonly nodeRef: string;
+        readonly nodeType: string;
+        readonly status: string;
+    }[];
+}
+/** A flow node's graph id: its type and its ref, which together are unique in a flow (a step and a finish may share a ref). */
+export declare function flowGraphNodeId(type: Flow_Node_Type | string, ref: string): string;
+/**
+ * A flow as a graph. Each outgoing edge of a node that has SEVERAL gets a port of its own, in the order the flow lists
+ * them (`out-0`, `out-1`, …), so a branch's or a parallel's edges leave from distinct ports; a node with one outgoing
+ * edge keeps the single `out` port. The flow model names no port, so the order of its edges is the only thing that
+ * tells them apart, and it is what is used. An edge naming a node the flow does not declare draws nothing.
+ */
+export declare function flowGraph(flow: GraphViewFlowInput): GraphView;
+/**
+ * A FLOW's canvas input from the graph the backend serves for it (`FlowActorSystem_FrontendInfo.graph`, #676) and, for a
+ * run, the run's node states (`FlowRun_State.nodes`, the run's task output). A served flow graph keys every node by its
+ * ref, unique across the flow, so each edge's node types are read from the nodes it names; an edge naming no node is
+ * dropped, as `flowGraph` drops it.
+ */
+export declare function flowGraphInputOf(graph: FlowActorSystem_FrontendGraph, nodeStates?: GraphViewFlowInput['nodeStates']): GraphViewFlowInput;
+/**
+ * A choreography's rounds as the runs read serves them (the companion's round measurement, structurally): what each
+ * round ran, whether each run failed, and which earlier round a repeat began from.
+ */
+export interface GraphViewChoreographyInput {
+    readonly rounds: readonly {
+        readonly iteration: number;
+        readonly sameInputStateAsIteration?: number;
+        readonly children: readonly {
+            readonly playbookRef: string;
+            readonly failed: boolean;
+        }[];
+    }[];
+}
+/**
+ * A choreography as a graph: one group per round, the playbooks it ran inside it, NEXT_ROUND edges in the order of the
+ * rounds' numbers, and a REPEATS_INPUT_STATE edge from a round that began from an earlier round's input state back to
+ * that round — the loop a lane that is not converging makes, drawn because the record states it.
+ *
+ * A playbook run is FAILED when the round records it failed and COMPLETED otherwise: landing nothing is a finished
+ * run that changed nothing, not a failure. A nested lane's own rounds are not expanded here.
+ */
+export declare function choreographyGraph(trace: GraphViewChoreographyInput): GraphView;
+/** A playbook as the catalog map needs it: its ref and the edges it declares, each a ref or a family id. */
+export interface GraphViewCatalogPlaybook {
+    readonly playbookRef: string;
+    /** The families it writes: its declared outputs, not those of the children a composite runs. */
+    readonly outputFamilies: readonly string[];
+    /** The families its declared inputs read. */
+    readonly inputFamilies: readonly string[];
+    /** The families its preconditions name. */
+    readonly preconditionFamilies: readonly string[];
+    /** The families whose decision decides whether one of its preconditions applies; it never waits for them. */
+    readonly conditionFamilies: readonly string[];
+    /** The playbooks it runs as children when it is a composite, by ref; empty otherwise. */
+    readonly admits: readonly string[];
+}
+export interface GraphViewPlaybookCatalogInput {
+    readonly playbooks: readonly GraphViewCatalogPlaybook[];
+    /** A family's name, from its own record; a family named nowhere is labelled by its id. */
+    readonly familyLabels?: ReadonlyMap<string, string>;
+}
+/**
+ * The port a playbook's GATES and CONDITIONS edges enter by, apart from its READS and ADMITS, so a family that both feeds
+ * and gates it shows both. A condition enters by the gate too, since it changes what the gate asks.
+ */
+export declare const GRAPH_VIEW_GATE_PORT = "gate";
+/** The port a composite's ADMITS edges leave by, apart from the families it writes. */
+export declare const GRAPH_VIEW_ADMITS_PORT = "admits";
+/** A catalog node's id: playbooks and families live in separate namespaces, since a ref and a family id may be spelled alike. */
+export declare function playbookCatalogNodeId(kind: GraphViewNodeKind.PLAYBOOK | GraphViewNodeKind.SPECIFICATION_FAMILY, ref: string): string;
+/**
+ * A playbook catalog as a graph: what unlocks what. One node per playbook and one per family any of them names, and
+ * the five relations a playbook declares: it PRODUCES the families it writes, READS its inputs, waits for the families
+ * its preconditions name (GATES), lets a family's decision decide what it waits for (CONDITIONS), and, as a composite,
+ * ADMITS its children.
+ *
+ * Nothing is drawn that the declarations do not hold. A playbook carries no status here: whether it may run now is a
+ * verdict the host owns and shows on the node's body. Nor does it wait on anything the graph can name: a precondition
+ * may ask for a family to exist, be valid, be stale or decide, and only the gate knows which, so `waitsOn` stays empty
+ * rather than guess. A child the catalog does not hold draws no edge, as a dependency on an unknown step does not.
+ *
+ * Each relation a node has more than one meaning for gets its own port: a playbook's GATES and CONDITIONS enter by the
+ * gate port and its READS and ADMITS by the main one, and a composite's ADMITS leave by the admits port. A family that both feeds a
+ * playbook and gates it therefore draws two visible arrows, not one hidden under the other.
+ */
+export declare function playbookCatalogGraph(input: GraphViewPlaybookCatalogInput): GraphView;
+//# sourceMappingURL=graph-view.model.d.ts.map

package/dist/esm/core/flows-actors/graph-view.model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-view.model.d.ts","sourceRoot":"","sources":["../../../../../src/core/flows-actors/graph-view.model.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,kBAAkB,EAElB,cAAc,EAEd,KAAK,qBAAqB,EAC1B,KAAK,6BAA6B,EAClC,KAAK,0BAA0B,EAEhC,MAAM,uBAAuB,CAAC;AAe/B,8CAA8C;AAC9C,oBAAY,iBAAiB;IAC3B,mHAAmH;IACnH,SAAS,cAAc;IACvB,4EAA4E;IAC5E,IAAI,SAAS;IACb,0BAA0B;IAC1B,YAAY,iBAAiB;IAC7B,4FAA4F;IAC5F,SAAS,cAAc;IACvB,yBAAyB;IACzB,WAAW,gBAAgB;IAC3B,kFAAkF;IAClF,kBAAkB,uBAAuB;IACzC,2CAA2C;IAC3C,YAAY,iBAAiB;IAC7B,qGAAqG;IACrG,QAAQ,aAAa;IACrB,iFAAiF;IACjF,oBAAoB,yBAAyB;CAC9C;AAED,2CAA2C;AAC3C,oBAAY,iBAAiB;IAC3B;;;;OAIG;IACH,UAAU,eAAe;IACzB,0EAA0E;IAC1E,IAAI,SAAS;IACb,uFAAuF;IACvF,UAAU,eAAe;IACzB,sHAAsH;IACtH,mBAAmB,wBAAwB;IAC3C,sGAAsG;IACtG,QAAQ,aAAa;IACrB,oGAAoG;IACpG,KAAK,UAAU;IACf;;;;OAIG;IACH,KAAK,UAAU;IACf;;;;;OAKG;IACH,UAAU,eAAe;IACzB,+FAA+F;IAC/F,MAAM,WAAW;CAClB;AAED,kHAAkH;AAClH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC;IACjC,2HAA2H;IAC3H,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,0DAA0D;IAC1D,QAAQ,CAAC,MAAM,CAAC,EAAE,kBAAkB,CAAC;IACrC;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,QAAQ,CAAC,OAAO,EAAE,SAAS,aAAa,EAAE,CAAC;IAC3C,QAAQ,CAAC,QAAQ,EAAE,SAAS,aAAa,EAAE,CAAC;IAC5C,iEAAiE;IACjE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,sGAAsG;IACtG,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,+HAA+H;IAC/H,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,aAAa;IAC5B,0EAA0E;IAC1E,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC;IACjC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED,sGAAsG;AACtG,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,KAAK,EAAE,SAAS,aAAa,EAAE,CAAC;IACzC,QAAQ,CAAC,KAAK,EAAE,SAAS,aAAa,EAAE,CAAC;IACzC,uHAAuH;IACvH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,yBAAyB,CAAC;CACvD;AAED,sHAAsH;AACtH,eAAO,MAAM,kBAAkB,OAAO,CAAC;AACvC,eAAO,MAAM,mBAAmB,QAAQ,CAAC;AA0BzC,iHAAiH;AACjH,MAAM,WAAW,iBAAkB,SAAQ,0BAA0B;IACnE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,CAAC,EAAE,kBAAkB,CAAC;CACtC;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,SAAS,iBAAiB,EAAE,EAAE,UAAU,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,GAAG,SAAS,CAyB9H;AAcD;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,IAAI,CAAC,qBAAqB,EAAE,QAAQ,GAAG,YAAY,GAAG,MAAM,GAAG,iBAAiB,GAAG,sBAAsB,CAAC,GACpH,SAAS,CAoDX;AAMD,sFAAsF;AACtF,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,QAAQ,EAAE,SAAS;QAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACrF,QAAQ,CAAC,KAAK,EAAE,SAAS;QAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAClG,QAAQ,CAAC,QAAQ,EAAE,SAAS;QAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACtF,QAAQ,CAAC,KAAK,EAAE,SAAS;QAAE,QAAQ,CAAC,IAAI,EAAE;YAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;YAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;SAAE,CAAC;QAAC,QAAQ,CAAC,EAAE,EAAE;YAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;YAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,EAAE,CAAC;IAC5J,8GAA8G;IAC9G,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS;QAAE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CACnH;AASD,+HAA+H;AAC/H,wBAAgB,eAAe,CAAC,IAAI,EAAE,cAAc,GAAG,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAElF;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,kBAAkB,GAAG,SAAS,CAgD7D;AASD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,6BAA6B,EACpC,UAAU,CAAC,EAAE,kBAAkB,CAAC,YAAY,CAAC,GAC5C,kBAAkB,CAgBpB;AAMD;;;GAGG;AACH,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,MAAM,EAAE,SAAS;QACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;QAC3B,QAAQ,CAAC,yBAAyB,CAAC,EAAE,MAAM,CAAC;QAC5C,QAAQ,CAAC,QAAQ,EAAE,SAAS;YAC1B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;YAC7B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;SAC1B,EAAE,CAAC;KACL,EAAE,CAAC;CACL;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,0BAA0B,GAAG,SAAS,CA+B9E;AAMD,4GAA4G;AAC5G,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,gGAAgG;IAChG,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,6CAA6C;IAC7C,QAAQ,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1C,2CAA2C;IAC3C,QAAQ,CAAC,oBAAoB,EAAE,SAAS,MAAM,EAAE,CAAC;IACjD,6GAA6G;IAC7G,QAAQ,CAAC,iBAAiB,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9C,yFAAyF;IACzF,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;CACpC;AAED,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,SAAS,EAAE,SAAS,wBAAwB,EAAE,CAAC;IACxD,0FAA0F;IAC1F,QAAQ,CAAC,YAAY,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACrD;AAED;;;GAGG;AACH,eAAO,MAAM,oBAAoB,SAAS,CAAC;AAC3C,uFAAuF;AACvF,eAAO,MAAM,sBAAsB,WAAW,CAAC;AAE/C,iIAAiI;AACjI,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,iBAAiB,CAAC,QAAQ,GAAG,iBAAiB,CAAC,oBAAoB,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAEpI;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,6BAA6B,GAAG,SAAS,CA4DpF"}