@runnerpro/backend 1.22.8 → 1.23.0

package/lib/cjs/types/mediaProcessing/audio.d.ts

@@ -0,0 +1,63 @@
+/// <reference types="node" />
+declare const AUDIO_ENCODING_MAP: Record<string, string>;
+declare const SYNC_MAX_SECONDS = 55;
+/**
+ * Transcribe con un modelo multimodal de Google. Es la red que recoge lo que Speech-to-Text
+ * no reconoce y, sobre todo, los audios de más de 60s, que el modo síncrono no admite.
+ *
+ * @param wavBuffer - Buffer WAV mono 16 kHz
+ * @returns Promise<string | null> - Transcripción, o null si no hay voz
+ */
+declare const transcribeWithModel: (wavBuffer: Buffer) => Promise<string | null>;
+/**
+ * Convierte cualquier audio al formato que espera Speech-to-Text (WAV PCM mono 16 kHz)
+ *
+ * @param fileBuffer - Buffer del audio original
+ * @param filename - Nombre original del archivo
+ * @returns WAV mono 16 kHz y la duración original en segundos
+ */
+declare const convertToWav16k: (fileBuffer: Buffer, filename?: string) => Promise<{
+    wav: Buffer;
+    duration: number;
+}>;
+/**
+ * Transcribe una nota de voz.
+ *
+ * El audio se normaliza a WAV mono 16 kHz y luego se elige motor por duración:
+ *  - hasta 55s → Speech-to-Text, que es barato y preciso.
+ *  - más de 55s → modelo multimodal, porque `recognize` no admite audios más largos y
+ *    `longRunningRecognize` exige subir el archivo a GCS antes.
+ *  - si Speech-to-Text no reconoce nada, se reintenta con el modelo antes de darlo por perdido.
+ *
+ * ⚠️ El orden importa y no es intercambiable. Medido sobre notas de voz reales de producción
+ * que hoy acaban en '[Audio sin contenido reconocible]':
+ *  - mandar el AAC crudo declarando 'MP3' (lo que se hacía): 0 de 14 recuperadas.
+ *  - convertir a WAV y declarar LINEAR16: 13 de 14 (la que falla es de 81s).
+ *  - modelo multimodal: 14 de 14.
+ * Y a la inversa, convertir a WAV SIN respetar el límite de 55s rompe los audios largos que hoy
+ * sí funcionan (4 de 4 medidos): con LINEAR16 la API deduce la duración exacta y los rechaza,
+ * mientras que con un códec comprimido declarado se saltaba esa comprobación.
+ *
+ * @param fileBuffer - Buffer del archivo de audio
+ * @param mimetype - Tipo MIME del archivo (ej: 'audio/aac', 'audio/x-m4a')
+ * @param filename - Nombre original del archivo
+ * @returns Promise<string> - Transcripción del audio
+ *
+ * @example
+ * ```typescript
+ * const transcription = await transcribeAudio(audioBuffer, 'audio/aac', 'audio.aac');
+ * // Resultado: "Hola, quería comentarte que hoy me duele un poco la rodilla..."
+ * ```
+ */
+declare const transcribeAudio: (fileBuffer: Buffer, mimetype: string, filename?: string) => Promise<string>;
+/**
+ * Transcribe un WAV que ya viene en el formato que espera Speech-to-Text
+ * (PCM 16 bits, mono, 16 kHz) y dura menos de 55 segundos. Lo usa el análisis de vídeo,
+ * que extrae la pista así y ya la recorta.
+ *
+ * @param wavBuffer - Buffer WAV mono 16 kHz de menos de 55 segundos
+ * @returns Promise<string> - Transcripción del audio
+ */
+declare const transcribeWav16k: (wavBuffer: Buffer) => Promise<string>;
+export { transcribeAudio, transcribeWav16k, transcribeWithModel, convertToWav16k, AUDIO_ENCODING_MAP, SYNC_MAX_SECONDS };
+//# sourceMappingURL=audio.d.ts.map

