@aintela/bi 0.2.0

package/dist/composer/pad/DatasetParameterizationControls.d.ts

@@ -0,0 +1,34 @@
+import { default as React } from 'react';
+export interface DatasetOption {
+    /** The BigQuery dataset id (`BI_Acme`). */
+    dataSetId: string;
+    name: string;
+    isTemplate?: boolean;
+}
+export interface AgentOption {
+    id: string;
+    name: string;
+}
+export interface DatasetParameterizationControlsProps {
+    /** `'row'` packs the controls inline (the V1 header); `'column'` stacks them (the V2 rail). */
+    orientation?: 'row' | 'column';
+    /** Datasets the default-dataset picker offers (include the template dataset). */
+    datasets: DatasetOption[];
+    /** Dataset preselected when the toggle is switched on and none is stored yet. */
+    defaultTemplateDataset?: string;
+    /** Agents for the agent picker. Omit `agents` to hide the picker. */
+    agents?: AgentOption[];
+    /** The live agent id (the host's `agentContext.agentConfig.id`). */
+    agentId?: string;
+    /** Recommended agent while the host has not picked one — shown, never written. */
+    recommendedAgentId?: (isDatasetParameterized: boolean) => string | undefined;
+    onAgentChange?: (agent: AgentOption) => void;
+}
+/**
+ * The admin block: "DataSet Dinâmico" toggle (writes `isDatasetParameterized`
+ * / `defaultDatasetName` on the sketch), the default-dataset picker, and the
+ * agent picker (host state — the composer never chooses an agent itself).
+ * Render it only for admins; it does not check permissions.
+ */
+export declare const DatasetParameterizationControls: React.FC<DatasetParameterizationControlsProps>;
+export default DatasetParameterizationControls;

package/dist/composer/pad/FilterSketch.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+import { SketchedFilter } from '../models/sketchModels';
+export interface FilterSketchProps {
+    filter: SketchedFilter;
+    onEdit: (filter: SketchedFilter) => void;
+    onDelete: (filterId: string) => void;
+}
+/** One sketched filter chip: icon, click-to-rename, mandatory / multi-select toggle, delete. */
+export declare const FilterSketch: React.FC<FilterSketchProps>;
+export default FilterSketch;

package/dist/composer/pad/HoverButton.d.ts

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+export interface HoverButtonProps {
+    onClick?: (event: React.MouseEvent<HTMLDivElement, MouseEvent>) => void;
+    icon: React.ReactNode | (() => React.ReactNode);
+    /** Always show the label (instead of revealing it on hover). */
+    fixed?: boolean;
+    label: string;
+    maxWidth?: number;
+}
+/** Icon button whose label slides out on hover — the pad toolbar's action style. */
+export declare const HoverButton: React.FC<HoverButtonProps>;
+export default HoverButton;

package/dist/composer/pad/TitleSketch.d.ts

@@ -0,0 +1,19 @@
+import { default as React } from 'react';
+export interface TitleSketchProps {
+    onEdit: (text: string) => void;
+    multiline?: boolean;
+    text: string;
+    placeHolderText: string;
+    /** Font size of the label / input (px). The V1 pad used 14.4 (0.9rem), the V2 rail 12. */
+    fontSize?: number;
+}
+/**
+ * Click-to-edit text (the dashboard name, the notes). Enter commits, Escape
+ * reverts, blur commits. Was `TitleSkath.tsx` / `TitleSkathV2.tsx`.
+ */
+export declare const TitleSketch: React.FC<TitleSketchProps>;
+/** @deprecated legacy spelling — use {@link TitleSketch}. */
+export declare const TextSketh: React.FC<TitleSketchProps>;
+/** @deprecated legacy spelling — use {@link TitleSketch}. */
+export declare const TitleSkath: React.FC<TitleSketchProps>;
+export default TitleSketch;

package/dist/composer/pad/ToolBox.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+import { CardCategory, CardSpecificType, FilterType } from '../models/sketchModels';
+export interface ToolBoxProps {
+    onAddGeneric: () => void;
+    onAddTyped: (category: CardCategory, specificType: CardSpecificType, label: string) => void;
+    /** When omitted the "Filtro" button is not rendered. */
+    onAddFilter?: (filterType: FilterType) => void;
+}
+/** The pad's toolbar: drag-to-add handle, "+ Card" (with a typed dropdown) and "Filtro". */
+export declare const ToolBox: React.FC<ToolBoxProps>;
+export default ToolBox;

