@signalcore/ui 0.1.0 → 1.0.0-beta.0

package/dist/windows/hearing.d.ts

@@ -1,11 +0,0 @@
-import type { UiClient } from "../client.js";
-/**
- * The same client, told of the run behind each answer the agent gives. A shell needs the runs'
- * journals (that is where the app's own windows are opened, `ui.window`), and a turn can be sent
- * from the chat, from a voice window or from a generated one: listening at the client is the one
- * place that sees them all, and none of them has to know the shell is there.
- *
- * A client that cannot invoke an agent, or cannot read a run's journal, is returned as it is:
- * there is nothing to hear, or nothing to follow it with.
- */
-export declare function hearingRuns(client: UiClient | undefined, onRun: (runId: string) => void): UiClient | undefined;

package/dist/windows/hearing.js

@@ -1,26 +0,0 @@
-/**
- * The same client, told of the run behind each answer the agent gives. A shell needs the runs'
- * journals (that is where the app's own windows are opened, `ui.window`), and a turn can be sent
- * from the chat, from a voice window or from a generated one: listening at the client is the one
- * place that sees them all, and none of them has to know the shell is there.
- *
- * A client that cannot invoke an agent, or cannot read a run's journal, is returned as it is:
- * there is nothing to hear, or nothing to follow it with.
- */
-export function hearingRuns(client, onRun) {
-    const invoke = client?.agents?.invoke;
-    if (!client?.runs || !invoke)
-        return client;
-    return {
-        ...client,
-        agents: {
-            ...client.agents,
-            invoke: async (agentId, body) => {
-                const answer = await invoke(agentId, body);
-                if (answer.run_id !== null)
-                    onRun(answer.run_id);
-                return answer;
-            },
-        },
-    };
-}

package/dist/windows/kinds.d.ts

@@ -1,47 +0,0 @@
-import type { ComponentType } from "react";
-/**
- * The windows the app draws from facts, never generates (ADR 0011). The first four are the ones
- * an agent may open for a person (`signalcore_core.ui.windows`, which this mirrors: the kinds are
- * the engine's, so a `ui.window` event names one of them); `browser` and `live` are windows too,
- * but the platform opens those as a run shows what it drives, and the agent never asks for them.
- */
-export declare const DEFAULT_WINDOW_KINDS: readonly ["chat", "automations", "flow", "voice", "browser", "live"];
-export type DefaultWindowKind = (typeof DEFAULT_WINDOW_KINDS)[number];
-/**
- * The windows an end user of the business may be shown (ADR 0009): the conversation and the
- * voice. The ones about the business itself (what it automates, how the agent is built, the
- * browser it drives) are its owner's, and need an owner's credential: the engine does not offer
- * them to an end user's agent, and the shell does not open them for an end user's client.
- */
-export declare const END_USER_WINDOW_KINDS: readonly DefaultWindowKind[];
-/** Who is looking: the business's owner (or its team), or a person the business serves. */
-export type Viewer = "owner" | "end_user";
-export declare function isDefaultWindowKind(value: unknown): value is DefaultWindowKind;
-/** The kinds of window this viewer may be shown. */
-export declare function kindsFor(viewer: Viewer): readonly DefaultWindowKind[];
-/**
- * What a component that draws a default window is given by the shell. Every kind takes the same
- * props, so a host registers its own for any kind, and the windows that live in other entries
- * (`FlowWindow` from `@signalcore/ui/flow`, `VoiceWindow` from `@signalcore/ui/voice`) are
- * registered as they are: what they do not read, they ignore.
- */
-export interface DefaultWindowProps {
-    agentId: string;
-    /** The conversation the shell speaks in; the voice speaks in the same one. */
-    thread: string | undefined;
-    /** What the window is called: its title, for someone who cannot see it. */
-    label: string;
-    /**
-     * What the agent said the window shows, when it opened it (`ui.window`): the text twin, for a
-     * window that is drawn by no component here. Absent for a window the host opened.
-     */
-    fallbackText: string | undefined;
-    /**
-     * What the host opened the window with, for the kinds that need more than the agent can say:
-     * `sessionId` for a `browser`, `streamId` (and `aspect`) for a `live`.
-     */
-    params: Readonly<Record<string, string>>;
-    className?: string | undefined;
-}
-/** The components that draw the default windows, by kind. A kind with none shows its text twin. */
-export type DefaultWindowComponents = Partial<Record<DefaultWindowKind, ComponentType<DefaultWindowProps>>>;