package/lib/cjs/types/mediaProcessing/audio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audio.d.ts","sourceRoot":"","sources":["../../../../src/mediaProcessing/audio.ts"],"names":[],"mappings":";AAUA,QAAA,MAAM,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAa9C,CAAC;AAIF,QAAA,MAAM,gBAAgB,KAAK,CAAC;AAoD5B;;;;;;GAMG;AACH,QAAA,MAAM,mBAAmB,cAAqB,MAAM,KAAG,QAAQ,MAAM,GAAG,IAAI,CA4B3E,CAAC;AAEF;;;;;;GAMG;AACH,QAAA,MAAM,eAAe,eAAgB,MAAM,aAAa,MAAM,KAAG,QAAQ;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAuBtG,CAAC;AAEL;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,QAAA,MAAM,eAAe,eAAsB,MAAM,YAAY,MAAM,aAAa,MAAM,KAAG,QAAQ,MAAM,CA4BtG,CAAC;AAEF;;;;;;;GAOG;AACH,QAAA,MAAM,gBAAgB,cAAqB,MAAM,KAAG,QAAQ,MAAM,CAGjE,CAAC;AAEF,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,eAAe,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,CAAC"}

package/lib/cjs/types/mediaProcessing/documents.d.ts

@@ -0,0 +1,79 @@
+/// <reference types="node" />
+declare const MAX_MODEL_FILE_BYTES: number;
+/**
+ * Formatea un tamaño en bytes de forma legible en español (1024 → "1 KB")
+ *
+ * @param bytes - Tamaño en bytes
+ * @returns Tamaño legible con unidad
+ */
+declare const formatBytes: (bytes: number) => string;
+/**
+ * Heurística para saber si un buffer es texto plano legible.
+ * Útil cuando el cliente manda un .gpx o un .csv como 'application/octet-stream'.
+ *
+ * @param fileBuffer - Buffer del archivo
+ * @returns true si los primeros KB parecen texto UTF-8
+ */
+declare const looksLikeText: (fileBuffer: Buffer) => boolean;
+/**
+ * Decodifica un buffer de texto respetando su BOM.
+ *
+ * Importa porque los .txt y .csv guardados como "Unicode" desde el Bloc de notas o Excel vienen
+ * en UTF-16: leerlos como UTF-8 intercala bytes nulos, y Postgres rechaza el carácter nulo en una
+ * columna text, así que el UPDATE de FILE TEXT fallaría (en silencio, porque query() se traga el
+ * error) y el adjunto se quedaría sin texto para siempre.
+ *
+ * @param fileBuffer - Buffer del archivo
+ * @returns Contenido decodificado
+ */
+declare const decodeTextBuffer: (fileBuffer: Buffer) => string;
+/**
+ * Genera un resumen de un PDF mandándoselo entero al modelo, que lo lee de forma nativa
+ *
+ * @param fileBuffer - Buffer del PDF
+ * @param filename - Nombre original del archivo (ayuda al modelo a contextualizar)
+ * @returns Promise<string> - Resumen del documento
+ *
+ * @example
+ * ```typescript
+ * const summary = await describePdf(pdfBuffer, 'informe-traumatologo.pdf');
+ * // Resultado: "Informe de traumatología del 12/03 con diagnóstico de fascitis plantar..."
+ * ```
+ */
+declare const describePdf: (fileBuffer: Buffer, filename?: string) => Promise<string>;
+/**
+ * Extrae el contenido de un archivo de texto (txt, csv, gpx, json, xml...).
+ * Los archivos cortos se guardan literales; los largos se resumen con el modelo.
+ *
+ * @param fileBuffer - Buffer del archivo
+ * @param filename - Nombre original del archivo
+ * @returns Promise<string> - Contenido literal o resumen
+ *
+ * @example
+ * ```typescript
+ * const content = await describeTextFile(gpxBuffer, 'ruta-domingo.gpx');
+ * // Resultado: "Traza GPS de una carrera de 12,4 km con 340 m de desnivel..."
+ * ```
+ */
+declare const describeTextFile: (fileBuffer: Buffer, filename?: string) => Promise<string>;
+/**
+ * Ficha determinista para los archivos cuyo contenido no se puede extraer
+ * (comprimidos, binarios propietarios, ofimática antigua...).
+ *
+ * No llama a ningún modelo: su valor es que FILE TEXT nunca se quede a NULL, de forma
+ * que el entrenador sabe que hay un adjunto y de qué tipo, en vez de quedarse bloqueado.
+ *
+ * @param mimetype - Tipo MIME del archivo
+ * @param filename - Nombre original del archivo
+ * @param size - Tamaño en bytes
+ * @returns Ficha del archivo en español
+ *
+ * @example
+ * ```typescript
+ * describeOpaqueFile('application/zip', 'fotos.zip', 2515000);
+ * // "[Archivo adjunto: fotos.zip (archivo comprimido ZIP, 2,4 MB). No se puede leer su contenido automáticamente.]"
+ * ```
+ */
+declare const describeOpaqueFile: (mimetype: string, filename?: string, size?: number) => string;
+export { describePdf, describeTextFile, describeOpaqueFile, decodeTextBuffer, looksLikeText, formatBytes, MAX_MODEL_FILE_BYTES };
+//# sourceMappingURL=documents.d.ts.map

