@signalcore/ui 0.1.0 → 1.0.0-beta.0

package/dist/chat/useComposer.d.ts

@@ -1,46 +0,0 @@
-import { type ChangeEvent, type KeyboardEvent, type RefObject } from "react";
-export interface ComposerOptions {
-    /** The person sent what is written (not trimmed: the one who receives it decides). */
-    onSend: (text: string) => void;
-    /** A turn is running and can be stopped: Esc in the box stops it. */
-    onStop?: (() => void) | undefined;
-    /** A turn is running: nothing more can be sent. */
-    live?: boolean | undefined;
-    /** Nothing can be sent for now (the history is being read). The box stays free to write in. */
-    disabled?: boolean | undefined;
-    /** The text, when the host holds it (to add dictated words); else the hook keeps it. */
-    value?: string | undefined;
-    onValueChange?: ((value: string) => void) | undefined;
-    /** Something other than text is ready to go (a file attached), so an empty message may be sent. */
-    ready?: boolean | undefined;
-    /** Sending must wait for something (a file still uploading). */
-    blocked?: boolean | undefined;
-    /** Take the focus whenever this changes. */
-    focusSignal?: number | undefined;
-    /** Whether Esc in the box stops a running turn (default). A host that listens to Esc itself turns it off. */
-    escapeStops?: boolean | undefined;
-}
-export interface Composer {
-    text: string;
-    /** There is something to send, and nothing in the way. */
-    canSend: boolean;
-    /** Sends what is written, and empties the box. Nothing when it cannot be sent. */
-    send: () => void;
-    focus: () => void;
-    /** What to spread onto the `<textarea>`: it grows with the text, Enter sends, Shift+Enter breaks the line. */
-    input: {
-        ref: RefObject<HTMLTextAreaElement | null>;
-        rows: 1;
-        value: string;
-        onChange: (event: ChangeEvent<HTMLTextAreaElement>) => void;
-        onKeyDown: (event: KeyboardEvent<HTMLTextAreaElement>) => void;
-    };
-}
-/**
- * The behavior of the message box, without its look: what is written (held here or by the host),
- * when it can be sent, a box that grows with its text and takes the focus when asked, Enter to
- * send (never in the middle of an IME composition), Shift+Enter for a new line, and Esc to stop a
- * running turn. `Composer` is this with the package's markup; a host with its own look uses it
- * with its own.
- */
-export declare function useComposer({ onSend, onStop, live, disabled, value, onValueChange, ready, blocked, focusSignal, escapeStops, }: ComposerOptions): Composer;

package/dist/chat/useComposer.js

@@ -1,62 +0,0 @@
-import { useEffect, useLayoutEffect, useRef, useState, } from "react";
-/** How tall the box may grow with what is written before it scrolls. */
-const MAX_HEIGHT_PX = 200;
-/**
- * The behavior of the message box, without its look: what is written (held here or by the host),
- * when it can be sent, a box that grows with its text and takes the focus when asked, Enter to
- * send (never in the middle of an IME composition), Shift+Enter for a new line, and Esc to stop a
- * running turn. `Composer` is this with the package's markup; a host with its own look uses it
- * with its own.
- */
-export function useComposer({ onSend, onStop, live = false, disabled = false, value, onValueChange, ready = false, blocked = false, focusSignal, escapeStops = true, }) {
-    const [own, setOwn] = useState("");
-    const input = useRef(null);
-    const text = value ?? own;
-    const canSend = (text.trim() !== "" || ready) && !blocked && !live && !disabled;
-    const change = (next) => {
-        setOwn(next);
-        onValueChange?.(next);
-    };
-    const send = () => {
-        if (!canSend)
-            return;
-        onSend(text);
-        change("");
-    };
-    useLayoutEffect(() => {
-        const el = input.current;
-        if (!el)
-            return;
-        el.style.height = "auto";
-        el.style.height = `${Math.min(el.scrollHeight, MAX_HEIGHT_PX)}px`;
-    }, [text]);
-    useEffect(() => {
-        if (focusSignal)
-            input.current?.focus();
-    }, [focusSignal]);
-    return {
-        text,
-        canSend,
-        send,
-        focus: () => {
-            input.current?.focus();
-        },
-        input: {
-            ref: input,
-            rows: 1,
-            value: text,
-            onChange: (event) => {
-                change(event.target.value);
-            },
-            onKeyDown: (event) => {
-                if (event.key === "Enter" && !event.shiftKey && !event.nativeEvent.isComposing) {
-                    event.preventDefault();
-                    send();
-                }
-                else if (event.key === "Escape" && live && escapeStops) {
-                    onStop?.();
-                }
-            },
-        },
-    };
-}