package/dist/windows/kinds.js

@@ -1,28 +0,0 @@
-/**
- * The windows the app draws from facts, never generates (ADR 0011). The first four are the ones
- * an agent may open for a person (`signalcore_core.ui.windows`, which this mirrors: the kinds are
- * the engine's, so a `ui.window` event names one of them); `browser` and `live` are windows too,
- * but the platform opens those as a run shows what it drives, and the agent never asks for them.
- */
-export const DEFAULT_WINDOW_KINDS = [
-    "chat",
-    "automations",
-    "flow",
-    "voice",
-    "browser",
-    "live",
-];
-/**
- * The windows an end user of the business may be shown (ADR 0009): the conversation and the
- * voice. The ones about the business itself (what it automates, how the agent is built, the
- * browser it drives) are its owner's, and need an owner's credential: the engine does not offer
- * them to an end user's agent, and the shell does not open them for an end user's client.
- */
-export const END_USER_WINDOW_KINDS = ["chat", "voice"];
-export function isDefaultWindowKind(value) {
-    return DEFAULT_WINDOW_KINDS.some((kind) => kind === value);
-}
-/** The kinds of window this viewer may be shown. */
-export function kindsFor(viewer) {
-    return viewer === "owner" ? DEFAULT_WINDOW_KINDS : END_USER_WINDOW_KINDS;
-}

package/dist/windows/reduce.d.ts

@@ -1,98 +0,0 @@
-import type { Placement, SurfaceData } from "../surface/types.js";
-import type { RunEvent } from "../stream/reduce.js";
-import { type DefaultWindowKind } from "./kinds.js";
-/** The conversation is a window every stage has, first in the order, and it cannot be closed. */
-export declare const CHAT_ID: DefaultWindowKind;
-interface Opened {
-    /** Stable for as long as the window is the same one: its slot, or its kind. */
-    id: string;
-    title: string;
-    /** When it was opened (milliseconds, the host's clock); a reopened window starts again. */
-    openedAt: number;
-}
-/**
- * A page the agent composed and placed (`Surface.window`): the last surface of its slot. Nothing
- * is patched in place; a new surface in the slot replaces this one.
- */
-export interface GeneratedWindow extends Opened {
-    kind: "surface";
-    slot: string;
-    surface: SurfaceData;
-}
-/** A window the app draws from facts, never generated (`chat`, `automations`, `flow`…). */
-export interface DefaultWindow extends Opened {
-    kind: DefaultWindowKind;
-    /** The agent's words for what the window shows, when it opened it: the window's text twin. */
-    fallbackText: string | undefined;
-    /** What the host opened it with (`sessionId` of a browser, `streamId` of a live stream). */
-    params: Readonly<Record<string, string>>;
-}
-export type AgentWindow = GeneratedWindow | DefaultWindow;
-export declare const isDefault: (window: AgentWindow) => window is DefaultWindow;
-/** What a default window is called when nobody named it. */
-export type TitleOf = (kind: DefaultWindowKind) => string;
-/** The state of a stage, derived from facts and from what the person did; see `reduce`. */
-export interface WindowsState {
-    /** The open windows, in the order they were opened; the conversation is the first. */
-    windows: AgentWindow[];
-    /** The one on the stage. */
-    focusedId: string;
-    /**
-     * The windows the person closed, the latest first, for them to reopen. A closed window stays
-     * closed until they reopen it or the agent puts something new in it: the same surface or
-     * event reaching the stage again (a history read twice) does not bring it back.
-     */
-    closed: AgentWindow[];
-    /** The default windows this viewer may be shown; the others are never opened. */
-    allowed: readonly DefaultWindowKind[];
-    titleOf: TitleOf;
-    /** The surfaces and journal events already dealt with, so nothing is placed twice. */
-    seen: ReadonlySet<string>;
-}
-export interface BeginOptions {
-    /** Default windows to open besides the conversation; the first one listed takes the stage. */
-    initial: readonly DefaultWindowKind[];
-    allowed: readonly DefaultWindowKind[];
-    titleOf: TitleOf;
-    at: number;
-}
-export type Action = 
-/** The agent showed these surfaces; the ones with a window are placed (not taking the stage if `quiet`). */
-{
-    type: "place";
-    surfaces: readonly SurfaceData[];
-    quiet: boolean;
-    at: number;
-}
-/** A run's journal, from the start or with more of it: what it placed and opened. */
- | {
-    type: "journal";
-    runId: string;
-    events: readonly RunEvent[];
-    at: number;
-} | {
-    type: "open";
-    kind: DefaultWindowKind;
-    title?: string | undefined;
-    fallbackText?: string | undefined;
-    params?: Readonly<Record<string, string>> | undefined;
-    at: number;
-} | {
-    type: "focus";
-    id: string;
-} | {
-    type: "close";
-    id: string;
-} | {
-    type: "reopen";
-    id: string;
-    at: number;
-};
-export declare function begin({ initial, allowed, titleOf, at }: BeginOptions): WindowsState;
-export declare function reduce(state: WindowsState, action: Action): WindowsState;
-/**
- * Where a surface says it goes, if it does, with the title the window will have: the one it was
- * placed with, else its slot. The payload is a model's, so it is read defensively.
- */
-export declare function placementOf(surface: SurfaceData): Placement | undefined;
-export {};