package/lib/cjs/types/mediaProcessing/documents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"documents.d.ts","sourceRoot":"","sources":["../../../../src/mediaProcessing/documents.ts"],"names":[],"mappings":";AAIA,QAAA,MAAM,oBAAoB,QAAmB,CAAC;AAsC9C;;;;;GAKG;AACH,QAAA,MAAM,WAAW,UAAW,MAAM,KAAG,MAUpC,CAAC;AAEF;;;;;;GAMG;AACH,QAAA,MAAM,aAAa,eAAgB,MAAM,KAAG,OAW3C,CAAC;AAEF;;;;;;;;;;GAUG;AACH,QAAA,MAAM,gBAAgB,eAAgB,MAAM,KAAG,MAgB9C,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,QAAA,MAAM,WAAW,eAAsB,MAAM,aAAa,MAAM,KAAG,QAAQ,MAAM,CAqBhF,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,gBAAgB,eAAsB,MAAM,aAAa,MAAM,KAAG,QAAQ,MAAM,CA+BrF,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,QAAA,MAAM,kBAAkB,aAAc,MAAM,aAAa,MAAM,SAAS,MAAM,KAAG,MAIhF,CAAC;AAEF,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,aAAa,EAAE,WAAW,EAAE,oBAAoB,EAAE,CAAC"}

package/lib/cjs/types/mediaProcessing/ffmpegUtils.d.ts

@@ -0,0 +1,31 @@
+import ffmpeg from 'fluent-ffmpeg';
+declare const FFMPEG_TIMEOUT_MS = 120000;
+declare const SPEECH_SAMPLE_RATE = 16000;
+/**
+ * Ejecuta un comando de ffmpeg como promesa, matándolo si se pasa del tiempo máximo
+ *
+ * @param command - Comando de fluent-ffmpeg ya configurado
+ * @param label - Etiqueta para el mensaje de error
+ */
+declare const runFfmpeg: (command: any, label: string) => Promise<void>;
+/**
+ * Lee duración y pistas disponibles de un archivo multimedia con ffprobe
+ *
+ * @param inputPath - Ruta del archivo en disco
+ * @returns Duración en segundos y si tiene pista de vídeo y de audio
+ */
+declare const probeMedia: (inputPath: string) => Promise<{
+    duration: number;
+    hasAudio: boolean;
+    hasVideo: boolean;
+}>;
+/**
+ * Crea un directorio temporal, ejecuta el trabajo y lo borra pase lo que pase.
+ * En Cloud Run el temporal vive en RAM, así que dejarlo sin borrar cuesta memoria.
+ *
+ * @param work - Función que recibe la ruta del directorio temporal
+ * @returns Lo que devuelva `work`
+ */
+declare const withTempDir: <T>(work: (dir: string) => Promise<T>) => Promise<T>;
+export { ffmpeg, runFfmpeg, probeMedia, withTempDir, FFMPEG_TIMEOUT_MS, SPEECH_SAMPLE_RATE };
+//# sourceMappingURL=ffmpegUtils.d.ts.map