package/dist/composer/store/ComposerProvider.d.ts

@@ -0,0 +1,36 @@
+import { default as React } from 'react';
+import { BiClient } from '../../client';
+import { DashboardEnvironment } from '../environment/types';
+import { ComposerState, ComposerStoreApi, CreateComposerStoreOptions } from './createComposerStore';
+export interface ComposerProviderProps extends Omit<CreateComposerStoreOptions, 'client'> {
+    /** Autosave client. Defaults to the ambient `BiClientProvider`; `null` disables autosave. */
+    client?: BiClient | null;
+    /** Bring your own store (tests, or sharing one composer across two mount points). */
+    store?: ComposerStoreApi;
+    children: React.ReactNode;
+}
+/**
+ * Owns one composer store. Everything under it — `ComposerView`,
+ * `DashboardPad`, `useComposer()`, `useComposerEnvironment()` — reads that
+ * store; a second `ComposerProvider` elsewhere on the page is fully independent.
+ */
+export declare const ComposerProvider: React.FC<ComposerProviderProps>;
+/** The store API (`getState()` / `setState()` / `subscribe()`) — for handlers that must read the latest state without subscribing. */
+export declare function useComposerStore(): ComposerStoreApi;
+/** Same as {@link useComposerStore} but `null` instead of throwing. */
+export declare function useComposerStoreOptional(): ComposerStoreApi | null;
+/**
+ * Subscribe to the ambient composer store. Select a primitive whenever you
+ * can: the live definition is re-allocated on every agent partial.
+ */
+export declare function useComposer(): ComposerState;
+export declare function useComposer<T>(selector: (state: ComposerState) => T): T;
+/**
+ * The `DashboardEnvironment` bound to this composer — pass it to the chat
+ * library's `EnvironmentProvider` and to `createBiUiTools({ environment })`.
+ * Shallow-stable: the actions are store methods, so the object only changes
+ * when the store does.
+ */
+export declare function useComposerEnvironment(): DashboardEnvironment;
+/** Build the environment object from a store outside React (tests, the bridge). */
+export declare function environmentFromStore(api: ComposerStoreApi): DashboardEnvironment;

package/dist/composer/store/createComposerStore.d.ts

