pixelon 0.3.31 → 0.3.74

package/dist/components/molecules/chat/StructuredContent/components/ReactiveCrud/types.d.ts

@@ -0,0 +1,148 @@
+import type { FieldValidation } from '../ReactiveForm/types';
+import type { FilterFieldConfig, FilterManager } from '../../../../lumi/Filter/types';
+export type CrudMolecule = 'INPUT' | 'INPUT_NUMBER' | 'INPUT_CURRENCY' | 'TEXTAREA' | 'SELECT' | 'DATE_INPUT' | 'TIME_INPUT' | 'CHECKBOX' | 'BADGE' | 'FILE'
+/** SPEC-023 — ubicación: un campo con dos vías (mi ubicación / buscar dirección) que produce
+ *  dirección + coordenadas. Requiere `bind` para saber a qué claves van los tres valores. */
+ | 'LOCATION'
+/** SPEC-011 — columna que abre la conversación: el valor de la celda es el chatId; al click
+ *  emite OPEN_CHAT. Vacío → sin botón. Solo tabla (showInForm:false). */
+ | 'CHAT_LINK';
+/** Endpoint de escritura/lectura. `payloadMap` resuelve `$campo` contra el contexto. */
+export interface EndpointRef {
+    service: string;
+    url: string;
+    method: string;
+    payloadMap?: Record<string, string>;
+    /** SPEC-002: si apunta a un campo array (`$photos`), ejecuta el endpoint UNA vez por elemento;
+     * en el payloadMap, `$item` es el elemento actual (ej. inspección con N fotos). */
+    forEach?: string;
+}
+/** Carga de opciones para un SELECT (mismo patrón que reactive_form). */
+export interface CrudFieldOptionsEndpoint {
+    service: string;
+    url: string;
+    method: string;
+    value_field: string;
+    label_field: string;
+    response_path?: string;
+    /** SPEC-002: body de la request (ej. { all_data: true } para listas paginadas). */
+    body?: Record<string, unknown>;
+}
+export interface ReactiveCrudField {
+    name: string;
+    label: string;
+    moleculeType: CrudMolecule;
+    /** SPEC-023 — solo para LOCATION: a qué claves del payload van los tres valores del campo.
+     *  Un campo produce tres datos, así que el consumidor declara su destino en vez de que el
+     *  componente invente convenciones por sufijo. */
+    bind?: {
+        address: string;
+        lat: string;
+        lng: string;
+        source?: string;
+    };
+    showInTable?: boolean;
+    showInForm?: boolean;
+    showInModes?: Array<'create' | 'edit' | 'view'>;
+    required?: boolean;
+    placeholder?: string;
+    options?: Array<{
+        value: string;
+        label: string;
+        color?: string;
+    }>;
+    optionsEndpoint?: CrudFieldOptionsEndpoint;
+    validation?: FieldValidation;
+    /** Clave del registro de formatters (§8) — NO función inline. */
+    format?: string;
+    /** Ancho de columna. `number` = fracción flex si la columna NO es fija (ej. 2 = 2 partes);
+     *  con `fixed` un número se toma como px. `string` = valor CSS exacto (ej. '150px', '20%'). */
+    columnWidth?: number | string;
+    /** SPEC-006 — muestra un botón de copiar junto al valor en el detalle "Ver" (solo si hay dato). */
+    copyable?: boolean;
+    /** Fija la columna al hacer scroll horizontal (sticky). Requiere `columnWidth` y
+     *  `tableScroll.x` en el config. Típico: la 1ª columna con `fixed: 'left'`. */
+    fixed?: 'left' | 'right';
+    align?: 'left' | 'center' | 'right';
+    /** SPEC-002 (solo FILE): filtro del picker, ej. 'image/*' | 'video/*' | 'application/pdf'. */
+    accept?: string;
+    /** SPEC-002 (solo FILE): tipo para el media/file-manager: 'image'|'video'|'file'|'audio'. */
+    fileType?: string;
+    /** SPEC-002 (solo FILE): permite seleccionar y subir varios archivos; el valor es un array de ids. */
+    multiple?: boolean;
+    /** SPEC-012 (solo CHAT_LINK): abre VARIOS chats desde distintos campos de la fila (role-aware).
+     * Renderiza un botón por fuente con valor. Si se omite, usa el `name` (un solo chat). */
+    chats?: Array<{
+        field: string;
+        label?: string;
+    }>;
+}
+/** Visibilidad de una acción según el valor de un campo de la fila (dato, no función). */
+export interface RowActionVisibleWhen {
+    field: string;
+    in: string[];
+}
+export interface RowActionDef {
+    key: string;
+    label: string;
+    icon?: string;
+    intent?: 'primary' | 'secondary' | 'danger';
+    visibleWhen?: RowActionVisibleWhen;
+    /** SPEC-007: la acción se muestra pero queda DESHABILITADA cuando `String(row[field])` está en
+     * `in` (ej. "Iniciar" deshabilitado hasta que `has_inspection` sea true). */
+    disabledWhen?: RowActionVisibleWhen;
+    /** SPEC-007: tooltip cuando la acción está deshabilitada (ej. "Registra la inspección primero"). */
+    disabledReason?: string;
+    /** SPEC-007: muestra un ✓ al final cuando `String(row[field])` está en `in` (ej. inspección ya
+     * registrada). Indicador de "hecho"; no bloquea reejecutar la acción. */
+    doneWhen?: RowActionVisibleWhen;
+    endpoint: EndpointRef;
+    /** SPEC-002: varias llamadas en orden (ej. inspección = register-inspection foto + video). Si
+     * se define, tiene prioridad sobre `endpoint`; todos comparten el mismo contexto del form. */
+    endpoints?: EndpointRef[];
+    /** Sub-form declarativo para acciones con input (asignar→grúa, completar→precio). SPEC-001 T2. */
+    form?: {
+        fields: ReactiveCrudField[];
+        payloadMap?: Record<string, string>;
+    };
+}
+/** Vista de detalle ("Ver"): campos read-only + galería de archivos (fotos/videos/docs). */
+export interface ReactiveCrudDetail {
+    /** Endpoint que devuelve el detalle agregado; recibe { service_id: <idField> }. */
+    get: EndpointRef;
+    /** Ruta al array de documentos dentro de la respuesta (default 'documents'). */
+    documentsPath?: string;
+    /** Campo del documento con el id del archivo en el media store (default 'media_file_id'). */
+    mediaIdField?: string;
+    /** Cómo resolver la URL del archivo: GET a `urlPath` con `{id}` reemplazado → { url }. */
+    media?: {
+        service: string;
+        urlPath: string;
+    };
+    /** Campo de la fila para el título del drawer (ej. 'service_number'). */
+    titleField?: string;
+}
+export interface ReactiveCrudConfig {
+    title?: string;
+    /** Campo id de la fila (getRowKey de LumiCrud es obligatorio). */
+    idField: string;
+    fields: ReactiveCrudField[];
+    data: {
+        list: EndpointRef;
+        create?: EndpointRef;
+        get?: EndpointRef;
+    };
+    /** Vista "Ver" con campos + galería de archivos. */
+    detail?: ReactiveCrudDetail;
+    rowActions?: RowActionDef[];
+    filters?: FilterFieldConfig[];
+    pageSize?: number;
+    labels?: Record<string, string>;
+    /** Scroll de la tabla. `x` habilita el scroll horizontal responsive + columnas `fixed`.
+     *  Ej: `{ x: 1100 }` — bajo ese ancho aparece scroll y la 1ª columna queda fija. */
+    tableScroll?: {
+        x?: number | string;
+        y?: number | string;
+    };
+}
+export type { FilterManager };

