@makinbakin/sdk 0.0.1-rc.2 → 0.0.1-rc.21

package/_internal/app/components/conversation/reply-toast.d.ts

@@ -0,0 +1,15 @@
+export declare function ConversationReplyToast({ agentId, title, preview, to, onNavigate, testId }: {
+    agentId: string;
+    /** e.g. "replied" / "replied in a project brainstorm" — prefixed with the agent's name. */
+    title: string;
+    preview?: string;
+    /** Internal route to navigate to on click (router push, never a reload). */
+    to: string;
+    /** Called before navigation (wire the attention hook's `dismiss` here). */
+    onNavigate?: () => void;
+    /** data-* marker attribute value for tests (e.g. chat sets data-chat-toast). */
+    testId?: {
+        attr: string;
+        value: string;
+    };
+}): import("react/jsx-runtime").JSX.Element;

package/_internal/app/components/conversation/thread-id.d.ts

@@ -0,0 +1,8 @@
+/**
+ * conversationThreadId — the adapter-neutral durable thread key for embedded
+ * conversation surfaces: `scope:entityId:agentId`, each part URL-encoded,
+ * empty parts defaulting to 'default'. (The chat plugin uses its own
+ * `chat:<chatId>` scheme; this is for entity-scoped threads like
+ * brainstorms and plan reviews.)
+ */
+export declare function conversationThreadId(scope: string, entityId: string, agentId: string): string;

package/_internal/app/components/conversation/tool-call-drawer.d.ts

@@ -0,0 +1,7 @@
+import type { ConversationToolCall } from './fold';
+export interface ToolCallDrawerProps {
+    call: ConversationToolCall | null;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+}
+export declare function ToolCallDrawer({ call, open, onOpenChange }: ToolCallDrawerProps): import("react/jsx-runtime").JSX.Element | null;

package/_internal/app/components/conversation/turn-recorder.d.ts

@@ -0,0 +1,37 @@
+/**
+ * createTurnRecorder — server-side helper turning one streamed turn's
+ * RuntimeChatChunks into persisted ConversationMessage rows. ONE
+ * implementation of "what survives a turn" shared by the chat plugin's
+ * stream bridge and embedded surfaces' plugin routes:
+ *
+ * - assistant text accumulates and lands as ONE assistant row (in stream
+ *   position relative to the tool rows around it — earlier text flushes
+ *   when a tool result arrives so replay preserves interleaving)
+ * - only `phase:'result'` tool chunks persist, merged over their call
+ *   phase (summary/previews), previews clipped at honest byte caps with
+ *   a `metadata.truncated` marker
+ * - error chunks persist as error rows (after any partial text)
+ * - status/done chunks never persist
+ */
+import type { ChatChunk as RuntimeChatChunk } from '../../../core/adapters/runtime';
+import type { ConversationMessage } from './fold';
+export declare const SUMMARY_MAX_CHARS = 500;
+export declare const PREVIEW_MAX_CHARS = 2000;
+interface RecorderOptions {
+    turnId: string;
+    agentId?: string;
+    now?: () => string;
+}
+export interface TurnRecorder {
+    ingest: (chunk: RuntimeChatChunk) => void;
+    /**
+     * Rows settled since the last drain (tool results, flushed text) — lets
+     * callers persist incrementally so a crash keeps the partial turn.
+     * Pending (unflushed) text stays buffered until finish().
+     */
+    drain: () => ConversationMessage[];
+    /** Flush trailing text and return the remaining undrained rows; call once at turn end. */
+    finish: () => ConversationMessage[];
+}
+export declare function createTurnRecorder({ turnId, agentId, now }: RecorderOptions): TurnRecorder;
+export {};

package/_internal/app/components/conversation/use-conversation-attention.d.ts

