diff --git a/.claude/settings.json b/.claude/settings.json
index 9e6afbe..6d5339c 100644
--- a/.claude/settings.json
+++ b/.claude/settings.json
@@ -10,6 +10,10 @@
       "Bash(python3 -m muriel.oklch:*)",
       "Bash(.venv/bin/python -m muriel.oklch:*)",
       "Bash(uv run python -m muriel.oklch:*)",
+      "Bash(python -m muriel.rasterize:*)",
+      "Bash(python3 -m muriel.rasterize:*)",
+      "Bash(.venv/bin/python -m muriel.rasterize:*)",
+      "Bash(uv run python -m muriel.rasterize:*)",
       "Bash(cairosvg:*)",
       "Bash(.venv/bin/cairosvg:*)",
       "Bash(python -m cairosvg:*)",
diff --git a/CHANGELOG.md b/CHANGELOG.md
index b3d4375..27b55a8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,6 +8,21 @@ version numbers follow [Semantic Versioning](https://semver.org/).
 
 ### Added
 
+- **`muriel rasterize` — SVG to PNG without Cairo.** The critique agent's
+  rasterize step called `cairosvg`, which on Windows installs and then fails
+  at import (no `libcairo-2.dll`). `muriel.rasterize` keeps cairosvg first
+  and falls back to ImageMagick 7 (`magick`), whose Windows build carries
+  librsvg and Cairo itself. Its librsvg reads only the first family of a
+  `font-family` stack and rounds weight 600 to Bold, so before the render
+  every stack is resolved against `magick -list font`. The CSS keywords muriel's
+  generators lead with (`ui-sans-serif`, `system-ui`, `ui-monospace`)
+  resolve to the faces a browser picks. On Windows, intermediate weights
+  become their named faces ("Segoe UI Semibold"), chosen by the CSS
+  weight-matching rule. Prints the backend, every substitution, leftover
+  font fallbacks, and a note when `<image>` elements are present, since
+  ImageMagick's librsvg drops them. The critique agent and the repo's
+  permission allowlist now point at it.
+
 - **`muriel.collection` accepts a clip's `video` for Wunderkammer's next
   release.** Wunderkammer's `feat/video-tiles` (4c86e79) adds an optional
   `video` to a clip: one http(s), `blob:` or relative URL, never `data:`,
diff --git a/muriel/__main__.py b/muriel/__main__.py
index 956ce41..22d1075 100644
--- a/muriel/__main__.py
+++ b/muriel/__main__.py
@@ -19,6 +19,7 @@
     muriel diagram-check fig.svg           # a11y + label + contrast gate
     muriel dimensions                      # print the dimensions registry
     muriel heroshot in.png out.png --tilt 12
+    muriel rasterize fig.svg -o fig.png    # SVG to PNG, cairosvg or ImageMagick
     muriel tilt-shift raw.png hero.png
     muriel venn spec.json out.png
     muriel styleguide examples/muriel-brand.toml --css
@@ -60,6 +61,7 @@
     "import-tokens":  ("muriel.design_tokens_import",         "Convert a DTCG / open-codesign tokens.json into a muriel brand.toml"),
     "import-corpus":  ("muriel.tools.corpus_audit",          "Audit a DESIGN.md corpus through design_md_import + 8:1 floor"),
     "palettes":       ("muriel.palettes",                   "List / generate / validate categorical palettes (CVD + contrast)"),
+    "rasterize":      ("muriel.rasterize",                  "SVG to PNG for a visual audit: cairosvg, else ImageMagick with fonts pinned to installed faces"),
     "smartcrop":      ("muriel.tools.smartcrop",            "Saliency-aware crop solver (edges + optional faces / text / saliency)"),
     "squint":         ("muriel.squint",                     "Dimension-scaled blur ladder + thumbnail companions — does hierarchy survive degradation?"),
     "styleguide":     ("muriel.styleguide",                 "Load a brand.toml; print / derive CSS / matplotlibrc / contrast audit"),
diff --git a/muriel/rasterize.py b/muriel/rasterize.py
new file mode 100644
index 0000000..ec57bb3
--- /dev/null
+++ b/muriel/rasterize.py
@@ -0,0 +1,624 @@
+"""
+muriel.rasterize — SVG to PNG for a visual audit, on whatever renderer the box has.
+
+The critique agent judges a PNG, not SVG source, so every SVG audit starts
+with a rasterize step. cairosvg (the ``[critique]`` extra) was the only
+path, and on Windows it installs cleanly and then fails at import: it binds
+the system Cairo library through cffi, and Windows ships no
+``libcairo-2.dll``. ImageMagick's Windows build carries librsvg and Cairo
+inside it, so ``magick`` renders SVG with nothing else installed.
+
+Backends, first that works wins:
+
+1. ``cairosvg`` — unchanged wherever it already works. An import that
+   raises OSError (installed, no Cairo library) counts as unavailable.
+2. ``magick`` — ImageMagick 7's librsvg delegate, with fonts pinned first.
+
+Font pinning
+------------
+
+The librsvg that ImageMagick bundles (2.40) hands a whole ``font-family``
+value to Pango as one name. It does not walk a CSS stack: ``Inter, Arial,
+sans-serif`` with Inter absent falls back to Pango's generic "Sans" with an
+"expect ugly output" warning and never reaches Arial, and the CSS-only
+keywords muriel's generators lead with (``ui-sans-serif``, ``system-ui``,
+``ui-monospace``) match nothing. So before the render every
+``font-family`` — attribute, inline style, ``<style>`` sheet — is resolved
+to the first family ImageMagick lists as installed, with the keywords
+standing for the faces a browser picks (``system-ui`` is Segoe UI on
+Windows, ``monospace`` is Consolas).
+
+On Windows a second gap remains: only a family's regular, bold and their
+italics answer to the family name, so ``font-weight: 600`` renders Bold and
+300 renders Regular. muriel's generators put 500 and 600 on most labels,
+so the unpinned render overstates hierarchy. Windows also names those
+faces as families of their own ("Segoe UI Semibold"), so every element
+that declares a font is rewritten to name the face directly at weight 400,
+the face chosen by the CSS weight-matching rule. A family with one listed
+face (a variable font) is left to the renderer. Weight pinning is skipped
+when a ``<style>`` sheet sets fonts: the cascade here reads attributes and
+inline styles only, and an inline pin would override the sheet.
+
+cairosvg also reads only the first family of a stack. Pinning is not
+applied on that rung, so output on boxes where cairosvg works is unchanged.
+
+Embedded images do not survive the ImageMagick rung: its librsvg drops
+nested-SVG and data-URI ``<image>`` elements and discolors PNG ones. The
+result carries a note when the source has any, pointing at ``muriel
+capture``, which renders through Chromium.
+
+Usage
+-----
+
+::
+
+    python -m muriel.rasterize fig.svg -o fig.png             # 2x by default
+    python -m muriel.rasterize fig.svg -o fig.png --scale 1   # CSS pixels
+    python -m muriel.rasterize fig.svg -o fig.png --backend magick --json
+"""
+
+from __future__ import annotations
+
+import functools
+import io
+import json
+import re
+import shutil
+import struct
+import subprocess
+import sys
+import tempfile
+import xml.etree.ElementTree as ET
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional, Sequence
+
+
+BACKENDS = ("cairosvg", "magick")
+DEFAULT_SCALE = 2.0
+CSS_PX_PER_INCH = 96
+
+# CSS keyword → the family group a browser resolves it to.
+GENERIC_KEYWORDS: dict[str, str] = {
+    "system-ui":          "system-ui",
+    "-apple-system":      "system-ui",
+    "blinkmacsystemfont": "system-ui",
+    "ui-sans-serif":      "system-ui",
+    "ui-rounded":         "system-ui",
+    "sans-serif":         "sans-serif",
+    "ui-serif":           "serif",
+    "serif":              "serif",
+    "ui-monospace":       "monospace",
+    "monospace":          "monospace",
+}
+
+# Installed-family candidates per group, in the order a browser on each
+# platform would land on them. First one ImageMagick lists wins.
+GENERIC_CANDIDATES: dict[str, tuple[str, ...]] = {
+    "system-ui":  ("Segoe UI", "SF Pro Text", "Helvetica Neue", "Cantarell",
+                   "Ubuntu", "Noto Sans", "DejaVu Sans"),
+    "sans-serif": ("Arial", "Helvetica", "Liberation Sans", "DejaVu Sans"),
+    "serif":      ("Times New Roman", "Times", "Liberation Serif", "DejaVu Serif"),
+    "monospace":  ("Consolas", "Cascadia Mono", "Menlo", "SF Mono",
+                   "Liberation Mono", "DejaVu Sans Mono", "Courier New"),
+}
+
+# When no candidate is installed, the plain generic fontconfig understands.
+_FONTCONFIG_GENERIC = {
+    "system-ui": "sans-serif", "sans-serif": "sans-serif",
+    "serif": "serif", "monospace": "monospace",
+}
+
+_CSS_GENERICS = set(GENERIC_KEYWORDS) | {"cursive", "fantasy", "emoji", "math", "fangsong"}
+_FONT_PROPS = ("font-family", "font-weight", "font-style")
+_SHEET_FAMILY = re.compile(r"(font-family\s*:\s*)([^;{}!]*[^;{}!\s])")
+_SHEET_SETS_FONTS = re.compile(r"font(?:-family|-weight)?\s*:")
+_RELATIVE_REF = re.compile(
+    r"""(?:href\s*=\s*["']|url\(\s*["']?)(?!#|data:|[a-zA-Z][a-zA-Z0-9+.-]*:)""")
+_IMAGE_ELEMENT = re.compile(r"<(?:[\w.-]+:)?image\b")
+
+
+class RasterizeUnavailable(RuntimeError):
+    """No rasterizer backend works on this box."""
+
+
+# --------------------------------------------------------------------------
+# Font catalog — what ImageMagick can render
+# --------------------------------------------------------------------------
+
+@dataclass(frozen=True)
+class Face:
+    name: str      # ImageMagick font name, e.g. "Segoe-UI-Semibold"
+    family: str    # "Segoe UI"
+    weight: int    # 100-900
+    italic: bool
+
+
+FontCatalog = dict[str, list[Face]]   # keyed by lower-case family
+
+
+def parse_font_list(text: str) -> FontCatalog:
+    """Parse ``magick -list font`` output into faces grouped by family."""
+    catalog: FontCatalog = {}
+    current: dict[str, object] = {}
+
+    def flush() -> None:
+        family = current.get("family")
+        if current.get("name") and family:
+            face = Face(str(current["name"]), str(family),
+                        int(current.get("weight", 400)),
+                        bool(current.get("italic", False)))
+            catalog.setdefault(face.family.lower(), []).append(face)
+
+    for line in text.splitlines():
+        key, sep, value = line.strip().partition(":")
+        if not sep:
+            continue
+        key, value = key.strip().lower(), value.strip()
+        if key == "font":
+            flush()
+            current = {"name": value}
+        elif key == "family":
+            current["family"] = value
+        elif key == "style":
+            current["italic"] = value.lower() in ("italic", "oblique")
+        elif key == "weight":
+            try:
+                current["weight"] = int(value)
+            except ValueError:
+                pass
+    flush()
+    return catalog
+
+
+@functools.lru_cache(maxsize=4)
+def installed_faces(magick: str) -> FontCatalog:
+    """The fonts ``magick`` can see; empty when the listing fails."""
+    try:
+        proc = subprocess.run([magick, "-list", "font"], capture_output=True,
+                              text=True, encoding="utf-8", errors="replace",
+                              timeout=60)
+    except (OSError, subprocess.TimeoutExpired):
+        return {}
+    return parse_font_list(proc.stdout)
+
+
+# --------------------------------------------------------------------------
+# Resolution — stacks to families, weights to faces
+# --------------------------------------------------------------------------
+
+def split_stack(value: str) -> list[str]:
+    """``"'Inter', system-ui"`` → ``["Inter", "system-ui"]``."""
+    return [part.strip().strip("'\"").strip()
+            for part in value.split(",") if part.strip().strip("'\"").strip()]
+
+
+def resolve_stack(value: str, catalog: FontCatalog) -> Optional[str]:
+    """First installed family in a CSS stack, keywords expanded.
+
+    None when nothing in the stack resolves and it names no generic; the
+    value is then left as authored.
+    """
+    fallback = None
+    for item in split_stack(value):
+        group = GENERIC_KEYWORDS.get(item.lower())
+        if group is None:
+            faces = catalog.get(item.lower())
+            if faces:
+                return faces[0].family
+            continue
+        for candidate in GENERIC_CANDIDATES[group]:
+            faces = catalog.get(candidate.lower())
+            if faces:
+                return faces[0].family
+        fallback = fallback or _FONTCONFIG_GENERIC[group]
+    return fallback
+
+
+def match_weight(desired: int, available: Sequence[int]) -> int:
+    """The weight CSS font matching picks from ``available`` (CSS Fonts 4 §5.2)."""
+    weights = sorted(set(available))
+    if not weights:
+        raise ValueError("no weights to match against")
+    if desired in weights:
+        return desired
+    below = [w for w in reversed(weights) if w < desired]
+    above = [w for w in weights if w > desired]
+    if 400 <= desired <= 500:
+        order = ([w for w in above if w <= 500] + below
+                 + [w for w in above if w > 500])
+    elif desired < 400:
+        order = below + above
+    else:
+        order = above + below
+    return order[0]
+
+
+def face_family(face: Face) -> Optional[str]:
+    """The family name Windows gives a non-RIBBI face ("Segoe UI Semibold").
+
+    Derived from ImageMagick's hyphenated font name; None for regular and
+    bold faces, which answer to the family name, and for names that do not
+    extend the family.
+    """
+    prefix = face.family.replace(" ", "-") + "-"
+    if not face.name.startswith(prefix):
+        return None
+    words = [w for w in face.name[len(prefix):].split("-")
+             if w and w.lower() not in ("italic", "oblique")]
+    if not words or [w.lower() for w in words] in (["regular"], ["bold"]):
+        return None
+    return f"{face.family} {' '.join(words)}"
+
+
+def _parse_weight(raw: Optional[str], parent: int) -> Optional[int]:
+    if raw is None:
+        return None
+    value = raw.strip().lower()
+    if value == "normal":
+        return 400
+    if value == "bold":
+        return 700
+    if value == "bolder":
+        return 400 if parent < 350 else 700 if parent < 550 else 900
+    if value == "lighter":
+        return 100 if parent < 550 else 400 if parent < 750 else 700
+    try:
+        return max(1, min(1000, int(float(value))))
+    except ValueError:
+        return None
+
+
+def _quote(family: str) -> str:
+    """CSS-quote one family name; generics and stacks pass through."""
+    if "," in family or family[:1] in "'\"" or family.lower() in _CSS_GENERICS:
+        return family
+    return f"'{family}'"
+
+
+# --------------------------------------------------------------------------
+# Pinning — rewrite the SVG so librsvg gets one installed face per element
+# --------------------------------------------------------------------------
+
+@dataclass
+class PinReport:
+    families: dict[tuple[str, str], int] = field(default_factory=dict)
+    faces: dict[tuple[str, str], int] = field(default_factory=dict)
+    notes: list[str] = field(default_factory=list)
+
+    def _count(self, table: dict, key: tuple[str, str]) -> None:
+        table[key] = table.get(key, 0) + 1
+
+    @property
+    def changed(self) -> bool:
+        return bool(self.families or self.faces)
+
+    def to_list(self) -> list[dict]:
+        rows = [{"kind": "family", "from": a, "to": b, "count": n}
+                for (a, b), n in self.families.items()]
+        rows += [{"kind": "face", "from": a, "to": b, "count": n}
+                 for (a, b), n in self.faces.items()]
+        return rows
+
+
+def _style_decls(raw: Optional[str]) -> dict[str, str]:
+    decls: dict[str, str] = {}
+    for part in (raw or "").split(";"):
+        name, sep, value = part.partition(":")
+        if sep and name.strip():
+            decls[name.strip().lower()] = value.strip()
+    return decls
+
+
+def _style_text(decls: dict[str, str]) -> str:
+    return ";".join(f"{k}:{v}" for k, v in decls.items())
+
+
+def _register_namespaces(svg_text: str) -> None:
+    """Keep the source's prefixes so ET writes ``xlink:href``, not ``ns0:href``."""
+    try:
+        for _event, (prefix, uri) in ET.iterparse(io.StringIO(svg_text),
+                                                  events=("start-ns",)):
+            try:
+                ET.register_namespace(prefix, uri)
+            except ValueError:
+                pass
+    except ET.ParseError:
+        pass
+
+
+def pin_fonts(svg_text: str, catalog: FontCatalog, *,
+              named_faces: Optional[bool] = None) -> tuple[str, PinReport]:
+    """Resolve every font stack, and on Windows every intermediate weight.
+
+    Returns the rewritten SVG text and a report of what changed. The text
+    comes back untouched when the catalog is empty, the SVG does not parse,
+    or nothing needed pinning.
+    """
+    report = PinReport()
+    if not catalog:
+        report.notes.append("font pinning skipped: ImageMagick listed no fonts")
+        return svg_text, report
+    if named_faces is None:
+        named_faces = sys.platform == "win32"
+
+    _register_namespaces(svg_text)
+    try:
+        root = ET.fromstring(svg_text)
+    except ET.ParseError as exc:
+        report.notes.append(f"font pinning skipped: SVG did not parse ({exc})")
+        return svg_text, report
+
+    def resolve(stack: str) -> str:
+        resolved = resolve_stack(stack, catalog)
+        if resolved is None or split_stack(stack) == [resolved]:
+            return stack
+        report._count(report.families, (stack.strip(), resolved))
+        return resolved
+
+    sheet_sets_fonts = False
+    for el in root.iter():
+        if isinstance(el.tag, str) and el.tag.rsplit("}", 1)[-1] == "style" and el.text:
+            sheet_sets_fonts = sheet_sets_fonts or bool(_SHEET_SETS_FONTS.search(el.text))
+            el.text = _SHEET_FAMILY.sub(
+                lambda m: m.group(1) + _quote(resolve(m.group(2))), el.text)
+    pin_weights = named_faces and not sheet_sets_fonts
+    if named_faces and sheet_sets_fonts:
+        report.notes.append(
+            "weight pinning skipped: a <style> sheet sets fonts, so the cascade "
+            "here cannot see every element's weight")
+
+    def walk(el: ET.Element, family: Optional[str], weight: int, italic: bool) -> None:
+        decls = _style_decls(el.get("style"))
+        raw = {p: decls.get(p, el.get(p)) for p in _FONT_PROPS}
+        raw = {p: v for p, v in raw.items()
+               if v is not None and v.strip().lower() != "inherit"}
+
+        if "font-family" in raw:
+            family = resolve(raw["font-family"])
+            if "font-family" in decls:
+                decls["font-family"] = _quote(family)
+            else:
+                el.set("font-family", family)
+        parsed = _parse_weight(raw.get("font-weight"), weight)
+        if parsed is not None:
+            weight = parsed
+        if "font-style" in raw:
+            italic = raw["font-style"].strip().lower() in ("italic", "oblique")
+
+        if pin_weights and raw and family is not None:
+            target, target_weight = family, weight
+            faces = [f for f in catalog.get(family.lower(), []) if f.italic == italic]
+            if len(faces) >= 2:
+                chosen = match_weight(weight, [f.weight for f in faces])
+                if chosen in (400, 700):
+                    target_weight = chosen
+                else:
+                    named = face_family(next(f for f in faces if f.weight == chosen))
+                    if named:
+                        target, target_weight = named, 400
+                        report._count(report.faces, (f"{family} @{weight}", named))
+            # Explicit on every declaring element, even when unchanged, so a
+            # descendant never inherits an ancestor's pinned face in place of
+            # the one its own cascade asks for.
+            for prop in ("font-family", "font-weight"):
+                el.attrib.pop(prop, None)
+            decls["font-family"] = _quote(target)
+            decls["font-weight"] = str(target_weight)
+
+        if decls and decls != _style_decls(el.get("style")):
+            el.set("style", _style_text(decls))
+        for child in el:
+            walk(child, family, weight, italic)
+
+    walk(root, None, 400, False)
+    if not report.changed:
+        return svg_text, report
+    return ET.tostring(root, encoding="unicode"), report
+
+
+# --------------------------------------------------------------------------
+# Backends
+# --------------------------------------------------------------------------
+
+def _load_cairosvg():
+    """(module, None) when cairosvg imports, else (None, reason)."""
+    try:
+        import cairosvg  # type: ignore
+    except ImportError:
+        return None, "not installed (pip install 'muriel[critique]')"
+    except OSError as exc:
+        first = str(exc).splitlines()[0] if str(exc) else type(exc).__name__
+        return None, f"installed, but the Cairo library is missing: {first}"
+    return cairosvg, None
+
+
+def available_backends() -> dict[str, Optional[str]]:
+    """Backend → None when usable, else why not."""
+    _, cairo_reason = _load_cairosvg()
+    return {
+        "cairosvg": cairo_reason,
+        "magick": None if shutil.which("magick") else "ImageMagick 7 (magick) not on PATH",
+    }
+
+
+def _png_size(path: Path) -> Optional[tuple[int, int]]:
+    try:
+        with open(path, "rb") as fh:
+            head = fh.read(24)
+    except OSError:
+        return None
+    if head[:8] != b"\x89PNG\r\n\x1a\n" or len(head) < 24:
+        return None
+    return struct.unpack(">II", head[16:24])
+
+
+@dataclass
+class RasterResult:
+    source: Path
+    output: Path
+    backend: str
+    scale: float
+    size: Optional[tuple[int, int]]
+    fonts: list[dict] = field(default_factory=list)
+    notes: list[str] = field(default_factory=list)
+
+    def to_dict(self) -> dict:
+        return {
+            "source": str(self.source),
+            "output": str(self.output),
+            "backend": self.backend,
+            "scale": self.scale,
+            "width": self.size[0] if self.size else None,
+            "height": self.size[1] if self.size else None,
+            "fonts": self.fonts,
+            "notes": self.notes,
+        }
+
+
+def _render_magick(magick: str, svg: Path, out: Path, scale: float) -> list[str]:
+    cmd = [magick, "-background", "none", "-density", f"{CSS_PX_PER_INCH * scale:g}",
+           str(svg), str(out)]
+    proc = subprocess.run(cmd, capture_output=True, text=True, encoding="utf-8",
+                          errors="replace", timeout=300)
+    if proc.returncode != 0 or not out.exists() or out.stat().st_size == 0:
+        detail = (proc.stderr or proc.stdout).strip().splitlines()
+        raise RuntimeError("magick failed: " + (detail[-1] if detail else f"exit {proc.returncode}"))
+    misses = [line for line in proc.stderr.splitlines() if "couldn't load font" in line]
+    if not misses:
+        return []
+    first = misses[0].split("couldn't load font", 1)[1].strip()
+    return [f"{len(misses)} font fallback(s) in the render, e.g. {first}"]
+
+
+def rasterize(svg: Path, out: Path, *, scale: float = DEFAULT_SCALE,
+              backend: str = "auto", pin: bool = True,
+              named_faces: Optional[bool] = None) -> RasterResult:
+    """Render ``svg`` to ``out`` with the first backend that works.
+
+    Raises RasterizeUnavailable when the requested backend (or, for
+    ``auto``, every backend) is unusable, and RuntimeError when a backend
+    runs but fails.
+    """
+    svg, out = Path(svg), Path(out)
+    if scale <= 0:
+        raise ValueError(f"scale must be positive, got {scale}")
+    if backend not in ("auto",) + BACKENDS:
+        raise ValueError(f"unknown backend {backend!r}")
+    if not svg.exists():
+        raise FileNotFoundError(svg)
+    out.parent.mkdir(parents=True, exist_ok=True)
+
+    status = available_backends()
+    order = BACKENDS if backend == "auto" else (backend,)
+    usable = [b for b in order if status[b] is None]
+    if not usable:
+        why = "; ".join(f"{b}: {status[b]}" for b in order)
+        raise RasterizeUnavailable(f"no SVG rasterizer available ({why})")
+    chosen = usable[0]
+    notes = [f"{b} skipped: {status[b]}" for b in order[:order.index(chosen)]]
+
+    if chosen == "cairosvg":
+        cairosvg, _ = _load_cairosvg()
+        cairosvg.svg2png(url=str(svg), write_to=str(out), scale=scale)
+        return RasterResult(svg, out, chosen, scale, _png_size(out), notes=notes)
+
+    magick = shutil.which("magick")
+    text = svg.read_text(encoding="utf-8", errors="replace")
+    images = len(_IMAGE_ELEMENT.findall(text))
+    if images:
+        notes.append(f"{images} <image> element(s): ImageMagick's librsvg drops or "
+                     "discolors embedded images; use muriel capture (Chromium) "
+                     "when they matter")
+    if not pin:
+        notes += _render_magick(magick, svg, out, scale)
+        return RasterResult(svg, out, chosen, scale, _png_size(out), notes=notes)
+
+    pinned, report = pin_fonts(text, installed_faces(magick), named_faces=named_faces)
+    fonts, notes = report.to_list(), notes + report.notes
+    if not report.changed:
+        notes += _render_magick(magick, svg, out, scale)
+        return RasterResult(svg, out, chosen, scale, _png_size(out), fonts, notes)
+
+    # Relative hrefs resolve against the SVG's own directory, so the pinned
+    # copy goes beside the source when it has any; otherwise system temp.
+    temp_dir = svg.parent if _RELATIVE_REF.search(text) else None
+    try:
+        handle = tempfile.NamedTemporaryFile("w", encoding="utf-8", suffix=".svg",
+                                             prefix=".muriel-raster-", dir=temp_dir,
+                                             delete=False)
+    except OSError:
+        handle = tempfile.NamedTemporaryFile("w", encoding="utf-8", suffix=".svg",
+                                             prefix=".muriel-raster-", delete=False)
+        notes.append("source directory not writable; relative hrefs may not resolve")
+    try:
+        with handle:
+            handle.write(pinned)
+        notes += _render_magick(magick, Path(handle.name), out, scale)
+    finally:
+        Path(handle.name).unlink(missing_ok=True)
+    return RasterResult(svg, out, chosen, scale, _png_size(out), fonts, notes)
+
+
+# --------------------------------------------------------------------------
+# CLI
+# --------------------------------------------------------------------------
+
+def _print_result(result: RasterResult) -> None:
+    print(f"rasterize  {result.source}")
+    print(f"  backend  {result.backend}")
+    size = f"  {result.size[0]}x{result.size[1]}" if result.size else ""
+    print(f"  output   {result.output}{size}  at {result.scale:g}x")
+    for i, row in enumerate(result.fonts):
+        label = "  fonts    " if i == 0 else "           "
+        print(f"{label}{row['from']} -> {row['to']}  (x{row['count']})")
+    for note in result.notes:
+        print(f"  note     {note}")
+
+
+def _main(argv: Optional[Sequence[str]] = None) -> int:
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        prog="python -m muriel.rasterize",
+        description=(
+            "Rasterize an SVG to PNG for a visual audit: cairosvg where it "
+            "works, else ImageMagick with font stacks and weights pinned to "
+            "installed faces."
+        ),
+    )
+    parser.add_argument("svg", type=Path, help="Source SVG.")
+    parser.add_argument("-o", "--output", type=Path, required=True,
+                        help="Output PNG path.")
+    parser.add_argument("--scale", type=float, default=DEFAULT_SCALE,
+                        help=f"Device scale; 1 = CSS pixels at 96 dpi (default: {DEFAULT_SCALE:g}).")
+    parser.add_argument("--backend", choices=("auto",) + BACKENDS, default="auto",
+                        help="Force one backend (default: first that works).")
+    parser.add_argument("--no-pin-fonts", action="store_true",
+                        help="Hand ImageMagick the SVG as authored.")
+    parser.add_argument("--json", action="store_true",
+                        help="Print the result as JSON instead of a table.")
+    args = parser.parse_args(argv)
+
+    if not args.svg.exists():
+        print(f"error: file not found: {args.svg}", file=sys.stderr)
+        return 3
+    try:
+        result = rasterize(args.svg, args.output, scale=args.scale,
+                           backend=args.backend, pin=not args.no_pin_fonts)
+    except RasterizeUnavailable as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 4
+    except (RuntimeError, ValueError, OSError, subprocess.TimeoutExpired) as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 3
+
+    if args.json:
+        print(json.dumps(result.to_dict(), indent=2))
+    else:
+        _print_result(result)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(_main())
diff --git a/muriel/squint.py b/muriel/squint.py
index 7b365f2..846c9fa 100644
--- a/muriel/squint.py
+++ b/muriel/squint.py
@@ -121,7 +121,7 @@
 Limitations
 -----------
 