package/dist/components/molecules/chat/StructuredContent/components/ReactiveCrud/useReactiveCrud.d.ts

@@ -0,0 +1,19 @@
+import { type ChatEventBus } from '../../../../../../core/eventBus/chatEventBus';
+import type { EndpointRef, ReactiveCrudConfig, FilterManager } from './types';
+export declare function useReactiveCrud(config: ReactiveCrudConfig, eventBus?: ChatEventBus): {
+    rows: Record<string, unknown>[];
+    total: number;
+    loading: boolean;
+    error: string | null;
+    actionError: string | null;
+    clearActionError: () => void;
+    skip: number;
+    pageSize: number;
+    filters: FilterManager[];
+    setSkip: import("react").Dispatch<import("react").SetStateAction<number>>;
+    setFilters: import("react").Dispatch<import("react").SetStateAction<FilterManager[]>>;
+    reload: () => Promise<void>;
+    create: (values: Record<string, unknown>) => Promise<void>;
+    runEndpoint: (ep: EndpointRef, ctx: Record<string, unknown>) => Promise<void>;
+    runEndpoints: (eps: EndpointRef[], ctx: Record<string, unknown>) => Promise<void>;
+};

package/dist/components/molecules/chat/StructuredContent/components/ReactiveMap/ReactiveMap.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import type { ChatEventBus } from '../../../../../../core/eventBus/chatEventBus';
+import type { ReactiveMapConfig } from './types';
+export interface ReactiveMapProps {
+    config: ReactiveMapConfig;
+    eventBus?: ChatEventBus;
+    apiKey?: string;
+    /** Filtro que llega desde el LLM (ej. un número de servicio o un estado). */
+    filter?: Record<string, unknown>;
+}
+export declare const ReactiveMap: React.FC<ReactiveMapProps>;
+export default ReactiveMap;

