@calliopelabs/ui 0.7.0 → 0.11.0

package/dist/workflow/definition.js

@@ -0,0 +1,411 @@
+/** The definition format this package reads and writes. */
+export const WORKFLOW_DEFINITION_VERSION = 1;
+/** Every kind of node a flow is built from. */
+export const WORKFLOW_NODE_KINDS = [
+    "step",
+    "subflow",
+    "gate",
+    "condition",
+    "goto",
+    "fanout",
+    "join",
+    "variants",
+    "evaluator",
+    "classifier",
+    "check",
+];
+export const WORKFLOW_SELECTORS = [
+    "evaluator",
+    "first-passing",
+    "cheapest-passing",
+    "person",
+];
+// ---------------------------------------------------------------- lookups
+export function findPreset(registry, ref) {
+    if (!ref)
+        return null;
+    const module = registry.modules.find((m) => m.id === ref.module);
+    const preset = module?.presets.find((p) => p.id === ref.id);
+    return module && preset ? { module, preset } : null;
+}
+export function findFact(registry, id) {
+    return registry.facts.find((f) => f.id === id);
+}
+export function findGateKind(registry, id) {
+    return registry.gateKinds.find((g) => g.id === id);
+}
+/** The operators that fit a fact's type. */
+export function operatorsFor(registry, fact) {
+    if (!fact)
+        return [];
+    return registry.operators.filter((o) => o.types.includes(fact.type));
+}
+/** Every data type the registry names: the modules' own, then the host's. */
+export function dataTypes(registry) {
+    return [...registry.modules.flatMap((m) => m.types ?? []), ...(registry.types ?? [])];
+}
+/** Whether a value of type `given` can go where `wanted` is asked for. */
+export function typeAccepts(registry, given, wanted) {
+    if (wanted === "any" || given === wanted)
+        return true;
+    const types = dataTypes(registry);
+    const seen = new Set();
+    const stack = [given];
+    while (stack.length) {
+        const id = stack.pop();
+        if (id === wanted)
+            return true;
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        for (const t of types)
+            if (t.id === id)
+                stack.push(...(t.extends ?? []));
+    }
+    return false;
+}
+export const isJudge = (n) => n.kind === "evaluator" || n.kind === "classifier" || n.kind === "check";
+const SUBJECT = { id: "subject", label: "Subject", type: "any", optional: true };
+/**
+ * A node's typed inputs: a preset's, a custom step's own, a sub-flow's
+ * flow's, and a judge's subject (what it reads; the latest output when unbound).
+ */
+export function inputsOf(node, registry, definition) {
+    switch (node.kind) {
+        case "step":
+            return findPreset(registry, node.preset)?.preset.inputs ?? node.inputs ?? [];
+        case "variants":
+            return findPreset(registry, node.preset)?.preset.inputs ?? [];
+        case "subflow":
+            return definition?.flows[node.flow]?.inputs ?? [];
+        case "evaluator":
+        case "classifier":
+        case "check":
+            return [SUBJECT];
+        default:
+            return [];
+    }
+}
+/** A node's typed outputs. Gates, logic and judges pass work on but make nothing. */
+export function outputsOf(node, registry, definition) {
+    switch (node.kind) {
+        case "step":
+            return findPreset(registry, node.preset)?.preset.outputs ?? node.outputs ?? [];
+        case "variants":
+            return findPreset(registry, node.preset)?.preset.outputs ?? [];
+        case "subflow":
+            return definition?.flows[node.flow]?.outputs ?? [];
+        default:
+            return [];
+    }
+}
+// ---------------------------------------------------------------- exits and edges
+/** The way on from a node with one exit. */
+export const OUT = "out";
+/** The handle a loop leaves from, and the one it comes back into. */
+export const LOOP_OUT = "back";
+export const LOOP_IN = "back-in";
+/** The handle work comes into. */
+export const IN = "in";
+/**
+ * The exits a node offers for `next` edges, in order: a condition's cases and
+ * else, a check's yes and no, a classifier's labels, other and else, a routing
+ * evaluator's pass and fail. A go-to has none: it jumps.
+ */
+export function exitsOf(node) {
+    switch (node.kind) {
+        case "goto":
+            return [];
+        case "condition":
+            return [...node.cases.map((c) => `case:${c.id}`), "else"];
+        case "check":
+            return ["yes", "no"];
+        case "classifier":
+            return [
+                ...node.options.map((o) => `option:${o.id}`),
+                ...(node.other ? ["other"] : []),
+                "else",
+            ];
+        case "evaluator":
+            return node.routes ? ["pass", "fail"] : [OUT];
+        default:
+            return [OUT];
+    }
+}
+/**
+ * An exit as the node names it: a case's or a label's own words; the fixed
+ * exits (`else`, `yes`, `no`, `other`, `pass`, `fail`, `out`) come back as
+ * themselves for the caller's copy to name.
+ */
+export function exitLabel(node, exit) {
+    if (node.kind === "condition" && exit.startsWith("case:"))
+        return node.cases.find((c) => `case:${c.id}` === exit)?.label ?? exit;
+    if (node.kind === "classifier" && exit.startsWith("option:"))
+        return node.options.find((o) => `option:${o.id}` === exit)?.label ?? exit;
+    return exit;
+}
+export const portOf = (e) => e.port ?? (e.kind === "loop" ? LOOP_OUT : OUT);
+/** A stable id for an edge: its kind, ends and ports. */
+export const edgeId = (e) => `${e.kind}:${e.from}:${portOf(e)}>${e.to}${e.kind === "data" && e.input ? `:${e.input}` : ""}`;
+/** Ids reachable from `from` over next edges. */
+export function downstream(flow, from) {
+    return walk(flow, from, "down");
+}
+/** Ids with a path of next edges to `to`. */
+export function upstream(flow, to) {
+    return walk(flow, to, "up");
+}
+function walk(flow, start, dir) {
+    const seen = new Set();
+    const stack = [start];
+    while (stack.length) {
+        const id = stack.pop();
+        for (const e of flow.edges) {
+            if (e.kind !== "next")
+                continue;
+            const [a, b] = dir === "down" ? [e.from, e.to] : [e.to, e.from];
+            if (a === id && !seen.has(b)) {
+                seen.add(b);
+                stack.push(b);
+            }
+        }
+    }
+    return seen;
+}
+/** The node a flow starts at: the first with no next edge coming in. */
+export function startOf(flow) {
+    const into = new Set(flow.edges.filter((e) => e.kind === "next").map((e) => e.to));
+    return flow.nodes.find((n) => !into.has(n.id))?.id ?? null;
+}
+/** The default exit a new loop tests: the first boolean fact of the node that loops. */
+function defaultUntil(registry, from) {
+    const fact = registry.facts.find((f) => f.type === "boolean" && f.node && (f.node === true || f.node.includes(from.kind)));
+    const op = operatorsFor(registry, fact).find((o) => !o.unary);
+    return fact && op ? { fact: fact.id, node: from.id, op: op.id, value: true } : undefined;
+}
+/**
+ * Whether a connection makes a legal edge, and the edge when it does. Next
+ * edges go from an exit into `in`, one per exit (a fan-out excepted), and
+ * never close a cycle. Loops go from `back` into an earlier node's `back-in`.
+ * Data goes from an output to an input of a type it fits, on a node that runs
+ * after it, one source per input. The canvas only lands what this accepts.
+ */
+export function canConnect(flow, c, registry, definition) {
+    const a = flow.nodes.find((n) => n.id === c.from);
+    const b = flow.nodes.find((n) => n.id === c.to);
+    const refuse = (reason, values = {}) => ({ ok: false, reason, values });
+    if (!a || !b)
+        return refuse("missing-node");
+    const names = { from: a.label, to: b.label };
+    if (a.id === b.id)
+        return refuse("self", names);
+    if (c.source.startsWith("output:")) {
+        const out = outputsOf(a, registry, definition).find((p) => `output:${p.id}` === c.source);
+        if (!out)
+            return refuse("no-output", names);
+        if (!c.target.startsWith("input:"))
+            return refuse("data-target", names);
+        const input = inputsOf(b, registry, definition).find((p) => `input:${p.id}` === c.target);
+        if (!input)
+            return refuse("no-input", names);
+        const types = {
+            ...names,
+            output: out.label,
+            input: input.label,
+            given: out.type,
+            wanted: input.type,
+        };
+        if (!typeAccepts(registry, out.type, input.type))
+            return refuse("type-mismatch", types);
+        if (!downstream(flow, a.id).has(b.id))
+            return refuse("data-order", types);
+        if (flow.edges.some((e) => e.kind === "data" && e.to === b.id && e.input === input.id))
+            return refuse("input-taken", types);
+        return {
+            ok: true,
+            edge: { kind: "data", from: a.id, to: b.id, port: out.id, input: input.id },
+        };
+    }
+    if (c.source === LOOP_OUT) {
+        if (c.target !== LOOP_IN)
+            return refuse("loop-target", names);
+        if (!downstream(flow, b.id).has(a.id))
+            return refuse("loop-not-back", names);
+        if (flow.edges.some((e) => e.kind === "loop" && e.from === a.id && e.to === b.id))
+            return refuse("loop-exists", names);
+        const until = defaultUntil(registry, a);
+        return {
+            ok: true,
+            edge: { kind: "loop", from: a.id, to: b.id, max: 3, ...(until ? { until } : {}) },
+        };
+    }
+    if (c.target !== IN)
+        return refuse("next-target", names);
+    if (!exitsOf(a).includes(c.source))
+        return refuse("no-exit", { ...names, exit: c.source });
+    const sameExit = (e) => e.kind === "next" && e.from === a.id && portOf(e) === c.source;
+    if (flow.edges.some((e) => sameExit(e) && e.to === b.id))
+        return refuse("exists", names);
+    if (a.kind !== "fanout" && flow.edges.some(sameExit))
+        return refuse("exit-taken", { ...names, exit: exitLabel(a, c.source) });
+    if (downstream(flow, b.id).has(a.id))
+        return refuse("cycle", names);
+    return {
+        ok: true,
+        edge: { kind: "next", from: a.id, to: b.id, ...(c.source === OUT ? {} : { port: c.source }) },
+    };
+}
+// ---------------------------------------------------------------- edits
+/** A fresh node id from a label, not taken. */
+export function freshId(label, taken) {
+    const set = new Set(taken);
+    const base = label
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 24) || "node";
+    let id = base;
+    for (let i = 2; set.has(id); i++)
+        id = `${base}-${i}`;
+    return id;
+}
+/**
+ * A new node with workable defaults. Labels come from the preset or gate kind
+ * when there is one, else from `label` (the caller's copy for the kind).
+ */
+export function createNode(template, id, registry, label) {
+    const named = template.label ?? label;
+    switch (template.kind) {
+        case "step": {
+            const found = findPreset(registry, template.preset);
+            return found
+                ? { id, kind: "step", label: template.label ?? found.preset.label, preset: template.preset }
+                : { id, kind: "step", label: named, inputs: [], outputs: [] };
+        }
+        case "subflow":
+            return { id, kind: "subflow", label: named, flow: "" };
+        case "gate": {
+            const kind = findGateKind(registry, template.gate ?? "") ?? registry.gateKinds[0];
+            const fields = kind?.fields ?? [];
+            return {
+                id,
+                kind: "gate",
+                label: template.label ?? kind?.label ?? named,
+                gate: kind?.id ?? "",
+                ...(fields.includes("approvers") || fields.includes("timeout")
+                    ? {
+                        policy: fields.includes("approvers")
+                            ? { roles: registry.roles?.[0] ? [registry.roles[0].id] : [], quorum: 1 }
+                            : {},
+                    }
+                    : {}),
+                ...(fields.includes("threshold") ? { threshold: 0.7 } : {}),
+                ...(fields.includes("rule") ? { rule: "" } : {}),
+            };
+        }
+        case "condition": {
+            const fact = registry.facts[0];
+            const op = operatorsFor(registry, fact)[0];
+            return {
+                id,
+                kind: "condition",
+                label: named,
+                cases: [
+                    {
+                        id: "c1",
+                        label: "case 1",
+                        when: { fact: fact?.id ?? "", op: op?.id ?? "", ...(op?.unary ? {} : { value: "" }) },
+                    },
+                ],
+            };
+        }
+        case "goto":
+            return { id, kind: "goto", label: named, target: "", max: 2 };
+        case "fanout":
+            return { id, kind: "fanout", label: named };
+        case "join":
+            return { id, kind: "join", label: named, wait: "all" };
+        case "variants":
+            return {
+                id,
+                kind: "variants",
+                label: named,
+                ...(template.preset ? { preset: template.preset } : {}),
+                variants: [
+                    { id: "a", label: "A" },
+                    { id: "b", label: "B" },
+                ],
+                select: "first-passing",
+            };
+        case "evaluator":
+            return { id, kind: "evaluator", label: named, levels: [], threshold: 0.7, routes: true };
+        case "classifier":
+            return { id, kind: "classifier", label: named, options: [], other: true };
+        case "check":
+            return { id, kind: "check", label: named, question: "", threshold: 0.7 };
+    }
+}
+/** Adds a node, chained after `after` (or the last node) when an exit there is free. */
+export function addNode(flow, node, after) {
+    const from = flow.nodes.find((n) => n.id === after) ?? flow.nodes.at(-1);
+    const nodes = [...flow.nodes, node];
+    if (!from)
+        return { ...flow, nodes };
+    const exit = exitsOf(from).find((p) => from.kind === "fanout" ||
+        !flow.edges.some((e) => e.kind === "next" && e.from === from.id && portOf(e) === p));
+    if (!exit)
+        return { ...flow, nodes };
+    const edge = {
+        kind: "next",
+        from: from.id,
+        to: node.id,
+        ...(exit === OUT ? {} : { port: exit }),
+    };
+    return { ...flow, nodes, edges: [...flow.edges, edge] };
+}
+/** Removes a node and every edge touching it; a go-to or a condition pointing at it loses the reference. */
+export function removeNode(flow, id) {
+    return {
+        ...flow,
+        nodes: flow.nodes
+            .filter((n) => n.id !== id)
+            .map((n) => {
+            if (n.kind === "goto" && n.target === id)
+                return { ...n, target: "" };
+            if (n.kind === "variants" && n.evaluator === id)
+                return { ...n, evaluator: undefined };
+            return n;
+        }),
+        edges: flow.edges.filter((e) => e.from !== id && e.to !== id),
+    };
+}
+/** Replaces a node's fields, then drops next edges from exits it no longer has. */
+export function updateNode(flow, id, patch) {
+    const nodes = flow.nodes.map((n) => (n.id === id ? { ...n, ...patch } : n));
+    const node = nodes.find((n) => n.id === id);
+    if (!node)
+        return flow;
+    const exits = new Set(exitsOf(node));
+    return {
+        ...flow,
+        nodes,
+        edges: flow.edges.filter((e) => e.kind !== "next" || e.from !== id || exits.has(portOf(e))),
+    };
+}
+/** Moves a node; positions are part of the document. */
+export function moveNode(flow, id, at) {
+    return {
+        ...flow,
+        nodes: flow.nodes.map((n) => n.id === id ? { ...n, at: { x: Math.round(at.x), y: Math.round(at.y) } } : n),
+    };
+}
+export function removeEdge(flow, id) {
+    return { ...flow, edges: flow.edges.filter((e) => edgeId(e) !== id) };
+}
+export function updateEdge(flow, id, patch) {
+    return { ...flow, edges: flow.edges.map((e) => (edgeId(e) === id ? { ...e, ...patch } : e)) };
+}
+/** The definition with one flow replaced. */
+export function withFlow(definition, name, flow) {
+    return { ...definition, flows: { ...definition.flows, [name]: flow } };
+}