package/dist/windows/reduce.js

@@ -1,151 +0,0 @@
-import { surfaceOf } from "../surface/check.js";
-import { isDefaultWindowKind } from "./kinds.js";
-/** The conversation is a window every stage has, first in the order, and it cannot be closed. */
-export const CHAT_ID = "chat";
-/** How many closed windows the stage remembers, for the person to reopen. */
-const MAX_CLOSED = 8;
-export const isDefault = (window) => window.kind !== "surface";
-export function begin({ initial, allowed, titleOf, at }) {
-    // The conversation is the window every viewer has.
-    const permitted = allowed.includes(CHAT_ID) ? allowed : [CHAT_ID, ...allowed];
-    const first = {
-        windows: [],
-        focusedId: CHAT_ID,
-        closed: [],
-        allowed: permitted,
-        titleOf,
-        seen: new Set(),
-    };
-    const opened = [CHAT_ID, ...initial].reduce((state, kind) => open(state, { kind, at }), first);
-    const listed = initial.find((kind) => permitted.includes(kind));
-    return { ...opened, focusedId: listed ?? CHAT_ID };
-}
-export function reduce(state, action) {
-    switch (action.type) {
-        case "place":
-            return action.surfaces.reduce((now, surface) => place(now, surface, action.quiet, action.at), state);
-        case "journal":
-            return action.events.reduce((now, event, index) => hear(now, `${action.runId}#${index}`, event, action.at), state);
-        case "open":
-            return open(state, action);
-        case "focus":
-            return state.windows.some((window) => window.id === action.id)
-                ? { ...state, focusedId: action.id }
-                : state;
-        case "close":
-            return close(state, action.id);
-        case "reopen": {
-            const window = state.closed.find((each) => each.id === action.id);
-            if (!window)
-                return state;
-            return {
-                ...state,
-                windows: [...state.windows, { ...window, openedAt: action.at }],
-                closed: state.closed.filter((each) => each.id !== action.id),
-                focusedId: window.id,
-            };
-        }
-    }
-}
-/** A surface the agent showed: a window if it says where, replacing what its slot had. */
-function place(state, surface, quiet, at) {
-    const placement = placementOf(surface);
-    if (!placement || state.seen.has(surface.id))
-        return state;
-    const id = `slot:${placement.slot}`;
-    const before = state.windows.find((window) => window.id === id);
-    const window = {
-        id,
-        kind: "surface",
-        slot: placement.slot,
-        title: placement.title,
-        surface,
-        openedAt: before?.openedAt ?? at,
-    };
-    return {
-        ...state,
-        windows: withWindow(state.windows, window),
-        closed: state.closed.filter((each) => each.id !== id),
-        focusedId: quiet ? state.focusedId : id,
-        seen: remembering(state.seen, surface.id),
-    };
-}
-/** One event of a run's journal; `key` is where it came from, so a replay changes nothing. */
-function hear(state, key, event, at) {
-    if (state.seen.has(key))
-        return state;
-    const heard = { ...state, seen: remembering(state.seen, key) };
-    if (event.type === "ui.surface") {
-        const surface = surfaceOf(event.surface);
-        return surface ? place(heard, surface, false, at) : heard;
-    }
-    if (event.type !== "ui.window" || !isDefaultWindowKind(event.kind))
-        return heard;
-    const title = event.title?.trim();
-    return open(heard, {
-        kind: event.kind,
-        title: title === "" ? undefined : title,
-        fallbackText: event.fallback_text,
-        at,
-    });
-}
-/**
- * Opens a default window and puts it on the stage; one that is open already is only brought
- * forward (with a new title or words if it came with some). A kind this viewer may not be shown
- * is not opened.
- */
-function open(state, opening) {
-    const { kind } = opening;
-    if (!state.allowed.includes(kind))
-        return state;
-    const before = state.windows.find((window) => isDefault(window) && window.id === kind);
-    const window = {
-        id: kind,
-        kind,
-        title: opening.title ?? before?.title ?? state.titleOf(kind),
-        fallbackText: opening.fallbackText ?? before?.fallbackText,
-        params: opening.params ?? before?.params ?? {},
-        openedAt: before?.openedAt ?? opening.at,
-    };
-    return {
-        ...state,
-        windows: withWindow(state.windows, window),
-        closed: state.closed.filter((each) => each.id !== kind),
-        focusedId: kind,
-    };
-}
-/** Closes a window; the stage goes to the one opened before it if it was on it. */
-function close(state, id) {
-    const index = state.windows.findIndex((window) => window.id === id);
-    const window = state.windows[index];
-    if (!window || window.id === CHAT_ID)
-        return state;
-    const windows = state.windows.filter((each) => each.id !== id);
-    return {
-        ...state,
-        windows,
-        closed: [window, ...state.closed].slice(0, MAX_CLOSED),
-        focusedId: state.focusedId === id ? (windows[index - 1]?.id ?? CHAT_ID) : state.focusedId,
-    };
-}
-/** The window where its place already is, else at the end. */
-function withWindow(windows, window) {
-    return windows.some((each) => each.id === window.id)
-        ? windows.map((each) => (each.id === window.id ? window : each))
-        : [...windows, window];
-}
-const remembering = (seen, key) => new Set(seen).add(key);
-/**
- * Where a surface says it goes, if it does, with the title the window will have: the one it was
- * placed with, else its slot. The payload is a model's, so it is read defensively.
- */
-export function placementOf(surface) {
-    const placement = surface.window;
-    if (typeof placement !== "object" || placement === null)
-        return undefined;
-    const { slot, title } = placement;
-    if (typeof slot !== "string" || slot === "")
-        return undefined;
-    const named = typeof title === "string" ? title.trim() : "";
-    return { slot, title: named === "" ? slot : named };
-}