@@ -0,0 +1,107 @@
+import { StoreApi } from 'zustand/vanilla';
+import { TodoItem } from '@aintela/chat/models';
+import { BiClient } from '../../client';
+import { ComposerDashboard, SimplePadDefinition } from '../models/sketchModels';
+import { CloneComponentOptions, CloneComponentResult, EnvironmentTarget, GuideOptions, GuideStep, HighlightOptions } from '../environment/types';
+/**
+ * How long the viewer waits after the most-recent sketch edit before
+ * catching up to the live state. Generous by design — a sketch drag /
+ * resize / rename must not cascade into the heavy dashboard viewer.
+ */
+export declare const VIEWER_COMMIT_DEBOUNCE_MS = 3000;
+/** Autosave debounce after the last `updateDashboard`. */
+export declare const DRAFT_SAVE_DEBOUNCE_MS = 800;
+/** `showGuide` publishes its steps after this delay so the DOM can settle first. */
+export declare const GUIDE_SHOW_DELAY_MS = 500;
+export type ComposerViewType = 'Sketch' | 'Generated';
+export interface ComposerViewport {
+    width: number;
+    height: number;
+}
+export interface ComposerState {
+    /** The live sketch the pad edits. */
+    dashboardDefinition: ComposerDashboard | null;
+    /**
+     * "Published" snapshot read-only surfaces (the side panel's viewer)
+     * render from. Advances on a debounced timer after edits (skipped while
+     * a turn is open), immediately on `commitForSend()`, and at hydration /
+     * agent boundaries.
+     */
+    publishedDashboard: ComposerDashboard | null;
+    /** Snapshot at the last real send — the "queued changes" chip diffs against it. */
+    lastSentDashboard: ComposerDashboard | null;
+    dashboardId: string | null;
+    viewType: ComposerViewType;
+    scriptLoadOnMount: boolean;
+    /** Bumped when the bundle CODE changes (generated / loaded / refreshed) — the viewer's `codeGeneration`. */
+    renderGeneration: number;
+    turnOpen: boolean;
+    currentSessionId: string | null;
+    /** Bumped on viewer commits, refreshes and agent updates — the viewer's `llmRenderCount`. */
+    llmCounter: number;
+    /** Bumped ONLY when the agent touched the sketch (`updateDashboardPad`, `dashboardGenerated`). */
+    agentPulseTick: number;
+    todosByCardKey: Record<string, {
+        todo: TodoItem;
+        turnOpen: boolean;
+    }>;
+    sketchExpanded: boolean;
+    hasCompletedOnce: boolean;
+    producedDashboardId: string | null;
+    viewport: ComposerViewport;
+    guideSteps: GuideStep[] | null;
+    guideOptions: GuideOptions | null;
+    _client: BiClient | null;
+    _draftSaveTimer: ReturnType<typeof setTimeout> | null;
+    _draftSavePromise: Promise<void> | null;
+    _viewerCommitTimer: ReturnType<typeof setTimeout> | null;
+    _guideShowTimer: ReturnType<typeof setTimeout> | null;
+    setClient: (client: BiClient | null) => void;
+    flushDraft: () => Promise<void>;
+    /** Agent tool events (`dashboardGenerated`, `todolistUpdated`) — the chat bridge forwards them here. */
+    ingestToolEvent: (eventName: string, eventData: string) => void;
+    setTurnOpen: (open: boolean) => void;
+    onTurnOpened: () => void;
+    onTurnClosed: () => void;
+    setDashboardId: (id: string | null) => void;
+    setCurrentSessionId: (sessionId: string | null) => void;
+    setViewType: (v: ComposerViewType) => void;
+    /** Merge `fields` into the live sketch; `undefined` wipes it (and both snapshots). */
+    updateDashboard: (fields?: Partial<ComposerDashboard>) => void;
+    loadDashboard: (dashboard: ComposerDashboard) => void;
+    /** One entry into the per-turn `clientSideChanges` hint (last write per key wins). Does not trigger a save. */
+    recordSketchChange: (key: string, text: string) => void;
+    clearClientSideChanges: () => void;
+    /** The user is sending: both snapshots advance, the pending viewer commit is cancelled. */
+    commitForSend: () => void;
+    /** A layout edit made inside the preview viewer: align `publishedDashboard` now, keep `lastSentDashboard`. */
+    commitDashboardLayout: () => void;
+    setSketchExpanded: (next: boolean | ((prev: boolean) => boolean)) => void;
+    setHasCompletedOnce: (next: boolean) => void;
+    setProducedDashboardId: (id: string | null) => void;
+    setViewport: (viewport: ComposerViewport) => void;
+    highlightComponent: (target: EnvironmentTarget, options?: HighlightOptions) => number;
+    cloneComponent: (target: EnvironmentTarget, options?: CloneComponentOptions) => CloneComponentResult | null;
+    createDashboardPad: (dashboard: ComposerDashboard | SimplePadDefinition) => void;
+    updateDashboardPad: (dashboard: ComposerDashboard | SimplePadDefinition) => void;
+    refreshDashboard: () => void;
+    showGuide: (steps: GuideStep[], options?: GuideOptions) => void;
+    dismissGuide: () => void;
+    /** Reset for a (possibly different) dashboard, or to an empty composer. */
+    openComposer: (dashboard?: ComposerDashboard) => void;
+}
+export type ComposerStoreApi = StoreApi<ComposerState>;
+export interface CreateComposerStoreOptions {
+    /** Autosave transport. `null` disables the debounced draft save (the pad still works). */
+    client?: BiClient | null;
+    viewerCommitDebounceMs?: number;
+    draftSaveDebounceMs?: number;
+    /** Called when the autosave POST fails (default: `console.warn`). */
+    onDraftSaveError?: (error: unknown) => void;
+}
+/**
+ * One composer = one store. `ComposerProvider` calls this per instance;
+ * nothing here is module-level, so two composers on one page (or two tests)
+ * never share state.
+ */
+export declare function createComposerStore(options?: CreateComposerStoreOptions): ComposerStoreApi;

package/dist/composer/store/drafts.d.ts

