@w6w/ui 0.2.0 → 0.2.54

package/dist/canvas-context-menu.d.ts

@@ -0,0 +1,27 @@
+/** A right-click's flow-space drop point plus the nodes its node actions apply to. */
+export interface CanvasMenuTarget {
+    /** Where an added node lands — the click converted to flow coordinates. */
+    flow: {
+        x: number;
+        y: number;
+    };
+    /** Node ids Duplicate / Delete act on. Empty on a bare-canvas right-click. */
+    nodeIds: string[];
+}
+export type CanvasMenuAction = "duplicate" | "delete" | "add-node" | "add-trigger";
+export interface CanvasMenuItem {
+    action: CanvasMenuAction;
+    label: string;
+    disabled: boolean;
+    danger?: boolean;
+    /** A divider is drawn above this item. */
+    separated?: boolean;
+}
+/**
+ * The nodes a right-click acts on. A node that is part of the current selection acts on
+ * the whole selection; any other node acts on itself alone (and becomes the selection).
+ * The bare canvas acts on whatever is selected.
+ */
+export declare function contextMenuTargets(selectedIds: readonly string[], nodeId?: string): string[];
+/** Duplicate + Delete when nodes are targeted, then Add node + Add trigger. All greyed when read-only. */
+export declare function canvasMenuItems(nodeIds: readonly string[], readOnly: boolean): CanvasMenuItem[];

package/dist/canvas-types.d.ts

@@ -0,0 +1,36 @@
+/** Workflow canvas (notes + sections); hand-mirror of core's `Workflow.canvas`. */
+export interface CanvasNote {
+    id: string;
+    color: string;
+    position: {
+        x: number;
+        y: number;
+    };
+    size: {
+        width: number;
+        height: number;
+    };
+    content: string;
+}
+export interface CanvasSection {
+    id: string;
+    title: string;
+    color: string;
+    position: {
+        x: number;
+        y: number;
+    };
+    size: {
+        width: number;
+        height: number;
+    };
+    /** Member node ids; a node belongs to at most one section. */
+    nodes: string[];
+}
+export interface FlowCanvas {
+    notes?: CanvasNote[];
+    sections?: CanvasSection[];
+}
+export declare const MAX_NOTES = 200;
+export declare const MAX_SECTIONS = 200;
+export declare const MAX_NOTE_BYTES = 10240;

package/dist/canvas-utils.d.ts

@@ -0,0 +1,44 @@
+import { FlowCanvas } from './canvas-types.ts';
+/** Live geometry keyed by note/section id. */
+export interface LiveGeometry {
+    [id: string]: {
+        position?: {
+            x: number;
+            y: number;
+        };
+        size?: {
+            width: number;
+            height: number;
+        };
+    };
+}
+/** Round every stored number to an integer. */
+export declare function roundGeometry<T extends {
+    x: number;
+    y: number;
+} | {
+    width: number;
+    height: number;
+}>(g: T): T;
+/**
+ * Stamp live geometry onto the stored canvas, rounded to integers. When
+ * `savePosition === false` the stored canvas is returned untouched (mirrors
+ * `flowToWorkflow`'s `withPosition`): not written is not erased.
+ */
+export declare function withCanvasGeometry(canvas: FlowCanvas, savePosition: boolean, live?: LiveGeometry): FlowCanvas;
+/** Remove a deleted node id from every section. */
+export declare function pruneSectionMembers(canvas: FlowCanvas, deletedNodeId: string): FlowCanvas;
+/** Map a renamed node id in every section. */
+export declare function renameSectionMember(canvas: FlowCanvas, from: string, to: string): FlowCanvas;
+/** Put `nodeIds` into `sectionId`, removing them from any other section (at most one each). */
+export declare function assignMembership(canvas: FlowCanvas, sectionId: string, nodeIds: string[]): FlowCanvas;
+/** Ids of every section containing the node. */
+export declare function sectionsContaining(canvas: FlowCanvas, nodeId: string): string[];
+/** Enforce the caps: 200 notes, 200 sections, 10240 UTF-8 bytes per note content. */
+export declare function clampCanvas(canvas: FlowCanvas): FlowCanvas;
+/**
+ * The canvas to emit. Geometry is stamped (rounded) from the live canvas when `savePosition` is
+ * on; when off, every item already in `stored` keeps its STORED position/size (live edits render
+ * but are not written — mirrors node positions). Items new this session keep their live geometry.
+ */
+export declare function persistCanvas(canvas: FlowCanvas, stored: FlowCanvas | undefined, savePosition: boolean): FlowCanvas;

