ghostykit 0.0.0-stage → 0.2.0

package/dist/core/index.js

@@ -0,0 +1,72 @@
+import {
+  RESTART_NOTICE,
+  RESUME_TEXT,
+  TOOL_VERBS_EN,
+  TOOL_VERBS_ES,
+  appendAgentMessages,
+  beginSend,
+  cleanReplyOption,
+  createPilotState,
+  dropLastExchange,
+  expiryMs,
+  extractReplyOptions,
+  groupSteps,
+  isNarration,
+  isRunning,
+  lastUserTurn,
+  narrationToMarkdown,
+  reconcileTurns,
+  reconcileWith,
+  reducePilotEvent,
+  resolvePermission,
+  resumeMode,
+  sendAccepted,
+  sendFailed,
+  sendRejectedBusy,
+  splitNarration,
+  stepLabel,
+  stopTurn,
+  summarizeTools,
+  toolName
+} from "../chunks/chunk-XWOGK2HN.js";
+import {
+  applyReferences,
+  cleanUserText,
+  formatDuration,
+  systemNoteOf
+} from "../chunks/chunk-6U545WJG.js";
+export {
+  RESTART_NOTICE,
+  RESUME_TEXT,
+  TOOL_VERBS_EN,
+  TOOL_VERBS_ES,
+  appendAgentMessages,
+  applyReferences,
+  beginSend,
+  cleanReplyOption,
+  cleanUserText,
+  createPilotState,
+  dropLastExchange,
+  expiryMs,
+  extractReplyOptions,
+  formatDuration,
+  groupSteps,
+  isNarration,
+  isRunning,
+  lastUserTurn,
+  narrationToMarkdown,
+  reconcileTurns,
+  reconcileWith,
+  reducePilotEvent,
+  resolvePermission,
+  resumeMode,
+  sendAccepted,
+  sendFailed,
+  sendRejectedBusy,
+  splitNarration,
+  stepLabel,
+  stopTurn,
+  summarizeTools,
+  systemNoteOf,
+  toolName
+};

package/dist/core/narration.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Narración intercalada: lo que el agente dice ANTES de cada herramienta («Reviso tus archivos.»,
+ * «Armo el calendario.») es avance, no respuesta. Se pinta como lista con palomitas encima de la
+ * respuesta final, como los pasos de claude.ai.
+ *
+ * Dos fuentes, mismo resultado:
+ * - En vivo: el reductor anota en qué largo del texto arrancó cada herramienta (`cuts`).
+ * - En la copia guardada: el servidor la escribe como `- ✓ …` al inicio, así la recarga la ve igual.
+ */
+/** Un tramo es «narración» si es corto y de un solo párrafo; si no, es texto normal. */
+export declare function isNarration(chunk: string): boolean;
+export declare function splitNarration(text: string, cuts?: number[]): {
+    steps: string[];
+    rest: string;
+};
+/** La copia que se guarda: narración como `- ✓ …` y luego la respuesta. */
+export declare function narrationToMarkdown(chunks: string[], answer: string): string;

package/dist/core/options.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Cuando la ÚLTIMA respuesta, ya terminada, cierra con una oferta («Si quieres, puedo:»,
+ * «¿Quieres que…?», «Dos caminos, tú eliges:») seguida de una lista corta, esa lista se pinta como
+ * BOTONES: un clic manda la opción como mensaje del usuario, por el camino normal.
+ */
+export type ReplyOptions = {
+    before: string;
+    items: string[];
+    numbered: boolean;
+};
+/** ¿El texto termina en una oferta con 2–5 opciones cortas? Si sí, la separa. */
+export declare function extractReplyOptions(text: string): ReplyOptions | null;
+/** La opción como la mandaría una persona: sin «o »/«y », sin negritas ni puntuación final. */
+export declare function cleanReplyOption(t: string): string;

package/dist/core/reconcile.d.ts

@@ -0,0 +1,7 @@
+import type { Turn } from "./types";
+/**
+ * Si la copia trae MÁS mensajes del usuario que la pantalla, faltan los de otro cliente: se repinta
+ * con la copia, conservando el turno vivo (pasos, segundos, uso) de cada mensaje que coincide. Con
+ * los mismos mensajes del usuario no se toca nada (las burbujas en vivo son más ricas que la copia).
+ */
+export declare function reconcileTurns(current: Turn[], fresh: Turn[]): Turn[];