package/dist/chat/useConversation.d.ts

@@ -1,35 +0,0 @@
-import type { SurfaceAction } from "../surface/types.js";
-import type { ChatMessage } from "./types.js";
-export interface ConversationOptions {
-    agentId: string;
-    /** The conversation to speak in; the agent remembers it across messages. */
-    thread?: string | undefined;
-    /**
-     * The messages already said in this thread, when the host can read them. Without it the chat
-     * reads the caller's own conversation if the client can (`endUsers.myConversation`).
-     */
-    loadHistory?: ((thread: string | undefined) => Promise<ChatMessage[]>) | undefined;
-    /** The person did something on a surface; it has already gone to the agent. */
-    onSurfaceAction?: ((action: SurfaceAction) => void) | undefined;
-}
-export interface Conversation {
-    messages: ChatMessage[];
-    /** The history is being read. */
-    loading: boolean;
-    /** The agent is writing its answer. */
-    answering: boolean;
-    /** The run paused for the owner to confirm something, and goes on when they do. */
-    waiting: boolean;
-    /** Something went wrong; the text is for the person, not for a developer. */
-    problem: string | undefined;
-    /** What the agent just said, in words, for whoever cannot see the page; empty before it speaks. */
-    announcement: string;
-    send: (text: string) => void;
-    /** The person picked or submitted something on a surface. */
-    act: (action: SurfaceAction) => void;
-}
-/**
- * The conversation between a person and an agent: what was said before (the history), then each
- * message and its answer (`useTurns`, which the voice window sends its turns with too).
- */
-export declare function useConversation(options: ConversationOptions): Conversation;

package/dist/chat/useConversation.js

@@ -1,71 +0,0 @@
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { useMessages, useSignalcore } from "../SignalcoreProvider.js";
-import { historyOf } from "./history.js";
-import { useTurns } from "./useTurns.js";
-/**
- * The conversation between a person and an agent: what was said before (the history), then each
- * message and its answer (`useTurns`, which the voice window sends its turns with too).
- */
-export function useConversation(options) {
-    const { agentId, thread } = options;
-    const { client } = useSignalcore();
-    const copy = useMessages();
-    const turns = useTurns({ agentId, thread });
-    const [past, setPast] = useState([]);
-    const [cannotLoad, setCannotLoad] = useState();
-    // The host's loader, else the caller's own conversation if the client can read it.
-    const loader = options.loadHistory ?? historyOf(client, agentId);
-    const [reading, setReading] = useState(loader !== undefined);
-    const latest = useRef({ options, loader, copy });
-    useEffect(() => {
-        latest.current = { options, loader, copy };
-    });
-    // What was said before comes first, whatever the person typed while it was being read.
-    useEffect(() => {
-        const load = latest.current.loader;
-        if (!load)
-            return undefined;
-        let current = true;
-        load(thread).then((before) => {
-            if (!current)
-                return;
-            setPast(before);
-            setReading(false);
-        }, () => {
-            if (!current)
-                return;
-            setCannotLoad(latest.current.copy.cannotLoadConversation);
-            setReading(false);
-        });
-        return () => {
-            current = false;
-        };
-    }, [thread]);
-    const { ask } = turns;
-    const say = useCallback((body, shown) => {
-        if (reading || !ask(body, shown))
-            return false;
-        setCannotLoad(undefined);
-        return true;
-    }, [ask, reading]);
-    const send = useCallback((text) => {
-        const input = text.trim();
-        if (input)
-            say({ input }, input);
-    }, [say]);
-    const act = useCallback((action) => {
-        if (say({ action }, action.label))
-            latest.current.options.onSurfaceAction?.(action);
-    }, [say]);
-    const messages = useMemo(() => [...past, ...turns.said], [past, turns.said]);
-    return {
-        messages,
-        loading: reading,
-        answering: turns.answering,
-        waiting: turns.waiting,
-        problem: turns.problem ?? cannotLoad,
-        announcement: turns.announcement,
-        send,
-        act,
-    };
-}