package/dist/code.cjs

@@ -1,2 +1,2 @@
-"use client";"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./CodeBlock-CZu4TFSi.cjs"),o=require("./Copyable-CYZU1o4X.cjs");exports.CodeBlock=e.CodeBlock;exports.Copyable=o.Copyable;
+"use client";"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./CodeBlock-CymlfyeA.cjs");exports.CodeBlock=e.CodeBlock;exports.Copyable=e.Copyable;
 //# sourceMappingURL=code.cjs.map

package/dist/code.mjs

@@ -1,8 +1,7 @@
 "use client";
-import { C as r } from "./CodeBlock-Dot3Pd7P.js";
-import { C as a } from "./Copyable-1niV9gUa.js";
+import { C as a, a as l } from "./CodeBlock-C-oIIYfC.js";
 export {
-  r as CodeBlock,
-  a as Copyable
+  a as CodeBlock,
+  l as Copyable
 };
 //# sourceMappingURL=code.mjs.map

package/dist/code.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"code.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}
+{"version":3,"file":"code.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;"}

package/dist/components/AnchoredFlyout.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode, RefObject } from 'react';
+/** Full-row flyout anchored inside the nearest dialog’s top layer. */
+export declare function AnchoredFlyout({ anchorRef, onClose, children, }: {
+    anchorRef: RefObject<HTMLElement | null>;
+    onClose: () => void;
+    children: ReactNode;
+}): import('react').ReactPortal | null;

package/dist/components/AuthFieldsForm.d.ts

@@ -21,6 +21,17 @@ interface Props {
      */
     mode?: "create" | "edit";
 }
+/**
+ * Parses every filled `json` field of `values` (they are held as raw text while typing). Returns
+ * the values with those fields parsed, or an `error` naming the offending field by label. The
+ * error NEVER contains the typed text or the parser's message (which can quote it): a pasted key
+ * file that is almost valid must not be echoed back into the page.
+ */
+export declare function parseJsonFields(fields: AuthField[], values: Record<string, unknown>): {
+    values: Record<string, unknown>;
+} | {
+    error: string;
+};
 /**
  * Renders the form for an Auth method's `fields` declaration. Field shape
  * comes from the app's manifest so no app-specific knowledge is needed here.

package/dist/components/BudgetMeter.d.ts

@@ -0,0 +1,15 @@
+export interface BudgetMeterProps {
+    /** Accessible name and the visible caption. */
+    label: string;
+    /** Amount already consumed. */
+    used: number;
+    /** Upper bound `used` is measured against. */
+    limit: number;
+    /** Amount held back but not yet spent. The segment renders only when > 0. */
+    reserved?: number;
+    /** Formats every number the meter prints (visible text and aria-valuetext). */
+    format?: (n: number) => string;
+    className?: string;
+    testId?: string;
+}
+export declare function BudgetMeter({ label, used, limit, reserved, format, className, testId, }: BudgetMeterProps): import("react").JSX.Element;

package/dist/components/CallableList.d.ts