package/dist/workflow/editor/WorkflowDiff.d.ts

@@ -0,0 +1,17 @@
+import type { WorkflowFlow } from "../definition.js";
+import type { WorkflowDefinitionDiff } from "../portable.js";
+export interface WorkflowDiffProps {
+    /** From `diffDefinitions(before, after)`. */
+    diff: WorkflowDefinitionDiff;
+    /** The flows, to name them by their labels. */
+    flows?: Readonly<Record<string, Pick<WorkflowFlow, "label">>>;
+    /** Names the comparison ("Draft against live"). */
+    label?: string;
+    className?: string;
+}
+/**
+ * What a change does to what runs: details, flows,
+ * nodes and connections added, removed or changed, flow by flow. Moved nodes
+ * are counted apart, since a move does not change a run.
+ */
+export declare function WorkflowDiff({ diff: d, flows, label, className }: WorkflowDiffProps): import("react").JSX.Element;

package/dist/workflow/editor/WorkflowDiff.js

@@ -0,0 +1,25 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { cn } from "../../lib/cn.js";
+import { useUI } from "../../provider/UIProvider.js";
+/**
+ * What a change does to what runs: details, flows,
+ * nodes and connections added, removed or changed, flow by flow. Moved nodes
+ * are counted apart, since a move does not change a run.
+ */
+export function WorkflowDiff({ diff: d, flows, label, className }) {
+    const { messages } = useUI();
+    const m = messages.workspace;
+    const flowName = (name) => flows?.[name]?.label ?? name;
+    const edge = (e) => messages.editor.edgeName(e.kind, e.from, e.to);
+    const moved = d.flows.reduce((n, f) => n + f.moved.length, 0);
+    const row = (change, what, items) => items.length ? (_jsxs("li", { className: "flex gap-2", children: [_jsx("span", { "aria-hidden": true, className: cn("w-3 shrink-0 text-center font-mono", change === "added" && "text-success-fg", change === "removed" && "text-danger-fg", change === "changed" && "text-warning-fg"), children: change === "added" ? "+" : change === "removed" ? "-" : "~" }), _jsxs("span", { children: [m.change(change, what), ": ", items.join(", ")] })] })) : null;
+    return (_jsx("section", { "aria-label": label ?? m.diff, "data-slot": "workflow-diff", className: cn("flex flex-col gap-3 text-sm", className), children: d.same ? (_jsx("p", { className: "text-muted-foreground", children: moved ? m.onlyMoved(moved) : m.noChanges })) : (_jsxs(_Fragment, { children: [d.details.length || d.flowsAdded.length || d.flowsRemoved.length ? (_jsxs("ul", { className: "flex flex-col gap-1", children: [row("changed", m.details, d.details.map((k) => m.detail(k))), row("added", m.flows, d.flowsAdded.map(flowName)), row("removed", m.flows, d.flowsRemoved.map(flowName))] })) : null, d.flows.map((f) => [
+                    f.nodesAdded,
+                    f.nodesRemoved,
+                    f.nodesChanged,
+                    f.edgesAdded,
+                    f.edgesRemoved,
+                    f.edgesChanged,
+                ].some((l) => l.length) ? (_jsxs("div", { className: "flex flex-col gap-1", children: [_jsx("h3", { className: "text-xs font-medium text-muted-foreground", children: flowName(f.flow) }), _jsxs("ul", { className: "flex flex-col gap-1", children: [row("added", m.nodes, f.nodesAdded.map((n) => n.label)), row("removed", m.nodes, f.nodesRemoved.map((n) => n.label)), row("changed", m.nodes, f.nodesChanged.map((n) => n.label)), row("added", m.connections, f.edgesAdded.map(edge)), row("removed", m.connections, f.edgesRemoved.map(edge)), row("changed", m.connections, f.edgesChanged.map(edge))] })] }, f.flow)) : null), moved ? _jsx("p", { className: "text-muted-foreground", children: m.moved(moved) }) : null] })) }));
+}

