@damiangilgonzalez/harness 1.3.7

package/skills/tastemaker/scripts/audit_motion.py

@@ -0,0 +1,233 @@
+#!/usr/bin/env python3
+"""Scan source files for common motion craft failures.
+
+This is a lightweight guardrail, not a substitute for reviewing motion in a
+browser. It catches the mistakes Tastemaker should never ship by accident:
+unbounded transitions, sluggish easing, impossible scale origins, layout
+animation, long UI durations, hover motion without pointer gating, and movement
+without reduced-motion handling.
+"""
+
+from __future__ import annotations
+
+import argparse
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+
+EXTENSIONS = {
+    ".css",
+    ".html",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".ts",
+    ".tsx",
+    ".vue",
+    ".svelte",
+}
+
+SKIP_DIRS = {
+    ".git",
+    ".netlify",
+    ".playwright-cli",
+    "node_modules",
+    "dist",
+    "build",
+    "coverage",
+}
+
+LAYOUT_PROPERTIES = (
+    "width",
+    "height",
+    "margin",
+    "padding",
+    "top",
+    "right",
+    "bottom",
+    "left",
+    "inset",
+    "border-radius",
+    "box-shadow",
+)
+
+
+@dataclass
+class Finding:
+    severity: str
+    path: Path
+    line: int
+    rule: str
+    message: str
+
+
+def iter_files(paths: list[Path]) -> list[Path]:
+    files: list[Path] = []
+    for path in paths:
+        if path.is_file() and path.suffix in EXTENSIONS:
+            files.append(path)
+            continue
+        if not path.is_dir():
+            continue
+        for child in path.rglob("*"):
+            if any(part in SKIP_DIRS for part in child.parts):
+                continue
+            if child.is_file() and child.suffix in EXTENSIONS:
+                files.append(child)
+    return sorted(set(files))
+
+
+def line_number(text: str, index: int) -> int:
+    return text.count("\n", 0, index) + 1
+
+
+def add_regex_findings(
+    findings: list[Finding],
+    path: Path,
+    text: str,
+    pattern: str,
+    severity: str,
+    rule: str,
+    message: str,
+    flags: int = re.IGNORECASE,
+) -> None:
+    for match in re.finditer(pattern, text, flags):
+        findings.append(Finding(severity, path, line_number(text, match.start()), rule, message))
+
+
+def audit_file(path: Path) -> list[Finding]:
+    text = path.read_text(encoding="utf-8", errors="ignore")
+    findings: list[Finding] = []
+
+    has_motion = bool(re.search(r"\b(transition|animation|gsap\.|animate\(|@keyframes|ScrollTrigger|motion\.)\b", text))
+    has_reduced_motion = "prefers-reduced-motion" in text or "useReducedMotion" in text or "matchMedia" in text
+    has_hover_motion = bool(re.search(r":hover[^{]*\{[^}]*\b(transform|animation|transition)\b", text, re.I | re.S))
+    has_pointer_gate = "@media (hover: hover)" in text or "@media(hover:hover)" in text
+
+    add_regex_findings(
+        findings,
+        path,
+        text,
+        r"transition\s*:\s*all\b",
+        "HIGH",
+        "transition-all",
+        "Avoid `transition: all`; name transform, opacity, color, or background explicitly.",
+    )
+    add_regex_findings(
+        findings,
+        path,
+        text,
+        r"\bease-in\b",
+        "HIGH",
+        "ease-in-ui",
+        "Avoid `ease-in` for UI motion; use a strong ease-out for entrances and responses.",
+    )
+    add_regex_findings(
+        findings,
+        path,
+        text,
+        r"scale(?:3d|X|Y)?\(\s*0(?:\.0+)?\s*\)",
+        "HIGH",
+        "scale-zero",
+        "Avoid `scale(0)`; start near `scale(0.95)` with opacity.",
+    )
+    add_regex_findings(
+        findings,
+        path,
+        text,
+        r"transform-origin\s*:\s*center",
+        "MEDIUM",
+        "origin-center",
+        "`transform-origin: center` is wrong for trigger-anchored popovers, menus, and tooltips. Confirm this is a modal or change it.",
+    )
+
+    transition_prop_pattern = r"transition(?:-property)?\s*:\s*([^;\n}]+)"
+    for match in re.finditer(transition_prop_pattern, text, re.I):
+        value = match.group(1)
+        for prop in LAYOUT_PROPERTIES:
+            if re.search(rf"\b{re.escape(prop)}\b", value, re.I):
+                findings.append(
+                    Finding(
+                        "HIGH",
+                        path,
+                        line_number(text, match.start()),
+                        "layout-transition",
+                        f"Transition includes `{prop}`; prefer transform or opacity.",
+                    )
+                )
+
+    duration_context = re.compile(
+        r"(?:transition|animation|duration|delay)[^;\n}]*?(?<![\w.])(\d+(?:\.\d+)?|\.\d+)(ms|s)\b",
+        re.I,
+    )
+    for match in duration_context.finditer(text):
+        amount = float(match.group(1))
+        unit = match.group(2).lower()
+        ms = amount * 1000 if unit == "s" else amount
+        if 300 < ms <= 2000:
+            findings.append(
+                Finding(
+                    "MEDIUM",
+                    path,
+                    line_number(text, match.start()),
+                    "long-duration",
+                    f"Duration `{match.group(0)}` exceeds the 300ms UI budget. Keep only if this is marketing, modal, drawer, or explained motion.",
+                )
+            )
+
+    if path.suffix != ".html" and has_motion and not has_reduced_motion:
+        findings.append(
+            Finding(
+                "MEDIUM",
+                path,
+                1,
+                "missing-reduced-motion",
+                "File contains motion but no visible reduced-motion branch.",
+            )
+        )
+
+    if has_hover_motion and not has_pointer_gate:
+        findings.append(
+            Finding(
+                "MEDIUM",
+                path,
+                1,
+                "ungated-hover-motion",
+                "Hover motion should be gated with `@media (hover: hover) and (pointer: fine)`.",
+            )
+        )
+
+    return findings
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Audit common motion craft failures.")
+    parser.add_argument("paths", nargs="+", type=Path, help="Files or directories to scan")
+    parser.add_argument("--max-findings", type=int, default=200, help="Stop printing after this many findings")
+    args = parser.parse_args()
+
+    files = iter_files(args.paths)
+    findings: list[Finding] = []
+    for file_path in files:
+        findings.extend(audit_file(file_path))
+
+    if not findings:
+        print(f"Motion audit passed: scanned {len(files)} files.")
+        return 0
+
+    order = {"HIGH": 0, "MEDIUM": 1, "LOW": 2}
+    findings.sort(key=lambda item: (order.get(item.severity, 9), str(item.path), item.line, item.rule))
+
+    print(f"Motion audit found {len(findings)} finding(s) across {len(files)} file(s):")
+    for finding in findings[: args.max_findings]:
+        print(f"{finding.severity} {finding.path}:{finding.line} [{finding.rule}] {finding.message}")
+
+    if len(findings) > args.max_findings:
+        print(f"... {len(findings) - args.max_findings} more finding(s) hidden by --max-findings.")
+
+    return 1 if any(item.severity == "HIGH" for item in findings) else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/skills/tastemaker/scripts/check_contrast.py