@@ -0,0 +1,64 @@
+/**
+ * useConversationAttention — the provider building block behind every
+ * conversational surface's `nav-badge-providers` slot component (#703).
+ * Mount the consumer's provider outside the router (the host renders the
+ * slot on every page) and call this hook with the surface's wiring; it
+ * keeps the nav badge (unread count / working dot), the optional `(N)`
+ * tab-title prefix, and fires toast + chime + OS notification when a
+ * reply lands while the user is elsewhere — rules in ./attention.ts,
+ * mechanics generalized from chat's ChatBadgeProvider (which now
+ * composes this hook).
+ */
+import { type ReactNode } from 'react';
+import { type PluginEventPayload } from '../../hooks/use-plugin-event';
+import { type ConversationDonePayload } from './attention';
+export interface ConversationAttentionTotals {
+    unreadTotal: number;
+    /** Threads with a server-seeded in-flight turn (kept live by chunk/done events). */
+    inflightKeys: string[];
+}
+export interface ConversationAttentionConfig {
+    pluginId: string;
+    navItemId: string;
+    /**
+     * The surface's bus event names; `refresh` lists extra total-bumping
+     * events — AT MOST TWO (hook-count constraints; extras would be
+     * silently dropped, so the type forbids them).
+     */
+    events: {
+        chunk: string;
+        done: string;
+        error: string;
+        started?: string;
+        refresh?: [string] | [string, string];
+    };
+    keyOf: (payload: PluginEventPayload) => string;
+    /** The thread key currently on screen ('' = none) — read at event time. */
+    visibleKey: () => string;
+    /** Fetch unread + in-flight totals; null keeps the previous totals. */
+    refreshTotals: () => Promise<ConversationAttentionTotals | null>;
+    /** Attention settings at event time. Default: sound + toasts on. */
+    settings?: () => {
+        sound: boolean;
+        toasts: boolean;
+    };
+    /** Reply toast content; `dismiss` closes it (call before in-app navigation). */
+    renderToast: (payload: ConversationDonePayload, dismiss: () => void) => ReactNode | string;
+    /**
+     * OS notification for a reply that landed while the user was elsewhere;
+     * null skips it. Runs only when the done carries a preview (matching
+     * chat: silent settles never notify).
+     */
+    osNotification: (payload: ConversationDonePayload) => {
+        title: string;
+        body: string;
+        href: string;
+    } | null;
+    /** Error toast content when a turn fails off-screen; null skips. */
+    errorToast?: (payload: PluginEventPayload) => string | null;
+    /** Maintain the `(N)` tab-title prefix (chat does; embedded surfaces may skip). */
+    titlePrefix?: boolean;
+    /** Injectable chime (tests); defaults to the kit reply chime. */
+    chime?: () => void;
+}
+export declare function useConversationAttention(config: ConversationAttentionConfig): void;

package/_internal/app/components/conversation/use-conversation-thread.d.ts

@@ -0,0 +1,55 @@
+import type { ChatChunk as RuntimeChatChunk } from '../../../core/adapters/runtime';
+import type { ConversationMessage } from './fold';
+export interface ConversationThreadLoad<Meta> {
+    messages: ConversationMessage[];
+    /**
+     * Server-seeded in-flight flag: true seeds the streaming indicator on
+     * mount so a turn started before this mount shows as live immediately.
+     */
+    streaming?: boolean;
+    /**
+     * Assistant text the in-flight turn streamed BEFORE this mount (the
+     * engine's inflightPreview) — seeds liveChunks so mid-turn rehydration
+     * doesn't show a reply missing its beginning.
+     */
+    streamingText?: string;
+    /** Consumer payload fetched alongside the transcript (e.g. chat summary). */
+    meta?: Meta;
+}
+export interface ConversationThreadOptions<Meta = unknown, Attachment = unknown> {
+    /** Active thread key; empty string disables loading and sending. */
+    threadKey: string;
+    /** The consumer's bus event names (e.g. chat.chunk/chat.done/chat.error). */
+    events: {
+        chunk: string;
+        done: string;
+        error: string;
+    };
+    /** Extract the thread key from a bus payload (e.g. p => p.chatId). */
+    keyOf: (payload: Record<string, unknown>) => unknown;
+    /** Fetch the durable transcript (+ in-flight flag + consumer meta). Null = gone. */
+    load: (key: string) => Promise<ConversationThreadLoad<Meta> | null>;
+    /** POST the user's message; the turn itself arrives over the bus. */
+    post: (key: string, content: string, attachments?: Attachment[]) => Promise<{
+        ok: boolean;
+        status?: number;
+        error?: string;
+    }>;
+    /** Build the optimistic user row (chat maps attachment paths to URLs here). */
+    optimisticRow?: (content: string, attachments?: Attachment[]) => ConversationMessage;
+    /** A turn for the ACTIVE thread settled (after the refetch was triggered). */
+    onSettled?: (payload: Record<string, unknown>) => void;
+}
+export interface ConversationThread<Meta = unknown, Attachment = unknown> {
+    /** Durable transcript rows (+ any optimistic user rows awaiting refetch). */
+    messages: ConversationMessage[];
+    /** Consumer meta from the last load (e.g. chat summary), null before it. */
+    meta: Meta | null;
+    /** The in-flight turn's chunks; null when idle. */
+    liveChunks: RuntimeChatChunk[] | null;
+    streaming: boolean;
+    sendError: string | null;
+    send: (content: string, attachments?: Attachment[]) => Promise<void>;
+    refresh: () => Promise<void>;
+}
+export declare function useConversationThread<Meta = unknown, Attachment = unknown>(options: ConversationThreadOptions<Meta, Attachment>): ConversationThread<Meta, Attachment>;