package/dist/core/reducer.d.ts

@@ -0,0 +1,49 @@
+import type { Attachment, PermissionRequest, PilotState, SendResult, Turn } from "./types";
+/** El aviso de reinicio del servidor. Se retira solo si el agente sigue mandando algo. */
+export declare const RESTART_NOTICE = "El servidor se reinici\u00F3 a media respuesta. Vuelve a enviar el mensaje.";
+/** Lo que se ve en el hilo al retomar (el servidor manda al agente la continuación entera). */
+export declare const RESUME_TEXT = "Contin\u00FAa donde te quedaste.";
+export declare function createPilotState(turns?: Turn[]): PilotState;
+/**
+ * Un evento del stream → estado nuevo. `data` ya viene parseado (JSON); `null` si no traía.
+ * `now` se inyecta para que el reductor sea puro (tiempos de turno y de página).
+ */
+export declare function reducePilotEvent(prev: PilotState, name: string, data: unknown, now?: number): PilotState;
+/** `expiresAt` (ISO o epoch ms) → epoch ms. */
+export declare function expiryMs(v: string | number): number;
+/**
+ * El usuario manda un mensaje. Con turno en vuelo es una CORRECCIÓN: el servidor intenta meterlo
+ * al turno (steer) y, hasta saber si entró, la burbuja viva se conserva.
+ */
+export declare function beginSend(prev: PilotState, text: string, attachments: Attachment[], now?: number): PilotState;
+/** El servidor aceptó el encargo. `inFlight` = había turno en vuelo al mandar. */
+export declare function sendAccepted(prev: PilotState, r: SendResult, inFlight: boolean, now?: number): PilotState;
+/**
+ * El servidor ya tiene un turno corriendo (409 `turn_busy`): el mensaje de este cliente NO entró.
+ * Se quita de la pantalla y se avisa; el transporte se re-engancha al turno que sí corre.
+ */
+export declare function sendRejectedBusy(prev: PilotState, message: string): PilotState;
+/** El encargo fue rechazado (sin saldo, sin cuenta…): se DICE, para que no se quede pensando. */
+export declare function sendFailed(prev: PilotState, message: string, needsLogin?: boolean): PilotState;
+/** Detener el turno en curso (el POST de cancelar lo hace el transporte). */
+export declare function stopTurn(prev: PilotState): PilotState;
+/** Quita el último intercambio (las respuestas del final y el último mensaje del usuario). */
+export declare function dropLastExchange(prev: PilotState): PilotState;
+/**
+ * El usuario contestó una tarjeta: sale de las abiertas y queda anotada en la última respuesta
+ * («Aprobaste: correr la purga»). `resolved: false` = ya no estaba abierta (venció o la contestó otro).
+ */
+export declare function resolvePermission(prev: PilotState, id: string, optionId: string, resolved: boolean, detail?: string, 
+/** La tarjeta como estaba al contestarla (el stream pudo retirarla mientras tanto). */
+asked?: PermissionRequest): PilotState;
+/** Un mensaje del agente que entró fuera de un turno (el remate de los subagentes). */
+export declare function appendAgentMessages(prev: PilotState, texts: string[]): PilotState;
+/** La copia del hilo cambió: trae los mensajes que el usuario mandó desde OTRO cliente. Sólo en reposo. */
+export declare function reconcileWith(prev: PilotState, fresh: Turn[]): PilotState;
+/** El último mensaje del usuario (para reintentar o retomar). */
+export declare function lastUserTurn(turns: Turn[]): Turn | null;
+/**
+ * «Retomar»: si el agente alcanzó a trabajar (texto o pasos tras el último mensaje), se le pide
+ * CONTINUAR; si no, es reenviar el mensaje tal cual.
+ */
+export declare function resumeMode(turns: Turn[]): "continue" | "resend";

package/dist/core/steps.d.ts

