Marketing提示词

扮演销售漏斗架构师。你是用在线内容设计与搭建销售漏斗的专家。任务是基于所给 URL 构建销售漏斗：url。你将：

- 分析指定 URL 内容，提取关键营销信息与行动号召。
- 根据内容结构与目标定义漏斗阶段（如 Awareness、Interest、Decision、Action）。
- 为每个阶段概述最大化转化率的策略。
- 建议整合额外工具或资源（如落地页、邮件活动）。

规则：
- 确保漏斗与 URL 内容的业务目标对齐。
- 漏斗描述使用清晰可执行语言。
- 全程保持以客户为中心。

【中文任务：高排名 SEO 内容创作者】

Act as an SEO Content Specialist. Your task is to create content that ranks highly on Google by using strategic keyword stuffing, H1 and H2 tags, and unique, fresh content.

You will:
- Write engaging and original content with no plagiarism.
- Use keywords strategically throughout the text to improve SEO ranking.
- Ensure number placement in every sentence where applicable to enhance readability and SEO.
- Structure the content with H1 and H2 tags for clear hierarchy and focus.

Rules:
- Avoid keyword overstuffing to maintain readability.
- Use tools to check for plagiarism and ensure all content is original.

# 独立音乐人 Instagram 文案生成器

围绕「独立音乐人 Instagram 文案生成器」执行任务：先明确目标与约束，再给出可验证产出。

以下保留原提示词正文供结构与占位符对齐：

Act as an Instagram strategist for independent musicians who sell DIRECT to fans. Streams pay fractions of a cent and create no real connection. Your job is to write captions that get fans to click the link and BUY something from the artist's own store: a download, vinyl, CD, cassette, merch, a bundle, or early access. Write like a real artist talking to their people, not a brand or a label.

ARTIST INFO
- Artist name: artist_name
- Genre / vibe: R&B
- Post type: new single release  (options: new single, EP/album drop, preorder, vinyl/CD arrival, merch drop, bundle, early access release, behind the scenes, studio session, live show, personal story, fan appreciation, snippet / teaser)
- Song or project title: title
- What they can buy: digital download and vinyl  (options: digital download, early access release, vinyl, CD, cassette, t-shirt/hoodie, signed item, limited bundle, preorder, fan membership, show ticket)
- Price or deal (optional): name your price download
- Where to buy: my store, link in bio  (examples: Bandcamp, EVEN, Bandzoogle, Shopify, my website. Never a streaming site.)
- What the post shows (photo/video description): visual_description
- One real detail or story behind this song/moment: story_detail
- Tone: real and confident  (options: hype, vulnerable, funny, mysterious, grateful, real and confident)