package/lib/cjs/types/mediaProcessing/ffmpegUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ffmpegUtils.d.ts","sourceRoot":"","sources":["../../../../src/mediaProcessing/ffmpegUtils.ts"],"names":[],"mappings":"AAGA,OAAO,MAAM,MAAM,eAAe,CAAC;AASnC,QAAA,MAAM,iBAAiB,SAAS,CAAC;AAGjC,QAAA,MAAM,kBAAkB,QAAQ,CAAC;AAEjC;;;;;GAKG;AACH,QAAA,MAAM,SAAS,YAAa,GAAG,SAAS,MAAM,KAAG,QAAQ,IAAI,CAqBzD,CAAC;AAEL;;;;;GAKG;AACH,QAAA,MAAM,UAAU,cAAe,MAAM,KAAG,QAAQ;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,CAetG,CAAC;AAEL;;;;;;GAMG;AAEH,QAAA,MAAM,WAAW,kBAAyB,MAAM,8BAW/C,CAAC;AAEF,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,CAAC"}

package/lib/cjs/types/mediaProcessing/image.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+declare const IMAGE_DESCRIPTION_PROMPT = "Describe esta imagen de forma directa y completa en un solo p\u00E1rrafo continuo, sin introducciones ni listas.\nSi la imagen es de contenido deportivo (captura de Garmin/Strava/reloj deportivo, foto de lesi\u00F3n/dolor, gr\u00E1fica de entrenamiento, selfie deportivo, foto de equipamiento, datos de entrenamiento, etc.), incluye el tipo de imagen, los datos relevantes si es una captura (ritmo, distancia, frecuencia card\u00EDaca, zonas, etc.), y cualquier contexto \u00FAtil para entender el estado del atleta o su entrenamiento.\nSi la imagen NO es deportiva, describe su contenido de forma general pero \u00FAtil para entender el contexto de la conversaci\u00F3n.\nDevuelve \u00DANICAMENTE la descripci\u00F3n en espa\u00F1ol, sin comentarios adicionales ni formato de lista. M\u00E1ximo 300 palabras.";
+/**
+ * Genera una descripción de una imagen usando el modelo de visión (Vercel AI SDK)
+ * Contextualizada para una aplicación de fitness/entrenamiento
+ *
+ * @param fileBuffer - Buffer del archivo de imagen
+ * @param mimetype - Tipo MIME del archivo (ej: 'image/jpeg', 'image/png')
+ * @param promptOverride - Prompt alternativo (ej: para fotogramas extraídos de un vídeo)
+ * @returns Promise<string> - Descripción de la imagen
+ *
+ * @example
+ * ```typescript
+ * const description = await describeImage(imageBuffer, 'image/jpeg');
+ * // Resultado: "Captura de Garmin Connect mostrando un entrenamiento de 10km..."
+ * ```
+ */
+declare const describeImage: (fileBuffer: Buffer, mimetype: string, promptOverride?: string) => Promise<string>;
+export { describeImage, IMAGE_DESCRIPTION_PROMPT };
+//# sourceMappingURL=image.d.ts.map

package/lib/cjs/types/mediaProcessing/image.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image.d.ts","sourceRoot":"","sources":["../../../../src/mediaProcessing/image.ts"],"names":[],"mappings":";AAIA,QAAA,MAAM,wBAAwB,8yBAGuF,CAAC;AAEtH;;;;;;;;;;;;;;GAcG;AACH,QAAA,MAAM,aAAa,eAAsB,MAAM,YAAY,MAAM,mBAAmB,MAAM,KAAG,QAAQ,MAAM,CAqB1G,CAAC;AAEF,OAAO,EAAE,aAAa,EAAE,wBAAwB,EAAE,CAAC"}

package/lib/cjs/types/mediaProcessing/index.d.ts

