@kubed.io/cdn 0.0.1 → 0.0.4

package/dist/kd/elements/tile.d.ts

@@ -0,0 +1,19 @@
+import { KdElement } from '../element';
+/**
+ * The chat tile's header link: a large icon (an image URL or an emoji) over a
+ * small label. An `http(s)` link opens in a new tab.
+ *
+ * `<kd-tile icon="🤖" label="Ask" href="https://…"></kd-tile>`
+ */
+export declare class KdTile extends KdElement {
+    static properties: {
+        icon: {};
+        label: {};
+        href: {};
+    };
+    static styles: import("lit").CSSResult[];
+    icon: string | undefined;
+    label: string | undefined;
+    href: string | undefined;
+    render(): import("lit-html").TemplateResult<1>;
+}

package/dist/kd/helpers.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Data for a JSON attribute. Double-stash it so Handlebars escapes the quotes:
+ * `<kd-table data="{{kdjson rows}}">`. Never triple-stash JSON into an
+ * attribute: one `'` in the data turns the whole tag into escaped text.
+ */
+export declare function kdjson(value: unknown): string;
+interface Handlebars {
+    registerHelper(name: string, helper: (...args: unknown[]) => unknown): void;
+}
+/** Registers `kdjson` on Business Text's `context.handlebars`. */
+export declare function registerHelpers(handlebars: Handlebars): void;
+export {};

package/dist/kd/index.d.ts

@@ -1,2 +1,32 @@
 export { applyTheme, followTheme, type ThemeLike } from './theme';
 export { define, VERSION } from './define';
+export { KdElement, base, json, themedAncestor } from './element';
+export { kdjson, registerHelpers } from './helpers';
+import './elements/bar';
+import './elements/data';
+import './elements/groups';
+import './elements/link';
+import './elements/mask';
+import './elements/meter';
+import './elements/pill';
+import './elements/sheet';
+import './elements/steps';
+import './elements/table';
+import './elements/tabs';
+import './elements/tile';
+export { renderCell, cellStyles, isEmpty, type Cell, type PillCell, type HrefCell, type DashboardCell, type DataCell, type CodeCell, } from './cell';
+export { renderIcon, safeHref, tone, tones, type Tone } from './parts';
+export { toYaml, yamlLines, quote, type YamlKind, type YamlLine, type YamlToken } from './yaml';
+export { KdBar, type BarData } from './elements/bar';
+export { KdData } from './elements/data';
+export { KdGroups, jsonValue, type GroupsData } from './elements/groups';
+export { KdLink, linkUrl, type LinkData, type Vars } from './elements/link';
+export { KdMask } from './elements/mask';
+export { KdMeter, type MeterData, type MeterMark } from './elements/meter';
+export { KdPill } from './elements/pill';
+export { KdSheet, type SheetData, type SheetRow } from './elements/sheet';
+export { KdSteps, type Step, type StepStatus } from './elements/steps';
+export { KdTable, type TableColumn, type TableData } from './elements/table';
+export { KdTabs } from './elements/tabs';
+export { KdTile } from './elements/tile';
+export * from './scene';

package/dist/kd/parts.d.ts

@@ -0,0 +1,15 @@
+import { nothing, type TemplateResult } from 'lit';
+/** A semantic colour. Each maps to `--kd-<tone>`; neutral is the secondary text colour. */
+export type Tone = 'primary' | 'success' | 'warning' | 'error' | 'info' | 'neutral';
+/** `value` when it names a tone, else `fallback`. */
+export declare function tone(value: unknown, fallback?: Tone): Tone;
+/**
+ * Tone classes. Each sets `--tone` (the colour), `--tone-ink` (text in that
+ * colour, pulled towards the text colour so it reads on either theme) and
+ * `--tone-line` (a border in that colour).
+ */
+export declare const tones: import("lit").CSSResult;
+/** An icon that is either an image URL or a short text such as an emoji. */
+export declare function renderIcon(value: string | null | undefined, cls?: string): TemplateResult | typeof nothing;
+/** `href` unless it is a script or data URL, which data must never smuggle into a link. */
+export declare function safeHref(href: string | null | undefined): string | undefined;