package/dist/chat/useStickToBottom.d.ts

@@ -1,9 +0,0 @@
-/**
- * Keeps a scroll container pinned to the bottom while its content grows, unless the reader has
- * scrolled up to look at something; scrolling back down pins it again. `scroller` goes on the
- * element that scrolls, `content` on the one inside it that grows.
- */
-export declare function useStickToBottom<S extends HTMLElement, C extends HTMLElement>(): {
-    scroller: import("react").RefObject<S | null>;
-    content: import("react").RefObject<C | null>;
-};

package/dist/chat/useStickToBottom.js

@@ -1,33 +0,0 @@
-import { useEffect, useRef } from "react";
-const NEAR_BOTTOM_PX = 80;
-/**
- * Keeps a scroll container pinned to the bottom while its content grows, unless the reader has
- * scrolled up to look at something; scrolling back down pins it again. `scroller` goes on the
- * element that scrolls, `content` on the one inside it that grows.
- */
-export function useStickToBottom() {
-    const scroller = useRef(null);
-    const content = useRef(null);
-    const pinned = useRef(true);
-    useEffect(() => {
-        const el = scroller.current;
-        const inner = content.current;
-        // Where there is nothing to watch the size with, the page simply does not follow.
-        if (!el || !inner || typeof ResizeObserver === "undefined")
-            return undefined;
-        const onScroll = () => {
-            pinned.current = el.scrollHeight - el.scrollTop - el.clientHeight < NEAR_BOTTOM_PX;
-        };
-        const observer = new ResizeObserver(() => {
-            if (pinned.current)
-                el.scrollTop = el.scrollHeight;
-        });
-        el.addEventListener("scroll", onScroll, { passive: true });
-        observer.observe(inner);
-        return () => {
-            el.removeEventListener("scroll", onScroll);
-            observer.disconnect();
-        };
-    }, []);
-    return { scroller, content };
-}

package/dist/chat/useTurns.d.ts

@@ -1,49 +0,0 @@
-import type { Schemas } from "@signalcore/sdk";
-import type { ChatMessage } from "./types.js";
-/** What `POST /v1/agents/{id}/invoke` takes. */
-type Invoke = Schemas["Invoke"];
-/**
- * How the person talks to the agent: by writing, or by voice (ADR 0011). A voice turn tells the
- * agent the person is listening, so it keeps its answer short and puts detail in a window.
- */
-export type Modality = NonNullable<Invoke["modality"]>;
-/** What a turn carries: the person's words or what they did on a surface. */
-export type TurnBody = Omit<Invoke, "thread" | "modality">;
-export interface TurnsOptions {
-    agentId: string;
-    /** The conversation to speak in; the agent remembers it across messages. */
-    thread?: string | undefined;
-    /**
-     * How the person talks to the agent. Left out, the API takes it as written; `"voice"` tells
-     * the agent they are listening.
-     */
-    modality?: Modality | undefined;
-}
-export interface Turns {
-    /**
-     * What was said since the turns began, oldest first: the person's messages and, after each,
-     * the agent's answer (and what a run said once it went on after pausing).
-     */
-    said: ChatMessage[];
-    /** The agent is writing its answer. */
-    answering: boolean;
-    /** The run paused for the owner to confirm something, and goes on when they do. */
-    waiting: boolean;
-    /** Something went wrong; the text is for the person, not for a developer. */
-    problem: string | undefined;
-    /** What the agent just said, in words, for whoever cannot see the page; empty before it speaks. */
-    announcement: string;
-    /**
-     * Sends a turn to the agent: `shown` is how it reads in the conversation. Nothing is sent, and
-     * this says so, while a turn is still under way or the client cannot invoke an agent.
-     */
-    ask: (body: TurnBody, shown: string) => boolean;
-}
-/**
- * The turns between a person and an agent, the one way both the chat and the voice window have:
- * a message goes out (`agents.invoke`, in the thread), the answer comes back, and a run that
- * paused for the owner to confirm something is followed until it ends and then shown. The
- * person never sees what was asked of the owner, only that the answer is waiting for it.
- */
-export declare function useTurns({ agentId, thread, modality }: TurnsOptions): Turns;
-export {};

package/dist/chat/useTurns.js