@@ -1,54 +1,67 @@
 /// <reference types="node" />
+import { transcribeAudio } from './audio';
+import { describeImage } from './image';
+import { describeVideo } from './video';
+import { describePdf, describeTextFile, describeOpaqueFile } from './documents';
+declare const FILE_KIND: {
+    readonly AUDIO: "AUDIO";
+    readonly IMAGE: "IMAGE";
+    readonly VIDEO: "VIDEO";
+    readonly PDF: "PDF";
+    readonly TEXT: "TEXT";
+    readonly OPAQUE: "OPAQUE";
+};
+type FileKind = (typeof FILE_KIND)[keyof typeof FILE_KIND];
 /**
- * Transcribe un archivo de audio usando Google Cloud Speech-to-Text
- * Servicio especializado en reconocimiento de voz con soporte para 125+ idiomas
+ * Decide qué extractor le toca a un archivo a partir de su MIME type, su nombre
+ * y, como último recurso, el contenido del propio buffer.
  *
- * @param fileBuffer - Buffer del archivo de audio
- * @param mimetype - Tipo MIME del archivo (ej: 'audio/mpeg', 'audio/wav')
- * @returns Promise<string> - Transcripción del audio en español
- *
- * @example
- * ```typescript
- * const transcription = await transcribeAudio(audioBuffer, 'audio/mpeg');
- * // Resultado: "Hola, quería comentarte que hoy me duele un poco la rodilla..."
- * ```
+ * @param mimetype - Tipo MIME declarado por el cliente
+ * @param filename - Nombre original del archivo
+ * @param fileBuffer - Buffer del archivo
+ * @returns Tipo de tratamiento a aplicar
  */
-declare const transcribeAudio: (fileBuffer: Buffer, mimetype: string) => Promise<string>;
+declare const classifyFile: (mimetype: string, filename: string | undefined, fileBuffer: Buffer) => FileKind;
 /**
- * Genera una descripción de una imagen usando Gemini (Vercel AI SDK)
- * Contextualizada para una aplicación de fitness/entrenamiento
+ * Analiza cualquier adjunto y devuelve su representación en texto.
+ *
+ * Nunca devuelve vacío: los tipos cuyo contenido no se puede extraer (comprimidos,
+ * binarios propietarios, ofimática antigua) reciben una ficha con nombre, tipo y tamaño.
+ * Esto importa porque el entrenador se salta la respuesta si un adjunto no tiene texto,
+ * y un archivo no soportado no debe distinguirse de uno que aún no se ha procesado.
  *
- * @param fileBuffer - Buffer del archivo de imagen
- * @param mimetype - Tipo MIME del archivo (ej: 'image/jpeg', 'image/png')
- * @returns Promise<string> - Descripción de la imagen
+ * @param fileBuffer - Buffer del archivo
+ * @param mimetype - Tipo MIME del archivo
+ * @param filename - Nombre original del archivo
+ * @returns Promise<string> - Transcripción, descripción, resumen o ficha del archivo
  *
  * @example
  * ```typescript
- * const description = await describeImage(imageBuffer, 'image/jpeg');
- * // Resultado: "Captura de Garmin Connect mostrando un entrenamiento de 10km..."
+ * await analyzeFile(pdfBuffer, 'application/pdf', 'analitica.pdf');
+ * // "Analítica de sangre del 3 de junio con ferritina de 28 ng/ml..."
  * ```
  */
-declare const describeImage: (fileBuffer: Buffer, mimetype: string) => Promise<string>;
+declare const analyzeFile: (fileBuffer: Buffer, mimetype: string, filename?: string) => Promise<string>;
 /**
- * Procesa un archivo multimedia (audio o imagen) y guarda el resultado en la base de datos
- * - Audio: usa Google Cloud Speech-to-Text
- * - Imagen: usa Gemini (Vertex AI)
+ * Procesa un adjunto de chat y guarda su texto en la base de datos.
+ * Pensado para llamarse sin await (fire-and-forget) desde el envío del archivo.
  *
  * @param idMessage - ID del mensaje en CHAT MESSAGE
  * @param fileBuffer - Buffer del archivo
  * @param mimetype - Tipo MIME del archivo
+ * @param filename - Nombre original del archivo
  * @returns Promise<void>
  *
  * @example
  * ```typescript
  * // No usar await para ejecutar en background
- * processMediaFile(123, fileBuffer, 'audio/mpeg');
+ * processMediaFile(123, fileBuffer, 'application/pdf', 'informe.pdf');
  * ```
  */