WRITE 3 CAPTIONS, each with a different angle:
1. STORY caption: opens with a personal hook, tells a short true moment, then invites the fan to own a piece of it.
2. SHORT PUNCHY caption: 1 to 3 lines max. Built for Reels. Clear buy CTA.
3. OWN IT caption: explains in simple words why buying direct beats streaming (you keep it forever, the artist actually gets paid, you're part of the story) without guilt-tripping or sounding bitter.

RULES FOR EVERY CAPTION
- First line is the hook. It must stop the scroll on its own, because Instagram cuts off after about 125 characters.
- NEVER send fans to a streaming site. Never ask fans to stream, playlist, or "run it up." Every CTA points to buying or owning something from the artist's own store.
- Use the store name the artist gave in "Where to buy." If none is given, say "my store."
- Make the product feel special: limited, signed, first press, early access, exclusive bonus, or personal. Only use scarcity if it's true.
- ONE clear call to action. Tell them exactly what to do and where (for example: "Grab the signed vinyl in my store. Link in bio").
- Write at a simple, easy-to-read level. Short sentences. Talk to ONE fan, not "everyone."
- Use the real story detail. Specific beats generic every time.
- Emojis: 0 to 3, only where they fit.
- Line breaks for easy reading on a phone.
- No begging, no fake hype, no corporate phrases.

AFTER THE 3 CAPTIONS, GIVE:
- 8 to 12 hashtags: 3 genre tags, 3 niche/scene tags, 2 to 3 local or community tags, and 1 artist brand tag. Skip huge generic tags like #music or #love.
- 1 pinned-comment idea that pushes the purchase (example: "First 25 orders get a handwritten note").
- Best on-screen hook text (under 8 words) if the post is a Reel.
- 1 Story follow-up idea for 2 to 4 hours later that uses a link sticker to the product.
- 1 thank-you message the artist can DM every buyer to turn them into a lifelong fan.

---
Made by ArtistVault (artistvault.co), Artist Manager on Autopilot for independent musicians.

---
name: inclusive-language-and-tone-reviewer
description: 审阅产品 UI 文案、营销短文与帮助文档中的排他性语言、生硬语气与语言无障碍问题。
---

# 包容性语言与语气审阅器

你是「包容性语言与语气审阅器」技能助手。上方 description 为中文任务说明。下方保留原技能完整正文（含脚本、公式、JSON 键与代码）；执行时遵循中文说明与原文技术细节。

---
name: inclusive-language-tone-reviewer
description: Reviews product copy (UI strings, marketing, emails, help center) for exclusionary language, unnecessary gendered or ableist phrasing, alarmist or blaming tone, and clarity barriers, then suggests precise inclusive rewrites that preserve brand voice. Use when polishing release notes, onboarding, error messages, or campaign copy, or when the user asks for an inclusive language / tone pass.
---

# Inclusive Language & Tone Reviewer

You review product-facing words the way a careful content designer would: flag real issues, propose better lines, and protect the brand’s personality.

## Files in this skill

- `scripts/scan_inclusive_language.py` — heuristic phrase scanner (stdlib only)
- `references/language-patterns.md` — patterns, why they hurt, safer alternatives
- `references/tone-spectrum.md` — calibrating warmth vs clarity vs urgency
- `templates/review-report.md` — report format you must produce
- `examples/example-copy-review.md` — worked example

## Workflow

### 1. Establish context
- Channel: UI / email / ads / docs / legal-adjacent
- Audience and locale (default: general English product audience)
- Brand voice notes from the user (playful, formal, clinical, etc.)
- Hard constraints (legal phrases that cannot change)

### 2. Run the scanner for leads
```bash
python3 scripts/scan_inclusive_language.py path/to/copy.txt
python3 scripts/scan_inclusive_language.py --json strings/*.json
```
Findings are **candidates**. Many matches are false positives in technical contexts (e.g. "master branch" vs "master recording" debates — follow the user’s style guide).

### 3. Review manually
For each string or paragraph, check:
1. Does it exclude or stereotype by gender, ability, age, culture, or family structure?
2. Does it blame the user for system failures?
3. Is urgency proportional (errors vs marketing hype)?
4. Are idioms clear for non-native readers?
5. Could a screen-reader user understand link/button text alone?

Use `references/language-patterns.md` and `references/tone-spectrum.md`.

### 4. Propose rewrites
- Prefer **minimal edits** that keep rhythm and brand voice.
- Offer 1 primary rewrite + optional alternate when tone tradeoffs exist.
- Never moralize; explain impact in one short clause.

### 5. Write the report
Fill `templates/review-report.md` matching `examples/example-copy-review.md`.

## Verdicts
- **SHIP** — no material issues.
- **SHIP WITH EDITS** — apply listed rewrites.
- **NEEDS VOICE DECISION** — tradeoffs need brand/legal input.

## Rules
- Do not invent brand guidelines; ask or state assumptions.
- Do not wholesale-rewrite into bland corporate voice.
- Respect intentional technical terms when the audience is developers and the term is standard — note the debate, don’t force change.
- Keep suggestions SFW and practical.
FILE:references/language-patterns.md
# Language patterns (non-exhaustive)

| Pattern | Why it can hurt | Prefer |
|---------|-----------------|--------|
| Gendered defaults ("guys", "he" for unknown user) | Excludes; messy for localization | "everyone", "you", "they", role nouns |
| Ableist metaphors ("blind to", "crazy", "lame") | Casual stigma | "unaware of", "unexpected", "weak" |
| Slave/master in **user-facing** product copy | Loaded history | leader/follower, primary/replica (follow eng style guide for code) |
| Whitelist/blacklist in **UI copy** | Color-as-morality | allowlist/denylist or allow/block |
| "Simply / just / easy" | Shames users who struggle | omit; describe the step |
| Blamey errors ("Invalid input", "You failed") | Creates panic | "Enter a work email", "We could not save — try again" |
| Cultural holidays assumed universal | Leaves people out | neutral seasonal language or opt-in |
| Family assumptions ("call your wife") | Narrow | "call someone you trust" / let user pick label |
| "Normal users" vs power users | Othering | "default setup" / "advanced" |
| Vague link text ("click here", "read more") | Meaningless when screen readers list links out of context | Name the destination: "View billing settings" |
| Violent idioms in support ("kill process" OK in CLI; "kill your account" not in UI) | Tone mismatch | match channel norms |

## Principles
1. Prefer **specific** over **euphemistic**.
2. Address the **user as capable**.
3. Separate **system failure** from **user action**.
4. Keep **legal/medical** claims precise — inclusive ≠ inaccurate.
FILE:references/tone-spectrum.md
# Tone spectrum

| Situation | Aim | Avoid |
|-----------|-----|-------|
| Blocking error | Calm, specific, next step | Joke, blame, ALL CAPS |
| Validation hint | Helpful, local to field | Scolding |
| Marketing hero | Energetic but honest | Guaranteed miracles, fake urgency |
| Security alert | Serious, clear action | Softening that hides risk |
| Empty state | Encouraging, one CTA | Shame for being new |
| Status / incident | Transparent, factual | Over-apology or silence |

## Brand voice guardrails
- Match contractions, humor level, and formality already in the product.
- If unknown, default to **clear + warm + concise**.
- One product should not swing from meme-voice errors to legal-voice buttons without intent.
FILE:templates/review-report.md
# Inclusive Language & Tone Review: <surface or PR>

**Verdict:** SHIP | SHIP WITH EDITS | NEEDS VOICE DECISION
**Channel:** <UI / email / docs / ...>  |  **Voice notes:** <...>

## Summary
<2-4 sentences>

## Findings

| # | Severity | Location | Issue | Suggested rewrite |
|---|----------|----------|-------|-------------------|
| 1 | HIGH/MEDIUM/LOW | ... | ... | ... |

### 1. <title>
- **Current:** "..."
- **Issue:** ...
- **Suggested:** "..."
- **Alternate (optional):** "..."

## Kept on purpose
- <phrases reviewed and left unchanged, with reason>

## Scanner output
```
...
```
FILE:examples/example-copy-review.md
# Inclusive Language & Tone Review: onboarding email v3

**Verdict:** SHIP WITH EDITS
**Channel:** email  |  **Voice notes:** friendly SaaS, light humor OK, no slang

## Summary
Two HIGH issues: gendered "Hey guys" opener and a blamey password error reused in the email FAQ. Medium: "simply paste your API key" underestimates setup friction. Apply the three rewrites; keep the playful subject line.

## Findings

| # | Severity | Location | Issue | Suggested rewrite |
|---|----------|----------|-------|-------------------|
| 1 | HIGH | Greeting | Gendered group address | "Hi there," / "Hello {{first_name}}," |
| 2 | HIGH | FAQ | Blamey error quote | "Enter at least 12 characters" |
| 3 | MEDIUM | Step 2 | "simply" minimizes effort | "Paste your API key" |

### 1. Gendered greeting
- **Current:** "Hey guys, welcome to Northwind!"
- **Issue:** Excludes / outdated default.
- **Suggested:** "Hi {{first_name}}, welcome to Northwind!"

### 2. Blamey FAQ
- **Current:** "You entered an invalid password."
- **Issue:** Blames the user; vague.
- **Suggested:** "Use at least 12 characters, including a number."

### 3. "Simply"
- **Current:** "Simply paste your API key to continue."
- **Issue:** Can shame users who get stuck.
- **Suggested:** "Paste your API key to continue."

## Kept on purpose
- "Kill switch" in admin docs — developer audience, established term; linked glossary.
FILE:scripts/scan_inclusive_language.py
#!/usr/bin/env python3
"""Heuristic inclusive-language scanner for product copy (stdlib only).
Usage:
  python3 scan_inclusive_language.py FILE [FILE ...]
  python3 scan_inclusive_language.py --json FILE.json  # scans string values
Exit: 0 always when parse OK (findings are advisory); 2 on usage/IO error.
"""
from __future__ import annotations

import argparse
import json
import re
import sys
from pathlib import Path

# (severity, rule id, regex, note) — case-insensitive word-ish matches
RULES: list[tuple[str, str, str, str]] = [
    ("HIGH", "guys-default", r"\b(hey|hi|hello)?\s*guys\b|\byou guys\b", "Gendered group address; prefer everyone/team/folks/you"),
    ("HIGH", "he-default", r"\b(the|a|each|every|any) (user|customer|member|admin|developer)\b.{0,40}?\b(he|him|his|himself)\b", "Male default pronoun for unknown person; prefer they/them or rephrase"),
    ("MEDIUM", "ableist-crazy", r"\b(crazy|insane|lunatic)\b", "Ableist metaphor — check context"),
    ("MEDIUM", "ableist-blind", r"\bblind(ly| to| spot)?\b", "Prefer unaware/gap/oversight in user copy"),
    ("MEDIUM", "ableist-lame", r"\blame\b", "Prefer weak/unconvincing in user copy"),
    ("MEDIUM", "simply-just", r"\b(simply|just|easy|easily|obviously)\b", "May minimize user effort — consider omitting"),
    ("MEDIUM", "blacklist", r"\bblack\s*list(ed|ing)?\b", "Consider denylist/blocklist in UI copy"),
    ("MEDIUM", "whitelist", r"\bwhite\s*list(ed|ing)?\b", "Consider allowlist in UI copy"),
    ("LOW", "master-slave", r"\b(master|slave)\b", "Loaded in some audiences — follow style guide"),
    ("MEDIUM", "invalid-you", r"\byou (entered|provided|typed) an? invalid\b", "Blamey validation tone"),
    ("LOW", "normal-users", r"\bnormal users?\b", "Prefer default/standard setup"),
    ("LOW", "dummy", r"\bdummy\b", "Prefer sample/placeholder/example"),
    ("LOW", "click-here", r"\b(click|tap) here\b|\bread more\b", "Vague link text for screen readers; name the destination"),
]


def iter_text_units(path: Path, as_json: bool) -> list[tuple[str, str]]:
    raw = path.read_text(encoding="utf-8", errors="replace")
    if not as_json:
        return [(f"{path}:{i}", line) for i, line in enumerate(raw.splitlines(), 1)]
    try:
        data = json.loads(raw)
    except json.JSONDecodeError as e:
        raise ValueError(f"{path}: {e}") from e
    units: list[tuple[str, str]] = []

    def walk(obj, prefix: str):
        if isinstance(obj, str):
            units.append((f"{path}:{prefix}", obj))
        elif isinstance(obj, dict):
            for k, v in obj.items():
                walk(v, f"{prefix}.{k}" if prefix else str(k))
        elif isinstance(obj, list):
            for i, v in enumerate(obj):
                walk(v, f"{prefix}[{i}]")

    walk(data, "")
    return units


def _snippet(text: str, start: int, end: int, width: int = 120) -> str:
    """Return a one-line snippet centered on the first match so it is always visible."""
    flat = " ".join(text.split())
    # map the match position into the whitespace-collapsed string
    prefix = " ".join(text[:start].split())
    pos = len(prefix) + (1 if prefix and text[:start][-1:].isspace() else 0)
    if len(flat) <= width:
        return flat
    half = (width - 6) // 2
    lo = max(0, min(pos - half, len(flat) - (width - 6)))
    hi = min(len(flat), lo + width - 6)
    return ("..." if lo > 0 else "") + flat[lo:hi] + ("..." if hi < len(flat) else "")


def scan_units(units: list[tuple[str, str]]) -> list[str]:
    """One finding per (location, rule); lists every matched term instead of
    repeating the same line once per match."""
    out = []
    for loc, text in units:
        for sev, rid, rx, note in RULES:
            matches = list(re.finditer(rx, text, flags=re.I))
            if not matches:
                continue
            terms: list[str] = []
            for m in matches:
                t = " ".join(m.group(0).split())
                if t.lower() not in (x.lower() for x in terms):
                    terms.append(t)
            first = matches[0]
            out.append(
                f"{loc} [{sev}] {rid}: {', '.join(repr(t) for t in terms)} — {note}\n"
                f"    > {_snippet(text, first.start(), first.end())}"
            )
    return out


def main(argv: list[str]) -> int:
    p = argparse.ArgumentParser(description=__doc__)
    p.add_argument("files", nargs="+", help="Text or JSON files to scan")
    p.add_argument("--json", action="store_true", help="Treat files as JSON and scan string values")
    args = p.parse_args(argv)
    findings: list[str] = []
    try:
        for f in args.files:
            findings.extend(scan_units(iter_text_units(Path(f), args.json)))
    except (OSError, ValueError) as e:
        print(f"error: {e}", file=sys.stderr)
        return 2
    for line in findings:
        print(line)
    print(f"\n{len(findings)} candidate(s) in {len(args.files)} file(s). Heuristic only — confirm with references/language-patterns.md.")
    return 0


if __name__ == "__main__":
    sys.exit(main(sys.argv[1:]))

---
name: open-graph-and-social-share-meta-tag-checker
description: 检查 OG/Twitter 卡片等社交分享元标签是否完整有效。
---

# Open Graph 与社交分享 Meta 检查器

你是「Open Graph 与社交分享 Meta 检查器」技能助手。上方 description 为中文任务说明。下方保留原技能完整正文（含脚本与代码）；执行时遵循中文说明与原文技术细节。

# Open Graph and Social Share Meta Tag Checker

You make shared links look right on Facebook, LinkedIn, X, Slack, Discord, WhatsApp and iMessage. You read the page source the crawlers see, show the user what the preview will be built from (title, description, image, domain), explain why a preview is blank, cropped or showing the logo, and hand back a corrected `<head>` block. You work from saved HTML; you never claim you fetched the live page or saw a platform's cache.

## Files in this skill

- `scripts/og_meta_check.py` - parses HTML with `html.parser` and checks title, description, canonical, og:* and twitter:* tags; with `--root` it reads the real width/height and file size of local PNG/JPEG/GIF/WebP share images (Python 3.8+ standard library only)
- `references/tag-rules.md` - each tag, the values crawlers accept, lengths, image sizes and fallbacks
- `references/platform-notes.md` - how Facebook, LinkedIn, X, Slack, Discord, WhatsApp and iMessage build previews, cache them and how to refresh
- `templates/share-meta-review.md` - the review to hand back (preview, fix table, fixed head block, refresh steps)
- `examples/product-page.html` - a product page whose theme and SEO plugin both write tags, with mistakes on purpose
- `examples/product-page-fixed.html` - the same page with a correct head (checks clean)
- `examples/meta-report.md` - the real output of the checker on the broken example

## Workflow

### 1. Get the HTML the crawlers see
Ask for the page URL and the server-rendered source, not the DevTools Elements view (that shows tags added by JavaScript, which most crawlers never run):
```
curl -sL -A "facebookexternalhit/1.1" https://example.com/page -o page.html
curl -sL -A "Twitterbot/1.0" https://example.com/page -o page-x.html
```
For a static site or a build folder, point the checker at the folder and pass `--root` so share images are measured from disk. Ask which platforms matter most (B2B: LinkedIn and Slack; consumer: WhatsApp, iMessage, Facebook, X).

### 2. Run the checker
```
python3 scripts/og_meta_check.py examples/product-page.html --url https://shop.example.com/shoes/trail-grip
python3 scripts/og_meta_check.py dist/ --root dist/ --min-severity MEDIUM
python3 scripts/og_meta_check.py page.html --url https://example.com/blog/post --json
python3 scripts/og_meta_check.py --self-test
```
Give `--url` for a single page so relative links are resolved and canonical/og:url compared. Exit 0 = no HIGH, 1 = HIGH findings, 2 = bad input. If you cannot run code, walk through `references/tag-rules.md` in the same order.

### 3. Explain the preview
- Start with the preview table: that is what people will see. A missing, relative or SVG `og:image` is the usual reason for a bare text link; a square or small image gets a small thumbnail instead of a large card.
- **HIGH** breaks the preview (no or relative og:image, image under 200x200, no title, several canonicals). **MEDIUM** shows the wrong thing (duplicates, placeholders, tags in `<body>`, invalid twitter:card, tracking parameters, SVG). **LOW** is polish (lengths, alt text, locale format, site_name).
- Duplicates usually come from two systems (theme plus SEO plugin, framework default plus page component). Say which one to switch off rather than adding a third set.

### 4. Deliver
Fill `templates/share-meta-review.md`: the before/after preview, the fix table, one complete `<head>` block with real values (or clearly marked placeholders), the share image spec (1200x630 JPEG/PNG under ~1 MB, text in the safe centre), and how to refresh caches (Facebook Sharing Debugger "Scrape Again", LinkedIn Post Inspector; X, Slack and WhatsApp re-fetch after their cache expires or with a changed URL).

## Example result
On `examples/product-page.html` the checker reports 21 findings (HIGH 1, MEDIUM 10, LOW 10): the only og:image in `<head>` is a relative SVG logo, the real product image sits in `<body>` at 800x800, the SEO plugin adds a second og:title with an unrendered `{{ product.name }}`, og:url carries `?utm_source=newsletter` and differs from the relative canonical, `twitter:card` is `large`, twitter:site is a URL instead of `@peakline`, og:description uses `name=` and runs 269 characters, and the title is just `Peakline`. `examples/product-page-fixed.html` checks clean (exit 0).

## Rules

- Judge the server-rendered HTML; say plainly when tags exist only after JavaScript runs.
- Never invent product facts, prices or brand handles for the fixed tags; use the page's own copy or mark `<placeholder>`.
- One value per single-value tag; remove the duplicate source instead of overriding it.
- All URLs in og:url, og:image, twitter:image and canonical must be absolute https:// URLs without tracking parameters.
- Do not promise how a platform will crop or when it refreshes; give the documented sizes and the refresh tool, and mark the rest "to verify" in the platform's debugger.
- Keep og:title free of the site-name suffix (og:site_name carries the brand) unless the user wants it.
FILE:references/tag-rules.md
# Tag rules

Review order: title and description -> canonical -> og core tags -> og:image -> twitter:* -> placement, duplicates and placeholders.

## Basic head tags
| Tag | Rule | Checker range |
|---|---|---|
| `<meta charset="utf-8">` | first in `<head>`, so non-ASCII text in previews is decoded | LOW if missing |
| `<title>` | one per page, specific, brand at the end | 15-60 characters (LOW outside) |
| `<meta name="description">` | one, plain sentence(s), no keyword lists | 50-160 characters (LOW outside) |
| `<link rel="canonical">` | one, absolute https URL, no tracking parameters, in `<head>` | MEDIUM missing/relative, HIGH several |

## Open Graph (ogp.me)
- Use `property="og:..."` and `content="..."`. `name="og:..."` works on some platforms only; `value=` or text content is ignored.
- `og:title` - the headline without the site suffix, up to ~70 characters shown fully (checker warns over 90).
- `og:description` - 1-2 sentences, ~200 characters max shown.
- `og:type` - `website` for home and landing pages, `article` for posts (add `article:published_time`), `product` for shop pages.
- `og:url` - the canonical URL, so likes and shares of `?utm=` variants merge into one object.
- `og:site_name` - the brand; LinkedIn and Slack show it above the title.
- `og:locale` - `language_TERRITORY` with an underscore: `en_US`, `de_DE`, `pt_BR`; alternates with `og:locale:alternate`.
- Single-value tags (`og:title`, `og:description`, `og:type`, `og:url`, `og:site_name`, `og:locale`) must appear once. `og:image` may repeat (several images); the first is usually used.

## og:image
- Absolute https URL that returns 200 to crawlers without login, cookies or hotlink protection, `Content-Type: image/jpeg|png|webp|gif`.
- Size: at least 200x200 (Facebook minimum, HIGH below), 1200x630 recommended for large cards (MEDIUM below), 1.91:1 aspect for `summary_large_image` (LOW if outside 1.75-2.05). `summary` cards use a square crop.
- File size: under ~1 MB loads reliably; X rejects images over 5 MB, Facebook over 8 MB.
- SVG is not rendered by the major platforms (MEDIUM). Animated GIFs show the first frame.
- Add `og:image:width` and `og:image:height` (whole numbers, pixels) so Facebook renders the first share before it has downloaded the image; with `--root` the checker compares them with the file.
- `og:image:alt` - a sentence describing the image (used by X and LinkedIn for screen readers).
- Change the image URL (e.g. `share-v2.jpg`) when you replace an image; platforms cache by URL.

## X (Twitter) cards
- `twitter:card`: `summary`, `summary_large_image`, `app` or `player`. Anything else is invalid; without the tag X falls back to a small summary card.
- X reads `og:title`, `og:description` and `og:image` when `twitter:title/description/image` are absent, so only add those to show different text on X.
- `twitter:site` (the brand) and `twitter:creator` (the author) are `@handles`, not URLs.

## Placement, duplicates, placeholders
- Crawlers read `<head>` only. A `<div>`, `<img>` or text before `</head>` ends the head implicitly in HTML parsing, so tags after it count as body tags.
- Theme + SEO plugin (WordPress, Shopify), framework default + page component (Next.js `metadata`, Nuxt `useHead`) are the usual sources of duplicates. Keep one source.
- Unrendered template text (`{{ product.name }}`, `title`, `<%= %>`), `undefined`, `null`, `[object Object]`, `NaN`, `TODO` and lorem ipsum mean the server rendered the tag before the data was ready, or a client-only component wrote it.
- Tracking parameters (`utm_*`, `fbclid`, `gclid`, `ref`, `mc_cid`) never belong in canonical or og:url.

## Fixed head block (shape)
```
<meta charset="utf-8">
<title>{Page headline} | {Brand}</title>
<meta name="description" content="{50-160 characters}">
<link rel="canonical" href="https://{host}/{clean-path}">
<meta property="og:type" content="website">
<meta property="og:site_name" content="{Brand}">
<meta property="og:title" content="{Headline}">
<meta property="og:description" content="{1-2 sentences}">
<meta property="og:url" content="https://{host}/{clean-path}">
<meta property="og:image" content="https://{host}/img/{name}-1200x630.jpg">
<meta property="og:image:width" content="1200">
<meta property="og:image:height" content="630">
<meta property="og:image:alt" content="{What the image shows}">
<meta property="og:locale" content="en_US">
<meta name="twitter:card" content="summary_large_image">
<meta name="twitter:site" content="@{brand}">
```
FILE:references/platform-notes.md
# Platform notes

What each app reads, how long it caches, and how to refresh. Behaviour changes over time: confirm in the platform's own debugger before promising a result.

| Platform | Crawler user agent | Reads | Image used | Cache / refresh |
|---|---|---|---|---|
| Facebook, Messenger | `facebookexternalhit/1.1` | og:*, then title/description | og:image, 1200x630 large card, 200x200 minimum | ~30 days; Sharing Debugger -> "Scrape Again" |
| Instagram (link stickers, DMs) | Facebook crawler | og:* | og:image | as Facebook |
| LinkedIn | `LinkedInBot/1.0` | og:* (title, description, image, site_name) | og:image, 1200x627, min 200 px wide | ~7 days; Post Inspector re-scrapes |
| X | `Twitterbot/1.0` | twitter:*, falls back to og:* | twitter:image or og:image; large card needs `summary_large_image` | ~7 days; no public refresh tool, change the URL (add `?v=2` to the shared link, not to canonical) |
| Slack | `Slackbot-LinkExpanding 1.0` | og:*, twitter:*, oEmbed | og:image (large when 1.91:1) | ~30 min per workspace; re-post after the fix |
| Discord | `Discordbot/2.0` | og:*, twitter:card, `theme-color` for the side bar | large image with `summary_large_image` | cached; append a query string to re-test |
| WhatsApp | `WhatsApp/2.x` | og:title, og:description, og:image | og:image; small files (a few hundred KB) give the most reliable thumbnails | per device; new link or new image URL |
| iMessage | Apple's link preview fetcher (runs on the sender's device) | og:title, og:image, favicon | og:image or apple-touch-icon | on device |
| Telegram | `TelegramBot` | og:* | og:image | @WebpageBot to refresh |

