@saulwade/swl-ses 1.0.0

package/habilidades/build-errors-rust/SKILL.md

@@ -0,0 +1,284 @@
+---
+name: build-errors-rust
+description: >
+  Resolución de errores de compilación Rust: cargo build, clippy, borrow checker
+  y lifetimes. Incluye errores de trait bounds, async y feature flags.
+  Cargar cuando un build Rust falle o haya errores del borrow checker, lifetimes
+  o compilación de crates.
+version: "1.0.0"
+herramientasPermitidas: [Read, Bash, Grep]
+exclusiones:
+  - "No cargar para panics en runtime (unwrap() en None, index out of bounds en ejecución) — si `cargo build` pasa pero el programa panics, es un error lógico; diagnosticar con `RUST_BACKTRACE=1`."
+  - "No cargar para diseñar la arquitectura de crates en un workspace Rust — si la pregunta es cómo estructurar un workspace multi-crate o qué crates separar, cargar `rust-patrones` o `rust-experto`."
+  - "No cargar para fallos de tests que son correctos a nivel de compilación (assert_eq! con valor incorrecto) — si `cargo test --no-run` pasa pero los tests fallan, es un error de lógica de tests."
+  - "No cargar para problemas de rendimiento de Rust detectados en profiling — si el código compila y es correcto pero es lento, no es un error de build; usar flamegraph y profiling."
+evolvable: true  # default para skill estandar
+---
+# Build Errors Rust — Diagnóstico y Solución
+
+## Cuándo NO cargar
+
+- El programa compila pero panics en runtime (`unwrap()` en `None`, OOB index) — no es un error de compilación; diagnosticar con `RUST_BACKTRACE=1`.
+- Los tests fallan por `assert_eq!` con valor incorrecto aunque `cargo test --no-run` pasa — es un error de lógica, no de build.
+- La pregunta es cómo estructurar un workspace o separar crates — para arquitectura cargar `rust-patrones`.
+
+## Cuándo cargar
+
+- `cargo build` o `cargo test` falla con mensajes del compilador
+- Errores del borrow checker (`cannot borrow`, `value moved`, `does not live long enough`)
+- Errores de lifetime (`missing lifetime specifier`, `conflicting requirements`)
+- Errores de trait bounds (`the trait X is not implemented for Y`)
+- Warnings de clippy que bloquean CI con `RUSTFLAGS="-D warnings"`
+- Errores de features o dependencias de crates
+
+---
+
+## Borrow Checker — Errores Más Frecuentes
+
+### `cannot borrow as mutable because it is also borrowed as immutable`
+
+**Causa**: se intenta mutar un valor mientras existe una referencia inmutable viva.
+
+```rust
+// MAL
+let mut v = vec![1, 2, 3];
+let first = &v[0];   // referencia inmutable activa
+v.push(4);           // error: mutacion mientras existe referencia
+println!("{first}");
+
+// BIEN: acotar el lifetime de la referencia inmutable
+let mut v = vec![1, 2, 3];
+{
+    let first = &v[0];
+    println!("{first}");
+}  // referencia inmutable cae aquí
+v.push(4);
+```
+
+### `value used after move`
+
+**Causa**: un tipo sin `Copy` se mueve a otra variable o función y luego se usa.
+
+```rust
+// MAL
+let s = String::from("hola");
+let s2 = s;         // s se mueve a s2
+println!("{s}");    // error: s fue movido
+
+// BIEN — opción 1: clonar si se necesitan dos copias independientes
+let s2 = s.clone();
+println!("{s} {s2}");
+
+// BIEN — opción 2: pasar referencia en vez de mover
+fn imprimir(texto: &str) { println!("{texto}"); }
+imprimir(&s);
+println!("{s}");  // s sigue siendo válido
+```
+
+### `does not live long enough`
+
+**Causa**: una referencia se usa más allá del lifetime del valor al que apunta.
+
+```rust
+// MAL
+fn obtener_nombre() -> &str {  // error: falta especificador de lifetime
+    let nombre = String::from("Ana");
+    &nombre  // nombre se destruye al salir de la función
+}
+
+// BIEN — opción 1: retornar String (owned)
+fn obtener_nombre() -> String {
+    String::from("Ana")
+}
+
+// BIEN — opción 2: tomar referencia de entrada y retornarla
+fn primer_nombre<'a>(texto: &'a str) -> &'a str {
+    texto.split_whitespace().next().unwrap_or("")
+}
+```
+
+---
+
+## Lifetimes — Errores de Especificación
+
+### `missing lifetime specifier`
+
+**Causa**: el compilador no puede inferir el lifetime de una referencia en la firma.
+
+```rust
+// MAL — el compilador no sabe de dónde viene el lifetime del retorno
+struct Extractor { separador: char }
+impl Extractor {
+    fn extraer(&self, texto: &str) -> &str {  // ambiguo: de &self o de texto?
+        texto.split(self.separador).next().unwrap_or("")
+    }
+}
+
+// BIEN — anotar explícitamente
+impl Extractor {
+    fn extraer<'a>(&self, texto: &'a str) -> &'a str {
+        texto.split(self.separador).next().unwrap_or("")
+    }
+}
+```
+
+### `lifetime may not live long enough` en structs con referencias
+
+```rust
+// MAL
+struct Reporte {
+    titulo: &str,  // error: falta parametro de lifetime
+}
+
+// BIEN
+struct Reporte<'a> {
+    titulo: &'a str,
+}
+```
+
+---
+
+## Trait Bounds — Errores de Implementación
+
+### `the trait X is not implemented for Y`
+
+**Causa**: se usa un tipo donde se requiere un trait que no implementa.
+
+```rust
+// MAL
+fn imprimir_todos<T>(items: Vec<T>) {
+    for item in items {
+        println!("{item}");  // error: T no implementa Display
+    }
+}
+
+// BIEN — agregar el bound necesario
+use std::fmt::Display;
+fn imprimir_todos<T: Display>(items: Vec<T>) {
+    for item in items {
+        println!("{item}");
+    }
+}
+```
+
+### `cannot be sent between threads safely` / `future is not Send`
+
+**Causa**: tipo que no implementa `Send` o `Sync` se usa en contexto async multi-hilo
+(tokio, rayon).
+
+```rust
+// MAL — Rc no es Send
+use std::rc::Rc;
+async fn tarea() {
+    let dato = Rc::new(42);
+    tokio::spawn(async move { println!("{dato}"); });  // error: Rc no es Send
+}
+
+// BIEN — usar Arc para compartir entre hilos
+use std::sync::Arc;
+async fn tarea() {
+    let dato = Arc::new(42);
+    tokio::spawn(async move { println!("{dato}"); });  // ok: Arc es Send
+}
+```
+
+---
+
+## Cargo Build — Errores de Dependencias y Features
+
+### `unresolved import` / `use of undeclared crate`
+
+**Causa**: crate no declarado en `Cargo.toml` o feature no habilitada.
+
+```toml
+# Verificar que el crate existe en Cargo.toml
+[dependencies]
+serde = { version = "1", features = ["derive"] }
+tokio = { version = "1", features = ["full"] }
+
+# Error típico: usar serde::Serialize sin habilitar feature "derive"
+# serde = "1"   <- MAL si se usa #[derive(Serialize)]
+```
+
+### `feature X is not defined in package Y`
+
+**Causa**: se solicita un feature que no existe en esa versión del crate.
+
+```toml
+# Diagnóstico: ver features disponibles
+# cargo metadata --format-version 1 | jq '.packages[] | select(.name=="nombre") | .features'
+
+# MAL — feature inventado o renombrado en nueva version
+tokio = { version = "1", features = ["io_util"] }  # nombre incorrecto
+
+# BIEN — nombre exacto del feature
+tokio = { version = "1", features = ["io-util"] }
+```
+
+---
+
+## Clippy — Warnings que Bloquean CI
+
+| Warning | Causa | Solución |
+|---------|-------|----------|
+| `needless_return` | `return expr;` al final | Quitar `return` |
+| `clone_on_copy` | `.clone()` en tipo `Copy` | Quitar `.clone()` |
+| `manual_map` | `match opt { Some(x) => Some(f(x)), None => None }` | Usar `opt.map(f)` |
+| `unwrap_or_else` | `.unwrap_or(f())` cuando `f()` es costosa | Usar `.unwrap_or_else(\|\| f())` |
+| `redundant_closure` | `\|x\| f(x)` donde `f` es una función | Usar `f` directamente |
+
+```rust
+// Suprimir warning específico documentado con razón
+#[allow(clippy::too_many_arguments)]
+fn configurar_pipeline(/* 8 parámetros justificados */) { }
+
+// Para todo el proyecto en clippy.toml:
+// avoid-breaking-exported-api = false
+```
+
+---
+
+## Errores Async Avanzados
+
+### `async fn in trait` (pre Rust 1.75)
+
+**Causa**: versiones anteriores no soportaban `async fn` directo en traits.
+
+```rust
+// MAL en Rust < 1.75
+trait Servicio {
+    async fn procesar(&self) -> Result<(), Error>;  // no permitido
+}
+
+// BIEN — usar crate async-trait o boxear el futuro
+use async_trait::async_trait;
+#[async_trait]
+trait Servicio {
+    async fn procesar(&self) -> Result<(), Error>;
+}
+
+// O en Rust 1.75+ directamente sin async-trait
+trait Servicio {
+    fn procesar(&self) -> impl Future<Output = Result<(), Error>> + Send;
+}
+```
+
+---
+
+## Gotchas / Errores comunes no obvios
+
+- **El compilador sugiere agregar lifetime `'a` pero agregarlo produce un error diferente en el llamador**: el error original era incorrecto en su diagnóstico — el problema real es que la función devuelve una referencia que vive menos que el caller. Causa: rustc a veces sugiere lifetimes que resuelven el error local pero desplazan el problema al sitio de llamada. Solución: en lugar de seguir la sugerencia del compilador ciegamente, dibujar el diagrama de ownership: si el valor puede no existir cuando se necesita, la solución correcta es clonar o devolver un `String`/`Vec` owned en lugar de una referencia.
+- **`cannot move out of X because it is borrowed`** aparece en código que debería ser seguro: hay un `Mutex::lock()` cuyo guard no está en una variable explícita — se crea temporariamente en una expresión y se libera antes de lo esperado. Causa: `mutex.lock().unwrap().metodo()` libera el lock al final de la expresión, pero si el valor retornado tiene un lifetime ligado al lock, el compilador detecta el conflicto. Solución: asignar el guard a una variable explícita con `let guard = mutex.lock().unwrap(); let val = guard.metodo();`.
+- **Clippy bloquea CI con `#[allow(clippy::X)]` que ya no es necesario en la nueva versión**: después de actualizar Rust, el `#[allow]` para un lint que ya no existe produce un warning de "unknown lint" que con `-D warnings` se convierte en error. Causa: los nombres de lints de clippy cambian entre versiones. Solución: ejecutar `cargo clippy 2>&1 | grep "unknown lint"` para detectar `#[allow]` obsoletos y eliminarlos.
+- **`cargo build` falla con `error: failed to run custom build command for X-sys`**: los bindings de C a través de `*-sys` crates requieren que la librería nativa esté instalada en el sistema. Causa: crates como `openssl-sys`, `sqlite3-sys` o `libpq-sys` ejecutan un script de build que invoca `pkg-config` para encontrar la librería del sistema; si no está instalada, el build falla con un mensaje confuso. Solución: instalar la librería del sistema (`libssl-dev`, `libsqlite3-dev`, etc.) o agregar al `Cargo.toml` la feature `vendored` si el crate la ofrece (`openssl = { features = ["vendored"] }`).
+
+## Checklist de Diagnóstico
+
+- [ ] Leer el error completo: rustc incluye la causa, ubicación y sugerencia.
+- [ ] Ejecutar `cargo check` antes de `cargo build` para feedback más rápido.
+- [ ] Usar `cargo clippy -- -D warnings` en CI para detectar problemas anticipados.
+- [ ] Si el error menciona lifetime: dibujar el diagrama de propiedad en papel.
+- [ ] Si el error es `not Send`: buscar `Rc`, `RefCell`, `*mut`, raw pointers en el tipo.
+- [ ] Si hay conflicto de features: `cargo tree -f "{p} {f}"` para ver el árbol de features.
+- [ ] `RUST_BACKTRACE=1 cargo test` para stack trace completo en panics.
+- [ ] `cargo expand` (requiere `cargo-expand`) para depurar macros que no compilan.