package/dist/windows/registry.d.ts

@@ -1,18 +0,0 @@
-import type { DefaultWindowComponents } from "./kinds.js";
-/**
- * What a window says when nothing here draws it, or what it needs to be drawn is missing: its
- * text twin if the agent gave one when it opened it, else that it is not available. Never an
- * error: a host that has not registered a kind is a host that does not show it.
- */
-export declare function WindowTwin({ text }: {
-    text: string | undefined;
-}): import("react").JSX.Element;
-/**
- * The windows the core of the package draws. A host's `windows` on the provider are laid over
- * them, and the kinds that live in other entries (`flow`, `voice`) or need an owner's data
- * (`automations`) are the host's to register, so a page that never shows them does not load
- * them.
- */
-export declare const CORE_WINDOWS: DefaultWindowComponents;
-/** The components that draw the default windows here: the core's, with the host's laid over. */
-export declare function useWindowComponents(): DefaultWindowComponents;

package/dist/windows/registry.js

@@ -1,61 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { useMemo } from "react";
-import { AgentChat } from "../chat/AgentChat.js";
-import { ChatView } from "../chat/ChatView.js";
-import { BrowserView } from "../browser/BrowserView.js";
-import { LiveView } from "../live/LiveView.js";
-import { useMessages, useParts, useSignalcore } from "../SignalcoreProvider.js";
-import { Captions } from "./Captions.js";
-import { useSpaceChat } from "./space.js";
-/**
- * What a window says when nothing here draws it, or what it needs to be drawn is missing: its
- * text twin if the agent gave one when it opened it, else that it is not available. Never an
- * error: a host that has not registered a kind is a host that does not show it.
- */
-export function WindowTwin({ text }) {
-    const part = useParts();
-    const copy = useMessages();
-    return _jsx("p", { ...part("window__twin"), children: text ?? copy.space.noComponent });
-}
-/**
- * The conversation. Inside a shell it is the shell's own (the box is in the dock, and when the
- * person speaks the transcript collapses to captions); on its own, where a host lays windows out
- * itself, it is a chat of its own, `AgentChat`.
- */
-function ChatWindow({ agentId, thread, label, className }) {
-    const chat = useSpaceChat();
-    if (!chat) {
-        return _jsx(AgentChat, { agentId: agentId, thread: thread, label: label, className: className });
-    }
-    return chat.voice ? (_jsx(Captions, { chat: chat, className: className })) : (_jsx(ChatView, { conversation: chat.conversation, label: label, className: className, docked: true }));
-}
-/** A hosted browser, which the host opens with the session to watch (`params.sessionId`). */
-function BrowserWindow({ params, fallbackText, label, className }) {
-    const sessionId = params["sessionId"];
-    if (sessionId === undefined)
-        return _jsx(WindowTwin, { text: fallbackText });
-    return (_jsx(BrowserView, { sessionId: sessionId, streamId: params["streamId"], url: params["url"], title: params["title"] ?? label, className: className }));
-}
-/** A live stream, which the host opens with the stream to watch (`params.streamId`). */
-function LiveWindow({ params, fallbackText, label, className }) {
-    const streamId = params["streamId"];
-    if (streamId === undefined)
-        return _jsx(WindowTwin, { text: fallbackText });
-    return (_jsx(LiveView, { streamId: streamId, aspect: params["aspect"], input: params["input"] === "true", label: label, className: className }));
-}
-/**
- * The windows the core of the package draws. A host's `windows` on the provider are laid over
- * them, and the kinds that live in other entries (`flow`, `voice`) or need an owner's data
- * (`automations`) are the host's to register, so a page that never shows them does not load
- * them.
- */
-export const CORE_WINDOWS = {
-    chat: ChatWindow,
-    browser: BrowserWindow,
-    live: LiveWindow,
-};
-/** The components that draw the default windows here: the core's, with the host's laid over. */
-export function useWindowComponents() {
-    const { windows } = useSignalcore();
-    return useMemo(() => ({ ...CORE_WINDOWS, ...windows }), [windows]);
-}