package/_internal/app/components/conversation/user-message.d.ts

@@ -0,0 +1,11 @@
+/**
+ * UserMessage — the user's side of a conversation: right-aligned bubble in
+ * contrast-safe tokens, attachment thumbnails, hover timestamp + copy.
+ */
+import type { ConversationTurn } from './fold';
+export interface UserMessageProps {
+    turn: Extract<ConversationTurn, {
+        kind: 'user';
+    }>;
+}
+export declare function UserMessage({ turn }: UserMessageProps): import("react/jsx-runtime").JSX.Element;

package/_internal/app/components/danger-zone.d.ts

@@ -0,0 +1,28 @@
+import { type ReactNode } from 'react';
+export interface DangerZoneProps {
+    /** Section heading (default "Danger zone"). */
+    title?: ReactNode;
+    /** What the action destroys and what the consequences are — spell it out. */
+    description: ReactNode;
+    /** The destructive button + dialog confirm label (e.g. "Delete this brand"). */
+    confirmLabel: string;
+    /** The exact value the user must type to arm the confirm button (e.g. the record id). */
+    confirmValue: string;
+    /** Dialog title (default = confirmLabel + "?"). */
+    confirmTitle?: ReactNode;
+    /** Dialog body copy (default = description). */
+    confirmDescription?: ReactNode;
+    /** Action in flight — keeps the dialog open and disables its buttons. */
+    busy?: boolean;
+    /** Inline error from a failed attempt, shown in the dialog. */
+    error?: string | null;
+    onConfirm: () => void;
+    className?: string;
+}
+/**
+ * The big-and-scary destructive section that belongs at the very bottom of a
+ * settings surface: red-bordered, consequences spelled out, and a typed
+ * confirmation (via ConfirmDialog's `confirmValue` — the ONE confirm engine)
+ * so nothing irreversible is one accidental click away.
+ */
+export declare function DangerZone({ title, description, confirmLabel, confirmValue, confirmTitle, confirmDescription, busy, error, onConfirm, className, }: DangerZoneProps): import("react/jsx-runtime").JSX.Element;

package/_internal/app/components/empty-state.d.ts

@@ -1,10 +1,22 @@
-import type { LucideIcon } from 'lucide-react';
+import type { ComponentType, ReactNode } from 'react';
 interface EmptyStateProps {
-    icon?: LucideIcon;
-    title: string;
-    description?: string;
-    action?: React.ReactNode;
+    icon?: ComponentType<{
+        className?: string;
+    }>;
+    title: ReactNode;
+    description?: ReactNode;
+    action?: ReactNode;
     className?: string;
+    /**
+     * Visual size.
+     * - `default` — compact rounded chip + small title (the original SDK look).
+     * - `panel` — larger rounded-2xl chip + semibold title for full-tab empty
+     *   surfaces (folded in from the team plugin's former local variant).
+     * - `section` — soft in-card empty for a SectionCard body (folded in from
+     *   the brands plugin): centered caption in a breathing tinted container,
+     *   never a muted sentence blended into section copy.
+     */
+    variant?: 'default' | 'panel' | 'section';
 }
