feat(datascience): auto-commit con 5 cambios

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

docs/capabilities/INDEX.md

@@ -14,7 +14,7 @@ Indice de grupos de capacidades del registry. Cada grupo agrupa >=3 funciones qu
 
 | Grupo | N | Que cubre |
 |---|---|---|
-| [gamedev-2d](gamedev-2d.md) | 36 | Assets 2D para Godot via ComfyUI: 31 builders de workflow (pixelart/seamless/iso/sprite/topdown/card/enemy/prop/structure/foliage/trap/projectile/decal/particle/rune/weather/badge/skill-tree/dialogue/icon/portrait/VFX...) + 5 de apoyo: post-proceso (pixelize, luma->alpha) + puente de assets a Godot 4 (.import + reimport headless). Tag canonico `gamedev-2d` (antes `gamedev`, ya unificado) |
+| [gamedev-2d](gamedev-2d.md) | 47 | Assets 2D para Godot via ComfyUI: 36 builders de workflow (31 de generación desde texto: pixelart/seamless/iso/sprite/topdown/card/enemy/prop/structure/foliage/trap/projectile/decal/particle/rune/weather/badge/skill-tree/dialogue/icon/portrait/VFX... + 5 de transformación desde imagen: asset_variant/sprite_from_sketch/inpaint_asset/outpaint_asset/directional_sprite) + 11 de apoyo: post-proceso (pixelize, luma->alpha, flatten_alpha), puente de assets a Godot 4 (.import + reimport headless), style presets (get/apply_gamedev_style_preset) y pipelines one-shot (asset_pack/character_set/styled_asset). Tag canonico `gamedev-2d` (antes `gamedev`, ya unificado) |
 | [gamedev-engine](gamedev-engine.md) | 8 | Runtime de juego C++ multiplataforma (PC + WebAssembly): SDL3 + sokol_gfx + miniaudio. Game loop fixed-timestep, camara 2D, input unificado (teclado/gamepad/touch), sprite batch, setup de render/audio y build a wasm. Grupo hermano de `gamedev-2d` (este ejecuta el juego, aquel genera los assets) |
 | [registry](registry.md) | 17 | Auditoria y monitorizacion del propio registry: copied-code, uses-functions, unused, proposals, telemetria |
 | [systemd](systemd.md) | 14 | Generar, instalar, restart y status de unit files systemd via SSH (deploys a VPS) |
@@ -72,8 +72,9 @@ Indice de grupos de capacidades del registry. Cada grupo agrupa >=3 funciones qu
 | [seo](seo.md) | 3 | SEO orientado a datos sobre Google Search Console: autenticar con service account (`gsc_auth`), extraer Search Analytics paginado (`pull_gsc_search_analytics`) y el pipeline de ingesta a DuckDB + espejo Postgres para Metabase (`ingest_gsc_search_analytics`). Cadena de ingesta del proyecto `seo_analytics`; alimenta dashboards de striking distance, CTR opportunities y content decay |
 | [local-hub](local-hub.md) | 4 | Exponer los procesos locales como subdominios `*.localhost` (via Caddy, sin DNS) y reunirlos en una pantalla principal Glance con estado en vivo, refrescada a diario por dag_engine. Descubre servicios (manifiesto + registry), renderiza Caddyfile + config Glance (puras), y el pipeline `refresh_local_hub` regenera+recarga. Fuente de verdad: `apps/local_hub/local_services.yaml` |
 | [comfyui-judge](comfyui-judge.md) | 4 | Panel multi-juez de calidad de imagen: estético LAION-V2 (`comfyui_score_aesthetic`, 0-10) + fidelidad CLIP prompt↔imagen (`comfyui_score_clip_alignment`, 0-1) + crítica LLM-vision (`comfyui_critique_image_llm`, good/bad). Agregados por voto mayoría en `comfyui_judge_image`. Gate objetivo para tests/DoD y el bucle de mejora de skills ComfyUI; degrada con gracia si un juez cae. Jueces estético/fidelidad por subproceso al venv ComfyUI (torch+open_clip), crítico via claude-direct |
-| [comfyui](comfyui.md) | 29 | Controlar ComfyUI (Stable Diffusion por grafos) de dos formas: por API HTTP (build_txt2img_workflow puro → submit → wait → object_info; download_model con validación Civitai/HF) y por la UI web vía CDP sobre la pestaña abierta (load_workflow_ui, set_node_widget_ui para tunear prompt/steps/seed en vivo, queue_prompt_ui = botón Queue Prompt, export_workflow_ui, refresh_nodes_ui). El API format es el puente entre ambos caminos. Las funciones de UI componen `cdp_eval`. Incluye imagen→3D nativo (Hunyuan3D-2, tag `img-to-3d`): build_image_to_3d_workflow + fetch_output_mesh + install_3d_model + pipeline image_to_3d_oneshot |
+| [comfyui](comfyui.md) | 126 | Controlar ComfyUI (Stable Diffusion por grafos) de dos formas: por API HTTP (build_txt2img_workflow puro → submit → wait → object_info; download_model con validación Civitai/HF) y por la UI web vía CDP sobre la pestaña abierta (load_workflow_ui, set_node_widget_ui para tunear prompt/steps/seed en vivo, queue_prompt_ui = botón Queue Prompt, export_workflow_ui, refresh_nodes_ui). El API format es el puente entre ambos caminos. Las funciones de UI componen `cdp_eval`. Cubre txt2img/img2img/inpaint/controlnet/sdxl-refiner/flux, upscale + hires-fix + facedetailer, vídeo (LTX/Wan/SVD), audio (ACE-Step), imagen→3D nativo (Hunyuan3D-2) + post-proceso de malla, templates oficiales, civitai harvest y control de cola. N = funciones con tag `comfyui` (incluye los sub-grupos `comfyui-skill`/`comfyui-styles` y 45 de `gamedev-2d`); las páginas madre de cada sub-grupo desglosan su parte |
-| [comfyui-skill](comfyui-skill.md) | 11 | Tratar una configuración de generación ComfyUI como una skill: receta versionada en disco (checkpoint + LoRAs + params + scaffold de prompt + post-proceso) que se compila a un workflow cambiando solo el subject. Save/load/list de recetas, bucle de mejora genera→juzga→bump con gate objetivo (el score del juez decide qué se promueve), export de la skill a grafo cargable en el navegador, y cosecha de Civitai (extract_recipe_from_png + harvest oneshot) que destila el workflow embebido de una imagen pública en una skill candidata |
+| [comfyui-skill](comfyui-skill.md) | 17 | Tratar una configuración de generación ComfyUI como una skill: receta versionada en disco (checkpoint + LoRAs + params + scaffold de prompt + post-proceso) que se compila a un workflow cambiando solo el subject. Save/load/list de recetas, bucle de mejora genera→juzga→bump con gate objetivo (el score del juez decide qué se promueve), export de la skill a grafo cargable en el navegador, y cosecha de Civitai (extract_recipe_from_png + harvest oneshot) que destila el workflow embebido de una imagen pública en una skill candidata |
+| [comfyui-styles](comfyui-styles.md) | 5 | Capa de estilo reutilizable sobre los builders ComfyUI. Catálogo WAS (tag `comfyui-styles`): `curated_styles_catalog` (~190 estilos), `generate_styles_llm` (genera estilos por LLM via ask_llm), `append_styles` (merge+dedup+backup sobre el styles.json del selector WAS). Style presets gamedev (tag `gamedev-2d`): `get_gamedev_style_preset` (gameboy/ghibli/pixel-art-retro como datos puros) + `apply_style_preset` (preset+subject → kwargs de un builder gamedev-2d). El estilo se trata como dato curado, no como prompt repetido |
 | [comfyui-overview](comfyui-overview.md) | — | Mapa cross-grupo de las capacidades de generación ComfyUI (txt2img, img2img/inpaint, controlnet, skills/multiestilo-LoRA, video, upscale/detail, 3D, juez, operación): cada capacidad → builders/pipelines del registry + grafos UI + skills que la cubren. Índice de entrada al stack ComfyUI; las firmas y gotchas viven en `comfyui.md`/`comfyui-skill.md`/`comfyui-judge.md`. Catálogo navegable de los grafos en disco (subcarpetas por capacidad) en `~/ComfyUI/CAPABILITIES.md` |
 
 ## Como anadir grupo

docs/capabilities/comfyui-overview.md

@@ -8,7 +8,9 @@ Las tres páginas madre detalladas siguen siendo la fuente de verdad por grupo:
 
 - [comfyui.md](comfyui.md) — grupo `comfyui`: builders de workflow, ejecución HTTP, UI vía CDP, I/O.
 - [comfyui-skill.md](comfyui-skill.md) — grupo `comfyui-skill`: recetas de estilo versionadas.
+- [comfyui-styles.md](comfyui-styles.md) — grupo `comfyui-styles`: presets + catálogo de estilo (selector WAS).
 - [comfyui-judge.md](comfyui-judge.md) — grupo `comfyui-judge`: panel multi-juez de calidad.
+- [gamedev-2d.md](gamedev-2d.md) — grupo `gamedev-2d`: 47 builders de assets 2D para Godot (45 también `comfyui`).
 
 El catálogo navegable con los grafos concretos en disco (subcarpetas por capacidad, cómo cargar
 cada uno) vive **fuera del repo**, junto a la instalación: `~/ComfyUI/CAPABILITIES.md`. Este doc es
@@ -25,7 +27,9 @@ Filtros MCP: `mcp__registry__fn_search query="" tag="comfyui"` (y `tag="comfyui-
 | 02 | **img2img / inpaint** | imagen → imagen, regenerar zona enmascarada | `build_img2img`, `build_inpaint` | ✅ | — |
 | 03 | **controlnet** | generación guiada por mapa (depth/pose/canny) | `build_controlnet` | ✅ | — |
 | 04 | **skills (multiestilo/LoRA)** | recetas de estilo reproducibles con `{subject}` | `build_skill_workflow`, `inject_lora`, `generate_with_skill_oneshot`, `harvest_civitai_skill_oneshot` | ✅ ×2 | ✅ ×2 |
+| 04b | **styles (presets/catálogo)** | estilo reutilizable: catálogo WAS + presets gamedev | `curated_styles_catalog`, `generate_styles_llm`, `append_styles`, `get_gamedev_style_preset`, `apply_style_preset` | — | — |
 | 05 | **video** | imagen/texto → vídeo (SVD, LTX, Wan) | `build_img2vid`, `build_video` | ✅ | — |
+| 05b | **audio** | texto → música/SFX/voz (ACE-Step) | `build_audio_workflow`, `fetch_output_audio` | — | — |
 | 06 | **upscale / detail** | ampliar y recuperar detalle (ESRGAN, hires-fix, FaceDetailer) | `build_upscale`, `build_hires_fix`, `inject_hires_fix`, `build_facedetailer` | — | — |
 | 07 | **3D** | imagen/texto → malla 3D (Hunyuan3D) + limpieza | `build_image_to_3d`, `build_textured_3d_multiview`, `image_to_3d_oneshot`, `text_to_3d_oneshot`, `mesh_cleanup_oneshot` | — | — |
 | 08 | **juez / calidad** | puntuar lo generado (gate de DoD y bucle de mejora) | `judge_image`, `score_aesthetic`, `score_clip_alignment`, `critique_image_llm` | — | — |
@@ -67,6 +71,16 @@ sus IDs reales cuando se ejecute `fn index`.
 - `comfyui_extract_recipe_from_png_py_ml` — destila un PNG de Civitai en receta candidata.
 - CRUD + telemetría: `comfyui_list_skills_py_ml`, `comfyui_load_skill_py_ml`, `comfyui_save_skill_py_ml`, `comfyui_update_skill_score_py_ml`, `comfyui_bump_skill_version_py_ml`.
 
+### 04b · styles (presets / catálogo)
+
+Página madre: [comfyui-styles.md](comfyui-styles.md). Estilo reutilizable como dato, no como prompt repetido.
+
+- `comfyui_curated_styles_catalog_py_ml` (pura) — catálogo curado (~190 estilos) para el selector WAS.
+- `comfyui_generate_styles_llm_py_ml` (impura) — genera N estilos de una categoría vía `ask_llm`.
+- `comfyui_append_styles_py_ml` (impura) — fusiona estilos sobre el `styles.json` WAS (merge+dedup+backup).
+- `comfyui_get_gamedev_style_preset_py_ml` (pura) — receta de *style preset* gamedev (gameboy/ghibli/pixel-art-retro).
+- `comfyui_apply_style_preset_py_ml` (pura) — traduce un preset + subject a los kwargs de un builder gamedev-2d.
+
 ### 05 · video
 
 - `comfyui_build_img2vid_workflow_py_ml` (pura) — SVD: condicionamiento por CLIP_VISION (sin prompt de texto).

docs/capabilities/comfyui-skill.md

@@ -12,6 +12,13 @@ submit/wait). Una skill no es un workflow: es la *receta* que compila a uno.
 
 Filtro MCP: `mcp__registry__fn_search query="" tag="comfyui-skill"`.
 
+> **Tamaño del grupo (al 28/06/2026):** 17 funciones con tag `comfyui-skill` — CRUD de recetas
+> (save/load/list), compilación a workflow (`build_skill_workflow`), inyectores encadenables
+> (`inject_hires_fix`/`inject_multi_lora`, `build_ipadapter_workflow`), bucle de mejora
+> genera→juzga→bump (`generate_with_skill_oneshot` + `update_skill_score` + `bump_skill_version`),
+> export a grafo (`export_skill_template`), mixer de capacidades (`compose_capabilities` +
+> `generate_mixed_oneshot`) y cosecha de Civitai (`extract_recipe_from_png` + `harvest_civitai_skill_oneshot`).
+
 ## Qué es una skill
 
 Una receta vive en `~/ComfyUI/skills_library/<slug>/` y la manipulan las funciones de este grupo:

docs/capabilities/comfyui-styles.md

@@ -0,0 +1,101 @@
+# ComfyUI Styles — presets y catálogo de estilo
+
+Tag: `comfyui-styles` (+ `gamedev-2d` para los dos presets gamedev). Sub-grupo de
+[`comfyui`](comfyui.md) que añade una **capa de estilo reutilizable** sobre los builders de
+workflow: en vez de repetir a mano los mismos modificadores de cámara/iluminación/render en cada
+prompt, el estilo se trata como un dato curado y reusable.
+
+Dos vertientes complementarias:
+
+- **Catálogo WAS** (`comfyui-styles`): ~190 estilos curados en el formato exacto del selector WAS de
+  ComfyUI (*Prompt Styles Selector* / *Prompt Multiple Styles Selector*), generación de estilos
+  nuevos por LLM, y fusión segura sobre el `styles.json` del usuario.
+- **Style presets gamedev** (`gamedev-2d`): recetas que empaquetan como datos puros el *look* de un
+  juego entero (prefijo/sufijo de prompt, checkpoint, LoRA, negative, tamaño, post-proceso) y se
+  traducen a los kwargs que consume un builder de sujeto del grupo [`gamedev-2d`](gamedev-2d.md).
+
+Filtro MCP: `mcp__registry__fn_search query="" tag="comfyui-styles"` (catálogo WAS) y
+`mcp__registry__fn_search query="style preset" tag="gamedev-2d"` (presets gamedev).
+
+## Funciones del grupo
+
+### Catálogo WAS — dominio `ml` (tag `comfyui-styles`)
+
+| ID | Firma corta | Qué hace |
+|---|---|---|
+| [comfyui_curated_styles_catalog_py_ml](../../python/functions/ml/comfyui_curated_styles_catalog.md) | `curated_styles_catalog(category=None) -> dict` | Catálogo curado (~190 estilos) en el formato exacto `{nombre: {prompt, negative_prompt}}` que consume el selector WAS. Cada `prompt` son modificadores de estilo potentes (cámara, lente, iluminación, render engine, medio artístico, paleta, mood), no descripciones de escena. Filtra por `category`. **Pura**. |
+| [comfyui_generate_styles_llm_py_ml](../../python/functions/ml/comfyui_generate_styles_llm.md) | `generate_styles_llm(category, n=8, prefix='', avoid=None, model='claude-haiku-4-5-20251001') -> dict` | Genera N estilos de una categoría temática usando `ask_llm` (grupo claude-direct, API directa, arranque 0), en el mismo formato `{nombre: {prompt, negative_prompt}}`. `avoid` evita duplicar nombres ya existentes. **Impura** (LLM). |
+| [comfyui_append_styles_py_ml](../../python/functions/ml/comfyui_append_styles.md) | `append_styles(new_styles, styles_path=DEFAULT_STYLES_PATH, overwrite=False, backup=True, dry_run=False) -> dict` | Fusiona (merge + dedup por nombre) un dict de estilos sobre el `styles.json` del selector WAS de forma SEGURA y NO destructiva: preserva todos los existentes (ganan salvo `overwrite=True`), hace backup con timestamp antes de escribir. `dry_run=True` previsualiza sin tocar disco. **Impura** (I/O disco). |
+
+### Style presets gamedev — dominio `ml` (tag `gamedev-2d`)
+
+| ID | Firma corta | Qué hace |
+|---|---|---|
+| [comfyui_get_gamedev_style_preset_py_ml](../../python/functions/ml/comfyui_get_gamedev_style_preset.md) | `get_gamedev_style_preset(name=None) -> dict` | Devuelve la receta de un *style preset* gamedev curado (`gameboy`, `ghibli`, `pixel-art-retro`) o el catálogo de nombres si `name=None`. Un preset empaqueta como DATOS puros el look de un juego entero: `subject_prefix`/`suffix`, `style`, `negative`, checkpoint recomendado, LoRA + strength, `size`, `transparent`, post-proceso. **Pura**. |
+| [comfyui_apply_style_preset_py_ml](../../python/functions/ml/comfyui_apply_style_preset.md) | `apply_style_preset(preset, subject, *, style=None, negative=None) -> dict` | Traduce un *style preset* gamedev (de `get_gamedev_style_preset`) + un `subject` del usuario a lo que necesita un builder de sujeto del grupo gamedev-2d: el subject combinado con el prefijo/sufijo del estilo y los kwargs comunes (`style`, `checkpoint`, `lora`, `lora_strength`, `negative`, resolución) listos para `**spread`. `style`/`negative` permiten override puntual. **Pura**. |
+
+## Ejemplo canónico — generar un estilo, fusionarlo y aplicarlo
+
+Dos flujos típicos: (1) ampliar el catálogo del selector WAS, y (2) usar un preset gamedev para
+generar un asset con look consistente.
+
+### A) Ampliar el catálogo WAS con estilos nuevos por LLM
+
+```python
+import sys, os
+sys.path.insert(0, os.path.join("python", "functions"))
+from ml.comfyui_generate_styles_llm import comfyui_generate_styles_llm
+from ml.comfyui_append_styles import comfyui_append_styles
+
+# 1. Pedir 6 estilos de una categoría. Devuelve el dict {nombre: {prompt, negative_prompt}}
+#    directo (best-effort: {} si el LLM falla).
+nuevos = comfyui_generate_styles_llm("film noir cinematic", n=6, prefix="noir-")
+
+# 2. Previsualizar la fusión (no escribe), luego aplicar con backup.
+if nuevos:
+    print(comfyui_append_styles(nuevos, dry_run=True)["total_after"])   # nº tras fusionar, sin tocar disco
+    res = comfyui_append_styles(nuevos)                                  # backup + merge + dedup + escritura
+    print(res["total_before"], "->", res["total_after"], "añadidos:", len(res["added"]))
+```
+
+### B) Aplicar un style preset gamedev a un sujeto
+
+```python
+import sys, os
+sys.path.insert(0, os.path.join("python", "functions"))
+from ml.comfyui_get_gamedev_style_preset import comfyui_get_gamedev_style_preset
+from ml.comfyui_apply_style_preset import comfyui_apply_style_preset
+from ml.comfyui_build_enemy_creature_workflow import comfyui_build_enemy_creature_workflow
+
+preset = comfyui_get_gamedev_style_preset("gameboy")     # receta pura del look Game Boy
+ap = comfyui_apply_style_preset(preset, "a wizard casting a spell")
+# ap = {subject, builder_kwargs, size, transparent, post, ...} listo para un builder gamedev-2d:
+wf = comfyui_build_enemy_creature_workflow(
+    ap["subject"], size=ap["size"], transparent=ap["transparent"], **ap["builder_kwargs"]
+)
+```
+
+El catálogo curado completo se consulta sin red (devuelve el dict plano directo):
+
+```python
+from ml.comfyui_curated_styles_catalog import comfyui_curated_styles_catalog
+print(comfyui_curated_styles_catalog("__categories__"))  # {'categories': {...}, 'total': 190}
+todos = comfyui_curated_styles_catalog()                  # dict {nombre: {prompt, negative_prompt}}
+print(len(todos), list(todos)[:5])
+```
+
+## Fronteras
+
+- **No genera imágenes**: este sub-grupo produce y gestiona DATOS de estilo (dicts de prompt /
+  negative, presets). Generar el asset es trabajo de los builders del grupo [`comfyui`](comfyui.md)
+  y [`gamedev-2d`](gamedev-2d.md), o de los pipelines oneshot (p.ej.
+  `comfyui_generate_styled_asset_oneshot_py_pipelines`, que compone un preset + un builder + submit).
+- **El catálogo WAS asume el custom node WAS instalado**: `append_styles` escribe sobre el
+  `styles.json` que lee el selector WAS en la UI. Sin ese node, el catálogo sigue siendo usable como
+  dict de modificadores, pero el selector no aparecerá en el grafo.
+- **Los dos presets gamedev (`get`/`apply`) llevan tag `gamedev-2d`**, no `comfyui-styles`: son la
+  vía de estilo para los builders de assets de juego, no para el selector WAS genérico. Se listan
+  aquí por afinidad de capacidad (estilo reutilizable).
+- **Formato exacto**: el dict de estilos es `{nombre: {prompt, negative_prompt}}`. Los prompts son
+  modificadores (cámara/lente/luz/render/medio/paleta/mood), no descripciones de escena — la escena
+  la pone el `subject` del usuario.

docs/capabilities/comfyui.md

@@ -13,6 +13,17 @@ Tag: `comfyui`. Grupo de funciones para controlar [ComfyUI](https://github.com/c
 
 Filtro MCP: `mcp__registry__fn_search query="" tag="comfyui"`.
 
+> **Tamaño del grupo (al 28/06/2026):** 126 funciones con tag `comfyui` (63 puras, 50 impuras,
+> 13 pipelines). El grupo se reparte en sub-grupos con página madre propia:
+> [`comfyui-skill`](comfyui-skill.md) (recetas de estilo versionadas),
+> [`comfyui-styles`](comfyui-styles.md) (presets + catálogo de estilo para el selector WAS),
+> [`comfyui-judge`](comfyui-judge.md) (panel de calidad) y
+> [`gamedev-2d`](gamedev-2d.md) (assets 2D para Godot: 47 funciones, 45 de ellas también `comfyui`).
+> Esta página documenta el **núcleo** (lifecycle del server, API HTTP, builders, I/O de workflows,
+> imagen→3D, UI por CDP, audio, templates); los builders específicos de gamedev-2d viven en su
+> propia página. El mapa cross-grupo de capacidades está en
+> [comfyui-overview.md](comfyui-overview.md).
+
 ## Dos caminos, mismo motor
 
 ```
@@ -44,7 +55,7 @@ El **API format** (dict de nodos numerados que produce `build_txt2img_workflow`
 | ID | Firma corta | Qué hace |
 |---|---|---|
 | [comfyui_build_txt2img_workflow_py_ml](../../python/functions/ml/comfyui_build_txt2img_workflow.md) | `build_txt2img_workflow(ckpt_name, positive, negative='', *, steps, cfg, width, height, seed, ...) -> dict` | Construye el dict del workflow txt2img básico (Checkpoint → CLIPTextEncode×2 + EmptyLatent → KSampler → VAEDecode → SaveImage) en API format. **Pura**. |
-| [comfyui_build_flux_workflow_py_ml](../../python/functions/ml/comfyui_build_flux_workflow.md) | `build_flux_workflow(prompt, *, unet='flux1-schnell-fp8-e4m3fn.safetensors', clip_l, t5xxl, vae='ae.safetensors', width=1024, height=1024, steps=4, guidance=3.5, seed, weight_dtype='fp8_e4m3fn', ...) -> dict` | Builder txt2img para **Flux** (schnell/dev): UNETLoader + DualCLIPLoader (clip_l + t5xxl, type flux) + VAELoader → CLIPTextEncode → FluxGuidance + EmptySD3LatentImage → KSampler (cfg fijo 1.0) → VAEDecode → SaveImage. La guía va por FluxGuidance, no por el cfg. fp8 + ~4 pasos para 8 GB. **Pura**. |
+| [comfyui_build_flux_workflow_py_ml](../../python/functions/ml/comfyui_build_flux_workflow.md) | `build_flux_workflow(prompt, *, variant='schnell', width=1024, height=1024, steps=None, guidance=3.5, seed=0, unet_name=None, clip_l_name='clip_l.safetensors', t5xxl_name='t5xxl_fp8_e4m3fn_scaled.safetensors', vae_name='ae.safetensors', weight_dtype='default', sampler_name='euler', scheduler='simple', ...) -> dict` | Builder txt2img para **Flux** (`variant='schnell'` o `'dev'`): UNETLoader + DualCLIPLoader (clip_l + t5xxl, type flux) + VAELoader → CLIPTextEncode → FluxGuidance + EmptySD3LatentImage → camino custom-advanced (RandomNoise + KSamplerSelect + BasicScheduler → BasicGuider → SamplerCustomAdvanced) → VAEDecode → SaveImage. La guía va por FluxGuidance, no por el cfg. `steps=None` autoselecciona por variante (~4 schnell); `unet_name=None` deduce el checkpoint de la variante; `weight_dtype='default'`. **Pura**. |
 | [comfyui_object_info_py_ml](../../python/functions/ml/comfyui_object_info.md) | `object_info(server='127.0.0.1:8188', node_class=None, timeout) -> dict` | Catálogo de nodos del server: inputs, tipos y enums (lista de checkpoints/samplers visibles). Para validar antes de enviar. Impura. |
 | [comfyui_submit_workflow_py_ml](../../python/functions/ml/comfyui_submit_workflow.md) | `submit_workflow(workflow, server, client_id, timeout) -> dict` | Encola un workflow API format vía POST /prompt; devuelve `prompt_id` + posición en cola. HTTP 400 propaga la validación por nodo. Impura. |
 | [comfyui_wait_result_py_ml](../../python/functions/ml/comfyui_wait_result.md) | `wait_result(prompt_id, server, timeout, poll_interval) -> dict` | Sondea GET /history/{prompt_id} hasta que termina; devuelve los outputs (PNGs con filename/subfolder/type). Impura. |
@@ -207,6 +218,22 @@ un error accionable, sin lanzar.
 | [comfyui_list_templates_py_ml](../../python/functions/ml/comfyui_list_templates.md) | `list_templates(comfyui_python=None, bundle=None, name_filter=None, with_nodes=True, workflows_only=True, limit=0) -> dict` | Lista los templates oficiales con su grafo: nombre, bundle/categoría, path en disco, `n_nodes` y `node_types` (class_types reales, aplanando subgrafos y descartando UUID de instancia). Filtra por bundle/nombre; excluye entradas no-workflow por defecto. Impura (lee disco vía el intérprete de ComfyUI). |
 | [comfyui_extract_template_py_ml](../../python/functions/ml/comfyui_extract_template.md) | `extract_template(name, comfyui_python=None, to_api=False, server='127.0.0.1:8188') -> dict` | Extrae el grafo completo (formato UI) + `class_types` de un template por su `template_id`. `to_api=True` lo convierte a API format vía `comfyui_import_workflow_json` (requiere servidor ComfyUI vivo). Nombre inexistente → `ok=False` con sugerencias cercanas, sin traceback. Impura. |
 
+### Estilos — presets y catálogo (sub-grupo `comfyui-styles`)
+
+Capa de **estilo reutilizable** sobre los builders: un catálogo curado de ~190 modificadores de
+estilo para el selector WAS (Prompt Styles Selector), generación de estilos por LLM, y *style
+presets* gamedev (gameboy, ghibli, pixel-art-retro) que empaquetan como datos puros el look de un
+juego entero (prefijo/sufijo de prompt, checkpoint, LoRA, negative, tamaño). Página madre dedicada:
+[comfyui-styles.md](comfyui-styles.md). Las 5 funciones:
+
+| ID | Firma corta | Qué hace |
+|---|---|---|
+| [comfyui_curated_styles_catalog_py_ml](../../python/functions/ml/comfyui_curated_styles_catalog.md) | `curated_styles_catalog(category=None) -> dict` | Catálogo curado (~190 estilos) en formato `{nombre: {prompt, negative_prompt}}` para el selector WAS. Cada prompt son modificadores potentes (cámara, lente, iluminación, render, medio, paleta). **Pura**. |
+| [comfyui_generate_styles_llm_py_ml](../../python/functions/ml/comfyui_generate_styles_llm.md) | `generate_styles_llm(category, n=8, prefix='', avoid=None, model='claude-haiku-4-5-...') -> dict` | Genera N estilos nuevos de una categoría temática vía `ask_llm` (grupo claude-direct), en el mismo formato del selector WAS. **Impura**. |
+| [comfyui_append_styles_py_ml](../../python/functions/ml/comfyui_append_styles.md) | `append_styles(new_styles, styles_path=..., overwrite=False, backup=True, dry_run=False) -> dict` | Fusiona (merge + dedup) estilos nuevos sobre el `styles.json` del selector WAS de forma NO destructiva: preserva los existentes (salvo `overwrite`), backup con timestamp. **Impura**. |
+| [comfyui_get_gamedev_style_preset_py_ml](../../python/functions/ml/comfyui_get_gamedev_style_preset.md) | `get_gamedev_style_preset(name=None) -> dict` | Devuelve la receta de un *style preset* gamedev curado (gameboy, ghibli, pixel-art-retro) o el catálogo de nombres si `name=None`. Empaqueta el look como datos puros. **Pura**. |
+| [comfyui_apply_style_preset_py_ml](../../python/functions/ml/comfyui_apply_style_preset.md) | `apply_style_preset(preset, subject, *, style=None, negative=None) -> dict` | Traduce un *style preset* gamedev + un subject del usuario a los kwargs que consume un builder de sujeto del grupo gamedev-2d (subject combinado + `**kwargs` listos para spread). **Pura**. |
+
 ## Ejemplo canónico end-to-end (build → load → tune → queue → resultado)
 
 Combina API + UI: construyes el workflow por API, lo cargas en la UI del usuario, ajustas el

docs/capabilities/gamedev-2d.md

@@ -11,8 +11,9 @@ Cluster de funciones para producir y mover assets 2D de juego entre **ComfyUI**
 3. **Puente de assets** (CPU): coloca el resultado en un proyecto Godot
    con sus import settings.
 
-Tag único del grupo: `gamedev-2d` (los 31 builders de workflow + las 5 funciones de
+Tag único del grupo: `gamedev-2d` — **47 funciones**: 36 builders de workflow (31 de
-apoyo de post-proceso y puente). El tag plano `gamedev` quedó deprecado y unificado a
+generación desde texto + 5 de transformación desde una imagen de entrada) + 11 de apoyo
+(post-proceso, puente a Godot, style presets y pipelines one-shot). El tag plano `gamedev` quedó deprecado y unificado a
 `gamedev-2d`. El **runtime de juego C++** (el motor que ejecuta el juego: game loop,
 cámara, input, render por lotes, audio) vive en el grupo hermano `gamedev-engine`.
 Filtro: `mcp__registry__fn_search query="" tag="gamedev-2d"`.

python/functions/datascience/__init__.py

@@ -44,8 +44,10 @@ from .trend_slope import trend_slope
 from .run_eda_models import run_eda_models
 from .eda_llm_insights import eda_llm_insights
 from .build_eda_notebook import build_eda_notebook
+from .decode_qr_image import decode_qr_image
 
 __all__ = [
+    "decode_qr_image",
     "summarize_table_duckdb",
     "summarize_table_pg",
     "spearman_corr",

python/functions/datascience/decode_qr_image.py

@@ -0,0 +1,269 @@
+"""
+Decodificación robusta de códigos QR desde una imagen en disco.
+
+Función del registry (grupo de capacidad `qr`, dominio `datascience`). Pensada para el caso real
+en el que un lector básico (pyzbar, `cv2.QRCodeDetector` sobre la imagen cruda) NO capta el QR:
+screenshots de pantalla con QR pálidos (bajo contraste) o pequeños. En vez de un único intento,
+genera varias variantes preprocesadas de la imagen y prueba cada detector disponible sobre cada
+variante, parando al primer acierto.
+
+Impura: lee un archivo de disco y depende de OpenCV (`opencv-contrib-python-headless`). Degrada
+limpio (devuelve `[]`) si la imagen no se puede leer o si ningún QR se decodifica; no lanza.
+
+Detectores (se usan los que estén instalados; el import se envuelve en try/except para degradar):
+  - `cv2.QRCodeDetectorAruco`  (preferido — OpenCV puro, sin libs de sistema)
+  - `cv2.QRCodeDetector`       (fallback OpenCV puro)
+  - `cv2.wechat_qrcode.WeChatQRCode`  (excelente con bajo contraste; SOLO si los modelos cargan)
+  - `pyzbar`                   (bonus opcional; requiere la lib de sistema `libzbar0`)
+
+Cero dependencias de sistema obligatorias: con solo OpenCV la función ya funciona.
+"""
+
+from __future__ import annotations
+
+import sys
+
+import cv2
+import numpy as np
+
+
+# --------------------------------------------------------------------------------------------
+# Detectores. Cada uno se normaliza a una función run(img) -> list[str] que nunca lanza.
+# --------------------------------------------------------------------------------------------
+def _make_opencv_runner(detector):
+    """Envuelve un cv2.QRCodeDetector(Aruco) en run(img) -> list[str]."""
+
+    def run(img):
+        out: list[str] = []
+        # detectAndDecodeMulti: capta varios QR en la misma imagen.
+        try:
+            ok, decoded, _points, _ = detector.detectAndDecodeMulti(img)
+            if ok and decoded:
+                out = [s for s in decoded if s]
+        except cv2.error:
+            pass
+        if not out:
+            # Fallback al decodificador de un solo QR.
+            try:
+                s, _pts, _ = detector.detectAndDecode(img)
+                if s:
+                    out = [s]
+            except cv2.error:
+                pass
+        return out
+
+    return run
+
+
+def _make_wechat_runner(wd):
+    """Envuelve un cv2.wechat_qrcode.WeChatQRCode en run(img) -> list[str]."""
+
+    def run(img):
+        try:
+            texts, _points = wd.detectAndDecode(img)
+            return [t for t in texts if t]
+        except Exception:
+            # Si los modelos no están cargados o el detector falla, degradar sin romper.
+            return []
+
+    return run
+
+
+def _make_pyzbar_runner(zbar_decode):
+    """Envuelve pyzbar.decode en run(img) -> list[str]."""
+
+    def run(img):
+        out: list[str] = []
+        try:
+            for sym in zbar_decode(img):
+                try:
+                    out.append(sym.data.decode("utf-8", "replace"))
+                except Exception:
+                    pass
+        except Exception:
+            return []
+        return out
+
+    return run
+
+
+def _build_detectors(debug=False):
+    """Construye la lista de (nombre, runner) de detectores disponibles, en orden de preferencia."""
+    detectors = []
+
+    # OpenCV Aruco (preferido): no requiere libs de sistema ni descarga de modelos.
+    if hasattr(cv2, "QRCodeDetectorAruco"):
+        try:
+            detectors.append(("opencv_aruco", _make_opencv_runner(cv2.QRCodeDetectorAruco())))
+        except Exception:
+            pass
+
+    # OpenCV clásico (fallback puro).
+    if hasattr(cv2, "QRCodeDetector"):
+        try:
+            detectors.append(("opencv", _make_opencv_runner(cv2.QRCodeDetector())))
+        except Exception:
+            pass
+
+    # WeChat QR (excelente con bajo contraste) — SOLO si los modelos cargan; opcional.
+    if hasattr(cv2, "wechat_qrcode"):
+        try:
+            wd = cv2.wechat_qrcode.WeChatQRCode()
+            detectors.append(("wechat", _make_wechat_runner(wd)))
+        except Exception:
+            # Modelos no presentes / build sin soporte → saltar sin romper.
+            pass
+
+    # pyzbar (bonus): requiere libzbar0 (lib de sistema). Degrada si falta.
+    try:
+        from pyzbar.pyzbar import decode as _zbar_decode  # type: ignore
+
+        detectors.append(("pyzbar", _make_pyzbar_runner(_zbar_decode)))
+    except (ImportError, OSError, Exception):  # noqa: B014 - OSError = libzbar0 ausente
+        pass
+
+    if debug:
+        print(
+            f"[decode_qr_image] detectores disponibles: {[n for n, _ in detectors]}",
+            file=sys.stderr,
+        )
+    return detectors
+
+
+# --------------------------------------------------------------------------------------------
+# Variantes preprocesadas de la imagen. Orden = prioridad; se para en el primer acierto.
+# --------------------------------------------------------------------------------------------
+def _load_bgr(image_path):
+    """Carga la imagen como BGR (uint8). Devuelve None si no se puede leer."""
+    bgr = cv2.imread(image_path, cv2.IMREAD_COLOR)
+    if bgr is not None:
+        return bgr
+    # Fallback PIL para formatos que cv2.imread no maneja en esta build.
+    try:
+        from PIL import Image
+
+        pil = Image.open(image_path).convert("RGB")
+        return cv2.cvtColor(np.asarray(pil), cv2.COLOR_RGB2BGR)
+    except Exception:
+        return None
+
+
+def _build_variants(image_path, upscale):
+    """Genera (nombre, ndarray) de variantes preprocesadas, en orden de prioridad."""
+    bgr = _load_bgr(image_path)
+    if bgr is None:
+        return []
+
+    gray = cv2.cvtColor(bgr, cv2.COLOR_BGR2GRAY)
+
+    # Contrast stretch (NORM_MINMAX): clave para QR de bajo contraste (gris sobre gris).
+    stretch = cv2.normalize(gray, None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8)
+
+    # CLAHE: realce de contraste local.
+    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8)).apply(gray)
+
+    # Upscale del stretch: QR pequeño es la causa #1 de fallo.
+    if upscale and upscale > 1:
+        up = cv2.resize(stretch, None, fx=upscale, fy=upscale, interpolation=cv2.INTER_CUBIC)
+    else:
+        up = stretch
+
+    # Binarizaciones sobre el stretch (mejor base que el gris crudo).
+    _, otsu = cv2.threshold(stretch, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+    adaptive = cv2.adaptiveThreshold(
+        stretch, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 31, 5
+    )
+
+    variants = [
+        ("original", bgr),
+        ("gray", gray),
+        ("contrast_stretch", stretch),
+        ("clahe", clahe),
+        ("upscale", up),
+        ("otsu", otsu),
+        ("adaptive_gaussian", adaptive),
+    ]
+
+    # Rotaciones sobre la mejor variante binarizada (Otsu).
+    for name, rot in (
+        ("rot90", cv2.ROTATE_90_CLOCKWISE),
+        ("rot180", cv2.ROTATE_180),
+        ("rot270", cv2.ROTATE_90_COUNTERCLOCKWISE),
+    ):
+        variants.append((f"otsu_{name}", cv2.rotate(otsu, rot)))
+
+    return variants
+
+
+# --------------------------------------------------------------------------------------------
+# API pública.
+# --------------------------------------------------------------------------------------------
+def decode_qr_image(image_path: str, upscale: int = 2, debug: bool = False) -> list[str]:
+    """Decodifica los códigos QR de una imagen, robusto a bajo contraste y QR pequeños.
+
+    Genera varias variantes preprocesadas de la imagen (escala de grises, contrast stretch,
+    CLAHE, upscale, binarización Otsu/adaptativa, rotaciones) y prueba cada detector disponible
+    (OpenCV Aruco/clásico, WeChat si hay modelos, pyzbar si hay libzbar0) sobre cada variante,
+    parando al primer acierto.
+
+    Parámetros (`upscale` y `debug` pensados como opciones keyword):
+        image_path: ruta del archivo de imagen a leer (png/jpg/...).
+        upscale: factor de ampliación (INTER_CUBIC) aplicado a la variante de contraste estirado
+            para rescatar QR pequeños. Default 2. <=1 desactiva el upscale.
+        debug: si True, imprime a stderr qué variante/detector acertó (o que no se detectó nada).
+
+    Returns:
+        Lista de payloads de texto de los QR detectados (deduplicada, preservando orden). Lista
+        vacía si no se detecta ninguno o si la imagen no se puede leer. No lanza.
+    """
+    try:
+        variants = _build_variants(image_path, upscale)
+    except Exception as exc:  # pragma: no cover - defensa ante imágenes corruptas
+        if debug:
+            print(f"[decode_qr_image] fallo construyendo variantes: {exc}", file=sys.stderr)
+        return []
+
+    if not variants:
+        if debug:
+            print(f"[decode_qr_image] no se pudo leer la imagen: {image_path}", file=sys.stderr)
+        return []
+
+    detectors = _build_detectors(debug=debug)
+    if not detectors:
+        if debug:
+            print("[decode_qr_image] ningún detector QR disponible", file=sys.stderr)
+        return []
+
+    for vname, vimg in variants:
+        for dname, drun in detectors:
+            payloads = drun(vimg)
+            uniq = list(dict.fromkeys(p for p in payloads if p))
+            if uniq:
+                if debug:
+                    print(
+                        f"[decode_qr_image] acierto variante={vname} detector={dname} "
+                        f"n={len(uniq)}",
+                        file=sys.stderr,
+                    )
+                return uniq
+
+    if debug:
+        print("[decode_qr_image] ningún QR decodificado en ninguna variante", file=sys.stderr)
+    return []
+
+
+if __name__ == "__main__":
+    # Demo CLI para `python3 decode_qr_image.py <image_path> [upscale] [debug]`.
+    # (fn run usa su propio runner generado; este bloque es para invocación manual directa.)
+    import json
+
+    if len(sys.argv) < 2:
+        print(json.dumps({"error": "uso: <image_path> [upscale] [debug]"}))
+        sys.exit(1)
+
+    _path = sys.argv[1]
+    _upscale = int(sys.argv[2]) if len(sys.argv) > 2 else 2
+    _debug = (sys.argv[3].lower() in ("1", "true", "yes")) if len(sys.argv) > 3 else False
+
+    _result = decode_qr_image(_path, upscale=_upscale, debug=_debug)
+    print(json.dumps(_result))

python/functions/ml/assemble_animated_sprite.md

@@ -0,0 +1,92 @@
+---
+name: assemble_animated_sprite
+kind: function
+lang: py
+domain: ml
+version: "1.0.0"
+purity: impure
+signature: "def assemble_animated_sprite(frame_paths: list, out_dir: str, *, name: str = \"anim\", fps: int = 8, fmt: str = \"webp\", loop: bool = True, spritesheet: bool = True, pad: int = 0) -> dict"
+description: "Ensambla N frames PNG RGBA (p.ej. los frames de un walk cycle ya pixelizados a 32x32 con alpha) en DOS entregables: un sprite sheet horizontal (1 fila x N columnas) PNG RGBA con la transparencia intacta, y una animacion en loop WEBP lossless o GIF animado. Es la pieza de ensamblado final de cualquier animacion de sprite. Salta frames que falten o no abran (aviso en error, no aborta); normaliza tamano al primer frame valido reescalando con NEAREST. Solo PIL. No-throw. Devuelve {ok, spritesheet_path, animation_path, n_frames, frame_size, fmt, error}."
+tags: [gamedev-2d, comfyui, sprite, animation]
+uses_functions: []
+uses_types: []
+returns: []
+returns_optional: false
+error_type: "error_go_core"
+imports: []
+params:
+  - name: frame_paths
+    desc: "lista de rutas a PNG RGBA en orden de reproduccion; los que falten o no abran se saltan (aviso en error)."
+  - name: out_dir
+    desc: "directorio de salida; se crea si no existe. Se escriben '<name>_sheet.png' y '<name>.<ext>' dentro."
+  - name: name
+    desc: "nombre base de los ficheros generados (keyword-only, default 'anim')."
+  - name: fps
+    desc: "frames por segundo de la animacion; duration_ms = round(1000/max(1,fps)) por frame (keyword-only, default 8)."
+  - name: fmt
+    desc: "formato de la animacion: 'webp' (recomendado, lossless, alpha completo) o 'gif' (alpha binario) (keyword-only)."
+  - name: loop
+    desc: "si True la animacion se repite indefinidamente (loop=0); si False una sola vez (keyword-only, default True)."
+  - name: spritesheet
+    desc: "si True genera tambien el sprite sheet horizontal PNG RGBA (keyword-only, default True)."
+  - name: pad
+    desc: "pixeles de separacion transparente entre columnas del sheet (keyword-only, default 0)."
+output: "dict con ok (bool, True si se produjo la animacion con >=1 frame valido), spritesheet_path (str, '' si spritesheet=False o fallo), animation_path (str, '' si fallo), n_frames (int, frames validos usados), frame_size ([w,h] del frame normalizado), fmt (str, 'webp'|'gif'), error (str, avisos y/o error; '' si limpio)."
+tested: false
+tests: []
+test_file_path: ""
+file_path: "python/functions/ml/assemble_animated_sprite.py"
+---
+
+## Ejemplo
+
+```python
+import sys, os
+sys.path.insert(0, os.path.join(os.environ["HOME"], "fn_registry", "python", "functions"))
+from ml.assemble_animated_sprite import assemble_animated_sprite
+
+# Frames de un walk cycle ya pixelizados a 32x32 RGBA (p.ej. salida del pipeline ComfyUI):
+frames = [
+    "/tmp/walk/frame_00.png",
+    "/tmp/walk/frame_01.png",
+    "/tmp/walk/frame_02.png",
+    "/tmp/walk/frame_03.png",
+]
+res = assemble_animated_sprite(frames, "/tmp/walk_out", name="hero_walk", fps=8, fmt="webp")
+# {'ok': True,
+#  'spritesheet_path': '/tmp/walk_out/hero_walk_sheet.png',
+#  'animation_path': '/tmp/walk_out/hero_walk.webp',
+#  'n_frames': 4, 'frame_size': [32, 32], 'fmt': 'webp', 'error': ''}
+```
+
+## Cuando usarla
+
+Al final de cualquier pipeline de animacion de sprite, cuando ya tienes los frames
+sueltos (pixelizados, con alpha) y necesitas (a) verlos animados en bucle para validar
+el ciclo a ojo y (b) un sprite sheet horizontal listo para que un motor de juego lo
+trocee por columnas. Tipico despues de generar un walk cycle frame a frame con ComfyUI
+y pasarlo por el pixelizado: este es el paso de "juntarlo todo". Usa `fmt="webp"` por
+defecto; `fmt="gif"` solo si necesitas compatibilidad con visores que no abren WEBP.
+
+## Gotchas
+
+- **GIF solo tiene alpha binario** (1 bit): cada pixel es opaco o totalmente
+  transparente, los pixeles con `alpha < 128` se vuelven transparentes y se pierde el
+  anti-aliasing del borde. **WEBP (lossless) es el formato recomendado** para sprites con
+  alpha — conserva el canal alpha completo y no ensucia el pixel-art. Usa GIF solo por
+  compatibilidad.
+- Al guardar GIF, PIL **reoptimiza la paleta** y el indice de transparencia puede
+  cambiar (p.ej. de 255 a 1 al releer): es normal, los pixeles transparentes se
+  preservan (verificable convirtiendo el frame a RGBA y mirando el canal alpha).
+- **Frames que faltan o no abren se SALTAN** (se anota en `error`), no se aborta: la
+  animacion se monta con los frames validos. Si quedan **0 frames validos** → `ok=False`.
+- El campo `error` puede venir **no vacio aunque `ok=True`**: ahi van los avisos de
+  frames saltados. `ok` refleja si se genero la animacion, no la ausencia de avisos.
+- El tamano se normaliza al **primer frame valido**; los frames de tamano distinto se
+  reescalan con **NEAREST** (sin interpolacion, preserva el pixel-art duro), lo que puede
+  deformarlos si su aspect ratio difiere. Asegurate de que todos los frames ya vienen al
+  mismo tamano.
+- Escribe en disco: crea `out_dir` si no existe; si no hay permiso de escritura, el
+  fallo del sheet va a `error` como aviso y el de la animacion pone `ok=False`.
+- `disposal=2` limpia el lienzo entre frames (transparencia correcta en cada paso); sin
+  el, los frames se acumularian unos sobre otros.

python/functions/ml/assemble_animated_sprite.py

@@ -0,0 +1,221 @@
+"""Ensambla frames PNG RGBA en un sprite sheet horizontal + una animacion en loop.
+
+Funcion impura: lee N frames de disco (los frames ya pixelizados de un walk cycle,
+por ejemplo) y escribe DOS entregables:
+
+  1. Un sprite sheet horizontal (1 fila x N columnas) PNG RGBA, con la transparencia
+     de cada frame intacta.
+  2. Una animacion en bucle (WEBP lossless o GIF animado) que reproduce los frames.
+
+Es la pieza de ensamblado final de cualquier animacion de sprite: convierte una lista
+de frames sueltos en algo que se ve animado (la .webp/.gif) y algo que un motor de
+juego puede trocear (el sheet). Solo depende de PIL (Pillow), presente en el venv del
+registry. No lanza excepciones: cualquier problema se reporta en el campo "error".
+"""
+from __future__ import annotations
+
+import os
+
+
+def assemble_animated_sprite(
+    frame_paths: list,
+    out_dir: str,
+    *,
+    name: str = "anim",
+    fps: int = 8,
+    fmt: str = "webp",
+    loop: bool = True,
+    spritesheet: bool = True,
+    pad: int = 0,
+) -> dict:
+    """Monta un sprite sheet horizontal y una animacion en loop a partir de N frames.
+
+    Carga cada ruta de ``frame_paths`` como RGBA. Los frames que falten o no abran se
+    SALTAN (se anota un aviso en ``error``, no se aborta): se anima con los que haya.
+    El tamano se normaliza al del primer frame valido; los frames de tamano distinto se
+    reescalan con NEAREST a ese tamano (preserva el pixel-art duro, sin interpolacion).
+
+    Args:
+        frame_paths: lista de rutas a PNG RGBA, en orden de reproduccion.
+        out_dir: directorio de salida; se crea si no existe.
+        name: nombre base de los ficheros generados (``<name>_sheet.png`` y
+            ``<name>.<ext>``). keyword-only.
+        fps: frames por segundo de la animacion; duration_ms = round(1000/max(1,fps)).
+            keyword-only.
+        fmt: formato de la animacion, "webp" (recomendado) o "gif". keyword-only.
+        loop: si True la animacion se repite indefinidamente; si False se reproduce una
+            sola vez. keyword-only.
+        spritesheet: si True genera tambien el sprite sheet horizontal PNG RGBA.
+            keyword-only.
+        pad: pixeles de separacion transparente entre columnas del sheet (default 0).
+            keyword-only.
+
+    Returns:
+        dict con:
+        - ok (bool): True si se produjo al menos la animacion con >=1 frame valido.
+        - spritesheet_path (str): ruta del PNG del sheet ("" si spritesheet=False o fallo).
+        - animation_path (str): ruta de la animacion WEBP/GIF ("" si fallo).
+        - n_frames (int): numero de frames validos efectivamente usados.
+        - frame_size ([w, h]): tamano del frame normalizado.
+        - fmt (str): formato real de la animacion ("webp" o "gif").
+        - error (str): avisos y/o mensaje de error; "" si todo fue limpio.
+    """
+    out = {
+        "ok": False,
+        "spritesheet_path": "",
+        "animation_path": "",
+        "n_frames": 0,
+        "frame_size": [0, 0],
+        "fmt": "",
+        "error": "",
+    }
+    warnings: list = []
+
+    try:
+        from PIL import Image
+    except ImportError:
+        out["error"] = "PIL (Pillow) no esta instalado en este interprete"
+        return out
+
+    if not frame_paths:
+        out["error"] = "frame_paths vacio: no hay nada que ensamblar"
+        return out
+
+    fmt = str(fmt).lower().strip()
+    if fmt not in ("webp", "gif"):
+        out["error"] = f"fmt invalido {fmt!r}: usa 'webp' o 'gif'"
+        return out
+    out["fmt"] = fmt
+
+    # --- Cargar y normalizar frames (saltando los invalidos) ---
+    frames: list = []
+    target = None  # (w, h) del primer frame valido
+    for path in frame_paths:
+        if not os.path.isfile(path):
+            warnings.append(f"falta: {path}")
+            continue
+        try:
+            with Image.open(path) as src:
+                im = src.convert("RGBA")
+        except (OSError, ValueError) as exc:
+            warnings.append(f"no abre {path}: {exc}")
+            continue
+        if target is None:
+            target = (im.width, im.height)
+        elif (im.width, im.height) != target:
+            im = im.resize(target, Image.NEAREST)
+        frames.append(im)
+
+    if not frames:
+        out["error"] = "; ".join(["0 frames validos"] + warnings)
+        return out
+
+    w, h = target
+    out["frame_size"] = [w, h]
+    out["n_frames"] = len(frames)
+    n = len(frames)
+
+    try:
+        os.makedirs(out_dir, exist_ok=True)
+    except OSError as exc:
+        out["error"] = "; ".join([f"no se pudo crear out_dir {out_dir!r}: {exc}"] + warnings)
+        return out
+
+    # --- Sprite sheet horizontal (1 fila x N columnas), RGBA transparente ---
+    if spritesheet:
+        pad = max(0, int(pad))
+        sheet_w = n * w + (n - 1) * pad if n > 0 else 0
+        sheet = Image.new("RGBA", (sheet_w, h), (0, 0, 0, 0))
+        for i, im in enumerate(frames):
+            x = i * (w + pad)
+            # Tercer arg = mascara alpha del propio frame: respeta su transparencia.
+            sheet.paste(im, (x, 0), im)
+        sheet_path = os.path.join(out_dir, f"{name}_sheet.png")
+        try:
+            sheet.save(sheet_path, format="PNG")
+            out["spritesheet_path"] = sheet_path
+        except OSError as exc:
+            warnings.append(f"sheet no guardado: {exc}")
+
+    # --- Animacion en loop (WEBP lossless o GIF con alpha binario) ---
+    duration_ms = round(1000 / max(1, int(fps)))
+    loop_count = 0 if loop else 1  # 0 = infinito
+    ext = fmt
+    anim_path = os.path.join(out_dir, f"{name}.{ext}")
+
+    try:
+        if fmt == "webp":
+            frames[0].save(
+                anim_path,
+                save_all=True,
+                append_images=frames[1:],
+                duration=duration_ms,
+                loop=loop_count,
+                format="WEBP",
+                lossless=True,   # no ensucia el pixel-art
+                disposal=2,      # limpia entre frames -> transparencia correcta
+            )
+        else:  # gif
+            pal_frames = [_rgba_to_p_transparent(im) for im in frames]
+            pal_frames[0].save(
+                anim_path,
+                save_all=True,
+                append_images=pal_frames[1:],
+                duration=duration_ms,
+                loop=loop_count,
+                format="GIF",
+                transparency=255,  # indice reservado para el pixel transparente
+                disposal=2,
+            )
+        out["animation_path"] = anim_path
+        out["ok"] = True
+    except (OSError, ValueError) as exc:
+        warnings.append(f"animacion no guardada: {exc}")
+        out["ok"] = False
+
+    out["error"] = "; ".join(warnings)
+    return out
+
+
+def _rgba_to_p_transparent(im, alpha_threshold: int = 128):
+    """Convierte un frame RGBA a modo P reservando el indice 255 como transparente.
+
+    GIF solo soporta 1 bit de alpha: cada pixel es opaco o totalmente transparente.
+    Los pixeles con alpha < alpha_threshold se mapean al indice 255 (transparente);
+    el resto se cuantiza a 255 colores (indices 0..254).
+    """
+    from PIL import Image
+
+    alpha = im.getchannel("A")
+    # Cuantiza el RGB a 255 colores -> indices 0..254 libres, 255 para transparencia.
+    p = im.convert("RGB").quantize(colors=255, method=Image.Quantize.MEDIANCUT)
+    # Mascara de los pixeles "transparentes" (alpha por debajo del umbral).
+    mask = alpha.point(lambda a: 255 if a < alpha_threshold else 0)
+    p.paste(255, (0, 0), mask)
+    return p
+
+
+if __name__ == "__main__":
+    import json
+    import tempfile
+
+    from PIL import Image as _Image, ImageDraw as _ImageDraw
+
+    # --- Genera 4 frames de prueba: un cuadrado de color que se mueve de izquierda a
+    #     derecha sobre un lienzo RGBA transparente de 32x32. ---
+    tmp = tempfile.mkdtemp(prefix="assemble_sprite_demo_")
+    demo_frames: list = []
+    box = 10
+    for i in range(4):
+        frame = _Image.new("RGBA", (32, 32), (0, 0, 0, 0))  # fondo transparente
+        d = _ImageDraw.Draw(frame)
+        x0 = 1 + i * 6  # se desplaza hacia la derecha cada frame
+        d.rectangle([x0, 11, x0 + box, 11 + box], fill=(40, 180, 230, 255))
+        fpath = os.path.join(tmp, f"frame_{i:02d}.png")
+        frame.save(fpath)
+        demo_frames.append(fpath)
+
+    result = assemble_animated_sprite(
+        demo_frames, tmp, name="walk_demo", fps=8, fmt="webp"
+    )
+    print(json.dumps(result, indent=2))

python/functions/ml/comfyui_build_asset_variant_workflow.md

@@ -49,7 +49,9 @@ params:
   - name: filename_prefix
     desc: "Prefijo del archivo de salida en SaveImage. keyword-only."
 output: "dict en API format listo para comfyui_submit_workflow: img2img base (parte de input_image) con prompt de variante + ImageScale opcional (normaliza a size) + LoRA opcional. Nodos: CheckpointLoaderSimple '4', LoadImage '10', VAEEncode '11', CLIPTextEncode '6'/'7', KSampler '3' (denoise medio), VAEDecode '8', SaveImage '9', + ImageScale y LoraLoader si aplican."
-tested: false
+tested: true
+tests: ["estructura img2img (LoadImage+VAEEncode, sin EmptyLatentImage)", "input_image/prompt reflejados en LoadImage y CLIPTextEncode positivo", "size por defecto inserta ImageScale a 512; size=None lo omite", "denoise se clampa a [0,1]", "filename_prefix/seed/lora opcional reflejados", "input_image o variant vacios -> ValueError", "determinismo: misma entrada -> mismo dict"]
+test_file_path: "python/functions/ml/tests/test_comfyui_build_asset_variant_workflow.py"
 file_path: python/functions/ml/comfyui_build_asset_variant_workflow.py
 ---
 

python/functions/ml/comfyui_build_directional_sprite_workflow.md

@@ -44,7 +44,9 @@ params:
   - name: filename_prefix
     desc: "Prefijo del archivo de salida del SaveImage. keyword-only."
 output: "dict en API format listo para comfyui_submit_workflow (claves = node_ids string, valores = class_type + inputs). SV3D: ImageOnlyCheckpointLoader + LoadImage + SV3D_Conditioning + VideoLinearCFGGuidance + KSampler + VAEDecode + SaveImage (los N frames del orbit). Zero123: ImageOnlyCheckpointLoader + LoadImage + StableZero123_Conditioning_Batched + KSampler + VAEDecode + SaveImage (un batch de directions vistas). El frame i (i-esima imagen del SaveImage, azimuth creciente desde la frontal) = direccion i de directional_sprite_view_order(directions). El modulo expone ademas directional_sprite_view_order(directions) -> lista de nombres de direccion alineada por indice con los frames."
-tested: false
+tested: true
+tests: ["sv3d: estructura + orbit (video_frames=directions, size nativa 576)", "orbit_frames override", "zero123: StableZero123_Conditioning_Batched, azimuth equiespaciado, size 256", "cfg/ckpt por defecto segun modelo", "elevation/seed reflejados", "directional_sprite_view_order para 4/8/N", "errores: input vacio, model invalido, directions<1", "determinismo"]
+test_file_path: "python/functions/ml/tests/test_comfyui_build_directional_sprite_workflow.py"
 file_path: "python/functions/ml/comfyui_build_directional_sprite_workflow.py"
 ---
 

python/functions/ml/comfyui_build_grid.md

@@ -26,9 +26,9 @@ params:
   - name: labels
     desc: "rotulos opcionales, uno por imagen (mismo orden); reservan una franja bajo cada celda."
 output: "dict con ok (bool), out_path (str, ruta del PNG generado), rows (int, filas), cols (int, columnas), error (str, vacio si OK)."
-tested: false
+tested: true
-tests: []
+tests: ["grid basico: ok + out_path + cols/rows (ceil(sqrt(N)))", "cols explicito define filas", "cell define dimension del canvas", "labels reservan franja bajo cada celda", "error: lista vacia", "error: ruta inexistente", "determinismo del dict de salida"]
-test_file_path: ""
+test_file_path: "python/functions/ml/tests/test_comfyui_build_grid.py"
 file_path: "python/functions/ml/comfyui_build_grid.py"
 ---
 

python/functions/ml/comfyui_build_inpaint_asset_workflow.md

@@ -57,7 +57,9 @@ params:
   - name: filename_prefix
     desc: "Prefijo del archivo de salida en SaveImage. keyword-only."
 output: "dict en API format listo para comfyui_submit_workflow: inpaint que repinta SOLO la region marcada en blanco por la mascara, conservando el resto del asset, con grow_mask para difuminar la costura, escalado consistente opcional (img+mask) y LoRA de estilo opcional. Nodos modo vae_encode: CheckpointLoaderSimple '4', LoadImage '10', LoadImageMask '12', VAEEncodeForInpaint '11', CLIPTextEncode '6'/'7', KSampler '3', VAEDecode '8', SaveImage '9' (+ ImageScale/ImageToMask si size, + LoraLoader si lora). Modo noise_mask sustituye VAEEncodeForInpaint por VAEEncode + SetLatentNoiseMask (+ GrowMask)."
-tested: false
+tested: true
+tests: ["estructura vae_encode (LoadImage+LoadImageMask+VAEEncodeForInpaint)", "prompt de region + grow_mask reflejados", "grow_mask se clampa a [0,64]", "mode noise_mask degrada a VAEEncode+SetLatentNoiseMask+GrowMask", "size inserta ImageScale a imagen y mascara + ImageToMask", "lora opcional + filename_prefix", "errores: input/mask/prompt vacios, mode invalido", "determinismo"]
+test_file_path: "python/functions/ml/tests/test_comfyui_build_inpaint_asset_workflow.py"
 file_path: python/functions/ml/comfyui_build_inpaint_asset_workflow.py
 ---
 

python/functions/ml/comfyui_build_outpaint_asset_workflow.md

@@ -55,7 +55,9 @@ params:
   - name: filename_prefix
     desc: "Prefijo del archivo de salida en SaveImage. keyword-only."
 output: "dict en API format listo para comfyui_submit_workflow: outpaint que extiende el lienzo por los lados pedidos y genera lo nuevo con '{prompt}, {style}, seamless extension...', conservando el asset original. Nodos: CheckpointLoaderSimple '4', LoadImage '10', ImagePadForOutpaint (id nuevo, reusa el '12' que libera el LoadImageMask eliminado), VAEEncodeForInpaint '11' (pixels <- pad IMAGE, mask <- pad MASK), CLIPTextEncode '6'/'7', KSampler '3', VAEDecode '8', SaveImage '9' (+ LoraLoader si lora). El LoadImageMask de la base inpaint se elimina: la mascara la GENERA el pad."
-tested: false
+tested: true
+tests: ["estructura outpaint (ImagePadForOutpaint, sin LoadImageMask)", "pad cableado a VAEEncodeForInpaint (pixels<-IMAGE, mask<-MASK)", "extensiones redondeadas a multiplo de 8", "sin extension (todo 0 tras redondear) -> ValueError", "feather y prompt reflejados", "lora opcional + filename_prefix", "errores: input/prompt vacios", "determinismo"]
+test_file_path: "python/functions/ml/tests/test_comfyui_build_outpaint_asset_workflow.py"
 file_path: python/functions/ml/comfyui_build_outpaint_asset_workflow.py
 ---
 

python/functions/ml/comfyui_build_parallax_background_workflow.md

@@ -78,6 +78,21 @@ CheckpointLoaderSimple -> ... -> KSampler -> VAEDecode --IMAGE--+-> SaveImage (f
                                                                  `-> DepthAnythingV2Preprocessor -> SaveImage (depth)
 ```
 
+## Ejemplo
+
+```python
+import sys, os
+sys.path.insert(0, os.path.join("python", "functions"))
+from ml.comfyui_build_parallax_background_workflow import comfyui_build_parallax_background_workflow
+
+# Fondo apaisado + su mapa de profundidad, 4 bandas de parallax (función pura, sin red).
+wf = comfyui_build_parallax_background_workflow("forest at dusk, fantasy", layers=4, seed=7)
+
+# El dict API format trae DOS SaveImage: el fondo y el depth map. Encólalo con submit_workflow.
+saves = [n for n in wf.values() if n.get("class_type") == "SaveImage"]
+print(len(saves), "SaveImage (fondo + depth)")   # 2
+```
+
 ## Cuando usarla
 
 Cuando necesites el fondo de un nivel 2D con scroll parallax y quieras las capas

python/functions/ml/comfyui_build_pixelart_workflow.md

@@ -3,11 +3,11 @@ name: comfyui_build_pixelart_workflow
 kind: function
 lang: py
 domain: ml
-version: "1.0.0"
+version: "1.1.0"
 purity: pure
-signature: "def comfyui_build_pixelart_workflow(positive: str, negative: str = \"blurry, jpeg artifacts, gradient, smooth shading, anti-aliasing\", *, ckpt_name: str = \"IMG_juggernaut_xl_v11.safetensors\", pixel_lora: str = \"SDXL_pixel-art.safetensors\", lora_strength: float = 1.2, use_lcm: bool = True, lcm_lora: str = \"SDXL_lcm-lora.safetensors\", lcm_strength: float = 1.0, steps: int | None = None, cfg: float | None = None, width: int = 1024, height: int = 1024, seed: int = 0, sampler_name: str | None = None, scheduler: str | None = None, filename_prefix: str = \"pixelart\") -> dict"
+signature: "def comfyui_build_pixelart_workflow(positive: str, negative: str = \"blurry, jpeg artifacts, gradient, smooth shading, anti-aliasing\", *, ckpt_name: str = \"IMG_juggernaut_xl_v11.safetensors\", pixel_lora: str = \"SDXL_pixel-art.safetensors\", lora_strength: float = 1.2, use_lcm: bool = True, lcm_lora: str = \"SDXL_lcm-lora.safetensors\", lcm_strength: float = 1.0, steps: int | None = None, cfg: float | None = None, width: int = 1024, height: int = 1024, seed: int = 0, sampler_name: str | None = None, scheduler: str | None = None, transparent: bool = True, rembg_model: str = \"u2net\", filename_prefix: str = \"pixelart\") -> dict"
-description: "Construye el dict (API format) del workflow ComfyUI de pixel-art Fase 1: SDXL base + LoRA SDXL_pixel-art (nerijs), opcionalmente con LCM-LoRA para 8 steps. Compone comfyui_build_txt2img_workflow + comfyui_inject_multi_lora. El pixel-perfect (Fase 2) lo hace comfyui_pixelize_image, no este workflow. Pura, sin red ni I/O. class_types verificados contra /object_info (8GB lowvram)."
+description: "Construye el dict (API format) del workflow ComfyUI de pixel-art Fase 1: SDXL base + LoRA SDXL_pixel-art (nerijs), opcionalmente con LCM-LoRA para 8 steps. Si transparent (default), inyecta un nodo 'Image Rembg' tras el VAEDecode para recortar el fondo -> sprite con alpha (mismo patron que comfyui_build_item_icon_workflow); transparent=False para tiles/fondos opacos. Compone comfyui_build_txt2img_workflow + comfyui_inject_multi_lora. El pixel-perfect (Fase 2) lo hace comfyui_pixelize_image, no este workflow. Pura, sin red ni I/O. class_types verificados contra /object_info (8GB lowvram)."
-tags: [comfyui, ml, gamedev-2d, pixelart, workflow, stable-diffusion, sdxl]
+tags: [comfyui, ml, gamedev-2d, pixelart, workflow, stable-diffusion, sdxl, rembg, transparent]
 uses_functions: [comfyui_build_txt2img_workflow_py_ml, comfyui_inject_multi_lora_py_ml]
 uses_types: []
 returns: []
@@ -45,11 +45,15 @@ params:
     desc: "Sampler del KSampler. None = default del modo ('lcm' con LCM, 'euler' sin). keyword-only."
   - name: scheduler
     desc: "Scheduler del KSampler. None = default del modo ('sgm_uniform' con LCM, 'normal' sin). keyword-only."
+  - name: transparent
+    desc: "si True (default) inyecta 'Image Rembg' tras VAEDecode y el PNG sale con alpha (fondo recortado) — para sprites de sujeto (personajes/objetos). False deja fondo opaco — para tiles/texturas/fondos. keyword-only."
+  - name: rembg_model
+    desc: "modelo Rembg ('u2net' general, 'isnet-anime' anime). Solo se usa si transparent=True. keyword-only."
   - name: filename_prefix
     desc: "Prefijo del PNG que SaveImage escribe en output/. keyword-only."
-output: "dict en API format listo para comfyui_submit_workflow: CheckpointLoaderSimple + 1 LoraLoader (SDXL_pixel-art) o 2 (+ SDXL_lcm-lora si use_lcm) + KSampler con params del modo + SaveImage."
+output: "dict en API format listo para comfyui_submit_workflow: CheckpointLoaderSimple + 1 LoraLoader (SDXL_pixel-art) o 2 (+ SDXL_lcm-lora si use_lcm) + KSampler con params del modo + nodo 'Image Rembg' antes del SaveImage si transparent + SaveImage."
 tested: true
-tests: ["golden use_lcm=True: 2 LoraLoader (SDXL_pixel-art@1.2, lcm@1.0) + KSampler steps 8/cfg 1.5/sampler lcm/sgm_uniform", "edge use_lcm=False: 1 LoraLoader + KSampler steps 25/cfg 7/euler/normal", "edge overrides steps/cfg + clamp lora_strength a 2.0", "error positive vacio -> ValueError", "determinismo"]
+tests: ["golden use_lcm=True: 2 LoraLoader (SDXL_pixel-art@1.2, lcm@1.0) + KSampler steps 8/cfg 1.5/sampler lcm/sgm_uniform", "edge use_lcm=False: 1 LoraLoader + KSampler steps 25/cfg 7/euler/normal", "edge overrides steps/cfg + clamp lora_strength a 2.0", "error positive vacio -> ValueError", "determinismo", "transparent default inyecta Image Rembg + repunta SaveImage", "transparent=False sin Rembg (SaveImage lee del VAEDecode)", "rembg_model override"]
 test_file_path: "python/functions/ml/comfyui_build_pixelart_workflow_test.py"
 file_path: "python/functions/ml/comfyui_build_pixelart_workflow.py"
 ---
@@ -94,3 +98,15 @@ Para tilesets, genera cada tile por separado y ensambla con `comfyui_build_grid`
   `--lowvram`; la Fase 2 es CPU y no toca VRAM.
 - Función pura: no valida contra el server. Si una LoRA/checkpoint falta, el HTTP
   400 salta al enviar con `comfyui_submit_workflow`.
+- **transparent=True (default, v1.1.0)**: inyecta el nodo `Image Rembg (Remove
+  Background)`. Requiere el custom node `ComfyUI-Image-Background-Remove` (o equiv.)
+  instalado en el server; si falta, el `submit` devuelve error en el dict (no crashea).
+  El sprite sale RGBA con fondo recortado — ideal para personajes/objetos. Para
+  tiles/texturas/fondos sin contorno usar `transparent=False` (PNG opaco).
+
+## Capability growth log
+
+- v1.1.0 (2026-06-28) — `transparent`/`rembg_model`: inyecta `Image Rembg` tras el
+  VAEDecode (mismo patron que `comfyui_build_item_icon_workflow`) para producir
+  sprites con fondo transparente. Cierra el bug del pipeline pixelart que no podia
+  generar sprites sin fondo (issue sprite-fix).

python/functions/ml/comfyui_build_pixelart_workflow.py

@@ -19,6 +19,7 @@ Funcion pura: sin red, sin I/O. Determinista para los mismos argumentos.
 """
 from __future__ import annotations
 
+import copy
 import os
 import sys
 
@@ -29,6 +30,44 @@ _LCM_DEFAULTS = {"steps": 8, "cfg": 1.5, "sampler_name": "lcm", "scheduler": "sg
 _PLAIN_DEFAULTS = {"steps": 25, "cfg": 7.0, "sampler_name": "euler", "scheduler": "normal"}
 
 
+def _inject_rembg(workflow: dict, model: str) -> dict:
+    """Inserta 'Image Rembg (Remove Background)' (transparency=True) entre VAEDecode y SaveImage.
+
+    Mismo helper que comfyui_build_item_icon_workflow / comfyui_build_sprite_sheet_workflow:
+    el nodo recorta la silueta del sujeto dejando alpha, y se repunta SaveImage.images a
+    la salida del Rembg para que el PNG salga con fondo transparente. No muta el dict de
+    entrada (copia profunda).
+    """
+    wf = copy.deepcopy(workflow)
+    vaedecode_id = next(
+        (nid for nid, n in wf.items() if n.get("class_type") == "VAEDecode"), None
+    )
+    save_id = next((nid for nid, n in wf.items() if n.get("class_type") == "SaveImage"), None)
+    if vaedecode_id is None or save_id is None:
+        raise ValueError(
+            "comfyui_build_pixelart_workflow: no se encontro VAEDecode/SaveImage para Rembg"
+        )
+    numeric = [int(k) for k in wf.keys() if str(k).isdigit()]
+    rembg_id = str((max(numeric) + 1) if numeric else len(wf) + 1)
+    wf[rembg_id] = {
+        "class_type": "Image Rembg (Remove Background)",
+        "inputs": {
+            "images": [vaedecode_id, 0],
+            "transparency": True,
+            "model": model,
+            "post_processing": False,
+            "only_mask": False,
+            "alpha_matting": False,
+            "alpha_matting_foreground_threshold": 240,
+            "alpha_matting_background_threshold": 10,
+            "alpha_matting_erode_size": 10,
+            "background_color": "none",
+        },
+    }
+    wf[save_id]["inputs"]["images"] = [rembg_id, 0]
+    return wf
+
+
 def comfyui_build_pixelart_workflow(
     positive: str,
     negative: str = "blurry, jpeg artifacts, gradient, smooth shading, anti-aliasing",
@@ -46,6 +85,8 @@ def comfyui_build_pixelart_workflow(
     seed: int = 0,
     sampler_name: str | None = None,
     scheduler: str | None = None,
+    transparent: bool = True,
+    rembg_model: str = "u2net",
     filename_prefix: str = "pixelart",
 ) -> dict:
     """Construye el dict (API format) del workflow pixel-art SDXL + LoRA.
@@ -70,15 +111,24 @@ def comfyui_build_pixelart_workflow(
         width, height: resolucion base (1024x1024 SDXL; luego downscale x8 -> 128
             en la Fase 2 con comfyui_pixelize_image).
         seed: semilla del KSampler.
+        transparent: si True (default) inyecta 'Image Rembg' tras el VAEDecode y el
+            PNG sale con alpha (fondo recortado) — lo habitual para sprites de sujeto
+            (personajes, criaturas, objetos). Si False deja la imagen opaca sobre
+            fondo plano, para tiles/texturas/fondos que no quieren transparencia.
+            keyword-only.
+        rembg_model: modelo Rembg ('u2net' general, 'isnet-anime' para anime). Solo
+            se usa si transparent=True. keyword-only.
         filename_prefix: prefijo del PNG en output/.
 
     Returns:
         dict en API format listo para comfyui_submit_workflow, con el
         CheckpointLoaderSimple, 1 LoraLoader (SDXL_pixel-art) o 2 (SDXL_pixel-art +
-        SDXL_lcm-lora si use_lcm), KSampler con los params del modo y SaveImage.
+        SDXL_lcm-lora si use_lcm), KSampler con los params del modo, un nodo
+        'Image Rembg' antes del SaveImage si transparent, y SaveImage.
 
     Raises:
-        ValueError: si positive esta vacio.
+        ValueError: si positive esta vacio, o si la base no tiene VAEDecode/SaveImage
+            donde inyectar el Rembg (propagado por el helper, solo si transparent).
     """
     from ml.comfyui_build_txt2img_workflow import comfyui_build_txt2img_workflow
     from ml.comfyui_inject_multi_lora import comfyui_inject_multi_lora
@@ -117,7 +167,12 @@ def comfyui_build_pixelart_workflow(
             {"name": lcm_lora, "strength_model": lcm_strength, "strength_clip": lcm_strength}
         )
 
-    return comfyui_inject_multi_lora(base, loras)
+    wf = comfyui_inject_multi_lora(base, loras)
+
+    if transparent:
+        wf = _inject_rembg(wf, rembg_model)
+
+    return wf
 
 
 if __name__ == "__main__":

python/functions/ml/comfyui_build_sprite_from_sketch_workflow.md

@@ -51,7 +51,9 @@ params:
   - name: filename_prefix
     desc: "Prefijo del archivo de salida en SaveImage. keyword-only."
 output: "dict en API format listo para comfyui_submit_workflow: txt2img base (CheckpointLoaderSimple '4', EmptyLatentImage '5', CLIPTextEncode '6'/'7', KSampler '3' denoise 1.0, VAEDecode '8', SaveImage '9') + rama ControlNet (LoadImage del boceto -> [Preprocessor del control_type si preprocess] -> ControlNetApply -> KSampler.positive, con ControlNetLoader del modelo CN) + LoraLoader si lora. Es UN sprite; varios objetos del mismo set -> llamar por subject/sketch_image con el mismo style/checkpoint/(lora)."
-tested: false
+tested: true
+tests: ["estructura txt2img + ControlNet (EmptyLatentImage, ControlNetLoader/Apply)", "lineart: preprocesador + modelo por defecto, ControlNetApply consume el mapa de lineas", "canny: preprocesador + modelo", "preprocess=False pasa el boceto directo al ControlNet", "controlnet_name override + strength reflejado", "strength se clampa a [0,2]", "lora opcional", "errores: sketch/subject vacios, control_type invalido", "determinismo"]
+test_file_path: "python/functions/ml/tests/test_comfyui_build_sprite_from_sketch_workflow.py"
 file_path: python/functions/ml/comfyui_build_sprite_from_sketch_workflow.py
 ---
 

python/functions/ml/comfyui_build_walk_cycle_workflow.md

@@ -0,0 +1,121 @@
+---
+name: comfyui_build_walk_cycle_workflow
+kind: function
+lang: py
+domain: ml
+version: "1.0.0"
+purity: pure
+signature: "def comfyui_build_walk_cycle_workflow(subject: str, pose_skeletons: list, *, ckpt_name: str = \"IMG_dreamshaper_8.safetensors\", char_lora: str | None = None, lora_strength: float = 1.0, controlnet_name: str = \"control_v11p_sd15_openpose_fp16.safetensors\", controlnet_strength: float = 0.7, controlnet_start: float = 0.0, controlnet_end: float = 0.8, transparent: bool = True, rembg_model: str = \"u2net\", negative: str = \"blurry, lowres, extra limbs, deformed\", width: int = 512, height: int = 768, steps: int = 24, cfg: float = 7.0, seed: int = 0, sampler_name: str = \"dpmpp_2m\", scheduler: str = \"karras\", fps: int = 8, filename_prefix: str = \"walk_cycle\") -> dict"
+description: "Construye el dict (API format) del workflow de un WALK CYCLE animado: genera N frames de un personaje en N poses OpenPose con la MISMA seed (identidad consistente), los combina en un batch encadenando ImageBatch, recorta el fondo a alpha con Rembg y los exporta como WEBP animado con SaveAnimatedWEBP. Caso 1 del report 0217 (animacion de sprite frame-by-frame pose-driven). Hermano animado de comfyui_build_sprite_sheet_workflow (frame estatico) y de comfyui_build_directional_sprite_workflow (rotacion 3D). Pura, sin red ni I/O. class_types e inputs verificados contra /object_info."
+tags: [gamedev-2d, comfyui, sprite, animation, walk-cycle, controlnet, openpose]
+uses_functions: []
+uses_types: []
+returns: []
+returns_optional: false
+error_type: ""
+imports: []
+params:
+  - name: subject
+    desc: "Descripcion del personaje (ej. 'pixel art knight'). Se completa con ', full body, game sprite, simple background, walking'. No puede estar vacio."
+  - name: pose_skeletons
+    desc: "Lista (no vacia) de nombres de archivo de esqueletos OpenPose en el dir input/ del servidor, uno por frame del ciclo en orden de animacion. Cada uno debe ser string no vacio. La lista no se muta."
+  - name: ckpt_name
+    desc: "Checkpoint SD1.5 (OpenPose solo instalado en SD1.5; default 'IMG_dreamshaper_8.safetensors'). keyword-only."
+  - name: char_lora
+    desc: "LoRA de personaje/estilo opcional en models/loras (refuerza consistencia de ropa/cuerpo entre frames). None = sin LoRA. keyword-only."
+  - name: lora_strength
+    desc: "Fuerza del char_lora sobre model y clip. keyword-only."
+  - name: controlnet_name
+    desc: "ControlNet OpenPose (default SD1.5 'control_v11p_sd15_openpose_fp16.safetensors'). keyword-only."
+  - name: controlnet_strength
+    desc: "Fuerza del OpenPose (default 0.7). keyword-only."
+  - name: controlnet_start
+    desc: "Inicio de aplicacion del OpenPose (fraccion 0..1). keyword-only."
+  - name: controlnet_end
+    desc: "Fin de aplicacion del OpenPose (end<1.0 deja libres los ultimos pasos para pelo/ropa; default 0.8). keyword-only."
+  - name: transparent
+    desc: "Si True inyecta Rembg para alpha (recomendado para sprites de juego). False = fondo opaco. keyword-only."
+  - name: rembg_model
+    desc: "Modelo Rembg ('u2net' general, 'isnet-anime' para anime). keyword-only."
+  - name: negative
+    desc: "Prompt negativo. keyword-only."
+  - name: width
+    desc: "Ancho en px (512). keyword-only."
+  - name: height
+    desc: "Alto en px (768, vertical, encuadra cuerpo entero). keyword-only."
+  - name: steps
+    desc: "Pasos del KSampler. keyword-only."
+  - name: cfg
+    desc: "CFG del KSampler. keyword-only."
+  - name: seed
+    desc: "Semilla del KSampler, FIJA e identica para todos los frames (identidad consistente). keyword-only."
+  - name: sampler_name
+    desc: "Sampler del KSampler (default 'dpmpp_2m'). keyword-only."
+  - name: scheduler
+    desc: "Scheduler del KSampler (default 'karras'). keyword-only."
+  - name: fps
+    desc: "Frames por segundo del WEBP animado (default 8). keyword-only."
+  - name: filename_prefix
+    desc: "Prefijo del archivo WEBP en output/ (default 'walk_cycle'). keyword-only."
+output: "dict en API format listo para comfyui_submit_workflow. Claves = node_ids (string); cada valor tiene class_type + inputs. Estructura: CheckpointLoaderSimple (+ LoraLoader si char_lora) + 2x CLIPTextEncode + ControlNetLoader compartido + N x (LoadImage + ControlNetApplyAdvanced + EmptyLatentImage + KSampler + VAEDecode) + cadena de ImageBatch que une los N frames + Rembg (si transparent) + SaveAnimatedWEBP."
+tested: false
+tests: []
+test_file_path: ""
+file_path: "python/functions/ml/comfyui_build_walk_cycle_workflow.py"
+---
+
+## Ejemplo
+
+```python
+import sys, os
+sys.path.insert(0, os.path.join(os.environ["HOME"], "fn_registry", "python", "functions"))
+from ml.comfyui_build_walk_cycle_workflow import comfyui_build_walk_cycle_workflow
+
+# Ciclo de andar de 4 frames: 4 esqueletos OpenPose (en input/ del servidor),
+# misma seed -> el mismo personaje caminando, no 4 personajes distintos.
+wf = comfyui_build_walk_cycle_workflow(
+    "pixel art knight",
+    pose_skeletons=[
+        "walk_pose_00.png",
+        "walk_pose_01.png",
+        "walk_pose_02.png",
+        "walk_pose_03.png",
+    ],
+    transparent=True,
+    fps=8,
+    seed=0,
+)
+# wf es API format -> comfyui_submit_workflow(wf) genera el WEBP animado en output/.
+```
+
+O lanzable directo con: `./fn run comfyui_build_walk_cycle_workflow` (imprime nodos + class_types del ejemplo).
+
+## Cuando usarla
+
+Cuando necesites una **animacion** de un sprite de personaje 2D (no un frame suelto):
+ciclo de andar, correr, atacar, idle... — cualquier secuencia donde el personaje conserva
+su identidad y solo cambia la postura. Dibuja los N esqueletos OpenPose de la secuencia,
+pasalos en orden, fija la `seed` y obtienes un WEBP animado de una sola pasada. Para UN
+frame estatico usa `comfyui_build_sprite_sheet_workflow`; para rotar el personaje en 3D
+(vistas direccionales) usa `comfyui_build_directional_sprite_workflow`.
+
+## Gotchas
+
+- **Solo SD1.5 hoy**: el ControlNet OpenPose esta instalado solo en SD1.5. Usa
+  `IMG_dreamshaper_8` u otro checkpoint SD1.5.
+- **`pose_skeletons` son nombres de archivo en el dir `input/` del servidor**, no rutas
+  locales. Subelas antes (cada LoadImage las lee de ahi). El orden de la lista = el orden
+  de los frames de la animacion.
+- **La `seed` es FIJA para todos los frames a proposito**: compartir seed + prompt +
+  checkpoint y variar solo el OpenPose es lo que mantiene al mismo personaje entre
+  fotogramas. Una seed por frame haria "parpadear" la identidad (cara/ropa/paleta derivan).
+- **`ControlNetApplyAdvanced` con `end_percent` 0.8** deja los ultimos pasos libres para
+  que pelo/ropa no queden aplastados contra el esqueleto.
+- **El batch se construye encadenando `ImageBatch`** (toma 2 imagenes): para N frames hay
+  N-1 nodos ImageBatch. Con N=1 no hay ImageBatch (el unico frame va directo al Save).
+- `Image Rembg` da matting binario (silueta solida) — ideal para personajes, NO para
+  efectos translucidos (humo/fuego). Con `transparent=False` se omite (fondo opaco).
+- **El WEBP animado** usa `lossless=True`, `quality=90`, `method="default"`; sube/baja
+  `fps` para la velocidad del ciclo. Verificado que `method` admite `default/fastest/slowest`.
+- Funcion pura: construye el grafo, NO valida contra el server ni envia nada. El coste GPU
+  esta al enviar con `comfyui_submit_workflow`.

python/functions/ml/comfyui_build_walk_cycle_workflow.py

@@ -0,0 +1,299 @@
+"""Construye el workflow ComfyUI de un WALK CYCLE animado (N frames pose-driven -> WEBP).
+
+Caso 1 del report 0217 ("animacion de sprite frame-by-frame pose-driven"): a partir de
+N esqueletos OpenPose que describen las poses sucesivas de un ciclo de andar, construye el
+dict (API format) de un workflow que:
+
+  1. genera un frame por pose con la MISMA seed y el MISMO prompt/checkpoint/LoRA, de modo
+     que el personaje conserva su identidad de un frame al siguiente (la unica variable es
+     el esqueleto OpenPose que dicta la postura);
+  2. combina los N frames en un unico batch encadenando `ImageBatch`;
+  3. recorta el fondo a alpha con `Image Rembg (Remove Background)` (transparencia para el
+     motor del juego);
+  4. los exporta como WEBP animado con `SaveAnimatedWEBP` (un solo archivo reproducible).
+
+Es el builder PURO equivalente a `comfyui_build_sprite_sheet_workflow` (que produce UN
+frame estatico) pero orientado a ANIMACION: en vez de devolver un sprite suelto por pose y
+montar un contact-sheet a posteriori, este grafo produce de una sola pasada el WEBP animado
+del ciclo. Hermano direccional: `comfyui_build_directional_sprite_workflow` (rota el
+personaje en 3D); aqui el personaje no rota, camina (mismo angulo de camara, poses 2D).
+
+Por que ControlNetApplyAdvanced (y no el legacy ControlNetApply): `end_percent` < 1.0 deja
+los ultimos pasos del sampler libres para que pelo y ropa no queden aplastados contra el
+esqueleto OpenPose (mismo razonamiento que el sprite sheet, report 0137).
+
+Por que la seed es FIJA para todos los frames: una seed distinta por frame haria que el
+personaje "parpadee" de identidad entre fotogramas (ropa/cara/paleta derivan). Compartir la
+seed + prompt + checkpoint y variar solo el OpenPose es lo que hace que sea el mismo
+personaje andando, no N personajes distintos en N posturas.
+
+Funcion PURA: sin red, sin I/O. No muta las entradas (no recibe dicts; copia la lista de
+poses). Todos los class_types y sus inputs estan verificados contra /object_info del server
+8GB (CheckpointLoaderSimple, LoraLoader, CLIPTextEncode, ControlNetLoader, LoadImage,
+ControlNetApplyAdvanced, EmptyLatentImage, KSampler, VAEDecode, ImageBatch,
+'Image Rembg (Remove Background)', SaveAnimatedWEBP).
+"""
+from __future__ import annotations
+
+
+def comfyui_build_walk_cycle_workflow(
+    subject: str,
+    pose_skeletons: list,
+    *,
+    ckpt_name: str = "IMG_dreamshaper_8.safetensors",
+    char_lora: str | None = None,
+    lora_strength: float = 1.0,
+    controlnet_name: str = "control_v11p_sd15_openpose_fp16.safetensors",
+    controlnet_strength: float = 0.7,
+    controlnet_start: float = 0.0,
+    controlnet_end: float = 0.8,
+    transparent: bool = True,
+    rembg_model: str = "u2net",
+    negative: str = "blurry, lowres, extra limbs, deformed",
+    width: int = 512,
+    height: int = 768,
+    steps: int = 24,
+    cfg: float = 7.0,
+    seed: int = 0,
+    sampler_name: str = "dpmpp_2m",
+    scheduler: str = "karras",
+    fps: int = 8,
+    filename_prefix: str = "walk_cycle",
+) -> dict:
+    """Construye el dict (API format) del workflow de un walk cycle animado.
+
+    Genera un frame por cada esqueleto OpenPose de ``pose_skeletons`` con identidad
+    consistente (misma seed/prompt/checkpoint), los combina en un batch, los recorta a
+    alpha (Rembg) y los guarda como WEBP animado.
+
+    Args:
+        subject: descripcion del personaje (ej. "pixel art knight"). Se completa con
+            ", full body, game sprite, simple background, walking". No puede estar vacio.
+        pose_skeletons: lista (no vacia) de nombres de archivo de esqueletos OpenPose en el
+            dir ``input/`` del servidor (uno por frame del ciclo, en orden de animacion). El
+            grafo crea un LoadImage por entrada; cada uno debe ser un string no vacio. La
+            lista no se muta.
+        ckpt_name: checkpoint SD1.5 (OpenPose solo instalado en SD1.5; default
+            'IMG_dreamshaper_8.safetensors'). keyword-only.
+        char_lora: LoRA de personaje/estilo opcional en models/loras (refuerza la
+            consistencia de ropa/cuerpo entre frames). None = sin LoRA. keyword-only.
+        lora_strength: fuerza del char_lora sobre model y clip. keyword-only.
+        controlnet_name: ControlNet OpenPose (default SD1.5). keyword-only.
+        controlnet_strength: fuerza del OpenPose (default 0.7). keyword-only.
+        controlnet_start: inicio de aplicacion del OpenPose (fraccion 0..1). keyword-only.
+        controlnet_end: fin de aplicacion del OpenPose (end<1.0 deja libres los ultimos
+            pasos para pelo/ropa; default 0.8). keyword-only.
+        transparent: si True inyecta Rembg para alpha (recomendado para sprites de juego).
+            False = fondo opaco. keyword-only.
+        rembg_model: modelo Rembg ('u2net' general, 'isnet-anime' para anime). keyword-only.
+        negative: prompt negativo. keyword-only.
+        width: ancho en px (512). keyword-only.
+        height: alto en px (768, vertical, encuadra cuerpo entero). keyword-only.
+        steps: pasos del KSampler. keyword-only.
+        cfg: CFG del KSampler. keyword-only.
+        seed: semilla del KSampler, FIJA e identica para todos los frames (identidad
+            consistente). keyword-only.
+        sampler_name: sampler del KSampler (default 'dpmpp_2m'). keyword-only.
+        scheduler: scheduler del KSampler (default 'karras'). keyword-only.
+        fps: frames por segundo del WEBP animado (default 8). keyword-only.
+        filename_prefix: prefijo del archivo WEBP en output/ (default 'walk_cycle').
+            keyword-only.
+
+    Returns:
+        dict en API format listo para comfyui_submit_workflow. Las claves son node_ids
+        (string) y cada valor tiene class_type + inputs. Estructura: CheckpointLoaderSimple
+        (+ LoraLoader si char_lora) + 2x CLIPTextEncode + ControlNetLoader compartido +
+        N x (LoadImage + ControlNetApplyAdvanced + EmptyLatentImage + KSampler + VAEDecode)
+        + cadena de ImageBatch que une los N frames + Rembg (si transparent) +
+        SaveAnimatedWEBP.
+
+    Raises:
+        ValueError: si subject esta vacio, pose_skeletons esta vacio, o alguna pose no es un
+            string no vacio.
+    """
+    if not subject or not subject.strip():
+        raise ValueError("comfyui_build_walk_cycle_workflow: 'subject' no puede estar vacio")
+    if not isinstance(pose_skeletons, (list, tuple)) or len(pose_skeletons) == 0:
+        raise ValueError(
+            "comfyui_build_walk_cycle_workflow: 'pose_skeletons' debe ser una lista no vacia "
+            "de nombres de esqueletos OpenPose en input/ (uno por frame del ciclo)."
+        )
+    poses = list(pose_skeletons)
+    for i, p in enumerate(poses):
+        if not isinstance(p, str) or not p.strip():
+            raise ValueError(
+                "comfyui_build_walk_cycle_workflow: pose_skeletons["
+                f"{i}] debe ser un string no vacio (nombre de archivo en input/)."
+            )
+
+    positive = f"{subject}, full body, game sprite, simple background, walking"
+
+    wf: dict = {}
+    counter = [0]
+
+    def nid() -> str:
+        counter[0] += 1
+        return str(counter[0])
+
+    # 1. Checkpoint -> MODEL(0), CLIP(1), VAE(2).
+    ckpt_id = nid()
+    wf[ckpt_id] = {
+        "class_type": "CheckpointLoaderSimple",
+        "inputs": {"ckpt_name": ckpt_name},
+    }
+    model_src = [ckpt_id, 0]
+    clip_src = [ckpt_id, 1]
+    vae_src = [ckpt_id, 2]
+
+    # 2. LoRA opcional -> reapunta MODEL/CLIP a su salida.
+    if char_lora:
+        lora_id = nid()
+        wf[lora_id] = {
+            "class_type": "LoraLoader",
+            "inputs": {
+                "model": model_src,
+                "clip": clip_src,
+                "lora_name": char_lora,
+                "strength_model": lora_strength,
+                "strength_clip": lora_strength,
+            },
+        }
+        model_src = [lora_id, 0]
+        clip_src = [lora_id, 1]
+
+    # 3. Prompts positivo y negativo (compartidos por todos los frames).
+    pos_clip_id = nid()
+    wf[pos_clip_id] = {
+        "class_type": "CLIPTextEncode",
+        "inputs": {"text": positive, "clip": clip_src},
+    }
+    neg_clip_id = nid()
+    wf[neg_clip_id] = {
+        "class_type": "CLIPTextEncode",
+        "inputs": {"text": negative, "clip": clip_src},
+    }
+
+    # 4. ControlNetLoader compartido (uno solo para todas las poses).
+    cn_loader_id = nid()
+    wf[cn_loader_id] = {
+        "class_type": "ControlNetLoader",
+        "inputs": {"control_net_name": controlnet_name},
+    }
+
+    # 5. Por cada pose: LoadImage -> ControlNetApplyAdvanced -> EmptyLatent -> KSampler -> VAEDecode.
+    frame_image_srcs: list = []
+    for pose in poses:
+        load_id = nid()
+        wf[load_id] = {"class_type": "LoadImage", "inputs": {"image": pose}}
+
+        apply_id = nid()
+        wf[apply_id] = {
+            "class_type": "ControlNetApplyAdvanced",
+            "inputs": {
+                "positive": [pos_clip_id, 0],
+                "negative": [neg_clip_id, 0],
+                "control_net": [cn_loader_id, 0],
+                "image": [load_id, 0],
+                "strength": controlnet_strength,
+                "start_percent": controlnet_start,
+                "end_percent": controlnet_end,
+            },
+        }
+
+        latent_id = nid()
+        wf[latent_id] = {
+            "class_type": "EmptyLatentImage",
+            "inputs": {"width": width, "height": height, "batch_size": 1},
+        }
+
+        ksampler_id = nid()
+        wf[ksampler_id] = {
+            "class_type": "KSampler",
+            "inputs": {
+                "seed": seed,  # FIJA: misma seed para todos los frames (identidad consistente).
+                "steps": steps,
+                "cfg": cfg,
+                "sampler_name": sampler_name,
+                "scheduler": scheduler,
+                "denoise": 1.0,
+                "model": model_src,
+                "positive": [apply_id, 0],
+                "negative": [apply_id, 1],
+                "latent_image": [latent_id, 0],
+            },
+        }
+
+        vae_id = nid()
+        wf[vae_id] = {
+            "class_type": "VAEDecode",
+            "inputs": {"samples": [ksampler_id, 0], "vae": vae_src},
+        }
+        frame_image_srcs.append([vae_id, 0])
+
+    # 6. Combinar los N frames en un solo batch encadenando ImageBatch.
+    if len(frame_image_srcs) == 1:
+        batch_src = frame_image_srcs[0]
+    else:
+        batch_src = frame_image_srcs[0]
+        for next_src in frame_image_srcs[1:]:
+            ib_id = nid()
+            wf[ib_id] = {
+                "class_type": "ImageBatch",
+                "inputs": {"image1": batch_src, "image2": next_src},
+            }
+            batch_src = [ib_id, 0]
+
+    # 7. Rembg opcional sobre el batch (alpha para el motor del juego).
+    save_images_src = batch_src
+    if transparent:
+        rembg_id = nid()
+        wf[rembg_id] = {
+            "class_type": "Image Rembg (Remove Background)",
+            "inputs": {
+                "images": batch_src,
+                "transparency": True,
+                "model": rembg_model,
+                "post_processing": False,
+                "only_mask": False,
+                "alpha_matting": False,
+                "alpha_matting_foreground_threshold": 240,
+                "alpha_matting_background_threshold": 10,
+                "alpha_matting_erode_size": 10,
+                "background_color": "none",
+            },
+        }
+        save_images_src = [rembg_id, 0]
+
+    # 8. Exportar el ciclo como WEBP animado.
+    save_id = nid()
+    wf[save_id] = {
+        "class_type": "SaveAnimatedWEBP",
+        "inputs": {
+            "images": save_images_src,
+            "filename_prefix": filename_prefix,
+            "fps": float(fps),
+            "lossless": True,
+            "quality": 90,
+            "method": "default",
+        },
+    }
+
+    return wf
+
+
+if __name__ == "__main__":
+    import json
+
+    wf = comfyui_build_walk_cycle_workflow(
+        "pixel art knight",
+        pose_skeletons=[
+            "walk_pose_00.png",
+            "walk_pose_01.png",
+            "walk_pose_02.png",
+            "walk_pose_03.png",
+        ],
+    )
+    print(json.dumps({
+        "nodes": list(wf),
+        "classes": sorted({n["class_type"] for n in wf.values()}),
+    }, indent=2))

python/functions/ml/comfyui_critique_image_llm.md

@@ -26,9 +26,9 @@ params:
   - name: token
     desc: "Token OAuth; si vacio lo carga ask_llm_vision automaticamente. keyword-only."
 output: "dict {ok, verdict, score_0_10, reasons, error}. En exito ok=True, verdict 'good'|'bad', score_0_10 el score del modelo y reasons la lista de razones. En error (imagen invalida, API caida, 429, JSON no parseable) ok=False con error. Nunca lanza excepcion."
-tested: false
+tested: true
-tests: []
+tests: ["_extract_json: fence json", "_extract_json: brace plano", "_extract_json: sin objeto -> ValueError", "flujo: veredicto estructurado good", "verdict ambiguo -> bad conservador", "API caida -> ok=False", "respuesta no parseable -> ok=False"]
-test_file_path: ""
+test_file_path: "python/functions/ml/tests/test_comfyui_critique_image_llm.py"
 file_path: "python/functions/ml/comfyui_critique_image_llm.py"
 ---
 

python/functions/ml/comfyui_extract_recipe_from_png.md

@@ -26,9 +26,9 @@ params:
   - name: nsfw
     desc: "Marca provenance.nsfw. keyword-only."
 output: "dict {ok, recipe, slug, has_workflow, error}. recipe sigue el schema minimo de comfyui_save_skill con provenance.source='civitai' y score_n=0. ok=False solo si no hay ni workflow embebido ni civitai_meta utilizable."
-tested: false
+tested: true
-tests: []
+tests: ["_slugify (normaliza y acota a 6 tokens)", "_loras_from_prompt", "_dims_from_prompt + _checkpoint_from_prompt", "_detect_base_workflow (flux/txt2img)", "_from_civitai_meta (mapea steps/cfg/size/modelo/prompts)", "flujo fallback a civitai_meta sin workflow embebido", "slug derivado del prompt", "error: sin workflow ni meta"]
-test_file_path: ""
+test_file_path: "python/functions/ml/tests/test_comfyui_extract_recipe_from_png.py"
 file_path: "python/functions/ml/comfyui_extract_recipe_from_png.py"
 ---
 

python/functions/ml/comfyui_fetch_civitai_image_meta.md

@@ -5,7 +5,7 @@ lang: py
 domain: ml
 version: "1.0.0"
 purity: impure
-signature: "def comfyui_fetch_civitai_image_meta(image_ref, *, token: str | None = None, timeout: float = 15.0) -> dict"
+signature: "def comfyui_fetch_civitai_image_meta(image_ref, token: str | None = None, timeout: float = 15.0) -> dict"
 description: "Recupera los detalles de generacion de una imagen de Civitai por su id o URL (civitai.com/images/<id>): prompt, prompt negativo, modelo, sampler, steps, cfg, seed, dimensiones, recursos (checkpoint + LoRAs) y nivel NSFW. Es el paso 'entrar al link y observar como lo hicieron'. Usa los endpoints tRPC image.getGenerationData + image.get que consume la propia web de civitai.com, porque la API v1 publica (GET /api/v1/images) hoy devuelve meta=null y un JPEG recomprimido sin workflow embebido. Si la meta trae un workflow ComfyUI embebido (campo comfy) lo devuelve en API format. NO descarga la imagen ni reconstruye workflow: solo lee. Impura: HTTP a civitai.com + subprocess (pass para el token)."
 tags: [comfyui, civitai, replicate, ml, metadata, http, stable-diffusion]
 uses_functions: []

python/functions/ml/comfyui_fetch_civitai_image_meta.py

@@ -128,15 +128,15 @@ def _extract_comfy_workflow(meta):
     return {}
 
 
-def comfyui_fetch_civitai_image_meta(image_ref, *, token=None, timeout=15.0):
+def comfyui_fetch_civitai_image_meta(image_ref, token=None, timeout=15.0):
     """Recupera los detalles de generación de una imagen de Civitai por id/URL.
 
     Args:
         image_ref: id numérico de la imagen (int o str), o su URL
             `https://civitai.com/images/<id>` (con o sin query string).
         token: API token de Civitai (header Authorization Bearer). Si None se
-            resuelve de `pass civitai/api-token`. No hardcodear. keyword-only.
+            resuelve de `pass civitai/api-token`. No hardcodear.
-        timeout: timeout HTTP en segundos por petición. keyword-only.
+        timeout: timeout HTTP en segundos por petición.
 
     Returns:
         dict {ok, image_id, meta, resources, process, comfy_workflow, width,

python/functions/ml/comfyui_flatten_alpha_on_color.md

@@ -26,9 +26,9 @@ params:
   - name: resample
     desc: "filtro de reescalado: 'lanczos' (por defecto), 'nearest', 'bilinear', 'bicubic', 'area'. String desconocido -> LANCZOS. keyword-only."
 output: "dict con ok (bool), out_path (str, ruta del PNG RGB; vacio si error), size ([w,h] final), error (str, vacio si OK)."
-tested: false
+tested: true
-tests: []
+tests: ["aplana transparente sobre blanco -> RGB sin alpha", "color de fondo personalizado", "size redimensiona a cuadrado", "out_path por defecto con sufijo _flat", "error: imagen inexistente", "determinismo (mismos bytes de salida)"]
-test_file_path: ""
+test_file_path: "python/functions/ml/tests/test_comfyui_flatten_alpha_on_color.py"
 file_path: "python/functions/ml/comfyui_flatten_alpha_on_color.py"
 ---
 

python/functions/ml/comfyui_import_workflow_json.md

@@ -22,9 +22,9 @@ params:
   - name: timeout
     desc: "Timeout HTTP en segundos. keyword-only."
 output: "dict {ok, workflow, format_detected, error}. workflow = dict en API format; format_detected = 'api' (passthrough) o 'ui_graph' (convertido) o ''. Si falla la lectura/parse, ok=False y error explica."
-tested: false
+tested: true
-tests: []
+tests: ["API format se devuelve tal cual (format=api)", "UI graph se normaliza a API (descarta Note, resuelve conexiones)", "JSON invalido -> error", "formato no reconocido -> error", "JSON no es objeto -> error", "archivo inexistente -> error", "determinismo"]
-test_file_path: ""
+test_file_path: "python/functions/ml/tests/test_comfyui_import_workflow_json.py"
 file_path: "python/functions/ml/comfyui_import_workflow_json.py"
 ---
 

python/functions/ml/comfyui_import_workflow_png.md

@@ -5,7 +5,7 @@ lang: py
 domain: ml
 version: "1.0.0"
 purity: impure
-signature: "def comfyui_import_workflow_png(png_path_or_url: str, *, timeout: float = 15.0) -> dict"
+signature: "def comfyui_import_workflow_png(png_path_or_url: str, timeout: float = 15.0) -> dict"
 description: "Extrae el workflow embebido en los chunks de texto de un PNG de ComfyUI. Lee el chunk 'prompt' (API format) y/o 'workflow' (UI graph) de los chunks tEXt/zTXt/iTXt con stdlib (struct, zlib). Acepta path local o URL. Impura: red opcional + lectura de disco."
 tags: [comfyui, ml, import, png, workflow, stable-diffusion]
 uses_functions: []

python/functions/ml/comfyui_import_workflow_png.py

@@ -14,12 +14,12 @@ import urllib.request
 import zlib
 
 
-def comfyui_import_workflow_png(png_path_or_url: str, *, timeout: float = 15.0) -> dict:
+def comfyui_import_workflow_png(png_path_or_url: str, timeout: float = 15.0) -> dict:
     """Devuelve el/los workflow(s) embebido(s) en un PNG de ComfyUI.
 
     Args:
         png_path_or_url: ruta local de un PNG, o URL http(s) de un PNG.
-        timeout: timeout HTTP en segundos (solo si es URL). keyword-only.
+        timeout: timeout HTTP en segundos (solo si es URL).
 
     Returns:
         dict {ok, prompt, workflow, format_detected, error}:

python/functions/ml/comfyui_interrupt_queue.md

@@ -3,10 +3,10 @@ name: comfyui_interrupt_queue
 kind: function
 lang: py
 domain: ml
-version: "1.0.0"
+version: "1.1.0"
 purity: impure
-signature: "def comfyui_interrupt_queue(server: str = \"127.0.0.1:8188\") -> dict"
+signature: "def comfyui_interrupt_queue(clear_pending: bool = False, server: str = \"127.0.0.1:8188\", timeout: float = 10.0) -> dict"
-description: "Corta la generacion en curso de ComfyUI (POST /interrupt) y devuelve el estado de la cola (GET /queue). Devuelve {ok, interrupted, queue_running, queue_pending, error}. NO lanza excepcion en fallo de red: degrada a {ok: False, error}. /interrupt corta solo el prompt en ejecucion, no vacia los pendientes. Impura: HTTP POST + GET, solo stdlib (urllib, json)."
+description: "Corta la generacion en curso de ComfyUI (POST /interrupt) y, si clear_pending=True, vacia ademas la cola de pendientes (POST /queue {\"clear\":true}). Consulta GET /queue al final para reportar queue_remaining. Devuelve {ok, interrupted, cleared, queue_remaining, error}. NO lanza excepcion en fallo de red: degrada a {ok: False, error}. /interrupt corta solo el prompt en ejecucion, no vacia los pendientes salvo clear_pending. Impura: HTTP POST + GET, solo stdlib (urllib, json)."
 tags: [comfyui, ml, queue, interrupt, control, http]
 uses_functions: []
 uses_types: []
@@ -15,12 +15,16 @@ returns_optional: false
 error_type: "error_go_core"
 imports: []
 params:
+  - name: clear_pending
+    desc: "keyword-only. Si True, ademas de cortar el prompt en ejecucion vacia la cola de pendientes con POST /queue {\"clear\":true}. Default False."
   - name: server
-    desc: "host:port del servidor ComfyUI sin esquema (default '127.0.0.1:8188')."
+    desc: "keyword-only. host:port del servidor ComfyUI sin esquema (default '127.0.0.1:8188')."
-output: "dict con ok (bool, True si interrupt + lectura de cola OK), interrupted (bool, True si POST /interrupt respondio), queue_running (int, prompts ejecutandose), queue_pending (int, prompts encolados), error (str, vacio si todo OK)."
+  - name: timeout
-tested: false
+    desc: "keyword-only. Timeout de cada peticion HTTP en segundos (default 10.0)."
-tests: []
+output: "dict con ok (bool, True si interrupt + clear (si se pidio) + lectura de cola OK), interrupted (bool, True si POST /interrupt respondio), cleared (bool, True si clear_pending y POST /queue {clear:true} respondio; False si no se pidio o fallo), queue_remaining (int, queue_running + queue_pending tras la operacion), error (str, vacio si todo OK)."
-test_file_path: ""
+tested: true
+tests: ["test_interrumpe_sin_vaciar", "test_clear_pending_vacia_cola", "test_clear_pending_cola_vacia_no_rompe", "test_servidor_caido_no_lanza"]
+test_file_path: "python/functions/ml/tests/test_comfyui_interrupt_queue.py"
 file_path: "python/functions/ml/comfyui_interrupt_queue.py"
 ---
 
@@ -31,30 +35,47 @@ import sys, os
 sys.path.insert(0, os.path.join(os.environ["HOME"], "fn_registry", "python", "functions"))
 from ml.comfyui_interrupt_queue import comfyui_interrupt_queue
 
+# Solo cortar el prompt en ejecucion (los pendientes siguen):
 res = comfyui_interrupt_queue()
-# {'ok': True, 'interrupted': True, 'queue_running': 0, 'queue_pending': 0, 'error': ''}
+# {'ok': True, 'interrupted': True, 'cleared': False, 'queue_remaining': 3, 'error': ''}
-if res["ok"] and res["interrupted"]:
+
-    print(f"cortado; pendientes en cola: {res['queue_pending']}")
+# Cortar el actual Y vaciar los pendientes de golpe:
+res = comfyui_interrupt_queue(clear_pending=True)
+# {'ok': True, 'interrupted': True, 'cleared': True, 'queue_remaining': 0, 'error': ''}
+if res["ok"]:
+    print(f"cortado; quedan {res['queue_remaining']} en cola")
 ```
 
-O lanzable directo con: `./fn run comfyui_interrupt_queue`.
+O lanzable directo: `./fn run comfyui_interrupt_queue` · `./fn run comfyui_interrupt_queue --clear`.
 
 ## Cuando usarla
 
 Para abortar una generacion que se esta tomando demasiado, que tira de mas VRAM de
-la prevista, o tras encolar por error un workflow pesado. Tambien para inspeccionar
+la prevista, o tras encolar por error un workflow pesado. Con `clear_pending=True`
-de un vistazo cuanto queda en cola (`queue_running` / `queue_pending`) sin parsear
+es el freno de mano completo: corta el actual y borra todo lo encolado en una sola
-el JSON de /queue a mano. Es el freno de mano del round-trip build -> submit -> wait.
+llamada (sin tener que encadenar `comfyui_queue_manage("clear")` despues). Tras la
+operacion `queue_remaining` dice de un vistazo cuanto queda en cola.
 
 ## Gotchas
 
-- `/interrupt` corta SOLO el prompt en ejecucion; los pendientes (`queue_pending`)
+- `/interrupt` corta SOLO el prompt en ejecucion; sin `clear_pending` los pendientes
-  siguen y el siguiente arranca de inmediato. Para vaciar la cola entera hay que
+  (`queue_pending`) siguen y el siguiente arranca de inmediato. Pasa
-  llamar `POST /queue` con `{"clear": true}` (no lo hace esta funcion — solo corta
+  `clear_pending=True` para vaciar tambien la cola (POST /queue {"clear": true}).
-  + lee).
 - No es idempotente en el sentido de "sin efecto": si hay algo ejecutandose, lo
-  mata. Si la cola esta vacia, el interrupt es inocuo (interrupted=True igual).
+  mata. Si la cola esta vacia, tanto el interrupt como el clear son inocuos
+  (`interrupted=True`/`cleared=True` igual, `queue_remaining=0`).
+- `queue_remaining` se lee al FINAL (GET /queue tras interrupt+clear): es
+  `queue_running + queue_pending`. Justo tras un interrupt sin clear puede ser >0
+  porque el siguiente pendiente ya arranco.
 - En fallo de red NO lanza: devuelve `ok=False` con el mensaje en `error`. Comprueba
-  `ok` antes de fiarte de los conteos.
+  `ok` antes de fiarte de `queue_remaining`.
 - Tras el interrupt conviene liberar VRAM con `POST /free` si vas a encolar otro
-  trabajo pesado (esta funcion no lo hace).
+  trabajo pesado (esta funcion no lo hace; ver el round-trip build -> submit -> wait).
+- Para operaciones de cola mas finas (borrar UN prompt por id, contar el historial)
+  usa `comfyui_queue_manage`; esta funcion se centra en el interrupt + clear masivo.
+
+## Capability growth log
+
+- v1.1.0 (2026-06-28) — anade flag `clear_pending` (vacia la cola en la misma
+  llamada) + param `timeout`; el output pasa a {ok, interrupted, cleared,
+  queue_remaining, error} y se anaden tests (mock HTTP local).

python/functions/ml/comfyui_interrupt_queue.py

@@ -1,38 +1,52 @@
-"""Interrumpe la generacion en curso de ComfyUI y devuelve el estado de la cola.
+"""Interrumpe la generacion en curso de ComfyUI y, opcionalmente, vacia la cola.
 
-Funcion impura: hace red (HTTP POST /interrupt + GET /queue). Solo stdlib.
+Funcion impura: hace red (HTTP POST /interrupt, POST /queue, GET /queue). Solo
+stdlib (urllib, json).
 
-POST /interrupt corta el prompt que ComfyUI esta ejecutando ahora mismo (no vacia
+POST /interrupt corta el prompt que ComfyUI esta ejecutando ahora mismo: NO vacia
-la cola: los prompts pendientes siguen). GET /queue devuelve queue_running (lo que
+los pendientes, solo aborta el actual y el siguiente arranca de inmediato. Para
-se ejecuta) y queue_pending (lo encolado). Esta funcion combina ambos en un dict
+vaciar de golpe los pendientes hay que ademas hacer POST /queue con {"clear": true}
-honesto que NO lanza excepcion en fallo de red: devuelve {ok: False, error}.
+(lo que activa el flag clear_pending). GET /queue se consulta al final para reportar
+cuantos trabajos quedan en cola tras la operacion (queue_remaining).
+
+NO lanza excepcion en fallo de red: devuelve un dict de estado {ok: False, error}.
 """
 import json
 import urllib.error
 import urllib.request
 
 
-def comfyui_interrupt_queue(server: str = "127.0.0.1:8188") -> dict:
+def comfyui_interrupt_queue(
-    """Interrumpe la generacion en curso y devuelve el estado de la cola.
+    clear_pending: bool = False,
+    server: str = "127.0.0.1:8188",
+    timeout: float = 10.0,
+) -> dict:
+    """Corta la generacion en curso de ComfyUI y devuelve el estado de la cola.
 
     Args:
+        clear_pending: si True, ademas de cortar el prompt en ejecucion vacia la
+            cola de pendientes con POST /queue {"clear": true}. keyword-only.
         server: host:port del servidor ComfyUI sin esquema (default
-            "127.0.0.1:8188").
+            "127.0.0.1:8188"). keyword-only.
+        timeout: timeout de cada peticion HTTP en segundos (default 10.0).
+            keyword-only.
 
     Returns:
         dict con:
-        - ok (bool): True si tanto el interrupt como la lectura de la cola
+        - ok (bool): True si el interrupt, la lectura de la cola y (si se pidio)
-          tuvieron exito.
+          el clear tuvieron exito.
         - interrupted (bool): True si el POST /interrupt respondio sin error.
-        - queue_running (int): numero de prompts ejecutandose ahora mismo.
+        - cleared (bool): True si clear_pending era True y el POST /queue
-        - queue_pending (int): numero de prompts encolados pendientes.
+          {"clear": true} respondio sin error; False si no se pidio o fallo.
+        - queue_remaining (int): trabajos que quedan en cola tras la operacion
+          (queue_running + queue_pending segun GET /queue al final).
         - error (str): mensaje de error si algo fallo; cadena vacia si todo OK.
     """
     out = {
         "ok": False,
         "interrupted": False,
-        "queue_running": 0,
+        "cleared": False,
-        "queue_pending": 0,
+        "queue_remaining": 0,
         "error": "",
     }
     base = f"http://{server}"
@@ -40,19 +54,37 @@ def comfyui_interrupt_queue(server: str = "127.0.0.1:8188") -> dict:
     # 1. POST /interrupt (cuerpo vacio): corta el prompt en ejecucion.
     try:
         req = urllib.request.Request(f"{base}/interrupt", data=b"", method="POST")
-        with urllib.request.urlopen(req, timeout=10.0):
+        with urllib.request.urlopen(req, timeout=timeout):
             out["interrupted"] = True
     except urllib.error.URLError as exc:
         reason = getattr(exc, "reason", exc)
         out["error"] = f"interrupt fallo: no se pudo conectar a {base}/interrupt: {reason}"
         return out
 
-    # 2. GET /queue: estado actual de la cola tras el interrupt.
+    # 2. Opcional: POST /queue {"clear": true} para vaciar los pendientes.
+    if clear_pending:
+        try:
+            payload = json.dumps({"clear": True}).encode()
+            req = urllib.request.Request(
+                f"{base}/queue",
+                data=payload,
+                method="POST",
+                headers={"Content-Type": "application/json"},
+            )
+            with urllib.request.urlopen(req, timeout=timeout):
+                out["cleared"] = True
+        except urllib.error.URLError as exc:
+            reason = getattr(exc, "reason", exc)
+            out["error"] = f"clear fallo: no se pudo conectar a {base}/queue: {reason}"
+            return out
+
+    # 3. GET /queue: cuantos trabajos quedan en cola tras la operacion.
     try:
-        with urllib.request.urlopen(f"{base}/queue", timeout=10.0) as resp:
+        with urllib.request.urlopen(f"{base}/queue", timeout=timeout) as resp:
             data = json.loads(resp.read())
-        out["queue_running"] = len(data.get("queue_running", []))
+        running = len(data.get("queue_running", []))
-        out["queue_pending"] = len(data.get("queue_pending", []))
+        pending = len(data.get("queue_pending", []))
+        out["queue_remaining"] = running + pending
         out["ok"] = True
     except urllib.error.URLError as exc:
         reason = getattr(exc, "reason", exc)
@@ -63,9 +95,12 @@ def comfyui_interrupt_queue(server: str = "127.0.0.1:8188") -> dict:
 
 
 if __name__ == "__main__":
-    res = comfyui_interrupt_queue()
+    import sys
+
+    clear = "--clear" in sys.argv[1:]
+    res = comfyui_interrupt_queue(clear_pending=clear)
     print(
         f"ok={res['ok']} interrupted={res['interrupted']} "
-        f"running={res['queue_running']} pending={res['queue_pending']} "
+        f"cleared={res['cleared']} queue_remaining={res['queue_remaining']} "
         f"error={res['error']!r}"
     )

python/functions/ml/comfyui_judge_image.md

@@ -32,9 +32,9 @@ params:
   - name: venv_python
     desc: "Python del venv ComfyUI para los jueces estetico/fidelidad. keyword-only."
 output: "dict {ok, verdict, score, votes, reasons, error, details}. verdict 'good'|'bad' por mayoria; score media ponderada 0-10 de los jueces vivos; votes = {clip, aesthetic, llm} cada uno 'good'|'bad'|'failed'; reasons agrega razones del critico + notas de jueces caidos; details lleva el dict crudo de cada juez. ok=False solo si los tres fallan."
-tested: false
+tested: true
-tests: []
+tests: ["tres votos good -> verdict good + score medio", "mayoria bad", "empate -> bad conservador", "juez caido se excluye sin crashear", "los tres jueces fallan -> ok=False", "weights afectan score pero no el voto"]
-test_file_path: ""
+test_file_path: "python/functions/ml/tests/test_comfyui_judge_image.py"
 file_path: "python/functions/ml/comfyui_judge_image.py"
 ---
 

python/functions/ml/comfyui_list_skills.md

@@ -5,7 +5,7 @@ lang: py
 domain: ml
 version: "1.0.0"
 purity: impure
-signature: "def comfyui_list_skills(*, library_dir: str = None, include_nsfw: bool = False) -> dict"
+signature: "def comfyui_list_skills(library_dir: str = None, include_nsfw: bool = False) -> dict"
 description: "Lista las skills ComfyUI guardadas en la libreria de disco con su metadata de resumen: slug, title, base_workflow, version, score_mean/score_n y nsfw (de provenance.nsfw), mas n_versions. Respeta include_nsfw=False (oculta las NSFW por defecto). Libreria inexistente o vacia -> lista vacia sin error. library_dir default ~/ComfyUI/skills_library."
 error_type: error_go_core
 tags: [comfyui, comfyui-skill, ml, skill, library]

python/functions/ml/comfyui_list_skills.py

@@ -28,13 +28,12 @@ def _n_versions(skill_dir):
                 if f.startswith("v") and f.endswith(".json")])
 
 
-def comfyui_list_skills(*, library_dir: str = None, include_nsfw: bool = False) -> dict:
+def comfyui_list_skills(library_dir: str = None, include_nsfw: bool = False) -> dict:
     """Lista las skills de la libreria con su metadata de resumen.
 
     Args:
-        library_dir: raiz de la libreria. Default `~/ComfyUI/skills_library`. keyword-only.
+        library_dir: raiz de la libreria. Default `~/ComfyUI/skills_library`.
         include_nsfw: si False (default), oculta las skills con `provenance.nsfw == True`.
-            keyword-only.
 
     Returns:
         dict ``{ok, skills, count, error}`` donde `skills` es una lista de dicts

python/functions/ml/comfyui_load_skill.md

@@ -5,7 +5,7 @@ lang: py
 domain: ml
 version: "1.0.0"
 purity: impure
-signature: "def comfyui_load_skill(slug: str, *, version=None, library_dir: str = None) -> dict"
+signature: "def comfyui_load_skill(slug: str, version=None, library_dir: str = None) -> dict"
 description: "Lee una receta de skill ComfyUI de la libreria de disco: recipe.json (version actual) o un snapshot versions/vN.json. Hermana inversa de comfyui_save_skill; el round-trip save(recipe)->load(slug) devuelve un dict identico. library_dir default ~/ComfyUI/skills_library. Slug, version o archivo inexistente -> {ok:False} sin lanzar."
 error_type: error_go_core
 tags: [comfyui, comfyui-skill, ml, skill, library]

python/functions/ml/comfyui_load_skill.py

@@ -36,14 +36,14 @@ def _version_filename(version):
     return None
 
 
-def comfyui_load_skill(slug: str, *, version=None, library_dir: str = None) -> dict:
+def comfyui_load_skill(slug: str, version=None, library_dir: str = None) -> dict:
     """Lee la receta de una skill (version actual o un snapshot concreto).
 
     Args:
         slug: slug de la skill (nombre de su carpeta en la libreria).
         version: si None, lee `recipe.json` (version actual). Si se pasa (int, "1" o
-            "v1"), lee el snapshot `versions/vN.json`. keyword-only.
+            "v1"), lee el snapshot `versions/vN.json`.
-        library_dir: raiz de la libreria. Default `~/ComfyUI/skills_library`. keyword-only.
+        library_dir: raiz de la libreria. Default `~/ComfyUI/skills_library`.
 
     Returns:
         dict ``{ok, recipe, slug, path, version, error}``. En exito ``ok=True`` y `recipe`

python/functions/ml/comfyui_pixelize_image.md

@@ -3,11 +3,11 @@ name: comfyui_pixelize_image
 kind: function
 lang: py
 domain: ml
-version: "1.0.0"
+version: "1.1.0"
 purity: impure
-signature: "def comfyui_pixelize_image(src_path: str, dst_path: str, *, downscale: int = 8, colors: int = 16, palette=None, dither: bool = False, upscale_back: bool = True) -> dict"
+signature: "def comfyui_pixelize_image(src_path: str, dst_path: str, *, downscale: int = 8, colors: int = 16, palette=None, dither: bool = False, upscale_back: bool = True, keep_alpha: bool = True, alpha_threshold: int = 128) -> dict"
-description: "Post-proceso pixel-perfect (Fase 2 pixelart): imagen -> downscale nearest-neighbor por factor (colapsa cada bloque borroso a un pixel duro) -> cuantizacion a N colores (MEDIANCUT) o a una paleta fija embebida (game-boy / pico-8 / nes / lista de hex) -> opcional re-upscale nearest conservando los pixeles duros. Convierte el 'pixelart borroso de IA' en pixelart de verdad. Nucleo PIL puro, CPU-only: sin GPU, sin red. Devuelve {ok, out_path, size, n_colors_final, error}. Impura solo por la lectura/escritura de disco."
+description: "Post-proceso pixel-perfect (Fase 2 pixelart): imagen -> downscale nearest-neighbor por factor (colapsa cada bloque borroso a un pixel duro) -> cuantizacion a N colores (MEDIANCUT) o a una paleta fija embebida (game-boy / pico-8 / nes / lista de hex) -> opcional re-upscale nearest conservando los pixeles duros. Alpha-aware: si la entrada es RGBA y keep_alpha, cuantiza SOLO el RGB (el fondo transparente no entra en la paleta) y preserva/binariza el alpha por separado -> PNG RGBA con transparencia real. Convierte el 'pixelart borroso de IA' en pixelart de verdad. Nucleo PIL puro, CPU-only: sin GPU, sin red. Devuelve {ok, out_path, size, n_colors_final, has_alpha, error}. Impura solo por la lectura/escritura de disco."
-tags: [comfyui, gamedev-2d, pixelart, ml, pil, quantize, palette, image]
+tags: [comfyui, gamedev-2d, pixelart, ml, pil, quantize, palette, image, alpha, transparent]
 uses_functions: []
 uses_types: []
 returns: []
@@ -29,9 +29,13 @@ params:
     desc: "aplica Floyd-Steinberg al cuantizar (off por defecto = pixelart limpio). keyword-only."
   - name: upscale_back
     desc: "re-escala nearest al tamano original (preview con pixeles duros). False deja la imagen pequena. keyword-only."
-output: "dict con ok (bool), out_path (str), size ([w,h] de la imagen final), n_colors_final (int, colores distintos del resultado), error (str, vacio si OK)."
+  - name: keep_alpha
+    desc: "si True (default) y la entrada tiene canal alpha, preserva la transparencia: cuantiza solo el RGB y downscalea/binariza el alpha aparte -> PNG RGBA. Sin efecto si la imagen no tiene alpha (sale RGB igual que antes). keyword-only."
+  - name: alpha_threshold
+    desc: "umbral (0..255) para binarizar el alpha en opaco (255) o transparente (0). Solo aplica cuando se preserva el alpha. keyword-only."
+output: "dict con ok (bool), out_path (str), size ([w,h] de la imagen final), n_colors_final (int, colores RGB distintos; en la zona opaca si es RGBA), has_alpha (bool, True si la salida es RGBA), error (str, vacio si OK)."
 tested: true
-tests: [test_golden_downscale_quantize, test_no_upscale_back_keeps_small, test_edge_fixed_palette_game_boy, test_edge_palette_list_hex, test_edge_downscale_1_only_quantizes, test_error_missing_src, test_error_downscale_zero, test_error_bad_palette]
+tests: [test_golden_downscale_quantize, test_no_upscale_back_keeps_small, test_edge_fixed_palette_game_boy, test_edge_palette_list_hex, test_edge_downscale_1_only_quantizes, test_error_missing_src, test_error_downscale_zero, test_error_bad_palette, test_alpha_preserved_transparent_corners, test_alpha_off_flattens_to_rgb, test_rgb_input_unaffected_by_keep_alpha, test_error_all_transparent_no_crash]
 test_file_path: "python/functions/ml/comfyui_pixelize_image_test.py"
 file_path: "python/functions/ml/comfyui_pixelize_image.py"
 ---
@@ -54,14 +58,21 @@ res = comfyui_pixelize_image(
 # Forzar la paleta retro Game Boy (4 colores) y dejar la imagen pequena (sin upscale)
 comfyui_pixelize_image("/tmp/hero_pixel.png", "/tmp/hero_gb.png",
                        palette="game-boy", upscale_back=False)
+
+# Sprite RGBA (tras rembg): preserva la transparencia, cuantiza solo el sujeto
+res = comfyui_pixelize_image("/tmp/knight_rgba.png", "/tmp/knight_px.png",
+                             downscale=1, colors=16, keep_alpha=True)
+# {'ok': True, 'has_alpha': True, 'n_colors_final': 16, ...}  -> fondo transparente intacto
 ```
 
 ## Cuando usarla
 
 Fase 2 del pipeline pixelart: tras generar el crudo (SDXL + LoRA `SDXL_pixel-art`),
-para colapsar el grid borroso a pixeles duros y limitar la paleta. Tambien sirve
+para colapsar el grid borroso a pixeles duros y limitar la paleta. Si la imagen
-para "pixelizar" cualquier imagen (sprite, render, foto) a estetica retro sin
+viene de `rembg` con fondo recortado (RGBA), `keep_alpha=True` mantiene la
-tocar la GPU. Para llevar el resultado a Godot con filtro Nearest:
+transparencia y deja el fondo fuera de la paleta. Tambien sirve para "pixelizar"
+cualquier imagen (sprite, render, foto) a estetica retro sin tocar la GPU. Para
+llevar el resultado a Godot con filtro Nearest:
 `comfyui_export_asset_to_godot(out, "pixelart", proj)`.
 
 ## Gotchas
@@ -76,7 +87,22 @@ tocar la GPU. Para llevar el resultado a Godot con filtro Nearest:
   duros (preview).
 - Todo error es **dict `ok=False`** (no excepcion): `src_path` inexistente,
   `downscale<1`, paleta desconocida -> `error` explica. No crashea ni borra nada.
-- `n_colors_final` cuenta colores distintos reales del PNG escrito; con paleta fija
+- `n_colors_final` cuenta colores RGB distintos reales del PNG escrito; con salida
-  puede ser **menor** que el tamano de la paleta si la imagen no usa todos.
+  RGBA cuenta **solo la zona opaca** (el transparente no es un color del pixel-art);
+  con paleta fija puede ser **menor** que el tamano de la paleta si la imagen no usa todos.
+- **alpha-aware (v1.1.0)**: con entrada RGBA y `keep_alpha=True` (default), el fondo
+  transparente se rellena internamente con la moda del sujeto antes de cuantizar, asi
+  NO gasta una entrada de la paleta; el alpha se downscalea nearest aparte y se
+  binariza por `alpha_threshold` (0/255 = bordes duros pixel-art). Entrada sin alpha
+  -> comportamiento RGB identico al de antes (retrocompatible).
+- Si la entrada RGBA esta **toda transparente** (rembg sin sujeto), no crashea:
+  devuelve `ok=True`, `has_alpha=True`, `n_colors_final=0` y el PNG sigue transparente.
 - CPU-only: no toca la GPU ni el servidor ComfyUI; corre en cualquier interprete
-  con Pillow.
+  con Pillow (numpy acelera el relleno alpha; sin numpy degrada limpio).
+
+## Capability growth log
+
+- v1.1.0 (2026-06-28) — alpha-aware: `keep_alpha`/`alpha_threshold`. Si la entrada
+  es RGBA, cuantiza solo el RGB (fondo transparente fuera de la paleta) y preserva el
+  alpha binarizado -> PNG RGBA con transparencia real. Cierra el bug del pipeline
+  pixelart que perdia el fondo transparente por el `convert("RGB")` (issue sprite-fix).

python/functions/ml/comfyui_pixelize_image.py

@@ -64,8 +64,60 @@ def _normalize_palette(palette):
     return [_hex_to_rgb(h) for h in hexes]
 
 
-def _pixelize_pil(img, downscale, colors, palette_rgb, dither, upscale_back):
+def _img_has_alpha(img) -> bool:
-    """Nucleo puro PIL: imagen RGB -> imagen RGB pixelizada.
+    """True si la imagen lleva transparencia (RGBA, LA o P con transparency)."""
+    return img.mode in ("RGBA", "LA") or (img.mode == "P" and "transparency" in img.info)
+
+
+def _fill_transparent_with_mode(small_rgb, small_alpha, threshold):
+    """Rellena los pixeles transparentes con el color opaco mas frecuente (moda).
+
+    Asi el fondo transparente NO aporta colores nuevos a la cuantizacion: las zonas
+    con alpha <= threshold toman un color que ya esta en el sujeto (y por tanto en la
+    paleta resultante), sin gastar entradas de la paleta en el color de fondo. El
+    color real de esas zonas es irrelevante para la salida porque luego reciben
+    alpha 0. Si no hay numpy, cae a no rellenar (degradacion limpia).
+
+    Args:
+        small_rgb: PIL.Image RGB ya reducida.
+        small_alpha: PIL.Image 'L' del alpha ya reducido (mismo tamano).
+        threshold: umbral de alpha (0..255); <= threshold = transparente.
+
+    Returns:
+        PIL.Image RGB con el fondo transparente relleno con la moda del sujeto.
+    """
+    from PIL import Image
+
+    rgb = small_rgb.convert("RGB")
+    mask = small_alpha.point(lambda p: 255 if p > threshold else 0).convert("L")
+    try:
+        import numpy as np
+    except ImportError:
+        return rgb
+
+    arr = np.asarray(rgb).reshape(-1, 3)
+    opaque = np.asarray(mask).reshape(-1) > 0
+    if not opaque.any():
+        return rgb  # nada opaco: caso degenerado, deja igual
+    op_pixels = arr[opaque]
+    colors, counts = np.unique(op_pixels, axis=0, return_counts=True)
+    fill = tuple(int(x) for x in colors[counts.argmax()])
+    bg = Image.new("RGB", rgb.size, fill)
+    bg.paste(rgb, (0, 0), mask)  # rgb donde mask=255, fill (moda) donde mask=0
+    return bg
+
+
+def _pixelize_pil(img, downscale, colors, palette_rgb, dither, upscale_back,
+                  keep_alpha, alpha_threshold):
+    """Nucleo puro PIL: imagen -> imagen pixelizada (RGB, o RGBA si keep_alpha).
+
+    Si la imagen de entrada tiene canal alpha y keep_alpha es True, la cuantizacion
+    de color se hace SOLO sobre el RGB (con el fondo transparente relleno con la moda
+    del sujeto para que no entre en la paleta) y el alpha se downscalea nearest por
+    separado y se binariza por `alpha_threshold`, recombinando a RGBA. Asi se
+    preserva la transparencia sin que las zonas transparentes contaminen la paleta.
+    Para imagenes sin alpha (o keep_alpha False) el comportamiento RGB es identico al
+    de antes.
 
     Args:
         img: PIL.Image de entrada.
@@ -74,22 +126,39 @@ def _pixelize_pil(img, downscale, colors, palette_rgb, dither, upscale_back):
         palette_rgb: lista [(r,g,b), ...] o None (cuantizacion automatica).
         dither: aplica Floyd-Steinberg al cuantizar si True.
         upscale_back: re-escala nearest al tamano original si True.
+        keep_alpha: si True y la imagen tiene alpha, preserva la transparencia.
+        alpha_threshold: umbral (0..255) para binarizar el alpha (opaco/transparente).
 
     Returns:
-        PIL.Image RGB pixelizada.
+        PIL.Image pixelizada: RGB, o RGBA si se preservo la transparencia.
     """
     from PIL import Image
 
-    img = img.convert("RGB")
+    has_alpha = bool(keep_alpha) and _img_has_alpha(img)
-    w, h = img.size
+    if has_alpha:
+        rgba = img.convert("RGBA")
+        alpha_full = rgba.getchannel("A")
+        rgb = rgba.convert("RGB")
+    else:
+        rgb = img.convert("RGB")
+        alpha_full = None
+
+    w, h = rgb.size
     # 1. downscale nearest -> grid real (colapsa bloques borrosos a 1 pixel).
     sw, sh = max(1, w // downscale), max(1, h // downscale)
-    small = img.resize((sw, sh), Image.NEAREST)
+    small = rgb.resize((sw, sh), Image.NEAREST)
+    small_alpha = (
+        alpha_full.resize((sw, sh), Image.NEAREST) if alpha_full is not None else None
+    )
+    # 1b. con alpha: el fondo transparente no debe entrar en la paleta.
+    if small_alpha is not None:
+        small = _fill_transparent_with_mode(small, small_alpha, int(alpha_threshold))
+
     d = Image.Dither.FLOYDSTEINBERG if dither else Image.Dither.NONE
-    # 2. cuantizar la paleta.
+    # 2. cuantizar la paleta (siempre sobre RGB).
     if palette_rgb:
         pal_img = Image.new("P", (1, 1))
-        flat = [c for rgb in palette_rgb for c in rgb][:768]
+        flat = [c for rgb_c in palette_rgb for c in rgb_c][:768]
         # Rellena las 256 entradas repitiendo el ultimo color real (no ceros): asi
         # quantize no puede introducir un color extra (negro) por las entradas vacias.
         if flat:
@@ -102,12 +171,42 @@ def _pixelize_pil(img, downscale, colors, palette_rgb, dither, upscale_back):
         n = max(2, min(256, int(colors)))
         small = small.quantize(colors=n, method=Image.Quantize.MEDIANCUT, dither=d)
     out = small.convert("RGB")
+
+    # 2b. recombinar el alpha (binarizado) -> RGBA con transparencia dura.
+    if small_alpha is not None:
+        out = out.convert("RGBA")
+        hard_alpha = small_alpha.point(lambda p: 255 if p > int(alpha_threshold) else 0)
+        out.putalpha(hard_alpha)
+
     # 3. opcional: re-upscale nearest para preview/entrega (pixeles duros).
     if upscale_back:
         out = out.resize((w, h), Image.NEAREST)
     return out
 
 
+def _count_colors(result) -> int:
+    """Numero de colores RGB distintos en el resultado.
+
+    Para salida RGBA cuenta solo los colores de la zona opaca (alpha > 0), que es lo
+    que define el sprite; el transparente no es un "color" del pixel-art. Para RGB
+    cuenta todos los colores. Devuelve -1 si no se pudo contar.
+    """
+    if result.mode == "RGBA":
+        try:
+            import numpy as np
+        except ImportError:
+            colors_found = result.convert("RGB").getcolors(maxcolors=1 << 20)
+            return len(colors_found) if colors_found is not None else -1
+        arr = np.asarray(result)
+        opaque = arr[..., 3] > 0
+        rgb_op = arr[..., :3][opaque]
+        if rgb_op.size == 0:
+            return 0
+        return int(len(np.unique(rgb_op.reshape(-1, 3), axis=0)))
+    colors_found = result.getcolors(maxcolors=1 << 20)
+    return len(colors_found) if colors_found is not None else -1
+
+
 def comfyui_pixelize_image(
     src_path: str,
     dst_path: str,
@@ -117,6 +216,8 @@ def comfyui_pixelize_image(
     palette=None,
     dither: bool = False,
     upscale_back: bool = True,
+    keep_alpha: bool = True,
+    alpha_threshold: int = 128,
 ) -> dict:
     """Pixeliza una imagen y la guarda como PNG.
 
@@ -135,16 +236,28 @@ def comfyui_pixelize_image(
             limpio). keyword-only.
         upscale_back: re-escala nearest al tamano original (preview con pixeles
             duros). False deja la imagen pequena (sw x sh). keyword-only.
+        keep_alpha: si True (default) y la imagen de entrada tiene canal alpha,
+            preserva la transparencia: cuantiza solo el RGB y downscalea/binariza el
+            alpha por separado, devolviendo PNG RGBA. Las zonas transparentes no
+            entran en la paleta de color. Si la imagen no tiene alpha, no tiene
+            efecto (sale RGB igual que antes). keyword-only.
+        alpha_threshold: umbral (0..255) para binarizar el alpha en opaco (255) o
+            transparente (0). Solo aplica cuando se preserva el alpha. keyword-only.
 
     Returns:
         dict con:
         - ok (bool): True si se pixelizo y guardo.
         - out_path (str): ruta del PNG generado.
         - size (list[int]): [w, h] de la imagen final.
-        - n_colors_final (int): numero de colores distintos en el resultado.
+        - n_colors_final (int): numero de colores RGB distintos en el resultado
+          (en la zona opaca si la salida es RGBA).
+        - has_alpha (bool): True si la salida es RGBA con transparencia preservada.
         - error (str): mensaje de error; cadena vacia si todo OK.
     """
-    out = {"ok": False, "out_path": "", "size": [0, 0], "n_colors_final": 0, "error": ""}
+    out = {
+        "ok": False, "out_path": "", "size": [0, 0], "n_colors_final": 0,
+        "has_alpha": False, "error": "",
+    }
 
     try:
         from PIL import Image
@@ -168,7 +281,8 @@ def comfyui_pixelize_image(
     try:
         with Image.open(src_path) as src:
             result = _pixelize_pil(
-                src, int(downscale), colors, palette_rgb, bool(dither), bool(upscale_back)
+                src, int(downscale), colors, palette_rgb, bool(dither),
+                bool(upscale_back), bool(keep_alpha), int(alpha_threshold),
             )
     except OSError as exc:
         out["error"] = f"no se pudo leer/decodificar {src_path!r}: {exc}"
@@ -182,10 +296,10 @@ def comfyui_pixelize_image(
         out["error"] = f"no se pudo escribir {dst_path!r}: {exc}"
         return out
 
-    colors_found = result.getcolors(maxcolors=1 << 20)
+    n_final = _count_colors(result)
-    n_final = len(colors_found) if colors_found is not None else -1
     out.update(
-        ok=True, out_path=dst_path, size=list(result.size), n_colors_final=n_final
+        ok=True, out_path=dst_path, size=list(result.size), n_colors_final=n_final,
+        has_alpha=(result.mode == "RGBA"),
     )
     return out
 

python/functions/ml/comfyui_pixelize_sprite_png.md

@@ -0,0 +1,118 @@
+---
+name: comfyui_pixelize_sprite_png
+kind: function
+lang: py
+domain: ml
+version: "1.0.0"
+purity: impure
+signature: "def comfyui_pixelize_sprite_png(src_path: str, dst_path: str, *, size: int = 32, colors: int = 16, engine: str = 'pixeloe', palette=None, transparent: bool = True, autocrop: bool = True, crop_pad_ratio: float = 0.02, mode: str = 'contrast', patch_size: int = 16, thickness: int = 2, alpha_threshold: int = 128, comfy_python: str | None = None) -> dict"
+description: "Pixeliza un PNG existente (un render a alta resolucion, p.ej. 512x768 RGBA con fondo transparente) a un sprite pixel-art REAL de size x size RGBA. Extrae la logica de pixelizado de un PNG existente: la misma secuencia que comfyui_pixelart_real_oneshot aplica internamente (fases 1b/2a/2a-bis/2b), pero desacoplada de la generacion -> sirve para pixelizar cada frame de una animacion, una hoja de sprites o cualquier render existente sin volver a pasar por la difusion. Compone tres funciones del registry: crop_to_content (autocrop al contenido + cuadrar para llenar el frame) -> pixeloe_downscale (downscale contrast-aware que conserva la silueta, engine='pixeloe', con fallback automatico a nearest) -> comfyui_pixelize_image (cuantizacion dura a N colores libres o paleta fija pico-8/nes/game-boy, alpha-aware). PixelOE trabaja en RGB y pierde el alpha, asi que se downscalea el canal alpha aparte (nearest) y se reaplica al grid antes de cuantizar. Impura: lectura/escritura de disco + subprocess del bridge de pixeloe. No-throw: todo error viaja en el campo error del dict. Devuelve {ok, out_path, size, colors_final, has_alpha, engine_used, autocrop_applied, error}."
+tags: [gamedev-2d, comfyui, pixelart, sprite, ml, downscale, quantize, palette, alpha, transparent, animation]
+uses_functions: [crop_to_content_py_ml, pixeloe_downscale_py_ml, comfyui_pixelize_image_py_ml]
+uses_types: []
+returns: []
+returns_optional: false
+error_type: "error_py_core"
+imports: []
+params:
+  - name: src_path
+    desc: "ruta del PNG de entrada (un render a alta resolucion, p.ej. 512x768 RGBA con fondo transparente). Debe existir."
+  - name: dst_path
+    desc: "ruta del PNG de salida size x size (se crea el directorio si falta)."
+  - name: size
+    desc: "lado del grid final en pixeles (32 iconos/objetos simples, 64 personajes/sprites). Debe ser >= 1. keyword-only."
+  - name: colors
+    desc: "numero de colores de la paleta libre cuando palette es None (cuantizacion MEDIANCUT). keyword-only."
+  - name: engine
+    desc: "'pixeloe' (downscale contrast-aware, para sujetos con silueta: personajes/criaturas/iconos) o 'nearest' (downscale nearest simple, mas barato, para tiles/texturas/fondos sin contorno). Si 'pixeloe' falla o la lib no esta disponible, cae automaticamente a 'nearest' y lo refleja en engine_used. keyword-only."
+  - name: palette
+    desc: "None (paleta libre a 'colors'), nombre builtin ('pico-8','nes','game-boy') o lista de hex. Una paleta fija ignora 'colors'. keyword-only."
+  - name: transparent
+    desc: "si True (default) trata la entrada como RGBA y produce un sprite RGBA con transparencia real (el fondo transparente no entra en la paleta). Para tiles/texturas opacas, False produce salida RGB. keyword-only."
+  - name: autocrop
+    desc: "si True (default) recorta el PNG al bounding box de su contenido y lo cuadra antes del downscale, para que el sujeto llene el frame (evita el sprite diminuto). Usa el alpha si transparent, o el color de fondo si RGB. keyword-only."
+  - name: crop_pad_ratio
+    desc: "margen relativo que deja el autocrop alrededor del sujeto (0.02 = 2% del lado). keyword-only."
+  - name: mode
+    desc: "modo de downscale de PixelOE ('contrast' SOTA, 'k-centroid', 'nearest', 'center', 'bicubic'); solo aplica con engine='pixeloe'. keyword-only."
+  - name: patch_size
+    desc: "tamano de patch de PixelOE (default 16). keyword-only."
+  - name: thickness
+    desc: "grosor del outline expansion de PixelOE (default 2). keyword-only."
+  - name: alpha_threshold
+    desc: "umbral (0..255) para binarizar el alpha en opaco (255) o transparente (0) en la cuantizacion final. Solo aplica si transparent. keyword-only."
+  - name: comfy_python
+    desc: "ruta al interprete de ComfyUI (con la lib pixeloe) para el bridge; None autodetecta COMFY_PYTHON y luego ~/ComfyUI/.venv/bin/python3. keyword-only."
+output: "dict con ok (bool, True si se produjo el PNG final), out_path (str, ruta del PNG final size x size; vacio si fallo), size (int, lado real del PNG final), colors_final (int, colores distintos en el resultado; en la zona opaca si es RGBA), has_alpha (bool, True si el PNG es RGBA con transparencia), engine_used (str, 'pixeloe' o 'nearest' reflejando el fallback real), autocrop_applied (bool, True si el autocrop recorto/cuadro la imagen), error (str, vacio si todo OK)."
+tested: false
+tests: []
+test_file_path: ""
+file_path: "python/functions/ml/comfyui_pixelize_sprite_png.py"
+---
+
+## Ejemplo
+
+```python
+import sys, os
+sys.path.insert(0, os.path.join(os.environ["HOME"], "fn_registry", "python", "functions"))
+from ml.comfyui_pixelize_sprite_png import comfyui_pixelize_sprite_png
+
+# Un render existente de 512x768 RGBA con fondo transparente -> sprite pixel-art 32x32
+res = comfyui_pixelize_sprite_png(
+    os.path.expanduser("~/ComfyUI/output/knight_hi_res.png"),
+    "/tmp/knight_32.png",
+    size=32, colors=16, transparent=True,
+)
+# {'ok': True, 'out_path': '/tmp/knight_32.png', 'size': 32, 'colors_final': 16,
+#  'has_alpha': True, 'engine_used': 'pixeloe', 'autocrop_applied': True, 'error': ''}
+
+# Pixelizar cada frame de una animacion a 48px con paleta fija PICO-8
+for i, frame in enumerate(["walk_0.png", "walk_1.png", "walk_2.png", "walk_3.png"]):
+    comfyui_pixelize_sprite_png(
+        f"/tmp/anim/{frame}", f"/tmp/anim/px_{i}.png",
+        size=48, palette="pico-8", transparent=True,
+    )
+
+# Un tile/textura sin silueta -> downscale nearest barato, sin transparencia
+comfyui_pixelize_sprite_png(
+    "/tmp/grass_tile.png", "/tmp/grass_16.png",
+    size=16, colors=8, engine="nearest", transparent=False,
+)
+```
+
+## Cuando usarla
+
+Cuando ya tienes un PNG renderizado a alta resolucion y necesitas su version
+pixel-art REAL (grid duro + paleta limitada) **sin regenerar** con la difusion: cada
+frame de una animacion, una hoja de sprites entera, un render externo, o el resultado
+de cualquier otra funcion que produzca PNGs. Es la pieza desacoplada del pixelizado
+que `comfyui_pixelart_real_oneshot` usa por dentro tras generar — usala directamente
+cuando la generacion no es parte del trabajo. Usa `engine="pixeloe"` para sujetos con
+silueta (personajes, criaturas, iconos con contorno) y `engine="nearest"` para
+tiles/texturas/fondos planos sin contorno (mas barato). Para llevar el resultado a
+Godot con filtro Nearest, encadena con `comfyui_export_asset_to_godot`.
+
+## Gotchas
+
+- **Necesita la lib `pixeloe`** (en `~/ComfyUI/.venv`) para `engine="pixeloe"`: se
+  invoca via bridge de subprocess (`pixeloe_downscale`). Si la lib no esta o falla,
+  cae automaticamente a `engine="nearest"` y lo refleja en `engine_used` + deja la
+  nota del fallo en `error` (el resultado sigue siendo valido). Pasa `comfy_python`
+  para apuntar a otro interprete con pixeloe.
+- **Todo error es dict `ok=False`** (no excepcion): `src_path` inexistente, `size < 1`,
+  `engine` distinto de pixeloe/nearest -> `error` lo explica. No crashea ni borra nada.
+- **`autocrop` es best-effort**: si el recorte falla (PIL/lectura), se sigue con el PNG
+  original sin recortar, `autocrop_applied=False` y la nota va en `error` (no critico).
+  `crop_to_content` cuadra el sujeto para que llene el frame — sin esto un sujeto que
+  ocupa el 25% del lienzo queda diminuto a 32px.
+- **`transparent` espera entrada RGBA**: con `transparent=True` el alpha se preserva y
+  el fondo transparente NO entra en la paleta. PixelOE trabaja en RGB y perderia el
+  alpha, asi que se downscalea el canal alpha aparte (nearest) y se reaplica al grid
+  antes de cuantizar (fase 2a-bis). Con `transparent=False` la salida es RGB opaca.
+- **`palette` fija (pico-8/nes/game-boy o lista de hex) ignora `colors`**. `colors_final`
+  cuenta colores RGB distintos REALES de la zona opaca: puede ser **menor** que `colors`
+  o que el tamano de la paleta si el sprite no usa todos (un sprite de un solo color
+  solido devuelve `colors_final=1`, correcto).
+- **CPU-only en la cuantizacion**; el unico coste GPU/red es nulo (PixelOE es CPU via
+  bridge). Los intermedios (crop, mid) se escriben en un directorio temporal y se
+  limpian siempre, incluso si la cuantizacion falla.

python/functions/ml/comfyui_pixelize_sprite_png.py

@@ -0,0 +1,284 @@
+"""comfyui_pixelize_sprite_png — pixeliza un PNG existente a un sprite pixel-art REAL.
+
+Toma un PNG YA renderizado a alta resolucion (p.ej. 512x768 RGBA con fondo
+transparente) y lo convierte en un sprite pixel-art de verdad de `size` x `size`.
+Es la pieza reutilizable que extrae la logica de pixelizado de un PNG existente: la
+MISMA secuencia que `comfyui_pixelart_real_oneshot` aplica internamente en sus fases
+1b/2a/2a-bis/2b, pero desacoplada de la generacion. Sirve para pixelizar cada frame
+de una animacion, una hoja de sprites, o cualquier render existente sin volver a
+pasar por la difusion.
+
+El metodo (report 0215) tiene tres etapas de post-proceso encadenadas:
+
+  1. crop al contenido (`crop_to_content`): recorta al bounding box del sujeto y lo
+     cuadra para que llene el frame; si el sujeto ocupa el 25% del lienzo, a 32px
+     quedaria diminuto. Best-effort: si falla, se sigue con el PNG original.
+  2. downscale a un grid `size` x `size`:
+       - engine="pixeloe": downscale contrast-aware (`pixeloe_downscale`, no_upscale)
+         que conserva la silueta — para sujetos con contorno (personajes, iconos).
+         Si la lib no esta o falla, cae automaticamente a "nearest".
+       - engine="nearest": downscale nearest simple (PIL) — mas barato, para
+         tiles/texturas sin contorno.
+     PixelOE trabaja en RGB y pierde el alpha, asi que tras el (fase 2a-bis) se
+     downscalea el canal alpha por separado (nearest) y se reaplica al grid.
+  3. cuantizacion dura (`comfyui_pixelize_image`, downscale=1): clava la paleta
+     exacta (N colores libres MEDIANCUT, o paleta fija pico-8 / nes / game-boy) sobre
+     el grid ya hecho -> N colores + 100% grid duro, preservando el alpha.
+
+Compone funciones del registry, no reescribe su logica:
+    crop_to_content_py_ml          (autocrop al contenido + cuadrar; pura)
+    pixeloe_downscale_py_ml        (downscale contrast-aware, engine pixeloe)
+    comfyui_pixelize_image_py_ml   (cuantizacion dura + alpha-aware)
+
+Funcion impura: lectura/escritura de disco (+ subprocess del bridge de pixeloe).
+No-throw: cualquier fallo se captura y viaja en el campo `error` del dict.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+import tempfile
+
+# Importa las funciones del registry (mismo arbol python/functions).
+_FUNCTIONS_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if _FUNCTIONS_ROOT not in sys.path:
+    sys.path.insert(0, _FUNCTIONS_ROOT)
+
+from ml.comfyui_pixelize_image import comfyui_pixelize_image
+from ml.crop_to_content import crop_to_content
+from ml.pixeloe_downscale import pixeloe_downscale
+
+
+def comfyui_pixelize_sprite_png(
+    src_path: str,
+    dst_path: str,
+    *,
+    size: int = 32,
+    colors: int = 16,
+    engine: str = "pixeloe",
+    palette=None,
+    transparent: bool = True,
+    autocrop: bool = True,
+    crop_pad_ratio: float = 0.02,
+    mode: str = "contrast",
+    patch_size: int = 16,
+    thickness: int = 2,
+    alpha_threshold: int = 128,
+    comfy_python: str | None = None,
+) -> dict:
+    """Pixeliza un PNG existente a un sprite pixel-art REAL de `size` x `size`.
+
+    Args:
+        src_path: ruta del PNG de entrada (un render a alta resolucion, p.ej.
+            512x768 RGBA con fondo transparente). Debe existir.
+        dst_path: ruta del PNG de salida size x size (se crea el directorio si falta).
+        size: lado del grid final en pixeles (32 iconos/objetos simples, 64
+            personajes/sprites). Debe ser >= 1. keyword-only.
+        colors: numero de colores de la paleta libre cuando palette es None
+            (cuantizacion MEDIANCUT). keyword-only.
+        engine: "pixeloe" (downscale contrast-aware, para sujetos con silueta:
+            personajes/criaturas/iconos) o "nearest" (downscale nearest simple, mas
+            barato, para tiles/texturas/fondos sin contorno). Si "pixeloe" falla o la
+            lib no esta disponible, cae automaticamente a "nearest" y lo refleja en
+            engine_used. keyword-only.
+        palette: None (paleta libre a `colors`), nombre builtin ("pico-8", "nes",
+            "game-boy") o lista de hex. Una paleta fija ignora `colors`. keyword-only.
+        transparent: si True (default) trata la entrada como RGBA y produce un sprite
+            RGBA con transparencia real (el fondo transparente no entra en la paleta).
+            Para tiles/texturas opacas, False produce salida RGB. keyword-only.
+        autocrop: si True (default) recorta el PNG al bounding box de su contenido y lo
+            cuadra antes del downscale, para que el sujeto llene el frame (evita el
+            sprite diminuto). Usa el alpha si transparent, o el color de fondo si RGB.
+            keyword-only.
+        crop_pad_ratio: margen relativo que deja el autocrop alrededor del sujeto
+            (0.02 = 2% del lado). keyword-only.
+        mode: modo de downscale de PixelOE ("contrast" SOTA, "k-centroid", "nearest",
+            "center", "bicubic"); solo aplica con engine="pixeloe". keyword-only.
+        patch_size: tamano de patch de PixelOE (default 16). keyword-only.
+        thickness: grosor del outline expansion de PixelOE (default 2). keyword-only.
+        alpha_threshold: umbral (0..255) para binarizar el alpha en opaco (255) o
+            transparente (0) en la cuantizacion final. Solo aplica si transparent.
+            keyword-only.
+        comfy_python: ruta al interprete de ComfyUI (con la lib pixeloe) para el
+            bridge; None autodetecta COMFY_PYTHON y luego ~/ComfyUI/.venv/bin/python3.
+            keyword-only.
+
+    Returns:
+        dict con:
+        - ok (bool): True si se produjo el PNG final pixelizado.
+        - out_path (str): ruta del PNG final size x size (vacio si fallo).
+        - size (int): lado real del PNG final.
+        - colors_final (int): numero de colores distintos en el resultado (en la zona
+          opaca si es RGBA).
+        - has_alpha (bool): True si el PNG final es RGBA con transparencia.
+        - engine_used (str): "pixeloe" o "nearest" (refleja el fallback real).
+        - autocrop_applied (bool): True si el autocrop recorto/cuadro la imagen.
+        - error (str): mensaje de error; cadena vacia si todo OK.
+    """
+    out = {
+        "ok": False,
+        "out_path": "",
+        "size": int(size),
+        "colors_final": 0,
+        "has_alpha": False,
+        "engine_used": engine,
+        "autocrop_applied": False,
+        "error": "",
+    }
+
+    # --- Validaciones (no-throw). ---
+    if not src_path or not os.path.isfile(src_path):
+        out["error"] = f"src_path no existe: {src_path!r}"
+        return out
+    if int(size) < 1:
+        out["error"] = f"size debe ser >= 1, recibido {size!r}"
+        return out
+    if engine not in ("pixeloe", "nearest"):
+        out["error"] = f"engine invalido: {engine!r} (usa 'pixeloe' o 'nearest')"
+        return out
+
+    # Directorio temporal para los intermedios (crop + mid); se limpia al final.
+    try:
+        tmp_dir = tempfile.mkdtemp(prefix="pixelize_sprite_")
+    except OSError as exc:
+        out["error"] = f"no se pudo crear directorio temporal: {exc}"
+        return out
+
+    crop_path = os.path.join(tmp_dir, "crop.png")
+    mid_path = os.path.join(tmp_dir, "mid.png")
+
+    try:
+        # --- Fase 1b (opcional): autocrop al contenido + cuadrar. ---
+        # La imagen sobre la que se hace el downscale: la recortada si autocrop, o la
+        # original sin tocar.
+        pre_ds_path = src_path
+        if autocrop:
+            try:
+                from PIL import Image
+                with Image.open(src_path) as base_im:
+                    src_im = (
+                        base_im.convert("RGBA") if transparent else base_im.convert("RGB")
+                    )
+                    before = src_im.size
+                    cropped = crop_to_content(
+                        src_im, pad_ratio=float(crop_pad_ratio), square=True,
+                    )
+                cropped.save(crop_path)
+                pre_ds_path = crop_path
+                out["autocrop_applied"] = cropped.size != before
+            except (ImportError, OSError, ValueError) as exc:
+                # Autocrop es best-effort: si falla, se sigue con el src sin recortar.
+                pre_ds_path = src_path
+                out["autocrop_applied"] = False
+                if not out["error"]:
+                    out["error"] = f"autocrop fallo (no critico): {exc}"
+
+        # --- Fase 2a: downscale a un grid `size` x `size` (mid). ---
+        engine_used = engine
+        if engine == "pixeloe":
+            ds = pixeloe_downscale(
+                pre_ds_path, mid_path, mode=mode, target_size=int(size),
+                patch_size=int(patch_size), thickness=int(thickness),
+                no_upscale=True, comfy_python=comfy_python,
+            )
+            if not ds.get("ok"):
+                # Fallback limpio: PixelOE no disponible / fallo -> nearest.
+                engine_used = "nearest"
+                out["error"] = f"pixeloe fallo ({ds.get('error')}); fallback a nearest"
+
+        if engine_used == "nearest":
+            # Downscale nearest simple a size x size (PIL del venv del registry).
+            # nearest preserva el alpha por canal: si transparent, conserva la silueta.
+            try:
+                from PIL import Image
+                with Image.open(pre_ds_path) as src:
+                    target_mode = "RGBA" if transparent else "RGB"
+                    small = src.convert(target_mode).resize(
+                        (int(size), int(size)), Image.NEAREST
+                    )
+                    small.save(mid_path)
+            except (ImportError, OSError) as exc:
+                out["error"] = f"downscale nearest fallo: {exc}"
+                return out
+
+        if not os.path.isfile(mid_path):
+            out["error"] = "no se genero la imagen intermedia (mid)"
+            return out
+
+        # --- Fase 2a-bis: recombinar alpha tras pixeloe (PixelOE trabaja en RGB). ---
+        # El nucleo de PixelOE convierte a RGB: el grid `mid` sale sin transparencia.
+        # Se downscalea el alpha de la imagen pre-downscale por separado (nearest al
+        # mismo size) y se reaplica al grid para no perder el recorte ni la
+        # transparencia. (engine="nearest" ya conserva su alpha, no hace falta.)
+        if transparent and engine_used == "pixeloe":
+            try:
+                from PIL import Image
+                with Image.open(pre_ds_path) as src_im:
+                    alpha = src_im.convert("RGBA").getchannel("A").resize(
+                        (int(size), int(size)), Image.NEAREST
+                    )
+                with Image.open(mid_path) as mid_im:
+                    mid_rgba = mid_im.convert("RGBA")
+                    mid_rgba.putalpha(alpha)
+                    mid_rgba.save(mid_path)
+            except (ImportError, OSError) as exc:
+                if not out["error"]:
+                    out["error"] = f"recombinacion de alpha fallo (no critico): {exc}"
+
+        # --- Fase 2b: cuantizacion dura (paleta exacta) sobre el grid ya hecho. ---
+        quant = comfyui_pixelize_image(
+            mid_path, dst_path, downscale=1, colors=int(colors), palette=palette,
+            upscale_back=False, keep_alpha=bool(transparent),
+            alpha_threshold=int(alpha_threshold),
+        )
+        if not quant.get("ok"):
+            out["error"] = f"cuantizacion fallo: {quant.get('error')}"
+            return out
+
+        out["out_path"] = dst_path
+        out["size"] = quant["size"][0] if quant.get("size") else int(size)
+        out["colors_final"] = quant.get("n_colors_final", 0)
+        out["has_alpha"] = bool(quant.get("has_alpha", False))
+        out["engine_used"] = engine_used
+        out["ok"] = True
+        return out
+    finally:
+        # Limpieza de intermedios + directorio temporal.
+        for tmp in (crop_path, mid_path):
+            try:
+                os.remove(tmp)
+            except OSError:
+                pass
+        try:
+            os.rmdir(tmp_dir)
+        except OSError:
+            pass
+
+
+if __name__ == "__main__":
+    import json
+
+    # Demo autosuficiente: genera un PNG de prueba (circulo de color sobre fondo
+    # transparente 512x512) y lo pixeliza a 32x32 con 16 colores y transparencia.
+    demo_dir = tempfile.mkdtemp(prefix="pixelize_sprite_demo_")
+    demo_src = os.path.join(demo_dir, "demo_src.png")
+    demo_dst = os.path.join(demo_dir, "demo_sprite.png")
+
+    try:
+        from PIL import Image, ImageDraw
+        im = Image.new("RGBA", (512, 512), (0, 0, 0, 0))  # fondo transparente
+        draw = ImageDraw.Draw(im)
+        draw.ellipse((96, 96, 416, 416), fill=(220, 60, 60, 255))   # circulo rojo
+        draw.ellipse((176, 160, 256, 240), fill=(250, 230, 120, 255))  # ojo amarillo
+        draw.ellipse((280, 160, 360, 240), fill=(60, 120, 220, 255))   # ojo azul
+        im.save(demo_src)
+    except ImportError as exc:
+        print(json.dumps({"ok": False, "error": f"PIL no disponible: {exc}"}))
+        raise SystemExit(0)
+
+    res = comfyui_pixelize_sprite_png(
+        demo_src, demo_dst, size=32, colors=16, engine="pixeloe",
+        transparent=True, autocrop=True,
+    )
+    print(json.dumps(res, indent=2))

python/functions/ml/comfyui_read_png_metadata.md

@@ -18,9 +18,9 @@ params:
   - name: png_path
     desc: "Ruta local del PNG generado por ComfyUI."
 output: "dict {ok, prompt, parameters, error}. prompt = workflow API format embebido (dict); parameters = {model, seed, steps, cfg, sampler_name, scheduler, denoise, positive, negative} extraido del KSampler y nodos conectados; error = motivo si ok=False."
-tested: false
+tested: true
-tests: []
+tests: ["extrae prompt embebido + parametros del KSampler (seed/steps/cfg/sampler/scheduler/denoise/positive/negative/model)", "error: archivo inexistente", "error: PNG sin chunk prompt", "error: chunk prompt no es JSON", "error: no es un PNG valido", "determinismo"]
-test_file_path: ""
+test_file_path: "python/functions/ml/tests/test_comfyui_read_png_metadata.py"
 file_path: "python/functions/ml/comfyui_read_png_metadata.py"
 ---
 

python/functions/ml/comfyui_resolve_workflow_deps.md

@@ -20,9 +20,9 @@ params:
   - name: server
     desc: "host:port del servidor ComfyUI sin esquema. Debe estar vivo para consultar /object_info."
 output: "dict {ok, missing_nodes, missing_models, suggestions, error}. ok = se pudo consultar el servidor; missing_nodes = class_type ausentes (nodos custom); missing_models = lista de {node, input, value}; suggestions = lista de {kind, name, action, hint, ...} (una por nodo/modelo faltante) con la funcion a usar; error = motivo si ok=False."
-tested: false
+tested: true
-tests: []
+tests: ["traduce nodos y modelos faltantes en suggestions (install_custom_node / search_and_download)", "sin faltantes -> suggestions vacio", "servidor caido -> ok=False con error propagado"]
-test_file_path: ""
+test_file_path: "python/functions/ml/tests/test_comfyui_resolve_workflow_deps.py"
 file_path: "python/functions/ml/comfyui_resolve_workflow_deps.py"
 ---
 

python/functions/ml/comfyui_save_skill.md

@@ -5,7 +5,7 @@ lang: py
 domain: ml
 version: "1.0.0"
 purity: impure
-signature: "def comfyui_save_skill(recipe: dict, *, library_dir: str = None) -> dict"
+signature: "def comfyui_save_skill(recipe: dict, library_dir: str = None) -> dict"
 description: "Persiste una receta de skill ComfyUI (schema comfyui-skill) en la libreria de disco: valida el schema minimo y escribe <library_dir>/<slug>/recipe.json + un snapshot inmutable versions/vN.json (N incremental) + bitacora growth_log.jsonl + regenera INDEX.md. No muta la receta (round-trip identico con comfyui_load_skill). library_dir default ~/ComfyUI/skills_library. Devuelve dict {ok, slug, path, version_file, n_versions, error}; nunca lanza."
 error_type: error_go_core
 tags: [comfyui, comfyui-skill, ml, skill, library, persistence]

python/functions/ml/comfyui_save_skill.py

@@ -91,13 +91,13 @@ def _rewrite_index(lib):
         fh.write("\n".join(lines))
 
 
-def comfyui_save_skill(recipe: dict, *, library_dir: str = None) -> dict:
+def comfyui_save_skill(recipe: dict, library_dir: str = None) -> dict:
     """Valida y persiste una receta de skill en la libreria de disco.
 
     Args:
         recipe: dict de la receta (schema `comfyui-skill`). Requiere al menos `slug`,
             `base_workflow` y `version` (strings no vacios). No se muta.
-        library_dir: raiz de la libreria. Default `~/ComfyUI/skills_library`. keyword-only.
+        library_dir: raiz de la libreria. Default `~/ComfyUI/skills_library`.
 
     Returns:
         dict ``{ok, slug, path, recipe_path, version_file, n_versions, error}``. En error de

python/functions/ml/comfyui_score_aesthetic.md

@@ -26,9 +26,9 @@ params:
   - name: timeout
     desc: "Timeout del subproceso en segundos (la primera vez puede descargar CLIP). keyword-only."
 output: "dict {ok, score_0_10, error}. En exito ok=True y score_0_10 es el score continuo (~1-10, mayor = mejor). En error ok=False, score_0_10=0.0 y error describe la causa. Nunca lanza excepcion."
-tested: false
+tested: true
-tests: []
+tests: ["error: imagen inexistente (guard previo al subproceso)", "error: python del venv ComfyUI ausente", "error: .pth del modelo ausente", "nunca lanza excepcion + determinismo del error"]
-test_file_path: ""
+test_file_path: "python/functions/ml/tests/test_comfyui_score_aesthetic.py"
 file_path: "python/functions/ml/comfyui_score_aesthetic.py"
 ---
 

python/functions/ml/comfyui_score_clip_alignment.md

@@ -28,9 +28,9 @@ params:
   - name: timeout
     desc: "Timeout del subproceso en segundos. keyword-only."
 output: "dict {ok, score_0_1, error}. En exito ok=True y score_0_1 es la similitud coseno clamp a [0,1] (mayor = mas fiel al prompt; tipico 0.28-0.35 buen match, 0.10-0.18 distinto). En error ok=False, score_0_1=0.0 y error describe la causa. Nunca lanza excepcion."
-tested: false
+tested: true
-tests: []
+tests: ["error: imagen inexistente", "error: prompt vacio", "error: python del venv ComfyUI ausente", "nunca lanza excepcion + determinismo del error"]
-test_file_path: ""
+test_file_path: "python/functions/ml/tests/test_comfyui_score_clip_alignment.py"
 file_path: "python/functions/ml/comfyui_score_clip_alignment.py"
 ---
 

python/functions/ml/crop_to_content.md

@@ -0,0 +1,76 @@
+---
+name: crop_to_content
+kind: function
+lang: py
+domain: ml
+version: "1.0.0"
+purity: pure
+signature: "def crop_to_content(img, *, pad_ratio: float = 0.06, square: bool = True, alpha_threshold: int = 10, bg_tolerance: int = 16)"
+description: "Recorta una imagen PIL al bounding box de su contenido y la cuadra, para que el sujeto llene el frame antes de un downscale a pixel-art. Detecta el contenido por alpha (region con alpha > alpha_threshold) si la imagen es RGBA/LA, o por diferencia contra el color de fondo de las esquinas (con bg_tolerance) si es RGB. Recorta al bbox, anade un margen pad_ratio y, si square, rellena a cuadrado centrando el sujeto sin deformar (fondo transparente si RGBA, color de fondo si RGB). Pura PIL (opera sobre el objeto PIL.Image, no toca disco ni red, no muta la entrada). Si no hay contenido (todo transparente o todo fondo) devuelve una copia intacta — no crashea."
+tags: [pil, image, crop, bbox, pixelart, gamedev-2d, ml, alpha, sprite]
+uses_functions: []
+uses_types: []
+returns: []
+returns_optional: false
+error_type: ""
+imports: []
+params:
+  - name: img
+    desc: "PIL.Image de entrada (cualquier modo). No se muta. None lanza ValueError."
+  - name: pad_ratio
+    desc: "Margen anadido alrededor del sujeto como fraccion del lado mayor del bbox recortado (0.06 = 6%). 0 = sin margen. keyword-only."
+  - name: square
+    desc: "Si True rellena a un lienzo cuadrado de lado max(w,h)+2*pad con el sujeto centrado (fondo transparente si hay alpha, color de fondo si RGB); si False solo recorta al bbox + margen sin cuadrar. keyword-only."
+  - name: alpha_threshold
+    desc: "Umbral de alpha (0..255) para considerar un pixel 'contenido' cuando la imagen tiene canal alpha. keyword-only."
+  - name: bg_tolerance
+    desc: "Tolerancia (0..255) de diferencia contra el color de fondo de las esquinas para imagenes sin alpha (RGB). keyword-only."
+output: "PIL.Image nueva recortada (y cuadrada si square) con el sujeto llenando el frame. Si la imagen no tiene contenido detectable, devuelve una copia intacta de la entrada (mismo tamano)."
+tested: true
+tests: [test_golden_corner_subject_fills_frame, test_edge_centered_subject_not_overcropped, test_edge_rgb_background_bbox, test_edge_no_square_only_crops, test_error_all_transparent_returns_copy, test_error_none_raises, test_does_not_mutate_input]
+test_file_path: "python/functions/ml/crop_to_content_test.py"
+file_path: "python/functions/ml/crop_to_content.py"
+---
+
+## Ejemplo
+
+```python
+import sys, os
+sys.path.insert(0, os.path.join(os.environ["HOME"], "fn_registry", "python", "functions"))
+from PIL import Image
+from ml.crop_to_content import crop_to_content
+
+# Sprite RGBA tras rembg: el sujeto ocupa una esquina -> recortar al bbox y cuadrar.
+with Image.open("/tmp/knight_rgba.png") as im:
+    out = crop_to_content(im, pad_ratio=0.06, square=True)
+out.save("/tmp/knight_cropped.png")   # RGBA cuadrada, sujeto centrado llenando el frame
+
+# CLI directo:
+#   ./fn run crop_to_content   (corre los tests)
+#   python3 crop_to_content.py /tmp/in.png /tmp/out.png 0.06
+```
+
+## Cuando usarla
+
+Antes de bajar una imagen a pixel-art (32/64px): si el sujeto ocupa poca area del
+lienzo, al downscalear queda diminuto y tosco. `crop_to_content` recorta el aire
+alrededor y cuadra para que el sujeto aproveche todos los pixeles del grid. Es el
+paso de encuadre del pipeline `comfyui_pixelart_real_oneshot` (autocrop). Funciona
+con sprites recortados por rembg (detecta por alpha) o con imagenes de fondo plano
+(detecta por diferencia contra el color de esquina).
+
+## Gotchas
+
+- **Pura sobre PIL.Image**: recibe y devuelve un objeto `PIL.Image`, NO rutas. El
+  caller hace el `Image.open` / `.save`. No muta la imagen de entrada.
+- Deteccion del contenido: con **alpha** usa `alpha > alpha_threshold`; sin alpha
+  usa la **moda de las 4 esquinas** como color de fondo y `bg_tolerance` de
+  diferencia. Si el fondo no es uniforme (gradiente) la deteccion RGB puede fallar;
+  para esos casos pasa la imagen ya recortada por rembg (RGBA).
+- Si no hay contenido (todo transparente o todo del color de fondo) devuelve una
+  **copia intacta** del original (mismo tamano), nunca lanza por una imagen vacia.
+  Solo lanza `ValueError` si `img` es `None`.
+- `square=True` (default) cuadra a `max(w,h)+2*pad`: si el sujeto es muy alargado el
+  lienzo crece al lado mayor y el sujeto queda centrado con barras transparentes (o
+  de color de fondo) a los lados — sin deformar.
+- `pad_ratio` es relativo al lado **mayor del bbox**, no del lienzo original.

python/functions/ml/crop_to_content.py

@@ -0,0 +1,162 @@
+"""crop_to_content — recorta una imagen PIL al bounding box de su contenido y la cuadra.
+
+Quita el aire alrededor del sujeto para que llene el frame antes de un downscale a
+pixel-art: si el sujeto ocupa el 25% del lienzo, al bajar a 64px queda diminuto y
+tosco (pocos pixeles para el detalle). Esta funcion calcula el bounding box del
+contenido, recorta a ese bbox, anade un margen relativo y, opcionalmente, rellena a
+cuadrado sin deformar para que el sujeto llene el frame.
+
+Como detecta el contenido:
+  - Si la imagen tiene canal alpha (RGBA / LA / P con transparencia): el bbox es la
+    region con `alpha > alpha_threshold` (lo opaco es el sujeto, lo transparente es
+    fondo). Es el caso tras pasar la imagen por rembg.
+  - Si no tiene alpha (RGB): el bbox es la region que difiere del color de fondo,
+    estimado como la moda de los cuatro pixeles de esquina. Sirve para imagenes con
+    fondo plano sin recortar todavia.
+
+Relleno a cuadrado (`square=True`): el lado del lienzo final es `max(w, h) + 2*pad`
+y el sujeto se centra. El fondo del lienzo es transparente si la imagen tiene alpha,
+o el color de fondo estimado si es RGB. Asi no se deforma el sujeto.
+
+Funcion pura: opera sobre el objeto PIL.Image y devuelve uno nuevo; no toca disco ni
+red y no muta la imagen de entrada. Si no encuentra contenido (lienzo vacio o todo
+transparente), devuelve una copia intacta de la entrada — nunca lanza por una imagen
+sin sujeto (contrato no-throw salvo `img` None).
+"""
+from __future__ import annotations
+
+from collections import Counter
+
+
+def _as_rgb_tuple(c) -> tuple:
+    """Normaliza un pixel (int de modo L, o tupla RGB/RGBA) a una 3-tupla RGB."""
+    if isinstance(c, (tuple, list)):
+        return tuple(int(x) for x in c[:3])
+    return (int(c), int(c), int(c))
+
+
+def _corner_bg_color(img) -> tuple:
+    """Color de fondo estimado: la moda de los cuatro pixeles de esquina (RGB)."""
+    rgb = img.convert("RGB")
+    w, h = rgb.size
+    corners = [
+        rgb.getpixel((0, 0)),
+        rgb.getpixel((w - 1, 0)),
+        rgb.getpixel((0, h - 1)),
+        rgb.getpixel((w - 1, h - 1)),
+    ]
+    corners = [_as_rgb_tuple(c) for c in corners]
+    return Counter(corners).most_common(1)[0][0]
+
+
+def _has_alpha(img) -> bool:
+    """True si la imagen lleva transparencia (RGBA, LA o P con transparency)."""
+    return img.mode in ("RGBA", "LA") or (img.mode == "P" and "transparency" in img.info)
+
+
+def _content_bbox(img, alpha_threshold: int, bg_tolerance: int):
+    """Devuelve (l, t, r, b) del contenido o None si no hay.
+
+    Por alpha si la imagen lo tiene; si no, por diferencia contra el color de fondo
+    de las esquinas con tolerancia `bg_tolerance`.
+    """
+    from PIL import Image, ImageChops
+
+    if _has_alpha(img):
+        alpha = img.convert("RGBA").getchannel("A")
+        mask = alpha.point(lambda p: 255 if p > alpha_threshold else 0)
+        return mask.getbbox()
+
+    rgb = img.convert("RGB")
+    bg = Image.new("RGB", rgb.size, _corner_bg_color(rgb))
+    diff = ImageChops.difference(rgb, bg).convert("L")
+    mask = diff.point(lambda p: 255 if p > bg_tolerance else 0)
+    return mask.getbbox()
+
+
+def crop_to_content(
+    img,
+    *,
+    pad_ratio: float = 0.02,
+    square: bool = True,
+    alpha_threshold: int = 10,
+    bg_tolerance: int = 16,
+):
+    """Recorta una imagen PIL al bbox de su contenido, con margen y cuadrado opcional.
+
+    Args:
+        img: PIL.Image de entrada (cualquier modo). No se muta.
+        pad_ratio: margen anadido alrededor del sujeto como fraccion del lado mayor
+            del bbox recortado (0.06 = 6%). 0 = sin margen. keyword-only.
+        square: si True rellena a un lienzo cuadrado de lado `max(w,h)+2*pad` con el
+            sujeto centrado (fondo transparente si hay alpha, color de fondo si RGB);
+            si False solo recorta al bbox + margen sin cuadrar. keyword-only.
+        alpha_threshold: umbral de alpha (0..255) para considerar un pixel "contenido"
+            cuando la imagen tiene canal alpha. keyword-only.
+        bg_tolerance: tolerancia (0..255) de diferencia contra el color de fondo de
+            las esquinas para imagenes sin alpha (RGB). keyword-only.
+
+    Returns:
+        PIL.Image nueva recortada (y cuadrada si square). Si la imagen no tiene
+        contenido detectable (todo transparente o todo del color de fondo), devuelve
+        una copia intacta de la entrada.
+
+    Raises:
+        ValueError: si img es None.
+    """
+    from PIL import Image
+
+    if img is None:
+        raise ValueError("crop_to_content: img es None")
+
+    bbox = _content_bbox(img, int(alpha_threshold), int(bg_tolerance))
+    if bbox is None:
+        return img.copy()
+
+    left, top, right, bottom = bbox
+    cropped = img.crop((left, top, right, bottom))
+    cw, ch = cropped.size
+    pad = int(round(max(cw, ch) * float(pad_ratio)))
+    has_alpha = _has_alpha(img)
+
+    if has_alpha:
+        base = cropped.convert("RGBA")
+        bg_fill = (0, 0, 0, 0)
+        mode = "RGBA"
+    else:
+        base = cropped.convert("RGB")
+        bg_fill = _corner_bg_color(img)
+        mode = "RGB"
+
+    if square:
+        side = max(cw, ch) + 2 * pad
+        canvas = Image.new(mode, (side, side), bg_fill)
+        ox = (side - cw) // 2
+        oy = (side - ch) // 2
+    else:
+        if pad <= 0:
+            return base
+        canvas = Image.new(mode, (cw + 2 * pad, ch + 2 * pad), bg_fill)
+        ox = oy = pad
+
+    if has_alpha:
+        canvas.paste(base, (ox, oy), base)  # usa el alpha del sujeto como mascara
+    else:
+        canvas.paste(base, (ox, oy))
+    return canvas
+
+
+if __name__ == "__main__":
+    import sys
+
+    from PIL import Image
+
+    if len(sys.argv) < 3:
+        print("uso: crop_to_content.py <src> <dst> [pad_ratio]", file=sys.stderr)
+        sys.exit(2)
+    src, dst = sys.argv[1], sys.argv[2]
+    pr = float(sys.argv[3]) if len(sys.argv) > 3 else 0.06
+    with Image.open(src) as im:
+        out = crop_to_content(im, pad_ratio=pr)
+    out.save(dst)
+    print(f"ok: {src} -> {dst} {out.size} {out.mode}")

python/functions/ml/pixeloe_downscale.md

@@ -0,0 +1,92 @@
+---
+name: pixeloe_downscale
+kind: function
+lang: py
+domain: ml
+version: "1.0.0"
+purity: impure
+signature: "def pixeloe_downscale(src_path: str, dst_path: str, *, mode: str = 'contrast', target_size: int = 64, patch_size: int = 16, thickness: int = 2, color_matching: bool = True, no_upscale: bool = True, comfy_python: str | None = None) -> dict"
+description: "Downscale contrast-aware (Contrast-Aware Outline Expansion de Kohaku, lib `pixeloe`) que colapsa una ilustracion a un grid de pixel-art pequeno (64 personajes, 32 iconos) conservando contornos/silueta. Es la etapa de downscale del metodo SOTA de pixel-art (report 0215). NO cuantiza la paleta (eso lo hace despues comfyui_pixelize_image). Resuelve el gotcha de que `pixeloe` solo vive en el venv de ComfyUI con un 'bridge' de interprete: si falta en el interprete actual, re-ejecuta su nucleo por subprocess con el python de ComfyUI. No-throw: todo error viaja en `error`. Determinista; impura por I/O de disco + subprocess. Devuelve {ok, out_path, size, mode, target_size, via, error}."
+tags: [comfyui, gamedev-2d, pixelart, ml, pixeloe, downscale, contrast-aware, image, bridge]
+uses_functions: []
+uses_types: []
+returns: []
+returns_optional: false
+error_type: "error_py_core"
+imports: []
+params:
+  - name: src_path
+    desc: "ruta de la imagen de entrada (PNG/JPG/...). Si no existe -> ok=False con error."
+  - name: dst_path
+    desc: "ruta del PNG de salida; se crea el directorio padre si falta."
+  - name: mode
+    desc: "algoritmo de downscale de pixeloe: 'contrast' (SOTA, conserva silueta), 'bicubic', 'nearest', 'center' o 'k-centroid'. keyword-only."
+  - name: target_size
+    desc: "lado del grid resultante en pixeles (64 para personajes, 32 para iconos). keyword-only."
+  - name: patch_size
+    desc: "tamano del patch que pixeloe colapsa por celda del grid. keyword-only."
+  - name: thickness
+    desc: "grosor de la expansion de contorno (outline expansion). keyword-only."
+  - name: color_matching
+    desc: "corrige el color de cada celda contra el original si True. keyword-only."
+  - name: no_upscale
+    desc: "True devuelve el grid real target_size x target_size (lo habitual, para luego cuantizar); False re-escala al tamano original con pixeles duros (preview). keyword-only."
+  - name: comfy_python
+    desc: "ruta a un interprete con `pixeloe` para el bridge cuando el actual no la tiene. Si None: COMFY_PYTHON y luego ~/ComfyUI/.venv/bin/python3. keyword-only."
+output: "dict con ok (bool), out_path (str), size ([w,h] de la imagen escrita), mode (str usado), target_size (int pedido), via ('inproc' si pixeloe estaba en este interprete, 'bridge' si se delego por subprocess) y error (str, vacio si OK). No lanza excepciones."
+tested: true
+tests: [test_golden_downscale_64_or_clean_degrade, test_edge_target_size_32, test_edge_mode_nearest_no_color_matching, test_error_missing_src_no_throw, test_error_no_interpreter_with_pixeloe]
+test_file_path: "python/functions/ml/pixeloe_downscale_test.py"
+file_path: "python/functions/ml/pixeloe_downscale.py"
+---
+
+## Ejemplo
+
+```python
+import sys, os
+sys.path.insert(0, os.path.join(os.environ["HOME"], "fn_registry", "python", "functions"))
+from ml.pixeloe_downscale import pixeloe_downscale
+
+# Colapsa el render del caballero (1024x1024) a un grid de pixel-art 64x64
+# conservando la silueta. NO cuantiza paleta todavia.
+res = pixeloe_downscale(
+    os.path.expanduser("~/ComfyUI/output/pixel_compare/knight_base_00001_.png"),
+    "/tmp/knight_grid64.png",
+    mode="contrast", target_size=64, no_upscale=True,
+)
+# {'ok': True, 'out_path': '/tmp/knight_grid64.png', 'size': [64, 64],
+#  'mode': 'contrast', 'target_size': 64, 'via': 'bridge', 'error': ''}
+
+# Despues: dureza de color (cuantizacion) con la funcion hermana.
+from ml.comfyui_pixelize_image import comfyui_pixelize_image
+comfyui_pixelize_image("/tmp/knight_grid64.png", "/tmp/knight_q16.png",
+                       downscale=1, colors=16, upscale_back=False)
+```
+
+## Cuando usarla
+
+Primera etapa del metodo SOTA de pixel-art: cuando ya tienes una ilustracion (render
+SDXL/Flux, sprite, foto) y quieres reducirla a un grid de pixel-art chico **sin perder
+los contornos** (lo que arruina un resize NEAREST/lanczos normal). Usala **antes** de
+la cuantizacion dura de paleta con `comfyui_pixelize_image` (paso de color). `target_size`
+64 para personajes, 32 para iconos. Si solo necesitas el resize+cuantizado rapido sin
+contornos finos, `comfyui_pixelize_image` sola basta; para el resultado ganador, encadena
+`pixeloe_downscale` -> `comfyui_pixelize_image`.
+
+## Gotchas
+
+- **`pixeloe` solo esta en el venv de ComfyUI** (`~/ComfyUI/.venv`), no en el del registry.
+  La funcion lo resuelve con un *bridge*: si `import pixeloe` falla, re-ejecuta su nucleo
+  por subprocess con el python de ComfyUI. El campo `via` dice si fue `inproc` o `bridge`.
+- **El modulo es `pixeloe.legacy.pixelize`**, no `pixeloe.pixelize` (ruta vieja eliminada).
+- **El nodo `PixelOEPixelize+` de ComfyUI_essentials estaba roto** por ese cambio de import;
+  por eso aqui se llama la lib directa (numpy + PIL, sin cv2).
+- **NO cuantiza la paleta**: el resultado conserva muchos colores; la dureza retro la aplica
+  despues `comfyui_pixelize_image`. No esperes pocos colores en la salida.
+- **No-throw**: src inexistente, pixeloe ausente en todos los interpretes, o subprocess
+  caido -> `ok=False` con `error` explicado, nunca excepcion. El pipeline llamante hace
+  fallback mirando `ok`.
+- Resolucion del interprete del bridge: arg `comfy_python` -> env `COMFY_PYTHON` ->
+  `~/ComfyUI/.venv/bin/python3` (el primero que exista como archivo).
+- `no_upscale=True` (default) devuelve el grid real `target_size x target_size`; con `False`
+  vuelve al tamano original con pixeles duros (preview), no el grid pequeno.

python/functions/ml/pixeloe_downscale.py

@@ -0,0 +1,322 @@
+"""pixeloe_downscale — downscale contrast-aware a un grid de pixel-art (etapa SOTA).
+
+Colapsa una ilustracion a un grid de pixel-art pequeno (p.ej. 64x64) usando la
+libreria `pixeloe` de Kohaku (Contrast-Aware Outline Expansion), el metodo SOTA
+para preservar contornos/silueta al reducir. Es la etapa de *downscale* del
+metodo ganador de pixel-art (ver report 0215): NO cuantiza la paleta — esa dureza
+de color la aplica despues otra funcion (`comfyui_pixelize_image`).
+
+Gotcha de entorno (resuelto con un "bridge" de interprete): la lib `pixeloe` solo
+esta instalada en el venv de ComfyUI (`~/ComfyUI/.venv`), no en el venv del
+registry, y su modulo vive en `pixeloe.legacy.pixelize` (la ruta vieja
+`pixeloe.pixelize` ya no existe). Por eso la funcion:
+
+  1. Intenta `import pixeloe` en el interprete actual y ejecuta el nucleo directo.
+  2. Si falta (`ModuleNotFoundError`), re-ejecuta este mismo archivo como subprocess
+     (`python pixeloe_downscale.py --bridge <json>`) con un interprete que SI la
+     tenga, parseando la unica linea JSON que ese hijo imprime a stdout.
+  3. Si no hay ningun interprete con pixeloe, devuelve ok=False (sin excepcion);
+     el pipeline que la llama hara fallback.
+
+La funcion es no-throw: cualquier error se captura y viaja en el campo `error`.
+Determinista; impura solo por la lectura/escritura de disco y el subprocess.
+"""
+
+import os
+
+
+def _resolve_comfy_python(comfy_python):
+    """Devuelve el primer interprete candidato que exista como archivo, o None.
+
+    Orden: arg comfy_python -> env COMFY_PYTHON -> ~/ComfyUI/.venv/bin/python3.
+    """
+    candidates = []
+    if comfy_python:
+        candidates.append(comfy_python)
+    env = os.environ.get("COMFY_PYTHON")
+    if env:
+        candidates.append(env)
+    candidates.append(os.path.expanduser("~/ComfyUI/.venv/bin/python3"))
+    for c in candidates:
+        if c and os.path.isfile(c):
+            return c
+    return None
+
+
+def _run_core(src_path, dst_path, mode, target_size, patch_size, thickness,
+              color_matching, no_upscale):
+    """Nucleo no-throw: requiere `pixeloe` importable EN ESTE interprete.
+
+    Lee src como RGB uint8 (numpy + PIL, sin cv2), llama
+    `pixeloe.legacy.pixelize.pixelize` y guarda el resultado como PNG. Devuelve el
+    dict de resultado. NO lanza excepciones: las captura en `error`.
+    """
+    out = {
+        "ok": False,
+        "out_path": "",
+        "size": [0, 0],
+        "mode": mode,
+        "target_size": int(target_size),
+        "via": "inproc",
+        "error": "",
+    }
+
+    try:
+        import numpy as np
+        from PIL import Image
+    except Exception as exc:  # noqa: BLE001 - degradacion limpia, no relanzar
+        out["error"] = f"numpy/PIL no disponible en este interprete: {exc}"
+        return out
+
+    if not os.path.isfile(src_path):
+        out["error"] = f"src_path no existe: {src_path!r}"
+        return out
+
+    try:
+        from pixeloe.legacy.pixelize import pixelize
+    except Exception as exc:  # noqa: BLE001
+        out["error"] = f"no se pudo importar pixeloe.legacy.pixelize: {exc}"
+        return out
+
+    try:
+        img = np.array(Image.open(src_path).convert("RGB"))  # HxWx3 uint8
+    except Exception as exc:  # noqa: BLE001
+        out["error"] = f"no se pudo leer/decodificar {src_path!r}: {exc}"
+        return out
+
+    try:
+        res = pixelize(
+            img,
+            mode=mode,
+            target_size=int(target_size),
+            patch_size=int(patch_size),
+            thickness=int(thickness),
+            contrast=1.0,
+            saturation=1.0,
+            color_matching=bool(color_matching),
+            no_upscale=bool(no_upscale),
+        )
+    except TypeError as exc:
+        # Firma de pixelize distinta a la esperada: reseñar, no relanzar.
+        out["error"] = f"pixelize rechazo los kwargs (firma distinta?): {exc}"
+        return out
+    except Exception as exc:  # noqa: BLE001
+        out["error"] = f"pixelize fallo: {exc}"
+        return out
+
+    try:
+        arr = np.asarray(res)
+        result_img = Image.fromarray(arr)
+        dst_dir = os.path.dirname(os.path.abspath(dst_path))
+        os.makedirs(dst_dir, exist_ok=True)
+        result_img.save(dst_path)
+    except Exception as exc:  # noqa: BLE001
+        out["error"] = f"no se pudo escribir {dst_path!r}: {exc}"
+        return out
+
+    out.update(ok=True, out_path=dst_path, size=list(result_img.size), error="")
+    return out
+
+
+def _run_via_bridge(interp, src_path, dst_path, mode, target_size, patch_size,
+                    thickness, color_matching, no_upscale):
+    """Ejecuta el nucleo en otro interprete (que tiene pixeloe) via subprocess.
+
+    Corre `interp <este_archivo> --bridge <json_args>` y parsea la ultima linea de
+    stdout que sea JSON valido (pixeloe puede emitir ruido antes). No-throw.
+    """
+    import json
+    import subprocess
+
+    out = {
+        "ok": False,
+        "out_path": "",
+        "size": [0, 0],
+        "mode": mode,
+        "target_size": int(target_size),
+        "via": "bridge",
+        "error": "",
+    }
+
+    args = {
+        "src_path": src_path,
+        "dst_path": dst_path,
+        "mode": mode,
+        "target_size": int(target_size),
+        "patch_size": int(patch_size),
+        "thickness": int(thickness),
+        "color_matching": bool(color_matching),
+        "no_upscale": bool(no_upscale),
+    }
+
+    try:
+        proc = subprocess.run(
+            [interp, os.path.abspath(__file__), "--bridge", json.dumps(args)],
+            capture_output=True,
+            text=True,
+            timeout=600,
+        )
+    except Exception as exc:  # noqa: BLE001
+        out["error"] = f"fallo el subprocess bridge ({interp}): {exc}"
+        return out
+
+    if proc.returncode != 0:
+        tail = (proc.stderr or "").strip()[-500:]
+        out["error"] = f"bridge salio con codigo {proc.returncode}: {tail}"
+        return out
+
+    # Parsea de atras hacia delante la primera linea que sea JSON valido.
+    parsed = None
+    for ln in reversed((proc.stdout or "").splitlines()):
+        ln = ln.strip()
+        if not ln:
+            continue
+        try:
+            parsed = json.loads(ln)
+            break
+        except Exception:  # noqa: BLE001 - linea de ruido, sigue probando
+            continue
+
+    if parsed is None:
+        tail = (proc.stderr or "").strip()[-300:]
+        out["error"] = f"bridge no produjo salida JSON. stderr: {tail}"
+        return out
+
+    parsed["via"] = "bridge"
+    return parsed
+
+
+def pixeloe_downscale(
+    src_path: str,
+    dst_path: str,
+    *,
+    mode: str = "contrast",
+    target_size: int = 64,
+    patch_size: int = 16,
+    thickness: int = 2,
+    color_matching: bool = True,
+    no_upscale: bool = True,
+    comfy_python: str | None = None,
+) -> dict:
+    """Downscale contrast-aware de una imagen a un grid de pixel-art (no cuantiza).
+
+    Args:
+        src_path: ruta de la imagen de entrada (PNG/JPG/...).
+        dst_path: ruta del PNG de salida (se crea el directorio si falta).
+        mode: algoritmo de downscale de pixeloe: "contrast" (SOTA, conserva
+            silueta), "bicubic", "nearest", "center" o "k-centroid". keyword-only.
+        target_size: lado del grid resultante en pixeles (64 personajes, 32
+            iconos). keyword-only.
+        patch_size: tamano del patch que pixeloe colapsa por celda. keyword-only.
+        thickness: grosor de la expansion de contorno (outline). keyword-only.
+        color_matching: corrige el color de cada celda contra el original si True.
+            keyword-only.
+        no_upscale: True devuelve el grid real target_size x target_size (lo
+            habitual para luego cuantizar); False re-escala al tamano original con
+            pixeles duros (preview). keyword-only.
+        comfy_python: ruta a un interprete con `pixeloe` para el bridge cuando el
+            actual no la tiene. Si None, se prueba COMFY_PYTHON y luego
+            ~/ComfyUI/.venv/bin/python3. keyword-only.
+
+    Returns:
+        dict con:
+        - ok (bool): True si se hizo el downscale y se guardo el PNG.
+        - out_path (str): ruta del PNG generado.
+        - size (list[int]): [w, h] de la imagen escrita.
+        - mode (str): modo de downscale usado.
+        - target_size (int): lado del grid pedido.
+        - via (str): "inproc" si pixeloe estaba en este interprete, "bridge" si se
+          delego a otro interprete por subprocess.
+        - error (str): mensaje de error; cadena vacia si todo OK.
+    """
+    out = {
+        "ok": False,
+        "out_path": "",
+        "size": [0, 0],
+        "mode": mode,
+        "target_size": int(target_size),
+        "via": "",
+        "error": "",
+    }
+
+    try:
+        if not os.path.isfile(src_path):
+            out["error"] = f"src_path no existe: {src_path!r}"
+            return out
+
+        # 1. pixeloe disponible en el interprete actual -> nucleo directo.
+        has_local = True
+        try:
+            import pixeloe  # noqa: F401
+        except ModuleNotFoundError:
+            has_local = False
+        except Exception:  # noqa: BLE001 - pixeloe presente pero roto -> bridge
+            has_local = False
+
+        if has_local:
+            res = _run_core(
+                src_path, dst_path, mode, int(target_size), int(patch_size),
+                int(thickness), bool(color_matching), bool(no_upscale),
+            )
+            res["via"] = "inproc"
+            return res
+
+        # 2. Bridge a un interprete que tenga pixeloe.
+        interp = _resolve_comfy_python(comfy_python)
+        if interp is None:
+            out["error"] = (
+                "pixeloe no disponible: no se encontro ningun interprete con "
+                "pixeloe (pasa comfy_python, define COMFY_PYTHON, o instala "
+                "~/ComfyUI/.venv)"
+            )
+            return out
+
+        return _run_via_bridge(
+            interp, src_path, dst_path, mode, int(target_size), int(patch_size),
+            int(thickness), bool(color_matching), bool(no_upscale),
+        )
+    except Exception as exc:  # noqa: BLE001 - contrato no-throw
+        out["error"] = f"error inesperado: {exc}"
+        return out
+
+
+if __name__ == "__main__":
+    import json
+    import sys
+
+    if "--bridge" in sys.argv:
+        # Modo bridge: ejecuta el nucleo y emite UNA linea JSON a stdout.
+        _idx = sys.argv.index("--bridge")
+        _payload = sys.argv[_idx + 1] if len(sys.argv) > _idx + 1 else "{}"
+        try:
+            _a = json.loads(_payload)
+        except Exception as _exc:  # noqa: BLE001
+            print(json.dumps({
+                "ok": False, "out_path": "", "size": [0, 0], "mode": "",
+                "target_size": 0, "via": "inproc",
+                "error": f"payload --bridge invalido: {_exc}",
+            }))
+            sys.exit(0)
+        _res = _run_core(
+            _a.get("src_path", ""),
+            _a.get("dst_path", ""),
+            _a.get("mode", "contrast"),
+            _a.get("target_size", 64),
+            _a.get("patch_size", 16),
+            _a.get("thickness", 2),
+            _a.get("color_matching", True),
+            _a.get("no_upscale", True),
+        )
+        print(json.dumps(_res))
+        sys.exit(0)
+
+    # Modo CLI normal.
+    if len(sys.argv) < 3:
+        print("uso: pixeloe_downscale.py <src> <dst> [target_size] [mode]",
+              file=sys.stderr)
+        sys.exit(2)
+    _src, _dst = sys.argv[1], sys.argv[2]
+    _ts = int(sys.argv[3]) if len(sys.argv) > 3 else 64
+    _md = sys.argv[4] if len(sys.argv) > 4 else "contrast"
+    print(json.dumps(pixeloe_downscale(_src, _dst, target_size=_ts, mode=_md),
+                     indent=2))

python/functions/ml/render_openpose_walk_skeletons.md

@@ -0,0 +1,93 @@
+---
+name: render_openpose_walk_skeletons
+kind: function
+lang: py
+domain: ml
+version: "1.0.0"
+purity: impure
+signature: "def render_openpose_walk_skeletons(out_dir: str, *, frames: int = 4, width: int = 512, height: int = 768, facing: str = 'right', line_width: int = 4, point_radius: int = 6, filename_prefix: str = 'walk_pose') -> dict"
+description: "Dibuja con PIL una secuencia de N esqueletos OpenPose COCO-18 (18 keypoints, 17 limbs, colores canonicos) de un ciclo de caminar lateral, una fase del paso por frame, sobre fondo negro, y los guarda como PNG. Son la ENTRADA fija del ControlNet OpenPose (control_v11p_sd15_openpose_fp16) para animar un personaje frame-by-frame: el esqueleto NO lo genera la IA, lo aportas dibujado. Para frames=4 produce las 4 fases canonicas (contact-izq, passing, contact-der, passing); para mas frames muestrea el ciclo parametrico continuo. Piernas en oposicion a los brazos + rebote vertical del cuerpo (walk cycle de manual de animacion). facing='right'|'left' espeja en X. Impura: escribe N PNGs. Devuelve {ok, skeleton_paths, frames, width, height, error}."
+tags: [gamedev-2d, comfyui, controlnet, openpose, pose, animation]
+uses_functions: []
+uses_types: []
+returns: []
+returns_optional: false
+error_type: "error_go_core"
+imports: []
+params:
+  - name: out_dir
+    desc: "directorio destino de los PNG; se crea si no existe. None lanza ValueError (unico caso que lanza)."
+  - name: frames
+    desc: "numero de fases del ciclo a renderizar (default 4 = las 4 fases canonicas contact/passing/contact/passing); con mas frames se muestrea el ciclo parametrico de forma continua interpolando las fases intermedias down/up. keyword-only."
+  - name: width
+    desc: "ancho en pixeles de cada PNG (default 512, el tamaño nativo de SD1.5). keyword-only."
+  - name: height
+    desc: "alto en pixeles de cada PNG (default 768, retrato para personaje de cuerpo entero). keyword-only."
+  - name: facing
+    desc: "'right' (el personaje mira a +x) o 'left' (espeja el esqueleto en X). Cualquier otro valor devuelve ok=False con error. keyword-only."
+  - name: line_width
+    desc: "grosor en pixeles de las lineas de los limbs (default 4). keyword-only."
+  - name: point_radius
+    desc: "radio en pixeles de los circulos rellenos de cada keypoint (default 6). keyword-only."
+  - name: filename_prefix
+    desc: "prefijo de los archivos; se nombran '<prefix>_<NN>.png' con NN de dos digitos en orden de fase (default 'walk_pose'). keyword-only."
+output: "dict con ok (bool, True si todos los PNG se generaron), skeleton_paths (list[str], rutas de los PNG en orden de fase), frames (int, frames generados), width (int), height (int), error (str, vacio si OK)."
+tested: false
+tests: []
+test_file_path: ""
+file_path: "python/functions/ml/render_openpose_walk_skeletons.py"
+---
+
+## Ejemplo
+
+```python
+import sys, os
+sys.path.insert(0, os.path.join(os.environ["HOME"], "fn_registry", "python", "functions"))
+from ml.render_openpose_walk_skeletons import render_openpose_walk_skeletons
+
+res = render_openpose_walk_skeletons("/tmp/walk_skeletons_demo", frames=4)
+# {'ok': True,
+#  'skeleton_paths': ['/tmp/walk_skeletons_demo/walk_pose_00.png', ..._03.png],
+#  'frames': 4, 'width': 512, 'height': 768, 'error': ''}
+
+# 8 fases mirando a la izquierda, lineas/puntos mas finos:
+res8 = render_openpose_walk_skeletons(
+    "/tmp/walk_poses_left", frames=8, facing="left",
+    line_width=3, point_radius=5,
+)
+```
+
+Los PNG resultantes se conectan luego con `comfyui_build_controlnet_workflow`
+(uno por frame, `control_net_name="control_v11p_sd15_openpose_fp16.safetensors"`)
+para generar el personaje animado fotograma a fotograma.
+
+## Cuando usarla
+
+Usala cuando vayas a animar un sprite/personaje 2D con ComfyUI + ControlNet
+OpenPose y necesites el insumo que la IA NO genera: la pose-map del esqueleto.
+Llamala ANTES de montar el workflow ControlNet — produce las N pose-maps del
+walk cycle (el caso mas comun de animacion de personaje) que el modelo seguira
+frame a frame. Tambien sirve como base para otras acciones ciclicas si ajustas
+las fases. Si necesitas una pose suelta (idle, ataque) en vez de un ciclo,
+extrae el patron a una funcion hermana — esta es especifica de caminar.
+
+## Gotchas
+
+- Escribe N PNGs en disco (impura): si `out_dir` no es escribible devuelve
+  `ok=False` con el error; si `out_dir` es `None` lanza `ValueError` (unico caso
+  que lanza — el resto de fallos se capturan en `error`).
+- El orden de los 18 keypoints es COCO-18 EXACTO (0 nose ... 17 left_ear) y los
+  colores son los canonicos de OpenPose/controlnet_aux. NO cambies el orden ni la
+  paleta: el preprocesador/ControlNet identifica las articulaciones por color y
+  posicion; alterarlos degrada o rompe el guiado de pose.
+- Es un esqueleto sintetico parametrico, no una captura real: las proporciones
+  son humanas estandar y la vista es estrictamente lateral. Para vistas 3/4 o
+  proporciones no humanas (chibi, criaturas) habria que reparametrizar.
+- Fondo NEGRO solido (RGB 0,0,0) por diseño — es lo que el ControlNet OpenPose
+  espera como lienzo. No lo compongas sobre otra imagen.
+- `frames=4` da exactamente las 4 fases canonicas; valores que no dividan bien el
+  ciclo (p.ej. 3, 5) siguen muestreando t=i/frames de forma uniforme y producen
+  fases validas pero no necesariamente las "de manual". Para animacion fluida usa
+  multiplos de 4 (8, 12, 16).
+- Necesita Pillow (PIL); si no esta instalado devuelve `ok=False` con error en vez
+  de lanzar.

python/functions/ml/render_openpose_walk_skeletons.py

@@ -0,0 +1,260 @@
+"""Dibuja una secuencia de esqueletos OpenPose (COCO-18) de un ciclo de caminar.
+
+Funcion impura: rasteriza con PIL (Pillow) N frames de un walk cycle lateral y
+escribe cada uno como PNG sobre fondo negro. Cada PNG es una pose-map valida para
+el ControlNet OpenPose de SD1.5 (control_v11p_sd15_openpose_fp16): el esqueleto NO
+lo genera la IA, lo aportas tu dibujado y el modelo anima el personaje sobre el.
+
+El formato es el render clasico de OpenPose: 18 keypoints (COCO-18), 17 limbs,
+colores canonicos por articulacion/par. Las piernas oscilan en oposicion a los
+brazos y el cuerpo "bota" (sube en passing, baja en contact) — un walk cycle de
+manual de animacion. Para frames=4 produce las 4 fases canonicas
+(contact-izq, passing, contact-der, passing); para mas frames muestrea el ciclo
+parametrico de forma continua (interpolando las fases intermedias down/up).
+"""
+import json
+import math
+import os
+
+
+# Orden de indice COCO-18 que espera el ControlNet OpenPose.
+COCO18_NAMES = [
+    "nose", "neck", "right_shoulder", "right_elbow", "right_wrist",
+    "left_shoulder", "left_elbow", "left_wrist", "right_hip", "right_knee",
+    "right_ankle", "left_hip", "left_knee", "left_ankle",
+    "right_eye", "left_eye", "right_ear", "left_ear",
+]
+
+# Pares (limbs) — formato OpenPose clasico (17 limbs sobre 18 keypoints).
+LIMB_SEQ = [
+    (1, 2), (1, 5), (2, 3), (3, 4), (5, 6), (6, 7), (1, 8), (8, 9), (9, 10),
+    (1, 11), (11, 12), (12, 13), (1, 0), (0, 14), (14, 16), (0, 15), (15, 17),
+]
+
+# Colores canonicos (RGB) por indice, identicos a los del render original de
+# OpenPose / controlnet_aux. El keypoint i usa COLORS[i]; el limb i usa COLORS[i].
+COLORS = [
+    [255, 0, 0], [255, 85, 0], [255, 170, 0], [255, 255, 0], [170, 255, 0],
+    [85, 255, 0], [0, 255, 0], [0, 255, 85], [0, 255, 170], [0, 255, 255],
+    [0, 170, 255], [0, 85, 255], [0, 0, 255], [85, 0, 255], [170, 0, 255],
+    [255, 0, 255], [255, 0, 170], [255, 0, 85],
+]
+
+
+def _walk_pose_norm(t: float) -> dict:
+    """Devuelve los 18 keypoints normalizados (0..1, y hacia abajo) de un walk
+    cycle lateral mirando a la derecha, para la fase t in [0, 1).
+
+    t=0.0 -> contact (pierna izq adelante), t=0.25 -> passing (cuerpo arriba),
+    t=0.5 -> contact (pierna der adelante), t=0.75 -> passing.
+    """
+    two_pi = 2.0 * math.pi
+    cx = 0.50
+    neck_y = 0.245
+    sh_y = 0.265
+    hip_y0 = 0.55
+    ground_y = 0.885
+    thigh_drop = 0.165   # caida vertical hip->knee
+    stride = 0.105       # desplazamiento horizontal max del pie respecto al hip
+    bob_amp = 0.025      # rebote vertical del cuerpo
+    lift_amp = 0.05      # cuanto se levanta el pie en swing
+    sh_dx = 0.024        # media separacion horizontal de hombros (profundidad)
+    hip_dx = 0.026       # media separacion horizontal de caderas
+
+    # Rebote: bajo en contact (t=0, .5), alto en passing (t=.25, .75).
+    rise = bob_amp * (1.0 - math.cos(2.0 * two_pi * t)) / 2.0
+    nx = cx
+    ny = neck_y - rise
+    hip_cy = hip_y0 - rise
+
+    pts = {}
+    pts[1] = (nx, ny)                        # neck
+    pts[0] = (nx + 0.055, ny - 0.105)        # nose (mira a la derecha)
+    pts[14] = (nx + 0.045, ny - 0.120)       # right_eye
+    pts[15] = (nx + 0.026, ny - 0.120)       # left_eye
+    pts[16] = (nx + 0.002, ny - 0.103)       # right_ear (atras)
+    pts[17] = (nx - 0.012, ny - 0.097)       # left_ear (atras)
+    pts[2] = (nx - sh_dx, sh_y - rise)       # right_shoulder
+    pts[5] = (nx + sh_dx, sh_y - rise)       # left_shoulder
+
+    r_hip = (cx - hip_dx, hip_cy)
+    l_hip = (cx + hip_dx, hip_cy)
+    pts[8] = r_hip
+    pts[11] = l_hip
+
+    # Factores de oscilacion de las piernas (opuestas entre si).
+    fwd_l = math.cos(two_pi * t)             # pierna izq adelante en t=0
+    fwd_r = -fwd_l                           # pierna der opuesta
+    lift_l = lift_amp * max(0.0, -math.sin(two_pi * t))  # izq levanta t in (.5,1)
+    lift_r = lift_amp * max(0.0, math.sin(two_pi * t))   # der levanta t in (0,.5)
+
+    def _leg(hip, fwd, lift):
+        hx, hy = hip
+        ax = hx + stride * fwd
+        ay = ground_y - lift
+        bend = 0.012 + 0.06 * (lift / lift_amp if lift_amp else 0.0)
+        kx = (hx + ax) / 2.0 + bend          # rodilla apunta hacia delante
+        ky = hy + thigh_drop
+        return (kx, ky), (ax, ay)
+
+    rk, ra = _leg(r_hip, fwd_r, lift_r)
+    lk, la = _leg(l_hip, fwd_l, lift_l)
+    pts[9], pts[10] = rk, ra                 # right_knee, right_ankle
+    pts[12], pts[13] = lk, la                # left_knee, left_ankle
+
+    # Brazos en oposicion: brazo der adelante cuando pierna izq adelante.
+    arm_fwd_r = fwd_l
+    arm_fwd_l = fwd_r
+    sh_to_el = 0.105
+    el_to_wr = 0.110
+    arm_sw = 0.05
+
+    def _arm(sh, fwd):
+        sx, sy = sh
+        ex = sx + arm_sw * fwd + 0.008
+        ey = sy + sh_to_el
+        wx = sx + arm_sw * 1.7 * fwd + 0.016
+        wy = ey + el_to_wr
+        return (ex, ey), (wx, wy)
+
+    re, rw = _arm(pts[2], arm_fwd_r)
+    le, lw = _arm(pts[5], arm_fwd_l)
+    pts[3], pts[4] = re, rw                  # right_elbow, right_wrist
+    pts[6], pts[7] = le, lw                  # left_elbow, left_wrist
+
+    return pts
+
+
+def render_openpose_walk_skeletons(
+    out_dir: str,
+    *,
+    frames: int = 4,
+    width: int = 512,
+    height: int = 768,
+    facing: str = "right",
+    line_width: int = 4,
+    point_radius: int = 6,
+    filename_prefix: str = "walk_pose",
+) -> dict:
+    """Dibuja N esqueletos OpenPose COCO-18 de un walk cycle y los guarda como PNG.
+
+    Args:
+        out_dir: directorio destino de los PNG; se crea si no existe.
+        frames: numero de fases del ciclo a renderizar (default 4 = las 4
+            fases canonicas contact/passing/contact/passing). keyword-only.
+        width: ancho de cada PNG en pixeles (default 512). keyword-only.
+        height: alto de cada PNG en pixeles (default 768, retrato). keyword-only.
+        facing: "right" (mira a +x) o "left" (espeja en X). keyword-only.
+        line_width: grosor en px de las lineas de los limbs (default 4).
+            keyword-only.
+        point_radius: radio en px de los circulos de cada keypoint (default 6).
+            keyword-only.
+        filename_prefix: prefijo de los archivos; se nombran
+            "<prefix>_<NN>.png" con NN de dos digitos. keyword-only.
+
+    Returns:
+        dict con:
+        - ok (bool): True si todos los PNG se generaron.
+        - skeleton_paths (list[str]): rutas de los PNG creados, en orden de fase.
+        - frames (int): numero de frames generados.
+        - width (int): ancho usado.
+        - height (int): alto usado.
+        - error (str): mensaje de error; cadena vacia si todo OK.
+
+    No lanza salvo que out_dir sea None: cualquier otro fallo se captura en
+    el campo "error" con ok=False.
+    """
+    if out_dir is None:
+        raise ValueError("out_dir no puede ser None")
+
+    out = {
+        "ok": False, "skeleton_paths": [], "frames": int(frames or 0),
+        "width": int(width or 0), "height": int(height or 0), "error": "",
+    }
+
+    try:
+        from PIL import Image, ImageDraw
+    except ImportError:
+        out["error"] = "PIL (Pillow) no esta instalado en este interprete"
+        return out
+
+    try:
+        frames = int(frames)
+        width = int(width)
+        height = int(height)
+        line_width = max(1, int(line_width))
+        point_radius = max(1, int(point_radius))
+    except (TypeError, ValueError) as exc:
+        out["error"] = f"argumento numerico invalido: {exc}"
+        return out
+
+    if frames <= 0:
+        out["error"] = "frames debe ser >= 1"
+        return out
+    if width < 16 or height < 16:
+        out["error"] = "width y height deben ser >= 16"
+        return out
+    if facing not in ("right", "left"):
+        out["error"] = f"facing debe ser 'right' o 'left', no {facing!r}"
+        return out
+
+    out["frames"] = frames
+    out["width"] = width
+    out["height"] = height
+
+    try:
+        os.makedirs(out_dir, exist_ok=True)
+    except OSError as exc:
+        out["error"] = f"no se pudo crear out_dir {out_dir!r}: {exc}"
+        return out
+
+    paths = []
+    try:
+        for i in range(frames):
+            t = i / float(frames)
+            norm = _walk_pose_norm(t)
+
+            # Mirror en X para facing izquierda (el esqueleto sigue siendo valido).
+            kp = {}
+            for idx, (x, y) in norm.items():
+                if facing == "left":
+                    x = 1.0 - x
+                kp[idx] = (x * width, y * height)
+
+            img = Image.new("RGB", (width, height), (0, 0, 0))
+            draw = ImageDraw.Draw(img)
+
+            # Limbs primero (lineas gruesas del color del par).
+            for li, (a, b) in enumerate(LIMB_SEQ):
+                if a in kp and b in kp:
+                    col = tuple(COLORS[li % len(COLORS)])
+                    draw.line([kp[a], kp[b]], fill=col, width=line_width)
+
+            # Keypoints encima (circulos rellenos del color de la articulacion).
+            for idx in range(len(COCO18_NAMES)):
+                if idx not in kp:
+                    continue
+                cx, cy = kp[idx]
+                col = tuple(COLORS[idx % len(COLORS)])
+                draw.ellipse(
+                    [cx - point_radius, cy - point_radius,
+                     cx + point_radius, cy + point_radius],
+                    fill=col,
+                )
+
+            path = os.path.join(out_dir, f"{filename_prefix}_{i:02d}.png")
+            img.save(path)
+            paths.append(path)
+    except (OSError, ValueError) as exc:
+        out["error"] = f"fallo al rasterizar/guardar el frame {len(paths)}: {exc}"
+        out["skeleton_paths"] = paths
+        return out
+
+    out["ok"] = True
+    out["skeleton_paths"] = paths
+    return out
+
+
+if __name__ == "__main__":
+    res = render_openpose_walk_skeletons("/tmp/walk_skeletons_demo", frames=4)
+    print(json.dumps(res, indent=2))

python/functions/ml/tests/test_comfyui_build_asset_variant_workflow.py

@@ -0,0 +1,86 @@
+"""Tests de estructura/determinismo para comfyui_build_asset_variant_workflow (func pura, img2img)."""
+
+import os
+import sys
+
+import pytest
+
+sys.path.insert(0, os.path.dirname(__file__))
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", ".."))
+
+from ml.comfyui_build_asset_variant_workflow import comfyui_build_asset_variant_workflow
+from _comfyui_wf_assert import assert_api_format, class_types, node_by_ct
+
+
+def _texts(wf):
+    return [n["inputs"].get("text", "") for n in wf.values() if n["class_type"] == "CLIPTextEncode"]
+
+
+def test_estructura_img2img():
+    # img2img: parte de una imagen (LoadImage + VAEEncode), NO de EmptyLatentImage.
+    wf = comfyui_build_asset_variant_workflow("enemy.png", "ice element")
+    assert_api_format(wf)
+    cts = class_types(wf)
+    for ct in ("CheckpointLoaderSimple", "LoadImage", "VAEEncode", "CLIPTextEncode",
+               "KSampler", "VAEDecode", "SaveImage"):
+        assert ct in cts, f"falta nodo {ct}"
+    assert "EmptyLatentImage" not in cts  # img2img no genera desde ruido
+
+
+def test_load_image_y_prompt_reflejados():
+    wf = comfyui_build_asset_variant_workflow("  enemy_creature_00001_.png  ", "fire element")
+    # input_image se strippea y llega al LoadImage.
+    assert node_by_ct(wf, "LoadImage")["inputs"]["image"] == "enemy_creature_00001_.png"
+    # el positivo contiene la variante + el refuerzo de composicion.
+    pos = [t for t in _texts(wf) if "same composition" in t]
+    assert pos and "fire element" in pos[0]
+
+
+def test_size_default_inserta_imagescale():
+    # size=512 por defecto -> normaliza la base con un ImageScale a 512x512.
+    wf = comfyui_build_asset_variant_workflow("enemy.png", "golden tier 2")
+    scale = node_by_ct(wf, "ImageScale")["inputs"]
+    assert scale["width"] == 512 and scale["height"] == 512
+
+
+def test_size_none_sin_imagescale():
+    wf = comfyui_build_asset_variant_workflow("enemy.png", "frozen", size=None)
+    assert "ImageScale" not in class_types(wf)
+
+
+def test_denoise_se_clampa():
+    assert node_by_ct(comfyui_build_asset_variant_workflow("e.png", "v", denoise=2.0),
+                      "KSampler")["inputs"]["denoise"] == 1.0
+    assert node_by_ct(comfyui_build_asset_variant_workflow("e.png", "v", denoise=-1.0),
+                      "KSampler")["inputs"]["denoise"] == 0.0
+    assert node_by_ct(comfyui_build_asset_variant_workflow("e.png", "v", denoise=0.5),
+                      "KSampler")["inputs"]["denoise"] == 0.5
+
+
+def test_filename_prefix_y_seed():
+    wf = comfyui_build_asset_variant_workflow("e.png", "v", seed=123, filename_prefix="mio")
+    assert node_by_ct(wf, "SaveImage")["inputs"]["filename_prefix"] == "mio"
+    assert node_by_ct(wf, "KSampler")["inputs"]["seed"] == 123
+
+
+def test_lora_inyecta_loraloader():
+    sin = comfyui_build_asset_variant_workflow("e.png", "v")
+    con = comfyui_build_asset_variant_workflow("e.png", "v", lora="SD15_dark.safetensors")
+    assert "LoraLoader" not in class_types(sin)
+    assert "LoraLoader" in class_types(con)
+
+
+def test_input_image_vacio_lanza():
+    with pytest.raises(ValueError):
+        comfyui_build_asset_variant_workflow("   ", "v")
+
+
+def test_variant_vacio_lanza():
+    with pytest.raises(ValueError):
+        comfyui_build_asset_variant_workflow("e.png", "")
+
+
+def test_determinista():
+    a = comfyui_build_asset_variant_workflow("e.png", "ice", seed=7, denoise=0.5)
+    b = comfyui_build_asset_variant_workflow("e.png", "ice", seed=7, denoise=0.5)
+    assert a == b

python/functions/ml/tests/test_comfyui_build_directional_sprite_workflow.py

@@ -0,0 +1,83 @@
+"""Tests de estructura/determinismo para comfyui_build_directional_sprite_workflow (func pura, 2.5D)."""
+
+import os
+import sys
+
+import pytest
+
+sys.path.insert(0, os.path.dirname(__file__))
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", ".."))
+
+from ml.comfyui_build_directional_sprite_workflow import (
+    comfyui_build_directional_sprite_workflow,
+    directional_sprite_view_order,
+)
+from _comfyui_wf_assert import assert_api_format, class_types, node_by_ct
+
+
+def test_sv3d_estructura_y_orbit_default():
+    wf = comfyui_build_directional_sprite_workflow("goblin.png", directions=8, model="sv3d")
+    assert_api_format(wf)
+    cts = class_types(wf)
+    for ct in ("LoadImage", "ImageOnlyCheckpointLoader", "SV3D_Conditioning",
+               "VideoLinearCFGGuidance", "KSampler", "VAEDecode", "SaveImage"):
+        assert ct in cts, f"falta nodo {ct}"
+    cond = node_by_ct(wf, "SV3D_Conditioning")["inputs"]
+    # video_frames default = directions; size nativa sv3d = 576.
+    assert cond["video_frames"] == 8
+    assert cond["width"] == 576 and cond["height"] == 576
+
+
+def test_sv3d_orbit_frames_override():
+    wf = comfyui_build_directional_sprite_workflow("g.png", directions=8, orbit_frames=21)
+    assert node_by_ct(wf, "SV3D_Conditioning")["inputs"]["video_frames"] == 21
+
+
+def test_zero123_estructura_y_azimuth():
+    wf = comfyui_build_directional_sprite_workflow("g.png", directions=4, model="zero123")
+    assert_api_format(wf)
+    cts = class_types(wf)
+    assert "StableZero123_Conditioning_Batched" in cts
+    assert "SV3D_Conditioning" not in cts  # camino distinto al sv3d
+    cond = node_by_ct(wf, "StableZero123_Conditioning_Batched")["inputs"]
+    # batch = directions; size nativa zero123 = 256; azimuth equiespaciado 360/N.
+    assert cond["batch_size"] == 4
+    assert cond["width"] == 256 and cond["height"] == 256
+    assert cond["azimuth_batch_increment"] == 90.0
+
+
+def test_cfg_y_ckpt_default_por_modelo():
+    sv3d = comfyui_build_directional_sprite_workflow("g.png", model="sv3d")
+    z123 = comfyui_build_directional_sprite_workflow("g.png", model="zero123")
+    assert node_by_ct(sv3d, "KSampler")["inputs"]["cfg"] == 2.5
+    assert node_by_ct(z123, "KSampler")["inputs"]["cfg"] == 4.0
+    assert node_by_ct(sv3d, "ImageOnlyCheckpointLoader")["inputs"]["ckpt_name"] == "3D_sv3d_p.safetensors"
+    assert node_by_ct(z123, "ImageOnlyCheckpointLoader")["inputs"]["ckpt_name"] == "3D_stable_zero123.ckpt"
+
+
+def test_elevation_y_seed_reflejados():
+    wf = comfyui_build_directional_sprite_workflow("g.png", model="sv3d", elevation=15.0, seed=42)
+    assert node_by_ct(wf, "SV3D_Conditioning")["inputs"]["elevation"] == 15.0
+    assert node_by_ct(wf, "KSampler")["inputs"]["seed"] == 42
+
+
+def test_view_order_helper():
+    assert directional_sprite_view_order(8) == ["S", "SE", "E", "NE", "N", "NW", "W", "SW"]
+    assert directional_sprite_view_order(4) == ["S", "E", "N", "W"]
+    # N no canonico -> etiquetas por azimuth.
+    assert directional_sprite_view_order(6) == ["az0", "az60", "az120", "az180", "az240", "az300"]
+
+
+def test_errores():
+    with pytest.raises(ValueError):
+        comfyui_build_directional_sprite_workflow("")
+    with pytest.raises(ValueError):
+        comfyui_build_directional_sprite_workflow("g.png", model="turbo")
+    with pytest.raises(ValueError):
+        comfyui_build_directional_sprite_workflow("g.png", directions=0)
+
+
+def test_determinista():
+    a = comfyui_build_directional_sprite_workflow("g.png", directions=8, seed=7, elevation=15.0)
+    b = comfyui_build_directional_sprite_workflow("g.png", directions=8, seed=7, elevation=15.0)
+    assert a == b

python/functions/ml/tests/test_comfyui_build_grid.py

@@ -0,0 +1,74 @@
+"""Tests offline para comfyui_build_grid (impura PIL: lee N imagenes -> PNG grid).
+
+Sin red, sin GPU, sin servidor: crea PNGs reales en un tmp_path y monta el grid.
+"""
+
+import os
+import sys
+
+import pytest
+
+sys.path.insert(0, os.path.dirname(__file__))
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", ".."))
+
+from ml.comfyui_build_grid import comfyui_build_grid
+
+PIL = pytest.importorskip("PIL")
+from PIL import Image  # noqa: E402
+
+
+def _png(path, size=(64, 64), color=(120, 30, 30)):
+    Image.new("RGB", size, color).save(path)
+    return str(path)
+
+
+def test_grid_basico(tmp_path):
+    paths = [_png(tmp_path / f"i{i}.png") for i in range(4)]
+    out = tmp_path / "grid.png"
+    res = comfyui_build_grid(paths, out_path=str(out))
+    assert res["ok"] is True
+    assert res["error"] == ""
+    assert os.path.isfile(res["out_path"]) and res["out_path"] == str(out)
+    # 4 imagenes -> ceil(sqrt(4)) = 2 columnas, 2 filas.
+    assert res["cols"] == 2 and res["rows"] == 2
+
+
+def test_cols_explicito_y_filas(tmp_path):
+    paths = [_png(tmp_path / f"i{i}.png") for i in range(5)]
+    res = comfyui_build_grid(paths, cols=5, out_path=str(tmp_path / "g.png"))
+    assert res["cols"] == 5 and res["rows"] == 1
+
+
+def test_cell_define_dimension_del_canvas(tmp_path):
+    paths = [_png(tmp_path / f"i{i}.png") for i in range(2)]
+    res = comfyui_build_grid(paths, cols=2, cell=128, out_path=str(tmp_path / "g.png"))
+    with Image.open(res["out_path"]) as im:
+        # 2 columnas x 128 cell = 256 ancho; 1 fila x 128 = 128 alto.
+        assert im.size == (256, 128)
+
+
+def test_labels_reservan_franja(tmp_path):
+    paths = [_png(tmp_path / f"i{i}.png") for i in range(2)]
+    res = comfyui_build_grid(paths, cols=2, cell=64, labels=["a", "b"],
+                             out_path=str(tmp_path / "g.png"))
+    with Image.open(res["out_path"]) as im:
+        # con labels se reservan 22px bajo cada celda: alto = 64 + 22.
+        assert im.size == (128, 86)
+
+
+def test_error_lista_vacia():
+    res = comfyui_build_grid([])
+    assert res["ok"] is False and "vacio" in res["error"]
+
+
+def test_error_ruta_inexistente(tmp_path):
+    res = comfyui_build_grid([str(tmp_path / "no_existe.png")])
+    assert res["ok"] is False and "no existen" in res["error"]
+
+
+def test_determinista_mismo_dict(tmp_path):
+    paths = [_png(tmp_path / f"i{i}.png") for i in range(3)]
+    a = comfyui_build_grid(paths, out_path=str(tmp_path / "a.png"))
+    b = comfyui_build_grid(paths, out_path=str(tmp_path / "b.png"))
+    # rows/cols/ok son determableinistas para las mismas entradas.
+    assert (a["ok"], a["rows"], a["cols"]) == (b["ok"], b["rows"], b["cols"])

python/functions/ml/tests/test_comfyui_build_inpaint_asset_workflow.py

@@ -0,0 +1,78 @@
+"""Tests de estructura/determinismo para comfyui_build_inpaint_asset_workflow (func pura, inpaint)."""
+
+import os
+import sys
+
+import pytest
+
+sys.path.insert(0, os.path.dirname(__file__))
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", ".."))
+
+from ml.comfyui_build_inpaint_asset_workflow import comfyui_build_inpaint_asset_workflow
+from _comfyui_wf_assert import assert_api_format, class_types, node_by_ct
+
+
+def _texts(wf):
+    return [n["inputs"].get("text", "") for n in wf.values() if n["class_type"] == "CLIPTextEncode"]
+
+
+def test_estructura_vae_encode():
+    wf = comfyui_build_inpaint_asset_workflow("asset.png", "mask.png", "a golden sword")
+    assert_api_format(wf)
+    cts = class_types(wf)
+    for ct in ("CheckpointLoaderSimple", "LoadImage", "LoadImageMask",
+               "VAEEncodeForInpaint", "CLIPTextEncode", "KSampler", "VAEDecode", "SaveImage"):
+        assert ct in cts, f"falta nodo {ct}"
+
+
+def test_prompt_region_y_grow_mask():
+    wf = comfyui_build_inpaint_asset_workflow("a.png", "m.png", "blue shield", grow_mask=8)
+    pos = [t for t in _texts(wf) if "seamless blend" in t]
+    assert pos and "blue shield" in pos[0]
+    assert node_by_ct(wf, "VAEEncodeForInpaint")["inputs"]["grow_mask_by"] == 8
+
+
+def test_grow_mask_se_clampa():
+    wf = comfyui_build_inpaint_asset_workflow("a.png", "m.png", "p", grow_mask=999)
+    assert node_by_ct(wf, "VAEEncodeForInpaint")["inputs"]["grow_mask_by"] == 64
+
+
+def test_modo_noise_mask_degrada():
+    # noise_mask reemplaza VAEEncodeForInpaint por VAEEncode + SetLatentNoiseMask (+ GrowMask).
+    wf = comfyui_build_inpaint_asset_workflow("a.png", "m.png", "p", mode="noise_mask", grow_mask=6)
+    cts = class_types(wf)
+    assert "VAEEncodeForInpaint" not in cts
+    assert "VAEEncode" in cts and "SetLatentNoiseMask" in cts and "GrowMask" in cts
+
+
+def test_size_inserta_imagescale_a_imagen_y_mascara():
+    # size en modo vae_encode escala imagen Y mascara de forma consistente.
+    wf = comfyui_build_inpaint_asset_workflow("a.png", "m.png", "p", size=768)
+    scales = [n for n in wf.values() if n["class_type"] == "ImageScale"]
+    assert len(scales) == 2  # una para la imagen, otra para la mascara
+    assert all(s["inputs"]["width"] == 768 and s["inputs"]["height"] == 768 for s in scales)
+    assert "ImageToMask" in class_types(wf)
+
+
+def test_lora_y_filename():
+    wf = comfyui_build_inpaint_asset_workflow("a.png", "m.png", "p", lora="x.safetensors",
+                                              filename_prefix="mio")
+    assert "LoraLoader" in class_types(wf)
+    assert node_by_ct(wf, "SaveImage")["inputs"]["filename_prefix"] == "mio"
+
+
+def test_errores():
+    with pytest.raises(ValueError):
+        comfyui_build_inpaint_asset_workflow("", "m.png", "p")
+    with pytest.raises(ValueError):
+        comfyui_build_inpaint_asset_workflow("a.png", "", "p")
+    with pytest.raises(ValueError):
+        comfyui_build_inpaint_asset_workflow("a.png", "m.png", "")
+    with pytest.raises(ValueError):
+        comfyui_build_inpaint_asset_workflow("a.png", "m.png", "p", mode="otro")
+
+
+def test_determinista():
+    a = comfyui_build_inpaint_asset_workflow("a.png", "m.png", "orb", seed=7, grow_mask=6)
+    b = comfyui_build_inpaint_asset_workflow("a.png", "m.png", "orb", seed=7, grow_mask=6)
+    assert a == b

python/functions/ml/tests/test_comfyui_build_outpaint_asset_workflow.py

@@ -0,0 +1,73 @@
+"""Tests de estructura/determinismo para comfyui_build_outpaint_asset_workflow (func pura, outpaint)."""
+
+import os
+import sys
+
+import pytest
+
+sys.path.insert(0, os.path.dirname(__file__))
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", ".."))
+
+from ml.comfyui_build_outpaint_asset_workflow import comfyui_build_outpaint_asset_workflow
+from _comfyui_wf_assert import assert_api_format, class_types, node_by_ct
+
+
+def test_estructura_outpaint():
+    wf = comfyui_build_outpaint_asset_workflow("bg.png", "more forest", right=256)
+    assert_api_format(wf)
+    cts = class_types(wf)
+    for ct in ("CheckpointLoaderSimple", "LoadImage", "ImagePadForOutpaint",
+               "VAEEncodeForInpaint", "CLIPTextEncode", "KSampler", "VAEDecode", "SaveImage"):
+        assert ct in cts, f"falta nodo {ct}"
+    # outpaint genera su mascara con el pad: NO usa LoadImageMask.
+    assert "LoadImageMask" not in cts
+
+
+def test_pad_cableado_a_vaeencode():
+    # VAEEncodeForInpaint toma pixels de la IMAGE del pad y mask de la MASK del pad.
+    wf = comfyui_build_outpaint_asset_workflow("bg.png", "sky", top=128)
+    pad_id = next(nid for nid, n in wf.items() if n["class_type"] == "ImagePadForOutpaint")
+    enc = node_by_ct(wf, "VAEEncodeForInpaint")["inputs"]
+    assert enc["pixels"] == [pad_id, 0]
+    assert enc["mask"] == [pad_id, 1]
+
+
+def test_extensiones_redondeadas_a_8():
+    # _round8 normaliza al multiplo de 8 mas cercano.
+    wf = comfyui_build_outpaint_asset_workflow("bg.png", "p", right=10)
+    pad = node_by_ct(wf, "ImagePadForOutpaint")["inputs"]
+    assert pad["right"] == 8 and pad["left"] == 0 and pad["top"] == 0 and pad["bottom"] == 0
+
+
+def test_sin_extension_lanza():
+    # las cuatro extensiones a 0 (tras redondear) -> no hay nada que extender.
+    with pytest.raises(ValueError):
+        comfyui_build_outpaint_asset_workflow("bg.png", "p", left=3, right=2)
+
+
+def test_feather_y_prompt():
+    wf = comfyui_build_outpaint_asset_workflow("bg.png", "open sky", top=64, feather=30)
+    assert node_by_ct(wf, "ImagePadForOutpaint")["inputs"]["feathering"] == 30
+    pos = [n["inputs"]["text"] for n in wf.values()
+           if n["class_type"] == "CLIPTextEncode" and "seamless extension" in n["inputs"].get("text", "")]
+    assert pos and "open sky" in pos[0]
+
+
+def test_lora_y_filename():
+    wf = comfyui_build_outpaint_asset_workflow("bg.png", "p", right=64, lora="x.safetensors",
+                                               filename_prefix="mio")
+    assert "LoraLoader" in class_types(wf)
+    assert node_by_ct(wf, "SaveImage")["inputs"]["filename_prefix"] == "mio"
+
+
+def test_errores_vacios():
+    with pytest.raises(ValueError):
+        comfyui_build_outpaint_asset_workflow("", "p", right=64)
+    with pytest.raises(ValueError):
+        comfyui_build_outpaint_asset_workflow("bg.png", "", right=64)
+
+
+def test_determinista():
+    a = comfyui_build_outpaint_asset_workflow("bg.png", "forest", right=256, seed=7)
+    b = comfyui_build_outpaint_asset_workflow("bg.png", "forest", right=256, seed=7)
+    assert a == b

python/functions/ml/tests/test_comfyui_build_pixelart_workflow.py

@@ -67,3 +67,33 @@ def test_determinism():
     a = comfyui_build_pixelart_workflow("pixel cat", seed=3)
     b = comfyui_build_pixelart_workflow("pixel cat", seed=3)
     assert a == b
+
+
+def test_transparent_default_injects_rembg():
+    """transparent default True -> nodo Image Rembg y SaveImage repuntado a el."""
+    wf = comfyui_build_pixelart_workflow("pixel knight, full body")
+    rembg = [n for n in wf.values() if n["class_type"] == "Image Rembg (Remove Background)"]
+    assert len(rembg) == 1
+    assert rembg[0]["inputs"]["transparency"] is True
+    assert rembg[0]["inputs"]["model"] == "u2net"
+    # SaveImage debe leer de la salida del Rembg, no del VAEDecode.
+    rembg_id = next(k for k, n in wf.items() if n["class_type"] == "Image Rembg (Remove Background)")
+    save = next(n for n in wf.values() if n["class_type"] == "SaveImage")
+    assert save["inputs"]["images"][0] == rembg_id
+
+
+def test_transparent_false_no_rembg():
+    """transparent=False -> sin nodo Rembg (tiles/fondos opacos)."""
+    wf = comfyui_build_pixelart_workflow("seamless grass tile", transparent=False)
+    rembg = [n for n in wf.values() if n["class_type"] == "Image Rembg (Remove Background)"]
+    assert len(rembg) == 0
+    # SaveImage lee directo del VAEDecode.
+    vae_id = next(k for k, n in wf.items() if n["class_type"] == "VAEDecode")
+    save = next(n for n in wf.values() if n["class_type"] == "SaveImage")
+    assert save["inputs"]["images"][0] == vae_id
+
+
+def test_rembg_model_override():
+    wf = comfyui_build_pixelart_workflow("anime hero", rembg_model="isnet-anime")
+    rembg = next(n for n in wf.values() if n["class_type"] == "Image Rembg (Remove Background)")
+    assert rembg["inputs"]["model"] == "isnet-anime"

python/functions/ml/tests/test_comfyui_build_sprite_from_sketch_workflow.py

@@ -0,0 +1,80 @@
+"""Tests de estructura/determinismo para comfyui_build_sprite_from_sketch_workflow (func pura, ControlNet)."""
+
+import os
+import sys
+
+import pytest
+
+sys.path.insert(0, os.path.dirname(__file__))
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", ".."))
+
+from ml.comfyui_build_sprite_from_sketch_workflow import comfyui_build_sprite_from_sketch_workflow
+from _comfyui_wf_assert import assert_api_format, class_types, node_by_ct
+
+
+def test_estructura_txt2img_mas_controlnet():
+    # txt2img (EmptyLatentImage, denoise alto) guiado por ControlNet atado al boceto.
+    wf = comfyui_build_sprite_from_sketch_workflow("sketch.png", "armored knight")
+    assert_api_format(wf)
+    cts = class_types(wf)
+    for ct in ("CheckpointLoaderSimple", "EmptyLatentImage", "CLIPTextEncode", "KSampler",
+               "VAEDecode", "SaveImage", "LoadImage", "ControlNetLoader", "ControlNetApply"):
+        assert ct in cts, f"falta nodo {ct}"
+
+
+def test_lineart_default_preprocesador_y_modelo():
+    wf = comfyui_build_sprite_from_sketch_workflow("s.png", "knight", control_type="lineart")
+    assert "LineArtPreprocessor" in class_types(wf)
+    assert node_by_ct(wf, "ControlNetLoader")["inputs"]["control_net_name"] == \
+        "control_v11p_sd15_lineart_fp16.safetensors"
+    # el ControlNetApply consume el mapa de lineas del preprocesador, no el LoadImage directo.
+    pre_id = next(nid for nid, n in wf.items() if n["class_type"].endswith("Preprocessor"))
+    assert node_by_ct(wf, "ControlNetApply")["inputs"]["image"] == [pre_id, 0]
+
+
+def test_canny_preprocesador_y_modelo():
+    wf = comfyui_build_sprite_from_sketch_workflow("s.png", "chest", control_type="canny")
+    assert "CannyEdgePreprocessor" in class_types(wf)
+    assert node_by_ct(wf, "ControlNetLoader")["inputs"]["control_net_name"] == \
+        "control_v11p_sd15_canny_fp16.safetensors"
+
+
+def test_preprocess_false_pasa_boceto_directo():
+    wf = comfyui_build_sprite_from_sketch_workflow("s.png", "k", preprocess=False)
+    assert not any(n["class_type"].endswith("Preprocessor") for n in wf.values())
+    load_id = next(nid for nid, n in wf.items() if n["class_type"] == "LoadImage")
+    assert node_by_ct(wf, "ControlNetApply")["inputs"]["image"] == [load_id, 0]
+
+
+def test_controlnet_name_override_y_strength():
+    wf = comfyui_build_sprite_from_sketch_workflow(
+        "s.png", "k", control_type="lineart",
+        controlnet_name="control_v11p_sd15_canny_fp16.safetensors", strength=0.65)
+    assert node_by_ct(wf, "ControlNetLoader")["inputs"]["control_net_name"] == \
+        "control_v11p_sd15_canny_fp16.safetensors"
+    assert node_by_ct(wf, "ControlNetApply")["inputs"]["strength"] == 0.65
+
+
+def test_strength_se_clampa():
+    wf = comfyui_build_sprite_from_sketch_workflow("s.png", "k", strength=5.0)
+    assert node_by_ct(wf, "ControlNetApply")["inputs"]["strength"] == 2.0
+
+
+def test_lora_inyecta():
+    assert "LoraLoader" in class_types(
+        comfyui_build_sprite_from_sketch_workflow("s.png", "k", lora="x.safetensors"))
+
+
+def test_errores():
+    with pytest.raises(ValueError):
+        comfyui_build_sprite_from_sketch_workflow("", "k")
+    with pytest.raises(ValueError):
+        comfyui_build_sprite_from_sketch_workflow("s.png", "")
+    with pytest.raises(ValueError):
+        comfyui_build_sprite_from_sketch_workflow("s.png", "k", control_type="depth")
+
+
+def test_determinista():
+    a = comfyui_build_sprite_from_sketch_workflow("s.png", "knight", seed=7, strength=0.8)
+    b = comfyui_build_sprite_from_sketch_workflow("s.png", "knight", seed=7, strength=0.8)
+    assert a == b

python/functions/ml/tests/test_comfyui_critique_image_llm.py

@@ -0,0 +1,62 @@
+"""Tests offline para comfyui_critique_image_llm (impura: critica LLM-vision via ask_llm_vision).
+
+Sin red, sin API: prueba el parser de JSON puro (_extract_json) y el flujo con ask_llm_vision
+monkeypatcheado (veredicto estructurado, ambiguo->bad conservador, API caida, texto no parseable).
+"""
+
+import os
+import sys
+
+import pytest
+
+sys.path.insert(0, os.path.dirname(__file__))
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", ".."))
+
+import ml.comfyui_critique_image_llm as mod
+from ml.comfyui_critique_image_llm import comfyui_critique_image_llm, _extract_json
+
+
+def test_extract_json_fenced():
+    txt = 'blah\n```json\n{"verdict": "good", "score": 8}\n```\nfin'
+    assert _extract_json(txt) == {"verdict": "good", "score": 8}
+
+
+def test_extract_json_brace_plano():
+    assert _extract_json('  {"verdict": "bad", "score": 2}  ') == {"verdict": "bad", "score": 2}
+
+
+def test_extract_json_sin_objeto_lanza():
+    with pytest.raises(ValueError):
+        _extract_json("no hay json aqui")
+
+
+def _fake_vision(text, ok=True):
+    return lambda user_prompt, image_path, **kw: {"ok": ok, "text": text, "error": "" if ok else "429"}
+
+
+def test_flujo_veredicto_estructurado(monkeypatch):
+    monkeypatch.setattr(mod, "ask_llm_vision",
+                        _fake_vision('{"verdict": "good", "score": 8.5, "reasons": ["nitida"]}'))
+    res = comfyui_critique_image_llm("i.png", "a cat")
+    assert res["ok"] is True
+    assert res["verdict"] == "good" and res["score_0_10"] == 8.5
+    assert res["reasons"] == ["nitida"]
+
+
+def test_verdict_ambiguo_cae_a_bad(monkeypatch):
+    monkeypatch.setattr(mod, "ask_llm_vision",
+                        _fake_vision('{"verdict": "maybe", "score": 5}'))
+    res = comfyui_critique_image_llm("i.png", "p")
+    assert res["ok"] is True and res["verdict"] == "bad"  # conservador ante ambiguo
+
+
+def test_api_caida_ok_false(monkeypatch):
+    monkeypatch.setattr(mod, "ask_llm_vision", _fake_vision("", ok=False))
+    res = comfyui_critique_image_llm("i.png", "p")
+    assert res["ok"] is False and res["error"]
+
+
+def test_respuesta_no_parseable_ok_false(monkeypatch):
+    monkeypatch.setattr(mod, "ask_llm_vision", _fake_vision("lo siento, no puedo"))
+    res = comfyui_critique_image_llm("i.png", "p")
+    assert res["ok"] is False and "no parseable" in res["error"]

python/functions/ml/tests/test_comfyui_extract_recipe_from_png.py

@@ -0,0 +1,86 @@
+"""Tests offline para comfyui_extract_recipe_from_png (impura: destila PNG -> receta de skill).
+
+Sin red, sin servidor: prueba los helpers puros de extraccion y el flujo de degradacion a la
+`meta` de Civitai cuando el PNG no trae workflow embebido (PNG inexistente -> sin workflow).
+"""
+
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(__file__))
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", ".."))
+
+from ml.comfyui_extract_recipe_from_png import (
+    comfyui_extract_recipe_from_png,
+    _slugify,
+    _loras_from_prompt,
+    _dims_from_prompt,
+    _checkpoint_from_prompt,
+    _detect_base_workflow,
+    _from_civitai_meta,
+)
+
+
+def test_slugify():
+    assert _slugify("A Red Apple!", "fb") == "a_red_apple"
+    assert _slugify("", "fallback") == "fallback"
+    # acota a 6 tokens.
+    assert _slugify("one two three four five six seven eight", "fb").count("_") == 5
+
+
+def test_loras_from_prompt():
+    prompt = {"7": {"class_type": "LoraLoader",
+                    "inputs": {"lora_name": "style.safetensors",
+                               "strength_model": 0.8, "strength_clip": 0.7}}}
+    loras = _loras_from_prompt(prompt)
+    assert loras == [{"name": "style.safetensors", "strength_model": 0.8, "strength_clip": 0.7}]
+    assert _loras_from_prompt({}) == []
+
+
+def test_dims_y_checkpoint_from_prompt():
+    prompt = {
+        "1": {"class_type": "CheckpointLoaderSimple", "inputs": {"ckpt_name": "dream.safetensors"}},
+        "5": {"class_type": "EmptyLatentImage", "inputs": {"width": 832, "height": 1216}},
+    }
+    assert _dims_from_prompt(prompt) == {"width": 832, "height": 1216}
+    assert _checkpoint_from_prompt(prompt) == "dream.safetensors"
+
+
+def test_detect_base_workflow():
+    assert _detect_base_workflow({"1": {"class_type": "UNETLoader", "inputs": {}}}) == "flux"
+    assert _detect_base_workflow({"1": {"class_type": "CheckpointLoaderSimple", "inputs": {}}}) == "txt2img"
+
+
+def test_from_civitai_meta():
+    meta = {"steps": 25, "sampler": "Euler a", "Size": "832x1216", "seed": 7,
+            "cfgScale": 6.5, "Model": "mymodel", "prompt": "a cat", "negativePrompt": "blurry"}
+    out = _from_civitai_meta(meta)
+    assert out["checkpoint"] == "mymodel"
+    assert out["positive"] == "a cat" and out["negative"] == "blurry"
+    assert out["params"]["steps"] == 25 and out["params"]["cfg"] == 6.5
+    assert out["params"]["width"] == 832 and out["params"]["height"] == 1216
+
+
+def test_flujo_fallback_civitai_meta(tmp_path):
+    # PNG inexistente -> sin workflow embebido; cae a la meta de Civitai (utilizable).
+    res = comfyui_extract_recipe_from_png(
+        str(tmp_path / "no.png"),
+        civitai_meta={"prompt": "a knight", "Model": "dream.safetensors", "steps": 20})
+    assert res["ok"] is True
+    assert res["has_workflow"] is False
+    recipe = res["recipe"]
+    assert recipe["checkpoint"] == "dream.safetensors"
+    assert recipe["prompt_scaffold"]["positive"] == "a knight"
+    assert recipe["provenance"]["source"] == "civitai" and recipe["score_n"] == 0
+
+
+def test_slug_derivado_del_prompt(tmp_path):
+    res = comfyui_extract_recipe_from_png(
+        str(tmp_path / "no.png"), civitai_meta={"prompt": "Fire Goblin Warrior"})
+    assert res["ok"] is True and res["slug"] == "fire_goblin_warrior"
+
+
+def test_error_sin_workflow_ni_meta(tmp_path):
+    res = comfyui_extract_recipe_from_png(str(tmp_path / "no.png"))
+    assert res["ok"] is False and res["recipe"] == {}
+    assert "no trae workflow" in res["error"]

python/functions/ml/tests/test_comfyui_flatten_alpha_on_color.py

@@ -0,0 +1,68 @@
+"""Tests offline para comfyui_flatten_alpha_on_color (impura PIL: aplana RGBA sobre fondo solido).
+
+Sin red, sin GPU, sin servidor: crea un PNG RGBA real y verifica el RGB resultante.
+"""
+
+import os
+import sys
+
+import pytest
+
+sys.path.insert(0, os.path.dirname(__file__))
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", ".."))
+
+from ml.comfyui_flatten_alpha_on_color import comfyui_flatten_alpha_on_color
+
+PIL = pytest.importorskip("PIL")
+from PIL import Image  # noqa: E402
+
+
+def _rgba(path, size=(32, 32), color=(0, 0, 0, 0)):
+    Image.new("RGBA", size, color).save(path)
+    return str(path)
+
+
+def test_aplana_transparente_sobre_blanco(tmp_path):
+    src = _rgba(tmp_path / "sprite.png", color=(0, 0, 0, 0))  # totalmente transparente
+    out = tmp_path / "flat.png"
+    res = comfyui_flatten_alpha_on_color(src, out_path=str(out), color=(255, 255, 255))
+    assert res["ok"] is True and res["error"] == ""
+    with Image.open(res["out_path"]) as im:
+        assert im.mode == "RGB"  # sin alpha
+        # sobre alpha 0 queda el fondo solido: blanco.
+        assert im.getpixel((0, 0)) == (255, 255, 255)
+
+
+def test_color_de_fondo_personalizado(tmp_path):
+    src = _rgba(tmp_path / "s.png", color=(0, 0, 0, 0))
+    res = comfyui_flatten_alpha_on_color(src, out_path=str(tmp_path / "o.png"), color=(10, 20, 30))
+    with Image.open(res["out_path"]) as im:
+        assert im.getpixel((0, 0)) == (10, 20, 30)
+
+
+def test_size_redimensiona_cuadrado(tmp_path):
+    src = _rgba(tmp_path / "s.png", size=(32, 16))
+    res = comfyui_flatten_alpha_on_color(src, out_path=str(tmp_path / "o.png"), size=64)
+    assert res["size"] == [64, 64]
+    with Image.open(res["out_path"]) as im:
+        assert im.size == (64, 64)
+
+
+def test_out_path_default_sufijo_flat(tmp_path):
+    src = _rgba(tmp_path / "sprite.png")
+    res = comfyui_flatten_alpha_on_color(src)  # out_path None -> <base>_flat.png
+    assert res["ok"] is True
+    assert res["out_path"].endswith("sprite_flat.png")
+
+
+def test_error_imagen_inexistente(tmp_path):
+    res = comfyui_flatten_alpha_on_color(str(tmp_path / "no.png"))
+    assert res["ok"] is False and "no existe" in res["error"]
+
+
+def test_determinista(tmp_path):
+    src = _rgba(tmp_path / "s.png", color=(5, 5, 5, 128))
+    a = comfyui_flatten_alpha_on_color(src, out_path=str(tmp_path / "a.png"), color=(200, 0, 0))
+    b = comfyui_flatten_alpha_on_color(src, out_path=str(tmp_path / "b.png"), color=(200, 0, 0))
+    with Image.open(a["out_path"]) as ia, Image.open(b["out_path"]) as ib:
+        assert ia.tobytes() == ib.tobytes()

python/functions/ml/tests/test_comfyui_import_workflow_json.py

@@ -0,0 +1,88 @@
+"""Tests offline para comfyui_import_workflow_json (impura: lee disco/URL + normaliza a API format).
+
+Sin red, sin servidor: lee workflows desde archivos locales. Para el caso UI graph monkeypatchea
+comfyui_object_info (devuelve None) para no consultar el servidor; se valida la resolucion de
+conexiones y el descarte de nodos virtuales (Note).
+"""
+
+import json
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(__file__))
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", ".."))
+
+import ml.comfyui_import_workflow_json as mod
+from ml.comfyui_import_workflow_json import comfyui_import_workflow_json
+from _comfyui_wf_assert import assert_api_format, class_types
+
+
+_API = {
+    "1": {"class_type": "CheckpointLoaderSimple", "inputs": {"ckpt_name": "m.safetensors"}},
+    "2": {"class_type": "VAEDecode", "inputs": {"samples": ["1", 0], "vae": ["1", 2]}},
+}
+
+_UI_GRAPH = {
+    "nodes": [
+        {"id": 1, "type": "CheckpointLoaderSimple", "inputs": [], "widgets_values": ["m.safetensors"]},
+        {"id": 2, "type": "Note", "inputs": []},
+        {"id": 3, "type": "VAEDecode",
+         "inputs": [{"name": "samples", "link": 10}, {"name": "vae", "link": 11}]},
+    ],
+    "links": [
+        [10, 1, 0, 3, 0, "LATENT"],
+        [11, 1, 2, 3, 1, "VAE"],
+    ],
+}
+
+
+def _write(tmp_path, name, obj):
+    p = tmp_path / name
+    p.write_text(json.dumps(obj))
+    return str(p)
+
+
+def test_api_format_se_devuelve_tal_cual(tmp_path):
+    res = comfyui_import_workflow_json(_write(tmp_path, "api.json", _API))
+    assert res["ok"] is True and res["format_detected"] == "api"
+    assert res["workflow"] == _API
+
+
+def test_ui_graph_se_normaliza(tmp_path, monkeypatch):
+    monkeypatch.setattr(mod, "comfyui_object_info", lambda server="", timeout=5.0: None)
+    res = comfyui_import_workflow_json(_write(tmp_path, "ui.json", _UI_GRAPH))
+    assert res["ok"] is True and res["format_detected"] == "ui_graph"
+    api = res["workflow"]
+    assert_api_format(api)
+    # el nodo virtual Note se descarta; las conexiones del VAEDecode se resuelven al CheckpointLoader.
+    assert "Note" not in class_types(api)
+    assert "2" not in api
+    assert api["3"]["inputs"]["samples"] == ["1", 0]
+    assert api["3"]["inputs"]["vae"] == ["1", 2]
+
+
+def test_json_invalido_error(tmp_path):
+    p = tmp_path / "bad.json"
+    p.write_text("no soy json {")
+    res = comfyui_import_workflow_json(str(p))
+    assert res["ok"] is False and "JSON invalido" in res["error"]
+
+
+def test_formato_no_reconocido(tmp_path):
+    res = comfyui_import_workflow_json(_write(tmp_path, "x.json", {"foo": "bar"}))
+    assert res["ok"] is False and "no reconocido" in res["error"]
+
+
+def test_json_no_es_objeto(tmp_path):
+    res = comfyui_import_workflow_json(_write(tmp_path, "lst.json", [1, 2, 3]))
+    assert res["ok"] is False and "no es un objeto de workflow" in res["error"]
+
+
+def test_archivo_inexistente(tmp_path):
+    res = comfyui_import_workflow_json(str(tmp_path / "no.json"))
+    assert res["ok"] is False and "no se pudo leer" in res["error"]
+
+
+def test_determinista(tmp_path):
+    path = _write(tmp_path, "api.json", _API)
+    assert comfyui_import_workflow_json(path) == comfyui_import_workflow_json(path)

python/functions/ml/tests/test_comfyui_interrupt_queue.py

@@ -0,0 +1,149 @@
+"""Tests de comfyui_interrupt_queue contra un servidor ComfyUI simulado.
+
+La funcion es pura I/O (HTTP), asi que levantamos un http.server local que imita
+los endpoints relevantes de ComfyUI (/interrupt, /queue) y verificamos:
+
+- Golden: interrupt sin clear corta el actual pero NO vacia los pendientes.
+- Edge: clear_pending=True vacia la cola (queue_remaining=0).
+- Edge: clear_pending=True con la cola ya vacia no rompe.
+- Error: si el servidor no responde, devuelve {ok:False, error} sin lanzar.
+"""
+
+import http.server
+import json
+import os
+import socket
+import sys
+import threading
+
+sys.path.insert(0, os.path.dirname(__file__))
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", ".."))
+
+from ml.comfyui_interrupt_queue import comfyui_interrupt_queue
+
+
+class _FakeComfyHandler(http.server.BaseHTTPRequestHandler):
+    """Imita ComfyUI: estado de cola mutable compartido via la clase del server."""
+
+    def log_message(self, *args):  # silenciar el log del servidor en los tests
+        pass
+
+    def _send_json(self, obj, code=200):
+        body = json.dumps(obj).encode()
+        self.send_response(code)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def do_POST(self):
+        st = self.server.state
+        if self.path == "/interrupt":
+            st["running"] = []  # interrupt corta el prompt en ejecucion
+            self._send_json({})
+            return
+        if self.path == "/queue":
+            length = int(self.headers.get("Content-Length", 0))
+            raw = self.rfile.read(length) if length else b"{}"
+            body = json.loads(raw or b"{}")
+            if body.get("clear"):
+                st["pending"] = []  # clear vacia los pendientes
+            elif "delete" in body:
+                st["pending"] = [
+                    p for p in st["pending"] if p not in body["delete"]
+                ]
+            self._send_json({})
+            return
+        self._send_json({"error": "not found"}, code=404)
+
+    def do_GET(self):
+        st = self.server.state
+        if self.path == "/queue":
+            self._send_json(
+                {
+                    "queue_running": st["running"],
+                    "queue_pending": st["pending"],
+                }
+            )
+            return
+        self._send_json({"error": "not found"}, code=404)
+
+
+def _start_fake_server(running, pending):
+    """Levanta el servidor fake en un puerto efimero. Devuelve (server, addr, thread)."""
+    server = http.server.HTTPServer(("127.0.0.1", 0), _FakeComfyHandler)
+    server.state = {"running": list(running), "pending": list(pending)}
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    host, port = server.server_address
+    return server, f"{host}:{port}", thread
+
+
+def _free_port():
+    """Reserva y libera un puerto para garantizar que NADA escucha ahi (error path)."""
+    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    s.bind(("127.0.0.1", 0))
+    port = s.getsockname()[1]
+    s.close()
+    return port
+
+
+def test_interrumpe_sin_vaciar():
+    # Golden: 1 ejecutandose + 2 pendientes; interrupt corta el actual, pendientes siguen.
+    server, addr, _ = _start_fake_server(running=["r1"], pending=["p1", "p2"])
+    try:
+        res = comfyui_interrupt_queue(server=addr)
+    finally:
+        server.shutdown()
+    assert res["ok"] is True
+    assert res["interrupted"] is True
+    assert res["cleared"] is False
+    # running cortado (0) + 2 pendientes que siguen = 2 restantes.
+    assert res["queue_remaining"] == 2
+    assert res["error"] == ""
+
+
+def test_clear_pending_vacia_cola():
+    # Edge: clear_pending vacia los pendientes -> queue_remaining 0.
+    server, addr, _ = _start_fake_server(running=["r1"], pending=["p1", "p2", "p3"])
+    try:
+        res = comfyui_interrupt_queue(clear_pending=True, server=addr)
+    finally:
+        server.shutdown()
+    assert res["ok"] is True
+    assert res["interrupted"] is True
+    assert res["cleared"] is True
+    assert res["queue_remaining"] == 0
+    assert res["error"] == ""
+
+
+def test_clear_pending_cola_vacia_no_rompe():
+    # Edge: clear_pending con la cola ya vacia es inocuo, no rompe.
+    server, addr, _ = _start_fake_server(running=[], pending=[])
+    try:
+        res = comfyui_interrupt_queue(clear_pending=True, server=addr)
+    finally:
+        server.shutdown()
+    assert res["ok"] is True
+    assert res["interrupted"] is True
+    assert res["cleared"] is True
+    assert res["queue_remaining"] == 0
+    assert res["error"] == ""
+
+
+def test_servidor_caido_no_lanza():
+    # Error: nada escucha en el puerto -> {ok:False, error} sin excepcion cruda.
+    dead = f"127.0.0.1:{_free_port()}"
+    res = comfyui_interrupt_queue(server=dead, timeout=1.0)
+    assert res["ok"] is False
+    assert res["interrupted"] is False
+    assert res["error"] != ""
+    assert "interrupt fallo" in res["error"]
+
+
+if __name__ == "__main__":
+    test_interrumpe_sin_vaciar()
+    test_clear_pending_vacia_cola()
+    test_clear_pending_cola_vacia_no_rompe()
+    test_servidor_caido_no_lanza()
+    print("OK: 4 tests passed")

python/functions/ml/tests/test_comfyui_judge_image.py

@@ -0,0 +1,82 @@
+"""Tests offline para comfyui_judge_image (impura: panel multi-juez por mayoria).
+
+Sin GPU, sin red, sin servidor: monkeypatchea los tres jueces (estetico, fidelidad CLIP,
+critico LLM) con stubs para probar la LOGICA de voto, agregacion y exclusion de jueces caidos.
+"""
+
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(__file__))
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", ".."))
+
+import ml.comfyui_judge_image as mod
+from ml.comfyui_judge_image import comfyui_judge_image
+
+
+def _aes(score, ok=True):
+    return lambda image_path, **kw: {"ok": ok, "score_0_10": score, "error": "" if ok else "boom"}
+
+
+def _clip(score, ok=True):
+    return lambda image_path, prompt, **kw: {"ok": ok, "score_0_1": score, "error": "" if ok else "boom"}
+
+
+def _llm(verdict, score=7.0, ok=True):
+    return lambda image_path, prompt, **kw: {
+        "ok": ok, "verdict": verdict, "score_0_10": score,
+        "reasons": ["motivo"], "error": "" if ok else "boom"}
+
+
+def _patch(monkeypatch, aes, clip, llm):
+    monkeypatch.setattr(mod, "comfyui_score_aesthetic", aes)
+    monkeypatch.setattr(mod, "comfyui_score_clip_alignment", clip)
+    monkeypatch.setattr(mod, "comfyui_critique_image_llm", llm)
+
+
+def test_tres_good_verdict_good(monkeypatch):
+    _patch(monkeypatch, _aes(8.0), _clip(0.30), _llm("good"))
+    res = comfyui_judge_image("i.png", "a cat")
+    assert res["ok"] is True and res["verdict"] == "good"
+    assert res["votes"] == {"aesthetic": "good", "clip": "good", "llm": "good"}
+    # score = media de 8, 3.0(=0.30*10), 7 = 6.0
+    assert abs(res["score"] - 6.0) < 1e-9
+
+
+def test_mayoria_bad(monkeypatch):
+    # estetico bajo (bad) + clip bajo (bad) + llm good -> 2 bad, 1 good -> bad.
+    _patch(monkeypatch, _aes(2.0), _clip(0.05), _llm("good"))
+    res = comfyui_judge_image("i.png", "p")
+    assert res["verdict"] == "bad"
+
+
+def test_empate_es_bad_conservador(monkeypatch):
+    # 1 good (estetico) + 1 bad (clip) + 1 failed (llm) -> empate -> bad.
+    _patch(monkeypatch, _aes(8.0), _clip(0.05), _llm("good", ok=False))
+    res = comfyui_judge_image("i.png", "p")
+    assert res["votes"]["llm"] == "failed"
+    assert res["verdict"] == "bad"
+
+
+def test_juez_caido_se_excluye_no_crashea(monkeypatch):
+    # estetico falla pero el panel sigue votando con los otros dos.
+    _patch(monkeypatch, _aes(0.0, ok=False), _clip(0.30), _llm("good"))
+    res = comfyui_judge_image("i.png", "p")
+    assert res["ok"] is True
+    assert res["votes"]["aesthetic"] == "failed"
+    assert res["verdict"] == "good"
+
+
+def test_tres_fallan_ok_false(monkeypatch):
+    _patch(monkeypatch, _aes(0.0, ok=False), _clip(0.0, ok=False), _llm("", ok=False))
+    res = comfyui_judge_image("i.png", "p")
+    assert res["ok"] is False and "los tres jueces fallaron" in res["error"]
+
+
+def test_weights_afectan_score_no_voto(monkeypatch):
+    _patch(monkeypatch, _aes(10.0), _clip(0.30), _llm("good", score=0.0))
+    base = comfyui_judge_image("i.png", "p")
+    # subir el peso del estetico (10) y anular el del llm (0) sube el score agregado.
+    weighted = comfyui_judge_image("i.png", "p", weights={"aesthetic": 5.0, "llm": 0.0})
+    assert weighted["score"] > base["score"]
+    assert weighted["verdict"] == base["verdict"] == "good"

python/functions/ml/tests/test_comfyui_pixelize_image.py

@@ -79,3 +79,69 @@ def test_error_bad_palette(tmp_path):
     res = comfyui_pixelize_image(src, str(tmp_path / "o.png"), palette="not-a-palette")
     assert res["ok"] is False
     assert "paleta" in res["error"].lower()
+
+
+# --- alpha-aware (sprites con fondo transparente) ---
+
+def _rgba_subject_png(path, canvas=256, box=120):
+    """RGBA: sujeto opaco de colores variados centrado, fondo transparente."""
+    rng = np.random.default_rng(3)
+    arr = np.zeros((canvas, canvas, 4), dtype=np.uint8)
+    o = (canvas - box) // 2
+    arr[o:o + box, o:o + box, :3] = rng.integers(0, 256, size=(box, box, 3), dtype=np.uint8)
+    arr[o:o + box, o:o + box, 3] = 255  # sujeto opaco
+    Image.fromarray(arr, "RGBA").save(path)
+    return path
+
+
+def test_alpha_preserved_transparent_corners(tmp_path):
+    """RGBA in -> RGBA out con esquinas transparentes y paleta limitada en lo opaco."""
+    src = _rgba_subject_png(str(tmp_path / "sprite.png"))
+    dst = str(tmp_path / "px.png")
+    res = comfyui_pixelize_image(src, dst, downscale=4, colors=16, upscale_back=False)
+    assert res["ok"] is True, res["error"]
+    assert res["has_alpha"] is True
+    out = Image.open(dst).convert("RGBA")
+    a = np.asarray(out)[..., 3]
+    w, h = out.size
+    # Las 4 esquinas deben ser transparentes (alpha == 0).
+    assert a[0, 0] == 0 and a[0, w - 1] == 0
+    assert a[h - 1, 0] == 0 and a[h - 1, w - 1] == 0
+    # Centro opaco.
+    assert a[h // 2, w // 2] == 255
+    # Colores limitados en la zona opaca.
+    assert res["n_colors_final"] <= 16
+
+
+def test_alpha_off_flattens_to_rgb(tmp_path):
+    """keep_alpha=False sobre RGBA -> sale RGB (sin canal alpha)."""
+    src = _rgba_subject_png(str(tmp_path / "sprite.png"))
+    dst = str(tmp_path / "flat.png")
+    res = comfyui_pixelize_image(src, dst, downscale=4, colors=16, keep_alpha=False)
+    assert res["ok"] is True
+    assert res["has_alpha"] is False
+    assert Image.open(dst).mode != "RGBA"
+
+
+def test_rgb_input_unaffected_by_keep_alpha(tmp_path):
+    """Imagen RGB (sin alpha) con keep_alpha=True sigue saliendo RGB, sin romper."""
+    src = _noisy_png(str(tmp_path / "raw.png"))
+    dst = str(tmp_path / "rgb.png")
+    res = comfyui_pixelize_image(src, dst, downscale=8, colors=16)  # keep_alpha default True
+    assert res["ok"] is True
+    assert res["has_alpha"] is False
+    assert res["n_colors_final"] <= 16
+
+
+def test_error_all_transparent_no_crash(tmp_path):
+    """RGBA toda transparente (rembg sin sujeto): no crashea, 0 colores opacos."""
+    arr = np.zeros((64, 64, 4), dtype=np.uint8)  # alpha 0 en todo
+    src = str(tmp_path / "empty.png")
+    Image.fromarray(arr, "RGBA").save(src)
+    dst = str(tmp_path / "out.png")
+    res = comfyui_pixelize_image(src, dst, downscale=1, colors=16)
+    assert res["ok"] is True, res["error"]
+    assert res["has_alpha"] is True
+    assert res["n_colors_final"] == 0
+    out = np.asarray(Image.open(dst).convert("RGBA"))
+    assert out[..., 3].max() == 0  # sigue toda transparente

python/functions/ml/tests/test_comfyui_read_png_metadata.py

@@ -0,0 +1,80 @@
+"""Tests offline para comfyui_read_png_metadata (impura stdlib: parsea metadata de un PNG ComfyUI).
+
+Sin red, sin GPU, sin servidor: fabrica PNGs con chunk de texto 'prompt' y verifica el parsing.
+"""
+
+import json
+import os
+import sys
+
+import pytest
+
+sys.path.insert(0, os.path.dirname(__file__))
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", ".."))
+
+from ml.comfyui_read_png_metadata import comfyui_read_png_metadata
+
+PIL = pytest.importorskip("PIL")
+from PIL import Image  # noqa: E402
+from PIL.PngImagePlugin import PngInfo  # noqa: E402
+
+
+_PROMPT = {
+    "1": {"class_type": "CheckpointLoaderSimple", "inputs": {"ckpt_name": "model.safetensors"}},
+    "2": {"class_type": "CLIPTextEncode", "inputs": {"text": "a cat on a table"}},
+    "3": {"class_type": "CLIPTextEncode", "inputs": {"text": "blurry, lowres"}},
+    "4": {"class_type": "KSampler", "inputs": {
+        "seed": 42, "steps": 20, "cfg": 7.0, "sampler_name": "euler",
+        "scheduler": "normal", "denoise": 1.0,
+        "positive": ["2", 0], "negative": ["3", 0], "model": ["1", 0], "latent_image": ["5", 0]}},
+}
+
+
+def _png_with_prompt(path, prompt_obj=_PROMPT, text=None):
+    info = PngInfo()
+    info.add_text("prompt", text if text is not None else json.dumps(prompt_obj))
+    Image.new("RGB", (8, 8), (0, 0, 0)).save(path, pnginfo=info)
+    return str(path)
+
+
+def _png_plain(path):
+    Image.new("RGB", (8, 8), (0, 0, 0)).save(path)
+    return str(path)
+
+
+def test_extrae_prompt_y_parametros(tmp_path):
+    res = comfyui_read_png_metadata(_png_with_prompt(tmp_path / "g.png"))
+    assert res["ok"] is True and res["error"] == ""
+    assert res["prompt"] == _PROMPT
+    p = res["parameters"]
+    assert p["seed"] == 42 and p["steps"] == 20 and p["cfg"] == 7.0
+    assert p["sampler_name"] == "euler" and p["scheduler"] == "normal" and p["denoise"] == 1.0
+    assert p["positive"] == "a cat on a table" and p["negative"] == "blurry, lowres"
+    assert p["model"] == "model.safetensors"
+
+
+def test_error_archivo_inexistente(tmp_path):
+    res = comfyui_read_png_metadata(str(tmp_path / "no.png"))
+    assert res["ok"] is False and "no se pudo leer" in res["error"]
+
+
+def test_error_png_sin_chunk_prompt(tmp_path):
+    res = comfyui_read_png_metadata(_png_plain(tmp_path / "plain.png"))
+    assert res["ok"] is False and "no contiene chunk 'prompt'" in res["error"]
+
+
+def test_error_prompt_no_json(tmp_path):
+    res = comfyui_read_png_metadata(_png_with_prompt(tmp_path / "bad.png", text="no soy json {"))
+    assert res["ok"] is False and "no es JSON valido" in res["error"]
+
+
+def test_error_no_es_png(tmp_path):
+    bad = tmp_path / "fake.png"
+    bad.write_bytes(b"esto no es un PNG")
+    res = comfyui_read_png_metadata(str(bad))
+    assert res["ok"] is False and res["error"]
+
+
+def test_determinista(tmp_path):
+    path = _png_with_prompt(tmp_path / "g.png")
+    assert comfyui_read_png_metadata(path) == comfyui_read_png_metadata(path)

python/functions/ml/tests/test_comfyui_resolve_workflow_deps.py

@@ -0,0 +1,49 @@
+"""Tests offline para comfyui_resolve_workflow_deps (impura: compone comfyui_validate_workflow).
+
+Sin red, sin servidor: monkeypatchea comfyui_validate_workflow para probar la traduccion de
+nodos/modelos faltantes en sugerencias accionables y el error path cuando el servidor no responde.
+"""
+
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(__file__))
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", ".."))
+
+import ml.comfyui_resolve_workflow_deps as mod
+from ml.comfyui_resolve_workflow_deps import comfyui_resolve_workflow_deps
+
+_WF = {"1": {"class_type": "CheckpointLoaderSimple", "inputs": {"ckpt_name": "x.safetensors"}}}
+
+
+def test_traduce_nodos_y_modelos_faltantes(monkeypatch):
+    monkeypatch.setattr(mod, "comfyui_validate_workflow", lambda wf, server="": {
+        "ok": True,
+        "missing_nodes": ["FooNode"],
+        "missing_models": [{"node": "1", "input": "ckpt_name", "value": "x.safetensors"}],
+    })
+    res = comfyui_resolve_workflow_deps(_WF)
+    assert res["ok"] is True and res["error"] == ""
+    assert res["missing_nodes"] == ["FooNode"]
+    kinds = {s["kind"] for s in res["suggestions"]}
+    assert kinds == {"node", "model"}
+    node_sug = next(s for s in res["suggestions"] if s["kind"] == "node")
+    assert node_sug["action"] == "install_custom_node" and node_sug["name"] == "FooNode"
+    model_sug = next(s for s in res["suggestions"] if s["kind"] == "model")
+    assert model_sug["action"] == "search_and_download" and model_sug["name"] == "x.safetensors"
+
+
+def test_sin_faltantes_suggestions_vacio(monkeypatch):
+    monkeypatch.setattr(mod, "comfyui_validate_workflow", lambda wf, server="": {
+        "ok": True, "missing_nodes": [], "missing_models": []})
+    res = comfyui_resolve_workflow_deps(_WF)
+    assert res["ok"] is True and res["suggestions"] == []
+
+
+def test_servidor_caido_propaga_error(monkeypatch):
+    monkeypatch.setattr(mod, "comfyui_validate_workflow", lambda wf, server="": {
+        "ok": False, "error": "no se pudo conectar al servidor"})
+    res = comfyui_resolve_workflow_deps(_WF)
+    assert res["ok"] is False
+    assert "no se pudo conectar" in res["error"]
+    assert res["suggestions"] == []

python/functions/ml/tests/test_comfyui_score_aesthetic.py

@@ -0,0 +1,51 @@
+"""Tests offline para comfyui_score_aesthetic (impura: scoring LAION-V2 via subproceso torch).
+
+Sin GPU, sin torch, sin servidor: ejercita SOLO los guards previos al subproceso (imagen,
+python del venv ComfyUI y .pth del modelo ausentes), que cortan antes de tocar la GPU.
+"""
+
+import os
+import sys
+
+import pytest
+
+sys.path.insert(0, os.path.dirname(__file__))
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", ".."))
+
+from ml.comfyui_score_aesthetic import comfyui_score_aesthetic
+
+PIL = pytest.importorskip("PIL")
+from PIL import Image  # noqa: E402
+
+
+def _png(path):
+    Image.new("RGB", (8, 8), (0, 0, 0)).save(path)
+    return str(path)
+
+
+def test_error_imagen_inexistente(tmp_path):
+    res = comfyui_score_aesthetic(str(tmp_path / "no.png"))
+    assert res["ok"] is False and res["score_0_10"] == 0.0
+    assert "imagen no encontrada" in res["error"]
+
+
+def test_error_venv_python_inexistente(tmp_path):
+    # imagen valida pero venv_python ausente -> corta antes del subproceso.
+    res = comfyui_score_aesthetic(_png(tmp_path / "i.png"),
+                                  venv_python=str(tmp_path / "no_python"))
+    assert res["ok"] is False and "python del venv ComfyUI no encontrado" in res["error"]
+
+
+def test_error_modelo_inexistente(tmp_path):
+    # imagen + python validos, .pth ausente -> error de modelo, sin lanzar el subproceso.
+    res = comfyui_score_aesthetic(_png(tmp_path / "i.png"),
+                                  venv_python=sys.executable,
+                                  model_path=str(tmp_path / "no.pth"))
+    assert res["ok"] is False and "modelo estetico no encontrado" in res["error"]
+
+
+def test_nunca_lanza_y_es_determinista(tmp_path):
+    img = _png(tmp_path / "i.png")
+    a = comfyui_score_aesthetic(img, venv_python=str(tmp_path / "x"))
+    b = comfyui_score_aesthetic(img, venv_python=str(tmp_path / "x"))
+    assert a == b and a["ok"] is False

python/functions/ml/tests/test_comfyui_score_clip_alignment.py

@@ -0,0 +1,47 @@
+"""Tests offline para comfyui_score_clip_alignment (impura: similitud CLIP via subproceso torch).
+
+Sin GPU, sin torch, sin servidor: ejercita SOLO los guards previos al subproceso (imagen
+ausente, prompt vacio, python del venv ComfyUI ausente).
+"""
+
+import os
+import sys
+
+import pytest
+
+sys.path.insert(0, os.path.dirname(__file__))
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", ".."))
+
+from ml.comfyui_score_clip_alignment import comfyui_score_clip_alignment
+
+PIL = pytest.importorskip("PIL")
+from PIL import Image  # noqa: E402
+
+
+def _png(path):
+    Image.new("RGB", (8, 8), (0, 0, 0)).save(path)
+    return str(path)
+
+
+def test_error_imagen_inexistente(tmp_path):
+    res = comfyui_score_clip_alignment(str(tmp_path / "no.png"), "a cat")
+    assert res["ok"] is False and res["score_0_1"] == 0.0
+    assert "imagen no encontrada" in res["error"]
+
+
+def test_error_prompt_vacio(tmp_path):
+    res = comfyui_score_clip_alignment(_png(tmp_path / "i.png"), "   ")
+    assert res["ok"] is False and "prompt vacio" in res["error"]
+
+
+def test_error_venv_python_inexistente(tmp_path):
+    res = comfyui_score_clip_alignment(_png(tmp_path / "i.png"), "a cat",
+                                       venv_python=str(tmp_path / "no_python"))
+    assert res["ok"] is False and "python del venv ComfyUI no encontrado" in res["error"]
+
+
+def test_nunca_lanza_y_es_determinista(tmp_path):
+    img = _png(tmp_path / "i.png")
+    a = comfyui_score_clip_alignment(img, "a cat", venv_python=str(tmp_path / "x"))
+    b = comfyui_score_clip_alignment(img, "a cat", venv_python=str(tmp_path / "x"))
+    assert a == b and a["ok"] is False

python/functions/ml/tests/test_crop_to_content.py

@@ -0,0 +1,112 @@
+"""Tests de crop_to_content (offline, sin red ni GPU; PIL/numpy)."""
+
+import os
+import sys
+
+import numpy as np
+from PIL import Image
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from ml.crop_to_content import crop_to_content  # noqa: E402
+
+
+def _rgba_subject_in_corner(canvas=256, box=40, ox=8, oy=8):
+    """RGBA con un rectangulo opaco rojo en una esquina, resto transparente."""
+    arr = np.zeros((canvas, canvas, 4), dtype=np.uint8)
+    arr[oy:oy + box, ox:ox + box, 0] = 220   # R
+    arr[oy:oy + box, ox:ox + box, 3] = 255   # alpha opaco
+    return Image.fromarray(arr, "RGBA")
+
+
+def _rgba_subject_centered(canvas=256, fill_ratio=0.9):
+    """RGBA con un rectangulo opaco que llena ~fill_ratio del lienzo, centrado."""
+    arr = np.zeros((canvas, canvas, 4), dtype=np.uint8)
+    side = int(canvas * fill_ratio)
+    o = (canvas - side) // 2
+    arr[o:o + side, o:o + side, 1] = 200     # G
+    arr[o:o + side, o:o + side, 3] = 255
+    return Image.fromarray(arr, "RGBA")
+
+
+def _rgb_subject_on_bg(canvas=200, box=50, ox=10, oy=10, bg=(255, 255, 255)):
+    """RGB con un cuadrado de color sobre fondo plano (sin alpha)."""
+    arr = np.zeros((canvas, canvas, 3), dtype=np.uint8)
+    arr[:, :] = bg
+    arr[oy:oy + box, ox:ox + box] = (0, 0, 200)  # sujeto azul
+    return Image.fromarray(arr, "RGB")
+
+
+def _alpha_bbox_coverage(img, threshold=10):
+    """Fraccion del lado que ocupa el bbox del contenido (alpha>threshold)."""
+    a = np.asarray(img.convert("RGBA"))[..., 3]
+    ys, xs = np.where(a > threshold)
+    if xs.size == 0:
+        return 0.0
+    bw = xs.max() - xs.min() + 1
+    bh = ys.max() - ys.min() + 1
+    return max(bw, bh) / max(img.size)
+
+
+def test_golden_corner_subject_fills_frame():
+    """Sujeto en la esquina -> tras crop ocupa casi todo el frame (square)."""
+    img = _rgba_subject_in_corner()
+    before = _alpha_bbox_coverage(img)
+    out = crop_to_content(img, pad_ratio=0.06, square=True)
+    after = _alpha_bbox_coverage(out)
+    assert out.mode == "RGBA"
+    assert out.size[0] == out.size[1]          # cuadrado
+    assert before < 0.25                       # antes diminuto
+    assert after >= 0.80                       # despues llena el frame
+
+
+def test_edge_centered_subject_not_overcropped():
+    """Sujeto ya centrado que llena ~90%: la cobertura se mantiene alta, no se rompe."""
+    img = _rgba_subject_centered(fill_ratio=0.9)
+    out = crop_to_content(img, pad_ratio=0.06, square=True)
+    assert out.size[0] == out.size[1]
+    assert _alpha_bbox_coverage(out) >= 0.80
+
+
+def test_edge_rgb_background_bbox():
+    """RGB con fondo plano: detecta el sujeto por diff-fondo y lo cuadra."""
+    img = _rgb_subject_on_bg()
+    out = crop_to_content(img, pad_ratio=0.05, square=True)
+    assert out.mode == "RGB"
+    assert out.size[0] == out.size[1]
+    # El sujeto azul debe ocupar buena parte del lienzo recortado.
+    arr = np.asarray(out)
+    is_subject = (arr[..., 2] > 120) & (arr[..., 0] < 80)
+    cov = is_subject.sum() / (out.size[0] * out.size[1])
+    assert cov >= 0.4
+
+
+def test_edge_no_square_only_crops():
+    """square=False: recorta al bbox + margen, sin forzar cuadrado."""
+    img = _rgba_subject_in_corner(box=40)
+    out = crop_to_content(img, pad_ratio=0.0, square=False)
+    # bbox del sujeto es 40x40 -> sin pad ni cuadrar, sale 40x40.
+    assert out.size == (40, 40)
+
+
+def test_error_all_transparent_returns_copy():
+    """Imagen toda transparente: no crashea, devuelve copia intacta (mismo tamano)."""
+    arr = np.zeros((128, 128, 4), dtype=np.uint8)  # alpha 0 en todo
+    img = Image.fromarray(arr, "RGBA")
+    out = crop_to_content(img)
+    assert out.size == (128, 128)
+    assert np.asarray(out)[..., 3].max() == 0
+
+
+def test_error_none_raises():
+    try:
+        crop_to_content(None)
+        assert False, "deberia lanzar ValueError"
+    except ValueError as e:
+        assert "None" in str(e)
+
+
+def test_does_not_mutate_input():
+    img = _rgba_subject_in_corner()
+    snapshot = np.asarray(img).copy()
+    crop_to_content(img)
+    assert np.array_equal(np.asarray(img), snapshot)

python/functions/ml/tests/test_pixeloe_downscale.py

@@ -0,0 +1,122 @@
+"""Tests de pixeloe_downscale — tolerantes al entorno.
+
+El venv del registry NO trae `pixeloe`, asi que estas pruebas ejercitan el
+"bridge" de interprete (subprocess al python de ComfyUI, que si la tiene). Si
+tampoco hay ningun interprete con pixeloe disponible, la funcion debe degradar
+limpiamente: ok=False con error no vacio y SIN lanzar excepcion.
+
+Por eso cada test PASA en los dos escenarios:
+  - pixeloe disponible (inproc o via bridge): assert sobre el resultado real.
+  - pixeloe ausente en todos lados: assert sobre la degradacion no-throw.
+Asi la suite es verde tanto en este PC (ComfyUI presente) como en uno sin ComfyUI,
+y el contrato "no-throw" queda cubierto en ambos.
+"""
+
+import os
+import sys
+
+import numpy as np
+from PIL import Image
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from ml.pixeloe_downscale import pixeloe_downscale  # noqa: E402
+
+
+def _shapes_png(path, w=256, h=256):
+    """PNG 256x256 RGB con un gradiente + formas (contraste con silueta clara)."""
+    yy, xx = np.mgrid[0:h, 0:w]
+    arr = np.zeros((h, w, 3), dtype=np.uint8)
+    arr[..., 0] = (xx * 255 // max(1, w - 1)).astype(np.uint8)   # gradiente rojo
+    arr[..., 1] = (yy * 255 // max(1, h - 1)).astype(np.uint8)   # gradiente verde
+    # Bloque azul central: borde duro para que el modo "contrast" tenga silueta.
+    arr[h // 4:3 * h // 4, w // 4:3 * w // 4, 2] = 255
+    Image.fromarray(arr, "RGB").save(path)
+    return path
+
+
+def test_golden_downscale_64_or_clean_degrade(tmp_path):
+    """Golden: 256x256 -> grid 64x64 (no_upscale). Si pixeloe no esta -> ok=False limpio."""
+    src = _shapes_png(str(tmp_path / "raw.png"))
+    dst = str(tmp_path / "grid64.png")
+    res = pixeloe_downscale(src, dst, target_size=64, no_upscale=True)
+    assert isinstance(res, dict)
+    if res["ok"]:
+        assert os.path.isfile(dst)
+        assert res["size"] == [64, 64]          # no_upscale=True -> grid real
+        assert res["error"] == ""
+        assert res["via"] in ("inproc", "bridge")
+        assert res["mode"] == "contrast"
+        assert res["target_size"] == 64
+    else:
+        # Degradacion limpia: sin pixeloe en ningun interprete.
+        assert res["error"] != ""
+        assert res["via"] in ("", "bridge", "inproc")
+
+
+def test_edge_target_size_32(tmp_path):
+    """Edge: grid de 32 (iconos). size==[32,32] cuando pixeloe esta presente."""
+    src = _shapes_png(str(tmp_path / "raw.png"))
+    dst = str(tmp_path / "grid32.png")
+    res = pixeloe_downscale(src, dst, target_size=32, no_upscale=True)
+    if res["ok"]:
+        assert res["size"] == [32, 32]
+        assert res["target_size"] == 32
+        assert os.path.isfile(dst)
+    else:
+        assert res["error"] != ""
+
+
+def test_edge_mode_nearest_no_color_matching(tmp_path):
+    """Edge: otro modo + color_matching off; debe seguir produciendo el grid o degradar."""
+    src = _shapes_png(str(tmp_path / "raw.png"))
+    dst = str(tmp_path / "near.png")
+    res = pixeloe_downscale(
+        src, dst, mode="nearest", target_size=64,
+        color_matching=False, no_upscale=True,
+    )
+    assert isinstance(res, dict)
+    if res["ok"]:
+        assert res["mode"] == "nearest"
+        assert res["size"] == [64, 64]
+    else:
+        assert res["error"] != ""
+
+
+def test_error_missing_src_no_throw(tmp_path):
+    """Error path: src inexistente -> ok=False, error explica, sin excepcion."""
+    res = pixeloe_downscale(
+        str(tmp_path / "nope.png"), str(tmp_path / "o.png"), target_size=64,
+    )
+    assert res["ok"] is False
+    assert "no existe" in res["error"]
+    assert res["size"] == [0, 0]
+
+
+def test_error_no_interpreter_with_pixeloe(tmp_path):
+    """Error path: forzar comfy_python invalido cuando el actual no tiene pixeloe.
+
+    Si el interprete que corre el test YA tiene pixeloe (inproc), el comfy_python
+    invalido se ignora y la llamada puede salir ok=True; el test sigue siendo
+    valido (no-throw). Si NO lo tiene, no hay ningun interprete con pixeloe y debe
+    devolver ok=False con error, nunca lanzar.
+    """
+    src = _shapes_png(str(tmp_path / "raw.png"))
+    dst = str(tmp_path / "o.png")
+    res = pixeloe_downscale(
+        src, dst, target_size=64, comfy_python="/no/such/python-interpreter",
+    )
+    assert isinstance(res, dict)
+    try:
+        import pixeloe  # noqa: F401
+        has_local = True
+    except Exception:  # noqa: BLE001
+        has_local = False
+    if has_local:
+        # pixeloe en el interprete del test -> ruta inproc, comfy_python ignorado.
+        assert res["ok"] is True
+    else:
+        # comfy_python invalido + env vacio: si ~/ComfyUI/.venv existe, puede
+        # bridgear y salir ok; si no, ok=False con error. Ambos no-throw.
+        assert res["ok"] in (True, False)
+        if not res["ok"]:
+            assert res["error"] != ""

python/functions/pipelines/comfyui_generate_until_quality.md

@@ -0,0 +1,131 @@
+---
+name: comfyui_generate_until_quality
+kind: pipeline
+lang: py
+domain: pipelines
+version: "1.0.0"
+purity: impure
+signature: "comfyui_generate_until_quality(builder, subject, *, threshold=6.0, clip_threshold=0.24, max_iters=4, strategy='reroll+escalate+refine_prompt', server='127.0.0.1:8188', dest_dir='~/ComfyUI/output', judge_prompt=None, seed=0, refine_model='claude-haiku-4-5-20251001', judge_model='claude-opus-4-8', wait_timeout=300.0, **builder_kwargs) -> dict"
+description: "Loop evaluator-optimizer (GAN sin entrenar): genera una imagen con un builder del registry, la juzga con el panel multi-juez, y si no alcanza la calidad pedida refina (nueva seed, mas calidad, prompt corregido con el feedback del juez) y regenera hasta pasar el umbral o agotar intentos. Siempre devuelve la mejor candidata por score (best-of-N)."
+tags: [comfyui, comfyui-skill, pipeline, launcher, generate, judge, quality-loop, evaluator-optimizer]
+uses_functions:
+  - comfyui_submit_workflow_py_ml
+  - comfyui_wait_result_py_ml
+  - comfyui_fetch_output_image_py_ml
+  - comfyui_judge_image_py_ml
+  - ask_llm_py_core
+uses_types: []
+returns: []
+returns_optional: false
+error_type: error_py_core
+imports: [comfyui_submit_workflow_py_ml, comfyui_wait_result_py_ml, comfyui_fetch_output_image_py_ml, comfyui_judge_image_py_ml, ask_llm_py_core]
+params:
+  - name: builder
+    desc: "Callable o nombre (str) de un builder comfyui_build_*_workflow del registry. El subject se pasa como primer positional (builders de asset: ui_hud, item_icon, enemy_creature...)."
+  - name: subject
+    desc: "Descripcion del elemento a generar (p.ej. 'RPG health and mana bars'). Se inyecta en el builder y, si se refina, se reescribe con el feedback del juez."
+  - name: threshold
+    desc: "Umbral estetico 0-10 que el juez usa para votar good/bad."
+  - name: clip_threshold
+    desc: "Umbral de fidelidad CLIP 0-1 del juez (prompt<->imagen)."
+  - name: max_iters
+    desc: "Numero maximo de iteraciones de generacion."
+  - name: strategy
+    desc: "Tacticas de mejora separadas por '+': reroll (seed nueva), escalate (mas steps/cfg en iters tardias), refine_prompt (reescribe el subject con ask_llm usando las razones del juez)."
+  - name: server
+    desc: "host:port del servidor ComfyUI sin esquema."
+  - name: dest_dir
+    desc: "Directorio local donde guardar los PNG."
+  - name: judge_prompt
+    desc: "Texto que se pasa al juez para medir fidelidad. None = se extrae el positive del workflow construido."
+  - name: seed
+    desc: "Semilla base; los rerolls derivan de ella de forma determinista."
+  - name: refine_model
+    desc: "Modelo de ask_llm para el refine del prompt (barato, haiku por defecto)."
+  - name: judge_model
+    desc: "Modelo del juez critico LLM-vision."
+  - name: wait_timeout
+    desc: "Segundos maximos esperando cada generacion."
+  - name: builder_kwargs
+    desc: "Parametros extra del builder (ui_style, checkpoint, size, transparent...). Solo se pasan los que el builder acepta (filtrados por inspect.signature)."
+output: "dict {ok, converged, best_image_path, best_score, best_verdict, iterations, error}. iterations = lista de {iter, seed, params, score, verdict, reasons, image, error}. converged=True si alguna iteracion logro verdict 'good'. best_* apuntan a la mejor candidata por score aunque ninguna convergiera."
+file_path: "python/functions/pipelines/comfyui_generate_until_quality.py"
+tested: false
+tests: []
+test_file_path: ""
+---
+
+# comfyui_generate_until_quality
+
+Loop **evaluator-optimizer** sobre ComfyUI: el patrón de una GAN (generador vs.
+discriminador) pero **sin entrenar nada**. Un builder genera una imagen, el panel
+multi-juez (`comfyui_judge_image`) la puntúa, y si no llega al umbral el pipeline
+**refina** (nueva seed, más calidad, prompt corregido con las quejas del juez) y
+regenera, hasta converger (`verdict == 'good'`) o agotar `max_iters`. Devuelve
+**siempre la mejor candidata por score** (best-of-N): nunca basura por agotar
+intentos.
+
+Es la promoción a pipeline one-shot (issue 0087) del bucle de mejora del grupo
+`comfyui-skill`: build → submit → wait → fetch → judge → (refine) → repeat.
+
+## Ejemplo
+
+```python
+import sys, json
+sys.path.insert(0, "python/functions")
+from pipelines.comfyui_generate_until_quality import comfyui_generate_until_quality
+
+res = comfyui_generate_until_quality(
+    "comfyui_build_ui_hud_workflow",                 # builder por nombre
+    "RPG health and mana bars, clean game UI",       # subject
+    ui_style="fantasy game UI, clean vector, high contrast, sharp edges",
+    threshold=6.5, max_iters=3,
+    dest_dir="/tmp/comfy_until_quality", transparent=False, seed=1000,
+)
+print(res["converged"], round(res["best_score"], 2), res["best_verdict"])
+print("scores:", [it["score"] for it in res["iterations"]])  # historial subiendo
+print("mejor imagen:", res["best_image_path"])
+```
+
+```bash
+# Lanzar directo (caso HUD del ejemplo __main__)
+~/fn_registry/python/.venv/bin/python3 \
+  python/functions/pipelines/comfyui_generate_until_quality.py
+```
+
+## Cuando usarla
+
+- Cuando pides un asset (HUD, icono, sprite) y la primera generación sale
+  borrosa/floja y quieres que el sistema **itere solo** hasta una versión usable,
+  en vez de re-tirar seeds a mano.
+- Cuando quieres un **gate de calidad objetivo** que devuelva lo mejor de N
+  intentos rankeado por el panel multi-juez, no la primera que salga.
+- Como bloque del bucle reactivo del grupo `comfyui-skill`: un skill no está
+  "hecho" hasta que su imagen pasa el panel; este pipeline es ese bucle.
+
+## Gotchas
+
+- **Impuro**: red (HTTP a ComfyUI), GPU (generación), disco (PNG), API
+  (juez crítico LLM + refine de prompt). Necesita ComfyUI vivo en `server` y el
+  venv de jueces (`~/ComfyUI/.venv`, ver `comfyui-judge`).
+- **El `subject` se pasa como PRIMER positional del builder**. Vale para los
+  builders de asset (`comfyui_build_ui_hud_workflow`, `_item_icon_`,
+  `_enemy_creature_`...), cuyo primer arg es el elemento. NO para
+  `comfyui_build_txt2img_workflow` (primer arg = `ckpt`): para texto crudo, envuélvelo
+  o pasa un builder de asset.
+- **Filtra kwargs con `inspect.signature`**: solo pasa al builder los que acepta,
+  así `escalate` (sube `steps`/`cfg`) y `reroll` (set `seed`) no rompen entre
+  builders con firmas distintas. Si un builder no expone `steps`/`seed`, esa
+  táctica simplemente no aplica en él.
+- **`escalate` sube `steps`+`cfg`**, no inyecta hires-fix (no todos los builders
+  lo soportan y ui_hud lleva Rembg). Para upscale dedicado, usar
+  `comfyui_build_hires_fix_workflow` como builder.
+- **Degrada con gracia**: si el juez cae (HTTP 429) la imagen se conserva con
+  score 0/verdict 'unknown' y el loop sigue; si una iteración falla en
+  submit/wait/fetch se registra su `error` y se reintenta la siguiente. Solo
+  devuelve `ok=False` si NINGUNA iteración produjo imagen.
+- **VRAM (8GB)**: entre familias de generación, liberar con
+  `POST /free {"unload_models":true,"free_memory":true}` si el juez estético
+  (CLIP+LAION en el venv ComfyUI) compite por VRAM con el checkpoint SD.
+- **Determinista en estructura**: nunca lanza excepción cruda; siempre dict de
+  estado. El refine usa `ask_llm` (best-effort): si falla, mantiene el subject.

python/functions/pipelines/comfyui_generate_until_quality.py

@@ -0,0 +1,349 @@
+"""comfyui_generate_until_quality — loop evaluator-optimizer (GAN sin entrenar).
+
+Genera una imagen con un builder del registry, la juzga con el panel multi-juez
+(`comfyui_judge_image`), y si no alcanza la calidad pedida REFINA (nueva seed,
+mas calidad, prompt corregido con el feedback del juez) y regenera, hasta que
+pasa el umbral (`verdict == 'good'`) o se agotan los intentos. Siempre devuelve
+la MEJOR candidata por score (best-of-N): nunca devuelve basura por agotar
+iteraciones.
+
+Es la doctrina del issue 0087 (promover una secuencia repetida a un pipeline
+one-shot) aplicada al bucle de mejora del grupo `comfyui-skill`: build -> submit
+-> wait -> fetch -> judge -> (refine) -> repeat. Compone funciones del registry:
+
+    <builder>_py_ml                       (workflow de nodos en API format)
+    comfyui_submit_workflow_py_ml         (POST /prompt)
+    comfyui_wait_result_py_ml             (poll /history)
+    comfyui_fetch_output_image_py_ml      (GET /view -> disco)
+    comfyui_judge_image_py_ml             (panel estetico + CLIP + critica LLM)
+    ask_llm_py_core                       (refine del prompt con el feedback)
+
+Pipeline impuro: red (HTTP), GPU (generacion), disco (PNG), y API (juez critico
++ refine de prompt). Determinista en estructura: nunca lanza excepcion cruda,
+siempre devuelve un dict de estado.
+"""
+
+from __future__ import annotations
+
+import importlib
+import inspect
+import os
+import sys
+
+# Importa las funciones del registry (mismo arbol python/functions).
+_FUNCTIONS_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if _FUNCTIONS_ROOT not in sys.path:
+    sys.path.insert(0, _FUNCTIONS_ROOT)
+
+from ml.comfyui_fetch_output_image import comfyui_fetch_output_image
+from ml.comfyui_judge_image import comfyui_judge_image
+from ml.comfyui_submit_workflow import comfyui_submit_workflow
+from ml.comfyui_wait_result import comfyui_wait_result
+
+
+# Primo grande para derrochar el espacio de seeds entre rerolls de forma
+# determinista (mismo subject + mismo base_seed -> misma traza de seeds).
+_SEED_STRIDE = 101_117
+
+
+def _resolve_builder(builder):
+    """Devuelve el callable del builder.
+
+    Acepta un callable directo o el nombre de la funcion (string), que se
+    resuelve desde el paquete `ml` (convencion del registry: el modulo se llama
+    igual que la funcion, p.ej. `comfyui_build_ui_hud_workflow`).
+    """
+    if callable(builder):
+        return builder
+    if isinstance(builder, str):
+        mod = importlib.import_module(f"ml.{builder}")
+        return getattr(mod, builder)
+    raise TypeError(
+        f"builder debe ser callable o str (nombre de funcion ml.*), no {type(builder)}"
+    )
+
+
+def _extract_positive_prompt(workflow: dict) -> str:
+    """Extrae el prompt positivo textual del workflow para pasarselo al juez.
+
+    Sigue el input `positive` del KSampler hasta su CLIPTextEncode. Fallback: el
+    CLIPTextEncode con el texto mas largo (heuristica: el positive suele serlo).
+    """
+    if not isinstance(workflow, dict):
+        return ""
+    for node in workflow.values():
+        if not isinstance(node, dict):
+            continue
+        if node.get("class_type") in ("KSampler", "KSamplerAdvanced"):
+            pos = node.get("inputs", {}).get("positive")
+            if isinstance(pos, list) and pos:
+                tgt = workflow.get(str(pos[0]))
+                if isinstance(tgt, dict) and tgt.get("class_type") == "CLIPTextEncode":
+                    txt = tgt.get("inputs", {}).get("text")
+                    if isinstance(txt, str) and txt.strip():
+                        return txt
+    texts = [
+        n["inputs"]["text"]
+        for n in workflow.values()
+        if isinstance(n, dict)
+        and n.get("class_type") == "CLIPTextEncode"
+        and isinstance(n.get("inputs", {}).get("text"), str)
+    ]
+    return max(texts, key=len) if texts else ""
+
+
+def _builder_default(sig: inspect.Signature, name: str, fallback):
+    """Default declarado de un parametro del builder, o el fallback dado."""
+    p = sig.parameters.get(name)
+    if p is None or p.default is inspect.Parameter.empty:
+        return fallback
+    return p.default if isinstance(p.default, (int, float)) else fallback
+
+
+def _refine_subject(subject: str, judge_prompt: str, reasons, model: str) -> str:
+    """Reescribe el subject corrigiendo lo que el juez senalo, via ask_llm.
+
+    Devuelve el subject mejorado (string corto) o el original si el LLM falla.
+    """
+    from core.ask_llm import ask_llm
+
+    complaints = "; ".join(str(r) for r in (reasons or []) if r) or "(sin razones)"
+    system = (
+        "Eres un prompt-engineer de generacion de imagenes. Recibes el SUBJECT de "
+        "una imagen rechazada por un juez de calidad y la lista de quejas del juez. "
+        "Devuelve un SUBJECT mejorado y conciso (una frase, en ingles) que conserve la "
+        "intencion original pero corrija las quejas anadiendo descriptores visuales "
+        "concretos (p.ej. 'clean vector UI, sharp edges, high contrast, crisp lines' "
+        "si era borroso). NO escribas explicaciones, NO uses comillas: responde SOLO "
+        "con el subject mejorado."
+    )
+    user = (
+        f"SUBJECT original: {subject}\n"
+        f"Prompt completo generado: {judge_prompt}\n"
+        f"Quejas del juez: {complaints}\n"
+        "SUBJECT mejorado:"
+    )
+    try:
+        out = ask_llm(user, model=model, system=system, echo=False)
+        out = (out or "").strip().strip('"').strip()
+        return out or subject
+    except Exception:  # noqa: BLE001 — refine es best-effort; nunca rompe el loop.
+        return subject
+
+
+def comfyui_generate_until_quality(
+    builder,
+    subject: str,
+    *,
+    threshold: float = 6.0,
+    clip_threshold: float = 0.24,
+    max_iters: int = 4,
+    strategy: str = "reroll+escalate+refine_prompt",
+    server: str = "127.0.0.1:8188",
+    dest_dir: str = "~/ComfyUI/output",
+    judge_prompt: str | None = None,
+    seed: int = 0,
+    refine_model: str = "claude-haiku-4-5-20251001",
+    judge_model: str = "claude-opus-4-8",
+    wait_timeout: float = 300.0,
+    **builder_kwargs,
+) -> dict:
+    """Genera y refina hasta alcanzar la calidad pedida (o agotar intentos).
+
+    Args:
+        builder: callable o nombre (str) de un builder `comfyui_build_*_workflow`
+            del registry. El `subject` se pasa como PRIMER positional del builder
+            (caso de los builders de asset: ui_hud, item_icon, enemy_creature...,
+            cuyo primer arg es el elemento/sujeto).
+        subject: descripcion del elemento a generar (p.ej. "RPG health and mana
+            bars" para `comfyui_build_ui_hud_workflow`). Se inyecta en el builder
+            y, si se refina, se reescribe con el feedback del juez.
+        threshold: umbral estetico (0-10) que el juez usa para votar good/bad.
+            keyword-only.
+        clip_threshold: umbral de fidelidad CLIP (0-1) del juez. keyword-only.
+        max_iters: numero maximo de iteraciones de generacion. keyword-only.
+        strategy: combinacion de tacticas de mejora separadas por '+':
+            'reroll' (seed nueva cada iter), 'escalate' (mas steps/cfg en iters
+            tardias) y 'refine_prompt' (reescribe el subject con ask_llm usando
+            las razones del juez). keyword-only.
+        server: host:port del servidor ComfyUI (sin esquema). keyword-only.
+        dest_dir: directorio local donde guardar los PNG. keyword-only.
+        judge_prompt: texto que se pasa al juez para medir fidelidad. Si None,
+            se extrae el prompt positivo del workflow construido. keyword-only.
+        seed: semilla base; los rerolls derivan de ella de forma determinista.
+            keyword-only.
+        refine_model: modelo de ask_llm para el refine del prompt (barato).
+        judge_model: modelo del juez critico LLM-vision. keyword-only.
+        wait_timeout: segundos maximos esperando cada generacion. keyword-only.
+        **builder_kwargs: parametros extra del builder (ui_style, checkpoint,
+            size, transparent...). Solo se pasan los que el builder acepta.
+
+    Returns:
+        dict {ok, converged, best_image_path, best_score, best_verdict,
+        iterations, error}. `iterations` es una lista de
+        {iter, seed, params, score, verdict, reasons, image, error}. `converged`
+        True si alguna iteracion logro verdict 'good'. `best_*` apuntan a la
+        candidata de mayor score (aunque ninguna convergiera). Si nada se pudo
+        generar, ok=False y error explica.
+    """
+    parts = {p.strip() for p in str(strategy).split("+") if p.strip()}
+    do_reroll = "reroll" in parts
+    do_escalate = "escalate" in parts
+    do_refine = "refine_prompt" in parts
+
+    try:
+        builder_fn = _resolve_builder(builder)
+    except (ImportError, AttributeError, TypeError) as exc:
+        return {
+            "ok": False, "converged": False, "best_image_path": "",
+            "best_score": None, "best_verdict": "", "iterations": [],
+            "error": f"no se pudo resolver el builder: {exc}",
+        }
+
+    sig = inspect.signature(builder_fn)
+    accepts = set(sig.parameters)
+    base_steps = builder_kwargs.get("steps", _builder_default(sig, "steps", 28))
+    base_cfg = builder_kwargs.get("cfg", _builder_default(sig, "cfg", 7.0))
+    prefix = builder_kwargs.get("filename_prefix", "until_quality")
+
+    dest = os.path.expanduser(dest_dir)
+    subject_cur = subject
+    iterations: list[dict] = []
+    best: dict | None = None
+    converged = False
+
+    for i in range(max(1, int(max_iters))):
+        # --- parametros de esta iteracion segun la estrategia ---
+        cur_seed = (seed + i * _SEED_STRIDE) if do_reroll else seed
+        kw = dict(builder_kwargs)
+        if "seed" in accepts:
+            kw["seed"] = cur_seed
+        if do_escalate and i > 0:
+            if "steps" in accepts:
+                kw["steps"] = int(base_steps) + i * 8  # mas pasos = mas nitidez
+            if "cfg" in accepts:
+                kw["cfg"] = round(min(float(base_cfg) + i * 0.5, 12.0), 2)
+        if "filename_prefix" in accepts:
+            kw["filename_prefix"] = f"{prefix}_i{i}"
+        # Solo pasamos kwargs que el builder acepta (evita TypeError entre builders).
+        kw = {k: v for k, v in kw.items() if k in accepts}
+        params = {
+            "seed": cur_seed,
+            "steps": kw.get("steps", base_steps),
+            "cfg": kw.get("cfg", base_cfg),
+            "subject": subject_cur,
+        }
+
+        rec = {"iter": i, "seed": cur_seed, "params": params, "score": None,
+               "verdict": "", "reasons": [], "image": "", "error": ""}
+
+        # --- build ---
+        try:
+            workflow = builder_fn(subject_cur, **kw)
+        except Exception as exc:  # noqa: BLE001 — registra y reintenta siguiente iter.
+            rec["error"] = f"build fallo: {exc}"
+            iterations.append(rec)
+            continue
+
+        jp = judge_prompt if judge_prompt else _extract_positive_prompt(workflow)
+
+        # --- submit ---
+        try:
+            sub = comfyui_submit_workflow(workflow, server=server)
+            prompt_id = sub["prompt_id"]
+        except (RuntimeError, KeyError) as exc:
+            rec["error"] = f"submit fallo: {exc}"
+            iterations.append(rec)
+            continue
+
+        # --- wait ---
+        try:
+            outputs = comfyui_wait_result(prompt_id, server=server, timeout=wait_timeout)
+        except (TimeoutError, RuntimeError) as exc:
+            rec["error"] = f"wait fallo: {exc}"
+            iterations.append(rec)
+            continue
+
+        # --- localizar el PNG ---
+        img = None
+        for node_out in outputs.values():
+            images = node_out.get("images") if isinstance(node_out, dict) else None
+            if images:
+                img = images[0]
+                break
+        if img is None:
+            rec["error"] = f"el workflow no produjo imagenes (outputs={list(outputs)})"
+            iterations.append(rec)
+            continue
+
+        # --- fetch ---
+        fetched = comfyui_fetch_output_image(
+            img["filename"], subfolder=img.get("subfolder", ""),
+            type_=img.get("type", "output"), server=server, dest_dir=dest,
+        )
+        if not fetched.get("ok"):
+            rec["error"] = f"fetch fallo: {fetched.get('error')}"
+            iterations.append(rec)
+            continue
+        rec["image"] = fetched["path"]
+
+        # --- judge (degrada con gracia si un juez cae) ---
+        try:
+            verdict = comfyui_judge_image(
+                fetched["path"], jp, threshold=threshold,
+                clip_threshold=clip_threshold, server=server, model=judge_model,
+            )
+        except Exception as exc:  # noqa: BLE001 — un juez caido no debe tumbar el loop.
+            verdict = {"ok": False, "verdict": "unknown", "score": 0.0,
+                       "reasons": [f"juez no disponible: {exc}"]}
+
+        rec["score"] = float(verdict.get("score") or 0.0)
+        rec["verdict"] = verdict.get("verdict", "unknown")
+        rec["reasons"] = list(verdict.get("reasons") or [])
+        iterations.append(rec)
+
+        # --- best-of-N: guarda siempre la mejor por score ---
+        if best is None or rec["score"] > best["score"]:
+            best = rec
+
+        # --- convergencia ---
+        if rec["verdict"] == "good":
+            converged = True
+            break
+
+        # --- refine para la siguiente iteracion ---
+        if do_refine and i < max_iters - 1:
+            subject_cur = _refine_subject(subject_cur, jp, rec["reasons"], refine_model)
+
+    if best is None:
+        last_err = iterations[-1]["error"] if iterations else "sin iteraciones"
+        return {
+            "ok": False, "converged": False, "best_image_path": "",
+            "best_score": None, "best_verdict": "", "iterations": iterations,
+            "error": f"ninguna iteracion produjo imagen ({last_err})",
+        }
+
+    return {
+        "ok": True,
+        "converged": converged,
+        "best_image_path": best["image"],
+        "best_score": best["score"],
+        "best_verdict": best["verdict"],
+        "iterations": iterations,
+        "error": "",
+    }
+
+
+if __name__ == "__main__":
+    import json
+
+    res = comfyui_generate_until_quality(
+        "comfyui_build_ui_hud_workflow",
+        "RPG health and mana bars, clean game UI",
+        ui_style="fantasy game UI, clean vector, high contrast",
+        threshold=6.5,
+        max_iters=3,
+        dest_dir="/tmp/comfy_until_quality",
+        transparent=False,
+    )
+    print(json.dumps(res, indent=2))

python/functions/pipelines/comfyui_pixelart_real_oneshot.md

@@ -0,0 +1,164 @@
+---
+name: comfyui_pixelart_real_oneshot
+kind: pipeline
+lang: py
+domain: pipelines
+version: "1.1.0"
+purity: impure
+signature: "def comfyui_pixelart_real_oneshot(subject: str, *, size: int = 64, colors: int = 16, engine: str = \"pixeloe\", palette=None, server: str = \"127.0.0.1:8188\", dest_dir: str = \"~/ComfyUI/output\", seed: int = 0, negative: str | None = None, mode: str = \"contrast\", patch_size: int = 16, thickness: int = 2, fill_frame: bool = True, transparent: bool = True, autocrop: bool = True, crop_pad_ratio: float = 0.06, rembg_model: str = \"u2net\", upscale_preview: int = 512, keep_base: bool = True, comfy_python: str | None = None, wait_timeout: float = 300.0, filename_prefix: str = \"pixelart_real\", **gen_kwargs) -> dict"
+description: "Pipeline one-shot prompt de texto -> sprite pixel-art REAL (grid duro + paleta limitada) en disco, con fondo transparente y sujeto que llena el frame. Materializa el metodo ganador del report 0215, ahora alpha-aware: generar a alta-res con SDXL + LoRA SDXL_pixel-art (rembg recorta el fondo si transparent), AUTOCROP al bbox del contenido + cuadrado (el sujeto llena el frame, no diminuto), downscale contrast-aware con PixelOE (engine=pixeloe, sprites; alpha recombinado aparte porque PixelOE trabaja en RGB) o nearest (tiles), y cuantizacion dura alpha-aware con comfyui_pixelize_image (16 colores libres o paleta fija pico-8/nes/game-boy). Salida PNG RGBA con transparencia real. Sweet-spot 64px personajes, 32px iconos. Fallback automatico pixeloe->nearest. Compone build_pixelart + submit + wait + fetch + crop_to_content + pixeloe_downscale + pixelize_image. Impuro: HTTP + disco."
+tags: [comfyui, gamedev-2d, pixelart, pipelines, sprite, launcher, alpha, transparent, autocrop]
+uses_functions: [comfyui_build_pixelart_workflow_py_ml, comfyui_submit_workflow_py_ml, comfyui_wait_result_py_ml, comfyui_fetch_output_image_py_ml, crop_to_content_py_ml, pixeloe_downscale_py_ml, comfyui_pixelize_image_py_ml]
+uses_types: []
+returns: []
+returns_optional: false
+error_type: error_py_core
+imports: [comfyui_build_pixelart_workflow_py_ml, comfyui_submit_workflow_py_ml, comfyui_wait_result_py_ml, comfyui_fetch_output_image_py_ml, crop_to_content_py_ml, pixeloe_downscale_py_ml, comfyui_pixelize_image_py_ml]
+params:
+  - name: subject
+    desc: "Prompt positivo (lo que se quiere ver: 'pixel art knight, full body, side view'). No puede estar vacio."
+  - name: size
+    desc: "Lado del grid final en pixeles. 64 personajes/sprites, 32 iconos/objetos simples. keyword-only."
+  - name: colors
+    desc: "Numero de colores de la paleta libre (MEDIANCUT) cuando palette es None. keyword-only."
+  - name: engine
+    desc: "'pixeloe' (downscale contrast-aware, sujetos con silueta) o 'nearest' (downscale simple, tiles/texturas). Fallback automatico a nearest si pixeloe falla. keyword-only."
+  - name: palette
+    desc: "None (paleta libre a `colors`), nombre builtin ('pico-8', 'nes', 'game-boy') o lista de hex. Una paleta fija ignora `colors`. keyword-only."
+  - name: server
+    desc: "host:port del servidor ComfyUI (sin esquema). keyword-only."
+  - name: dest_dir
+    desc: "Directorio donde guardar los PNG (se expande ~). keyword-only."
+  - name: seed
+    desc: "Semilla del KSampler. keyword-only."
+  - name: negative
+    desc: "Prompt negativo; None usa el default de build_pixelart (evita blur/gradientes/anti-alias). keyword-only."
+  - name: mode
+    desc: "Modo de downscale de PixelOE ('contrast' SOTA, 'k-centroid', 'nearest', 'center', 'bicubic'); solo con engine='pixeloe'. keyword-only."
+  - name: patch_size
+    desc: "Tamano de patch de PixelOE (default 16). keyword-only."
+  - name: thickness
+    desc: "Grosor del outline expansion de PixelOE (default 2). keyword-only."
+  - name: fill_frame
+    desc: "Si True anade un hint de encuadre al subject para que el sujeto llene el frame (mejor detalle por pixel tras el downscale). keyword-only."
+  - name: transparent
+    desc: "Si True (default) genera con fondo recortado (rembg en el workflow) y produce sprite RGBA con transparencia real. False para tiles/texturas sin alpha (PNG opaco). keyword-only."
+  - name: autocrop
+    desc: "Si True (default) recorta la imagen base al bbox del contenido + cuadrado antes del downscale, para que el sujeto llene el frame (evita el sprite diminuto). Usa el alpha si transparent, o el color de fondo si no. keyword-only."
+  - name: crop_pad_ratio
+    desc: "Margen relativo que deja el autocrop alrededor del sujeto (0.06 = 6% del lado). keyword-only."
+  - name: rembg_model
+    desc: "Modelo Rembg para recortar el fondo ('u2net' general, 'isnet-anime' anime). Solo aplica si transparent. keyword-only."
+  - name: upscale_preview
+    desc: "Si > 0 escribe ademas un PNG re-escalado nearest a ese lado (preview con pixeles duros, p.ej. 512). 0 lo desactiva. keyword-only."
+  - name: keep_base
+    desc: "Si True conserva el PNG base de alta resolucion; si False lo borra tras pixelizar. keyword-only."
+  - name: comfy_python
+    desc: "Ruta al interprete de ComfyUI (con la lib pixeloe); None autodetecta. keyword-only."
+  - name: wait_timeout
+    desc: "Segundos maximos esperando al server. keyword-only."
+  - name: filename_prefix
+    desc: "Prefijo de los archivos de salida. keyword-only."
+  - name: gen_kwargs
+    desc: "Params extra para comfyui_build_pixelart_workflow (width, height, ckpt_name, lora_strength, use_lcm, steps, cfg, ...). keyword-only (**gen_kwargs)."
+output: "dict {ok, out_path, out_path_upscaled, base_path, size, colors_final, engine_used, has_alpha, autocrop_applied, prompt_id, error}. out_path = PNG final size x size (RGBA si transparent); out_path_upscaled = preview re-escalado; has_alpha = True si lleva transparencia; autocrop_applied = True si el autocrop recorto la base; engine_used refleja el fallback (pixeloe->nearest). Si falla, ok=False y error explica en que paso. No-throw."
+tested: false
+tests: []
+test_file_path: ""
+file_path: "python/functions/pipelines/comfyui_pixelart_real_oneshot.py"
+---
+
+## Ejemplo
+
+```bash
+# Sprite de personaje 64px: RGBA transparente + autocrop (sujeto llena el frame).
+./fn run comfyui_pixelart_real_oneshot "pixel art knight, full body, centered"
+```
+
+```python
+import sys, os
+sys.path.insert(0, os.path.join(os.environ["HOME"], "fn_registry", "python", "functions"))
+from pipelines.comfyui_pixelart_real_oneshot import comfyui_pixelart_real_oneshot
+
+# (a) Sprite personaje 64px: fondo transparente + autocrop (defaults).
+res = comfyui_pixelart_real_oneshot(
+    "pixel art knight, full body, centered",
+    size=64, colors=16, engine="pixeloe", seed=42,
+    transparent=True, autocrop=True, dest_dir="~/ComfyUI/output",
+)
+print(res["out_path"], res["colors_final"], res["has_alpha"], res["engine_used"])
+# -> 64px RGBA, ~16 colores, has_alpha=True, esquinas transparentes, sujeto ~88% del frame
+
+# (b) Icono 32px de un item (sprite con alpha).
+res = comfyui_pixelart_real_oneshot(
+    "pixel art sword icon, single object",
+    size=32, colors=16, engine="pixeloe", seed=7,
+)
+
+# (c) Tile sin silueta -> nearest + paleta fija PICO-8, SIN transparencia.
+res = comfyui_pixelart_real_oneshot(
+    "pixel art grass texture tile, top down, seamless",
+    size=64, engine="nearest", palette="pico-8",
+    transparent=False, autocrop=False, fill_frame=False,
+)
+```
+
+## Cuando usarla
+
+Cuando quieres pixel-art **de verdad** (grid duro + paleta limitada, verificable
+por conteo de colores), no la salida cruda de la difusion (que parece pixelada
+pero tiene decenas de miles de colores y bordes con anti-aliasing). Una sola
+llamada hace generar -> recortar -> downscale -> cuantizar. Para **sprites de
+sujeto** (personajes, criaturas, objetos) deja los defaults `transparent=True` +
+`autocrop=True`: salen RGBA con fondo transparente y el sujeto llena el frame. Usa
+`engine="pixeloe"` para conservar la silueta. Para **tiles/texturas/fondos** sin
+contorno usa `engine="nearest"`, `transparent=False`, `autocrop=False` (mas barato,
+CPU puro, sin alpha). 64px es el sweet-spot de personajes; 32px solo para
+iconos/objetos simples.
+
+## Gotchas
+
+- Impuro: requiere el **servidor ComfyUI vivo** en `server` (default
+  `127.0.0.1:8188`) y los modelos instalados (SDXL Juggernaut + LoRA
+  `SDXL_pixel-art` + `SDXL_lcm-lora`). Si esta caido, falla en submit con
+  `ok=False` y el error de conexion (nunca lanza).
+- `engine="pixeloe"` necesita la lib `pixeloe`, que vive en el venv de ComfyUI
+  (no en el del registry). `pixeloe_downscale` hace el puente de interprete
+  automaticamente; si no la encuentra, el pipeline **cae a `nearest`** y lo
+  reporta en `engine_used` + `error` (no aborta).
+- El nodo `PixelOEPixelize+` de ComfyUI_essentials estaba **roto** por un import
+  obsoleto (`pixeloe.pixelize` -> ahora `pixeloe.legacy.pixelize`); por eso el
+  pipeline usa la lib directa via `pixeloe_downscale`, no el nodo del server.
+- `dest_dir` es un **directorio** (se crea si no existe). Los nombres de salida
+  son `<prefix>_<size>px_<engine>_<paleta|qN>.png` y `..._up.png` (preview).
+- Una **paleta fija** (`pico-8`/`nes`/`game-boy`/lista hex) ignora `colors` y
+  puede dar menos colores que `colors` si el sujeto no cubre toda la paleta.
+- Encuadre: si el sujeto ocupa poca area del frame, a 64/32px queda diminuto. Dos
+  mecanismos lo evitan: `fill_frame=True` (hint al prompt) y, sobre todo,
+  `autocrop=True` (default) que recorta al bbox real del contenido + cuadrado tras
+  generar. Con autocrop el sujeto llena ~85-90% del frame aunque el prompt no lo
+  encuadre perfecto.
+- **transparencia (v1.1.0)**: `transparent=True` (default) mete el nodo `Image
+  Rembg` en el workflow (requiere ese custom node en el server) y produce PNG
+  **RGBA**. Las 4 esquinas salen `alpha==0`. Para tiles/fondos opacos: `transparent=False`.
+- **alpha a traves de PixelOE**: PixelOE trabaja en RGB y pierde el alpha; el
+  pipeline downscalea el alpha del recorte por separado (nearest al mismo `size`) y
+  lo recombina sobre el grid antes de cuantizar. Por eso el sprite final conserva la
+  transparencia con `engine="pixeloe"`.
+- Si la generacion sale **toda transparente** (rembg no detecto sujeto), no crashea:
+  el autocrop deja la imagen sin recortar y el resto del pipeline sigue (sprite
+  vacio, `colors_final` bajo). Revisa el `subject` en ese caso.
+- No reintenta el sampler: para mejor toma, varia `seed`.
+
+## Capability growth log
+
+- v1.1.0 (2026-06-28) — sprite-fix: `transparent`/`autocrop`/`crop_pad_ratio`/
+  `rembg_model`. Arregla los 2 bugs reportados: (1) sprite diminuto -> autocrop al
+  bbox del contenido + cuadrado antes del downscale (sujeto pasa de ~48% a ~88% del
+  frame); (2) sin transparencia -> rembg en el workflow + cuantizacion alpha-aware +
+  alpha recombinado tras PixelOE -> PNG RGBA con esquinas alpha==0. Anade
+  `crop_to_content` a la composicion. Verificado en GPU (knight 64px).
+- v1.0.0 (2026-06-28) — pipeline inicial. Materializa el metodo ganador del
+  report 0215 (PixelOE contrast downscale -> cuantizacion dura). Compone
+  build_pixelart + submit + wait + fetch + pixeloe_downscale + pixelize_image
+  (issue 0087).

python/functions/pipelines/comfyui_pixelart_real_oneshot.py

@@ -0,0 +1,387 @@
+"""comfyui_pixelart_real_oneshot — prompt de texto -> sprite pixel-art REAL en disco.
+
+Pipeline one-shot (issue 0087) que materializa el metodo ganador de la
+investigacion (report 0215): la difusion NO sabe pintar pixel-perfect (su salida
+tiene decenas de miles de colores y bordes con anti-aliasing — pixel-art FALSO),
+asi que el pixel-art de verdad es siempre post-proceso en dos ejes: colapsar a un
+grid duro y limitar la paleta. El metodo ganador combina:
+
+  1. Generar a alta resolucion con el look pixel-art (SDXL Juggernaut + LoRA
+     SDXL_pixel-art), via comfyui_build_pixelart_workflow.
+  2. Downscale contrast-aware con PixelOE (pixeloe_downscale): elige el pixel mas
+     representativo de cada zona y engrosa contornos -> silueta legible. Es lo que
+     distingue un sprite reconocible de una mancha. Solo para sujetos con silueta
+     (engine="pixeloe"); para tiles/texturas sin contorno, un downscale nearest
+     simple basta (engine="nearest") y es mas barato.
+  3. Cuantizacion dura con comfyui_pixelize_image (downscale=1): clava la paleta
+     exacta (N colores libres MEDIANCUT, o paleta fija pico-8 / nes / game-boy)
+     sobre el grid ya hecho -> 16 colores exactos + 100% grid duro.
+
+Resultado del combo verificado por PIL: grid duro perfecto + paleta limitada +
+outline nitido. Sweet-spot: 64px personajes/sprites, 32px iconos/objetos simples.
+
+Compone funciones del registry, no reescribe su logica:
+    comfyui_build_pixelart_workflow_py_ml  (workflow SDXL + LoRA pixel-art)
+    comfyui_submit_workflow_py_ml          (POST /prompt)
+    comfyui_wait_result_py_ml              (poll /history)
+    comfyui_fetch_output_image_py_ml       (GET /view -> disco, imagen base)
+    pixeloe_downscale_py_ml                (downscale contrast-aware, engine pixeloe)
+    comfyui_pixelize_image_py_ml           (cuantizacion dura + nearest fallback)
+
+Pipeline impuro: red (HTTP a ComfyUI) + escritura en disco. No-throw: cualquier
+fallo se captura y se devuelve en el dict de estado (campo error).
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+
+# Importa las funciones del registry (mismo arbol python/functions).
+_FUNCTIONS_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if _FUNCTIONS_ROOT not in sys.path:
+    sys.path.insert(0, _FUNCTIONS_ROOT)
+
+from ml.comfyui_build_pixelart_workflow import comfyui_build_pixelart_workflow
+from ml.comfyui_fetch_output_image import comfyui_fetch_output_image
+from ml.comfyui_pixelize_image import comfyui_pixelize_image
+from ml.comfyui_submit_workflow import comfyui_submit_workflow
+from ml.comfyui_wait_result import comfyui_wait_result
+from ml.crop_to_content import crop_to_content
+from ml.pixeloe_downscale import pixeloe_downscale
+
+# Sufijo de encuadre: empuja al sujeto a llenar el frame para que tras el
+# downscale conserve detalle por pixel (gotcha del report: un sujeto que ocupa el
+# 25% del frame queda diminuto a 64px). Solo se anade si no esta ya presente.
+_FRAME_HINT = "full body, centered, fills frame, no margins"
+
+
+def _frame_subject(subject: str, fill_frame: bool) -> str:
+    """Anade el hint de encuadre al subject si fill_frame y no esta ya."""
+    if not fill_frame:
+        return subject
+    low = subject.lower()
+    if "fills frame" in low or "full body" in low or "centered" in low:
+        return subject
+    return f"{subject}, {_FRAME_HINT}"
+
+
+def comfyui_pixelart_real_oneshot(
+    subject: str,
+    *,
+    size: int = 64,
+    colors: int = 16,
+    engine: str = "pixeloe",
+    palette=None,
+    server: str = "127.0.0.1:8188",
+    dest_dir: str = "~/ComfyUI/output",
+    seed: int = 0,
+    negative: str | None = None,
+    mode: str = "contrast",
+    patch_size: int = 16,
+    thickness: int = 2,
+    fill_frame: bool = True,
+    transparent: bool = True,
+    autocrop: bool = True,
+    crop_pad_ratio: float = 0.06,
+    rembg_model: str = "u2net",
+    upscale_preview: int = 512,
+    keep_base: bool = True,
+    comfy_python: str | None = None,
+    wait_timeout: float = 300.0,
+    filename_prefix: str = "pixelart_real",
+    **gen_kwargs,
+) -> dict:
+    """Genera un sprite pixel-art REAL desde un prompt de texto, end-to-end.
+
+    Args:
+        subject: prompt positivo (lo que se quiere ver: "pixel art knight, full
+            body, side view", etc.). No puede estar vacio.
+        size: lado del grid final en pixeles (64 personajes/sprites, 32 iconos).
+            keyword-only.
+        colors: numero de colores de la paleta libre cuando palette es None
+            (cuantizacion MEDIANCUT). keyword-only.
+        engine: "pixeloe" (downscale contrast-aware, para sujetos con silueta:
+            personajes/criaturas/iconos) o "nearest" (downscale nearest simple,
+            mas barato, para tiles/texturas/fondos sin contorno). Si "pixeloe"
+            falla o la lib no esta disponible, cae automaticamente a "nearest" y
+            lo reporta en engine_used. keyword-only.
+        palette: None (paleta libre a `colors`), nombre builtin ("pico-8", "nes",
+            "game-boy") o lista de hex. Una paleta fija ignora `colors`.
+            keyword-only.
+        server: host:port del servidor ComfyUI (sin esquema). keyword-only.
+        dest_dir: directorio donde guardar los PNG (se expande ~). keyword-only.
+        seed: semilla del KSampler. keyword-only.
+        negative: prompt negativo; None usa el default de build_pixelart
+            (evita blur/gradientes/anti-alias). keyword-only.
+        mode: modo de downscale de PixelOE ("contrast" SOTA, "k-centroid",
+            "nearest", "center", "bicubic"); solo aplica con engine="pixeloe".
+            keyword-only.
+        patch_size: tamano de patch de PixelOE (default 16). keyword-only.
+        thickness: grosor del outline expansion de PixelOE (default 2).
+            keyword-only.
+        fill_frame: si True, anade un hint de encuadre al subject para que el
+            sujeto llene el frame (mejor detalle por pixel tras el downscale).
+            keyword-only.
+        transparent: si True (default) genera con fondo recortado (rembg en el
+            workflow) y produce un sprite RGBA con transparencia real. Para
+            tiles/texturas que NO quieren alpha, pasar transparent=False (el sprite
+            sale RGB sobre fondo opaco). keyword-only.
+        autocrop: si True (default) recorta la imagen base al bounding box de su
+            contenido y la cuadra antes del downscale, para que el sujeto llene el
+            frame (evita el sprite diminuto). Usa el alpha si transparent, o el color
+            de fondo si no. keyword-only.
+        crop_pad_ratio: margen relativo que deja el autocrop alrededor del sujeto
+            (0.06 = 6% del lado). keyword-only.
+        rembg_model: modelo Rembg para recortar el fondo ('u2net' general,
+            'isnet-anime' para anime). Solo aplica si transparent. keyword-only.
+        upscale_preview: si > 0, escribe ademas un PNG re-escalado nearest a
+            ese lado (preview con pixeles duros, p.ej. 512). 0 lo desactiva.
+            keyword-only.
+        keep_base: si True conserva el PNG base de alta resolucion; si False lo
+            borra tras pixelizar. keyword-only.
+        comfy_python: ruta al interprete de ComfyUI (con la lib pixeloe); None
+            autodetecta. keyword-only.
+        wait_timeout: segundos maximos esperando al server. keyword-only.
+        filename_prefix: prefijo de los archivos de salida. keyword-only.
+        **gen_kwargs: params extra para comfyui_build_pixelart_workflow
+            (width, height, ckpt_name, lora_strength, use_lcm, steps, cfg, ...).
+
+    Returns:
+        dict con:
+        - ok (bool): True si se produjo el PNG final pixelizado.
+        - out_path (str): ruta del PNG final size x size.
+        - out_path_upscaled (str): ruta del preview re-escalado, o "" si off.
+        - base_path (str): ruta del PNG base de alta resolucion (o "" si se borro).
+        - size (int): lado real del PNG final.
+        - colors_final (int): numero de colores distintos en el resultado (en la
+          zona opaca si es RGBA).
+        - engine_used (str): "pixeloe" o "nearest" (refleja el fallback).
+        - has_alpha (bool): True si el PNG final es RGBA con transparencia.
+        - autocrop_applied (bool): True si el autocrop recorto la imagen base.
+        - prompt_id (str): id del trabajo en ComfyUI.
+        - error (str): mensaje de error; vacio si OK.
+    """
+    out = {
+        "ok": False, "out_path": "", "out_path_upscaled": "", "base_path": "",
+        "size": int(size), "colors_final": 0, "engine_used": engine,
+        "has_alpha": False, "autocrop_applied": False,
+        "prompt_id": "", "error": "",
+    }
+
+    if not subject or not subject.strip():
+        out["error"] = "subject vacio"
+        return out
+    if int(size) < 1:
+        out["error"] = f"size debe ser >= 1, recibido {size!r}"
+        return out
+    if engine not in ("pixeloe", "nearest"):
+        out["error"] = f"engine invalido: {engine!r} (usa 'pixeloe' o 'nearest')"
+        return out
+
+    dest = os.path.expanduser(dest_dir)
+    try:
+        os.makedirs(dest, exist_ok=True)
+    except OSError as exc:
+        out["error"] = f"no se pudo crear dest_dir {dest!r}: {exc}"
+        return out
+
+    # --- Fase 1: generar la imagen base de alta resolucion (look pixel-art) ---
+    positive = _frame_subject(subject, fill_frame)
+    try:
+        if negative is None:
+            workflow = comfyui_build_pixelart_workflow(
+                positive, seed=seed, transparent=bool(transparent),
+                rembg_model=rembg_model,
+                filename_prefix=f"{filename_prefix}_base", **gen_kwargs,
+            )
+        else:
+            workflow = comfyui_build_pixelart_workflow(
+                positive, negative, seed=seed, transparent=bool(transparent),
+                rembg_model=rembg_model,
+                filename_prefix=f"{filename_prefix}_base", **gen_kwargs,
+            )
+    except (ValueError, TypeError) as exc:
+        out["error"] = f"build workflow fallo: {exc}"
+        return out
+
+    try:
+        sub = comfyui_submit_workflow(workflow, server=server)
+        prompt_id = sub["prompt_id"]
+        out["prompt_id"] = prompt_id
+    except (RuntimeError, KeyError, OSError) as exc:
+        out["error"] = f"submit fallo (server {server} responde?): {exc}"
+        return out
+
+    try:
+        outputs = comfyui_wait_result(prompt_id, server=server, timeout=wait_timeout)
+    except (TimeoutError, RuntimeError, OSError) as exc:
+        out["error"] = f"wait fallo: {exc}"
+        return out
+
+    img = None
+    for node_out in outputs.values():
+        images = node_out.get("images") if isinstance(node_out, dict) else None
+        if images:
+            img = images[0]
+            break
+    if img is None:
+        out["error"] = f"el workflow no produjo imagenes (outputs={list(outputs)})"
+        return out
+
+    fetched = comfyui_fetch_output_image(
+        img["filename"], subfolder=img.get("subfolder", ""),
+        type_=img.get("type", "output"), server=server, dest_dir=dest,
+    )
+    if not fetched.get("ok"):
+        out["error"] = f"fetch de imagen base fallo: {fetched.get('error')}"
+        return out
+    base_path = fetched["path"]
+    out["base_path"] = base_path
+
+    # --- Fase 1b (opcional): autocrop al contenido + cuadrar (sujeto llena el frame). ---
+    # La imagen sobre la que se hace el downscale: la recortada si autocrop, o la base.
+    pre_ds_path = base_path
+    crop_path = ""
+    if autocrop:
+        crop_path = os.path.join(dest, f"{filename_prefix}_{size}px_crop.png")
+        try:
+            from PIL import Image
+            with Image.open(base_path) as base_im:
+                src_im = base_im.convert("RGBA") if transparent else base_im.convert("RGB")
+                before = src_im.size
+                cropped = crop_to_content(
+                    src_im, pad_ratio=float(crop_pad_ratio), square=True,
+                )
+            cropped.save(crop_path)
+            pre_ds_path = crop_path
+            out["autocrop_applied"] = cropped.size != before
+        except (ImportError, OSError, ValueError) as exc:
+            # Autocrop es best-effort: si falla, se sigue con la base sin recortar.
+            crop_path = ""
+            pre_ds_path = base_path
+            if not out["error"]:
+                out["error"] = f"autocrop fallo (no critico): {exc}"
+
+    # --- Fase 2a: downscale a un grid `size` x `size` (mid). ---
+    mid_path = os.path.join(dest, f"{filename_prefix}_{size}px_mid.png")
+    engine_used = engine
+
+    if engine == "pixeloe":
+        ds = pixeloe_downscale(
+            pre_ds_path, mid_path, mode=mode, target_size=int(size),
+            patch_size=patch_size, thickness=thickness, no_upscale=True,
+            comfy_python=comfy_python,
+        )
+        if not ds.get("ok"):
+            # Fallback limpio: PixelOE no disponible / fallo -> nearest.
+            engine_used = "nearest"
+            out["error"] = (
+                f"pixeloe fallo ({ds.get('error')}); fallback a nearest"
+            )
+
+    if engine_used == "nearest":
+        # Downscale nearest simple a size x size (PIL en el venv del registry).
+        # nearest preserva el alpha por canal: si transparent, conserva la silueta.
+        try:
+            from PIL import Image
+            with Image.open(pre_ds_path) as src:
+                target_mode = "RGBA" if transparent else "RGB"
+                small = src.convert(target_mode).resize(
+                    (int(size), int(size)), Image.NEAREST
+                )
+                small.save(mid_path)
+        except (ImportError, OSError) as exc:
+            out["error"] = f"downscale nearest fallo: {exc}"
+            return out
+
+    if not os.path.isfile(mid_path):
+        out["error"] = "no se genero la imagen intermedia (mid)"
+        return out
+
+    # --- Fase 2a-bis: recombinar alpha tras pixeloe (PixelOE trabaja en RGB). ---
+    # El nucleo de PixelOE convierte a RGB: el grid `mid` sale sin transparencia. Se
+    # downscalea el alpha de la imagen pre-downscale por separado (nearest al mismo
+    # size) y se reaplica al grid para no perder el recorte ni la transparencia.
+    if transparent and engine_used == "pixeloe":
+        try:
+            from PIL import Image
+            with Image.open(pre_ds_path) as src_im:
+                alpha = src_im.convert("RGBA").getchannel("A").resize(
+                    (int(size), int(size)), Image.NEAREST
+                )
+            with Image.open(mid_path) as mid_im:
+                mid_rgba = mid_im.convert("RGBA")
+                mid_rgba.putalpha(alpha)
+                mid_rgba.save(mid_path)
+        except (ImportError, OSError) as exc:
+            if not out["error"]:
+                out["error"] = f"recombinacion de alpha fallo (no critico): {exc}"
+
+    # --- Fase 2b: cuantizacion dura (paleta exacta) sobre el grid ya hecho. ---
+    final_tag = palette if isinstance(palette, str) else f"q{colors}"
+    final_path = os.path.join(
+        dest, f"{filename_prefix}_{size}px_{engine_used}_{final_tag}.png"
+    )
+    quant = comfyui_pixelize_image(
+        mid_path, final_path, downscale=1, colors=int(colors),
+        palette=palette, upscale_back=False, keep_alpha=bool(transparent),
+    )
+    if not quant.get("ok"):
+        out["error"] = f"cuantizacion fallo: {quant.get('error')}"
+        return out
+
+    out["out_path"] = final_path
+    out["size"] = quant["size"][0] if quant.get("size") else int(size)
+    out["colors_final"] = quant.get("n_colors_final", 0)
+    out["has_alpha"] = bool(quant.get("has_alpha", False))
+    out["engine_used"] = engine_used
+
+    # --- Fase 3 (opcional): preview re-escalado nearest a pixeles duros. ---
+    if int(upscale_preview) > 0:
+        up_path = os.path.join(
+            dest, f"{filename_prefix}_{size}px_{engine_used}_{final_tag}_up.png"
+        )
+        try:
+            from PIL import Image
+            with Image.open(final_path) as fin:
+                prev_mode = "RGBA" if transparent else "RGB"
+                up = fin.convert(prev_mode).resize(
+                    (int(upscale_preview), int(upscale_preview)), Image.NEAREST
+                )
+                up.save(up_path)
+            out["out_path_upscaled"] = up_path
+        except (ImportError, OSError) as exc:
+            # El preview es opcional: no invalida el resultado.
+            out["out_path_upscaled"] = ""
+            if not out["error"]:
+                out["error"] = f"preview upscale fallo (no critico): {exc}"
+
+    # Limpieza de intermedios (mid + crop temporal).
+    for tmp in (mid_path, crop_path):
+        if tmp:
+            try:
+                os.remove(tmp)
+            except OSError:
+                pass
+    if not keep_base:
+        try:
+            os.remove(base_path)
+            out["base_path"] = ""
+        except OSError:
+            pass
+
+    out["ok"] = True
+    return out
+
+
+if __name__ == "__main__":
+    import json
+
+    res = comfyui_pixelart_real_oneshot(
+        "pixel art knight, full body, centered, game sprite",
+        size=64, colors=16, engine="pixeloe", seed=42,
+        transparent=True, autocrop=True,
+        dest_dir="/tmp/comfy_pixelart_real",
+    )
+    print(json.dumps(res, indent=2))

python/functions/pipelines/comfyui_walk_cycle_oneshot.md

@@ -0,0 +1,110 @@
+---
+name: comfyui_walk_cycle_oneshot
+kind: pipeline
+lang: py
+domain: pipelines
+version: "1.0.0"
+purity: impure
+signature: "def comfyui_walk_cycle_oneshot(character: str, *, frames: int = 4, size: int = 32, colors: int = 16, fps: int = 8, checkpoint: str = 'IMG_dreamshaper_8.safetensors', ref_image: str | None = None, server: str = '127.0.0.1:8188', dest_dir: str = '~/ComfyUI/output', seed: int = 0, pose_method: str = 'auto', controlnet_strength: float = 0.7, engine: str = 'pixeloe', palette=None, fmt: str = 'webp', **gen_kwargs) -> dict"
+description: "Pipeline one-shot: de un prompt de personaje a una animacion de walk cycle en pixel-art (sprite sheet + GIF/WEBP en loop). Genera N frames frame-by-frame dirigidos por pose (ControlNet OpenPose con esqueletos del walk cycle, o fase del paso por prompt como fallback), con seed fija para identidad consistente y Rembg para alpha, y pixeliza cada frame a un grid duro size x size RGBA. Materializa el caso 1 de la investigacion de animacion de sprites (report 0217): personaje = frame-by-frame pose-driven, NUNCA modelos de video. Compone render_openpose_walk_skeletons + comfyui_build_sprite_sheet_workflow + submit/wait/fetch + comfyui_pixelize_sprite_png + assemble_animated_sprite. Impuro: red + GPU + disco. No-throw, salta frames que fallan."
+tags: [gamedev-2d, comfyui, pixelart, sprite, animation, walk-cycle, controlnet, openpose, launcher]
+uses_functions: ["render_openpose_walk_skeletons_py_ml", "comfyui_build_sprite_sheet_workflow_py_ml", "comfyui_submit_workflow_py_ml", "comfyui_wait_result_py_ml", "comfyui_fetch_output_image_py_ml", "comfyui_pixelize_sprite_png_py_ml", "assemble_animated_sprite_py_ml"]
+uses_types: []
+returns: []
+returns_optional: false
+error_type: "error_go_core"
+imports: ["os", "sys"]
+params:
+  - name: character
+    desc: "Prompt del personaje (ej. 'pixel art knight, full body, side view'). No vacio. La identidad se mantiene entre frames con seed fija."
+  - name: frames
+    desc: "Numero de frames del ciclo (>=2, recomendado 4-8). 4 = las 4 fases canonicas contact-L / passing / contact-R / passing."
+  - name: size
+    desc: "Lado del grid pixel-art final por frame en pixeles (32 sprites pequenos, 64 personajes con mas detalle)."
+  - name: colors
+    desc: "Numero de colores de la paleta libre por frame (cuantizacion MEDIANCUT) cuando palette es None."
+  - name: fps
+    desc: "Cadencia de la animacion en frames por segundo (duration = 1000/fps ms por frame)."
+  - name: checkpoint
+    desc: "Checkpoint SD1.5 (ControlNet OpenPose + IPAdapter-FaceID solo instalados en SD1.5; default 'IMG_dreamshaper_8.safetensors')."
+  - name: ref_image
+    desc: "Imagen de cara de referencia en el input/ del servidor para IPAdapter-FaceID (segunda ancla de identidad). None = solo seed + prompt."
+  - name: server
+    desc: "host:port del servidor ComfyUI (sin esquema). Default 127.0.0.1:8188."
+  - name: dest_dir
+    desc: "Directorio donde guardar frames + sprite sheet + animacion (se expande ~)."
+  - name: seed
+    desc: "Semilla FIJA del KSampler para TODOS los frames (identidad estable entre poses)."
+  - name: pose_method
+    desc: "'openpose' (esqueletos OpenPose -> ControlNet, control exacto), 'prompt' (fase del paso descrita en el prompt, sin esqueletos) o 'auto' (intenta openpose, cae a prompt si el render falla)."
+  - name: controlnet_strength
+    desc: "Fuerza del ControlNet OpenPose (0.7 da buen control sin aplastar el estilo). Solo aplica en modo openpose."
+  - name: engine
+    desc: "Motor de downscale del pixelizado: 'pixeloe' (contrast-aware, conserva silueta) o 'nearest'."
+  - name: palette
+    desc: "None (paleta libre a colors), nombre builtin ('pico-8','nes','game-boy') o lista de hex. Fija ignora colors."
+  - name: fmt
+    desc: "Formato de la animacion: 'webp' (recomendado, alpha real) o 'gif' (alpha binario)."
+output: "dict {ok, frames:[paths], spritesheet_path, animation_path, size, n_frames, seed, pose_method_used, skipped:[idx], error}. ok=True si se produjo la animacion con >=1 frame. n_frames puede ser < frames si alguno fallo (se salta y se sigue)."
+tested: false
+tests: []
+test_file_path: ""
+file_path: "python/functions/pipelines/comfyui_walk_cycle_oneshot.py"
+---
+
+## Ejemplo
+
+```python
+import sys, os
+sys.path.insert(0, os.path.join("python", "functions"))
+from pipelines.comfyui_walk_cycle_oneshot import comfyui_walk_cycle_oneshot
+
+# Requiere el servidor ComfyUI vivo en 127.0.0.1:8188 (GPU).
+res = comfyui_walk_cycle_oneshot(
+    "pixel art knight, full body, side view",
+    frames=4, size=32, colors=16, fps=8, seed=42,
+    dest_dir="/tmp/comfy_walk_cycle",
+)
+print(res["ok"], res["n_frames"], res["animation_path"], res["pose_method_used"])
+# -> True 4 /tmp/comfy_walk_cycle/walk_cycle.webp openpose
+```
+
+## Cuando usarla
+
+Cuando quieras una animacion de un personaje en pixel-art (caminar, correr) lista
+para un juego 2D, en un solo paso: das el prompt del personaje y recibes el sprite
+sheet + el GIF/WEBP en loop. Es la promocion a pipeline (issue 0087) de la receta
+del caso 1 del report 0217 — el camino correcto para sprites limpios de personaje
+con alpha, frente a AnimateDiff o modelos de video (que ensucian el alpha y no
+clavan la pose). Para una sola pose estatica usa `comfyui_pixelart_real_oneshot`;
+para varias vistas direccionales (8-way) usa
+`comfyui_build_directional_sprite_workflow`.
+
+## Gotchas
+
+- **Server vivo + GPU**: requiere ComfyUI en `server` con la GPU libre. El report
+  recomienda `POST /free` antes de cargas pesadas de modelo. Cada frame reusa el
+  mismo checkpoint, asi que el modelo solo se carga una vez.
+- **Poses OpenPose**: en modo `openpose` los esqueletos se escriben en el `input/`
+  del servidor (asume server local; para un server remoto haria falta subirlos con
+  `POST /upload/image`). Si el ControlNet no produce variacion de piernas
+  reconocible, usa `pose_method="prompt"`: a 32x32 el detalle de pose se simplifica
+  y la fase del paso por prompt + seed fija da un walk reconocible.
+- **Identidad**: la `seed` es FIJA para todos los frames — esa es la ancla de
+  identidad. Cambiar la seed entre frames rompe la consistencia del personaje.
+  `ref_image` (IPAdapter-FaceID) es una segunda ancla opcional; sobre un sprite de
+  cuerpo entero pequeno aporta sobre todo paleta/ropa (ver report 0217).
+- **No-throw, salta frames**: si un frame falla (red, GPU, build) se anade a
+  `skipped` y la animacion se monta con los que queden. ok=False solo si NINGUN
+  frame sale.
+- **Loop suave**: con `frames=4` el ciclo (contact-L, passing, contact-R, passing)
+  ya cierra el bucle — el frame siguiente al ultimo vuelve a la primera fase.
+- **WEBP vs GIF**: `fmt="webp"` conserva alpha real (lossless); `fmt="gif"` solo
+  tiene alpha binario (1 bit). Para sprites con transparencia, usa WEBP.
+
+## Capability growth log
+
+- v1.0.0 (2026-06-28) — version inicial. Caso 1 del report 0217 promovido a
+  pipeline one-shot: walk cycle pixel-art con poses OpenPose (o fallback prompt),
+  seed fija para identidad, Rembg para alpha, pixelizado a NxN RGBA, sprite sheet +
+  WEBP/GIF en loop.

python/functions/pipelines/comfyui_walk_cycle_oneshot.py

@@ -0,0 +1,362 @@
+"""comfyui_walk_cycle_oneshot — personaje andando -> sprite pixel-art animado (GIF/WEBP).
+
+Pipeline one-shot (issue 0087) que materializa el caso 1 de la investigacion de
+animacion de sprites (report 0217): un ciclo de caminar de personaje se anima
+**frame-by-frame dirigido por pose**, NO con modelos de video. Por cada fase del
+paso se genera el MISMO personaje cambiando solo la pose (ControlNet OpenPose +
+seed fija + IPAdapter opcional), se recorta el fondo a alpha (Rembg) y se pixeliza
+a un grid duro de `size` x `size` RGBA. Los N frames se ensamblan en un sprite
+sheet horizontal + una animacion en loop (WEBP/GIF).
+
+Dos metodos para las poses, seleccionables con `pose_method`:
+  - "openpose" (preferido): se dibujan N esqueletos OpenPose del walk cycle
+    (render_openpose_walk_skeletons) y se alimentan al ControlNet OpenPose, un
+    frame por pose. El timing del paso es exactamente el dibujado.
+  - "prompt" (fallback): sin esqueletos, la fase del paso se describe en el prompt
+    ("left leg forward", "passing pose", ...) con seed fija. A 32x32 el detalle de
+    pose se simplifica, asi que un walk de 4 frames reconocible basta. Se usa
+    cuando el ControlNet no da poses utilizables o el caller lo pide.
+  - "auto" (default): intenta "openpose"; si el render de esqueletos falla, cae a
+    "prompt" y lo refleja en pose_method_used.
+
+La identidad consistente entre frames se ancla con **seed fija** (mismo personaje,
+misma semilla) + prompt base fijo, y opcionalmente con `ref_image` (IPAdapter-FaceID
+en comfyui_build_sprite_sheet_workflow).
+
+Compone funciones del registry, no reescribe su logica:
+    render_openpose_walk_skeletons_py_ml    (esqueletos OpenPose del walk cycle)
+    comfyui_build_sprite_sheet_workflow_py_ml(1 frame: identidad + pose + alpha)
+    comfyui_submit_workflow_py_ml            (POST /prompt)
+    comfyui_wait_result_py_ml                (poll /history)
+    comfyui_fetch_output_image_py_ml         (GET /view -> disco)
+    comfyui_pixelize_sprite_png_py_ml        (PNG alta-res -> NxN RGBA pixel-art)
+    assemble_animated_sprite_py_ml           (frames -> sprite sheet + WEBP/GIF loop)
+
+Pipeline impuro: red (HTTP a ComfyUI), GPU (generacion), escritura en disco.
+No-throw: cualquier fallo se captura y viaja en el dict de estado (campo error).
+Si un frame concreto falla se salta y la animacion se monta con los que haya.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+
+# Importa las funciones del registry (mismo arbol python/functions).
+_FUNCTIONS_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if _FUNCTIONS_ROOT not in sys.path:
+    sys.path.insert(0, _FUNCTIONS_ROOT)
+
+from ml.assemble_animated_sprite import assemble_animated_sprite
+from ml.comfyui_build_sprite_sheet_workflow import comfyui_build_sprite_sheet_workflow
+from ml.comfyui_fetch_output_image import comfyui_fetch_output_image
+from ml.comfyui_pixelize_sprite_png import comfyui_pixelize_sprite_png
+from ml.comfyui_submit_workflow import comfyui_submit_workflow
+from ml.comfyui_wait_result import comfyui_wait_result
+from ml.render_openpose_walk_skeletons import render_openpose_walk_skeletons
+
+# Descriptores de fase del paso para el modo "prompt" (y como apoyo). El ciclo
+# canonico de 4 fases de un walk lateral: contacto pierna izquierda, paso (piernas
+# juntas, cuerpo arriba), contacto pierna derecha, paso. Para N != 4 se reparten
+# ciclicamente sobre estas cuatro.
+_WALK_PHASES = [
+    "walking, left leg forward, mid stride, dynamic walk pose",
+    "walking, legs together passing position, standing tall",
+    "walking, right leg forward, mid stride, dynamic walk pose",
+    "walking, legs together passing position, standing tall",
+]
+
+
+def _phase_for(index: int, total: int) -> str:
+    """Devuelve el descriptor de fase del paso para el frame `index` de `total`.
+
+    Mapea el frame al ciclo de 4 fases base de forma uniforme, de modo que el
+    primer y el ultimo frame cierren un loop continuo (el frame `total` volveria a
+    la fase del frame 0).
+    """
+    pos = (index / max(1, total)) * len(_WALK_PHASES)
+    return _WALK_PHASES[int(pos) % len(_WALK_PHASES)]
+
+
+def comfyui_walk_cycle_oneshot(
+    character: str,
+    *,
+    frames: int = 4,
+    size: int = 32,
+    colors: int = 16,
+    fps: int = 8,
+    checkpoint: str = "IMG_dreamshaper_8.safetensors",
+    ref_image: str | None = None,
+    server: str = "127.0.0.1:8188",
+    dest_dir: str = "~/ComfyUI/output",
+    seed: int = 0,
+    pose_method: str = "auto",
+    comfy_input_dir: str = "~/ComfyUI/input",
+    controlnet_strength: float = 0.7,
+    controlnet_end: float = 0.8,
+    facing: str = "right",
+    engine: str = "pixeloe",
+    palette=None,
+    fmt: str = "webp",
+    negative: str = "blurry, lowres, extra limbs, deformed, multiple characters",
+    width: int = 512,
+    height: int = 768,
+    steps: int = 24,
+    cfg: float = 7.0,
+    comfy_python: str | None = None,
+    wait_timeout: float = 300.0,
+    filename_prefix: str = "walk_cycle",
+    keep_frames: bool = True,
+    **gen_kwargs,
+) -> dict:
+    """Genera una animacion de personaje andando en pixel-art, end-to-end.
+
+    Args:
+        character: prompt del personaje ("pixel art knight, full body, side view").
+            No puede estar vacio. La identidad se mantiene entre frames con seed fija.
+        frames: numero de frames del ciclo (>=2, recomendado 4-8). keyword-only.
+        size: lado del grid pixel-art final por frame en pixeles (32 sprites
+            pequenos, 64 personajes con mas detalle). keyword-only.
+        colors: numero de colores de la paleta libre por frame (cuantizacion
+            MEDIANCUT) cuando palette es None. keyword-only.
+        fps: cadencia de la animacion en frames por segundo. keyword-only.
+        checkpoint: checkpoint SD1.5 (ControlNet OpenPose + IPAdapter-FaceID solo
+            instalados en SD1.5; default 'IMG_dreamshaper_8.safetensors'). keyword-only.
+        ref_image: imagen de cara de referencia en el input/ del servidor para
+            IPAdapter-FaceID (segunda ancla de identidad). None usa solo seed +
+            prompt. keyword-only.
+        server: host:port del servidor ComfyUI (sin esquema). keyword-only.
+        dest_dir: directorio donde guardar frames + sprite sheet + animacion.
+            keyword-only.
+        seed: semilla FIJA del KSampler para todos los frames (identidad estable).
+            keyword-only.
+        pose_method: "openpose" (esqueletos OpenPose -> ControlNet, control exacto),
+            "prompt" (fase del paso descrita en el prompt, sin esqueletos), o "auto"
+            (intenta openpose, cae a prompt si el render falla). keyword-only.
+        comfy_input_dir: directorio input/ del servidor ComfyUI donde se escriben
+            los esqueletos para que el ControlNet los lea (server local).
+            keyword-only.
+        controlnet_strength: fuerza del ControlNet OpenPose (0.7 da buen control de
+            la pose sin aplastar el estilo). keyword-only.
+        controlnet_end: fraccion de pasos en que el OpenPose deja de aplicarse
+            (end<1.0 libera los ultimos pasos para pelo/ropa). keyword-only.
+        facing: direccion a la que mira el personaje en los esqueletos ("right" o
+            "left"). keyword-only.
+        engine: motor de downscale del pixelizado ("pixeloe" contrast-aware o
+            "nearest"). keyword-only.
+        palette: None (paleta libre a `colors`), nombre builtin ("pico-8", "nes",
+            "game-boy") o lista de hex. keyword-only.
+        fmt: formato de la animacion ("webp" recomendado para alpha, o "gif").
+            keyword-only.
+        negative: prompt negativo de generacion. keyword-only.
+        width, height: resolucion de generacion por frame (512x768 vertical encuadra
+            cuerpo entero). keyword-only.
+        steps, cfg: parametros del KSampler. keyword-only.
+        comfy_python: interprete con pixeloe para el pixelizado (None autodetecta
+            ~/ComfyUI/.venv). keyword-only.
+        wait_timeout: segundos maximos esperando cada frame al server. keyword-only.
+        filename_prefix: prefijo de los archivos de salida. keyword-only.
+        keep_frames: si True conserva los PNG de cada frame pixelizado; si False los
+            borra tras montar la animacion. keyword-only.
+        **gen_kwargs: params extra para comfyui_build_sprite_sheet_workflow
+            (sampler_name, scheduler, char_lora, lora_strength, weight, ...).
+
+    Returns:
+        dict con:
+        - ok (bool): True si se produjo la animacion con >=1 frame.
+        - frames (list[str]): rutas de los PNG pixelizados (size x size RGBA).
+        - spritesheet_path (str): ruta del sprite sheet horizontal.
+        - animation_path (str): ruta de la animacion WEBP/GIF en loop.
+        - size (int): lado real de cada frame pixelizado.
+        - n_frames (int): numero de frames producidos (puede ser < `frames` si
+          alguno fallo y se salto).
+        - seed (int): semilla usada.
+        - pose_method_used (str): "openpose" o "prompt" (refleja el fallback).
+        - skipped (list[int]): indices de frames que fallaron y se saltaron.
+        - error (str): mensaje de error; vacio si todo OK.
+    """
+    out = {
+        "ok": False, "frames": [], "spritesheet_path": "", "animation_path": "",
+        "size": int(size), "n_frames": 0, "seed": int(seed),
+        "pose_method_used": "", "skipped": [], "error": "",
+    }
+
+    if not character or not character.strip():
+        out["error"] = "character vacio"
+        return out
+    if int(frames) < 2:
+        out["error"] = f"frames debe ser >= 2, recibido {frames!r}"
+        return out
+    if int(size) < 1:
+        out["error"] = f"size debe ser >= 1, recibido {size!r}"
+        return out
+    if pose_method not in ("auto", "openpose", "prompt"):
+        out["error"] = f"pose_method invalido: {pose_method!r}"
+        return out
+
+    n = int(frames)
+    dest = os.path.expanduser(dest_dir)
+    frames_dir = os.path.join(dest, f"{filename_prefix}_frames")
+    try:
+        os.makedirs(frames_dir, exist_ok=True)
+    except OSError as exc:
+        out["error"] = f"no se pudo crear dest_dir {frames_dir!r}: {exc}"
+        return out
+
+    # --- Fase 0: resolver el metodo de poses + esqueletos OpenPose si aplica. ---
+    skeleton_names: list[str | None] = [None] * n
+    method = "prompt" if pose_method == "prompt" else "openpose"
+    if method == "openpose":
+        input_dir = os.path.expanduser(comfy_input_dir)
+        sk = render_openpose_walk_skeletons(
+            input_dir, frames=n, width=int(width), height=int(height),
+            facing=facing, filename_prefix=f"{filename_prefix}_pose",
+        )
+        if sk.get("ok") and sk.get("skeleton_paths"):
+            paths = sk["skeleton_paths"]
+            # El builder espera el basename relativo al input/ del servidor.
+            skeleton_names = [os.path.basename(p) for p in paths][:n]
+            # Si se generaron menos esqueletos que frames, rellena con None.
+            while len(skeleton_names) < n:
+                skeleton_names.append(None)
+        else:
+            # Fallback limpio: no hay esqueletos -> modo prompt.
+            method = "prompt"
+            out["error"] = (
+                f"render de esqueletos OpenPose fallo ({sk.get('error')}); "
+                f"fallback a pose por prompt"
+            )
+            if pose_method == "openpose":
+                # El caller forzo openpose y no hay esqueletos: aun asi seguimos en
+                # prompt para no abortar, pero queda anotado en el error.
+                pass
+    out["pose_method_used"] = method
+
+    # --- Fase 1..N: generar + pixelizar cada frame del ciclo. ---
+    pixel_frames: list[str] = []
+    for i in range(n):
+        pose_skeleton = skeleton_names[i] if method == "openpose" else None
+        # En modo openpose la pose la fija el esqueleto: no se mete la fase en el
+        # prompt para no competir con el ControlNet. En modo prompt, la fase guia.
+        if method == "prompt":
+            subject_i = f"{character}, {_phase_for(i, n)}"
+        else:
+            subject_i = f"{character}, walking"
+
+        try:
+            wf = comfyui_build_sprite_sheet_workflow(
+                subject_i,
+                ref_image=ref_image,
+                pose_skeleton=pose_skeleton,
+                ckpt_name=checkpoint,
+                controlnet_strength=controlnet_strength,
+                controlnet_end=controlnet_end,
+                transparent=True,
+                negative=negative,
+                width=int(width),
+                height=int(height),
+                steps=int(steps),
+                cfg=float(cfg),
+                seed=int(seed),  # FIJA: identidad consistente entre frames.
+                filename_prefix=f"{filename_prefix}_f{i}",
+                **gen_kwargs,
+            )
+        except (ValueError, TypeError) as exc:
+            out["skipped"].append(i)
+            if not out["error"]:
+                out["error"] = f"build workflow frame {i} fallo: {exc}"
+            continue
+
+        # submit -> wait -> fetch (alta resolucion RGBA). Cualquier fallo de red/
+        # GPU salta este frame y sigue (error path del DoD).
+        try:
+            sub = comfyui_submit_workflow(wf, server=server)
+            prompt_id = sub["prompt_id"]
+            outputs = comfyui_wait_result(prompt_id, server=server, timeout=wait_timeout)
+        except (RuntimeError, KeyError, OSError, TimeoutError) as exc:
+            out["skipped"].append(i)
+            if not out["error"]:
+                out["error"] = f"frame {i} fallo en submit/wait: {exc}"
+            continue
+
+        img = None
+        for node_out in outputs.values():
+            images = node_out.get("images") if isinstance(node_out, dict) else None
+            if images:
+                img = images[0]
+                break
+        if img is None:
+            out["skipped"].append(i)
+            continue
+
+        fetched = comfyui_fetch_output_image(
+            img["filename"], subfolder=img.get("subfolder", ""),
+            type_=img.get("type", "output"), server=server, dest_dir=frames_dir,
+        )
+        if not fetched.get("ok"):
+            out["skipped"].append(i)
+            if not out["error"]:
+                out["error"] = f"frame {i} fetch fallo: {fetched.get('error')}"
+            continue
+
+        # Pixelizar el PNG alta-res a un grid duro size x size RGBA.
+        frame_px = os.path.join(frames_dir, f"{filename_prefix}_px_{i:02d}.png")
+        px = comfyui_pixelize_sprite_png(
+            fetched["path"], frame_px, size=int(size), colors=int(colors),
+            engine=engine, palette=palette, transparent=True, autocrop=True,
+            comfy_python=comfy_python,
+        )
+        if not px.get("ok"):
+            out["skipped"].append(i)
+            if not out["error"]:
+                out["error"] = f"frame {i} pixelizado fallo: {px.get('error')}"
+            continue
+
+        pixel_frames.append(frame_px)
+
+    if not pixel_frames:
+        if not out["error"]:
+            out["error"] = "ningun frame se genero correctamente"
+        return out
+
+    # --- Ensamblado: sprite sheet horizontal + animacion en loop. ---
+    asm = assemble_animated_sprite(
+        pixel_frames, dest, name=filename_prefix, fps=int(fps), fmt=fmt,
+        loop=True, spritesheet=True,
+    )
+    if not asm.get("ok"):
+        out["frames"] = pixel_frames
+        out["n_frames"] = len(pixel_frames)
+        if not out["error"]:
+            out["error"] = f"ensamblado fallo: {asm.get('error')}"
+        return out
+
+    out["frames"] = pixel_frames
+    out["spritesheet_path"] = asm.get("spritesheet_path", "")
+    out["animation_path"] = asm.get("animation_path", "")
+    out["n_frames"] = len(pixel_frames)
+    # El size real lo confirma el primer frame ensamblado.
+    fs = asm.get("frame_size") or [int(size), int(size)]
+    out["size"] = int(fs[0])
+
+    if not keep_frames:
+        for fp in pixel_frames:
+            try:
+                os.remove(fp)
+            except OSError:
+                pass
+
+    out["ok"] = True
+    # El error de fallback de poses (si lo hubo) es informativo, no invalida el ok.
+    return out
+
+
+if __name__ == "__main__":
+    import json
+
+    res = comfyui_walk_cycle_oneshot(
+        "pixel art knight, full body, side view",
+        frames=4, size=32, colors=16, fps=8, seed=42,
+        dest_dir="/tmp/comfy_walk_cycle",
+    )
+    print(json.dumps(res, indent=2))

python/pyproject.toml

@@ -19,7 +19,9 @@ dependencies = [
     "google-cloud-storage>=3.10.1",
     "httpx",
     "matplotlib>=3.10.9",
+    "opencv-contrib-python-headless>=4.13.0.92",
     "openpyxl>=3.1.5",
+    "pillow>=12.2.0",
     "polars>=1.40.1",
     "pymeshlab>=2025.7.post1",
     "pymssql>=2.3.13",
@@ -27,6 +29,7 @@ dependencies = [
     "pyproj>=3.7.2",
     "python-docx>=1.2.0",
     "pyyaml>=6.0.3",
+    "qrcode[pil]>=8.2",
     "rapidfuzz>=3.14.5",
     "reportlab>=4.5.0",
     "scikit-image>=0.26.0",

python/uv.lock

@@ -900,7 +900,9 @@ dependencies = [
     { name = "google-cloud-storage" },
     { name = "httpx" },
     { name = "matplotlib" },
+    { name = "opencv-contrib-python-headless" },
     { name = "openpyxl" },
+    { name = "pillow" },
     { name = "polars" },
     { name = "pymeshlab" },
     { name = "pymssql" },
@@ -908,6 +910,7 @@ dependencies = [
     { name = "pyproj" },
     { name = "python-docx" },
     { name = "pyyaml" },
+    { name = "qrcode", extra = ["pil"] },
     { name = "rapidfuzz" },
     { name = "reportlab" },
     { name = "scikit-image" },
@@ -956,7 +959,9 @@ requires-dist = [
     { name = "jupyter-mcp-server", marker = "extra == 'jupyter'" },
     { name = "jupyterlab", marker = "extra == 'jupyter'", specifier = ">=4.0" },
     { name = "matplotlib", specifier = ">=3.10.9" },
+    { name = "opencv-contrib-python-headless", specifier = ">=4.13.0.92" },
     { name = "openpyxl", specifier = ">=3.1.5" },
+    { name = "pillow", specifier = ">=12.2.0" },
     { name = "polars", specifier = ">=1.40.1" },
     { name = "pymeshlab", specifier = ">=2025.7.post1" },
     { name = "pymssql", specifier = ">=2.3.13" },
@@ -964,6 +969,7 @@ requires-dist = [
     { name = "pyproj", specifier = ">=3.7.2" },
     { name = "python-docx", specifier = ">=1.2.0" },
     { name = "pyyaml", specifier = ">=6.0.3" },
+    { name = "qrcode", extras = ["pil"], specifier = ">=8.2" },
     { name = "rapidfuzz", specifier = ">=3.14.5" },
     { name = "reportlab", specifier = ">=4.5.0" },
     { name = "scikit-image", specifier = ">=0.26.0" },
@@ -2945,6 +2951,24 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/df/4e/1c9df57496409dc86b320bd38f29ad7a34b7115e4f35b8fca44a827568a7/onnxruntime-1.25.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7e79fd5ce7db10ebcc24e020e2ed0159476e69e2326b9b7828e5aadcf6184212", size = 18021249, upload-time = "2026-04-27T22:00:18.954Z" },
 ]
 
+[[package]]
+name = "opencv-contrib-python-headless"
+version = "4.13.0.92"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/70/b5/9af5b81d9279e9982e21dad52f8a6aec10f7c891ae1e3d3d1b3ce111f8e7/opencv_contrib_python_headless-4.13.0.92-cp37-abi3-macosx_13_0_arm64.whl", hash = "sha256:b0467988c2d56c283b00fb808e0b57f5db2e3ca7743164a3b3efc733bfa03d3a", size = 52041681, upload-time = "2026-02-05T07:01:39.651Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/42/f0aef27baf1f376007b018b00f6c304c42c20d31aa8491633c53b18912cb/opencv_contrib_python_headless-4.13.0.92-cp37-abi3-macosx_14_0_x86_64.whl", hash = "sha256:79e503b77880d806a1b106ff8182c6f898347ccfd1db58ffc9a6369acc236c4c", size = 38830456, upload-time = "2026-02-05T07:01:56.47Z" },
+    { url = "https://files.pythonhosted.org/packages/14/84/e6b3568f9147b4f114e881fb0e733fd97bdca15452feba78b510351584d1/opencv_contrib_python_headless-4.13.0.92-cp37-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:449c1f00a685a3a7dff8d6fa93a70fbfe0de5537c24358ea03a1d996d12b33e8", size = 39355323, upload-time = "2026-02-05T10:17:31.671Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/09/89714580c617cf6e9f66eed9137759fc017ab6ab093c2a03227e8ee19578/opencv_contrib_python_headless-4.13.0.92-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c9b028adc04f6579f37227eb1d648bead14fd6fefc58da86df37c8320351f7bd", size = 62147375, upload-time = "2026-02-05T10:20:03.076Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/29/abdd2ff2f8f07e9aa37c70edc9987b8aa63730ae70957c378f6f2e9d72d2/opencv_contrib_python_headless-4.13.0.92-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:cdd974b34801f24735d18b1057cfaab1698d5cb02c9bba01dab7dc47201f2ef6", size = 40840722, upload-time = "2026-02-05T10:21:27.877Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/0a/3194fdf035ef5123bd8cc3e3ad1a96c1ddeeedd0fdd12aaa0d2cfeb1649a/opencv_contrib_python_headless-4.13.0.92-cp37-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:9e26469baed9069f627ea56fa46819690c4545580362071dd09f1dcf47a40f2f", size = 66610130, upload-time = "2026-02-05T10:23:32.427Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/4b/afe9b43c02b86b675a3d3ac6fc220473a88016e1acb487f5138efd2d2630/opencv_contrib_python_headless-4.13.0.92-cp37-abi3-win32.whl", hash = "sha256:696a6dd84d309a499efc63644e375f035447b1da777faa2954f2dea7626cc0e7", size = 36708602, upload-time = "2026-02-05T07:02:36.041Z" },
+    { url = "https://files.pythonhosted.org/packages/23/22/9fdc70520eb915b46d816f9cc5415458b1bd114a65d7a7e657cbd9b863e5/opencv_contrib_python_headless-4.13.0.92-cp37-abi3-win_amd64.whl", hash = "sha256:dcbb12d04ae74f5dcd782e3b166e1894c6fbdfaaf30866588746205d2a0cde5a", size = 46345416, upload-time = "2026-02-05T07:02:33.446Z" },
+]
+
 [[package]]
 name = "openpyxl"
 version = "3.1.5"
@@ -4020,6 +4044,23 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/81/d6/4bfbb40c9a0b42fc53c7cf442f6385db70b40f74a783130c5d0a5aa62228/pyzmq-27.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:dc5dbf68a7857b59473f7df42650c621d7e8923fb03fa74a526890f4d33cc4d7", size = 575170, upload-time = "2025-09-08T23:09:01.418Z" },
 ]
 
+[[package]]
+name = "qrcode"
+version = "8.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8f/b2/7fc2931bfae0af02d5f53b174e9cf701adbb35f39d69c2af63d4a39f81a9/qrcode-8.2.tar.gz", hash = "sha256:35c3f2a4172b33136ab9f6b3ef1c00260dd2f66f858f24d88418a015f446506c", size = 43317, upload-time = "2025-05-01T15:44:24.726Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dd/b8/d2d6d731733f51684bbf76bf34dab3b70a9148e8f2cef2bb544fccec681a/qrcode-8.2-py3-none-any.whl", hash = "sha256:16e64e0716c14960108e85d853062c9e8bba5ca8252c0b4d0231b9df4060ff4f", size = 45986, upload-time = "2025-05-01T15:44:22.781Z" },
+]
+
+[package.optional-dependencies]
+pil = [
+    { name = "pillow" },
+]
+
 [[package]]
 name = "rapidfuzz"
 version = "3.14.5"