@rendra-ui/web 2.7.0 → 2.9.0

package/dist/types/components/ui/flow-viewer.d.ts

@@ -10,39 +10,56 @@ export interface FlowBlockData extends Record<string, unknown> {
     issues: string[];
     /** Bloco que a simulação executa agora. */
     active: boolean;
-    /** Alças grandes (montar com mouse ou toque) ou discretas (só ver). */
-    handles: 'lg' | 'sm';
-    /** Mostra o botão "Editar bloco" dentro do bloco. */
-    edit: boolean;
 }
 export type FlowRfNode = Node<FlowBlockData, 'bloco'>;
+/** O que o card e a ligação podem pedir ao editor. No viewer não há nada (contexto nulo). */
+export interface FlowActions {
+    play: (id: string) => void;
+    edit?: (id: string) => void;
+    remove?: (id: string) => void;
+    /** Só com montagem liberada: a lixeira da ligação selecionada. */
+    removeEdge?: (id: string) => void;
+}
+export declare const FlowActionsContext: import("react").Context<FlowActions | null>;
+/** Raio de atração das alças em px: menor que o padrão da biblioteca (20), para não ligar sozinho. */
+export declare const CONNECTION_RADIUS = 12;
 export declare const FLOW_ICON: Record<FlowNodeType, ComponentType<{
     className?: string;
 }>>;
+/** Cor do ícone do bloco, por grupo (também usada na barra de blocos). */
+export declare const flowTone: (type: FlowNodeType) => string;
 /** Os textos que a biblioteca escreve no DOM (leitor de tela), em português. */
 export declare const FLOW_ARIA: Partial<AriaLabelConfig>;
 interface RfNodeOptions {
     activeId?: string | null;
     issues?: FlowIssue[];
-    handles: 'lg' | 'sm';
-    edit: boolean;
 }
 /** Os blocos do Rendra como nós do React Flow (a biblioteca só vê isto). */
-export declare function toRfNodes(flow: Flow, opts: RfNodeOptions): FlowRfNode[];
+export declare function toRfNodes(flow: Flow, opts?: RfNodeOptions): FlowRfNode[];
+export interface FlowEdgeData extends Record<string, unknown> {
+    /** Rótulo da regra na ligação ("> 500", "Senão"); `null` fora da condição. */
+    label: string | null;
+    from: string;
+    to: string;
+}
 /** As ligações do Rendra como arestas do React Flow, com a descrição em português. */
-export declare function toRfEdges(flow: Flow): Edge[];
+export declare function toRfEdges(flow: Flow): Edge<FlowEdgeData>[];
 /** Aproximar, afastar e enquadrar, com 44 px de toque (os botões da biblioteca têm 26 px). */
 export declare function FlowZoomControls(): import("react").JSX.Element;
+/** Zoom mínimo do enquadramento inicial: abaixo disso os cards e as alças ficam ilegíveis e pequenos demais. */
+export declare const MIN_FIT_ZOOM = 0.5;
 export interface FlowSurfaceProps extends ReactFlowProps<FlowRfNode, Edge> {
     children?: ReactNode;
+    /** Falso quando o contêiner de fora já dá a altura (o FlowEditor): o canvas só o preenche. */
+    fill?: boolean;
 }
 /**
  * O canvas: contêiner com a altura que sobra na tela (`h-board`), tema pelos tokens e a
  * biblioteca por dentro. A rolagem horizontal é do canvas (`data-allow-overflow`), nunca da página.
  */