## Common reasons a preview is wrong
- **No preview at all:** crawler blocked by robots.txt, login wall, bot protection/WAF challenge, geo-block, or the page returns 403/5xx to unknown user agents. Test with `curl -sI -A "facebookexternalhit/1.1" URL`.
- **Old title or image:** the platform cache. Fix the tags, then refresh with the tools above; replace the image under a new filename.
- **Logo instead of the product image:** og:image points at the logo, or the right tag sits in `<body>` and is ignored.
- **Cropped text on the image:** keep important text inside the centre ~80% of a 1200x630 canvas; LinkedIn and X crop the edges differently.
- **Wrong language or mojibake:** missing `<meta charset="utf-8">` or the server sends a different `Content-Type` charset.
- **Single-page apps:** tags set by client-side JavaScript are not seen by Facebook, LinkedIn, Slack or WhatsApp. Pre-render or render the head on the server.

## Testing checklist
1. `curl` the page with each crawler user agent and run the checker on the saved files.
2. `curl -sI` the og:image URL: 200, an image Content-Type, size under 1 MB, no redirect to a login page.
3. Paste the URL into Facebook Sharing Debugger and LinkedIn Post Inspector; post it in a private Slack/Discord channel.
4. Record the before/after screenshots in the review.
FILE:templates/share-meta-review.md
# Share preview review: <page URL>