package/dist/components/molecules/chat/StructuredContent/components/ReactiveMap/ReactiveMapChat.d.ts

@@ -0,0 +1,3 @@
+import type { ChatComponentProps } from '../../helpers/types';
+export declare function ReactiveMapChat({ component, eventBus }: ChatComponentProps): import("react/jsx-runtime").JSX.Element | null;
+export default ReactiveMapChat;

package/dist/components/molecules/chat/StructuredContent/components/ReactiveMap/types.d.ts

@@ -0,0 +1,36 @@
+import type { EndpointRef } from '../ReactiveCrud/types';
+export interface ReactiveMapMapping {
+    /** Campo de la fila que identifica el registro. */
+    id: string;
+    lat: string;
+    lng: string;
+    /** Campo para la etiqueta del marcador (ej. el número de servicio). */
+    label?: string;
+    /** Campo del que sale el icono; si no, se usa `defaultIcon`. */
+    icon?: string;
+}
+export interface ReactiveMapConfig {
+    title?: string;
+    /** De dónde salen las filas. Se pide por el chatEventBus, como en ReactiveCrud. */
+    data: {
+        list: EndpointRef;
+    };
+    mapping: ReactiveMapMapping;
+    /** Icono para todos los puntos cuando la fila no trae uno. */
+    defaultIcon?: string;
+    /** Color por valor de un campo (mismo espíritu que la columna BADGE del crud). */
+    colorBy?: {
+        field: string;
+        map: Record<string, string>;
+        fallback?: string;
+    };
+    /** Endpoint del trayecto de UN registro. Sin esto, no se ofrecen rutas. */
+    route?: EndpointRef;
+    height?: number;
+    labels?: {
+        emptyText?: string;
+        /** Aviso de las filas que no se pudieron ubicar. `{n}` se reemplaza por el número. */
+        missingText?: string;
+        loadingText?: string;
+    };
+}

package/dist/components/molecules/chat/StructuredContent/components/ServiceShortcuts/ServiceShortcuts.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+import { type ChatEventBus } from '../../../../../../core/eventBus/chatEventBus';
+export interface ServiceShortcut {
+    id: string;
+    label: string;
+    hint?: string;
+    /** A dónde llevar. Alternativa a `prompt`. */
+    route?: string;
+    prompt?: string;
+    icon?: 'map' | 'list' | 'tow' | 'search' | 'user';
+}
+export interface ServiceShortcutsProps {
+    options: ServiceShortcut[];
+    eventBus?: ChatEventBus;
+    /** SPEC-052 — id ya elegido: apaga el grupo entero y marca cuál fue. */
+    selectedId?: string;
+    /** SPEC-052 — avisa al host para que persista la elección. */
+    onSelect?: (id: string) => void;
+}
+export declare const ServiceShortcuts: React.FC<ServiceShortcutsProps>;
+export default ServiceShortcuts;

package/dist/components/molecules/chat/StructuredContent/components/ServiceShortcuts/ServiceShortcutsChat.d.ts

@@ -0,0 +1,3 @@
+import type { ChatComponentProps } from '../../helpers/types';
+export declare function ServiceShortcutsChat({ component, eventBus, assistantMessageId }: ChatComponentProps): import("react/jsx-runtime").JSX.Element;
+export default ServiceShortcutsChat;