@@ -0,0 +1,20 @@
+import { BiClient } from '../../client';
+import { ComposerDashboard, SketchCardItem, SketchedFilter } from '../models/sketchModels';
+/**
+ * The upsert body the server expects: document metadata at the top level,
+ * the editable part under `draft`. `clientSideChanges` is the transient
+ * per-turn hint and never leaves the client.
+ */
+export declare function toDraftPayload(dashboard: ComposerDashboard): Record<string, unknown>;
+/** Flattens the server's `{ ...metadata, draft | committed }` document back into a `ComposerDashboard`. */
+export declare function fromUpsertResponse(resp: unknown): ComposerDashboard;
+/** POST the draft; resolves to the server's flattened document. */
+export declare function upsertDashboardDraft(client: BiClient, dashboard: ComposerDashboard): Promise<ComposerDashboard>;
+export interface DraftSeed {
+    name?: string;
+    cards?: SketchCardItem[];
+    filters?: SketchedFilter[];
+    layoutType?: 'Naked' | 'Boxed';
+}
+/** A fresh server-side draft bound to `sessionId` (the `originalSessionId` autosave needs). */
+export declare function createDashboardDraft(client: BiClient, sessionId: string, seed?: DraftSeed & Partial<ComposerDashboard>): Promise<ComposerDashboard>;

package/dist/composer/view/ComposerChatBinding.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+/**
+ * Optional glue, mounted INSIDE the host's `AiChatProvider`: mirrors the live
+ * chat session id into the composer store and forwards the gateway's tool
+ * events (`dashboardGenerated`, `todolistUpdated`). A host that prefers to
+ * wire these itself uses `useComposerChatBridge().setSessionId` /
+ * `.ingestToolEvent` instead.
+ */
+export declare const ComposerChatBinding: React.FC;
+export default ComposerChatBinding;

package/dist/composer/view/ComposerView.d.ts

@@ -0,0 +1,49 @@
+import { default as React } from 'react';
+import { EnvironmentTarget } from '../environment/types';
+import { RecentSessionItem } from './composerTypes';
+import { ComposerSuggestion } from './data/suggestions';
+import { ComposerTemplate } from './data/templates';
+export interface ComposerProgressPanelArgs {
+    hasDashboard: boolean;
+    dashboardCollapsed: boolean;
+    turnOpen: boolean;
+}
+export interface ComposerViewProps {
+    /** The live chat session id (the host's AiChat store). `null` until the handshake binds one. */
+    sessionId?: string | null;
+    /** The session in the route (`/composer/:sessionId`) — hydrates the dashboard bound to it and skips the splash. */
+    routeSessionId?: string;
+    /** The transcript — the host renders `<AiChatV2Pane hideHeader />` (or its own). */
+    chatPane: React.ReactNode;
+    /** The right-hand activity panel (`RunProgressPanelV2`), sized by the host from the args. */
+    renderProgressPanel?: (args: ComposerProgressPanelArgs) => React.ReactNode;
+    /** Rendered under the prompt on the splash (`RunProgressStripV2`). */
+    progressStrip?: React.ReactNode;
+    /** Runs before every send, after the view ensured a server draft exists. */
+    onBeforeSend?: (text: string) => void | Promise<void>;
+    /** Spotlight target resolver (default: first visible `data-env-*` / selector match). */
+    resolveGuideElement?: (target: EnvironmentTarget) => HTMLElement | null;
+    suggestions?: readonly ComposerSuggestion[];
+    templates?: readonly ComposerTemplate[];
+    /** Recent sessions for the splash. When omitted (and a client is in scope) the view lists dashboards itself. */
+    recentSessions?: RecentSessionItem[];
+    onSelectSession?: (sessionId: string) => void;
+    onSearchAllSessions?: () => void;
+    /** The sketch's name (or `null` when there is none) — for a breadcrumb. */
+    onDashboardNameChange?: (name: string | null) => void;
+    /** The admin dataset / agent block in the rail (`<DatasetParameterizationControls orientation="column" …/>`). */
+    datasetControls?: React.ReactNode;
+    /** Card description renderer (Markdown in the legacy app). */
+    renderDescription?: (text: string) => React.ReactNode;
+    /** Side panel width when expanded (default `'70%'`). */
+    sidePanelWidth?: string;
+    /** Chat column width when a dashboard is showing (default `'80%'`). */
+    chatColumnWidthWithDashboard?: string;
+}
+/**
+ * The composer screen. Mount it under `ComposerProvider`, `BiClientProvider`
+ * (for drafts) and the host's `AiChatProvider` + `EnvironmentProvider`; the
+ * host wires `useComposerChatBridge()` into that provider.
+ */
+export declare const ComposerView: React.FC<ComposerViewProps>;
+export default ComposerView;