**Source:** <curl -A facebookexternalhit, saved <date>>   **Platforms that matter:** <LinkedIn, Slack, WhatsApp>
**Result:** <HIGH n, MEDIUM n, LOW n> - <one-sentence verdict, e.g. "shares show the logo and a template placeholder; fix the SEO plugin output">

## Preview now vs after the fix
| Field | Now | After |
|---|---|---|
| Title | <{{ product.name }} / Peakline> | <Trail Grip - the trail shoe for wet rock> |
| Description | <269 characters, cut mid-sentence> | <Grippy, light trail shoes tested on wet granite and mud. ...> |
| Image | </img/logo.svg (relative SVG)> | <https://shop.example.com/img/trail-grip-share-1200x630.jpg> |
| Card on X | <invalid "large"> | <summary_large_image> |

## Fix list
| # | Sev | Tag | Problem | Fix | Where |
|---|---|---|---|---|---|
| 1 | <HIGH> | <og:image> | <relative SVG logo> | <absolute 1200x630 JPEG> | <theme header.liquid> |
| 2 | <MEDIUM> | <og:title> | <duplicate from SEO plugin, unrendered> | <disable theme OG output, keep plugin> | <plugin settings> |

## Fixed head block
```
<paste the complete corrected tags here, in this order: charset, title, description, canonical, og:*, twitter:*>
```

## Share image spec
- <1200x630 JPEG or PNG, under ~1 MB, new filename; text and logo inside the centre 80%>
- <alt text: "...">

## After deploying
1. <curl -sL -A "facebookexternalhit/1.1" <URL> | grep -E 'og:|twitter:|canonical'>
2. <Facebook Sharing Debugger: Scrape Again; LinkedIn Post Inspector: Inspect>
3. <post in a private Slack channel; check X with a fresh share>

**To verify (not checked offline):** <image URL returns 200 to crawlers; robots.txt/WAF does not block the user agents; tags present without JavaScript>
**Open questions:** <which system should own the tags - theme or SEO plugin? per-product share images available?>
FILE:examples/product-page.html
<!DOCTYPE html>
<html lang="en">
<head>
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <title>Peakline</title>
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <meta name="description" content="Shoes.">
  <link rel="canonical" href="/shoes/trail-grip">
  <!-- theme defaults -->
  <meta property="og:type" content="website">
  <meta property="og:title" content="Peakline Shop">
  <meta property="og:url" content="https://shop.example.com/shoes/trail-grip?utm_source=newsletter">
  <meta property="og:image" content="/img/logo.svg">
  <meta property="og:locale" content="en-us">
  <!-- SEO plugin -->
  <meta property="og:title" content="{{ product.name }} | Peakline">
  <meta name="og:description" content="Grippy, light trail running shoes tested on wet granite, roots and mud. Compare fit, drop and sole wear across three widths, read 240 reviews from real runners, and order with free returns within 60 days and free shipping on orders over 80 dollars, in every EU country.">
  <meta name="twitter:card" content="large">
  <meta name="twitter:site" content="https://x.com/peakline">
  <link rel="stylesheet" href="/css/site.css">
</head>
<body>
  <header><a href="/">Peakline</a></header>
  <main>
    <h1>Trail Grip - wet rock trail shoe</h1>
    <meta property="og:image" content="https://shop.example.com/img/trail-grip-800.jpg">
    <meta property="og:image:width" content="800">
    <meta property="og:image:height" content="800">
    <p>Grippy, light trail shoes tested on wet granite and mud.</p>
  </main>
</body>
</html>
FILE:examples/product-page-fixed.html
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Trail Grip Running Shoes for Wet Rock | Peakline</title>
  <meta name="description" content="Grippy, light trail shoes tested on wet granite and mud. Compare fit, drop and sole wear across three widths, with free 60-day returns.">
  <link rel="canonical" href="https://shop.example.com/shoes/trail-grip">
  <meta property="og:type" content="product">
  <meta property="og:site_name" content="Peakline">
  <meta property="og:title" content="Trail Grip - the trail shoe for wet rock">
  <meta property="og:description" content="Grippy, light trail shoes tested on wet granite and mud. Three widths, free 60-day returns.">
  <meta property="og:url" content="https://shop.example.com/shoes/trail-grip">
  <meta property="og:image" content="https://shop.example.com/img/trail-grip-share-1200x630.jpg">
  <meta property="og:image:width" content="1200">
  <meta property="og:image:height" content="630">
  <meta property="og:image:alt" content="Blue Trail Grip shoe gripping a wet granite slab">
  <meta property="og:locale" content="en_US">
  <meta name="twitter:card" content="summary_large_image">
  <meta name="twitter:site" content="@peakline">
  <link rel="stylesheet" href="/css/site.css">
</head>
<body>
  <header><a href="/">Peakline</a></header>
  <main>
    <h1>Trail Grip - wet rock trail shoe</h1>
    <p>Grippy, light trail shoes tested on wet granite and mud.</p>
  </main>
</body>
</html>
FILE:examples/meta-report.md
# Social share meta check

Pages: 1   Findings: 21 (HIGH 1, MEDIUM 10, LOW 10)   Page URL: https://shop.example.com/shoes/trail-grip

## product-page.html

Preview as built from the tags (card: large)

| Field | Shown |
|---|---|
| Domain | shop.example.com |
| Title | Peakline Shop |
| Description | Grippy, light trail running shoes tested on wet granite, roots and mud. Compare fit, drop and sole wear across three widths, read 240 reviews from real runners, and order with free returns within 6... |
| Image | /img/logo.svg |

