studio-psd-extract 0.2.0__tar.gz

studio_psd_extract-0.2.0/LICENSE

@@ -0,0 +1,6 @@
+Copyright (c) 2026 Omnitok. Todos los derechos reservados.
+
+Este software es propietario. Se publica en PyPI solo para que el equipo y las
+personas autorizadas por Omnitok puedan instalarlo y ejecutarlo junto con Omnitok
+Studio. No se otorga permiso para copiarlo, modificarlo, redistribuirlo ni usarlo
+fuera de ese fin sin autorización escrita de Omnitok.

studio_psd_extract-0.2.0/PKG-INFO

@@ -0,0 +1,53 @@
+Metadata-Version: 2.4
+Name: studio-psd-extract
+Version: 0.2.0
+Summary: Extrae mesas, capas, texto e imágenes de un PSD al contrato JSON de Omnitok Studio.
+License-Expression: LicenseRef-Proprietary
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: psd-tools<1.26,>=1.25
+Requires-Dist: Pillow>=11
+Requires-Dist: fonttools>=4.50
+Provides-Extra: test
+Requires-Dist: pytest>=8.0; extra == "test"
+Dynamic: license-file
+
+# studio-psd-extract
+
+Extrae de un PSD las mesas, el árbol de capas, los runs de texto y los fondos rasterizados
+(sin capas de texto) al contrato JSON v1 de Omnitok Studio. Es el mismo extractor que usa la
+tool `studio_extract_psd` del MCP de Studio.
+
+## Desarrollo
+
+Desde la raíz del repo `omnitok-studio-mcp`:
+
+    uv pip install --python .venv/bin/python -e packages/studio-psd-extract --no-deps
+    PYTHONPATH=. .venv/bin/python -m pytest -q packages/studio-psd-extract/tests
+
+Fixtures: `python tests/fixtures/make_fixtures.py` (dentro del paquete) regenera los PSD de prueba.
+
+## Uso
+
+    uvx studio-psd-extract <archivo.psd> --out-dir <carpeta> [--brand-fonts "Fam A,Fam B"] [--font-dir <carpeta> ...] [--no-metrics]
+    uvx studio-psd-extract <carpeta>/extraction.json --artboard A3
+
+Escribe `<carpeta>/extraction.json` (contrato completo) y `<carpeta>/assets/psd-<hash12>.png`, e
+imprime en stdout un resumen compacto (mesas, fuentes, warnings, `assets_dir` y assets). Con
+`--artboard` imprime el outline compacto de esa mesa (ids, tipos, bbox, texto). Exit 0 = ok; 2 = error
+(`{"error": {"code", "message"}}`). Límites locales: 1 GB, 300 MP; PSB y Lab no soportados.
+
+Métrica de fuente sustituta: en capas de una línea (runs de la misma fuente y tamaño se unen) compara el ancho de tinta del PSD
+con el de la fuente declarada instalada en este equipo (carpetas del sistema, Adobe Fonts y
+`--font-dir`). `metrics.status`: `match` (±4 %, o ±2 px en textos chicos), `suspect` (Photoshop probablemente dibujó otra
+fuente; `tracking_needed_em` es el tracking que haría calzar), `font_not_installed` o `skipped` (con `reason`: `multiline`, `area_text`, `multi_run`, `transform_complex`, `empty`, `glyph_missing`, `small_caps`, `metrics_error`).
+
+## Publicación
+
+Solo con un tag `psd-v<versión>` que coincida con `version` del `pyproject.toml`; el workflow
+`publish-psd-extract` corre los tests, construye y publica en PyPI con trusted publishing.
+
+## Licencia
+
+Propietaria: todos los derechos reservados (ver `LICENSE`).

studio_psd_extract-0.2.0/README.md