package/dist/composer/view/DashboardPin.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+export declare const DashboardPin: React.NamedExoticComponent<{}>;
+export default DashboardPin;

package/dist/composer/view/DashboardSidePanel.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+export interface DashboardSidePanelProps {
+    /** Share of the execution layout when expanded (`'70%'`). */
+    width: string;
+    defaultCollapsed?: boolean;
+    onCollapseChange?: (collapsed: boolean) => void;
+}
+/** memo — the panel reads its own store fields, so parent re-renders must not re-mount the heavy viewer. */
+export declare const DashboardSidePanel: React.NamedExoticComponent<DashboardSidePanelProps>;
+export default DashboardSidePanel;

package/dist/composer/view/DrawablePrompt.d.ts

@@ -0,0 +1,22 @@
+import { default as React } from 'react';
+export interface DrawablePromptProps {
+    /** The "+ Adicionar sketch" CTA — the view creates a server draft. */
+    onCreateSketch?: () => void;
+    zoomLevel: number;
+    /** Runs before `PromptV2` sends (the view ensures a draft exists). */
+    onBeforeSend?: (text: string) => void | Promise<void>;
+    /** Controlled expand / collapse. */
+    sketchExpanded?: boolean;
+    onSketchExpandedChange?: (next: boolean) => void;
+    /** Fills the textarea (no auto-send). */
+    seedDraft?: string | null;
+    /** Compact textarea (execution layout). */
+    compact?: boolean;
+    bottomSlot?: React.ReactNode;
+    /** Rendered at the bottom of the rail (the admin dataset / agent block). */
+    datasetControls?: React.ReactNode;
+    renderDescription?: (text: string) => React.ReactNode;
+}
+/** The composer's prompt: `PromptV2` with the sketch pad riding in its `topSlot`. Needs `ComposerProvider` and the host's `AiChatProvider`. */
+export declare const DrawablePrompt: React.MemoExoticComponent<React.ForwardRefExoticComponent<DrawablePromptProps & React.RefAttributes<HTMLDivElement>>>;
+export default DrawablePrompt;

package/dist/composer/view/EntryEmptyState.d.ts

@@ -0,0 +1,22 @@
+import { default as React } from 'react';
+import { ComposerSuggestion } from './data/suggestions';
+import { ComposerTemplate } from './data/templates';
+import { RecentSessionItem } from './composerTypes';
+export interface EntryEmptyStateProps {
+    /** A suggestion click drops its `prompt` here (no auto-send). */
+    onDraftPromptChange: (next: string) => void;
+    onApplyTemplate: (template: ComposerTemplate) => void;
+    /** The prompt node (the parent wraps it in a `motion.div` with the shared `layoutId`). */
+    composerSlot: React.ReactNode;
+    /** Wrapper for the ambient blocks (hero / suggestions / templates) — the morph injects motion variants here. */
+    ambientWrapper?: (children: React.ReactNode, key: string) => React.ReactNode;
+    recentSessions?: RecentSessionItem[];
+    onSelectSession?: (sessionId: string) => void;
+    /** "Buscar todas as sessões" — the host opens its own search. Hidden when omitted. */
+    onSearchAllSessions?: () => void;
+    suggestions?: readonly ComposerSuggestion[];
+    templates?: readonly ComposerTemplate[];
+}
+/** The composer's splash: hero, the prompt, suggestions + recent sessions, starter templates. */
+export declare const EntryEmptyState: React.FC<EntryEmptyStateProps>;
+export default EntryEmptyState;

package/dist/composer/view/SpotlightOverlay.d.ts

@@ -0,0 +1,21 @@
+import { default as React } from 'react';
+import { GuideStep } from '../environment/types';
+export interface SpotlightOverlayProps {
+    steps: GuideStep[];
+    /** Backdrop opacity (default 0.6). */
+    overlayOpacity?: number;
+    /** Let clicks through the backdrop to the page. */
+    allowInteraction?: boolean;
+    onComplete?: () => void;
+    onDismiss: () => void;
+    /** Target → element. Defaults to the package resolver (first visible `data-env-*` / selector match). */
+    resolveElement?: (target: GuideStep['target']) => HTMLElement | null;
+}
+/**
+ * The guided tour `env.showGuide()` drives: a dimmed backdrop with a
+ * cut-out around the current target, an accent ring, and a tooltip with
+ * Anterior / Próximo / Concluir. → / Enter advance, ← retreats, Esc closes.
+ * A target that never resolves within 3 s is skipped (logged), not fatal.
+ */
+export declare const SpotlightOverlay: React.FC<SpotlightOverlayProps>;
+export default SpotlightOverlay;