-export declare function FlowSurface({ className, children, ...props }: FlowSurfaceProps): import("react").JSX.Element;
+export declare function FlowSurface({ className, children, fill, ...props }: FlowSurfaceProps): import("react").JSX.Element;
 export interface FlowViewerProps {
-    /** O fluxo a mostrar (o mesmo JSON do FlowEditor). */
+    /** O fluxo a mostrar (o mesmo JSON do FlowEditor; o da 2.7.0 também abre). */
     value: Flow;
     /** Bloco destacado (por exemplo, o passo que a simulação está executando). */
     activeId?: string | null;

package/dist/types/components/ui/kanban.d.ts

@@ -7,6 +7,20 @@ export interface KanbanColumn {
     tone?: BadgeProps['tone'];
     /** Limite de cards (WIP). Passando dele, o contador fica em alerta. */
     limit?: number;
+    /**
+     * Dias máximos de um card nesta etapa. Passando disso (pela `enteredColumnAt` do card), a
+     * cadência está vencida. Sem ela, a etapa nunca vence. Aparece no cabeçalho da coluna.
+     */
+    cadenceDays?: number;
+}
+/** Próxima atividade agendada do card: tipo, data com hora e com quem. */
+export interface KanbanActivity {
+    /** Ex.: "Reunião", "Ligação". Só aparece no hint do calendário. */
+    type: string;
+    /** Data e hora da atividade. */
+    at: Date;
+    /** Com quem (pessoa de contato). */
+    with?: string;
 }
 export interface KanbanCard {
     id: string;
@@ -33,12 +47,36 @@ export interface KanbanCard {
     meta?: string;
     /** Valores numéricos do card, pelas chaves de valueFields (ex.: { ps: 4800, mrr: 590 }). */
     values?: Record<string, number>;
+    /**
+     * Próxima atividade. Com ela (ou com `cadenceDays` em alguma etapa) o quadro passa a
+     * colorir o card pela situação e a mostrar o calendário no lugar do `dueDate`.
+     */
+    activity?: KanbanActivity;
+    /**
+     * Quando o card entrou na etapa atual. Quem usa o componente atualiza esta data ao mover
+     * o card, para a contagem da cadência recomeçar.
+     */
+    enteredColumnAt?: Date;
 }
 /** Valor somado no cabeçalho da coluna e mostrado no card (ex.: P&S e MRR). */
 export interface KanbanValueField {
     key: string;
     label: string;
 }
+/** Confirmação opcional de um destino de arraste: abre um modal antes de agir. */
+export interface KanbanDropConfirm {
+    title: string;
+    description: string;
+    /** Texto do botão. Padrão: o `label` do destino. */
+    confirmLabel?: string;
+    /** Botão destrutivo (ex.: Perder). */
+    destructive?: boolean;
+    /** Motivos a escolher; o escolhido chega como terceiro argumento de `onDropTarget`. */
+    reasons?: {
+        value: string;
+        label: string;
+    }[];
+}
 /**
  * Destino de arraste (etapa A14): uma ação para onde o card vai, diferente de "outra
  * coluna" (ex.: "Marcar como ganho", "Arquivar"). Aparece numa barra durante o arraste e
@@ -54,6 +92,8 @@ export interface KanbanDropTarget {
     disabled?: boolean;
     /** Motivo mostrado quando desabilitado; o destino recusa o solto. */
     disabledReason?: string;
+    /** Sem ela, o destino age na hora. Com ela, abre a confirmação (mouse, toque e menu). */
+    confirm?: KanbanDropConfirm;
 }
 export interface KanbanProps {
     columns: KanbanColumn[];
@@ -74,11 +114,11 @@ export interface KanbanProps {
     hasMore?: (columnId: string) => boolean;
     /** Etapas visíveis por vez no desktop; as demais pela rolagem lateral. Padrão: 5. */
     visibleColumns?: number;
-    /** Conteúdo próprio do card, no lugar do padrão. */
+    /** Conteúdo próprio do card, no lugar do padrão (substitui também calendário e valores). */
     renderCard?: (card: KanbanCard) => ReactNode;
     /**
-     * Valores do card (até 2, lado a lado com divisória) e o total de cada um na coluna.
-     * Ex.: [{ key: 'ps', label: 'P&S' }, { key: 'mrr', label: 'MRR' }].
+     * Valores do card (até 2, empilhados no rodapé) e o total de cada um na coluna, com o
+     * percentual sobre o total do quadro. Ex.: [{ key: 'ps', label: 'P&S' }, { key: 'mrr', label: 'MRR' }].
      */
     valueFields?: KanbanValueField[];
     /** Formato dos valores. Padrão: moeda (R$ 1.250,00). */
@@ -88,11 +128,40 @@ export interface KanbanProps {
      * barra durante o arraste e o menu "Mover para" passa a listar estes destinos.
      */
     dropTargets?: KanbanDropTarget[];
-    /** Card solto num destino da barra (ou escolhido no menu "Mover para"). */
-    onDropTarget?: (cardId: string, targetId: string) => void;
+    /**
+     * Card solto num destino da barra (ou escolhido no menu "Mover para"). `reason` é o motivo
+     * escolhido na confirmação (destinos com `confirm.reasons`).
+     */
+    onDropTarget?: (cardId: string, targetId: string, reason?: string) => void;
+    /** Data de hoje, para o status e a cadência (injetável em teste). Padrão: agora. */
+    referenceDate?: Date;
+    /** Liga a barra do quadro: busca, filtros, totais, Customizar e Novo card. */
+    toolbar?: boolean;
+    /** "Novo card" da barra do quadro (sem coluna; o (+) da coluna segue com `onAddCard`). */
+    onNewCard?: () => void;
+    /**
+     * Chave do `localStorage` em que o Customizar guarda os campos escondidos (por navegador).
+     * Sem ela, a escolha vale só enquanto o quadro está montado.
+     */
+    storageKey?: string;
     'aria-label'?: string;
     className?: string;
 }
-export declare function Kanban({ columns, cards, onCardMove, onCardClick, onAddCard, renderCard, valueFields, formatValue, pageSize, visibleColumns, onLoadMore, hasMore, dropTargets, onDropTarget, className, ...aria }: KanbanProps): import("react").JSX.Element;
+export interface KanbanCardStatus {
+    /** Fundo do card: crítico, cadência vencida, sem atividade ou normal. */
+    background: 'critical' | 'cadenceOverdue' | 'noActivity' | 'normal';
+    /** Situação do calendário: em dia, vence hoje, atrasada ou sem atividade. */
+    activity: 'onTime' | 'today' | 'late' | 'none';
+    /** Dias de calendário na etapa; `null` sem `enteredColumnAt`. */
+    daysInColumn: number | null;
+    /** Dias de atraso da atividade (0 fora de `late`). */
+    daysLate: number;
+}
+/**
+ * Situação do card a partir da próxima atividade e da cadência da etapa. Compara por dia de
+ * calendário; `referenceDate` é o "hoje" (injetável para teste).
+ */
+export declare function getKanbanCardStatus(card: KanbanCard, column: KanbanColumn | undefined, referenceDate: Date): KanbanCardStatus;
+export declare function Kanban({ columns, cards, onCardMove, onCardClick, onAddCard, renderCard, valueFields, formatValue, pageSize, visibleColumns, onLoadMore, hasMore, dropTargets, onDropTarget, referenceDate, toolbar, onNewCard, storageKey, className, ...aria }: KanbanProps): import("react").JSX.Element;
 /** Move um card na lista (para usar no onCardMove): devolve a lista nova. */
 export declare function moveKanbanCard(cards: KanbanCard[], cardId: string, toColumnId: string, toIndex: number): KanbanCard[];

package/dist/types/flow.d.ts

@@ -1,3 +1,3 @@
 export { FlowEditor, type FlowEditorProps } from './components/ui/flow-editor';
 export { FlowViewer, type FlowViewerProps } from './components/ui/flow-viewer';
-export { parseFlow, serializeFlow, validateFlow, type Flow, type FlowBranch, type FlowEdge, type FlowIssue, type FlowNode, type FlowNodeType, type ParseResult, } from './lib/flow';
+export { parseFlow, serializeFlow, validateFlow, type Flow, type FlowBranch, type FlowEdge, type FlowIssue, type FlowNode, type FlowNodeType, type FlowRule, type FlowRuleOperator, type ParseResult, } from './lib/flow';

package/dist/types/lib/flow-blocks.d.ts

@@ -0,0 +1,122 @@
+import type { Flow, FlowEdge, FlowNode, FlowNodeType, FlowRule, FlowRuleOperator, FlowWaitUnit } from './flow';
+/** Largura do card do bloco em px (igual a `w-flow-node`, 21rem). */
+export declare const FLOW_CARD_W = 336;
+export declare const FLOW_GAP_X = 96;
+export declare const FLOW_GAP_Y = 32;
+export declare const FLOW_WAIT_UNITS: readonly FlowWaitUnit[];
+/** A duração do bloco de espera ("5 minutos"), ou `null` se o config não a define. */
+export declare function formatWait(config: Record<string, unknown> | undefined): string | null;
+/** Texto da espera simulada: nunca espera de verdade. */
+export declare function describeWait(config: Record<string, unknown> | undefined): string;
+export type FlowBlockGroupId = 'gatilhos' | 'mensagens' | 'condicionais' | 'integracoes' | 'acoes';
+export interface FlowBlockDef {
+    type: FlowNodeType;
+    group: FlowBlockGroupId;
+    name: string;
+    /** Texto curto do card. */
+    description: string;
+    /** Dica usada na busca da barra de blocos. */
+    hint: string;
+    defaultConfig: () => Record<string, unknown>;
+    /** Campos de `config` que não podem ficar vazios. */
+    required: {
+        key: string;
+        label: string;
+    }[];
+    /** Fora da barra de blocos (tipos legados). */
+    hidden?: boolean;
+}
+export declare const FLOW_BLOCKS: Record<FlowNodeType, FlowBlockDef>;
+export declare const FLOW_BLOCK_GROUPS: {
+    id: FlowBlockGroupId;
+    name: string;
+    types: FlowNodeType[];
+}[];
+/** Nome do tipo de bloco, como aparece na interface. */
+export declare const FLOW_TYPE_NAME: Record<FlowNodeType, string>;
+/** Gatilho é todo bloco do grupo Gatilhos (inclui o legado `gatilho`). */
+export declare const isTrigger: (type: FlowNodeType) => boolean;
+export declare const FLOW_SYSTEM_FIELDS: {
+    value: string;
+    label: string;
+}[];
+/** O JSON de exemplo que "chega" no Receber webhook (simulado). */
+export declare const FLOW_SAMPLE_PAYLOAD: {
+    cliente: {
+        nome: string;
+        email: string;
+        telefone: string;
+        plano: string;
+    };
+    pedido: {
+        id: string;
+        valor: number;
+        criado_em: string;
+    };
+};
+/** Resposta de exemplo do Enviar webhook (simulado). */
+export declare const FLOW_SAMPLE_RESPONSE = "200 OK { \"id\": \"crm-88\" }";
+/** Achata o JSON em caminhos (`cliente.nome`) e valores em texto, na ordem de leitura. */
+export declare function flattenPayload(payload: unknown, prefix?: string): {
+    path: string;
+    value: string;
+}[];
+export interface FlowVariable {
+    /** O que vai entre chaves: `{{id}}`. */
+    id: string;
+    label: string;
+}
+export declare const asList: (v: unknown) => Record<string, unknown>[];
+/** Variáveis que os blocos podem usar: as do gatilho do fluxo (sem escopo por caminho). */
+export declare function flowVariables(flow: Flow): FlowVariable[];
+/** Valores de exemplo de cada variável do fluxo (usados no teste e na simulação). */
+export declare function flowSampleData(flow: Flow): Record<string, string>;
+export interface TemplatePart {
+    kind: 'text' | 'var';
+    value: string;
+}
+/** Parte o texto em trechos e variáveis `{{x}}` (as variáveis viram chips no card). */
+export declare function splitVariables(text: string): TemplatePart[];
+/** Troca cada `{{x}}` pelo valor de exemplo; variável sem valor fica como está. */
+export declare function renderTemplate(text: string, data: Record<string, string>): string;
+export declare const FLOW_RULE_OPERATORS: {
+    value: FlowRuleOperator;
+    label: string;
+    symbol: string;
+}[];
+/** Operadores que dispensam o valor. */
+export declare const operatorHasValue: (op: FlowRuleOperator) => op is "igual" | "diferente" | "maior" | "menor" | "contem";
+export declare const isRuleComplete: (rule: FlowRule) => boolean;
+/** "pedido.valor é maior que 500". */
+export declare function ruleSummary(rule: FlowRule): string;
+/** As regras do bloco condição (lista vazia se o config não as traz). */
+export declare function rulesOf(node: Pick<FlowNode, 'data'>): FlowRule[];
+/** Nome da saída: o rótulo da regra (ou "Regra N") e "Senão". */
+export declare function branchName(node: Pick<FlowNode, 'data'>, branch: string): string;
+/** Menor `rN` livre para uma regra nova. */
+export declare function nextRuleId(rules: {
+    id: string;
+}[]): string;
+/** Texto curto na ligação que sai de uma condição ("> 500", "= pro", "Senão"). */
+export declare function edgeLabel(flow: Flow, edge: FlowEdge): string | null;
+/** Saídas de um bloco: as regras e "Senão" na condição; uma só nos demais. */
+export declare function outputIds(node: Pick<FlowNode, 'type' | 'data'>): (string | undefined)[];
+export declare const RECORD_LABEL: Record<string, string>;
+/** O texto, ou vazio quando o valor não é texto. */
+export declare const str: (v: unknown) => string;
+/** Linhas "rótulo e valor" do resumo no card (variáveis `{{x}}` viram chips). */
+export declare function summarizeConfig(node: Pick<FlowNode, 'type' | 'data'>): {
+    label: string;
+    value: string;
+}[];
+/** Requisição simulada do Enviar webhook, com os valores de exemplo no corpo. */
+export declare function buildWebhookRequest(config: Record<string, unknown> | undefined, data: Record<string, string>): {
+    method: string;
+    url: string;
+    body: Record<string, string>;
+};
+/**
+ * Altura estimada do card em px (medida no navegador e arredondada para cima), usada enquanto o
+ * React Flow ainda não mediu o bloco: na arrumação automática e ao procurar espaço livre.
+ */
+export declare function estimateNodeHeight(node: Pick<FlowNode, 'type' | 'data'>): number;

package/dist/types/lib/flow-edit.d.ts

@@ -0,0 +1,88 @@
+import { type Flow, type FlowBranch, type FlowNode, type FlowNodeType } from './flow';
+export interface AddNodeOptions {
+    label?: string;
+    /** Ids que já existiram neste fluxo (mesmo apagados): não voltam a ser usados. */
+    reservedIds?: Iterable<string>;
+}
+/** Acrescenta um bloco com id único e determinístico (`tipo-N`) e a configuração padrão do tipo. */
+export declare function addNode(input: Flow, type: FlowNodeType, position: {
+    x: number;
+    y: number;
+}, options?: AddNodeOptions): {
+    flow: Flow;
+    id: string;
+};
+export type RemoveMode = 'so-este' | 'daqui-para-frente';
+/**
+ * Apaga o bloco. `so-este`: religa o anterior ao posterior quando o bloco tem uma entrada e uma
+ * saída e não é condição. `daqui-para-frente`: apaga também tudo o que só existe por causa dele.
+ */
+export declare function removeNode(input: Flow, id: string, mode?: RemoveMode): Flow;
+export declare function removeEdge(flow: Flow, id: string): Flow;
+/** Tira a ligação da saída `branch` de `source` (a única saída, nos blocos comuns). */
+export declare function clearOutput(flow: Flow, source: string, branch?: FlowBranch): Flow;
+export declare function moveNode(flow: Flow, id: string, position: {
+    x: number;
+    y: number;
+}): Flow;
+/** Troca o rótulo e/ou o config do bloco (o config informado substitui o anterior). */
+export declare function updateNodeData(flow: Flow, id: string, patch: {
+    label?: string;
+    config?: Record<string, unknown>;
+}): Flow;
+export type ConnectResult = {
+    ok: true;
+    flow: Flow;
+    replaced?: {
+        source: string;
+        target: string;
+        branch?: FlowBranch;
+    };
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * Liga dois blocos. A segunda ligação numa saída substitui a primeira e devolve a trocada em
+ * `replaced`, para o editor avisar. Recusa, com o motivo, o que o fluxo nunca aceita.
+ */
+export declare function connectNodes(flow: Flow, source: string, target: string, branch?: FlowBranch): ConnectResult;
+/** Blocos que `id` pode ter como próximo: nunca ele mesmo nem um gatilho. */
+export declare function nextCandidates(flow: Flow, id: string): FlowNode[];
+export interface NodeLinks {
+    anteriores: {
+        node: FlowNode;
+        saida?: string;
+    }[];
+    posteriores: {
+        node: FlowNode;
+        saida?: string;
+    }[];
+    /** Blocos que o modo `daqui-para-frente` apaga além do próprio. */
+    descendentes: number;
+}
+/** Onde o bloco está ligado: quem vem antes, quem vem depois e quantos cairiam junto. */
+export declare function describeNodeLinks(flow: Flow, id: string): NodeLinks;
+/**
+ * Primeira posição livre a partir de `from`: desce em passos de `FLOW_GAP_Y` e, se a coluna
+ * estiver cheia, passa à coluna da direita. Usa o tamanho medido dos blocos quando há, senão
+ * a estimativa. Determinística: o mesmo fluxo e o mesmo ponto dão sempre a mesma posição.
+ */
+export declare function findFreePosition(flow: Flow, size: {
+    w: number;
+    h: number;
+}, from: {
+    x: number;
+    y: number;
+}, measured?: Record<string, {
+    w: number;
+    h: number;
+}>): {
+    x: number;
+    y: number;
+};
+/** Aviso de troca: "A ligação anterior de "X" para "Y" foi trocada." */
+export declare function replacedMessage(flow: Flow, replaced: {
+    source: string;
+    target: string;
+}): string;

package/dist/types/lib/flow-layout.d.ts

@@ -0,0 +1,3 @@
+import type { Flow } from './flow';
+/** Camada de cada bloco (maior distância do início sem passar pelas ligações que fecham ciclo). */
+export declare function layoutFlow(flow: Flow): Flow;

package/dist/types/lib/flow-sim.d.ts

@@ -0,0 +1,24 @@
+import { type Flow, type FlowIssue, type FlowNodeType, type FlowRule } from './flow';
+export interface SimulationStep {
+    nodeId: string;
+    type: FlowNodeType;
+    label: string;
+    status: 'succeeded' | 'failed' | 'skipped';
+    detail?: string;
+}
+export interface SimulationState {
+    status: 'idle' | 'running' | 'finished' | 'error';
+    steps: SimulationStep[];
+    /** Bloco que o próximo avanço executa (o bloco ativo); `null` fora da simulação. */
+    currentId: string | null;
+    issues: FlowIssue[];
+}
+export declare function resetSimulation(): SimulationState;
+/** Começa no gatilho. Fluxo inválido não inicia: devolve `error` com os problemas. */
+export declare function startSimulation(input: Flow): SimulationState;
+/** Avalia uma regra contra os dados de exemplo; campo que não existe conta como vazio. */
+export declare function evaluateRule(rule: FlowRule, data: Record<string, string>): boolean;
+/** Roda só um bloco, com os mesmos dados de exemplo, e devolve o passo (o play do card). */
+export declare function simulateBlock(input: Flow, nodeId: string): SimulationStep | null;
+/** Executa o bloco ativo (um passo) e passa ao próximo. A condição escolhe sozinha a saída. */
+export declare function advanceSimulation(input: Flow, state: SimulationState): SimulationState;

package/dist/types/lib/flow.d.ts

@@ -1,6 +1,16 @@
-export type FlowNodeType = 'gatilho' | 'acao' | 'condicao' | 'espera' | 'fim';
-export type FlowBranch = 'sim' | 'nao';
+export type FlowNodeType = 'webhook-entrada' | 'agendamento' | 'registro-criado' | 'whatsapp' | 'email' | 'condicao' | 'espera' | 'webhook-saida' | 'tarefa' | 'gatilho' | 'acao' | 'fim';
+/** Id da regra da condição, ou `'senao'`. */
+export type FlowBranch = string;
 export type FlowWaitUnit = 'segundos' | 'minutos' | 'horas' | 'dias';
+export type FlowRuleOperator = 'igual' | 'diferente' | 'maior' | 'menor' | 'contem' | 'vazio' | 'nao-vazio';
+export interface FlowRule {
+    id: string;
+    label?: string;
+    field: string;
+    operator: FlowRuleOperator;
+    /** Vazio nos operadores `vazio` e `nao-vazio`. */
+    value: string;
+}
 export interface FlowNode {
     id: string;
     type: FlowNodeType;
@@ -17,10 +27,12 @@ export interface FlowEdge {
     id: string;
     source: string;
     target: string;
-    /** Só a saída de uma condição usa o ramo. */
+    /** Só a saída de uma condição usa o ramo: o id da regra ou `senao`. */
     branch?: FlowBranch;
 }
 export interface Flow {
+    /** Ausente = formato da 2.7.0 (convertido ao ler). */
+    version?: 2;
     nodes: FlowNode[];
     edges: FlowEdge[];
 }
@@ -30,34 +42,21 @@ export interface FlowIssue {
     nodeId?: string;
     edgeId?: string;
 }
-export interface SimulationStep {
-    nodeId: string;
-    type: FlowNodeType;
-    label: string;
-    status: 'succeeded' | 'failed' | 'skipped';
-    detail?: string;
-}
-export interface SimulationState {
-    status: 'idle' | 'running' | 'waiting-choice' | 'finished' | 'error';
-    steps: SimulationStep[];
-    /** Bloco que o próximo avanço executa (o bloco ativo); `null` fora da simulação. */
-    currentId: string | null;
-    issues: FlowIssue[];
-}
-export declare const FLOW_NODE_TYPES: readonly FlowNodeType[];
-export declare const FLOW_WAIT_UNITS: readonly FlowWaitUnit[];
-/** Nome do tipo de bloco, como aparece na interface. */
-export declare const FLOW_TYPE_NAME: Record<FlowNodeType, string>;
-/** A duração do bloco de espera ("5 minutos"), ou `null` se o config não a define. */
-export declare function formatWait(config: Record<string, unknown> | undefined): string | null;
-/** Texto da espera simulada: nunca espera de verdade. */
-export declare function describeWait(config: Record<string, unknown> | undefined): string;
 /** Nome do bloco para mensagens e rótulos: o rótulo, ou o tipo quando ele está vazio. */
 export declare const nodeName: (n: Pick<FlowNode, "type" | "data">) => string;
+/**
+ * Leva um fluxo da 2.7.0 (sem `version`) ao formato v2: tira os blocos Fim, a condição vira uma
+ * regra "Sim" mais "Senão", e os blocos são arrumados da esquerda para a direita. Quem já é v2
+ * volta igual.
+ */
+export declare function migrateFlow(flow: Flow): Flow;
 /** Problemas do fluxo, em ordem estável: a mesma entrada dá sempre a mesma lista. */
-export declare function validateFlow(flow: Flow): FlowIssue[];
-/** JSON do fluxo, com a ordem das chaves fixa: o mesmo fluxo dá sempre o mesmo texto. */
-export declare function serializeFlow(flow: Flow): string;
+export declare function validateFlow(input: Flow): FlowIssue[];
+/**
+ * JSON do fluxo (sempre no formato v2, com `version` na primeira chave) e a ordem das chaves
+ * fixa: o mesmo fluxo dá sempre o mesmo texto. Um fluxo da 2.7.0 é convertido antes.
+ */
+export declare function serializeFlow(input: Flow): string;
 export type ParseResult = {
     ok: true;
     flow: Flow;
@@ -65,57 +64,8 @@ export type ParseResult = {
     ok: false;
     errors: string[];
 };
-/** Lê o JSON de um fluxo. Nunca lança; campos que o contrato não conhece são ignorados. */
-export declare function parseFlow(text: string): ParseResult;
-export interface AddNodeOptions {
-    label?: string;
-    /** Ids que já existiram neste fluxo (mesmo apagados): não voltam a ser usados. */
-    reservedIds?: Iterable<string>;
-}
-/** Acrescenta um bloco com id único e determinístico (`tipo-N`). */
-export declare function addNode(flow: Flow, type: FlowNodeType, position: {
-    x: number;
-    y: number;
-}, options?: AddNodeOptions): {
-    flow: Flow;
-    id: string;
-};
-/** Apaga o bloco e as ligações que chegam ou saem dele. */
-export declare function removeNode(flow: Flow, id: string): Flow;
-export declare function removeEdge(flow: Flow, id: string): Flow;
-export declare function moveNode(flow: Flow, id: string, position: {
-    x: number;
-    y: number;
-}): Flow;
-/** Troca o rótulo e/ou o config do bloco (o config informado substitui o anterior). */
-export declare function updateNodeData(flow: Flow, id: string, patch: {
-    label?: string;
-    config?: Record<string, unknown>;
-}): Flow;
-export type ConnectResult = {
-    ok: true;
-    flow: Flow;
-} | {
-    ok: false;
-    reason: string;
-};
-/**
- * Liga dois blocos. A segunda saída de um bloco comum (ou do mesmo ramo da condição) substitui
- * a primeira. Recusa, com o motivo, o que o fluxo nunca aceita.
- */
-export declare function connectNodes(flow: Flow, source: string, target: string, branch?: FlowBranch): ConnectResult;
 /**
- * Define (ou, com `target` nulo, tira) o próximo bloco de `id`; na condição, o do ramo dado.
- * Uma ligação recusada devolve o próprio fluxo, sem mudança.
+ * Lê o JSON de um fluxo. Nunca lança; campos que o contrato não conhece são ignorados. Texto sem
+ * `version` é lido pelas regras da 2.7.0 e convertido; `version: 2` segue as regras do formato novo.
  */
-export declare function setNext(flow: Flow, id: string, target: string | null, branch?: FlowBranch): Flow;
-/** Blocos que `id` pode ter como próximo: nunca ele mesmo nem o gatilho. */
-export declare function nextCandidates(flow: Flow, id: string): FlowNode[];
-export declare function resetSimulation(): SimulationState;
-/** Começa no gatilho. Fluxo inválido não inicia: devolve `error` com os problemas. */
-export declare function startSimulation(flow: Flow): SimulationState;
-/**
- * Executa o bloco ativo (um passo) e passa ao próximo. Na condição é preciso escolher o ramo:
- * sem escolha válida nada anda. A espera é instantânea; só o texto diz quanto aguardaria.
- */
-export declare function advanceSimulation(flow: Flow, state: SimulationState, choice?: FlowBranch): SimulationState;
+export declare function parseFlow(text: string): ParseResult;

package/dist/{use-breakpoint-En17oXKY.js → use-breakpoint-BGmY3ir-.js}

@@ -1,4 +1,4 @@
-/*! Rendra Design System v2.7.0 | MIT | © 2026 Bruno Magalhaes | brunomagalhaes.me */
+/*! Rendra Design System v2.9.0 | MIT | © 2026 Bruno Magalhaes | brunomagalhaes.me */
 import { useSyncExternalStore } from "react";
 //#region src/hooks/use-breakpoint.ts
 /**
@@ -46,4 +46,4 @@ function useBreakpoint() {
 //#endregion
 export { useBreakpoint as n, breakpoints as t };
 
-//# sourceMappingURL=use-breakpoint-En17oXKY.js.map
+//# sourceMappingURL=use-breakpoint-BGmY3ir-.js.map

package/dist/{use-breakpoint-En17oXKY.js.map → use-breakpoint-BGmY3ir-.js.map}

@@ -1 +1 @@
-{"version":3,"file":"use-breakpoint-En17oXKY.js","names":[],"sources":["../src/hooks/use-breakpoint.ts"],"sourcesContent":["import { useSyncExternalStore } from 'react'\n\n/**\n * Pontos de quebra, espelhando os padrões do Tailwind (sm 40rem, md 48rem, lg 64rem...).\n * Único hook de detecção de tela do sistema. Para adaptação ao espaço disponível\n * dentro de um bloco (e não à tela), use container queries (@container) no CSS.\n */\nexport const breakpoints = { sm: 640, md: 768, lg: 1024, xl: 1280, '2xl': 1536 } as const\nexport type Breakpoint = keyof typeof breakpoints\n\nconst order: Breakpoint[] = ['sm', 'md', 'lg', 'xl', '2xl']\n\nfunction subscribe(cb: () => void) {\n  const lists = order.map((bp) => matchMedia(`(min-width: ${breakpoints[bp]}px)`))\n  lists.forEach((mq) => mq.addEventListener('change', cb))\n  return () => lists.forEach((mq) => mq.removeEventListener('change', cb))\n}\n\nfunction getCurrent(): Breakpoint | 'base' {\n  let current: Breakpoint | 'base' = 'base'\n  for (const bp of order) if (matchMedia(`(min-width: ${breakpoints[bp]}px)`).matches) current = bp\n  return current\n}\n\nexport function useBreakpoint() {\n  const current = useSyncExternalStore(subscribe, getCurrent, () => 'lg' as const)\n  const rank = current === 'base' ? -1 : order.indexOf(current)\n  const up = (bp: Breakpoint) => rank >= order.indexOf(bp)\n  return {\n    current,\n    up,\n    /** Abaixo de 768px: componentes se reconstroem no formato mobile. */\n    isMobile: !up('md'),\n    isTablet: up('md') && !up('lg'),\n    isDesktop: up('lg'),\n  }\n}\n"],"mappings":";;;;;;;;AAOA,IAAa,cAAc;CAAE,IAAI;CAAK,IAAI;CAAK,IAAI;CAAM,IAAI;CAAM,OAAO;AAAK;AAG/E,IAAM,QAAsB;CAAC;CAAM;CAAM;CAAM;CAAM;AAAK;AAE1D,SAAS,UAAU,IAAgB;CACjC,MAAM,QAAQ,MAAM,KAAK,OAAO,WAAW,eAAe,YAAY,IAAI,IAAI,CAAC;CAC/E,MAAM,SAAS,OAAO,GAAG,iBAAiB,UAAU,EAAE,CAAC;CACvD,aAAa,MAAM,SAAS,OAAO,GAAG,oBAAoB,UAAU,EAAE,CAAC;AACzE;AAEA,SAAS,aAAkC;CACzC,IAAI,UAA+B;CACnC,KAAK,MAAM,MAAM,OAAO,IAAI,WAAW,eAAe,YAAY,IAAI,IAAI,CAAC,CAAC,SAAS,UAAU;CAC/F,OAAO;AACT;AAEA,SAAgB,gBAAgB;CAC9B,MAAM,UAAU,qBAAqB,WAAW,kBAAkB,IAAa;CAC/E,MAAM,OAAO,YAAY,SAAS,KAAK,MAAM,QAAQ,OAAO;CAC5D,MAAM,MAAM,OAAmB,QAAQ,MAAM,QAAQ,EAAE;CACvD,OAAO;EACL;EACA;;EAEA,UAAU,CAAC,GAAG,IAAI;EAClB,UAAU,GAAG,IAAI,KAAK,CAAC,GAAG,IAAI;EAC9B,WAAW,GAAG,IAAI;CACpB;AACF"}
+{"version":3,"file":"use-breakpoint-BGmY3ir-.js","names":[],"sources":["../src/hooks/use-breakpoint.ts"],"sourcesContent":["import { useSyncExternalStore } from 'react'\n\n/**\n * Pontos de quebra, espelhando os padrões do Tailwind (sm 40rem, md 48rem, lg 64rem...).\n * Único hook de detecção de tela do sistema. Para adaptação ao espaço disponível\n * dentro de um bloco (e não à tela), use container queries (@container) no CSS.\n */\nexport const breakpoints = { sm: 640, md: 768, lg: 1024, xl: 1280, '2xl': 1536 } as const\nexport type Breakpoint = keyof typeof breakpoints\n\nconst order: Breakpoint[] = ['sm', 'md', 'lg', 'xl', '2xl']\n\nfunction subscribe(cb: () => void) {\n  const lists = order.map((bp) => matchMedia(`(min-width: ${breakpoints[bp]}px)`))\n  lists.forEach((mq) => mq.addEventListener('change', cb))\n  return () => lists.forEach((mq) => mq.removeEventListener('change', cb))\n}\n\nfunction getCurrent(): Breakpoint | 'base' {\n  let current: Breakpoint | 'base' = 'base'\n  for (const bp of order) if (matchMedia(`(min-width: ${breakpoints[bp]}px)`).matches) current = bp\n  return current\n}\n\nexport function useBreakpoint() {\n  const current = useSyncExternalStore(subscribe, getCurrent, () => 'lg' as const)\n  const rank = current === 'base' ? -1 : order.indexOf(current)\n  const up = (bp: Breakpoint) => rank >= order.indexOf(bp)\n  return {\n    current,\n    up,\n    /** Abaixo de 768px: componentes se reconstroem no formato mobile. */\n    isMobile: !up('md'),\n    isTablet: up('md') && !up('lg'),\n    isDesktop: up('lg'),\n  }\n}\n"],"mappings":";;;;;;;;AAOA,IAAa,cAAc;CAAE,IAAI;CAAK,IAAI;CAAK,IAAI;CAAM,IAAI;CAAM,OAAO;AAAK;AAG/E,IAAM,QAAsB;CAAC;CAAM;CAAM;CAAM;CAAM;AAAK;AAE1D,SAAS,UAAU,IAAgB;CACjC,MAAM,QAAQ,MAAM,KAAK,OAAO,WAAW,eAAe,YAAY,IAAI,IAAI,CAAC;CAC/E,MAAM,SAAS,OAAO,GAAG,iBAAiB,UAAU,EAAE,CAAC;CACvD,aAAa,MAAM,SAAS,OAAO,GAAG,oBAAoB,UAAU,EAAE,CAAC;AACzE;AAEA,SAAS,aAAkC;CACzC,IAAI,UAA+B;CACnC,KAAK,MAAM,MAAM,OAAO,IAAI,WAAW,eAAe,YAAY,IAAI,IAAI,CAAC,CAAC,SAAS,UAAU;CAC/F,OAAO;AACT;AAEA,SAAgB,gBAAgB;CAC9B,MAAM,UAAU,qBAAqB,WAAW,kBAAkB,IAAa;CAC/E,MAAM,OAAO,YAAY,SAAS,KAAK,MAAM,QAAQ,OAAO;CAC5D,MAAM,MAAM,OAAmB,QAAQ,MAAM,QAAQ,EAAE;CACvD,OAAO;EACL;EACA;;EAEA,UAAU,CAAC,GAAG,IAAI;EAClB,UAAU,GAAG,IAAI,KAAK,CAAC,GAAG,IAAI;EAC9B,WAAW,GAAG,IAAI;CACpB;AACF"}

package/dist/{use-motion-presets-D3ww1oJX.js → use-motion-presets-CmMLBQLI.js}

@@ -1,5 +1,5 @@
-/*! Rendra Design System v2.7.0 | MIT | © 2026 Bruno Magalhaes | brunomagalhaes.me */
-import { a as useMotionMode, c as getReducedMotion, l as subscribeReducedMotion } from "./motion-context-BUMPf0e9.js";
+/*! Rendra Design System v2.9.0 | MIT | © 2026 Bruno Magalhaes | brunomagalhaes.me */
+import { a as useMotionMode, c as getReducedMotion, l as subscribeReducedMotion } from "./motion-context-DWFl2xRr.js";
 import { useMemo, useSyncExternalStore } from "react";
 //#region src/lib/motion/tokens.ts
 /**
@@ -398,4 +398,4 @@ function useMotionPresets() {
 //#endregion
 export { toCubicBezier as n, useMotionPresets as t };
 
-//# sourceMappingURL=use-motion-presets-D3ww1oJX.js.map
+//# sourceMappingURL=use-motion-presets-CmMLBQLI.js.map