@@ -0,0 +1,38 @@
+# studio-psd-extract
+
+Extrae de un PSD las mesas, el árbol de capas, los runs de texto y los fondos rasterizados
+(sin capas de texto) al contrato JSON v1 de Omnitok Studio. Es el mismo extractor que usa la
+tool `studio_extract_psd` del MCP de Studio.
+
+## Desarrollo
+
+Desde la raíz del repo `omnitok-studio-mcp`:
+
+    uv pip install --python .venv/bin/python -e packages/studio-psd-extract --no-deps
+    PYTHONPATH=. .venv/bin/python -m pytest -q packages/studio-psd-extract/tests
+
+Fixtures: `python tests/fixtures/make_fixtures.py` (dentro del paquete) regenera los PSD de prueba.
+
+## Uso
+
+    uvx studio-psd-extract <archivo.psd> --out-dir <carpeta> [--brand-fonts "Fam A,Fam B"] [--font-dir <carpeta> ...] [--no-metrics]
+    uvx studio-psd-extract <carpeta>/extraction.json --artboard A3
+
+Escribe `<carpeta>/extraction.json` (contrato completo) y `<carpeta>/assets/psd-<hash12>.png`, e
+imprime en stdout un resumen compacto (mesas, fuentes, warnings, `assets_dir` y assets). Con
+`--artboard` imprime el outline compacto de esa mesa (ids, tipos, bbox, texto). Exit 0 = ok; 2 = error
+(`{"error": {"code", "message"}}`). Límites locales: 1 GB, 300 MP; PSB y Lab no soportados.
+
+Métrica de fuente sustituta: en capas de una línea (runs de la misma fuente y tamaño se unen) compara el ancho de tinta del PSD
+con el de la fuente declarada instalada en este equipo (carpetas del sistema, Adobe Fonts y
+`--font-dir`). `metrics.status`: `match` (±4 %, o ±2 px en textos chicos), `suspect` (Photoshop probablemente dibujó otra
+fuente; `tracking_needed_em` es el tracking que haría calzar), `font_not_installed` o `skipped` (con `reason`: `multiline`, `area_text`, `multi_run`, `transform_complex`, `empty`, `glyph_missing`, `small_caps`, `metrics_error`).
+
+## Publicación
+
+Solo con un tag `psd-v<versión>` que coincida con `version` del `pyproject.toml`; el workflow
+`publish-psd-extract` corre los tests, construye y publica en PyPI con trusted publishing.
+
+## Licencia
+
+Propietaria: todos los derechos reservados (ver `LICENSE`).

studio_psd_extract-0.2.0/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "studio-psd-extract"
+version = "0.2.0"
+description = "Extrae mesas, capas, texto e imágenes de un PSD al contrato JSON de Omnitok Studio."
+readme = "README.md"
+requires-python = ">=3.11"
+license = "LicenseRef-Proprietary"
+license-files = ["LICENSE"]
+dependencies = ["psd-tools>=1.25,<1.26", "Pillow>=11", "fonttools>=4.50"]
+
+[project.scripts]
+studio-psd-extract = "studio_psd_extract.cli:main"
+
+[project.optional-dependencies]
+test = ["pytest>=8.0"]
+
+[tool.setuptools.packages.find]
+where = ["src"]

studio_psd_extract-0.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

studio_psd_extract-0.2.0/src/studio_psd_extract/__init__.py