package/dist/windows/reveal.d.ts

@@ -1,9 +0,0 @@
-/**
- * Brings the window of a slot to the stage, opening it again if the person closed it. A shell
- * (`AgentSpace`) provides it; where there is none, the chat has no stage to point at, and a
- * surface the agent placed in a window is drawn in the transcript, as it always was.
- */
-export type Reveal = (slot: string) => void;
-export declare const RevealContext: import("react").Context<Reveal | undefined>;
-/** The way to bring a window forward, when the chat is part of a shell; else nothing. */
-export declare function useReveal(): Reveal | undefined;

package/dist/windows/reveal.js

@@ -1,6 +0,0 @@
-import { createContext, useContext } from "react";
-export const RevealContext = createContext(undefined);
-/** The way to bring a window forward, when the chat is part of a shell; else nothing. */
-export function useReveal() {
-    return useContext(RevealContext);
-}

package/dist/windows/space.d.ts

@@ -1,21 +0,0 @@
-import type { Conversation } from "../chat/useConversation.js";
-/** What the voice heard and was answered in its latest turn: the words the chat collapses to. */
-export interface Spoken {
-    said: string;
-    answer: string;
-}
-/**
- * What a shell holds that its conversation window draws: the conversation itself, which lives in
- * the shell so that the box in the dock, the transcript on the stage and the picks on a generated
- * window all speak in the same one, and whether the person is listening instead of reading.
- */
-export interface SpaceChat {
-    conversation: Conversation;
-    /** The person talks and listens: the transcript collapses to the words just said. */
-    voice: boolean;
-    /** The voice's latest turn, which the captions show while it is newer than the transcript. */
-    spoken: Spoken | undefined;
-}
-export declare const SpaceChatContext: import("react").Context<SpaceChat | undefined>;
-/** The shell's conversation, when the window is drawn inside one; else nothing. */
-export declare function useSpaceChat(): SpaceChat | undefined;