@@ -0,0 +1,166 @@
+#!/usr/bin/env python3
+"""
+WCAG contrast ratio checker for two hex colors, a whole palette, or the full
+pairing matrix of a palette.
+
+Why this exists: a palette (whether hand-picked, extracted from a reference
+image, or a user-supplied brand color) can look fine as a swatch and still
+fail contrast once it's actually used as text-on-background or a button
+label. The easiest miss is checking body-text-on-background and stopping
+there — a Primary/Accent color can pass that check and still be illegible
+as a button fill with white label text. This script checks pairs directly
+against the real WCAG math instead of eyeballing it.
+
+The deeper miss is time: a palette that passed for the pairings you enumerated
+at authoring time can still fail the moment the model uses two of its colors
+in a pairing you never listed. --matrix answers "which of these colors may
+legally touch which," so the lock certifies the palette as *usable*, not just
+as authored. See the contract described in references/style-lock-format.md.
+
+Usage:
+    # single pair
+    python3 check_contrast.py 050315 fbfbfe
+    python3 check_contrast.py "#050315" "#FBFBFE"
+
+    # a five-role palette: checks the critical pairings and PASS/FAILs
+    python3 check_contrast.py --palette text=050315 bg=fbfbfe primary=2f27ce \
+        secondary=dedcff accent=433bff
+
+    # the full pairing matrix: every color pair, classified by which floor it
+    # clears, plus a legal-pairings summary to record in the style lock.
+    # Include a label color (e.g. on-primary=ffffff) to see button-label legality.
+    python3 check_contrast.py --matrix text=e6e6ea bg=0b0d12 surface=161a21 \
+        primary=047857 accent=34d399 border=232a33 on-primary=ffffff
+
+Exit code: --palette and single-pair exit nonzero if any checked pairing fails
+its floor. --matrix is a report and exits 0 (it does not know each pair's
+intended use, so it classifies rather than pass/fails).
+"""
+
+import sys
+
+AA_NORMAL = 4.5        # body text on its background
+AA_LARGE_OR_UI = 3.0   # large text, UI components, graphical objects (WCAG 1.4.11)
+
+
+def _linearize(c):
+    c = c / 255
+    return c / 12.92 if c <= 0.03928 else ((c + 0.055) / 1.055) ** 2.4
+
+
+def _luminance(hex_color):
+    hex_color = hex_color.lstrip("#")
+    if len(hex_color) != 6:
+        raise ValueError(f"expected a 6-digit hex color, got {hex_color!r}")
+    r, g, b = (int(hex_color[i:i + 2], 16) for i in (0, 2, 4))
+    return 0.2126 * _linearize(r) + 0.7152 * _linearize(g) + 0.0722 * _linearize(b)
+
+
+def ratio(hex1, hex2):
+    l1, l2 = _luminance(hex1), _luminance(hex2)
+    l1, l2 = max(l1, l2), min(l1, l2)
+    return (l1 + 0.05) / (l2 + 0.05)
+
+
+def report(label, hex1, hex2, floor=AA_NORMAL):
+    r = ratio(hex1, hex2)
+    status = "PASS" if r >= floor else "FAIL"
+    print(f"[{status}] {label}: {r:.2f}:1 (floor {floor}:1) — #{hex1.lstrip('#')} vs #{hex2.lstrip('#')}")
+    return r >= floor
+
+
+def parse_roles(args):
+    roles = {}
+    for kv in args:
+        if "=" not in kv:
+            print(f"Bad argument (expected role=hex): {kv}", file=sys.stderr)
+            sys.exit(1)
+        k, v = kv.split("=", 1)
+        roles[k] = v.lstrip("#")
+    return roles
+
+
+def run_matrix(roles):
+    names = list(roles.keys())
+    pairs = []
+    for i in range(len(names)):
+        for j in range(i + 1, len(names)):
+            a, b = names[i], names[j]
+            pairs.append((a, b, ratio(roles[a], roles[b])))
+    pairs.sort(key=lambda p: -p[2])
+
+    text_safe, ui_safe, decorative = [], [], []
+    print(f"== Contrast matrix ({len(names)} roles, {len(pairs)} pairs) ==")
+    for a, b, r in pairs:
+        if r >= AA_NORMAL:
+            cls = "text-safe (>=4.5)"
+            text_safe.append(f"{a}/{b}")
+        elif r >= AA_LARGE_OR_UI:
+            cls = "UI-safe  (>=3.0)"
+            ui_safe.append(f"{a}/{b}")
+        else:
+            cls = "decorative (<3.0)"
+            decorative.append(f"{a}/{b}")
+        print(f"  {a:<12} x {b:<12} {r:6.2f}  {cls}")
+
+    print()
+    print("== Legal pairings (record these in the style lock) ==")
+    print(f"  Text-safe   (body text, links, button labels on a fill; >=4.5): {', '.join(text_safe) or 'none'}")
+    print(f"  UI-safe     (large text, icons, and borders that convey state; >=3.0 and <4.5): {', '.join(ui_safe) or 'none'}")
+    print(f"  Decorative  (below 3.0; fine as a subtle hairline, must NOT be the only thing conveying state): {', '.join(decorative) or 'none'}")
+    return pairs
+
+
+def main():
+    args = sys.argv[1:]
+    if not args:
+        print(__doc__, file=sys.stderr)
+        sys.exit(1)
+
+    if args[0] == "--matrix":
+        roles = parse_roles(args[1:])
+        if len(roles) < 2:
+            print("--matrix needs at least two role=hex colors.", file=sys.stderr)
+            sys.exit(1)
+        run_matrix(roles)
+        sys.exit(0)
+
+    all_pass = True
+
+    if args[0] == "--palette":
+        roles = parse_roles(args[1:])
+
+        missing = {"text", "bg"} - roles.keys()
+        if missing:
+            print(f"--palette requires at least text= and bg=; missing {missing}", file=sys.stderr)
+            sys.exit(1)
+
+        all_pass &= report("body text / background", roles["text"], roles["bg"], AA_NORMAL)
+
+        # Primary is treated as a solid CTA fill (role definition: "main CTAs"),
+        # so it needs a label color that's actually readable on it. Whichever
+        # of white/dark-text passes is the one to use for button labels.
+        if "primary" in roles:
+            white_ok = report("white label / primary fill", "ffffff", roles["primary"], AA_NORMAL)
+            dark_ok = report(f"dark text ({roles['text']}) / primary fill", roles["text"], roles["primary"], AA_NORMAL)
+            if not (white_ok or dark_ok):
+                print(f"  -> NEITHER white nor {roles['text']} text is readable on primary #{roles['primary']} — darken/lighten primary, don't just pick a label color and hope.")
+            all_pass &= (white_ok or dark_ok)
+            all_pass &= report("primary / background (visibility, UI-component floor)", roles["primary"], roles["bg"], AA_LARGE_OR_UI)
+
+        # Accent's own role (hyperlinks, highlights, small pops — not a solid
+        # button fill) only needs the lighter UI-component/large-text floor
+        # against the background, not full text-on-fill contrast.
+        if "accent" in roles:
+            all_pass &= report("accent / background (visibility + hyperlink-text floor)", roles["accent"], roles["bg"], AA_LARGE_OR_UI)
+    else:
+        if len(args) != 2:
+            print("Usage: check_contrast.py <hex1> <hex2>  OR  --palette role=hex ...  OR  --matrix role=hex ...", file=sys.stderr)
+            sys.exit(1)
+        all_pass = report("given pair", args[0], args[1], AA_NORMAL)
+
+    sys.exit(0 if all_pass else 1)
+
+
+if __name__ == "__main__":
+    main()