@@ -0,0 +1,30 @@
+import type { ToolEntry } from "./types";
+/** El verbo con el que una persona nombraría un paso. `%n` = cuántas veces. */
+export interface ToolVerb {
+    one: string;
+    many: string;
+    /** Rótulo mientras corre (p. ej. «Compactando la memoria…»); si falta, `one`. */
+    running?: string;
+}
+/** Por `kind` de ACP (`read`, `execute`…) o por NOMBRE de herramienta (`crm_card_update`). */
+export type ToolVerbs = Record<string, ToolVerb>;
+/** ¿Sigue corriendo? `pending` también: es el instante entre pedirla y arrancarla. */
+export declare const isRunning: (t: ToolEntry) => boolean;
+/** `mcp__servidor__nombre` → `nombre`; cualquier otro título, tal cual. */
+export declare function toolName(t: ToolEntry): string | null;
+/** El rótulo de un paso: el verbo de su nombre, o el título que manda el servidor, o su clase. */
+export declare function stepLabel(t: ToolEntry, verbs: ToolVerbs, fallback?: string): string;
+/** El resumen de una línea: los pasos agrupados por nombre o clase, con su verbo. */
+export declare function summarizeTools(tools: ToolEntry[], verbs: ToolVerbs): string;
+/**
+ * Pasos iguales (mismo rótulo y detalle) en UN renglón con «×3», en el orden en que aparecieron.
+ * El representante es el ÚLTIMO (su estado es el vigente), salvo que otro siga corriendo o haya
+ * fallado: eso manda.
+ */
+export declare function groupSteps(tools: ToolEntry[], label: (t: ToolEntry) => string): {
+    tool: ToolEntry;
+    times: number;
+}[];
+/** Los verbos de casa, en español. Las apps agregan los suyos (por nombre) con `toolVerbs`. */
+export declare const TOOL_VERBS_ES: ToolVerbs;
+export declare const TOOL_VERBS_EN: ToolVerbs;

package/dist/core/text.d.ts

@@ -0,0 +1,15 @@
+import type { Reference } from "./types";
+/** El texto del usuario como se pinta en su burbuja. Las apps afinan con `formatUserText`. */
+export declare function cleanUserText(raw: string): string;
+/**
+ * Un turno que abrió la PLATAFORMA y no la persona (una tarea programada, una entrega): empieza
+ * con «⏰ ». Se pinta como línea de sistema con sólo la causa, sin las instrucciones al modelo.
+ */
+export declare function systemNoteOf(text: string): string | null;
+/**
+ * Las referencias se mandan DENTRO del texto (es lo que el agente lee): primero los renglones con
+ * `prompt` (p. ej. un elemento señalado), luego las etiquetas juntas `[#12 Rosa, #7 Javier] `.
+ */
+export declare function applyReferences(text: string, refs: Reference[]): string;
+/** «45 s», «3 min», «1 h 05 min». */
+export declare function formatDuration(s: number): string;

package/dist/core/types.d.ts