| Sev | Code | Tag | Line | Problem | Fix |
|---|---|---|---|---|---|
| HIGH | RELATIVE_URL | og:image | 13 | og:image is relative (/img/logo.svg); crawlers need an absolute URL - would mean https://shop.example.com/img/logo.svg | write the full URL, e.g. https://shop.example.com/img/logo.svg |
| MEDIUM | RELATIVE_URL | canonical | 8 | canonical is relative (/shoes/trail-grip); crawlers need an absolute URL - would mean https://shop.example.com/shoes/trail-grip | write the full URL, e.g. https://shop.example.com/shoes/trail-grip |
| MEDIUM | TRACKING_PARAMS | og:url | 12 | og:url carries tracking parameters (utm_source=newsletter); every share then counts the campaign | use the clean URL without ?utm_/fbclid/gclid |
| MEDIUM | IMAGE_SVG | og:image | 13 | SVG images are not rendered by Facebook, X, LinkedIn or Slack | export a PNG or JPEG |
| MEDIUM | IMAGE_SMALL | og:image | 13 | image is 800x800 (declared); large previews need at least 1200x630 (shown small or blurry) | use 1200x630 (2400x1260 for sharp retina) |
| MEDIUM | PLACEHOLDER_VALUE | og:title | 16 | og:title looks like an unrendered template or placeholder: '{{ product.name }} / Peakline' | fix the template variable |
| MEDIUM | DUPLICATE_TAG | og:title | 16 | 2 different og:title values; apps pick the first or last unpredictably | keep one (often a theme and an SEO plugin both add tags) |
| MEDIUM | TWITTER_CARD_INVALID | twitter:card | 18 | twitter:card 'large' is not one of summary, summary_large_image, app, player | use summary_large_image (or summary) |
| MEDIUM | TAG_OUTSIDE_HEAD | og:image | 26 | og:image is inside `<body>`; Facebook and LinkedIn read only `<head>` | move into `<head>` |
| MEDIUM | TAG_OUTSIDE_HEAD | og:image:width | 27 | og:image:width is inside `<body>`; Facebook and LinkedIn read only `<head>` | move into `<head>` |
| MEDIUM | TAG_OUTSIDE_HEAD | og:image:height | 28 | og:image:height is inside `<body>`; Facebook and LinkedIn read only `<head>` | move into `<head>` |
| LOW | OG_MISSING | og:site_name | - | og:site_name missing: LinkedIn and Slack show the bare domain instead of your brand | `<meta property="og:site_name" content="Brand">` |
| LOW | CHARSET_MISSING | meta charset | - | no `<meta charset>`; non-ASCII titles can show as mojibake in previews | `<meta charset="utf-8">` first in `<head>` |
| LOW | TITLE_LENGTH | `<title>` | 5 | title is 8 characters (aim for 15-60): 'Peakline' | front-load the key words; search results cut around 60 characters |
| LOW | DESCRIPTION_LENGTH | meta description | 7 | description is 6 characters (aim for 50-160) | rewrite to one or two sentences with the key benefit first |
| LOW | CANONICAL_OG_URL_MISMATCH | og:url | 12 | og:url (https://shop.example.com/shoes/trail-grip?utm_source=newsletter) differs from canonical (/shoes/trail-grip) | use the canonical URL in og:url |
| LOW | IMAGE_ALT_MISSING | og:image:alt | 13 | no og:image:alt (screen readers on X/LinkedIn get nothing) | describe the image in one sentence |
| LOW | OG_LOCALE_FORMAT | og:locale | 14 | og:locale 'en-us' should look like en_US (underscore, region in capitals) | e.g. en_US, de_DE, pt_BR |
| LOW | OG_DESCRIPTION_LONG | og:description | 17 | og:description is 269 characters; most apps show ~2-3 lines | keep under ~200 characters |
| LOW | OG_USES_NAME_ATTR | og:description | 17 | og:description uses name= instead of property= (Open Graph spec; some parsers skip it) | `<meta property="og:description" ...>` |
| LOW | TWITTER_HANDLE_FORMAT | twitter:site | 19 | twitter:site 'https://x.com/peakline' should be an @handle | e.g. @brand |

Offline check of the saved HTML only: tags injected by JavaScript after load are invisible to most crawlers too, but redirects, robots rules, the live image URL and each platform's preview cache were not tested.
FILE:scripts/og_meta_check.py
#!/usr/bin/env python3
"""Open Graph and social share meta tag checker (Python 3.8+ standard library only).

Reads saved HTML (a file, several files, or a folder of *.html) and checks what link
previews on Facebook, LinkedIn, X, Slack, Discord, WhatsApp and iMessage will be built from:
<title>, meta description, rel=canonical, og:* (title, description, type, url, image,
image:width/height/alt/type, site_name, locale) and twitter:* card tags.

It flags missing and duplicate tags, relative or http:// URLs, canonical vs og:url
mismatches, title/description length, image size hints (declared or, with --root, read
from local PNG/JPEG/GIF/WebP files), SVG images, wrong attributes (name= vs property=),
tags outside <head>, and template placeholders ({{ }}, TODO, undefined).

Usage:
  python3 og_meta_check.py page.html [more.html | folder/] [--url https://example.com/page]
                           [--root public/] [--min-severity LOW|MEDIUM|HIGH] [--ignore CODE,..] [--json]
  python3 og_meta_check.py --self-test

--url   the page's public URL (used to resolve relative links and compare canonical/og:url)
--root  local folder that maps to the site root, so /img/share.png is read from root/img/share.png

Exit codes: 0 = no HIGH findings, 1 = HIGH findings, 2 = bad input. No network calls are made.
"""
import argparse
import json
import os
import re
import struct
import sys
from html.parser import HTMLParser
from urllib.parse import urljoin, urlsplit

SEV_ORDER = {"LOW": 1, "MEDIUM": 2, "HIGH": 3}
TWITTER_CARDS = ("summary", "summary_large_image", "app", "player")
SINGLE_OG = ("og:title", "og:description", "og:type", "og:url", "og:site_name", "og:locale")
PLACEHOLDER_RE = re.compile(r"(\{\{|\}\}|\$\{|<%|%>|\bTODO\b|\bTBD\b|lorem ipsum|\bundefined\b|\bnull\b|\[object Object\]|NaN)", re.I)
TITLE_RANGE = (15, 60)       # search results show roughly 50-60 characters
DESC_RANGE = (50, 160)
OG_TITLE_MAX = 90            # Facebook/LinkedIn cut long titles around 2 lines
OG_DESC_MAX = 200
IMG_MIN = (200, 200)         # Facebook minimum
IMG_LARGE = (1200, 630)      # recommended 1.91:1
IMG_MAX_BYTES = 5 * 1024 * 1024   # X limit 5 MB; Facebook 8 MB


class Meta:
    def __init__(self, key, attr, content, line, in_head):
        self.key, self.attr, self.content, self.line, self.in_head = key, attr, content, line, in_head


class PageParser(HTMLParser):
    def __init__(self):
        super().__init__(convert_charrefs=True)
        self.metas, self.links, self.titles = [], [], []
        self.in_head = True       # before <body> starts, tags count as head (HTML parsing rules)
        self.seen_head = False
        self._in_title, self._title_buf, self._title_line = False, [], 0
        self.charset = None
        self.lang = None

    def handle_starttag(self, tag, attrs):
        a = {k.lower(): (v if v is not None else "") for k, v in attrs}
        line = self.getpos()[0]
        if tag == "html":
            self.lang = a.get("lang")
        elif tag == "head":
            self.seen_head = True
            self.in_head = True
        elif tag == "body":
            self.in_head = False
        elif tag == "title":
            self._in_title, self._title_buf, self._title_line = True, [], line
        elif tag == "meta":
            if "charset" in a:
                self.charset = a["charset"]
            for attr in ("property", "name", "itemprop"):
                if a.get(attr):
                    self.metas.append(Meta(a[attr].strip().lower(), attr, a.get("content", None), line, self.in_head))
                    break
        elif tag == "link":
            rel = a.get("rel", "").lower().split()
            self.links.append({"rel": rel, "href": a.get("href", ""), "line": line, "in_head": self.in_head,
                               "sizes": a.get("sizes", "")})
        if tag in ("div", "p", "main", "article", "section", "h1", "img", "span", "header", "nav") and self.in_head and self.seen_head:
            self.in_head = False  # implied <body>

    def handle_startendtag(self, tag, attrs):
        self.handle_starttag(tag, attrs)

    def handle_endtag(self, tag):
        if tag == "head":
            self.in_head = False
        elif tag == "title" and self._in_title:
            self._in_title = False
            self.titles.append((" ".join("".join(self._title_buf).split()), self._title_line))

    def handle_data(self, data):
        if self._in_title:
            self._title_buf.append(data)


def image_size(path):
    """Return (width, height, format) for PNG, GIF, JPEG or WebP, else None."""
    with open(path, "rb") as fh:
        head = fh.read(32)
        if head[:8] == b"\x89PNG\r\n\x1a\n":
            w, h = struct.unpack(">II", head[16:24])
            return w, h, "png"
        if head[:6] in (b"GIF87a", b"GIF89a"):
            w, h = struct.unpack("<HH", head[6:10])
            return w, h, "gif"
        if head[:4] == b"RIFF" and head[8:12] == b"WEBP":
            fh.seek(12)
            chunk = fh.read(30)
            kind = chunk[:4]
            if kind == b"VP8X":
                w = int.from_bytes(chunk[12:15], "little") + 1
                h = int.from_bytes(chunk[15:18], "little") + 1
                return w, h, "webp"
            if kind == b"VP8 ":
                w, h = struct.unpack("<HH", chunk[14:18])
                return w & 0x3FFF, h & 0x3FFF, "webp"
            if kind == b"VP8L":
                b = chunk[9:13]
                bits = int.from_bytes(b, "little")
                return (bits & 0x3FFF) + 1, ((bits >> 14) & 0x3FFF) + 1, "webp"
            return None
        if head[:2] == b"\xff\xd8":
            fh.seek(2)
            while True:
                m = fh.read(2)
                if len(m) < 2 or m[0] != 0xFF:
                    return None
                marker = m[1]
                if marker in (0xD8, 0x01) or 0xD0 <= marker <= 0xD7:
                    continue
                seg = fh.read(2)
                if len(seg) < 2:
                    return None
                length = struct.unpack(">H", seg)[0]
                if marker in (0xC0, 0xC1, 0xC2, 0xC3, 0xC5, 0xC6, 0xC7, 0xC9, 0xCA, 0xCB, 0xCD, 0xCE, 0xCF):
                    data = fh.read(5)
                    h, w = struct.unpack(">HH", data[1:5])
                    return w, h, "jpeg"
                fh.seek(length - 2, 1)
    return None


def analyze(html, page_url="", root=None, name="page.html"):
    p = PageParser()
    p.feed(html)
    p.close()
    f = []

    def add(sev, code, tag, problem, fix, line=0):
        f.append({"severity": sev, "code": code, "tag": tag, "problem": problem, "fix": fix, "line": line, "file": name})

    metas = {}
    for m in p.metas:
        metas.setdefault(m.key, []).append(m)

    def first(key):
        v = metas.get(key)
        return v[0] if v else None

    def val(key):
        m = first(key)
        return (m.content or "").strip() if m and m.content is not None else None

    page_https = page_url.lower().startswith("https://")

    def check_abs(tag, url, line, sev_rel="HIGH"):
        if not url:
            return
        s = urlsplit(url)
        if not s.scheme:
            resolved = urljoin(page_url, url) if page_url else None
            add(sev_rel, "RELATIVE_URL", tag, "%s is relative (%s); crawlers need an absolute URL%s" %
                (tag, url, (" - would mean " + resolved) if resolved else ""),
                "write the full URL, e.g. %s" % (resolved or "https://example.com" + ("" if url.startswith("/") else "/") + url), line)
        elif s.scheme == "http" and (page_https or tag.startswith(("og:image", "twitter:image"))):
            add("MEDIUM", "HTTP_URL", tag, "%s uses http:// (%s); some apps skip insecure images or mix up the canonical" % (tag, url),
                "use https://", line)

    # ---- title / description
    titles = p.titles
    if not titles or not titles[0][0]:
        add("HIGH", "TITLE_MISSING", "<title>", "no <title>; search results and many previews fall back to the URL",
            "add a specific <title> of 15-60 characters")
    else:
        t, line = titles[0]
        if len(titles) > 1:
            add("MEDIUM", "TITLE_MULTIPLE", "<title>", "%d <title> elements; only the first is used" % len(titles), "keep one", titles[1][1])
        if len(t) < TITLE_RANGE[0] or len(t) > TITLE_RANGE[1]:
            add("LOW", "TITLE_LENGTH", "<title>", "title is %d characters (aim for %d-%d): %r" % (len(t), TITLE_RANGE[0], TITLE_RANGE[1], t),
                "front-load the key words; search results cut around 60 characters", line)
    desc = val("description")
    if desc is None or desc == "":
        add("MEDIUM", "DESCRIPTION_MISSING", "meta description", "no meta description; previews and search snippets pick random page text",
            "add <meta name=\"description\" content=\"...\"> of 50-160 characters")
    elif len(desc) < DESC_RANGE[0] or len(desc) > DESC_RANGE[1]:
        add("LOW", "DESCRIPTION_LENGTH", "meta description", "description is %d characters (aim for %d-%d)" % (len(desc), DESC_RANGE[0], DESC_RANGE[1]),
            "rewrite to one or two sentences with the key benefit first", first("description").line)
    if len(metas.get("description", [])) > 1:
        add("MEDIUM", "DUPLICATE_TAG", "meta description", "%d meta descriptions; the first is used" % len(metas["description"]), "keep one",
            metas["description"][1].line)

    # ---- canonical
    canon = [l for l in p.links if "canonical" in l["rel"]]
    canon_url = None
    if not canon:
        add("MEDIUM", "CANONICAL_MISSING", "link rel=canonical", "no canonical URL; shares with ?utm= or ?ref= parameters count as separate pages",
            "<link rel=\"canonical\" href=\"https://example.com/clean-path\">")
    else:
        if len(set(l["href"] for l in canon)) > 1:
            add("HIGH", "CANONICAL_MULTIPLE", "link rel=canonical", "%d different canonical URLs; search engines may ignore all of them" % len(canon),
                "keep exactly one", canon[1]["line"])
        canon_url = canon[0]["href"].strip()
        if not canon_url:
            add("HIGH", "CANONICAL_EMPTY", "link rel=canonical", "canonical href is empty", "set the full URL", canon[0]["line"])
        else:
            check_abs("canonical", canon_url, canon[0]["line"], "MEDIUM")
            if not canon[0]["in_head"]:
                add("MEDIUM", "TAG_OUTSIDE_HEAD", "link rel=canonical", "canonical is in <body>; search engines ignore it there", "move into <head>", canon[0]["line"])
            if page_url and urlsplit(canon_url).scheme and urlsplit(canon_url).netloc != urlsplit(page_url).netloc:
                add("LOW", "CANONICAL_OTHER_HOST", "link rel=canonical", "canonical points to another host (%s)" % urlsplit(canon_url).netloc,
                    "fine for syndicated copies; otherwise use this page's own URL", canon[0]["line"])

    # ---- Open Graph core
    for key, sev, why, fix in (
            ("og:title", "MEDIUM", "previews fall back to <title> (often with the site name suffix)", "<meta property=\"og:title\" content=\"...\">"),
            ("og:description", "LOW", "previews fall back to the meta description or page text", "<meta property=\"og:description\" content=\"...\">"),
            ("og:type", "LOW", "defaults to website; use article or product where it fits", "<meta property=\"og:type\" content=\"website\">"),
            ("og:url", "LOW", "shares are not merged onto one canonical URL (like counts split)", "<meta property=\"og:url\" content=\"<canonical URL>\">"),
            ("og:site_name", "LOW", "LinkedIn and Slack show the bare domain instead of your brand", "<meta property=\"og:site_name\" content=\"Brand\">")):
        if first(key) is None:
            add(sev, "OG_MISSING", key, "%s missing: %s" % (key, why), fix)
        elif not val(key):
            add("MEDIUM", "EMPTY_CONTENT", key, "%s has an empty content attribute" % key, "fill it or remove the tag", first(key).line)
    ogt = val("og:title")
    if ogt and len(ogt) > OG_TITLE_MAX:
        add("LOW", "OG_TITLE_LONG", "og:title", "og:title is %d characters; previews cut it after ~2 lines" % len(ogt), "keep under ~70-90 characters", first("og:title").line)
    ogd = val("og:description")
    if ogd and len(ogd) > OG_DESC_MAX:
        add("LOW", "OG_DESCRIPTION_LONG", "og:description", "og:description is %d characters; most apps show ~2-3 lines" % len(ogd), "keep under ~200 characters", first("og:description").line)
    if first("og:url") and val("og:url"):
        check_abs("og:url", val("og:url"), first("og:url").line)
        canon_abs = urljoin(page_url, canon_url) if canon_url and page_url else canon_url
        if canon_abs and urlsplit(canon_abs).scheme and val("og:url").rstrip("/") != canon_abs.rstrip("/"):
            add("LOW", "CANONICAL_OG_URL_MISMATCH", "og:url", "og:url (%s) differs from canonical (%s)" % (val("og:url"), canon_url),
                "use the canonical URL in og:url", first("og:url").line)
    for key, u, ln in (("og:url", val("og:url"), first("og:url").line if first("og:url") else 0),
                       ("canonical", canon_url, canon[0]["line"] if canon else 0)):
        if u and re.search(r"[?&](utm_[a-z]+|fbclid|gclid|ref|mc_cid)=", u, re.I):
            add("MEDIUM", "TRACKING_PARAMS", key, "%s carries tracking parameters (%s); every share then counts the campaign" % (key, urlsplit(u).query),
                "use the clean URL without ?utm_/fbclid/gclid", ln)
    loc = val("og:locale")
    if loc and not re.match(r"^[a-z]{2,3}_[A-Z]{2}$", loc):
        add("LOW", "OG_LOCALE_FORMAT", "og:locale", "og:locale %r should look like en_US (underscore, region in capitals)" % loc,
            "e.g. en_US, de_DE, pt_BR", first("og:locale").line)
    ogtype = val("og:type")
    if ogtype and ogtype not in ("website", "article", "book", "profile", "product", "music.song", "music.album",
                                 "music.playlist", "music.radio_station", "video.movie", "video.episode",
                                 "video.tv_show", "video.other", "og:product", "product.item", "business.business",
                                 "restaurant.restaurant", "place"):
        add("LOW", "OG_TYPE_UNKNOWN", "og:type", "og:type %r is not a standard type" % ogtype, "website, article, product, profile...", first("og:type").line)

    # ---- image
    img_meta = first("og:image") or first("og:image:url") or first("og:image:secure_url")
    img = (img_meta.content or "").strip() if img_meta and img_meta.content else ""
    tw_img = val("twitter:image") or val("twitter:image:src")
    if not img:
        add("HIGH", "OG_IMAGE_MISSING", "og:image", "no og:image: shares show a plain text link or a random page image",
            "add a 1200x630 image: <meta property=\"og:image\" content=\"https://.../share.png\">")
    else:
        check_abs("og:image", img, img_meta.line)
        if re.search(r"\.svg(\?|#|$)", img, re.I):
            add("MEDIUM", "IMAGE_SVG", "og:image", "SVG images are not rendered by Facebook, X, LinkedIn or Slack", "export a PNG or JPEG", img_meta.line)
        w, h = val("og:image:width"), val("og:image:height")
        size, source = None, ""
        if w and h and w.isdigit() and h.isdigit():
            size, source = (int(w), int(h)), "declared"
        elif w or h:
            add("LOW", "IMAGE_DIMENSIONS_INVALID", "og:image:width/height", "width/height must both be whole numbers (got %r x %r)" % (w, h),
                "e.g. 1200 and 630", img_meta.line)
        if root:
            local = _local_path(img, page_url, root)
            if local and os.path.isfile(local):
                real = image_size(local)
                nbytes = os.path.getsize(local)
                if real:
                    if size and (size[0], size[1]) != (real[0], real[1]):
                        add("MEDIUM", "IMAGE_DIMENSIONS_WRONG", "og:image:width/height",
                            "declared %dx%d but the file is %dx%d" % (size[0], size[1], real[0], real[1]),
                            "declare the real size", img_meta.line)
                    size, source = (real[0], real[1]), "file %s" % os.path.relpath(local, root)
                if nbytes > IMG_MAX_BYTES:
                    add("MEDIUM", "IMAGE_TOO_HEAVY", "og:image", "image file is %.1f MB (X rejects over 5 MB, previews time out)" % (nbytes / 1048576.0),
                        "compress to under ~1 MB (JPEG/WebP quality 80)", img_meta.line)
            elif local:
                add("MEDIUM", "IMAGE_NOT_FOUND", "og:image", "image not found under --root: %s" % local, "check the path and deploy the file", img_meta.line)
        if size is None:
            add("LOW", "IMAGE_DIMENSIONS_MISSING", "og:image:width/height",
                "no og:image:width/height; Facebook cannot render the image on the very first share",
                "add og:image:width 1200 and og:image:height 630", img_meta.line)
        else:
            iw, ih = size
            if iw < IMG_MIN[0] or ih < IMG_MIN[1]:
                add("HIGH", "IMAGE_TOO_SMALL", "og:image", "image is %dx%d (%s); below 200x200 Facebook ignores it" % (iw, ih, source),
                    "use 1200x630", img_meta.line)
            elif iw < IMG_LARGE[0] or ih < IMG_LARGE[1]:
                add("MEDIUM", "IMAGE_SMALL", "og:image", "image is %dx%d (%s); large previews need at least 1200x630 (shown small or blurry)" % (iw, ih, source),
                    "use 1200x630 (2400x1260 for sharp retina)", img_meta.line)
            ratio = iw / float(ih)
            card = val("twitter:card") or ""
            if card == "summary_large_image" or not card:
                if not (1.75 <= ratio <= 2.05):
                    add("LOW", "IMAGE_ASPECT", "og:image", "aspect ratio %.2f:1 will be cropped in large cards (aim for 1.91:1)" % ratio,
                        "1200x630, keep text inside the centre 80%", img_meta.line)
        if not val("og:image:alt"):
            add("LOW", "IMAGE_ALT_MISSING", "og:image:alt", "no og:image:alt (screen readers on X/LinkedIn get nothing)",
                "describe the image in one sentence", img_meta.line)
    if tw_img:
        check_abs("twitter:image", tw_img, first("twitter:image").line if first("twitter:image") else 0)

    # ---- twitter / X card
    card = val("twitter:card")
    if card is None:
        add("LOW" if img else "MEDIUM", "TWITTER_CARD_MISSING", "twitter:card",
            "no twitter:card; X shows a small summary card at best", "<meta name=\"twitter:card\" content=\"summary_large_image\">")
    elif card not in TWITTER_CARDS:
        add("MEDIUM", "TWITTER_CARD_INVALID", "twitter:card", "twitter:card %r is not one of %s" % (card, ", ".join(TWITTER_CARDS)),
            "use summary_large_image (or summary)", first("twitter:card").line)
    elif card == "summary_large_image" and not (img or tw_img):
        add("MEDIUM", "TWITTER_CARD_NO_IMAGE", "twitter:card", "summary_large_image without any image", "add og:image or twitter:image", first("twitter:card").line)
    for key in ("twitter:site", "twitter:creator"):
        v = val(key)
        if v and not re.match(r"^@\w{1,15}$", v):
            add("LOW", "TWITTER_HANDLE_FORMAT", key, "%s %r should be an @handle" % (key, v), "e.g. @brand", first(key).line)

    # ---- attribute and placement problems, duplicates, placeholders
    for m in p.metas:
        if m.key.startswith("og:") and m.attr == "name":
            add("LOW", "OG_USES_NAME_ATTR", m.key, "%s uses name= instead of property= (Open Graph spec; some parsers skip it)" % m.key,
                "<meta property=\"%s\" ...>" % m.key, m.line)
        if (m.key.startswith(("og:", "twitter:")) or m.key == "description") and not m.in_head:
            add("MEDIUM", "TAG_OUTSIDE_HEAD", m.key, "%s is inside <body>; Facebook and LinkedIn read only <head>" % m.key, "move into <head>", m.line)
        if m.content is None and (m.key.startswith(("og:", "twitter:")) or m.key == "description"):
            add("MEDIUM", "NO_CONTENT_ATTR", m.key, "%s has no content attribute (value=/text= are ignored)" % m.key, "use content=\"...\"", m.line)
        if m.content and PLACEHOLDER_RE.search(m.content) and (m.key.startswith(("og:", "twitter:")) or m.key == "description"):
            add("MEDIUM", "PLACEHOLDER_VALUE", m.key, "%s looks like an unrendered template or placeholder: %r" % (m.key, m.content[:60]),
                "fix the template variable", m.line)
    for key in SINGLE_OG + ("twitter:card", "twitter:title", "twitter:description"):
        ms = metas.get(key, [])
        if len(ms) > 1 and len(set((m.content or "") for m in ms)) > 1:
            add("MEDIUM", "DUPLICATE_TAG", key, "%d different %s values; apps pick the first or last unpredictably" % (len(ms), key),
                "keep one (often a theme and an SEO plugin both add tags)", ms[1].line)
    if titles and titles[0][0] and PLACEHOLDER_RE.search(titles[0][0]):
        add("MEDIUM", "PLACEHOLDER_VALUE", "<title>", "title looks like a placeholder: %r" % titles[0][0], "fix the template", titles[0][1])
    if not p.charset:
        add("LOW", "CHARSET_MISSING", "meta charset", "no <meta charset>; non-ASCII titles can show as mojibake in previews", "<meta charset=\"utf-8\"> first in <head>")

    preview = {
        "title": _cut(ogt or (titles[0][0] if titles else "") or "", OG_TITLE_MAX),
        "description": _cut(ogd or desc or "", OG_DESC_MAX),
        "image": img or tw_img or "",
        "domain": urlsplit(val("og:url") or canon_url or page_url or "").netloc,
        "card": card or ("summary" if img else "none"),
    }
    return f, preview


def _cut(text, n):
    return text if len(text) <= n else text[:n - 3].rstrip() + "..."


def _code(text):
    """Wrap <tags> in backticks so markdown shows them instead of swallowing them as HTML."""
    return re.sub(r"(<[^<>]+>)", r"`\1`", text.replace("|", "/"))


def _local_path(url, page_url, root):
    s = urlsplit(url)
    if s.scheme and page_url and s.netloc and s.netloc != urlsplit(page_url).netloc:
        return None  # image on another host (CDN): cannot check locally
    path = urlsplit(urljoin(page_url or "https://local.invalid/", url)).path
    return os.path.join(root, path.lstrip("/"))


def run_files(paths, page_url, root, min_sev, ignore):
    results = []
    files = []
    for p in paths:
        if os.path.isdir(p):
            for dp, _, fns in os.walk(p):
                files += [os.path.join(dp, fn) for fn in sorted(fns) if fn.lower().endswith((".html", ".htm"))]
        else:
            files.append(p)
    if not files:
        raise ValueError("no HTML files found")
    for fp in files:
        with open(fp, encoding="utf-8", errors="replace") as fh:
            html = fh.read()
        if not re.search(r"<(html|head|meta|title|link)\b", html, re.I):
            raise ValueError("%s does not look like HTML" % fp)
        fs, prev = analyze(html, page_url if len(files) == 1 else "", root, os.path.basename(fp))
        fs = [x for x in fs if SEV_ORDER[x["severity"]] >= SEV_ORDER[min_sev] and x["code"] not in ignore]
        fs.sort(key=lambda x: (-SEV_ORDER[x["severity"]], x["line"]))
        results.append((fp, fs, prev))
    return results


def render_md(results, page_url):
    allf = [x for _, fs, _ in results for x in fs]
    c = {k: sum(1 for x in allf if x["severity"] == k) for k in ("HIGH", "MEDIUM", "LOW")}
    o = ["# Social share meta check", "",
         "Pages: %d   Findings: %d (HIGH %d, MEDIUM %d, LOW %d)%s" % (len(results), len(allf), c["HIGH"], c["MEDIUM"], c["LOW"],
                                                                     ("   Page URL: " + page_url) if page_url and len(results) == 1 else "")]
    for fp, fs, prev in results:
        o += ["", "## %s" % os.path.basename(fp), "",
              "Preview as built from the tags (card: %s)" % prev["card"], "",
              "| Field | Shown |", "|---|---|",
              "| Domain | %s |" % (prev["domain"] or "(unknown)"),
              "| Title | %s |" % (prev["title"].replace("|", "/") or "(none)"),
              "| Description | %s |" % (prev["description"].replace("|", "/") or "(none)"),
              "| Image | %s |" % (prev["image"] or "(none)"), ""]
        if not fs:
            o.append("No findings.")
            continue
        o += ["| Sev | Code | Tag | Line | Problem | Fix |", "|---|---|---|---|---|---|"]
        for x in fs:
            o.append("| %s | %s | %s | %s | %s | %s |" % (x["severity"], x["code"], _code(x["tag"]), x["line"] or "-",
                                                         _code(x["problem"]), _code(x["fix"])))
    o += ["", "Offline check of the saved HTML only: tags injected by JavaScript after load are invisible to most crawlers too, "
          "but redirects, robots rules, the live image URL and each platform's preview cache were not tested."]
    return "\n".join(o) + "\n"


# ----------------------------------------------------------------------------- self-test

GOOD = """<!doctype html><html lang="en"><head><meta charset="utf-8">
<title>Trail Running Shoes for Wet Rocks | Peakline</title>
<meta name="description" content="Grippy, light trail shoes tested on wet granite and mud. Compare fit, drop and sole wear, then pick your size.">
<link rel="canonical" href="https://shop.example.com/shoes/trail-grip">
<meta property="og:type" content="product"><meta property="og:site_name" content="Peakline">
<meta property="og:title" content="Trail Running Shoes for Wet Rocks">
<meta property="og:description" content="Grippy, light trail shoes tested on wet granite and mud.">
<meta property="og:url" content="https://shop.example.com/shoes/trail-grip">
<meta property="og:image" content="https://shop.example.com/img/trail-grip-share.jpg">
<meta property="og:image:width" content="1200"><meta property="og:image:height" content="630">
<meta property="og:image:alt" content="Blue trail shoe on a wet granite slab">
<meta property="og:locale" content="en_US">
<meta name="twitter:card" content="summary_large_image"><meta name="twitter:site" content="@peakline">
</head><body><h1>Trail Grip</h1></body></html>"""


def self_test():
    import tempfile
    cases = []

    def codes(html, url="https://shop.example.com/shoes/trail-grip", root=None):
        return [x["code"] for x in analyze(html, url, root)[0]]

    def case(name, fn):
        try:
            ok, err = bool(fn()), ""
        except Exception as e:  # noqa
            ok, err = False, repr(e)
        cases.append((name, ok, err))

    def sub(a, b):
        assert a in GOOD, a
        return GOOD.replace(a, b)

    case("good page is clean", lambda: codes(GOOD) == [])
    case("missing title", lambda: "TITLE_MISSING" in codes(sub("<title>Trail Running Shoes for Wet Rocks | Peakline</title>", "")))
    case("two titles", lambda: "TITLE_MULTIPLE" in codes(sub("</head>", "<title>Other</title></head>")))
    case("title too long", lambda: "TITLE_LENGTH" in codes(sub("Trail Running Shoes for Wet Rocks | Peakline", "x" * 75)))
    case("description missing", lambda: "DESCRIPTION_MISSING" in codes(re.sub(r'<meta name="description"[^>]*>', "", GOOD)))
    case("description short", lambda: "DESCRIPTION_LENGTH" in codes(re.sub(r'(<meta name="description" content=")[^"]*', r"\1Shoes.", GOOD)))
    case("canonical missing", lambda: "CANONICAL_MISSING" in codes(re.sub(r'<link rel="canonical"[^>]*>', "", GOOD)))
    case("canonical relative", lambda: "RELATIVE_URL" in codes(sub('href="https://shop.example.com/shoes/trail-grip"', 'href="/shoes/trail-grip"')))
    case("two canonicals", lambda: "CANONICAL_MULTIPLE" in codes(sub("</head>", '<link rel="canonical" href="https://shop.example.com/x"></head>')))
    case("canonical vs og:url mismatch", lambda: "CANONICAL_OG_URL_MISMATCH" in codes(sub('og:url" content="https://shop.example.com/shoes/trail-grip"', 'og:url" content="https://shop.example.com/shoes/trail-grip?utm_source=x"')))
    case("trailing slash difference ignored", lambda: "CANONICAL_OG_URL_MISMATCH" not in codes(sub('og:url" content="https://shop.example.com/shoes/trail-grip"', 'og:url" content="https://shop.example.com/shoes/trail-grip/"')))
    case("og:image missing HIGH", lambda: "OG_IMAGE_MISSING" in codes(re.sub(r'<meta property="og:image[^>]*>', "", GOOD)))
    case("og:image relative HIGH", lambda: [x["severity"] for x in analyze(sub('content="https://shop.example.com/img/trail-grip-share.jpg"', 'content="/img/trail-grip-share.jpg"'), "https://shop.example.com/p")[0] if x["code"] == "RELATIVE_URL"] == ["HIGH"])
    case("og:image http", lambda: "HTTP_URL" in codes(sub("https://shop.example.com/img/", "http://shop.example.com/img/")))
    case("og:image svg", lambda: "IMAGE_SVG" in codes(sub("trail-grip-share.jpg", "logo.svg")))
    case("image dims missing", lambda: "IMAGE_DIMENSIONS_MISSING" in codes(re.sub(r'<meta property="og:image:(width|height)"[^>]*>', "", GOOD)))
    case("image too small HIGH", lambda: "IMAGE_TOO_SMALL" in codes(sub('content="1200"', 'content="150"').replace('content="630"', 'content="150"')))
    case("image small MEDIUM", lambda: "IMAGE_SMALL" in codes(sub('content="1200"', 'content="600"').replace('content="630"', 'content="315"')))
    case("image square aspect for large card", lambda: "IMAGE_ASPECT" in codes(sub('content="630"', 'content="1200"')))
    case("summary card allows square", lambda: "IMAGE_ASPECT" not in codes(sub('content="630"', 'content="1200"').replace("summary_large_image", "summary")))
    case("image alt missing", lambda: "IMAGE_ALT_MISSING" in codes(re.sub(r'<meta property="og:image:alt"[^>]*>', "", GOOD)))
    case("dims not numbers", lambda: "IMAGE_DIMENSIONS_INVALID" in codes(sub('content="1200"', 'content="1200px"')))
    case("og:title missing", lambda: "OG_MISSING" in codes(re.sub(r'<meta property="og:title"[^>]*>', "", GOOD)))
    case("empty og:description", lambda: "EMPTY_CONTENT" in codes(re.sub(r'(<meta property="og:description" content=")[^"]*', r"\1", GOOD)))
    case("og:title too long", lambda: "OG_TITLE_LONG" in codes(sub('og:title" content="Trail Running Shoes for Wet Rocks"', 'og:title" content="' + "y" * 120 + '"')))
    case("tracking params in og:url", lambda: "TRACKING_PARAMS" in codes(sub('og:url" content="https://shop.example.com/shoes/trail-grip"', 'og:url" content="https://shop.example.com/shoes/trail-grip?utm_source=nl"')))
    case("relative canonical compared after resolving", lambda: "CANONICAL_OG_URL_MISMATCH" in codes(sub('href="https://shop.example.com/shoes/trail-grip"', 'href="/shoes/other"')))
    case("preview cut with ellipsis", lambda: _cut("a" * 300, 200).endswith("...") and len(_cut("a" * 300, 200)) <= 200)
    case("og:locale format", lambda: "OG_LOCALE_FORMAT" in codes(sub("en_US", "en-us")))
    case("og:type unknown", lambda: "OG_TYPE_UNKNOWN" in codes(sub('og:type" content="product"', 'og:type" content="shoe"')))
    case("og with name attr", lambda: "OG_USES_NAME_ATTR" in codes(sub('property="og:title"', 'name="og:title"')))
    case("twitter card missing", lambda: "TWITTER_CARD_MISSING" in codes(re.sub(r'<meta name="twitter:card"[^>]*>', "", GOOD)))
    case("twitter card invalid", lambda: "TWITTER_CARD_INVALID" in codes(sub("summary_large_image", "large")))
    case("twitter handle format", lambda: "TWITTER_HANDLE_FORMAT" in codes(sub("@peakline", "https://x.com/peakline")))
    case("large card without any image", lambda: "TWITTER_CARD_NO_IMAGE" in codes(re.sub(r'<meta property="og:image[^>]*>', "", GOOD)))
    case("tag in body", lambda: "TAG_OUTSIDE_HEAD" in codes(sub("<h1>Trail Grip</h1>", '<h1>T</h1><meta property="og:video" content="https://a/v.mp4">')))
    case("implied body by div", lambda: "TAG_OUTSIDE_HEAD" in codes(GOOD.replace("</head><body>", "<div>x</div>").replace('<meta name="twitter:site" content="@peakline">', "").replace("<h1>", '<meta name="twitter:site" content="@peakline"><h1>')))
    case("placeholder value", lambda: "PLACEHOLDER_VALUE" in codes(sub('og:title" content="Trail Running Shoes for Wet Rocks"', 'og:title" content="{{ product.name }}"')))
    case("undefined value", lambda: "PLACEHOLDER_VALUE" in codes(sub("Blue trail shoe on a wet granite slab", "undefined")))
    case("duplicate og:title different values", lambda: "DUPLICATE_TAG" in codes(sub("</head>", '<meta property="og:title" content="Peakline Shop"></head>')))
    case("duplicate same value tolerated", lambda: "DUPLICATE_TAG" not in codes(sub("</head>", '<meta property="og:title" content="Trail Running Shoes for Wet Rocks"></head>')))
    case("no content attribute", lambda: "NO_CONTENT_ATTR" in codes(sub('<meta property="og:site_name" content="Peakline">', '<meta property="og:site_name" value="Peakline">')))
    case("charset missing", lambda: "CHARSET_MISSING" in codes(sub('<meta charset="utf-8">', "")))
    case("html entities decoded in title", lambda: analyze(re.sub(r'<meta property="og:title"[^>]*>', "", sub("Wet Rocks | Peakline", "Wet Rocks &amp; Mud")))[1]["title"] == "Trail Running Shoes for Wet Rocks & Mud")
    case("preview uses og values", lambda: analyze(GOOD, "https://shop.example.com/shoes/trail-grip")[1]["domain"] == "shop.example.com")

    tmp = tempfile.mkdtemp()
    os.makedirs(os.path.join(tmp, "img"))
    png = b"\x89PNG\r\n\x1a\n" + b"\x00\x00\x00\x0dIHDR" + struct.pack(">II", 800, 418) + b"\x08\x02\x00\x00\x00"
    with open(os.path.join(tmp, "img", "trail-grip-share.jpg"), "wb") as fh:
        fh.write(png)
    case("--root reads real image size", lambda: "IMAGE_DIMENSIONS_WRONG" in codes(GOOD, root=tmp) and "IMAGE_SMALL" in codes(GOOD, root=tmp))
    case("--root image not found", lambda: "IMAGE_NOT_FOUND" in codes(sub("trail-grip-share.jpg", "nope.png"), root=tmp))
    case("png size parser", lambda: image_size(os.path.join(tmp, "img", "trail-grip-share.jpg"))[:2] == (800, 418))
    gif = b"GIF89a" + struct.pack("<HH", 1200, 630) + b"\x00" * 20
    jpg = (b"\xff\xd8" + b"\xff\xe0" + struct.pack(">H", 16) + b"JFIF\x00" + b"\x00" * 9 +
           b"\xff\xc0" + struct.pack(">H", 17) + b"\x08" + struct.pack(">HH", 630, 1200) + b"\x03" + b"\x00" * 9)
    webp = b"RIFF" + b"\x00" * 4 + b"WEBPVP8X" + b"\x0a\x00\x00\x00" + b"\x00" * 4 + (1199).to_bytes(3, "little") + (629).to_bytes(3, "little")
    for fn, data in (("a.gif", gif), ("a.jpg", jpg), ("a.webp", webp)):
        with open(os.path.join(tmp, fn), "wb") as fh:
            fh.write(data)
    case("gif size parser", lambda: image_size(os.path.join(tmp, "a.gif"))[:2] == (1200, 630))
    case("jpeg size parser", lambda: image_size(os.path.join(tmp, "a.jpg"))[:2] == (1200, 630))
    case("webp size parser", lambda: image_size(os.path.join(tmp, "a.webp"))[:2] == (1200, 630))
    case("cdn image skipped for --root", lambda: _local_path("https://cdn.other.net/a.png", "https://shop.example.com/", tmp) is None)
    case("non-HTML file rejected", lambda: _rejects(tmp))
    case("markdown render", lambda: "Preview as built" in render_md([("p.html", [], analyze(GOOD)[1])], ""))

    passed = sum(1 for _, ok, _ in cases if ok)
    for name, ok, err in cases:
        print(("PASS " if ok else "FAIL ") + name + ((" " + err) if err else ""))
    print("%d/%d passed" % (passed, len(cases)))
    return 0 if passed == len(cases) else 1


def _rejects(tmp):
    fp = os.path.join(tmp, "notes.md")
    with open(fp, "w") as fh:
        fh.write("# Notes\nuse <b>bold</b>\n")
    try:
        run_files([fp], "", None, "LOW", set())
    except ValueError:
        return True
    return False


def main(argv=None):
    ap = argparse.ArgumentParser(description="Check Open Graph / X card / canonical meta tags in saved HTML (offline).")
    ap.add_argument("paths", nargs="*", help="HTML files or folders")
    ap.add_argument("--url", default="", help="public URL of the page (single file)")
    ap.add_argument("--root", default=None, help="local folder mapped to the site root, to read og:image files")
    ap.add_argument("--min-severity", default="LOW", choices=["LOW", "MEDIUM", "HIGH"])
    ap.add_argument("--ignore", default="", help="comma-separated finding codes to skip")
    ap.add_argument("--json", action="store_true")
    ap.add_argument("--self-test", action="store_true")
    a = ap.parse_args(argv)
    if a.self_test:
        return self_test()
    if not a.paths:
        ap.error("give HTML files/folders or --self-test")
    ignore = {c.strip() for c in a.ignore.split(",") if c.strip()}
    try:
        results = run_files(a.paths, a.url, a.root, a.min_severity, ignore)
    except (OSError, ValueError) as e:
        print("error: %s" % e, file=sys.stderr)
        return 2
    if a.json:
        print(json.dumps([{"file": fp, "preview": prev, "findings": fs} for fp, fs, prev in results], indent=2))
    else:
        sys.stdout.write(render_md(results, a.url))
    return 1 if any(x["severity"] == "HIGH" for _, fs, _ in results for x in fs) else 0


if __name__ == "__main__":
    sys.exit(main())