package/habilidades/build-errors-swift/SKILL.md

@@ -0,0 +1,272 @@
+---
+name: build-errors-swift
+description: >
+  Resolución de errores de compilación Swift: swiftc, Swift Package Manager,
+  Xcode build y Swift 6 concurrency. Incluye errores de signing, provisioning,
+  módulos y linker.
+  Cargar cuando un build Swift/iOS falle o haya errores de compilación.
+version: "1.0.0"
+herramientasPermitidas: [Read, Bash, Grep]
+exclusiones:
+  - "No cargar para bugs de lógica de la app iOS/macOS en runtime (crashes en EXC_BAD_ACCESS, lógica de negocio incorrecta) cuando `xcodebuild` compila — si el archive se genera pero la app crashea, no es un error de compilación."
+  - "No cargar para fallos de XCTest cuando el build compila (assertions fallidas, snapshot tests que difieren) — es un error de lógica de tests, no de build."
+  - "No cargar para diseñar la arquitectura Swift/iOS desde cero (MVVM, TCA, SwiftUI vs UIKit) — si la pregunta es qué patrón usar, cargar `swift-patrones` o `swift-experto`."
+  - "No cargar para problemas de distribución de App Store o TestFlight que no son errores de compilación (metadatos, capturas de pantalla, review guidelines) — esos son problemas de distribución, no de build."
+evolvable: true  # default para skill estandar
+---
+# Build Errors Swift — Diagnóstico y Solución
+
+## Cuándo NO cargar
+
+- El build compila pero la app crashea en runtime (EXC_BAD_ACCESS, lógica incorrecta) — no es un error de build; analizar con el crash log y Xcode debugger.
+- XCTest compila pero las assertions fallan — es un error de lógica de tests.
+- La pregunta es qué arquitectura usar en SwiftUI — para diseño cargar `swift-patrones`.
+
+## Cuándo cargar
+
+- `xcodebuild` o `swift build` falla con errores del compilador
+- Errores de Swift 6 concurrency (`Sendable`, actor isolation)
+- Errores de SPM (resolución de dependencias, version conflicts)
+- Errores de Xcode (signing, provisioning profile, bitcode)
+- `module not found` o errores de importación
+- Errores de linker en proyectos Swift/ObjC mixtos
+
+---
+
+## Errores del Compilador Swift
+
+### `value of type X has no member Y`
+
+**Causa**: propiedad o método no existe en el tipo, typo en el nombre, o falta import.
+
+```swift
+// MAL
+import Foundation
+let url = URL(string: "https://ejemplo.com")
+let host = url.hostname  // error: URL no tiene 'hostname'
+
+// BIEN — verificar nombre correcto en documentación
+let host = url?.host          // propiedad correcta en URL
+let hostStr = url?.host()     // en versiones modernas es funcion
+
+// MAL — acceder a miembro de Optional sin desenvolver
+var texto: String? = "hola"
+let longitud = texto.count    // error: Optional<String> no tiene 'count'
+
+// BIEN
+let longitud = texto?.count ?? 0
+```
+
+### `cannot convert value of type X to expected argument type Y`
+
+**Causa**: tipo incorrecto pasado a una función o inicializador.
+
+```swift
+// MAL
+func configurar(timeout: TimeInterval) { }
+configurar(timeout: 30)     // error: Int no convierte a TimeInterval implícitamente
+
+// BIEN — conversión explícita o usar el tipo correcto desde el inicio
+configurar(timeout: TimeInterval(30))
+configurar(timeout: 30.0)    // Double literal -> TimeInterval (alias de Double)
+
+// MAL — String vs Data
+URLSession.shared.uploadTask(with: request, from: "datos")  // error: String no es Data
+
+// BIEN
+let datos = "datos".data(using: .utf8)!
+URLSession.shared.uploadTask(with: request, from: datos)
+```
+
+### `expression is ambiguous without more context`
+
+**Causa**: inferencia de tipos falla por sobrecarga de funciones o literales ambiguos.
+
+```swift
+// MAL
+let resultado = [1, 2, 3].map { $0 * 2 }  // puede ser ambiguo en contextos complejos
+
+// BIEN — anotar el tipo explícitamente
+let resultado: [Int] = [1, 2, 3].map { $0 * 2 }
+
+// MAL en SwiftUI
+Text(valor)  // error si 'valor' puede ser Int o String
+
+// BIEN
+Text(String(valor))
+Text("\(valor)")
+```
+
+---
+
+## Swift 6 Concurrency — Errores de Sendable y Actor Isolation
+
+### `sending non-Sendable value across actor boundary`
+
+**Causa**: se pasa un tipo no-Sendable a un contexto de actor o tarea async.
+
+```swift
+// MAL — clase mutable sin Sendable
+class ConfiguracionMutable {
+    var tema: String = "oscuro"
+}
+
+// En Swift 6 esto falla:
+Task {
+    let config = ConfiguracionMutable()
+    await procesador.configurar(config)  // error: no es Sendable
+}
+
+// BIEN — opción 1: usar struct (implícitamente Sendable si todos los campos lo son)
+struct Configuracion: Sendable {
+    let tema: String
+}
+
+// BIEN — opción 2: marcar como @unchecked Sendable con sincronización manual
+final class ConfiguracionSincronizada: @unchecked Sendable {
+    private let lock = NSLock()
+    private var _tema: String = "oscuro"
+    var tema: String {
+        get { lock.withLock { _tema } }
+        set { lock.withLock { _tema = newValue } }
+    }
+}
+```
+
+### `actor-isolated property can not be referenced from a non-isolated context`
+
+**Causa**: acceder a propiedad de un actor sin `await`.
+
+```swift
+// MAL
+actor GestorCache {
+    var elementos: [String: Any] = [:]
+}
+
+let gestor = GestorCache()
+print(gestor.elementos)  // error: requiere await
+
+// BIEN — acceder desde contexto async
+Task {
+    let elems = await gestor.elementos
+    print(elems)
+}
+
+// BIEN — si el acceso es frecuente, exponer una función nonisolated
+extension GestorCache {
+    nonisolated var descripcion: String { "GestorCache" }
+}
+```
+
+---
+
+## Swift Package Manager — Errores de Dependencias
+
+### `the package at X has no remote at Y`
+
+**Causa**: URL del repositorio incorrecta o privada sin credenciales.
+
+```swift
+// En Package.swift — verificar URL exacta
+.package(url: "https://github.com/org/paquete.git", from: "1.0.0")
+
+// Para paquetes privados en Xcode:
+// Xcode > Preferences > Accounts > agregar cuenta GitHub/GitLab con token
+```
+
+### Conflicto de versiones entre dependencias transitivas
+
+```swift
+// Error: "package has already been required using a different source control requirement"
+// Un paquete requerido con diferentes rangos de versión
+
+// SOLUCIÓN: pinear versión exacta en Package.swift de la app
+.package(url: "https://github.com/apple/swift-log.git", exact: "1.5.3")
+
+// O usar el mínimo compatible que satisfaga a todos
+.package(url: "https://github.com/apple/swift-log.git", from: "1.5.0")
+```
+
+---
+
+## Xcode Build — Signing y Provisioning
+
+### `Code signing is required for product type 'Application'`
+
+```bash
+# Diagnóstico rápido
+xcodebuild -showBuildSettings | grep -E "CODE_SIGN|DEVELOPMENT_TEAM|PROVISIONING"
+
+# Para CI sin cuenta de desarrollador (simulador/tests):
+xcodebuild test \
+  -scheme MiApp \
+  -destination 'platform=iOS Simulator,name=iPhone 15' \
+  CODE_SIGNING_ALLOWED=NO \
+  CODE_SIGNING_REQUIRED=NO
+
+# Para builds de producción: usar automatic signing en Xcode
+# o exportar el perfil de aprovisionamiento como archivo .mobileprovision
+```
+
+### `Provisioning profile doesn't include the X entitlement`
+
+**Causa**: la capability está en el proyecto pero no en el provisioning profile.
+
+```
+Pasos de resolución:
+1. Xcode > Signing & Capabilities > verificar que la capability está listada
+2. developer.apple.com > Identifiers > actualizar App ID con la capability
+3. Regenerar provisioning profile en developer.apple.com
+4. Xcode > Preferences > Accounts > Download Manual Profiles
+```
+
+---
+
+## Module Not Found / Linker Errors
+
+### `No such module 'X'`
+
+**Causa**: framework no agregado al target, o SPM no resuelto.
+
+```bash
+# Para SPM: resolver paquetes
+File > Packages > Resolve Package Versions
+
+# Para frameworks del sistema: agregar en Xcode
+# Target > Build Phases > Link Binary With Libraries > agregar el framework
+
+# Para frameworks propios: verificar FRAMEWORK_SEARCH_PATHS en Build Settings
+```
+
+### `Undefined symbol: _X` (linker error)
+
+**Causa**: símbolo declarado pero no implementado, o librería no linkeada.
+
+```bash
+# Diagnóstico: el error indica el archivo objeto que necesita el símbolo
+# Buscar en que libreria/framework esta el simbolo:
+nm -gU /path/to/Framework.framework/Framework | grep "_NombreSimbolo"
+
+# Si es Swift <-> ObjC interop: verificar que el bridging header esta configurado
+# Build Settings > Swift Compiler - General > Objective-C Bridging Header
+```
+
+---
+
+## Gotchas / Errores comunes no obvios
+
+- **Swift 6 strict concurrency activa en el package pero no en los targets individuales**: `swift build` falla con errores de actor isolation aunque el developer activó `SWIFT_STRICT_CONCURRENCY=complete` en el paquete raíz. Causa: en Swift Package Manager, el flag de concurrency debe declararse en cada target individualmente en `Package.swift` con `swiftSettings: [.enableExperimentalFeature("StrictConcurrency")]` — el setting del paquete padre no se propaga automáticamente. Solución: agregar el setting por target explícitamente, o usar el flag de compilación `-strict-concurrency=complete` en CI.
+- **SPM resuelve el paquete correctamente en Xcode pero `swift build` en terminal falla con "no such module"**: el proyecto Xcode tiene un `DerivedData` cacheado con la versión correcta, pero en terminal el directorio de build es diferente. Causa: Xcode y `swift build` usan directorios de caché diferentes (`DerivedData` vs `.build/`). Solución: ejecutar `swift package resolve && swift build` desde el directorio del paquete, o eliminar el directorio `.build/` para forzar una resolución limpia.
+- **Error de signing "No profiles for bundle identifier X"** en CI aunque el certificate y el provisioning profile están instalados: el provisioning profile está instalado para el usuario del developer pero el CI ejecuta con un usuario diferente. Causa: los profiles se instalan en `~/Library/MobileDevice/Provisioning Profiles/` del usuario actual — en CI cada ejecución puede tener un usuario diferente. Solución: copiar el provisioning profile al directorio del usuario del agente CI en el step de setup, o usar `xcodebuild -allowProvisioningUpdates` con App Store Connect credentials.
+- **`Product > Clean Build Folder` resuelve el error temporalmente pero vuelve a aparecer en el siguiente build incremental**: hay un archivo generado por un script de build phase que tiene un timestamp más nuevo que los archivos fuente, forzando una recompilación con el archivo corrupto. Causa: un `Run Script Build Phase` sin `Input Files` ni `Output Files` declarados se ejecuta en cada build incremental y puede sobreescribir archivos generados con contenido incorrecto. Solución: agregar `Input Files` y `Output Files` explícitos al script de build phase para que Xcode solo lo ejecute cuando los inputs cambien.
+
+## Checklist de Diagnóstico
+
+- [ ] Leer el error completo en Xcode: el error secundario suele ser la causa raíz.
+- [ ] `Product > Clean Build Folder` (Cmd+Shift+K) antes de reintentar.
+- [ ] Para errores de Swift 6: habilitar incrementalmente con `SWIFT_STRICT_CONCURRENCY`.
+- [ ] Para SPM: `File > Packages > Reset Package Caches` si hay errores de resolución.
+- [ ] `xcodebuild -verbose` en terminal para diagnóstico más detallado que la UI.
+- [ ] Verificar que `IPHONEOS_DEPLOYMENT_TARGET` es compatible con las APIs usadas.
+- [ ] Para errores de signing en CI: verificar que los certificados no expiraron.
+- [ ] `swift package diagnose-api-breaking-changes` para detectar breaking changes en SPM.