package/skills/tastemaker/scripts/check_domains.py

@@ -0,0 +1,158 @@
+#!/usr/bin/env python3
+"""Fail the build if the skill references any domain that is not explicitly vetted.
+
+This exists because a security audit found a flagged phishing domain
+(`logoyoyo.com`) recommended inside this skill's own documentation. Removing it
+once is not a fix — the fix is that it, or anything like it, cannot come back
+without someone deliberately editing the allowlist in this file.
+
+What it does:
+  * walks every text file in the skill (and optionally the whole repo),
+  * extracts every http(s) URL and bare domain reference,
+  * fails on anything in DENY (known-bad, permanently banned),
+  * fails on anything not in the vetted allowlist.
+
+Usage:
+    python3 scripts/check_domains.py                # scan the skill
+    python3 scripts/check_domains.py <path> [...]   # scan specific paths
+
+Exit code 0 = clean, 1 = unvetted or banned domain found.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from _netguard import ALLOWED_HOSTS  # noqa: E402
+
+# Permanently banned. Removed after a security audit flagged it as a phishing
+# risk with an unverifiable license. Never reintroduce.
+DENY = {
+    "logoyoyo.com": "flagged as a phishing risk by security scanners; license was never verifiable",
+}
+
+# Domains the skill is allowed to *mention* in docs or fetch from. The network
+# allowlist (ALLOWED_HOSTS in _netguard.py) is folded in automatically, so the
+# runtime guard and this static check can never drift apart.
+DOC_ALLOWED = {
+    # source hosting / the project itself
+    "github.com", "raw.githubusercontent.com", "githubusercontent.com",
+    "codeswithroh.github.io", "tastemaker-skill.online", "tastemaker-skill.pages.dev",
+    "skills.sh", "www.skills.sh",
+    # asset + font sources documented in the skill
+    "undraw.co", "openverse.org", "iconify.design", "pixabay.com",
+    "fonts.googleapis.com", "fonts.gstatic.com", "streamlinehq.com",
+    # component registries (references/component-sourcing.md)
+    "ui.shadcn.com", "registry.watermelon.sh", "kokonutui.com", "ui.bklit.com",
+    "21st.dev", "motion.dev", "npmjs.com", "unpkg.com",
+    # tooling / standards referenced in docs
+    "developer.mozilla.org", "www.w3.org", "w3.org", "wcag.com",
+    "gsap.com", "greensock.com", "vercel.com", "linear.app",
+    "buy.polar.sh", "polar.sh", "fazier.com", "producthunt.com",
+    "creativecommons.org", "opensource.org", "choosealicense.com",
+    "schema.org", "developers.cloudflare.com",
+    # design references cited in the docs (studied, linked, or named as
+    # anti-references — all reachable, reputable, none fetched automatically)
+    "coolors.co", "fontpair.co", "realtimecolors.com", "make.design",
+    "motionsites.ai", "grayblocks.net", "symbolfyi.com", "www.typotheque.com",
+    "typotheque.com", "framer.com", "webflow.com",
+}
+
+ALLOWED = DOC_ALLOWED | set(ALLOWED_HOSTS)
+
+URL_RE = re.compile(r"https?://([A-Za-z0-9.\-]+)")
+# Bare domain mentions in prose, e.g. "logoyoyo.com is a library of…"
+BARE_RE = re.compile(
+    r"\b((?:[a-z0-9](?:[a-z0-9\-]*[a-z0-9])?\.)+"
+    r"(?:com|net|org|io|dev|ai|sh|co|app|design|co\.uk))\b"
+)
+
+SKIP_DIRS = {".git", "node_modules", "dist", ".wrangler", "__pycache__", "out", ".venv"}
+# The guard files themselves necessarily contain both the banned domain (as a
+# DENY entry) and lookalike test strings. Scanning them would be self-defeating.
+SELF = {"check_domains.py", "_netguard.py", "test_security.py"}
+TEXT_EXT = {
+    ".md", ".py", ".js", ".jsx", ".ts", ".tsx", ".html", ".css",
+    ".json", ".yml", ".yaml", ".txt", ".toml", ".svg",
+}
+
+
+def is_allowed(host: str) -> bool:
+    host = host.lower().strip(".")
+    if host in ALLOWED:
+        return True
+    return any(host.endswith("." + a) for a in ALLOWED)
+
+
+def banned_reason(host: str) -> str | None:
+    host = host.lower().strip(".")
+    for bad, why in DENY.items():
+        if host == bad or host.endswith("." + bad):
+            return why
+    return None
+
+
+def scan_file(path: str):
+    try:
+        with open(path, "r", encoding="utf-8", errors="ignore") as fh:
+            lines = fh.readlines()
+    except OSError:
+        return
+    for n, line in enumerate(lines, 1):
+        hosts = set(URL_RE.findall(line)) | set(BARE_RE.findall(line))
+        for host in hosts:
+            why = banned_reason(host)
+            if why:
+                yield n, host, f"BANNED — {why}", line.strip()[:110]
+            elif not is_allowed(host):
+                yield n, host, "not in the vetted allowlist", line.strip()[:110]
+
+
+def walk(roots):
+    for root in roots:
+        if os.path.isfile(root):
+            yield root
+            continue
+        for dirpath, dirnames, filenames in os.walk(root):
+            dirnames[:] = [d for d in dirnames if d not in SKIP_DIRS]
+            for fn in filenames:
+                if fn in SELF:
+                    continue
+                if os.path.splitext(fn)[1].lower() in TEXT_EXT:
+                    yield os.path.join(dirpath, fn)
+
+
+def main() -> int:
+    roots = sys.argv[1:] or [os.path.dirname(os.path.dirname(os.path.abspath(__file__)))]
+    findings = []
+    scanned = 0
+    for path in walk(roots):
+        scanned += 1
+        for n, host, why, ctx in scan_file(path):
+            findings.append((path, n, host, why, ctx))
+
+    if not findings:
+        print(f"Domain check passed: {scanned} files, 0 unvetted domains.")
+        return 0
+
+    banned = [f for f in findings if f[3].startswith("BANNED")]
+    for path, n, host, why, ctx in findings:
+        rel = os.path.relpath(path)
+        print(f"{'BANNED' if why.startswith('BANNED') else 'UNVETTED'} {rel}:{n}  {host}")
+        print(f"    {why}")
+        print(f"    {ctx}")
+    print(
+        f"\n{len(findings)} finding(s) across {scanned} files "
+        f"({len(banned)} banned).\n"
+        "If a domain is legitimate, add it to DOC_ALLOWED in this file "
+        "(or ALLOWED_HOSTS in _netguard.py if the skill fetches from it) "
+        "with a real reason. Never add anything in DENY."
+    )
+    return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/skills/tastemaker/scripts/export_favicons.py

@@ -0,0 +1,129 @@
+#!/usr/bin/env python3
+"""
+Export a project's logo mark to standard favicon and OG-card sizes.
+
+Why this exists: `ideagram/scripts/export_png.py` covers illustration export
+at social/presentation sizes, but a logo mark (the output of
+`references/logo-sourcing.md`) needs a different, smaller set of sizes —
+favicon.ico, apple-touch-icon, and a manifest icon — that no other script in
+this skill produces. Skipping this step is what leaves a generated site with
+a browser-default blank-page icon even though a real logo mark exists on disk.
+
+Requires cairosvg (pip install cairosvg) + Pillow, same as export_png.py.
+Degrades the same way: if either is missing, this says so plainly and exits
+nonzero rather than silently producing nothing — the source SVG remains
+usable directly in an <img> tag regardless.
+
+Usage:
+    python3 export_favicons.py logo-mark.svg --out design/assets/favicons/
+
+Produces:
+    favicon-16.png, favicon-32.png, favicon-48.png   (browser tab icon)
+    apple-touch-icon.png (180x180)                    (iOS home screen)
+    icon-192.png, icon-512.png                        (PWA manifest icons)
+    favicon.ico                                       (multi-size, legacy browsers)
+    og-card.png (1200x630)                             (link preview / social share)
+"""
+
+import sys
+import os
+import argparse
+
+SQUARE_SIZES = {
+    "favicon-16": 16,
+    "favicon-32": 32,
+    "favicon-48": 48,
+    "apple-touch-icon": 180,
+    "icon-192": 192,
+    "icon-512": 512,
+}
+OG_SIZE = (1200, 630)
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("svg_path")
+    parser.add_argument("--out", default="design/assets/favicons", help="Output directory")
+    parser.add_argument("--skip-og", action="store_true", help="Skip the 1200x630 OG-card render (favicon sizes only)")
+    args = parser.parse_args()
+
+    try:
+        import cairosvg
+    except ImportError:
+        print(
+            "cairosvg not installed. Run `pip install cairosvg` to enable favicon export.\n"
+            "Until then, the SVG itself still works directly as a favicon in modern "
+            "browsers via <link rel=\"icon\" type=\"image/svg+xml\" href=\"...\">, just "
+            "without the legacy .ico/apple-touch-icon/manifest sizes.",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+    except OSError as e:
+        print(
+            f"cairosvg is installed but couldn't load the native cairo library ({e}).\n"
+            "Install it at the system level, then retry:\n"
+            "  macOS:          brew install cairo\n"
+            "  Debian/Ubuntu:  sudo apt install libcairo2",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    try:
+        from PIL import Image
+    except ImportError:
+        print("Pillow not installed. Run `pip install Pillow` (needed for centering + writing the multi-size .ico).", file=sys.stderr)
+        sys.exit(1)
+
+    if not os.path.exists(args.svg_path):
+        print(f"File not found: {args.svg_path}", file=sys.stderr)
+        sys.exit(1)
+
+    os.makedirs(args.out, exist_ok=True)
+
+    def render_square(size):
+        temp_png = os.path.join(args.out, f".render-{size}.png")
+        cairosvg.svg2png(url=args.svg_path, write_to=temp_png, output_width=size * 2, output_height=size * 2)
+        img = Image.open(temp_png).convert("RGBA")
+        scale = min(size / img.width, size / img.height)
+        new_size = (max(1, int(img.width * scale)), max(1, int(img.height * scale)))
+        img = img.resize(new_size, Image.LANCZOS)
+        canvas = Image.new("RGBA", (size, size), (0, 0, 0, 0))
+        canvas.paste(img, ((size - new_size[0]) // 2, (size - new_size[1]) // 2), img)
+        os.remove(temp_png)
+        return canvas
+
+    rendered = {}
+    for label, size in SQUARE_SIZES.items():
+        img = render_square(size)
+        dest = os.path.join(args.out, f"{label}.png")
+        img.save(dest)
+        rendered[size] = img
+        print(f"Exported {dest} ({size}x{size})")
+
+    ico_dest = os.path.join(args.out, "favicon.ico")
+    ico_sizes = [s for s in (16, 32, 48) if s in rendered]
+    rendered[ico_sizes[0]].save(
+        ico_dest,
+        format="ICO",
+        sizes=[(s, s) for s in ico_sizes],
+    )
+    print(f"Exported {ico_dest} (multi-size: {ico_sizes})")
+
+    if not args.skip_og:
+        w, h = OG_SIZE
+        temp_png = os.path.join(args.out, ".render-og.png")
+        cairosvg.svg2png(url=args.svg_path, write_to=temp_png, output_width=w, output_height=h)
+        img = Image.open(temp_png).convert("RGBA")
+        scale = min(w / img.width, h / img.height) * 0.6  # logo mark shouldn't fill the whole OG card
+        new_size = (max(1, int(img.width * scale)), max(1, int(img.height * scale)))
+        img = img.resize(new_size, Image.LANCZOS)
+        canvas = Image.new("RGBA", (w, h), (0, 0, 0, 0))
+        canvas.paste(img, ((w - new_size[0]) // 2, (h - new_size[1]) // 2), img)
+        os.remove(temp_png)
+        dest = os.path.join(args.out, "og-card.png")
+        canvas.save(dest)
+        print(f"Exported {dest} ({w}x{h}) — a bare centered mark; if the OG card needs a wordmark/background too, compose that in code rather than relying on this alone.")
+
+
+if __name__ == "__main__":
+    main()