package/dist/kd/scene.d.ts

@@ -0,0 +1,178 @@
+/** The page: its Window, or any node in it (a panel's `context.element`). */
+export type Page = Window | Node;
+export interface VariableOption {
+    value: unknown;
+    label?: string;
+}
+/** A dashboard variable: a dropdown has `changeValueTo` and options, a text box `setValue`. */
+export interface SceneVariable {
+    state: {
+        name?: string;
+        options?: VariableOption[];
+    };
+    getValue(): unknown;
+    changeValueTo?(value: unknown, text?: unknown): void;
+    setValue?(value: string): void;
+}
+export interface VariableSet {
+    getByName(name: string): SceneVariable | undefined;
+}
+export interface RawRange {
+    from: string;
+    to: string;
+}
+/** SceneTimeRange: `from`/`to` are the raw picker strings, `value` the evaluated dates. */
+export interface SceneTimeRange {
+    state: {
+        from?: unknown;
+        to?: unknown;
+        value?: {
+            from?: unknown;
+            to?: unknown;
+        };
+    };
+    onTimeRangeChange?(range: {
+        raw: RawRange;
+        from: string;
+        to: string;
+    }): void;
+    updateFromUrl?(raw: RawRange): void;
+}
+export interface RefreshPicker {
+    state: {
+        refresh?: string;
+        intervals?: string[];
+    };
+    setState(patch: {
+        refresh: string;
+    }): void;
+}
+/** Any scene object, for walking the graph. */
+export interface SceneNode {
+    state: any;
+    parent?: SceneNode | null;
+    setState?(patch: Record<string, unknown>): void;
+    forEachChild?(fn: (child: SceneNode) => void): void;
+}
+export interface DashboardScene extends SceneNode {
+    state: {
+        $variables?: VariableSet;
+        $timeRange?: SceneTimeRange;
+        controls?: unknown;
+        refreshPicker?: unknown;
+        body?: SceneNode;
+        [key: string]: unknown;
+    };
+}
+/** A tab or a collapsible row, and the panels it holds (`panel-N` keys). */
+export interface Group {
+    name: string;
+    kind: 'tab' | 'row';
+    open: boolean;
+    /** False for a row with a hidden header: always on screen, nothing to open. */
+    focusable: boolean;
+    panels: string[];
+    show(): void;
+}
+export interface Focused {
+    group: string;
+    kind: 'tab' | 'row';
+    panel: number | null;
+}
+export interface TimeWindow {
+    from: string;
+    to: string;
+    fromIso: string;
+    toIso: string;
+}
+/** The page's Window, from the Window itself or any node in it. */
+export declare function pageWindow(page: Page | null | undefined): Window | null;
+/** The dashboard scene, or null off a dashboard (or outside Grafana). */
+export declare function scene(page: Page | null | undefined): DashboardScene | null;
+export declare function variable(page: Page, name: string): SceneVariable | null;
+/** A variable's value as text: a multi-value joins with commas; missing is ''. */
+export declare function variableValue(page: Page, name: string): string;
+/**
+ * Sets one variable. A dropdown takes one of its own options (or an `$__all`
+ * value); anything else is refused, because Grafana would store it and show a
+ * blank picker. A text box takes any value.
+ *
+ * @returns the value set, or null when nothing changed
+ */
+export declare function setVariable(page: Page, name: string, value: unknown): string | null;
+/**
+ * Sets the `allowed` names found in `values`, one at a time in `allowed`'s
+ * order (order can matter: a variable that starts a job goes last).
+ *
+ * @returns what really changed, which is not always what was asked for
+ */
+export declare function setVariables(page: Page, values: Record<string, unknown>, allowed: string[]): Record<string, string>;
+/** The window on screen: raw (`now-24h`, what a person reads) and ISO (what a query needs). */
+export declare function timeRange(page: Page): TimeWindow | null;
+/**
+ * Moves the time picker, both ends in one call: `onTimeRangeChange` reads only
+ * `raw`, evaluates it and pushes the URL, so a reload keeps the window. A
+ * missing end keeps the picker's current one.
+ *
+ * @returns the raw window set, or null
+ */
+export declare function setTimeRange(page: Page, from?: string | null, to?: string | null): RawRange | null;
+/** `5m` -> 300. Off, empty or unreadable is 0. */
+export declare function intervalSeconds(interval: string | null | undefined): number;
+/** The refresh interval: `''` when auto-refresh is off, null when there is no picker. */
+export declare function refresh(page: Page): string | null;
+/** The intervals this dashboard's picker offers. Anything else renders it blank. */
+export declare function refreshIntervals(page: Page): string[];
+/**
+ * The offered interval nearest `want`, on a log scale because the steps are
+ * multiplicative (10m is nearer 15m than 5m). A tie goes to the slower one:
+ * fewer queries is the cheaper mistake.
+ */
+export declare function snapInterval(want: string, offered: string[]): string | null;
+/**
+ * Sets auto-refresh. An interval the picker does not offer is not an error to
+ * Grafana - it is stored, the picker goes blank and refreshing stops - so it is
+ * snapped to the nearest offered one.
+ *
+ * @returns what was set (`off` or an interval), or null
+ */
+export declare function setRefresh(page: Page, value: string): string | null;
+/**
+ * The dashboard's tabs and collapsible rows, in order. A v2 dashboard is a list
+ * of rows; a row holds panels or a tabs manager, and both are groups here,
+ * because to the person looking at it either way some panels show and others
+ * do not.
+ */
+export declare function groups(page: Page): Group[];
+/**
+ * Brings a panel or a group on screen. `target` is a panel id (`5`, `panel-5`)
+ * or a group name; either way its group is opened, so the caller never needs
+ * to know whether that is a tab or a row. A panel is then scrolled to, retrying
+ * over animation frames because a tab that was closed mounts a beat later.
+ */
+export declare function focusPanel(page: Page, target: string | number | null | undefined): Focused | null;
+/** What `fitPanel` reads from Business Text's `context`. */
+export interface FitContext {
+    grafana?: {
+        replaceVariables?(text: string): string;
+    };
+    /** The panel id or key, when `content` is not inside the panel's own DOM. */
+    panel?: string | number;
+}
+/**
+ * Grid rows needed for `px` of content. A grid item of height h spans 38h - 8
+ * px; `pad` covers the panel's own padding (12 with Business Text's `.dt-row`
+ * padding set to `4px 0 0`).
+ */
+export declare function gridHeight(px: number, pad?: number): number;
+/**
+ * Fits a panel's grid height to its content. Grafana has none of its own, but
+ * the grid item is reachable in the scene: setting its height changes state
+ * only, and the grid relays out once its parent gets a new children list. Live
+ * only, never saved; a no-op when the height is already right, so it is safe in
+ * an `afterRender` that runs twice per refresh.
+ *
+ * @param content the element to measure, inside the panel
+ * @returns the height set or kept, or null when the panel was not found
+ */
+export declare function fitPanel(content: HTMLElement, context?: FitContext): number | null;