@@ -0,0 +1,236 @@
+/** Por dónde va la conexión con el agente antes de que conteste. */
+export type ConnectPhase = "waking" | "connecting" | "session";
+/** Un modelo que el agente ofrece para la sesión (selector ACP). */
+export interface ModelOption {
+    value: string;
+    name: string;
+}
+/**
+ * Un adjunto listo para el agente: base64 sin prefijo + su MIME, o una URL ya subida.
+ * Viaja en el cuerpo del POST como `images` (nombre histórico del contrato).
+ */
+export interface Attachment {
+    name?: string;
+    mimeType: string;
+    /** Base64 sin el prefijo `data:`. Vacío cuando el archivo viaja por `uri`. */
+    data: string;
+    /** URL del archivo ya subido (lo que el agente descarga cuando no es imagen ni texto). */
+    uri?: string;
+    /** Id del archivo en la app, si la app lo guarda. */
+    fileId?: string;
+}
+/** Un paso del agente (una herramienta), según ACP: pending → in_progress → completed | failed. */
+export interface ToolEntry {
+    id: string;
+    title?: string;
+    kind?: string;
+    status?: string;
+    path?: string;
+    /** Qué hace, en palabras de persona (el comando, el archivo, el prompt de la imagen). */
+    detail?: string;
+}
+/** Lo que el agente ENTREGÓ en el turno (evento `artifact`). `raw` es el payload tal cual. */
+export interface Delivery {
+    kind: "file" | "artifact";
+    name: string;
+    fileId?: string;
+    /** Documento editable de la app (Ghosty: `@ghostystudio/docs`). */
+    docId?: string;
+    mime?: string;
+    size?: number;
+    /** Captura de pantalla del navegador: se pinta en su tira, no como entrega suelta. */
+    capture?: boolean;
+    raw?: Record<string, unknown>;
+}
+/** Una sección de la página que el turno arma (constructor por secciones). */
+export interface PageBuildSection {
+    id: string;
+    label: string;
+    kind: string;
+    status: "pending" | "building" | "done" | "failed";
+    html?: string;
+}
+/** La revisión de la página armada: corriendo, o terminada con sus arreglos. */
+export interface PageReview {
+    status: "running" | "done";
+    fixes: {
+        name: string;
+        sectionId: string;
+    }[];
+    skipped: string[];
+    thumb?: string | null;
+    seconds?: number;
+}
+/** Una página que el turno está armando, por `pageId` (eventos `page-plan` … `page-ready`). */
+export interface PageBuild {
+    pageId: string;
+    title: string;
+    /** Opaco para Piloto: lo interpreta quien pinta la página (slot `renderDeliveries`). */
+    theme: unknown;
+    sections: PageBuildSection[];
+    startedAt: number;
+    readyAt?: number;
+    url?: string | null;
+    n?: number;
+    error?: string;
+    mode?: "build" | "edit";
+    focus?: {
+        sectionId: string;
+        nodeId: string;
+    };
+    editLabel?: string;
+    editSummary?: string;
+    review?: PageReview;
+}
+export interface Usage {
+    used: number;
+    size: number;
+    cost: number;
+    input?: number;
+    output?: number;
+}
+export interface Turn {
+    role: "user" | "assistant";
+    text: string;
+    /** Llegó entero fuera de un turno (el remate de los subagentes): se escribe al ritmo. */
+    arrived?: boolean;
+    deliveries?: Delivery[];
+    /** Cuánto tardó, en segundos. Se rellena al cerrar el turno. */
+    seconds?: number;
+    thought?: string;
+    tools?: ToolEntry[];
+    /** Largo del texto cuando arrancó cada herramienta: lo de antes es narración (`splitNarration`). */
+    cuts?: number[];
+    attachments?: Attachment[];
+    usage?: Usage;
+    /** Lo que el usuario decidió en las tarjetas de permiso de este turno (sólo en vivo). */
+    decisions?: Decision[];
+    /** Mensaje del usuario que ENTRÓ al turno en vuelo (steer): la respuesta sigue arriba. */
+    steer?: boolean;
+    pages?: PageBuild[];
+    /** El servidor ya está planeando una página (antes de que llegue su plan). */
+    planning?: boolean;
+    planningAt?: number;
+}
+/** Un turno que se cortó por falla del servidor (deploy, caja caída). Lo dice el servidor. */
+export interface Interrupted {
+    reason: string;
+    turnId?: string;
+    /** El servidor puede CONTINUAR ese turno (EasyBits: `continueTurnId`). */
+    canContinue?: boolean;
+}
+/** Una tarjeta de permiso ya contestada. */
+export interface Decision {
+    id: string;
+    title: string;
+    status: "approved" | "rejected" | "expired";
+    /** Lo que devolvió la app al resolverla (p. ej. «ejecutada»). */
+    detail?: string;
+}
+/** Una opción de un pedido de permiso, tal cual la manda el agente (ACP). */
+export interface PermissionOption {
+    optionId: string;
+    name: string;
+    /** `allow_once` | `allow_always` | `reject_once` | `reject_always` | otra. */
+    kind?: string;
+}
+/** El agente pide permiso antes de algo riesgoso: el turno está DETENIDO hasta que alguien conteste. */
+export interface PermissionRequest {
+    id: string;
+    title: string;
+    tool?: string;
+    options: PermissionOption[];
+    /**
+     * Hasta cuándo se puede contestar (ISO o epoch ms). Una tarjeta CON vencimiento no depende del
+     * turno (EasyBits: la propuesta vive 15 min aunque el turno ya cerró) y sobrevive al `done`.
+     */
+    expiresAt?: string | number;
+}
+/** Lo que una transición pide hacer FUERA del estado (avisos a la app). */
+export type PilotEffect = {
+    type: "turn-start";
+} | {
+    type: "turn-done";
+    text: string;
+    turnId?: string;
+    seconds?: number;
+} | {
+    type: "turn-interrupted";
+    reason: string;
+    turnId?: string;
+} | {
+    type: "needs-login";
+} | {
+    type: "title";
+    title?: string;
+} | {
+    type: "disconnected";
+};
+export interface PilotState {
+    turns: Turn[];
+    busy: boolean;
+    connected: boolean;
+    phase: ConnectPhase;
+    error: string | null;
+    notice: string | null;
+    usage: Usage | null;
+    models: ModelOption[];
+    currentModel: string | null;
+    /** Qué puede el agente. Empieza en `true` para no bloquear mientras se conecta. */
+    canSeeImages: boolean;
+    /** El último turno se cortó por falla del servidor: el chat ofrece Retomar. */
+    interrupted: Interrupted | null;
+    /** El turno sigue en OTRA instancia del servidor (deploy azul/verde): «sigo trabajando». */
+    elsewhere: boolean;
+    /** Permisos abiertos, en el orden en que llegaron. */
+    permissions: PermissionRequest[];
+    /** Cuándo empezó el turno que ESTE cliente encargó (0 = ninguno). */
+    turnStartedAt: number;
+    /** Hay una burbuja del asistente recibiendo eventos del turno en curso. */
+    streaming: boolean;
+    /** El `turnId` del turno que este cliente encargó (lo devuelve el POST). */
+    currentTurnId: string | null;
+    /** Cuántas veces se abrió el stream: >1 = reconexión. */
+    connections: number;
+    /** El servidor avisó (`caps.needAccount`) que hace falta cuenta: se avisa al cerrar el turno. */
+    needAccount: boolean;
+    /** Cada cuánto promete el servidor su latido (`started.latidoMs`). */
+    heartbeatMs: number | null;
+    /** Efectos de la ÚLTIMA transición. El hook los ejecuta y los descarta. */
+    effects: PilotEffect[];
+}
+/** Lo que se le pide al transporte al mandar un mensaje. */
+export interface SendInput {
+    text: string;
+    attachments: Attachment[];
+    /** Es el primer mensaje del hilo (el servidor lo bautiza al cerrar el turno). */
+    firstTurn: boolean;
+    /** «Retomar» un turno cortado: el servidor arma la continuación. */
+    resume?: boolean;
+    /** Con `resume`: el turno a continuar, si el servidor lo dijo (`interrupted.turnId`). */
+    resumeTurnId?: string;
+    /** Lo que el usuario ve en pantalla, para este turno. */
+    context?: unknown;
+    /** Las referencias que viajaron en el texto, también estructuradas. */
+    references?: Reference[];
+}
+/** Lo que contesta el servidor al encargo. */
+export interface SendResult {
+    /** El mensaje entró al turno en vuelo (steer). */
+    injected?: boolean;
+    /** `queued` = la caja está despertando. */
+    state?: string;
+    turnId?: string;
+}
+/**
+ * Una referencia que acompaña al mensaje (una tarjeta del tablero, un elemento señalado).
+ * Con `prompt`, ese renglón va ANTES del mensaje; sin él, las etiquetas van juntas como
+ * `[#12 Rosa, #7 Javier] ` (el formato del tablero de Ghosty).
+ */
+export interface Reference {
+    id: string;
+    label: string;
+    prompt?: string;
+    /** Texto secundario del chip («el texto señalado»). */
+    hint?: string;
+}