-export declare function EmptyState({ icon: Icon, title, description, action, className }: EmptyStateProps): import("react/jsx-runtime").JSX.Element;
+export declare function EmptyState({ icon: Icon, title, description, action, className, variant }: EmptyStateProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/_internal/app/components/plugin-header.d.ts

@@ -1,7 +1,9 @@
-interface PluginHeaderProps {
+export interface PluginHeaderProps {
     title: string;
     subtitle?: string;
     count?: number;
+    /** Optional path context rendered above the title. Supply a labelled nav when interactive. */
+    breadcrumbs?: React.ReactNode;
     actions?: React.ReactNode;
     meta?: React.ReactNode;
     search?: {
@@ -12,5 +14,4 @@ interface PluginHeaderProps {
         debounce?: number;
     };
 }
-export declare function PluginHeader({ title, subtitle, count, actions, meta, search }: PluginHeaderProps): import("react/jsx-runtime").JSX.Element;
-export {};
+export declare function PluginHeader({ title, subtitle, count, breadcrumbs, actions, meta, search, }: PluginHeaderProps): import("react/jsx-runtime").JSX.Element;

package/_internal/app/components/save-bar.d.ts

@@ -0,0 +1,32 @@
+import { type ReactNode } from 'react';
+export interface SaveBarProps {
+    /** Whether there are staged, unsaved changes. The bar renders only while dirty (or briefly flashing "Saved"). */
+    dirty: boolean;
+    /** Save in flight — disables both actions and spins the save button. */
+    saving?: boolean;
+    /** Inline error from the last failed save. */
+    error?: string | null;
+    /** Save button label (default "Save changes"). */
+    saveLabel?: string;
+    /** Extra content rendered before the actions (e.g. a changed-fields summary). */
+    children?: ReactNode;
+    className?: string;
+    onSave: () => void;
+    onDiscard: () => void;
+}
+/**
+ * Sticky bottom save/discard bar for pages that stage edits into one draft —
+ * the single dirty-state pattern (converges with PluginSettingsRenderer's
+ * disabled-until-dirty save; migrating the renderer onto this bar is a tracked
+ * follow-up). Renders nothing when clean; after a successful save it flashes
+ * "Saved" briefly so success is never silent.
+ *
+ * Pair with `useUnsavedGuard(dirty)` so a hard navigation can't eat staged edits.
+ */
+export declare function SaveBar({ dirty, saving, error, saveLabel, children, className, onSave, onDiscard, }: SaveBarProps): import("react/jsx-runtime").JSX.Element | null;
+/**
+ * Blocks the hard ways out (tab close, reload) while `dirty`. In-app route
+ * guards are the router's job — wire those at the page level where the
+ * navigation happens.
+ */
+export declare function useUnsavedGuard(dirty: boolean): void;

package/_internal/app/components/score-overlay.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Search-relevance debug overlay (spec req 2 / D17). Renders the fused
+ * score plus ONE badge per leg in `scoreBreakdown` — whatever legs the
+ * adapter reports, by their neutral names. No engine-specific key sniffing:
+ * the engine returns `full_text` plus the table's declared leg names.
+ *
+ * Embedding legs report -cosine_distance (higher = better, but negative);
+ * they render as cosine similarity (1 + score) so they read as a normal
+ * 0..1 relevance. Detection is by sign: negative = distance-based leg.
+ */
+export interface ScoreOverlayInfo {
+    /** Fused (RRF/RSF) score. */
+    score: number;
+    /** Per-leg scores keyed by neutral leg name (from the adapter). */
+    indexScores?: Record<string, number>;
+    /**
+     * Field names whose text contains the query terms (client-side
+     * approximation — see `computeMatchedFields`). Empty array = nothing
+     * matched textually, i.e. a pure semantic hit.
+     */
+    matchedFields?: string[];
+}
+/**
+ * Which of a hit's fields textually contain any query term (case-
+ * insensitive). An honest approximation for debug display — the engine
+ * exposes no per-field match info; a hit with NO textual match is a
+ * semantic (meaning-based) match and is labeled as such.
+ */
+export declare function computeMatchedFields(query: string, fields: Record<string, unknown>): string[];
+export declare function ScoreOverlay({ info, className }: {
+    info: ScoreOverlayInfo;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/_internal/app/components/search-degraded-chip.d.ts

@@ -0,0 +1,4 @@
+export declare function SearchDegradedChip({ testId, className }: {
+    testId?: string;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/_internal/app/components/search-partial-chip.d.ts

@@ -0,0 +1,13 @@
+export interface SearchPartialMeta {
+    partial?: boolean;
+    tables?: Array<{
+        table: string;
+        hits: number;
+        took_ms: number;
+        budget?: 'degraded' | 'omitted';
+    }>;
+}
+export declare function SearchPartialChip({ meta, className }: {
+    meta: SearchPartialMeta | null | undefined;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element | null;

package/_internal/app/components/search-unavailable.d.ts

@@ -0,0 +1,12 @@
+interface SearchUnavailableProps {
+    /** Re-run the query that hit the unavailable state. */
+    retry?: () => void;
+    className?: string;
+}
+/**
+ * Honest engine-down state (spec D11): search UIs show THIS — never a
+ * silent client-side fallback whose quality degrades invisibly. Browse
+ * and filter views keep working; only search is down.
+ */
+export declare function SearchUnavailable({ retry, className }: SearchUnavailableProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/_internal/app/components/section-card.d.ts

@@ -0,0 +1,22 @@
+import type { ComponentType, ReactNode } from 'react';
+export interface SectionCardProps {
+    title: ReactNode;
+    /** Lucide icon component rendered before the title. */
+    icon?: ComponentType<{
+        className?: string;
+    }>;
+    /** One line answering "why does this matter to me?" — every user-facing section should have one. */
+    description?: ReactNode;
+    /** Right-aligned header action (button, toggle, hint). */
+    action?: ReactNode;
+    children: ReactNode;
+    className?: string;
+    contentClassName?: string;
+}
+/**
+ * The standard titled settings/detail card: icon + title, a muted one-line
+ * description explaining why the section matters, an optional header action,
+ * and the section body. Compose this instead of hand-rolling card headers so
+ * every surface explains itself the same way.
+ */
+export declare function SectionCard({ title, icon: Icon, description, action, children, className, contentClassName, }: SectionCardProps): import("react/jsx-runtime").JSX.Element;

package/_internal/app/components/segmented-control.d.ts

@@ -0,0 +1,28 @@
+import type { ComponentType, ReactNode } from 'react';
+export interface SegmentedControlOption<T extends string> {
+    value: T;
+    label: ReactNode;
+    icon?: ComponentType<{
+        className?: string;
+    }>;
+    /** Icon-only segment — the label stays for screen readers + the hover title. */
+    hideLabel?: boolean;
+}
+export interface SegmentedControlProps<T extends string> {
+    options: ReadonlyArray<SegmentedControlOption<T>>;
+    value: T;
+    onValueChange: (value: T) => void;
+    /** `sm` (default) for toolbars, `md` for page-level view switchers. */
+    size?: 'sm' | 'md';
+    /** Accessible name for the group — always pass one. */
+    ariaLabel: string;
+    className?: string;
+}
+/**
+ * THE segmented control / mode toggle (Edit|Preview, Board|Log, 5m|1h|24h...).
+ * Five plugins hand-rolled this in two drifted dialects with almost no a11y —
+ * this is the one implementation: neutral track, card-colored active segment
+ * (selection is never accent — accent is signal only), proper tablist
+ * semantics.
+ */
+export declare function SegmentedControl<T extends string>({ options, value, onValueChange, size, ariaLabel, className, }: SegmentedControlProps<T>): import("react/jsx-runtime").JSX.Element;

package/_internal/app/components/stat-tile.d.ts

@@ -0,0 +1,26 @@
+import type { ComponentType, ReactNode } from 'react';
+export interface StatTileProps {
+    icon?: ComponentType<{
+        className?: string;
+    }>;
+    /** Uppercase micro-label above the number. */
+    label: ReactNode;
+    /** The big number (tabular). */
+    value: ReactNode;
+    /** Small line under the number (unit, denominator, context). */
+    sub?: ReactNode;
+    /** Optional meter under the number — `tone` follows the status scale. */
+    progress?: {
+        percent: number;
+        tone?: 'success' | 'warning' | 'destructive';
+    };
+    /** Makes the tile a jump link. */
+    onClick?: () => void;
+    className?: string;
+}
+/**
+ * THE metric tile (promoted from the brands overview; ≥7 surfaces hand-rolled
+ * the same label + big-number card with drifting styles): icon + uppercase
+ * micro-label, `text-2xl tabular-nums` value, optional sublabel and meter.
+ */
+export declare function StatTile({ icon: Icon, label, value, sub, progress, onClick, className }: StatTileProps): import("react/jsx-runtime").JSX.Element;

package/_internal/app/components/status-badge.d.ts

@@ -0,0 +1,19 @@
+import type { ComponentType, ReactNode } from 'react';
+export type StatusTone = 'neutral' | 'success' | 'warning' | 'destructive' | 'accent';
+export interface StatusBadgeProps {
+    tone?: StatusTone;
+    /** `solid` (default) or `outline` (softer fill + toned border). */
+    variant?: 'solid' | 'outline';
+    icon?: ComponentType<{
+        className?: string;
+    }>;
+    className?: string;
+    children: ReactNode;
+}
+/**
+ * THE status chip: one tone scale for every "what state is this thing in"
+ * badge (Draft/Published/Queued/Blocked/...). Ad-hoc Badge classNames drifted
+ * into three different Draft chips across one plugin — status chips compose
+ * this instead so state reads the same everywhere.
+ */
+export declare function StatusBadge({ tone, variant, icon: Icon, className, children }: StatusBadgeProps): import("react/jsx-runtime").JSX.Element;

package/_internal/app/components/turn-output-view.d.ts

@@ -0,0 +1,57 @@
+/**
+ * TurnOutputView — legacy-shaped renderer for normalized turn chunks,
+ * now a thin wrapper over the conversation kit: foldTurnChunks delegates
+ * to foldConversation (ONE folding engine) and flattens the turn model
+ * back to the flat segments/tools shape existing consumers pin.
+ *
+ * New surfaces should compose the kit directly (Conversation/AgentTurn/
+ * ActivityGroup); this stays for single-turn output embeds (task step
+ * viewer, workflow step drawer).
+ */
+import type { ReactNode } from 'react';
+import type { RuntimeChatChunk, RuntimeChatTextFormat } from '@makinbakin/sdk/types';
+export interface TurnTextSegment {
+    format: RuntimeChatTextFormat;
+    text: string;
+}
+export interface TurnToolChipState {
+    key: string;
+    toolName: string;
+    summary?: string;
+    status: 'running' | 'completed' | 'failed';
+}
+export interface FoldedTurnOutput {
+    segments: TurnTextSegment[];
+    tools: TurnToolChipState[];
+    /** Latest status chunk content (e.g. 'thinking'), if any. */
+    status: string | null;
+    error: {
+        message: string;
+        kind?: string;
+    } | null;
+    done: boolean;
+}
+/**
+ * Fold a chunk list into the flat renderable shape. Delegates to
+ * foldConversation and flattens: text items → segments (consecutive
+ * same-format segments re-merged across tool boundaries, preserving the
+ * legacy contract), activity calls → chips, latest status label, first
+ * error, done flag.
+ */
+export declare function foldTurnChunks(chunks: readonly RuntimeChatChunk[]): FoldedTurnOutput;
+/** One tool-activity chip (kit ToolCallRow under the legacy name/props). */
+export declare function TurnToolChip({ toolName, summary, status }: Omit<TurnToolChipState, 'key'>): import("react/jsx-runtime").JSX.Element;
+export interface TurnOutputViewProps {
+    chunks: readonly RuntimeChatChunk[];
+    /**
+     * Turn still in flight: renders the latest status ('thinking…') until
+     * text arrives, so the user sees life before the first token/tool.
+     */
+    live?: boolean;
+    /** Optional frame around the merged text block (e.g. chat's avatar bubble). */
+    textFrame?: (text: ReactNode) => ReactNode;
+    /** Applied to each tool/status/error row (e.g. chat's `pl-8` indent). */
+    rowClassName?: string;
+    className?: string;
+}
+export declare function TurnOutputView({ chunks, live, textFrame, rowClassName, className }: TurnOutputViewProps): import("react/jsx-runtime").JSX.Element;

package/_internal/app/components/ui/badge.d.ts

@@ -1,7 +1,7 @@
 import { useRender } from "@base-ui/react/use-render";
 import { type VariantProps } from "class-variance-authority";
 declare const badgeVariants: (props?: ({
-    variant?: "destructive" | "link" | "default" | "outline" | "secondary" | "ghost" | null | undefined;
+    variant?: "destructive" | "default" | "link" | "outline" | "secondary" | "ghost" | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;
 declare function Badge({ className, variant, render, ...props }: useRender.ComponentProps<"span"> & VariantProps<typeof badgeVariants>): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
 export { Badge, badgeVariants };

package/_internal/app/components/ui/button.d.ts

@@ -1,7 +1,7 @@
 import { Button as ButtonPrimitive } from "@base-ui/react/button";
 import { type VariantProps } from "class-variance-authority";
 declare const buttonVariants: (props?: ({
-    variant?: "destructive" | "link" | "default" | "outline" | "secondary" | "ghost" | "warning" | "accent" | null | undefined;
+    variant?: "warning" | "destructive" | "info" | "default" | "link" | "outline" | "secondary" | "ghost" | "accent" | null | undefined;
     size?: "default" | "sm" | "lg" | "icon" | "xs" | "icon-xs" | "icon-sm" | "icon-lg" | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;
 declare function Button({ className, variant, size, ...props }: ButtonPrimitive.Props & VariantProps<typeof buttonVariants>): import("react/jsx-runtime").JSX.Element;

package/_internal/app/components/underline-tabs.d.ts

@@ -1,4 +1,4 @@
-import type { ReactNode } from 'react';
+import { type ReactNode } from 'react';
 export interface UnderlineTab {
     id: string;
     label: string;
@@ -10,6 +10,10 @@ interface UnderlineTabsProps {
     onValueChange: (id: string) => void;
     className?: string;
     rightSlot?: ReactNode;
+    /** Accessible name for the tab list. */
+    ariaLabel?: string;
+    /** Links each tab to `${idPrefix}-panel-${tab.id}` and enables arrow-key activation. */
+    idPrefix?: string;
 }
-export declare function UnderlineTabs({ tabs, value, onValueChange, className, rightSlot }: UnderlineTabsProps): import("react/jsx-runtime").JSX.Element;
+export declare function UnderlineTabs({ tabs, value, onValueChange, className, rightSlot, ariaLabel, idPrefix, }: UnderlineTabsProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/_internal/app/components/unsaved-changes-guard.d.ts

@@ -0,0 +1,34 @@
+import { type ReactNode } from 'react';
+export interface UnsavedChangesGuardOptions {
+    /** True while the surface holds unsaved edits — gates all the interception. */
+    hasUnsavedChanges: boolean;
+    /** True while a save is in flight — disables the dialog actions. */
+    saving: boolean;
+    /** Whether the "Save and exit" action is offered (default true; e.g. managed sources can't save in place). */
+    canSaveInPlace?: boolean;
+    /** Extra disable for "Save and exit" beyond `saving` (e.g. an open node drawer). */
+    saveDisabled?: boolean;
+    /** Final navigation when there is nothing to confirm / after the user proceeds. */
+    onCancel?: () => void;
+    /** Persist + clear dirty state. Resolves true to proceed with the exit, false to stay. */
+    onSaveAndExit: () => Promise<boolean>;
+    /** Drop dirty state without saving. */
+    onDiscardAndExit: () => void;
+    /** Dialog copy overrides — defaults are surface-neutral. */
+    title?: ReactNode;
+    description?: ReactNode;
+    saveLabel?: string;
+}
+/**
+ * Generic unsaved-changes navigation guard: beforeunload, the TanStack
+ * history blocker, and a capture-phase anchor-click interceptor (TanStack's
+ * blocker misses plain `<a href>` navigation). Surfaces an exit-confirmation
+ * dialog and a `requestExit()` to drive from an explicit cancel/back button.
+ * `reset()` clears the in-flight prompt state — call it when the host re-seeds
+ * (its props-change reset effect) so a stale prompt can't linger.
+ */
+export declare function useUnsavedChangesGuard({ hasUnsavedChanges, saving, canSaveInPlace, saveDisabled, onCancel, onSaveAndExit, onDiscardAndExit, title, description, saveLabel, }: UnsavedChangesGuardOptions): {
+    requestExit: () => void;
+    reset: () => void;
+    dialog: ReactNode;
+};