package/dist/windows/space.js

@@ -1,6 +0,0 @@
-import { createContext, useContext } from "react";
-export const SpaceChatContext = createContext(undefined);
-/** The shell's conversation, when the window is drawn inside one; else nothing. */
-export function useSpaceChat() {
-    return useContext(SpaceChatContext);
-}

package/dist/windows/status.d.ts

@@ -1,11 +0,0 @@
-import type { Messages } from "../messages/types.js";
-/** How a state is coloured; the color is never the whole message, a word always goes with it. */
-export type Tone = "ok" | "signal" | "danger" | "neutral";
-export interface Status {
-    word: string;
-    tone: Tone;
-}
-/** How a channel stands: "Conectado", "Esperando el primer mensaje"… */
-export declare function channelStatus(state: string, copy: Messages): Status;
-/** How an automation stands: "Activa", "Sin activar", "Cambios sin activar". */
-export declare function automationStatus(state: string, copy: Messages): Status;

package/dist/windows/status.js

@@ -1,30 +0,0 @@
-const CHANNEL_TONE = {
-    active: "ok",
-    pending: "signal",
-    error: "danger",
-    disconnected: "neutral",
-};
-const AUTOMATION_TONE = {
-    active: "ok",
-    draft: "neutral",
-    changed: "neutral",
-};
-const toneOf = (table, state) => Object.hasOwn(table, state) ? (table[state] ?? "neutral") : "neutral";
-/** The word for a state the API named, or the state itself when this package does not know it. */
-function wordOf(words, state) {
-    return Object.hasOwn(words, state) ? (words[state] ?? state) : state;
-}
-/** How a channel stands: "Conectado", "Esperando el primer mensaje"… */
-export function channelStatus(state, copy) {
-    return {
-        word: wordOf(copy.automations.channelStatus, state),
-        tone: toneOf(CHANNEL_TONE, state),
-    };
-}
-/** How an automation stands: "Activa", "Sin activar", "Cambios sin activar". */
-export function automationStatus(state, copy) {
-    return {
-        word: wordOf(copy.automations.status, state),
-        tone: toneOf(AUTOMATION_TONE, state),
-    };
-}

package/dist/windows/types.d.ts

@@ -1,15 +0,0 @@
-import type { Schemas } from "@signalcore/sdk";
-/**
- * The agent as its owner sees it (`GET /v1/agents/{id}/overview`, `client.agents.overview`):
- * what the windows of an agent draw. A host that holds it already (the web app keeps it in its
- * cache) passes it as a prop; a window given only an `agentId` asks for it.
- */
-export type Overview = Schemas["Overview"];
-/** One automation of the overview: how it starts, how it stands, how the last run went. */
-export type Automation = Schemas["Automation"];
-/** An app a part uses, with what it does there and whether the owner has connected it. */
-export type AppChip = Schemas["AppChip"];
-/** What a model wrote about a part so the owner reads it in their words (`presentations`). */
-export type Presentation = Schemas["Part"];
-/** The files of an agent's package, by path: `agents.get(id).draft_files`. */
-export type PackageFiles = Record<string, string>;

package/dist/windows/types.js

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

package/dist/windows/useLoaded.d.ts