@@ -0,0 +1,152 @@
+"""Extracción de PSD -> contrato JSON v1. `extract` es PURA (sin red ni DAM)."""
+from __future__ import annotations
+
+import io
+import math
+from importlib.metadata import PackageNotFoundError, version as _version
+
+from .guard import GuardError, check_header
+
+try:
+    EXTRACTOR_VERSION = _version("studio-psd-extract")
+except PackageNotFoundError:  # árbol de fuentes sin instalar
+    EXTRACTOR_VERSION = "0+unknown"
+
+
+def _preorder(layers):
+    """Capas en el mismo orden pre-orden que usa `layers.walk` para numerar ids."""
+    for l in layers:
+        yield l
+        if l.is_group():
+            yield from _preorder(list(l))
+
+
+def _flatten(nodes):
+    for n in nodes:
+        yield n
+        yield from _flatten(n["children"])
+
+
+def _ppi(psd) -> int:
+    """ppi desde RESOLUTION_INFO: `horizontal` es fixed-point 16.16; unit 2 = px/cm."""
+    from psd_tools.constants import Resource
+    info = psd.image_resources.get_data(Resource.RESOLUTION_INFO)
+    raw = getattr(info, "horizontal", None)
+    if not raw:
+        return 72
+    try:
+        value = float(raw) / 65536.0
+        if getattr(info, "horizontal_unit", 1) == 2:  # px/cm -> px/in
+            value *= 2.54
+        ppi = int(round(value))
+    except (TypeError, ValueError):
+        return 72
+    return ppi if 1 <= ppi <= 2000 else 72
+
+
+def _transform_scale(layer) -> tuple[float, bool]:
+    """Escala efectiva del `TypeLayer.transform` (xx, xy, yx, yy, tx, ty) -> (escala, es_compleja).
+
+    Escala uniforme geométrica = sqrt(|det|) = sqrt(|xx*yy - xy*yx|): para escala pura
+    (con o sin reflejo) coincide con el factor; con rotación pura es 1.0 (la rotación no
+    cambia el tamaño). `es_compleja` si hay rotación/shear (xy o yx > 1% de la escala) o
+    escala anisotrópica (||xx|-|yy|| > 1% de la escala), donde una sola escala es aproximada. tx/ty son posición, no afectan. Identidad, atributo
+    ausente o valor inválido -> (1.0, False).
+    """
+    try:
+        xx, xy, yx, yy = (float(x) for x in tuple(layer.transform)[:4])
+    except (AttributeError, TypeError, ValueError):
+        return 1.0, False
+    scale = abs(xx * yy - xy * yx) ** 0.5
+    if not math.isfinite(scale) or not scale > 1e-9:
+        return 1.0, False
+    if abs(scale - 1.0) < 1e-6:
+        scale = 1.0
+    tol = 0.01 * scale
+    return scale, max(abs(xy), abs(yx)) > tol or abs(abs(xx) - abs(yy)) > tol
+
+
+def extract(psd_bytes: bytes, *, theme_families: list[str] | None = None, profile=None,
+            mode: str = "online") -> dict:
+    from . import artboards as _artboards, layers as _layers, limits, raster, text as _text
+    from .model import bbox_dict, map_kind
+
+    p = profile or limits.server()
+    head = check_header(psd_bytes, p)
+
+    from psd_tools import PSDImage
+    psd = PSDImage.open(io.BytesIO(psd_bytes))
+
+    from .color import ColorConverter
+
+    converter = ColorConverter(raster._icc_profile(psd), head["color_mode"])
+
+    all_layers = list(psd.descendants())
+    if len(all_layers) > p.max_layers:
+        raise GuardError("psd_too_complex", f"{len(all_layers)} capas > {p.max_layers}")
+    for l in all_layers:
+        try:
+            b = bbox_dict(l.bbox)
+        except ValueError:
+            continue
+        if b["w"] * b["h"] > p.max_layer_pixels:
+            raise GuardError("psd_too_complex",
+                             f"capa '{l.name}' {b['w']}x{b['h']}px > {p.max_layer_pixels}")
+
+    boards = _artboards.detect(psd)
+    tree = _layers.walk(psd, boards)
+    warnings: list[dict] = []
+    fonts: dict[str, dict] = {}
+    theme = set(theme_families or [])
+
+    flat_nodes = list(_flatten(tree))
+    ordered_layers = list(_preorder(list(psd)))
+    if len(flat_nodes) != len(ordered_layers):
+        raise RuntimeError(
+            f"desalineado nodo/capa: {len(flat_nodes)} nodos vs {len(ordered_layers)} capas")
+    for node, layer in zip(flat_nodes, ordered_layers):
+        if node["name"] != layer.name or node["kind"] != map_kind(layer):
+            raise RuntimeError(
+                f"desalineado nodo/capa: nodo {node['id']} ({node['name']!r}, {node['kind']}) "
+                f"vs capa {layer.name!r} ({map_kind(layer)})")
+        node["text"] = None
+        node["asset"] = None
+        if node["kind"] != "text":
+            continue
+        scale, complex_tf = _transform_scale(layer)
+        try:
+            t = _text.runs(layer, scale, theme, to_hex=converter.hex)
+        except Exception as exc:  # noqa: BLE001 - un run malo no debe perder el PSD entero
+            warnings.append({"code": "text_parse_failed", "layer": node["id"],
+                             "detail": repr(exc)})
+            continue
+        node["text"] = t
+        for r in t["runs"]:
+            f = fonts.setdefault(r["family"], {"family": r["family"],
+                                               "available": r["font_available"], "runs": 0})
+            f["runs"] += 1
+        if complex_tf:
+            warnings.append({"code": "text_transform_complex", "layer": node["id"],
+                             "scale": round(scale, 6)})
+
+    # Nodo extra por mesa con el background rasterizado (bytes; la subida es Task 7).
+    for a in boards:
+        bg = raster.artboard_background(psd, a, converter)
+        warnings.extend(bg["warnings"])
+        tree.append({
+            "id": f"{a['id']}-bg", "name": f"{a['name']} (fondo sin texto)", "kind": "pixel",
+            "artboard": a["id"], "bbox": dict(a["rect"]), "visible": True, "opacity": 1.0,
+            "clipping": False, "mask": False, "effects": [], "children": [], "text": None,
+            "asset": {"png": bg["png"], "rgba_hash": bg["rgba_hash"], "w": bg["w"], "h": bg["h"]},
+        })
+
+    return {
+        "contract_version": 1,
+        "extractor": {"mode": mode, "version": EXTRACTOR_VERSION},
+        "document": {"width": head["width"], "height": head["height"], "ppi": _ppi(psd),
+                     "color_mode": head["color_mode"], "depth": head["depth"]},
+        "artboards": boards,
+        "layers": tree,
+        "fonts_used": list(fonts.values()),
+        "warnings": warnings,
+    }