package/dist/workflow/editor/WorkflowImportPreview.d.ts

@@ -0,0 +1,19 @@
+import type { WorkflowImportSummary as Preview } from "../portable.js";
+export interface WorkflowImportPreviewProps {
+    /** From `previewWorkflowImport`, against this destination's registry. */
+    preview: Preview;
+    /** Imports it as the host decides (a new draft, or over the definition it replaces). Omitted: preview only. */
+    onConfirm?: () => void;
+    onCancel?: () => void;
+    /** While the host imports. */
+    busy?: boolean;
+    className?: string;
+}
+/**
+ * What importing a package would do here, before it does it: whether this
+ * destination could run it, each module it needs as installed here, the
+ * capabilities and vocabulary missing, the nodes that would come in disabled,
+ * the gates that need approvers here (named people never travel), the
+ * problems, and, when it replaces a definition, the diff.
+ */
+export declare function WorkflowImportPreview({ preview, onConfirm, onCancel, busy, className, }: WorkflowImportPreviewProps): import("react").JSX.Element;

package/dist/workflow/editor/WorkflowImportPreview.js

@@ -0,0 +1,50 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { cn } from "../../lib/cn.js";
+import { Button } from "../../primitives/Button.js";
+import { useUI } from "../../provider/UIProvider.js";
+import { StatusBadge } from "../../status/StatusBadge.js";
+import { blockingProblems } from "../problems.js";
+import { WorkflowDiff } from "./WorkflowDiff.js";
+const MODULE_TONE = {
+    available: "ok",
+    version: "warn",
+    unavailable: "warn",
+    missing: "error",
+};
+const AVAILABILITY_TONE = {
+    available: "ok",
+    "missing-capabilities": "warn",
+    unsupported: "error",
+};
+/**
+ * What importing a package would do here, before it does it: whether this
+ * destination could run it, each module it needs as installed here, the
+ * capabilities and vocabulary missing, the nodes that would come in disabled,
+ * the gates that need approvers here (named people never travel), the
+ * problems, and, when it replaces a definition, the diff.
+ */
+export function WorkflowImportPreview({ preview, onConfirm, onCancel, busy = false, className, }) {
+    const { messages } = useUI();
+    const m = messages.workspace;
+    const blocking = blockingProblems(preview.problems).length;
+    const unknown = [
+        ...preview.unknownGateKinds.map((g) => m.unknownGateKind(g)),
+        ...preview.unknownFacts.map((f) => m.unknownFact(f)),
+        ...preview.unknownOperators.map((o) => m.unknownOperator(o)),
+    ];
+    const section = (title, children) => (_jsxs("section", { "aria-label": title, className: "flex flex-col gap-1.5", children: [_jsx("h3", { className: "text-xs font-medium text-muted-foreground", children: title }), children] }));
+    return (_jsxs("div", { "data-slot": "workflow-import-preview", className: cn("flex flex-col gap-4 text-sm", className), children: [_jsxs("p", { className: "flex flex-wrap items-center gap-2", children: [_jsx("span", { className: "font-medium", children: preview.definition.name }), " ", _jsx(StatusBadge, { tone: AVAILABILITY_TONE[preview.availability.status], children: m.importAvailability(preview.availability.status) })] }), section(m.modules, preview.modules.length ? (_jsx("ul", { className: "flex flex-col gap-1", children: preview.modules.map((mod) => (_jsxs("li", { className: "flex flex-wrap items-center gap-2", children: [_jsx("span", { children: messages.workflow.module(mod.label, mod.version) }), " ", _jsx(StatusBadge, { tone: MODULE_TONE[mod.status], children: m.moduleStatus(mod.status, mod.installed) })] }, mod.id))) })) : (_jsx("p", { className: "text-muted-foreground", children: m.noModules }))), preview.missingCapabilities.length
+                ? section(m.missingCapabilities, _jsx("p", { children: preview.missingCapabilities.join(", ") }))
+                : null, unknown.length
+                ? section(m.unknownVocabulary, _jsx("ul", { className: "flex flex-col gap-1", children: unknown.map((u) => (_jsx("li", { children: u }, u))) }))
+                : null, preview.disabled.length
+                ? section(m.disabledNodes(preview.disabled.length), _jsx("ul", { className: "flex flex-col gap-1", children: preview.disabled.map((n) => (_jsxs("li", { children: [n.label, _jsxs("span", { className: "text-muted-foreground", children: [", ", n.availability.status === "missing-capabilities"
+                                        ? messages.workflow.missingCapabilities(n.availability.missing ?? [])
+                                        : (n.availability.reason ?? messages.workflow.unsupported)] })] }, `${n.flow}/${n.id}`))) }))
+                : null, preview.gatesNeedingApprovers.length
+                ? section(m.needsApprovers, _jsx("p", { children: preview.gatesNeedingApprovers.map((g) => g.label).join(", ") }))
+                : null, section(messages.editor.problems, _jsx("p", { children: blocking ? m.importBlocking(blocking) : messages.editor.noProblems })), preview.diff
+                ? section(m.replaces, _jsx(WorkflowDiff, { diff: preview.diff, flows: preview.definition.flows, label: m.replaces }))
+                : null, onConfirm || onCancel ? (_jsxs("div", { className: "flex flex-wrap justify-end gap-2", children: [onCancel ? (_jsx(Button, { type: "button", variant: "outline", onClick: onCancel, disabled: busy, children: messages.editor.cancel })) : null, onConfirm ? (_jsx(Button, { type: "button", onClick: onConfirm, disabled: busy, children: busy ? m.importing : m.importAction })) : null] })) : null] }));
+}