package/dist/components/molecules/chat/StructuredContent/components/ServicesMap/ServicesMap.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import type { ChatEventBus } from '../../../../../../core/eventBus/chatEventBus';
+import type { ServicesMapConfig } from './types';
+export interface ServicesMapProps {
+    config: ServicesMapConfig;
+    eventBus?: ChatEventBus;
+    apiKey?: string;
+    /** Filtro que llega desde el LLM (ej. un número de servicio o un estado). */
+    filter?: Record<string, unknown>;
+    /** En una ruta dedicada el mapa llena el contenedor; en el chat va acotado. */
+    fill?: boolean;
+}
+export declare const ServicesMap: React.FC<ServicesMapProps>;
+export default ServicesMap;

package/dist/components/molecules/chat/StructuredContent/components/ServicesMap/ServicesMapChat.d.ts

@@ -0,0 +1,3 @@
+import type { ChatComponentProps } from '../../helpers/types';
+export declare function ServicesMapChat({ component, eventBus }: ChatComponentProps): import("react/jsx-runtime").JSX.Element | null;
+export default ServicesMapChat;

package/dist/components/molecules/chat/StructuredContent/components/ServicesMap/outliers.d.ts

@@ -0,0 +1,14 @@
+import type { MapPoint } from '../MapView/types';
+/** Radio, en kilómetros, dentro del cual un punto se considera parte del grupo. */
+export declare const FIT_RADIUS_KM = 60;
+export interface EncuadreResult {
+    /** Los mismos puntos, con `fit: false` en los que quedan fuera del ajuste. */
+    points: MapPoint[];
+    /** Cuántos quedaron fuera. Sirve para decirlo, que es la otra mitad de apartarlos. */
+    outside: number;
+}
+/**
+ * Marca como no-encuadrables los puntos que se alejan del grupo.
+ * Con menos de `MIN_POINTS` no toca nada: dos puntos lejanos son un trayecto, no un error.
+ */
+export declare function markFitOutliers(points: MapPoint[], radiusKm?: number): EncuadreResult;

package/dist/components/molecules/chat/StructuredContent/components/ServicesMap/types.d.ts

@@ -0,0 +1,54 @@
+import type { EndpointRef } from '../ReactiveCrud/types';
+export interface ServicesMapMapping {
+    /** Campo de la fila que identifica el registro. */
+    id: string;
+    lat: string;
+    lng: string;
+    /** Campo para la etiqueta del marcador (ej. el número de servicio). */
+    label?: string;
+    /** Campo del que sale el icono; si no, se usa `defaultIcon`. */
+    icon?: string;
+}
+export interface ServicesMapConfig {
+    title?: string;
+    /** De dónde salen las filas. Se pide por el chatEventBus, como en ReactiveCrud. */
+    data: {
+        list: EndpointRef;
+    };
+    mapping: ServicesMapMapping;
+    /** Icono para todos los puntos cuando la fila no trae uno. */
+    defaultIcon?: string;
+    /** Color por valor de un campo (mismo espíritu que la columna BADGE del crud). */
+    colorBy?: {
+        field: string;
+        map: Record<string, string>;
+        fallback?: string;
+    };
+    /** Endpoint del trayecto de UN registro. Sin esto, no se ofrecen rutas. */
+    route?: EndpointRef;
+    /** SPEC-025 — capa de grúas en movimiento. Sin esto, el mapa es solo de puntos fijos.
+     *  Las posiciones NO se piden acá: las publica el host en el bus (`FLEET_POSITIONS`) tras
+     *  abrir el WS, igual que las conversaciones. El componente nunca abre sockets. */
+    live?: {
+        /** Icono de la grúa en movimiento. */
+        icon?: string;
+        color?: string;
+        /** Color de una posición SIMULADA, para que no se confunda con una real (R5). */
+        simulatedColor?: string;
+        /** Milisegundos del desplazamiento entre dos reportes (R7). */
+        animateMs?: number;
+        labels?: {
+            /** `{n}` se reemplaza por el número de grúas en movimiento. */
+            liveText?: string;
+            simulatedText?: string;
+        };
+    };
+    height?: number;
+    labels?: {
+        emptyText?: string;
+        /** Aviso de las filas que no se pudieron ubicar. `{n}` se reemplaza por el número. */
+        missingText?: string;
+        outsideText?: string;
+        loadingText?: string;
+    };
+}