studio_psd_extract-0.2.0/src/studio_psd_extract/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

studio_psd_extract-0.2.0/src/studio_psd_extract/artboards.py

@@ -0,0 +1,22 @@
+"""Detección de mesas (artboards) de un PSDImage de psd-tools."""
+from __future__ import annotations
+
+from .model import bbox_dict
+
+
+def detect(psd) -> list[dict]:
+    """Mesas = grupos con tagged block ARTBOARD_DATA (psd-tools los expone como
+    `Artboard`, con bbox = artboardRect). Sin mesas: una sola `A0` = canvas."""
+    found = []
+    for layer in psd.descendants():
+        if layer.kind != "artboard":
+            continue
+        try:
+            rect = bbox_dict(layer.bbox)
+        except ValueError:  # artboardRect ausente/incompleto
+            continue
+        found.append({"id": f"A{len(found)}", "name": layer.name, "rect": rect})
+    if found:
+        return found
+    return [{"id": "A0", "name": "A0",
+             "rect": {"x": 0, "y": 0, "w": psd.width, "h": psd.height}}]

studio_psd_extract-0.2.0/src/studio_psd_extract/builtin_fonts.py

@@ -0,0 +1,15 @@
+"""Fuentes built-in del render de Studio.
+
+Espejo de BUILTIN_FONTS (packages/studio-render-core/src/builtin-fonts.ts en
+omnitok-studio-api). Mantener en sync a mano si se agrega o quita una built-in.
+"""
+BUILTIN_FONTS = (
+    "Nunito Sans",
+    "Open Sans",
+    "Inter",
+    "Manrope",
+    "Libre Franklin",
+    "Lora",
+    "Roboto Slab",
+    "Plus Jakarta Sans",
+)