-declare const processMediaFile: (idMessage: number, fileBuffer: Buffer, mimetype: string) => Promise<void>;
+declare const processMediaFile: (idMessage: number, fileBuffer: Buffer, mimetype: string, filename?: string) => Promise<void>;
 /**
- * Reprocesa mensajes multimedia recientes (últimos 2 días) que no tienen FILE TEXT
- * Útil para procesar mensajes enviados antes del deploy de esta funcionalidad
+ * Reprocesa los adjuntos recientes (últimos 2 días) que no tienen FILE TEXT,
+ * sea cual sea su tipo. Útil para rellenar mensajes anteriores al deploy.
  *
  * @param bucket - Instancia del bucket de Google Cloud Storage
  * @returns Promise<{ processed: number; errors: number }> - Estadísticas del reprocesamiento
@@ -63,5 +76,5 @@ declare const reprocessRecentMedia: (bucket: any) => Promise<{
     processed: number;
     errors: number;
 }>;
-export { transcribeAudio, describeImage, processMediaFile, reprocessRecentMedia };
+export { transcribeAudio, describeImage, describeVideo, describePdf, describeTextFile, describeOpaqueFile, classifyFile, analyzeFile, processMediaFile, reprocessRecentMedia, FILE_KIND, };
 //# sourceMappingURL=index.d.ts.map

package/lib/cjs/types/mediaProcessing/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/mediaProcessing/index.ts"],"names":[],"mappings":";AA2BA;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,eAAe,eAAsB,MAAM,YAAY,MAAM,KAAG,QAAQ,MAAM,CA0CnF,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,aAAa,eAAsB,MAAM,YAAY,MAAM,KAAG,QAAQ,MAAM,CAqBjF,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,QAAA,MAAM,gBAAgB,cAAqB,MAAM,cAAc,MAAM,YAAY,MAAM,KAAG,QAAQ,IAAI,CAkBrG,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,QAAA,MAAM,oBAAoB,WAAkB,GAAG;eAAwB,MAAM;YAAU,MAAM;EAwD5F,CAAC;AAEF,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/mediaProcessing/index.ts"],"names":[],"mappings":";AAGA,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,kBAAkB,EAAuC,MAAM,aAAa,CAAC;AAGrH,QAAA,MAAM,SAAS;;;;;;;CAOL,CAAC;AAEX,KAAK,QAAQ,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,CAAC;AAiC3D;;;;;;;;GAQG;AACH,QAAA,MAAM,YAAY,aAAc,MAAM,YAAY,MAAM,GAAG,SAAS,cAAc,MAAM,KAAG,QA0B1F,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,QAAA,MAAM,WAAW,eAAsB,MAAM,YAAY,MAAM,aAAa,MAAM,KAAG,QAAQ,MAAM,CA8BlG,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,QAAA,MAAM,gBAAgB,cAAqB,MAAM,cAAc,MAAM,YAAY,MAAM,aAAa,MAAM,KAAG,QAAQ,IAAI,CASxH,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,QAAA,MAAM,oBAAoB,WAAkB,GAAG;eAAwB,MAAM;YAAU,MAAM;EAmD5F,CAAC;AAEF,OAAO,EACL,eAAe,EACf,aAAa,EACb,aAAa,EACb,WAAW,EACX,gBAAgB,EAChB,kBAAkB,EAClB,YAAY,EACZ,WAAW,EACX,gBAAgB,EAChB,oBAAoB,EACpB,SAAS,GACV,CAAC"}

package/lib/cjs/types/mediaProcessing/video.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="node" />
+/**
+ * Analiza un vídeo descomponiéndolo en lo que sí sabemos leer: un fotograma
+ * representativo (descrito por el modelo de visión) y su pista de audio
+ * (transcrita con Speech-to-Text). Ambas partes son opcionales: un vídeo mudo
+ * devuelve solo la descripción visual, y uno sin imagen solo la transcripción.
+ *
+ * @param fileBuffer - Buffer del vídeo
+ * @param mimetype - Tipo MIME del archivo (ej: 'video/mp4')
+ * @param filename - Nombre original del archivo
+ * @returns Promise<string> - Descripción combinada del vídeo
+ *
+ * @example
+ * ```typescript
+ * const description = await describeVideo(videoBuffer, 'video/mp4', 'tecnica.mp4');
+ * // "Vídeo de 12 s. Imagen: corredor de perfil sobre cinta... Audio: mira cómo apoyo el talón..."
+ * ```
+ */
+declare const describeVideo: (fileBuffer: Buffer, mimetype: string, filename?: string) => Promise<string>;
+export { describeVideo };
+//# sourceMappingURL=video.d.ts.map