package/dist/components/molecules/chat/StructuredContent/components/UserTools/UserTools.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { UserToolsConfig } from './types';
+export interface UserToolsProps {
+    config: UserToolsConfig;
+    /** (id, nuevoValor). El host decide qué hacer y dónde guardarlo. */
+    onChange?: (id: string, value: boolean) => void;
+    className?: string;
+}
+export declare const UserTools: React.FC<UserToolsProps>;
+export default UserTools;

package/dist/components/molecules/chat/StructuredContent/components/UserTools/UserToolsChat.d.ts

@@ -0,0 +1,3 @@
+import type { ChatComponentProps } from '../../helpers/types';
+export declare function UserToolsChat({ component, eventBus }: ChatComponentProps): import("react/jsx-runtime").JSX.Element | null;
+export default UserToolsChat;

package/dist/components/molecules/chat/StructuredContent/components/UserTools/types.d.ts

@@ -0,0 +1,17 @@
+export type UserToolKind = 'toggle';
+export interface UserToolItem {
+    id: string;
+    label: string;
+    /** Qué implica activarlo. Una línea. */
+    hint?: string;
+    kind: UserToolKind;
+    /** Estado actual. Lo pone quien resuelve la config: el componente no lee almacenamiento. */
+    value: boolean;
+    disabled?: boolean;
+}
+export interface UserToolsConfig {
+    title?: string;
+    /** Frase de contexto bajo el título. */
+    description?: string;
+    items: UserToolItem[];
+}

package/dist/components/molecules/chat/StructuredContent/components/index.d.ts

@@ -10,3 +10,24 @@ export { TimeInputWithConfirm } from './TimeInputWithConfirm/TimeInputWithConfir
 export { ReactiveForm } from './ReactiveForm/ReactiveForm';
 export { CarouselDisplay } from './CarouselDisplay/CarouselDisplay';
 export { ActionMenu } from './ActionMenu/ActionMenu';
+export { ReactiveCrud } from './ReactiveCrud/ReactiveCrud';
+export { ReactiveCrudChat } from './ReactiveCrud/ReactiveCrudChat';
+export { ReactiveCrudItemChat } from './ReactiveCrud/ReactiveCrudItemChat';
+export { PriceNegotiationChat } from './ReactiveCrud/PriceNegotiationChat';
+export { MapView } from './MapView/MapView';
+export { MapViewChat } from './MapView/MapViewChat';
+export type { MapPoint, MapViewProps, MapViewLabels } from './MapView/types';
+export { LocationField } from './LocationField/LocationField';
+export type { LocationValue, LocationSource, LocationFieldProps } from './LocationField/types';
+export { ServicesMap } from './ServicesMap/ServicesMap';
+export { ServicesMapChat } from './ServicesMap/ServicesMapChat';
+export type { ServicesMapConfig } from './ServicesMap/types';
+export { ServiceShortcuts } from './ServiceShortcuts/ServiceShortcuts';
+export { ServiceShortcutsChat } from './ServiceShortcuts/ServiceShortcutsChat';
+export { ChatNavigator } from './ChatNavigator/ChatNavigator';
+export { ChatNavigatorChat } from './ChatNavigator/ChatNavigatorChat';
+export type { ChatNavigatorConfig, ChatNavigatorItem, ChatNavigatorEndpoint } from './ChatNavigator/types';
+export { UserTools } from './UserTools/UserTools';
+export { UserToolsChat } from './UserTools/UserToolsChat';
+export type { UserToolsConfig, UserToolItem } from './UserTools/types';
+export type { ReactiveCrudConfig, ReactiveCrudField, RowActionDef, EndpointRef, } from './ReactiveCrud/types';

package/dist/components/molecules/chat/StructuredContent/helpers/types.d.ts

@@ -30,3 +30,5 @@ export type OnConfirm = (value: unknown, label: string) => void;
 export declare function getSubmitActionId(component: UIComponentData): string | undefined;
 export declare const TERMINAL_STATUS: Set<string>;
 export declare const DISPLAY_COMPONENTS: Set<string>;
+export declare const PERSISTENT_COMPONENTS: Set<string>;
+export declare const PURE_DISPLAY_COMPONENTS: Set<string>;

package/dist/components/molecules/chat/StructuredContent/helpers/uploadViaEventBus.d.ts

@@ -0,0 +1,2 @@
+import type { ChatEventBus } from '../../../../../core/eventBus/chatEventBus';
+export declare function uploadViaEventBus(eventBus: ChatEventBus, file: File, fileType: string): Promise<string>;