package/dist/workflow/editor/WorkflowInspector.d.ts

@@ -0,0 +1,40 @@
+import * as React from "react";
+import { type WorkflowCondition, type WorkflowDefinition, type WorkflowFlow, type WorkflowGatePolicy, type WorkflowRegistry, type WorkflowSelection } from "../definition.js";
+export interface WorkflowInspectorProps {
+    definition: WorkflowDefinition;
+    registry: WorkflowRegistry;
+    selection?: WorkflowSelection | null;
+    /** Every edit, as the whole next definition. Omitted, or `readOnly`: the fields only show. */
+    onChange?: (definition: WorkflowDefinition) => void;
+    /** After a delete from the inspector, the selection is cleared through this. */
+    onSelectionChange?: (selection: WorkflowSelection | null) => void;
+    readOnly?: boolean;
+    className?: string;
+}
+/** One comparison on a run fact: the fact, its node when it is a node's, the operator and the value. */
+export declare function ConditionEditor({ condition, onChange, flow, registry, label, disabled, }: {
+    condition: WorkflowCondition;
+    onChange: (condition: WorkflowCondition) => void;
+    flow: WorkflowFlow;
+    registry: WorkflowRegistry;
+    /** Names the group, so several on a page are told apart. */
+    label: string;
+    disabled?: boolean;
+}): React.JSX.Element;
+/** Who approves a gate: roles, named members, a quorum, and a timeout with what happens then. */
+export declare function GatePolicyEditor({ policy, onChange, registry, approvers, timeout, disabled, }: {
+    policy: WorkflowGatePolicy;
+    onChange: (policy: WorkflowGatePolicy) => void;
+    registry: WorkflowRegistry;
+    approvers?: boolean;
+    timeout?: boolean;
+    disabled?: boolean;
+}): React.JSX.Element;
+/**
+ * The selected node's or connection's fields, edited in place: per-kind
+ * fields, a condition editor over the host's facts and operators, a gate
+ * policy editor (roles, members, quorum, timeout), and the host's model,
+ * harness and effort pickers. With nothing selected, the workflow's name and
+ * description. Every edit goes out as the whole next definition.
+ */
+export declare function WorkflowInspector({ definition, registry, selection, onChange, onSelectionChange, readOnly, className, }: WorkflowInspectorProps): React.JSX.Element;