studio_psd_extract-0.2.0/src/studio_psd_extract/cli.py

@@ -0,0 +1,94 @@
+"""CLI local: `studio-psd-extract <archivo.psd> --out-dir <carpeta>`.
+
+Escribe `extraction.json` (contrato completo) y `assets/psd-<hash12>.png`, e imprime en stdout
+solo el resumen compacto. Corre `extract()` directo, sin sandbox: el archivo es de la persona.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from . import extract, limits
+from .compact import iter_nodes, outline, summary
+from .guard import GuardError
+
+
+def _parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(prog="studio-psd-extract",
+                                description="Extrae un PSD al contrato JSON de Omnitok Studio.")
+    p.add_argument("psd", type=Path, help="archivo .psd, o un extraction.json ya generado (con --artboard)")
+    p.add_argument("--out-dir", type=Path, help="carpeta de salida (obligatoria con un .psd)")
+    p.add_argument("--artboard", help="imprime el outline compacto de esa mesa en vez del resumen")
+    p.add_argument("--brand-fonts", default="",
+                   help="familias de la marca separadas por coma (font_available=theme)")
+    p.add_argument("--font-dir", type=Path, action="append", default=[],
+                   help="carpeta extra de fuentes (se puede repetir); se busca antes que las del sistema")
+    p.add_argument("--no-metrics", action="store_true", help="no medir fuentes sustitutas")
+    return p
+
+
+def _write_assets(result: dict, out_dir: Path) -> None:
+    assets_dir = out_dir / "assets"
+    assets_dir.mkdir(parents=True, exist_ok=True)
+    for node in iter_nodes(result.get("layers") or []):
+        a = node.get("asset")
+        if not isinstance(a, dict) or "png" not in a:
+            continue
+        h = a["rgba_hash"]
+        name = f"psd-{h[:12]}.png"
+        path = (assets_dir / name).resolve()
+        path.write_bytes(a["png"])
+        node["asset"] = {"local_path": str(path), "filename": name, "content_type": "image/png",
+                         "size": len(a["png"]), "hash": h, "tag": f"psd-hash:{h}",
+                         "w": a["w"], "h": a["h"]}
+
+
+def _error(code: str, message: str) -> int:
+    print(json.dumps({"error": {"code": code, "message": message}}, ensure_ascii=False))
+    return 2
+
+
+def _print_outline(result: dict, artboard_id: str) -> int:
+    view = outline(result, artboard_id)
+    if view is None:
+        return _error("artboard_not_found", f"no existe la mesa {artboard_id!r}")
+    print(json.dumps(view, ensure_ascii=False))
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = _parser()
+    args = parser.parse_args(argv)
+    if not args.psd.is_file():
+        parser.error(f"no existe el archivo: {args.psd}")
+    if args.psd.suffix.lower() == ".json":
+        if not args.artboard:
+            parser.error("con un extraction.json se necesita --artboard")
+        return _print_outline(json.loads(args.psd.read_text(encoding="utf-8")), args.artboard)
+    if args.out_dir is None:
+        parser.error("con un .psd se necesita --out-dir")
+    theme = [f.strip() for f in args.brand_fonts.split(",") if f.strip()]
+    try:
+        result = extract(args.psd.read_bytes(), theme_families=theme, profile=limits.local(), mode="local")
+    except GuardError as err:
+        return _error(err.code, str(err))
+    except Exception as err:  # noqa: BLE001 - el contrato del CLI es JSON + exit 2, no un traceback
+        return _error("extract_failed", f"{type(err).__name__}: {err}")
+    args.out_dir.mkdir(parents=True, exist_ok=True)
+    _write_assets(result, args.out_dir)
+    if not args.no_metrics:
+        from . import metrics
+
+        metrics.annotate(result, font_dirs=[*args.font_dir, *metrics.default_font_dirs()])
+    path = (args.out_dir / "extraction.json").resolve()
+    path.write_text(json.dumps(result, ensure_ascii=False, indent=1), encoding="utf-8")
+    if args.artboard:
+        return _print_outline(result, args.artboard)
+    print(json.dumps(summary(result, path, (args.out_dir / "assets").resolve()), ensure_ascii=False))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

studio_psd_extract-0.2.0/src/studio_psd_extract/color.py

@@ -0,0 +1,65 @@
+"""Conversión del color del documento (rgb|cmyk) a sRGB, para fondos y colores de texto.
+
+Un único transform por documento: el texto y los fondos quedan consistentes entre sí.
+"""
+from __future__ import annotations
+
+import io
+
+from PIL import Image, ImageCms
+
+
+def _clamp255(value: float) -> int:
+    return max(0, min(255, round(float(value) * 255)))
+
+
+class ColorConverter:
+    def __init__(self, icc: bytes | None, color_mode: str):
+        self.icc = icc
+        self.color_mode = color_mode
+        self._cmyk = None
+        self._cmyk_failed = False
+
+    def _cmyk_transform(self):
+        if self._cmyk is None and not self._cmyk_failed and self.icc:
+            try:
+                src = ImageCms.ImageCmsProfile(io.BytesIO(self.icc))
+                self._cmyk = ImageCms.buildTransform(src, ImageCms.createProfile("sRGB"), "CMYK", "RGB")
+            except (ImageCms.PyCMSError, OSError):
+                self._cmyk_failed = True
+        return self._cmyk
+
+    def image(self, img: Image.Image) -> tuple[Image.Image, list[dict]]:
+        """Imagen compuesta -> (RGBA sRGB, warnings)."""
+        if self.color_mode == "cmyk":
+            if img.mode != "CMYK":  # p. ej. el lienzo vacío de respaldo de raster._composite
+                return img.convert("RGBA"), []
+            if not self.icc:
+                return img.convert("RGB").convert("RGBA"), [{"code": "cmyk_no_icc"}]
+            transform = self._cmyk_transform()
+            if transform is None:
+                return img.convert("RGB").convert("RGBA"), [{"code": "icc_conversion_failed"}]
+            return ImageCms.applyTransform(img, transform).convert("RGBA"), []
+        img = img.convert("RGBA")
+        if not self.icc:
+            return img, [{"code": "icc_missing"}]
+        try:
+            src = ImageCms.ImageCmsProfile(io.BytesIO(self.icc))
+            return ImageCms.profileToProfile(img, src, ImageCms.createProfile("sRGB"), outputMode="RGBA"), []
+        except (ImageCms.PyCMSError, OSError):
+            return img, [{"code": "icc_conversion_failed"}]
+
+    def hex(self, values) -> str | None:
+        """`Values` de un FillColor del engine: [A,R,G,B] o [A,C,M,Y,K], floats 0..1 -> '#rrggbb'."""
+        try:
+            vals = [float(v) for v in values]
+        except (TypeError, ValueError):
+            return None
+        if len(vals) == 4:
+            return "#" + "".join(f"{_clamp255(c):02x}" for c in vals[1:])
+        if len(vals) == 5:
+            px = Image.new("CMYK", (1, 1), tuple(_clamp255(c) for c in vals[1:]))
+            transform = self._cmyk_transform()
+            rgb = (ImageCms.applyTransform(px, transform) if transform else px.convert("RGB")).getpixel((0, 0))
+            return "#" + "".join(f"{c:02x}" for c in rgb[:3])
+        return None

studio_psd_extract-0.2.0/src/studio_psd_extract/compact.py

@@ -0,0 +1,111 @@
+"""Vistas compactas de la extracción (sin red): lo que ve el agente por defecto."""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, Iterator, List, Optional
+
+PREVIEW_CHARS = 80
+
+
+def iter_nodes(nodes: List[Dict[str, Any]]) -> Iterator[Dict[str, Any]]:
+    """Recorre el árbol de capas en pre-orden."""
+    for n in nodes:
+        yield n
+        yield from iter_nodes(n.get("children") or [])
+
+
+def compact_text(result: Dict[str, Any], full_ids: Optional[set]) -> None:
+    """Reemplaza `text.runs` por {align, run_count, text_preview}, salvo en `full_ids` (None = todos)."""
+    for n in iter_nodes(result.get("layers") or []):
+        t = n.get("text")
+        if not isinstance(t, dict) or "runs" not in t:
+            continue
+        if full_ids is None or n.get("id") in full_ids:
+            continue
+        runs = t.get("runs") or []
+        joined = "".join(r.get("text", "") for r in runs)
+        n["text"] = {"align": t.get("align"), "run_count": len(runs),
+                     "text_preview": joined[:PREVIEW_CHARS]}
+
+
+MAX_SUSPECT_IN_SUMMARY = 30
+
+
+def _metrics_summary(nodes) -> Optional[Dict[str, Any]]:
+    suspect, missing, counts = [], {}, {"match": 0, "skipped": 0}
+    for n in nodes:
+        t = n.get("text")
+        m = t.get("metrics") if isinstance(t, dict) else None
+        if not m:
+            continue
+        run = (t.get("runs") or [{}])[0]
+        if m["status"] == "suspect":
+            suspect.append({"layer": n["id"], "name": n.get("name"), "font_ps_name": run.get("font_ps_name"),
+                            "text_preview": (run.get("text") or "")[:40], "width_ratio": m["width_ratio"],
+                            "tracking_needed_em": m["tracking_needed_em"]})
+        elif m["status"] == "font_not_installed":
+            ps = run.get("font_ps_name") or ""
+            missing[ps] = missing.get(ps, 0) + 1
+        else:
+            counts[m["status"]] += 1
+    if not (suspect or missing or counts["match"] or counts["skipped"]):
+        return None
+    return {"suspect": suspect[:MAX_SUSPECT_IN_SUMMARY], "suspect_total": len(suspect),
+            "font_not_installed": missing, **counts}
+
+
+ASSET_KEYS = ("filename", "size", "tag", "w", "h")  # local_path/hash/content_type quedan en extraction.json
+OUTLINE_PREVIEW_CHARS = 40
+
+
+def summary(result: Dict[str, Any], extraction_path: Path, assets_dir: Path) -> Dict[str, Any]:
+    """Resumen para stdout del CLI: todo menos el árbol de capas (ese queda en extraction.json)."""
+    nodes = list(iter_nodes(result.get("layers") or []))
+    text_nodes = [n for n in nodes if isinstance(n.get("text"), dict)]
+    warnings: Dict[str, int] = {}
+    for w in result.get("warnings") or []:
+        warnings[w.get("code")] = warnings.get(w.get("code"), 0) + 1
+    metrics_view = _metrics_summary(nodes)
+    out = {
+        "extraction_json": str(extraction_path),
+        "assets_dir": str(assets_dir),
+        "extractor": result.get("extractor"),
+        "document": result.get("document"),
+        "artboards": [{"id": a["id"], "name": a["name"], "w": a["rect"]["w"], "h": a["rect"]["h"]}
+                      for a in result.get("artboards") or []],
+        "counts": {"layers": len(nodes), "text_layers": len(text_nodes),
+                   "runs": sum(len(n["text"].get("runs") or []) for n in text_nodes)},
+        "fonts_used": result.get("fonts_used") or [],
+        "warnings": warnings,
+        "assets": [{"node": n["id"], **{k: n["asset"][k] for k in ASSET_KEYS if k in n["asset"]}}
+                   for n in nodes if isinstance(n.get("asset"), dict)],
+    }
+    if metrics_view is not None:
+        out["metrics"] = metrics_view
+    return out
+
+
+def outline(result: Dict[str, Any], artboard_id: str) -> Optional[Dict[str, Any]]:
+    """Capas de una mesa en pre-orden, compactas (medido: orden de 2-8 KB por mesa; la A1 de Indurama, ~7,8 KB). None si la mesa no existe."""
+    board = next((a for a in result.get("artboards") or [] if a.get("id") == artboard_id), None)
+    if board is None:
+        return None
+    rows: List[Dict[str, Any]] = []
+
+    def walk(nodes, depth):
+        for n in nodes:
+            if n.get("artboard") == artboard_id and n.get("kind") != "artboard":
+                bb = n.get("bbox")
+                row = {"id": n["id"], "name": n.get("name"), "kind": n.get("kind"), "depth": depth,
+                       "bbox": [bb["x"], bb["y"], bb["w"], bb["h"]] if isinstance(bb, dict) else bb}
+                t = n.get("text")
+                if isinstance(t, dict):
+                    joined = "".join(r.get("text", "") for r in t.get("runs") or []) or t.get("text_preview", "")
+                    row["text_preview"] = joined[:OUTLINE_PREVIEW_CHARS]
+                    if t.get("metrics"):
+                        row["metrics"] = t["metrics"]["status"]
+                rows.append(row)
+            walk(n.get("children") or [], depth + 1)
+
+    walk(result.get("layers") or [], 0)
+    return {"artboard": {"id": board["id"], "name": board.get("name"), "rect": board.get("rect")}, "nodes": rows}

studio_psd_extract-0.2.0/src/studio_psd_extract/fonts.py

@@ -0,0 +1,53 @@
+"""Resolución de nombres PostScript a family/weight/italic y disponibilidad."""
+import re
+
+from .builtin_fonts import BUILTIN_FONTS
+
+_WEIGHTS = {
+    "thin": 100, "hairline": 100,
+    "extralight": 200, "ultralight": 200,
+    "light": 300,
+    "regular": 400, "normal": 400, "book": 400, "roman": 400,
+    "medium": 500,
+    "semibold": 600, "demibold": 600, "demi": 600,
+    "bold": 700,
+    "extrabold": 800, "ultrabold": 800, "heavy": 800,
+    "black": 900,
+}
+_ITALIC = {"italic", "it", "oblique", "ital"}
+
+
+def _split_camel(s: str) -> str:
+    # "OpenSans" -> "Open Sans"; "PlusJakartaSans" -> "Plus Jakarta Sans"
+    return re.sub(r"(?<=[a-z0-9])(?=[A-Z])", " ", s)
+
+
+def _style_tokens(style: str) -> list[str]:
+    return [t.lower() for t in re.findall(r"[A-Z]?[a-z]+|[A-Z]+(?![a-z])", style)]
+
+
+def resolve(ps_name: str, theme_families: set[str]) -> dict:
+    base, _, style = (ps_name or "").partition("-")
+    family = _split_camel(base).strip()
+    weight, italic = 400, False
+    # Une tokens: "SemiBold", "BoldItalic", "Semi"+"Bold" -> comparar por concatenación.
+    tokens = _style_tokens(style)
+    i = 0
+    while i < len(tokens):
+        tok = tokens[i]
+        if i + 1 < len(tokens) and tok + tokens[i + 1] in _WEIGHTS:
+            weight = _WEIGHTS[tok + tokens[i + 1]]
+            i += 1
+        elif tok in _ITALIC:
+            italic = True
+        elif tok in _WEIGHTS:
+            weight = _WEIGHTS[tok]
+        i += 1
+
+    fam_l = family.lower()
+    available = None
+    if any(fam_l == b.lower() for b in BUILTIN_FONTS):
+        available = "builtin"
+    elif any(fam_l == t.lower() for t in theme_families):
+        available = "theme"
+    return {"family": family, "weight": weight, "italic": italic, "available": available}