@@ -1,44 +0,0 @@
-import type { Overview, PackageFiles } from "./types.js";
-/** What a window has to draw: ready, on its way, failed, or with no way to get it. */
-export type Loaded<T> = {
-    state: "ready";
-    value: T;
-} | {
-    state: "loading";
-} | {
-    state: "failed";
-} | {
-    state: "unavailable";
-};
-/**
- * What a window draws: what the host gave, else what the client fetches for `key`. The props
- * are the source of truth, so nothing is asked while they are there; without them and without a
- * client that can, the window says it cannot be drawn. A new `key` (another agent) asks again,
- * and an answer to an old one is never shown.
- */
-export declare function useLoaded<T>(given: T | undefined, key: string | undefined, load: ((key: string) => Promise<T>) | undefined): Loaded<T>;
-/** The overview of an agent: the host's, else `agents.overview` of the provider's client. */
-export declare function useOverview(given: Overview | undefined, agentId: string | undefined): Loaded<{
-    live: boolean;
-    gear: import("@signalcore/sdk").components["schemas"]["Gear"][];
-    documents: number;
-    channels: import("@signalcore/sdk").components["schemas"]["ChannelFlow"][];
-    automations: import("@signalcore/sdk").components["schemas"]["Automation"][];
-    skills: import("@signalcore/sdk").components["schemas"]["Skill"][];
-    knowledge: import("@signalcore/sdk").components["schemas"]["Knowledge"][];
-    unpublished: import("@signalcore/sdk").components["schemas"]["Change"][];
-    warnings: string[];
-    presentations?: {
-        [key: string]: import("@signalcore/sdk").components["schemas"]["Part"];
-    };
-    presenting?: boolean;
-}>;
-/** The files of an agent's package: the host's, else the draft of `agents.get`. */
-export declare function usePackageFiles(given: PackageFiles | undefined, agentId: string | undefined): Loaded<{
-    [key: string]: string;
-}>;
-/**
- * Two things a window needs, as one: ready when both are. Otherwise what will never come says
- * so first (nothing to ask with, then a failure), and until then it is loading.
- */
-export declare function both<A, B>(a: Loaded<A>, b: Loaded<B>): Loaded<[A, B]>;

package/dist/windows/useLoaded.js

@@ -1,58 +0,0 @@
-import { useEffect, useMemo, useState } from "react";
-import { useSignalcore } from "../SignalcoreProvider.js";
-/**
- * What a window draws: what the host gave, else what the client fetches for `key`. The props
- * are the source of truth, so nothing is asked while they are there; without them and without a
- * client that can, the window says it cannot be drawn. A new `key` (another agent) asks again,
- * and an answer to an old one is never shown.
- */
-export function useLoaded(given, key, load) {
-    const [answer, setAnswer] = useState();
-    useEffect(() => {
-        if (given !== undefined || key === undefined || load === undefined)
-            return undefined;
-        let current = true;
-        load(key).then((value) => {
-            if (current)
-                setAnswer({ key, load, value });
-        }, () => {
-            if (current)
-                setAnswer({ key, load, failed: true });
-        });
-        return () => {
-            current = false;
-        };
-    }, [given, key, load]);
-    if (given !== undefined)
-        return { state: "ready", value: given };
-    if (key === undefined || load === undefined)
-        return { state: "unavailable" };
-    if (answer?.key !== key || answer.load !== load)
-        return { state: "loading" };
-    return "failed" in answer ? { state: "failed" } : { state: "ready", value: answer.value };
-}
-/** The overview of an agent: the host's, else `agents.overview` of the provider's client. */
-export function useOverview(given, agentId) {
-    const load = useSignalcore().client?.agents?.overview;
-    return useLoaded(given, agentId, load);
-}
-/** The files of an agent's package: the host's, else the draft of `agents.get`. */
-export function usePackageFiles(given, agentId) {
-    const get = useSignalcore().client?.agents?.get;
-    const load = useMemo(() => get && (async (id) => (await get(id)).draft_files), [get]);
-    return useLoaded(given, agentId, load);
-}
-/**
- * Two things a window needs, as one: ready when both are. Otherwise what will never come says
- * so first (nothing to ask with, then a failure), and until then it is loading.
- */
-export function both(a, b) {
-    if (a.state === "ready" && b.state === "ready") {
-        return { state: "ready", value: [a.value, b.value] };
-    }
-    for (const state of ["unavailable", "failed"]) {
-        if (a.state === state || b.state === state)
-            return { state };
-    }
-    return { state: "loading" };
-}