package/dist/composer/view/composerAnimations.d.ts

@@ -0,0 +1,11 @@
+import { Transition, Variants } from 'framer-motion';
+/** Hero + suggestions + templates fade. Storyboard 0–180 ms. */
+export declare const ambientVariants: Variants;
+/** Right-side activity panel slide-in. Storyboard 220–320 ms. */
+export declare const activityPanelVariants: Variants;
+/** The shared-`layoutId` morph of the prompt between the centred and the docked position. Storyboard 0–280 ms. */
+export declare const composerLayoutTransition: Transition;
+/** Reduced-motion fallbacks — flat 150 ms cross-fades, no transforms. */
+export declare const ambientVariantsReduced: Variants;
+export declare const activityPanelVariantsReduced: Variants;
+export declare const composerLayoutTransitionReduced: Transition;

package/dist/composer/view/composerTypes.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Visible state of `ComposerView`.
+ *
+ *  - `'empty'`          Nothing submitted yet: hero + suggestions + templates
+ *                       around the centred prompt (the pad is available).
+ *  - `'generating'`     A turn is open: prompt docked, transcript + progress visible.
+ *  - `'done-text'`      The agent finished without producing a dashboard.
+ *  - `'done-dashboard'` The agent finished and produced a dashboard (side panel shows it).
+ */
+export type ComposerMode = 'empty' | 'generating' | 'done-text' | 'done-dashboard';
+export interface RecentSessionItem {
+    /** Chat session that produced the dashboard — what `onSelectSession` receives. */
+    sessionId: string;
+    name: string;
+    cardCount: number;
+    /** Epoch ms. */
+    updatedAt?: number;
+}

package/dist/composer/view/data/suggestions.d.ts

@@ -0,0 +1,10 @@
+/** One splash suggestion: the short label shown, and the fuller prompt a click drops into the textarea. */
+export interface ComposerSuggestion {
+    label: string;
+    prompt: string;
+}
+/**
+ * The product's default suggestions (Portuguese, travel BI). Pass your own
+ * through `ComposerView.suggestions` / `EntryEmptyState.suggestions`.
+ */
+export declare const defaultComposerSuggestions: readonly ComposerSuggestion[];

package/dist/composer/view/data/templates.d.ts