package/dist/fonts.css

@@ -0,0 +1,3 @@
+/* Opcional: las fuentes de las pieles de casa (Schibsted Grotesk para leer, Big Shoulders Stencil
+   para el reloj y el sello del pase). Sin esto, Piloto cae a las fuentes del sistema. */
+@import url("https://fonts.googleapis.com/css2?family=Big+Shoulders+Stencil+Display:wght@700;800;900&family=Schibsted+Grotesk:ital,wght@0,400..900;1,400..900&display=swap");

package/dist/pointer/index.d.ts

@@ -0,0 +1,9 @@
+import { type PickedElement } from "@ghostystudio/pointer/picked";
+import type { Reference } from "../core/types";
+/** Un elemento señalado → referencia: chip «Título «…»» y el renglón `[Elemento señalado …]` antes del mensaje. */
+export declare function elementReference(picked: PickedElement, fileName: string): Reference;
+/** Qué pedirle a lo señalado («¿Qué le cambio a este título? Ej.: …»), para el placeholder. */
+export declare function pickedPlaceholder(picked: PickedElement): string;
+/** `formatUserText` que además pinta el renglón señalado como etiqueta corta (`↳ Título «…»`). */
+export declare function formatWithPicked(text: string): string;
+export type { PickedElement };

package/dist/pointer/index.js