package/dist/components/molecules/lumi/BottomSheet/BottomSheet.d.ts

@@ -0,0 +1,29 @@
+import React from 'react';
+export interface BottomSheetProps {
+    open: boolean;
+    children: React.ReactNode;
+    /** Se llama al pulsar Escape o el fondo, cuando esos gestos están permitidos. */
+    onClose?: () => void;
+    /** El asa que indica que esto es una hoja. */
+    showGrabber?: boolean;
+    /** Cerrar al pulsar el fondo. Apagado por defecto: en decisiones importantes, un toque
+     *  perdido no debería descartar la hoja. */
+    closeOnBackdrop?: boolean;
+    /** Cerrar con Escape. Encendido por defecto. */
+    closeOnEscape?: boolean;
+    /** Etiqueta accesible cuando la hoja actúa como diálogo. */
+    ariaLabelledBy?: string;
+    className?: string;
+}
+/** Hoja que sube desde abajo, sobre una capa oscura.
+ *
+ * MOLÉCULA — compone el átomo `Card` como superficie y añade lo suyo: la capa, la posición, el
+ * asa, y el comportamiento de una capa modal (portal, bloqueo del scroll de fondo, Escape).
+ * No sabe qué contiene: sirve igual para un aviso, un formulario o un menú de acciones.
+ *
+ * Responsive por dentro: A SANGRE en móvil —de borde a borde, apoyada abajo, donde llega el
+ * pulgar— y tarjeta centrada y despegada en escritorio, porque a sangre en una pantalla ancha
+ * la hoja se leería como una franja y el texto quedaría perdido de lado a lado.
+ */
+export declare const BottomSheet: React.FC<BottomSheetProps>;
+export default BottomSheet;

package/dist/components/molecules/lumi/BottomSheet/index.d.ts

@@ -0,0 +1 @@
+export { BottomSheet, type BottomSheetProps } from './BottomSheet';

package/dist/components/molecules/lumi/Drawer/useDrawerKeyboardLock.d.ts

@@ -0,0 +1,18 @@
+import { RefObject } from "react";
+/**
+ * SPEC-016 — Mismo enfoque que useKeyboardLock del chat, pero para los inputs de un drawer/form.
+ *
+ * Problema: en iOS Safari, al tocar un input dentro de un overlay fixed con el teclado cerrado, Safari
+ * hace su scroll por defecto para "acomodar" el input → la página/overlay salta (y en el chat anidado
+ * asoma el overlay de atrás con otro título). El chat lo evita con el truco del proxy-textarea.
+ *
+ * Aquí replicamos el truco para CUALQUIER input/textarea dentro del contenedor:
+ *  1. Con el teclado cerrado, al tocar un input interceptamos el touchend → enfocamos un proxy invisible
+ *     en top:0 (Safari abre el teclado SIN scrollear).
+ *  2. Cuando el teclado se asienta (visualViewport.resize, con debounce), pasamos el foco al input real
+ *     con preventScroll y lo llevamos a la vista dentro de su scroller (sin salto).
+ *  3. Si el teclado YA está abierto (cambio de campo), no interceptamos: el foco nativo ya reposiciona bien.
+ *
+ * No-op fuera de Safari. Los <select> nativos y los dropdowns custom (no son input/textarea) no se tocan.
+ */
+export declare function useDrawerKeyboardLock<T extends HTMLElement>(containerRef: RefObject<T | null>, isOpen: boolean): void;

package/dist/components/molecules/lumi/Filter/types.d.ts

@@ -67,6 +67,10 @@ export interface FilterManager {
     condition: FilterConditionType;
     /** Valor de comparación */
     value: unknown;
+    /** SPEC-006 — extremo inicial de un rango (condición 'between'). */
+    initialValue?: unknown;
+    /** SPEC-006 — extremo final de un rango (condición 'between'). */
+    finalValue?: unknown;
     /** Grupo para operaciones OR (opcional) */
     group?: number | null;
 }

package/dist/components/molecules/lumi/LiveIndicator/LiveIndicator.d.ts