@@ -1,111 +0,0 @@
-import { useCallback, useRef, useState } from "react";
-import { useMessages, useSignalcore } from "../SignalcoreProvider.js";
-import { surfaceOf } from "../surface/check.js";
-import { useRunStream } from "../stream/useRunStream.js";
-import { arrivalOf } from "./arrival.js";
-const IDLE = { kind: "idle" };
-/**
- * The turns between a person and an agent, the one way both the chat and the voice window have:
- * a message goes out (`agents.invoke`, in the thread), the answer comes back, and a run that
- * paused for the owner to confirm something is followed until it ends and then shown. The
- * person never sees what was asked of the owner, only that the answer is waiting for it.
- */
-export function useTurns({ agentId, thread, modality }) {
-    const { client } = useSignalcore();
-    const copy = useMessages();
-    const invoke = client?.agents?.invoke;
-    const [said, setSaid] = useState([]);
-    const [phase, setPhase] = useState(IDLE);
-    const [problem, setProblem] = useState();
-    const [announcement, setAnnouncement] = useState("");
-    const counter = useRef(0);
-    const run = useRunStream(phase.kind === "following" ? phase.runId : undefined, { cards: false });
-    if (phase.kind === "following" && (run.status === "done" || run.status === "failed")) {
-        // The run is over: what it said after it paused joins the conversation (once, whatever
-        // the number of times this renders), and the person can speak again.
-        const arrival = arrivalOf(run.events);
-        const failed = run.status === "failed" || arrival.failed;
-        const id = `run-${phase.runId}`;
-        if (arrival.text !== "" || arrival.surfaces.length > 0) {
-            const message = {
-                id,
-                role: "agent",
-                text: arrival.text,
-                surfaces: arrival.surfaces,
-                at: undefined,
-            };
-            setSaid((now) => (now.some((each) => each.id === id) ? now : [...now, message]));
-            setAnnouncement(announce(message, copy));
-        }
-        if (failed)
-            setProblem(copy.cannotFinishAnswer);
-        setPhase(IDLE);
-    }
-    const ask = useCallback((body, shown) => {
-        if (!invoke || phase.kind !== "idle")
-            return false;
-        counter.current += 1;
-        const person = {
-            id: `person-${counter.current}`,
-            role: "person",
-            text: shown,
-            surfaces: [],
-            at: new Date().toISOString(),
-        };
-        setSaid((now) => [...now, person]);
-        setPhase({ kind: "answering" });
-        setProblem(undefined);
-        const turn = {
-            ...body,
-            ...(thread === undefined ? {} : { thread }),
-            ...(modality === undefined ? {} : { modality }),
-        };
-        invoke(agentId, turn).then((answer) => {
-            counter.current += 1;
-            const reply = replyOf(answer, `agent-${counter.current}`, copy);
-            if (reply) {
-                setSaid((now) => [...now, reply]);
-                setAnnouncement(announce(reply, copy));
-            }
-            setPhase(answer.waiting_for !== null && answer.run_id !== null
-                ? { kind: "following", runId: answer.run_id }
-                : IDLE);
-        }, () => {
-            setProblem(copy.cannotSendMessage);
-            setPhase(IDLE);
-        });
-        return true;
-    }, [invoke, phase.kind, agentId, thread, modality, copy]);
-    return {
-        said,
-        answering: phase.kind === "answering",
-        waiting: phase.kind === "following",
-        problem,
-        announcement,
-        ask,
-    };
-}
-/** What the agent answered, as a message; nothing when it said nothing at all. */
-function replyOf(answer, id, copy) {
-    const surfaces = (answer.surfaces ?? []).flatMap((raw) => surfaceOf(raw) ?? []);
-    // An escalated message has no answer from the agent: a person on the team will give it.
-    const text = answer.text !== "" ? answer.text : answer.escalated ? copy.handedToPerson : "";
-    if (text === "" && surfaces.length === 0)
-        return undefined;
-    return {
-        id: answer.message_id ?? id,
-        role: "agent",
-        text,
-        surfaces,
-        at: new Date().toISOString(),
-    };
-}
-/** A message in words alone: who said it, its text, and what its surfaces say in theirs. */
-function announce(message, copy) {
-    const parts = [message.text, ...message.surfaces.map((surface) => surface.fallback_text)]
-        .map((part) => part.trim())
-        .filter((part) => part !== "");
-    // Each part is a sentence: a pause between them, but not a second full stop.
-    const words = parts.map((part) => (/[.!?…:]$/.test(part) ? part : `${part}.`)).join(" ");
-    return `${copy.theAgent}: ${words}`;
-}