@@ -0,0 +1,27 @@
+import {
+  cleanUserText
+} from "../chunks/chunk-6U545WJG.js";
+
+// src/pointer/index.ts
+import { pickedKind, pickedLineLabel, pickedSnippet } from "@ghostystudio/pointer/kind";
+import { pickedElementLine } from "@ghostystudio/pointer/picked";
+function elementReference(picked, fileName) {
+  return {
+    id: `pick:${fileName}:${picked.id ?? picked.selector}`,
+    label: pickedKind(picked.tag).label,
+    hint: picked.text ? pickedSnippet(picked.text) : void 0,
+    prompt: pickedElementLine(picked, fileName)
+  };
+}
+function pickedPlaceholder(picked) {
+  const k = pickedKind(picked.tag);
+  return `\xBFQu\xE9 le cambio a ${k.this}? Ej.: ${k.example}`;
+}
+function formatWithPicked(text) {
+  return cleanUserText(pickedLineLabel(text));
+}
+export {
+  elementReference,
+  formatWithPicked,
+  pickedPlaceholder
+};

package/dist/react/Bubble.d.ts

@@ -0,0 +1,41 @@
+import { type ReactNode } from "react";
+import { type ReplyOptions } from "../core/options";
+import type { Delivery, Turn, Usage } from "../core/types";
+export declare function UserBubble({ turn }: {
+    turn: Turn;
+}): import("react").JSX.Element;
+/** Copiar lo que TÚ escribiste: un ícono bajo tu burbuja, al pasar el mouse (fijo en táctil). */
+export declare function CopyUserMessage({ text }: {
+    text: string;
+}): import("react").JSX.Element;
+/** Las opciones finales de la última respuesta como botones: un clic las manda como tu mensaje. */
+export declare function ReplyOptionButtons({ options, onPick }: {
+    options: ReplyOptions;
+    onPick: (text: string) => void;
+}): import("react").JSX.Element;
+/** Tokens del turno, qué tanto del contexto se llevó y cuánto costó. */
+export declare function UsageStats({ used, size, cost }: Usage): import("react").JSX.Element | null;
+/** El pie de una respuesta terminada: cuánto tardó, copiar y reintentar. */
+export declare function TurnFooter({ text, seconds, onRetry, showCopy }: {
+    text: string;
+    seconds?: number;
+    onRetry?: () => void;
+    showCopy?: boolean;
+}): import("react").JSX.Element;
+/** Las entregas por defecto: una ficha por archivo (las apps pintan las suyas con `renderDeliveries`). */
+export declare function DeliveryChips({ deliveries }: {
+    deliveries: Delivery[];
+}): import("react").JSX.Element | null;
+export interface AgentBubbleProps {
+    turn: Turn;
+    /** El turno sigue escribiéndose. */
+    live: boolean;
+    onRetry?: () => void;
+    /** Sólo la ÚLTIMA respuesta, ya terminada: sus opciones finales salen como botones. */
+    onOption?: (text: string) => void;
+    showUsage?: boolean;
+    showCopy?: boolean;
+    /** Las entregas (y lo que la app quiera bajo la respuesta). Sin esto, fichas simples. */
+    renderDeliveries?: (turn: Turn, live: boolean) => ReactNode;
+}
+export declare function AgentBubble({ turn, live, onRetry, onOption, showUsage, showCopy, renderDeliveries }: AgentBubbleProps): import("react").JSX.Element;

package/dist/react/Chips.d.ts

@@ -0,0 +1,13 @@
+import type { Reference } from "../core/types";
+/** Las referencias del mensaje: chips atómicos con ×. Clic en el chip = `onActivate` (resaltar en la app). */
+export declare function ReferenceChips({ references, onRemove, onActivate, }: {
+    references: Reference[];
+    onRemove: (id: string) => void;
+    onActivate?: (ref: Reference) => void;
+}): import("react").JSX.Element | null;
+/** Sugerencias para arrancar. Una que termina en «: » se escribe en la caja en vez de mandarse. */
+export declare function Suggestions({ items, onPick, onPrefill }: {
+    items: string[];
+    onPick: (text: string) => void;
+    onPrefill?: (text: string) => void;
+}): import("react").JSX.Element | null;

package/dist/react/Composer.d.ts