@@ -0,0 +1,28 @@
+import React from 'react';
+export type LiveIndicatorTone = 'live' | 'warning' | 'idle';
+/** Cuánto sitio ocupa:
+ *  - `full`    — punto + frase + detalle + acción. Para una pantalla.
+ *  - `compact` — pastilla: punto + etiqueta corta. Para una barra.
+ *  - `dot`     — solo el punto. Para cuando el estado se resume en encendido/apagado y el
+ *                control vive en otra parte; la frase queda para el título y la asistencia. */
+export type LiveIndicatorDensity = 'full' | 'compact' | 'dot';
+export interface LiveIndicatorProps {
+    /** La frase que lee el usuario. Corta: esto convive con el resto de la interfaz. */
+    label: string;
+    /** Detalle secundario (un contador, una hora, una causa). */
+    hint?: string;
+    /** `live` late; `warning` avisa sin alarmar; `idle` está apagado. */
+    tone?: LiveIndicatorTone;
+    /** Texto del botón de parada. Sin él, el indicador es solo informativo. */
+    actionLabel?: string;
+    onAction?: () => void;
+    className?: string;
+    /** SPEC-037 T2 — cuánto sitio ocupa. Por defecto `full`.
+     *  En `compact` y `dot` el `hint` no se pinta (no cabe) pero sigue describiendo el estado en
+     *  el título y para lectores de pantalla, y `actionLabel` deja de ser un botón aparte: pasa a
+     *  ser lo que hace el toque. Sin `onAction` el indicador no es pulsable y se anuncia como
+     *  estado, que es lo correcto cuando el control vive en otra pantalla. */
+    density?: LiveIndicatorDensity;
+}
+export declare const LiveIndicator: React.FC<LiveIndicatorProps>;
+export default LiveIndicator;

package/dist/components/molecules/lumi/LiveIndicator/index.d.ts

@@ -0,0 +1 @@
+export { LiveIndicator, type LiveIndicatorProps, type LiveIndicatorTone } from './LiveIndicator';

package/dist/components/molecules/lumi/Menu/types.d.ts