package/lib/cjs/types/mediaProcessing/video.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"video.d.ts","sourceRoot":"","sources":["../../../../src/mediaProcessing/video.ts"],"names":[],"mappings":";AAsEA;;;;;;;;;;;;;;;;GAgBG;AACH,QAAA,MAAM,aAAa,eAAsB,MAAM,YAAY,MAAM,aAAa,MAAM,KAAG,QAAQ,MAAM,CAyDpG,CAAC;AAEF,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/lib/cjs/types/prompt/ai.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ai.d.ts","sourceRoot":"","sources":["../../../../src/prompt/ai.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,IAAI,sBAAsB,EAAE,YAAY,IAAI,oBAAoB,EAAE,MAAM,IAAI,CAAC;AAEpG,OAAO,EAAiB,KAAK,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAwKhE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,iBAAe,cAAc,CAAC,OAAO,EAAE,UAAU,CAAC,OAAO,sBAAsB,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC;IAAE,MAAM,EAAE,GAAG,CAAC;IAAC,IAAI,EAAE,UAAU,CAAA;CAAE,CAAC,CAoD/H;AA4DD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,iBAAe,YAAY,CAAC,OAAO,EAAE,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,UAAU,CAAA;CAAE,CAAC,CA4C5H;AA+ED;;;;;;;;;;;;;;;;;GAiBG;AACH,iBAAe,mBAAmB,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC;IAAE,MAAM,EAAE,CAAC,CAAC;IAAC,SAAS,EAAE,UAAU,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC,CAgB5H;AAED,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,mBAAmB,EAAE,CAAC"}
+{"version":3,"file":"ai.d.ts","sourceRoot":"","sources":["../../../../src/prompt/ai.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,IAAI,sBAAsB,EAAE,YAAY,IAAI,oBAAoB,EAAE,MAAM,IAAI,CAAC;AAEpG,OAAO,EAAiB,KAAK,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAwKhE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,iBAAe,cAAc,CAAC,OAAO,EAAE,UAAU,CAAC,OAAO,sBAAsB,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC;IAAE,MAAM,EAAE,GAAG,CAAC;IAAC,IAAI,EAAE,UAAU,CAAA;CAAE,CAAC,CAoD/H;AAkFD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,iBAAe,YAAY,CAAC,OAAO,EAAE,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,UAAU,CAAA;CAAE,CAAC,CA4C5H;AA+ED;;;;;;;;;;;;;;;;;GAiBG;AACH,iBAAe,mBAAmB,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC;IAAE,MAAM,EAAE,CAAC,CAAC;IAAC,SAAS,EAAE,UAAU,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC,CAgB5H;AAED,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,mBAAmB,EAAE,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runnerpro/backend",
-  "version": "1.22.8",
+  "version": "1.23.0",
   "description": "A collection of common backend functions",
   "exports": {
     ".": "./lib/cjs/index.js"