package/dist/classes.d.ts

@@ -1,2 +0,0 @@
-/** A class attribute from the parts that apply: falsy ones are skipped. */
-export declare function classes(...parts: (string | false | null | undefined)[]): string;

package/dist/development.d.ts

@@ -1,5 +0,0 @@
-/**
- * Tells the developer something the people using their page must never see: it is said in a
- * development build and kept quiet in a production one.
- */
-export declare function warnInDevelopment(message: string): void;

package/dist/development.js

@@ -1,8 +0,0 @@
-/**
- * Tells the developer something the people using their page must never see: it is said in a
- * development build and kept quiet in a production one.
- */
-export function warnInDevelopment(message) {
-    if (process.env.NODE_ENV !== "production")
-        console.warn(message);
-}

package/dist/flow/FlowWindow.d.ts

@@ -1,42 +0,0 @@
-import "@xyflow/react/dist/base.css";
-import type { AppDirectory } from "../request/types.js";
-import type { Overview, PackageFiles } from "../windows/types.js";
-import { type MapNode } from "./map.js";
-export interface FlowWindowProps {
-    /**
-     * The agent as its owner sees it: its channels, automations, skills and the apps they use. It
-     * is what is drawn when given. Without it, the window asks for the overview of `agentId`
-     * through the provider's client (`agents.overview`).
-     */
-    overview?: Overview | undefined;
-    /**
-     * The agent's package, by path (`draft_files` of the agent): the map reads from its code which
-     * action each automation calls, which record it keeps, which app it uses, whom it reaches.
-     * Without it, the window asks for the files of `agentId` (`agents.get`).
-     */
-    files?: PackageFiles | undefined;
-    /** The agent to ask about for whichever of `overview` and `files` is not given. */
-    agentId?: string | undefined;
-    /** The part that is picked, by its id (`automation:<id>`, a file's path…). Without it the window keeps its own. */
-    selectedId?: string | null | undefined;
-    /** A part was picked, or (with `null`) the empty canvas was. */
-    onSelect?: ((part: MapNode | null) => void) | undefined;
-    /** A second press on a part (Enter, from the keyboard): the host shows what it does. */
-    onOpen?: ((part: MapNode) => void) | undefined;
-    /** How the host knows its apps (names and logos); without it an app is a monogram. */
-    apps?: AppDirectory | undefined;
-    /** What the map is called to someone who cannot see it. */
-    label?: string | undefined;
-    className?: string | undefined;
-}
-/**
- * The agent as a map (ADR 0011's `flow` window): its channels, automations, skills, actions,
- * records and apps as parts in columns from what starts things to what they reach, with a line
- * for each call, read from its package. It is drawn from facts and never generated, and it is a
- * window of the owner: what it reads (the package's code) needs an owner's credential.
- *
- * Pan and zoom, pick a part by pressing it; a second press (a double click, or Enter on the part
- * with the keyboard) tells the host to open it. It lives in its own entry,
- * `@signalcore/ui/flow`, because the graph it is drawn with is not small.
- */
-export declare function FlowWindow(props: FlowWindowProps): import("react").JSX.Element;

package/dist/flow/FlowWindow.js