@@ -23,6 +23,9 @@ export interface MenuItemData {
     /** Nombre del icono de lumi (string que mapea a LUMI_ICON_TYPES)
      * Ejemplo: "home" → LUMI_ICON_TYPES.HOME */
     icon?: string;
+    /** Contador/etiqueta que se pinta a la derecha del título (notificaciones sin leer,
+     * items pendientes...). No se renderiza cuando viene vacío, 0 o undefined. */
+    badge?: number | string;
     /** Fecha de creación */
     createdDate: string;
     /** Fecha de actualización */
@@ -80,6 +83,8 @@ export interface MenuItemProps {
     title: string;
     /** Icono del item (nombre en string) */
     icon?: string;
+    /** Contador/etiqueta a la derecha del título. Oculto si viene vacío, 0 o undefined. */
+    badge?: number | string;
     /** Ruta para React Router */
     to?: string;
     /** Si el item está deshabilitado */

package/dist/components/molecules/lumi/SessionExpiryPrompt/SessionExpiryPrompt.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+export interface SessionExpiryPromptProps {
+    /** Controlado por el consumidor: este componente no decide cuándo aparecer. */
+    open: boolean;
+    /** Segundos que quedan; se muestran para que la urgencia sea un dato, no una sensación. */
+    secondsLeft?: number;
+    title?: string;
+    description?: string;
+    continueLabel?: string;
+    endLabel?: string;
+    onContinue: () => void;
+    onEnd: () => void;
+}
+/** SPEC-029 B2 — aviso de sesión por expirar: hoja inferior a ancho completo.
+ *
+ * MOLÉCULA: compone el átomo `Button` en vez de pintar sus propios botones. Lo que aporta es la
+ * composición —capa, hoja, jerarquía de las dos salidas—, no un estilo de botón paralelo que
+ * mañana se desincronizaría del resto del sistema.
+ *
+ * Componente TONTO a propósito: no sabe qué es un token, ni cuándo vence, ni a quién hay que
+ * preguntarle. Recibe `open` y devuelve dos decisiones. Quién decide mostrarlo es el host, que
+ * es quien conoce la política.
+ */
+export declare const SessionExpiryPrompt: React.FC<SessionExpiryPromptProps>;
+export default SessionExpiryPrompt;

package/dist/components/molecules/lumi/SessionExpiryPrompt/index.d.ts

@@ -0,0 +1 @@
+export { SessionExpiryPrompt, type SessionExpiryPromptProps } from './SessionExpiryPrompt';

package/dist/components/molecules/lumi/index.d.ts

@@ -12,3 +12,5 @@ export { Tabs, type TabsProps, type TabItem, type TabType, type TabPosition, typ
 export { Filter, FilterRow, type FilterProps, type FilterFieldConfig, type FilterValue, type FilterManager, } from './Filter';
 export { DropdownMenu, type DropdownMenuProps, type DropdownMenuOption } from './DropdownMenu';
 export { Notification, type NotificationProps, type NotificationType, type NotificationMode, type NotificationPosition } from './Notification';
+export { BottomSheet, type BottomSheetProps } from './BottomSheet';
+export { LiveIndicator, type LiveIndicatorProps, type LiveIndicatorTone } from './LiveIndicator';

package/dist/components/organisms/chat/Chat/hooks/useAutoScroll.d.ts

@@ -8,9 +8,15 @@ export interface UseAutoScrollOptions {
  * - scrollToLastUserMessage: espera nuevo user message y lo posiciona arriba
  * - pinLastUserMessage: re-posiciona el último user message arriba (sin esperar nuevo)
  * - scrollToBottom: scroll al fondo (botón scroll-down)
+ *
+ * SPEC-041 — el observador vive en un ref, no en una variable del cuerpo del hook.
+ * Antes se reiniciaba a `null` en cada render: el observador quedaba huérfano (nadie podía
+ * desconectarlo), dos envíos seguidos dejaban dos observadores compitiendo por mover el scroll,
+ * y ninguno se limpiaba al desmontar.
  */
 export declare const useAutoScroll: ({ messagesEndRef, messagesContainerRef, }: UseAutoScrollOptions) => {
     scrollToLastUserMessage: () => void;
     pinLastUserMessage: () => void;
+    scrollToProactive: () => void;
     scrollToBottom: () => void;
 };

package/dist/components/organisms/chat/Chat/hooks/useChatHandlers.d.ts

@@ -2,7 +2,6 @@ export interface UseChatHandlersOptions {
     onSend: (content: string, files?: File[]) => void;
     onInputChange: (value: string) => void;
     clearAttachments: () => void;
-    scrollToLastUserMessage: () => void;
 }
 export interface UseChatHandlersReturn {
     handleSendWithFiles: (content: string, files?: File[]) => void;
@@ -12,4 +11,4 @@ export interface UseChatHandlersReturn {
  * Hook para manejar las acciones del chat como envío de mensajes
  * Centraliza la lógica de envío y manejo de eventos del input
  */
-export declare const useChatHandlers: ({ onSend, onInputChange, clearAttachments, scrollToLastUserMessage }: UseChatHandlersOptions) => UseChatHandlersReturn;
+export declare const useChatHandlers: ({ onSend, onInputChange, clearAttachments }: UseChatHandlersOptions) => UseChatHandlersReturn;

package/dist/components/organisms/chat/Chat/hooks/useInputFocus.d.ts

@@ -7,4 +7,5 @@ export declare const useInputFocus: ({ showThinking, messages }: UseInputFocusOp
     handleInputFocus: () => void;
     handleMainClick: (e: React.MouseEvent) => void;
     handleFooterClick: (e: React.MouseEvent, componentPrefix: string) => void;
+    isKeyboardOpen: boolean;
 };

package/dist/components/organisms/lumi/DashboardSidebar/types.d.ts

@@ -41,10 +41,23 @@ export interface DashboardSidebarProps {
      * @default 'light'
      */
     theme?: 'light' | 'dark';
+    /**
+     * SPEC-011 — título del sidebar. Se pasa al Drawer para que use su `__title`, que es el mismo
+     * de todos los drawers. Antes el consumidor lo metía por `headerExtra` como un `<span>` suelto,
+     * y ahí solo heredaba el tamaño base: se veía más pequeño que el resto de cabeceras.
+     */
+    title?: string;
     /**
      * Contenido extra en el header del drawer (junto al botón de close)
      */
     headerExtra?: React.ReactNode;
+    /**
+     * SPEC-037 T3 — pie del sidebar, debajo del menú y separado de él.
+     *
+     * Para lo que NO es navegación: cerrar sesión, la versión, un aviso. Colarlo como un ítem más
+     * del menú lo haría indistinguible de un destino, y cerrar sesión no lleva a ninguna parte.
+     */
+    footer?: React.ReactNode;
     /**
      * Si muestra el botón de cerrar en el drawer
      * @default true