@@ -0,0 +1,33 @@
+import { CardCategory, CardSpecificType, SketchCardItem } from '../../models/sketchModels';
+export type TemplateCardKind = 'kpi' | 'line' | 'bars' | 'table' | 'donut' | 'heatmap';
+/** Template card kind → the sketch's category / specific type. */
+export declare const TEMPLATE_KIND_TO_SKETCH: Record<TemplateCardKind, {
+    category: CardCategory;
+    specificType: CardSpecificType;
+}>;
+/** One template cell; `x/y/w/h` are 12-column grid units, as the pad uses them. */
+export interface TemplateCellSeed {
+    name: string;
+    kind: TemplateCardKind;
+    description: string;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+export interface ComposerTemplate {
+    id: string;
+    name: string;
+    desc: string;
+    /** Highlighted as the recommended pick. */
+    recommended?: boolean;
+    /** Empty → "start blank": no draft is created, the layout just switches to execution mode. */
+    cells: TemplateCellSeed[];
+}
+export declare function templateKinds(t: ComposerTemplate): TemplateCardKind[];
+/** Convert a template into ready-to-store `SketchCardItem`s. */
+export declare function seedFromTemplate(template: ComposerTemplate, idPrefix?: string): SketchCardItem[];
+/** The product's default starter templates (Portuguese). Replace through `ComposerView.templates`. */
+export declare const defaultComposerTemplates: readonly ComposerTemplate[];
+/** @deprecated legacy name — use {@link defaultComposerTemplates}. */
+export declare const STARTER_TEMPLATES: readonly ComposerTemplate[];

package/dist/composer/view/surfaces.d.ts

@@ -0,0 +1,19 @@
+import { Theme } from '@mui/material/styles';
+/** The few extra surface tokens the composer chrome uses beyond MUI's standard palette. */
+export interface ComposerSurfaces {
+    /** Raised chip / popover surface. */
+    raised: string;
+    /** Hover wash. */
+    hover: string;
+    /** Soft border between rail sections. */
+    borderSoft: string;
+    /** Monospace family for counters. */
+    fontFamilyMono: string;
+}
+/**
+ * Reads the chat library's v2 theme extension (`palette.surface`,
+ * `palette.border`, `typography.fontFamilyMono`) when the host theme
+ * carries it, and falls back to standard MUI tokens when it does not — so
+ * the composer renders the same under a plain `createTheme()`.
+ */
+export declare function resolveComposerSurfaces(theme: Theme): ComposerSurfaces;

package/dist/composer/view/useComposerChatBridge.d.ts

@@ -0,0 +1,43 @@
+import { DashboardEnvironment } from '../environment/types';
+/** Same constants the pad uses to project sketch w/h to pixels for the agent. */
+export declare const GRID_ROW_HEIGHT_PX = 20;
+/** The subset of the chat library's `Interaction` the bridge reads — structurally compatible with the real one. */
+export interface TurnCompleteInfo {
+    artifactData?: ReadonlyArray<{
+        type?: string;
+        id?: string;
+    } | null | undefined>;
+}
+export interface ComposerPromptEnvelope {
+    /** What the transcript shows for the user's message. */
+    promptAsString: string;
+    /** The JSON the agent receives (`PromptDashboardContainer`). */
+    json: string;
+}
+export interface ComposerChatBridge {
+    /** `AiChatProvider.onRenderPrompt` — wraps the text in the dashboard envelope and drains `clientSideChanges`. */
+    onRenderPrompt: (prompt: string) => ComposerPromptEnvelope;
+    /** `AiChatProvider.onTurnOpen`. */
+    onTurnOpen: () => void;
+    /** `AiChatProvider.onTurnComplete`. */
+    onTurnComplete: (interaction: TurnCompleteInfo) => void;
+    /** Agent tool events (`eventBusService.gatewayOnToolEvent`). */
+    ingestToolEvent: (eventName: string, eventData: string) => void;
+    /** The live chat session id — call when the host's AiChat session binds / changes. */
+    setSessionId: (sessionId: string | null) => void;
+    /** For `EnvironmentProvider value={…}` and `createBiUiTools({ environment })`. */
+    environment: DashboardEnvironment;
+}
+/**
+ * Everything the host wires between its `AiChatProvider` and the composer
+ * store. The composer never mounts the chat itself; the host does, and
+ * passes these handlers:
+ *
+ *     const bridge = useComposerChatBridge();
+ *     <AiChatProvider onRenderPrompt={bridge.onRenderPrompt} onTurnOpen={bridge.onTurnOpen}
+ *                     onTurnComplete={bridge.onTurnComplete} uiTools={uiTools} hidePromptInput …>
+ *       <EnvironmentProvider value={bridge.environment}>
+ *         <ComposerChatBinding /> {/* or wire sessionId + tool events by hand *\/}
+ *         <ComposerView … />
+ */
+export declare function useComposerChatBridge(): ComposerChatBridge;

package/dist/composer.d.ts

@@ -0,0 +1,2 @@
+export * from './composer/index'
+export {}

package/dist/composer.js

@@ -0,0 +1,99 @@
+import { C as e, a as t, c as o, d as r, e as n, f as i, g as d, h as C, i as E, j as m, D as S, k as p, l, m as T, n as _, o as P, p as c, q as I, r as D, E as h, s as u, t as A, u as v, v as R, w as O, F as k, x as g, y as L, G as y, z as N, H as b, P as f, A as F, B as G, S as H, I as M, J as V, M as x, T as B, N as Y, O as U, Q as w, R as z, V as K, U as W, W as q, X as J, Y as X, Z as j, _ as Q, $ as Z, a1 as $, a2 as aa, a3 as sa, a4 as ea, a5 as ta, a6 as oa, a7 as ra, a8 as na, a9 as ia, aa as da, ac as Ca, ag as Ea, ah as ma, ak as Sa, al as pa, am as la, ao as Ta, ap as _a, aq as Pa, as as ca, at as Ia, au as Da, av as ha, aw as ua, ay as Aa, az as va, aA as Ra, aB as Oa, aC as ka, aD as ga, aE as La, aF as ya, aG as Na, aH as ba, aI as fa, aJ as Fa, aK as Ga, aM as Ha, aN as Ma } from "./index-C6JQ6770.js";
+import { EnvironmentProvider as xa, InertEnvironmentProvider as Ba, useEnvironment as Ya, useEnvironmentOptional as Ua } from "@aintela/chat/components";
+export {
+  e as CARD_TYPE_CATALOG,
+  t as CATEGORY_ICONS,
+  o as COLOR_MAP,
+  r as CardScketch,
+  n as CardSketch,
+  i as CardTypeIconsProvider,
+  d as ClonedComponent,
+  C as ComposerChatBinding,
+  E as ComposerProvider,
+  m as ComposerView,
+  S as DEFAULT_PAD_HEIGHT_PX,
+  p as DRAFT_SAVE_DEBOUNCE_MS,
+  l as DashboardPad,
+  T as DashboardPadEditor,
+  _ as DashboardPadSketch,
+  P as DashboardPin,
+  c as DashboardSidePanel,
+  I as DatasetParameterizationControls,
+  D as DrawablePrompt,
+  h as ENV_HIGHLIGHT_CLASS,
+  u as EntryEmptyState,
+  xa as EnvironmentProvider,
+  A as ExampleCardSkath,
+  v as ExampleCardSketch,
+  R as ExampleCardSketh,
+  O as ExamplePad,
+  k as FILTER_TYPE_CATALOG,
+  g as FILTER_TYPE_ICONS,
+  L as FilterSketch,
+  y as GRID_ROW_HEIGHT_PX,
+  N as GUIDE_SHOW_DELAY_MS,
+  b as HoverButton,
+  Ba as InertEnvironmentProvider,
+  f as PAD_INTERNAL_CLASSES,
+  F as PAD_INTERNAL_IDS,
+  G as PrototypePad,
+  H as SPECIFIC_TYPE_ICONS,
+  M as SPECIFIC_TYPE_ICON_NAMES,
+  V as STARTER_TEMPLATES,
+  x as SpotlightOverlay,
+  B as TEMPLATE_KIND_TO_SKETCH,
+  Y as TextSketh,
+  U as TitleSkath,
+  w as TitleSketch,
+  z as ToolBox,
+  K as VIEWER_COMMIT_DEBOUNCE_MS,
+  W as activityPanelVariants,
+  q as activityPanelVariantsReduced,
+  J as ambientVariants,
+  X as ambientVariantsReduced,
+  j as autoComplete,
+  Q as c,
+  Z as categoryPrefix,
+  $ as composerLayoutTransition,
+  aa as composerLayoutTransitionReduced,
+  sa as createComposerStore,
+  ea as createDashboardDraft,
+  ta as datePicker,
+  oa as dateRange,
+  ra as defaultCardTypeIcons,
+  na as defaultComposerSuggestions,
+  ia as defaultComposerTemplates,
+  da as environmentFromStore,
+  Ca as fromUpsertResponse,
+  Ea as groupCardCatalog,
+  ma as guideStepsRequireSketch,
+  Sa as isElementVisible,
+  pa as isSimplePadDefinition,
+  la as joinClientSideChanges,
+  Ta as padConfigToDashboard,
+  _a as pickBestElement,
+  Pa as randomId,
+  ca as resolveComposerSurfaces,
+  Ia as resolveEnvironmentElements,
+  Da as resolveGuideElement,
+  ha as sanitizeToJsVariable,
+  ua as seedFromTemplate,
+  Aa as sketchCardItemComparer,
+  va as sketchFilterComparer,
+  Ra as targetSuggestsPadInternal,
+  Oa as templateKinds,
+  ka as toDraftPayload,
+  ga as toSelectorList,
+  La as upsertDashboardDraft,
+  ya as useCardTypeIcons,
+  Na as useComposer,
+  ba as useComposerChatBridge,
+  fa as useComposerEnvironment,
+  Fa as useComposerStore,
+  Ga as useComposerStoreOptional,
+  Ha as useDashboardPad,
+  Ya as useEnvironment,
+  Ua as useEnvironmentOptional,
+  Ma as validateSketch
+};
+//# sourceMappingURL=composer.js.map