-- Raster in, raster out. Rasterize SVG upstream (``cairosvg``) first.
+- Raster in, raster out. Rasterize SVG upstream (``muriel.rasterize``) first.
 - Judges luminance masses, not text. Contrast ratios belong to
   ``muriel.contrast``; this module deliberately reports none.
 - Pillow's ``GaussianBlur`` is a three-pass box approximation, so the
diff --git a/plugins/muriel/agents/muriel-critique.md b/plugins/muriel/agents/muriel-critique.md
index 4bbb858..2f9ddd6 100644
--- a/plugins/muriel/agents/muriel-critique.md
+++ b/plugins/muriel/agents/muriel-critique.md
@@ -29,7 +29,7 @@ You have read-only Bash scoped to muriel's own compute tools. Use them when it i
 
 - **`python -m muriel.contrast <file.svg>`** — exact WCAG ratios for text+background pairs inside an SVG. Prefer over eyeballing on any SVG artifact.
 - **`python -m muriel.oklch <color>`** — inspect any color (hex / `rgb()` / named / `oklch()`) and report sRGB, OKLCH, in-gamut flag.
-- **`cairosvg <in.svg> -o <out.png>`** — rasterize an SVG to PNG so you can then `Read` the PNG for a real visual audit. Use when a sibling PNG does not exist.
+- **`python -m muriel.rasterize <in.svg> -o <out.png>`** — rasterize an SVG to PNG so you can then `Read` the PNG for a real visual audit. Use when a sibling PNG does not exist. It uses cairosvg where that works, else ImageMagick with font stacks and weights pinned to installed faces, and prints which backend ran. Name the backend in the Verdict rationale when a typography finding depends on the render, and carry any `note` lines (font fallbacks, dropped `<image>` elements) into it.
 - **`python -m muriel.tools.impeccable_bridge <path-or-url>`** *(optional; no-op when its third-party CLI isn't installed)* — deterministic anti-pattern pre-scan via [pbakaus/impeccable](https://github.com/pbakaus/impeccable) (27 static rules, regex + headless Chrome, no LLM). If you have an HTML / URL / project-directory artifact, you may invoke this for a free deterministic preflight; if the command returns no output, impeccable isn't on the box — proceed with vision-only critique exactly as you would have. When it does return a block, paste it verbatim into a `## Deterministic pre-scan (impeccable)` section above your own `## Issues`, and don't re-derive findings the pre-scan already named. Add `--fast` for regex-only (skips Puppeteer). Never block on this; never instruct the user to install impeccable.
 
 The harness may substitute `python3`, `.venv/bin/python`, or `uv run python` depending on the environment — try each if the first fails. If all compute calls are denied (permission prompt, missing binary), fall back to read-only analysis, say so in the Verdict rationale, and hedge your numeric claims per the honest-hedging rule below.
@@ -41,7 +41,7 @@ Handle each artifact type accordingly:
 | Type | Workflow | Degraded? |
 |---|---|---|
 | **PNG / JPG** | Read the file — the multimodal view renders the image inline. Go straight to Visual Inventory (below). | No |
-| **SVG** | Read the file — this returns XML text, not a rendered image. Grep `<text>` / `fill=` / `stroke=` for color + text roles; audit structurally. Run `python -m muriel.contrast <file.svg>` for exact text-pair ratios. For visual composition: Glob for a sibling `<name>.png`; if none, rasterize via `cairosvg <file.svg> -o /tmp/<name>.png` then Read the PNG. | Only if rasterization fails |
+| **SVG** | Read the file — this returns XML text, not a rendered image. Grep `<text>` / `fill=` / `stroke=` for color + text roles; audit structurally. Run `python -m muriel.contrast <file.svg>` for exact text-pair ratios. For visual composition: Glob for a sibling `<name>.png`; if none, rasterize via `python -m muriel.rasterize <file.svg> -o /tmp/<name>.png` then Read the PNG. | Only if rasterization fails |
 | **PDF** | Read with `pages: "1"` first; iterate further pages only if the artifact is a multi-page deck. Name which page each finding refers to. | No, per page |
 | **HTML / URL / project directory** | You cannot render HTML with your tools. Require a pre-captured PNG (use `muriel capture` upstream). If none is supplied, decline with a single-sentence rationale in the Verdict rationale and ship `NEEDS REVISION` rather than inventing findings. Optionally, if the artifact is HTML/URL/dir, you may invoke the impeccable bridge (above) for a deterministic preflight; if it emits nothing, it isn't installed — keep going with the screenshot workflow unchanged. | N/A — decline (visual pass needs a screenshot) |
 | **Animated (gif, mp4, webm)** | You cannot decode video with your tools. Require pre-extracted frames as PNGs. If none, decline with a one-sentence Verdict rationale and ship `NEEDS REVISION`. | N/A — decline |
@@ -279,7 +279,7 @@ When the pre-scan ran and emitted findings, treat it as complementary, not redun
 
 ## What you do not do
 
-- You do not write or edit files. You have no Edit/Write. Your Bash is scoped read-only to muriel's compute CLIs (`muriel.contrast`, `muriel.oklch`, `cairosvg`); do not invoke anything else.
+- You do not write or edit files. You have no Edit/Write. Your Bash is scoped read-only to muriel's compute CLIs (`muriel.contrast`, `muriel.oklch`, `muriel.rasterize`); do not invoke anything else.
 - You do not fix the artifact. You name what's wrong; the human or another agent fixes.
 - You do not hedge excessively. If you are 80% confident an issue is real, report it at the appropriate severity. If you are 30% confident, put it in "Visual-judgment calls (non-binding)."
 - You do not defer. You are the critic. Judgment is the product.
diff --git a/plugins/muriel/skills/compose/channels/svg.md b/plugins/muriel/skills/compose/channels/svg.md
index e8ef0fa..eb384bc 100644
--- a/plugins/muriel/skills/compose/channels/svg.md
+++ b/plugins/muriel/skills/compose/channels/svg.md
@@ -102,6 +102,7 @@ Same seed and parameters produce byte-identical geometry. Examples:
 
 ## Conversion
 - **SVG → PNG:** `cairosvg input.svg -o out.png -W 1280 -H 720` or `rsvg-convert -w 1280 input.svg > out.png`
+- **SVG → PNG for an audit:** `python -m muriel.rasterize input.svg -o out.png` uses cairosvg where it imports, else ImageMagick (`magick`), which renders on Windows with no Cairo library. On that rung it pins each font stack to the first installed family and each 500/600 weight to its named face (librsvg would otherwise fall back to a generic Sans and round 600 to Bold), and it flags `<image>` elements, which ImageMagick's librsvg drops.
 - **SVG → PDF:** `cairosvg input.svg -o out.pdf` (for paper inclusion)
 - **HTML → SVG snapshot:** Playwright `page.locator('svg').screenshot()` for live-rendered figures — see [channels/web.md](web.md) for the static capture pipeline.
 
diff --git a/tests/test_rasterize.py b/tests/test_rasterize.py
new file mode 100644
index 0000000..7d53ea2
--- /dev/null
+++ b/tests/test_rasterize.py
@@ -0,0 +1,366 @@
+"""
+Tests for muriel.rasterize — SVG to PNG with an ImageMagick fallback.
+
+The module makes three claims, each tested here:
+
+  * The backend order holds. cairosvg wins where it imports; an install
+    that raises OSError at import (no Cairo library, the Windows case) is
+    unavailable rather than fatal; ImageMagick is next; nothing usable is
+    a clear error, not a traceback.
+  * Font stacks resolve the way a browser resolves them. librsvg takes
+    only the first family, so the pinned SVG must name the first
+    installed one, with the CSS-only keywords muriel's generators lead
+    with expanded to real faces.
+  * Intermediate weights survive. With named faces on, 600 on Segoe UI
+    becomes the Semibold face at weight 400, every declaring element is
+    explicit so descendants inherit the right face, and pinning stands
+    down where its cascade cannot see (a <style> sheet, a one-face
+    family).
+
+Pinning is pure and tested against a fixture font list, so it runs on
+any OS. The render tests need ImageMagick 7 and skip cleanly without it.
+Standard library only (unittest, no pytest dependency).
+"""
+
+from __future__ import annotations
+
+import io
+import shutil
+import subprocess
+import tempfile
+import unittest
+import xml.etree.ElementTree as ET
+from contextlib import redirect_stderr
+from pathlib import Path
+from unittest import mock
+
+from muriel import rasterize as rz
+from muriel.rasterize import (
+    Face,
+    RasterizeUnavailable,
+    face_family,
+    match_weight,
+    parse_font_list,
+    pin_fonts,
+    rasterize,
+    resolve_stack,
+    split_stack,
+)
+
+
+def _block(name: str, family: str, weight: int, style: str = "Normal") -> str:
+    return (f"  Font: {name}\n    family: {family}\n    style: {style}\n"
+            f"    stretch: Normal\n    weight: {weight}\n    metrics: not defined\n"
+            f"    glyphs: c:\\windows\\fonts\\{name.lower()}.ttf\n    index: 0\n")
+
+
+FONT_LIST = "Path: Windows Fonts\n" + "".join([
+    _block("Arial", "Arial", 400),
+    _block("Arial-Bold", "Arial", 700),
+    _block("Arial-Black", "Arial", 900),
+    _block("Consolas", "Consolas", 400),
+    _block("Consolas-Bold", "Consolas", 700),
+    _block("Consolas-Italic", "Consolas", 400, "Italic"),
+    _block("Segoe-UI", "Segoe UI", 400),
+    _block("Segoe-UI-Light", "Segoe UI", 300),
+    _block("Segoe-UI-Semibold", "Segoe UI", 600),
+    _block("Segoe-UI-Bold", "Segoe UI", 700),
+    _block("Segoe-UI-Black", "Segoe UI", 900),
+    _block("Segoe-UI-Italic", "Segoe UI", 400, "Italic"),
+    _block("Segoe-UI-Semibold-Italic", "Segoe UI", 600, "Italic"),
+    _block("Segoe-UI-Bold-Italic", "Segoe UI", 700, "Italic"),
+    _block("Segoe-UI-Variable", "Segoe UI Variable", 400),
+])
+CATALOG = parse_font_list(FONT_LIST)
+
+SVG_NS = "http://www.w3.org/2000/svg"
+MURIEL_STACK = "ui-sans-serif, -apple-system, system-ui, sans-serif"
+MONO_STACK = "ui-monospace, SFMono-Regular, Menlo, Consolas, monospace"
+
+
+def _svg(body: str, root_attrs: str = f'font-family="{MURIEL_STACK}"') -> str:
+    return (f'<svg xmlns="{SVG_NS}" xmlns:xlink="http://www.w3.org/1999/xlink" '
+            f'width="200" height="100" viewBox="0 0 200 100" {root_attrs}>{body}</svg>')
+
+
+def _style(el: ET.Element) -> dict[str, str]:
+    return rz._style_decls(el.get("style"))
+
+
+def _texts(svg_text: str) -> list[ET.Element]:
+    return ET.fromstring(svg_text).findall(f".//{{{SVG_NS}}}text")
+
+
+class ParseFontListTests(unittest.TestCase):
+    def test_faces_group_by_family(self):
+        self.assertEqual(sorted(CATALOG), ["arial", "consolas", "segoe ui",
+                                           "segoe ui variable"])
+        weights = sorted(f.weight for f in CATALOG["segoe ui"] if not f.italic)
+        self.assertEqual(weights, [300, 400, 600, 700, 900])
+
+    def test_italic_and_name_are_read(self):
+        face = next(f for f in CATALOG["segoe ui"] if f.italic and f.weight == 600)
+        self.assertEqual(face.name, "Segoe-UI-Semibold-Italic")
+
+    def test_glyph_path_colon_does_not_split_a_block(self):
+        self.assertEqual(len(CATALOG["arial"]), 3)
+
+    def test_empty_listing(self):
+        self.assertEqual(parse_font_list(""), {})
+
+
+class ResolveStackTests(unittest.TestCase):
+    def test_split_strips_quotes(self):
+        self.assertEqual(split_stack("'Inter', \"Segoe UI\" , sans-serif"),
+                         ["Inter", "Segoe UI", "sans-serif"])
+
+    def test_muriel_stack_lands_on_the_system_ui_face(self):
+        self.assertEqual(resolve_stack(MURIEL_STACK, CATALOG), "Segoe UI")
+
+    def test_monospace_stack_skips_missing_families(self):
+        self.assertEqual(resolve_stack(MONO_STACK, CATALOG), "Consolas")
+
+    def test_walks_past_a_missing_first_family(self):
+        self.assertEqual(resolve_stack("'Inter', Arial, sans-serif", CATALOG), "Arial")
+
+    def test_case_insensitive(self):
+        self.assertEqual(resolve_stack("segoe ui", CATALOG), "Segoe UI")
+
+    def test_nothing_installed_and_no_generic_is_none(self):
+        self.assertIsNone(resolve_stack("Inter, Roboto", CATALOG))
+
+    def test_generic_with_no_candidate_falls_to_fontconfig_generic(self):
+        only_variable = {"segoe ui variable": CATALOG["segoe ui variable"]}
+        self.assertEqual(resolve_stack("Inter, system-ui", only_variable), "sans-serif")
+
+
+class MatchWeightTests(unittest.TestCase):
+    """CSS Fonts 4 §5.2: the weight-matching branches."""
+
+    def test_exact(self):
+        self.assertEqual(match_weight(600, [400, 600, 700]), 600)
+
+    def test_above_500_prefers_heavier(self):
+        self.assertEqual(match_weight(600, [400, 700, 900]), 700)
+        self.assertEqual(match_weight(650, [400, 600]), 600)
+
+    def test_below_400_prefers_lighter_then_heavier(self):
+        self.assertEqual(match_weight(300, [200, 400]), 200)
+        self.assertEqual(match_weight(300, [400, 700]), 400)
+
+    def test_400_to_500_tries_up_to_500_then_lighter(self):
+        self.assertEqual(match_weight(450, [400, 500]), 500)
+        self.assertEqual(match_weight(500, [300, 400, 600, 700]), 400)
+        self.assertEqual(match_weight(450, [600, 700]), 600)
+
+    def test_empty_raises(self):
+        with self.assertRaises(ValueError):
+            match_weight(400, [])
+
+
+class FaceFamilyTests(unittest.TestCase):
+    def test_named_faces(self):
+        self.assertEqual(face_family(Face("Segoe-UI-Semibold", "Segoe UI", 600, False)),
+                         "Segoe UI Semibold")
+        self.assertEqual(face_family(Face("Segoe-UI-Semibold-Italic", "Segoe UI", 600, True)),
+                         "Segoe UI Semibold")
+        self.assertEqual(face_family(Face("Arial-Black", "Arial", 900, False)), "Arial Black")
+
+    def test_ribbi_faces_answer_to_the_family(self):
+        self.assertIsNone(face_family(Face("Segoe-UI", "Segoe UI", 400, False)))
+        self.assertIsNone(face_family(Face("Segoe-UI-Bold-Italic", "Segoe UI", 700, True)))
+
+    def test_name_that_does_not_extend_the_family(self):
+        self.assertIsNone(face_family(Face("SegoeUI-Semibold", "Segoe UI", 600, False)))
+
+
+class PinFontsTests(unittest.TestCase):
+    def pin(self, svg_text: str, named_faces: bool = True):
+        return pin_fonts(svg_text, CATALOG, named_faces=named_faces)
+
+    def test_muriel_label_weights_get_their_faces(self):
+        out, report = self.pin(_svg(
+            '<text font-weight="600">Title</text>'
+            '<text font-weight="700">Focal</text>'
+            f'<text font-family="{MONO_STACK}" font-size="11">38.0</text>'))
+        title, focal, mono = _texts(out)
+        self.assertEqual(_style(title), {"font-family": "'Segoe UI Semibold'",
+                                         "font-weight": "400"})
+        self.assertEqual(_style(focal), {"font-family": "'Segoe UI'", "font-weight": "700"})
+        self.assertEqual(_style(mono)["font-family"], "'Consolas'")
+        self.assertIsNone(title.get("font-weight"))
+        rows = {(r["from"], r["to"]) for r in report.to_list()}
+        self.assertIn((MURIEL_STACK, "Segoe UI"), rows)
+        self.assertIn(("Segoe UI @600", "Segoe UI Semibold"), rows)
+
+    def test_without_named_faces_only_stacks_change(self):
+        out, report = self.pin(_svg('<text font-weight="600">Title</text>'),
+                               named_faces=False)
+        root = ET.fromstring(out)
+        self.assertEqual(root.get("font-family"), "Segoe UI")
+        self.assertEqual(_texts(out)[0].get("font-weight"), "600")
+        self.assertFalse(report.faces)
+
+    def test_descendant_does_not_inherit_a_pinned_face_it_did_not_ask_for(self):
+        out, _ = self.pin(_svg(
+            '<g font-weight="600"><text font-weight="400">Body</text>'
+            '<text>Inherits</text></g>'))
+        root = ET.fromstring(out)
+        group = root.find(f"{{{SVG_NS}}}g")
+        body, inherits = _texts(out)
+        self.assertEqual(_style(group)["font-family"], "'Segoe UI Semibold'")
+        self.assertEqual(_style(body), {"font-family": "'Segoe UI'", "font-weight": "400"})
+        self.assertEqual(_style(inherits), {})
+
+    def test_italic_picks_from_italic_faces(self):
+        out, _ = self.pin(_svg('<text font-style="italic" font-weight="600">Aside</text>'))
+        text = _texts(out)[0]
+        self.assertEqual(_style(text)["font-family"], "'Segoe UI Semibold'")
+        self.assertEqual(text.get("font-style"), "italic")
+
+    def test_weight_with_no_matching_face_rounds_like_css(self):
+        out, report = self.pin(_svg('<text font-family="Arial" font-weight="600">A</text>'))
+        self.assertEqual(_style(_texts(out)[0]),
+                         {"font-family": "'Arial'", "font-weight": "700"})
+        self.assertFalse(report.faces)
+
+    def test_single_face_family_keeps_its_authored_weight(self):
+        out, report = self.pin(_svg(
+            '<text font-family="Segoe UI Variable" font-weight="600">A</text>'))
+        self.assertEqual(_style(_texts(out)[0]),
+                         {"font-family": "'Segoe UI Variable'", "font-weight": "600"})
+        self.assertFalse(report.faces)
+
+    def test_already_installed_family_is_returned_untouched(self):
+        src = _svg('<text font-weight="600">A</text>', root_attrs='font-family="Arial"')
+        out, report = self.pin(src)
+        self.assertEqual(out, src)
+        self.assertFalse(report.changed)
+
+    def test_style_sheet_resolves_stacks_but_skips_weights(self):
+        out, report = self.pin(_svg(
+            f"<style>.t {{ font-family: {MURIEL_STACK}; font-weight: 600 }}</style>"
+            '<text class="t" font-weight="600">A</text>', root_attrs=""))
+        style = ET.fromstring(out).find(f"{{{SVG_NS}}}style")
+        self.assertIn("font-family: 'Segoe UI';", style.text)
+        self.assertEqual(_texts(out)[0].get("font-weight"), "600")
+        self.assertTrue(any("<style> sheet" in n for n in report.notes))
+
+    def test_inline_style_stack_is_resolved_in_place(self):
+        out, _ = self.pin(_svg(f'<text style="font-family: {MURIEL_STACK}; fill: red">A</text>',
+                               root_attrs=""), named_faces=False)
+        self.assertEqual(_style(_texts(out)[0]),
+                         {"font-family": "'Segoe UI'", "fill": "red"})
+
+    def test_unresolvable_stack_is_left_as_authored(self):
+        out, _ = self.pin(_svg('<text font-weight="600">A</text>',
+                               root_attrs='font-family="Inter, Roboto"'))
+        self.assertEqual(ET.fromstring(out).get("font-family"), "Inter, Roboto")
+
+    def test_namespaces_survive(self):
+        out, _ = self.pin(_svg('<use xlink:href="#a"/><text>A</text>'))
+        self.assertIn("xlink:href", out)
+        self.assertNotIn("ns0", out)
+
+    def test_no_fonts_declared_returns_input_unchanged(self):
+        src = _svg("<rect width='5' height='5'/>", root_attrs="")
+        out, report = self.pin(src)
+        self.assertEqual(out, src)
+        self.assertFalse(report.changed)
+
+    def test_empty_catalog_and_bad_svg_are_noted_not_raised(self):
+        src = _svg("<text>A</text>")
+        out, report = pin_fonts(src, {}, named_faces=True)
+        self.assertEqual(out, src)
+        self.assertTrue(report.notes)
+        out, report = self.pin("<svg><text>unclosed</svg>")
+        self.assertEqual(out, "<svg><text>unclosed</svg>")
+        self.assertTrue(any("did not parse" in n for n in report.notes))
+
+
+class BackendOrderTests(unittest.TestCase):
+    def test_no_backend_is_a_clear_error(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            svg = Path(tmp) / "a.svg"
+            svg.write_text(_svg("<text>A</text>"), encoding="utf-8")
+            with mock.patch.object(rz, "_load_cairosvg", return_value=(None, "no cairo")), \
+                 mock.patch.object(rz.shutil, "which", return_value=None):
+                with self.assertRaises(RasterizeUnavailable) as ctx:
+                    rasterize(svg, Path(tmp) / "a.png")
+                self.assertIn("cairosvg: no cairo", str(ctx.exception))
+                self.assertIn("magick", str(ctx.exception))
+                with redirect_stderr(io.StringIO()):
+                    rc = rz._main([str(svg), "-o", str(Path(tmp) / "a.png")])
+                self.assertEqual(rc, 4)
+
+    def test_cairo_import_oserror_counts_as_unavailable(self):
+        real_import = __import__
+
+        def fake_import(name, *args, **kwargs):
+            if name == "cairosvg":
+                raise OSError('no library called "cairo-2" was found\nmore detail')
+            return real_import(name, *args, **kwargs)
+
+        with mock.patch("builtins.__import__", side_effect=fake_import):
+            module, reason = rz._load_cairosvg()
+        self.assertIsNone(module)
+        self.assertIn("Cairo library is missing", reason)
+        self.assertNotIn("more detail", reason)
+
+    def test_missing_file_exits_3(self):
+        with redirect_stderr(io.StringIO()):
+            self.assertEqual(rz._main(["does-not-exist.svg", "-o", "x.png"]), 3)
+
+    def test_registered_with_the_dispatcher(self):
+        from muriel.__main__ import SUBCOMMANDS
+        self.assertEqual(SUBCOMMANDS["rasterize"][0], "muriel.rasterize")
+
+
+@unittest.skipUnless(shutil.which("magick"), "ImageMagick 7 (magick) not on PATH")
+class MagickRenderTests(unittest.TestCase):
+    def render(self, body: str, scale: float = 2.0, **kwargs):
+        tmp = tempfile.TemporaryDirectory()
+        self.addCleanup(tmp.cleanup)
+        src = Path(tmp.name) / "fig.svg"
+        src.write_text(_svg(body), encoding="utf-8")
+        return src, rasterize(src, Path(tmp.name) / "out" / "fig.png", scale=scale,
+                              backend="magick", **kwargs)
+
+    def test_scale_sets_pixel_size(self):
+        _, result = self.render("<text x='4' y='40'>A</text>", scale=2)
+        self.assertEqual(result.backend, "magick")
+        self.assertEqual(result.size, (400, 200))
+
+    def test_pinned_render_leaves_no_temp_file(self):
+        src, result = self.render("<text x='4' y='40' font-weight='600'>A</text>")
+        self.assertTrue(result.fonts)
+        self.assertEqual([p.name for p in src.parent.iterdir() if p.name.startswith(".")], [])
+
+    def test_image_elements_are_flagged_and_the_side_copy_is_cleaned_up(self):
+        # A relative href puts the pinned copy beside the source; it must
+        # not outlive the render, and the image limitation must be named.
+        tmp = tempfile.TemporaryDirectory()
+        self.addCleanup(tmp.cleanup)
+        folder = Path(tmp.name)
+        (folder / "dot.svg").write_text(
+            f'<svg xmlns="{SVG_NS}" width="10" height="10"><rect width="10" height="10"/></svg>',
+            encoding="utf-8")
+        src = folder / "fig.svg"
+        src.write_text(_svg('<image href="dot.svg" width="200" height="100"/>'
+                            "<text x='4' y='40'>A</text>"), encoding="utf-8")
+        result = rasterize(src, folder / "fig.png", scale=1, backend="magick")
+        self.assertTrue(result.fonts)
+        self.assertEqual(sorted(p.name for p in folder.iterdir()),
+                         ["dot.svg", "fig.png", "fig.svg"])
+        self.assertTrue(any("<image>" in n and "muriel capture" in n for n in result.notes))
+
+    def test_empty_canvas_stays_transparent_like_cairosvg(self):
+        _, result = self.render("<rect width='10' height='10' fill='#123456'/>", scale=1)
+        alpha = subprocess.run(
+            [shutil.which("magick"), str(result.output), "-format", "%[fx:p{150,80}.a]", "info:"],
+            capture_output=True, text=True, check=True).stdout.strip()
+        self.assertEqual(alpha, "0")
+
+
+if __name__ == "__main__":
+    unittest.main()