@@ -1,126 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import "@xyflow/react/dist/base.css";
-import { Background, BackgroundVariant, Controls, Handle, MarkerType, Position, ReactFlow, ReactFlowProvider, useReactFlow, } from "@xyflow/react";
-import { memo, useEffect, useMemo, useState } from "react";
-import { Mark } from "../parts/Icon.js";
-import { AppLogo } from "../request/apps.js";
-import { Scoped, useMessages, useParts } from "../SignalcoreProvider.js";
-import { Pending } from "../windows/Pending.js";
-import { automationStatus, channelStatus } from "../windows/status.js";
-import { both, useOverview, usePackageFiles } from "../windows/useLoaded.js";
-import { agentMap, NODE_H, NODE_W } from "./map.js";
-import { NODE_PATHS } from "./nodePaths.js";
-/**
- * The agent as a map (ADR 0011's `flow` window): its channels, automations, skills, actions,
- * records and apps as parts in columns from what starts things to what they reach, with a line
- * for each call, read from its package. It is drawn from facts and never generated, and it is a
- * window of the owner: what it reads (the package's code) needs an owner's credential.
- *
- * Pan and zoom, pick a part by pressing it; a second press (a double click, or Enter on the part
- * with the keyboard) tells the host to open it. It lives in its own entry,
- * `@signalcore/ui/flow`, because the graph it is drawn with is not small.
- */
-export function FlowWindow(props) {
-    return (_jsx(Scoped, { children: _jsx(Frame, { ...props }) }));
-}
-function Frame({ overview, files, agentId, label, className, ...rest }) {
-    const part = useParts();
-    const copy = useMessages();
-    const loaded = both(useOverview(overview, agentId), usePackageFiles(files, agentId));
-    return (_jsx("section", { ...part("flow", [], className), "aria-label": label ?? copy.flow.label, "aria-busy": loaded.state === "loading", children: loaded.state === "ready" ? (_jsx(Drawing, { overview: loaded.value[0], files: loaded.value[1], ...rest })) : (_jsx(Pending, { state: loaded.state, failed: copy.flow.cannotLoad })) }));
-}
-/** The map of an agent that has been read: the nodes, and which of them is picked. */
-function Drawing({ overview, files, selectedId, onSelect, onOpen, apps }) {
-    const part = useParts();
-    const copy = useMessages();
-    const [picked, setPicked] = useState(null);
-    const selected = selectedId === undefined ? picked : selectedId;
-    const map = useMemo(() => agentMap(overview, files, copy.flow), [overview, files, copy.flow]);
-    if (map.nodes.length === 0)
-        return _jsx("p", { ...part("flow__empty"), children: copy.flow.empty });
-    return (_jsx(ReactFlowProvider, { children: _jsx(Graph, { map: map, copy: copy, apps: apps, selectedId: selected, onSelect: (node) => {
-                setPicked(node?.id ?? null);
-                onSelect?.(node);
-            }, onOpen: onOpen }) }));
-}
-const NODE_TYPES = { part: memo(PartCard) };
-function Graph({ map, copy, apps, selectedId, onSelect, onOpen }) {
-    const nodes = useMemo(() => map.nodes.map((node) => ({
-        id: node.id,
-        type: "part",
-        position: { x: node.x, y: node.y },
-        data: { node, apps, copy },
-        selected: node.id === selectedId,
-    })), [map, apps, copy, selectedId]);
-    const edges = useMemo(() => map.edges.map((edge) => ({
-        id: edge.id,
-        source: edge.from,
-        target: edge.to,
-        type: "smoothstep",
-        markerEnd: { type: MarkerType.ArrowClosed, width: 16, height: 16 },
-        ...(edge.label
-            ? {
-                label: edge.label,
-                labelBgPadding: [6, 3],
-                labelBgBorderRadius: 6,
-            }
-            : {}),
-    })), [map]);
-    const { fitView } = useReactFlow();
-    const shape = map.nodes.map((node) => node.id).join("|");
-    useEffect(() => {
-        const timer = setTimeout(() => {
-            void fitView({ padding: 0.18, duration: 300, maxZoom: 1 });
-        }, 60);
-        return () => {
-            clearTimeout(timer);
-        };
-    }, [shape, fitView]);
-    /**
-     * Enter on a part that has the focus opens it. The key bubbles up from the part's wrapper
-     * (xyflow makes parts focusable and uses Space and Enter to pick them), so it is read here.
-     */
-    const openFromKeyboard = (event) => {
-        const target = event.target;
-        if (event.key !== "Enter" || !(target instanceof HTMLElement))
-            return;
-        if (!target.classList.contains("react-flow__node"))
-            return;
-        const node = map.nodes.find((candidate) => candidate.id === target.dataset.id);
-        if (node)
-            onOpen?.(node);
-    };
-    return (_jsxs(ReactFlow, { onKeyDown: openFromKeyboard, nodes: nodes, edges: edges, nodeTypes: NODE_TYPES, nodesDraggable: false, nodesConnectable: false, edgesFocusable: false, fitView: true, fitViewOptions: { padding: 0.18, maxZoom: 1 }, minZoom: 0.3, maxZoom: 1.5, proOptions: { hideAttribution: true }, zoomOnDoubleClick: false, onNodeClick: (_, node) => {
-            onSelect(node.data.node);
-        }, onNodeDoubleClick: (_, node) => {
-            onOpen?.(node.data.node);
-        }, onPaneClick: () => {
-            onSelect(null);
-        }, children: [_jsx(Background, { variant: BackgroundVariant.Dots, gap: 18, size: 1.2 }), _jsx(Controls, { showInteractive: false, position: "bottom-right" })] }));
-}
-/** What a part's state is, for its dot and for those who cannot see the dot. */
-function statusOf(node, copy) {
-    if (!node.status)
-        return null;
-    if (node.kind === "automation")
-        return automationStatus(node.status, copy);
-    if (node.kind === "channel")
-        return channelStatus(node.status, copy);
-    if (node.kind === "app") {
-        const connected = node.status === "active";
-        return {
-            word: connected ? copy.flow.detail.connected : copy.flow.detail.notConnected,
-            tone: connected ? "ok" : "neutral",
-        };
-    }
-    return null;
-}
-/** One part of the agent: its mark, its name, a word under it, its state. */
-function PartCard({ data, selected }) {
-    const part = useParts();
-    const { node, apps, copy } = data;
-    const status = statusOf(node, copy);
-    const brand = node.provider && (node.kind === "channel" || node.kind === "app");
-    const strong = node.kind === "automation" || node.kind === "skill";
-    return (_jsxs("div", { ...part("flow__node", [node.kind, strong && "strong", selected && "selected"]), style: { width: NODE_W, height: NODE_H }, children: [_jsx(Handle, { type: "target", position: Position.Left, ...part("flow__handle") }), _jsx("span", { ...part("flow__mark", [strong && "strong"]), children: brand ? (_jsx(AppLogo, { apps: apps, mark: { provider: node.provider, name: node.label, icon: null, size: 22 } })) : (_jsx(Mark, { path: NODE_PATHS[node.kind], slot: "flow__glyph" })) }), _jsxs("span", { ...part("flow__text"), children: [_jsx("span", { ...part("flow__name"), children: node.label }), _jsxs("span", { ...part("flow__detail"), children: [node.trigger && _jsxs("span", { ...part("flow__trigger"), children: [node.trigger, " \u00B7 "] }), node.detail] })] }), status && (_jsxs(_Fragment, { children: [_jsx("span", { "aria-hidden": true, ...part("status__dot", [status.tone]) }), _jsx("span", { ...part("sr-only"), children: status.word })] })), _jsx(Handle, { type: "source", position: Position.Right, ...part("flow__handle") })] }));
-}