@@ -0,0 +1,45 @@
+import { type ReactNode } from "react";
+import type { Attachment, ModelOption, Reference } from "../core/types";
+/** Lo que devuelve la app al subir un archivo: su URL (y su id, si lo guarda). */
+export interface UploadResult {
+    url: string;
+    id?: string;
+}
+/** El tipo del archivo, deducido del nombre cuando el navegador no lo dice (pasa más de lo que parece). */
+export declare function mimeOf(file: File): string;
+export interface ComposerProps {
+    onSubmit: (text: string, attachments: Attachment[]) => void;
+    onStop?: () => void;
+    busy?: boolean;
+    /** ¿Se puede mandar texto con el turno en vuelo? (el servidor lo mete al turno). Default sí. */
+    canSteer?: boolean;
+    placeholder?: string;
+    initialValue?: string;
+    autoFocus?: boolean;
+    /** ¿El agente ve imágenes? Si no, el botón de imagen se apaga en vez de fingir. */
+    canSeeImages?: boolean;
+    /** Adjuntos: imágenes y texto viajan dentro del turno; lo demás se sube con `upload`. */
+    attachments?: boolean;
+    upload?: (file: File) => Promise<UploadResult>;
+    /** Nota de voz: con esto aparece el micrófono. */
+    transcribe?: (audio: Blob) => Promise<string>;
+    /** Cómo viaja lo dicho (p. ej. con un envoltorio para el agente). Default: tal cual. */
+    voiceNoteText?: (transcript: string) => string;
+    models?: ModelOption[];
+    currentModel?: string | null;
+    onModelChange?: (value: string) => void;
+    references?: Reference[];
+    onRemoveReference?: (id: string) => void;
+    onActivateReference?: (ref: Reference) => void;
+    /** Botones propios junto a adjuntar (slot `composerExtras`). */
+    extras?: ReactNode;
+    maxFiles?: number;
+    maxFileMb?: number;
+}
+export declare function Composer({ onSubmit, onStop, busy, canSteer, placeholder, initialValue, autoFocus, canSeeImages, attachments: withFiles, upload, transcribe, voiceNoteText, models, currentModel, onModelChange, references, onRemoveReference, onActivateReference, extras, maxFiles, maxFileMb, }: ComposerProps): import("react").JSX.Element;
+/** El selector de modelo: un menú corto hacia arriba, sin Radix. Cierra con clic fuera y Escape. */
+export declare function ModelPicker({ models, current, onChange }: {
+    models: ModelOption[];
+    current: string | null;
+    onChange: (value: string) => void;
+}): import("react").JSX.Element | null;

package/dist/react/ConfirmCard.d.ts

@@ -0,0 +1,17 @@
+import type { Decision, PermissionOption, PermissionRequest } from "../core/types";
+import type { PermissionAnswer } from "./usePilot";
+/** Las opciones de rechazo van primero y discretas; las de aprobar, al final y en color. */
+export declare const isRejectOption: (o: PermissionOption) => boolean;
+export declare function ConfirmCard({ request, onRespond, onSettled, onExpire, }: {
+    request: PermissionRequest;
+    /** Contesta (el transporte o la ruta de la app). `{resolved:false}` = ya no estaba abierta. */
+    onRespond: (id: string, optionId: string) => Promise<PermissionAnswer> | PermissionAnswer;
+    /** El sello ya se vio: anotar la decisión y retirar la tarjeta. */
+    onSettled?: (id: string, optionId: string, answer: PermissionAnswer) => void;
+    /** Venció sin contestarse. */
+    onExpire?: (id: string) => void;
+}): import("react").JSX.Element;
+/** Lo que el usuario decidió en las tarjetas de este turno: «Aprobaste: correr la purga». */
+export declare function DecisionLines({ decisions }: {
+    decisions: Decision[];
+}): import("react").JSX.Element | null;

package/dist/react/Markdown.d.ts

@@ -0,0 +1,12 @@
+import { type LinkSafetyModalProps } from "streamdown";
+/** El aviso de enlace externo, en la lengua y el tema de Piloto (el de Streamdown llega en inglés). */
+export declare function LinkSafetyModal({ isOpen, onClose, onConfirm, url }: LinkSafetyModalProps): import("react").JSX.Element | null;
+/**
+ * `animate`: la respuesta se está escribiendo y entra por tramos con fade. Una vez que animó, se
+ * queda con el mismo bloque aunque el turno cierre: cambiarlo re-montaría todo y cortaría el fade.
+ */
+export declare function Markdown({ children, animate, className }: {
+    children: string;
+    animate?: boolean;
+    className?: string;
+}): import("react").JSX.Element;