package/dist/kd/theme.d.ts

@@ -12,6 +12,8 @@ export interface ThemeLike {
  * @param theme a GrafanaTheme2, e.g. `context.grafana.theme`
  */
 export declare function applyTheme(element: HTMLElement | null | undefined, theme: ThemeLike | null | undefined): void;
+/** Marks an element that is theming itself because nothing above it was. */
+export declare const SELF_THEMED = "data-kd-self-themed";
 /**
  * Themes `element` from Grafana's live theme without being handed one, and
  * keeps it themed across a live theme switch. For code that has no

package/dist/kd/yaml.d.ts

@@ -0,0 +1,17 @@
+/** What a token is, for highlighting. Punctuation and indentation are `plain`. */
+export type YamlKind = 'key' | 'str' | 'num' | 'bool' | 'null' | 'plain';
+export interface YamlToken {
+    kind: YamlKind;
+    text: string;
+}
+/** One output line: its indentation (with any `- ` markers), then its tokens. */
+export interface YamlLine {
+    prefix: string;
+    tokens: YamlToken[];
+}
+/** A string as a YAML scalar, double-quoted (JSON's escapes are YAML's) only when it must be. */
+export declare function quote(s: string): string;
+/** A JSON value as YAML lines of tokens, for rendering with highlighting. */
+export declare function yamlLines(value: unknown): YamlLine[];
+/** A JSON value as YAML text. */
+export declare function toYaml(value: unknown): string;

package/dist/kd.js

@@ -1,64 +1,5 @@
-//#region src/kd/theme.ts
-var e = [
-	["--kd-bg", (e) => e.colors.background.primary],
-	["--kd-bg-2", (e) => e.colors.background.secondary],
-	["--kd-canvas", (e) => e.colors.background.canvas],
-	["--kd-text", (e) => e.colors.text.primary],
-	["--kd-text-2", (e) => e.colors.text.secondary],
-	["--kd-text-dim", (e) => e.colors.text.disabled],
-	["--kd-link", (e) => e.colors.text.link],
-	["--kd-border", (e) => e.colors.border.weak],
-	["--kd-border-strong", (e) => e.colors.border.medium],
-	["--kd-primary", (e) => e.colors.primary.main],
-	["--kd-success", (e) => e.colors.success.main],
-	["--kd-warning", (e) => e.colors.warning.main],
-	["--kd-error", (e) => e.colors.error.main],
-	["--kd-info", (e) => e.colors.info.main],
-	["--kd-font", (e) => e.typography.fontFamily],
-	["--kd-font-mono", (e) => e.typography.fontFamilyMonospace],
-	["--kd-radius", (e) => e.shape.radius.default],
-	["--kd-space", (e) => e.spacing(1)]
-];
-function t(e, t) {
-	try {
-		let n = t(e);
-		return typeof n == "string" || typeof n == "number" ? String(n) : void 0;
-	} catch {
-		return;
-	}
-}
-function n(n, r) {
-	if (n && r) {
-		for (let [i, a] of e) {
-			let e = t(r, a);
-			e !== void 0 && n.style.setProperty(i, e);
-		}
-		typeof r.isDark == "boolean" && n.setAttribute("data-theme", r.isDark ? "dark" : "light");
-	}
-}
-var r = /* @__PURE__ */ new WeakMap();
-function i(e) {
-	let t = r.get(e);
-	return t || (t = Promise.resolve().then(() => e.System?.import?.("@grafana/runtime")).then((e) => {
-		let t = e;
-		return t?.config?.theme2 && t.getAppEvents && t.ThemeChangedEvent ? t : null;
-	}).catch(() => null), r.set(e, t)), t;
-}
-async function a(e) {
-	let t = e.ownerDocument?.defaultView, r = t ? await i(t) : null;
-	if (!r) return () => {};
-	n(e, r.config.theme2);
-	let a = r.getAppEvents().subscribe(r.ThemeChangedEvent, (t) => n(e, t?.payload ?? r.config.theme2));
-	return () => a.unsubscribe();
-}
-//#endregion
-//#region src/kd/define.ts
-var o = "0.0.1";
-function s(e, t, n = customElements) {
-	let r = n.get(e);
-	return r ? (r !== t && r.kdVersion !== "0.0.1" && console.warn(`@kubed.io/cdn ${o}: <${e}> is already defined by ${r.kdVersion ? `@kubed.io/cdn ${r.kdVersion}` : "another script"}; that definition stays until the page is reloaded.`), !1) : (Object.defineProperty(t, "kdVersion", { value: o }), n.define(e, t), !0);
-}
-//#endregion
-export { o as VERSION, n as applyTheme, s as define, a as followTheme };
-
-//# sourceMappingURL=kd.js.map
+import { d as e, i as t, n, r, t as i, u as a } from "./chunks/element-ChNBLJ5X.js";
+import { n as o, t as s } from "./chunks/define-XzEniRJH.js";
+import { C as c, E as l, S as u, T as d, _ as f, a as p, b as m, c as h, d as g, f as _, g as v, h as y, i as b, l as x, m as S, n as C, o as w, p as T, r as E, s as D, t as O, u as k, v as A, w as j, x as M, y as N } from "./chunks/kd-Bbw0GeQ5.js";
+import { _ as P, a as F, c as I, d as L, f as R, g as z, h as B, i as V, l as H, m as U, n as W, o as G, p as K, r as q, s as J, t as Y, u as X } from "./chunks/scene-CUr0fSXC.js";
+export { k as KdBar, M as KdData, i as KdElement, h as KdGroups, y as KdLink, D as KdMask, w as KdMeter, S as KdPill, p as KdSheet, b as KdSteps, E as KdTable, C as KdTabs, O as KdTile, s as VERSION, a as applyTheme, n as base, g as cellStyles, o as define, Y as fitPanel, W as focusPanel, e as followTheme, q as gridHeight, V as groups, F as intervalSeconds, _ as isEmpty, r as json, x as jsonValue, d as kdjson, v as linkUrl, G as pageWindow, u as quote, J as refresh, I as refreshIntervals, l as registerHelpers, T as renderCell, f as renderIcon, A as safeHref, H as scene, X as setRefresh, L as setTimeRange, R as setVariable, K as setVariables, U as snapInterval, t as themedAncestor, B as timeRange, c as toYaml, N as tone, m as tones, z as variable, P as variableValue, j as yamlLines };

package/dist/n8n/config.d.ts

@@ -0,0 +1,57 @@
+/**
+ * What the library panel passes to `mount`: its `chat_*` constants (decoded),
+ * the viewer, and the Authorization header. A field that arrives as a literal
+ * `${...}` (a dashboard without that variable) reads as empty.
+ */
+export interface ChatConfig {
+    /** An emoji, or an image URL. */
+    icon?: string;
+    label?: string;
+    /** Where the tile goes; an http(s) link opens a new tab. */
+    link?: string;
+    /** The n8n Chat Trigger URL. Empty means tile only, and any leftover bubble is removed. */
+    webhook?: string;
+    title?: string;
+    subtitle?: string;
+    /** Greeting lines, split on `|`. */
+    greeting?: string;
+    /** Extra metadata as `key=variable` pairs, read live on every send: `pod=pod,database=datname`. */
+    context?: string;
+    /** The names the agent may set, in applied order. `time_from`, `time_to`, `refresh` and `focus` are reserved. */
+    settable?: string;
+    /** Each group's purpose, `Name=purpose` pairs joined by `|` (Grafana has no description on a tab or a row). */
+    groups?: string;
+    /** Stream the reply. Must match the Chat Trigger's responseMode, or nothing renders. */
+    stream?: boolean | string;
+    /** The viewer's login, sent as metadata. */
+    user?: string;
+    /** The Authorization header value. Kept in Grafana and passed in, never in this package. */
+    auth?: string;
+    /** The `@n8n/chat` version loaded from jsDelivr. */
+    chatVersion?: string;
+    /** The tile: an element, a selector, or by default `#n8n-chat-tile`. An `<a>` or a `<kd-tile>`. */
+    tile?: Element | string | null;
+    /** The page; by default the tile's, else the global window. */
+    window?: Window;
+}
+export declare const CHAT_VERSION = "1.39.2";
+export interface Settings {
+    icon: string;
+    label: string;
+    link: string;
+    webhook: string;
+    title: string;
+    subtitle: string;
+    greeting: string[];
+    context: [key: string, variable: string][];
+    settable: string[];
+    groups: Record<string, string>;
+    stream: boolean;
+    user: string;
+    auth: string;
+    chatVersion: string;
+}
+export declare function list(value: string): string[];
+/** `Name=purpose|Other=purpose` -> lower-cased name to purpose. */
+export declare function groupNotes(value: string): Record<string, string>;
+export declare function settings(config: ChatConfig): Settings;

package/dist/n8n/fetch.d.ts

@@ -0,0 +1,35 @@
+import type { Focused } from '../kd/scene';
+/**
+ * What the fetch wrapper acts for: the chat on screen. Kept on the page window
+ * as `n8nChat` in the shape the pre-package library panel used, so a wrapper
+ * installed by either one serves the other.
+ */
+export interface ChatHandle {
+    webhook: string;
+    settable: string[];
+    stream: boolean;
+    setVariables(vars: Record<string, unknown> | null | undefined, names: string[]): Record<string, string>;
+    cleanHistory<T>(reply: T): T;
+    filterStream(body: ReadableStream<Uint8Array>): ReadableStream<Uint8Array>;
+}
+/** The page globals the chat keeps. They outlive this module across SPA navigation and package versions. */
+export interface ChatWindow extends Window {
+    n8nChat?: ChatHandle | null;
+    n8nChatWatch?: number;
+    n8nChatFetchWrapped?: boolean;
+    n8nChatFit?: () => void;
+    n8nChatResize?: boolean;
+    n8nChatMount?: {
+        key: string;
+        done: boolean;
+        ready: Promise<void>;
+    };
+    /** The resolver the agent navigates with, for the dashboard's own buttons (Torrent's use it). */
+    dashboardFocus?: (target: string | number) => Focused | null;
+}
+/**
+ * Wraps the page's fetch, once per page. The wrapper reads `n8nChat` on every
+ * call, which each mount replaces, so it acts for the dashboard on screen and
+ * only for its webhook.
+ */
+export declare function wrapFetch(win: ChatWindow): void;

package/dist/n8n/history.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Cleans a `loadPreviousSession` reply for the widget, whose markdown renderer
+ * throws on anything but a string. Tool, system and function messages are
+ * dropped (a tool message's content is the tool's raw JSON, a non-empty string
+ * that would otherwise fill the reloaded chat); array content is flattened to
+ * its text, and a message left with no text is dropped.
+ */
+export declare function cleanHistory<T>(reply: T): T;

package/dist/n8n/index.d.ts

@@ -0,0 +1,8 @@
+export { VERSION } from '../kd/define';
+export { mount, fillTile, fitChat, injectStyles, chatBundle, chatStyle, type ChatLoader, type CreateChat } from './mount';
+export { CHAT_VERSION, settings, type ChatConfig, type Settings } from './config';
+export { CONTROL_NODE, controlFilter } from './stream';
+export { cleanHistory } from './history';
+export { applyState, applyToolCalls, readToolCalls, stateCard, placeCard, RESERVED, type DashboardState, type ToolCalls } from './state';
+export { chatMetadata, describeGroups } from './metadata';
+export type { ChatHandle, ChatWindow } from './fetch';

package/dist/n8n/metadata.d.ts

@@ -0,0 +1,10 @@
+import { type Group } from '../kd/scene';
+import type { Settings } from './config';
+/** The navigation map for the agent: one line per group, with its purpose from `chat_groups`. */
+export declare function describeGroups(list: Group[], notes: Record<string, string>): string;
+/**
+ * The metadata sent with every message. @n8n/chat serialises this same object
+ * on each send, so every live field is a getter: the agent hears about the
+ * window, refresh and layout on screen at send time, not at page load.
+ */
+export declare function chatMetadata(win: Window, s: Settings, home: string): Record<string, unknown>;

package/dist/n8n/mount.d.ts

@@ -0,0 +1,29 @@
+import { type ChatConfig, type Settings } from './config';
+export type CreateChat = (options: Record<string, unknown>) => unknown;
+export type ChatLoader = (url: string) => Promise<{
+    createChat: CreateChat;
+}>;
+export declare const chatBundle: (version: string) => string;
+export declare const chatStyle: (version: string) => string;
+/** Injects the tile's page-global stylesheet once; a newer build's replaces an older one's. */
+export declare function injectStyles(doc: Document): void;
+/** Fills the tile: an `<a>` with `.icon` and `.label` children, or a `<kd-tile>` by its attributes. */
+export declare function fillTile(tile: Element, s: Pick<Settings, 'icon' | 'label' | 'link'>): void;
+/**
+ * Pins the chat window's top under Grafana's controls row, which is measured
+ * because it grows when the variables wrap and is absent in a kiosk embed. With
+ * no row, or below 900px, the inline values go so the stylesheet's apply.
+ */
+export declare function fitChat(win: Window): void;
+/**
+ * Mounts the chat tile and its n8n chat on the page.
+ *
+ * Idempotent: the core text panel re-runs its script on every mount, so a
+ * repeat call for the same dashboard and settings keeps the chat that is there.
+ * Grafana is a single-page app, so the chat lives on `<body>` only while the URL
+ * stays on this dashboard. With no webhook it fills the tile and removes any
+ * leftover chat.
+ *
+ * @returns once the chat is created (or at once, tile only)
+ */
+export declare function mount(config?: ChatConfig, loader?: ChatLoader): Promise<void>;

package/dist/n8n/state.d.ts

@@ -0,0 +1,44 @@
+import { type Focused, type Page } from '../kd/scene';
+/** Names in `chat_settable` that are not template variables. */
+export declare const RESERVED: string[];
+export interface ToolCalls {
+    tools?: {
+        args?: Record<string, unknown> | null;
+    }[];
+}
+export interface DashboardState {
+    /** Settable names to values; a later call in the turn wins. */
+    vars: Record<string, string>;
+    /** What to bring on screen: an explicit `focus`, else the last panel read. Null unless `focus` is settable. */
+    focus: string | null;
+}
+/**
+ * Maps a turn's tool calls onto the dashboard. An argument named like a
+ * settable name IS that name, so no dashboard-specific mapping lives in n8n.
+ * `panelId` is how the agent says which panel it read, so reading a panel is a
+ * focus; an explicit `focus` argument beats it.
+ */
+export declare function readToolCalls(payload: ToolCalls | null | undefined, settable: string[]): DashboardState;
+/**
+ * Applies `values` to the page: only the `settable` names, in that order.
+ * `refresh` snaps to an offered interval; `time_from`/`time_to` are applied
+ * together at the end in one call, both ends reported even when one was asked
+ * for. `focus` is not applied here.
+ *
+ * @returns what really changed, for the state card
+ */
+export declare function applyState(page: Page, values: Record<string, unknown> | null | undefined, settable: string[]): Record<string, string>;
+/**
+ * The card saying what the agent just did to the dashboard, or null when it
+ * did nothing. Every value came from the model, so all of it is text, never
+ * markup. The focused group is a button that goes back there.
+ */
+export declare function stateCard(doc: Document, applied: Record<string, string>, focused: Focused | null, onGo: (target: string) => void): HTMLElement | null;
+/**
+ * Puts the card inside the last bot message. The widget's Vue list reorders
+ * foreign children of the list itself to below every later message; inside a
+ * message they are that message's own subtree and scroll away with its turn.
+ */
+export declare function placeCard(doc: Document, card: HTMLElement): boolean;
+/** Applies one turn's control chunk: the settable values, then the focus, then the card. */
+export declare function applyToolCalls(page: Page, payload: ToolCalls | null | undefined, settable: string[]): void;

package/dist/n8n/stream.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The node whose chunks drive the dashboard. Each agent workflow ends with a
+ * `Dashboard State` node that writes one chunk carrying the turn's tool calls
+ * as JSON, and n8n stamps every chunk with the node that wrote it.
+ */
+export declare const CONTROL_NODE = "Dashboard State";
+/**
+ * Rewrites n8n's NDJSON stream on its way to the widget. The control node's
+ * chunks are recognised by their author and swallowed whole - begin, item and
+ * end alike, since a begin/end that got through would render an empty bubble -
+ * and each item's content is handed to `onControl`. Every other line passes
+ * untouched.
+ *
+ * Chunks split anywhere, so a partial line is held back until its newline
+ * arrives (or the stream ends): a half-received control chunk never leaks.
+ */
+export declare function controlFilter(onControl: (payload: unknown) => void, node?: string): TransformStream<Uint8Array, Uint8Array>;

package/dist/n8n/styles.d.ts

@@ -0,0 +1 @@
+export declare const STYLES: string;