@@ -14,7 +14,7 @@ export interface CallableListProps {
     rows: readonly CallableListRow[];
     title: ReactNode;
     description?: ReactNode;
-    /** Shown when `rows` is empty (total, not the visible subset) and not `loading`. */
+    /** Shown (inside an EmptyState) when no rows exist at all and not `loading`. */
     emptyCopy?: ReactNode;
     /** Label of the New button. Defaults to "New". */
     newLabel?: string;
@@ -52,6 +52,7 @@ export interface CallableListProps {
 /**
  * A presentational list of callables (Functions, Endpoints, Workflows): rows in, callbacks out.
  * Owns only the archived filter and its toggle; it knows no router, query, modal or kind.
- * Rows render through {@link ListItem}: a button with `onOpen`, an anchor with `getHref`.
+ * Rows render through {@link DataTable}: a click handler with `onOpen`, anchors with `getHref`.
+ * No visible rows renders an {@link EmptyState}; when only archived rows exist it offers "Show archived".
  */
 export declare function CallableList({ rows, title, description, emptyCopy, newLabel, openRowTitle, testIds, loading, error, onCreate, creating, onImport, onOpen, getHref, showArchived: showArchivedProp, onShowArchivedChange, slots, }: CallableListProps): import("react").JSX.Element;

package/dist/components/ColumnsEditor.d.ts

@@ -0,0 +1,27 @@
+import { TableColumn } from '../data-stores/data-store-view.ts';
+/**
+ * The `table` kind's column list: a controlled row editor (rows + `onChange(next)`; the column
+ * list itself is never copied).
+ *
+ * The **key column** select is the one piece of the schema a row cannot decide for itself: only a
+ * column that is `required` and typed `string` or `integer` may be a row's key, so the select
+ * offers only those rows. A column renamed, retyped or un-required out of that set resets the
+ * selection to `""` ("generated keys") rather than holding a key the server would reject.
+ *
+ * `columnErrors` is keyed by column NAME (what the host's error envelope names in
+ * `error.column`), so a 400 lands under the row that caused it.
+ *
+ * Each row also takes a **default**, typed as text and parsed with the column's type: empty or
+ * refused text leaves the column with no `default` key at all, a valid one stores the typed value
+ * (`7`, `true`), never the text.
+ */
+export interface ColumnsEditorProps {
+    columns: TableColumn[];
+    onChange: (next: TableColumn[]) => void;
+    /** The selected key column's name, or `""` for "generated keys". */
+    keyColumn: string;
+    onKeyColumnChange: (k: string) => void;
+    /** One message per column name, from the server's `error.column`. */
+    columnErrors: Record<string, string>;
+}
+export declare function ColumnsEditor(props: ColumnsEditorProps): import("react").JSX.Element;

package/dist/components/Combobox.d.ts

@@ -1,6 +1,8 @@
 export interface ComboboxOption {
     value: string;
     label: string;
+    /** A muted second line under the label (e.g. a value preview); never matched by the filter. */
+    detail?: string;
 }
 export interface ComboboxProps {
     options: ComboboxOption[];
@@ -15,10 +17,26 @@ export interface ComboboxProps {
     forceSelection?: boolean;
     /** Estimated option height in px, used by `auto` mode. Default 32. */
     optionHeight?: number;
+    /**
+     * Cap for the open list, in px — the list scrolls past it instead of growing.
+     * Default 240 (the shared value). A host inside an already-scrolling container
+     * (a modal body) passes a smaller one so the popup cannot add a second scroller.
+     */
+    listMaxHeight?: number;
     className?: string;
+    /**
+     * Called with the typed text on every edit — for a host that searches server-side and
+     * passes the results back as `options`. The local filter still narrows what is shown.
+     */
+    onInputChange?: (text: string) => void;
+    /** Shown in the open list when no option matches. Default "No matches". */
+    emptyText?: string;
+    /** A muted line at the foot of the open list (e.g. "More entries — type to narrow"). */
+    footer?: string;
 }
 /** Combobox is chosen when the list would take more than 60% of the viewport. */
 export declare function shouldUseCombobox(count: number, optionHeight: number, viewportHeight: number): boolean;
 /** Case-insensitive substring match on label and value. */
 export declare function filterOptions(options: ComboboxOption[], query: string): ComboboxOption[];
-export declare function Combobox({ options, value, onChange, placeholder, disabled, "aria-label": ariaLabel, mode, forceSelection, optionHeight, className, }: ComboboxProps): import("react").JSX.Element;
+export declare const DEFAULT_LIST_MAX_HEIGHT = 240;
+export declare function Combobox({ options, value, onChange, placeholder, disabled, "aria-label": ariaLabel, mode, forceSelection, optionHeight, listMaxHeight, className, onInputChange, emptyText, footer, }: ComboboxProps): import("react").JSX.Element;

package/dist/components/ConnectionList.d.ts

@@ -33,9 +33,8 @@ export interface ConnectionListProps {
     };
 }
 /**
- * A presentational list of connections: rows in, callbacks out; it needs no provider. Each row is
- * a {@link ListItem} (app icon, name, auth key, state, an `invalid` tag after a failed test) with
- * Edit and Delete buttons as SIBLINGS of its link, never inside it.
+ * A presentational list of connections: rows in, callbacks out; it needs no provider. Rows render
+ * through {@link DataTable} (name/app, status, and an Edit/Delete column that is never a link).
  *
  * A `builtIn` row (the server's synthetic "no credential" entry) is a plain non-interactive item:
  * no link, no `onOpen`, no Edit, no Delete, because the server 404s get/test/delete on its id.

package/dist/components/CredentialPicker.d.ts

@@ -0,0 +1,35 @@
+import { AuthField, ConnectionBinding, CredentialSummary, ServiceAccountConfig } from '../types.ts';
+export interface CredentialPickerProps {
+    /** Credentials to offer. Pass them already filtered; this component renders them as given. */
+    credentials: CredentialSummary[];
+    /** `"existing"` picks one of `credentials`; `"new"` is for the caller's create form. */
+    mode: "existing" | "new";
+    onModeChange: (mode: "existing" | "new") => void;
+    /** The chosen credential id (`""` for none). Only used in `"existing"` mode. */
+    selectedId: string;
+    onSelect: (id: string) => void;
+    /** False hides the "Use existing" choice (nothing to choose from). Default true. */
+    canUseExisting?: boolean;
+    /** The contract the credential must satisfy, shown as a hint. */
+    contract?: string;
+}
+/**
+ * The Use existing / Create new switch of a connection's Credential step, plus the list of stored
+ * credentials. Presentational: no API access, no state of its own. Each option shows the
+ * credential's name and its non-secret `display` values, never a payload. The "Create new" form
+ * itself (name + fields) is the caller's, rendered beneath this.
+ */
+export declare function CredentialPicker({ credentials, mode, onModeChange, selectedId, onSelect, canUseExisting, contract, }: CredentialPickerProps): import("react").JSX.Element;
+/**
+ * The binding fields a `serviceAccount` auth asks for on a connection. `delegatedUser` is always
+ * labelled "Impersonated user" (the person the credential acts as, never the connection's owner),
+ * is absent when impersonation is `"none"` even if declared, and is synthesised when impersonation
+ * is allowed but the auth declares no such field.
+ */
+export declare function bindingFieldsFor(sa: ServiceAccountConfig): AuthField[];
+/**
+ * Maps typed binding values to the wire `binding`: `delegatedUser` stays top-level, every other key
+ * goes under `settings`, blank values are dropped, and an empty result is `undefined`. `scopes` is
+ * never sent (the server applies the auth's declared scopes).
+ */
+export declare function buildBinding(fields: AuthField[], values: Record<string, unknown>): ConnectionBinding | undefined;

package/dist/components/CsvPanel.d.ts

@@ -0,0 +1,21 @@
+export interface CsvPanelProps {
+    /** What the panel is telling the operator, and whether it failed. `null` renders nothing. */
+    result: {
+        ok: boolean;
+        message: string;
+    } | null;
+    /** Disables Export while a request is in flight. */
+    busy?: boolean;
+    /** A file within {@link CSV_MAX_BYTES}. Reading and sending it are the host's. */
+    onImport: (file: File) => void;
+    /** A file the panel refused before handing it over (too large). */
+    onRefuse: (message: string) => void;
+    onExport: () => void;
+}
+/**
+ * CSV import and export for one table store: one file input, one Export button, one result line.
+ * Props-only. The panel owns the size check (a file over {@link CSV_MAX_BYTES} is refused here and
+ * never reaches `onImport`); it never parses the CSV, because the host is the authority on line
+ * and column.
+ */
+export declare function CsvPanel({ result, busy, onImport, onRefuse, onExport }: CsvPanelProps): import("react").JSX.Element;

package/dist/components/DataEntryEditor.d.ts

@@ -0,0 +1,38 @@
+export interface DataEntryEditorProps {
+    /** `kv` edits one input; `doc` edits JSON in a {@link JsonEditor}. */
+    kind: "kv" | "doc";
+    /** True for a not-yet-created entry: opens directly in edit mode with a key input. */
+    isNew: boolean;
+    /** The entry's key (existing mode heading). */
+    entryKey?: string;
+    /** The new entry's key (controlled). */
+    newKey?: string;
+    /** Concurrency token supplied by the host; never presented as document history. */
+    version?: number | null;
+    /** Existing mode: ISO expiry, shown when set. */
+    expiresAt?: string | null;
+    /** The value text (controlled). */
+    text: string;
+    /** A host-supplied value/save error. */
+    error?: string | null;
+    /** True after a stale `ifVersion`: shows the conflict copy and Reload, and disables Save. */
+    conflict?: boolean;
+    /** True while a save is in flight: disables Save. */
+    saving?: boolean;
+    /** Fired per edit of the value, with the new text. */
+    onTextChange: (text: string) => void;
+    /** Fired per edit of the new-entry key, with the new text. */
+    onKeyChange: (key: string) => void;
+    /** Opens the host's delete confirmation for an existing entry. */
+    onDelete?: () => void;
+    onSave: () => void;
+    onCancel: () => void;
+    /** Fired by the conflict prompt's Reload. */
+    onReload: () => void;
+}
+/**
+ * Existing entries open for viewing, then Edit enables changes inside the same modal.
+ * New entries start in edit mode. Drafts, `ifVersion` and mutations live in the host.
+ * Document validity is derived from the controlled text, including initial values and reloads.
+ */
+export declare function DataEntryEditor({ kind, isNew, entryKey, newKey, expiresAt, text, error, conflict, saving, onTextChange, onKeyChange, onDelete, onSave, onCancel, onReload, }: DataEntryEditorProps): import("react").JSX.Element;

package/dist/components/DataEntryList.d.ts

@@ -0,0 +1,33 @@
+import { ReactNode } from 'react';
+/** One row of a kv/doc store's entry list, as the host has already prepared it. */
+export interface DataEntryListRow {
+    key: string;
+    version: number;
+    /** The short text shown in the Value column. */
+    preview: string;
+}
+export interface DataEntryListProps {
+    rows: readonly DataEntryListRow[];
+    /** Shown instead of the table when there are no rows and the list is not `loading`. */
+    empty?: ReactNode;
+    /** When there are no rows, shows the loading text instead of `empty`. */
+    loading?: boolean;
+    /** Initial text of the key-prefix box. */
+    searchValue?: string;
+    /** Renders "Load more" when true. */
+    hasMore?: boolean;
+    /** Fired when a row is opened by mouse or its key button by keyboard. */
+    onOpen: (key: string) => void;
+    /** Fired with the prefix text when the search form is SUBMITTED (never per keystroke). */
+    onSearch: (text: string) => void;
+    /** Fired by the "New entry" button. */
+    onNew: () => void;
+    /** Fired by "Load more". */
+    onLoadMore: () => void;
+}
+/**
+ * A presentational list of a kv/doc store's entries: view-model rows in, callbacks out. It owns
+ * only the text of the search box; the query, the editor and the delete confirmation are the
+ * host's. Rows render through {@link DataTable}.
+ */
+export declare function DataEntryList({ rows, empty, loading, searchValue, hasMore, onOpen, onSearch, onNew, onLoadMore, }: DataEntryListProps): import("react").JSX.Element;

package/dist/components/DataStoreList.d.ts

@@ -0,0 +1,33 @@
+import { MouseEvent, ReactNode } from 'react';
+import { DataStore } from '../data-stores/data-store-view.ts';
+export interface DataStoreListProps {
+    stores: readonly DataStore[];
+    loading?: boolean;
+    error?: string | null;
+    /** Row click. The event is passed through untouched; the host may `preventDefault`. */
+    onOpen?: (id: string, event: MouseEvent<Element>) => void;
+    /** When set, each row is a real `<a href>`. */
+    getHref?: (id: string) => string;
+    /** Renders an Edit button per row. */
+    onEdit?: (store: DataStore) => void;
+    /** Renders an Archive button per row. Confirmation and the archive call are the host's. */
+    onArchive?: (store: DataStore) => void;
+    /** Disables every Archive button while an archive is in flight. */
+    busy?: boolean;
+    /** Size formatter; defaults to the package's `formatBytes` (`2.0 KiB`). */
+    formatSize?: (bytes: number) => string;
+    slots?: {
+        /** Heading block above the rows. */
+        header?: ReactNode;
+        /** Trailing action(s) next to the header (e.g. a "New store" button). */
+        actions?: ReactNode;
+        /** Shown when there are no stores and the list is not `loading`. */
+        empty?: ReactNode;
+    };
+}
+/**
+ * A presentational list of Data stores: rows in, callbacks out; it needs no provider. Rows render
+ * through {@link DataTable} (name, kind, entry count, size, last update, and an Edit/Archive column
+ * that is never a link).
+ */
+export declare function DataStoreList({ stores, loading, error, onOpen, getHref, onEdit, onArchive, busy, formatSize, slots, }: DataStoreListProps): import("react").JSX.Element;

package/dist/components/DataTable.d.ts

@@ -0,0 +1,27 @@
+import { MouseEvent, ReactNode } from 'react';
+export interface DataTableColumn<Row> {
+    key: string;
+    header: ReactNode;
+    /** Omitted ⇒ the cell shows `String(row[key] ?? "")`. */
+    render?: (row: Row) => ReactNode;
+    width?: string;
+    align?: "left" | "right" | "center";
+    /** With `getRowHref`, wrap this column's cells in an anchor. Default true. */
+    link?: boolean;
+}
+export interface DataTableProps<Row> {
+    columns: readonly DataTableColumn<Row>[];
+    rows: readonly Row[];
+    rowKey: (row: Row) => string;
+    /** Row click. The event is passed through untouched; the host may `preventDefault`. */
+    onRowClick?: (row: Row, e: MouseEvent<Element>) => void;
+    /** When set, every cell of a `link !== false` column wraps its content in `<a href>`. */
+    getRowHref?: (row: Row) => string | undefined;
+    /** Rendered in place of the body when there are no rows and not `loading`. */
+    empty?: ReactNode;
+    loading?: boolean;
+    className?: string;
+    testId?: string;
+    rowTestId?: (row: Row) => string | undefined;
+}
+export declare function DataTable<Row>(props: DataTableProps<Row>): import("react").JSX.Element;

package/dist/components/DataTableGrid.d.ts

@@ -0,0 +1,46 @@
+import { ReactNode } from 'react';
+import { TableColumn } from '../data-stores/data-store-view.ts';
+/** One grid row as the host has prepared it. `id` is the entry key; the new row is `isNew`. */
+export interface DataTableGridRow {
+    id: string;
+    /** True for the unsaved row: its key cell is editable and its `data-row` is `"new"`. */
+    isNew?: boolean;
+    /** Draft cell text by column name. */
+    cells: Record<string, string>;
+    /** The version the row was loaded at; `null` for a new row. */
+    version: number | null;
+    /** True when the draft differs from the loaded entry. */
+    dirty: boolean;
+    /** True after a stale `ifVersion`: shows the conflict copy and Reload, and disables Save. */
+    conflict?: boolean;
+    /** Per-cell error messages by column name, shown under their own cell. */
+    cellErrors?: Record<string, string>;
+}
+export interface DataTableGridProps {
+    columns: readonly TableColumn[];
+    /** The column whose cell is the row key (read-only on an existing row). */
+    keyColumn: string;
+    rows: readonly DataTableGridRow[];
+    /** A grid-level (not cell) error. */
+    error?: string | null;
+    loading?: boolean;
+    empty?: ReactNode;
+    /** Initial text of the key-prefix box. */
+    searchValue?: string;
+    hasMore?: boolean;
+    onCellChange: (rowId: string, column: string, text: string) => void;
+    onSave: (rowId: string) => void;
+    /** Fired immediately; confirmation is the host's. */
+    onDelete: (rowId: string) => void;
+    onReload: (rowId: string) => void;
+    onAddRow: () => void;
+    onLoadMore: () => void;
+    /** Fired with the prefix text when the search form is SUBMITTED (never per keystroke). */
+    onSearch: (text: string) => void;
+}
+/**
+ * A presentational editable grid for a table store: row view-models in, callbacks out. Drafts,
+ * dirty tracking, version handling and the delete confirmation are the host's. Rows render through
+ * {@link DataTable}.
+ */
+export declare function DataTableGrid({ columns, keyColumn, rows, error, loading, empty, searchValue, hasMore, onCellChange, onSave, onDelete, onReload, onAddRow, onLoadMore, onSearch, }: DataTableGridProps): import("react").JSX.Element;

package/dist/components/EmptyState.d.ts

@@ -0,0 +1,9 @@
+import { ReactNode } from 'react';
+export interface EmptyStateProps {
+    title?: ReactNode;
+    children?: ReactNode;
+    action?: ReactNode;
+    className?: string;
+    testId?: string;
+}
+export declare function EmptyState({ title, children, action, className, testId }: EmptyStateProps): import("react").JSX.Element;

package/dist/components/EventbriteTriggerPicker.d.ts

@@ -0,0 +1,7 @@
+import { EventbriteTriggerChoices } from '../eventbrite-trigger-selection.ts';
+/** The same event list the app's webhook registration uses, saved as activity/actions. */
+export declare function EventbriteTriggerPicker({ choices, onChange, readOnly, }: {
+    choices: EventbriteTriggerChoices;
+    onChange: (actions: string[]) => void;
+    readOnly?: boolean;
+}): import("react").JSX.Element;

package/dist/components/ExecutionDetail.d.ts

@@ -36,6 +36,9 @@ export interface ExecutionDetailValue {
     /** A workflow run's steps. `undefined` = not a step-bearing run (no section);
      * `[]` = it ran and no step did (the panel's own empty state). */
     steps?: ExecutionLogStep[];
+    /** The execution this one is a re-run of — shown as "Re-run of <id>".
+     * `null`/omitted ⇒ an ordinary execution, no line. */
+    rerunOf?: string | null;
 }
 export interface ExecutionDetailProps {
     /** The execution to show, or `null` when there is nothing to show yet. */
@@ -54,6 +57,19 @@ export interface ExecutionDetailProps {
     /** Supplied ⇒ the "Open in visual editor" button renders and calls this.
      * Omitted ⇒ no button (a function/endpoint run has no visual editor to open). */
     onOpenInEditor?: () => void;
+    /** Supplied ⇒ a "Back" control renders above everything else and calls this
+     * — for a host that shows this detail IN PLACE of the list it was opened
+     * from. Omitted ⇒ no control. Rendered in every branch, so a view whose
+     * fetch failed can still be left. */
+    onBack?: () => void;
+    /** Supplied ⇒ the "Re-run" button renders and calls this. Omitted ⇒ no button. */
+    onRerun?: () => void;
+    /** `true` while the host's re-run is in flight — the button is disabled and
+     * says so. */
+    rerunning?: boolean;
+    /** Supplied ⇒ the "Re-run of <id>" id is a link that calls this with that
+     * id, to open the original. Omitted ⇒ plain text. */
+    onOpenExecution?: (id: string) => void;
 }
 /**
  * Everything known about one past execution: which callable it was and how it
@@ -67,4 +83,4 @@ export interface ExecutionDetailProps {
  *
  * A pure display leaf — no fetching, no polling, no live-ticking timer.
  */
-export declare function ExecutionDetail({ execution, loading, errorMessage, onClose, onOpenInEditor, }: ExecutionDetailProps): import("react").JSX.Element;
+export declare function ExecutionDetail({ execution, loading, errorMessage, onClose, onOpenInEditor, onBack, onRerun, rerunning, onOpenExecution, }: ExecutionDetailProps): import("react").JSX.Element;

package/dist/components/ExecutionList.d.ts

@@ -19,6 +19,17 @@ export interface ExecutionListItem {
     /** Wall-clock duration once the run has finished; `null` while it is still
      * queued/running (rendered as `—`). */
     durationMs: number | null;
+    /** The execution this one is a re-run of — the row then carries a "Re-run"
+     * tag. `null`/omitted ⇒ an ordinary execution. */
+    rerunOf?: string | null;
+    /** How the run was started (`manual`, `schedule`, `webhook`, `event`, `replay`, or any other
+     *  value the host passes through). `null`/omitted ⇒ no trigger segment. */
+    trigger?: string | null;
+    /** The trigger node the run entered through, shown beside the trigger. */
+    triggerNodeId?: string | null;
+    /** The start of the run's input as JSON text, shown as a one-line snippet. `null`/omitted ⇒
+     *  no snippet. */
+    inputPreview?: string | null;
 }
 export interface ExecutionListProps {
     /** The page of past executions, rendered in exactly this order — never re-sorted. */
@@ -47,6 +58,13 @@ export interface ExecutionListProps {
     onPrev?: () => void;
     /** Supplied ⇒ the pager renders and `Next` calls this. */
     onNext?: () => void;
+    /** Supplied ⇒ every row gets a "Re-run" control beside it that reports the
+     * row's id here. Omitted ⇒ no control. */
+    onRerun?: (id: string) => void;
+    /** The row whose re-run is in flight — its control is disabled. While any
+     * re-run is in flight every row's control is disabled, so two can never
+     * overlap. `null`/omitted ⇒ none. */
+    rerunningId?: string | null;
 }
 /**
  * A paged list of past executions: one row per run, click-to-select, with a
@@ -57,4 +75,4 @@ export interface ExecutionListProps {
  * reports a page request; the host owns which page is loaded and which row is
  * selected.
  */
-export declare function ExecutionList({ items, selectedId, onSelect, showCallable, loading, emptyLabel, hasPrev, hasNext, onPrev, onNext, }: ExecutionListProps): import("react").JSX.Element;
+export declare function ExecutionList({ items, selectedId, onSelect, showCallable, loading, emptyLabel, hasPrev, hasNext, onPrev, onNext, onRerun, rerunningId, }: ExecutionListProps): import("react").JSX.Element;