package/dist/flow/index.d.ts

@@ -1,16 +0,0 @@
-/**
- * The windows that carry a graph library, as a second entry of the package so a host that never
- * draws a map does not load one:
- *
- *     import { FlowWindow } from "@signalcore/ui/flow";
- *
- * It is the agent as a map of its parts, and the pure functions that read the map from the
- * agent's overview and its package: `agentMap` lays it out, `relationsOf` finds who calls,
- * keeps, uses and reaches what in the code, and `kindOf`, `partName` and `kindLabel` name the
- * package's parts the way the owner reads them. Everything else is in `@signalcore/ui`, which
- * imports nothing from here except types.
- */
-export { FlowWindow, type FlowWindowProps } from "./FlowWindow.js";
-export { KINDS, kindLabel, kindOf, partName, type FlowWords, type PartKind } from "./kinds.js";
-export { agentMap, ownerOf, type MapEdge, type MapNode, type NodeKind } from "./map.js";
-export { relationsOf, triggerOf, type Edge, type EdgeKind, type PartNode, type Trigger, } from "./relations.js";

package/dist/flow/index.js

@@ -1,16 +0,0 @@
-/**
- * The windows that carry a graph library, as a second entry of the package so a host that never
- * draws a map does not load one:
- *
- *     import { FlowWindow } from "@signalcore/ui/flow";
- *
- * It is the agent as a map of its parts, and the pure functions that read the map from the
- * agent's overview and its package: `agentMap` lays it out, `relationsOf` finds who calls,
- * keeps, uses and reaches what in the code, and `kindOf`, `partName` and `kindLabel` name the
- * package's parts the way the owner reads them. Everything else is in `@signalcore/ui`, which
- * imports nothing from here except types.
- */
-export { FlowWindow } from "./FlowWindow.js";
-export { KINDS, kindLabel, kindOf, partName } from "./kinds.js";
-export { agentMap, ownerOf } from "./map.js";
-export { relationsOf, triggerOf, } from "./relations.js";