diff --git a/README.md b/README.md
index 617fccd86..c088f1056 100644
--- a/README.md
+++ b/README.md
@@ -392,6 +392,34 @@ python -m client.query_runner
 - **GET /search** - Card search with query parameter support
 - **GET /favicon.ico** - Favicon for web interface
 
+### Scryfall-Compatible Endpoints
+
+Every route Scryfall documents under `/cards`, answering with Scryfall's own response objects and
+175-per-page pagination, so a client can be pointed here by swapping its base URL:
+
+- **GET /cards** and **GET /cards/search** - list routes (`format=json|csv`)
+- **GET /cards/named**, **/cards/autocomplete**, **/cards/random** - single-card and catalog lookups
+- **POST /cards/collection** - up to 75 identifiers at once
+- **GET /cards/:id**, **/cards/:code/:number(/:lang)**, and the multiverse / mtgo / arena /
+  tcgplayer / cardmarket id namespaces
+- **GET /cards/:id/rulings** and its four sibling addressings
+
+`format=text` and `format=image` are available on the single-card routes. What is *not* identical —
+chiefly that the corpus is a filtered subset of Scryfall's — is recorded in
+[docs/issues/local-scryfall-cards-api.md](docs/issues/local-scryfall-cards-api.md).
+
+The reference half of the API, mirrored from Scryfall rather than derived from the corpus:
+
+- **GET /sets**, **/sets/:code**, **/sets/:id**, **/sets/tcgplayer/:id** - 1,047 Set objects
+- **GET /catalog/:name** - all twenty catalogs, 62,187 values
+- **GET /symbology** - 84 card symbols
+- **GET /symbology/parse-mana?cost=** - computed, not stored, so it answers before the first import
+
+These are mirrored because the corpus cannot answer them: a Set object carries eight fields no card
+carries, `card_count` counts printings this instance never imported, and a symbol's `svg_uri` exists
+nowhere in the card data. Details in
+[docs/issues/local-scryfall-sets-catalogs-symbology.md](docs/issues/local-scryfall-sets-catalogs-symbology.md).
+
 ### Admin Endpoints
 
 Data-management routes — importing card data, running score/tag backfills, applying schema
diff --git a/api/admin_resource.py b/api/admin_resource.py
index 45ce865af..7a320e663 100644
--- a/api/admin_resource.py
+++ b/api/admin_resource.py
@@ -46,7 +46,11 @@
 
 from api.card_processing import preprocess_card
 from api.db.bulk_upsert import bulk_upsert as _bulk_upsert
+from api.rulings_import import import_rulings as _import_rulings
 from api.scryfall_bulk_data_fetcher import BulkDataKey, ScryfallBulkDataFetcher
+from api.scryfall_reference_import import import_catalogs as _import_catalogs
+from api.scryfall_reference_import import import_sets as _import_sets
+from api.scryfall_reference_import import import_symbology as _import_symbology
 from api.settings import settings
 from api.tag_import import import_art_tags as _import_art_tags
 from api.tag_import import import_oracle_tags as _import_oracle_tags
@@ -399,6 +403,13 @@ def _run_import_under_lock(self) -> None:
             self.backfill_prefer_scores()
             self.backfill_cubecobra_scores()
             _import_oracle_tags(self.app_context.writer_pool, self._bulk_data_fetcher)
+            # Rulings feed only /cards/*/rulings, so nothing above or below depends on them; they
+            # sit here rather than in their own pass so one bulk fetch cycle refreshes everything.
+            self._import_rulings_quietly()
+            # Alongside the rulings and for the same reason: reference data nothing else in this
+            # sequence reads, refreshed on the same cycle so one pass brings the whole surface up
+            # to date rather than leaving /sets and /catalog to age until a manual call.
+            self._import_reference_quietly()
             self.app_context.reload_engine(force=True)
             self._clear_caches()
             self.app_context.last_import_time.value = time.time()
@@ -931,6 +942,72 @@ def import_art_tags(self, **_: object) -> dict[str, Any]:
         """Import art tags from Scryfall bulk data into art_tags, art_tag_relationships, and card_art_tags."""
         return _import_art_tags(self.app_context.writer_pool, self._bulk_data_fetcher)
 
+    @route()
+    def import_rulings(self, **_: object) -> dict[str, Any]:
+        """Import Scryfall rulings bulk data into magic.rulings, backing the /cards/*/rulings routes.
+
+        Returns:
+            The number of rulings loaded.
+        """
+        return {"rulings_loaded": _import_rulings(self.app_context.writer_pool, self._bulk_data_fetcher)}
+
+    def _import_rulings_quietly(self) -> None:
+        """Refresh the rulings during a bulk import, logging rather than failing on error.
+
+        Rulings are the only data in the import sequence nothing else reads: a card search, the
+        prefer scores and the engine reload all work without them. Letting a bad rulings file
+        abort the import would cost the corpus refresh to save a rulings refresh.
+        """
+        try:
+            _import_rulings(self.app_context.writer_pool, self._bulk_data_fetcher)
+        except Exception:
+            logger.exception("Rulings import failed; continuing with the rest of the import")
+
+    @route()
+    def import_sets(self, **_: object) -> dict[str, Any]:
+        """Mirror Scryfall's set list into magic.sets, backing the /sets routes.
+
+        Returns:
+            A summary of the load.
+        """
+        return _import_sets(self.app_context.writer_pool, self._bulk_data_fetcher)
+
+    @route()
+    def import_catalogs(self, **_: object) -> dict[str, Any]:
+        """Mirror the twenty Scryfall catalogs into magic.catalogs, backing /catalog/*.
+
+        Returns:
+            A summary of the load.
+        """
+        return _import_catalogs(self.app_context.writer_pool, self._bulk_data_fetcher)
+
+    @route()
+    def import_symbology(self, **_: object) -> dict[str, Any]:
+        """Mirror Scryfall's card symbols into magic.card_symbols, backing /symbology.
+
+        Returns:
+            A summary of the load.
+        """
+        return _import_symbology(self.app_context.writer_pool, self._bulk_data_fetcher)
+
+    def _import_reference_quietly(self) -> None:
+        """Refresh sets, catalogs and symbology during a bulk import, logging rather than failing.
+
+        Each of the three is independent of the other two and of everything else in the sequence,
+        so one failing upstream endpoint must not cost the other two their refresh — nor the corpus
+        its. This is the rulings argument applied three more times: nothing downstream reads any of
+        these tables, so a stale one degrades three endpoints rather than breaking the import.
+        """
+        for name, step in (
+            ("Set", _import_sets),
+            ("Catalog", _import_catalogs),
+            ("Symbology", _import_symbology),
+        ):
+            try:
+                step(self.app_context.writer_pool, self._bulk_data_fetcher)
+            except Exception:
+                logger.exception("%s import failed; continuing with the rest of the import", name)
+
     @route()
     def import_all_is_tags(self, **_: object) -> dict[str, Any]:
         """Discover and import all is: tags from Scryfall syntax documentation.
diff --git a/api/api_resource.py b/api/api_resource.py
index aa2aa637b..1a449f214 100644
--- a/api/api_resource.py
+++ b/api/api_resource.py
@@ -18,13 +18,14 @@
 from typing import TYPE_CHECKING, Any, NoReturn
 
 import falcon
+import falcon.util
 import orjson
 import psycopg
 from cachebox import LRUCache, TTLCache
 
 from api.admin_resource import ADMIN_MOUNT_PREFIX, AdminContext, AdminResource
 from api.app_context import AppContext
-from api.enums import CardOrdering, PreferOrder, ResponseShape, SortDirection, UniqueOn
+from api.enums import CardOrdering, PreferOrder, ResponseShape, SortDirection, UniqueOn, resolve_direction
 from api.middlewares.timing import record_span
 from api.noscript_helpers import generate_results_count_html, generate_results_html
 from api.parsing import generate_sql_query, parse_scryfall_query
@@ -34,6 +35,7 @@
     QueryBudgetExceeded,
     bounded_query_log_context,
 )
+from api.scryfall_compat import ScryfallCardsRoutes, ScryfallReferenceRoutes
 from api.settings import settings
 from api.utils import db_utils, error_monitoring
 from api.utils.css_utils import build_critical_css
@@ -95,7 +97,39 @@ def _raise_query_bad_request(*, exc_name: str, query: str, description: str, err
 
 
 # Query parameters that must not be forwarded to action handlers.
-DISALLOWED_QUERY_ARGS: frozenset[str] = frozenset(["falcon_response", "request_host"])
+# The route keys that make up the SCRYFALL-COMPATIBLE surface.
+#
+# It decides one thing: which shape a DISPATCH-level error takes on that path -- Scryfall's
+# `{object, code, status, details}` or falcon's `{title, description}`. Everything a handler answers
+# for itself already knows which surface it is on.
+#
+# The split is by ROUTE KEY rather than by path prefix because the two surfaces interleave under one
+# namespace: `catalog` is Scryfall's `/catalog/:name` and `get_catalog` is this service's own, and
+# only the table can tell them apart. Keys for routes a given branch has not merged yet are harmless
+# -- an unregistered key is never resolved, so it is never consulted.
+#
+# What is deliberately NOT here: `_root`, `card`, `index`, `search` and `random_search` -- this
+# service's own surface, whose error bodies its web interface renders by reading `title` and
+# `description` -- plus `get_catalog`, `get_pid` and the admin handlers.
+SCRYFALL_SURFACE_ROUTES = frozenset(
+    {
+        "cards",
+        "cards/search",
+        "cards/named",
+        "cards/autocomplete",
+        "cards/random",
+        "cards/collection",
+        "catalog",
+        "sets",
+        "symbology",
+        "symbology/parse-mana",
+    },
+)
+
+# Scryfall's sentence for a path that addresses nothing, measured 2026-08-16.
+_SCRYFALL_NOT_FOUND_DETAILS = "The requested object or REST method was not found."
+
+DISALLOWED_QUERY_ARGS: frozenset[str] = frozenset(["falcon_response", "request", "request_host"])
 
 # Body for an unhandled exception. Fixed and content-free on purpose: the frames live at throw sites
 # inside query and import paths, so their locals can hold connection and query state. Diagnostics go
@@ -122,6 +156,25 @@ def pagination_ceiling() -> int:
     return int((time.time() - PAGINATION_BASE_TIMESTAMP) // PAGINATION_GROWTH_INTERVAL_SECONDS)
 
 
+# `order=color`, as SQL. The eleven buckets Scryfall sorts colour into, measured 2026-08-09 over 923
+# cards spanning every colour shape: mono WUBRG, then multicolour by HOW MANY colours (guild pairs
+# tie), then colourless, then lands. Two of those are not what a colour bitmask would give -- the
+# colourless bucket sorts last rather than first, and lands after it -- which is why this is a CASE
+# rather than an expression over card_colors. Mirrors color_sort_rank in card_engine/src/lib.rs; the
+# two must agree or the SQL and engine paths order the same query differently.
+_COLOR_ORDER_SQL = """
+        (CASE
+            WHEN card_colors = '{"W": true}'::jsonb THEN 0
+            WHEN card_colors = '{"U": true}'::jsonb THEN 1
+            WHEN card_colors = '{"B": true}'::jsonb THEN 2
+            WHEN card_colors = '{"R": true}'::jsonb THEN 3
+            WHEN card_colors = '{"G": true}'::jsonb THEN 4
+            WHEN (SELECT count(1) FROM jsonb_object_keys(card_colors)) > 1
+                THEN 3 + (SELECT count(1) FROM jsonb_object_keys(card_colors))
+            WHEN card_types ? 'Land' THEN 10
+            ELSE 9
+        END)"""
+
 RESULT_FIELD_COLUMNS: dict[str, str] = {
     "name": "card_name",
     "set_code": "card_set_code",
@@ -135,6 +188,11 @@ def pagination_ceiling() -> int:
     "illustration_id": "illustration_id",
     "scryfall_id": "scryfall_id",
     "price_usd": "price_usd",
+    # The other two currencies CardOrdering already sorts by (see the sql_orderby map's
+    # EUR/TIX entries). Without these a caller can rank a page by EUR or TIX and then have
+    # no way to read the number it was ranked on. Both are real magic.cards columns.
+    "price_eur": "price_eur",
+    "price_tix": "price_tix",
     "prefer_score": "prefer_score",
     # Card-data fields consumers need to run their own downstream filtering
     # (Scryfall JSON names and shapes): layout and rarity are plain text,
@@ -213,6 +271,29 @@ def rewrap(query: str) -> str:
     return " ".join(query.strip().split())
 
 
+def _request_injection(entry: BoundRoute | None, req: falcon.Request) -> dict[str, Any]:
+    """Return the `request` keyword for handlers that declare it, and nothing for the rest.
+
+    Only `POST /cards/collection` wants the request object: its identifiers arrive in the body,
+    which nothing else in the dispatch path reads. Injecting it unconditionally is not an option —
+    a non-string keyword a handler neither declares nor absorbs through `**kwargs` reaches it as a
+    TypeError, and `search` is one such handler.
+
+    Args:
+        entry: The resolved route, or None when the path identified nothing.
+        req: The request being dispatched.
+
+    Returns:
+        `{"request": req}` when the handler declares the parameter, otherwise an empty dict.
+    """
+    if entry is None:
+        return {}
+    binder = getattr(entry.action, "binder", None)
+    if binder is None or not binder.accepts("request"):
+        return {}
+    return {"request": req}
+
+
 def _columnarize_cards(cards: list[dict[str, Any]]) -> dict[str, list[Any]]:
     """Convert a list of card dicts into a dict of per-field value lists.
 
@@ -247,8 +328,16 @@ def _copy_query_result(result: dict[str, Any]) -> dict[str, Any]:
     return copied
 
 
-class APIResource:
-    """Class implementing request handling for our simple API."""
+class APIResource(ScryfallCardsRoutes, ScryfallReferenceRoutes):
+    """Class implementing request handling for our simple API.
+
+    The Scryfall-compatible routes live in the base classes rather than here: they are a
+    self-contained compatibility surface with their own response objects, and `iter_marked_routes`
+    scans inherited attributes, so they register exactly like the routes defined below. They are
+    two mixins rather than one because they answer from different places — `ScryfallCardsRoutes`
+    from the corpus and the engine, `ScryfallReferenceRoutes` from the tables mirrored off
+    api.scryfall.com — and share only the response plumbing in `ScryfallResponder`.
+    """
 
     def __init__(
         self,
@@ -336,6 +425,10 @@ def _build_action_kwargs(self, req: falcon.Request, resp: falcon.Response, entry
             Keyword arguments for the action call.
         """
         params = {k: v for k, v in req.params.items() if k not in DISALLOWED_QUERY_ARGS}
+        # The request object itself, for the one handler that declares it (POST /cards/collection
+        # reads its identifiers from the body). Only where declared: a non-string keyword reaches a
+        # handler that neither declares nor absorbs it as a TypeError.
+        params.update(_request_injection(entry, req))
         if entry is None:
             # Only _raise_not_found reads this; set after the query string so a request can't
             # spoof it via ?admin_authenticated=1 on a path that doesn't resolve to anything.
@@ -344,7 +437,7 @@ def _build_action_kwargs(self, req: falcon.Request, resp: falcon.Response, entry
         params["request_host"] = req.get_header("X-Proxy-Host") or req.host
         return params
 
-    def _handle(self, req: falcon.Request, resp: falcon.Response) -> None:
+    def _handle(self, req: falcon.Request, resp: falcon.Response) -> None:  # noqa: PLR0912
         """Handle a Falcon request and set the response.
 
         Args:
@@ -368,11 +461,31 @@ def _handle(self, req: falcon.Request, resp: falcon.Response) -> None:
 
         entry, action_args = self._resolve_action(path)
         action = self._raise_not_found
-        if entry is not None:
+        if entry is None and not req.context.get("admin_authenticated", False):
+            # AN UNKNOWN PATH ANSWERS IN SCRYFALL'S SHAPE, not with the route listing.
+            #
+            # The listing is a convenience for a human poking at the origin. A client is not a human:
+            # it parses `code` and `details`, and `{"title": ..., "description": {"routes": ...}}`
+            # gives it neither -- so a client pointed at this service instead of api.scryfall.com has
+            # to special-case this origin, which is exactly what it cannot do and still be pointable
+            # back at Scryfall. Status, wording and tier are measured (404, "The requested object or
+            # REST method was not found.", `no-cache`).
+            #
+            # A human still has the listing: every route is documented, and the route table is the
+            # source both this and `build_routes_listing` read -- and a caller who has proven they
+            # hold the admin secret (#966) still gets the full listing below, exactly as upstream
+            # answers them: the Scryfall shape is for the client that cannot present one.
+            self._respond_scryfall_error(resp, code="not_found", status=404, details=_SCRYFALL_NOT_FOUND_DETAILS)
+            return
+        if entry is None:
+            # Admin-authenticated unknown path: upstream's listing, the full one.
+            pass
+        elif req.method not in entry.spec.methods:
             # A route answers only the methods it declares. Checked after the path resolves, so a
             # path that identifies nothing stays a 404 rather than reporting what it would accept.
-            if req.method not in entry.spec.methods:
-                raise falcon.HTTPMethodNotAllowed(allowed_methods=sorted(entry.spec.methods))
+            self._reject_method(resp, path=path, allowed=sorted(entry.spec.methods))
+            return
+        else:
             action = entry.action
 
         res = None
@@ -444,6 +557,59 @@ def _raise_not_found(self, *_args: object, admin_authenticated: bool = False, **
             },
         )
 
+    def _reject_method(self, resp: falcon.Response, *, path: str, allowed: list[str]) -> None:
+        """Answer a method this route does not accept.
+
+        On the Scryfall surface this is a 404 carrying the ordinary `not_found` object, with NO
+        `Allow` header -- which is what api.scryfall.com answers, measured 2026-08-16 across eight
+        requests: POST, PUT, DELETE and PATCH against `/cards/search`, `/cards/named`,
+        `/cards/collection`, `/cards/:id` and `/sets`. Not one of them carries `Allow`.
+
+        405 is the more correct HTTP answer in the abstract, and it is deliberately not used here.
+        Sending one would have meant inventing an error `code` for it, since Scryfall never emits a
+        405 and there is therefore nothing to measure -- and an error body nobody checked is the same
+        defect as a column set nobody checked. A client that branches on 404-versus-405 has to see
+        what Scryfall shows it.
+
+        This service's OWN routes keep falcon's 405 and its `Allow`: nothing there is mirroring
+        Scryfall, and 405 remains right for a route that genuinely declares its methods.
+
+        Args:
+            resp: The response to write to.
+            path: The resolved route key, which selects the answer.
+            allowed: The methods this route does accept, sorted.
+
+        Raises:
+            falcon.HTTPMethodNotAllowed: On this service's own surface, whose behaviour is unchanged.
+        """
+        if path not in SCRYFALL_SURFACE_ROUTES:
+            raise falcon.HTTPMethodNotAllowed(allowed_methods=allowed)
+        self._respond_scryfall_error(resp, code="not_found", status=404, details=_SCRYFALL_NOT_FOUND_DETAILS)
+
+    @staticmethod
+    def _respond_scryfall_error(resp: falcon.Response, *, code: str, status: int, details: str) -> None:
+        """Write a dispatch-level error in Scryfall's shape.
+
+        Written directly rather than raised: falcon's error serializer produces `{title,
+        description}` from an `HTTPError`, which is the shape this is replacing. Indented, like every
+        `object: "error"` body api.scryfall.com sends, and `no-cache`, which is the tier it sends on
+        a 404 about a PATH (a 404 about DATA, such as `/sets/zzzz`, keeps the data tier and is
+        answered by its own route rather than here).
+
+        Args:
+            resp: The response to write to.
+            code: Scryfall's error code.
+            status: The HTTP status, which the body repeats.
+            details: The human-readable sentence.
+        """
+        resp.status = falcon.util.code_to_http_status(status)
+        resp.content_type = "application/json; charset=utf-8"
+        resp.set_header("Cache-Control", "no-cache")
+        resp.text = orjson.dumps(
+            {"object": "error", "code": code, "status": status, "details": details},
+            option=orjson.OPT_INDENT_2,
+        ).decode()
+
     def _run_query(
         self,
         *,
@@ -815,6 +981,13 @@ def _search_engine(  # noqa: PLR0913
         offset: int = DEFAULT_OFFSET,
         fields: Sequence[str] | None = None,
     ) -> dict[str, Any]:
+        # AUTO is a request-level spelling neither search path knows, resolved on the way in so
+        # nothing downstream can see it. Resolved in each path rather than once in `_search`
+        # because what AUTO means depends on `orderby`: doing it here is necessarily after
+        # everything upstream that can still change `orderby` -- today nothing, once the in-query
+        # directives land their fold. Resolving before that fold would answer `order:usd` with the
+        # default ordering's direction and hand the engine the literal "auto".
+        direction = resolve_direction(direction, orderby)
         logger.info("Searching engine for %r", query)
         query_explanation = parsed_query.to_human_explanation() if query else ""
         try:
@@ -862,6 +1035,13 @@ def _search_sql(  # noqa: PLR0913
         offset: int = DEFAULT_OFFSET,
         fields: Sequence[str] | None = None,
     ) -> dict[str, Any]:
+        # AUTO is a request-level spelling neither search path knows, resolved on the way in so
+        # nothing downstream can see it. Resolved in each path rather than once in `_search`
+        # because what AUTO means depends on `orderby`: doing it here is necessarily after
+        # everything upstream that can still change `orderby` -- today nothing, once the in-query
+        # directives land their fold. Resolving before that fold would answer `order:usd` with the
+        # default ordering's direction and hand the engine the literal "auto".
+        direction = resolve_direction(direction, orderby)
         logger.info("Searching SQL for %r", query)
         resolved_fields = self._resolve_result_fields(fields)
         query_explanation = parsed_query.to_human_explanation() if query else ""
@@ -880,7 +1060,18 @@ def _search_sql(  # noqa: PLR0913
             CardOrdering.RARITY: "card_rarity_int",
             CardOrdering.TOUGHNESS: "creature_toughness",
             CardOrdering.USD: "price_usd",
+            CardOrdering.EUR: "price_eur",
+            CardOrdering.TIX: "price_tix",
             CardOrdering.CUBECOBRA: "cubecobra_score",
+            CardOrdering.RELEASED: "released_at",
+            # lower() for the same reason as name: the engine ranks the lowercased artist, and set
+            # codes are stored lowercase but nothing constrains them to be.
+            CardOrdering.ARTIST: "lower(card_artist)",
+            CardOrdering.SET: "lower(card_set_code)",
+            # Scryfall's colour order is eleven buckets, not the colour bitmask -- WUBRG, then
+            # multicolour by how many colours, then colourless, then lands. Measured 2026-08-09;
+            # mirrors color_sort_rank in card_engine/src/lib.rs, which the engine path uses.
+            CardOrdering.COLOR: _COLOR_ORDER_SQL,
         }.get(orderby, "edhrec_rank")
         sql_direction = {
             "asc": "ASC",
diff --git a/api/card_processing.py b/api/card_processing.py
index 3de650c86..ad5dc0cff 100644
--- a/api/card_processing.py
+++ b/api/card_processing.py
@@ -85,6 +85,142 @@ def extract_collector_number_int(collector_number: str | int | float | None) ->
     return None  # Field will be null by default
 
 
+# Face-merge policy for multi-face cards (#400, #873). Scryfall AND's search predicates at the
+# CARD level, each satisfiable by any face — measured against api.scryfall.com 2026-08-08:
+# `t:sorcery t:land` returns the MDFC lands (no single face is both), o: conjunctions match
+# across faces (Ral, Monsoon Mage), and `c:b` matches Westvale Abbey's back-face-only color.
+# One row per printing carrying any-face unions reproduces those semantics directly; one row
+# per face would instead break every cross-face conjunction (no face-row satisfies both terms)
+# on top of colliding on the scryfall_id primary key, which is how the back face silently won
+# until now. Front-face scalars (cmc, mana cost, illustration, image, prices) match Scryfall's
+# own top-level fields, verified on its card objects.
+_FACE_LIST_UNIONS = ("card_types", "card_subtypes")
+_FACE_FLAG_UNIONS = ("card_colors", "card_keywords", "produced_mana")
+_FACE_JOINED_TEXTS = ("oracle_text", "flavor_text", "type_line")
+# Copied per GROUP from the first face that has any of the group, so the numeric columns and
+# their _text twins always describe the same face (the schema's check constraints couple them).
+_FACE_STAT_GROUPS = (
+    ("creature_power", "creature_toughness", "creature_power_text", "creature_toughness_text"),
+    ("planeswalker_loyalty", "planeswalker_loyalty_text"),
+)
+# Joins face texts. "\n" so substring/regex matches cannot span faces in practice (`.` does not
+# cross newlines), "//" because that is the face separator Scryfall itself renders.
+_FACE_TEXT_SEPARATOR = "\n//\n"
+
+# What `card_faces` stores per face, in Scryfall's own key names and value shapes.
+#
+# The merged row above is what the query planner filters on; this is what a face IS. Keeping it
+# structurally (rather than inside raw_card_blob) is what lets the ENGINE answer face-level
+# questions: the store is the only thing an engine-path request reads, and a JSONB column is not
+# in it. It also retires the merge's one documented residual — when several faces carry a stat
+# group (Brutal Cathar's 2/2 // 3/3) the merged row keeps only the front's, while Scryfall matches
+# either; per-face power/toughness/loyalty make the back searchable again.
+#
+# `object` is the constant "card_face" and `image_uris` is a pure function of the card's id and the
+# face's position, so neither is stored; both are re-emitted on read.
+_FACE_OBJECT_FIELDS = (
+    "name",
+    "mana_cost",
+    "type_line",
+    "oracle_text",
+    "power",
+    "toughness",
+    "loyalty",
+    # Battles print their defense on the FACE (Invasion of Alara's front face is `defense: 7`) and
+    # no column holds it, so leaving it out drops the number from every battle's card object.
+    "defense",
+    "colors",
+    "color_indicator",
+    "flavor_text",
+    "artist",
+    "artist_id",
+    "illustration_id",
+)
+
+
+def _face_records(card_faces: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    """Snapshot each face's own fields, front first.
+
+    Args:
+        card_faces: The card's raw `card_faces` array, as Scryfall sent it.
+
+    Returns:
+        One dict per face, carrying only the keys the face actually has. Absent keys stay absent
+        rather than becoming null, because Scryfall omits them and a reconstructed face has to
+        agree key-for-key.
+    """
+    return [{field: face[field] for field in _FACE_OBJECT_FIELDS if field in face} for face in card_faces]
+
+
+# Keys that do NOT go in card_compat_blob, because a column already holds them or they are a pure
+# function of one. Kept subtractive, and mirrored in 2026-08-10-01-engine-card-objects.sql: the
+# residue is "whatever is left", so a Scryfall key nobody has seen yet lands in the blob by default
+# instead of being silently dropped the first time it appears.
+#
+# `prices` is deliberately absent from this set even though price_usd/eur/tix are columns --
+# usd_foil, usd_etched and eur_foil are not, and keeping the object whole costs a few bytes against
+# losing three fields.
+_COMPAT_BLOB_EXCLUDED = frozenset(
+    {
+        # stored in a column of their own
+        "id", "oracle_id", "name", "released_at", "layout", "mana_cost", "cmc", "type_line",
+        "oracle_text", "power", "toughness", "loyalty", "colors", "color_identity", "keywords",
+        "set", "set_name", "collector_number", "rarity", "flavor_text", "artist",
+        "illustration_id", "border_color", "edhrec_rank", "legalities", "produced_mana",
+        "watermark", "reserved", "game_changer", "frame",
+        # pure functions of id / set / collector_number / oracle_id, re-emitted on read
+        "object", "uri", "scryfall_uri", "image_uris", "rulings_uri", "prints_search_uri",
+        "set_uri", "set_search_uri", "scryfall_set_uri", "card_back_id", "related_uris",
+        "purchase_uris", "resource_id",
+        # its own column
+        "card_faces",
+        # added by this module before the snapshot is taken
+        "card_name", "face_name", "face_idx", "scryfall_id",
+    },
+)  # fmt: skip
+
+
+def _compat_blob(card: dict[str, Any]) -> dict[str, Any]:
+    """The Scryfall keys that no column holds and no derivation recovers.
+
+    Args:
+        card: The card object as Scryfall sent it, before this module's own keys matter.
+
+    Returns:
+        The residue, ready to store as card_compat_blob.
+    """
+    return {key: value for key, value in card.items() if key not in _COMPAT_BLOB_EXCLUDED}
+
+
+def _merge_processed_faces(faces: list[dict[str, Any]]) -> dict[str, Any]:
+    """Collapse fully-processed per-face rows into the card's single searchable row.
+
+    The first face (the front) supplies the row and with it every identity and display
+    scalar; later faces fold in per the policy tables above. Known residual, sized in
+    the tests: when several faces carry a stat group (Brutal Cathar's 2/2 // 3/3), only
+    the first face's values are searchable — Scryfall also matches the back's.
+
+    Args:
+        faces: Non-empty list of processed rows, one per surviving face, front first.
+
+    Returns:
+        The merged row (the front face's dict, mutated in place).
+    """
+    merged, *rest = faces
+    for face in rest:
+        for key in _FACE_LIST_UNIONS:
+            seen = merged[key]
+            seen.extend(value for value in face[key] if value not in seen)
+        for key in _FACE_FLAG_UNIONS:
+            merged[key].update(face[key])
+        for key in _FACE_JOINED_TEXTS:
+            parts = [part for part in (merged.get(key), face.get(key)) if part]
+            merged[key] = (" // " if key == "type_line" else _FACE_TEXT_SEPARATOR).join(parts)
+        for group in _FACE_STAT_GROUPS:
+            if all(merged.get(field) is None for field in group) and any(face.get(field) is not None for field in group):
+                for field in group:
+                    merged[field] = face.get(field)
+    return merged
 def extract_frame_data_from_raw_card(raw_card: dict) -> dict[str, bool]:
     """Extract frame data from a raw card dictionary.
 
@@ -115,8 +251,9 @@ def extract_frame_data_from_raw_card(raw_card: dict) -> dict[str, bool]:
 def preprocess_card(card: dict[str, Any]) -> list[dict[str, Any]]:  # noqa: PLR0915,C901,PLR0912
     """Preprocess a card to remove invalid cards and add necessary fields.
 
-    For Double-Faced Cards (DFCs), returns multiple dictionaries (one per face).
-    For single-faced cards, returns a list with one dictionary.
+    A multi-face card (transform, MDFC, split, adventure, flip) is merged into ONE row
+    carrying the front face's identity and every face's searchable data — see
+    `_merge_processed_faces`. Single-faced cards return a list with one dictionary.
     Returns an empty list for invalid/filtered cards.
     """
     if not set(card["legalities"].values()) & {"legal", "restricted"}:
@@ -154,21 +291,41 @@ def preprocess_card(card: dict[str, Any]) -> list[dict[str, Any]]:  # noqa: PLR0
         # Recursive case: processing a face
         card["face_name"] = card.get("name")
 
-    # Handle cards with card_faces (DFCs)
+    # Handle cards with card_faces (DFCs): process each face through the full pipeline below,
+    # then collapse the per-face rows into the card's one searchable row.
     card_faces = card.get("card_faces")
     if card_faces:
         for creature_attribute in ["creature_power", "creature_toughness"]:
             card.pop(creature_attribute, None)
             card.pop(f"{creature_attribute}_text", None)
-        processed_faces = []
-        for face_idx, face_data in enumerate(card_faces, start=1):
+        face_rows = []
+        for face_data in card_faces:
             # Merge card-level data with face-specific data
-            # Precedence: face_idx override > face_data (name, type_line, etc.) > card (legalities, games, etc.)
-            merged = copy.deepcopy(card) | face_data | {"face_idx": face_idx}
+            # Precedence: face_data (name, type_line, etc.) > card (legalities, games, etc.)
+            merged = copy.deepcopy(card) | face_data
             merged.pop("card_faces", None)  # Don't keep recursing
-            processed_faces_for_face = preprocess_card(merged)
-            processed_faces.extend(processed_faces_for_face)
-        return processed_faces
+            face_rows.extend(preprocess_card(merged))
+        if not face_rows:
+            return []
+        merged_row = _merge_processed_faces(face_rows)
+        # The blob is the card-level object with its faces re-attached — what Scryfall sent, not a
+        # face promoted to look like a card. Every searchable field is already merged onto the row
+        # above, so the blob has no derivation left to do, and keeping it verbatim is what makes it
+        # answerable: a card object cannot be rebuilt from a face (`card_faces` is gone, `name` and
+        # `type_line` are the front's, and which fields a real card carries at top level varies by
+        # layout — a split card has `mana_cost` and `image_uris` there, a transform card does not).
+        #
+        # The one consumer that read a *face* field off the blob is `image_uris`, which for a
+        # transform card now lives only under `card_faces`; every reader coalesces to
+        # `card_faces->0` (scripts/copy_images_to_s3.py, scripts/prefer_weights.py). Everything else
+        # read from the blob — lang, set_type, games, finishes, frame_effects, image_status,
+        # reserved, game_changer — is card-level and identical either way.
+        merged_row["raw_card_blob"] = copy.deepcopy(card) | {"card_faces": card_faces}
+        # The engine's copy of the same thing. raw_card_blob is a Postgres column and the SQL path
+        # is a fallback, so anything only the blob carries is unanswerable on the engine path.
+        merged_row["card_faces"] = _face_records(card_faces)
+        merged_row["card_compat_blob"] = _compat_blob(card)
+        return [merged_row]
 
     # Single face case - set defaults
     card.setdefault("face_name", card.get("name"))
@@ -184,6 +341,7 @@ def preprocess_card(card: dict[str, Any]) -> list[dict[str, Any]]:  # noqa: PLR0
     # Store the original card data before modifications for raw_card_blob
     raw_card_data = copy.deepcopy(card)
     card["raw_card_blob"] = raw_card_data
+    card["card_compat_blob"] = _compat_blob(raw_card_data)
     card["scryfall_id"] = card["id"]
 
     card_types, card_subtypes = parse_type_line(card["type_line"])
diff --git a/api/db/2026-08-09-01-scryfall-cards-api.sql b/api/db/2026-08-09-01-scryfall-cards-api.sql
new file mode 100644
index 000000000..d247f88e7
--- /dev/null
+++ b/api/db/2026-08-09-01-scryfall-cards-api.sql
@@ -0,0 +1,84 @@
+-- Backing store for the Scryfall-compatible /cards/* API (api/scryfall_compat/).
+--
+-- Two parts, neither of which any existing route reads:
+--
+--   1. Lookup indexes for the identifiers Scryfall routes by that live inside raw_card_blob rather
+--      than in a column of their own. Each partial index predicates on the *same* expression the
+--      lookup compares, so the planner can prove the query implies the predicate.
+--
+--   2. magic.rulings, backing /cards/:id/rulings and its four sibling routes.
+--
+-- No column holds the card object the API serves: raw_card_blob is already what Scryfall sent, so
+-- api/scryfall_compat/objects.py recovers the card from it by stripping the three keys the importer
+-- adds. That is true of a multi-face printing only as of the merged-row work; see the deployment
+-- note in docs/issues/local-scryfall-cards-api.md.
+
+
+-- /cards/:code/:number and /cards/:code/:number/:lang. On lower(card_set_code) rather than the
+-- column, because Scryfall's set codes are case-insensitive and the lookup folds the segment; the
+-- corpus happens to store them lowercase already, but nothing constrains it to.
+CREATE INDEX IF NOT EXISTS idx_cards_set_collector_lang
+    ON magic.cards USING btree (lower(card_set_code), collector_number, (raw_card_blob ->> 'lang'));
+
+-- GET /cards/named?exact=. card_name_folded is already lowercase (fold_accents() lowercases before
+-- folding), so lower() here is a no-op on the value and only exists so the indexed expression is
+-- the one the lookup writes. The two split_part indexes cover the face names of a "Front // Back"
+-- card, which Scryfall's exact match accepts alongside the combined name: with all three indexed,
+-- the lookup's OR is a BitmapOr rather than a sequential scan.
+CREATE INDEX IF NOT EXISTS idx_cards_name_folded_exact
+    ON magic.cards USING btree (lower(card_name_folded));
+CREATE INDEX IF NOT EXISTS idx_cards_name_folded_front_face
+    ON magic.cards USING btree (lower(split_part(card_name_folded, ' // ', 1)));
+CREATE INDEX IF NOT EXISTS idx_cards_name_folded_back_face
+    ON magic.cards USING btree (lower(split_part(card_name_folded, ' // ', 2)));
+
+-- /cards/multiverse/:id -- multiverse_ids is an array, so containment rather than equality.
+CREATE INDEX IF NOT EXISTS idx_cards_multiverse_ids
+    ON magic.cards USING gin ((raw_card_blob -> 'multiverse_ids') jsonb_path_ops);
+
+-- /cards/mtgo/:id matches either the regular or the foil MTGO id, so both are indexed.
+CREATE INDEX IF NOT EXISTS idx_cards_mtgo_id
+    ON magic.cards USING btree (((raw_card_blob ->> 'mtgo_id')::bigint))
+    WHERE ((raw_card_blob ->> 'mtgo_id')::bigint) IS NOT NULL;
+
+CREATE INDEX IF NOT EXISTS idx_cards_mtgo_foil_id
+    ON magic.cards USING btree (((raw_card_blob ->> 'mtgo_foil_id')::bigint))
+    WHERE ((raw_card_blob ->> 'mtgo_foil_id')::bigint) IS NOT NULL;
+
+-- /cards/arena/:id
+CREATE INDEX IF NOT EXISTS idx_cards_arena_id
+    ON magic.cards USING btree (((raw_card_blob ->> 'arena_id')::bigint))
+    WHERE ((raw_card_blob ->> 'arena_id')::bigint) IS NOT NULL;
+
+-- /cards/tcgplayer/:id matches either the regular or the etched TCGplayer id.
+CREATE INDEX IF NOT EXISTS idx_cards_tcgplayer_id
+    ON magic.cards USING btree (((raw_card_blob ->> 'tcgplayer_id')::bigint))
+    WHERE ((raw_card_blob ->> 'tcgplayer_id')::bigint) IS NOT NULL;
+
+CREATE INDEX IF NOT EXISTS idx_cards_tcgplayer_etched_id
+    ON magic.cards USING btree (((raw_card_blob ->> 'tcgplayer_etched_id')::bigint))
+    WHERE ((raw_card_blob ->> 'tcgplayer_etched_id')::bigint) IS NOT NULL;
+
+-- /cards/cardmarket/:id
+CREATE INDEX IF NOT EXISTS idx_cards_cardmarket_id
+    ON magic.cards USING btree (((raw_card_blob ->> 'cardmarket_id')::bigint))
+    WHERE ((raw_card_blob ->> 'cardmarket_id')::bigint) IS NOT NULL;
+
+-- The oracle_id and illustration_id identifiers POST /cards/collection accepts, and the oracle_id
+-- the rulings hang off, are already served by idx_cards_oracle_id and idx_cards_illustration_id
+-- from 2026-06-21-01-bulk-tag-import.sql.
+
+CREATE TABLE IF NOT EXISTS magic.rulings (
+    oracle_id uuid NOT NULL,
+    source text NOT NULL,
+    published_at date NOT NULL,
+    comment text NOT NULL
+);
+
+COMMENT ON TABLE magic.rulings IS
+    'Scryfall rulings bulk data, keyed by oracle_id. One row per ruling; a card has zero or more.';
+
+-- The bulk file carries no ruling id, so identity is the tuple itself. md5() rather than the raw
+-- comment because a btree entry is capped at ~2700 bytes and rulings run longer than that.
+CREATE UNIQUE INDEX IF NOT EXISTS idx_rulings_identity
+    ON magic.rulings USING btree (oracle_id, source, published_at, md5(comment));
diff --git a/api/db/2026-08-10-01-engine-card-objects.sql b/api/db/2026-08-10-01-engine-card-objects.sql
new file mode 100644
index 000000000..eba384ee7
--- /dev/null
+++ b/api/db/2026-08-10-01-engine-card-objects.sql
@@ -0,0 +1,64 @@
+-- The engine serves searches; Postgres is the fallback for when the engine errors. Anything only
+-- raw_card_blob carries is therefore unanswerable on the primary path -- a jsonb column is not in
+-- the store, and the store is all an engine request reads. That is why /cards/* was SQL-only.
+--
+-- Two columns fix it, both shaped like the jsonb grab-bags this table already has (card_frame_data,
+-- card_is_tags, card_legalities):
+--
+--   card_compat_blob -- every Scryfall key that is neither stored in a column of its own nor a pure
+--                       function of one. Measured on a real card: 680 bytes against raw_card_blob's
+--                       5,881, because the blob is overwhelmingly redundant with columns we already
+--                       have plus URLs derivable from the card's id.
+--   card_faces       -- each face's own fields, so a face is a thing the engine can read rather
+--                       than something recoverable only by re-parsing a blob.
+--
+-- Both backfill from raw_card_blob, so this deploys without a reimport (same reasoning as
+-- 2026-08-06-01-lowercase-keywords.sql: the bulk import would rewrite these anyway, but the
+-- query-side change should not wait for a window where /cards/* returns nothing).
+ALTER TABLE magic.cards ADD COLUMN IF NOT EXISTS card_compat_blob jsonb;
+ALTER TABLE magic.cards ADD COLUMN IF NOT EXISTS card_faces jsonb;
+
+-- Subtractive rather than enumerated: the residue is defined as "what is left once everything we
+-- store or can derive is removed", so a Scryfall key we have never seen lands here by default
+-- instead of being silently dropped. Keys removed below are, in order: stored in their own column;
+-- derivable from id/set/collector_number/oracle_id; the faces, which get their own column; and the
+-- keys preprocess_card adds to the object before it is snapshotted.
+--
+-- `prices` is deliberately NOT removed even though price_usd/eur/tix are stored: usd_foil,
+-- usd_etched and eur_foil are not, and keeping the object whole costs a few bytes against losing
+-- three fields.
+UPDATE magic.cards
+SET card_compat_blob = raw_card_blob - ARRAY[
+        'id', 'oracle_id', 'name', 'released_at', 'layout', 'mana_cost', 'cmc', 'type_line',
+        'oracle_text', 'power', 'toughness', 'loyalty', 'colors', 'color_identity', 'keywords',
+        'set', 'set_name', 'collector_number', 'rarity', 'flavor_text', 'artist',
+        'illustration_id', 'border_color', 'edhrec_rank', 'legalities', 'produced_mana',
+        'watermark', 'reserved', 'game_changer', 'frame',
+        'object', 'uri', 'scryfall_uri', 'image_uris', 'rulings_uri', 'prints_search_uri',
+        'set_uri', 'set_search_uri', 'scryfall_set_uri', 'card_back_id', 'related_uris',
+        'purchase_uris', 'resource_id',
+        'card_faces',
+        'card_name', 'face_name', 'face_idx', 'scryfall_id'
+    ],
+    card_faces = CASE
+        WHEN raw_card_blob ? 'card_faces' THEN (
+            SELECT jsonb_agg(
+                face - ARRAY['object', 'image_uris']
+                ORDER BY ordinality
+            )
+            FROM jsonb_array_elements(raw_card_blob -> 'card_faces') WITH ORDINALITY AS t(face, ordinality)
+        )
+        ELSE NULL
+    END
+WHERE card_compat_blob IS NULL;
+
+-- The engine reload reads every ENGINE_COLUMNS value for every row, so a NULL here would mean a
+-- per-row branch in the hot path for a case that cannot legitimately occur.
+ALTER TABLE magic.cards ALTER COLUMN card_compat_blob SET DEFAULT '{}'::jsonb;
+UPDATE magic.cards SET card_compat_blob = '{}'::jsonb WHERE card_compat_blob IS NULL;
+ALTER TABLE magic.cards ALTER COLUMN card_compat_blob SET NOT NULL;
+
+ALTER TABLE magic.cards ADD CONSTRAINT card_compat_blob_must_be_object
+    CHECK ((jsonb_typeof(card_compat_blob) = 'object'::text));
+ALTER TABLE magic.cards ADD CONSTRAINT card_faces_must_be_array
+    CHECK (((card_faces IS NULL) OR (jsonb_typeof(card_faces) = 'array'::text)));
diff --git a/api/db/2026-08-11-02-scryfall-sets-catalogs-symbology.sql b/api/db/2026-08-11-02-scryfall-sets-catalogs-symbology.sql
new file mode 100644
index 000000000..b281659c4
--- /dev/null
+++ b/api/db/2026-08-11-02-scryfall-sets-catalogs-symbology.sql
@@ -0,0 +1,82 @@
+-- Backing store for the reference half of the Scryfall API: /sets, /catalog/* and /symbology.
+--
+-- All three are mirrored from api.scryfall.com rather than derived from magic.cards, and the reason
+-- is the same in each case: what the corpus can prove is a strict subset of what these endpoints
+-- have to say.
+--
+--   * A Set object carries eight fields no card carries -- tcgplayer_id, mtgo_code, arena_code,
+--     icon_svg_uri, block, block_code, parent_set_code, printed_size. /sets/tcgplayer/:id cannot be
+--     answered at all without the first of them.
+--   * card_count is Scryfall's count for the whole set, not the count this instance imported. The
+--     corpus is a filtered subset (no tokens, funny sets or digital-only printings), so deriving it
+--     would report a number no other Scryfall client agrees with.
+--   * A card symbol's svg_uri and gatherer_alternates exist nowhere in the card data.
+--
+-- Each table therefore stores the upstream object whole, in jsonb, and lifts out only what a lookup
+-- keys on. That keeps the served bytes identical to Scryfall's without a column-by-column mapping
+-- that would silently drop a field Scryfall adds later.
+
+
+-- One row per set, the object exactly as Scryfall sent it.
+--
+-- `position` preserves the order /sets returns rather than recomputing one. The list is sorted by
+-- released_at descending, but sets sharing a release date come back in an order that is neither
+-- alphabetical by code nor by name (2026-11-13 yields trk, trc, ttrk, sds), and nothing in the
+-- object reproduces it. Storing the index is exact and costs four bytes.
+CREATE TABLE IF NOT EXISTS magic.sets (
+    id uuid PRIMARY KEY,
+    code text NOT NULL,
+    tcgplayer_id bigint,
+    position integer NOT NULL,
+    set_object jsonb NOT NULL
+);
+
+COMMENT ON TABLE magic.sets IS
+    'Scryfall Set objects, mirrored from api.scryfall.com/sets. One row per set; set_object is the upstream object verbatim.';
+COMMENT ON COLUMN magic.sets.position IS
+    'Index in Scryfall''s own /sets ordering, which is not reproducible from the object.';
+
+-- /sets/:code. Scryfall matches a set code case-insensitively, so the index is on the folded value
+-- and the lookup folds its segment to match. Unique because a code identifies one set.
+CREATE UNIQUE INDEX IF NOT EXISTS idx_sets_code ON magic.sets USING btree (lower(code));
+
+-- /sets/tcgplayer/:id. Partial because most sets have no TCGplayer id, and a null there is not an
+-- identifier anyone can look up.
+CREATE INDEX IF NOT EXISTS idx_sets_tcgplayer_id
+    ON magic.sets USING btree (tcgplayer_id)
+    WHERE tcgplayer_id IS NOT NULL;
+
+-- GET /sets returns every row in one List object, so the listing is an index-only ordering scan.
+CREATE INDEX IF NOT EXISTS idx_sets_position ON magic.sets USING btree (position);
+
+
+-- The twenty /catalog/* endpoints, one row each.
+--
+-- A table of (name, entries) rather than twenty tables or twenty columns: the endpoints differ only
+-- in which list of strings they return, the set of them is fixed by Scryfall rather than by this
+-- schema, and a catalog is only ever read or replaced whole. `entries` is a jsonb array of strings,
+-- which is what the Catalog object's `data` is -- named `entries` rather than the obvious `values`
+-- because VALUES is a reserved word and the column would need quoting at every use site.
+CREATE TABLE IF NOT EXISTS magic.catalogs (
+    name text PRIMARY KEY,
+    entries jsonb NOT NULL
+);
+
+COMMENT ON TABLE magic.catalogs IS
+    'Scryfall Catalog payloads, one row per /catalog/:name endpoint, entries being the data array verbatim.';
+
+
+-- /symbology. Eighty-odd rows, each the upstream card_symbol object.
+--
+-- `position` for the same reason magic.sets has one: Scryfall returns the symbols in a fixed order
+-- that no field on the object reproduces, and /symbology is served as that list.
+CREATE TABLE IF NOT EXISTS magic.card_symbols (
+    symbol text PRIMARY KEY,
+    position integer NOT NULL,
+    symbol_object jsonb NOT NULL
+);
+
+COMMENT ON TABLE magic.card_symbols IS
+    'Scryfall CardSymbol objects, mirrored from api.scryfall.com/symbology, in the order that endpoint returns them.';
+
+CREATE INDEX IF NOT EXISTS idx_card_symbols_position ON magic.card_symbols USING btree (position);
diff --git a/api/enums.py b/api/enums.py
index f970591e8..4f64cc7c7 100644
--- a/api/enums.py
+++ b/api/enums.py
@@ -23,14 +23,28 @@ class PreferOrder(enum.StrEnum):
 
 
 class CardOrdering(enum.StrEnum):
-    """Enum for the ordering of the cards."""
+    """Enum for the ordering of the cards.
 
+    Every member must have a `SortCol` arm in card_engine/src/lib.rs and a `sql_orderby` entry in
+    api_resource.py. `orderby_to_col` falls through to edhrec on an unknown name, so a member added
+    here and nowhere else makes the engine and SQL paths sort the same query differently.
+
+    `cubecobra` is this project's own; the rest are Scryfall's `order=` vocabulary. Scryfall's
+    `penny` and `review` are deliberately absent -- see docs/issues/local-engine-order-vocabulary.md.
+    """
+
+    ARTIST = enum.auto()
     CMC = enum.auto()
+    COLOR = enum.auto()
     CUBECOBRA = enum.auto()
     EDHREC = enum.auto()
+    EUR = enum.auto()
     NAME = enum.auto()
     POWER = enum.auto()
     RARITY = enum.auto()
+    RELEASED = enum.auto()
+    SET = enum.auto()
+    TIX = enum.auto()
     TOUGHNESS = enum.auto()
     USD = enum.auto()
 
@@ -43,7 +57,43 @@ class ResponseShape(enum.StrEnum):
 
 
 class SortDirection(enum.StrEnum):
-    """Enum for the direction of the sort."""
+    """Enum for the direction of the sort.
+
+    AUTO is resolved to ASC or DESC per ordering before any search path sees it (see
+    AUTO_DIRECTIONS and `resolve_direction`), so neither the engine nor the SQL builder ever
+    receives it.
+    """
 
     ASC = enum.auto()
     DESC = enum.auto()
+    AUTO = enum.auto()
+
+
+# What `dir=auto` means for each ordering, measured against api.scryfall.com on 2026-08-09 by
+# comparing the `auto` page against the `asc` and `desc` pages of the same query. Only these five
+# invert; every other ordering, edhrec included, resolves ascending -- for edhrec that is the
+# direction putting rank 1 first, so "most popular first" and "ascending rank" are the same thing.
+AUTO_DESCENDING_ORDERINGS: frozenset[CardOrdering] = frozenset(
+    {
+        CardOrdering.RELEASED,
+        CardOrdering.RARITY,
+        CardOrdering.USD,
+        CardOrdering.TIX,
+        CardOrdering.EUR,
+    },
+)
+
+
+def resolve_direction(direction: SortDirection, orderby: CardOrdering) -> SortDirection:
+    """Resolve AUTO against an ordering, leaving an explicit direction alone.
+
+    Args:
+        direction: The requested direction, possibly AUTO.
+        orderby: The ordering AUTO is being resolved against.
+
+    Returns:
+        ASC or DESC, never AUTO.
+    """
+    if direction is not SortDirection.AUTO:
+        return direction
+    return SortDirection.DESC if orderby in AUTO_DESCENDING_ORDERINGS else SortDirection.ASC
diff --git a/api/parsing/db_info.py b/api/parsing/db_info.py
index 7f86df7d4..7131d7892 100644
--- a/api/parsing/db_info.py
+++ b/api/parsing/db_info.py
@@ -320,6 +320,7 @@ def __repr__(self: FieldInfo) -> str:
 
 CARD_TYPES = {
     "Artifact",
+    "Battle",  # reaches the corpus once faces merge (#400): every battle is a transform front
     "Conspiracy",
     "Creature",
     "Enchantment",
diff --git a/api/parsing/tests/test_pyparsing_parser.py b/api/parsing/tests/test_pyparsing_parser.py
index 6e2ab99aa..b82319327 100644
--- a/api/parsing/tests/test_pyparsing_parser.py
+++ b/api/parsing/tests/test_pyparsing_parser.py
@@ -1258,3 +1258,24 @@ def test_hyphenated_words_edge_cases_fail(invalid_query: str) -> None:
     """
     with pytest.raises(ValueError, match="Failed to parse query"):
         hand_parser.parse_str_to_query(invalid_query)
+
+
+class TestBattleTypeRouting:
+    """`t:battle` routes to card_types, matching every other card type.
+
+    Battle was absent from CARD_TYPES, so it fell through to the subtype arm on both the
+    SQL and engine paths — invisible while the corpus stored every battle as its back face
+    (#400), a guaranteed zero-match once the face merge put Battle into card_types.
+    """
+
+    def test_battle_routes_like_a_card_type(self) -> None:
+        """t:battle generates card_types SQL binding ['Battle'], as t:creature does for its type."""
+        sql, params = parsing.generate_sql_query(parsing.parse_scryfall_query("t:battle"))
+        assert "card_types" in sql
+        assert "card_subtypes" not in sql
+        assert ["Battle"] in params.values()
+
+    def test_siege_still_routes_as_a_subtype(self) -> None:
+        """t:siege stays on the subtype arm; only the card type moved."""
+        siege_sql = str(parsing.generate_sql_query(parsing.parse_scryfall_query("t:siege")))
+        assert "card_subtypes" in siege_sql
diff --git a/api/rulings_import.py b/api/rulings_import.py
new file mode 100644
index 000000000..050129d2f
--- /dev/null
+++ b/api/rulings_import.py
@@ -0,0 +1,103 @@
+"""Import Scryfall rulings bulk data into `magic.rulings`.
+
+Rulings back `/cards/:id/rulings` and its four sibling routes. They hang off `oracle_id`, not off a
+printing, so the table is independent of `magic.cards` and is loaded the same way the tag
+collections are: streamed from the cached bulk file and written in batches.
+
+The load is a whole-table replace inside one transaction, rather than an upsert. The bulk file
+carries no ruling id — a row's identity is the tuple itself — and rulings are occasionally
+retracted, so "insert what is there" would accumulate rows that Scryfall has withdrawn. A replace
+also cannot get the pruning wrong when one card's rulings straddle a batch boundary, which is the
+failure an incremental prune invites. `DELETE` rather than `TRUNCATE` so readers keep seeing the
+previous contents through MVCC instead of blocking on an ACCESS EXCLUSIVE lock for the load.
+"""
+
+from __future__ import annotations
+
+import itertools
+import logging
+import time
+from typing import TYPE_CHECKING, Any
+
+from psycopg.types.json import Jsonb
+
+from api.scryfall_bulk_data_fetcher import BulkDataKey
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Iterator
+
+    import psycopg_pool
+
+    from api.scryfall_bulk_data_fetcher import ScryfallBulkDataFetcher
+
+logger = logging.getLogger(__name__)
+
+# Rows per INSERT. The whole batch travels as one jsonb bind parameter, so this sets the statement's
+# server-side peak; the rulings file is two orders of magnitude smaller than the cards file, so it
+# can sit well above the card upsert's page size and still be a fraction of its parameter size.
+_BATCH_SIZE = 5_000
+
+_INSERT_SQL = """
+INSERT INTO magic.rulings (oracle_id, source, published_at, comment)
+SELECT
+    (entry ->> 'oracle_id')::uuid,
+    entry ->> 'source',
+    (entry ->> 'published_at')::date,
+    entry ->> 'comment'
+FROM jsonb_array_elements(%(rows)s) AS entry
+ON CONFLICT DO NOTHING
+"""
+
+_REQUIRED_FIELDS = ("oracle_id", "source", "published_at", "comment")
+
+# Scryfall publishes `published_at` as a bare date; slicing rather than parsing keeps a future
+# timestamp form from failing the ::date cast.
+_DATE_LENGTH = 10
+
+
+def _valid_rulings(rulings: Iterable[dict[str, Any]]) -> Iterator[dict[str, Any]]:
+    """Yield the entries that carry every column the table requires.
+
+    Args:
+        rulings: Raw entries from the bulk file.
+
+    Yields:
+        One normalized row per usable entry.
+    """
+    for ruling in rulings:
+        if all(ruling.get(field) for field in _REQUIRED_FIELDS):
+            yield {
+                "oracle_id": ruling["oracle_id"],
+                "source": ruling["source"],
+                "published_at": str(ruling["published_at"])[:_DATE_LENGTH],
+                "comment": ruling["comment"],
+            }
+
+
+def import_rulings(conn_pool: psycopg_pool.ConnectionPool, fetcher: ScryfallBulkDataFetcher) -> int:
+    """Replace `magic.rulings` with the current rulings bulk file.
+
+    Args:
+        conn_pool: Pool to run the load through.
+        fetcher: Bulk data fetcher, which caches the download between runs.
+
+    Returns:
+        The number of rulings loaded.
+    """
+    before = time.monotonic()
+    loaded = 0
+    with conn_pool.connection() as conn:
+        # One transaction: the DELETE is only visible to other sessions once the reload commits,
+        # so no request can observe an empty rulings table.
+        with conn.cursor() as cursor:
+            cursor.execute("DELETE FROM magic.rulings")
+            for batch in itertools.batched(_valid_rulings(fetcher.stream_data_for_key(BulkDataKey.RULINGS)), _BATCH_SIZE):
+                cursor.execute(_INSERT_SQL, {"rows": Jsonb(list(batch))})
+                # rowcount, not len(batch): the file repeats a tuple often enough to matter -- 37 of
+                # 77,998 entries on 2026-08-11 -- and ON CONFLICT DO NOTHING drops those. Counting
+                # what was sent would report a row total the table does not hold.
+                loaded += cursor.rowcount
+        conn.commit()
+
+    logger.info("Imported %d rulings in %.2f seconds", loaded, time.monotonic() - before)
+    return loaded
diff --git a/api/scryfall_bulk_data_fetcher.py b/api/scryfall_bulk_data_fetcher.py
index c12d0c44c..da35d75bc 100644
--- a/api/scryfall_bulk_data_fetcher.py
+++ b/api/scryfall_bulk_data_fetcher.py
@@ -157,6 +157,27 @@ def _get(self, url: str, *, timeout: int, **kwargs: object) -> requests.Response
         response.raise_for_status()
         return response
 
+    def fetch_api_json(self, path: str, *, timeout: int = 30) -> dict:
+        """GET one Scryfall API endpoint and decode it.
+
+        The reference data — sets, catalogs, symbology — is published as ordinary API responses
+        rather than as bulk dumps, and is small enough to fetch whole. It goes through this session
+        so it inherits the same retry policy and error logging the dumps get, rather than opening a
+        second HTTP client with its own behaviour.
+
+        Args:
+            path: Path below the API root, with no leading slash (e.g. "catalog/creature-types").
+            timeout: Per-attempt request timeout in seconds.
+
+        Returns:
+            The decoded response body.
+
+        Raises:
+            requests.HTTPError: If the final response after retries is not 2xx.
+            requests.RequestException: If the request fails at the transport level.
+        """
+        return self._get(f"https://api.scryfall.com/{path}", timeout=timeout).json()
+
     @cachebox_cached(cache=TTLCache(maxsize=2, global_ttl=5 * MINUTE))
     def list_bulk_data(self) -> dict[BulkDataKey, dict]:
         """Fetch bulk data from Scryfall, ignoring bulk data types we don't recognize."""
diff --git a/api/scryfall_compat/__init__.py b/api/scryfall_compat/__init__.py
new file mode 100644
index 000000000..162935cf7
--- /dev/null
+++ b/api/scryfall_compat/__init__.py
@@ -0,0 +1,12 @@
+"""Scryfall-compatible `/cards/*` API.
+
+The routes in `routes.py` answer the same paths as api.scryfall.com with the same parameters and
+the same response objects, so a client can be pointed at this host by swapping its base URL.
+`objects.py` holds the payload construction — card reconstruction, List/Catalog/error envelopes,
+and the `format=text` rendering — with no knowledge of Falcon or of the database.
+"""
+
+from api.scryfall_compat.reference_routes import ScryfallReferenceRoutes
+from api.scryfall_compat.routes import ScryfallCardsRoutes
+
+__all__ = ["ScryfallCardsRoutes", "ScryfallReferenceRoutes"]
diff --git a/api/scryfall_compat/fixtures/card_object_parity.json b/api/scryfall_compat/fixtures/card_object_parity.json
new file mode 100644
index 000000000..570a73e5b
--- /dev/null
+++ b/api/scryfall_compat/fixtures/card_object_parity.json
@@ -0,0 +1,1175 @@
+{
+  "_comment": [
+    "CROSS-LANGUAGE PARITY FIXTURE for the Scryfall card object.",
+    "",
+    "The same card JSON is built twice: card_engine/src/card_object.rs serves the engine path and",
+    "api/scryfall_compat/objects.py serves the SQL path. Both answer /cards/*, so a difference",
+    "between them is a difference a client can see, and nothing else compares them.",
+    "",
+    "Each case is an engine row plus the object BOTH implementations produce from it, built with",
+    "base_url 'https://api.example/v1'. card_object.rs asserts it in Rust and",
+    "test_scryfall_compat_objects.py asserts it in Python, so either one drifting turns its own",
+    "CI job red.",
+    "",
+    "Values and key PRESENCE are what this pins; key ORDER is not (both sides are compared as",
+    "parsed objects). Scryfall's key order is pinned separately by the position assertions in",
+    "card_object.rs, which is the only place the wire order is observable.",
+    "",
+    "To add a case: add the row, run both suites, and paste the object they agree on. If they do",
+    "not agree, that is the bug this file exists to find."
+  ],
+  "base_url": "https://api.example/v1",
+  "cases": [
+    {
+      "case": "a plain single-faced card",
+      "row": {
+        "scryfall_id": "01000000-0000-0000-0000-000000000001",
+        "oracle_id": "11111111-2222-3333-4444-555555555555",
+        "name": "Lightning Bolt",
+        "mana_cost": "{R}",
+        "cmc": 1,
+        "type_line": "Instant",
+        "oracle_text": "Lightning Bolt deals 3 damage to any target.",
+        "colors": [
+          "R"
+        ],
+        "color_identity": [
+          "R"
+        ],
+        "set_code": "lea",
+        "set_name": "Limited Edition Alpha",
+        "collector_number": "161",
+        "rarity": "common",
+        "lang": "en",
+        "layout": "normal",
+        "artist": "Christopher Rush",
+        "released_at": "1993-08-05",
+        "multiverse_ids": [
+          209
+        ],
+        "games": [
+          "paper"
+        ],
+        "tcgplayer_id": 1234
+      },
+      "expected": {
+        "artist": "Christopher Rush",
+        "booster": false,
+        "border_color": null,
+        "card_back_id": "0aeebaf5-8c7d-4636-9e82-8c27447861f7",
+        "cmc": 1.0,
+        "collector_number": "161",
+        "color_identity": [
+          "R"
+        ],
+        "colors": [
+          "R"
+        ],
+        "digital": false,
+        "finishes": [],
+        "full_art": false,
+        "games": [
+          "paper"
+        ],
+        "highres_image": false,
+        "id": "01000000-0000-0000-0000-000000000001",
+        "illustration_id": null,
+        "image_status": null,
+        "image_uris": {
+          "art": "https://cards.scryfall.io/art/front/0/1/01000000-0000-0000-0000-000000000001.webp",
+          "art_crop": "https://cards.scryfall.io/art_crop/front/0/1/01000000-0000-0000-0000-000000000001.jpg",
+          "border_crop": "https://cards.scryfall.io/border_crop/front/0/1/01000000-0000-0000-0000-000000000001.jpg",
+          "crop": "https://cards.scryfall.io/crop/front/0/1/01000000-0000-0000-0000-000000000001.webp",
+          "display": "https://cards.scryfall.io/display/front/0/1/01000000-0000-0000-0000-000000000001.webp",
+          "grid": "https://cards.scryfall.io/grid/front/0/1/01000000-0000-0000-0000-000000000001.webp",
+          "large": "https://cards.scryfall.io/large/front/0/1/01000000-0000-0000-0000-000000000001.jpg",
+          "normal": "https://cards.scryfall.io/normal/front/0/1/01000000-0000-0000-0000-000000000001.jpg",
+          "png": "https://cards.scryfall.io/png/front/0/1/01000000-0000-0000-0000-000000000001.png",
+          "small": "https://cards.scryfall.io/small/front/0/1/01000000-0000-0000-0000-000000000001.jpg",
+          "thumb": "https://cards.scryfall.io/thumb/front/0/1/01000000-0000-0000-0000-000000000001.webp"
+        },
+        "keywords": [],
+        "lang": "en",
+        "layout": "normal",
+        "mana_cost": "{R}",
+        "multiverse_ids": [
+          209
+        ],
+        "name": "Lightning Bolt",
+        "object": "card",
+        "oracle_id": "11111111-2222-3333-4444-555555555555",
+        "oracle_text": "Lightning Bolt deals 3 damage to any target.",
+        "oversized": false,
+        "prices": {
+          "eur": null,
+          "eur_foil": null,
+          "tix": null,
+          "usd": null,
+          "usd_etched": null,
+          "usd_foil": null
+        },
+        "prints_search_uri": "https://api.example/v1/cards/search?order=released&q=oracleid%3A11111111-2222-3333-4444-555555555555&unique=prints",
+        "promo": false,
+        "purchase_uris": {
+          "cardhoarder": "https://www.cardhoarder.com/cards?data%5Bsearch%5D=Lightning+Bolt",
+          "cardmarket": "https://www.cardmarket.com/en/Magic/Products/Search?searchString=Lightning+Bolt",
+          "tcgplayer": "https://www.tcgplayer.com/product/1234?page=1"
+        },
+        "rarity": "common",
+        "related_uris": {
+          "edhrec": "https://edhrec.com/route/?cc=Lightning+Bolt",
+          "gatherer": "https://gatherer.wizards.com/Pages/Card/Details.aspx?multiverseid=209&printed=false",
+          "tcgplayer_infinite_articles": "https://www.tcgplayer.com/search/articles?productLineName=magic&q=Lightning+Bolt",
+          "tcgplayer_infinite_decks": "https://www.tcgplayer.com/search/decks?productLineName=magic&q=Lightning+Bolt"
+        },
+        "released_at": "1993-08-05",
+        "reprint": false,
+        "reserved": false,
+        "rulings_uri": "https://api.example/v1/cards/01000000-0000-0000-0000-000000000001/rulings",
+        "scryfall_set_uri": "https://scryfall.com/sets/lea?utm_source=api",
+        "scryfall_uri": "https://scryfall.com/card/lea/161/lightning-bolt?utm_source=api",
+        "set": "lea",
+        "set_id": null,
+        "set_name": "Limited Edition Alpha",
+        "set_search_uri": "https://api.example/v1/cards/search?order=set&q=e%3Alea&unique=prints",
+        "set_type": null,
+        "set_uri": null,
+        "story_spotlight": false,
+        "tcgplayer_id": 1234,
+        "textless": false,
+        "type_line": "Instant",
+        "uri": "https://api.example/v1/cards/01000000-0000-0000-0000-000000000001",
+        "variation": false
+      }
+    },
+    {
+      "case": "a slug that deletes rather than hyphenates",
+      "row": {
+        "scryfall_id": "01000000-0000-0000-0000-000000000002",
+        "name": "Erayo's Essence",
+        "set_code": "chk",
+        "collector_number": "1",
+        "lang": "en",
+        "layout": "normal",
+        "games": [
+          "paper"
+        ]
+      },
+      "expected": {
+        "artist": null,
+        "booster": false,
+        "border_color": null,
+        "card_back_id": "0aeebaf5-8c7d-4636-9e82-8c27447861f7",
+        "cmc": null,
+        "collector_number": "1",
+        "color_identity": [],
+        "colors": [],
+        "digital": false,
+        "finishes": [],
+        "full_art": false,
+        "games": [
+          "paper"
+        ],
+        "highres_image": false,
+        "id": "01000000-0000-0000-0000-000000000002",
+        "illustration_id": null,
+        "image_status": null,
+        "image_uris": {
+          "art": "https://cards.scryfall.io/art/front/0/1/01000000-0000-0000-0000-000000000002.webp",
+          "art_crop": "https://cards.scryfall.io/art_crop/front/0/1/01000000-0000-0000-0000-000000000002.jpg",
+          "border_crop": "https://cards.scryfall.io/border_crop/front/0/1/01000000-0000-0000-0000-000000000002.jpg",
+          "crop": "https://cards.scryfall.io/crop/front/0/1/01000000-0000-0000-0000-000000000002.webp",
+          "display": "https://cards.scryfall.io/display/front/0/1/01000000-0000-0000-0000-000000000002.webp",
+          "grid": "https://cards.scryfall.io/grid/front/0/1/01000000-0000-0000-0000-000000000002.webp",
+          "large": "https://cards.scryfall.io/large/front/0/1/01000000-0000-0000-0000-000000000002.jpg",
+          "normal": "https://cards.scryfall.io/normal/front/0/1/01000000-0000-0000-0000-000000000002.jpg",
+          "png": "https://cards.scryfall.io/png/front/0/1/01000000-0000-0000-0000-000000000002.png",
+          "small": "https://cards.scryfall.io/small/front/0/1/01000000-0000-0000-0000-000000000002.jpg",
+          "thumb": "https://cards.scryfall.io/thumb/front/0/1/01000000-0000-0000-0000-000000000002.webp"
+        },
+        "keywords": [],
+        "lang": "en",
+        "layout": "normal",
+        "mana_cost": null,
+        "multiverse_ids": [],
+        "name": "Erayo's Essence",
+        "object": "card",
+        "oracle_id": "",
+        "oracle_text": null,
+        "oversized": false,
+        "prices": {
+          "eur": null,
+          "eur_foil": null,
+          "tix": null,
+          "usd": null,
+          "usd_etched": null,
+          "usd_foil": null
+        },
+        "prints_search_uri": "https://api.example/v1/cards/search?order=released&q=oracleid%3A&unique=prints",
+        "promo": false,
+        "purchase_uris": {
+          "cardhoarder": "https://www.cardhoarder.com/cards?data%5Bsearch%5D=Erayo%27s+Essence",
+          "cardmarket": "https://www.cardmarket.com/en/Magic/Products/Search?searchString=Erayo%27s+Essence",
+          "tcgplayer": "https://www.tcgplayer.com/search/magic/product?productLineName=magic&q=Erayo%27s+Essence&view=grid"
+        },
+        "rarity": null,
+        "related_uris": {
+          "edhrec": "https://edhrec.com/route/?cc=Erayo%27s+Essence",
+          "tcgplayer_infinite_articles": "https://www.tcgplayer.com/search/articles?productLineName=magic&q=Erayo%27s+Essence",
+          "tcgplayer_infinite_decks": "https://www.tcgplayer.com/search/decks?productLineName=magic&q=Erayo%27s+Essence"
+        },
+        "released_at": null,
+        "reprint": false,
+        "reserved": false,
+        "rulings_uri": "https://api.example/v1/cards/01000000-0000-0000-0000-000000000002/rulings",
+        "scryfall_set_uri": "https://scryfall.com/sets/chk?utm_source=api",
+        "scryfall_uri": "https://scryfall.com/card/chk/1/erayos-essence?utm_source=api",
+        "set": "chk",
+        "set_id": null,
+        "set_name": null,
+        "set_search_uri": "https://api.example/v1/cards/search?order=set&q=e%3Achk&unique=prints",
+        "set_type": null,
+        "set_uri": null,
+        "story_spotlight": false,
+        "textless": false,
+        "type_line": null,
+        "uri": "https://api.example/v1/cards/01000000-0000-0000-0000-000000000002",
+        "variation": false
+      }
+    },
+    {
+      "case": "a foreign printing takes the language path segment",
+      "row": {
+        "scryfall_id": "01000000-0000-0000-0000-000000000003",
+        "name": "Unmoored Ego",
+        "set_code": "grn",
+        "collector_number": "212",
+        "lang": "pt",
+        "layout": "normal",
+        "multiverse_ids": [
+          454775
+        ],
+        "games": [
+          "paper"
+        ]
+      },
+      "expected": {
+        "artist": null,
+        "booster": false,
+        "border_color": null,
+        "card_back_id": "0aeebaf5-8c7d-4636-9e82-8c27447861f7",
+        "cmc": null,
+        "collector_number": "212",
+        "color_identity": [],
+        "colors": [],
+        "digital": false,
+        "finishes": [],
+        "full_art": false,
+        "games": [
+          "paper"
+        ],
+        "highres_image": false,
+        "id": "01000000-0000-0000-0000-000000000003",
+        "illustration_id": null,
+        "image_status": null,
+        "image_uris": {
+          "art": "https://cards.scryfall.io/art/front/0/1/01000000-0000-0000-0000-000000000003.webp",
+          "art_crop": "https://cards.scryfall.io/art_crop/front/0/1/01000000-0000-0000-0000-000000000003.jpg",
+          "border_crop": "https://cards.scryfall.io/border_crop/front/0/1/01000000-0000-0000-0000-000000000003.jpg",
+          "crop": "https://cards.scryfall.io/crop/front/0/1/01000000-0000-0000-0000-000000000003.webp",
+          "display": "https://cards.scryfall.io/display/front/0/1/01000000-0000-0000-0000-000000000003.webp",
+          "grid": "https://cards.scryfall.io/grid/front/0/1/01000000-0000-0000-0000-000000000003.webp",
+          "large": "https://cards.scryfall.io/large/front/0/1/01000000-0000-0000-0000-000000000003.jpg",
+          "normal": "https://cards.scryfall.io/normal/front/0/1/01000000-0000-0000-0000-000000000003.jpg",
+          "png": "https://cards.scryfall.io/png/front/0/1/01000000-0000-0000-0000-000000000003.png",
+          "small": "https://cards.scryfall.io/small/front/0/1/01000000-0000-0000-0000-000000000003.jpg",
+          "thumb": "https://cards.scryfall.io/thumb/front/0/1/01000000-0000-0000-0000-000000000003.webp"
+        },
+        "keywords": [],
+        "lang": "pt",
+        "layout": "normal",
+        "mana_cost": null,
+        "multiverse_ids": [
+          454775
+        ],
+        "name": "Unmoored Ego",
+        "object": "card",
+        "oracle_id": "",
+        "oracle_text": null,
+        "oversized": false,
+        "prices": {
+          "eur": null,
+          "eur_foil": null,
+          "tix": null,
+          "usd": null,
+          "usd_etched": null,
+          "usd_foil": null
+        },
+        "prints_search_uri": "https://api.example/v1/cards/search?order=released&q=oracleid%3A&unique=prints",
+        "promo": false,
+        "purchase_uris": {
+          "cardhoarder": "https://www.cardhoarder.com/cards?data%5Bsearch%5D=Unmoored+Ego",
+          "cardmarket": "https://www.cardmarket.com/en/Magic/Products/Search?searchString=Unmoored+Ego",
+          "tcgplayer": "https://www.tcgplayer.com/search/magic/product?productLineName=magic&q=Unmoored+Ego&view=grid"
+        },
+        "rarity": null,
+        "related_uris": {
+          "edhrec": "https://edhrec.com/route/?cc=Unmoored+Ego",
+          "gatherer": "https://gatherer.wizards.com/Pages/Card/Details.aspx?multiverseid=454775&printed=true",
+          "tcgplayer_infinite_articles": "https://www.tcgplayer.com/search/articles?productLineName=magic&q=Unmoored+Ego",
+          "tcgplayer_infinite_decks": "https://www.tcgplayer.com/search/decks?productLineName=magic&q=Unmoored+Ego"
+        },
+        "released_at": null,
+        "reprint": false,
+        "reserved": false,
+        "rulings_uri": "https://api.example/v1/cards/01000000-0000-0000-0000-000000000003/rulings",
+        "scryfall_set_uri": "https://scryfall.com/sets/grn?utm_source=api",
+        "scryfall_uri": "https://scryfall.com/card/grn/212/pt/unmoored-ego?utm_source=api",
+        "set": "grn",
+        "set_id": null,
+        "set_name": null,
+        "set_search_uri": "https://api.example/v1/cards/search?order=set&q=e%3Agrn&unique=prints",
+        "set_type": null,
+        "set_uri": null,
+        "story_spotlight": false,
+        "textless": false,
+        "type_line": null,
+        "uri": "https://api.example/v1/cards/01000000-0000-0000-0000-000000000003",
+        "variation": false
+      }
+    },
+    {
+      "case": "a two-image layout keeps colors and pictures on its faces",
+      "row": {
+        "scryfall_id": "01000000-0000-0000-0000-000000000004",
+        "name": "Delver of Secrets // Insectile Aberration",
+        "layout": "transform",
+        "colors": [
+          "U"
+        ],
+        "color_identity": [
+          "U"
+        ],
+        "set_code": "isd",
+        "collector_number": "51",
+        "lang": "en",
+        "illustration_id": "22222222-3333-4444-5555-666666666666",
+        "games": [
+          "paper"
+        ],
+        "card_faces": [
+          {
+            "name": "Delver of Secrets",
+            "mana_cost": "{U}",
+            "oracle_text": "Front."
+          },
+          {
+            "name": "Insectile Aberration",
+            "mana_cost": "",
+            "oracle_text": "Back.",
+            "power": "3"
+          }
+        ]
+      },
+      "expected": {
+        "artist": null,
+        "booster": false,
+        "border_color": null,
+        "card_faces": [
+          {
+            "image_uris": {
+              "art": "https://cards.scryfall.io/art/front/0/1/01000000-0000-0000-0000-000000000004.webp",
+              "art_crop": "https://cards.scryfall.io/art_crop/front/0/1/01000000-0000-0000-0000-000000000004.jpg",
+              "border_crop": "https://cards.scryfall.io/border_crop/front/0/1/01000000-0000-0000-0000-000000000004.jpg",
+              "crop": "https://cards.scryfall.io/crop/front/0/1/01000000-0000-0000-0000-000000000004.webp",
+              "display": "https://cards.scryfall.io/display/front/0/1/01000000-0000-0000-0000-000000000004.webp",
+              "grid": "https://cards.scryfall.io/grid/front/0/1/01000000-0000-0000-0000-000000000004.webp",
+              "large": "https://cards.scryfall.io/large/front/0/1/01000000-0000-0000-0000-000000000004.jpg",
+              "normal": "https://cards.scryfall.io/normal/front/0/1/01000000-0000-0000-0000-000000000004.jpg",
+              "png": "https://cards.scryfall.io/png/front/0/1/01000000-0000-0000-0000-000000000004.png",
+              "small": "https://cards.scryfall.io/small/front/0/1/01000000-0000-0000-0000-000000000004.jpg",
+              "thumb": "https://cards.scryfall.io/thumb/front/0/1/01000000-0000-0000-0000-000000000004.webp"
+            },
+            "mana_cost": "{U}",
+            "name": "Delver of Secrets",
+            "object": "card_face",
+            "oracle_text": "Front."
+          },
+          {
+            "image_uris": {
+              "art": "https://cards.scryfall.io/art/back/0/1/01000000-0000-0000-0000-000000000004.webp",
+              "art_crop": "https://cards.scryfall.io/art_crop/back/0/1/01000000-0000-0000-0000-000000000004.jpg",
+              "border_crop": "https://cards.scryfall.io/border_crop/back/0/1/01000000-0000-0000-0000-000000000004.jpg",
+              "crop": "https://cards.scryfall.io/crop/back/0/1/01000000-0000-0000-0000-000000000004.webp",
+              "display": "https://cards.scryfall.io/display/back/0/1/01000000-0000-0000-0000-000000000004.webp",
+              "grid": "https://cards.scryfall.io/grid/back/0/1/01000000-0000-0000-0000-000000000004.webp",
+              "large": "https://cards.scryfall.io/large/back/0/1/01000000-0000-0000-0000-000000000004.jpg",
+              "normal": "https://cards.scryfall.io/normal/back/0/1/01000000-0000-0000-0000-000000000004.jpg",
+              "png": "https://cards.scryfall.io/png/back/0/1/01000000-0000-0000-0000-000000000004.png",
+              "small": "https://cards.scryfall.io/small/back/0/1/01000000-0000-0000-0000-000000000004.jpg",
+              "thumb": "https://cards.scryfall.io/thumb/back/0/1/01000000-0000-0000-0000-000000000004.webp"
+            },
+            "mana_cost": "",
+            "name": "Insectile Aberration",
+            "object": "card_face",
+            "oracle_text": "Back.",
+            "power": "3"
+          }
+        ],
+        "cmc": null,
+        "collector_number": "51",
+        "color_identity": [
+          "U"
+        ],
+        "digital": false,
+        "finishes": [],
+        "full_art": false,
+        "games": [
+          "paper"
+        ],
+        "highres_image": false,
+        "id": "01000000-0000-0000-0000-000000000004",
+        "image_status": null,
+        "keywords": [],
+        "lang": "en",
+        "layout": "transform",
+        "multiverse_ids": [],
+        "name": "Delver of Secrets // Insectile Aberration",
+        "object": "card",
+        "oracle_id": "",
+        "oversized": false,
+        "prices": {
+          "eur": null,
+          "eur_foil": null,
+          "tix": null,
+          "usd": null,
+          "usd_etched": null,
+          "usd_foil": null
+        },
+        "prints_search_uri": "https://api.example/v1/cards/search?order=released&q=oracleid%3A&unique=prints",
+        "promo": false,
+        "purchase_uris": {
+          "cardhoarder": "https://www.cardhoarder.com/cards?data%5Bsearch%5D=Delver+of+Secrets",
+          "cardmarket": "https://www.cardmarket.com/en/Magic/Products/Search?searchString=Delver+of+Secrets",
+          "tcgplayer": "https://www.tcgplayer.com/search/magic/product?productLineName=magic&q=Delver+of+Secrets&view=grid"
+        },
+        "rarity": null,
+        "related_uris": {
+          "edhrec": "https://edhrec.com/route/?cc=Delver+of+Secrets",
+          "tcgplayer_infinite_articles": "https://www.tcgplayer.com/search/articles?productLineName=magic&q=Delver+of+Secrets+%2F%2F+Insectile+Aberration",
+          "tcgplayer_infinite_decks": "https://www.tcgplayer.com/search/decks?productLineName=magic&q=Delver+of+Secrets+%2F%2F+Insectile+Aberration"
+        },
+        "released_at": null,
+        "reprint": false,
+        "reserved": false,
+        "rulings_uri": "https://api.example/v1/cards/01000000-0000-0000-0000-000000000004/rulings",
+        "scryfall_set_uri": "https://scryfall.com/sets/isd?utm_source=api",
+        "scryfall_uri": "https://scryfall.com/card/isd/51/delver-of-secrets-insectile-aberration?utm_source=api",
+        "set": "isd",
+        "set_id": null,
+        "set_name": null,
+        "set_search_uri": "https://api.example/v1/cards/search?order=set&q=e%3Aisd&unique=prints",
+        "set_type": null,
+        "set_uri": null,
+        "story_spotlight": false,
+        "textless": false,
+        "type_line": null,
+        "uri": "https://api.example/v1/cards/01000000-0000-0000-0000-000000000004",
+        "variation": false
+      }
+    },
+    {
+      "case": "a one-image multi-face card joins its cost at top level",
+      "row": {
+        "scryfall_id": "01000000-0000-0000-0000-000000000005",
+        "name": "Fire // Ice",
+        "layout": "split",
+        "set_code": "apc",
+        "collector_number": "128",
+        "lang": "en",
+        "games": [
+          "paper"
+        ],
+        "card_faces": [
+          {
+            "name": "Fire",
+            "mana_cost": "{1}{R}",
+            "oracle_text": "Two damage."
+          },
+          {
+            "name": "Ice",
+            "mana_cost": "{1}{U}",
+            "oracle_text": "Tap target."
+          }
+        ]
+      },
+      "expected": {
+        "artist": null,
+        "booster": false,
+        "border_color": null,
+        "card_back_id": "0aeebaf5-8c7d-4636-9e82-8c27447861f7",
+        "card_faces": [
+          {
+            "mana_cost": "{1}{R}",
+            "name": "Fire",
+            "object": "card_face",
+            "oracle_text": "Two damage."
+          },
+          {
+            "mana_cost": "{1}{U}",
+            "name": "Ice",
+            "object": "card_face",
+            "oracle_text": "Tap target."
+          }
+        ],
+        "cmc": null,
+        "collector_number": "128",
+        "color_identity": [],
+        "colors": [],
+        "digital": false,
+        "finishes": [],
+        "full_art": false,
+        "games": [
+          "paper"
+        ],
+        "highres_image": false,
+        "id": "01000000-0000-0000-0000-000000000005",
+        "illustration_id": null,
+        "image_status": null,
+        "image_uris": {
+          "art": "https://cards.scryfall.io/art/front/0/1/01000000-0000-0000-0000-000000000005.webp",
+          "art_crop": "https://cards.scryfall.io/art_crop/front/0/1/01000000-0000-0000-0000-000000000005.jpg",
+          "border_crop": "https://cards.scryfall.io/border_crop/front/0/1/01000000-0000-0000-0000-000000000005.jpg",
+          "crop": "https://cards.scryfall.io/crop/front/0/1/01000000-0000-0000-0000-000000000005.webp",
+          "display": "https://cards.scryfall.io/display/front/0/1/01000000-0000-0000-0000-000000000005.webp",
+          "grid": "https://cards.scryfall.io/grid/front/0/1/01000000-0000-0000-0000-000000000005.webp",
+          "large": "https://cards.scryfall.io/large/front/0/1/01000000-0000-0000-0000-000000000005.jpg",
+          "normal": "https://cards.scryfall.io/normal/front/0/1/01000000-0000-0000-0000-000000000005.jpg",
+          "png": "https://cards.scryfall.io/png/front/0/1/01000000-0000-0000-0000-000000000005.png",
+          "small": "https://cards.scryfall.io/small/front/0/1/01000000-0000-0000-0000-000000000005.jpg",
+          "thumb": "https://cards.scryfall.io/thumb/front/0/1/01000000-0000-0000-0000-000000000005.webp"
+        },
+        "keywords": [],
+        "lang": "en",
+        "layout": "split",
+        "mana_cost": "{1}{R} // {1}{U}",
+        "multiverse_ids": [],
+        "name": "Fire // Ice",
+        "object": "card",
+        "oracle_id": "",
+        "oversized": false,
+        "prices": {
+          "eur": null,
+          "eur_foil": null,
+          "tix": null,
+          "usd": null,
+          "usd_etched": null,
+          "usd_foil": null
+        },
+        "prints_search_uri": "https://api.example/v1/cards/search?order=released&q=oracleid%3A&unique=prints",
+        "promo": false,
+        "purchase_uris": {
+          "cardhoarder": "https://www.cardhoarder.com/cards?data%5Bsearch%5D=Fire+%2F%2F+Ice",
+          "cardmarket": "https://www.cardmarket.com/en/Magic/Products/Search?searchString=Fire+%2F%2F+Ice",
+          "tcgplayer": "https://www.tcgplayer.com/search/magic/product?productLineName=magic&q=Fire+%2F%2F+Ice&view=grid"
+        },
+        "rarity": null,
+        "related_uris": {
+          "edhrec": "https://edhrec.com/route/?cc=Fire+%2F%2F+Ice",
+          "tcgplayer_infinite_articles": "https://www.tcgplayer.com/search/articles?productLineName=magic&q=Fire+%2F%2F+Ice",
+          "tcgplayer_infinite_decks": "https://www.tcgplayer.com/search/decks?productLineName=magic&q=Fire+%2F%2F+Ice"
+        },
+        "released_at": null,
+        "reprint": false,
+        "reserved": false,
+        "rulings_uri": "https://api.example/v1/cards/01000000-0000-0000-0000-000000000005/rulings",
+        "scryfall_set_uri": "https://scryfall.com/sets/apc?utm_source=api",
+        "scryfall_uri": "https://scryfall.com/card/apc/128/fire-ice?utm_source=api",
+        "set": "apc",
+        "set_id": null,
+        "set_name": null,
+        "set_search_uri": "https://api.example/v1/cards/search?order=set&q=e%3Aapc&unique=prints",
+        "set_type": null,
+        "set_uri": null,
+        "story_spotlight": false,
+        "textless": false,
+        "type_line": null,
+        "uri": "https://api.example/v1/cards/01000000-0000-0000-0000-000000000005",
+        "variation": false
+      }
+    },
+    {
+      "case": "a flipped back face with no cost is skipped in the join",
+      "row": {
+        "scryfall_id": "01000000-0000-0000-0000-000000000006",
+        "name": "Erayo // Erayo's Essence",
+        "layout": "flip",
+        "set_code": "chk",
+        "collector_number": "2",
+        "lang": "en",
+        "games": [
+          "paper"
+        ],
+        "card_faces": [
+          {
+            "name": "Erayo",
+            "mana_cost": "{1}{U}",
+            "oracle_text": "Front."
+          },
+          {
+            "name": "Erayo's Essence",
+            "mana_cost": "",
+            "oracle_text": "Back."
+          }
+        ]
+      },
+      "expected": {
+        "artist": null,
+        "booster": false,
+        "border_color": null,
+        "card_back_id": "0aeebaf5-8c7d-4636-9e82-8c27447861f7",
+        "card_faces": [
+          {
+            "mana_cost": "{1}{U}",
+            "name": "Erayo",
+            "object": "card_face",
+            "oracle_text": "Front."
+          },
+          {
+            "mana_cost": "",
+            "name": "Erayo's Essence",
+            "object": "card_face",
+            "oracle_text": "Back."
+          }
+        ],
+        "cmc": null,
+        "collector_number": "2",
+        "color_identity": [],
+        "colors": [],
+        "digital": false,
+        "finishes": [],
+        "full_art": false,
+        "games": [
+          "paper"
+        ],
+        "highres_image": false,
+        "id": "01000000-0000-0000-0000-000000000006",
+        "illustration_id": null,
+        "image_status": null,
+        "image_uris": {
+          "art": "https://cards.scryfall.io/art/front/0/1/01000000-0000-0000-0000-000000000006.webp",
+          "art_crop": "https://cards.scryfall.io/art_crop/front/0/1/01000000-0000-0000-0000-000000000006.jpg",
+          "border_crop": "https://cards.scryfall.io/border_crop/front/0/1/01000000-0000-0000-0000-000000000006.jpg",
+          "crop": "https://cards.scryfall.io/crop/front/0/1/01000000-0000-0000-0000-000000000006.webp",
+          "display": "https://cards.scryfall.io/display/front/0/1/01000000-0000-0000-0000-000000000006.webp",
+          "grid": "https://cards.scryfall.io/grid/front/0/1/01000000-0000-0000-0000-000000000006.webp",
+          "large": "https://cards.scryfall.io/large/front/0/1/01000000-0000-0000-0000-000000000006.jpg",
+          "normal": "https://cards.scryfall.io/normal/front/0/1/01000000-0000-0000-0000-000000000006.jpg",
+          "png": "https://cards.scryfall.io/png/front/0/1/01000000-0000-0000-0000-000000000006.png",
+          "small": "https://cards.scryfall.io/small/front/0/1/01000000-0000-0000-0000-000000000006.jpg",
+          "thumb": "https://cards.scryfall.io/thumb/front/0/1/01000000-0000-0000-0000-000000000006.webp"
+        },
+        "keywords": [],
+        "lang": "en",
+        "layout": "flip",
+        "mana_cost": "{1}{U}",
+        "multiverse_ids": [],
+        "name": "Erayo // Erayo's Essence",
+        "object": "card",
+        "oracle_id": "",
+        "oversized": false,
+        "prices": {
+          "eur": null,
+          "eur_foil": null,
+          "tix": null,
+          "usd": null,
+          "usd_etched": null,
+          "usd_foil": null
+        },
+        "prints_search_uri": "https://api.example/v1/cards/search?order=released&q=oracleid%3A&unique=prints",
+        "promo": false,
+        "purchase_uris": {
+          "cardhoarder": "https://www.cardhoarder.com/cards?data%5Bsearch%5D=Erayo",
+          "cardmarket": "https://www.cardmarket.com/en/Magic/Products/Search?searchString=Erayo",
+          "tcgplayer": "https://www.tcgplayer.com/search/magic/product?productLineName=magic&q=Erayo&view=grid"
+        },
+        "rarity": null,
+        "related_uris": {
+          "edhrec": "https://edhrec.com/route/?cc=Erayo",
+          "tcgplayer_infinite_articles": "https://www.tcgplayer.com/search/articles?productLineName=magic&q=Erayo+%2F%2F+Erayo%27s+Essence",
+          "tcgplayer_infinite_decks": "https://www.tcgplayer.com/search/decks?productLineName=magic&q=Erayo+%2F%2F+Erayo%27s+Essence"
+        },
+        "released_at": null,
+        "reprint": false,
+        "reserved": false,
+        "rulings_uri": "https://api.example/v1/cards/01000000-0000-0000-0000-000000000006/rulings",
+        "scryfall_set_uri": "https://scryfall.com/sets/chk?utm_source=api",
+        "scryfall_uri": "https://scryfall.com/card/chk/2/erayo-erayos-essence?utm_source=api",
+        "set": "chk",
+        "set_id": null,
+        "set_name": null,
+        "set_search_uri": "https://api.example/v1/cards/search?order=set&q=e%3Achk&unique=prints",
+        "set_type": null,
+        "set_uri": null,
+        "story_spotlight": false,
+        "textless": false,
+        "type_line": null,
+        "uri": "https://api.example/v1/cards/01000000-0000-0000-0000-000000000006",
+        "variation": false
+      }
+    },
+    {
+      "case": "a reversible printing drops the three keys its faces carry",
+      "row": {
+        "scryfall_id": "01000000-0000-0000-0000-000000000007",
+        "oracle_id": "33333333-4444-5555-6666-777777777777",
+        "name": "Propaganda // Propaganda",
+        "layout": "reversible_card",
+        "cmc": 3,
+        "type_line": "Enchantment",
+        "set_code": "sld",
+        "collector_number": "500",
+        "lang": "en",
+        "games": [
+          "paper"
+        ],
+        "card_faces": [
+          {
+            "name": "Propaganda",
+            "mana_cost": "{2}{U}",
+            "oracle_text": "Front."
+          },
+          {
+            "name": "Propaganda",
+            "mana_cost": "{2}{U}",
+            "oracle_text": "Back."
+          }
+        ]
+      },
+      "expected": {
+        "artist": null,
+        "booster": false,
+        "border_color": null,
+        "card_faces": [
+          {
+            "cmc": 3.0,
+            "image_uris": {
+              "art": "https://cards.scryfall.io/art/front/0/1/01000000-0000-0000-0000-000000000007.webp",
+              "art_crop": "https://cards.scryfall.io/art_crop/front/0/1/01000000-0000-0000-0000-000000000007.jpg",
+              "border_crop": "https://cards.scryfall.io/border_crop/front/0/1/01000000-0000-0000-0000-000000000007.jpg",
+              "crop": "https://cards.scryfall.io/crop/front/0/1/01000000-0000-0000-0000-000000000007.webp",
+              "display": "https://cards.scryfall.io/display/front/0/1/01000000-0000-0000-0000-000000000007.webp",
+              "grid": "https://cards.scryfall.io/grid/front/0/1/01000000-0000-0000-0000-000000000007.webp",
+              "large": "https://cards.scryfall.io/large/front/0/1/01000000-0000-0000-0000-000000000007.jpg",
+              "normal": "https://cards.scryfall.io/normal/front/0/1/01000000-0000-0000-0000-000000000007.jpg",
+              "png": "https://cards.scryfall.io/png/front/0/1/01000000-0000-0000-0000-000000000007.png",
+              "small": "https://cards.scryfall.io/small/front/0/1/01000000-0000-0000-0000-000000000007.jpg",
+              "thumb": "https://cards.scryfall.io/thumb/front/0/1/01000000-0000-0000-0000-000000000007.webp"
+            },
+            "mana_cost": "{2}{U}",
+            "name": "Propaganda",
+            "object": "card_face",
+            "oracle_id": "33333333-4444-5555-6666-777777777777",
+            "oracle_text": "Front."
+          },
+          {
+            "cmc": 3.0,
+            "image_uris": {
+              "art": "https://cards.scryfall.io/art/back/0/1/01000000-0000-0000-0000-000000000007.webp",
+              "art_crop": "https://cards.scryfall.io/art_crop/back/0/1/01000000-0000-0000-0000-000000000007.jpg",
+              "border_crop": "https://cards.scryfall.io/border_crop/back/0/1/01000000-0000-0000-0000-000000000007.jpg",
+              "crop": "https://cards.scryfall.io/crop/back/0/1/01000000-0000-0000-0000-000000000007.webp",
+              "display": "https://cards.scryfall.io/display/back/0/1/01000000-0000-0000-0000-000000000007.webp",
+              "grid": "https://cards.scryfall.io/grid/back/0/1/01000000-0000-0000-0000-000000000007.webp",
+              "large": "https://cards.scryfall.io/large/back/0/1/01000000-0000-0000-0000-000000000007.jpg",
+              "normal": "https://cards.scryfall.io/normal/back/0/1/01000000-0000-0000-0000-000000000007.jpg",
+              "png": "https://cards.scryfall.io/png/back/0/1/01000000-0000-0000-0000-000000000007.png",
+              "small": "https://cards.scryfall.io/small/back/0/1/01000000-0000-0000-0000-000000000007.jpg",
+              "thumb": "https://cards.scryfall.io/thumb/back/0/1/01000000-0000-0000-0000-000000000007.webp"
+            },
+            "mana_cost": "{2}{U}",
+            "name": "Propaganda",
+            "object": "card_face",
+            "oracle_id": "33333333-4444-5555-6666-777777777777",
+            "oracle_text": "Back."
+          }
+        ],
+        "collector_number": "500",
+        "color_identity": [],
+        "digital": false,
+        "finishes": [],
+        "full_art": false,
+        "games": [
+          "paper"
+        ],
+        "highres_image": false,
+        "id": "01000000-0000-0000-0000-000000000007",
+        "image_status": null,
+        "keywords": [],
+        "lang": "en",
+        "layout": "reversible_card",
+        "multiverse_ids": [],
+        "name": "Propaganda // Propaganda",
+        "object": "card",
+        "oversized": false,
+        "prices": {
+          "eur": null,
+          "eur_foil": null,
+          "tix": null,
+          "usd": null,
+          "usd_etched": null,
+          "usd_foil": null
+        },
+        "prints_search_uri": "https://api.example/v1/cards/search?order=released&q=oracleid%3A33333333-4444-5555-6666-777777777777&unique=prints",
+        "promo": false,
+        "purchase_uris": {
+          "cardhoarder": "https://www.cardhoarder.com/cards?data%5Bsearch%5D=Propaganda+%2F%2F+Propaganda",
+          "cardmarket": "https://www.cardmarket.com/en/Magic/Products/Search?searchString=Propaganda+%2F%2F+Propaganda",
+          "tcgplayer": "https://www.tcgplayer.com/search/magic/product?productLineName=magic&q=Propaganda+%2F%2F+Propaganda&view=grid"
+        },
+        "rarity": null,
+        "related_uris": {
+          "edhrec": "https://edhrec.com/route/?cc=Propaganda+%2F%2F+Propaganda",
+          "tcgplayer_infinite_articles": "https://www.tcgplayer.com/search/articles?productLineName=magic&q=Propaganda+%2F%2F+Propaganda",
+          "tcgplayer_infinite_decks": "https://www.tcgplayer.com/search/decks?productLineName=magic&q=Propaganda+%2F%2F+Propaganda"
+        },
+        "released_at": null,
+        "reprint": false,
+        "reserved": false,
+        "rulings_uri": "https://api.example/v1/cards/01000000-0000-0000-0000-000000000007/rulings",
+        "scryfall_set_uri": "https://scryfall.com/sets/sld?utm_source=api",
+        "scryfall_uri": "https://scryfall.com/card/sld/500/propaganda-propaganda?utm_source=api",
+        "set": "sld",
+        "set_id": null,
+        "set_name": null,
+        "set_search_uri": "https://api.example/v1/cards/search?order=set&q=e%3Asld&unique=prints",
+        "set_type": null,
+        "set_uri": null,
+        "story_spotlight": false,
+        "textless": false,
+        "uri": "https://api.example/v1/cards/01000000-0000-0000-0000-000000000007",
+        "variation": false
+      }
+    },
+    {
+      "case": "no marketplace ids means a name search per key",
+      "row": {
+        "scryfall_id": "01000000-0000-0000-0000-000000000008",
+        "name": "Invasion of Alara // Awaken the Maelstrom",
+        "layout": "modal_dfc",
+        "set_code": "mom",
+        "collector_number": "195",
+        "lang": "en",
+        "games": [
+          "paper"
+        ],
+        "card_faces": [
+          {
+            "name": "Invasion of Alara",
+            "mana_cost": "{W}{U}{B}{R}{G}",
+            "oracle_text": "Front."
+          },
+          {
+            "name": "Awaken the Maelstrom",
+            "mana_cost": "",
+            "oracle_text": "Back."
+          }
+        ]
+      },
+      "expected": {
+        "artist": null,
+        "booster": false,
+        "border_color": null,
+        "card_faces": [
+          {
+            "image_uris": {
+              "art": "https://cards.scryfall.io/art/front/0/1/01000000-0000-0000-0000-000000000008.webp",
+              "art_crop": "https://cards.scryfall.io/art_crop/front/0/1/01000000-0000-0000-0000-000000000008.jpg",
+              "border_crop": "https://cards.scryfall.io/border_crop/front/0/1/01000000-0000-0000-0000-000000000008.jpg",
+              "crop": "https://cards.scryfall.io/crop/front/0/1/01000000-0000-0000-0000-000000000008.webp",
+              "display": "https://cards.scryfall.io/display/front/0/1/01000000-0000-0000-0000-000000000008.webp",
+              "grid": "https://cards.scryfall.io/grid/front/0/1/01000000-0000-0000-0000-000000000008.webp",
+              "large": "https://cards.scryfall.io/large/front/0/1/01000000-0000-0000-0000-000000000008.jpg",
+              "normal": "https://cards.scryfall.io/normal/front/0/1/01000000-0000-0000-0000-000000000008.jpg",
+              "png": "https://cards.scryfall.io/png/front/0/1/01000000-0000-0000-0000-000000000008.png",
+              "small": "https://cards.scryfall.io/small/front/0/1/01000000-0000-0000-0000-000000000008.jpg",
+              "thumb": "https://cards.scryfall.io/thumb/front/0/1/01000000-0000-0000-0000-000000000008.webp"
+            },
+            "mana_cost": "{W}{U}{B}{R}{G}",
+            "name": "Invasion of Alara",
+            "object": "card_face",
+            "oracle_text": "Front."
+          },
+          {
+            "image_uris": {
+              "art": "https://cards.scryfall.io/art/back/0/1/01000000-0000-0000-0000-000000000008.webp",
+              "art_crop": "https://cards.scryfall.io/art_crop/back/0/1/01000000-0000-0000-0000-000000000008.jpg",
+              "border_crop": "https://cards.scryfall.io/border_crop/back/0/1/01000000-0000-0000-0000-000000000008.jpg",
+              "crop": "https://cards.scryfall.io/crop/back/0/1/01000000-0000-0000-0000-000000000008.webp",
+              "display": "https://cards.scryfall.io/display/back/0/1/01000000-0000-0000-0000-000000000008.webp",
+              "grid": "https://cards.scryfall.io/grid/back/0/1/01000000-0000-0000-0000-000000000008.webp",
+              "large": "https://cards.scryfall.io/large/back/0/1/01000000-0000-0000-0000-000000000008.jpg",
+              "normal": "https://cards.scryfall.io/normal/back/0/1/01000000-0000-0000-0000-000000000008.jpg",
+              "png": "https://cards.scryfall.io/png/back/0/1/01000000-0000-0000-0000-000000000008.png",
+              "small": "https://cards.scryfall.io/small/back/0/1/01000000-0000-0000-0000-000000000008.jpg",
+              "thumb": "https://cards.scryfall.io/thumb/back/0/1/01000000-0000-0000-0000-000000000008.webp"
+            },
+            "mana_cost": "",
+            "name": "Awaken the Maelstrom",
+            "object": "card_face",
+            "oracle_text": "Back."
+          }
+        ],
+        "cmc": null,
+        "collector_number": "195",
+        "color_identity": [],
+        "digital": false,
+        "finishes": [],
+        "full_art": false,
+        "games": [
+          "paper"
+        ],
+        "highres_image": false,
+        "id": "01000000-0000-0000-0000-000000000008",
+        "image_status": null,
+        "keywords": [],
+        "lang": "en",
+        "layout": "modal_dfc",
+        "multiverse_ids": [],
+        "name": "Invasion of Alara // Awaken the Maelstrom",
+        "object": "card",
+        "oracle_id": "",
+        "oversized": false,
+        "prices": {
+          "eur": null,
+          "eur_foil": null,
+          "tix": null,
+          "usd": null,
+          "usd_etched": null,
+          "usd_foil": null
+        },
+        "prints_search_uri": "https://api.example/v1/cards/search?order=released&q=oracleid%3A&unique=prints",
+        "promo": false,
+        "purchase_uris": {
+          "cardhoarder": "https://www.cardhoarder.com/cards?data%5Bsearch%5D=Invasion+of+Alara",
+          "cardmarket": "https://www.cardmarket.com/en/Magic/Products/Search?searchString=Invasion+of+Alara",
+          "tcgplayer": "https://www.tcgplayer.com/search/magic/product?productLineName=magic&q=Invasion+of+Alara&view=grid"
+        },
+        "rarity": null,
+        "related_uris": {
+          "edhrec": "https://edhrec.com/route/?cc=Invasion+of+Alara",
+          "tcgplayer_infinite_articles": "https://www.tcgplayer.com/search/articles?productLineName=magic&q=Invasion+of+Alara+%2F%2F+Awaken+the+Maelstrom",
+          "tcgplayer_infinite_decks": "https://www.tcgplayer.com/search/decks?productLineName=magic&q=Invasion+of+Alara+%2F%2F+Awaken+the+Maelstrom"
+        },
+        "released_at": null,
+        "reprint": false,
+        "reserved": false,
+        "rulings_uri": "https://api.example/v1/cards/01000000-0000-0000-0000-000000000008/rulings",
+        "scryfall_set_uri": "https://scryfall.com/sets/mom?utm_source=api",
+        "scryfall_uri": "https://scryfall.com/card/mom/195/invasion-of-alara-awaken-the-maelstrom?utm_source=api",
+        "set": "mom",
+        "set_id": null,
+        "set_name": null,
+        "set_search_uri": "https://api.example/v1/cards/search?order=set&q=e%3Amom&unique=prints",
+        "set_type": null,
+        "set_uri": null,
+        "story_spotlight": false,
+        "textless": false,
+        "type_line": null,
+        "uri": "https://api.example/v1/cards/01000000-0000-0000-0000-000000000008",
+        "variation": false
+      }
+    },
+    {
+      "case": "an arena-only printing omits purchase_uris entirely",
+      "row": {
+        "scryfall_id": "01000000-0000-0000-0000-000000000009",
+        "name": "Alrund's Epiphany",
+        "set_code": "khm",
+        "collector_number": "A-198",
+        "lang": "en",
+        "layout": "normal",
+        "digital": true,
+        "games": [
+          "arena"
+        ]
+      },
+      "expected": {
+        "artist": null,
+        "booster": false,
+        "border_color": null,
+        "card_back_id": "0aeebaf5-8c7d-4636-9e82-8c27447861f7",
+        "cmc": null,
+        "collector_number": "A-198",
+        "color_identity": [],
+        "colors": [],
+        "digital": true,
+        "finishes": [],
+        "full_art": false,
+        "games": [
+          "arena"
+        ],
+        "highres_image": false,
+        "id": "01000000-0000-0000-0000-000000000009",
+        "illustration_id": null,
+        "image_status": null,
+        "image_uris": {
+          "art": "https://cards.scryfall.io/art/front/0/1/01000000-0000-0000-0000-000000000009.webp",
+          "art_crop": "https://cards.scryfall.io/art_crop/front/0/1/01000000-0000-0000-0000-000000000009.jpg",
+          "border_crop": "https://cards.scryfall.io/border_crop/front/0/1/01000000-0000-0000-0000-000000000009.jpg",
+          "crop": "https://cards.scryfall.io/crop/front/0/1/01000000-0000-0000-0000-000000000009.webp",
+          "display": "https://cards.scryfall.io/display/front/0/1/01000000-0000-0000-0000-000000000009.webp",
+          "grid": "https://cards.scryfall.io/grid/front/0/1/01000000-0000-0000-0000-000000000009.webp",
+          "large": "https://cards.scryfall.io/large/front/0/1/01000000-0000-0000-0000-000000000009.jpg",
+          "normal": "https://cards.scryfall.io/normal/front/0/1/01000000-0000-0000-0000-000000000009.jpg",
+          "png": "https://cards.scryfall.io/png/front/0/1/01000000-0000-0000-0000-000000000009.png",
+          "small": "https://cards.scryfall.io/small/front/0/1/01000000-0000-0000-0000-000000000009.jpg",
+          "thumb": "https://cards.scryfall.io/thumb/front/0/1/01000000-0000-0000-0000-000000000009.webp"
+        },
+        "keywords": [],
+        "lang": "en",
+        "layout": "normal",
+        "mana_cost": null,
+        "multiverse_ids": [],
+        "name": "Alrund's Epiphany",
+        "object": "card",
+        "oracle_id": "",
+        "oracle_text": null,
+        "oversized": false,
+        "prices": {
+          "eur": null,
+          "eur_foil": null,
+          "tix": null,
+          "usd": null,
+          "usd_etched": null,
+          "usd_foil": null
+        },
+        "prints_search_uri": "https://api.example/v1/cards/search?order=released&q=oracleid%3A&unique=prints",
+        "promo": false,
+        "rarity": null,
+        "related_uris": {
+          "edhrec": "https://edhrec.com/route/?cc=Alrund%27s+Epiphany",
+          "tcgplayer_infinite_articles": "https://www.tcgplayer.com/search/articles?productLineName=magic&q=Alrund%27s+Epiphany",
+          "tcgplayer_infinite_decks": "https://www.tcgplayer.com/search/decks?productLineName=magic&q=Alrund%27s+Epiphany"
+        },
+        "released_at": null,
+        "reprint": false,
+        "reserved": false,
+        "rulings_uri": "https://api.example/v1/cards/01000000-0000-0000-0000-000000000009/rulings",
+        "scryfall_set_uri": "https://scryfall.com/sets/khm?utm_source=api",
+        "scryfall_uri": "https://scryfall.com/card/khm/A-198/alrunds-epiphany?utm_source=api",
+        "set": "khm",
+        "set_id": null,
+        "set_name": null,
+        "set_search_uri": "https://api.example/v1/cards/search?order=set&q=e%3Akhm&unique=prints",
+        "set_type": null,
+        "set_uri": null,
+        "story_spotlight": false,
+        "textless": false,
+        "type_line": null,
+        "uri": "https://api.example/v1/cards/01000000-0000-0000-0000-000000000009",
+        "variation": false
+      }
+    },
+    {
+      "case": "an empty string is a value, not an absence",
+      "row": {
+        "scryfall_id": "01000000-0000-0000-0000-00000000000a",
+        "name": "Island",
+        "mana_cost": "",
+        "cmc": 0,
+        "type_line": "Basic Land — Island",
+        "oracle_text": "",
+        "artist": "",
+        "set_code": "lea",
+        "collector_number": "288",
+        "lang": "en",
+        "layout": "normal",
+        "games": [
+          "paper"
+        ]
+      },
+      "expected": {
+        "artist": "",
+        "booster": false,
+        "border_color": null,
+        "card_back_id": "0aeebaf5-8c7d-4636-9e82-8c27447861f7",
+        "cmc": 0.0,
+        "collector_number": "288",
+        "color_identity": [],
+        "colors": [],
+        "digital": false,
+        "finishes": [],
+        "full_art": false,
+        "games": [
+          "paper"
+        ],
+        "highres_image": false,
+        "id": "01000000-0000-0000-0000-00000000000a",
+        "illustration_id": null,
+        "image_status": null,
+        "image_uris": {
+          "art": "https://cards.scryfall.io/art/front/0/1/01000000-0000-0000-0000-00000000000a.webp",
+          "art_crop": "https://cards.scryfall.io/art_crop/front/0/1/01000000-0000-0000-0000-00000000000a.jpg",
+          "border_crop": "https://cards.scryfall.io/border_crop/front/0/1/01000000-0000-0000-0000-00000000000a.jpg",
+          "crop": "https://cards.scryfall.io/crop/front/0/1/01000000-0000-0000-0000-00000000000a.webp",
+          "display": "https://cards.scryfall.io/display/front/0/1/01000000-0000-0000-0000-00000000000a.webp",
+          "grid": "https://cards.scryfall.io/grid/front/0/1/01000000-0000-0000-0000-00000000000a.webp",
+          "large": "https://cards.scryfall.io/large/front/0/1/01000000-0000-0000-0000-00000000000a.jpg",
+          "normal": "https://cards.scryfall.io/normal/front/0/1/01000000-0000-0000-0000-00000000000a.jpg",
+          "png": "https://cards.scryfall.io/png/front/0/1/01000000-0000-0000-0000-00000000000a.png",
+          "small": "https://cards.scryfall.io/small/front/0/1/01000000-0000-0000-0000-00000000000a.jpg",
+          "thumb": "https://cards.scryfall.io/thumb/front/0/1/01000000-0000-0000-0000-00000000000a.webp"
+        },
+        "keywords": [],
+        "lang": "en",
+        "layout": "normal",
+        "mana_cost": "",
+        "multiverse_ids": [],
+        "name": "Island",
+        "object": "card",
+        "oracle_id": "",
+        "oracle_text": "",
+        "oversized": false,
+        "prices": {
+          "eur": null,
+          "eur_foil": null,
+          "tix": null,
+          "usd": null,
+          "usd_etched": null,
+          "usd_foil": null
+        },
+        "prints_search_uri": "https://api.example/v1/cards/search?order=released&q=oracleid%3A&unique=prints",
+        "promo": false,
+        "purchase_uris": {
+          "cardhoarder": "https://www.cardhoarder.com/cards?data%5Bsearch%5D=Island",
+          "cardmarket": "https://www.cardmarket.com/en/Magic/Products/Search?searchString=Island",
+          "tcgplayer": "https://www.tcgplayer.com/search/magic/product?productLineName=magic&q=Island&view=grid"
+        },
+        "rarity": null,
+        "related_uris": {
+          "edhrec": "https://edhrec.com/route/?cc=Island",
+          "tcgplayer_infinite_articles": "https://www.tcgplayer.com/search/articles?productLineName=magic&q=Island",
+          "tcgplayer_infinite_decks": "https://www.tcgplayer.com/search/decks?productLineName=magic&q=Island"
+        },
+        "released_at": null,
+        "reprint": false,
+        "reserved": false,
+        "rulings_uri": "https://api.example/v1/cards/01000000-0000-0000-0000-00000000000a/rulings",
+        "scryfall_set_uri": "https://scryfall.com/sets/lea?utm_source=api",
+        "scryfall_uri": "https://scryfall.com/card/lea/288/island?utm_source=api",
+        "set": "lea",
+        "set_id": null,
+        "set_name": null,
+        "set_search_uri": "https://api.example/v1/cards/search?order=set&q=e%3Alea&unique=prints",
+        "set_type": null,
+        "set_uri": null,
+        "story_spotlight": false,
+        "textless": false,
+        "type_line": "Basic Land — Island",
+        "uri": "https://api.example/v1/cards/01000000-0000-0000-0000-00000000000a",
+        "variation": false
+      }
+    }
+  ]
+}
diff --git a/api/scryfall_compat/mana.py b/api/scryfall_compat/mana.py
new file mode 100644
index 000000000..441f2e7ce
--- /dev/null
+++ b/api/scryfall_compat/mana.py
@@ -0,0 +1,420 @@
+"""Mana cost parsing for `GET /symbology/parse-mana`.
+
+The one reference endpoint that is computed rather than mirrored: it takes a cost written any way a
+human might write it (`RUW`, `2WW`, `{X}{R}{R}`) and returns Scryfall's normalized form plus the
+colors, mana value and the three colour-count flags.
+
+Two behaviours here were measured against api.scryfall.com on 2026-08-11 rather than inferred, both
+because nothing documents them:
+
+- **The normalized cost reorders colored pips into the canonical colour order**, so `RUW` comes back
+  as `{U}{R}{W}` (Jeskai) and not as it was written. `_canonical_colors` is that rule.
+- **The emission order is X, then generic, then every other pip in `GET /symbology` catalog
+  order**, regardless of where they appeared in the input: `2XWU` normalizes to `{X}{2}{W}{U}`, and
+  `CW` to `{W}{C}`. Generic pips are summed into one symbol, so `1{1}` is `{2}`. `_PIP_ORDER` is
+  that rule.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any, NamedTuple
+
+# The colour wheel. Every canonical ordering is a walk around this cycle.
+_WUBRG = ("W", "U", "B", "R", "G")
+_COLOR_INDEX = {color: index for index, color in enumerate(_WUBRG)}
+
+# Symbols that are mana but not a colour: colorless, snow, and the energy-style pips.
+_COLORLESS_PIPS = frozenset({"C", "S"})
+
+# Variable pips, which contribute nothing to mana value.
+_VARIABLE_PIPS = frozenset({"X", "Y", "Z"})
+
+_BRACED = re.compile(r"\{([^}]*)\}")
+
+# Half-mana symbols are written {HW}; the half applies to the symbol that follows the H.
+# `GET /symbology` lists exactly these two (2026-08-28), and reading `H` as a prefix over any colour
+# was one symbol too generous: `?cost={HB}` is a 422 on api.scryfall.com, measured the same day.
+_HALF_SYMBOLS = frozenset({"HW", "HR"})
+_HALF_MANA = 0.5
+
+# Every hybrid symbol api.scryfall.com knows, in the order `GET /symbology` lists them.
+#
+# Fetched whole on 2026-08-28: 84 symbols, 36 of them hybrids, and this is all 36. The inventory is
+# the rule -- a hybrid parses if and only if it is one of these -- because no rule stated in terms of
+# the halves gets the boundary right. This module used to require exactly TWO halves, which rejects
+# the ten PHYREXIAN HYBRIDS below: `{W/U/P}` and its nine siblings are printed symbols, and four live
+# cards carry one in their mana cost (`is:phyrexian is:hybrid`, 2026-08-28 -- Ajani, Sleeper Agent
+# `{1}{G}{G/W/P}{W}`; Tamiyo, Compleated Sage `{2}{G}{G/U/P}{U}`; Nahiri, the Unforgiving
+# `{1}{R}{R/W/P}{W}`; Lukka, Bound to Ruin `{2}{R}{R/G/P}{G}`). Loosening the count to "two or three"
+# would be just as wrong in the other direction: `{W/U/B}` and `{3/W}` are still 422s.
+#
+# The order is load-bearing twice over -- it is also the order hybrids are EMITTED in, see _PIP_ORDER.
+_HYBRID_SYMBOLS = (
+    # Colour pairs.
+    "W/U",
+    "W/B",
+    "B/R",
+    "B/G",
+    "U/B",
+    "U/R",
+    "R/G",
+    "R/W",
+    "G/W",
+    "G/U",
+    # Phyrexian hybrids -- one of two colours, or 2 life. All ten colour pairs exist.
+    "B/G/P",
+    "B/R/P",
+    "G/U/P",
+    "G/W/P",
+    "R/G/P",
+    "R/W/P",
+    "U/B/P",
+    "U/R/P",
+    "W/B/P",
+    "W/U/P",
+    # Colorless hybrids.
+    "C/W",
+    "C/U",
+    "C/B",
+    "C/R",
+    "C/G",
+    # Twobrid.
+    "2/W",
+    "2/U",
+    "2/B",
+    "2/R",
+    "2/G",
+    # Phyrexian.
+    "W/P",
+    "U/P",
+    "B/P",
+    "R/P",
+    "G/P",
+    "C/P",
+)
+
+# Every SPELLING that names one of those symbols, mapped to the spelling Scryfall answers with.
+#
+# A two-part hybrid may be written either way round and comes back canonical -- measured one request
+# each on 2026-08-28, once per family: `{U/W}`->`{W/U}`, `{W/2}`->`{2/W}`, `{P/W}`->`{W/P}`,
+# `{W/C}`->`{C/W}`. A three-part one may NOT: `{U/W/P}` and `{P/W/U}` are both 422s where `{W/U/P}`
+# parses, so the ten Phyrexian hybrids are accepted only as spelled above.
+_HYBRID_CANONICAL = {
+    spelling: symbol
+    for symbol in _HYBRID_SYMBOLS
+    for spelling in ((symbol, "/".join(reversed(symbol.split("/")))) if symbol.count("/") == 1 else (symbol,))
+}
+
+# The order pips are EMITTED in: `GET /symbology` catalog order, for everything a cost can carry
+# besides generic and variable pips (fetched 2026-08-28).
+#
+# Measured, one request per row on 2026-08-28, each written both ways round to prove it is a sort and
+# not the writing order::
+#
+#     ?cost={G}{G/W}{W}    {G/W}{G}{W}     a hybrid comes out ahead of a plain pip of its colour
+#     ?cost={W}{HW}        {HW}{W}         so does a half pip
+#     ?cost={R}{HR}{R/W}   {R/W}{HR}{R}    and a hybrid comes out ahead of a half pip
+#     ?cost={W}{C/P}       {C/P}{W}        a colourless hybrid sorts with the hybrids, not at the end
+#     ?cost={S}{C}         {C}{S}          the colorless pips have an order of their own
+#
+# Between two hybrids it is THIS list's order and not the colour order, which is the one thing a
+# colour-rank sort cannot express: `{G/W}{W/U}` answers `{W/U}{G/W}` and `{G/U}{W/B}` answers
+# `{W/B}{G/U}`, both of which put the later colour first. Same for half pips: `{HR}{HW}` answers
+# `{HW}{HR}` though Boros orders R before W.
+#
+# The five PLAIN colour pips are the exception, and the only one: `RUW` answers `{U}{R}{W}`, so they
+# come out in canonical colour order rather than catalog order. They occupy five consecutive catalog
+# slots, so ranking them within that block says exactly that -- see `_PLAIN_PIP_AT`.
+_PIP_ORDER = (*_HYBRID_SYMBOLS, "HW", "HR", "W", "U", "B", "R", "G", "C", "S")
+_PIP_INDEX = {symbol: index for index, symbol in enumerate(_PIP_ORDER)}
+_PLAIN_PIP_AT = _PIP_INDEX["W"]
+
+# How many CHARACTERS of the joined fragment list the error names before Scryfall cuts it.
+#
+# 51, and it is characters rather than bytes -- measured across nine lengths on 2026-08-16: 51 `a`s
+# come back whole and 52 come back as 51, while 51 `é`s (102 bytes) also come back whole and 60 come
+# back as 51 characters / 102 bytes. The cut applies to the WHOLE joined list rather than per
+# fragment: ten separate `{QQQQQQQQ}` tokens come back as 51 characters of the concatenation. There
+# is no ellipsis, unlike `/cards/collection`'s 30-character echo -- the string simply stops. 51 is an
+# odd bound and nothing here explains it, which is why the measurement travels with the constant.
+_FRAGMENT_ECHO_LIMIT = 51
+
+
+class ManaCostError(ValueError):
+    """A fragment of the cost could not be understood as mana."""
+
+
+class _UnparseableSymbolError(Exception):
+    """One token is not mana. Internal; never raised out of this module.
+
+    The message Scryfall sends names **every** unparseable fragment of the cost at once ("The
+    string fragment(s) ..."), so the fragments have to be collected before any error can be worded.
+    Raising the finished ``ManaCostError`` from ``_symbol_value`` reported only the first, and
+    reported it re-braced: ``?cost=!!!`` came back as ``“{!}”`` where api.scryfall.com says ``“!!!”``.
+    """
+
+
+def _canonical_colors(colors: set[str]) -> list[str]:
+    """Order a colour set the way Magic writes it.
+
+    Every canonical ordering — allied pairs, enemy pairs, shards, wedges, four-colour runs and
+    WUBRG itself — is a walk around the colour wheel taking a constant number of steps: one step for
+    anything contiguous (`{G}{W}` for Selesnya, `{W}{U}{B}` for Esper), two for the arrangements that
+    are not (`{R}{W}` for Boros, `{U}{R}{W}` for Jeskai). Trying step 1 before step 2, and starting
+    points in WUBRG order, picks the same arrangement Scryfall does for all 31 colour combinations.
+
+    Args:
+        colors: The colours present, in any order.
+
+    Returns:
+        The colours in canonical order.
+    """
+    if not colors:
+        return []
+    wanted = {_COLOR_INDEX[color] for color in colors}
+    for step in (1, 2):
+        for start in range(len(_WUBRG)):
+            walk = [(start + offset * step) % len(_WUBRG) for offset in range(len(wanted))]
+            if set(walk) == wanted:
+                return [_WUBRG[index] for index in walk]
+    # Unreachable for any subset of WUBRG, but a colour set that is not one must still come back
+    # deterministically rather than as None.
+    return [color for color in _WUBRG if color in colors]
+
+
+def _symbol_value(symbol: str) -> float:
+    """The mana value one braced symbol contributes.
+
+    Args:
+        symbol: The symbol's inside, without braces, uppercased.
+
+    Returns:
+        Its contribution to the total.
+
+    Raises:
+        ManaCostError: If the symbol is not mana at all.
+    """
+    if symbol.isdigit():
+        return float(symbol)
+    if symbol in _VARIABLE_PIPS:
+        return 0.0
+    if symbol in _HALF_SYMBOLS:
+        return _HALF_MANA
+    if "/" in symbol:
+        # A hybrid parses if and only if it is one of the 36 symbols Scryfall lists -- see
+        # _HYBRID_SYMBOLS for why the inventory rather than a rule about the halves.
+        canonical = _HYBRID_CANONICAL.get(symbol)
+        if canonical is None:
+            raise _UnparseableSymbolError
+        # A hybrid is worth its most expensive part: {2/W} is 2, {W/U}, {W/U/P} and {C/P} are 1.
+        return max(float(part) if part.isdigit() else 1.0 for part in canonical.split("/"))
+    if symbol in _COLORLESS_PIPS or symbol in _COLOR_INDEX:
+        return 1.0
+    raise _UnparseableSymbolError
+
+
+def _symbol_colors(symbol: str) -> set[str]:
+    """The colours one braced symbol contributes.
+
+    Args:
+        symbol: The symbol's inside, without braces, uppercased.
+
+    Returns:
+        The colours it produces; empty for generic, variable and colorless pips.
+    """
+    return {part for part in re.split(r"[/]", symbol.removeprefix("H")) if part in _COLOR_INDEX}
+
+
+class _Token(NamedTuple):
+    """One symbol, plus how it was written -- which the error wording needs and the rules do not."""
+
+    symbol: str
+    """The symbol's inside, brace-stripped and uppercased. Every parsing rule reads this."""
+    spelling: str
+    """How it was WRITTEN, uppercased: a braced token keeps its braces, a bare character does not."""
+    braced: bool
+    """True for a braced token, which is what stops `!!` and `{!}{!}` merging into one fragment."""
+
+
+def _tokenize(raw: str) -> list[_Token]:
+    """Split a written cost into braced-symbol contents.
+
+    Unbraced runs are read a character at a time, except for digits, which group so `11R` is
+    `{11}{R}` rather than `{1}{1}{R}`.
+
+    Args:
+        raw: The cost as written.
+
+    Returns:
+        One entry per symbol.
+    """
+    tokens: list[_Token] = []
+    position = 0
+    upper = raw.upper()
+    while position < len(upper):
+        braced = _BRACED.match(upper, position)
+        if braced:
+            tokens.append(_Token(braced.group(1).strip(), braced.group(0), braced=True))
+            position = braced.end()
+            continue
+        char = upper[position]
+        if char.isdigit():
+            digits = re.match(r"\d+", upper[position:]).group(0)
+            tokens.append(_Token(digits, digits, braced=False))
+            position += len(digits)
+            continue
+        if not char.isspace():
+            tokens.append(_Token(char, char, braced=False))
+        position += 1
+    return tokens
+
+
+def _reported_fragment(token: _Token) -> str:
+    """How Scryfall names a part of the cost it could not read.
+
+    Measured one request per row against api.scryfall.com on 2026-08-16::
+
+        ?cost=!!!       “!!!”     three bare characters, reported as ONE run
+        ?cost=é         “É”       uppercased, and reported as itself rather than re-braced
+        ?cost={QQQ}     “{QQQ}”   a braced token keeps its braces
+        ?cost={}        “{}”      including the empty one
+        ?cost={W/U/B}   “{//}”    the RECOGNIZED halves are struck out and the residue reported
+
+    The last row is the rule the others are a degenerate case of: what comes back is the fragment
+    with everything Scryfall could read removed. `{QQQ}` keeps all three Qs because none of them is
+    a symbol; `{W/U/B}` keeps only its punctuation.
+
+    What counts as "could read" is exactly the ten ONE-CHARACTER mana symbols -- the five colours,
+    `{C}`, `{S}` and the three variables. `P`, `H` and digits are NOT struck, which this used to get
+    wrong by inferring the set from what the parser prices rather than measuring it. Five more rows,
+    one request each on 2026-08-28, all of them costs the inventory above now rejects::
+
+        ?cost={U/W/P}   “{//P}”    a Phyrexian hybrid spelled backwards -- the P survives
+        ?cost={2/W/P}   “{2//P}”   and so does the generic half
+        ?cost={3/W}     “{3/}”     there is no {3/W}; only {2/X} twobrids exist
+        ?cost={H/W}     “{H/}”     H survives too
+        ?cost={HB}      “{H}”      there is no {HB} either; only {HW} and {HR}
+
+    Args:
+        token: The token that could not be parsed.
+
+    Returns:
+        The fragment as Scryfall would name it.
+    """
+    if not token.braced:
+        return token.spelling
+    residue = "".join(
+        char for char in token.symbol if char not in _COLOR_INDEX and char not in _COLORLESS_PIPS and char not in _VARIABLE_PIPS
+    )
+    return f"{{{residue}}}"
+
+
+def parse_mana_cost(raw: str) -> dict[str, Any]:
+    """Build Scryfall's ManaCost object for a written cost.
+
+    Args:
+        raw: The cost as the client wrote it.
+
+    Returns:
+        The ManaCost object.
+
+    Raises:
+        ManaCostError: If a fragment is not mana.
+    """
+    tokens = _tokenize(raw or "")
+
+    generic = 0
+    variables: list[str] = []
+    # One list for every pip that is neither generic nor variable -- colored, colorless and hybrid
+    # alike -- because their emission order is one catalog order and not three buckets: `{W}{C/P}`
+    # answers `{C/P}{W}`, so a colourless hybrid comes out AHEAD of a coloured pip.
+    pips: list[str] = []
+    color_set: set[str] = set()
+    total = 0.0
+
+    # EVERY unparseable fragment is collected before any error is raised, because Scryfall's message
+    # names them all at once -- CONCATENATED IN ORDER WITH NO SEPARATOR, and the readable symbols
+    # between them do not separate them either. Measured 2026-08-16, one request per row::
+    #
+    #     ?cost={Q}W{T}   “{Q}{T}”   the readable {W} between them leaves no trace
+    #     ?cost=!W!       “!!”       same, for bare characters
+    #     ?cost=!{Q}!     “!{Q}!”    braced and bare interleave in written order
+    #     ?cost=a{Q}b     “A{Q}”     `b` is BLACK MANA and readable, so only two fragments
+    #
+    # An earlier pass joined the fragments with a space, which no measurement supported and which
+    # `{Q}W{T}` disproves. One accumulated string is now the whole mechanism -- with an empty
+    # separator there is nothing left for a per-fragment merge rule to do.
+    bad = ""
+    for token in tokens:
+        try:
+            total += _symbol_value(token.symbol)
+        except _UnparseableSymbolError:
+            bad += _reported_fragment(token)
+            continue
+        color_set |= _symbol_colors(token.symbol)
+        if token.symbol.isdigit():
+            generic += int(token.symbol)
+        elif token.symbol in _VARIABLE_PIPS:
+            variables.append(token.symbol)
+        else:
+            # A hybrid is emitted in the spelling Scryfall answers with, not the one it was written in.
+            pips.append(_HYBRID_CANONICAL.get(token.symbol, token.symbol))
+
+    if bad:
+        msg = f"The string fragment(s) “{bad[:_FRAGMENT_ECHO_LIMIT]}” could not be understood as part of mana cost."
+        raise ManaCostError(msg)
+
+    colors = _canonical_colors(color_set)
+    # An empty cost is null, but a cost that was written and happens to be free is `{0}`: Scryfall
+    # answers `cost=` with null and `cost=0` with "{0}", so the two cannot share a branch.
+    cost = _render_cost(variables, generic, pips, colors) if tokens else None
+
+    return {
+        "object": "mana_cost",
+        "cost": cost,
+        "colors": [color for color in _WUBRG if color in color_set],
+        "cmc": total,
+        "colorless": not color_set,
+        "monocolored": len(color_set) == 1,
+        "multicolored": len(color_set) > 1,
+    }
+
+
+def _render_cost(
+    variables: list[str],
+    generic: int,
+    pips: list[str],
+    colors: list[str],
+) -> str | None:
+    """Assemble the normalized cost string.
+
+    Args:
+        variables: X/Y/Z pips, in the order written.
+        generic: Summed generic mana.
+        pips: Every other symbol, in the order written.
+        colors: The canonical colour order the five plain colour pips come out in.
+
+    Returns:
+        The normalized cost. A cost whose symbols all cancel to nothing renders as `{0}`.
+    """
+    rank = {color: index for index, color in enumerate(colors)}
+
+    def sort_key(symbol: str) -> int:
+        # Catalog order, with the five plain colour pips ranked inside their own block of the
+        # catalog so that they alone come out in canonical colour order. Every pip that reaches here
+        # is a symbol Scryfall lists, so the lookup always hits.
+        if symbol in rank:
+            return _PLAIN_PIP_AT + rank[symbol]
+        return _PIP_INDEX.get(symbol, len(_PIP_ORDER))
+
+    ordered = sorted(pips, key=sort_key)
+    # Variables come out in X, Y, Z order regardless of how they were written, and repeats group:
+    # `?cost=xyzzy` is `{X}{Y}{Y}{Z}{Z}` on api.scryfall.com (measured 2026-08-16) where writing
+    # order gives `{X}{Y}{Z}{Z}{Y}`. A plain sort does both at once -- the alphabet and the pip
+    # order coincide.
+    parts = [f"{{{symbol}}}" for symbol in sorted(variables)]
+    if generic:
+        parts.append(f"{{{generic}}}")
+    parts.extend(f"{{{symbol}}}" for symbol in ordered)
+    return "".join(parts) or "{0}"
diff --git a/api/scryfall_compat/objects.py b/api/scryfall_compat/objects.py
new file mode 100644
index 000000000..bfc949382
--- /dev/null
+++ b/api/scryfall_compat/objects.py
@@ -0,0 +1,798 @@
+"""Scryfall response objects: card reconstruction, envelopes, and the text rendering.
+
+Everything here is pure — dicts in, dicts out — so the payload shape can be tested without a
+database or a request. `routes.py` owns the HTTP and SQL sides.
+
+The one subtle piece is `to_scryfall_card`. `cards.raw_card_blob` holds the card object Scryfall
+sent, but not quite untouched: `preprocess_card` adds three internal keys to it and normalizes an
+absent `flavor_text` to `""`. Both are exactly reversible, and reversing them is the whole of the
+function.
+
+There is no column holding a pristine copy alongside it, and there deliberately isn't one: the blob
+being answerable is a property of the importer, maintained there rather than worked around here.
+The one case where the blob is *not* the card — a multi-face row written before the merged-row work
+— is handled as a fallback rather than as a stored duplicate, because it is a fixed window that one
+import closes.
+"""
+
+from __future__ import annotations
+
+import datetime
+import re
+import string
+import urllib.parse
+import uuid
+from typing import Any
+
+# Keys `preprocess_card` adds to the object it snapshots into raw_card_blob. Stripping them, and
+# undoing the flavor_text normalization below, inverts the snapshot. A multi-face row carries only
+# `card_name`; a single-face one carries all three.
+_IMPORTER_ADDED_KEYS = ("card_name", "face_name", "face_idx")
+
+# The `version` vocabulary of the image format -- SIX names, not the eleven `image_uris` carries.
+#
+# The two lists used to be the same list, and are not any more: Scryfall's `image_uris` gained five
+# webp sizes (see _IMAGE_EXTENSIONS) that `version=` does not accept. Measured against
+# api.scryfall.com on 2026-08-16 -- `?format=image&version=thumb` redirects to the LARGE jpg, byte
+# for byte the same fallback `version=bogus` gets, and the same for grid/display/art/crop. So these
+# five are emitted as URLs and refused as parameters, and widening this tuple to match the other
+# would silently change five 302 targets.
+IMAGE_VERSIONS = ("small", "normal", "large", "png", "art_crop", "border_crop")
+DEFAULT_IMAGE_VERSION = "large"
+
+# Scryfall pages every card list at 175, and clients page by following `next_page` rather than by
+# computing offsets, so this has to match or a client's page count silently disagrees with ours.
+PAGE_SIZE = 175
+
+# Scryfall caps a collection POST at 75 identifiers and 422s past it.
+MAX_COLLECTION_IDENTIFIERS = 75
+
+# Scryfall caps an autocomplete catalog at 20 names.
+MAX_AUTOCOMPLETE_VALUES = 20
+
+
+# Every field the engine must return for a card object to be assembled. Passed as `fields=` on each
+# lookup, so the engine emits exactly this and nothing is fetched that is never read.
+CARD_OBJECT_FIELDS = (
+    "name", "scryfall_id", "oracle_id", "layout", "mana_cost", "cmc", "type_line", "oracle_text",
+    "power", "toughness", "loyalty", "colors", "color_identity", "card_keywords", "set_code", "set_name",
+    "collector_number", "rarity", "flavor_text", "artist", "illustration_id", "released_at",
+    "legalities", "edhrec_rank", "price_usd", "price_eur", "price_tix", "watermark",
+    "card_frame_data", "card_is_tags", "border_color", "frame",
+    "lang", "image_status", "set_type", "security_stamp", "set_id", "arena_id", "mtgo_id",
+    "mtgo_foil_id", "tcgplayer_id", "tcgplayer_etched_id", "cardmarket_id", "penny_rank",
+    "image_updated_at", "price_usd_foil", "price_usd_etched", "price_eur_foil", "multiverse_ids",
+    "promo_types", "frame_effects", "games", "finishes", "booster", "digital", "foil", "nonfoil",
+    "full_art", "highres_image", "oversized", "promo", "reprint", "story_spotlight", "textless",
+    "variation", "card_faces", "all_parts",
+)  # fmt: skip
+
+# Scryfall's card back, one image for every normal card.
+CARD_BACK_ID = "0aeebaf5-8c7d-4636-9e82-8c27447861f7"
+
+# The file extension each `image_uris` size is served as, in Scryfall's own key order.
+#
+# ELEVEN, not the six this module shipped with. Scryfall added five webp sizes -- `thumb`, `grid`,
+# `display`, `art`, `crop` -- and every card object it serves carries all eleven; a six-key
+# `image_uris` differed from Scryfall on every card object emitted.
+#
+# Unconditional, and measured that way: across all 540,484 printings in the 2026-08-16 all_cards
+# bulk, `image_uris` is either wholly ABSENT (8,444 cards, 7,641 faces -- the layouts whose picture
+# lives on the other level) or carries exactly these eleven keys in exactly this order. No card,
+# face, layout or `image_status` carries a partial set, so there is no per-key conditionality to
+# round-trip the way `printed_*` has.
+#
+# Derived, not stored: the same scan confirms all eleven URLs are the same pure function of the id
+# and the face on every one of the 548,604 objects that has them -- `art_crop` and `art` are
+# different sizes of one path, not a stored pair. These five cost zero storage, which is why they
+# are a table and not a column.
+_IMAGE_EXTENSIONS = {
+    "small": "jpg",
+    "normal": "jpg",
+    "large": "jpg",
+    "png": "png",
+    "art_crop": "jpg",
+    "border_crop": "jpg",
+    "thumb": "webp",
+    "grid": "webp",
+    "display": "webp",
+    "art": "webp",
+    "crop": "webp",
+}
+
+# magic.cards column -> the engine's name for the same value. The columns predate the engine, and
+# `to_scryfall_card` reads engine names.
+_SQL_COLUMN_ALIASES = {
+    "card_name": "name",
+    "card_set_code": "set_code",
+    "mana_cost_text": "mana_cost",
+    "card_legalities": "legalities",
+    "card_layout": "layout",
+    "card_watermark": "watermark",
+    "card_artist": "artist",
+    "card_border": "border_color",
+}
+
+_RARITY_BY_INT = {0: "common", 1: "uncommon", 2: "rare", 3: "mythic", 4: "special", 5: "bonus"}
+
+
+def sql_row_to_engine_row(row: dict[str, Any]) -> dict[str, Any]:
+    """Reshape a `magic.cards` row into the shape the engine emits.
+
+    There is ONE card-object builder and both paths go through it; this is what lets the SQL
+    fallback use it. Two builders would be two chances to disagree with Scryfall, and a fallback is
+    where a different answer is least affordable — it runs when the engine is already in trouble.
+
+    Building from `raw_card_blob` instead is not an option: for a multi-face row the blob is the
+    FRONT FACE, not the card, so it would silently degrade exactly the cards the merge exists to fix.
+
+    Args:
+        row: A row selected with routes._CARD_COLUMNS.
+
+    Returns:
+        The same values under the engine's field names, with the compat residue flattened.
+    """
+    out: dict[str, Any] = {}
+    for column, value in row.items():
+        if column in ("card_compat_blob", "raw_card_blob", "card_colors", "card_color_identity"):
+            continue
+        # psycopg binds dates and uuids as objects; JSON carries neither, and the engine path
+        # already emits strings. Normalizing here is what keeps ONE builder viable.
+        if isinstance(value, datetime.date):
+            normalized: Any = value.isoformat()
+        elif isinstance(value, uuid.UUID):
+            normalized = str(value)
+        else:
+            normalized = value
+        out[_SQL_COLUMN_ALIASES.get(column, column)] = normalized
+
+    # jsonb objects store these as {key: true} sets; the engine emits lists.
+    for target, column in (("colors", "card_colors"), ("color_identity", "card_color_identity")):
+        value = row.get(column)
+        out[target] = sorted(value) if isinstance(value, dict) else []
+    for key in ("card_keywords", "card_is_tags"):
+        if isinstance(row.get(key), dict):
+            out[key] = sorted(row[key])
+
+    if row.get("card_rarity_int") is not None:
+        out["rarity"] = _RARITY_BY_INT.get(row["card_rarity_int"])
+
+    # The residue is one column here and individual fields on an engine row.
+    out.update(row.get("card_compat_blob") or {})
+    return out
+
+
+def _image_uris(scryfall_id: str, updated_at: int | None, face: str = "front") -> dict[str, str]:
+    """Build the CDN URLs for one face.
+
+    Scryfall's paths are a pure function of the card id: its first two hex digits become directory
+    levels, and `image_updated_at` rides as a cache-buster. Nothing about these is stored.
+    """
+    scryfall_id = str(scryfall_id or "")
+    if not scryfall_id:
+        return {}
+    suffix = f"?{updated_at}" if updated_at else ""
+    first, second = scryfall_id[0], scryfall_id[1]
+    return {
+        size: f"https://cards.scryfall.io/{size}/{face}/{first}/{second}/{scryfall_id}.{ext}{suffix}"
+        for size, ext in _IMAGE_EXTENSIONS.items()
+    }
+
+
+# Characters Scryfall DELETES from a slug rather than hyphenating. Live-derived: "Erayo's Essence"
+# slugs to `erayos-essence` (not `erayo-s-essence`), "S.H.I.E.L.D." to `shield`, `Henzie "Toolbox"
+# Torre` to `henzie-toolbox-torre`, and the zhs printings of Kongming/Pang Tong pin the curly
+# quotes. U+201E ("bottom quote") is NOT deleted -- `Henzie ,,Der Beschaffer" Torre` (de) keeps it.
+_SLUG_DELETED = frozenset("'\",./\u201c\u201d")
+
+# Slug bytes served literally; every other byte is UTF-8 percent-encoded, uppercase hex. The literal
+# set is exactly what appears un-encoded across the bulk corpus; `?` is the one ASCII special
+# observed encoded. Unobserved characters encode, which can never break a URL.
+_SLUG_LITERAL = frozenset(string.ascii_letters + string.digits + "!&()+-:;=_")
+
+# The languages Scryfall writes into the scryfall_uri path -- its ten print localizations, exactly.
+# The glyph and novelty languages (ph, qya, he, la, grc, ar, sa, dw) get NO path segment: a ph Elesh
+# Norn lives at `/card/one/414/elesh-norn-mother-of-machines`, English form.
+_SLUG_LANG_SEGMENTS = frozenset({"de", "es", "fr", "it", "ja", "ko", "pt", "ru", "zhs", "zht"})
+
+
+def _slug(name: str) -> str:
+    """Scryfall's URL slug for a card name.
+
+    NOT the folklore "non-alphanumerics collapse to hyphens" rule this used to carry -- that
+    hyphenates apostrophes (`erayo-s-essence`) and serves raw UTF-8 (`jötun-grunt`) where production
+    Scryfall deletes the apostrophe and percent-encodes the bytes. The real rule, verified against
+    the `scryfall_uri` of all 540,484 printings in the 2026-08-16 all_cards bulk (zero mismatches):
+
+      1. lowercase;
+      2. DELETE `' " , . /` and the curly quotes U+201C/U+201D;
+      3. each run of ASCII spaces becomes one hyphen -- literal hyphens pass through and may stack
+         (ru "Пламенник - военный разведчик" keeps `---`), and nothing is trimmed ("Humming-" and
+         "With Great Power . . ." both keep their trailing hyphen);
+      4. everything else survives verbatim (`:`, `!`, `&`, and CJK punctuation) and is then UTF-8
+         percent-encoded per _SLUG_LITERAL.
+    """
+    cleaned = "".join(c for c in name.lower() if c not in _SLUG_DELETED)
+    hyphenated = re.sub(" +", "-", cleaned)
+    return "".join(
+        chr(b) if chr(b) in _SLUG_LITERAL else f"%{b:02X}" for b in hyphenated.encode("utf-8")
+    )
+
+
+def _scryfall_uri(name: str, set_code: str, number: str, lang: str) -> str:
+    """`https://scryfall.com/card/{set}/{number}[/{lang}]/{slug}?utm_source=api`.
+
+    A foreign printing keeps the language segment and takes the plain English slug (ody/243/zhs ->
+    `/zhs/holistic-wisdom`, verified live). Scryfall also writes a
+    `slug(printed name)-(slug(english name))` path where it HAS a printed name (grn/212/pt is
+    `ego-%C3%A0-deriva-(unmoored-ego)`); reproducing that needs the printed name, which the card
+    row does not carry yet, and the English fallback is what it serves until then.
+    """
+    segment = f"{lang}/" if lang in _SLUG_LANG_SEGMENTS else ""
+    return f"https://scryfall.com/card/{set_code}/{number}/{segment}{_slug(name)}?utm_source=api"
+
+
+# The layouts Scryfall gives TWO images to -- the ones that are two pieces of cardboard, or a
+# front and a back. Everything else with `card_faces` (split, flip, adventure, prepare) is ONE
+# image, and its faces must NOT get per-face image_uris: doing so invents a `.../back/...` URL with
+# no image behind it. Verified exhaustively against the 2026-08-16 all_cards bulk, zero exceptions
+# in either direction. These layouts also keep `colors`, `card_back_id` and `illustration_id` on
+# their faces alone.
+_TWO_IMAGE_LAYOUTS = frozenset({"art_series", "double_faced_token", "modal_dfc", "reversible_card", "transform"})
+
+# A REVERSIBLE printing keeps NOTHING of the card at top level -- not even the three keys every
+# other multi-face layout keeps. Measured across the whole 2026-08-16 all_cards bulk: all 81 omit
+# `oracle_id`, `cmc` and `type_line`, where a `transform` printing sends all three. Its FACES carry
+# the card's `oracle_id` and `cmc` instead, 0 of 81 disagreeing, so omitting them loses nothing.
+_REVERSIBLE_LAYOUT = "reversible_card"
+
+# The layouts a SEARCH LINK spells with the JOINED name -- `related_uris.edhrec` and all three
+# marketplace fallbacks in `purchase_uris`, which take one and the same string. Every other
+# multi-face layout searches the FRONT face -- verified card for card against api.scryfall.com.
+#
+# THE MARKETPLACES SPLIT THE SAME WAY, which is why this is no longer edhrec's list alone. Measured
+# on api.scryfall.com 2026-08-31 over `unique=prints`, on the first printing of each card whose ids
+# are MISSING so the SEARCH form is what gets emitted, reading the tcgplayer term out of the `u=`
+# parameter of Scryfall's own partner redirect:
+#
+#   split               Bind // Liberate                      cmb2/88   cardhoarder `Bind // Liberate`
+#   reversible_card     Mechtitan // Mechtitan                sld/1969  cardhoarder `Mechtitan // Mechtitan`
+#   double_faced_token  Snake // Zombie                       cc2/9     all three, `Snake // Zombie`
+#   split               Who // What // When // Where // Why   und/75    cardhoarder the whole name
+#   adventure           Champions of Archery // Join the …    ph19/4    `Champions of Archery`
+#   flip                Curse of the Fire Penguin // …        unh/73    `Curse of the Fire Penguin`
+#   art_series          Aang and Katara // Aang and Katara    atle/8    `Aang and Katara`
+#   transform           Delver of Secrets // Insectile …      sld/2367  `Delver of Secrets`
+#
+# The two `tcgplayer_infinite_*` searches in `related_uris` are the exception that stays: they take
+# the joined name on EVERY layout, so those two and this are deliberately not one string.
+_JOINED_SEARCH_LAYOUTS = frozenset({"double_faced_token", "reversible_card", "split"})
+
+
+def _related_uris(name: str, search_name: str, multiverse_ids: list[Any], lang: str) -> dict[str, str]:
+    """Scryfall's `related_uris`, pointing at the destinations directly.
+
+    Scryfall wraps the TCGplayer entries in `partner.tcgplayer.com/...?u=<encoded real URL>` with
+    its own affiliate code. The destination is the same page, and emitting the wrapper from this
+    host would route another service's affiliate revenue to Scryfall.
+
+    `gatherer` LEADS the object when the printing has multiverse ids, built from the FIRST id, with
+    `printed=true` for every non-English printing and `printed=false` for English -- verified
+    against the bulk corpus at 540,430 of 540,484 printings. The 54 exceptions are foreign-only
+    promos (dd2-ja, snc launch, one-ph, ltc-qya) whose Gatherer entries carry no translation; that
+    fact lives on Scryfall's side of the wire and is not derivable from the row.
+    """
+    out: dict[str, str] = {}
+    first_id = multiverse_ids[0] if multiverse_ids else None
+    if isinstance(first_id, int):
+        printed = "false" if lang == "en" else "true"
+        out["gatherer"] = (
+            f"https://gatherer.wizards.com/Pages/Card/Details.aspx?multiverseid={first_id}&printed={printed}"
+        )
+    quoted = urllib.parse.quote_plus(name)
+    out["tcgplayer_infinite_articles"] = (
+        f"https://www.tcgplayer.com/search/articles?productLineName=magic&q={quoted}"
+    )
+    out["tcgplayer_infinite_decks"] = f"https://www.tcgplayer.com/search/decks?productLineName=magic&q={quoted}"
+    out["edhrec"] = f"https://edhrec.com/route/?cc={urllib.parse.quote_plus(search_name)}"
+    return out
+
+
+def _purchase_uris(row: dict[str, Any], search_name: str) -> dict[str, str]:
+    """Scryfall's `purchase_uris`, product links where the ids exist and name searches where not.
+
+    Rebuilt from the marketplace ids -- or, for a key whose id this printing does not have, from a
+    NAME SEARCH on that marketplace. Same affiliate reasoning as `_related_uris`.
+
+    All three keys are always present. The fallback is per KEY, not per card: an English printing
+    with TCGplayer and Cardmarket ids but no MTGO id gets two product links and a cardhoarder
+    search (verified live across khm). Every foreign printing takes the search form on all three --
+    marketplace product ids belong to the English printing. Emitting nothing was the alternative,
+    and it made `purchase_uris` an empty object on 426,416 printings.
+
+    `search_name` IS `_related_uris`' -- the caller decides the string, and all three marketplaces
+    split by layout exactly the way edhrec does (the measurements are on _JOINED_SEARCH_LAYOUTS).
+    This took the joined name and cut the front face off it here, on EVERY layout, which searched
+    for `Snake // Zombie` (cc2/9) as `Snake` and `Who // What // When // Where // Why` (und/75) as
+    `Who` against a Scryfall that spells both whole. On a transforming card the front face is still
+    right -- `Invasion of Alara`, not `Invasion of Alara // Awaken the Maelstrom` -- because there
+    the joined string matches no product.
+    """
+    q = urllib.parse.quote_plus(search_name)
+    tcg, cm, mtgo = row.get("tcgplayer_id"), row.get("cardmarket_id"), row.get("mtgo_id")
+    return {
+        "tcgplayer": (
+            f"https://www.tcgplayer.com/product/{tcg}?page=1"
+            if tcg
+            else f"https://www.tcgplayer.com/search/magic/product?productLineName=magic&q={q}&view=grid"
+        ),
+        "cardmarket": (
+            f"https://www.cardmarket.com/en/Magic/Products?idProduct={cm}"
+            if cm
+            else f"https://www.cardmarket.com/en/Magic/Products/Search?searchString={q}"
+        ),
+        "cardhoarder": (
+            f"https://www.cardhoarder.com/cards/{mtgo}"
+            if mtgo
+            else f"https://www.cardhoarder.com/cards?data%5Bsearch%5D={q}"
+        ),
+    }
+
+
+def _prices(row: dict[str, Any]) -> dict[str, Any]:
+    """Scryfall's `prices` object: the three price columns plus the three residue variants."""
+
+    def fmt(value: float | None) -> str | None:
+        return None if value is None else f"{float(value):.2f}"
+
+    return {
+        "usd": fmt(row.get("price_usd")),
+        "usd_foil": fmt(row.get("price_usd_foil")),
+        "usd_etched": fmt(row.get("price_usd_etched")),
+        "eur": fmt(row.get("price_eur")),
+        "eur_foil": fmt(row.get("price_eur_foil")),
+        "tix": fmt(row.get("price_tix")),
+    }
+
+
+def _faces(row: dict[str, Any], *, two_image: bool, reversible: bool) -> list[dict[str, Any]]:
+    """The card's faces, with the keys the engine deliberately does not store re-added.
+
+    `object` is the constant "card_face", and a face's `image_uris` is the card's CDN function with
+    front/back swapped, so neither is worth archive space.
+
+    `image_uris` is gated on the LAYOUT rather than on the face count: only a two-image layout has
+    a second picture, and giving one to a split or adventure face invents a URL with nothing behind
+    it. An empty `mana_cost` or `oracle_text` on a face is a VALUE, not an omission -- every face
+    of every multi-face printing in the corpus carries both keys (8,620 of 8,620 transform faces,
+    4,356 of them with an empty cost), so an empty string there is a costless back face.
+    """
+    faces = row.get("card_faces") or []
+    out = []
+    for index, face in enumerate(faces):
+        built: dict[str, Any] = {"object": "card_face"}
+        built.update(
+            {
+                key: value
+                for key, value in face.items()
+                if value is not None and (value not in ("", []) or key in ("mana_cost", "oracle_text"))
+            }
+        )
+        if reversible:
+            # Both faces of a reversible printing carry the CARD's oracle_id and cmc.
+            built.setdefault("oracle_id", str(row.get("oracle_id") or ""))
+            built.setdefault("cmc", _decimal(row.get("cmc")))
+        if two_image:
+            built["image_uris"] = _image_uris(
+                row.get("scryfall_id", ""),
+                row.get("image_updated_at"),
+                "front" if index == 0 else "back",
+            )
+        out.append(built)
+    return out
+
+
+def _decimal(value: float | int | None) -> float | None:
+    """Carry a mana value as the DECIMAL Scryfall types it as.
+
+    api.scryfall.com answers `"cmc":1.0`, not `"cmc":1` — check
+    https://api.scryfall.com/cards/named?exact=Lightning+Bolt. The field is decimal because
+    fractional mana values are real: Little Girl costs {HW} and answers `"cmc":0.5`
+    (https://api.scryfall.com/cards/named?exact=Little+Girl). A whole-numbered mana value therefore
+    still serializes with its decimal point, and `magic.cards.cmc` being an `integer` column is what
+    made this service answer `1` instead.
+
+    That column is also why the underlying 0.5 cannot be stored at all today; changing its type is a
+    migration and belongs on its own, and nothing that half-mana exists in is imported. This keeps
+    the SERIALIZATION honest in the meantime, which is what a client comparing against Scryfall
+    sees.
+
+    Args:
+        value: The stored mana value, or None. Typed narrowly rather than `Any` because this is the
+            one place the column's type matters: an `integer` column is exactly what produced the
+            wrong output.
+
+    Returns:
+        The value as a float, or None when the card has none.
+    """
+    return None if value is None else float(value)
+
+
+def to_scryfall_card(row: dict[str, Any], *, base_url: str = "https://api.scryfall.com") -> dict[str, Any]:
+    """Build the Scryfall card object for one engine row.
+
+    BUILDS rather than unwraps a stored copy, which is the whole reason /cards/* can be served from
+    the engine: an object assembled from columns is answerable from the store, while one recovered
+    from `raw_card_blob` is answerable only from Postgres — and Postgres is the fallback for when
+    the engine errors.
+
+    Three sources, and every one of Scryfall's keys comes from exactly one: 29 stored columns, 12
+    derived (every *_uri and image_uris, pure functions of the id/set/collector number/oracle id),
+    and the 33-key residue carried in card_compat_blob. Only `resource_id` is dropped — an
+    undocumented Scryfall internal with no stable meaning.
+
+    Args:
+        row: An engine row carrying CARD_OBJECT_FIELDS, or a SQL row through sql_row_to_engine_row.
+        base_url: The host self-referencing URIs should address.
+
+    Returns:
+        The card object. Keys Scryfall omits stay omitted rather than becoming null, because a
+        client comparing shapes would otherwise see a difference on every row.
+    """
+    # str() because a SQL row binds these as UUID objects while an engine row is already a string,
+    # and every derived URI slices the id.
+    scryfall_id = str(row.get("scryfall_id") or "")
+    oracle_id = str(row.get("oracle_id") or "")
+    name = row.get("name") or ""
+    set_code = row.get("set_code") or ""
+    number = row.get("collector_number") or ""
+    lang = row.get("lang") or "en"
+    layout = row.get("card_layout") or row.get("layout")
+    has_faces = bool(row.get("card_faces"))
+    # Only ever true for a card that HAS faces: the two-image layouts are all multi-face.
+    two_image = has_faces and layout in _TWO_IMAGE_LAYOUTS
+    reversible = layout == _REVERSIBLE_LAYOUT
+    faces = _faces(row, two_image=two_image, reversible=reversible)
+    # The name a SEARCH LINK spells: the joined one, except on the layouts whose searches take the
+    # front face (see _JOINED_SEARCH_LAYOUTS). `related_uris.edhrec` and every `purchase_uris`
+    # fallback take THIS string; the two `tcgplayer_infinite_*` links take the joined `name`.
+    search_name = name.split(" // ", 1)[0] if faces and layout not in _JOINED_SEARCH_LAYOUTS else name
+
+    card: dict[str, Any] = {
+        "object": "card",
+        "id": scryfall_id,
+        "oracle_id": oracle_id,
+        "multiverse_ids": row.get("multiverse_ids") or [],
+        "name": name,
+        "lang": lang,
+        "released_at": row.get("released_at"),
+        "uri": f"{base_url}/cards/{scryfall_id}",
+        "scryfall_uri": _scryfall_uri(name, set_code, number, lang),
+        "layout": row.get("card_layout") or row.get("layout"),
+        "highres_image": bool(row.get("highres_image")),
+        "image_status": row.get("image_status"),
+        "cmc": _decimal(row.get("cmc")),
+        "type_line": row.get("type_line"),
+        "colors": row.get("colors") or [],
+        "color_identity": row.get("color_identity") or [],
+        "keywords": row.get("card_keywords") or [],
+        "games": row.get("games") or [],
+        "reserved": "reserved" in (row.get("card_is_tags") or []),
+        "finishes": row.get("finishes") or [],
+        "oversized": bool(row.get("oversized")),
+        "promo": bool(row.get("promo")),
+        "reprint": bool(row.get("reprint")),
+        "variation": bool(row.get("variation")),
+        "set_id": row.get("set_id"),
+        "set": set_code,
+        "set_name": row.get("set_name"),
+        "set_type": row.get("set_type"),
+        "set_uri": f"{base_url}/sets/{row['set_id']}" if row.get("set_id") else None,
+        "set_search_uri": f"{base_url}/cards/search?order=set&q=e%3A{set_code}&unique=prints",
+        "scryfall_set_uri": f"https://scryfall.com/sets/{set_code}?utm_source=api",
+        "rulings_uri": f"{base_url}/cards/{scryfall_id}/rulings",
+        "prints_search_uri": f"{base_url}/cards/search?order=released&q=oracleid%3A{oracle_id}&unique=prints",
+        "collector_number": number,
+        "digital": bool(row.get("digital")),
+        "rarity": row.get("rarity"),
+        "card_back_id": CARD_BACK_ID,
+        "artist": row.get("artist"),
+        "illustration_id": str(row["illustration_id"]) if row.get("illustration_id") else None,
+        "border_color": row.get("border_color"),
+        "full_art": bool(row.get("full_art")),
+        "textless": bool(row.get("textless")),
+        "booster": bool(row.get("booster")),
+        "story_spotlight": bool(row.get("story_spotlight")),
+        "prices": _prices(row),
+        "related_uris": _related_uris(name, search_name, row.get("multiverse_ids") or [], lang),
+    }
+    # A printing NO MARKETPLACE SELLS omits the key rather than carrying three dead links. The
+    # rule is the marketplaces, not `digital` -- measured 2026-08-16: prm/80925 (games ["mtgo"],
+    # digital true) HAS purchase_uris and ymid/59 and khm/A-198 (games ["arena"], digital true) do
+    # not, so it is "paper or mtgo". An ABSENT `games` list emits: the omission is a positive claim
+    # about the printing rather than a gap.
+    games = row.get("games")
+    if games is None or not games or any(g in ("paper", "mtgo") for g in games):
+        card["purchase_uris"] = _purchase_uris(row, search_name)
+
+    # A two-image layout keeps `colors`, `card_back_id` and `illustration_id` on its FACES alone --
+    # there is no shared back and no card-level illustration when the card is two pictures --
+    # and Scryfall omits the top-level keys entirely rather than nulling them.
+    if two_image:
+        for key in ("colors", "card_back_id", "illustration_id"):
+            card.pop(key, None)
+    # ...and a reversible printing drops the three the other two-image layouts keep.
+    if reversible:
+        for key in ("oracle_id", "cmc", "type_line"):
+            card.pop(key, None)
+
+    # A multi-face card carries its faces and NOT the top-level text they replace; a single-faced
+    # one carries the text and no `card_faces`. Which keys sit at top level varies by LAYOUT, which
+    # is why this is a branch rather than a fixed key set.
+    if faces:
+        card["card_faces"] = faces
+        if not two_image:
+            # ONE image and one cost: a split/flip/adventure/prepare printing keeps both at top
+            # level, the cost joined " // " between the faces that HAVE one, skipping the ones
+            # that do not -- flipped Erayo, whose back face carries an empty cost, is `{1}{U}` and
+            # not `{1}{U} // `. Checked against all 3,654 such printings with zero misses.
+            card["mana_cost"] = " // ".join(
+                f["mana_cost"] for f in (row.get("card_faces") or []) if f.get("mana_cost")
+            )
+            card["image_uris"] = _image_uris(scryfall_id, row.get("image_updated_at"))
+    else:
+        card["mana_cost"] = row.get("mana_cost")
+        card["oracle_text"] = row.get("oracle_text")
+        card["image_uris"] = _image_uris(scryfall_id, row.get("image_updated_at"))
+
+    # Keys Scryfall sends only when the card has them. Emitting null instead would differ from
+    # Scryfall on every card that lacks them, which for most of these is most cards.
+    for key, value in (
+        ("power", row.get("power")),
+        ("toughness", row.get("toughness")),
+        # Where Scryfall puts it, beside the creature stats it is the planeswalker analogue of. The
+        # PRINTED string: `planeswalker_loyalty` is a u8 in the engine and cannot hold "X" or "1+*".
+        ("loyalty", row.get("loyalty")),
+        ("flavor_text", row.get("flavor_text") or None),
+        ("watermark", row.get("watermark")),
+        ("frame", row.get("frame")),
+        ("edhrec_rank", row.get("edhrec_rank")),
+        ("penny_rank", row.get("penny_rank")),
+        ("arena_id", row.get("arena_id")),
+        ("mtgo_id", row.get("mtgo_id")),
+        ("mtgo_foil_id", row.get("mtgo_foil_id")),
+        ("tcgplayer_id", row.get("tcgplayer_id")),
+        ("tcgplayer_etched_id", row.get("tcgplayer_etched_id")),
+        ("cardmarket_id", row.get("cardmarket_id")),
+        ("security_stamp", row.get("security_stamp")),
+        ("promo_types", row.get("promo_types") or None),
+        ("frame_effects", row.get("frame_effects") or None),
+        ("all_parts", row.get("all_parts") or None),
+        ("legalities", row.get("legalities")),
+    ):
+        if value is not None:
+            card[key] = value
+
+    return card
+
+
+def error_object(*, code: str, status: int, details: str, warnings: list[str] | None = None) -> dict[str, Any]:
+    """Build Scryfall's error object.
+
+    Args:
+        code: Scryfall's machine-readable error slug, e.g. "not_found".
+        status: The HTTP status the response carries.
+        details: Human-readable explanation.
+        warnings: Non-fatal notes about the request, when there are any.
+
+    Returns:
+        The error object, with `warnings` present only when non-empty.
+    """
+    error: dict[str, Any] = {"object": "error", "code": code, "status": status, "details": details}
+    if warnings:
+        error["warnings"] = warnings
+    return error
+
+
+def not_found_error(details: str) -> dict[str, Any]:
+    """Build the 404 error object.
+
+    Args:
+        details: Human-readable explanation.
+
+    Returns:
+        The error object.
+    """
+    return error_object(code="not_found", status=404, details=details)
+
+
+def bad_request_error(details: str, *, warnings: list[str] | None = None) -> dict[str, Any]:
+    """Build the 400 error object.
+
+    Args:
+        details: Human-readable explanation.
+        warnings: Non-fatal notes about the request.
+
+    Returns:
+        The error object.
+    """
+    return error_object(code="bad_request", status=400, details=details, warnings=warnings)
+
+
+def card_list(  # noqa: PLR0913
+    cards: list[dict[str, Any]],
+    *,
+    total_cards: int | None = None,
+    has_more: bool = False,
+    next_page: str | None = None,
+    not_found: list[dict[str, Any]] | None = None,
+    warnings: list[str] | None = None,
+) -> dict[str, Any]:
+    """Build Scryfall's List object.
+
+    Key order follows Scryfall's own so a byte-comparing client sees the same document.
+
+    Args:
+        cards: The page of objects.
+        total_cards: Unpaginated match count; omitted on lists that do not paginate.
+        has_more: Whether a further page exists.
+        next_page: Absolute URL of the next page, when there is one.
+        not_found: Identifiers a collection request could not resolve.
+        warnings: Non-fatal notes about the request.
+
+    Returns:
+        The List object.
+    """
+    result: dict[str, Any] = {"object": "list"}
+    if total_cards is not None:
+        result["total_cards"] = total_cards
+    if not_found is not None:
+        result["not_found"] = not_found
+    result["has_more"] = has_more
+    if next_page is not None:
+        result["next_page"] = next_page
+    if warnings:
+        result["warnings"] = warnings
+    result["data"] = cards
+    return result
+
+
+def catalog_object(values: list[str], uri: str | None = None) -> dict[str, Any]:
+    """Build Scryfall's Catalog object.
+
+    `uri` is present IFF one is given, and the two callers genuinely differ -- measured against
+    api.scryfall.com on 2026-08-12, `/catalog/battle-types` answers
+    `{"object": "catalog", "uri": "...", "total_values": 1, "data": ["Siege"]}` while
+    `/cards/autocomplete` answers the same object with no `uri` at all. Building one unconditionally
+    would put a key on the autocomplete catalog that Scryfall does not send.
+
+    The uri points at api.scryfall.com rather than at this host, which is the rule the card objects
+    already follow: a self-referencing URI is part of the payload, not pagination.
+
+    Args:
+        values: The catalog entries.
+        uri: The catalog's own URI, for the routes that carry one.
+
+    Returns:
+        The Catalog object.
+    """
+    catalog: dict[str, Any] = {"object": "catalog"}
+    if uri is not None:
+        catalog["uri"] = uri
+    catalog["total_values"] = len(values)
+    catalog["data"] = values
+    return catalog
+
+
+def ruling_object(row: dict[str, Any]) -> dict[str, Any]:
+    """Build one Scryfall Ruling object from a `magic.rulings` row.
+
+    Args:
+        row: A row with oracle_id, source, published_at and comment.
+
+    Returns:
+        The Ruling object.
+    """
+    return {
+        "object": "ruling",
+        "oracle_id": str(row["oracle_id"]),
+        "source": row["source"],
+        "published_at": row["published_at"].isoformat(),
+        "comment": row["comment"],
+    }
+
+
+def build_page_url(base_url: str, params: dict[str, Any], page: int) -> str:
+    """Build the absolute `next_page` URL for a search result.
+
+    Scryfall spells every effective parameter into `next_page` rather than echoing only what the
+    client sent, and clients follow the URL verbatim, so the query string is rebuilt from the
+    resolved values.
+
+    Args:
+        base_url: Scheme and host the request arrived on, plus the route path.
+        params: Effective query parameters, excluding `page`.
+        page: The page number the URL should fetch.
+
+    Returns:
+        The absolute URL.
+    """
+    query = dict(sorted(params.items()))
+    query["page"] = page
+    return f"{base_url}?{urllib.parse.urlencode(sorted(query.items()))}"
+
+
+def _face_of(card: dict[str, Any], face: str) -> dict[str, Any]:
+    """Return the requested face of a card, falling back to the card itself.
+
+    Args:
+        card: A Scryfall card object.
+        face: "back" for the second face; anything else selects the card/front.
+
+    Returns:
+        The face object, or the card when it has no distinct faces.
+    """
+    faces = card.get("card_faces") or []
+    back_face_count = 2
+    if face == "back" and len(faces) >= back_face_count:
+        return faces[1]
+    return card
+
+
+def image_uri(card: dict[str, Any], *, version: str, face: str) -> str | None:
+    """Return the image URL for a card at a given size and face.
+
+    Args:
+        card: A Scryfall card object.
+        version: One of IMAGE_VERSIONS.
+        face: "front" or "back".
+
+    Returns:
+        The image URL, or None when the card carries no image of that size.
+    """
+    selected = _face_of(card, face)
+    uris = selected.get("image_uris") or card.get("image_uris") or {}
+    return uris.get(version)
+
+
+def _render_face(face: dict[str, Any]) -> str:
+    """Render one card face in Scryfall's plain-text format.
+
+    Args:
+        face: A card or card_face object.
+
+    Returns:
+        The rendered face, without a trailing newline.
+    """
+    heading = face.get("name", "")
+    mana_cost = face.get("mana_cost")
+    if mana_cost:
+        heading = f"{heading} {mana_cost}"
+
+    lines = [heading]
+    if face.get("type_line"):
+        lines.append(face["type_line"])
+    if face.get("oracle_text"):
+        lines.append(face["oracle_text"])
+    if face.get("power") is not None and face.get("toughness") is not None:
+        lines.append(f"{face['power']}/{face['toughness']}")
+    elif face.get("loyalty") is not None:
+        lines.append(f"Loyalty: {face['loyalty']}")
+    elif face.get("defense") is not None:
+        lines.append(f"Defense: {face['defense']}")
+    return "\n".join(lines)
+
+
+def card_to_text(card: dict[str, Any]) -> str:
+    """Render a card in Scryfall's `format=text` layout.
+
+    Args:
+        card: A Scryfall card object.
+
+    Returns:
+        The rendered card. Multi-face cards render every face, separated by a blank line.
+    """
+    faces = card.get("card_faces") or []
+    if faces:
+        return "\n\n".join(_render_face(face) for face in faces)
+    return _render_face(card)
diff --git a/api/scryfall_compat/reference_routes.py b/api/scryfall_compat/reference_routes.py
new file mode 100644
index 000000000..e06879da9
--- /dev/null
+++ b/api/scryfall_compat/reference_routes.py
@@ -0,0 +1,382 @@
+"""The Scryfall-compatible `/sets`, `/catalog/*` and `/symbology` routes.
+
+`ScryfallReferenceRoutes` is a second mixin on `APIResource`, alongside `ScryfallCardsRoutes`. It is
+separate because it is a separate kind of thing: these routes answer from the reference tables
+mirrored by `api/scryfall_reference_import.py` rather than from the corpus, so none of them touch
+the engine, the parser or `_search`.
+
+The same two conventions as the cards routes apply — every parameter is annotated `str` so the
+generic binder never puts a non-Scryfall error body on the wire, and the router matches a full path
+before falling back to the first segment, which is what lets `/symbology/parse-mana` claim its exact
+path while `/sets/tcgplayer/:id` arrives at `scryfall_sets` as positional segments.
+
+One route is computed rather than mirrored: `/symbology/parse-mana`, in `mana.py`.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+# A runtime import, not a type-checking one, even though `falcon` appears only in annotations here:
+# `@route` registration runs every handler's annotations through `typing.get_type_hints`, which
+# evaluates them for real. Behind `if TYPE_CHECKING` the name is absent and registration dies with
+# `NameError: name 'falcon' is not defined` before the app can serve anything.
+import falcon  # noqa: TC002
+
+from api.scryfall_compat.mana import ManaCostError, parse_mana_cost
+from api.scryfall_compat.objects import card_list, catalog_object, error_object, not_found_error
+from api.scryfall_compat.responder import ScryfallResponder
+from api.utils.routing import route
+
+logger = logging.getLogger(__name__)
+
+# Cache tiers, matched to what api.scryfall.com sends on each of these routes (measured
+# 2026-08-11). They are not the `public, max-age=57600` the card routes carry:
+#
+#   /sets, /sets/:code, /sets/tcgplayer/:id, /catalog/*, /symbology   ->  public
+#   /symbology/parse-mana                    ->  max-age=0, private, must-revalidate
+#
+# Bare `public` with no max-age leaves freshness to the cache's heuristics, which is weaker than an
+# explicit lifetime and is arguably a wart upstream. It is mirrored anyway, because a client that
+# swaps its base URL should get the same caching behaviour it tuned against Scryfall — a response
+# this service holds for 16 hours where Scryfall revalidates is a behavioural difference the client
+# cannot see until it serves something stale.
+_MIRRORED_CACHE_CONTROL = "public"
+
+# parse-mana is the deterministic one, so caching it hard would be safe -- but Scryfall marks it
+# private and must-revalidate, and parity is the point. `private` does not defeat this service's own
+# CachingMiddleware (only `no-store` does, which is why /cards/random uses that), so the in-process
+# cache still answers repeat parses.
+_PARSE_MANA_CACHE_CONTROL = "max-age=0, private, must-revalidate"
+
+# The tier on a MISS THAT IS ABOUT THE ROUTE rather than about Magic, measured 2026-08-16 -- and it
+# is a real split, not noise. `/sets/zzzz`, a well-formed set lookup that found nothing, is `public`:
+# the same tier the answer would have had, because "there is no such set" is a fact about Magic.
+# `/catalog/not-a-catalog`, `/catalog/Card-Types`, `/sets/khm/extra` and every parse-mana 422 are
+# `no-cache`, because those are facts about the URL. This surface sent `public` on all of them, so a
+# client that mistyped a catalog name got the mistake held at every edge for as long as the
+# heuristics liked.
+_ROUTE_MISS_CACHE_CONTROL = "no-cache"
+
+# The twenty catalogs Scryfall documents. Listed rather than discovered so that a request for a name
+# this instance has never imported 404s as an unknown catalog, instead of reporting an empty one and
+# letting a client conclude Magic has no creature types.
+CATALOG_NAMES = (
+    "card-names",
+    "artist-names",
+    "word-bank",
+    "supertypes",
+    "card-types",
+    "artifact-types",
+    "battle-types",
+    "creature-types",
+    "enchantment-types",
+    "land-types",
+    "planeswalker-types",
+    "spell-types",
+    "powers",
+    "toughnesses",
+    "loyalties",
+    "watermarks",
+    "keyword-abilities",
+    "keyword-actions",
+    "ability-words",
+    "flavor-words",
+)
+
+# Scryfall's own not-found wording on these routes, measured against api.scryfall.com on
+# 2026-08-12. Neither is the generic body the cards surface sends, and the catalog one is that
+# sentence WITHOUT its "Please double-check your URI and try again." tail -- same sentence,
+# different ending, so they are spelled out separately rather than shared.
+#
+#   /sets/<code>, /sets/<id>, /sets/tcgplayer/<id>, /sets/tcgplayer
+#       "No Magic set found for the given code or ID"
+#   /catalog/<unknown>
+#       "The requested object or REST method was not found."
+_SET_MISS_DETAILS = "No Magic set found for the given code or ID"
+_CATALOG_MISS_DETAILS = "The requested object or REST method was not found."
+# The wording for a path that addresses nothing. Today it is the same sentence the catalog miss uses
+# and it is spelled separately anyway: the two mean different things ("there is no such catalog"
+# against "there is no such route"), and one of them changing must not be blocked by the other.
+_ROUTE_MISS_DETAILS = "The requested object or REST method was not found."
+
+# The host a Catalog's own `uri` points at: Scryfall's, not this service's, which is the rule the
+# card objects already follow for `uri`, `rulings_uri` and `prints_search_uri`.
+_SCRYFALL_API = "https://api.scryfall.com"
+
+# Path segment naming the external-id namespace under /sets, mirroring the /cards namespaces.
+_SETS_TCGPLAYER_NAMESPACE = "tcgplayer"
+
+
+def _as_bool(value: str | None, *, default: bool = False) -> bool:
+    """Parse a Scryfall boolean query parameter.
+
+    Args:
+        value: The raw parameter value, or None when absent.
+        default: What an absent parameter means.
+
+    Returns:
+        The parsed flag; anything other than a recognized true spelling is False.
+    """
+    if value is None:
+        return default
+    return value.strip().lower() in ("1", "true", "yes", "on")
+
+
+def _set_reference_cache(falcon_response: falcon.Response | None, tier: str = _MIRRORED_CACHE_CONTROL) -> None:
+    """Set a reference-route cache tier.
+
+    Args:
+        falcon_response: The response to write to, or None for an internal caller.
+        tier: The Cache-Control value; defaults to the tier the mirrored routes share.
+    """
+    if falcon_response is not None:
+        falcon_response.set_header("Cache-Control", tier)
+
+
+class ScryfallReferenceRoutes(ScryfallResponder):
+    """The `/sets`, `/catalog` and `/symbology` routes, mixed into `APIResource`.
+
+    Depends on `_run_query` and `_require_setup_complete` from the class it is mixed into, the same
+    way `ScryfallCardsRoutes` does.
+    """
+
+    # ---------------------------------------------------------------- GET /sets
+
+    @route(paths=("sets",))
+    def scryfall_sets(
+        self,
+        identifier: str = "",
+        second: str = "",
+        *,
+        falcon_response: falcon.Response | None = None,
+        pretty: str = "false",
+        **_: object,
+    ) -> dict[str, Any] | None:
+        """Answer every `/sets` shape.
+
+        Covers `/sets`, `/sets/:code`, `/sets/:id` and `/sets/tcgplayer/:id` — one handler because
+        the router hands trailing segments to whichever route claims the first one.
+
+        Args:
+            identifier: A set code, a Scryfall set id, or the "tcgplayer" namespace.
+            second: The TCGplayer id, when `identifier` named that namespace.
+            falcon_response: The Falcon response to write to.
+            pretty: Whether to indent JSON output.
+
+        Returns:
+            A List object of sets, one Set object, or a Scryfall error.
+        """
+        is_pretty = _as_bool(pretty)
+        _set_reference_cache(falcon_response)
+        self._require_setup_complete()
+
+        if not identifier:
+            return self._scryfall_respond(falcon_response, card_list(self._all_sets()), pretty=is_pretty)
+
+        if identifier.lower() == _SETS_TCGPLAYER_NAMESPACE:
+            if not second:
+                # Scryfall answers the namespace-with-no-id path with its ordinary set miss, not
+                # with a message about the id being absent. Clearer is not the goal here.
+                return self._scryfall_respond(falcon_response, not_found_error(_SET_MISS_DETAILS), pretty=is_pretty)
+            found = self._set_by_tcgplayer_id(second)
+        elif second:
+            # /sets takes at most one identifying segment; anything longer addresses nothing -- and
+            # that is a statement about the URL, not about Magic, so it answers with the ROUTE miss
+            # rather than the set one. `/sets/khm/extra` on api.scryfall.com is "The requested object
+            # or REST method was not found." at `no-cache`, not "No Magic set found ..." at `public`
+            # (measured 2026-08-16); this sent the latter, which told a client the set was missing
+            # when the set was fine and the path was not.
+            _set_reference_cache(falcon_response, _ROUTE_MISS_CACHE_CONTROL)
+            return self._scryfall_respond(falcon_response, not_found_error(_ROUTE_MISS_DETAILS), pretty=is_pretty)
+        else:
+            found = self._set_by_code_or_id(identifier)
+
+        if found is None:
+            return self._scryfall_respond(falcon_response, not_found_error(_SET_MISS_DETAILS), pretty=is_pretty)
+        return self._scryfall_respond(falcon_response, found, pretty=is_pretty)
+
+    def _all_sets(self) -> list[dict[str, Any]]:
+        """Every set, in the order Scryfall returns them.
+
+        Returns:
+            The Set objects.
+        """
+        rows = self._run_query(
+            query="SELECT set_object FROM magic.sets ORDER BY position",
+            params={},
+            explain=False,
+        )["result"]
+        return [row["set_object"] for row in rows]
+
+    def _set_by_code_or_id(self, identifier: str) -> dict[str, Any] | None:
+        """One set by set code or by Scryfall set id.
+
+        A single query over both keys rather than a UUID test first: a set code is never shaped like
+        a UUID, so the two can never both match, and one round trip answers either spelling.
+
+        Args:
+            identifier: The set code or set id.
+
+        Returns:
+            The Set object, or None when nothing matches.
+        """
+        rows = self._run_query(
+            query=("SELECT set_object FROM magic.sets WHERE lower(code) = %(folded)s OR id::text = %(raw)s LIMIT 1"),
+            params={"folded": identifier.lower(), "raw": identifier.lower()},
+            explain=False,
+        )["result"]
+        return rows[0]["set_object"] if rows else None
+
+    def _set_by_tcgplayer_id(self, raw_id: str) -> dict[str, Any] | None:
+        """One set by its TCGplayer group id.
+
+        Args:
+            raw_id: The id as it appeared in the path.
+
+        Returns:
+            The Set object, or None when the id is unparseable or matches nothing.
+        """
+        try:
+            tcgplayer_id = int(raw_id.strip())
+        except (ValueError, AttributeError):
+            return None
+        rows = self._run_query(
+            query="SELECT set_object FROM magic.sets WHERE tcgplayer_id = %(value)s LIMIT 1",
+            params={"value": tcgplayer_id},
+            explain=False,
+        )["result"]
+        return rows[0]["set_object"] if rows else None
+
+    # ---------------------------------------------------------------- GET /catalog/:name
+
+    @route(paths=("catalog",))
+    def scryfall_catalog(
+        self,
+        name: str = "",
+        *,
+        falcon_response: falcon.Response | None = None,
+        pretty: str = "false",
+        **_: object,
+    ) -> dict[str, Any] | None:
+        """Return one catalog.
+
+        Args:
+            name: The catalog name, e.g. "creature-types".
+            falcon_response: The Falcon response to write to.
+            pretty: Whether to indent JSON output.
+
+        Returns:
+            A Catalog object, or a Scryfall error.
+        """
+        is_pretty = _as_bool(pretty)
+        _set_reference_cache(falcon_response)
+        self._require_setup_complete()
+
+        # VERBATIM, not lowercased and not stripped: catalog names are CASE-SENSITIVE on
+        # api.scryfall.com -- `/catalog/Card-Types` is a 404 there and was a 200 here (measured
+        # 2026-08-16). Folding the case made this route answer a URL Scryfall does not serve, which
+        # is the same class of mistake as failing to answer one it does.
+        wanted = name
+        if wanted not in CATALOG_NAMES:
+            # `no-cache`, not the data tier: a 404 about the PATH is a statement about the URL, and
+            # Scryfall declines to cache those. Its `/sets/zzzz` -- a well-formed set lookup that
+            # found nothing -- keeps `public`, which is the other half of the same rule.
+            _set_reference_cache(falcon_response, _ROUTE_MISS_CACHE_CONTROL)
+            return self._scryfall_respond(falcon_response, not_found_error(_CATALOG_MISS_DETAILS), pretty=is_pretty)
+
+        rows = self._run_query(
+            query="SELECT entries FROM magic.catalogs WHERE name = %(name)s",
+            params={"name": wanted},
+            explain=False,
+        )["result"]
+        # A known catalog that has not been imported yet is empty rather than missing: the name is
+        # real, so 404 would tell a client the endpoint does not exist.
+        entries = rows[0]["entries"] if rows else []
+        return self._scryfall_respond(
+            falcon_response,
+            catalog_object(list(entries), uri=f"{_SCRYFALL_API}/catalog/{wanted}"),
+            pretty=is_pretty,
+        )
+
+    # ---------------------------------------------------------------- GET /symbology
+
+    @route(paths=("symbology",))
+    def scryfall_symbology(
+        self,
+        *,
+        falcon_response: falcon.Response | None = None,
+        pretty: str = "false",
+        **_: object,
+    ) -> dict[str, Any] | None:
+        """Return every card symbol.
+
+        Args:
+            falcon_response: The Falcon response to write to.
+            pretty: Whether to indent JSON output.
+
+        Returns:
+            A List object of CardSymbol objects.
+        """
+        is_pretty = _as_bool(pretty)
+        _set_reference_cache(falcon_response)
+        self._require_setup_complete()
+
+        rows = self._run_query(
+            query="SELECT symbol_object FROM magic.card_symbols ORDER BY position",
+            params={},
+            explain=False,
+        )["result"]
+        return self._scryfall_respond(
+            falcon_response,
+            card_list([row["symbol_object"] for row in rows]),
+            pretty=is_pretty,
+        )
+
+    # ---------------------------------------------------------------- GET /symbology/parse-mana
+
+    @route(paths=("symbology/parse-mana",))
+    def scryfall_parse_mana(
+        self,
+        *,
+        falcon_response: falcon.Response | None = None,
+        cost: str | None = None,
+        pretty: str = "false",
+        **_: object,
+    ) -> dict[str, Any] | None:
+        """Parse a mana cost into Scryfall's ManaCost object.
+
+        The one reference route that reads no table: it is a pure function of `cost`, so it answers
+        the same before the first import as after it.
+
+        Args:
+            falcon_response: The Falcon response to write to.
+            cost: The mana cost as written.
+            pretty: Whether to indent JSON output.
+
+        Returns:
+            A ManaCost object, or a Scryfall error.
+        """
+        is_pretty = _as_bool(pretty)
+        _set_reference_cache(falcon_response, _PARSE_MANA_CACHE_CONTROL)
+
+        # A MISSING `cost` is the same request as an empty one, and both are answered: measured
+        # 2026-08-16, `/symbology/parse-mana` with no parameter and `?cost=` both return
+        # `200 {"object": "mana_cost", "cost": null, "colors": [], "cmc": 0.0, ...}`. This sent a 400
+        # saying "You must provide a cost parameter to parse." -- a sentence Scryfall does not own
+        # and a rejection it does not make. `parse_mana_cost("")` already produces exactly that body.
+        try:
+            parsed = parse_mana_cost(cost or "")
+        except ManaCostError as bad_cost:
+            # 422 rather than 400, which is what Scryfall answers an unparseable fragment with -- at
+            # `no-cache` rather than this route's own tier, because an unreadable cost is a fact
+            # about the REQUEST and Scryfall declines to cache those (measured on `{QQQ}`, `!!!`,
+            # `{}`, `é` and `{W/U/B}`).
+            _set_reference_cache(falcon_response, _ROUTE_MISS_CACHE_CONTROL)
+            return self._scryfall_respond(
+                falcon_response,
+                error_object(code="validation_error", status=422, details=str(bad_cost)),
+                pretty=is_pretty,
+            )
+        return self._scryfall_respond(falcon_response, parsed, pretty=is_pretty)
diff --git a/api/scryfall_compat/responder.py b/api/scryfall_compat/responder.py
new file mode 100644
index 000000000..168f58d1e
--- /dev/null
+++ b/api/scryfall_compat/responder.py
@@ -0,0 +1,72 @@
+"""Response plumbing shared by every Scryfall-compatible surface.
+
+The `/cards/*` routes and the reference routes (`/sets`, `/catalog`, `/symbology`) are separate
+mixins on `APIResource`, but they answer with the same content type, the same `pretty` handling and
+the same rule for errors: a handler returns a Scryfall error object rather than raising, and the
+status rides on the payload so the generic Falcon error serializer never sees it. That rule lives
+here so both surfaces cannot drift apart on it.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import falcon
+import falcon.util
+import orjson
+
+# Spelled out rather than falcon.MEDIA_JSON, which omits the charset Scryfall sends.
+JSON_CONTENT_TYPE = "application/json; charset=utf-8"
+
+
+class ScryfallResponder:
+    """Writes Scryfall-shaped JSON, honoring the status an error object carries."""
+
+    def _scryfall_respond(
+        self,
+        falcon_response: falcon.Response | None,
+        payload: dict[str, Any],
+        *,
+        pretty: bool = False,
+    ) -> dict[str, Any] | None:
+        """Write a JSON payload, honoring the error status it carries and `pretty`.
+
+        Args:
+            falcon_response: The response to write to.
+            payload: The Scryfall object to serialize.
+            pretty: Whether to emit indented JSON.
+
+        Returns:
+            The payload when the caller should let the framework serialize it, or None when this
+            method already wrote the body.
+        """
+        if falcon_response is not None:
+            falcon_response.content_type = JSON_CONTENT_TYPE
+            is_error = payload.get("object") == "error"
+            status = payload.get("status") if is_error else None
+            if isinstance(status, int):
+                falcon_response.status = falcon.util.code_to_http_status(status)
+            # AN ERROR BODY IS ALWAYS INDENTED, whatever `pretty` says. Not a style choice: it is
+            # what api.scryfall.com does. Measured 2026-08-16 across the whole surface -- every
+            # `object: "error"` body comes back two-space-indented while every data body comes back
+            # compact, and it does not negotiate: `Accept: application/json`, `Accept: text/html`, a
+            # bare wildcard and an explicit `?pretty=false` all produce the same 130-byte indented
+            # not-found. Scryfall renders errors through a different serializer than answers, and
+            # this rendered both compact, so a client comparing bytes saw a different document for
+            # every 4xx it received.
+            if pretty or is_error:
+                falcon_response.text = orjson.dumps(payload, option=orjson.OPT_INDENT_2).decode()
+                return None
+        return payload
+
+    def _respond_text(self, falcon_response: falcon.Response | None, body: str, content_type: str) -> None:
+        """Write a non-JSON body.
+
+        Args:
+            falcon_response: The response to write to.
+            body: The rendered document.
+            content_type: Its media type.
+        """
+        if falcon_response is not None:
+            falcon_response.content_type = content_type
+            falcon_response.text = body
diff --git a/api/scryfall_compat/routes.py b/api/scryfall_compat/routes.py
new file mode 100644
index 000000000..d2f2172a3
--- /dev/null
+++ b/api/scryfall_compat/routes.py
@@ -0,0 +1,1800 @@
+"""The Scryfall-compatible `/cards/*` routes.
+
+`ScryfallCardsRoutes` is a mixin on `APIResource`: it is a separate class only so that the
+compatibility layer lands in its own file rather than growing `api_resource.py`, and it depends on
+`_search`, `_run_query` and `_require_setup_complete` from the class it is mixed into.
+
+Two conventions run through every handler here:
+
+- **Every parameter is annotated `str`.** The generic binder coerces by annotation and raises its
+  own `400` on a bad value, which would put a non-Scryfall error body on the wire. Parsing the
+  values in the handler keeps every failure inside the Scryfall error object.
+- **The router is prefix-based.** `_resolve_action` matches the full path first and then falls back
+  to the first segment, so the five named sub-routes (`search`, `named`, `autocomplete`, `random`,
+  `collection`) register their exact paths and everything else — `/cards`, `/cards/:id`,
+  `/cards/:code/:number/:lang`, the five external-id namespaces, and the rulings variants — arrives
+  at `scryfall_cards` as up to three positional segments.
+
+What is *not* identical to api.scryfall.com is recorded in
+docs/issues/local-scryfall-cards-api.md; the short version is that the corpus is a filtered subset
+of Scryfall's, so a card this instance never imported 404s here and resolves there.
+"""
+
+from __future__ import annotations
+
+import csv
+import io
+import logging
+import re
+from typing import TYPE_CHECKING, Any
+
+import falcon
+
+from api.enums import CardOrdering, PreferOrder, SortDirection, UniqueOn
+from api.parsing import generate_sql_query, parse_scryfall_query
+from api.parsing.card_query_nodes import fold_accents
+from api.parsing.query_budget import (
+    InvalidRegexPatternError,
+    QueryBudgetExceeded,
+    bounded_query_log_context,
+)
+from api.scryfall_compat import objects
+from api.scryfall_compat.objects import (
+    CARD_OBJECT_FIELDS,
+    DEFAULT_IMAGE_VERSION,
+    IMAGE_VERSIONS,
+    MAX_AUTOCOMPLETE_VALUES,
+    MAX_COLLECTION_IDENTIFIERS,
+    PAGE_SIZE,
+    bad_request_error,
+    card_list,
+    card_to_text,
+    catalog_object,
+    error_object,
+    not_found_error,
+    ruling_object,
+    sql_row_to_engine_row,
+    to_scryfall_card,
+)
+from api.scryfall_compat.responder import ScryfallResponder
+from api.settings import settings
+from api.utils import db_utils
+from api.utils.routing import route
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Sequence
+
+logger = logging.getLogger(__name__)
+
+# Columns every card lookup needs: the blob `to_scryfall_card` reads, plus the id it is re-sorted
+# by when a batch comes back in an order the caller did not ask for.
+# The columns a card object is built from. Deliberately NOT raw_card_blob: there is one builder
+# (objects.to_scryfall_card) and both paths go through it, so the fallback cannot answer differently
+# from the engine. The blob is also no longer the card for a multi-face row -- it is the front face
+# -- so building from it would silently degrade exactly the cards the merge was written to fix.
+_CARD_COLUMNS = (
+    "scryfall_id, oracle_id, card_name, card_layout, mana_cost_text, cmc, type_line, oracle_text, "
+    "creature_power_text AS power, creature_toughness_text AS toughness, card_colors, "
+    "card_color_identity, card_keywords, card_set_code, set_name, collector_number, "
+    "card_rarity_int, flavor_text, card_artist AS artist, illustration_id, released_at, "
+    "card_legalities, card_border, card_watermark, card_frame_data, card_is_tags, "
+    "card_compat_blob, card_faces"
+)
+
+# ------------------------------------------------------------------ the by-name key rule
+#
+# `named?exact=` and a `POST /cards/collection` `{"name"}` identifier are two lookups over one set
+# of keys, and they are NOT the same lookup. Measured against api.scryfall.com on 2026-08-31, ONE
+# IDENTIFIER PER REQUEST -- a collection response's `data` is not in identifier order, and a batched
+# probe silently attributes its answers to the wrong needles:
+#
+#   {"name":"Delver of Secrets"}                   -> Delver of Secrets // Insectile Aberration
+#   {"name":"Insectile Aberration"}                -> the same card (a BACK face names it)
+#   {"name":"Delver of Secrets // Insectile ..."}  -> not_found   <- `exact=` answers the card
+#   {"name":"Fire // Ice"}                         -> not_found
+#   {"name":"Wear // Tear"}                        -> not_found
+#   {"name":"Bonecrusher Giant // Stomp"}          -> not_found
+#   {"name":"Who // What // When // Where // Why"} -> und/75 (a FIVE-part name IS a key)
+#   {"name":"Who"}                                 -> not_found (so is `exact=Who`)
+#   {"name":"Elves"}                               -> Elves (ffdn/9), the card named that and not
+#                                                     one of the hundreds containing the word
+#   {"name":"limduls vault"}                       -> Lim-Dul's Vault (collated)
+#   {"name":"Delver of Secrets","set":"mid"}       -> mid/47 (set FILTERS the lookup)
+#
+# So a card answers to its two FACE names when its name splits in EXACTLY two, and to its whole name
+# otherwise -- never both. `exact=` adds the joined name of a two-faced card, and that is the only
+# key the two surfaces disagree about.
+#
+# The ENGINE is the path that ships (`name_key_tier` in card_engine/src/lib.rs). These fragments are
+# the SQL fallback saying the same thing, so the two cannot answer differently for a needle either
+# of them can reach.
+
+
+def _collate_name(value: str) -> str:
+    """Collate a name: accent-folded, lowercased, every non-alphanumeric character removed.
+
+    This is what Scryfall compares on both name surfaces. Measured on api.scryfall.com, 2026-08-31:
+    `exact=delverofsecrets`, `exact=Lightning-Bolt`, `exact=limduls vault`,
+    `exact=Kongming Sleeping Dragon` and `exact=whowhatwhenwherewhy` all resolve, as do the same
+    spellings as collection identifiers -- and the folded comparison both routes used before
+    answered 404 to every one of them. It subsumes trimming: `{"name":"  Lightning Bolt  "}`
+    resolves there and did not here, because the collection route compared the string as posted.
+
+    `str.isalnum` per character rather than an ASCII class, matching the engine's
+    `char::is_alphanumeric`: the value is accent-folded first, so a character still non-ASCII at
+    this point is one NFKD had no base letter for and must be kept, not dropped.
+
+    Args:
+        value: A name as the client spelled it.
+
+    Returns:
+        Its collated form, which is "" for a value carrying no alphanumeric character at all.
+    """
+    return "".join(char for char in fold_accents(value.lower()) if char.isalnum())
+
+
+def _collated_sql(expr: str) -> str:
+    """The SQL that collates `expr` the way `_collate_name` collates the needle.
+
+    `[:alnum:]` is the server's character class where the engine uses Rust's
+    `char::is_alphanumeric`. The two agree over ASCII, which is all `card_name_folded` holds on this
+    corpus -- it is written by `fold_accents` at import. That is the one place the fallback can
+    drift from the engine, and it needs a name NFKD cannot reduce to ASCII to do it.
+    """
+    return f"regexp_replace(lower({expr}), '[^[:alnum:]]', '', 'g')"
+
+
+_NAME_FRONT = "split_part(card_name_folded, ' // ', 1)"
+_NAME_BACK = "split_part(card_name_folded, ' // ', 2)"
+
+# EXACTLY two halves, which is the load-bearing word: a name with more of them has no face keys at
+# all. `exact=Who`, `exact=What` and `{"name":"Who"}` are each not_found on api.scryfall.com while
+# `Who // What // When // Where // Why` answers und/75 on both surfaces -- the five-part name is the
+# key and its parts are not. Part 3 being empty is what distinguishes the two cases.
+_NAME_SPLITS_IN_TWO = f"({_NAME_BACK} <> '' AND split_part(card_name_folded, ' // ', 3) = '')"
+
+_FACE_NAME_MATCH = f"(%(collated)s IN ({_collated_sql(_NAME_FRONT)}, {_collated_sql(_NAME_BACK)}))"
+_WHOLE_NAME_MATCH = f"({_collated_sql('card_name_folded')} = %(collated)s)"
+
+# A collection identifier's keys: the faces, or the whole name, never both.
+_COLLECTION_NAME_MATCH = f"(CASE WHEN {_NAME_SPLITS_IN_TWO} THEN {_FACE_NAME_MATCH} ELSE {_WHOLE_NAME_MATCH} END)"
+
+# `exact=`'s keys: the same set, plus the JOINED name of a two-faced card.
+_EXACT_NAME_MATCH = f"({_WHOLE_NAME_MATCH} OR ({_NAME_SPLITS_IN_TWO} AND {_FACE_NAME_MATCH}))"
+
+# A WHOLE-name match beats a FACE match on both surfaces, ahead of prefer_score rather than beside
+# it. Without it a needle that is one card's whole name and another's face answers whichever scores
+# higher: on this corpus `Lightning Bolt` would resolve "Emeritus of Conflict // Lightning Bolt".
+# One expression for both scopes -- a two-faced card matched by a face cannot also carry the needle
+# as its whole collated name.
+_WHOLE_NAME_FIRST = f"{_WHOLE_NAME_MATCH} DESC, "
+
+# Path segments that name an external id namespace rather than a set code.
+_EXTERNAL_ID_NAMESPACES = ("multiverse", "mtgo", "arena", "tcgplayer", "cardmarket")
+
+# Blob keys each namespace matches. Scryfall's MTGO and TCGplayer routes each accept two ids —
+# the regular printing's and the foil/etched printing's — and both resolve to the same card.
+# Scryfall's `order` vocabulary, which `CardOrdering` covers except for the two below. Built from
+# the enum rather than listed, so an ordering added there is accepted here without a second edit;
+# the extra member that is not Scryfall's (`cubecobra`) is a harmless superset.
+_ORDER_MAP: dict[str, CardOrdering] = {str(member): member for member in CardOrdering}
+
+# The two Scryfall orders with no counterpart. `penny` needs penny_rank lifted out of raw_card_blob
+# into a column; `review` is Scryfall-internal with no public input and is not reproducible at all.
+# Both fall back to `name`, which is what Scryfall does with an order it does not recognize
+# (measured 2026-08-09: it falls back silently), and add a warning saying so.
+_SCRYFALL_ONLY_ORDERS = ("penny", "review")
+
+# Scryfall's `dir` vocabulary. `auto` is not resolved here -- it reaches `_search` as AUTO and is
+# folded against the ordering there, so this route and /search agree on what auto means.
+_DIRECTION_MAP: dict[str, SortDirection] = {
+    "asc": SortDirection.ASC,
+    "desc": SortDirection.DESC,
+    "auto": SortDirection.AUTO,
+}
+
+_UNIQUE_MAP: dict[str, UniqueOn] = {
+    "cards": UniqueOn.CARD,
+    "art": UniqueOn.ARTWORK,
+    "prints": UniqueOn.PRINTING,
+}
+
+# Scryfall's own wording, down to the typographic apostrophe, so a client that string-matches on
+# `details` behaves the same.
+_NO_MATCH_DETAILS = (
+    "Your query didn’t match any cards. Adjust your search terms or refer to the syntax guide "  # noqa: RUF001
+    "at https://scryfall.com/docs/syntax"
+)
+_EMPTY_QUERY_DETAILS = "You didn't enter anything to search for."
+
+# CSV columns for `format=csv`. Fixed rather than derived from the page's cards so the header does
+# not change between pages of one result set. Nested objects are flattened with `_`, matching how
+# Scryfall spells `image_uris_normal` and `prices_usd` in its own export.
+_CSV_SCALAR_COLUMNS = (
+    "object",
+    "id",
+    "oracle_id",
+    "multiverse_ids",
+    "mtgo_id",
+    "mtgo_foil_id",
+    "tcgplayer_id",
+    "cardmarket_id",
+    "name",
+    "lang",
+    "released_at",
+    "uri",
+    "scryfall_uri",
+    "layout",
+    "highres_image",
+    "image_status",
+    "mana_cost",
+    "cmc",
+    "type_line",
+    "oracle_text",
+    "power",
+    "toughness",
+    "loyalty",
+    "colors",
+    "color_identity",
+    "keywords",
+    "games",
+    "reserved",
+    "foil",
+    "nonfoil",
+    "finishes",
+    "oversized",
+    "promo",
+    "reprint",
+    "variation",
+    "set_id",
+    "set",
+    "set_name",
+    "set_type",
+    "set_uri",
+    "set_search_uri",
+    "scryfall_set_uri",
+    "rulings_uri",
+    "prints_search_uri",
+    "collector_number",
+    "digital",
+    "rarity",
+    "flavor_text",
+    "card_back_id",
+    "artist",
+    "artist_ids",
+    "illustration_id",
+    "border_color",
+    "frame",
+    "full_art",
+    "textless",
+    "booster",
+    "story_spotlight",
+    "edhrec_rank",
+    "penny_rank",
+)
+_CSV_NESTED_COLUMNS = (
+    ("image_uris", IMAGE_VERSIONS),
+    ("prices", ("usd", "usd_foil", "usd_etched", "eur", "eur_foil", "tix")),
+    ("related_uris", ("gatherer", "tcgplayer_infinite_articles", "tcgplayer_infinite_decks", "edhrec")),
+    ("purchase_uris", ("tcgplayer", "cardmarket", "cardhoarder")),
+)
+
+
+class _EngineMiss:
+    """The engine could not serve this lookup, so the caller should try SQL.
+
+    Distinct from None, which means the engine answered and there is no such card. Collapsing the
+    two would let an unloaded store 404 a card that exists.
+    """
+
+
+_ENGINE_MISS = _EngineMiss()
+
+# SQL fallback only: the blob subfields each external-id namespace maps to. The engine path uses its
+# own index and never reads these.
+_EXTERNAL_ID_COLUMNS: dict[str, tuple[str, ...]] = {
+    "multiverse": ("multiverse_ids",),
+    "mtgo": ("mtgo_id", "mtgo_foil_id"),
+    "arena": ("arena_id",),
+    "tcgplayer": ("tcgplayer_id", "tcgplayer_etched_id"),
+    "cardmarket": ("cardmarket_id",),
+}
+
+_UUID_RE = re.compile(r"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$")
+
+# Thresholds for the typo-tolerant stage of `?fuzzy=`. A candidate must score at least the floor,
+# and the best must lead the next distinct card name by at least the lead — closer than that and
+# the query does not identify either card, so it is `ambiguous` rather than a guess. The floor sits
+# deliberately above pg_trgm's default 0.3 similarity_threshold, so the index-assisted `%`
+# prefilter always admits a strict superset of what the floor keeps.
+FUZZY_SIMILARITY_FLOOR = 0.4
+FUZZY_SIMILARITY_LEAD = 0.05
+
+# Returned by the similarity stage when two names are too close to choose between. A distinct
+# object rather than a flag so the caller compares with `is` and cannot confuse it with a row.
+_AMBIGUOUS: dict[str, Any] = {"ambiguous": True}
+
+# How long a /cards/* answer may be reused, measured against api.scryfall.com rather than chosen:
+# it sends `public, max-age=57600` on search, named, autocomplete and every by-id addressing, and
+# the tier rides on its error responses too. These routes sent NO Cache-Control at all, so a CDN in
+# front of this service cached none of them -- CachingMiddleware is an internal response cache and
+# says nothing to anyone downstream.
+#
+# `/cards/random` keeps its stronger `no-store` (Scryfall sends `no-cache`): the draw must not be
+# replayed by either layer, and no-store is the one that also defeats the internal cache.
+_CARDS_CACHE_CONTROL = "public, max-age=57600"
+
+
+def _set_cards_cache(falcon_response: falcon.Response | None) -> None:
+    """Set the /cards/* cache tier.
+
+    Local rather than `api_resource.set_cache_header`, which is the same line of code: these
+    routes are a MIXIN ON `APIResource`, so `api_resource` imports this module and importing back
+    is a circular import that fails at startup.
+
+    Args:
+        falcon_response: The response to write to, or None for an internal caller.
+    """
+    if falcon_response is not None:
+        falcon_response.set_header("Cache-Control", _CARDS_CACHE_CONTROL)
+
+
+# Hosts an absolute self-URL should address over plain HTTP. Everything else is assumed to be
+# reached over TLS, which is what `next_page` has to say for a client to follow it.
+_PLAINTEXT_HOSTS = ("localhost", "127.0.0.1", "0.0.0.0", "[::1]")  # noqa: S104
+
+# Scryfall's three not-found bodies for these routes, measured against api.scryfall.com on
+# 2026-08-12. They are worded by the SHAPE of the path rather than by the outcome, and none of them
+# is the single string this used to answer with -- which carried a "Please double-check your URI and
+# try again." tail Scryfall does not send, so the generic case was wrong as well as the specific
+# ones.
+#
+#   /cards/<not-an-id>, /cards/<namespace>        the path addresses nothing
+#   /cards/<id>, /cards/<ns>/<id>, /cards/<code>/<number>(/<lang>)
+#                                                 a card miss: the address is well formed
+#   the rulings variants                          the same, worded for the routes that take a
+#                                                 multiverse id too
+#
+# `&` rather than `and`, and `multiverse ID` appearing only in the rulings one, are both Scryfall's.
+_NOT_ADDRESSABLE_DETAILS = "The requested object or REST method was not found."
+_CARD_MISS_DETAILS = "No card found with the given ID or set code and collector number."
+_RULINGS_MISS_DETAILS = "No card found with the given ID, multiverse ID, or set code & collector number."
+
+
+def _miss_details(identifier: str, number: str, suffix: str) -> str:
+    """Pick the body a `/cards/...` miss answers with.
+
+    Decided from the segments, not from what the lookup did, because that is how Scryfall words
+    them: `/cards/nonsense` and `/cards/<a real id that matches nothing>` are both misses and get
+    different sentences.
+
+    `/cards/<x>/rulings` where x is not an id is the subtle one, and it is measured both ways:
+    Scryfall reads it as a set code and a collector number that happens to be "rulings", so it
+    answers the CARD miss rather than the rulings one.
+
+    Args:
+        identifier: First path segment.
+        number: Second path segment.
+        suffix: Third path segment.
+
+    Returns:
+        The `details` string for the 404.
+    """
+    if not number and not _is_uuid(identifier):
+        return _NOT_ADDRESSABLE_DETAILS
+    if (number == "rulings" and _is_uuid(identifier)) or suffix == "rulings":
+        return _RULINGS_MISS_DETAILS
+    return _CARD_MISS_DETAILS
+
+
+def _is_uuid(value: str) -> bool:
+    """Return whether a path segment is shaped like a UUID.
+
+    Args:
+        value: The segment to test.
+
+    Returns:
+        True when the segment is a canonical 8-4-4-4-12 UUID.
+    """
+    return bool(_UUID_RE.match(value))
+
+
+def _as_bool(value: str | None, *, default: bool = False) -> bool:
+    """Parse a Scryfall boolean query parameter.
+
+    Args:
+        value: The raw parameter value, or None when absent.
+        default: What an absent parameter means.
+
+    Returns:
+        The parsed flag; anything other than a recognized true spelling is False.
+    """
+    if value is None:
+        return default
+    return value.strip().lower() in ("1", "true", "yes", "on")
+
+
+def _as_int(value: str | None) -> int | None:
+    """Parse an integer query parameter or path segment.
+
+    Args:
+        value: The raw value, or None when absent.
+
+    Returns:
+        The integer, or None when absent or unparseable.
+    """
+    if value is None:
+        return None
+    try:
+        return int(value.strip())
+    except (ValueError, AttributeError):
+        return None
+
+
+def _self_base_url(request: falcon.Request | None, request_host: str, path: str) -> str:
+    """Build the absolute URL of a route on this host.
+
+    A `next_page` a client cannot follow is worse than no pagination at all, so the scheme is the
+    request's own as corrected by `Forwarded` / `X-Forwarded-Proto` — the only signal that knows
+    about a TLS-terminating proxy, behind which the request itself arrives as plain `http`. A
+    deployment that terminates TLS in front of this service must send one of those headers, as it
+    must already for `X-Proxy-Host` to give the right host.
+
+    Guessing `https` from the host name instead was tried and is worse: it silently breaks any
+    plain-HTTP deployment on a real hostname, which is a configuration this project supports,
+    to paper over one that is misconfigured. The host only decides when there is no request to
+    read, which is an internal caller rather than a served request.
+
+    Args:
+        request: The request being answered, when the handler has one.
+        request_host: Host the request arrived on.
+        path: Absolute route path, leading slash included.
+
+    Returns:
+        The absolute URL, with no query string.
+    """
+    host = request_host or "api.scryfall.com"
+    if request is not None:
+        return f"{request.forwarded_scheme}://{host}{path}"
+    scheme = "http" if host.split(":")[0] in _PLAINTEXT_HOSTS else "https"
+    return f"{scheme}://{host}{path}"
+
+
+def _flatten_for_csv(card: dict[str, Any]) -> dict[str, Any]:
+    """Flatten a card object onto the fixed CSV column set.
+
+    Args:
+        card: A Scryfall card object.
+
+    Returns:
+        A mapping from column name to cell value; list values are joined on commas.
+    """
+    row: dict[str, Any] = {}
+    for column in _CSV_SCALAR_COLUMNS:
+        value = card.get(column)
+        row[column] = ",".join(str(item) for item in value) if isinstance(value, list) else value
+    for parent, children in _CSV_NESTED_COLUMNS:
+        nested = card.get(parent) or {}
+        for child in children:
+            row[f"{parent}_{child}"] = nested.get(child)
+    return row
+
+
+def _csv_columns() -> list[str]:
+    """Return the CSV header in column order.
+
+    Returns:
+        Every scalar column followed by the flattened nested columns.
+    """
+    columns = list(_CSV_SCALAR_COLUMNS)
+    for parent, children in _CSV_NESTED_COLUMNS:
+        columns.extend(f"{parent}_{child}" for child in children)
+    return columns
+
+
+def _cards_to_csv(cards: Sequence[dict[str, Any]]) -> str:
+    """Render a page of cards as CSV.
+
+    Args:
+        cards: The card objects to render.
+
+    Returns:
+        The CSV document, header row included.
+    """
+    buffer = io.StringIO()
+    writer = csv.DictWriter(buffer, fieldnames=_csv_columns(), extrasaction="ignore")
+    writer.writeheader()
+    for card in cards:
+        writer.writerow(_flatten_for_csv(card))
+    return buffer.getvalue()
+
+
+class ScryfallCardsRoutes(ScryfallResponder):
+    """The `/cards/*` routes, mixed into `APIResource`.
+
+    Every handler returns the value that becomes the response body, or None after writing the
+    response itself (the text and CSV formats, which are not JSON). Errors are returned as
+    Scryfall error objects with the matching status rather than raised, so the generic Falcon
+    error serializer never sees them — `ScryfallResponder` is where that rule lives, shared with
+    the `/sets`, `/catalog` and `/symbology` routes.
+    """
+
+    def _render_card(  # noqa: PLR0913
+        self,
+        card: dict[str, Any],
+        *,
+        falcon_response: falcon.Response | None,
+        card_format: str,
+        face: str,
+        version: str,
+        pretty: bool,
+    ) -> dict[str, Any] | None:
+        """Emit one card in the requested format.
+
+        Args:
+            card: The Scryfall card object.
+            falcon_response: The response to write to.
+            card_format: "json", "text" or "image".
+            face: "front" or "back".
+            version: One of IMAGE_VERSIONS.
+            pretty: Whether JSON output is indented.
+
+        Returns:
+            The payload to serialize, or None when the body was written here.
+
+        Raises:
+            falcon.HTTPFound: For `format=image`, redirecting to the image itself.
+        """
+        if card_format == "text":
+            self._respond_text(falcon_response, card_to_text(card), "text/plain; charset=utf-8")
+            return None
+        if card_format == "image":
+            location = objects.image_uri(card, version=version, face=face)
+            if not location:
+                return self._scryfall_respond(
+                    falcon_response,
+                    not_found_error("No image is available for this card in that version."),
+                    pretty=pretty,
+                )
+            raise falcon.HTTPFound(location)
+        return self._scryfall_respond(falcon_response, card, pretty=pretty)
+
+    # ---------------------------------------------------------------- card lookups
+
+    def _run_uncached(self, *, query: str, params: dict[str, Any]) -> list[dict[str, Any]]:
+        """Run a query that must not be memoized, and return its rows.
+
+        `_run_query` keys its cache on the SQL text and the bound parameters, which is right for
+        every lookup here except the random draw: that one is deliberately non-deterministic for a
+        fixed query and parameter set, so caching it would replay one card forever.
+
+        Args:
+            query: The SQL to run.
+            params: Bound parameters.
+
+        Returns:
+            The result rows.
+        """
+        with self.app_context.reader_pool.connection() as conn, conn.cursor() as cursor:
+            db_utils.set_statement_timeout(cursor, 10_000)
+            cursor.execute(query, params)
+            return [dict(row) for row in cursor.fetchall()]
+
+    def _engine_for_lookup(self) -> object | None:
+        """The engine when it can answer, or None when the caller must fall back to SQL.
+
+        Mirrors the three branches `search()` already uses: feature-gated off, store not loaded, or
+        ready. SQL is the fallback for when the engine cannot serve, not a peer path -- every route
+        below asks here first and only reaches Postgres if this returns None or the engine raises.
+        """
+        if not settings.enable_engine:
+            return None
+        try:
+            if self.app_context.engine.size() == 0:
+                self._trigger_background_reload_if_needed()
+                return None
+        # An engine that cannot report its size cannot serve, whatever the reason.
+        except Exception:  # noqa: BLE001
+            return None
+        return self.app_context.engine
+
+    def _engine_card(self, fetch: Callable[[Any], dict[str, Any] | None]) -> dict[str, Any] | _EngineMiss | None:
+        """Run one engine lookup, or report that the engine could not serve it.
+
+        Returns the card, None for a genuine "no such card", or _ENGINE_MISS when the caller should
+        try SQL. Separating the last from the first matters: a store that is not loaded must not
+        answer 404 for a card that exists.
+        """
+        engine = self._engine_for_lookup()
+        if engine is None:
+            return _ENGINE_MISS
+        try:
+            row = fetch(engine)
+        # Any engine failure is a fallback, never a 500.
+        except Exception:
+            logger.exception("Engine lookup failed, falling back to SQL")
+            return _ENGINE_MISS
+        return to_scryfall_card(row) if row else None
+
+    def _card_by_scryfall_id(self, scryfall_id: str) -> dict[str, Any] | None:
+        """One card by Scryfall id, from the store when it can answer."""
+        found = self._engine_card(lambda e: e.card_by_scryfall_id(str(scryfall_id), list(CARD_OBJECT_FIELDS)))
+        if found is not _ENGINE_MISS:
+            return found
+        return self._fetch_one_card("scryfall_id = %(value)s", {"value": str(scryfall_id)})
+
+    def _card_by_oracle_id(self, oracle_id: str) -> dict[str, Any] | None:
+        """The representative printing of one oracle card, from the store when it can answer."""
+        engine = self._engine_for_lookup()
+        if engine is not None:
+            try:
+                rows = engine.printings_of_oracle_id(str(oracle_id), list(CARD_OBJECT_FIELDS))
+                # Printings are stored in descending default-prefer order, so the first is the
+                # representative printing every other by-name path shows.
+                return to_scryfall_card(rows[0]) if rows else None
+            except Exception:
+                logger.exception("Engine oracle-id lookup failed, falling back to SQL")
+        return self._fetch_one_card("oracle_id = %(value)s", {"value": str(oracle_id)})
+
+    def _card_by_external_id(self, namespace: str, external_id: int | None) -> dict[str, Any] | None:
+        """One card by a marketplace or client id, from the store when it can answer."""
+        if external_id is None:
+            return None
+        found = self._engine_card(
+            lambda e: e.card_by_external_id(namespace, int(external_id), list(CARD_OBJECT_FIELDS)),
+        )
+        if found is not _ENGINE_MISS:
+            return found
+        columns = _EXTERNAL_ID_COLUMNS.get(namespace, ())
+        if not columns:
+            return None
+        clauses = " OR ".join(f"(raw_card_blob ->> '{column}')::bigint = %(value)s" for column in columns)
+        return self._fetch_one_card(f"({clauses})", {"value": external_id})
+
+    def _fetch_one_card(self, where: str, params: dict[str, Any], *, rank_first: str = "") -> dict[str, Any] | None:
+        """Fetch the single best printing matching a predicate.
+
+        Ties are broken by prefer_score, so a lookup that spans printings (by name, by oracle id)
+        returns the same representative printing the rest of the API would pick.
+
+        Args:
+            where: SQL predicate, referencing `card` as the table alias.
+            params: Bound parameters for the predicate.
+            rank_first: An ORDER BY term applied BEFORE prefer_score, for a caller whose predicate
+                admits matches of different qualities. `named?exact=` needs it: it matches either
+                face of a "Front // Back" name, and without this a two-faced card whose back face
+                carries the name outranks the card actually named that whenever its score is
+                higher.
+
+        Returns:
+            The card, or None when nothing matched.
+        """
+        rows = self._run_query(
+            query=(
+                f"SELECT {_CARD_COLUMNS} FROM magic.cards AS card WHERE {where} "
+                f"ORDER BY {rank_first}prefer_score DESC NULLS LAST, released_at DESC LIMIT 1"
+            ),
+            params=params,
+            explain=False,
+        )["result"]
+        return to_scryfall_card(sql_row_to_engine_row(rows[0])) if rows else None
+
+    def _engine_exact_name(self, folded: str, set_code: str | None) -> dict[str, Any] | None:
+        """The exact-name match from the engine, or None when it cannot answer.
+
+        Args:
+            folded: The accent-folded, lowercased name.
+            set_code: Restrict to this set, or None for any.
+
+        Returns:
+            `{"scryfall_id", "card_name"}` for the best match, or None to fall back to SQL.
+        """
+        engine = self._engine_for_lookup()
+        if engine is None:
+            return None
+        try:
+            row = engine.exact_card_by_name(folded, set_code, list(CARD_OBJECT_FIELDS))
+        # Any engine failure falls back to SQL; it never 500s.
+        except Exception:
+            logger.exception("Engine exact name match failed, falling back to SQL")
+            return None
+        if row is None:
+            return None
+        # Outside the except ON PURPOSE: a missing key is a SHAPE mismatch between this call and
+        # CARD_OBJECT_FIELDS, not an engine that cannot answer, and swallowing it would turn the
+        # fast path into a permanent silent fallback. See _fuzzy_similarity_candidate, where
+        # exactly that happened.
+        return {"scryfall_id": row["scryfall_id"], "card_name": row["name"]}
+
+    def _card_by_illustration_id(self, illustration_id: str) -> dict[str, Any] | None:
+        """Return the best printing carrying an illustration id.
+
+        The ENGINE first, like every other identifier `/cards/collection` accepts. This was the one
+        left on SQL, and it is a scan there too — `illustration_id` has no index on the table, where
+        the engine answers it from a sorted permutation in O(log n).
+
+        Args:
+            illustration_id: The illustration UUID.
+
+        Returns:
+            The matching printing, or None.
+        """
+        engine = self._engine_for_lookup()
+        if engine is not None:
+            try:
+                row = engine.card_by_illustration_id(illustration_id, list(CARD_OBJECT_FIELDS))
+            # Any engine failure falls back to SQL; it never 500s.
+            except Exception:
+                logger.exception("Engine illustration lookup failed, falling back to SQL")
+            else:
+                if row is None:
+                    return None
+                return self._fetch_one_card("scryfall_id = %(value)s", {"value": str(row["scryfall_id"])})
+
+        return self._fetch_one_card("illustration_id = %(value)s", {"value": illustration_id})
+
+    def _cards_by_ids(self, scryfall_ids: Sequence[str]) -> list[dict[str, Any]]:
+        """Fetch cards by scryfall id, preserving the order of the ids given.
+
+        Args:
+            scryfall_ids: The ids to fetch.
+
+        Returns:
+            The cards, in `scryfall_ids` order; ids that matched nothing are skipped.
+        """
+        if not scryfall_ids:
+            return []
+        engine = self._engine_for_lookup()
+        if engine is not None:
+            try:
+                by_id_engine = {}
+                for card_id in scryfall_ids:
+                    row = engine.card_by_scryfall_id(str(card_id), list(CARD_OBJECT_FIELDS))
+                    if row:
+                        by_id_engine[str(card_id)] = to_scryfall_card(row)
+                return [by_id_engine[i] for i in scryfall_ids if i in by_id_engine]
+            # Hydration failure falls back; it does not 500.
+            except Exception:
+                logger.exception("Engine hydration failed, falling back to SQL")
+        rows = self._run_query(
+            # A comma-joined string rather than a list: _run_query passes list parameters through
+            # maybe_json(), which binds them as jsonb, and jsonb does not cast to uuid[].
+            query=(
+                f"SELECT {_CARD_COLUMNS} FROM magic.cards AS card WHERE scryfall_id = ANY(string_to_array(%(ids)s, ',')::uuid[])"
+            ),
+            params={"ids": ",".join(scryfall_ids)},
+            explain=False,
+        )["result"]
+        by_id = {str(row["scryfall_id"]): to_scryfall_card(sql_row_to_engine_row(row)) for row in rows}
+        return [by_id[card_id] for card_id in scryfall_ids if card_id in by_id]
+
+    # ---------------------------------------------------------------- GET /cards/search
+
+    @route(paths=("cards/search",))
+    def scryfall_cards_search(  # noqa: PLR0913
+        self,
+        *,
+        falcon_response: falcon.Response | None = None,
+        request: falcon.Request | None = None,
+        request_host: str = "",
+        q: str | None = None,
+        unique: str = "cards",
+        order: str = "name",
+        dir: str = "auto",  # noqa: A002  -- Scryfall's parameter name
+        page: str = "1",
+        format: str = "json",  # noqa: A002  -- Scryfall's parameter name
+        pretty: str = "false",
+        include_extras: str = "false",
+        include_multilingual: str = "false",
+        include_variations: str = "false",
+        **_: object,
+    ) -> dict[str, Any] | None:
+        """Search for cards, paginated 175 at a time.
+
+        `include_extras`, `include_multilingual` and `include_variations` are accepted and have no
+        effect: the corpus holds no tokens, emblems or funny-set cards for `include_extras` to add,
+        and it holds every printing and language it has imported unconditionally.
+
+        Args:
+            falcon_response: The Falcon response to write to.
+            request: The Falcon request, read for the scheme `next_page` should use.
+            request_host: Host the request arrived on, used to build `next_page`.
+            q: The search query.
+            unique: Rollup mode -- cards, art or prints.
+            order: Sort key.
+            dir: Sort direction -- auto, asc or desc.
+            page: 1-based page number.
+            format: Response format -- json or csv.
+            pretty: Whether to indent JSON output.
+            include_extras: Accepted, ignored.
+            include_multilingual: Accepted, ignored.
+            include_variations: Accepted, ignored.
+
+        Returns:
+            A List object of cards, or a Scryfall error object.
+        """
+        is_pretty = _as_bool(pretty)
+        # Before the handler runs, so the tier rides on the 400s raised inside it too -- which is
+        # what api.scryfall.com does (an empty-query 400 comes back with the route's own max-age).
+        _set_cards_cache(falcon_response)
+        if not q or not q.strip():
+            return self._scryfall_respond(falcon_response, bad_request_error(_EMPTY_QUERY_DETAILS), pretty=is_pretty)
+
+        # `or 1` would swallow page=0 into page=1; an unparseable page defaults, a non-positive
+        # one is rejected below.
+        parsed_page = _as_int(page)
+        page_number = 1 if parsed_page is None else parsed_page
+        if page_number < 1:
+            return self._scryfall_respond(
+                falcon_response,
+                bad_request_error("The page parameter must be a positive integer."),
+                pretty=is_pretty,
+            )
+
+        warnings: list[str] = []
+        unique_on = _UNIQUE_MAP.get(unique.lower())
+        if unique_on is None:
+            warnings.append(f"Unrecognized unique mode {unique!r}; rolled up by card instead.")
+            unique_on = UniqueOn.CARD
+
+        orderby = _ORDER_MAP.get(order.lower())
+        if orderby is None:
+            if order.lower() in _SCRYFALL_ONLY_ORDERS:
+                warnings.append(f"This server cannot sort by {order!r} yet; sorted by name instead.")
+            else:
+                warnings.append(f"Unrecognized order {order!r}; sorted by name instead.")
+            orderby = CardOrdering.NAME
+
+        # An unrecognized direction falls back to AUTO, which is also the parameter's default --
+        # Scryfall ignores one it does not know rather than erroring.
+        direction = _DIRECTION_MAP.get(dir.lower(), SortDirection.AUTO)
+
+        try:
+            result = self._search(
+                query=q,
+                orderby=orderby,
+                direction=direction,
+                fields=["scryfall_id"],
+                limit=PAGE_SIZE,
+                offset=(page_number - 1) * PAGE_SIZE,
+                unique=unique_on,
+                prefer=PreferOrder.DEFAULT,
+            )
+        except falcon.HTTPBadRequest as err:
+            return self._scryfall_respond(
+                falcon_response,
+                bad_request_error(str(err.description or "The query could not be parsed."), warnings=warnings),
+                pretty=is_pretty,
+            )
+
+        warnings.extend(result.get("warnings") or [])
+        total_cards = result["total_cards"]
+        cards = self._cards_by_ids([str(row["scryfall_id"]) for row in result["cards"]])
+        if not cards:
+            return self._scryfall_respond(
+                falcon_response,
+                error_object(code="not_found", status=404, details=_NO_MATCH_DETAILS, warnings=warnings),
+                pretty=is_pretty,
+            )
+
+        has_more = (page_number - 1) * PAGE_SIZE + len(cards) < total_cards
+        next_page = None
+        if has_more:
+            next_page = objects.build_page_url(
+                _self_base_url(request, request_host, "/cards/search"),
+                {
+                    "dir": dir,
+                    "format": format,
+                    "include_extras": str(_as_bool(include_extras)).lower(),
+                    "include_multilingual": str(_as_bool(include_multilingual)).lower(),
+                    "include_variations": str(_as_bool(include_variations)).lower(),
+                    "order": order,
+                    "q": q,
+                    "unique": unique,
+                },
+                page_number + 1,
+            )
+
+        if format.lower() == "csv":
+            self._respond_text(falcon_response, _cards_to_csv(cards), "text/csv; charset=utf-8")
+            return None
+        return self._scryfall_respond(
+            falcon_response,
+            card_list(cards, total_cards=total_cards, has_more=has_more, next_page=next_page, warnings=warnings),
+            pretty=is_pretty,
+        )
+
+    # ---------------------------------------------------------------- GET /cards/named
+
+    @route(paths=("cards/named",))
+    def scryfall_cards_named(  # noqa: PLR0913
+        self,
+        *,
+        falcon_response: falcon.Response | None = None,
+        exact: str | None = None,
+        fuzzy: str | None = None,
+        set: str | None = None,  # noqa: A002  -- Scryfall's parameter name
+        format: str = "json",  # noqa: A002  -- Scryfall's parameter name
+        face: str = "front",
+        version: str = DEFAULT_IMAGE_VERSION,
+        pretty: str = "false",
+        **_: object,
+    ) -> dict[str, Any] | None:
+        """Return one card by exact or fuzzy name.
+
+        Args:
+            falcon_response: The Falcon response to write to.
+            exact: A name to match exactly, ignoring case.
+            fuzzy: A name to match loosely.
+            set: Restrict the search to one set code.
+            format: Response format -- json, text or image.
+            face: Which face an image request wants.
+            version: Which image size an image request wants.
+            pretty: Whether to indent JSON output.
+
+        Returns:
+            A card object, or a Scryfall error object.
+        """
+        is_pretty = _as_bool(pretty)
+        _set_cards_cache(falcon_response)
+        self._require_setup_complete()
+        if not (exact or fuzzy):
+            return self._scryfall_respond(
+                falcon_response,
+                bad_request_error("You must provide a fuzzy or exact name parameter."),
+                pretty=is_pretty,
+            )
+
+        params: dict[str, Any] = {}
+        clauses = []
+        if set:
+            clauses.append("lower(card_set_code) = lower(%(set_code)s)")
+            params["set_code"] = set
+
+        if exact:
+            # Scryfall's exact match ignores case, diacritics AND punctuation, and matches a single
+            # face of a two-faced card as well as the combined "Front // Back" this corpus stores.
+            # `_EXACT_NAME_MATCH` is that key set; the block above it carries the measurements, and
+            # the two things it corrects here are that the comparison is COLLATED rather than
+            # folded, and that a face key exists only when the name splits in EXACTLY two --
+            # `split_part(..., 2)` read *Who // What // When // Where // Why* as having a back face
+            # named "What", so `exact=What` answered und/75 where Scryfall 404s.
+            params["folded"] = fold_accents(exact.strip().lower())
+            params["collated"] = _collate_name(exact)
+            clauses.append(_EXACT_NAME_MATCH)
+            # The ENGINE first, same as the fuzzy stages below and `_cards_by_ids`. This was the
+            # last by-name lookup still answering from SQL, and it is the one a scan hurts most:
+            # `named?exact=` is a single-card fetch that walked all ~31,700 folded names. It takes
+            # the FOLDED needle and collates it itself, so the two paths cannot collate differently.
+            card = None
+            chosen = self._engine_exact_name(params["folded"], params.get("set_code"))
+            if chosen is not None:
+                found = self._cards_by_ids([str(chosen["scryfall_id"])])
+                card = found[0] if found else None
+            if card is None:
+                card = self._fetch_one_card(" AND ".join(clauses), params, rank_first=_WHOLE_NAME_FIRST)
+            if card is None:
+                return self._scryfall_respond(
+                    falcon_response,
+                    not_found_error(f"No cards found matching “{exact}”"),
+                    pretty=is_pretty,
+                )
+            return self._render_card(
+                card,
+                falcon_response=falcon_response,
+                card_format=format.lower(),
+                face=face,
+                version=version,
+                pretty=is_pretty,
+            )
+
+        return self._named_fuzzy(
+            fuzzy or "",
+            base_clauses=clauses,
+            base_params=params,
+            falcon_response=falcon_response,
+            card_format=format.lower(),
+            face=face,
+            version=version,
+            pretty=is_pretty,
+        )
+
+    def _named_fuzzy(  # noqa: PLR0913
+        self,
+        fuzzy: str,
+        *,
+        base_clauses: list[str],
+        base_params: dict[str, Any],
+        falcon_response: falcon.Response | None,
+        card_format: str,
+        face: str,
+        version: str,
+        pretty: bool,
+    ) -> dict[str, Any] | None:
+        """Resolve a fuzzy name: exact, then all-words-present, then typo-tolerant similarity.
+
+        The three stages mirror what Scryfall resolves in practice — `lightning bolt` exactly,
+        `bolt` by containment, `lighning bolt` by trigram distance — and each stage that finds more
+        than one distinct card name reports `ambiguous` rather than guessing between them.
+
+        Args:
+            fuzzy: The name fragment to match.
+            base_clauses: Predicates already established (the set filter).
+            base_params: Their bound parameters.
+            falcon_response: The Falcon response to write to.
+            card_format: "json", "text" or "image".
+            face: Which face an image request wants.
+            version: Which image size an image request wants.
+            pretty: Whether to indent JSON output.
+
+        Returns:
+            A card object, or a Scryfall error object.
+        """
+        needle = fold_accents(fuzzy.strip().lower())
+        words = [word for word in re.split(r"[^\w']+", needle) if word]
+        if not words:
+            return self._scryfall_respond(
+                falcon_response,
+                bad_request_error("You must provide a fuzzy or exact name parameter."),
+                pretty=pretty,
+            )
+
+        chosen = self._fuzzy_exact_candidate(needle, base_clauses, base_params)
+        if chosen is None:
+            candidates = self._fuzzy_containment_candidates(words, base_clauses, base_params)
+            if len(candidates) > 1:
+                return self._ambiguous(falcon_response, fuzzy, pretty=pretty)
+            if candidates:
+                chosen = candidates[0]
+
+        if chosen is None:
+            chosen = self._fuzzy_similarity_candidate(needle, base_clauses, base_params)
+            if chosen is _AMBIGUOUS:
+                return self._ambiguous(falcon_response, fuzzy, pretty=pretty)
+
+        if not chosen:
+            return self._scryfall_respond(
+                falcon_response,
+                not_found_error(f"No cards found matching “{fuzzy}”"),
+                pretty=pretty,
+            )
+
+        cards = self._cards_by_ids([str(chosen["scryfall_id"])])
+        if not cards:
+            return self._scryfall_respond(
+                falcon_response,
+                not_found_error(f"No cards found matching “{fuzzy}”"),
+                pretty=pretty,
+            )
+        return self._render_card(
+            cards[0],
+            falcon_response=falcon_response,
+            card_format=card_format,
+            face=face,
+            version=version,
+            pretty=pretty,
+        )
+
+    def _ambiguous(self, falcon_response: falcon.Response | None, name: str, *, pretty: bool) -> dict[str, Any] | None:
+        """Emit Scryfall's `ambiguous` error.
+
+        Args:
+            falcon_response: The Falcon response to write to.
+            name: The name that matched more than one card.
+            pretty: Whether to indent JSON output.
+
+        Returns:
+            The error object.
+        """
+        return self._scryfall_respond(
+            falcon_response,
+            error_object(
+                code="ambiguous",
+                status=404,
+                details=f"Too many cards match ambiguous name “{name}”. Add more words to refine your search.",
+            ),
+            pretty=pretty,
+        )
+
+    def _best_printing(self, where: str, params: dict[str, Any]) -> dict[str, Any] | None:
+        """Return the id and name of the best-scoring printing matching a predicate.
+
+        Args:
+            where: SQL predicate over `magic.cards AS card`.
+            params: Bound parameters.
+
+        Returns:
+            A row with scryfall_id and card_name, or None.
+        """
+        rows = self._run_query(
+            query=(
+                f"SELECT scryfall_id, card_name FROM magic.cards AS card WHERE {where} "
+                "ORDER BY prefer_score DESC NULLS LAST, released_at DESC LIMIT 1"
+            ),
+            params=params,
+            explain=False,
+        )["result"]
+        return rows[0] if rows else None
+
+    def _fuzzy_exact_candidate(
+        self,
+        needle: str,
+        base_clauses: list[str],
+        base_params: dict[str, Any],
+    ) -> dict[str, Any] | None:
+        """Return the card whose folded name is exactly the folded query, if there is one.
+
+        Args:
+            needle: The accent-folded, lowercased query.
+            base_clauses: Predicates already established (the set filter).
+            base_params: Their bound parameters.
+
+        Returns:
+            The matching printing, or None.
+        """
+        # The ENGINE first, like every other lookup on this surface. Unlike `fuzzy_card_by_name`,
+        # `exact_card_by_name` takes the set code, so a set filter no longer forces SQL.
+        row = self._engine_exact_name(needle, base_params.get("set_code"))
+        if row is not None:
+            return row
+
+        params = {**base_params, "needle": needle}
+        clauses = [*base_clauses, "lower(card_name_folded) = %(needle)s"]
+        return self._best_printing(" AND ".join(clauses), params)
+
+    def _fuzzy_containment_candidates(
+        self,
+        words: list[str],
+        base_clauses: list[str],
+        base_params: dict[str, Any],
+    ) -> list[dict[str, Any]]:
+        """Return one printing per distinct card name containing every query word.
+
+        Args:
+            words: The folded query, split into words.
+            base_clauses: Predicates already established (the set filter).
+            base_params: Their bound parameters.
+
+        Returns:
+            Up to two rows -- enough to tell "one match" from "ambiguous" without fetching more.
+        """
+        # The ENGINE first. A LIKE per word is a sequential scan of every folded name; the engine
+        # narrows the same predicate through `name_trigram` -- measured 1,303 us against 11 us.
+        engine = self._engine_for_lookup()
+        if engine is not None and words:
+            try:
+                rows = engine.cards_containing_all_words(
+                    list(words),
+                    base_params.get("set_code"),
+                    2,
+                    list(CARD_OBJECT_FIELDS),
+                )
+            # Any engine failure falls back to SQL; it never 500s.
+            except Exception:
+                logger.exception("Engine containment match failed, falling back to SQL")
+            else:
+                # `else`, not the `try` body: a key error here is a shape mismatch, not an engine
+                # failure, and must not be swallowed into a silent fallback.
+                return [{"scryfall_id": row["scryfall_id"], "card_name": row["name"]} for row in rows]
+
+        params = dict(base_params)
+        clauses = list(base_clauses)
+        for index, word in enumerate(words):
+            params[f"word_{index}"] = f"%{word}%"
+            clauses.append(f"lower(card_name_folded) LIKE %(word_{index})s")
+        return self._run_query(
+            query=(
+                "SELECT DISTINCT ON (card_name) card_name, scryfall_id "
+                f"FROM magic.cards AS card WHERE {' AND '.join(clauses)} "
+                "ORDER BY card_name, prefer_score DESC NULLS LAST LIMIT 2"
+            ),
+            params=params,
+            explain=False,
+        )["result"]
+
+    def _fuzzy_similarity_candidate(
+        self,
+        needle: str,
+        base_clauses: list[str],
+        base_params: dict[str, Any],
+    ) -> dict[str, Any] | None:
+        """Return the typo-tolerant match, `_AMBIGUOUS` when two names are too close to separate.
+
+        A candidate must clear FUZZY_SIMILARITY_FLOOR, and the best must lead the next distinct
+        card name by FUZZY_SIMILARITY_LEAD. The floor sits above pg_trgm's default 0.3 threshold,
+        so the index-assisted `%` prefilter is always a strict superset of what the floor admits
+        and no decision rests on a row the prefilter dropped.
+
+        Args:
+            needle: The accent-folded, lowercased query.
+            base_clauses: Predicates already established (the set filter).
+            base_params: Their bound parameters.
+
+        Returns:
+            The matching printing, `_AMBIGUOUS`, or None.
+        """
+        # The ENGINE first, like every other lookup on this surface. `fuzzy_name_match`
+        # reimplements pg_trgm's similarity() exactly for this, and until now nothing called it:
+        # the whole of "Fuzzy Name Match and Autocomplete, Computed Not Stored" was unreachable
+        # from the API, which is the same defect the duplicate `_card_by_external_id` had.
+        #
+        # A set filter still goes to SQL: the engine matches on names alone and has no way to
+        # restrict to one set, and answering the unrestricted match would be a different card.
+        if not base_clauses:
+            engine = self._engine_for_lookup()
+            if engine is not None:
+                try:
+                    status, row = engine.fuzzy_card_by_name(
+                        needle,
+                        FUZZY_SIMILARITY_FLOOR,
+                        FUZZY_SIMILARITY_LEAD,
+                        list(CARD_OBJECT_FIELDS),
+                    )
+                # Any engine failure falls back to SQL; it never 500s.
+                except Exception:
+                    logger.exception("Engine fuzzy match failed, falling back to SQL")
+                else:
+                    # The key is `scryfall_id`, which is what CARD_OBJECT_FIELDS asks for. It read
+                    # `id` before, so every hit raised KeyError INSIDE the try above, was logged as
+                    # an engine failure and fell through to SQL -- this fast path had never once
+                    # returned. Reading the row in `else` is what makes the next such mismatch a
+                    # test failure rather than a silent permanent fallback.
+                    if status == "ambiguous":
+                        return _AMBIGUOUS
+                    if status == "miss":
+                        return None
+                    if row:
+                        return {"scryfall_id": row["scryfall_id"], "card_name": row["name"]}
+
+        params = {**base_params, "needle": needle, "floor": FUZZY_SIMILARITY_FLOOR}
+        # `%%` escapes psycopg's placeholder marker: the bare `%` operator would be read as the
+        # start of one. OPERATOR(magic.%) is pg_trgm's similarity match, which the folded-name GIN
+        # index serves.
+        clauses = [*base_clauses, "lower(card_name_folded) OPERATOR(magic.%%) %(needle)s"]
+        rows = self._run_query(
+            query=(
+                "SELECT DISTINCT ON (card_name) card_name, scryfall_id, "
+                "magic.similarity(lower(card_name_folded), %(needle)s) AS score "
+                f"FROM magic.cards AS card WHERE {' AND '.join(clauses)} "
+                "AND magic.similarity(lower(card_name_folded), %(needle)s) >= %(floor)s "
+                "ORDER BY card_name, prefer_score DESC NULLS LAST"
+            ),
+            params=params,
+            explain=False,
+        )["result"]
+        if not rows:
+            return None
+        ranked = sorted(rows, key=lambda row: row["score"], reverse=True)
+        if len(ranked) > 1 and ranked[0]["score"] - ranked[1]["score"] < FUZZY_SIMILARITY_LEAD:
+            return _AMBIGUOUS
+        return ranked[0]
+
+    # ---------------------------------------------------------------- GET /cards/autocomplete
+
+    @route(paths=("cards/autocomplete",))
+    def scryfall_cards_autocomplete(
+        self,
+        *,
+        falcon_response: falcon.Response | None = None,
+        q: str | None = None,
+        pretty: str = "false",
+        include_extras: str = "false",  # noqa: ARG002  -- declared so the 404 route listing shows it
+        **_: object,
+    ) -> dict[str, Any] | None:
+        """Return up to 20 card names matching a partial name.
+
+        Args:
+            falcon_response: The Falcon response to write to.
+            q: The partial name.
+            pretty: Whether to indent JSON output.
+            include_extras: Accepted, ignored -- the corpus holds no extras to include.
+
+        Returns:
+            A Catalog object of card names.
+        """
+        is_pretty = _as_bool(pretty)
+        _set_cards_cache(falcon_response)
+        self._require_setup_complete()
+        needle = (q or "").strip()
+        min_query_length = 2
+        if len(needle) < min_query_length:
+            return self._scryfall_respond(falcon_response, catalog_object([]), pretty=is_pretty)
+        # FOLDED, like `named?exact=` and the fuzzy stages above. Unfolded, an ASCII query could not
+        # reach a name with diacritics -- `q=eowyn` answered an empty catalog where Scryfall answers
+        # three Éowyn cards -- and nobody types the accent. Both paths below compare the folded name,
+        # so the engine and the SQL fallback keep answering alike.
+        needle = fold_accents(needle.lower())
+
+        # The ENGINE first, for the same reason the fuzzy match above now does: `autocomplete` was
+        # added by "Fuzzy Name Match and Autocomplete, Computed Not Stored" and nothing called it.
+        engine = self._engine_for_lookup()
+        if engine is not None:
+            try:
+                names = engine.autocomplete(needle, MAX_AUTOCOMPLETE_VALUES)
+                return self._scryfall_respond(falcon_response, catalog_object(list(names)), pretty=is_pretty)
+            # Any engine failure falls back to SQL; it never 500s.
+            except Exception:
+                logger.exception("Engine autocomplete failed, falling back to SQL")
+
+        rows = self._run_query(
+            query=(
+                "SELECT card_name, "
+                "min(CASE WHEN lower(card_name_folded) LIKE %(prefix)s THEN 0 ELSE 1 END) AS rank "
+                "FROM magic.cards AS card WHERE lower(card_name_folded) LIKE %(needle)s "
+                "GROUP BY card_name ORDER BY rank, length(card_name), card_name LIMIT %(limit)s"
+            ),
+            params={"prefix": f"{needle}%", "needle": f"%{needle}%", "limit": MAX_AUTOCOMPLETE_VALUES},
+            explain=False,
+        )["result"]
+        return self._scryfall_respond(falcon_response, catalog_object([row["card_name"] for row in rows]), pretty=is_pretty)
+
+    # ---------------------------------------------------------------- GET /cards/random
+
+    @route(paths=("cards/random",))
+    def scryfall_cards_random(  # noqa: PLR0913
+        self,
+        *,
+        falcon_response: falcon.Response | None = None,
+        q: str | None = None,
+        format: str = "json",  # noqa: A002  -- Scryfall's parameter name
+        face: str = "front",
+        version: str = DEFAULT_IMAGE_VERSION,
+        pretty: str = "false",
+        **_: object,
+    ) -> dict[str, Any] | None:
+        """Return one random card, optionally restricted by a search query.
+
+        Args:
+            falcon_response: The Falcon response to write to.
+            q: An optional search query the card must match.
+            format: Response format -- json, text or image.
+            face: Which face an image request wants.
+            version: Which image size an image request wants.
+            pretty: Whether to indent JSON output.
+
+        Returns:
+            A card object, or a Scryfall error object.
+        """
+        is_pretty = _as_bool(pretty)
+        self._require_setup_complete()
+        where, params = "TRUE", {}
+        if q and q.strip():
+            try:
+                where, params = generate_sql_query(parse_scryfall_query(q))
+            except QueryBudgetExceeded as err:
+                # Same treatment `_search` gives the budget: the stable non-disclosing message,
+                # and a bounded preview in the log rather than the full query in the body.
+                log_ctx = bounded_query_log_context(q)
+                logger.info(
+                    "Query budget exceeded (%s) preview=%r digest=%s",
+                    err.kind,
+                    log_ctx["query_preview"],
+                    log_ctx["query_digest"],
+                )
+                return self._scryfall_respond(
+                    falcon_response,
+                    bad_request_error(err.user_message),
+                    pretty=is_pretty,
+                )
+            except InvalidRegexPatternError as err:
+                return self._scryfall_respond(
+                    falcon_response,
+                    bad_request_error(err.user_message_for_query(q)),
+                    pretty=is_pretty,
+                )
+            except ValueError:
+                return self._scryfall_respond(
+                    falcon_response,
+                    bad_request_error(f'Failed to parse query: "{q}"'),
+                    pretty=is_pretty,
+                )
+
+        # This response must not be cached at either layer. The HTTP cache would pin one card as
+        # "the" random card for the generation, and _run_query's cache would do the same a level
+        # down -- the draw's SQL text and parameters are identical on every call, so its first
+        # result would be replayed forever. Hence no-store here and an uncached draw below.
+        if falcon_response is not None:
+            falcon_response.set_header("Cache-Control", "no-store")
+
+        # Two statements rather than ORDER BY random(): the count is deterministic, so it can go
+        # through the cache, and the offset scan stops as soon as it has one row where a sort would
+        # order the whole match set to throw all but one away.
+        matched = self._run_query(
+            query=f"SELECT count(1) AS total FROM magic.cards AS card WHERE {where}",
+            params=params,
+            explain=False,
+        )["result"][0]["total"]
+        if not matched:
+            return self._scryfall_respond(falcon_response, not_found_error(_NO_MATCH_DETAILS), pretty=is_pretty)
+
+        rows = self._run_uncached(
+            query=(
+                f"SELECT {_CARD_COLUMNS} FROM magic.cards AS card WHERE {where} "
+                "OFFSET floor(random() * %(matched)s)::bigint LIMIT 1"
+            ),
+            params={**params, "matched": matched},
+        )
+        if not rows:
+            return self._scryfall_respond(falcon_response, not_found_error(_NO_MATCH_DETAILS), pretty=is_pretty)
+        return self._render_card(
+            to_scryfall_card(sql_row_to_engine_row(rows[0])),
+            falcon_response=falcon_response,
+            card_format=format.lower(),
+            face=face,
+            version=version,
+            pretty=is_pretty,
+        )
+
+    # ---------------------------------------------------------------- POST /cards/collection
+
+    @route(paths=("cards/collection",), methods=("POST",))
+    def scryfall_cards_collection(
+        self,
+        *,
+        falcon_response: falcon.Response | None = None,
+        request: falcon.Request | None = None,
+        pretty: str = "false",
+        **_: object,
+    ) -> dict[str, Any] | None:
+        """Resolve up to 75 card identifiers in one request.
+
+        Args:
+            falcon_response: The Falcon response to write to.
+            request: The Falcon request, whose JSON body carries the identifiers.
+            pretty: Whether to indent JSON output.
+
+        Returns:
+            A List object whose `data` holds the cards found and whose `not_found` holds the
+            identifiers that resolved to nothing, or a Scryfall error object.
+        """
+        is_pretty = _as_bool(pretty)
+        # A shared cache keys on the URL and this route's answer depends entirely on the BODY,
+        # so it is private and always revalidated -- api.scryfall.com sends the same.
+        if falcon_response is not None:
+            falcon_response.set_header("Cache-Control", "max-age=0, private, must-revalidate")
+        self._require_setup_complete()
+        try:
+            body = request.get_media() if request is not None else None
+        except (falcon.MediaMalformedError, falcon.MediaNotFoundError):
+            body = None
+        if not isinstance(body, dict) or not isinstance(body.get("identifiers"), list):
+            return self._scryfall_respond(
+                falcon_response,
+                error_object(
+                    code="validation_error",
+                    status=422,
+                    details="The request body must be a JSON object with an `identifiers` array.",
+                ),
+                pretty=is_pretty,
+            )
+
+        identifiers = body["identifiers"]
+        if len(identifiers) > MAX_COLLECTION_IDENTIFIERS:
+            return self._scryfall_respond(
+                falcon_response,
+                error_object(
+                    code="validation_error",
+                    status=422,
+                    details=f"A maximum of {MAX_COLLECTION_IDENTIFIERS} card references may be submitted at once.",
+                ),
+                pretty=is_pretty,
+            )
+
+        found: list[dict[str, Any]] = []
+        not_found: list[dict[str, Any]] = []
+        seen: set[str] = set()
+        for identifier in identifiers:
+            card = self._resolve_identifier(identifier) if isinstance(identifier, dict) else None
+            if card is None:
+                not_found.append(identifier)
+                continue
+            if card["id"] in seen:
+                continue
+            seen.add(card["id"])
+            found.append(card)
+
+        return self._scryfall_respond(falcon_response, card_list(found, not_found=not_found), pretty=is_pretty)
+
+    def _resolve_identifier(self, identifier: dict[str, Any]) -> dict[str, Any] | None:
+        """Resolve one collection identifier to a card.
+
+        Args:
+            identifier: One entry of the request's `identifiers` array.
+
+        Returns:
+            The card it names, or None when nothing matched or the shape is not one Scryfall
+            defines.
+        """
+        if "id" in identifier and _is_uuid(str(identifier["id"])):
+            return self._card_by_scryfall_id(str(identifier["id"]))
+        if "oracle_id" in identifier and _is_uuid(str(identifier["oracle_id"])):
+            return self._card_by_oracle_id(str(identifier["oracle_id"]))
+        if "illustration_id" in identifier and _is_uuid(str(identifier["illustration_id"])):
+            return self._card_by_illustration_id(str(identifier["illustration_id"]))
+        if "mtgo_id" in identifier:
+            return self._card_by_external_id("mtgo", _as_int(str(identifier["mtgo_id"])))
+        if "multiverse_id" in identifier:
+            return self._card_by_multiverse_id(_as_int(str(identifier["multiverse_id"])))
+        if "set" in identifier and "collector_number" in identifier:
+            return self._fetch_one_card(
+                "lower(card_set_code) = lower(%(set_code)s) AND collector_number = %(number)s",
+                {"set_code": str(identifier["set"]), "number": str(identifier["collector_number"])},
+            )
+        if "name" in identifier:
+            set_code = identifier.get("set")
+            return self._card_by_name_identifier(
+                str(identifier["name"]),
+                str(set_code) if set_code else None,
+            )
+        return None
+
+    def _card_by_name_identifier(self, name: str, set_code: str | None) -> dict[str, Any] | None:
+        """Resolve a collection identifier's `name` -- a NAME LOOKUP with its own keys.
+
+        Not `named?exact=`'s keys, which is why this is its own engine entry point and not a call
+        to the one beside it: `{"name":"Delver of Secrets // Insectile Aberration"}` is not_found on
+        api.scryfall.com while `exact=` of that same string answers the card. The block above
+        `_collate_name` carries the measurements for both.
+
+        Four things the SQL this replaces got wrong, each measured: it never looked at the BACK face
+        (`{"name":"Insectile Aberration"}` answers the card there and missed here), it accepted the
+        joined name (`{"name":"Fire // Ice"}` is not_found there and answered here), it read a
+        five-part name as having a front face (`{"name":"Who"}` is not_found there and answered
+        und/75 here), and it compared `card_name` as posted -- so no accent, punctuation or spacing
+        difference resolved, and `{"name":"  Lightning Bolt  "}` missed on its own whitespace.
+
+        The ENGINE first, through `_engine_card`, like every other identifier this route accepts:
+        a genuine "no such card" from a loaded store IS the answer, and only a store that cannot
+        serve falls through to SQL. `_engine_exact_name` conflates those two, which is right for
+        `named?exact=` -- there the SQL is a second chance at the same question -- and wrong here,
+        where SQL answering a needle the engine reported not_found would be the pre-existing bug
+        coming back through the fallback.
+
+        Args:
+            name: The identifier's `name` value, as posted.
+            set_code: The identifier's `set`, which FILTERS the lookup -- `{"name":"Delver of
+                Secrets","set":"mid"}` answers mid/47, the same card in the set asked for, and a
+                card with no printing in that set drops out rather than answering another printing.
+
+        Returns:
+            The card it names, or None for not_found.
+        """
+        collated = _collate_name(name)
+        # A needle with no alphanumeric character is nobody's name. Answered here rather than as a
+        # query, because `%(collated)s = ''` would match any card whose name is punctuation alone.
+        if not collated:
+            return None
+        found = self._engine_card(
+            lambda e: e.collection_card_by_name(fold_accents(name.strip().lower()), set_code, list(CARD_OBJECT_FIELDS)),
+        )
+        if found is not _ENGINE_MISS:
+            return found
+        clauses = [_COLLECTION_NAME_MATCH]
+        params: dict[str, Any] = {"collated": collated}
+        if set_code:
+            clauses.append("lower(card_set_code) = lower(%(set_code)s)")
+            params["set_code"] = set_code
+        return self._fetch_one_card(" AND ".join(clauses), params, rank_first=_WHOLE_NAME_FIRST)
+
+    # ---------------------------------------------------------------- GET /cards and /cards/...
+
+    @route()
+    def cards(  # noqa: PLR0913
+        self,
+        identifier: str = "",
+        number: str = "",
+        suffix: str = "",
+        *,
+        falcon_response: falcon.Response | None = None,
+        request: falcon.Request | None = None,
+        request_host: str = "",
+        page: str = "1",
+        format: str = "json",  # noqa: A002  -- Scryfall's parameter name
+        face: str = "front",
+        version: str = DEFAULT_IMAGE_VERSION,
+        pretty: str = "false",
+        **_: object,
+    ) -> dict[str, Any] | None:
+        """Serve every `/cards/*` route the five named sub-routes do not claim.
+
+        The path shapes, by segment count:
+
+        - `/cards` -- every card, paginated.
+        - `/cards/:id` -- one card by Scryfall id.
+        - `/cards/:namespace/:id` -- one card by multiverse, MTGO, Arena, TCGplayer or Cardmarket id.
+        - `/cards/:id/rulings` -- the rulings for one card.
+        - `/cards/:code/:number` -- one card by set code and collector number.
+        - `/cards/:code/:number/:lang` -- the same, in one language.
+        - `/cards/:namespace/:id/rulings` and `/cards/:code/:number/rulings` -- rulings, addressed
+          the same two ways.
+
+        Args:
+            identifier: First path segment: a Scryfall id, an external id namespace, or a set code.
+            number: Second path segment: an external id, a collector number, or "rulings".
+            suffix: Third path segment: a language code or "rulings".
+            falcon_response: The Falcon response to write to.
+            request: The Falcon request, read for the scheme `next_page` should use.
+            request_host: Host the request arrived on, used to build `next_page`.
+            page: 1-based page number, for the unfiltered `/cards` listing.
+            format: Response format -- json, text or image.
+            face: Which face an image request wants.
+            version: Which image size an image request wants.
+            pretty: Whether to indent JSON output.
+
+        Returns:
+            A card, List or Catalog object, or a Scryfall error object.
+        """
+        is_pretty = _as_bool(pretty)
+        _set_cards_cache(falcon_response)
+        self._require_setup_complete()
+
+        if not identifier:
+            return self._all_cards_page(
+                falcon_response=falcon_response,
+                request=request,
+                request_host=request_host,
+                page=page,
+                pretty=is_pretty,
+            )
+
+        wants_rulings = "rulings" in (number, suffix)
+        card = self._resolve_path_card(identifier, number, suffix, wants_rulings=wants_rulings)
+        if card is None:
+            return self._scryfall_respond(
+                falcon_response,
+                not_found_error(_miss_details(identifier, number, suffix)),
+                pretty=is_pretty,
+            )
+        if wants_rulings:
+            return self._scryfall_respond(falcon_response, self._rulings_for(card), pretty=is_pretty)
+        return self._render_card(
+            card, falcon_response=falcon_response, card_format=format.lower(), face=face, version=version, pretty=is_pretty
+        )
+
+    def _resolve_path_card(self, identifier: str, number: str, suffix: str, *, wants_rulings: bool) -> dict[str, Any] | None:
+        """Resolve the card a `/cards/...` path addresses.
+
+        Args:
+            identifier: First path segment.
+            number: Second path segment.
+            suffix: Third path segment.
+            wants_rulings: Whether a trailing "rulings" segment was consumed from the path.
+
+        Returns:
+            The card, or None when the path addresses nothing.
+        """
+        # Drop the trailing "rulings" so the rest reads as a plain card address.
+        if wants_rulings:
+            if suffix == "rulings":
+                suffix = ""
+            else:
+                number, suffix = "", ""
+
+        if identifier in _EXTERNAL_ID_NAMESPACES:
+            external_id = _as_int(number)
+            if external_id is None:
+                return None
+            if identifier == "multiverse":
+                return self._card_by_multiverse_id(external_id)
+            return self._card_by_external_id(identifier, external_id)
+
+        if not number:
+            if not _is_uuid(identifier):
+                return None
+            return self._card_by_scryfall_id(identifier)
+
+        clauses = ["lower(card_set_code) = lower(%(set_code)s)", "collector_number = %(number)s"]
+        params: dict[str, Any] = {"set_code": identifier, "number": number}
+        # Scryfall defaults the language segment to English rather than to "any language".
+        clauses.append("raw_card_blob ->> 'lang' = %(lang)s")
+        params["lang"] = suffix or "en"
+        return self._fetch_one_card(" AND ".join(clauses), params)
+
+    def _card_by_multiverse_id(self, multiverse_id: int | None) -> dict[str, Any] | None:
+        """Fetch a card by Gatherer multiverse id.
+
+        Args:
+            multiverse_id: The id to match.
+
+        Returns:
+            The card, or None when nothing matched.
+        """
+        if multiverse_id is None:
+            return None
+        return self._fetch_one_card(
+            "raw_card_blob -> 'multiverse_ids' @> %(value)s::jsonb",
+            {"value": str(multiverse_id)},
+        )
+
+    def _all_cards_page(
+        self,
+        *,
+        falcon_response: falcon.Response | None,
+        request: falcon.Request | None,
+        request_host: str,
+        page: str,
+        pretty: bool,
+    ) -> dict[str, Any] | None:
+        """Serve one page of the unfiltered `/cards` listing.
+
+        Args:
+            falcon_response: The Falcon response to write to.
+            request: The Falcon request, read for the scheme `next_page` should use.
+            request_host: Host the request arrived on.
+            page: 1-based page number.
+            pretty: Whether to indent JSON output.
+
+        Returns:
+            A List object of cards, or a Scryfall error object.
+        """
+        # `or 1` would swallow page=0 into page=1; an unparseable page defaults, a non-positive
+        # one is rejected below.
+        parsed_page = _as_int(page)
+        page_number = 1 if parsed_page is None else parsed_page
+        if page_number < 1:
+            return self._scryfall_respond(
+                falcon_response,
+                bad_request_error("The page parameter must be a positive integer."),
+                pretty=pretty,
+            )
+        total = self._run_query(query="SELECT count(1) AS total FROM magic.cards", explain=False)["result"][0]["total"]
+        rows = self._run_query(
+            query=(
+                f"SELECT {_CARD_COLUMNS} FROM magic.cards AS card "
+                "ORDER BY card_name, card_set_code, collector_number_int, collector_number "
+                "LIMIT %(limit)s OFFSET %(offset)s"
+            ),
+            params={"limit": PAGE_SIZE, "offset": (page_number - 1) * PAGE_SIZE},
+            explain=False,
+        )["result"]
+        if not rows:
+            return self._scryfall_respond(falcon_response, not_found_error(_NO_MATCH_DETAILS), pretty=pretty)
+
+        cards = [to_scryfall_card(row) for row in rows]
+        has_more = (page_number - 1) * PAGE_SIZE + len(cards) < total
+        next_page = None
+        if has_more:
+            next_page = objects.build_page_url(_self_base_url(request, request_host, "/cards"), {}, page_number + 1)
+        return self._scryfall_respond(
+            falcon_response,
+            card_list(cards, total_cards=total, has_more=has_more, next_page=next_page),
+            pretty=pretty,
+        )
+
+    def _rulings_for(self, card: dict[str, Any]) -> dict[str, Any]:
+        """Build the rulings List object for a card.
+
+        Newest first, which is the order api.scryfall.com serves and NOT the ascending one this
+        started with. Measured on 2026-08-12 over the cards whose rulings span more than one date:
+        16 of 16 came back `published_at` descending, 0 ascending -- so ascending inverted every
+        multi-date card for a client that had changed nothing but its base URL. Three concrete
+        examples, as Scryfall returns them: Kindred Discovery 2023-09-01, 2022-06-10, 2022-06-10,
+        2017-08-25; Eye of the Storm 2006-02-01, 2006-01-01, 2005-10-01 x3; Diabolic Intent
+        2022-10-14 x2, 2013-04-15 x2, 2004-10-04.
+
+        WITHIN one date the order cannot be reproduced from the bulk file, and `comment` is a
+        deterministic stand-in rather than a claim to match. Scryfall orders same-date rulings by an
+        internal ruling id; the file carries no id, and none of the file's own order, that order
+        reversed, comment ascending or comment descending matched on any of 10 sampled cards that
+        have a date carrying several rulings. That is most cards -- 13,847 of the 19,770 with
+        rulings, against the 2026-08-11 dump -- so the remaining 5,923 (one ruling, or one per date)
+        are the ones this now matches exactly. See docs/issues/local-scryfall-cards-api.md.
+
+        Args:
+            card: The card whose oracle id the rulings hang off.
+
+        Returns:
+            A List object of Ruling objects, empty when the card has none.
+        """
+        oracle_id = card.get("oracle_id")
+        if not oracle_id:
+            return card_list([])
+        rows = self._run_query(
+            query=(
+                "SELECT oracle_id, source, published_at, comment FROM magic.rulings "
+                "WHERE oracle_id = %(oracle_id)s ORDER BY published_at DESC, comment"
+            ),
+            params={"oracle_id": str(oracle_id)},
+            explain=False,
+        )["result"]
+        return card_list([ruling_object(row) for row in rows])
diff --git a/api/scryfall_reference_import.py b/api/scryfall_reference_import.py
new file mode 100644
index 000000000..8d6e0e0c6
--- /dev/null
+++ b/api/scryfall_reference_import.py
@@ -0,0 +1,165 @@
+"""Mirror Scryfall's reference data — sets, catalogs and card symbols — into `magic`.
+
+These three are not bulk data. Scryfall publishes them as ordinary API endpoints, small enough to
+fetch whole: 1,047 sets, twenty catalogs totalling around 60,000 strings, and 84 card symbols. So
+this module talks to `api.scryfall.com` directly through the bulk fetcher's retrying session rather
+than through `stream_data_for_key`.
+
+Every load is a whole-table replace inside one transaction, for the reason the rulings load is: the
+upstream response is the entire truth each time, a set can be renamed or withdrawn before release,
+and a replace cannot get the pruning wrong. `DELETE` rather than `TRUNCATE` so readers keep seeing
+the previous contents through MVCC instead of blocking on an ACCESS EXCLUSIVE lock.
+
+Why mirrored and not derived: the corpus cannot answer these. A Set object carries eight fields no
+card carries, `card_count` counts printings this instance deliberately never imported, and a card
+symbol's `svg_uri` exists nowhere in the card data. The full argument is in the migration header,
+`api/db/2026-08-11-02-scryfall-sets-catalogs-symbology.sql`.
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from typing import TYPE_CHECKING, Any
+
+from psycopg.types.json import Jsonb
+
+from api.scryfall_compat.reference_routes import CATALOG_NAMES
+
+if TYPE_CHECKING:
+    import psycopg_pool
+
+    from api.scryfall_bulk_data_fetcher import ScryfallBulkDataFetcher
+
+logger = logging.getLogger(__name__)
+
+
+def import_sets(conn_pool: psycopg_pool.ConnectionPool, fetcher: ScryfallBulkDataFetcher) -> dict[str, Any]:
+    """Replace `magic.sets` with Scryfall's current set list.
+
+    Args:
+        conn_pool: Pool to run the load through.
+        fetcher: Fetcher whose session the request goes through.
+
+    Returns:
+        A summary of the load.
+    """
+    start = time.monotonic()
+    payload = fetcher.fetch_api_json("sets")
+    sets = [entry for entry in payload.get("data", []) if entry.get("id") and entry.get("code")]
+
+    rows = [
+        {
+            "id": entry["id"],
+            "code": entry["code"],
+            "tcgplayer_id": entry.get("tcgplayer_id"),
+            "position": position,
+            "set_object": Jsonb(entry),
+        }
+        for position, entry in enumerate(sets)
+    ]
+
+    with conn_pool.connection() as conn:
+        with conn.cursor() as cursor:
+            cursor.execute("DELETE FROM magic.sets")
+            cursor.executemany(
+                "INSERT INTO magic.sets (id, code, tcgplayer_id, position, set_object) "
+                "VALUES (%(id)s, %(code)s, %(tcgplayer_id)s, %(position)s, %(set_object)s) "
+                "ON CONFLICT (id) DO NOTHING",
+                rows,
+            )
+        conn.commit()
+
+    result = {
+        "duration_seconds": round(time.monotonic() - start, 2),
+        "sets_imported": len(rows),
+        "sets_with_tcgplayer_id": sum(1 for row in rows if row["tcgplayer_id"] is not None),
+    }
+    logger.info("Set import complete: %s", result)
+    return result
+
+
+def import_catalogs(conn_pool: psycopg_pool.ConnectionPool, fetcher: ScryfallBulkDataFetcher) -> dict[str, Any]:
+    """Replace `magic.catalogs` with the current contents of every documented catalog.
+
+    A catalog that fails to fetch is skipped rather than fatal, and its previous row is left in
+    place: nineteen fresh catalogs and one stale one is a better answer than aborting the refresh.
+
+    Args:
+        conn_pool: Pool to run the load through.
+        fetcher: Fetcher whose session the requests go through.
+
+    Returns:
+        A summary of the load.
+    """
+    start = time.monotonic()
+    fetched: dict[str, list[str]] = {}
+    failed: list[str] = []
+    for name in CATALOG_NAMES:
+        try:
+            payload = fetcher.fetch_api_json(f"catalog/{name}")
+        except Exception:
+            logger.exception("Catalog %s could not be fetched; keeping the previous contents", name)
+            failed.append(name)
+            continue
+        values = payload.get("data")
+        if isinstance(values, list):
+            fetched[name] = [value for value in values if isinstance(value, str)]
+        else:
+            failed.append(name)
+
+    with conn_pool.connection() as conn:
+        with conn.cursor() as cursor:
+            # Only the catalogs that came back are replaced, so a failed fetch keeps its old row.
+            cursor.executemany(
+                "INSERT INTO magic.catalogs (name, entries) VALUES (%(name)s, %(entries)s) "
+                "ON CONFLICT (name) DO UPDATE SET entries = EXCLUDED.entries",
+                [{"name": name, "entries": Jsonb(values)} for name, values in fetched.items()],
+            )
+        conn.commit()
+
+    result = {
+        "duration_seconds": round(time.monotonic() - start, 2),
+        "catalogs_imported": len(fetched),
+        "catalogs_failed": len(failed),
+        "values_imported": sum(len(values) for values in fetched.values()),
+    }
+    logger.info("Catalog import complete: %s", result)
+    return result
+
+
+def import_symbology(conn_pool: psycopg_pool.ConnectionPool, fetcher: ScryfallBulkDataFetcher) -> dict[str, Any]:
+    """Replace `magic.card_symbols` with Scryfall's current symbol list.
+
+    Args:
+        conn_pool: Pool to run the load through.
+        fetcher: Fetcher whose session the request goes through.
+
+    Returns:
+        A summary of the load.
+    """
+    start = time.monotonic()
+    payload = fetcher.fetch_api_json("symbology")
+    symbols = [entry for entry in payload.get("data", []) if entry.get("symbol")]
+
+    rows = [
+        {"symbol": entry["symbol"], "position": position, "symbol_object": Jsonb(entry)} for position, entry in enumerate(symbols)
+    ]
+
+    with conn_pool.connection() as conn:
+        with conn.cursor() as cursor:
+            cursor.execute("DELETE FROM magic.card_symbols")
+            cursor.executemany(
+                "INSERT INTO magic.card_symbols (symbol, position, symbol_object) "
+                "VALUES (%(symbol)s, %(position)s, %(symbol_object)s) "
+                "ON CONFLICT (symbol) DO NOTHING",
+                rows,
+            )
+        conn.commit()
+
+    result = {
+        "duration_seconds": round(time.monotonic() - start, 2),
+        "symbols_imported": len(rows),
+    }
+    logger.info("Symbology import complete: %s", result)
+    return result
diff --git a/api/static/app.js b/api/static/app.js
index cb0050c32..046b3e28e 100644
--- a/api/static/app.js
+++ b/api/static/app.js
@@ -105,6 +105,7 @@ class CardSearch {
     this.currentRequestUrl = null; // URL of the in-flight request, if any
     this.imageObserver = null;
     this.cardsData = new Map(); // Store card data by ID
+    this.backFaceKeys = new Map(); // "set/collector" -> bool, cached back-face image probes
     this.lastCompletedUrl = null; // URL whose results are currently displayed; null when results are cleared
     this.isAscending = true; // Track order direction
     this.currentCardCount = 0; // Track current number of cards displayed for resize handling
@@ -962,6 +963,9 @@ class CardSearch {
         .join('');
     }
 
+    // Runs against the DOM, so it enhances SSR-rendered and JS-rendered cards alike.
+    this.enhanceDoubleFacedCards();
+
     // Record arrival time; we only push this state when leaving if they stayed > DWELL_MS and it's not already saved (updateURL)
     const url = this.buildCurrentSearchUrl();
     window.history.replaceState({ arrivalTime: Date.now() }, '', url);
@@ -1008,9 +1012,134 @@ class CardSearch {
     this.resultsContainer.style.gridTemplateColumns = `repeat(${actualColumns}, 1fr)`;
   }
 
-  buildImageUrl(card, size) {
-    const face = card.face_idx || 1;
-    return `https://d1hot9ps2xugbc.cloudfront.net/img/${card.set_code}/${card.collector_number}/${face}/${size}.webp`;
+  buildImageUrl(card, size, face) {
+    const resolvedFace = face || card.face_idx || 1;
+    return `https://d1hot9ps2xugbc.cloudfront.net/img/${card.set_code}/${card.collector_number}/${resolvedFace}/${size}.webp`;
+  }
+
+  buildSrcset(card, face) {
+    return ['280', '388', '538', '745'].map(size => `${this.buildImageUrl(card, size, face)} ${size}w`).join(', ');
+  }
+
+  // ── Double-faced cards: flip button (progressive enhancement) ──
+  // The rendered card HTML is shared with the no-JS server renderer (parity fixture), so the
+  // flip button is injected AFTER render rather than templated in. A card gets one when a
+  // face-2 image exists on the CDN — which is exactly the set of cards with a physical back
+  // face (transform/MDFC), since the image sync only uploads face 2 for those. Split and
+  // adventure cards share a "//" name but have no face-2 image, so they correctly get none.
+
+  cardBackFaceKey(card) {
+    return `${card.set_code}/${card.collector_number}`;
+  }
+
+  probeBackFace(card, onExists) {
+    if (!card.name || !card.name.includes(' // ') || !card.set_code || !card.collector_number) {
+      return;
+    }
+    const key = this.cardBackFaceKey(card);
+    if (this.backFaceKeys.has(key)) {
+      if (this.backFaceKeys.get(key)) onExists();
+      return;
+    }
+    const probe = new Image();
+    probe.onload = () => {
+      this.backFaceKeys.set(key, true);
+      onExists();
+    };
+    probe.onerror = () => this.backFaceKeys.set(key, false);
+    probe.src = this.buildImageUrl(card, '280', 2);
+  }
+
+  enhanceDoubleFacedCards() {
+    for (const [cardId, card] of this.cardsData) {
+      this.probeBackFace(card, () => this.attachGridFlipButton(cardId, card));
+    }
+  }
+
+  // The button is positioned as a percentage of the CARD IMAGE, so it needs a
+  // containing block that is exactly the image's box. Neither natural parent is:
+  // a grid tile is the image plus the name/type/text rows, and the modal's image
+  // wrapper is a flex area far wider than the picture inside it — which is how
+  // the button ended up floating in the margin beside a large card.
+  //
+  // The frame cannot be the <a> that already wraps the image: a <button> inside
+  // an <a> is interactive content nested in interactive content, which is invalid
+  // and breaks keyboard traversal. So JS inserts a plain <div> around the link.
+  // Injecting it here rather than in the server markup keeps the no-JS render —
+  // and its parity fixture — untouched, and the frame only ever exists on the
+  // cards that actually get a button.
+  frameFor(container, imageSelector) {
+    const existing = container.querySelector('.card-image-frame');
+    if (existing) return existing;
+    const img = container.querySelector(imageSelector);
+    if (!img) return null;
+    // Frame the link if the image is wrapped in one, so the whole clickable area
+    // stays inside the frame; otherwise frame the bare image.
+    const node = img.closest('a') || img;
+    const frame = document.createElement('div');
+    frame.className = 'card-image-frame';
+    node.parentNode.insertBefore(frame, node);
+    frame.appendChild(node);
+    return frame;
+  }
+
+  createFlipButton(onFlip) {
+    const button = document.createElement('button');
+    button.type = 'button';
+    button.className = 'card-flip-button';
+    button.title = 'Transform';
+    button.setAttribute('aria-label', 'Show other face');
+    button.setAttribute('aria-pressed', 'false');
+    // An SVG, not a text glyph: a glyph's ink box is not its em box, so no amount of
+    // flex centring puts it in the middle of the disc. currentColor means the inverted
+    // back-face state restyles it with no extra rule.
+    button.innerHTML =
+      '<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke-width="1.5" stroke="currentColor" aria-hidden="true" focusable="false"><path stroke-linecap="round" stroke-linejoin="round" d="M16.023 9.348h4.992v-.001M2.985 19.644v-4.992m0 0h4.992m-4.993 0 3.181 3.183a8.25 8.25 0 0 0 13.803-3.7M4.031 9.865a8.25 8.25 0 0 1 13.803-3.7l3.181 3.182m0-4.991v4.99" /></svg>';
+    button.addEventListener('click', event => {
+      event.preventDefault();
+      event.stopPropagation();
+      onFlip();
+    });
+    return button;
+  }
+
+  attachGridFlipButton(cardId, card) {
+    // cardId is the numeric grid index (displayCards), safe to interpolate directly.
+    const item = this.resultsContainer && this.resultsContainer.querySelector(`.card-item[data-card-id="${cardId}"]`);
+    if (!item || item.querySelector('.card-flip-button')) {
+      return;
+    }
+    const frame = this.frameFor(item, '.card-image');
+    if (!frame) {
+      return;
+    }
+    frame.appendChild(
+      this.createFlipButton(() => this.flipCardImage(item.querySelector('.card-image'), card, frame, '388', true))
+    );
+  }
+
+  flipCardImage(img, card, faceHolder, size, withSrcset) {
+    if (!img) {
+      return;
+    }
+    const nextFace = faceHolder.dataset.shownFace === '2' ? 1 : 2;
+    faceHolder.dataset.shownFace = String(nextFace);
+    // The button inverts while the back is showing: once the art has changed it is
+    // the only thing that still says which face this is. Toggled immediately, not
+    // inside the timeout, so the control answers the click rather than lagging it.
+    const flipButton = faceHolder.querySelector('.card-flip-button');
+    if (flipButton) {
+      flipButton.classList.toggle('showing-back', nextFace === 2);
+      flipButton.setAttribute('aria-pressed', nextFace === 2 ? 'true' : 'false');
+    }
+    img.classList.add('card-image-flipping');
+    setTimeout(() => {
+      img.src = this.buildImageUrl(card, size, nextFace);
+      if (withSrcset) {
+        img.srcset = this.buildSrcset(card, nextFace);
+      }
+      img.classList.remove('card-image-flipping');
+    }, 150);
   }
 
   createCardHTML(card, index, isFirstRow = false) {
@@ -1182,6 +1311,23 @@ class CardSearch {
       </div>
     `;
 
+    // Flip button for cards with a physical back face (cached probe from the grid, or fresh)
+    this.probeBackFace(card, () => {
+      const wrapper = modalContent.querySelector('.modal-image-wrapper');
+      if (!wrapper || wrapper.querySelector('.card-flip-button')) {
+        return;
+      }
+      const frame = this.frameFor(wrapper, '.modal-image');
+      if (!frame) {
+        return;
+      }
+      frame.appendChild(
+        this.createFlipButton(() =>
+          this.flipCardImage(wrapper.querySelector('.modal-image'), card, frame, '745', false)
+        )
+      );
+    });
+
     // Show modal
     modalOverlay.style.display = 'flex';
 
diff --git a/api/static/app.test.js b/api/static/app.test.js
index 738c46490..712ec4b70 100644
--- a/api/static/app.test.js
+++ b/api/static/app.test.js
@@ -739,3 +739,70 @@ describe('CardSearch getColumnsFromViewportWidth', () => {
     expect(search.getColumnsFromViewportWidth()).toBe(expectedColumns);
   });
 });
+
+describe('CardSearch double-faced flip', () => {
+  const dfc = { name: 'Front // Back', set_code: 'mid', collector_number: '5' };
+
+  test('buildImageUrl face parameter overrides the card face', () => {
+    expect(search.buildImageUrl(dfc, '388')).toContain('/mid/5/1/388.webp');
+    expect(search.buildImageUrl(dfc, '388', 2)).toContain('/mid/5/2/388.webp');
+  });
+
+  test('buildSrcset builds all four sizes for the requested face', () => {
+    const srcset = search.buildSrcset(dfc, 2);
+    for (const size of ['280', '388', '538', '745']) {
+      expect(srcset).toContain(`/mid/5/2/${size}.webp ${size}w`);
+    }
+  });
+
+  test('probeBackFace skips cards without a // name', () => {
+    const onExists = jest.fn();
+    search.probeBackFace({ name: 'Lightning Bolt', set_code: 'm15', collector_number: '1' }, onExists);
+    expect(onExists).not.toHaveBeenCalled();
+    expect(search.backFaceKeys.size).toBe(0);
+  });
+
+  test('probeBackFace uses the cached probe result', () => {
+    const onExists = jest.fn();
+    search.backFaceKeys.set('mid/5', true);
+    search.probeBackFace(dfc, onExists);
+    expect(onExists).toHaveBeenCalledTimes(1);
+
+    search.backFaceKeys.set('mid/5', false);
+    search.probeBackFace(dfc, onExists);
+    expect(onExists).toHaveBeenCalledTimes(1);
+  });
+
+  test('flip button toggles the image between faces', () => {
+    jest.useFakeTimers();
+    try {
+      search.resultsContainer.innerHTML =
+        '<div class="card-item" data-card-id="0"><img class="card-image" src="x" srcset="y" /></div>';
+      search.attachGridFlipButton('0', dfc);
+
+      const item = search.resultsContainer.querySelector('.card-item');
+      const button = item.querySelector('.card-flip-button');
+      expect(button).not.toBeNull();
+
+      button.click();
+      jest.runAllTimers();
+      const img = item.querySelector('.card-image');
+      expect(img.src).toContain('/mid/5/2/388.webp');
+      expect(img.srcset).toContain('/mid/5/2/745.webp 745w');
+
+      button.click();
+      jest.runAllTimers();
+      expect(img.src).toContain('/mid/5/1/388.webp');
+    } finally {
+      jest.useRealTimers();
+    }
+  });
+
+  test('attachGridFlipButton injects at most one button', () => {
+    search.resultsContainer.innerHTML =
+      '<div class="card-item" data-card-id="0"><img class="card-image" src="x" /></div>';
+    search.attachGridFlipButton('0', dfc);
+    search.attachGridFlipButton('0', dfc);
+    expect(search.resultsContainer.querySelectorAll('.card-flip-button')).toHaveLength(1);
+  });
+});
diff --git a/api/static/card.js b/api/static/card.js
index 81cd19619..e96c9273a 100644
--- a/api/static/card.js
+++ b/api/static/card.js
@@ -7,9 +7,63 @@ function escapeHtml(str) {
   return String(str).replace(HTML_ESCAPE_RE, c => HTML_ESCAPE_MAP[c]);
 }
 
-function buildImageUrl(card, size) {
-  const face = card.face_idx || 1;
-  return `https://d1hot9ps2xugbc.cloudfront.net/img/${card.set_code}/${card.collector_number}/${face}/${size}.webp`;
+function buildImageUrl(card, size, face) {
+  const resolvedFace = face || card.face_idx || 1;
+  return `https://d1hot9ps2xugbc.cloudfront.net/img/${card.set_code}/${card.collector_number}/${resolvedFace}/${size}.webp`;
+}
+
+// Flip button for double-faced cards, mirroring the search page's progressive enhancement:
+// shown only when a face-2 image exists on the CDN (transform/MDFC backs; split and
+// adventure cards have no back image and correctly get no button).
+function attachFlipButton(container, card) {
+  if (!card.name || !card.name.includes(' // ') || !card.set_code || !card.collector_number) return;
+  const probe = new Image();
+  probe.onload = () => {
+    const wrapper = container.querySelector('.modal-image-wrapper');
+    if (!wrapper || wrapper.querySelector('.card-flip-button')) return;
+    // A frame that hugs the image, so the button's percentage offsets resolve
+    // against the picture rather than the flex area around it. See app.js.
+    const img = wrapper.querySelector('.modal-image');
+    if (!img) return;
+    let frame = wrapper.querySelector('.card-image-frame');
+    if (!frame) {
+      const node = img.closest('a') || img;
+      frame = document.createElement('div');
+      frame.className = 'card-image-frame';
+      node.parentNode.insertBefore(frame, node);
+      frame.appendChild(node);
+    }
+    const button = document.createElement('button');
+    button.type = 'button';
+    button.className = 'card-flip-button';
+    button.title = 'Transform';
+    button.setAttribute('aria-label', 'Show other face');
+    button.setAttribute('aria-pressed', 'false');
+    // An SVG, not a text glyph: a glyph's ink box is not its em box, so no amount of
+    // flex centring puts it in the middle of the disc. currentColor means the inverted
+    // back-face state restyles it with no extra rule.
+    button.innerHTML =
+      '<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke-width="1.5" stroke="currentColor" aria-hidden="true" focusable="false"><path stroke-linecap="round" stroke-linejoin="round" d="M16.023 9.348h4.992v-.001M2.985 19.644v-4.992m0 0h4.992m-4.993 0 3.181 3.183a8.25 8.25 0 0 0 13.803-3.7M4.031 9.865a8.25 8.25 0 0 1 13.803-3.7l3.181 3.182m0-4.991v4.99" /></svg>';
+    button.addEventListener('click', event => {
+      event.preventDefault();
+      event.stopPropagation();
+      const img = wrapper.querySelector('.modal-image');
+      if (!img) return;
+      const nextFace = wrapper.dataset.shownFace === '2' ? 1 : 2;
+      wrapper.dataset.shownFace = String(nextFace);
+      // Inverted while the back is showing, toggled now rather than after the
+      // transition so the control answers the click.
+      button.classList.toggle('showing-back', nextFace === 2);
+      button.setAttribute('aria-pressed', nextFace === 2 ? 'true' : 'false');
+      img.classList.add('card-image-flipping');
+      setTimeout(() => {
+        img.src = buildImageUrl(card, '745', nextFace);
+        img.classList.remove('card-image-flipping');
+      }, 150);
+    });
+    frame.appendChild(button);
+  };
+  probe.src = buildImageUrl(card, '280', 2);
 }
 
 const MANA_SYMBOLS = new Map([
@@ -217,6 +271,7 @@ async function main() {
   const cardFace = document.getElementById('card-face');
   cardFace.innerHTML = renderCardFace(card);
   cardFace.style.display = '';
+  attachFlipButton(cardFace, card);
   document.getElementById('card-loading').style.display = 'none';
 
   try {
diff --git a/api/static/index.html b/api/static/index.html
index 39d8f1a1c..04f4373e4 100644
--- a/api/static/index.html
+++ b/api/static/index.html
@@ -125,7 +125,13 @@ <h1 id="site-title">%%%SITENAME%%%</h1>
             <option value="power">Power</option>
             <option value="toughness">Toughness</option>
             <option value="rarity">Rarity</option>
+            <option value="released">Released</option>
+            <option value="set">Set</option>
+            <option value="artist">Artist</option>
+            <option value="color">Color</option>
             <option value="usd">USD</option>
+            <option value="eur">EUR</option>
+            <option value="tix">TIX</option>
           </select>
           <label for="uniqueDropdown" class="dropdown-label">Unique Mode:</label>
           <select class="order-dropdown" id="uniqueDropdown" name="unique">
@@ -138,8 +144,8 @@ <h1 id="site-title">%%%SITENAME%%%</h1>
             <option value="default">Default</option>
             <option value="oldest">Oldest</option>
             <option value="newest">Newest</option>
-            <option value="usd-low">$ Low</option>
-            <option value="usd-high">$ High</option>
+            <option value="usd_low">$ Low</option>
+            <option value="usd_high">$ High</option>
             <option value="promo">Promo</option>
           </select>
           <input type="hidden" name="direction" id="directionInput" value="asc" />
diff --git a/api/static/styles.css b/api/static/styles.css
index e0aae8ab2..64ff4176c 100644
--- a/api/static/styles.css
+++ b/api/static/styles.css
@@ -527,6 +527,107 @@ body {
   display: flex;
   align-items: center;
   justify-content: center;
+  position: relative; /* anchors the injected .card-flip-button over the image */
+}
+
+/* Flip button for double-faced cards, injected by JS when a back-face image exists.
+   Sits over the card image's top-right corner, like Scryfall's transform button. */
+/* Geometry, colours and timing taken from Scryfall's own
+   .card-grid-item-transform-button, so the control reads as the same control. */
+.card-flip-button {
+  position: absolute;
+  /* NOT a corner. Scryfall places it over the right edge of the artwork about a
+     quarter of the way down — roughly where the transform icon sits on the
+     printed card. Percentages OF .card-image-frame, which hugs the image, so
+     they mean the same thing in a grid tile and in a full-size modal. */
+  top: 26%;
+  left: 75%;
+  z-index: 2;
+  box-sizing: border-box;
+  width: 44px;
+  height: 44px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  /* White disc, dark ring — it has to read against both a black card border and
+     bright artwork, and inverting to a dark fill loses it against the border. */
+  border: 2px solid #343242;
+  border-radius: 100%;
+  background: #fff;
+  color: #343242;
+  line-height: 1;
+  cursor: pointer;
+  /* Always present, dimmed. Revealing on hover would make it undiscoverable on
+     touch, where there is no hover at all — and Scryfall does not hide it either. */
+  opacity: 0.6;
+  transition:
+    background-color 200ms linear,
+    opacity 50ms linear;
+}
+
+/* Inverted while the BACK face is showing (Scryfall's `.spooky`). The button is
+   the only thing on screen that says which face you are looking at once the art
+   has changed, so it carries the state rather than just the action. */
+.card-flip-button.showing-back {
+  background: #343242;
+  border-color: #fff;
+  color: #fff;
+}
+
+/* 22px inside the 44px disc. Scryfall insets its icon by 7px, but its artwork
+   carries padding inside its own viewBox; this outline stroke runs to the edge
+   of the 24-unit box, so matching their inset makes a visibly bigger mark.
+   Matching the resulting INK is what makes it read the same.
+   display:block drops the inline baseline gap, which is what otherwise leaves
+   an SVG sitting a pixel or two high in a flex-centred button. */
+.card-flip-button svg {
+  display: block;
+  width: 22px;
+  height: 22px;
+}
+
+.card-flip-button:hover,
+.card-flip-button:active,
+.card-flip-button:focus-visible {
+  opacity: 1;
+}
+
+.card-flip-button:focus-visible {
+  outline: 2px solid #343242;
+  outline-offset: 2px;
+}
+
+.card-flip-button.showing-back:focus-visible {
+  outline-color: #fff;
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .card-flip-button {
+    transition: none;
+  }
+}
+
+.card-image-flipping {
+  transform: rotateY(90deg);
+}
+
+/* Hugs the card image so the flip button can be positioned as a percentage OF
+   THE IMAGE. Injected by JS alongside the button, never present in the server
+   render. Neither natural parent works: a grid tile also contains the name,
+   type and text rows, and the modal's image wrapper is a flex area much wider
+   than the picture — which is how the button ended up beside a large card
+   rather than on it. fit-content makes the box the image's box in both. */
+.card-image-frame {
+  position: relative;
+  width: fit-content;
+  max-width: 100%;
+  margin-inline: auto;
+  line-height: 0;
+}
+
+.card-image,
+.modal-image {
+  transition: transform 0.15s ease;
 }
 
 .modal-image-link {
diff --git a/api/tests/fixtures/engine_cards.json b/api/tests/fixtures/engine_cards.json
index 17946cdbf..865b4a097 100644
--- a/api/tests/fixtures/engine_cards.json
+++ b/api/tests/fixtures/engine_cards.json
@@ -1386,6 +1386,7 @@
     "mana_cost_text": "{2}{U}{U}",
     "oracle_text": "+2: Look at the top card of target player's library. You may put that card on the bottom of that player's library.\n0: Draw three cards, then put two cards from your hand on top of your library in any order.\n−1: Return target creature to its owner's hand.\n−12: Exile all cards from target player's library, then that player shuffles their hand into their library.",
     "planeswalker_loyalty": 3,
+    "planeswalker_loyalty_text": "3",
     "price_eur": 17.1,
     "price_tix": 0.3,
     "price_usd": 24.64,
@@ -1471,6 +1472,7 @@
     "mana_cost_text": "{2}{U}{U}",
     "oracle_text": "+2: Look at the top card of target player's library. You may put that card on the bottom of that player's library.\n0: Draw three cards, then put two cards from your hand on top of your library in any order.\n−1: Return target creature to its owner's hand.\n−12: Exile all cards from target player's library, then that player shuffles their hand into their library.",
     "planeswalker_loyalty": 3,
+    "planeswalker_loyalty_text": "3",
     "price_eur": null,
     "price_tix": null,
     "price_usd": null,
@@ -1556,6 +1558,7 @@
     "mana_cost_text": "{2}{U}{U}",
     "oracle_text": "+2: Look at the top card of target player's library. You may put that card on the bottom of that player's library.\n0: Draw three cards, then put two cards from your hand on top of your library in any order.\n−1: Return target creature to its owner's hand.\n−12: Exile all cards from target player's library, then that player shuffles their hand into their library.",
     "planeswalker_loyalty": 3,
+    "planeswalker_loyalty_text": "3",
     "price_eur": 14.42,
     "price_tix": 0.3,
     "price_usd": 18.45,
@@ -1641,6 +1644,7 @@
     "mana_cost_text": "{2}{U}{U}",
     "oracle_text": "+2: Look at the top card of target player's library. You may put that card on the bottom of that player's library.\n0: Draw three cards, then put two cards from your hand on top of your library in any order.\n−1: Return target creature to its owner's hand.\n−12: Exile all cards from target player's library, then that player shuffles their hand into their library.",
     "planeswalker_loyalty": 3,
+    "planeswalker_loyalty_text": "3",
     "price_eur": 14.98,
     "price_tix": 0.7,
     "price_usd": 17.42,
@@ -1726,6 +1730,7 @@
     "mana_cost_text": "{2}{U}{U}",
     "oracle_text": "+2: Look at the top card of target player's library. You may put that card on the bottom of that player's library.\n0: Draw three cards, then put two cards from your hand on top of your library in any order.\n−1: Return target creature to its owner's hand.\n−12: Exile all cards from target player's library, then that player shuffles their hand into their library.",
     "planeswalker_loyalty": 3,
+    "planeswalker_loyalty_text": "3",
     "price_eur": null,
     "price_tix": 2.82,
     "price_usd": null,
@@ -1811,6 +1816,7 @@
     "mana_cost_text": "{2}{U}{U}",
     "oracle_text": "+2: Look at the top card of target player's library. You may put that card on the bottom of that player's library.\n0: Draw three cards, then put two cards from your hand on top of your library in any order.\n−1: Return target creature to its owner's hand.\n−12: Exile all cards from target player's library, then that player shuffles their hand into their library.",
     "planeswalker_loyalty": 3,
+    "planeswalker_loyalty_text": "3",
     "price_eur": 14.67,
     "price_tix": 2.42,
     "price_usd": 17.42,
@@ -1896,6 +1902,7 @@
     "mana_cost_text": "{2}{U}{U}",
     "oracle_text": "+2: Look at the top card of target player's library. You may put that card on the bottom of that player's library.\n0: Draw three cards, then put two cards from your hand on top of your library in any order.\n−1: Return target creature to its owner's hand.\n−12: Exile all cards from target player's library, then that player shuffles their hand into their library.",
     "planeswalker_loyalty": 3,
+    "planeswalker_loyalty_text": "3",
     "price_eur": 18.01,
     "price_tix": null,
     "price_usd": 24.16,
@@ -1981,6 +1988,7 @@
     "mana_cost_text": "{2}{U}{U}",
     "oracle_text": "+2: Look at the top card of target player's library. You may put that card on the bottom of that player's library.\n0: Draw three cards, then put two cards from your hand on top of your library in any order.\n−1: Return target creature to its owner's hand.\n−12: Exile all cards from target player's library, then that player shuffles their hand into their library.",
     "planeswalker_loyalty": 3,
+    "planeswalker_loyalty_text": "3",
     "price_eur": 122.14,
     "price_tix": null,
     "price_usd": 306.59,
@@ -2066,6 +2074,7 @@
     "mana_cost_text": "{2}{U}{U}",
     "oracle_text": "+2: Look at the top card of target player's library. You may put that card on the bottom of that player's library.\n0: Draw three cards, then put two cards from your hand on top of your library in any order.\n−1: Return target creature to its owner's hand.\n−12: Exile all cards from target player's library, then that player shuffles their hand into their library.",
     "planeswalker_loyalty": 3,
+    "planeswalker_loyalty_text": "3",
     "price_eur": 24.09,
     "price_tix": 2.35,
     "price_usd": 25.55,
@@ -2152,6 +2161,7 @@
     "mana_cost_text": "{2}{U}{U}",
     "oracle_text": "+2: Look at the top card of target player's library. You may put that card on the bottom of that player's library.\n0: Draw three cards, then put two cards from your hand on top of your library in any order.\n−1: Return target creature to its owner's hand.\n−12: Exile all cards from target player's library, then that player shuffles their hand into their library.",
     "planeswalker_loyalty": 3,
+    "planeswalker_loyalty_text": "3",
     "price_eur": null,
     "price_tix": 1.5,
     "price_usd": null,
@@ -3079,6 +3089,7 @@
     "mana_cost_text": "{4}{U}{B}{B}{R}",
     "oracle_text": "+3: Destroy target noncreature permanent.\n−2: Gain control of target creature.\n−9: Nicol Bolas deals 7 damage to target player or planeswalker. That player or that planeswalker's controller discards seven cards, then sacrifices seven permanents of their choice.",
     "planeswalker_loyalty": 5,
+    "planeswalker_loyalty_text": "5",
     "price_eur": 2.94,
     "price_tix": 0.02,
     "price_usd": 3.81,
@@ -3174,6 +3185,7 @@
     "mana_cost_text": "{4}{U}{B}{B}{R}",
     "oracle_text": "+3: Destroy target noncreature permanent.\n−2: Gain control of target creature.\n−9: Nicol Bolas deals 7 damage to target player or planeswalker. That player or that planeswalker's controller discards seven cards, then sacrifices seven permanents of their choice.",
     "planeswalker_loyalty": 5,
+    "planeswalker_loyalty_text": "5",
     "price_eur": null,
     "price_tix": null,
     "price_usd": null,
@@ -3269,6 +3281,7 @@
     "mana_cost_text": "{4}{U}{B}{B}{R}",
     "oracle_text": "+3: Destroy target noncreature permanent.\n−2: Gain control of target creature.\n−9: Nicol Bolas deals 7 damage to target player or planeswalker. That player or that planeswalker's controller discards seven cards, then sacrifices seven permanents of their choice.",
     "planeswalker_loyalty": 5,
+    "planeswalker_loyalty_text": "5",
     "price_eur": 2.66,
     "price_tix": 0.02,
     "price_usd": 3.53,
@@ -3364,6 +3377,7 @@
     "mana_cost_text": "{4}{U}{B}{B}{R}",
     "oracle_text": "+3: Destroy target noncreature permanent.\n−2: Gain control of target creature.\n−9: Nicol Bolas deals 7 damage to target player or planeswalker. That player or that planeswalker's controller discards seven cards, then sacrifices seven permanents of their choice.",
     "planeswalker_loyalty": 5,
+    "planeswalker_loyalty_text": "5",
     "price_eur": 2.78,
     "price_tix": null,
     "price_usd": 2.78,
@@ -3459,6 +3473,7 @@
     "mana_cost_text": "{4}{U}{B}{B}{R}",
     "oracle_text": "+3: Destroy target noncreature permanent.\n−2: Gain control of target creature.\n−9: Nicol Bolas deals 7 damage to target player or planeswalker. That player or that planeswalker's controller discards seven cards, then sacrifices seven permanents of their choice.",
     "planeswalker_loyalty": 5,
+    "planeswalker_loyalty_text": "5",
     "price_eur": null,
     "price_tix": 4.61,
     "price_usd": null,
@@ -3554,6 +3569,7 @@
     "mana_cost_text": "{4}{U}{B}{B}{R}",
     "oracle_text": "+3: Destroy target noncreature permanent.\n−2: Gain control of target creature.\n−9: Nicol Bolas deals 7 damage to target player or planeswalker. That player or that planeswalker's controller discards seven cards, then sacrifices seven permanents of their choice.",
     "planeswalker_loyalty": 5,
+    "planeswalker_loyalty_text": "5",
     "price_eur": 5.91,
     "price_tix": null,
     "price_usd": 8.58,
@@ -3649,6 +3665,7 @@
     "mana_cost_text": "{4}{U}{B}{B}{R}",
     "oracle_text": "+3: Destroy target noncreature permanent.\n−2: Gain control of target creature.\n−9: Nicol Bolas deals 7 damage to target player or planeswalker. That player or that planeswalker's controller discards seven cards, then sacrifices seven permanents of their choice.",
     "planeswalker_loyalty": 5,
+    "planeswalker_loyalty_text": "5",
     "price_eur": null,
     "price_tix": null,
     "price_usd": null,
diff --git a/api/tests/test_admin_authenticated_not_found.py b/api/tests/test_admin_authenticated_not_found.py
index e6abd5133..3c98abf90 100644
--- a/api/tests/test_admin_authenticated_not_found.py
+++ b/api/tests/test_admin_authenticated_not_found.py
@@ -31,6 +31,18 @@
 
 TEST_PASSWORD = "correct-horse-battery-staple"
 
+# What an UNAUTHENTICATED caller gets for a path that addresses nothing: Scryfall's error object,
+# not the route listing (scryfall-sets-catalogs-symbology) -- a client pointed here instead of
+# api.scryfall.com parses `code` and `details`, and a listing carries neither. Trivially, no admin
+# route can leak through a body that names no routes at all. The listing -- the full one -- is
+# still what an authenticated caller gets, which is the half of #966 this surface keeps.
+_SCRYFALL_NOT_FOUND = {
+    "object": "error",
+    "code": "not_found",
+    "status": 404,
+    "details": "The requested object or REST method was not found.",
+}
+
 _AUTH_HEADERS = {"Authorization": "Basic d2hvZXZlcjpjb3JyZWN0LWhvcnNlLWJhdHRlcnktc3RhcGxl"}  # whoever:TEST_PASSWORD
 
 
@@ -65,7 +77,7 @@ def test_unauthenticated_404_omits_admin_routes(self, resource: APIResource, adm
         del admin_password
         result = _client(resource).simulate_get("/totally/bogus")
         assert result.status == falcon.HTTP_404
-        assert "setup_schema" not in result.json["description"]["routes"]
+        assert result.json == _SCRYFALL_NOT_FOUND
 
     def test_authenticated_404_includes_admin_routes(self, resource: APIResource, admin_password: str) -> None:
         del admin_password
@@ -78,7 +90,7 @@ def test_wrong_credential_still_gets_the_public_listing(self, resource: APIResou
         wrong = {"Authorization": "Basic d2hvZXZlcjp3cm9uZw=="}  # whoever:wrong
         result = _client(resource).simulate_get("/totally/bogus", headers=wrong)
         assert result.status == falcon.HTTP_404
-        assert "setup_schema" not in result.json["description"]["routes"]
+        assert result.json == _SCRYFALL_NOT_FOUND
 
     def test_authenticated_404_under_the_mount_also_gets_the_full_listing(
         self, resource: APIResource, admin_password: str
@@ -106,7 +118,7 @@ def test_repeated_anonymous_404_is_never_a_cache_hit(self, resource: APIResource
 
         assert first.headers.get("X-Cache") == "miss"
         assert second.headers.get("X-Cache") == "miss"
-        assert "setup_schema" not in second.json["description"]["routes"]
+        assert second.json == _SCRYFALL_NOT_FOUND
 
     def test_repeated_authenticated_404_is_never_a_cache_hit(self, resource: APIResource, admin_password: str) -> None:
         del admin_password
@@ -127,7 +139,7 @@ def test_authenticated_404_is_not_served_to_a_later_unauthenticated_caller(
         unauthed = client.simulate_get("/totally/bogus")
 
         assert f"{ADMIN_MOUNT_PREFIX}/setup_schema" in authed.json["description"]["routes"]
-        assert "setup_schema" not in unauthed.json["description"]["routes"]
+        assert unauthed.json == _SCRYFALL_NOT_FOUND
         assert unauthed.headers.get("X-Cache") != "hit"
 
     def test_unauthenticated_404_does_not_mask_a_later_authenticated_caller(
@@ -138,7 +150,7 @@ def test_unauthenticated_404_does_not_mask_a_later_authenticated_caller(
         unauthed = client.simulate_get("/totally/bogus")
         authed = client.simulate_get("/totally/bogus", headers=_AUTH_HEADERS)
 
-        assert "setup_schema" not in unauthed.json["description"]["routes"]
+        assert unauthed.json == _SCRYFALL_NOT_FOUND
         assert f"{ADMIN_MOUNT_PREFIX}/setup_schema" in authed.json["description"]["routes"]
         assert authed.headers.get("X-Cache") != "hit"
 
diff --git a/api/tests/test_admin_mount.py b/api/tests/test_admin_mount.py
index 1580d0592..a9c5fe9d1 100644
--- a/api/tests/test_admin_mount.py
+++ b/api/tests/test_admin_mount.py
@@ -22,6 +22,19 @@
 EXPECTED_PUBLIC_ROUTES = {
     "_root",
     "card",
+    # The Scryfall-compatible surface (ScryfallCardsRoutes, mixed into APIResource): public by
+    # design, a client points here by swapping its base URL.
+    "cards",
+    "cards/autocomplete",
+    "cards/collection",
+    "cards/named",
+    "cards/random",
+    "cards/search",
+    # The reference half of that surface (ScryfallReferenceRoutes): /sets, /catalog/*, /symbology.
+    "catalog",
+    "sets",
+    "symbology",
+    "symbology/parse-mana",
     "favicon.ico",
     "get_catalog",
     "get_common_keywords",
@@ -50,6 +63,12 @@
     "import_cards_by_search",
     "import_data",
     "import_oracle_tags",
+    # The rulings bulk file, behind the mount with every other import (scryfall-cards-api).
+    "import_rulings",
+    # The reference tables, mirrored off api.scryfall.com (scryfall-sets-catalogs-symbology).
+    "import_catalogs",
+    "import_sets",
+    "import_symbology",
     "ingest_cubecobra",
     "prefer_score_tuner",
     "setup_schema",
diff --git a/api/tests/test_api_resource.py b/api/tests/test_api_resource.py
index 9ab3b8aed..8c78ac5d5 100644
--- a/api/tests/test_api_resource.py
+++ b/api/tests/test_api_resource.py
@@ -235,23 +235,35 @@ def test_positional_path_segments_reach_the_action(self) -> None:
         assert resp.status == falcon.HTTP_200
         assert resp.content_type == "text/html"
 
-    def test_unmatched_route_with_extra_segments_raises_not_found(self) -> None:
-        with pytest.raises(falcon.HTTPNotFound):
-            self._dispatch("/nonexistent/thing/other")
+    def _assert_scryfall_not_found(self, resp: falcon.Response) -> None:
+        """An unresolved path answers Scryfall's error object rather than the route listing."""
+        assert resp.status == falcon.HTTP_404
+        assert resp.content_type == "application/json; charset=utf-8"
+        assert resp.headers["cache-control"] == "no-cache"
+        assert json.loads(resp.text) == {
+            "object": "error",
+            "code": "not_found",
+            "status": 404,
+            "details": "The requested object or REST method was not found.",
+        }
+
+    def test_unmatched_route_with_extra_segments_is_a_scryfall_not_found(self) -> None:
+        # No longer an HTTPNotFound carrying the route listing: a client parses `code` and
+        # `details`, and `{"title": ..., "description": {"routes": ...}}` gives it neither.
+        self._assert_scryfall_not_found(self._dispatch("/nonexistent/thing/other"))
 
     def test_known_zero_arg_route_with_extra_segment_raises_not_found(self) -> None:
         # Regression: a matched action_word that can't absorb a trailing segment (get_pid takes
         # no positional args) used to reach the handler anyway, raising a TypeError that _handle
         # converted to 400 — the extra segment means the path doesn't identify anything, so this
         # should 404 like any other unmatched path.
-        with pytest.raises(falcon.HTTPNotFound):
-            self._dispatch("/get_pid/extra")
+        self._assert_scryfall_not_found(self._dispatch("/get_pid/extra"))
 
-    def test_positional_route_with_too_many_segments_raises_not_found(self) -> None:
+    def test_positional_route_with_too_many_segments_is_not_found(self) -> None:
         # card() accepts exactly 2 positional args (set_code, collector_number); a 3rd segment
-        # should 404 rather than reach the handler.
-        with pytest.raises(falcon.HTTPNotFound):
-            self._dispatch("/card/eoc/104/extra")
+        # should 404 rather than reach the handler. The path identifies nothing, so it gets the
+        # Scryfall-shaped 404 every unresolved path now gets, whatever surface it looks like.
+        self._assert_scryfall_not_found(self._dispatch("/card/eoc/104/extra"))
 
     @pytest.mark.parametrize(argnames=["path"], argvalues=[(url,) for url in REAL_ASSET_URLS])
     def test_static_asset_is_registered_at_its_real_url(self, path: str) -> None:
@@ -279,8 +291,7 @@ def test_static_asset_is_served_at_its_real_url(self, path: str) -> None:
     )
     def test_underscore_spelling_is_no_longer_a_route(self, path: str) -> None:
         # Artifacts of deriving route keys from Python identifiers. Nothing ever linked to them.
-        with pytest.raises(falcon.HTTPNotFound):
-            self._dispatch(path)
+        self._assert_scryfall_not_found(self._dispatch(path))
 
     def test_one_handler_two_paths_shares_a_single_entry(self) -> None:
         # The favicon is requested at the root by browser convention and under /static/ by the
@@ -316,8 +327,7 @@ def test_keyword_only_injection_route_with_extra_segment_raises_not_found(self)
         # While it was positional the segment was absorbed and then silently overwritten by the
         # injected response, so a path identifying nothing still returned 200.
         assert self.api_resource.routes["get_catalog"].positional_capacity == 0
-        with pytest.raises(falcon.HTTPNotFound):
-            self._dispatch("/get_catalog/foo")
+        self._assert_scryfall_not_found(self._dispatch("/get_catalog/foo"))
 
     def test_unconvertible_enum_query_value_is_rejected(self) -> None:
         # orderby is annotated CardOrdering. The raw string used to reach the handler unconverted;
@@ -418,17 +428,13 @@ def test_handle_processes_valid_paths(self) -> None:
             # Should call get_pid method and set response media
             assert mock_resp.media is not None
 
-    def test_handle_raises_not_found_for_invalid_paths(self) -> None:
-        """Test _handle raises HTTPNotFound for invalid paths."""
-        mock_req = MagicMock()
-        mock_req.method = "GET"
-        mock_req.uri = mock_req.path = mock_req.relative_uri = "/nonexistent"
-        mock_req.params = {}
-        mock_resp = MagicMock()
-        mock_resp.complete = False
-
-        with pytest.raises(falcon.HTTPNotFound):
-            self.api_resource._handle(mock_req, mock_resp)
+    def test_handle_answers_a_scryfall_not_found_for_invalid_paths(self) -> None:
+        """_handle writes the error itself now rather than raising for falcon to serialize."""
+        req = falcon.Request(falcon.testing.create_environ(path="/nonexistent"))
+        resp = falcon.Response()
+        self.api_resource._handle(req, resp)
+        assert resp.status == falcon.HTTP_404
+        assert json.loads(resp.text)["code"] == "not_found"
 
     def test_disallowed_query_params_do_not_cause_type_error(self) -> None:
         """Query params named after internal kwargs must be stripped before dispatch."""
diff --git a/api/tests/test_card_ordering.py b/api/tests/test_card_ordering.py
index 7f67409e5..9143800fb 100644
--- a/api/tests/test_card_ordering.py
+++ b/api/tests/test_card_ordering.py
@@ -57,3 +57,47 @@ def test_orderby_column_in_compiled_sql(stub_api_resource: APIResource, ordering
     """Every CardOrdering value should produce its mapped column in the compiled SQL."""
     needle = f", {expected_column} AS sort_value FROM magic.cards"
     assert needle in _compiled_sql(stub_api_resource, ordering)
+
+
+# The columns the SQL path sorts each ordering by. Written out rather than imported so that the
+# mapping is asserted against something, not against itself.
+EXPECTED_SORT_COLUMNS = {
+    CardOrdering.ARTIST: "lower(card_artist)",
+    CardOrdering.CMC: "cmc",
+    CardOrdering.CUBECOBRA: "cubecobra_score",
+    CardOrdering.EDHREC: "edhrec_rank",
+    CardOrdering.EUR: "price_eur",
+    CardOrdering.NAME: "lower(card_name)",
+    CardOrdering.POWER: "creature_power",
+    CardOrdering.RARITY: "card_rarity_int",
+    CardOrdering.RELEASED: "released_at",
+    CardOrdering.SET: "lower(card_set_code)",
+    CardOrdering.TIX: "price_tix",
+    CardOrdering.TOUGHNESS: "creature_toughness",
+    CardOrdering.USD: "price_usd",
+}
+
+
+def test_every_ordering_has_an_expected_column() -> None:
+    """COLOR is the one ordering whose sort key is an expression rather than a column."""
+    assert set(EXPECTED_SORT_COLUMNS) | {CardOrdering.COLOR} == set(CardOrdering)
+
+
+@pytest.mark.parametrize("ordering", sorted(EXPECTED_SORT_COLUMNS), ids=str)
+def test_ordering_sorts_by_its_own_column(stub_api_resource: APIResource, ordering: CardOrdering) -> None:
+    """`sql_orderby` falls back to edhrec_rank on a missing entry, so an unmapped ordering is silent.
+
+    Iterating the enum rather than a list of the orderings that happen to be wired means a member
+    added without its `sql_orderby` entry fails here.
+    """
+    needle = f", {EXPECTED_SORT_COLUMNS[ordering]} AS sort_value FROM magic.cards"
+    assert needle in _compiled_sql(stub_api_resource, ordering)
+
+
+def test_color_sorts_by_the_bucket_expression(stub_api_resource: APIResource) -> None:
+    """Scryfall's colour order is eleven buckets, not the colour bitmask — see the CASE in api_resource."""
+    compiled = _compiled_sql(stub_api_resource, CardOrdering.COLOR)
+    assert "AS sort_value FROM magic.cards" in compiled
+    # Colourless after every coloured bucket, and lands after that: the two parts a bitmask gets wrong.
+    assert "WHEN card_types ? 'Land' THEN 10" in compiled
+    assert "ELSE 9" in compiled
diff --git a/api/tests/test_card_processing.py b/api/tests/test_card_processing.py
index e28ee6af4..be3ae03ba 100644
--- a/api/tests/test_card_processing.py
+++ b/api/tests/test_card_processing.py
@@ -2,10 +2,13 @@
 
 from __future__ import annotations
 
+import copy
 import json
 import pathlib
 import uuid
-from typing import Any
+from typing import Any, ClassVar
+
+import pytest
 
 from api.card_processing import extract_frame_data_from_raw_card, preprocess_card
 
@@ -117,21 +120,24 @@ def test_preprocess_card_filters_non_paper_cards(self) -> None:
         result = preprocess_card(invalid_card)
         assert result == []
 
-    def test_preprocess_card_processes_double_faced_cards(self) -> None:
-        """Test preprocess_card processes cards with card_faces (DFCs) correctly."""
+    def test_preprocess_card_merges_double_faced_cards_into_one_row(self) -> None:
+        """A multi-face card produces exactly ONE row, so faces no longer fight for the PK.
+
+        The old per-face fan-out emitted N rows sharing one scryfall_id; the upsert's
+        ON CONFLICT then kept whichever face came last — the back — which is how every
+        battle, MDFC spell side, and front-face text went missing (#400, #873).
+        """
         dfc_card = create_test_card(
             card_faces=[{"name": "Front", "type_line": "Creature — Human"}, {"name": "Back", "type_line": "Creature — Werewolf"}],
         )
 
         result = preprocess_card(dfc_card)
-        # DFCs should return 2 cards (one per face)
-        assert len(result) == 2
-        assert result[0]["face_idx"] == 1
-        assert result[0]["face_name"] == "Front"
-        assert result[0]["card_name"] == "Test Card"
-        assert result[1]["face_idx"] == 2
-        assert result[1]["face_name"] == "Back"
-        assert result[1]["card_name"] == "Test Card"
+        assert len(result) == 1
+        merged = result[0]
+        assert merged["card_name"] == "Test Card"
+        assert merged["scryfall_id"] == dfc_card["id"]
+        assert merged["card_subtypes"] == ["Human", "Werewolf"]
+        assert merged["type_line"] == "Creature — Human // Creature — Werewolf"
 
     def test_preprocess_card_filters_same_faced_double_side_cards(self) -> None:
         """Test preprocess_card filters out cards with the same name on both faces (X // X)."""
@@ -158,8 +164,8 @@ def test_preprocess_card_allows_different_faced_double_side_cards(self) -> None:
         )
 
         result = preprocess_card(normal_dfc)
-        # Different names — should be processed normally (2 faces)
-        assert len(result) == 2
+        assert len(result) == 1
+        assert result[0]["card_name"] == "Hound Tamer // Untamed Pup"
 
     def test_preprocess_card_filters_all_not_legal_cards(self) -> None:
         """Test preprocess_card filters out cards that are not legal in any format."""
@@ -398,48 +404,447 @@ def test_preprocess_card_handles_non_numeric_power_toughness(self) -> None:
         assert result["creature_toughness"] is None
 
     def test_preprocess_hound_tamer_dfc(self) -> None:
-        """Test preprocess_card processes Hound Tamer DFC sample data correctly."""
+        """A real transform card merges to one row: front stats, both faces searchable."""
         sample_file = _SAMPLE_DATA_DIR / "hound_tamer.json"
         with sample_file.open() as f:
             hound_tamer = json.load(f)
 
         result = preprocess_card(hound_tamer)
 
-        # Should return 2 faces
-        assert len(result) == 2
-
-        # Check front face
-        front = result[0]
-        assert front["face_idx"] == 1
-        assert front["face_name"] == "Hound Tamer"
-        assert front["card_name"] == "Hound Tamer // Untamed Pup"
-        assert front["creature_power"] == 3
-        assert front["creature_toughness"] == 3
-        assert "Creature" in front["card_types"]
-        assert front["cmc"] == 3
-
-        # Check back face
-        back = result[1]
-        assert back["face_idx"] == 2
-        assert back["face_name"] == "Untamed Pup"
-        assert back["card_name"] == "Hound Tamer // Untamed Pup"
-        assert back["creature_power"] == 4
-        assert back["creature_toughness"] == 4
-        assert "Creature" in back["card_types"]
-        # CMC is inherited from the card (3), even though back face has no mana cost
-        assert back["cmc"] == 3
+        assert len(result) == 1
+        merged = result[0]
+        assert merged["card_name"] == "Hound Tamer // Untamed Pup"
+        # Front face supplies the stat group (the 3/3, not the pup's 4/4)
+        assert merged["creature_power"] == 3
+        assert merged["creature_toughness"] == 3
+        assert merged["cmc"] == 3
+        assert merged["mana_cost_text"] == "{2}{G}"
+        # Both faces' searchable data is present
+        assert merged["card_subtypes"] == ["Human", "Werewolf"]
+        assert merged["type_line"] == "Creature — Human Werewolf // Creature — Werewolf"
+        assert "Trample" in merged["oracle_text"]  # front-face text
+        assert "Nightbound" in merged["oracle_text"]  # back-face text
+        assert "nightbound" in merged["card_keywords"]
 
     def test_preprocess_obyras_attendants(self) -> None:
-        """Test preprocess_card processes Obyra's Attendants DFC sample data correctly."""
+        """A real adventure card merges to one row with both faces' types searchable."""
         sample_file = _SAMPLE_DATA_DIR / "obyras_attendants.json"
         with sample_file.open() as f:
             obyras_attendants = json.load(f)
 
         result = preprocess_card(obyras_attendants)
 
-        # Should return 2 faces
-        front, back = result
-        assert front["creature_power"] == 3
-        assert back.get("creature_power") is None
-        assert front["card_types"] == ["Creature"]
-        assert back["card_types"] == ["Instant"]
+        assert len(result) == 1
+        merged = result[0]
+        # Creature body's stats, both faces' types: `t:creature t:instant` both match now
+        assert merged["creature_power"] == 3
+        assert merged["card_types"] == ["Creature", "Instant"]
+        assert merged["card_subtypes"] == ["Faerie", "Wizard", "Adventure"]
+
+
+class TestFaceMerging:
+    """The face-merge policy: front-face identity, any-face searchability (#400, #873).
+
+    Scryfall AND's predicates at the card level, each satisfiable by any face (measured
+    2026-08-08: `t:sorcery t:land` returns MDFC lands, `o:` conjunctions match across
+    faces, `c:b` matches Westvale Abbey's back-face-only color). These tests pin the
+    merged row to those semantics.
+    """
+
+    @staticmethod
+    def _battle_card() -> dict:
+        """A transform battle shaped like Invasion of Kamigawa // Rooftop Saboteurs."""
+        return create_test_card(
+            name="Invasion of Testing // Test Saboteurs",
+            layout="transform",
+            cmc=3,
+            card_faces=[
+                {
+                    "name": "Invasion of Testing",
+                    "type_line": "Battle — Siege",
+                    "mana_cost": "{2}{U}",
+                    "colors": ["U"],
+                    "oracle_text": "When this Siege enters, look at the top card.",
+                    "defense": "7",
+                    "illustration_id": "11111111-1111-1111-1111-111111111111",
+                },
+                {
+                    "name": "Test Saboteurs",
+                    "type_line": "Creature — Moonfolk Ninja",
+                    "mana_cost": "",
+                    "colors": ["U"],
+                    "power": "3",
+                    "toughness": "2",
+                    "oracle_text": "This creature can't be blocked.",
+                    "illustration_id": "22222222-2222-2222-2222-222222222222",
+                },
+            ],
+        )
+
+    def test_battle_face_keeps_its_defense(self) -> None:
+        """Scryfall prints a battle's defense on the FACE, and no column holds it.
+
+        Every battle so far is a transform card, so a face field list without `defense` loses the
+        number outright rather than degrading it.
+        """
+        merged = preprocess_card(self._battle_card())[0]
+        assert merged["card_faces"][0]["defense"] == "7"
+        # Absent on the face that has none, because Scryfall omits rather than nulls.
+        assert "defense" not in merged["card_faces"][1]
+
+    def test_battle_front_types_are_searchable(self) -> None:
+        """`t:battle` must match transform battles — the union carries the front's types.
+
+        The acceptance test from #400: Battle appears in zero type lines corpus-wide today
+        because every battle is stored as its back face.
+        """
+        merged = preprocess_card(self._battle_card())[0]
+        assert merged["card_types"] == ["Battle", "Creature"]
+        assert merged["card_subtypes"] == ["Siege", "Moonfolk", "Ninja"]
+
+    def test_front_face_supplies_identity_scalars(self) -> None:
+        """Mana cost, illustration, and image come from the front face, as on Scryfall."""
+        merged = preprocess_card(self._battle_card())[0]
+        assert merged["mana_cost_text"] == "{2}{U}"
+        assert merged["illustration_id"] == "11111111-1111-1111-1111-111111111111"
+
+    def test_oracle_text_joins_faces_with_separator(self) -> None:
+        """Each face's text is substring-searchable in the one joined column.
+
+        The newline separator keeps `.`-based regexes from matching across the face boundary.
+        """
+        merged = preprocess_card(self._battle_card())[0]
+        assert merged["oracle_text"] == ("When this Siege enters, look at the top card.\n//\nThis creature can't be blocked.")
+
+    def test_back_face_stats_used_when_front_has_none(self) -> None:
+        """A land-front / creature-back card (Westvale Abbey) keeps the back's P/T.
+
+        The front offers none, and Scryfall's pow: matches the back there too.
+        """
+        card = create_test_card(
+            name="Test Abbey // Test Prince",
+            card_faces=[
+                {"name": "Test Abbey", "type_line": "Land", "colors": [], "oracle_text": "{T}: Add {C}."},
+                {
+                    "name": "Test Prince",
+                    "type_line": "Legendary Creature — Demon",
+                    "colors": ["B"],
+                    "power": "9",
+                    "toughness": "7",
+                    "oracle_text": "Flying, lifelink.",
+                },
+            ],
+        )
+        merged = preprocess_card(card)[0]
+        assert merged["creature_power"] == 9
+        assert merged["creature_toughness"] == 7
+        # ...and the back-face-only color is searchable (c:b matches on Scryfall)
+        assert merged["card_colors"] == {"B": True}
+
+    def test_front_face_stats_win_when_both_faces_have_them(self) -> None:
+        """Two creature faces (Brutal Cathar's 2/2 // 3/3): the front's group wins.
+
+        Known residual vs Scryfall, which also matches the back's pow=3; documented in
+        the merge policy and left for a per-face follow-up if measurement warrants.
+        """
+        card = create_test_card(
+            name="Test Cathar // Test Brute",
+            card_faces=[
+                {"name": "Test Cathar", "type_line": "Creature — Human Soldier", "colors": ["W"], "power": "2", "toughness": "2"},
+                {"name": "Test Brute", "type_line": "Creature — Werewolf", "colors": [], "power": "3", "toughness": "3"},
+            ],
+        )
+        merged = preprocess_card(card)[0]
+        assert merged["creature_power"] == 2
+        assert merged["creature_toughness"] == 2
+        assert merged["creature_power_text"] == "2"
+
+    def test_stat_group_stays_face_consistent(self) -> None:
+        """The numeric and _text stat columns always describe the same face.
+
+        A `*`-power back face still counts as carrying the group: its text is real data.
+        """
+        card = create_test_card(
+            name="Test Land // Test Goyf",
+            card_faces=[
+                {"name": "Test Land", "type_line": "Land", "colors": []},
+                {"name": "Test Goyf", "type_line": "Creature — Lhurgoyf", "colors": ["G"], "power": "*", "toughness": "1+*"},
+            ],
+        )
+        merged = preprocess_card(card)[0]
+        assert merged["creature_power"] is None  # "*" is non-numeric
+        assert merged["creature_power_text"] == "*"
+        assert merged["creature_toughness_text"] == "1+*"
+
+    def test_mdfc_spell_and_land_types_both_searchable(self) -> None:
+        """`t:sorcery t:land` matches an MDFC (Agadeem's Awakening) — #400's acceptance."""
+        card = create_test_card(
+            name="Test Awakening // Test Undercrypt",
+            layout="modal_dfc",
+            card_faces=[
+                {
+                    "name": "Test Awakening",
+                    "type_line": "Sorcery",
+                    "mana_cost": "{X}{B}{B}{B}",
+                    "colors": ["B"],
+                    "oracle_text": "Return cards from your graveyard.",
+                },
+                {
+                    "name": "Test Undercrypt",
+                    "type_line": "Land",
+                    "mana_cost": "",
+                    "colors": [],
+                    "oracle_text": "As this land enters, you may pay 3 life.",
+                },
+            ],
+        )
+        merged = preprocess_card(card)[0]
+        assert merged["card_types"] == ["Sorcery", "Land"]
+        assert merged["mana_cost_text"] == "{X}{B}{B}{B}"
+
+    def test_all_faces_filtered_drops_the_card(self) -> None:
+        """A card whose every face is filtered (e.g. Token type lines) yields no row."""
+        card = create_test_card(
+            name="Test A // Test B",
+            card_faces=[
+                {"name": "Test A", "type_line": "Token Creature — Goblin"},
+                {"name": "Test B", "type_line": "Token Creature — Elf"},
+            ],
+        )
+        assert preprocess_card(card) == []
+
+
+class TestMultiFaceRawBlob:
+    """`raw_card_blob` on a merged row is the card Scryfall sent, not a face promoted to look like one.
+
+    Every searchable field is merged onto the row's own columns, so the blob has no derivation left
+    to do — and keeping it verbatim is what makes it answerable. A card object cannot be rebuilt
+    from a face: `card_faces` is gone, `name` and `type_line` are the front's, and which fields a
+    real card carries at top level varies by layout. These tests pin both layouts that differ.
+    """
+
+    # The importer lifts the combined name before splitting faces; it is the only key the blob
+    # gains, and the only one a reader has to strip to recover Scryfall's object exactly.
+    IMPORTER_ADDED: ClassVar[set[str]] = {"card_name"}
+
+    @staticmethod
+    def _transform_card() -> dict:
+        """A transform card: images and text live per face, with nothing at top level."""
+        card = create_test_card(
+            name="Test Delver // Test Aberration",
+            object="card",
+            layout="transform",
+            type_line="Creature — Human Wizard // Creature — Human Insect",
+            colors=["U"],
+            color_identity=["U"],
+            card_faces=[
+                {
+                    "object": "card_face",
+                    "name": "Test Delver",
+                    "mana_cost": "{U}",
+                    "type_line": "Creature — Human Wizard",
+                    "oracle_text": "Look at the top card of your library.",
+                    "power": "1",
+                    "toughness": "1",
+                    "colors": ["U"],
+                    "image_uris": {"normal": "https://cards.test/front.jpg"},
+                },
+                {
+                    "object": "card_face",
+                    "name": "Test Aberration",
+                    "mana_cost": "",
+                    "type_line": "Creature — Human Insect",
+                    "oracle_text": "Flying",
+                    "power": "3",
+                    "toughness": "2",
+                    "colors": ["U"],
+                    "image_uris": {"normal": "https://cards.test/back.jpg"},
+                },
+            ],
+        )
+        card.pop("image_uris", None)
+        card.pop("mana_cost", None)
+        return card
+
+    @staticmethod
+    def _split_card() -> dict:
+        """A split card: one physical face, so `mana_cost` and `image_uris` stay at top level."""
+        return create_test_card(
+            name="Test Fire // Test Ice",
+            object="card",
+            layout="split",
+            type_line="Instant // Instant",
+            mana_cost="{1}{R} // {1}{U}",
+            colors=["R", "U"],
+            color_identity=["R", "U"],
+            image_uris={"normal": "https://cards.test/split.jpg"},
+            card_faces=[
+                {
+                    "object": "card_face",
+                    "name": "Test Fire",
+                    "mana_cost": "{1}{R}",
+                    "type_line": "Instant",
+                    "oracle_text": "Deals 2.",
+                },
+                {
+                    "object": "card_face",
+                    "name": "Test Ice",
+                    "mana_cost": "{1}{U}",
+                    "type_line": "Instant",
+                    "oracle_text": "Tap it.",
+                },
+            ],
+        )
+
+    @pytest.mark.parametrize("builder", ["_transform_card", "_split_card"], ids=["transform", "split"])
+    def test_the_blob_is_the_card_it_was_given(self, builder) -> None:
+        """Whatever the layout, the blob differs from the input by the lifted name and nothing else."""
+        card = getattr(self, builder)()
+        original = copy.deepcopy(card)
+        blob = preprocess_card(card)[0]["raw_card_blob"]
+
+        assert set(blob) - set(original) == self.IMPORTER_ADDED
+        assert set(original) - set(blob) == set()
+        assert {key: value for key, value in blob.items() if key not in self.IMPORTER_ADDED} == original
+
+    def test_a_transform_card_keeps_its_images_only_on_the_faces(self) -> None:
+        """The reason every blob image read coalesces to `card_faces->0` (scripts/prefer_weights.py)."""
+        blob = preprocess_card(self._transform_card())[0]["raw_card_blob"]
+        assert "image_uris" not in blob
+        assert blob["card_faces"][0]["image_uris"]["normal"] == "https://cards.test/front.jpg"
+
+    def test_a_split_card_keeps_its_top_level_image(self) -> None:
+        """Which is why stripping the promoted fields by rule could not have worked: layout decides."""
+        blob = preprocess_card(self._split_card())[0]["raw_card_blob"]
+        assert blob["image_uris"]["normal"] == "https://cards.test/split.jpg"
+        assert blob["mana_cost"] == "{1}{R} // {1}{U}"
+
+    def test_the_faces_round_trip_untouched(self) -> None:
+        card = self._transform_card()
+        faces = copy.deepcopy(card["card_faces"])
+        assert preprocess_card(card)[0]["raw_card_blob"]["card_faces"] == faces
+
+    def test_the_blob_is_not_a_face(self) -> None:
+        blob = preprocess_card(self._transform_card())[0]["raw_card_blob"]
+        assert blob["object"] == "card"
+        assert blob["name"] == "Test Delver // Test Aberration"
+        assert blob["type_line"] == "Creature — Human Wizard // Creature — Human Insect"
+
+    def test_the_searchable_row_still_carries_the_merged_faces(self) -> None:
+        """The blob going verbatim must not have cost the merge — that is what #400 was about."""
+        row = preprocess_card(self._transform_card())[0]
+        assert row["card_name"] == "Test Delver // Test Aberration"
+        assert "Flying" in row["oracle_text"]
+        assert "Look at the top card" in row["oracle_text"]
+        assert row["creature_power"] == 1
+
+
+class TestEngineCardObjects:
+    """What the ENGINE needs to answer a card-shaped question, without reading raw_card_blob.
+
+    The engine serves searches and Postgres is the fallback for when it errors, so a field that
+    lives only in the blob is a field /cards/* cannot answer on the primary path. These pin the
+    two columns that close that gap.
+    """
+
+    @staticmethod
+    def _two_faced() -> dict:
+        """A transform card whose two faces disagree on every per-face field that matters."""
+        return create_test_card(
+            name="Front Test // Back Test",
+            layout="transform",
+            lang="en",
+            set_type="expansion",
+            games=["paper", "mtgo"],
+            finishes=["nonfoil", "foil"],
+            arena_id=12345,
+            card_faces=[
+                {
+                    "name": "Front Test",
+                    "type_line": "Creature — Human",
+                    "mana_cost": "{1}{W}",
+                    "colors": ["W"],
+                    "power": "2",
+                    "toughness": "2",
+                    "oracle_text": "Front text.",
+                    "flavor_text": "Front flavor.",
+                    "artist": "Front Artist",
+                    "illustration_id": "11111111-1111-1111-1111-111111111111",
+                },
+                {
+                    "name": "Back Test",
+                    "type_line": "Creature — Werewolf",
+                    "mana_cost": "",
+                    "colors": ["R"],
+                    "power": "3",
+                    "toughness": "3",
+                    "oracle_text": "Back text.",
+                    "artist": "Back Artist",
+                    "illustration_id": "22222222-2222-2222-2222-222222222222",
+                },
+            ],
+        )
+
+    def test_faces_are_stored_structurally(self) -> None:
+        """Each face keeps its own fields, front first, so the engine can read a face."""
+        faces = preprocess_card(self._two_faced())[0]["card_faces"]
+        assert [face["name"] for face in faces] == ["Front Test", "Back Test"]
+        assert faces[0]["illustration_id"] == "11111111-1111-1111-1111-111111111111"
+        assert faces[1]["illustration_id"] == "22222222-2222-2222-2222-222222222222"
+        assert faces[0]["artist"] == "Front Artist"
+        assert faces[1]["artist"] == "Back Artist"
+
+    def test_back_face_stats_survive_the_merge(self) -> None:
+        """Both faces' stats stay reachable, retiring the merge's documented residual.
+
+        _merge_processed_faces keeps only the FRONT's stat group, while Scryfall matches either
+        face. The per-face records carry both, so the back's 3/3 is searchable again.
+        """
+        row = preprocess_card(self._two_faced())[0]
+        assert row["creature_power_text"] == "2"
+        assert [face["power"] for face in row["card_faces"]] == ["2", "3"]
+        assert [face["toughness"] for face in row["card_faces"]] == ["2", "3"]
+
+    def test_absent_face_keys_stay_absent(self) -> None:
+        """A face without flavor_text stores no flavor_text key.
+
+        Scryfall omits it rather than sending null, and a reconstructed face has to agree
+        key-for-key.
+        """
+        faces = preprocess_card(self._two_faced())[0]["card_faces"]
+        assert faces[0]["flavor_text"] == "Front flavor."
+        assert "flavor_text" not in faces[1]
+
+    def test_single_faced_cards_have_no_face_records(self) -> None:
+        """One face is not a face list; the column stays absent so the engine stores nothing."""
+        assert "card_faces" not in preprocess_card(create_test_card(name="Solo Test"))[0]
+
+    def test_compat_blob_carries_what_no_column_holds(self) -> None:
+        """The fields /cards/* needs and nothing else stores."""
+        blob = preprocess_card(self._two_faced())[0]["card_compat_blob"]
+        assert blob["lang"] == "en"
+        assert blob["set_type"] == "expansion"
+        assert blob["games"] == ["paper", "mtgo"]
+        assert blob["finishes"] == ["nonfoil", "foil"]
+        assert blob["arena_id"] == 12345
+
+    def test_compat_blob_excludes_what_columns_already_hold(self) -> None:
+        """Redundancy is the whole cost of raw_card_blob; the residue must not repeat it."""
+        blob = preprocess_card(self._two_faced())[0]["card_compat_blob"]
+        for stored in ("name", "type_line", "oracle_text", "colors", "legalities", "set"):
+            assert stored not in blob, f"{stored} has a column of its own"
+
+    def test_compat_blob_excludes_derivable_uris(self) -> None:
+        """Every *_uri is a pure function of the card's id, set or oracle id."""
+        blob = preprocess_card(self._two_faced())[0]["card_compat_blob"]
+        for derived in ("uri", "scryfall_uri", "image_uris", "rulings_uri", "prints_search_uri"):
+            assert derived not in blob, f"{derived} is derivable"
+
+    def test_compat_blob_is_much_smaller_than_the_raw_blob(self) -> None:
+        """The reason this exists: the blob is overwhelmingly redundant with columns we have."""
+        row = preprocess_card(self._two_faced())[0]
+        assert len(json.dumps(row["card_compat_blob"])) < len(json.dumps(row["raw_card_blob"])) / 2
+
+    def test_single_faced_cards_still_get_a_compat_blob(self) -> None:
+        """The residue is card-level, so it is not a multi-face concern."""
+        assert "card_compat_blob" in preprocess_card(create_test_card(name="Solo Test"))[0]
diff --git a/api/tests/test_engine_unit.py b/api/tests/test_engine_unit.py
index e1d6861a3..5e7f183d6 100644
--- a/api/tests/test_engine_unit.py
+++ b/api/tests/test_engine_unit.py
@@ -37,7 +37,7 @@
 import pytest
 
 from api.parsing import parse_scryfall_query
-from card_engine import QueryEngine, UnknownFieldError
+from card_engine import ENGINE_COLUMNS, QueryEngine, UnknownFieldError
 
 if TYPE_CHECKING:
     from collections.abc import Callable, Generator
@@ -1237,6 +1237,49 @@ def test_default_fields_omit_illustration_and_price(self, engine: QueryEngine) -
             "type_line",
         }
 
+    def test_loyalty_is_the_printed_string_from_the_engine(self, engine: QueryEngine) -> None:
+        """`loyalty` comes from planeswalker_loyalty_text, not the u8 the planner filters on.
+
+        The numeric column is an `Option<u8>` -- "always 1-12" -- so it cannot carry "X" (Nissa,
+        Steward of Elements) or "1+*". Before this field existed the key was served by nothing, and
+        every planeswalker's card object came back without it.
+        """
+        _, cards = _run(engine, "t:planeswalker", unique="card", fields=["name", "loyalty"])
+        assert cards, "the fixture corpus has planeswalkers"
+        assert all(c["loyalty"] for c in cards), f"every planeswalker reports a loyalty: {cards}"
+        assert {c["name"]: c["loyalty"] for c in cards} == {
+            "Jace, the Mind Sculptor": "3",
+            "Nicol Bolas, Planeswalker": "5",
+        }
+
+        # A card with no loyalty reports none, rather than a zero the u8 would have implied.
+        _, bolt = _run(engine, 'name="Lightning Bolt"', unique="card", limit=1, fields=["name", "loyalty"])
+        assert bolt[0]["loyalty"] is None
+
+    def test_engine_columns_feed_every_key_the_loader_reads(self, fresh_engine: Callable[[], QueryEngine]) -> None:
+        """A reload from rows projected to exactly ENGINE_COLUMNS still answers `loyalty`.
+
+        The production reload SELECTs ENGINE_COLUMNS and nothing else, so a key card_from_pydict()
+        reads that is missing from the list is silently None on every card -- the archive builds,
+        every query answers, and the field is just absent. The test above cannot see that: it
+        reloads from the raw fixture dicts, which carry every key regardless of the list.
+
+        This one simulates the SQL row shape -- each fixture card cut down to ENGINE_COLUMNS, with
+        None where the fixture has no value, exactly as psycopg returns a row -- and asserts the
+        printed loyalty survives. It failed before planeswalker_loyalty_text joined the list: the
+        column existed, the import filled it, and the SELECT never fetched it.
+        """
+        cards = json.loads(_FIXTURE.read_text())
+        projected = [{col: card.get(col) for col in ENGINE_COLUMNS} for card in cards]
+        e = fresh_engine()
+        e.reload(projected)
+
+        _, walkers = _run(e, "t:planeswalker", unique="card", fields=["name", "loyalty"])
+        assert {c["name"]: c["loyalty"] for c in walkers} == {
+            "Jace, the Mind Sculptor": "3",
+            "Nicol Bolas, Planeswalker": "5",
+        }, "a field the SELECT list does not fetch is silently absent from every card object"
+
     def test_requested_fields_returned_exactly(self, engine: QueryEngine) -> None:
         _, cards = _run(
             engine,
diff --git a/api/tests/test_frontend_vocabularies.py b/api/tests/test_frontend_vocabularies.py
new file mode 100644
index 000000000..066c966a8
--- /dev/null
+++ b/api/tests/test_frontend_vocabularies.py
@@ -0,0 +1,47 @@
+"""The dropdowns in index.html must offer exactly what the enums accept.
+
+An enum member with no `<option>` is unreachable from the UI; an `<option>` with no member is a
+ParamCoercionError the moment someone picks it. Neither shows up in any other test — the API is
+happy either way — so the drift is invisible until a user tries it. #913 added six orderings and
+shipped without touching the markup, which is what prompted this.
+"""
+
+from __future__ import annotations
+
+import pathlib
+import re
+
+from api.enums import CardOrdering, PreferOrder, UniqueOn
+
+_INDEX_HTML = (pathlib.Path(__file__).resolve().parents[1] / "static" / "index.html").read_text(encoding="utf-8")
+
+
+def _options(select_id: str) -> list[str]:
+    """The option values of one <select>, in document order."""
+    block = re.search(rf'<select[^>]*id="{select_id}".*?</select>', _INDEX_HTML, re.DOTALL)
+    assert block is not None, f"no <select id={select_id!r}> in index.html"
+    return re.findall(r'<option value="([^"]*)"', block.group(0))
+
+
+def test_order_dropdown_offers_every_ordering() -> None:
+    assert set(_options("orderDropdown")) == {str(member) for member in CardOrdering}
+
+
+def test_unique_dropdown_offers_every_mode() -> None:
+    assert set(_options("uniqueDropdown")) == {str(member) for member in UniqueOn}
+
+
+def test_prefer_dropdown_offers_every_prefer() -> None:
+    assert set(_options("preferDropdown")) == {str(member) for member in PreferOrder}
+
+
+def test_no_dropdown_offers_a_value_the_api_would_reject() -> None:
+    """The direction of the check that produces the worse failure: a 400 on a click."""
+    for select_id, enum_cls in (
+        ("orderDropdown", CardOrdering),
+        ("uniqueDropdown", UniqueOn),
+        ("preferDropdown", PreferOrder),
+    ):
+        accepted = {str(member) for member in enum_cls}
+        for value in _options(select_id):
+            assert value in accepted, f"{select_id} offers {value!r}, which {enum_cls.__name__} rejects"
diff --git a/api/tests/test_legality_registry_across_processes.py b/api/tests/test_legality_registry_across_processes.py
new file mode 100644
index 000000000..e715c03b8
--- /dev/null
+++ b/api/tests/test_legality_registry_across_processes.py
@@ -0,0 +1,74 @@
+"""`legalities` must decode in a worker that mmapped the archive without importing it.
+
+Its own module, and it spawns a SUBPROCESS on purpose. The format->shift registry
+(`FORMAT_SHIFTS`) is a process-global that `reload()` populates as a side effect of interning, so
+any test that builds the archive and reads it back in the same interpreter passes whether or not
+mapping the archive populates the registry. That is not the deployment: `api/entrypoint.py` starts
+multiple Bjoern worker processes and each one mmaps the shm archive some other process wrote.
+
+What it guards: `legality_bits_to_pydict` iterates the registry and yields an EMPTY dict when it is
+unpopulated rather than failing. Until `get_mmap` adopted the archive's shifts, the only caller of
+`sync_format_shifts` was `bind_and_split_filter`, on the filter path -- so a worker answered
+`"legalities": {}` from /cards/named, /cards/:id and /cards/collection until it happened to serve a
+search, and those responses are cacheable.
+"""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+import tempfile
+import textwrap
+import uuid
+from pathlib import Path
+
+from card_engine import QueryEngine
+
+_FIXTURE = Path(__file__).parent / "fixtures" / "engine_cards.json"
+
+# Black Lotus in the fixture corpus: banned in more than one format, so a decode that silently
+# produced the not_legal default for everything could not pass either.
+_SCRYFALL_ID = "b0faa7f2-b547-42c4-a810-839da50dadfe"
+
+# Runs in a FRESH interpreter: mmap only, no reload, no filter query.
+_CHILD = textwrap.dedent(
+    """
+    import json, sys
+    from card_engine import QueryEngine
+    engine = QueryEngine(shm_path=sys.argv[1])
+    row = engine.card_by_scryfall_id(sys.argv[2], ["name", "legalities"])
+    json.dump(row, sys.stdout)
+    """
+)
+
+
+def test_a_worker_that_only_mmapped_the_archive_still_decodes_legalities() -> None:
+    with tempfile.TemporaryDirectory() as tmp:
+        shm_path = str(Path(tmp) / f"sylvan_legality_{uuid.uuid4().hex}")
+
+        # Parent: build the archive. This populates THIS process's registry, which is exactly why
+        # the assertion below has to happen somewhere else.
+        QueryEngine(shm_path=shm_path).reload(json.loads(_FIXTURE.read_text()))
+
+        proc = subprocess.run(  # noqa: S603
+            [sys.executable, "-c", _CHILD, shm_path, _SCRYFALL_ID],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        assert proc.returncode == 0, f"child failed: {proc.stderr}"
+        row = json.loads(proc.stdout)
+
+    assert row is not None, "the child could not find the card at all"
+    legalities = row["legalities"]
+    assert legalities, (
+        "legalities decoded to {} in a worker that mmapped the archive without importing it -- "
+        "the exact shape /cards/named served from a fresh worker process"
+    )
+
+    # Values, not just presence: an empty registry gives {}, but a registry carrying the wrong
+    # shifts gives a full dict of wrong answers, which a truthiness check alone accepts.
+    assert legalities["vintage"] == "restricted"
+    assert legalities["duel"] == "banned"
+    assert legalities["commander"] == "banned"
diff --git a/api/tests/test_order_vocabulary.py b/api/tests/test_order_vocabulary.py
new file mode 100644
index 000000000..c9a8167fe
--- /dev/null
+++ b/api/tests/test_order_vocabulary.py
@@ -0,0 +1,171 @@
+"""The `order=` vocabulary: every member wired on both paths, and `dir=auto` resolved per order.
+
+The risk this file exists for is drift between three lists that must agree — `CardOrdering`, the
+`sql_orderby` map, and `SortCol` in card_engine/src/lib.rs. `orderby_to_col` falls through to
+edhrec on a name it does not know, so an ordering wired on one path and not the other does not
+raise: it silently returns a differently-ordered page depending on which path served the query.
+Two completeness tests below iterate the enum rather than a hand-written list, so a member added
+without its counterpart fails here instead of in production.
+
+The `dir=auto` table is measured against api.scryfall.com (2026-08-09) — see
+docs/issues/local-engine-order-vocabulary.md.
+"""
+
+from __future__ import annotations
+
+import random
+from typing import TYPE_CHECKING, Any, ClassVar
+
+import pytest
+
+from api.enums import AUTO_DESCENDING_ORDERINGS, CardOrdering, SortDirection, resolve_direction
+from api.parsing import parse_scryfall_query
+from card_engine import QueryEngine
+
+if TYPE_CHECKING:
+    from collections.abc import Generator
+
+
+class TestAutoDirection:
+    """`auto` is per-ordering, and resolved before either search path sees it."""
+
+    # Measured against api.scryfall.com on 2026-08-09 over `q=t:creature s:dom`, by comparing the
+    # `auto` page against the `asc` and `desc` pages of the same query.
+    MEASURED: ClassVar[dict[CardOrdering, SortDirection]] = {
+        CardOrdering.RELEASED: SortDirection.DESC,
+        CardOrdering.RARITY: SortDirection.DESC,
+        CardOrdering.USD: SortDirection.DESC,
+        CardOrdering.TIX: SortDirection.DESC,
+        CardOrdering.EUR: SortDirection.DESC,
+        CardOrdering.NAME: SortDirection.ASC,
+        CardOrdering.SET: SortDirection.ASC,
+        CardOrdering.COLOR: SortDirection.ASC,
+        CardOrdering.CMC: SortDirection.ASC,
+        CardOrdering.POWER: SortDirection.ASC,
+        CardOrdering.TOUGHNESS: SortDirection.ASC,
+        CardOrdering.EDHREC: SortDirection.ASC,
+        CardOrdering.ARTIST: SortDirection.ASC,
+    }
+
+    @pytest.mark.parametrize("ordering", sorted(MEASURED), ids=str)
+    def test_auto_matches_what_scryfall_does(self, ordering: CardOrdering) -> None:
+        assert resolve_direction(SortDirection.AUTO, ordering) == self.MEASURED[ordering]
+
+    def test_edhrec_auto_is_ascending(self) -> None:
+        """Ascending rank is most-popular-first; descending would surface the least-played cards.
+
+        Called out on its own because "descending popularity" and "ascending rank" are the same
+        direction here, and reading it the other way inverts the site's default sort.
+        """
+        assert resolve_direction(SortDirection.AUTO, CardOrdering.EDHREC) == SortDirection.ASC
+
+    @pytest.mark.parametrize("ordering", sorted(CardOrdering), ids=str)
+    def test_auto_always_resolves_to_a_concrete_direction(self, ordering: CardOrdering) -> None:
+        """No ordering may leave AUTO in place — neither search path knows the value."""
+        assert resolve_direction(SortDirection.AUTO, ordering) in (SortDirection.ASC, SortDirection.DESC)
+
+    @pytest.mark.parametrize("explicit", [SortDirection.ASC, SortDirection.DESC], ids=str)
+    @pytest.mark.parametrize("ordering", sorted(AUTO_DESCENDING_ORDERINGS), ids=str)
+    def test_an_explicit_direction_is_never_overridden(self, ordering: CardOrdering, explicit: SortDirection) -> None:
+        """Including on the orderings whose auto is desc — `dir=asc` there must stay ascending."""
+        assert resolve_direction(explicit, ordering) == explicit
+
+
+def _ordered_ids(engine: QueryEngine, orderby: CardOrdering, direction: SortDirection) -> list[str]:
+    _total, cards = engine.query(
+        filters=parse_scryfall_query("cmc>=0"),
+        unique="printing",
+        prefer="default",
+        orderby=str(orderby),
+        direction=str(direction),
+        limit=1_000,
+        offset=0,
+        fields=["scryfall_id"],
+    )
+    return [str(c["scryfall_id"]) for c in cards]
+
+
+class TestEngineKnowsEveryOrdering:
+    """Every CardOrdering member has its own `SortCol` arm, not the edhrec fallthrough.
+
+    `orderby_to_col` cannot be inspected from Python, so this is behavioural: an ordering that fell
+    through would produce the exact page edhrec produces. The corpus is built so that no two
+    orderings agree by accident — each card is deliberately distinct on every sortable column.
+    """
+
+    @pytest.fixture(scope="class", name="engine")
+    def engine_fixture(self, tmp_path_factory: pytest.TempPathFactory) -> Generator[QueryEngine]:
+        rng = random.Random(20260809)
+        cards: list[dict[str, Any]] = []
+        colors = [{}, {"W": True}, {"U": True}, {"B": True}, {"R": True}, {"G": True}, {"W": True, "U": True}]
+        for i in range(40):
+            cid = f"{i:08x}-0000-4000-8000-{i:012x}"
+            cards.append(
+                {
+                    "scryfall_id": cid,
+                    "oracle_id": f"{i:08x}-1111-4111-8111-{i:012x}",
+                    "illustration_id": f"{i:08x}-2222-4222-8222-{i:012x}",
+                    "card_name": f"Card {i:03d}",
+                    "card_name_lower": f"card {i:03d}",
+                    "card_name_folded": f"card {i:03d}",
+                    # Every sortable column gets a different permutation of the same 40 cards, so
+                    # two orderings returning the same page means one of them was not applied.
+                    "cmc": i % 13,
+                    "edhrec_rank": (i * 7) % 40,
+                    "cubecobra_score": float((i * 29) % 40),
+                    "creature_power": (i * 3) % 11,
+                    "creature_toughness": (i * 5) % 11,
+                    "card_rarity_int": i % 4,
+                    "price_usd": (i * 11) % 97,
+                    "price_eur": (i * 13) % 89,
+                    "price_tix": (i * 17) % 83,
+                    "released_at": f"20{10 + (i % 15):02d}-{1 + (i % 12):02d}-{1 + (i % 28):02d}",
+                    "card_set_code": f"s{(i * 19) % 40:02d}",
+                    "card_artist": f"Artist {(i * 23) % 40:03d}",
+                    "card_colors": colors[i % len(colors)],
+                    "type_line": "Land" if i % 9 == 0 else "Creature — Test",
+                    "oracle_text": f"text {i}",
+                    "prefer_score": float(rng.randrange(100)),
+                }
+            )
+        engine = QueryEngine(str(tmp_path_factory.mktemp("orders") / "orders.store"))
+        assert engine.reload_begin()
+        engine.add_batch(cards)
+        engine.reload_commit()
+        return engine
+
+    def test_the_corpus_loaded(self, engine: QueryEngine) -> None:
+        assert engine.size() == 40
+
+    @pytest.mark.parametrize(
+        "ordering",
+        [o for o in sorted(CardOrdering) if o is not CardOrdering.EDHREC],
+        ids=str,
+    )
+    def test_ordering_is_not_the_edhrec_fallthrough(self, engine: QueryEngine, ordering: CardOrdering) -> None:
+        """The failure this catches is silent: an unmapped name sorts by edhrec and still 200s."""
+        by_edhrec = _ordered_ids(engine, CardOrdering.EDHREC, SortDirection.ASC)
+        assert _ordered_ids(engine, ordering, SortDirection.ASC) != by_edhrec
+
+    @pytest.mark.parametrize("ordering", sorted(CardOrdering), ids=str)
+    def test_every_ordering_returns_the_whole_corpus(self, engine: QueryEngine, ordering: CardOrdering) -> None:
+        """A sort key must reorder rows, never drop them — an absent value sorts last, not out."""
+        assert len(_ordered_ids(engine, ordering, SortDirection.ASC)) == 40
+
+    @pytest.mark.parametrize("ordering", sorted(CardOrdering), ids=str)
+    def test_descending_is_the_reverse_ordering(self, engine: QueryEngine, ordering: CardOrdering) -> None:
+        """Not element-wise reversed — ties break the same way in both directions by design."""
+        ascending = _ordered_ids(engine, ordering, SortDirection.ASC)
+        descending = _ordered_ids(engine, ordering, SortDirection.DESC)
+        assert set(ascending) == set(descending)
+        assert ascending != descending
+
+    def test_released_orders_by_date_not_by_a_truncated_key(self, engine: QueryEngine) -> None:
+        """A raw yyyymmdd exceeds the f32 sort key's exact range, collapsing adjacent dates.
+
+        Forty distinct dates must give forty distinct positions; a truncating key ties some of them
+        and lets the secondary sort decide, which reads as "nearly sorted" rather than as a failure.
+        """
+        ids = _ordered_ids(engine, CardOrdering.RELEASED, SortDirection.ASC)
+        assert ids != _ordered_ids(engine, CardOrdering.RELEASED, SortDirection.DESC)
+        assert len(set(ids)) == 40
diff --git a/api/tests/test_parsing_errors.py b/api/tests/test_parsing_errors.py
index 5b59b5ce9..68af4f170 100644
--- a/api/tests/test_parsing_errors.py
+++ b/api/tests/test_parsing_errors.py
@@ -370,6 +370,23 @@ def test_none_resolves_to_default_fields(self) -> None:
 
         assert self.api_resource._resolve_result_fields(None) == list(DEFAULT_RESULT_FIELDS)
 
+    def test_every_price_ordering_is_also_a_readable_field(self) -> None:
+        """An `order=` you can rank by is an `order=` whose number you can read back.
+
+        Asserted over CardOrdering rather than over a literal list, so a currency added to
+        the ordering vocabulary without a matching result field fails here rather than
+        shipping a page nobody can interpret.
+        """
+        from api.api_resource import RESULT_FIELD_COLUMNS  # noqa: PLC0415
+        from api.enums import CardOrdering  # noqa: PLC0415
+
+        for ordering in (CardOrdering.USD, CardOrdering.EUR, CardOrdering.TIX):
+            assert f"price_{ordering}" in RESULT_FIELD_COLUMNS
+
+    def test_price_fields_resolve_in_order(self) -> None:
+        resolved = self.api_resource._resolve_result_fields(["price_usd", "price_eur", "price_tix"])
+        assert resolved == ["price_usd", "price_eur", "price_tix"]
+
 
 @pytest.mark.usefixtures("engine_enabled")
 class TestResultFieldRouting:
diff --git a/api/tests/test_rulings_import.py b/api/tests/test_rulings_import.py
new file mode 100644
index 000000000..00269a45e
--- /dev/null
+++ b/api/tests/test_rulings_import.py
@@ -0,0 +1,188 @@
+"""Tests for the rulings bulk import.
+
+Mocked connection pool rather than the container, matching test_tagging_integration.py. The reason
+here is stronger than convention: `import_rulings` opens with an unconditional
+`DELETE FROM magic.rulings`, and the postgres container is shared across the whole session, so a
+database-backed test would wipe the row test_scryfall_cards_routes.py inserts for its own rulings
+assertions and leave that module dependent on file ordering. What the mocks cannot reach -- the
+`::date` cast, `ON CONFLICT DO NOTHING` against idx_rulings_identity -- is covered by running the
+importer against the live bulk file, which is not something the suite should do on every run.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from api import rulings_import
+from api.rulings_import import _valid_rulings, import_rulings
+from api.scryfall_bulk_data_fetcher import BulkDataKey
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+ORACLE_ID = "aaaaaaaa-1111-4111-8111-aaaaaaaaaaaa"
+
+RULINGS_FIXTURE = [
+    {"oracle_id": ORACLE_ID, "source": "wotc", "published_at": "2004-10-04", "comment": "First ruling."},
+    {"oracle_id": ORACLE_ID, "source": "scryfall", "published_at": "2019-08-23", "comment": "Second ruling."},
+]
+
+
+def _make_mock_conn_pool(rowcount: int = 0) -> tuple[MagicMock, MagicMock, MagicMock]:
+    """Return a mock conn_pool, its connection and its cursor."""
+    cursor = MagicMock()
+    cursor.__enter__ = lambda _: cursor
+    cursor.__exit__ = MagicMock(return_value=False)
+    cursor.rowcount = rowcount
+
+    conn = MagicMock()
+    conn.__enter__ = lambda _: conn
+    conn.__exit__ = MagicMock(return_value=False)
+    conn.cursor.return_value = cursor
+
+    pool = MagicMock()
+    pool.connection.return_value.__enter__ = lambda _: conn
+    pool.connection.return_value.__exit__ = MagicMock(return_value=False)
+    return pool, conn, cursor
+
+
+def _make_fetcher(entries) -> MagicMock:
+    """A fetcher whose stream yields the given bulk entries."""
+    fetcher = MagicMock()
+    fetcher.stream_data_for_key.return_value = iter(entries)
+    return fetcher
+
+
+def _executed_sql(cursor: MagicMock) -> list[str]:
+    """The SQL of every execute() call, in order."""
+    return [call.args[0] for call in cursor.execute.call_args_list]
+
+
+class TestValidRulings:
+    """Which bulk entries survive into the table."""
+
+    def test_a_complete_entry_is_kept(self) -> None:
+        assert list(_valid_rulings(RULINGS_FIXTURE)) == RULINGS_FIXTURE
+
+    @pytest.mark.parametrize("missing", ["oracle_id", "source", "published_at", "comment"])
+    def test_an_entry_missing_a_required_field_is_dropped(self, missing: str) -> None:
+        entry = dict(RULINGS_FIXTURE[0])
+        del entry[missing]
+        assert list(_valid_rulings([entry])) == []
+
+    @pytest.mark.parametrize("blank", ["oracle_id", "source", "published_at", "comment"])
+    def test_an_empty_value_counts_as_missing(self, blank: str) -> None:
+        """Every column is NOT NULL and an empty comment is not a ruling, so "" is not a value."""
+        entry = dict(RULINGS_FIXTURE[0]) | {blank: ""}
+        assert list(_valid_rulings([entry])) == []
+
+    def test_a_timestamp_published_at_is_truncated_to_a_date(self) -> None:
+        """A future timestamp form must not reach the ::date cast as a timestamp."""
+        entry = dict(RULINGS_FIXTURE[0]) | {"published_at": "2004-10-04T00:00:00.000+00:00"}
+        assert next(iter(_valid_rulings([entry])))["published_at"] == "2004-10-04"
+
+    def test_only_the_four_columns_are_carried_through(self) -> None:
+        """The bulk file's extra keys are dropped rather than travelling in the jsonb parameter."""
+        entry = dict(RULINGS_FIXTURE[0]) | {"object": "ruling", "oracle_uri": "https://api.scryfall.com/..."}
+        assert set(next(iter(_valid_rulings([entry])))) == {"oracle_id", "source", "published_at", "comment"}
+
+
+class TestImportRulings:
+    """The load itself."""
+
+    def test_streams_the_rulings_bulk_key(self) -> None:
+        pool, _, _ = _make_mock_conn_pool()
+        fetcher = _make_fetcher(RULINGS_FIXTURE)
+
+        import_rulings(pool, fetcher)
+
+        fetcher.stream_data_for_key.assert_called_once_with(BulkDataKey.RULINGS)
+
+    def test_the_table_is_emptied_before_anything_is_inserted(self) -> None:
+        pool, _, cursor = _make_mock_conn_pool()
+
+        import_rulings(pool, _make_fetcher(RULINGS_FIXTURE))
+
+        statements = _executed_sql(cursor)
+        assert statements[0] == "DELETE FROM magic.rulings"
+        assert all("INSERT INTO magic.rulings" in statement for statement in statements[1:])
+
+    def test_the_load_commits_once_and_only_at_the_end(self) -> None:
+        """One transaction, so no reader can observe the table between the DELETE and the reload."""
+        pool, conn, _ = _make_mock_conn_pool()
+
+        import_rulings(pool, _make_fetcher(RULINGS_FIXTURE))
+
+        conn.commit.assert_called_once()
+
+    def test_rows_are_written_in_batches(self) -> None:
+        pool, _, cursor = _make_mock_conn_pool()
+        entries = [dict(RULINGS_FIXTURE[0], comment=f"Ruling {i}.") for i in range(7)]
+
+        with patch.object(rulings_import, "_BATCH_SIZE", 3):
+            import_rulings(pool, _make_fetcher(entries))
+
+        inserts = [call for call in cursor.execute.call_args_list if "INSERT" in call.args[0]]
+        assert len(inserts) == 3  # 3 + 3 + 1
+        assert [len(call.args[1]["rows"].obj) for call in inserts] == [3, 3, 1]
+
+    def test_the_count_is_rows_inserted_not_rows_sent(self) -> None:
+        """ON CONFLICT DO NOTHING drops tuples the file repeats; those must not be counted.
+
+        The live file carried 37 such duplicates out of 77,998 entries on 2026-08-11, so reporting
+        len(batch) claimed a row total the table did not hold.
+        """
+        pool, _, _ = _make_mock_conn_pool(rowcount=1)
+
+        loaded = import_rulings(pool, _make_fetcher(RULINGS_FIXTURE))
+
+        assert loaded == 1  # one INSERT of two rows, of which the server accepted one
+
+    def test_an_empty_bulk_file_still_clears_the_table(self) -> None:
+        pool, conn, cursor = _make_mock_conn_pool()
+
+        assert import_rulings(pool, _make_fetcher([])) == 0
+
+        assert _executed_sql(cursor) == ["DELETE FROM magic.rulings"]
+        conn.commit.assert_called_once()
+
+    def test_a_failure_mid_stream_never_commits(self) -> None:
+        """The single transaction is what makes a truncated download safe.
+
+        `stream_data_for_key` raises BulkDataParseError when too little of a large file parses. If
+        the DELETE were committed separately, that raise would leave magic.rulings empty until the
+        next successful import; inside one transaction it rolls back and readers keep the previous
+        rulings.
+        """
+        pool, conn, _ = _make_mock_conn_pool()
+
+        def exploding_stream() -> Iterator[dict]:
+            yield RULINGS_FIXTURE[0]
+            msg = "not enough of the file parsed"
+            raise ValueError(msg)
+
+        fetcher = MagicMock()
+        fetcher.stream_data_for_key.return_value = exploding_stream()
+
+        with patch.object(rulings_import, "_BATCH_SIZE", 1), pytest.raises(ValueError, match="not enough"):
+            import_rulings(pool, fetcher)
+
+        conn.commit.assert_not_called()
+
+
+class TestImportRulingsQuietly:
+    """The wrapper the import sequence calls."""
+
+    def test_a_rulings_failure_does_not_abort_the_import(self, stub_api_resource) -> None:
+        """Rulings are the one import step nothing downstream reads, so they must not be fatal."""
+        with patch("api.admin_resource._import_rulings", side_effect=RuntimeError("bulk file is garbage")):
+            stub_api_resource.admin._import_rulings_quietly()
+
+    def test_a_successful_refresh_calls_the_importer(self, stub_api_resource) -> None:
+        with patch("api.admin_resource._import_rulings", return_value=77_961) as importer:
+            stub_api_resource.admin._import_rulings_quietly()
+
+        importer.assert_called_once()
diff --git a/api/tests/test_scryfall_cards_routes.py b/api/tests/test_scryfall_cards_routes.py
new file mode 100644
index 000000000..a5c43f6b3
--- /dev/null
+++ b/api/tests/test_scryfall_cards_routes.py
@@ -0,0 +1,985 @@
+"""Integration tests for the Scryfall-compatible /cards/* routes.
+
+Everything here dispatches through `_handle`, the same path a real request takes: route resolution,
+parameter binding, and the response object the client would receive. The corpus is a handful of
+cards this module inserts under names no other test uses, because the postgres container is shared
+across the session.
+"""
+
+from __future__ import annotations
+
+import copy
+import json
+import uuid
+from typing import TYPE_CHECKING
+from urllib.parse import urlencode
+
+import falcon
+import falcon.testing
+import orjson
+import pytest
+from cachebox import LRUCache
+
+from api.enums import SortDirection, resolve_direction
+from api.scryfall_compat.objects import PAGE_SIZE
+from api.settings import settings
+from api.tests.helpers import make_raw_card
+from api.utils.generation_cache import GenerationCache
+
+if TYPE_CHECKING:
+    from api.api_resource import APIResource
+
+# Set code and names owned by this module alone, so assertions can be exact against a shared
+# database. "sfc" is not a real Scryfall set code.
+SET_CODE = "sfc"
+BOLT_ID = "11111111-1111-4111-8111-111111111111"
+BEAR_ID = "22222222-2222-4222-8222-222222222222"
+DELVER_ID = "33333333-3333-4333-8333-333333333333"
+BOLT_ORACLE_ID = "aaaaaaaa-1111-4111-8111-aaaaaaaaaaaa"
+
+# The by-name key rule wants two more shapes -- a name with FIVE halves and a punctuated, accented
+# one -- and they live in a set of their own so the `s:sfc` paging tests keep asserting three cards.
+NAME_SET_CODE = "sfn"
+WHO_ID = "55555555-5555-4555-8555-555555555555"
+VAULT_ID = "66666666-6666-4666-8666-666666666666"
+# 50 bytes, and deliberately short: the engine stores a card's folded name in an `InlineStr<61>`
+# and TRUNCATES anything longer, so a five-part name spelled "Compat ..." five times (70 bytes) is
+# unreachable through the engine while the SQL fallback still finds it. That is a pre-existing bug
+# in its own right -- 36 names in the real corpus are over the limit -- and not the one under test
+# here, so this name stays inside the bound rather than pinning the wrong divergence.
+WHO_NAME = "Cw Who // Cw What // Cw When // Cw Where // Cw Why"
+VAULT_NAME = "Compat Lim-Dûl's Vault"
+
+
+def _bolt() -> dict:
+    card = make_raw_card(card_id=BOLT_ID, name="Compat Bolt")
+    card |= {
+        "object": "card",
+        "oracle_id": BOLT_ORACLE_ID,
+        "set": SET_CODE,
+        "set_name": "Scryfall Compat",
+        "collector_number": "1",
+        "mana_cost": "{R}",
+        "type_line": "Instant",
+        "oracle_text": "Compat Bolt deals 3 damage to any target.",
+        "lang": "en",
+        "multiverse_ids": [900001],
+        "mtgo_id": 900002,
+        "arena_id": 900003,
+        "tcgplayer_id": 900004,
+        "cardmarket_id": 900005,
+        "illustration_id": "44444444-4444-4444-8444-444444444444",
+    }
+    return card
+
+
+def _bear() -> dict:
+    card = make_raw_card(card_id=BEAR_ID, name="Compat Bears")
+    card |= {
+        "object": "card",
+        "set": SET_CODE,
+        "set_name": "Scryfall Compat",
+        "collector_number": "2",
+        "mana_cost": "{1}{G}",
+        "type_line": "Creature — Bear",
+        "oracle_text": "",
+        "power": "2",
+        "toughness": "2",
+        "colors": ["G"],
+        "color_identity": ["G"],
+        "lang": "en",
+    }
+    return card
+
+
+def _delver() -> dict:
+    """A transform card, so the multi-face path is exercised end to end."""
+    card = make_raw_card(card_id=DELVER_ID, name="Compat Delver // Compat Aberration")
+    card |= {
+        "object": "card",
+        "set": SET_CODE,
+        "set_name": "Scryfall Compat",
+        "collector_number": "3",
+        "layout": "transform",
+        "type_line": "Creature — Human Wizard // Creature — Human Insect",
+        "colors": ["U"],
+        "color_identity": ["U"],
+        "card_faces": [
+            {
+                "object": "card_face",
+                "name": "Compat Delver",
+                "mana_cost": "{U}",
+                "type_line": "Creature — Human Wizard",
+                "oracle_text": "Look at the top card of your library.",
+                "power": "1",
+                "toughness": "1",
+                "colors": ["U"],
+                "image_uris": {"large": "https://cards.test/front.jpg", "png": "https://cards.test/front.png"},
+            },
+            {
+                "object": "card_face",
+                "name": "Compat Aberration",
+                "mana_cost": "",
+                "type_line": "Creature — Human Insect",
+                "oracle_text": "Flying",
+                "power": "3",
+                "toughness": "2",
+                "colors": ["U"],
+                "image_uris": {"large": "https://cards.test/back.jpg", "png": "https://cards.test/back.png"},
+            },
+        ],
+    }
+    card.pop("image_uris", None)
+    return card
+
+
+def _who() -> dict:
+    """A FIVE-part name, which has no face keys at all.
+
+    `{"name":"Who // What // When // Where // Why"}` answers und/75 on api.scryfall.com while
+    `{"name":"Who"}` and `exact=Who` are each not_found -- the whole name is the key and its parts
+    are not. A rule built on `split_part(name, ' // ', 1)` reads this as a card with a front face
+    named "Compat Who" and answers it.
+    """
+    card = make_raw_card(card_id=WHO_ID, name=WHO_NAME)
+    card |= {
+        "object": "card",
+        "set": NAME_SET_CODE,
+        "set_name": "Scryfall Compat Names",
+        "collector_number": "1",
+        "layout": "split",
+        "type_line": " // ".join(["Sorcery"] * 5),
+        "colors": ["W"],
+        "color_identity": ["W"],
+        "card_faces": [
+            {
+                "object": "card_face",
+                "name": part,
+                "mana_cost": "{W}",
+                "type_line": "Sorcery",
+                "oracle_text": f"{part} does nothing.",
+            }
+            for part in WHO_NAME.split(" // ")
+        ],
+    }
+    card.pop("image_uris", None)
+    return card
+
+
+def _vault() -> dict:
+    """A name carrying an accent AND an apostrophe AND a hyphen, so collation has something to do.
+
+    `{"name":"limduls vault"}` and `{"name":"lim-duls vault"}` both answer Lim-Dûl's Vault on
+    api.scryfall.com, and `exact=` of either does too. Every one of those spellings was a 404 here.
+    """
+    card = make_raw_card(card_id=VAULT_ID, name=VAULT_NAME)
+    card |= {
+        "object": "card",
+        "set": NAME_SET_CODE,
+        "set_name": "Scryfall Compat Names",
+        "collector_number": "2",
+        "mana_cost": "{1}{B}",
+        "type_line": "Instant",
+        "oracle_text": "Look at the top five cards of your library.",
+        "colors": ["B"],
+        "color_identity": ["B"],
+        "lang": "en",
+    }
+    return card
+
+
+@pytest.fixture(name="compat_corpus", scope="module")
+def compat_corpus_fixture(api_resource: APIResource) -> APIResource:
+    """Load this module's cards and their rulings once, then hand back the resource."""
+    api_resource.admin._upsert_cards([copy.deepcopy(card) for card in (_bolt(), _bear(), _delver(), _who(), _vault())])
+    with api_resource.app_context.reader_pool.connection() as conn, conn.cursor() as cursor:
+        cursor.execute("DELETE FROM magic.rulings WHERE oracle_id = %(oracle_id)s", {"oracle_id": BOLT_ORACLE_ID})
+        # Three rulings across two dates, two of them same-day: a single ruling cannot tell one
+        # ordering from another, which is how the ascending sort went unnoticed. Inserted oldest
+        # first so the expected answer is not the insertion order either.
+        cursor.executemany(
+            "INSERT INTO magic.rulings (oracle_id, source, published_at, comment) VALUES (%s, %s, %s, %s)",
+            [
+                (BOLT_ORACLE_ID, "wotc", "2004-10-04", "Any target means any target."),
+                (BOLT_ORACLE_ID, "wotc", "2021-02-05", "Zero damage is still damage."),
+                (BOLT_ORACLE_ID, "wotc", "2021-02-05", "A later clarification."),
+            ],
+        )
+        conn.commit()
+    # /cards/search runs through _search, which prefers the in-process engine when its store is
+    # loaded -- a store built before this insert would answer every query here with zero rows.
+    api_resource.app_context.reload_engine(force=True)
+    api_resource.admin._clear_caches()
+    return api_resource
+
+
+def dispatch(api: APIResource, path: str, query_string: str = "", *, method: str = "GET", body: dict | None = None):
+    """Run one request through `_handle` and return the Falcon response."""
+    environ = falcon.testing.create_environ(
+        path=path,
+        query_string=query_string,
+        method=method,
+        body=json.dumps(body) if body is not None else "",
+        headers={"Content-Type": "application/json"} if body is not None else None,
+    )
+    req = falcon.Request(environ)
+    resp = falcon.Response()
+    api._handle(req, resp)
+    return resp
+
+
+@pytest.fixture(name="by_name_paths", params=["engine", "sql"])
+def by_name_paths_fixture(request, compat_corpus: APIResource):
+    """The corpus with the engine serving, and again with it gated off so SQL answers.
+
+    The two are not peers -- every by-name route asks the engine first and reaches Postgres only
+    when no store is loaded -- but they must agree, or the same request answers differently
+    depending on which worker takes it. Running each case twice is what says so.
+    """
+    saved = settings.enable_engine
+    settings.enable_engine = request.param == "engine"
+    yield compat_corpus
+    settings.enable_engine = saved
+
+
+def payload(resp) -> dict:
+    """Decode a response body regardless of whether it was set as media or as text."""
+    if resp.media is not None:
+        return resp.media
+    return orjson.loads(resp.render_body())
+
+
+class TestRouteRegistration:
+    """Every Scryfall /cards/* path resolves, and only the ones that exist."""
+
+    @pytest.mark.parametrize(
+        "path",
+        ["cards", "cards/search", "cards/named", "cards/autocomplete", "cards/random", "cards/collection"],
+    )
+    def test_path_is_registered(self, stub_api_resource: APIResource, path):
+        assert path in stub_api_resource.routes
+
+    def test_catch_all_absorbs_three_segments(self, stub_api_resource: APIResource):
+        """/cards/:code/:number/:lang is the longest shape, so capacity must be exactly three."""
+        assert stub_api_resource.routes["cards"].positional_capacity == 3
+
+    def test_a_fourth_segment_is_not_a_route(self, stub_api_resource: APIResource):
+        entry, _ = stub_api_resource._resolve_action("cards/a/b/c/d")
+        assert entry is None
+
+    def test_collection_answers_post_not_get(self, stub_api_resource: APIResource):
+        spec = stub_api_resource.routes["cards/collection"].spec
+        assert spec.methods == frozenset({"POST"})
+
+    def test_the_named_subroutes_win_over_the_catch_all(self, stub_api_resource: APIResource):
+        entry, args = stub_api_resource._resolve_action("cards/search")
+        assert args == []
+        assert entry.action.__name__ == "scryfall_cards_search"
+
+
+class TestSearch:
+    """GET /cards/search."""
+
+    def test_returns_a_list_object(self, compat_corpus: APIResource):
+        body = payload(dispatch(compat_corpus, "/cards/search", "q=%21%22Compat+Bolt%22"))
+        assert body["object"] == "list"
+        assert body["total_cards"] == 1
+        assert body["has_more"] is False
+        assert body["data"][0]["name"] == "Compat Bolt"
+
+    def test_cards_are_full_scryfall_objects(self, compat_corpus: APIResource):
+        card = payload(dispatch(compat_corpus, "/cards/search", "q=%21%22Compat+Bolt%22"))["data"][0]
+        assert card["object"] == "card"
+        assert card["id"] == BOLT_ID
+        assert card["oracle_text"] == "Compat Bolt deals 3 damage to any target."
+        assert "card_name" not in card
+
+    def test_no_match_is_a_scryfall_404(self, compat_corpus: APIResource):
+        resp = dispatch(compat_corpus, "/cards/search", "q=%21%22No+Such+Compat+Card%22")
+        body = payload(resp)
+        assert resp.status == falcon.HTTP_404
+        assert body["object"] == "error"
+        assert body["code"] == "not_found"
+
+    def test_missing_query_is_a_scryfall_400(self, compat_corpus: APIResource):
+        resp = dispatch(compat_corpus, "/cards/search")
+        assert resp.status == falcon.HTTP_400
+        assert payload(resp)["details"] == "You didn't enter anything to search for."
+
+    @pytest.mark.parametrize("order", ["penny", "review"])
+    def test_the_two_unsupported_orders_warn_instead_of_failing(self, compat_corpus: APIResource, order):
+        """Scryfall itself falls back silently; the cards still come back, with a note saying why."""
+        body = payload(dispatch(compat_corpus, "/cards/search", f"q=%21%22Compat+Bolt%22&order={order}"))
+        assert body["total_cards"] == 1
+        assert any(order in warning for warning in body["warnings"])
+
+    @pytest.mark.parametrize("order", ["released", "set", "artist", "color", "eur", "tix", "rarity", "cmc"])
+    def test_supported_orders_do_not_warn(self, compat_corpus: APIResource, order):
+        """The vocabulary is built from CardOrdering, so this fails if an ordering stops being wired."""
+        body = payload(dispatch(compat_corpus, "/cards/search", f"q=%21%22Compat+Bolt%22&order={order}"))
+        assert body["total_cards"] == 1
+        assert "warnings" not in body
+
+    def test_an_unrecognized_order_still_warns(self, compat_corpus: APIResource):
+        body = payload(dispatch(compat_corpus, "/cards/search", "q=%21%22Compat+Bolt%22&order=nonsense"))
+        assert any("nonsense" in warning for warning in body["warnings"])
+
+    @pytest.mark.parametrize(
+        ("order", "expected"),
+        [("usd", SortDirection.DESC), ("rarity", SortDirection.DESC), ("name", SortDirection.ASC)],
+        ids=["usd-desc", "rarity-desc", "name-asc"],
+    )
+    def test_dir_auto_resolves_per_order(self, compat_corpus: APIResource, monkeypatch, order, expected):
+        """`auto` is Scryfall's default and is per-ordering; it must not flatten to ascending.
+
+        Asserted on what reaches `_search` rather than on the returned page, because the fixture
+        corpus is too small for two directions to differ on most orderings.
+        """
+        seen = {}
+        original = compat_corpus._search
+
+        def spy(**kwargs: object) -> dict:
+            seen.update(kwargs)
+            return original(**kwargs)
+
+        monkeypatch.setattr(compat_corpus, "_search", spy)
+        dispatch(compat_corpus, "/cards/search", f"q=%21%22Compat+Bolt%22&order={order}&dir=auto")
+        assert resolve_direction(seen["direction"], seen["orderby"]) == expected
+
+    def test_an_explicit_dir_is_not_turned_into_auto(self, compat_corpus: APIResource, monkeypatch):
+        seen = {}
+        original = compat_corpus._search
+        monkeypatch.setattr(compat_corpus, "_search", lambda **kw: (seen.update(kw), original(**kw))[1])
+        dispatch(compat_corpus, "/cards/search", "q=%21%22Compat+Bolt%22&order=usd&dir=asc")
+        assert seen["direction"] == SortDirection.ASC
+
+    def test_page_beyond_the_results_is_a_404(self, compat_corpus: APIResource):
+        resp = dispatch(compat_corpus, "/cards/search", "q=%21%22Compat+Bolt%22&page=2")
+        assert resp.status == falcon.HTTP_404
+
+    def test_next_page_is_absent_when_the_page_is_the_last(self, compat_corpus: APIResource):
+        assert "next_page" not in payload(dispatch(compat_corpus, "/cards/search", "q=%21%22Compat+Bolt%22"))
+
+    def test_page_size_matches_scryfall(self):
+        assert PAGE_SIZE == 175
+
+    def test_pretty_emits_indented_json(self, compat_corpus: APIResource):
+        resp = dispatch(compat_corpus, "/cards/search", "q=%21%22Compat+Bolt%22&pretty=true")
+        assert resp.text.startswith('{\n  "object"')
+
+    def test_csv_format_has_a_stable_header(self, compat_corpus: APIResource):
+        resp = dispatch(compat_corpus, "/cards/search", "q=%21%22Compat+Bolt%22&format=csv")
+        assert resp.content_type.startswith("text/csv")
+        header, row = resp.text.splitlines()[:2]
+        assert header.startswith("object,id,oracle_id,")
+        assert BOLT_ID in row
+
+    def test_unparseable_query_is_a_scryfall_400(self, compat_corpus: APIResource):
+        resp = dispatch(compat_corpus, "/cards/search", "q=cmc%3E")
+        assert resp.status == falcon.HTTP_400
+        assert payload(resp)["object"] == "error"
+
+
+class TestNamed:
+    """GET /cards/named."""
+
+    def test_exact_match_is_case_insensitive(self, compat_corpus: APIResource):
+        body = payload(dispatch(compat_corpus, "/cards/named", "exact=compat+bolt"))
+        assert body["name"] == "Compat Bolt"
+
+    def test_exact_miss_is_a_404(self, compat_corpus: APIResource):
+        resp = dispatch(compat_corpus, "/cards/named", "exact=Compat+Nothing")
+        assert resp.status == falcon.HTTP_404
+        assert payload(resp)["code"] == "not_found"
+
+    def test_exact_matches_one_face_of_a_multi_face_card(self, compat_corpus: APIResource):
+        body = payload(dispatch(compat_corpus, "/cards/named", "exact=Compat+Aberration"))
+        assert body["id"] == DELVER_ID
+
+    def test_set_filter_narrows_the_match(self, compat_corpus: APIResource):
+        body = payload(dispatch(compat_corpus, "/cards/named", f"exact=Compat+Bolt&set={SET_CODE}"))
+        assert body["set"] == SET_CODE
+
+    def test_set_filter_that_excludes_the_card_is_a_404(self, compat_corpus: APIResource):
+        resp = dispatch(compat_corpus, "/cards/named", "exact=Compat+Bolt&set=zzz")
+        assert resp.status == falcon.HTTP_404
+
+    def test_fuzzy_resolves_a_containment_match(self, compat_corpus: APIResource):
+        body = payload(dispatch(compat_corpus, "/cards/named", "fuzzy=compat+bears"))
+        assert body["name"] == "Compat Bears"
+
+    def test_fuzzy_tolerates_a_typo(self, compat_corpus: APIResource):
+        body = payload(dispatch(compat_corpus, "/cards/named", "fuzzy=Compat+Bolzt"))
+        assert body["name"] == "Compat Bolt"
+
+    def test_fuzzy_miss_is_a_404(self, compat_corpus: APIResource):
+        resp = dispatch(compat_corpus, "/cards/named", "fuzzy=qqqqzzzzxxxx")
+        assert resp.status == falcon.HTTP_404
+
+    def test_neither_parameter_is_a_400(self, compat_corpus: APIResource):
+        resp = dispatch(compat_corpus, "/cards/named")
+        assert resp.status == falcon.HTTP_400
+        assert payload(resp)["code"] == "bad_request"
+
+    def test_text_format_renders_plain_text(self, compat_corpus: APIResource):
+        resp = dispatch(compat_corpus, "/cards/named", "exact=Compat+Bolt&format=text")
+        assert resp.content_type.startswith("text/plain")
+        assert resp.text.splitlines()[0] == "Compat Bolt {R}"
+
+    def test_image_format_redirects_to_the_image(self, compat_corpus: APIResource):
+        with pytest.raises(falcon.HTTPFound) as found:
+            dispatch(compat_corpus, "/cards/named", "exact=Compat+Bolt&format=image&version=png")
+        assert "/png/" in found.value.headers["location"]
+
+    def test_image_format_honors_the_back_face(self, compat_corpus: APIResource):
+        with pytest.raises(falcon.HTTPFound) as found:
+            dispatch(compat_corpus, "/cards/named", "exact=Compat+Delver&format=image&face=back&version=large")
+        # Derived from the card id, not read from the fixture: image URLs are a pure function of
+        # the id, so the store carries none of them.
+        assert (
+            found.value.headers["location"] == "https://cards.scryfall.io/large/back/3/3/33333333-3333-4333-8333-333333333333.jpg"
+        )
+
+
+class TestNameKeyRule:
+    """The keys a card answers to, on `named?exact=` and on a collection `{"name"}` identifier.
+
+    THE TWO ARE NOT THE SAME LOOKUP. Measured against api.scryfall.com on 2026-08-31, ONE
+    IDENTIFIER PER REQUEST -- a collection response's `data` is not in identifier order, and a
+    batched probe attributes its answers to the wrong needles, which is how the first reading of
+    this rule came out wrong:
+
+      {"name":"Delver of Secrets"}                   -> Delver of Secrets // Insectile Aberration
+      {"name":"Insectile Aberration"}                -> the same card (a BACK face names it)
+      {"name":"Delver of Secrets // Insectile ..."}  -> not_found, where `exact=` is the card
+      {"name":"Fire // Ice"} / {"Wear // Tear"} /
+      {"name":"Bonecrusher Giant // Stomp"}          -> not_found, all three
+      {"name":"Who // What // When // Where // Why"} -> und/75, a FIVE-part name IS a key
+      {"name":"Who"}                                 -> not_found, and so is `exact=Who`
+      {"name":"Elves"}                               -> Elves (ffdn/9), a KEY and not a substring
+      {"name":"limduls vault"}                       -> Lim-Dûl's Vault, collated
+      {"name":"  Lightning Bolt  "}                  -> Lightning Bolt, trimmed
+      {"name":"Delver of Secrets","set":"mid"}       -> mid/47, set FILTERS the lookup
+
+    Every case runs TWICE, through `by_name_paths`: once with the engine serving and once with it
+    gated off so the SQL fallback answers. The fallback is what a worker with no store loaded uses,
+    so a key rule expressed in only one of the two is a rule this API applies only sometimes.
+    """
+
+    @staticmethod
+    def _collection(api: APIResource, name: str, set_code: str | None = None) -> dict:
+        identifier: dict = {"name": name}
+        if set_code:
+            identifier["set"] = set_code
+        return payload(dispatch(api, "/cards/collection", method="POST", body={"identifiers": [identifier]}))
+
+    @staticmethod
+    def _resolves(api: APIResource, name: str, set_code: str | None = None) -> str | None:
+        """The id a collection identifier resolves to, or None for not_found."""
+        body = TestNameKeyRule._collection(api, name, set_code)
+        return body["data"][0]["id"] if body["data"] else None
+
+    @staticmethod
+    def _exact(api: APIResource, name: str) -> str | None:
+        """The id `named?exact=name` resolves to, or None for a 404."""
+        resp = dispatch(api, "/cards/named", urlencode({"exact": name}))
+        return None if resp.status == falcon.HTTP_404 else payload(resp)["id"]
+
+    @pytest.mark.parametrize("name", ["Compat Delver", "Compat Aberration"])
+    def test_either_face_names_the_card_on_both_surfaces(self, by_name_paths: APIResource, name):
+        """The BACK face is the half the predicate this replaced never looked at.
+
+        It compared `split_part(card_name, ' // ', 1)` and the whole name, so
+        `{"name":"Compat Aberration"}` missed a card api.scryfall.com resolves.
+        """
+        assert self._resolves(by_name_paths, name) == DELVER_ID
+        assert self._exact(by_name_paths, name) == DELVER_ID
+
+    def test_the_joined_name_is_exacts_key_and_not_a_collection_identifiers(self, by_name_paths: APIResource):
+        """The one key the two surfaces disagree about."""
+        joined = "Compat Delver // Compat Aberration"
+        assert self._exact(by_name_paths, joined) == DELVER_ID
+        assert self._resolves(by_name_paths, joined) is None
+
+    def test_a_five_part_name_is_a_key_and_none_of_its_parts_is(self, by_name_paths: APIResource):
+        """EXACTLY two halves is what makes a face key, which `split_part` cannot say on its own."""
+        assert self._resolves(by_name_paths, WHO_NAME) == WHO_ID
+        assert self._exact(by_name_paths, WHO_NAME) == WHO_ID
+        for part in WHO_NAME.split(" // "):
+            assert self._resolves(by_name_paths, part) is None, part
+            assert self._exact(by_name_paths, part) is None, part
+
+    @pytest.mark.parametrize(
+        "spelling",
+        [
+            "Compat Lim-Dûl's Vault",
+            "Compat Lim-Dul's Vault",
+            "compat limduls vault",
+            "compat lim-duls vault",
+            "compatlimdulsvault",
+            "COMPAT LIMDULS VAULT",
+        ],
+    )
+    def test_names_compare_collated(self, by_name_paths: APIResource, spelling):
+        """Accent, apostrophe, hyphen and spacing all drop out of the comparison."""
+        assert self._resolves(by_name_paths, spelling) == VAULT_ID
+        assert self._exact(by_name_paths, spelling) == VAULT_ID
+
+    def test_a_collated_face_does_not_straddle_the_join(self, by_name_paths: APIResource):
+        """The halves are split BEFORE either side is collated, so `" // "` is not just punctuation.
+
+        Collating first would delete the join and let `compatdelvercompataberration` -- and worse,
+        a needle spanning it -- read as a face.
+        """
+        assert self._resolves(by_name_paths, "compatdelver") == DELVER_ID
+        assert self._resolves(by_name_paths, "delvercompataberration") is None
+        assert self._resolves(by_name_paths, "compatdelvercompataberration") is None
+        assert self._exact(by_name_paths, "compatdelvercompataberration") == DELVER_ID
+
+    def test_leading_and_trailing_whitespace_is_not_part_of_the_name(self, by_name_paths: APIResource):
+        """`{"name":"  Lightning Bolt  "}` resolves on api.scryfall.com; this compared it as posted."""
+        assert self._resolves(by_name_paths, "  Compat Bolt  ") == BOLT_ID
+
+    @pytest.mark.parametrize("needle", ["Compat", "Bolt", "Vault", "", "   "])
+    def test_a_substring_of_a_name_is_not_a_key(self, by_name_paths: APIResource, needle):
+        """A name lookup, not a search.
+
+        `{"name":"Elves"}` answers *Elves* (ffdn/9) on api.scryfall.com -- the card actually named
+        that, not one of the hundreds whose names contain the word, which is what a containment
+        lookup cut to one row would have answered.
+        """
+        assert self._resolves(by_name_paths, needle) is None
+
+    def test_set_filters_the_lookup(self, by_name_paths: APIResource):
+        """`{"name":"Delver of Secrets","set":"mid"}` answers mid/47 -- the card, in the set asked for.
+
+        A card with no printing in that set drops out of the lookup rather than answering another
+        printing, which is the same thing `exact=&set=` does.
+        """
+        assert self._resolves(by_name_paths, "Compat Bolt", SET_CODE) == BOLT_ID
+        assert self._resolves(by_name_paths, "Compat Bolt", NAME_SET_CODE) is None
+        assert self._resolves(by_name_paths, VAULT_NAME, NAME_SET_CODE) == VAULT_ID
+
+    def test_an_unresolvable_name_comes_back_in_not_found(self, by_name_paths: APIResource):
+        """Reported, not dropped: the client has to be able to tell which identifier failed."""
+        body = self._collection(by_name_paths, "Compat Delver // Compat Aberration")
+        assert body["data"] == []
+        assert body["not_found"] == [{"name": "Compat Delver // Compat Aberration"}]
+
+
+class TestAutocomplete:
+    """GET /cards/autocomplete."""
+
+    def test_returns_a_catalog(self, compat_corpus: APIResource):
+        body = payload(dispatch(compat_corpus, "/cards/autocomplete", "q=Compat+Bol"))
+        assert body["object"] == "catalog"
+        assert "Compat Bolt" in body["data"]
+        assert body["total_values"] == len(body["data"])
+
+    def test_short_queries_return_an_empty_catalog(self, compat_corpus: APIResource):
+        assert payload(dispatch(compat_corpus, "/cards/autocomplete", "q=C"))["data"] == []
+
+    def test_at_most_twenty_values(self, compat_corpus: APIResource):
+        assert len(payload(dispatch(compat_corpus, "/cards/autocomplete", "q=co"))["data"]) <= 20
+
+
+class TestRandom:
+    """GET /cards/random."""
+
+    def test_returns_a_card(self, compat_corpus: APIResource):
+        """Unrestricted, so it can draw any row in the session-shared database -- assert on id only.
+
+        The `object` key comes from whatever the drawn row's blob holds, and other modules insert
+        fixtures that never had one; `test_query_restricts_the_draw` pins the full shape.
+        """
+        body = payload(dispatch(compat_corpus, "/cards/random"))
+        assert uuid.UUID(body["id"])
+
+    def test_query_restricts_the_draw(self, compat_corpus: APIResource):
+        body = payload(dispatch(compat_corpus, "/cards/random", "q=%21%22Compat+Bolt%22"))
+        assert body["object"] == "card"
+        assert body["id"] == BOLT_ID
+
+    def test_query_matching_nothing_is_a_404(self, compat_corpus: APIResource):
+        resp = dispatch(compat_corpus, "/cards/random", "q=%21%22No+Such+Compat+Card%22")
+        assert resp.status == falcon.HTTP_404
+
+    def test_repeated_draws_are_not_all_the_same_card(self, compat_corpus: APIResource, monkeypatch):
+        """The draw's SQL text and parameters never vary, so a memoized result would pin one card.
+
+        The query cache holds a single entry when caching is off, which is how the suite runs — the
+        count query and the draw evict each other and the bug hides. So this installs the
+        multi-entry cache production has. Twenty draws over a corpus of at least three cards
+        collide on one id with probability below (1/3)**19, so one distinct id here means the
+        result was replayed rather than redrawn.
+        """
+        monkeypatch.setattr(
+            compat_corpus,
+            "_query_cache",
+            GenerationCache(factory=lambda: LRUCache(maxsize=1_000), generation=compat_corpus.app_context.cache_generation),
+        )
+        drawn = {payload(dispatch(compat_corpus, "/cards/random"))["id"] for _ in range(20)}
+        assert len(drawn) > 1
+
+    def test_the_response_is_marked_uncacheable(self, compat_corpus: APIResource):
+        resp = dispatch(compat_corpus, "/cards/random")
+        assert "no-store" in resp.get_header("Cache-Control")
+
+
+class TestByIdentifier:
+    """GET /cards/:id and the external-id namespaces."""
+
+    def test_scryfall_id(self, compat_corpus: APIResource):
+        assert payload(dispatch(compat_corpus, f"/cards/{BOLT_ID}"))["id"] == BOLT_ID
+
+    def test_unknown_scryfall_id_is_a_404(self, compat_corpus: APIResource):
+        resp = dispatch(compat_corpus, f"/cards/{uuid.uuid4()}")
+        assert resp.status == falcon.HTTP_404
+        assert payload(resp)["object"] == "error"
+
+    def test_a_segment_that_is_not_a_uuid_is_a_404(self, compat_corpus: APIResource):
+        assert dispatch(compat_corpus, "/cards/not-an-id").status == falcon.HTTP_404
+
+    @pytest.mark.parametrize(
+        ("namespace", "external_id"),
+        [("multiverse", 900001), ("mtgo", 900002), ("arena", 900003), ("tcgplayer", 900004), ("cardmarket", 900005)],
+    )
+    def test_external_id_namespaces(self, compat_corpus: APIResource, namespace, external_id):
+        assert payload(dispatch(compat_corpus, f"/cards/{namespace}/{external_id}"))["id"] == BOLT_ID
+
+    def test_unknown_external_id_is_a_404(self, compat_corpus: APIResource):
+        assert dispatch(compat_corpus, "/cards/mtgo/999999999").status == falcon.HTTP_404
+
+    def test_non_numeric_external_id_is_a_404(self, compat_corpus: APIResource):
+        assert dispatch(compat_corpus, "/cards/mtgo/abc").status == falcon.HTTP_404
+
+    def test_set_code_and_collector_number(self, compat_corpus: APIResource):
+        assert payload(dispatch(compat_corpus, f"/cards/{SET_CODE}/1"))["id"] == BOLT_ID
+
+    def test_set_code_is_case_insensitive(self, compat_corpus: APIResource):
+        assert payload(dispatch(compat_corpus, f"/cards/{SET_CODE.upper()}/1"))["id"] == BOLT_ID
+
+    def test_language_segment_selects_english_by_default(self, compat_corpus: APIResource):
+        assert payload(dispatch(compat_corpus, f"/cards/{SET_CODE}/1/en"))["id"] == BOLT_ID
+
+    def test_a_language_the_printing_lacks_is_a_404(self, compat_corpus: APIResource):
+        assert dispatch(compat_corpus, f"/cards/{SET_CODE}/1/ja").status == falcon.HTTP_404
+
+    def test_text_format_on_a_path_lookup(self, compat_corpus: APIResource):
+        resp = dispatch(compat_corpus, f"/cards/{BOLT_ID}", "format=text")
+        assert resp.text.splitlines()[0] == "Compat Bolt {R}"
+
+
+class TestMultiFaceFidelity:
+    """A multi-face printing comes back as the card Scryfall sent, not as one of its faces."""
+
+    def test_the_card_object_carries_its_faces(self, compat_corpus: APIResource):
+        card = payload(dispatch(compat_corpus, f"/cards/{DELVER_ID}"))
+        assert card["object"] == "card"
+        assert card["name"] == "Compat Delver // Compat Aberration"
+        assert [face["name"] for face in card["card_faces"]] == ["Compat Delver", "Compat Aberration"]
+
+    def test_no_importer_key_reaches_the_payload(self, compat_corpus: APIResource):
+        """The blob is the card, but not byte-for-byte: three internal keys have to come back off."""
+        card = payload(dispatch(compat_corpus, f"/cards/{DELVER_ID}"))
+        assert not {"card_name", "face_name", "face_idx", "raw_card_blob"} & set(card)
+
+    def test_text_format_renders_both_faces(self, compat_corpus: APIResource):
+        resp = dispatch(compat_corpus, f"/cards/{DELVER_ID}", "format=text")
+        assert "Compat Delver {U}" in resp.text
+        assert "Compat Aberration" in resp.text
+
+
+class TestCollection:
+    """POST /cards/collection."""
+
+    def test_resolves_mixed_identifiers(self, compat_corpus: APIResource):
+        body = payload(
+            dispatch(
+                compat_corpus,
+                "/cards/collection",
+                method="POST",
+                body={"identifiers": [{"id": BOLT_ID}, {"name": "Compat Bears"}, {"set": SET_CODE, "collector_number": "3"}]},
+            ),
+        )
+        assert body["object"] == "list"
+        assert {card["id"] for card in body["data"]} == {BOLT_ID, BEAR_ID, DELVER_ID}
+        assert body["not_found"] == []
+
+    def test_unresolvable_identifiers_are_reported(self, compat_corpus: APIResource):
+        body = payload(
+            dispatch(compat_corpus, "/cards/collection", method="POST", body={"identifiers": [{"name": "Nothing At All Compat"}]}),
+        )
+        assert body["data"] == []
+        assert body["not_found"] == [{"name": "Nothing At All Compat"}]
+
+    def test_oracle_id_identifier(self, compat_corpus: APIResource):
+        body = payload(
+            dispatch(compat_corpus, "/cards/collection", method="POST", body={"identifiers": [{"oracle_id": BOLT_ORACLE_ID}]}),
+        )
+        assert body["data"][0]["id"] == BOLT_ID
+
+    def test_over_the_limit_is_a_422(self, compat_corpus: APIResource):
+        resp = dispatch(
+            compat_corpus,
+            "/cards/collection",
+            method="POST",
+            body={"identifiers": [{"id": BOLT_ID}] * 76},
+        )
+        assert resp.status == falcon.HTTP_422
+        assert payload(resp)["code"] == "validation_error"
+
+    def test_a_body_without_identifiers_is_a_422(self, compat_corpus: APIResource):
+        resp = dispatch(compat_corpus, "/cards/collection", method="POST", body={"cards": []})
+        assert resp.status == falcon.HTTP_422
+
+    def test_get_is_not_allowed(self, compat_corpus: APIResource):
+        """Answered rather than raised, and as Scryfall answers it: 404, `not_found`, no `Allow`."""
+        resp = dispatch(compat_corpus, "/cards/collection")
+        assert resp.status == falcon.HTTP_404
+        assert "allow" not in resp.headers
+        assert payload(resp) == {
+            "object": "error",
+            "code": "not_found",
+            "status": 404,
+            "details": "The requested object or REST method was not found.",
+        }
+
+
+class TestRulings:
+    """The five rulings routes."""
+
+    def test_rulings_by_scryfall_id(self, compat_corpus: APIResource):
+        body = payload(dispatch(compat_corpus, f"/cards/{BOLT_ID}/rulings"))
+        assert body["object"] == "list"
+        assert body["data"][0]["object"] == "ruling"
+
+    def test_rulings_are_newest_first_like_scryfalls(self, compat_corpus: APIResource):
+        """The order api.scryfall.com serves: `published_at` descending.
+
+        Measured against it on 2026-08-12 -- 16 of 16 cards whose rulings span more than one date
+        came back newest-first, 0 oldest-first. The ascending sort this replaced inverted every one
+        of them, which is the opposite of what a compatibility surface is for.
+
+        The order WITHIN one date is `comment` only because something has to be deterministic:
+        Scryfall breaks that tie with an internal ruling id the bulk file does not carry.
+        """
+        body = payload(dispatch(compat_corpus, f"/cards/{BOLT_ID}/rulings"))
+        assert [(row["published_at"], row["comment"]) for row in body["data"]] == [
+            ("2021-02-05", "A later clarification."),
+            ("2021-02-05", "Zero damage is still damage."),
+            ("2004-10-04", "Any target means any target."),
+        ]
+
+    def test_rulings_by_set_and_collector_number(self, compat_corpus: APIResource):
+        body = payload(dispatch(compat_corpus, f"/cards/{SET_CODE}/1/rulings"))
+        assert len(body["data"]) == 3
+
+    @pytest.mark.parametrize(
+        ("namespace", "external_id"),
+        [("multiverse", 900001), ("mtgo", 900002), ("arena", 900003)],
+    )
+    def test_rulings_by_external_id(self, compat_corpus: APIResource, namespace, external_id):
+        body = payload(dispatch(compat_corpus, f"/cards/{namespace}/{external_id}/rulings"))
+        assert len(body["data"]) == 3
+
+    def test_a_card_with_no_rulings_returns_an_empty_list(self, compat_corpus: APIResource):
+        body = payload(dispatch(compat_corpus, f"/cards/{BEAR_ID}/rulings"))
+        assert body["data"] == []
+        assert body["has_more"] is False
+
+    @pytest.mark.parametrize(
+        ("path", "details"),
+        [
+            # The path addresses nothing at all.
+            ("/cards/not-a-uuid", "The requested object or REST method was not found."),
+            ("/cards/multiverse", "The requested object or REST method was not found."),
+            # A well-formed address that resolves to no card.
+            ("/cards/00000000-0000-4000-8000-000000000000", "No card found with the given ID or set code and collector number."),
+            ("/cards/multiverse/99999999", "No card found with the given ID or set code and collector number."),
+            # `/cards/<x>/rulings` where x is not an id reads as a set code and a collector number
+            # called "rulings", so Scryfall answers the CARD miss rather than the rulings one.
+            ("/cards/not-a-uuid/rulings", "No card found with the given ID or set code and collector number."),
+            # The rulings shapes.
+            (
+                "/cards/00000000-0000-4000-8000-000000000000/rulings",
+                "No card found with the given ID, multiverse ID, or set code & collector number.",
+            ),
+            (
+                "/cards/multiverse/99999999/rulings",
+                "No card found with the given ID, multiverse ID, or set code & collector number.",
+            ),
+            ("/cards/zzz/999/rulings", "No card found with the given ID, multiverse ID, or set code & collector number."),
+        ],
+    )
+    def test_a_miss_carries_the_body_scryfall_words_for_that_shape(
+        self, compat_corpus: APIResource, path: str, details: str
+    ) -> None:
+        """Three bodies, not one, and none of them the string this used to send.
+
+        Captured from api.scryfall.com on 2026-08-12. Nothing pinned `details` before -- the route
+        tests asserted the status and the code and left the field a client string-matches alone,
+        which is exactly how a compatibility surface drifts on it.
+        """
+        response = dispatch(compat_corpus, path)
+        assert response.status == falcon.HTTP_404
+        assert payload(response)["details"] == details
+
+    def test_rulings_for_an_unknown_card_is_a_404(self, compat_corpus: APIResource):
+        assert dispatch(compat_corpus, f"/cards/{uuid.uuid4()}/rulings").status == falcon.HTTP_404
+
+
+class TestAllCards:
+    """GET /cards, the unfiltered listing."""
+
+    def test_first_page_is_a_list_object(self, compat_corpus: APIResource):
+        body = payload(dispatch(compat_corpus, "/cards"))
+        assert body["object"] == "list"
+        assert body["total_cards"] >= 3
+        assert len(body["data"]) <= PAGE_SIZE
+
+    def test_a_page_past_the_end_is_a_404(self, compat_corpus: APIResource):
+        assert dispatch(compat_corpus, "/cards", "page=100000").status == falcon.HTTP_404
+
+    def test_a_non_positive_page_is_a_400(self, compat_corpus: APIResource):
+        resp = dispatch(compat_corpus, "/cards", "page=0")
+        assert resp.status == falcon.HTTP_400
+        assert payload(resp)["code"] == "bad_request"
+
+    def test_next_page_addresses_this_host(self, compat_corpus: APIResource, monkeypatch):
+        """The listing builds its own next_page, on a path the search route's tests never reach.
+
+        Page size shrunk to 1 so a second page exists over the session's corpus rather than
+        needing 176 rows.
+        """
+        monkeypatch.setattr("api.scryfall_compat.routes.PAGE_SIZE", 1)
+        body = payload(dispatch(compat_corpus, "/cards"))
+        assert body["has_more"] is True
+        assert body["next_page"] == "http://falconframework.org/cards?page=2"
+
+
+class TestThroughTheFullApp:
+    """The same routes through a real Falcon app, which `_handle` alone does not exercise.
+
+    `_handle` leaves `resp.media` for the framework to serialize and lets a redirect propagate as an
+    exception. Only a full app resolves the media handler against the `application/json;
+    charset=utf-8` content type these routes set, and only a full app turns `format=image` into an
+    actual 302.
+    """
+
+    def _client(self, api: APIResource) -> falcon.testing.TestClient:
+        app = falcon.App()
+        app.add_sink(api._handle, prefix="/")
+        return falcon.testing.TestClient(app)
+
+    def test_a_card_serializes_over_the_wire(self, compat_corpus: APIResource):
+        result = self._client(compat_corpus).simulate_get(f"/cards/{BOLT_ID}")
+        assert result.status_code == 200
+        assert result.headers["content-type"] == "application/json; charset=utf-8"
+        assert orjson.loads(result.content)["id"] == BOLT_ID
+
+    def test_a_search_serializes_over_the_wire(self, compat_corpus: APIResource):
+        result = self._client(compat_corpus).simulate_get("/cards/search", params={"q": '!"Compat Bolt"'})
+        assert result.status_code == 200
+        assert orjson.loads(result.content)["object"] == "list"
+
+    def test_an_error_carries_its_status_over_the_wire(self, compat_corpus: APIResource):
+        result = self._client(compat_corpus).simulate_get("/cards/named", params={"exact": "Compat Nothing"})
+        assert result.status_code == 404
+        assert orjson.loads(result.content) == {
+            "object": "error",
+            "code": "not_found",
+            "status": 404,
+            "details": "No cards found matching “Compat Nothing”",
+        }
+
+    def test_image_format_is_a_302(self, compat_corpus: APIResource):
+        result = self._client(compat_corpus).simulate_get(
+            "/cards/named",
+            params={"exact": "Compat Delver", "format": "image", "face": "back"},
+        )
+        assert result.status_code == 302
+        assert result.headers["location"] == "https://cards.scryfall.io/large/back/3/3/33333333-3333-4333-8333-333333333333.jpg"
+
+    def test_head_is_accepted_wherever_get_is(self, compat_corpus: APIResource):
+        assert self._client(compat_corpus).simulate_head(f"/cards/{BOLT_ID}").status_code == 200
+
+    def test_collection_round_trips_a_posted_body(self, compat_corpus: APIResource):
+        result = self._client(compat_corpus).simulate_post(
+            "/cards/collection",
+            json={"identifiers": [{"id": BOLT_ID}, {"name": "Nothing At All Compat"}]},
+        )
+        assert result.status_code == 200
+        body = orjson.loads(result.content)
+        assert [card["id"] for card in body["data"]] == [BOLT_ID]
+        assert body["not_found"] == [{"name": "Nothing At All Compat"}]
+
+    def test_next_page_addresses_this_host(self, compat_corpus: APIResource, monkeypatch):
+        """Every other URI in the payload stays Scryfall's; this one has to point back here.
+
+        The page size is shrunk to 1 rather than inserting 176 cards: what is under test is the URL
+        the handler builds when there is a further page, not the boundary arithmetic, which
+        `test_page_beyond_the_results_is_a_404` already pins.
+        """
+        monkeypatch.setattr("api.scryfall_compat.routes.PAGE_SIZE", 1)
+        result = self._client(compat_corpus).simulate_get("/cards/search", params={"q": f"s:{SET_CODE}"})
+        body = orjson.loads(result.content)
+
+        assert body["total_cards"] == 3
+        assert len(body["data"]) == 1
+        assert body["has_more"] is True
+        assert body["next_page"].startswith("http://falconframework.org/cards/search?")
+        assert "page=2" in body["next_page"]
+        assert f"q=s%3A{SET_CODE}" in body["next_page"]
+
+    def test_the_last_page_has_no_next_page(self, compat_corpus: APIResource, monkeypatch):
+        monkeypatch.setattr("api.scryfall_compat.routes.PAGE_SIZE", 1)
+        body = orjson.loads(
+            self._client(compat_corpus).simulate_get("/cards/search", params={"q": f"s:{SET_CODE}", "page": "3"}).content,
+        )
+        assert body["has_more"] is False
+        assert "next_page" not in body
+
+    def test_following_next_page_walks_the_result_set(self, compat_corpus: APIResource, monkeypatch):
+        """Paging by `next_page` must visit every card exactly once, which is what a client does."""
+        monkeypatch.setattr("api.scryfall_compat.routes.PAGE_SIZE", 1)
+        client = self._client(compat_corpus)
+        seen, page = [], 1
+        while True:
+            body = orjson.loads(client.simulate_get("/cards/search", params={"q": f"s:{SET_CODE}", "page": str(page)}).content)
+            seen.extend(card["id"] for card in body["data"])
+            if not body["has_more"]:
+                break
+            page += 1
+        assert sorted(seen) == sorted([BOLT_ID, BEAR_ID, DELVER_ID])
+
+
+class TestSelfUrlScheme:
+    """`next_page` has to be followable, which means getting the scheme right behind a proxy."""
+
+    def _next_page(self, api: APIResource, monkeypatch, headers: dict[str, str] | None = None) -> str:
+        monkeypatch.setattr("api.scryfall_compat.routes.PAGE_SIZE", 1)
+        environ = falcon.testing.create_environ(path="/cards", headers=headers)
+        req, resp = falcon.Request(environ), falcon.Response()
+        api._handle(req, resp)
+        return payload(resp)["next_page"]
+
+    def test_plain_http_request_stays_http(self, compat_corpus: APIResource, monkeypatch):
+        assert self._next_page(compat_corpus, monkeypatch).startswith("http://falconframework.org/")
+
+    def test_a_forwarded_proto_wins_over_the_requests_own_scheme(self, compat_corpus: APIResource, monkeypatch):
+        """Behind a TLS-terminating proxy the request itself is http; only the header knows better."""
+        url = self._next_page(compat_corpus, monkeypatch, {"X-Forwarded-Proto": "https"})
+        assert url.startswith("https://")
+
+    def test_the_rfc_7239_forwarded_header_is_honored_too(self, compat_corpus: APIResource, monkeypatch):
+        url = self._next_page(compat_corpus, monkeypatch, {"Forwarded": "proto=https"})
+        assert url.startswith("https://")
+
+    def test_the_proxy_host_header_sets_the_host(self, compat_corpus: APIResource, monkeypatch):
+        url = self._next_page(
+            compat_corpus,
+            monkeypatch,
+            {"X-Proxy-Host": "cards.example.test", "X-Forwarded-Proto": "https"},
+        )
+        assert url.startswith("https://cards.example.test/cards?")
diff --git a/api/tests/test_scryfall_compat_objects.py b/api/tests/test_scryfall_compat_objects.py
new file mode 100644
index 000000000..c2ee254e1
--- /dev/null
+++ b/api/tests/test_scryfall_compat_objects.py
@@ -0,0 +1,514 @@
+"""Unit tests for the Scryfall response objects: no database, no request.
+
+`api/tests/test_scryfall_cards_routes.py` covers the routes themselves against a real corpus.
+"""
+
+from __future__ import annotations
+
+import datetime
+import json
+import pathlib
+import urllib.parse
+
+import pytest
+
+from api.scryfall_compat.objects import (
+    build_page_url,
+    card_list,
+    card_to_text,
+    catalog_object,
+    error_object,
+    image_uri,
+    ruling_object,
+    sql_row_to_engine_row,
+    to_scryfall_card,
+)
+
+
+def row(**overrides: object) -> dict:
+    """An engine row carrying CARD_OBJECT_FIELDS, as the store emits it."""
+    return {
+        "scryfall_id": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
+        "oracle_id": "11111111-2222-3333-4444-555555555555",
+        "name": "Lightning Bolt",
+        "mana_cost": "{R}",
+        "cmc": 1.0,
+        "type_line": "Instant",
+        "oracle_text": "Lightning Bolt deals 3 damage to any target.",
+        "colors": ["R"],
+        "color_identity": ["R"],
+        "set_code": "lea",
+        "set_name": "Limited Edition Alpha",
+        "set_id": "99999999-8888-7777-6666-555555555555",
+        "collector_number": "161",
+        "rarity": "common",
+        "released_at": "1993-08-05",
+        "lang": "en",
+        "layout": "normal",
+        "legalities": {"modern": "legal"},
+        "tcgplayer_id": 697344,
+        "cardmarket_id": 892161,
+        "mtgo_id": 152037,
+        "image_updated_at": 1783903008,
+        "card_faces": [],
+        "all_parts": [],
+    } | overrides
+
+
+class TestToScryfallCard:
+    """An engine row BECOMES a card object; nothing is unwrapped from a stored copy.
+
+    That distinction is the reason /cards/* can be served from the store at all: a blob is a
+    Postgres column, and Postgres is the fallback for when the engine errors.
+    """
+
+    def test_stored_columns_carry_through(self):
+        card = to_scryfall_card(row())
+        assert card["object"] == "card"
+        assert card["id"] == "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"
+        assert card["name"] == "Lightning Bolt"
+        assert card["type_line"] == "Instant"
+        assert card["colors"] == ["R"]
+        assert card["set"] == "lea"
+        assert card["rarity"] == "common"
+        assert card["legalities"] == {"modern": "legal"}
+
+    def test_cmc_is_a_decimal_even_when_the_column_holds_an_integer(self):
+        """`"cmc":1.0` is what api.scryfall.com answers, and `magic.cards.cmc` is an integer column.
+
+        The field is decimal because fractional mana values are real -- Little Girl costs {HW} and
+        Scryfall answers `"cmc":0.5` for it. A whole-numbered mana value therefore still carries its
+        decimal point, and a client comparing bodies against Scryfall can see the difference.
+        """
+        card = to_scryfall_card(row(cmc=1))
+        assert isinstance(card["cmc"], float)
+        assert '"cmc": 1.0' in json.dumps(card)
+        assert to_scryfall_card(row(cmc=None))["cmc"] is None
+
+    def test_uris_are_derived_not_stored(self):
+        """Every *_uri is a pure function of the id, set, collector number or oracle id."""
+        card = to_scryfall_card(row(), base_url="https://example.test")
+        assert card["uri"] == "https://example.test/cards/aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"
+        assert card["rulings_uri"] == "https://example.test/cards/aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee/rulings"
+        assert "oracleid%3A11111111-2222-3333-4444-555555555555" in card["prints_search_uri"]
+        assert card["scryfall_uri"] == "https://scryfall.com/card/lea/161/lightning-bolt?utm_source=api"
+        assert card["scryfall_set_uri"] == "https://scryfall.com/sets/lea?utm_source=api"
+
+    def test_image_uris_follow_scryfalls_cdn_path(self):
+        """The first two hex digits of the id are directory levels, and the cache-buster rides."""
+        card = to_scryfall_card(row())
+        assert card["image_uris"]["large"] == (
+            "https://cards.scryfall.io/large/front/a/a/aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee.jpg?1783903008"
+        )
+        assert card["image_uris"]["png"].endswith(".png?1783903008")
+
+    def test_image_uris_carries_scryfalls_eleven_sizes_in_scryfalls_order(self):
+        """Scryfall's key set, not ours.
+
+        This module served SIX keys for as long as it existed, missing `thumb`, `grid`, `display`,
+        `art` and `crop`, so every card object differed from Scryfall's. The list below is read off
+        api.scryfall.com and confirmed against all 540,484 printings in the 2026-08-16 all_cards
+        bulk, where `image_uris` is either wholly absent or exactly these eleven keys in this order
+        -- no layout, `image_status` or face position produces a partial set.
+        """
+        expected = [
+            "small",
+            "normal",
+            "large",
+            "png",
+            "art_crop",
+            "border_crop",
+            "thumb",
+            "grid",
+            "display",
+            "art",
+            "crop",
+        ]
+        card = to_scryfall_card(row())
+        assert list(card["image_uris"]) == expected
+        # The five new sizes are webp; the original six keep their own extensions.
+        for size in ("thumb", "grid", "display", "art", "crop"):
+            assert card["image_uris"][size].endswith(".webp?1783903008")
+
+        # Per-face too: the gap was on both placements, and a face builds its own dict.
+        two_faced = row()
+        two_faced["layout"] = "transform"
+        two_faced["card_faces"] = [{"name": "Delver of Secrets"}, {"name": "Insectile Aberration"}]
+        faces = to_scryfall_card(two_faced)["card_faces"]
+        assert [list(face["image_uris"]) for face in faces] == [expected, expected]
+        assert "/front/" in faces[0]["image_uris"]["thumb"]
+        assert "/back/" in faces[1]["image_uris"]["crop"]
+
+    def test_purchase_uris_drop_scryfalls_affiliate_wrapper(self):
+        """Same destination, without routing another service's affiliate revenue to Scryfall."""
+        card = to_scryfall_card(row())
+        assert card["purchase_uris"]["tcgplayer"] == "https://www.tcgplayer.com/product/697344?page=1"
+        assert card["purchase_uris"]["cardhoarder"] == "https://www.cardhoarder.com/cards/152037"
+        for uri in card["purchase_uris"].values():
+            assert "partner.tcgplayer.com" not in uri
+            assert "affiliate_id" not in uri
+            assert "scryfall" not in uri
+
+    @pytest.mark.parametrize(
+        ("layout", "name", "faces", "expected"),
+        [
+            ("transform", "Invasion of Alara // Awaken the Maelstrom",
+             ["Invasion of Alara", "Awaken the Maelstrom"], "Invasion of Alara"),
+            ("adventure", "Champions of Archery // Join the Group",
+             ["Champions of Archery", "Join the Group"], "Champions of Archery"),
+            ("art_series", "Aang and Katara // Aang and Katara",
+             ["Aang and Katara", "Aang and Katara"], "Aang and Katara"),
+            ("split", "Bind // Liberate", ["Bind", "Liberate"], "Bind // Liberate"),
+            ("double_faced_token", "Snake // Zombie", ["Snake", "Zombie"], "Snake // Zombie"),
+            ("reversible_card", "Mechtitan // Mechtitan", ["Mechtitan", "Mechtitan"], "Mechtitan // Mechtitan"),
+            ("split", "Who // What // When // Where // Why",
+             ["Who", "What", "When", "Where", "Why"], "Who // What // When // Where // Why"),
+            ("normal", "Lightning Bolt", [], "Lightning Bolt"),
+        ],
+    )
+    def test_a_marketplace_search_spells_the_name_the_way_edhrec_does(self, layout, name, faces, expected):
+        """The search string splits by LAYOUT, and by exactly the split `related_uris.edhrec` uses.
+
+        `_purchase_uris` cut the front face off the joined name on every layout, so `Snake // Zombie`
+        was searched for as `Snake`. Measured on api.scryfall.com 2026-08-31 over `unique=prints`,
+        on the first printing of each card whose marketplace ids are MISSING so the SEARCH form is
+        what gets emitted -- a printing WITH the id gets a product link and says nothing -- and
+        reading the tcgplayer term out of the `u=` parameter of Scryfall's partner redirect:
+
+          split               Bind // Liberate                      cmb2/88   `Bind // Liberate`
+          reversible_card     Mechtitan // Mechtitan                sld/1969  `Mechtitan // Mechtitan`
+          double_faced_token  Snake // Zombie                       cc2/9     `Snake // Zombie`, all three
+          split               Who // What // When // Where // Why   und/75    the whole five-part name
+          adventure           Champions of Archery // Join the …    ph19/4    `Champions of Archery`
+          flip                Curse of the Fire Penguin // …        unh/73    `Curse of the Fire Penguin`
+          art_series          Aang and Katara // Aang and Katara    atle/8    `Aang and Katara`
+          transform           Delver of Secrets // Insectile …      sld/2367  `Delver of Secrets`
+
+        The ids are dropped from the row on purpose: with them the object carries product links and
+        the search string is never built.
+        """
+        card = to_scryfall_card(row(
+            name=name, layout=layout,
+            card_faces=[{"name": face} for face in faces],
+            tcgplayer_id=None, cardmarket_id=None, mtgo_id=None,
+        ))
+        quoted = urllib.parse.quote_plus(expected)
+        assert card["purchase_uris"] == {
+            "tcgplayer": f"https://www.tcgplayer.com/search/magic/product?productLineName=magic&q={quoted}&view=grid",
+            "cardmarket": f"https://www.cardmarket.com/en/Magic/Products/Search?searchString={quoted}",
+            "cardhoarder": f"https://www.cardhoarder.com/cards?data%5Bsearch%5D={quoted}",
+        }
+        # edhrec takes the same string, and the two tcgplayer_infinite_* searches take the JOINED
+        # name on every layout -- the exception this rule is deliberately not extended to.
+        assert card["related_uris"]["edhrec"] == f"https://edhrec.com/route/?cc={quoted}"
+        joined = urllib.parse.quote_plus(name)
+        assert card["related_uris"]["tcgplayer_infinite_articles"].endswith(f"q={joined}")
+        assert card["related_uris"]["tcgplayer_infinite_decks"].endswith(f"q={joined}")
+
+    def test_absent_keys_stay_absent(self):
+        """Scryfall OMITS a key it has no value for. Emitting null would differ on every row."""
+        card = to_scryfall_card(row())
+        for key in ("power", "toughness", "loyalty", "flavor_text", "watermark", "arena_id", "promo_types"):
+            assert key not in card, f"{key} should be omitted, not null"
+
+    def test_a_planeswalkers_printed_loyalty_is_the_string(self):
+        """The engine holds `planeswalker_loyalty` as a u8 for `loy:`; the card object needs the text.
+
+        Without its own field the key was emitted by nothing at all, so every planeswalker's card
+        object came back with no `loyalty` -- and deriving it from the number would still lose "X"
+        (Nissa, Steward of Elements) and "1+*", which do not fit in a u8.
+        """
+        card = to_scryfall_card(row(name="Jace Beleren", loyalty="3"))
+        assert card["loyalty"] == "3"
+
+        keys = list(card)
+        assert keys.index("loyalty") > keys.index("type_line"), "loyalty sits with the printed stats"
+
+        assert to_scryfall_card(row(loyalty="X"))["loyalty"] == "X"
+
+    def test_border_color_and_frame_come_from_the_engine_row(self):
+        """Both come from the engine row now.
+
+        They were read from keys no engine row carried, so every engine-served card had
+        `border_color: null` and no `frame` at all -- where Scryfall always sends both.
+        """
+        card = to_scryfall_card(row(border_color="black", frame="2015"))
+        assert card["border_color"] == "black"
+        assert card["frame"] == "2015"
+
+    def test_border_color_survives_the_sql_alias(self):
+        """The SQL column aliases into the engine's field name.
+
+        The column is `card_border` and the engine field is `border_color`; one builder reads one
+        name, so the SQL row is aliased into it rather than the builder reading both.
+        """
+        assert sql_row_to_engine_row({"card_border": "borderless"})["border_color"] == "borderless"
+
+    def test_present_optional_keys_appear(self):
+        card = to_scryfall_card(row(power="3", toughness="2", flavor_text="Kaboom.", arena_id=12345))
+        assert card["power"] == "3"
+        assert card["flavor_text"] == "Kaboom."
+        assert card["arena_id"] == 12345
+
+    def test_prices_use_scryfalls_string_format(self):
+        card = to_scryfall_card(row(price_usd=1.5, price_usd_foil=282.0))
+        assert card["prices"]["usd"] == "1.50"
+        assert card["prices"]["usd_foil"] == "282.00"
+        assert card["prices"]["eur"] is None, "prices keys are always present, unlike optional keys"
+
+    def test_a_single_faced_card_has_top_level_text_and_no_faces(self):
+        card = to_scryfall_card(row())
+        assert "card_faces" not in card
+        assert card["oracle_text"] == "Lightning Bolt deals 3 damage to any target."
+        assert card["image_uris"]
+
+    def test_a_two_image_card_moves_its_text_and_its_pictures_into_the_faces(self):
+        """Which keys sit at top level varies by LAYOUT, so this is a branch, not a fixed shape."""
+        card = to_scryfall_card(
+            row(
+                name="Delver of Secrets // Insectile Aberration",
+                layout="transform",
+                card_faces=[
+                    {"name": "Delver of Secrets", "oracle_text": "Front.", "mana_cost": "{U}"},
+                    {"name": "Insectile Aberration", "oracle_text": "Back.", "power": "3"},
+                ],
+            )
+        )
+        assert "oracle_text" not in card
+        assert "image_uris" not in card
+        assert [f["name"] for f in card["card_faces"]] == ["Delver of Secrets", "Insectile Aberration"]
+        assert all(f["object"] == "card_face" for f in card["card_faces"])
+        # Each face gets its own side of the CDN path.
+        assert "/front/" in card["card_faces"][0]["image_uris"]["large"]
+        assert "/back/" in card["card_faces"][1]["image_uris"]["large"]
+        # ...and the keys that belong to a face on a two-image layout leave the top level.
+        for key in ("colors", "card_back_id", "illustration_id"):
+            assert key not in card
+
+    def test_a_one_image_multi_face_card_keeps_its_picture_and_cost_at_top_level(self):
+        """A split card is ONE piece of cardboard, so its faces get no `image_uris` of their own.
+
+        Gating on the face COUNT rather than the layout invents a `.../back/...` URL with no image
+        behind it on every split, flip, adventure and prepare printing. The top-level cost is the
+        faces' joined " // " -- skipping the faces that have none, so flipped Erayo is `{1}{U}` and
+        not `{1}{U} // `.
+        """
+        card = to_scryfall_card(
+            row(
+                name="Fire // Ice",
+                layout="split",
+                card_faces=[
+                    {"name": "Fire", "oracle_text": "Two damage.", "mana_cost": "{1}{R}"},
+                    {"name": "Ice", "oracle_text": "Tap target.", "mana_cost": "{1}{U}"},
+                ],
+            )
+        )
+        assert "image_uris" not in card["card_faces"][0]
+        assert "image_uris" not in card["card_faces"][1]
+        assert card["image_uris"]
+        assert card["mana_cost"] == "{1}{R} // {1}{U}"
+        # ...and a two-image layout's face-owned keys stay at top level here.
+        assert card["card_back_id"]
+
+    def test_a_reversible_printing_drops_the_three_keys_its_faces_carry(self):
+        """A reversible printing keeps nothing of the card at top level.
+
+        All 81 omit `oracle_id`, `cmc` and `type_line` there, and carry the card's `oracle_id` and
+        `cmc` on both faces instead.
+        """
+        card = to_scryfall_card(
+            row(
+                name="Propaganda // Propaganda",
+                layout="reversible_card",
+                card_faces=[
+                    {"name": "Propaganda", "oracle_text": "Front.", "mana_cost": "{2}{U}"},
+                    {"name": "Propaganda", "oracle_text": "Back.", "mana_cost": "{2}{U}"},
+                ],
+            )
+        )
+        for key in ("oracle_id", "cmc", "type_line"):
+            assert key not in card
+        assert all(f["oracle_id"] == "11111111-2222-3333-4444-555555555555" for f in card["card_faces"])
+        assert all(f["cmc"] == 1.0 for f in card["card_faces"])
+
+    def test_related_cards_pass_through_when_present(self):
+        parts = [{"object": "related_card", "id": "x", "component": "token", "name": "Goblin", "type_line": "Token"}]
+        assert to_scryfall_card(row(all_parts=parts))["all_parts"] == parts
+
+    def test_card_back_id_is_the_shared_constant(self):
+        assert to_scryfall_card(row())["card_back_id"] == "0aeebaf5-8c7d-4636-9e82-8c27447861f7"
+
+
+class TestEnvelopes:
+    """The List, Catalog, Ruling and error objects match Scryfall's shapes."""
+
+    def test_error_object_omits_warnings_when_there_are_none(self):
+        assert error_object(code="not_found", status=404, details="nope") == {
+            "object": "error",
+            "code": "not_found",
+            "status": 404,
+            "details": "nope",
+        }
+
+    def test_error_object_carries_warnings(self):
+        error = error_object(code="bad_request", status=400, details="nope", warnings=["heads up"])
+        assert error["warnings"] == ["heads up"]
+
+    def test_card_list_key_order_matches_scryfall(self):
+        listing = card_list([{"object": "card"}], total_cards=200, has_more=True, next_page="https://x/?page=2")
+        assert list(listing) == ["object", "total_cards", "has_more", "next_page", "data"]
+
+    def test_card_list_omits_pagination_it_was_not_given(self):
+        assert card_list([]) == {"object": "list", "has_more": False, "data": []}
+
+    def test_collection_list_carries_not_found(self):
+        listing = card_list([], not_found=[{"name": "Nope"}])
+        assert listing["not_found"] == [{"name": "Nope"}]
+
+    def test_catalog_object_counts_its_values(self):
+        assert catalog_object(["Bolt", "Shock"]) == {"object": "catalog", "total_values": 2, "data": ["Bolt", "Shock"]}
+
+    def test_the_uri_is_present_only_when_given(self) -> None:
+        """`/catalog/*` sends one and `/cards/autocomplete` does not, both measured 2026-08-12.
+
+        So the default has to stay absent: building one unconditionally would put a key on the
+        autocomplete catalog that Scryfall never sends there.
+        """
+        assert "uri" not in catalog_object(["Bolt"])
+        with_uri = catalog_object(["Bolt"], uri="https://api.scryfall.com/catalog/card-names")
+        assert with_uri["uri"] == "https://api.scryfall.com/catalog/card-names"
+        assert list(with_uri) == ["object", "uri", "total_values", "data"]
+
+    def test_ruling_object_renders_the_date_as_iso(self):
+        row = {
+            "oracle_id": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
+            "source": "wotc",
+            "published_at": datetime.date(2004, 10, 4),
+            "comment": "It does.",
+        }
+        assert ruling_object(row)["published_at"] == "2004-10-04"
+
+
+class TestPageUrl:
+    """`next_page` is absolute, sorted, and carries the page it fetches."""
+
+    def test_page_is_appended_and_parameters_sorted(self):
+        url = build_page_url("https://example.test/cards/search", {"q": "fire", "order": "name"}, 2)
+        assert url == "https://example.test/cards/search?order=name&page=2&q=fire"
+
+    def test_query_values_are_escaped(self):
+        url = build_page_url("https://example.test/cards/search", {"q": "t:creature c:r"}, 3)
+        assert "q=t%3Acreature+c%3Ar" in url
+
+
+class TestImageUri:
+    """`format=image` resolves the size and face the client asked for."""
+
+    def test_front_face_size_is_selected(self):
+        card = {"image_uris": {"png": "https://cdn/front.png", "large": "https://cdn/front.jpg"}}
+        assert image_uri(card, version="png", face="front") == "https://cdn/front.png"
+
+    def test_back_face_uses_the_second_face(self):
+        card = {
+            "image_uris": {"large": "https://cdn/front.jpg"},
+            "card_faces": [
+                {"image_uris": {"large": "https://cdn/front.jpg"}},
+                {"image_uris": {"large": "https://cdn/back.jpg"}},
+            ],
+        }
+        assert image_uri(card, version="large", face="back") == "https://cdn/back.jpg"
+
+    def test_back_face_on_a_single_faced_card_falls_back_to_the_front(self):
+        card = {"image_uris": {"large": "https://cdn/front.jpg"}}
+        assert image_uri(card, version="large", face="back") == "https://cdn/front.jpg"
+
+    def test_missing_size_is_reported_as_absent(self):
+        assert image_uri({"image_uris": {}}, version="png", face="front") is None
+
+
+class TestCardToText:
+    """`format=text` renders the card the way Scryfall's text format does."""
+
+    def test_instant_renders_name_cost_type_and_text(self):
+        card = {
+            "name": "Lightning Bolt",
+            "mana_cost": "{R}",
+            "type_line": "Instant",
+            "oracle_text": "Lightning Bolt deals 3 damage to any target.",
+        }
+        assert card_to_text(card) == ("Lightning Bolt {R}\nInstant\nLightning Bolt deals 3 damage to any target.")
+
+    def test_creature_appends_power_and_toughness(self):
+        card = {"name": "Grizzly Bears", "mana_cost": "{1}{G}", "type_line": "Creature — Bear", "power": "2", "toughness": "2"}
+        assert card_to_text(card).endswith("\n2/2")
+
+    def test_planeswalker_appends_loyalty(self):
+        card = {"name": "Ajani", "mana_cost": "{2}{W}{W}", "type_line": "Legendary Planeswalker — Ajani", "loyalty": "4"}
+        assert card_to_text(card).endswith("\nLoyalty: 4")
+
+    def test_faces_are_separated_by_a_blank_line(self):
+        card = {
+            "name": "Delver of Secrets // Insectile Aberration",
+            "card_faces": [
+                {
+                    "name": "Delver of Secrets",
+                    "mana_cost": "{U}",
+                    "type_line": "Creature — Human Wizard",
+                    "power": "1",
+                    "toughness": "1",
+                },
+                {
+                    "name": "Insectile Aberration",
+                    "mana_cost": "",
+                    "type_line": "Creature — Human Insect",
+                    "power": "3",
+                    "toughness": "2",
+                },
+            ],
+        }
+        rendered = card_to_text(card)
+        assert rendered.count("\n\n") == 1
+        assert rendered.startswith("Delver of Secrets {U}")
+        assert rendered.endswith("3/2")
+
+    @pytest.mark.parametrize("missing", ["oracle_text", "mana_cost"])
+    def test_absent_pieces_are_skipped_rather_than_rendered_empty(self, missing):
+        card = {
+            "name": "Vanilla",
+            "mana_cost": "{G}",
+            "type_line": "Creature — Bear",
+            "oracle_text": "text",
+            "power": "2",
+            "toughness": "2",
+        }
+        del card[missing]
+        assert "\n\n" not in card_to_text(card)
+
+
+_PARITY_FIXTURE = pathlib.Path(__file__).resolve().parents[1] / "scryfall_compat" / "fixtures" / "card_object_parity.json"
+
+
+def _parity_cases() -> list[tuple[str, dict, dict]]:
+    doc = json.loads(_PARITY_FIXTURE.read_text(encoding="utf-8"))
+    return [(c["case"], c["row"], c["expected"]) for c in doc["cases"]]
+
+
+class TestCardObjectParityWithTheRustBuilder:
+    """The SAME cases `card_engine/src/card_object.rs` asserts, from the same file.
+
+    Two implementations build this object -- `objects.py` for the SQL path, `card_object.rs` for
+    the engine path -- and both answer `/cards/*`, so a difference between them is one a client can
+    see. Nothing else compares them: the Python suite and the Rust suite are separate CI jobs that
+    never meet. A shared fixture is what makes each job fail on its own drift.
+
+    Values and key PRESENCE, not key order: both sides compare parsed objects. The wire order is
+    pinned by the position assertions in card_object.rs.
+    """
+
+    def test_the_fixture_carries_cases(self):
+        assert _parity_cases(), "the parity fixture must not be empty"
+
+    @pytest.mark.parametrize(("case", "row", "expected"), _parity_cases(), ids=lambda v: v if isinstance(v, str) else "")
+    def test_the_card_object_matches_the_rust_builder(self, case: str, row: dict, expected: dict):
+        doc = json.loads(_PARITY_FIXTURE.read_text(encoding="utf-8"))
+        assert to_scryfall_card(dict(row), base_url=doc["base_url"]) == expected, case
diff --git a/api/tests/test_scryfall_mana.py b/api/tests/test_scryfall_mana.py
new file mode 100644
index 000000000..40dca2d29
--- /dev/null
+++ b/api/tests/test_scryfall_mana.py
@@ -0,0 +1,878 @@
+"""Tests for `GET /symbology/parse-mana`'s cost parser.
+
+Every expectation below is a **golden captured from api.scryfall.com on 2026-08-11**, not a value
+worked out by hand, because two of the behaviours being pinned are undocumented: the canonical
+colour reordering (`RUW` answers `{U}{R}{W}`) and the emission order (`2XWU` answers `{X}{2}{W}{U}`).
+A hand-written expectation for those would only re-assert whatever the implementation happened to do.
+
+The colour cases are exhaustive: all 31 non-empty subsets of WUBRG, each written both forwards and
+backwards, so `_canonical_colors` is pinned over its whole domain rather than at a few samples.
+
+A second measurement session on 2026-08-28 added the HYBRID goldens -- 61 more requests, one per row,
+driven by `GET /symbology`'s own inventory of 84 symbols rather than by what the parser happened to
+accept. That inventory is what the parser is now written against, because the rule it used to carry
+("a hybrid has exactly two halves") rejected `{W/U/P}` -- a printed Phyrexian hybrid that four live
+cards put in their mana cost.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import pytest
+
+from api.scryfall_compat.mana import ManaCostError, parse_mana_cost
+
+GOLDENS = [
+    ("", {"cost": None, "colors": [], "cmc": 0.0, "colorless": True, "monocolored": False, "multicolored": False}),
+    ("0", {"cost": "{0}", "colors": [], "cmc": 0.0, "colorless": True, "monocolored": False, "multicolored": False}),
+    ("2WW", {"cost": "{2}{W}{W}", "colors": ["W"], "cmc": 4.0, "colorless": False, "monocolored": True, "multicolored": False}),
+    ("XRR", {"cost": "{X}{R}{R}", "colors": ["R"], "cmc": 2.0, "colorless": False, "monocolored": True, "multicolored": False}),
+    ("W2", {"cost": "{2}{W}", "colors": ["W"], "cmc": 3.0, "colorless": False, "monocolored": True, "multicolored": False}),
+    ("RX", {"cost": "{X}{R}", "colors": ["R"], "cmc": 1.0, "colorless": False, "monocolored": True, "multicolored": False}),
+    (
+        "GWU2",
+        {
+            "cost": "{2}{G}{W}{U}",
+            "colors": ["W", "U", "G"],
+            "cmc": 5.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "2XWU",
+        {"cost": "{X}{2}{W}{U}", "colors": ["W", "U"], "cmc": 4.0, "colorless": False, "monocolored": False, "multicolored": True},
+    ),
+    (
+        "WUBRGC",
+        {
+            "cost": "{W}{U}{B}{R}{G}{C}",
+            "colors": ["W", "U", "B", "R", "G"],
+            "cmc": 6.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    ("CW", {"cost": "{W}{C}", "colors": ["W"], "cmc": 2.0, "colorless": False, "monocolored": True, "multicolored": False}),
+    ("{2/W}", {"cost": "{2/W}", "colors": ["W"], "cmc": 2.0, "colorless": False, "monocolored": True, "multicolored": False}),
+    ("{W/P}", {"cost": "{W/P}", "colors": ["W"], "cmc": 1.0, "colorless": False, "monocolored": True, "multicolored": False}),
+    ("{HW}", {"cost": "{HW}", "colors": ["W"], "cmc": 0.5, "colorless": False, "monocolored": True, "multicolored": False}),
+    ("{C}", {"cost": "{C}", "colors": [], "cmc": 1.0, "colorless": True, "monocolored": False, "multicolored": False}),
+    ("{S}", {"cost": "{S}", "colors": [], "cmc": 1.0, "colorless": True, "monocolored": False, "multicolored": False}),
+    ("11R", {"cost": "{11}{R}", "colors": ["R"], "cmc": 12.0, "colorless": False, "monocolored": True, "multicolored": False}),
+    ("{10}", {"cost": "{10}", "colors": [], "cmc": 10.0, "colorless": True, "monocolored": False, "multicolored": False}),
+    (
+        "{W/U}{B/R}",
+        {
+            "cost": "{W/U}{B/R}",
+            "colors": ["W", "U", "B", "R"],
+            "cmc": 2.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "{1}{W/U}{W/U}",
+        {"cost": "{1}{W/U}{W/U}", "colors": ["W", "U"], "cmc": 3.0, "colorless": False, "monocolored": False, "multicolored": True},
+    ),
+    (
+        "{X}{X}{R}",
+        {"cost": "{X}{X}{R}", "colors": ["R"], "cmc": 1.0, "colorless": False, "monocolored": True, "multicolored": False},
+    ),
+    (
+        "{B/G}{B/G}",
+        {"cost": "{B/G}{B/G}", "colors": ["B", "G"], "cmc": 2.0, "colorless": False, "monocolored": False, "multicolored": True},
+    ),
+    ("{HR}{R}", {"cost": "{HR}{R}", "colors": ["R"], "cmc": 1.5, "colorless": False, "monocolored": True, "multicolored": False}),
+    ("W", {"cost": "{W}", "colors": ["W"], "cmc": 1.0, "colorless": False, "monocolored": True, "multicolored": False}),
+    ("U", {"cost": "{U}", "colors": ["U"], "cmc": 1.0, "colorless": False, "monocolored": True, "multicolored": False}),
+    ("B", {"cost": "{B}", "colors": ["B"], "cmc": 1.0, "colorless": False, "monocolored": True, "multicolored": False}),
+    ("R", {"cost": "{R}", "colors": ["R"], "cmc": 1.0, "colorless": False, "monocolored": True, "multicolored": False}),
+    ("G", {"cost": "{G}", "colors": ["G"], "cmc": 1.0, "colorless": False, "monocolored": True, "multicolored": False}),
+    ("WU", {"cost": "{W}{U}", "colors": ["W", "U"], "cmc": 2.0, "colorless": False, "monocolored": False, "multicolored": True}),
+    ("UW", {"cost": "{W}{U}", "colors": ["W", "U"], "cmc": 2.0, "colorless": False, "monocolored": False, "multicolored": True}),
+    ("WB", {"cost": "{W}{B}", "colors": ["W", "B"], "cmc": 2.0, "colorless": False, "monocolored": False, "multicolored": True}),
+    ("BW", {"cost": "{W}{B}", "colors": ["W", "B"], "cmc": 2.0, "colorless": False, "monocolored": False, "multicolored": True}),
+    ("WR", {"cost": "{R}{W}", "colors": ["W", "R"], "cmc": 2.0, "colorless": False, "monocolored": False, "multicolored": True}),
+    ("RW", {"cost": "{R}{W}", "colors": ["W", "R"], "cmc": 2.0, "colorless": False, "monocolored": False, "multicolored": True}),
+    ("WG", {"cost": "{G}{W}", "colors": ["W", "G"], "cmc": 2.0, "colorless": False, "monocolored": False, "multicolored": True}),
+    ("GW", {"cost": "{G}{W}", "colors": ["W", "G"], "cmc": 2.0, "colorless": False, "monocolored": False, "multicolored": True}),
+    ("UB", {"cost": "{U}{B}", "colors": ["U", "B"], "cmc": 2.0, "colorless": False, "monocolored": False, "multicolored": True}),
+    ("BU", {"cost": "{U}{B}", "colors": ["U", "B"], "cmc": 2.0, "colorless": False, "monocolored": False, "multicolored": True}),
+    ("UR", {"cost": "{U}{R}", "colors": ["U", "R"], "cmc": 2.0, "colorless": False, "monocolored": False, "multicolored": True}),
+    ("RU", {"cost": "{U}{R}", "colors": ["U", "R"], "cmc": 2.0, "colorless": False, "monocolored": False, "multicolored": True}),
+    ("UG", {"cost": "{G}{U}", "colors": ["U", "G"], "cmc": 2.0, "colorless": False, "monocolored": False, "multicolored": True}),
+    ("GU", {"cost": "{G}{U}", "colors": ["U", "G"], "cmc": 2.0, "colorless": False, "monocolored": False, "multicolored": True}),
+    ("BR", {"cost": "{B}{R}", "colors": ["B", "R"], "cmc": 2.0, "colorless": False, "monocolored": False, "multicolored": True}),
+    ("RB", {"cost": "{B}{R}", "colors": ["B", "R"], "cmc": 2.0, "colorless": False, "monocolored": False, "multicolored": True}),
+    ("BG", {"cost": "{B}{G}", "colors": ["B", "G"], "cmc": 2.0, "colorless": False, "monocolored": False, "multicolored": True}),
+    ("GB", {"cost": "{B}{G}", "colors": ["B", "G"], "cmc": 2.0, "colorless": False, "monocolored": False, "multicolored": True}),
+    ("RG", {"cost": "{R}{G}", "colors": ["R", "G"], "cmc": 2.0, "colorless": False, "monocolored": False, "multicolored": True}),
+    ("GR", {"cost": "{R}{G}", "colors": ["R", "G"], "cmc": 2.0, "colorless": False, "monocolored": False, "multicolored": True}),
+    (
+        "WUB",
+        {
+            "cost": "{W}{U}{B}",
+            "colors": ["W", "U", "B"],
+            "cmc": 3.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "BUW",
+        {
+            "cost": "{W}{U}{B}",
+            "colors": ["W", "U", "B"],
+            "cmc": 3.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "WUR",
+        {
+            "cost": "{U}{R}{W}",
+            "colors": ["W", "U", "R"],
+            "cmc": 3.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "RUW",
+        {
+            "cost": "{U}{R}{W}",
+            "colors": ["W", "U", "R"],
+            "cmc": 3.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "WUG",
+        {
+            "cost": "{G}{W}{U}",
+            "colors": ["W", "U", "G"],
+            "cmc": 3.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "GUW",
+        {
+            "cost": "{G}{W}{U}",
+            "colors": ["W", "U", "G"],
+            "cmc": 3.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "WBR",
+        {
+            "cost": "{R}{W}{B}",
+            "colors": ["W", "B", "R"],
+            "cmc": 3.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "RBW",
+        {
+            "cost": "{R}{W}{B}",
+            "colors": ["W", "B", "R"],
+            "cmc": 3.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "WBG",
+        {
+            "cost": "{W}{B}{G}",
+            "colors": ["W", "B", "G"],
+            "cmc": 3.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "GBW",
+        {
+            "cost": "{W}{B}{G}",
+            "colors": ["W", "B", "G"],
+            "cmc": 3.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "WRG",
+        {
+            "cost": "{R}{G}{W}",
+            "colors": ["W", "R", "G"],
+            "cmc": 3.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "GRW",
+        {
+            "cost": "{R}{G}{W}",
+            "colors": ["W", "R", "G"],
+            "cmc": 3.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "UBR",
+        {
+            "cost": "{U}{B}{R}",
+            "colors": ["U", "B", "R"],
+            "cmc": 3.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "RBU",
+        {
+            "cost": "{U}{B}{R}",
+            "colors": ["U", "B", "R"],
+            "cmc": 3.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "UBG",
+        {
+            "cost": "{B}{G}{U}",
+            "colors": ["U", "B", "G"],
+            "cmc": 3.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "GBU",
+        {
+            "cost": "{B}{G}{U}",
+            "colors": ["U", "B", "G"],
+            "cmc": 3.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "URG",
+        {
+            "cost": "{G}{U}{R}",
+            "colors": ["U", "R", "G"],
+            "cmc": 3.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "GRU",
+        {
+            "cost": "{G}{U}{R}",
+            "colors": ["U", "R", "G"],
+            "cmc": 3.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "BRG",
+        {
+            "cost": "{B}{R}{G}",
+            "colors": ["B", "R", "G"],
+            "cmc": 3.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "GRB",
+        {
+            "cost": "{B}{R}{G}",
+            "colors": ["B", "R", "G"],
+            "cmc": 3.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "WUBR",
+        {
+            "cost": "{W}{U}{B}{R}",
+            "colors": ["W", "U", "B", "R"],
+            "cmc": 4.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "RBUW",
+        {
+            "cost": "{W}{U}{B}{R}",
+            "colors": ["W", "U", "B", "R"],
+            "cmc": 4.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "WUBG",
+        {
+            "cost": "{G}{W}{U}{B}",
+            "colors": ["W", "U", "B", "G"],
+            "cmc": 4.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "GBUW",
+        {
+            "cost": "{G}{W}{U}{B}",
+            "colors": ["W", "U", "B", "G"],
+            "cmc": 4.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "WURG",
+        {
+            "cost": "{R}{G}{W}{U}",
+            "colors": ["W", "U", "R", "G"],
+            "cmc": 4.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "GRUW",
+        {
+            "cost": "{R}{G}{W}{U}",
+            "colors": ["W", "U", "R", "G"],
+            "cmc": 4.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "WBRG",
+        {
+            "cost": "{B}{R}{G}{W}",
+            "colors": ["W", "B", "R", "G"],
+            "cmc": 4.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "GRBW",
+        {
+            "cost": "{B}{R}{G}{W}",
+            "colors": ["W", "B", "R", "G"],
+            "cmc": 4.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "UBRG",
+        {
+            "cost": "{U}{B}{R}{G}",
+            "colors": ["U", "B", "R", "G"],
+            "cmc": 4.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "GRBU",
+        {
+            "cost": "{U}{B}{R}{G}",
+            "colors": ["U", "B", "R", "G"],
+            "cmc": 4.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    # --- The hybrid inventory, measured from `GET /symbology` on 2026-08-28 -----------------------
+    #
+    # All ten PHYREXIAN HYBRIDS. These were 422s here until 2026-08-28: the parser required a hybrid
+    # to have exactly two halves, which is right for `{W/U/B}` and wrong for every row below.
+    (
+        "{W/U/P}",
+        {"cost": "{W/U/P}", "colors": ["W", "U"], "cmc": 1.0, "colorless": False, "monocolored": False, "multicolored": True},
+    ),
+    (
+        "{W/B/P}",
+        {"cost": "{W/B/P}", "colors": ["W", "B"], "cmc": 1.0, "colorless": False, "monocolored": False, "multicolored": True},
+    ),
+    (
+        "{U/B/P}",
+        {"cost": "{U/B/P}", "colors": ["U", "B"], "cmc": 1.0, "colorless": False, "monocolored": False, "multicolored": True},
+    ),
+    (
+        "{U/R/P}",
+        {"cost": "{U/R/P}", "colors": ["U", "R"], "cmc": 1.0, "colorless": False, "monocolored": False, "multicolored": True},
+    ),
+    (
+        "{B/R/P}",
+        {"cost": "{B/R/P}", "colors": ["B", "R"], "cmc": 1.0, "colorless": False, "monocolored": False, "multicolored": True},
+    ),
+    (
+        "{B/G/P}",
+        {"cost": "{B/G/P}", "colors": ["B", "G"], "cmc": 1.0, "colorless": False, "monocolored": False, "multicolored": True},
+    ),
+    (
+        "{R/G/P}",
+        {"cost": "{R/G/P}", "colors": ["R", "G"], "cmc": 1.0, "colorless": False, "monocolored": False, "multicolored": True},
+    ),
+    (
+        "{R/W/P}",
+        {"cost": "{R/W/P}", "colors": ["W", "R"], "cmc": 1.0, "colorless": False, "monocolored": False, "multicolored": True},
+    ),
+    (
+        "{G/W/P}",
+        {"cost": "{G/W/P}", "colors": ["W", "G"], "cmc": 1.0, "colorless": False, "monocolored": False, "multicolored": True},
+    ),
+    (
+        "{G/U/P}",
+        {"cost": "{G/U/P}", "colors": ["U", "G"], "cmc": 1.0, "colorless": False, "monocolored": False, "multicolored": True},
+    ),
+    # The four cards that actually print one, mana cost as `/cards/search?q=is:phyrexian is:hybrid`
+    # gives it (2026-08-28, 4 results, no more): Ajani, Sleeper Agent (DMU); Tamiyo, Compleated Sage
+    # (NEO); Nahiri, the Unforgiving (ONE); Lukka, Bound to Ruin (ONE). Every one of these was a 422.
+    (
+        "{1}{G}{G/W/P}{W}",
+        {
+            "cost": "{1}{G/W/P}{G}{W}",
+            "colors": ["W", "G"],
+            "cmc": 4.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "{2}{G}{G/U/P}{U}",
+        {
+            "cost": "{2}{G/U/P}{G}{U}",
+            "colors": ["U", "G"],
+            "cmc": 5.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "{1}{R}{R/W/P}{W}",
+        {
+            "cost": "{1}{R/W/P}{R}{W}",
+            "colors": ["W", "R"],
+            "cmc": 4.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "{2}{R}{R/G/P}{G}",
+        {
+            "cost": "{2}{R/G/P}{R}{G}",
+            "colors": ["R", "G"],
+            "cmc": 5.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    # The colorless hybrids, which the two-halves rule also rejected -- not for the count, but
+    # because it priced only colours, digits and `P`, and `C` is none of the three. `{C/P}` produces
+    # NO colour.
+    ("{C/W}", {"cost": "{C/W}", "colors": ["W"], "cmc": 1.0, "colorless": False, "monocolored": True, "multicolored": False}),
+    ("{C/U}", {"cost": "{C/U}", "colors": ["U"], "cmc": 1.0, "colorless": False, "monocolored": True, "multicolored": False}),
+    ("{C/B}", {"cost": "{C/B}", "colors": ["B"], "cmc": 1.0, "colorless": False, "monocolored": True, "multicolored": False}),
+    ("{C/R}", {"cost": "{C/R}", "colors": ["R"], "cmc": 1.0, "colorless": False, "monocolored": True, "multicolored": False}),
+    ("{C/G}", {"cost": "{C/G}", "colors": ["G"], "cmc": 1.0, "colorless": False, "monocolored": True, "multicolored": False}),
+    ("{C/P}", {"cost": "{C/P}", "colors": [], "cmc": 1.0, "colorless": True, "monocolored": False, "multicolored": False}),
+    # A TWO-part hybrid may be written either way round and comes back in the listed spelling. A
+    # three-part one may not -- see UNPARSEABLE_MESSAGES, where `{U/W/P}` is a 422 though `{W/U/P}`
+    # parses.
+    ("{U/W}", {"cost": "{W/U}", "colors": ["W", "U"], "cmc": 1.0, "colorless": False, "monocolored": False, "multicolored": True}),
+    ("{W/2}", {"cost": "{2/W}", "colors": ["W"], "cmc": 2.0, "colorless": False, "monocolored": True, "multicolored": False}),
+    ("{P/W}", {"cost": "{W/P}", "colors": ["W"], "cmc": 1.0, "colorless": False, "monocolored": True, "multicolored": False}),
+    ("{W/C}", {"cost": "{C/W}", "colors": ["W"], "cmc": 1.0, "colorless": False, "monocolored": True, "multicolored": False}),
+    ("{W/G}", {"cost": "{G/W}", "colors": ["W", "G"], "cmc": 1.0, "colorless": False, "monocolored": False, "multicolored": True}),
+    (
+        "{W/U}{U/W}",
+        {"cost": "{W/U}{W/U}", "colors": ["W", "U"], "cmc": 2.0, "colorless": False, "monocolored": False, "multicolored": True},
+    ),
+    # EMISSION ORDER. Every row here was also requested written the other way round and answered
+    # the same, which is what makes it a sort rather than the writing order. The order is
+    # `/symbology` catalog order -- the plain colour pips are the one exception, and keep the
+    # canonical colour order the goldens above pin. `{G/W}{W/U}` and `{G/U}{W/B}` are the rows a
+    # colour-rank sort cannot reach: both put the LATER colour's hybrid first.
+    (
+        "{G}{G/W}{W}",
+        {"cost": "{G/W}{G}{W}", "colors": ["W", "G"], "cmc": 3.0, "colorless": False, "monocolored": False, "multicolored": True},
+    ),
+    ("{W}{HW}", {"cost": "{HW}{W}", "colors": ["W"], "cmc": 1.5, "colorless": False, "monocolored": True, "multicolored": False}),
+    (
+        "{R}{HR}{R/W}",
+        {"cost": "{R/W}{HR}{R}", "colors": ["W", "R"], "cmc": 2.5, "colorless": False, "monocolored": False, "multicolored": True},
+    ),
+    ("{W}{C/P}", {"cost": "{C/P}{W}", "colors": ["W"], "cmc": 2.0, "colorless": False, "monocolored": True, "multicolored": False}),
+    ("{C}{C/P}", {"cost": "{C/P}{C}", "colors": [], "cmc": 2.0, "colorless": True, "monocolored": False, "multicolored": False}),
+    ("{S}{C}", {"cost": "{C}{S}", "colors": [], "cmc": 2.0, "colorless": True, "monocolored": False, "multicolored": False}),
+    (
+        "{HR}{HW}",
+        {"cost": "{HW}{HR}", "colors": ["W", "R"], "cmc": 1.0, "colorless": False, "monocolored": False, "multicolored": True},
+    ),
+    (
+        "{G/W}{W/U}",
+        {
+            "cost": "{W/U}{G/W}",
+            "colors": ["W", "U", "G"],
+            "cmc": 2.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "{G/U}{W/B}",
+        {
+            "cost": "{W/B}{G/U}",
+            "colors": ["W", "U", "B", "G"],
+            "cmc": 2.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "{U/B}{W/U}{B/R}",
+        {
+            "cost": "{W/U}{B/R}{U/B}",
+            "colors": ["W", "U", "B", "R"],
+            "cmc": 3.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "{C/G}{G/P}{2/G}{G/W}",
+        {
+            "cost": "{G/W}{C/G}{2/G}{G/P}",
+            "colors": ["W", "G"],
+            "cmc": 5.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "{G}{G/U/P}{U}{G/W}",
+        {
+            "cost": "{G/W}{G/U/P}{G}{U}",
+            "colors": ["W", "U", "G"],
+            "cmc": 4.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "{HW}{R}",
+        {"cost": "{HW}{R}", "colors": ["W", "R"], "cmc": 1.5, "colorless": False, "monocolored": False, "multicolored": True},
+    ),
+    (
+        "{HR}{G/W}",
+        {
+            "cost": "{G/W}{HR}",
+            "colors": ["W", "R", "G"],
+            "cmc": 1.5,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "{2/W}{G/U}",
+        {
+            "cost": "{G/U}{2/W}",
+            "colors": ["W", "U", "G"],
+            "cmc": 3.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "{G/U/P}{W/U}",
+        {
+            "cost": "{W/U}{G/U/P}",
+            "colors": ["W", "U", "G"],
+            "cmc": 2.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "{G/W/P}{G/U/P}",
+        {
+            "cost": "{G/U/P}{G/W/P}",
+            "colors": ["W", "U", "G"],
+            "cmc": 2.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "{G/W}{G/W/P}",
+        {"cost": "{G/W}{G/W/P}", "colors": ["W", "G"], "cmc": 2.0, "colorless": False, "monocolored": False, "multicolored": True},
+    ),
+    (
+        "2{W/U/P}{G}",
+        {
+            "cost": "{2}{W/U/P}{G}",
+            "colors": ["W", "U", "G"],
+            "cmc": 4.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "{W/U/P}{W/U/P}",
+        {
+            "cost": "{W/U/P}{W/U/P}",
+            "colors": ["W", "U"],
+            "cmc": 2.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "WUBRG",
+        {
+            "cost": "{W}{U}{B}{R}{G}",
+            "colors": ["W", "U", "B", "R", "G"],
+            "cmc": 5.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+    (
+        "GRBUW",
+        {
+            "cost": "{W}{U}{B}{R}{G}",
+            "colors": ["W", "U", "B", "R", "G"],
+            "cmc": 5.0,
+            "colorless": False,
+            "monocolored": False,
+            "multicolored": True,
+        },
+    ),
+]
+
+# Costs api.scryfall.com rejects with a 422 rather than parsing.
+UNPARSEABLE = [
+    "{T}",
+    "{Q}",
+]
+
+# What Scryfall SAYS about an unreadable cost, not merely that it says something. Every pair is a
+# golden captured from api.scryfall.com on 2026-08-16, one request each, and together they pin the
+# rule the wording follows: the reported fragment is the input with everything Scryfall could read
+# struck out, adjacent bare characters merge into one run, and a braced token keeps its braces.
+UNPARSEABLE_MESSAGES = [
+    ("{QQQ}", "{QQQ}"),
+    ("{}", "{}"),
+    ("{", "{"),
+    ("!!!", "!!!"),
+    ("é", "É"),
+    # A triple hybrid is not a Magic symbol. This one is also the reason the rule above had to be
+    # worked out at all: the recognized halves come out and only the punctuation is reported.
+    ("{W/U/B}", "{//}"),
+    # The boundary the hybrid goldens sit against, one request per row on 2026-08-28. A slash symbol
+    # parses only if `GET /symbology` lists it, so a fourth half, the same symbol spelled backwards,
+    # a combination that is not printed and a generic half that is not 2 are all 422s -- even though
+    # `{W/U/P}` itself parses. These fragments also pin what "everything Scryfall could read" strikes
+    # out: the ten one-character symbols and nothing else. `P`, `H` and digits SURVIVE, which the
+    # residue rule here used to get wrong by striking whatever the parser could price.
+    ("{U/W/P}", "{//P}"),
+    ("{P/W/U}", "{P//}"),
+    ("{W/U/P/P}", "{//P/P}"),
+    ("{C/W/P}", "{//P}"),
+    ("{W/W/P}", "{//P}"),
+    ("{2/W/P}", "{2//P}"),
+    ("{3/W}", "{3/}"),
+    ("{S/W}", "{/}"),
+    ("{X/W}", "{/}"),
+    ("{C/S}", "{/}"),
+    # `H` is not a prefix over any colour: `GET /symbology` lists {HW} and {HR}, and no others.
+    ("{H/W}", "{H/}"),
+    ("{HB}", "{H}"),
+    # SEVERAL fragments, which is what the "(s)" in the message is about. They concatenate in written
+    # order with NO separator, and the readable symbols between them leave no trace. An earlier pass
+    # here asserted a space, which nothing measured supported and `{Q}W{T}` disproves.
+    ("{Q}W{T}", "{Q}{T}"),
+    ("{Q}{T}", "{Q}{T}"),
+    ("!W!", "!!"),
+    ("{Q}WW{T}", "{Q}{T}"),
+    ("!{Q}!", "!{Q}!"),
+    ("{Q} {T}", "{Q}{T}"),
+    # `b` is BLACK MANA and reads fine, so only `a` and `{Q}` are reported.
+    ("a{Q}b", "A{Q}"),
+    # The 51-CHARACTER cap, measured across nine lengths. It is characters and not bytes (51 `é` come
+    # back whole at 102 bytes), it applies to the whole joined list rather than per fragment, and
+    # there is no ellipsis -- the string simply stops.
+    ("a" * 51, "A" * 51),
+    ("a" * 52, "A" * 51),
+    ("a" * 200, "A" * 51),
+    ("é" * 51, "É" * 51),
+    ("é" * 60, "É" * 51),
+    ("{" + "a" * 50 + "}", ("{" + "A" * 50 + "}")[:51]),
+    ("{QQQQQQQQ}" * 10, ("{QQQQQQQQ}" * 10)[:51]),
+]
+
+
+class TestParseManaGoldens:
+    """Parity with Scryfall, case by case."""
+
+    @pytest.mark.parametrize(("written", "expected"), GOLDENS)
+    def test_matches_scryfall(self, written: str, expected: dict[str, Any]) -> None:
+        parsed = parse_mana_cost(written)
+        assert parsed["object"] == "mana_cost"
+        assert {field: parsed[field] for field in expected} == expected
+
+    @pytest.mark.parametrize("written", UNPARSEABLE)
+    def test_a_non_mana_fragment_is_rejected(self, written: str) -> None:
+        with pytest.raises(ManaCostError):
+            parse_mana_cost(written)
+
+    @pytest.mark.parametrize(("written", "fragment"), UNPARSEABLE_MESSAGES)
+    def test_the_rejection_names_the_fragment_scryfall_names(self, written: str, fragment: str) -> None:
+        """The `details` string is compared byte for byte by clients, so it is pinned that way."""
+        with pytest.raises(ManaCostError) as raised:
+            parse_mana_cost(written)
+        expected = f"The string fragment(s) “{fragment}” could not be understood as part of mana cost."
+        assert str(raised.value) == expected
+
+
+class TestParseManaProperties:
+    """Properties the goldens imply but do not state outright."""
+
+    def test_an_empty_cost_is_null_but_an_explicit_zero_is_not(self) -> None:
+        """The two differ upstream, so they cannot share a branch here."""
+        assert parse_mana_cost("")["cost"] is None
+        assert parse_mana_cost("0")["cost"] == "{0}"
+
+    def test_case_and_whitespace_do_not_change_the_answer(self) -> None:
+        assert parse_mana_cost("ruw") == parse_mana_cost("RUW")
+        assert parse_mana_cost(" 2 W W ") == parse_mana_cost("2WW")
+
+    def test_generic_pips_are_summed_into_one_symbol(self) -> None:
+        assert parse_mana_cost("1{1}")["cost"] == "{2}"
+
+    def test_consecutive_digits_are_one_number(self) -> None:
+        """`11R` is eleven generic and a red pip, not two ones."""
+        assert parse_mana_cost("11R")["cmc"] == 12.0
+
+    def test_the_colors_list_is_always_wubrg_order(self) -> None:
+        """Unlike `cost`, which is reordered canonically, `colors` is not."""
+        assert parse_mana_cost("RUW")["cost"] == "{U}{R}{W}"
+        assert parse_mana_cost("RUW")["colors"] == ["W", "U", "R"]
+
+    def test_variable_pips_come_out_in_xyz_order_however_they_were_written(self) -> None:
+        """`?cost=xyzzy` answers `{X}{Y}{Y}{Z}{Z}` on api.scryfall.com, not writing order."""
+        assert parse_mana_cost("xyzzy")["cost"] == "{X}{Y}{Y}{Z}{Z}"
+        assert parse_mana_cost("zyx")["cost"] == "{X}{Y}{Z}"
+
+    def test_a_hybrid_is_the_symbols_scryfall_lists(self) -> None:
+        """The rule this replaced counted halves, which gets `{W/U/B}` right and `{W/U/P}` wrong.
+
+        Neither "exactly two" nor "two or three" is the boundary -- the inventory is.
+        """
+        assert parse_mana_cost("{W/U}")["cost"] == "{W/U}"
+        assert parse_mana_cost("{W/U/P}")["cost"] == "{W/U/P}"
+        assert parse_mana_cost("{2/W}")["cmc"] == 2.0
+        assert parse_mana_cost("{W/P}")["cmc"] == 1.0
+        assert parse_mana_cost("{W/U/P}")["cmc"] == 1.0
+        for written in ("{W/U/B}", "{U/W/P}", "{3/W}"):
+            with pytest.raises(ManaCostError):
+                parse_mana_cost(written)
+
+    def test_a_phyrexian_hybrid_contributes_both_its_colours_and_one_mana(self) -> None:
+        """Ajani, Sleeper Agent -- the whole point of the fix.
+
+        `is:phyrexian is:hybrid` finds four cards and this route used to 422 on all four
+        (measured 2026-08-28).
+        """
+        ajani = parse_mana_cost("{1}{G}{G/W/P}{W}")
+        assert ajani["cost"] == "{1}{G/W/P}{G}{W}"
+        assert ajani["colors"] == ["W", "G"]
+        assert ajani["cmc"] == 4.0
+
+    def test_every_unreadable_fragment_is_named_at_once(self) -> None:
+        """The message says "fragment(s)" because it can name more than one -- concatenated, not spaced.
+
+        The exact strings live in UNPARSEABLE_MESSAGES; this states the property they encode.
+        """
+        with pytest.raises(ManaCostError) as raised:
+            parse_mana_cost("{Q}W{T}")
+        assert "“{Q}{T}”" in str(raised.value)
diff --git a/api/tests/test_scryfall_reference_import.py b/api/tests/test_scryfall_reference_import.py
new file mode 100644
index 000000000..0da03e3fc
--- /dev/null
+++ b/api/tests/test_scryfall_reference_import.py
@@ -0,0 +1,302 @@
+"""Tests for the sets / catalogs / symbology mirror.
+
+Mocked connection pool, in the shape test_tagging_integration.py and test_rulings_import.py use for
+import code. The upstream calls are mocked too: these importers talk to api.scryfall.com rather than
+to a cached bulk file, so a test that did not stub the fetcher would hit the network on every run.
+"""
+
+from __future__ import annotations
+
+import contextlib
+from typing import TYPE_CHECKING, Any
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from api.scryfall_compat.reference_routes import CATALOG_NAMES
+from api.scryfall_reference_import import import_catalogs, import_sets, import_symbology
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+# The module-level names `_import_reference_quietly` dispatches through.
+_STEPS = ("_import_sets", "_import_catalogs", "_import_symbology")
+
+
+@contextlib.contextmanager
+def _all_steps_stubbed() -> Iterator[dict[str, MagicMock]]:
+    """Stub every reference import step at once.
+
+    All three together, never one at a time: `stub_api_resource` carries a real fetcher and a real
+    connection pool, so any step left unstubbed performs a live import against api.scryfall.com and
+    writes it into the session's shared database.
+
+    Yields:
+        The step name to its stub.
+    """
+    with contextlib.ExitStack() as stack:
+        yield {name: stack.enter_context(patch(f"api.admin_resource.{name}")) for name in _STEPS}
+
+
+SETS_PAYLOAD = {
+    "object": "list",
+    "has_more": False,
+    "data": [
+        {"object": "set", "id": "11111111-1111-4111-8111-111111111111", "code": "aaa", "tcgplayer_id": 42},
+        {"object": "set", "id": "22222222-2222-4222-8222-222222222222", "code": "bbb"},
+    ],
+}
+
+SYMBOLOGY_PAYLOAD = {
+    "object": "list",
+    "data": [
+        {"object": "card_symbol", "symbol": "{T}", "svg_uri": "https://svgs.test/t.svg"},
+        {"object": "card_symbol", "symbol": "{W}", "svg_uri": "https://svgs.test/w.svg"},
+    ],
+}
+
+
+def _make_mock_conn_pool() -> tuple[MagicMock, MagicMock, MagicMock]:
+    """Return a mock conn_pool, its connection and its cursor."""
+    cursor = MagicMock()
+    cursor.__enter__ = lambda _: cursor
+    cursor.__exit__ = MagicMock(return_value=False)
+
+    conn = MagicMock()
+    conn.__enter__ = lambda _: conn
+    conn.__exit__ = MagicMock(return_value=False)
+    conn.cursor.return_value = cursor
+
+    pool = MagicMock()
+    pool.connection.return_value.__enter__ = lambda _: conn
+    pool.connection.return_value.__exit__ = MagicMock(return_value=False)
+    return pool, conn, cursor
+
+
+def _catalog_fetcher(total: int = 3) -> MagicMock:
+    """A fetcher answering every catalog request with `total` values."""
+    fetcher = MagicMock()
+    fetcher.fetch_api_json.side_effect = lambda path, **_: {
+        "object": "catalog",
+        "data": [f"{path}-{index}" for index in range(total)],
+    }
+    return fetcher
+
+
+def _rows_of(cursor: MagicMock) -> list[dict[str, Any]]:
+    """The parameter sequence handed to the last executemany()."""
+    return list(cursor.executemany.call_args.args[1])
+
+
+class TestImportSets:
+    """GET /sets into magic.sets."""
+
+    def test_fetches_the_sets_endpoint(self) -> None:
+        pool, _, _ = _make_mock_conn_pool()
+        fetcher = MagicMock()
+        fetcher.fetch_api_json.return_value = SETS_PAYLOAD
+
+        import_sets(pool, fetcher)
+
+        fetcher.fetch_api_json.assert_called_once_with("sets")
+
+    def test_the_table_is_emptied_before_the_insert(self) -> None:
+        pool, _, cursor = _make_mock_conn_pool()
+        fetcher = MagicMock()
+        fetcher.fetch_api_json.return_value = SETS_PAYLOAD
+
+        import_sets(pool, fetcher)
+
+        assert cursor.execute.call_args_list[0].args[0] == "DELETE FROM magic.sets"
+
+    def test_position_preserves_the_upstream_order(self) -> None:
+        """/sets is served in this order, and no field on a Set object reproduces it."""
+        pool, _, cursor = _make_mock_conn_pool()
+        fetcher = MagicMock()
+        fetcher.fetch_api_json.return_value = SETS_PAYLOAD
+
+        import_sets(pool, fetcher)
+
+        assert [row["position"] for row in _rows_of(cursor)] == [0, 1]
+        assert [row["code"] for row in _rows_of(cursor)] == ["aaa", "bbb"]
+
+    def test_a_set_without_a_tcgplayer_id_stores_null(self) -> None:
+        pool, _, cursor = _make_mock_conn_pool()
+        fetcher = MagicMock()
+        fetcher.fetch_api_json.return_value = SETS_PAYLOAD
+
+        import_sets(pool, fetcher)
+
+        assert [row["tcgplayer_id"] for row in _rows_of(cursor)] == [42, None]
+
+    def test_entries_without_an_id_or_code_are_dropped(self) -> None:
+        """Both are NOT NULL, and a set with neither is not addressable by any route."""
+        pool, _, cursor = _make_mock_conn_pool()
+        fetcher = MagicMock()
+        fetcher.fetch_api_json.return_value = {"data": [{"object": "set"}, {"id": "x"}, {"code": "y"}]}
+
+        result = import_sets(pool, fetcher)
+
+        assert result["sets_imported"] == 0
+        assert _rows_of(cursor) == []
+
+    def test_reports_duration_and_counts(self) -> None:
+        pool, _, _ = _make_mock_conn_pool()
+        fetcher = MagicMock()
+        fetcher.fetch_api_json.return_value = SETS_PAYLOAD
+
+        result = import_sets(pool, fetcher)
+
+        assert result["sets_imported"] == 2
+        assert result["sets_with_tcgplayer_id"] == 1
+        assert "duration_seconds" in result
+
+    def test_the_load_is_one_transaction(self) -> None:
+        pool, conn, _ = _make_mock_conn_pool()
+        fetcher = MagicMock()
+        fetcher.fetch_api_json.return_value = SETS_PAYLOAD
+
+        import_sets(pool, fetcher)
+
+        conn.commit.assert_called_once()
+
+
+class TestImportCatalogs:
+    """The twenty /catalog/* endpoints into magic.catalogs."""
+
+    def test_fetches_every_documented_catalog(self) -> None:
+        pool, _, _ = _make_mock_conn_pool()
+        fetcher = _catalog_fetcher()
+
+        import_catalogs(pool, fetcher)
+
+        requested = [call.args[0] for call in fetcher.fetch_api_json.call_args_list]
+        assert requested == [f"catalog/{name}" for name in CATALOG_NAMES]
+
+    def test_reports_what_it_loaded(self) -> None:
+        pool, _, _ = _make_mock_conn_pool()
+
+        result = import_catalogs(pool, _catalog_fetcher(total=3))
+
+        assert result["catalogs_imported"] == len(CATALOG_NAMES)
+        assert result["catalogs_failed"] == 0
+        assert result["values_imported"] == 3 * len(CATALOG_NAMES)
+
+    def test_one_failing_catalog_does_not_lose_the_other_nineteen(self) -> None:
+        """A per-catalog failure is skipped, not fatal: nineteen fresh beats aborting the refresh."""
+        pool, _, cursor = _make_mock_conn_pool()
+        fetcher = MagicMock()
+
+        def answer(path: str, **_: object) -> dict[str, Any]:
+            if path == "catalog/word-bank":
+                msg = "upstream is down"
+                raise RuntimeError(msg)
+            return {"data": ["value"]}
+
+        fetcher.fetch_api_json.side_effect = answer
+
+        result = import_catalogs(pool, fetcher)
+
+        assert result["catalogs_failed"] == 1
+        assert result["catalogs_imported"] == len(CATALOG_NAMES) - 1
+        assert "word-bank" not in {row["name"] for row in _rows_of(cursor)}
+
+    def test_a_failed_catalog_is_not_written_as_empty(self) -> None:
+        """Writing an empty row would tell a client Magic has no such vocabulary."""
+        pool, _, cursor = _make_mock_conn_pool()
+        fetcher = MagicMock()
+        fetcher.fetch_api_json.side_effect = RuntimeError("upstream is down")
+
+        import_catalogs(pool, fetcher)
+
+        assert _rows_of(cursor) == []
+
+    def test_a_malformed_payload_counts_as_a_failure(self) -> None:
+        pool, _, _ = _make_mock_conn_pool()
+        fetcher = MagicMock()
+        fetcher.fetch_api_json.return_value = {"data": "not a list"}
+
+        result = import_catalogs(pool, fetcher)
+
+        assert result["catalogs_failed"] == len(CATALOG_NAMES)
+
+    def test_non_string_values_are_dropped(self) -> None:
+        pool, _, cursor = _make_mock_conn_pool()
+        fetcher = MagicMock()
+        fetcher.fetch_api_json.return_value = {"data": ["Goblin", None, 7, "Wizard"]}
+
+        import_catalogs(pool, fetcher)
+
+        assert _rows_of(cursor)[0]["entries"].obj == ["Goblin", "Wizard"]
+
+
+class TestImportSymbology:
+    """GET /symbology into magic.card_symbols."""
+
+    def test_fetches_the_symbology_endpoint(self) -> None:
+        pool, _, _ = _make_mock_conn_pool()
+        fetcher = MagicMock()
+        fetcher.fetch_api_json.return_value = SYMBOLOGY_PAYLOAD
+
+        import_symbology(pool, fetcher)
+
+        fetcher.fetch_api_json.assert_called_once_with("symbology")
+
+    def test_position_preserves_the_upstream_order(self) -> None:
+        pool, _, cursor = _make_mock_conn_pool()
+        fetcher = MagicMock()
+        fetcher.fetch_api_json.return_value = SYMBOLOGY_PAYLOAD
+
+        import_symbology(pool, fetcher)
+
+        assert [(row["symbol"], row["position"]) for row in _rows_of(cursor)] == [("{T}", 0), ("{W}", 1)]
+
+    def test_the_table_is_emptied_before_the_insert(self) -> None:
+        pool, _, cursor = _make_mock_conn_pool()
+        fetcher = MagicMock()
+        fetcher.fetch_api_json.return_value = SYMBOLOGY_PAYLOAD
+
+        import_symbology(pool, fetcher)
+
+        assert cursor.execute.call_args_list[0].args[0] == "DELETE FROM magic.card_symbols"
+
+    def test_reports_duration_and_count(self) -> None:
+        pool, _, _ = _make_mock_conn_pool()
+        fetcher = MagicMock()
+        fetcher.fetch_api_json.return_value = SYMBOLOGY_PAYLOAD
+
+        result = import_symbology(pool, fetcher)
+
+        assert result["symbols_imported"] == 2
+        assert "duration_seconds" in result
+
+
+class TestImportReferenceQuietly:
+    """The wrapper the import sequence calls."""
+
+    @pytest.mark.parametrize("failing", _STEPS)
+    def test_any_failing_step_is_swallowed(self, stub_api_resource, failing: str) -> None:
+        """Nothing downstream reads these tables, so a bad upstream must not cost the corpus refresh.
+
+        All three steps are stubbed and only the named one is made to fail. Stubbing just the
+        failing one would leave the other two to run for real — a live fetch of api.scryfall.com and
+        a write into the shared test database — while the test still passed.
+        """
+        with _all_steps_stubbed() as steps:
+            steps[failing].side_effect = RuntimeError("upstream is down")
+            stub_api_resource.admin._import_reference_quietly()
+
+    def test_a_failure_in_one_step_still_runs_the_others(self, stub_api_resource) -> None:
+        with _all_steps_stubbed() as steps:
+            steps["_import_sets"].side_effect = RuntimeError("down")
+            stub_api_resource.admin._import_reference_quietly()
+
+        steps["_import_catalogs"].assert_called_once()
+        steps["_import_symbology"].assert_called_once()
+
+    def test_all_three_run_on_the_happy_path(self, stub_api_resource) -> None:
+        with _all_steps_stubbed() as steps:
+            stub_api_resource.admin._import_reference_quietly()
+
+        for step in steps.values():
+            step.assert_called_once()
diff --git a/api/tests/test_scryfall_reference_routes.py b/api/tests/test_scryfall_reference_routes.py
new file mode 100644
index 000000000..ef1764dda
--- /dev/null
+++ b/api/tests/test_scryfall_reference_routes.py
@@ -0,0 +1,373 @@
+"""Integration tests for the Scryfall-compatible `/sets`, `/catalog` and `/symbology` routes.
+
+Everything here dispatches through `_handle`, the same path a real request takes. The reference
+tables are global rather than per-card, so unlike the `/cards/*` tests this module cannot scope its
+fixtures to rows it owns: it seeds all three tables and asserts against exactly what it seeded.
+That is safe because nothing else in the suite writes them, and it is stated here so a future test
+that does write them knows what it would break.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING, Any
+
+import falcon
+import falcon.testing
+import orjson
+import pytest
+from psycopg.types.json import Jsonb
+
+if TYPE_CHECKING:
+    from api.api_resource import APIResource
+
+BOLT_SET_ID = "aaaaaaaa-0000-4000-8000-aaaaaaaaaaaa"
+OLD_SET_ID = "bbbbbbbb-0000-4000-8000-bbbbbbbbbbbb"
+TCGPLAYER_ID = 90210
+
+
+def _set_object(set_id: str, code: str, name: str, released: str, tcgplayer_id: int | None) -> dict[str, Any]:
+    """A Set object shaped like Scryfall's, including the fields no card carries."""
+    payload = {
+        "object": "set",
+        "id": set_id,
+        "code": code,
+        "mtgo_code": code,
+        "arena_code": code,
+        "name": name,
+        "uri": f"https://api.scryfall.com/sets/{set_id}",
+        "scryfall_uri": f"https://scryfall.com/sets/{code}",
+        "search_uri": f"https://api.scryfall.com/cards/search?q=e%3A{code}",
+        "released_at": released,
+        "set_type": "expansion",
+        "card_count": 135,
+        "digital": False,
+        "nonfoil_only": False,
+        "foil_only": False,
+        "icon_svg_uri": f"https://svgs.scryfall.io/sets/{code}.svg",
+    }
+    if tcgplayer_id is not None:
+        payload["tcgplayer_id"] = tcgplayer_id
+    return payload
+
+
+SETS = [
+    _set_object(BOLT_SET_ID, "zzt", "Compat Test Set", "2026-01-01", TCGPLAYER_ID),
+    _set_object(OLD_SET_ID, "zzo", "Compat Older Set", "1999-01-01", None),
+]
+
+SYMBOLS = [
+    {"object": "card_symbol", "symbol": "{ZT}", "svg_uri": "https://svgs.test/zt.svg", "english": "compat tap", "cmc": 0.0},
+    {"object": "card_symbol", "symbol": "{ZW}", "svg_uri": "https://svgs.test/zw.svg", "english": "compat white", "cmc": 1.0},
+]
+
+CREATURE_TYPES = ["Compat Beast", "Compat Wizard"]
+
+
+@pytest.fixture(name="reference_corpus", scope="module")
+def reference_corpus_fixture(api_resource: APIResource) -> APIResource:
+    """Seed the three reference tables once, then hand back the resource."""
+    with api_resource.app_context.reader_pool.connection() as conn, conn.cursor() as cursor:
+        cursor.execute("DELETE FROM magic.sets")
+        cursor.executemany(
+            "INSERT INTO magic.sets (id, code, tcgplayer_id, position, set_object) VALUES (%s, %s, %s, %s, %s)",
+            [
+                (entry["id"], entry["code"], entry.get("tcgplayer_id"), position, Jsonb(entry))
+                for position, entry in enumerate(SETS)
+            ],
+        )
+        cursor.execute("DELETE FROM magic.card_symbols")
+        cursor.executemany(
+            "INSERT INTO magic.card_symbols (symbol, position, symbol_object) VALUES (%s, %s, %s)",
+            [(entry["symbol"], position, Jsonb(entry)) for position, entry in enumerate(SYMBOLS)],
+        )
+        cursor.execute(
+            "INSERT INTO magic.catalogs (name, entries) VALUES (%s, %s) "
+            "ON CONFLICT (name) DO UPDATE SET entries = EXCLUDED.entries",
+            ("creature-types", Jsonb(CREATURE_TYPES)),
+        )
+        conn.commit()
+    api_resource.admin._clear_caches()
+    return api_resource
+
+
+def dispatch(api: APIResource, path: str, query_string: str = "", *, method: str = "GET") -> falcon.Response:
+    """Run one request through `_handle` and return the Falcon response."""
+    environ = falcon.testing.create_environ(path=path, query_string=query_string, method=method, body="")
+    req = falcon.Request(environ)
+    resp = falcon.Response()
+    api._handle(req, resp)
+    return resp
+
+
+def payload(resp: falcon.Response) -> dict[str, Any]:
+    """Decode a response body regardless of whether it was set as media or as text."""
+    if resp.media is not None:
+        return resp.media
+    return orjson.loads(resp.render_body())
+
+
+class TestSetsListing:
+    """GET /sets."""
+
+    def test_returns_a_list_object(self, reference_corpus: APIResource) -> None:
+        body = payload(dispatch(reference_corpus, "/sets"))
+        assert body["object"] == "list"
+        assert body["has_more"] is False
+        assert [entry["code"] for entry in body["data"]] == ["zzt", "zzo"]
+
+    def test_preserves_scryfalls_own_ordering(self, reference_corpus: APIResource) -> None:
+        """Ordered by the stored position, not recomputed — sets sharing a date have no derivable order."""
+        body = payload(dispatch(reference_corpus, "/sets"))
+        assert body["data"][0]["released_at"] > body["data"][1]["released_at"]
+
+    def test_serves_the_fields_no_card_carries(self, reference_corpus: APIResource) -> None:
+        """The whole reason sets are mirrored rather than derived."""
+        first = payload(dispatch(reference_corpus, "/sets"))["data"][0]
+        for field in ("icon_svg_uri", "mtgo_code", "arena_code", "card_count", "tcgplayer_id"):
+            assert field in first, field
+
+
+class TestSetLookup:
+    """GET /sets/:code, /sets/:id and /sets/tcgplayer/:id."""
+
+    def test_by_set_code(self, reference_corpus: APIResource) -> None:
+        body = payload(dispatch(reference_corpus, "/sets/zzt"))
+        assert body["object"] == "set"
+        assert body["id"] == BOLT_SET_ID
+
+    def test_set_codes_are_case_insensitive(self, reference_corpus: APIResource) -> None:
+        assert payload(dispatch(reference_corpus, "/sets/ZZT"))["id"] == BOLT_SET_ID
+
+    def test_by_scryfall_id(self, reference_corpus: APIResource) -> None:
+        assert payload(dispatch(reference_corpus, f"/sets/{BOLT_SET_ID}"))["code"] == "zzt"
+
+    def test_by_tcgplayer_id(self, reference_corpus: APIResource) -> None:
+        assert payload(dispatch(reference_corpus, f"/sets/tcgplayer/{TCGPLAYER_ID}"))["code"] == "zzt"
+
+    @pytest.mark.parametrize(
+        "path",
+        ["/sets/zzz", "/sets/tcgplayer/999999", "/sets/tcgplayer", "/sets/00000000-0000-4000-8000-000000000000"],
+    )
+    def test_a_set_miss_carries_scryfalls_own_wording(self, reference_corpus: APIResource, path: str) -> None:
+        """Not the cards surface's generic body, and not a message about the id being absent.
+
+        Captured from api.scryfall.com on 2026-08-12, including the `/sets/tcgplayer` shape: it
+        answers the ordinary set miss there too.
+        """
+        resp = dispatch(reference_corpus, path)
+        assert resp.status == falcon.HTTP_404
+        assert payload(resp)["details"] == "No Magic set found for the given code or ID"
+
+    def test_an_unknown_code_is_a_404(self, reference_corpus: APIResource) -> None:
+        resp = dispatch(reference_corpus, "/sets/nope")
+        assert resp.status == falcon.HTTP_404
+        assert payload(resp)["object"] == "error"
+
+    def test_an_unknown_tcgplayer_id_is_a_404(self, reference_corpus: APIResource) -> None:
+        assert dispatch(reference_corpus, "/sets/tcgplayer/1").status == falcon.HTTP_404
+
+    def test_a_non_numeric_tcgplayer_id_is_a_404_not_a_500(self, reference_corpus: APIResource) -> None:
+        """The segment reaches the handler as text, so the int() has to be guarded."""
+        assert dispatch(reference_corpus, "/sets/tcgplayer/abc").status == falcon.HTTP_404
+
+    def test_a_set_with_no_tcgplayer_id_is_still_addressable_by_code(self, reference_corpus: APIResource) -> None:
+        assert payload(dispatch(reference_corpus, "/sets/zzo"))["id"] == OLD_SET_ID
+
+
+class TestCatalog:
+    """GET /catalog/:name."""
+
+    def test_returns_a_catalog_object(self, reference_corpus: APIResource) -> None:
+        body = payload(dispatch(reference_corpus, "/catalog/creature-types"))
+        assert body["object"] == "catalog"
+        assert body["total_values"] == len(CREATURE_TYPES)
+        assert body["data"] == CREATURE_TYPES
+
+    def test_a_catalog_carries_its_own_uri(self, reference_corpus: APIResource) -> None:
+        """Measured: `/catalog/*` sends `uri`, and it sits between `object` and `total_values`.
+
+        `/cards/autocomplete` answers the same object with no `uri` at all, which is why
+        `catalog_object` takes one rather than always building one -- see the test below.
+        """
+        body = payload(dispatch(reference_corpus, "/catalog/creature-types"))
+        assert body["uri"] == "https://api.scryfall.com/catalog/creature-types"
+        assert list(body) == ["object", "uri", "total_values", "data"]
+
+    def test_an_unknown_catalog_is_a_404(self, reference_corpus: APIResource) -> None:
+        resp = dispatch(reference_corpus, "/catalog/not-a-catalog")
+        assert resp.status == falcon.HTTP_404
+        body = payload(resp)
+        assert body["object"] == "error"
+        # Scryfall's catalog miss has no "Please double-check your URI and try again." tail, where
+        # the cards surface's generic body does. Measured, not assumed.
+        assert body["details"] == "The requested object or REST method was not found."
+
+    def test_a_known_but_unimported_catalog_is_empty_rather_than_missing(self, reference_corpus: APIResource) -> None:
+        """The name is real, so 404 would tell a client the endpoint does not exist."""
+        body = payload(dispatch(reference_corpus, "/catalog/watermarks"))
+        assert body["object"] == "catalog"
+        assert body["total_values"] == 0
+
+    def test_the_name_is_CASE_SENSITIVE(self, reference_corpus: APIResource) -> None:  # noqa: N802
+        """`/catalog/Creature-Types` is a 404 on api.scryfall.com (measured 2026-08-16).
+
+        This asserted the opposite. Folding the case made the route answer a URL Scryfall does not
+        serve, which is the same class of mistake as failing to answer one it does -- and it is the
+        worse direction of the two, because a client cannot discover it from a 200.
+        """
+        resp = dispatch(reference_corpus, "/catalog/Creature-Types")
+        assert resp.status == falcon.HTTP_404
+        assert payload(resp)["object"] == "error"
+        assert payload(dispatch(reference_corpus, "/catalog/creature-types"))["data"] == CREATURE_TYPES
+
+    def test_a_path_miss_is_no_cache_where_a_data_miss_keeps_the_data_tier(self, reference_corpus: APIResource) -> None:
+        """The tier splits by what the 404 is a statement ABOUT, and Scryfall really sends both.
+
+        `/sets/zzzz` -- a well-formed set lookup that found nothing -- is `public`, the same tier the
+        answer would have had. `/catalog/not-a-catalog` and `/sets/khm/extra` are `no-cache`. All
+        three were `public` here, so a mistyped catalog name was held at every edge.
+        """
+        assert dispatch(reference_corpus, "/catalog/not-a-catalog").headers["cache-control"] == "no-cache"
+        assert dispatch(reference_corpus, "/sets/zzzz").headers["cache-control"] == "public"
+
+    def test_a_wrong_method_on_the_scryfall_surface_is_scryfalls_404(self, reference_corpus: APIResource) -> None:
+        """404 with the ordinary `not_found` object and NO `Allow`, which is what Scryfall answers.
+
+        Measured 2026-08-16 across eight requests -- POST, PUT, DELETE and PATCH against
+        `/cards/search`, `/cards/named`, `/cards/collection`, `/cards/:id` and `/sets`. Not one
+        carries `Allow`. 405 is the more correct HTTP answer in the abstract and would have needed an
+        error code no measurement backs, since api.scryfall.com never emits a 405 to measure.
+        """
+        resp = dispatch(reference_corpus, "/sets", method="DELETE")
+        assert resp.status == falcon.HTTP_404
+        assert "allow" not in resp.headers
+        assert payload(resp) == {
+            "object": "error",
+            "code": "not_found",
+            "status": 404,
+            "details": "The requested object or REST method was not found.",
+        }
+
+    def test_an_over_long_path_is_a_route_miss_not_a_set_miss(self, reference_corpus: APIResource) -> None:
+        """`/sets/khm/extra` said "No Magic set found ..." -- about a set that was fine."""
+        resp = dispatch(reference_corpus, "/sets/zzt/extra")
+        assert resp.status == falcon.HTTP_404
+        assert payload(resp)["details"] == "The requested object or REST method was not found."
+        assert resp.headers["cache-control"] == "no-cache"
+
+
+class TestSymbology:
+    """GET /symbology."""
+
+    def test_returns_every_symbol_in_order(self, reference_corpus: APIResource) -> None:
+        body = payload(dispatch(reference_corpus, "/symbology"))
+        assert body["object"] == "list"
+        assert [entry["symbol"] for entry in body["data"]] == ["{ZT}", "{ZW}"]
+
+    def test_serves_the_fields_no_card_carries(self, reference_corpus: APIResource) -> None:
+        assert payload(dispatch(reference_corpus, "/symbology"))["data"][0]["svg_uri"].startswith("https://")
+
+
+class TestParseMana:
+    """GET /symbology/parse-mana."""
+
+    def test_parses_a_cost(self, reference_corpus: APIResource) -> None:
+        body = payload(dispatch(reference_corpus, "/symbology/parse-mana", "cost=RUW"))
+        assert body["object"] == "mana_cost"
+        assert body["cost"] == "{U}{R}{W}"
+        assert body["cmc"] == 3.0
+
+    def test_a_missing_cost_is_the_same_200_an_empty_cost_is(self, reference_corpus: APIResource) -> None:
+        """api.scryfall.com does not reject this (measured 2026-08-16).
+
+        A missing `cost` is the same request as an empty one and both answer
+        `200 {"object": "mana_cost", "cost": null, ...}`. This asserted the 400 the route used to
+        send, whose sentence -- "You must provide a cost parameter to parse." -- Scryfall does not own.
+        """
+        resp = dispatch(reference_corpus, "/symbology/parse-mana")
+        assert resp.status == falcon.HTTP_200
+        body = payload(resp)
+        assert body["object"] == "mana_cost"
+        assert body["cost"] is None
+        assert payload(dispatch(reference_corpus, "/symbology/parse-mana", "cost=")) == body
+
+    def test_an_unreadable_cost_is_no_cache(self, reference_corpus: APIResource) -> None:
+        """An unreadable cost is a fact about the REQUEST, and Scryfall declines to cache those."""
+        resp = dispatch(reference_corpus, "/symbology/parse-mana", "cost=%7BQ%7D")
+        assert resp.headers["cache-control"] == "no-cache"
+
+    def test_an_unparseable_cost_is_a_422(self, reference_corpus: APIResource) -> None:
+        """Scryfall answers 422 here, not 400."""
+        resp = dispatch(reference_corpus, "/symbology/parse-mana", "cost=%7BQ%7D")
+        assert resp.status == falcon.HTTP_422
+        body = payload(resp)
+        assert body["object"] == "error"
+        # `validation_error`, which is what Scryfall sends with this 422 -- not `bad_request`.
+        assert body["code"] == "validation_error"
+
+    def test_it_answers_without_any_imported_data(self, reference_corpus: APIResource) -> None:
+        """A pure function of the parameter, so it works before the first import."""
+        assert payload(dispatch(reference_corpus, "/symbology/parse-mana", "cost=0"))["cost"] == "{0}"
+
+
+class TestSharedBehaviour:
+    """Conventions the reference routes inherit from the cards surface."""
+
+    @pytest.mark.parametrize(
+        ("path", "expected"),
+        [
+            # Measured from api.scryfall.com on 2026-08-11. Deliberately NOT the card routes'
+            # `public, max-age=57600`: the mirrored routes send a bare `public` upstream, and
+            # parse-mana is marked private and must-revalidate despite being the one deterministic
+            # route here. A client that swaps its base URL should get the caching behaviour it
+            # tuned against Scryfall, so these mirror upstream rather than being chosen.
+            ("/sets", "public"),
+            ("/sets/zzt", "public"),
+            ("/sets/tcgplayer/90210", "public"),
+            ("/catalog/creature-types", "public"),
+            ("/symbology", "public"),
+            ("/symbology/parse-mana?cost=R", "max-age=0, private, must-revalidate"),
+        ],
+    )
+    def test_each_route_sends_the_tier_scryfall_sends(
+        self,
+        reference_corpus: APIResource,
+        path: str,
+        expected: str,
+    ) -> None:
+        route, _, query = path.partition("?")
+        resp = dispatch(reference_corpus, route, query)
+        assert resp.headers["cache-control"] == expected
+
+    def test_an_error_still_carries_the_cache_tier(self, reference_corpus: APIResource) -> None:
+        """The header is set before the handler body, so a 404 is cacheable like Scryfall's."""
+        assert dispatch(reference_corpus, "/sets/nope").headers["cache-control"] == "public"
+
+    @pytest.mark.parametrize("path", ["/sets", "/catalog/creature-types", "/symbology"])
+    def test_pretty_indents_the_body(self, reference_corpus: APIResource, path: str) -> None:
+        resp = dispatch(reference_corpus, path, "pretty=true")
+        assert b"\n  " in resp.render_body()
+
+    def test_errors_carry_the_scryfall_error_shape(self, reference_corpus: APIResource) -> None:
+        body = payload(dispatch(reference_corpus, "/sets/nope"))
+        assert body["object"] == "error"
+        assert body["status"] == 404
+        assert isinstance(body["details"], str)
+
+
+class TestThroughTheFullApp:
+    """The same routes through a real falcon.App, for wire-level concerns."""
+
+    def _client(self, api: APIResource) -> falcon.testing.TestClient:
+        app = falcon.App()
+        app.add_sink(api._handle, prefix="/")
+        return falcon.testing.TestClient(app)
+
+    def test_content_type_is_scryfalls(self, reference_corpus: APIResource) -> None:
+        result = self._client(reference_corpus).simulate_get("/sets")
+        assert result.headers["content-type"] == "application/json; charset=utf-8"
+
+    def test_a_set_lookup_round_trips(self, reference_corpus: APIResource) -> None:
+        result = self._client(reference_corpus).simulate_get("/sets/zzt")
+        assert json.loads(result.text)["code"] == "zzt"
diff --git a/api/utils/param_binding.py b/api/utils/param_binding.py
index a4a679084..3880614ad 100644
--- a/api/utils/param_binding.py
+++ b/api/utils/param_binding.py
@@ -186,6 +186,21 @@ def __init__(self, func: Callable[..., Any]) -> None:
         self._positional_names = tuple(positional)
         self._known = frozenset(name for name, *_ in plan)
 
+    def accepts(self, name: str) -> bool:
+        """Return whether the handler declares a parameter by this name.
+
+        Lets a caller inject an object only into the handlers that asked for it. Injecting one
+        unconditionally is not an option: a non-string keyword a handler neither declares nor
+        absorbs through `**kwargs` reaches it as a TypeError, and most handlers declare neither.
+
+        Args:
+            name: The parameter name to look for.
+
+        Returns:
+            True when the handler has a parameter of that name.
+        """
+        return name in self._known
+
     def bind(self, args: Sequence[Any], kwargs: Mapping[str, Any]) -> dict[str, Any]:
         """Map positional and raw keyword arguments onto typed keyword arguments.
 
diff --git a/card_engine/card_engine/__init__.py b/card_engine/card_engine/__init__.py
index 4847b5188..86430752a 100644
--- a/card_engine/card_engine/__init__.py
+++ b/card_engine/card_engine/__init__.py
@@ -48,6 +48,8 @@ class EngineField(enum.StrEnum):
     "card_border",
     "card_color_identity",
     "card_colors",
+    "card_compat_blob",
+    "card_faces",
     "card_frame_data",
     "card_is_tags",
     "card_keywords",
@@ -73,6 +75,7 @@ class EngineField(enum.StrEnum):
     "mana_cost_text",
     "oracle_text",
     "planeswalker_loyalty",
+    "planeswalker_loyalty_text",
     "price_eur",
     "price_tix",
     "price_usd",
diff --git a/card_engine/src/card_object.rs b/card_engine/src/card_object.rs
new file mode 100644
index 000000000..ca1ac6f4b
--- /dev/null
+++ b/card_engine/src/card_object.rs
@@ -0,0 +1,1353 @@
+//! Scryfall card objects, built in the engine rather than by the caller.
+//!
+//! LOCAL ADDITION (Cloudflare port), destined for upstream — the twin of `to_scryfall_card` in
+//! `api/scryfall_compat/objects.py` and `toScryfallCard` in the port's
+//! `src/routes/scryfall-compat/objects.ts`. Both of those build the object OUTSIDE the engine, per
+//! card, from an engine row: Python builds ~60 dict entries per card and the port's Durable Object
+//! builds the same in JS. A 175-card page pays that 175 times, on top of parsing the engine's rows
+//! back out of JSON and re-encoding the result.
+//!
+//! Measured against the live deployment, that whole round trip is what `/cards/search` spends its
+//! Durable Object CPU on: the DO's cost is very nearly a pure function of payload bytes (~15us/KB),
+//! while the row construction underneath is ~16us per CARD. Building the object here removes the
+//! parse and the re-encode entirely — the bytes written by this module are the bytes on the wire.
+//!
+//! WRITTEN, NOT BUILT. This emits JSON directly rather than assembling a `serde_json::Value`,
+//! for two reasons:
+//!
+//!   - `serde_json` here has no `preserve_order` feature, so `Map` is a `BTreeMap` and a `Value`
+//!     would come out ALPHABETICAL. Both existing implementations emit insertion order, and while
+//!     Scryfall's own order matches neither of them (its `arena_id` is 4th, `legalities` 27th),
+//!     changing our own output order for every card is a gratuitous break for clients and tests.
+//!   - It is faster, which is the point: no intermediate tree, and no freshly allocated `String`
+//!     key per field per card.
+//!
+//! Key order follows UPSTREAM's dict literal. The port's `toScryfallCard` agreed with it
+//! everywhere except `security_stamp`, which sat 6th in the optional tail there and 14th upstream —
+//! cosmetic, but the two should not disagree, and upstream is the reference for a port, so the port
+//! moved to match this rather than the other way round.
+
+use serde_json::{Map, Value};
+
+/// Scryfall's shared card back, the same id on every card object.
+const CARD_BACK_ID: &str = "0aeebaf5-8c7d-4636-9e82-8c27447861f7";
+
+/// Image size -> file extension, in Scryfall's own order.
+///
+/// ELEVEN, not the six this file shipped with. Scryfall added five webp sizes — `thumb`, `grid`,
+/// `display`, `art`, `crop` — and every card object it serves carries all eleven; a six-key
+/// `image_uris` differed from Scryfall on every card object emitted.
+///
+/// Unconditional, and measured that way: across all 540,484 printings in the 2026-08-16 all_cards
+/// bulk, `image_uris` is either wholly ABSENT (8,444 cards, 7,641 faces — the layouts whose picture
+/// lives on the other level) or carries exactly these eleven keys in exactly this order. No card,
+/// face, layout or `image_status` carries a partial set, so there is no per-key conditionality to
+/// round-trip the way `printed_*` has.
+///
+/// Derived, not stored: the same scan confirms all eleven URLs are the same pure function of the id
+/// and the face on every one of the 548,604 objects that has them — `art_crop` and `art` are
+/// different sizes of one path, not a stored pair. These five cost zero archive bytes, which is why
+/// they are a table and not a column.
+///
+/// NOT the `version=` vocabulary of `format=image`, which stays six: measured against
+/// api.scryfall.com, `version=thumb` redirects to the LARGE jpg, the same fallback `version=bogus`
+/// gets, and the same for grid/display/art/crop.
+const IMAGE_EXTENSIONS: [(&str, &str); 11] = [
+    ("small", "jpg"),
+    ("normal", "jpg"),
+    ("large", "jpg"),
+    ("png", "png"),
+    ("art_crop", "jpg"),
+    ("border_crop", "jpg"),
+    ("thumb", "webp"),
+    ("grid", "webp"),
+    ("display", "webp"),
+    ("art", "webp"),
+    ("crop", "webp"),
+];
+
+// ─── row accessors, mirroring the port's str/num/bool/list ───────────────────
+//
+// Absent, wrong-typed and empty-string all read the same: the key was not answered. That is the
+// rule both existing implementations follow, and it is why a card without a watermark omits the
+// key rather than sending null.
+
+fn str_of<'a>(row: &'a Map<String, Value>, key: &str) -> Option<&'a str> {
+    match row.get(key) {
+        Some(Value::String(s)) if !s.is_empty() => Some(s),
+        _ => None,
+    }
+}
+
+/// Like `str_of`, but an empty string is a VALUE rather than an absence.
+///
+/// Scryfall distinguishes the two and this port collapsed them: a basic land's `mana_cost` is `""`
+/// on 61,908 of the 540,484 printings in the 2026-08-16 bulk, its `oracle_text` is `""` on 7,266,
+/// and `artist` is `""` on 965 — and all three came out of here as `null`. The distinction is safe
+/// to draw because the three keys are always PRESENT where they are emitted at all: `mana_cost` is
+/// on every one of the 532,040 rows that is not a two-image layout, `oracle_text` on every one of
+/// the 528,386 that is not multi-faced, and `artist` on all 540,484. A `null` from this accessor is
+/// a row that carried no key at all, which only a hand-built one does.
+fn present_str_of<'a>(row: &'a Map<String, Value>, key: &str) -> Option<&'a str> {
+    match row.get(key) {
+        Some(Value::String(s)) => Some(s),
+        _ => None,
+    }
+}
+
+fn num_of<'a>(row: &'a Map<String, Value>, key: &str) -> Option<&'a Value> {
+    match row.get(key) {
+        Some(v @ Value::Number(_)) => Some(v),
+        _ => None,
+    }
+}
+
+fn u64_of(row: &Map<String, Value>, key: &str) -> Option<u64> {
+    row.get(key).and_then(Value::as_u64).filter(|n| *n != 0)
+}
+
+fn bool_of(row: &Map<String, Value>, key: &str) -> bool {
+    row.get(key) == Some(&Value::Bool(true))
+}
+
+fn list_of<'a>(row: &'a Map<String, Value>, key: &str) -> Option<&'a Vec<Value>> {
+    match row.get(key) {
+        Some(Value::Array(a)) => Some(a),
+        _ => None,
+    }
+}
+
+// ─── JSON writing primitives ─────────────────────────────────────────────────
+
+fn write_json_str(out: &mut Vec<u8>, s: &str) {
+    // serde_json's own string encoder, so escaping matches everything else this crate emits.
+    serde_json::to_writer(&mut *out, s).expect("writing a str to a Vec cannot fail");
+}
+
+fn write_key(out: &mut Vec<u8>, first: &mut bool, key: &str) {
+    if *first {
+        *first = false;
+    } else {
+        out.push(b',');
+    }
+    write_json_str(out, key);
+    out.push(b':');
+}
+
+fn write_value(out: &mut Vec<u8>, first: &mut bool, key: &str, value: &Value) {
+    write_key(out, first, key);
+    serde_json::to_writer(&mut *out, value).expect("writing a Value to a Vec cannot fail");
+}
+
+fn write_str_or_null(out: &mut Vec<u8>, first: &mut bool, key: &str, value: Option<&str>) {
+    write_key(out, first, key);
+    match value {
+        Some(s) => write_json_str(out, s),
+        None => out.extend_from_slice(b"null"),
+    }
+}
+
+fn write_bool(out: &mut Vec<u8>, first: &mut bool, key: &str, value: bool) {
+    write_key(out, first, key);
+    out.extend_from_slice(if value { b"true" } else { b"false" });
+}
+
+/// An array value, or `[]` when the row carries nothing.
+fn write_list(out: &mut Vec<u8>, first: &mut bool, key: &str, value: Option<&Vec<Value>>) {
+    write_key(out, first, key);
+    match value {
+        Some(a) => serde_json::to_writer(&mut *out, a).expect("writing an array to a Vec cannot fail"),
+        None => out.extend_from_slice(b"[]"),
+    }
+}
+
+// ─── derived values ──────────────────────────────────────────────────────────
+
+/// Scryfall's URL slug for a card name.
+///
+/// NOT the folklore "non-alphanumerics collapse to hyphens" rule this file first shipped — that
+/// rule hyphenates apostrophes (`erayo-s-essence`) and serves raw UTF-8 (`jötun-grunt`) where
+/// production Scryfall deletes the apostrophe and percent-encodes the bytes. The real rule,
+/// verified against the `scryfall_uri` of all 540,484 printings in the 2026-08-16 all_cards bulk
+/// (zero mismatches):
+///
+///   1. lowercase;
+///   2. DELETE `' " , . /` and the curly quotes U+201C/U+201D ("S.H.I.E.L.D." -> `shield`,
+///      `Henzie "Toolbox" Torre` -> `henzie-toolbox-torre`; U+201E is NOT deleted — the de
+///      printing `Henzie „Der Beschaffer" Torre` keeps it);
+///   3. each run of ASCII spaces becomes one hyphen — literal hyphens pass through and may stack
+///      (ru "Пламенник - военный разведчик" keeps `---`), and nothing is trimmed ("Humming-" and
+///      "With Great Power . . ." both keep their trailing hyphen);
+///   4. everything else survives verbatim (`:`, `!`, `&`, `、`, `・`, fullwidth punctuation,
+///      U+00A0) and is then UTF-8 percent-encoded, uppercase hex, sparing exactly the bytes the
+///      corpus serves literally: alphanumerics and `!&()+-:;=_`.
+fn slug(name: &str) -> String {
+    let mut hyphenated = String::with_capacity(name.len());
+    let mut prev_space = false;
+    for ch in name.chars().flat_map(char::to_lowercase) {
+        if matches!(ch, '\'' | '"' | ',' | '.' | '/' | '\u{201C}' | '\u{201D}') {
+            continue;
+        }
+        if ch == ' ' {
+            if !prev_space {
+                hyphenated.push('-');
+            }
+            prev_space = true;
+        } else {
+            prev_space = false;
+            hyphenated.push(ch);
+        }
+    }
+    const HEX: &[u8; 16] = b"0123456789ABCDEF";
+    let mut out = String::with_capacity(hyphenated.len());
+    for byte in hyphenated.as_bytes() {
+        match byte {
+            b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'!' | b'&' | b'(' | b')' | b'+' | b'-'
+            | b':' | b';' | b'=' | b'_' => out.push(*byte as char),
+            _ => {
+                out.push('%');
+                out.push(HEX[(byte >> 4) as usize] as char);
+                out.push(HEX[(byte & 0xf) as usize] as char);
+            }
+        }
+    }
+    out
+}
+
+/// The layouts whose faces each get their OWN image — and, with it, their own copy of every value
+/// the one-image layouts keep at the top level.
+///
+/// This is the single fact the whole multi-face branch turns on, and it is a property of the
+/// LAYOUT, not of anything the row carries: a transform card's front and back are two photographs,
+/// so Scryfall puts `image_uris`, `colors`, `power`, `illustration_id`, `flavor_text` and the rest
+/// on the faces and sends NO top-level copy (and no `card_back_id` — there is no shared back). A
+/// split or adventure card is ONE photograph of one piece of cardboard, so Scryfall sends one
+/// top-level `image_uris` and one top-level `colors`, and its faces carry only text.
+///
+/// Verified exhaustively against the 2026-08-16 all_cards bulk: of 540,484 printings, every row of
+/// these five layouts has per-face `image_uris` and no top-level one, and every row of every other
+/// layout has the reverse — zero exceptions in either direction. The port used to serve per-face
+/// URLs for all multi-face cards, which invented a `.../back/...` URL with no image behind it on
+/// every split, flip, adventure and prepare printing.
+const TWO_IMAGE_LAYOUTS: [&str; 5] =
+    ["art_series", "double_faced_token", "modal_dfc", "reversible_card", "transform"];
+
+/// The multi-face layouts a SEARCH LINK spells with the JOINED name — `related_uris.edhrec` and
+/// every marketplace fallback in `purchase_uris`, which take one and the same string.
+///
+/// EDHREC files a transforming or adventuring card under its front face (`cc=Delver+of+Secrets`,
+/// `cc=Brazen+Borrower`, `cc=Erayo%2C+Soratami+Ascendant`, `cc=Agadeem%27s+Awakening`) and a split
+/// or double-backed card under both halves (`cc=Fire+%2F%2F+Ice`, `cc=Wear+%2F%2F+Tear`,
+/// `cc=Temple+Garden+%2F%2F+Temple+Garden`, `cc=Punchcard+%2F%2F+Punchcard`) — all eight verified
+/// against api.scryfall.com. `art_series` sits with the front-face group, not with the other
+/// two-image layouts.
+///
+/// THE MARKETPLACES SPLIT THE SAME WAY, which is why the list is no longer edhrec's alone. Measured
+/// on api.scryfall.com 2026-08-31, over `unique=prints`, on the first printing of each card whose
+/// ids are MISSING so the SEARCH form is what gets emitted (a printing WITH the id gets a product
+/// link and says nothing), and reading the tcgplayer term out of the `u=` parameter of Scryfall's
+/// own partner redirect:
+///
+///   split               Bind // Liberate                      cmb2/88   cardhoarder `Bind // Liberate`
+///   reversible_card     Mechtitan // Mechtitan                sld/1969  cardhoarder `Mechtitan // Mechtitan`
+///   double_faced_token  Snake // Zombie                       cc2/9     tcgplayer, cardmarket AND
+///                                                                       cardhoarder, all `Snake // Zombie`
+///   split               Who // What // When // Where // Why   und/75    cardhoarder the whole
+///                                                                       five-part name
+///   adventure           Champions of Archery // Join the …    ph19/4    cardmarket, cardhoarder
+///                                                                       `Champions of Archery`
+///   flip                Curse of the Fire Penguin // …        unh/73    cardhoarder `Curse of the
+///                                                                       Fire Penguin`
+///   art_series          Aang and Katara // Aang and Katara    atle/8    tcgplayer, cardmarket,
+///                                                                       cardhoarder `Aang and Katara`
+///   transform           Delver of Secrets // Insectile …      sld/2367  cardhoarder `Delver of Secrets`
+///
+/// The `tcgplayer_infinite_*` links in `related_uris` are the exception that stays: they keep the
+/// joined name on EVERY layout, split or not.
+const JOINED_SEARCH_LAYOUTS: [&str; 3] = ["double_faced_token", "reversible_card", "split"];
+
+/// The layout whose printings keep NOTHING of the card at top level — see `write_scryfall_card`.
+///
+/// One name rather than a set, because it is one: nothing else in the corpus omits `oracle_id`,
+/// and nothing else puts `layout` on a face.
+const REVERSIBLE_LAYOUT: &str = "reversible_card";
+
+/// Top-level keys a two-image layout does not carry, because they belong to a face there.
+///
+/// `watermark` is deliberately NOT here — it is face-owned on EVERY faced layout, not only the
+fn is_face_owned_key(key: &str) -> bool {
+    matches!(
+        key,
+        "colors"
+            | "card_back_id"
+            | "illustration_id"
+            | "power"
+            | "toughness"
+            | "loyalty"
+            | "flavor_text"
+            | "color_indicator"
+    )
+}
+
+/// The languages Scryfall writes into the scryfall_uri path — its ten print localizations,
+/// exactly. The glyph and novelty languages (ph, qya, he, la, grc, ar, sa, dw) get NO path
+/// segment: a ph Elesh Norn lives at `/card/one/414/elesh-norn-mother-of-machines`, English form.
+const SLUG_LANG_SEGMENTS: [&str; 10] = ["de", "es", "fr", "it", "ja", "ko", "pt", "ru", "zhs", "zht"];
+
+/// `scryfall_uri`: `https://scryfall.com/card/{set}/{number}[/{lang}]/{slug}?utm_source=api`.
+///
+/// A foreign printing keeps the language segment and takes the plain English slug
+/// (ody/243/zhs -> `/zhs/holistic-wisdom`, verified live). Scryfall also writes a
+/// `slug(printed name)-(slug(english name))` path where it HAS a printed name (grn/212/pt is
+/// `ego-%C3%A0-deriva-(unmoored-ego)`); reproducing that needs the printed name in the archive,
+/// which this branch does not store yet, and the English fallback is what it serves until then.
+fn scryfall_uri(name: &str, set_code: &str, number: &str, lang: &str) -> String {
+    let segment = if SLUG_LANG_SEGMENTS.contains(&lang) { format!("{lang}/") } else { String::new() };
+    format!("https://scryfall.com/card/{set_code}/{number}/{segment}{}?utm_source=api", slug(name))
+}
+
+/// Python's `urllib.parse.quote_plus`: space to `+`, everything outside the unreserved set
+/// percent-encoded uppercase.
+///
+/// Spelled out rather than reached for from a crate because the safe set is the thing that has to
+/// match: `~` stays literal (Python leaves it, and so must we), while `!`, `*`, `'`, `(` and `)`
+/// are escaped — which is exactly where a naive `encodeURIComponent` twin drifts.
+fn quote_plus(value: &str) -> String {
+    const HEX: &[u8; 16] = b"0123456789ABCDEF";
+    let mut out = String::with_capacity(value.len());
+    for byte in value.as_bytes() {
+        match byte {
+            b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' | b'~' => out.push(*byte as char),
+            b' ' => out.push('+'),
+            _ => {
+                out.push('%');
+                out.push(HEX[(byte >> 4) as usize] as char);
+                out.push(HEX[(byte & 0xf) as usize] as char);
+            }
+        }
+    }
+    out
+}
+
+/// The CDN URLs for one face. Scryfall's paths are a pure function of the id, so nothing is stored.
+fn write_image_uris(out: &mut Vec<u8>, scryfall_id: &str, updated_at: Option<u64>, face: &str) {
+    let mut bytes = scryfall_id.bytes();
+    let (Some(first), Some(second)) = (bytes.next(), bytes.next()) else {
+        out.extend_from_slice(b"{}"); // no id, no paths -- same as both twins
+        return;
+    };
+    let (first, second) = (first as char, second as char);
+    let suffix = updated_at.map_or(String::new(), |t| format!("?{t}"));
+    out.push(b'{');
+    let mut first_key = true;
+    for (size, ext) in IMAGE_EXTENSIONS {
+        write_key(out, &mut first_key, size);
+        write_json_str(
+            out,
+            &format!("https://cards.scryfall.io/{size}/{face}/{first}/{second}/{scryfall_id}.{ext}{suffix}"),
+        );
+    }
+    out.push(b'}');
+}
+
+/// `prices`: the three price columns plus the three residue variants, each `"0.00"` or null.
+fn write_prices(out: &mut Vec<u8>, row: &Map<String, Value>) {
+    out.push(b'{');
+    let mut first = true;
+    for (key, column) in [
+        ("usd", "price_usd"),
+        ("usd_foil", "price_usd_foil"),
+        ("usd_etched", "price_usd_etched"),
+        ("eur", "price_eur"),
+        ("eur_foil", "price_eur_foil"),
+        ("tix", "price_tix"),
+    ] {
+        write_key(out, &mut first, key);
+        match num_of(row, column).and_then(Value::as_f64) {
+            // Two decimals, matching Python's `f"{float(v):.2f}"` and the port's `toFixed(2)`.
+            Some(v) => write_json_str(out, &format!("{v:.2}")),
+            None => out.extend_from_slice(b"null"),
+        }
+    }
+    out.push(b'}');
+}
+
+/// `related_uris`, pointing at the destinations directly rather than through Scryfall's affiliate
+/// wrapper — emitting the wrapper from this host would route another service's revenue to them.
+///
+/// `gatherer` LEADS the object when the printing has multiverse ids, built from the FIRST id,
+/// with `printed=true` for every non-English printing and `printed=false` for English — verified
+/// against the bulk corpus at 540,430 of 540,484 printings. The 54 exceptions are foreign-only
+/// promos (dd2-ja, snc launch, one-ph, ltc-qya) whose Gatherer entries carry no translation; that
+/// fact lives on Scryfall's side of the wire and is not derivable from the row, so they stay a
+/// known limit rather than a rule.
+///
+/// `edhrec` takes `search_name`, which is the front face's on most multi-face layouts — see
+/// JOINED_SEARCH_LAYOUTS. The two tcgplayer searches take the joined name on every layout.
+fn write_related_uris(
+    out: &mut Vec<u8>,
+    name: &str,
+    search_name: &str,
+    multiverse_first: Option<u64>,
+    lang: &str,
+) {
+    let quoted = quote_plus(name);
+    out.push(b'{');
+    let mut first = true;
+    if let Some(id) = multiverse_first {
+        let printed = if lang == "en" { "false" } else { "true" };
+        write_key(out, &mut first, "gatherer");
+        write_json_str(
+            out,
+            &format!("https://gatherer.wizards.com/Pages/Card/Details.aspx?multiverseid={id}&printed={printed}"),
+        );
+    }
+    for (key, url) in [
+        (
+            "tcgplayer_infinite_articles",
+            format!("https://www.tcgplayer.com/search/articles?productLineName=magic&q={quoted}"),
+        ),
+        (
+            "tcgplayer_infinite_decks",
+            format!("https://www.tcgplayer.com/search/decks?productLineName=magic&q={quoted}"),
+        ),
+        ("edhrec", format!("https://edhrec.com/route/?cc={}", quote_plus(search_name))),
+    ] {
+        write_key(out, &mut first, key);
+        write_json_str(out, &url);
+    }
+    out.push(b'}');
+}
+
+/// The FRONT face's name — everything before the ` // ` a multi-faced card's name joins on.
+///
+/// The half of `search_name` that is not the joined name — see JOINED_SEARCH_LAYOUTS, which
+/// decides which of the two a given layout gets. Scryfall searches TCGplayer for
+/// `Invasion of Alara`, never for `Invasion of Alara // Awaken the Maelstrom`, because on a
+/// transforming card the joined string matches no product; on a split or a double-faced token it
+/// is the product, and there the joined name is what it searches for.
+///
+/// Applied through `search_name` at the top of `write_scryfall_card` and NOWHERE else: doing it
+/// again inside `write_purchase_uris` is exactly the bug that spelled `Snake // Zombie` as `Snake`.
+fn front_face_name(name: &str) -> &str {
+    name.split_once(" // ").map_or(name, |(front, _)| front)
+}
+
+/// `purchase_uris`, rebuilt from the marketplace ids — or, for a key whose id this printing does
+/// not have, from a NAME SEARCH on that marketplace.
+///
+/// All three keys are always present. Scryfall emits the search form per KEY, not per card: an
+/// English printing with a TCGplayer and a Cardmarket id but no MTGO id gets two product links
+/// and a cardhoarder search (verified live across khm). Every foreign printing takes the search
+/// form on all three, because marketplace product ids are carried by the English printing alone —
+/// they never reach an annex row, and inventing one would point at the wrong product. Emitting
+/// nothing was the alternative, and it made `purchase_uris` an empty object on 426,416 printings.
+///
+/// `search_name` IS `write_related_uris`' — the caller decides the string, and all three
+/// marketplaces split by layout exactly the way edhrec does (the measurements are on
+/// JOINED_SEARCH_LAYOUTS). This took the joined `name` and cut the front face off it here, on
+/// EVERY layout, which searched for `Snake // Zombie` (cc2/9) as `Snake` and
+/// `Who // What // When // Where // Why` (und/75) as `Who` against a Scryfall that spells both
+/// whole.
+fn write_purchase_uris(out: &mut Vec<u8>, row: &Map<String, Value>, search_name: &str) {
+    let quoted = quote_plus(search_name);
+    out.push(b'{');
+    let mut first = true;
+    write_key(out, &mut first, "tcgplayer");
+    write_json_str(
+        out,
+        &match u64_of(row, "tcgplayer_id") {
+            Some(id) => format!("https://www.tcgplayer.com/product/{id}?page=1"),
+            None => format!("https://www.tcgplayer.com/search/magic/product?productLineName=magic&q={quoted}&view=grid"),
+        },
+    );
+    write_key(out, &mut first, "cardmarket");
+    write_json_str(
+        out,
+        &match u64_of(row, "cardmarket_id") {
+            Some(id) => format!("https://www.cardmarket.com/en/Magic/Products?idProduct={id}"),
+            None => format!("https://www.cardmarket.com/en/Magic/Products/Search?searchString={quoted}"),
+        },
+    );
+    write_key(out, &mut first, "cardhoarder");
+    write_json_str(
+        out,
+        &match u64_of(row, "mtgo_id") {
+            Some(id) => format!("https://www.cardhoarder.com/cards/{id}"),
+            None => format!("https://www.cardhoarder.com/cards?data%5Bsearch%5D={quoted}"),
+        },
+    );
+    out.push(b'}');
+}
+
+/// The joined top-level `mana_cost` a one-image multi-face card carries.
+///
+/// Scryfall's rule, checked against all 3,654 split/flip/adventure/prepare printings in the
+/// 2026-08-16 bulk with zero misses: `" // "` between the faces that HAVE a cost, skipping the
+/// ones that do not. Fire // Ice is `"{1}{R} // {1}{U}"`; flipped Erayo, whose back face carries
+/// `"mana_cost": ""`, is `"{1}{U}"` and not `"{1}{U} // "`.
+///
+/// Derived rather than stored because the ingest cannot preserve it: transform_row overlays each
+/// face onto the parent card, so the stored top-level cost is the FRONT face's alone.
+fn joined_mana_cost(faces: &[Value]) -> String {
+    faces
+        .iter()
+        .filter_map(|face| match face {
+            Value::Object(map) => str_of(map, "mana_cost"),
+            _ => None,
+        })
+        .collect::<Vec<_>>()
+        .join(" // ")
+}
+
+/// The card's faces, with the two keys the engine deliberately does not store re-added: `object`
+/// is the constant, and a face's `image_uris` is the card's own CDN function with the face swapped
+/// — on the two-image layouts, which are the only ones whose faces have their own picture.
+fn write_faces(
+    out: &mut Vec<u8>,
+    faces: &[Value],
+    scryfall_id: &str,
+    updated_at: Option<u64>,
+    two_image: bool,
+    // The card's `oracle_id` and `cmc`, to be written on EVERY face -- `Some` only for a
+    // reversible printing, which is the one layout whose faces carry them (and whose top-level
+    // object omits them). Both faces of all 81 send the card's own values, never a second one.
+    card_ids: Option<(&str, Option<&Value>)>,
+) {
+    out.push(b'[');
+    for (index, face) in faces.iter().enumerate() {
+        if index > 0 {
+            out.push(b',');
+        }
+        out.push(b'{');
+        let mut first = true;
+        write_key(out, &mut first, "object");
+        write_json_str(out, "card_face");
+        if let Some((oid, cmc)) = card_ids {
+            write_key(out, &mut first, "oracle_id");
+            write_json_str(out, oid);
+            write_key(out, &mut first, "cmc");
+            match cmc.and_then(serde_json::Value::as_f64) {
+                Some(v) => serde_json::to_writer(&mut *out, &v).expect("number"),
+                None => out.extend_from_slice(b"null"),
+            }
+        }
+        if let Value::Object(map) = face {
+            for (key, value) in map {
+                // `colors` is a face key only where the faces own their own art: every face of
+                // every two-image printing carries one, empty included (Agadeem, the Undercrypt is
+                // colorless and still sends `"colors": []`), and no face of a split, flip,
+                // adventure or prepare printing carries one at all. The engine always writes the
+                // key, so both halves of that are decided here.
+                if key == "colors" {
+                    if two_image {
+                        write_value(out, &mut first, key, value);
+                    }
+                    continue;
+                }
+                // Absent stays absent: null, "" and [] mean Scryfall did not send this face that
+                // key -- EXCEPT for `mana_cost` and `oracle_text`, where "" is a value Scryfall
+                // does send. Every face of every multi-face printing in the corpus carries both
+                // keys (8,620 of 8,620 transform faces, 4,356 of them with an empty cost), so an
+                // empty string there is a costless back face, never an omission.
+                let empty = match value {
+                    Value::Null => true,
+                    Value::String(s) => s.is_empty() && !matches!(key.as_str(), "mana_cost" | "oracle_text"),
+                    Value::Array(a) => a.is_empty(),
+                    _ => false,
+                };
+                if !empty {
+                    write_value(out, &mut first, key, value);
+                }
+            }
+        }
+        if two_image {
+            write_key(out, &mut first, "image_uris");
+            write_image_uris(out, scryfall_id, updated_at, if index == 0 { "front" } else { "back" });
+        }
+        out.push(b'}');
+    }
+    out.push(b']');
+}
+
+// ─── the card object ─────────────────────────────────────────────────────────
+
+/// Write one engine row as a Scryfall card object.
+///
+/// `base_url` is the host self-referencing URIs should address — the deployment's own, not
+/// Scryfall's, so a client following `uri` or `prints_search_uri` stays on this API.
+pub fn write_scryfall_card(out: &mut Vec<u8>, row: &Map<String, Value>, base_url: &str) {
+    let scryfall_id = str_of(row, "scryfall_id").unwrap_or("");
+    let oracle_id = str_of(row, "oracle_id").unwrap_or("");
+    let name = str_of(row, "name").unwrap_or("");
+    let set_code = str_of(row, "set_code").unwrap_or("");
+    let number = str_of(row, "collector_number").unwrap_or("");
+    let set_id = str_of(row, "set_id");
+    let lang = str_of(row, "lang").unwrap_or("en");
+    let image_updated_at = u64_of(row, "image_updated_at");
+    let faces = list_of(row, "card_faces").filter(|f| !f.is_empty());
+    let layout = str_of(row, "layout");
+    // Only ever true for a card that HAS faces: the two-image layouts are all multi-face.
+    let two_image = faces.is_some() && layout.is_some_and(|l| TWO_IMAGE_LAYOUTS.contains(&l));
+    // A REVERSIBLE printing keeps NOTHING of the card at top level -- not even the three keys
+    // every other multi-face layout keeps. Measured across the whole 2026-08-16 all_cards bulk:
+    // all 81 of them omit `oracle_id`, `cmc` and `type_line`, where a `transform` printing sends
+    // all three (verified live on Delver of Secrets // Insectile Aberration). Its FACES carry
+    // their own `oracle_id` and `cmc` instead -- the card's, on both faces, 0 of 81 disagreeing --
+    // which is why omitting the top-level pair loses nothing.
+    let reversible = layout == Some(REVERSIBLE_LAYOUT);
+    // The name a SEARCH LINK spells: the joined one, except on the layouts whose searches take the
+    // front face (see JOINED_SEARCH_LAYOUTS). `related_uris.edhrec` and every `purchase_uris`
+    // fallback take THIS string; the two `tcgplayer_infinite_*` links take the joined `name`.
+    let search_name = if faces.is_some() && !layout.is_some_and(|l| JOINED_SEARCH_LAYOUTS.contains(&l)) {
+        front_face_name(name)
+    } else {
+        name
+    };
+
+    out.push(b'{');
+    let mut first = true;
+
+    write_key(out, &mut first, "object");
+    write_json_str(out, "card");
+    write_key(out, &mut first, "id");
+    write_json_str(out, scryfall_id);
+    if !reversible {
+        write_key(out, &mut first, "oracle_id");
+        write_json_str(out, oracle_id);
+    }
+    write_list(out, &mut first, "multiverse_ids", list_of(row, "multiverse_ids"));
+    write_key(out, &mut first, "name");
+    write_json_str(out, name);
+    // Between `name` and `lang`, where api.scryfall.com puts it (verified on grn/212/pt and
+    // khm/1/ja) — and PRESENT only when the printing carries one, which is why this is
+    // `write_opt_str` mid-object rather than an entry in the optional tail: the tail would put it
+    // after `legalities`, and key position is part of the parity contract here the same way
+    // security_stamp's position was (see the note at the tail).
+    write_key(out, &mut first, "lang");
+    write_json_str(out, lang);
+    write_str_or_null(out, &mut first, "released_at", str_of(row, "released_at"));
+    write_key(out, &mut first, "uri");
+    write_json_str(out, &format!("{base_url}/cards/{scryfall_id}"));
+    write_key(out, &mut first, "scryfall_uri");
+    write_json_str(out, &scryfall_uri(name, set_code, number, lang));
+    write_str_or_null(out, &mut first, "layout", str_of(row, "layout"));
+    write_bool(out, &mut first, "highres_image", bool_of(row, "highres_image"));
+    write_str_or_null(out, &mut first, "image_status", str_of(row, "image_status"));
+    // `cmc` and `type_line` are the two the ordinary multi-face branch keeps and a REVERSIBLE
+    // printing does not — see the note on `reversible` above.
+    if !reversible {
+        write_key(out, &mut first, "cmc");
+        // As a DECIMAL, which is what api.scryfall.com answers with: `"cmc":1.0`, not `"cmc":1`
+        // (see https://api.scryfall.com/cards/named?exact=Lightning+Bolt). Writing the stored
+        // number directly emits `1`, because the engine holds cmc as an integer -- and that would
+        // also put the engine at odds with `toScryfallCard`, which carries the same value as a
+        // decimal. The two must agree byte for byte: tests/routes/card-object-parity.test.ts holds
+        // them to it.
+        //
+        // The PRECISION behind the formatting is now real too: the stored value is an
+        // `Option<f32>` (`opt_f32(d, "cmc")` in lib.rs, `jv_opt_f32` in core_api.rs), so Little
+        // Girl's 0.5 survives the archive and arrives here as 0.5 rather than 0. The corpus still
+        // excludes funny sets -- this is the capability, not a decision to import them.
+        match num_of(row, "cmc").and_then(serde_json::Value::as_f64) {
+            Some(v) => serde_json::to_writer(&mut *out, &v).expect("number"),
+            None => out.extend_from_slice(b"null"),
+        }
+    }
+    if !reversible {
+        write_str_or_null(out, &mut first, "type_line", str_of(row, "type_line"));
+    }
+    // Directly after the oracle `type_line` it translates, per the live objects.
+    // Vanguard's two starting-total deltas, in Scryfall's own key position: measured on the live
+    // object for `Akroma, Angel of Wrath Avatar` (61b07ae0), the order is
+    // `oracle_text -> life_modifier -> hand_modifier -> colors`. Absent on every other layout, and
+    // `write_opt_str` is what keeps the key out rather than writing null — all 119 printings that
+    // carry them are `vanguard`, and all 119 carry BOTH.
+    // `colors` is one of the values a two-image layout keeps on its faces alone (see
+    // TWO_IMAGE_LAYOUTS); `color_identity` is the card's and stays at top level on every layout.
+    if !two_image {
+        write_list(out, &mut first, "colors", list_of(row, "colors"));
+    }
+    write_list(out, &mut first, "color_identity", list_of(row, "color_identity"));
+    write_list(out, &mut first, "keywords", list_of(row, "card_keywords"));
+    write_list(out, &mut first, "games", list_of(row, "games"));
+    // `reserved` is a tag rather than a column: the reserved list is a property of the card, and
+    // the engine stores it in the same is-tag set everything else uses.
+    let reserved = list_of(row, "card_is_tags")
+        .is_some_and(|tags| tags.iter().any(|t| t.as_str() == Some("reserved")));
+    write_bool(out, &mut first, "reserved", reserved);
+    write_list(out, &mut first, "finishes", list_of(row, "finishes"));
+    write_bool(out, &mut first, "oversized", bool_of(row, "oversized"));
+    write_bool(out, &mut first, "promo", bool_of(row, "promo"));
+    write_bool(out, &mut first, "reprint", bool_of(row, "reprint"));
+    write_bool(out, &mut first, "variation", bool_of(row, "variation"));
+    write_str_or_null(out, &mut first, "set_id", set_id);
+    write_key(out, &mut first, "set");
+    write_json_str(out, set_code);
+    write_str_or_null(out, &mut first, "set_name", str_of(row, "set_name"));
+    write_str_or_null(out, &mut first, "set_type", str_of(row, "set_type"));
+    write_key(out, &mut first, "set_uri");
+    match set_id {
+        Some(id) => write_json_str(out, &format!("{base_url}/sets/{id}")),
+        None => out.extend_from_slice(b"null"),
+    }
+    write_key(out, &mut first, "set_search_uri");
+    write_json_str(out, &format!("{base_url}/cards/search?order=set&q=e%3A{set_code}&unique=prints"));
+    write_key(out, &mut first, "scryfall_set_uri");
+    write_json_str(out, &format!("https://scryfall.com/sets/{set_code}?utm_source=api"));
+    write_key(out, &mut first, "rulings_uri");
+    write_json_str(out, &format!("{base_url}/cards/{scryfall_id}/rulings"));
+    write_key(out, &mut first, "prints_search_uri");
+    write_json_str(
+        out,
+        &format!("{base_url}/cards/search?order=released&q=oracleid%3A{oracle_id}&unique=prints"),
+    );
+    write_key(out, &mut first, "collector_number");
+    write_json_str(out, number);
+    write_bool(out, &mut first, "digital", bool_of(row, "digital"));
+    write_str_or_null(out, &mut first, "rarity", str_of(row, "rarity"));
+    // No shared card back on a two-image layout, and no card-level illustration: both belong to a
+    // face there, and Scryfall omits the top-level keys entirely.
+    if !two_image {
+        write_key(out, &mut first, "card_back_id");
+        write_json_str(out, CARD_BACK_ID);
+    }
+    write_str_or_null(out, &mut first, "artist", present_str_of(row, "artist"));
+    if !two_image {
+        write_str_or_null(out, &mut first, "illustration_id", str_of(row, "illustration_id"));
+    }
+    write_str_or_null(out, &mut first, "border_color", str_of(row, "border_color"));
+    write_bool(out, &mut first, "full_art", bool_of(row, "full_art"));
+    write_bool(out, &mut first, "textless", bool_of(row, "textless"));
+    write_bool(out, &mut first, "booster", bool_of(row, "booster"));
+    write_bool(out, &mut first, "story_spotlight", bool_of(row, "story_spotlight"));
+    write_key(out, &mut first, "prices");
+    write_prices(out, row);
+    write_key(out, &mut first, "related_uris");
+    let multiverse_first = list_of(row, "multiverse_ids").and_then(|ids| ids.first()).and_then(Value::as_u64);
+    write_related_uris(out, name, search_name, multiverse_first, lang);
+    // A printing NO MARKETPLACE SELLS omits the key rather than carrying three dead links, and
+    // the rule is the marketplaces rather than `digital` — measured 2026-08-16: prm/80925
+    // (games ["mtgo"], digital true) HAS purchase_uris, ymid/59 and khm/A-198 (games ["arena"],
+    // digital true) do not. tcgplayer and cardmarket sell cardboard, cardhoarder sells MTGO, and
+    // nothing sells Arena.
+    // An ABSENT or empty `games` emits: the omission is a positive statement ("this printing is
+    // sold nowhere"), and a row that never carried the column has made no such statement.
+    let sold = list_of(row, "games").is_none_or(|gs| {
+        gs.is_empty() || gs.iter().any(|g| matches!(g.as_str(), Some("paper") | Some("mtgo")))
+    });
+    if sold {
+        write_key(out, &mut first, "purchase_uris");
+        write_purchase_uris(out, row, search_name);
+    }
+
+    // A multi-face card carries its faces and NOT the top-level ORACLE TEXT they replace; a
+    // single-faced one carries the text and no `card_faces`. Which keys sit at top level varies by
+    // LAYOUT, which is why this is a branch rather than a fixed key set.
+    //
+    // `mana_cost` and `image_uris` are the two the multi-face branch keeps, on the one-image
+    // layouts only: one piece of cardboard has one picture and one printed cost, so Scryfall sends
+    // both at top level for split/flip/adventure/prepare — and neither for transform/modal_dfc,
+    // where each face has its own.
+    if let Some(faces) = faces {
+        write_key(out, &mut first, "card_faces");
+        write_faces(out, faces, scryfall_id, image_updated_at, two_image, reversible.then_some((oracle_id, num_of(row, "cmc"))));
+        if !two_image {
+            write_key(out, &mut first, "mana_cost");
+            write_json_str(out, &joined_mana_cost(faces));
+            write_key(out, &mut first, "image_uris");
+            write_image_uris(out, scryfall_id, image_updated_at, "front");
+        }
+    } else {
+        // An empty string is a VALUE for both of these — every basic land carries
+        // `"mana_cost": ""` and 7,266 printings carry `"oracle_text": ""` — so they read through
+        // `present_str_of` rather than the empty-is-absent `str_of`.
+        write_str_or_null(out, &mut first, "mana_cost", present_str_of(row, "mana_cost"));
+        write_str_or_null(out, &mut first, "oracle_text", present_str_of(row, "oracle_text"));
+        // Directly after the `oracle_text` it translates — single-face only, like the text it
+        // shadows; a multi-face printing's printed text rides its face objects.
+        write_key(out, &mut first, "image_uris");
+        write_image_uris(out, scryfall_id, image_updated_at, "front");
+    }
+
+    // Keys Scryfall sends only when the card HAS them. Emitting null instead would differ from
+    // Scryfall on every card that lacks them, which for most of these is most cards.
+    for (key, value) in [
+        ("power", str_of(row, "power")),
+        ("toughness", str_of(row, "toughness")),
+        // Beside the creature stats it is the planeswalker analogue of, as the PRINTED string --
+        // the `planeswalker_loyalty` the planner filters on is a u8 and loses "X" and "1+*".
+        ("loyalty", str_of(row, "loyalty")),
+        ("flavor_text", str_of(row, "flavor_text")),
+        ("watermark", str_of(row, "watermark")),
+        ("frame", str_of(row, "frame")),
+    ] {
+        // Four of these six belong to a face on a two-image layout; `frame` is the printing's and
+        // stays. See is_face_owned_key.
+        if two_image && is_face_owned_key(key) {
+            continue;
+        }
+        if let Some(v) = value {
+            write_key(out, &mut first, key);
+            write_json_str(out, v);
+        }
+    }
+    for key in [
+        "edhrec_rank",
+        "penny_rank",
+        "arena_id",
+        "mtgo_id",
+        "mtgo_foil_id",
+        "tcgplayer_id",
+        "tcgplayer_etched_id",
+        "cardmarket_id",
+    ] {
+        if let Some(v) = num_of(row, key) {
+            write_value(out, &mut first, key, v);
+        }
+    }
+    // After the ids, matching upstream's dict literal. The port's TypeScript had it up with the
+    // other strings; upstream is the reference for a port, so the port moved rather than this.
+    if let Some(v) = str_of(row, "security_stamp") {
+        write_key(out, &mut first, "security_stamp");
+        write_json_str(out, v);
+    }
+    // `produced_mana` joins them: the engine has always stored the mana a card can make (the
+    // `produces:` filter reads the same byte) and no card object ever carried it, so every land
+    // this port served was missing a key Scryfall sends. On a modal DFC it is the union over the
+    // faces, which is what the store already holds.
+    for key in ["promo_types", "frame_effects", "all_parts"] {
+        // `color_indicator` is the one of these five that belongs to a face on a two-image layout.
+        if two_image && is_face_owned_key(key) {
+            continue;
+        }
+        if let Some(a) = list_of(row, key).filter(|a| !a.is_empty()) {
+            write_value(out, &mut first, key, &Value::Array(a.clone()));
+        }
+    }
+    if let Some(v) = row.get("legalities").filter(|v| !v.is_null()) {
+        write_value(out, &mut first, "legalities", v);
+    }
+
+    out.push(b'}');
+}
+
+/// A page of rows as a JSON array of card objects, written straight into `out`.
+pub fn write_scryfall_cards(out: &mut Vec<u8>, rows: &[Value], base_url: &str) {
+    out.push(b'[');
+    for (index, row) in rows.iter().enumerate() {
+        if index > 0 {
+            out.push(b',');
+        }
+        match row {
+            Value::Object(map) => write_scryfall_card(out, map, base_url),
+            // Unreachable: the query path only ever produces objects. Emitting the row verbatim
+            // rather than panicking keeps a malformed row from taking down a whole page.
+            other => serde_json::to_writer(&mut *out, other).expect("writing a Value cannot fail"),
+        }
+    }
+    out.push(b']');
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    fn build(row: serde_json::Value) -> serde_json::Value {
+        let serde_json::Value::Object(map) = row else { panic!("row must be an object") };
+        let mut out = Vec::new();
+        write_scryfall_card(&mut out, &map, "https://api.example/v1");
+        serde_json::from_slice(&out).expect("the writer must emit valid JSON")
+    }
+
+    /// A planeswalker's printed loyalty reaches the card object, as the STRING Scryfall prints.
+    ///
+    /// The engine holds `planeswalker_loyalty` as a `u8` for `loy:` to filter on, which is why the
+    /// text is its own field: "X" (Nissa, Steward of Elements) does not fit in the number at all,
+    /// so deriving the key from it would silently drop those cards' loyalty.
+    #[test]
+    fn a_planeswalkers_printed_loyalty_is_the_string() {
+        let card = build(json!({
+            "name": "Jace Beleren",
+            "scryfall_id": "ab000000-0000-0000-0000-000000000002",
+            "loyalty": "3",
+        }));
+        assert_eq!(card["loyalty"], "3");
+
+        let x = build(json!({
+            "name": "Nissa, Steward of Elements",
+            "scryfall_id": "ab000000-0000-0000-0000-000000000003",
+            "loyalty": "X",
+        }));
+        assert_eq!(x["loyalty"], "X", "a non-numeric loyalty survives verbatim");
+    }
+
+    /// A FACED printing emits its watermark on the faces and NOWHERE else.
+    ///
+    /// Measured over the whole 2026-08-16 all_cards bulk: api.scryfall.com sends a top-level
+    /// `watermark` on 36,437 printings and on 0 of the 12,098 that have `card_faces`. This port
+    /// sent one on all 156 faced printings that carry a face watermark, because the builder's face
+    /// overlay copies face 0's value into `card_watermark` and the only gate on the key was the
+    /// TWO-IMAGE one — which `split`, `flip`, `adventure` and `prepare` never trip. One piece of
+    #[test]
+    fn optional_keys_are_omitted_rather_than_nulled() {
+        let card = build(json!({"name": "Llanowar Elves", "scryfall_id": "ab000000-0000-0000-0000-000000000001"}));
+        for absent in
+            ["power", "toughness", "loyalty", "flavor_text", "watermark", "frame", "security_stamp", "legalities"]
+        {
+            assert!(card.get(absent).is_none(), "{absent} should be omitted when the row has none");
+        }
+        // ... while the keys Scryfall always sends are present, even when empty.
+        assert_eq!(card["object"], "card");
+        assert_eq!(card["colors"], json!([]));
+        assert_eq!(card["set_uri"], serde_json::Value::Null);
+        assert_eq!(card["card_back_id"], CARD_BACK_ID);
+    }
+
+    /// A single-faced card carries the text and image_uris; a multi-faced one carries the faces,
+    /// and WHERE the picture lives is the layout's answer, not the face count's.
+    #[test]
+    fn faces_replace_the_top_level_text_they_stand_in_for() {
+        let base = json!({
+            "name": "Delver of Secrets // Insectile Aberration",
+            "scryfall_id": "cd000000-0000-0000-0000-000000000002",
+            "layout": "normal", "mana_cost": "{U}", "oracle_text": "top level",
+        });
+
+        let single = build(base.clone());
+        assert_eq!(single["mana_cost"], "{U}");
+        assert!(single.get("card_faces").is_none());
+        assert!(single["image_uris"]["small"].as_str().unwrap().contains("/front/"));
+
+        // A TWO-IMAGE layout: each face owns its picture, and the card carries neither the
+        // picture nor the values that ride with it.
+        let mut two = base.clone();
+        two["layout"] = json!("transform");
+        two["colors"] = json!(["U"]);
+        two["power"] = json!("1");
+        two["illustration_id"] = json!("cd000000-0000-0000-0000-0000000000ff");
+        two["card_faces"] = json!([
+            {"name": "Delver of Secrets", "mana_cost": "{U}", "colors": ["U"]},
+            {"name": "Insectile Aberration", "mana_cost": "", "colors": [], "watermark": ""},
+        ]);
+        let card = build(two);
+        assert!(card.get("mana_cost").is_none(), "a two-image card has no top-level mana_cost");
+        assert!(card.get("image_uris").is_none(), "...and no top-level image_uris");
+        for hoisted in ["colors", "power", "illustration_id", "card_back_id"] {
+            assert!(card.get(hoisted).is_none(), "{hoisted} belongs to a face on a transform");
+        }
+        let faces = card["card_faces"].as_array().expect("faces");
+        assert_eq!(faces[0]["object"], "card_face");
+        assert!(faces[0]["image_uris"]["png"].as_str().unwrap().contains("/front/"));
+        assert!(faces[1]["image_uris"]["png"].as_str().unwrap().contains("/back/"));
+        // An empty mana cost is a VALUE on a costless back face, and an empty face colour list is
+        // one too — Scryfall sends `"mana_cost": ""` and `"colors": []` on both. An empty
+        // watermark is still an absence.
+        assert_eq!(faces[1]["mana_cost"], "");
+        assert_eq!(faces[1]["colors"], json!([]));
+        assert!(faces[1].get("watermark").is_none());
+
+        // A ONE-IMAGE multi-face layout: one picture, one joined cost, both at top level — and
+        // the faces carry no picture and no colours at all.
+        let mut split = base.clone();
+        split["layout"] = json!("split");
+        split["name"] = json!("Fire // Ice");
+        split["colors"] = json!(["R", "U"]);
+        split["card_faces"] = json!([
+            {"name": "Fire", "mana_cost": "{1}{R}", "colors": []},
+            {"name": "Ice", "mana_cost": "{1}{U}", "colors": []},
+        ]);
+        let card = build(split);
+        assert_eq!(card["mana_cost"], "{1}{R} // {1}{U}", "the faces' costs, joined");
+        assert!(card["image_uris"]["png"].as_str().unwrap().contains("/front/"));
+        assert_eq!(card["colors"], json!(["R", "U"]));
+        assert_eq!(card["card_back_id"], CARD_BACK_ID);
+        let faces = card["card_faces"].as_array().expect("faces");
+        assert!(faces[0].get("image_uris").is_none(), "a split's faces have no picture of their own");
+        assert!(faces[1].get("image_uris").is_none());
+        assert!(faces[0].get("colors").is_none(), "...and no colours of their own");
+    }
+
+    /// All ELEVEN sizes, in Scryfall's order, with the webp five spelled out.
+    ///
+    /// A key-SET test, not a URL-shape one: the six-key version of this table was wrong on every
+    /// card object for as long as it shipped, and neither parity harness could see it because both
+    /// reduce `image_uris` before comparing. Pinned to the bytes, so a size added in the middle of
+    /// the table fails here rather than reordering every card object silently.
+    #[test]
+    fn image_uris_carries_scryfalls_eleven_sizes_in_scryfalls_order() {
+        const EXPECTED: [(&str, &str); 11] = [
+            ("small", "jpg"),
+            ("normal", "jpg"),
+            ("large", "jpg"),
+            ("png", "png"),
+            ("art_crop", "jpg"),
+            ("border_crop", "jpg"),
+            ("thumb", "webp"),
+            ("grid", "webp"),
+            ("display", "webp"),
+            ("art", "webp"),
+            ("crop", "webp"),
+        ];
+        let id = "cd000000-0000-0000-0000-000000000002";
+        let expected = |face: &str, suffix: &str| {
+            let body = EXPECTED
+                .iter()
+                .map(|(size, ext)| {
+                    format!(r#""{size}":"https://cards.scryfall.io/{size}/{face}/c/d/{id}.{ext}{suffix}""#)
+                })
+                .collect::<Vec<_>>()
+                .join(",");
+            format!("{{{body}}}")
+        };
+
+        // Single-faced, with the cache-buster the row's image_updated_at supplies.
+        let mut out = Vec::new();
+        write_image_uris(&mut out, id, Some(1_783_903_008), "front");
+        assert_eq!(String::from_utf8(out).expect("utf-8"), expected("front", "?1783903008"));
+
+        // Per-face, back half, no cache-buster — the same eleven keys either way.
+        let mut out = Vec::new();
+        write_image_uris(&mut out, id, None, "back");
+        assert_eq!(String::from_utf8(out).expect("utf-8"), expected("back", ""));
+    }
+
+    /// The joined top-level cost skips a face that has none, which is how a flip card reads.
+    #[test]
+    fn a_flipped_back_face_does_not_leave_a_dangling_separator() {
+        let card = build(json!({
+            "name": "Erayo, Soratami Ascendant // Erayo's Essence",
+            "scryfall_id": "cd000000-0000-0000-0000-000000000003",
+            "layout": "flip",
+            "card_faces": [
+                {"name": "Erayo, Soratami Ascendant", "mana_cost": "{1}{U}"},
+                {"name": "Erayo's Essence", "mana_cost": ""},
+            ],
+        }));
+        assert_eq!(card["mana_cost"], "{1}{U}");
+        assert_eq!(card["card_faces"][1]["mana_cost"], "", "the face still reports its empty cost");
+    }
+
+    /// EDHREC files most multi-face cards under the FRONT face and split-likes under both halves.
+    /// The tcgplayer searches beside it keep the joined name on every layout.
+    #[test]
+    fn edhrec_uses_the_front_face_name_except_on_the_split_like_layouts() {
+        let front = |layout: &str| {
+            let card = build(json!({
+                "name": "Delver of Secrets // Insectile Aberration",
+                "scryfall_id": "cd000000-0000-0000-0000-000000000004",
+                "layout": layout,
+                "card_faces": [{"name": "Delver of Secrets"}, {"name": "Insectile Aberration"}],
+            }));
+            card["related_uris"]["edhrec"].as_str().unwrap().to_owned()
+        };
+        for layout in ["transform", "modal_dfc", "flip", "adventure", "prepare", "art_series"] {
+            assert_eq!(front(layout), "https://edhrec.com/route/?cc=Delver+of+Secrets", "{layout}");
+        }
+        for layout in ["split", "reversible_card", "double_faced_token"] {
+            assert_eq!(
+                front(layout),
+                "https://edhrec.com/route/?cc=Delver+of+Secrets+%2F%2F+Insectile+Aberration",
+                "{layout}"
+            );
+        }
+        // The joined name on both tcgplayer searches, split included.
+        let card = build(json!({
+            "name": "Fire // Ice", "scryfall_id": "cd000000-0000-0000-0000-000000000005",
+            "layout": "split", "card_faces": [{"name": "Fire"}, {"name": "Ice"}],
+        }));
+        assert_eq!(
+            card["related_uris"]["tcgplayer_infinite_decks"],
+            "https://www.tcgplayer.com/search/decks?productLineName=magic&q=Fire+%2F%2F+Ice"
+        );
+    }
+
+    /// Prices format to two decimals; a missing price is null rather than "0.00", and zero is a
+    /// price like any other.
+    #[test]
+    fn prices_are_two_decimals_or_null() {
+        let card = build(json!({"name": "x", "scryfall_id": "ef000000-0000-0000-0000-000000000003",
+            "price_usd": 1, "price_eur": 0.005, "price_tix": 0}));
+        assert_eq!(card["prices"]["usd"], "1.00");
+        assert_eq!(card["prices"]["eur"], "0.01");
+        assert_eq!(card["prices"]["tix"], "0.00");
+        assert_eq!(card["prices"]["usd_foil"], serde_json::Value::Null);
+    }
+
+    /// The slug and quote_plus paths, which are where a reimplementation drifts. Every slug
+    /// expectation here is a live production byte string (see the rule note on `slug`).
+    #[test]
+    fn slug_and_quote_plus_match_their_live_originals() {
+        assert_eq!(slug("Lightning Bolt"), "lightning-bolt");
+        assert_eq!(slug("Fire // Ice"), "fire-ice", "slashes are deleted, the space run is one hyphen");
+        // Apostrophes are DELETED, not hyphenated: sok/35 serves
+        // `erayo-soratami-ascendant-erayos-essence`.
+        assert_eq!(
+            slug("Erayo, Soratami Ascendant // Erayo's Essence"),
+            "erayo-soratami-ascendant-erayos-essence"
+        );
+        // Non-ASCII output is UTF-8 percent-encoded: cmd/16 serves `j%C3%B6tun-grunt`.
+        assert_eq!(slug("Jötun Grunt"), "j%C3%B6tun-grunt");
+        assert_eq!(slug("Æther Vial"), "%C3%A6ther-vial");
+        // Deleted set beyond the apostrophe: periods and straight/curly double quotes.
+        assert_eq!(slug("S.H.I.E.L.D. Flying Car"), "shield-flying-car");
+        assert_eq!(slug("Henzie \"Toolbox\" Torre"), "henzie-toolbox-torre");
+        // Kept set: colon and bang survive (msc's Summon cards, acorn names), and literal hyphens
+        // stack with space-hyphens rather than collapsing (dis/61's ru printed name keeps `---`).
+        assert_eq!(slug("Summon: Choco/Mog"), "summon:-chocomog");
+        assert_eq!(slug("Пламенник - военный разведчик"), "%D0%BF%D0%BB%D0%B0%D0%BC%D0%B5%D0%BD%D0%BD%D0%B8%D0%BA---%D0%B2%D0%BE%D0%B5%D0%BD%D0%BD%D1%8B%D0%B9-%D1%80%D0%B0%D0%B7%D0%B2%D0%B5%D0%B4%D1%87%D0%B8%D0%BA");
+        // Nothing is trimmed: unfinity's "Humming-" ends in its hyphen on production.
+        assert_eq!(slug("Humming-"), "humming-");
+
+        assert_eq!(quote_plus("Lightning Bolt"), "Lightning+Bolt");
+        assert_eq!(quote_plus("Æther Vial"), "%C3%86ther+Vial");
+        assert_eq!(quote_plus("Fire // Ice"), "Fire+%2F%2F+Ice");
+        // The safe set is the thing that has to match: `~` is left alone, `!*'()` are not.
+        assert_eq!(quote_plus("a~b"), "a~b");
+        assert_eq!(quote_plus("Yawgmoth's (Alt!)*"), "Yawgmoth%27s+%28Alt%21%29%2A");
+    }
+
+    /// A foreign printing takes the language segment in its scryfall_uri path, and only the ten
+    /// print localizations get one — a `ph` printing stays on the English form. Pinned to live
+    /// objects (grn/212/pt and one/414/ph, cached 2026-08-16).
+    ///
+    /// Scryfall also writes a `slug(printed name)-(slug(english name))` path where the printing
+    /// HAS a printed name; that needs the printed name in the archive, which this branch does not
+    /// store, so the English slug is the documented fallback until it does.
+    #[test]
+    fn a_foreign_printing_takes_the_language_path_segment() {
+        let pt = build(json!({
+            "name": "Unmoored Ego", "scryfall_id": "87130bc6-3a34-4855-9dd6-10607983bb29",
+            "set_code": "grn", "collector_number": "212", "lang": "pt",
+        }));
+        assert_eq!(
+            pt["scryfall_uri"],
+            "https://scryfall.com/card/grn/212/pt/unmoored-ego?utm_source=api"
+        );
+
+        // A glyph language gets NO segment: ph Elesh Norn lives at the English form.
+        let ph = build(json!({
+            "name": "Elesh Norn, Mother of Machines", "scryfall_id": "87130bc6-3a34-4855-9dd6-10607983bb2a",
+            "set_code": "one", "collector_number": "414", "lang": "ph",
+        }));
+        assert_eq!(
+            ph["scryfall_uri"],
+            "https://scryfall.com/card/one/414/elesh-norn-mother-of-machines?utm_source=api"
+        );
+
+        // ...and English itself is unsegmented.
+        let en = build(json!({
+            "name": "Unmoored Ego", "scryfall_id": "87130bc6-3a34-4855-9dd6-10607983bb2b",
+            "set_code": "grn", "collector_number": "212", "lang": "en",
+        }));
+        assert_eq!(
+            en["scryfall_uri"],
+            "https://scryfall.com/card/grn/212/unmoored-ego?utm_source=api"
+        );
+    }
+
+    #[test]
+    fn gatherer_rides_the_first_multiverse_id() {
+        let with_ids = build(json!({"name": "Jötun Grunt", "scryfall_id": "ab000000-0000-0000-0000-000000000007",
+            "multiverse_ids": [247182, 999999]}));
+        assert_eq!(
+            with_ids["related_uris"]["gatherer"],
+            "https://gatherer.wizards.com/Pages/Card/Details.aspx?multiverseid=247182&printed=false"
+        );
+
+        let without = build(json!({"name": "x", "scryfall_id": "ab000000-0000-0000-0000-000000000007"}));
+        assert!(without["related_uris"].get("gatherer").is_none());
+    }
+
+    /// `purchase_uris` always carries all three marketplaces: a product link where the printing
+    /// has that id, a NAME SEARCH where it does not (verified live — the fallback is per KEY, not
+    /// per card: khm English printings with tcgplayer+cardmarket ids and no mtgo id get two
+    /// product links and a cardhoarder search). A zero id is not an id.
+    #[test]
+    fn purchase_uris_fall_back_to_a_name_search_per_missing_id() {
+        let search = json!({
+            "tcgplayer": "https://www.tcgplayer.com/search/magic/product?productLineName=magic&q=Jötun+Grunt&view=grid",
+            "cardmarket": "https://www.cardmarket.com/en/Magic/Products/Search?searchString=Jötun+Grunt",
+            "cardhoarder": "https://www.cardhoarder.com/cards?data%5Bsearch%5D=Jötun+Grunt",
+        });
+        // quote_plus percent-encodes the umlaut; the literals above are compared after that.
+        let expect_search = json!({
+            "tcgplayer": search["tcgplayer"].as_str().unwrap().replace('ö', "%C3%B6"),
+            "cardmarket": search["cardmarket"].as_str().unwrap().replace('ö', "%C3%B6"),
+            "cardhoarder": search["cardhoarder"].as_str().unwrap().replace('ö', "%C3%B6"),
+        });
+        let none = build(json!({"name": "Jötun Grunt", "scryfall_id": "01000000-0000-0000-0000-000000000004"}));
+        assert_eq!(none["purchase_uris"], expect_search);
+
+        let zero = build(json!({"name": "Jötun Grunt", "scryfall_id": "01000000-0000-0000-0000-000000000004",
+            "tcgplayer_id": 0, "mtgo_id": 0, "cardmarket_id": 0}));
+        assert_eq!(zero["purchase_uris"], expect_search, "a zero id is not an id");
+
+        let some = build(json!({"name": "x", "scryfall_id": "01000000-0000-0000-0000-000000000004",
+            "tcgplayer_id": 42, "mtgo_id": 7}));
+        assert_eq!(some["purchase_uris"]["tcgplayer"], "https://www.tcgplayer.com/product/42?page=1");
+        assert_eq!(some["purchase_uris"]["cardhoarder"], "https://www.cardhoarder.com/cards/7");
+        assert_eq!(
+            some["purchase_uris"]["cardmarket"],
+            "https://www.cardmarket.com/en/Magic/Products/Search?searchString=x",
+            "the one missing id takes the search form, the two present ones do not"
+        );
+    }
+
+    /// A marketplace search takes the SAME string `related_uris.edhrec` does: the FRONT face on a
+    /// transforming card, the JOINED name on the three JOINED_SEARCH_LAYOUTS. `related_uris`'
+    /// tcgplayer_infinite_* links are the exception and keep the joined name on every layout.
+    ///
+    /// The front half is verified live on mom/230/es. The joined half on api.scryfall.com
+    /// 2026-08-31, over `unique=prints`, on printings whose marketplace ids are missing so the
+    /// SEARCH form is the one emitted: `Snake // Zombie` (cc2/9, double_faced_token) searches
+    /// tcgplayer, cardmarket and cardhoarder for `Snake // Zombie`; `Bind // Liberate` (cmb2/88,
+    /// split) and `Mechtitan // Mechtitan` (sld/1969, reversible_card) do the same with theirs,
+    /// where `Champions of Archery // Join the Group` (ph19/4, adventure) and
+    /// `Curse of the Fire Penguin // …` (unh/73, flip) search for their front faces.
+    ///
+    /// The fixtures carry `card_faces` AND a `layout` on purpose: `search_name` reads a row with
+    /// no faces as single-faced and hands back the whole `name`, so a faceless fixture would pass
+    /// the joined assertions while testing nothing.
+    #[test]
+    fn purchase_uris_search_splits_by_layout_the_way_edhrec_does() {
+        // A FRONT-FACE layout. This is the assertion that used to hold for every layout, because
+        // `write_purchase_uris` cut the front face off whatever it was handed.
+        let transform = build(json!({"name": "Invasion of Alara // Awaken the Maelstrom",
+            "scryfall_id": "01000000-0000-0000-0000-000000000004", "layout": "transform",
+            "card_faces": [{"name": "Invasion of Alara"}, {"name": "Awaken the Maelstrom"}]}));
+        assert_eq!(
+            transform["purchase_uris"]["tcgplayer"],
+            "https://www.tcgplayer.com/search/magic/product?productLineName=magic&q=Invasion+of+Alara&view=grid"
+        );
+        assert_eq!(
+            transform["related_uris"]["tcgplayer_infinite_articles"],
+            "https://www.tcgplayer.com/search/articles?productLineName=magic&q=Invasion+of+Alara+%2F%2F+Awaken+the+Maelstrom"
+        );
+
+        // A JOINED-SEARCH layout: all three marketplaces spell the whole name, and so does edhrec,
+        // while tcgplayer_infinite_* spells it too — for the other reason, on every layout.
+        let token = build(json!({"name": "Snake // Zombie",
+            "scryfall_id": "01000000-0000-0000-0000-000000000005", "layout": "double_faced_token",
+            "card_faces": [{"name": "Snake"}, {"name": "Zombie"}]}));
+        let uris = &token["purchase_uris"];
+        assert_eq!(
+            uris["tcgplayer"],
+            "https://www.tcgplayer.com/search/magic/product?productLineName=magic&q=Snake+%2F%2F+Zombie&view=grid"
+        );
+        assert_eq!(uris["cardmarket"], "https://www.cardmarket.com/en/Magic/Products/Search?searchString=Snake+%2F%2F+Zombie");
+        assert_eq!(uris["cardhoarder"], "https://www.cardhoarder.com/cards?data%5Bsearch%5D=Snake+%2F%2F+Zombie");
+        assert_eq!(token["related_uris"]["edhrec"], "https://edhrec.com/route/?cc=Snake+%2F%2F+Zombie");
+
+        // The five-part split whose collection identifier this branch's name work made resolvable:
+        // und/75's cardhoarder link searched for `Who`, where Scryfall searches the whole string.
+        let five = build(json!({"name": "Who // What // When // Where // Why",
+            "scryfall_id": "01000000-0000-0000-0000-000000000006", "layout": "split",
+            "card_faces": [{"name": "Who"}, {"name": "What"}, {"name": "When"}, {"name": "Where"}, {"name": "Why"}]}));
+        assert_eq!(
+            five["purchase_uris"]["cardhoarder"],
+            "https://www.cardhoarder.com/cards?data%5Bsearch%5D=Who+%2F%2F+What+%2F%2F+When+%2F%2F+Where+%2F%2F+Why"
+        );
+
+        // A single-faced card is unaffected either way, which is the overwhelming majority.
+        let plain = build(json!({"name": "Lightning Bolt", "scryfall_id": "01000000-0000-0000-0000-000000000007"}));
+        assert_eq!(
+            plain["purchase_uris"]["cardhoarder"],
+            "https://www.cardhoarder.com/cards?data%5Bsearch%5D=Lightning+Bolt"
+        );
+    }
+
+    /// `reserved` is a tag, not a column — the reserved list is a property of the card and the
+    /// engine stores it in the same is-tag set as everything else.
+    #[test]
+    fn reserved_comes_from_the_is_tag_set() {
+        let plain = build(json!({"name": "x", "scryfall_id": "01000000-0000-0000-0000-000000000005"}));
+        assert_eq!(plain["reserved"], false);
+        let listed = build(json!({"name": "x", "scryfall_id": "01000000-0000-0000-0000-000000000005",
+            "card_is_tags": ["reprint", "reserved"]}));
+        assert_eq!(listed["reserved"], true);
+    }
+
+    /// The written bytes are key-ORDERED, which a `Value` round trip cannot show: parsing sorts
+    /// them. Asserted against the encoded text, since that is what a client receives.
+    #[test]
+    fn keys_are_written_in_order_not_sorted() {
+        let serde_json::Value::Object(map) = json!({
+            "name": "Llanowar Elves", "scryfall_id": "01000000-0000-0000-0000-000000000006",
+            "security_stamp": "oval", "cardmarket_id": 9, "watermark": "set",
+        }) else {
+            panic!()
+        };
+        let mut out = Vec::new();
+        write_scryfall_card(&mut out, &map, "https://api.example/v1");
+        let text = String::from_utf8(out).expect("utf-8");
+
+        assert!(text.starts_with(r#"{"object":"card","id":"#), "object and id lead: {}", &text[..40]);
+        let at = |needle: &str| text.find(needle).unwrap_or_else(|| panic!("{needle} missing"));
+        // `name` before `prices` before the optional tail, and `security_stamp` AFTER the ids —
+        // upstream's order, which alphabetical sorting would not produce for any of these.
+        assert!(at(r#""name":"#) < at(r#""prices":"#));
+        assert!(at(r#""prices":"#) < at(r#""watermark":"#));
+        assert!(at(r#""watermark":"#) < at(r#""cardmarket_id":"#));
+        assert!(at(r#""cardmarket_id":"#) < at(r#""security_stamp":"#));
+    }
+    #[test]
+    fn cmc_is_written_as_a_decimal() {
+        // api.scryfall.com answers `"cmc":1.0`, not `"cmc":1` -- the field is decimal because
+        // fractional mana values are real (Little Girl costs {HW} and answers `"cmc":0.5`). The
+        // stored value arrives as an INTEGER, because `magic.cards.cmc` is an integer column, and
+        // writing it straight through is what produced `1`.
+        let serde_json::Value::Object(map) = json!({
+            "name": "Lightning Bolt", "scryfall_id": "01000000-0000-0000-0000-000000000007", "cmc": 1,
+        }) else {
+            panic!()
+        };
+        let mut out = Vec::new();
+        write_scryfall_card(&mut out, &map, "https://api.example/v1");
+        let text = String::from_utf8(out).expect("utf-8");
+        assert!(text.contains(r#""cmc":1.0"#), "cmc must be decimal: {text}");
+
+        // And a card with no mana value at all still says so.
+        let serde_json::Value::Object(none) = json!({
+            "name": "Ancestral Vision", "scryfall_id": "01000000-0000-0000-0000-000000000008",
+        }) else {
+            panic!()
+        };
+        let mut out = Vec::new();
+        write_scryfall_card(&mut out, &none, "https://api.example/v1");
+        assert!(String::from_utf8(out).expect("utf-8").contains(r#""cmc":null"#));
+    }
+
+    /// The SAME cases `api/scryfall_compat/objects.py` asserts, from the same file.
+    ///
+    /// Two implementations build this object — this one for the engine path, `objects.py` for the
+    /// SQL path — and both answer `/cards/*`, so a difference between them is one a client can
+    /// see. Nothing else compares them: the Rust suite and the Python suite are separate CI jobs
+    /// that never meet. A shared fixture is what makes each job fail on its own drift.
+    ///
+    /// Values and key PRESENCE, not key order: both sides are compared as parsed objects. The wire
+    /// order is pinned by the position assertions elsewhere in this module.
+    #[test]
+    fn the_card_object_matches_the_python_builder_case_for_case() {
+        const FIXTURE: &str =
+            include_str!("../../api/scryfall_compat/fixtures/card_object_parity.json");
+        let doc: serde_json::Value = serde_json::from_str(FIXTURE).expect("fixture must be JSON");
+        let base_url = doc["base_url"].as_str().expect("base_url");
+        let cases = doc["cases"].as_array().expect("cases must be an array");
+        assert!(!cases.is_empty(), "fixture must carry cases");
+
+        for case in cases {
+            let name = case["case"].as_str().unwrap_or("<unnamed>");
+            let serde_json::Value::Object(row) = case["row"].clone() else {
+                panic!("{name}: row must be an object")
+            };
+            let mut out = Vec::new();
+            write_scryfall_card(&mut out, &row, base_url);
+            let got: serde_json::Value =
+                serde_json::from_slice(&out).expect("the writer must emit valid JSON");
+            assert_eq!(got, case["expected"], "{name}: diverged from the Python builder");
+        }
+    }
+
+}
diff --git a/card_engine/src/filter.rs b/card_engine/src/filter.rs
index bca7138cf..8d70b9ae8 100644
--- a/card_engine/src/filter.rs
+++ b/card_engine/src/filter.rs
@@ -443,7 +443,7 @@ fn text_search_field_value<'a>(
     match field {
         // Accent-folded (#649): the query word is folded the same way in Python
         // before it reaches TextContains/NameMatch, so this must match.
-        TextSearchField::NameLower       => StrVal::Known(card.card_name_folded.as_str()),
+        TextSearchField::NameLower       => StrVal::Known(crate::folded_name(card, strings)),
         TextSearchField::OracleTextLower => opt_sv(str_at(strings, u32::from(card.oracle_text_lower_id))),
         TextSearchField::FlavorTextLower => printing.map_or(StrVal::PDep, |p| opt_sv(str_at(strings, u32::from(p.flavor_text_lower_id)))),
         // Rewritten to ArtistMatch by bind(); printings carry no artist strings.
@@ -1205,7 +1205,7 @@ impl FilterExpr {
                 let finder = memmem::Finder::new(word.as_bytes()); // built once, reused across the verify scan
                 let mut ids: Vec<u32> = cand
                     .into_iter()
-                    .filter(|&cid| finder.find(cards[cid as usize].card_name_folded.as_str().as_bytes()).is_some())
+                    .filter(|&cid| finder.find(crate::folded_name(&cards[cid as usize], strings).as_bytes()).is_some())
                     .map(|cid| u32::from(cards[cid as usize].card_name_id))
                     .collect();
                 ids.sort_unstable();
diff --git a/card_engine/src/lib.rs b/card_engine/src/lib.rs
index 4860fa351..63bb1e292 100644
--- a/card_engine/src/lib.rs
+++ b/card_engine/src/lib.rs
@@ -3,10 +3,13 @@ use pyo3::exceptions::PyValueError;
 use pyo3::prelude::*;
 use pyo3::types::{PyDate, PyDateAccess, PyDict, PyList, PyTuple};
 use rkyv::{Archive, Archived, Deserialize, Serialize};
+use rkyv::niche::niching::Zero;
+use rkyv::with::NicheInto;
 use memmap2::Mmap;
 use memchr::memmem;
 use serde_json::Value;
 use std::collections::{HashMap, HashSet};
+use std::num::NonZeroU32;
 use std::io::Write as IoWrite;
 use std::path::PathBuf;
 use std::sync::{Arc, LazyLock, Mutex};
@@ -229,6 +232,178 @@ struct ManaCost {
     cmc: f32,
 }
 
+/// One face's own text, for the ~18% of cards that have faces.
+///
+/// The merged row (see api/card_processing.py's face-merge policy) is what filters run against:
+/// unions and joined texts, so any face satisfies a card-level predicate. That is deliberately
+/// lossy about WHICH face said what — right for searching, not enough to answer with a card
+/// object. These records carry the per-face values, so a face is something the engine can read
+/// rather than something only a JSONB column remembers.
+///
+/// Text is oracle-level (every printing of a card prints the same faces), so it lives here and the
+/// per-printing art lives on `PrintingFace`.
+#[derive(Archive, Serialize, Deserialize)]
+struct OracleFace {
+    card_name_id: u32,
+    mana_cost_text_id: u32,
+    type_line_id: u32,
+    oracle_text_id: u32,
+    creature_power_text_id: u32,
+    creature_toughness_text_id: u32,
+    planeswalker_loyalty_text_id: u32,
+    // Battles print their defense on the FACE, never at top level -- every battle so far is a
+    // transform card, so without this the number is simply lost (Invasion of Alara's `defense: 7`).
+    defense_text_id: u32,
+    card_colors: u8,
+    // Scryfall's color_indicator: the printed dot for a face whose color is not implied by its mana
+    // cost (a transform back has no mana cost at all). Same WUBRGC bit layout as card_colors.
+    color_indicator: u8,
+}
+
+/// One entry of Scryfall's `all_parts`: a card this one is related to.
+///
+/// Carries the reference's own id, name and type line rather than an index into our cards, because
+/// most of these point OUTSIDE the corpus -- `preprocess_card` filters Token and Card type lines,
+/// and tokens are exactly what a `token` component references. An index would resolve to nothing
+/// for them, so the reference has to stand alone.
+#[derive(Archive, Serialize, Deserialize)]
+struct RelatedCard {
+    id: u128,
+    name_id: u32,
+    type_line_id: u32,
+    // Interned rather than an enum: Scryfall has added components before (meld_part, meld_result,
+    // combo_piece, token) and an unknown one should pass through, not fail the import.
+    component_id: u16,
+}
+
+/// One face's art and flavor, which vary per printing where `OracleFace`'s text does not.
+#[derive(Archive, Serialize, Deserialize)]
+struct PrintingFace {
+    illustration_id: u128,
+    card_artist_vid: u16,
+    flavor_text_id: u32,
+}
+
+// Bit positions in `CompatFields.flags`. Twelve booleans Scryfall sends on every card object; a
+// word rather than twelve bools because they are only ever read together, when rebuilding one.
+const COMPAT_BOOSTER: u16 = 1 << 0;
+const COMPAT_DIGITAL: u16 = 1 << 1;
+const COMPAT_FOIL: u16 = 1 << 2;
+const COMPAT_NONFOIL: u16 = 1 << 3;
+const COMPAT_FULL_ART: u16 = 1 << 4;
+const COMPAT_HIGHRES_IMAGE: u16 = 1 << 5;
+const COMPAT_OVERSIZED: u16 = 1 << 6;
+const COMPAT_PROMO: u16 = 1 << 7;
+const COMPAT_REPRINT: u16 = 1 << 8;
+const COMPAT_STORY_SPOTLIGHT: u16 = 1 << 9;
+const COMPAT_TEXTLESS: u16 = 1 << 10;
+const COMPAT_VARIATION: u16 = 1 << 11;
+
+// `games` and `finishes` bitsets. Closed vocabularies, so a byte each beats a Vec of interned ids.
+const GAME_PAPER: u8 = 1 << 0;
+const GAME_MTGO: u8 = 1 << 1;
+const GAME_ARENA: u8 = 1 << 2;
+const FINISH_NONFOIL: u8 = 1 << 0;
+const FINISH_FOIL: u8 = 1 << 1;
+const FINISH_ETCHED: u8 = 1 << 2;
+const FINISH_GLOSSY: u8 = 1 << 3;
+
+/// The Scryfall fields that no column holds and no derivation recovers — the `card_compat_blob`
+/// residue, packed.
+///
+/// Measured on a real card object: 66 keys and 5,881 bytes, of which 25 are already columns and 15
+/// are pure functions of the card's id, set or oracle id. What is left is this, and packed it is
+/// ~50 bytes a printing rather than the ~5.9 KB a whole blob would cost. That ratio is the reason
+/// the store can answer a card-shaped question at all: blobs at corpus scale are ~575 MB, and this
+/// is ~5 MB.
+#[derive(Archive, Serialize, Deserialize)]
+struct CompatFields {
+    // Marketplace and client ids. Sparse -- most printings carry two to four of the six -- and
+    // NonZeroU32 rather than u32 so rkyv can niche the None into the value itself: an Option<u32>
+    // archives as 8 bytes (tag plus payload), an Option<NonZeroU32> as 4. Eleven of them, on every
+    // printing, so the niche is worth 44 bytes a row on its own. None of these ids is ever 0.
+    //
+    // The `NicheInto<Zero>` attribute is REQUIRED for that. rkyv 0.8 does not niche an
+    // Option<NonZeroU32> on its own -- measured at 8 bytes without it, so CompatFields was 128
+    // rather than the 84 it is now, and the whole 44-byte saving this comment describes was not
+    // actually happening. The 160 -> 128 the commit message reports came from set_id's u128
+    // alignment going away, not from the niche.
+    #[rkyv(with = NicheInto<Zero>)]
+    arena_id: Option<NonZeroU32>,
+    #[rkyv(with = NicheInto<Zero>)]
+    mtgo_id: Option<NonZeroU32>,
+    #[rkyv(with = NicheInto<Zero>)]
+    mtgo_foil_id: Option<NonZeroU32>,
+    #[rkyv(with = NicheInto<Zero>)]
+    tcgplayer_id: Option<NonZeroU32>,
+    #[rkyv(with = NicheInto<Zero>)]
+    tcgplayer_etched_id: Option<NonZeroU32>,
+    #[rkyv(with = NicheInto<Zero>)]
+    cardmarket_id: Option<NonZeroU32>,
+    #[rkyv(with = NicheInto<Zero>)]
+    penny_rank: Option<NonZeroU32>,
+    // The cache-buster Scryfall appends to every image_uris entry; without it the derived URLs are
+    // reachable but not byte-identical to what Scryfall serves.
+    #[rkyv(with = NicheInto<Zero>)]
+    image_updated_at: Option<NonZeroU32>,
+    // Integer cents, exactly like the three price columns. These three have no column.
+    #[rkyv(with = NicheInto<Zero>)]
+    price_usd_foil: Option<NonZeroU32>,
+    #[rkyv(with = NicheInto<Zero>)]
+    price_usd_etched: Option<NonZeroU32>,
+    #[rkyv(with = NicheInto<Zero>)]
+    price_eur_foil: Option<NonZeroU32>,
+    // Small closed vocabularies interned into coll_vocab: ~10 languages, ~6 image statuses,
+    // ~20 set types, ~5 security stamps -- and the SET, which is why set_id is no longer the
+    // raw u128 UUID. There are ~1,000 sets against ~98,000 printings, so interning it costs a
+    // vocab entry each and 2 bytes a row instead of 16. It also removes the only 16-byte-aligned
+    // member of this struct, and with it the padding that alignment forced on every printing.
+    // The UUID is reconstructed on read from the vocab string.
+    set_vid: u16,
+    lang_id: u16,
+    image_status_id: u16,
+    set_type_id: u16,
+    security_stamp_id: u16,
+    games: u8,
+    finishes: u8,
+    flags: u16,
+    multiverse_ids: Vec<u32>,
+    promo_types: Vec<u16>,
+    frame_effects: Vec<u16>,
+}
+
+/// Hand-written rather than derived, because `#[derive(Default)]` zeroes the interned ids and
+/// vocab id 0 is a REAL string. A card with no `lang` would then report whatever happens to sit at
+/// slot 0. Absent has to be the sentinel.
+impl Default for CompatFields {
+    fn default() -> Self {
+        Self {
+            arena_id: None,
+            mtgo_id: None,
+            mtgo_foil_id: None,
+            tcgplayer_id: None,
+            tcgplayer_etched_id: None,
+            cardmarket_id: None,
+            penny_rank: None,
+            image_updated_at: None,
+            price_usd_foil: None,
+            price_usd_etched: None,
+            price_eur_foil: None,
+            set_vid: VOCAB_NONE,
+            lang_id: VOCAB_NONE,
+            image_status_id: VOCAB_NONE,
+            set_type_id: VOCAB_NONE,
+            security_stamp_id: VOCAB_NONE,
+            games: 0,
+            finishes: 0,
+            flags: 0,
+            multiverse_ids: Vec::new(),
+            promo_types: Vec::new(),
+            frame_effects: Vec::new(),
+        }
+    }
+}
+
 #[derive(Archive, Serialize, Deserialize)]
 struct OracleCard {
     // Hot fields first — fits in the first cache lines for fast filter short-circuiting.
@@ -236,7 +411,17 @@ struct OracleCard {
     // Accent-folded card_name_lower (e.g. "éowyn" -> "eowyn"), precomputed in Python via
     // fold_accents() (#649). Backs fuzzy name: search (name_trigram/name_bigrams/TextContains)
     // so "eowyn" matches "Éowyn"; exact-match paths deliberately keep using card_name_lower.
-    card_name_folded: InlineStr<61>,
+    //
+    // An INTERNED ID, not a second inline copy. It differs from `card_name_lower` only where a name
+    // carries a diacritic -- 88 of 31,724 cards on the current corpus -- so 61 bytes a card stored
+    // a string identical to the one above it 99.72% of the time. `NONE_STR` means exactly that,
+    // "read card_name_lower", and only the exceptions reach the strings table, at ~1.6 KB.
+    // `OracleCard` goes 304 -> 240 bytes.
+    //
+    // FOLDED is the half that moved because it is the COLDER of the two -- six read sites against
+    // `card_name_lower`'s, and every one of them already holds a `strings` table. Resolve with
+    // `folded_name`, never by reading this field.
+    card_name_folded_id: u32,
     card_colors: u8,
     card_color_identity: u8,
     produced_mana: u8,
@@ -285,6 +470,17 @@ struct OracleCard {
 
     creature_power_text_id: u32,
     creature_toughness_text_id: u32,
+    // The PRINTED loyalty, beside the printed power and toughness. `planeswalker_loyalty` above is
+    // the u8 the query planner filters `loy:` on and cannot stand in for it: "X" (Nissa, Steward of
+    // Elements) and "1+*" are real printed loyalties that do not fit in it at all.
+    planeswalker_loyalty_text_id: u32,
+
+    // Empty for the ~82% of cards with a single face. Front first, in Scryfall's own order.
+    faces: Vec<OracleFace>,
+
+    // Scryfall's all_parts, on ~41% of cards. Oracle-level: a card's relations do not vary by
+    // printing, so this hangs off the card exactly as face TEXT does.
+    all_parts: Vec<RelatedCard>,
 }
 
 #[derive(Archive, Serialize, Deserialize)]
@@ -303,6 +499,13 @@ struct Printing {
     // strings live on the printing.
     card_artist_vid: u16,
     card_set_code: InlineStr<8>,
+    // Dense ranks of card_set_code and the artist name in byte order, assigned post-load by
+    // assign_set_ranks / assign_artist_ranks; the sort keys for SortCol::Set and SortCol::Artist.
+    // Neither can be derived at sort time: a set code is a string, and card_artist_vid is intern
+    // order (first seen), not alphabetical. Equal values share a rank so the sort secondaries break
+    // their ties, and both stay far below 2^24 so the f32 sort-key conversion is exact.
+    set_rank: u32,
+    artist_rank: u32,
     card_border_id: u32,
     card_watermark_id: u32,
     collector_number_id: u32,
@@ -336,6 +539,14 @@ struct Printing {
     // #629's replacement for comparing/deduping on the full illustration_id UUID
     // in the artwork-mode match-count and emission hot paths.
     artwork_group_id: u16,
+
+    // Parallel to the owning OracleCard's `faces`, so index i is the same face in both. Empty for
+    // single-faced cards, and empty when a multi-face card's printing carries no per-face art.
+    faces: Vec<PrintingFace>,
+
+    // The card_compat_blob residue, packed. Printing-level: every field here varies by printing
+    // (ids, prices, finishes) or is set-level and therefore constant across a set's printings.
+    compat: CompatFields,
 }
 
 /// Parse-time row: one DB row (= one printing) with every field, before the
@@ -394,6 +605,34 @@ struct CardRow {
 
     creature_power_text_id: u32,
     creature_toughness_text_id: u32,
+    planeswalker_loyalty_text_id: u32,
+
+    // Both halves of each face, together, until the commit pass splits them the same way it splits
+    // the row itself: text to the OracleCard, art to the Printing.
+    card_faces: Vec<FaceRow>,
+    all_parts: Vec<RelatedCard>,
+
+    compat: CompatFields,
+}
+
+/// Parse-time face: `OracleFace` and `PrintingFace` before the commit pass separates them.
+/// Never archived.
+struct FaceRow {
+    card_name_id: u32,
+    mana_cost_text_id: u32,
+    type_line_id: u32,
+    oracle_text_id: u32,
+    creature_power_text_id: u32,
+    creature_toughness_text_id: u32,
+    planeswalker_loyalty_text_id: u32,
+    // Battles print their defense on the FACE, never at top level -- every battle so far is a
+    // transform card, so without this the number is simply lost (Invasion of Alara's `defense: 7`).
+    defense_text_id: u32,
+    card_colors: u8,
+    color_indicator: u8,
+    illustration_id: u128,
+    card_artist_vid: u16,
+    flavor_text_id: u32,
 }
 
 // Type aliases for the archived (mmap-backed) store types
@@ -407,9 +646,35 @@ pub(crate) type AOffsets = Archived<Vec<u32>>;
 /// Sentinel id for absent optional strings (a card never has 4 billion distinct strings).
 const NONE_STR: u32 = u32::MAX;
 
+/// A card's accent-folded lowercase name.
+///
+/// `NONE_STR` in `card_name_folded_id` means "identical to `card_name_lower`", which is every card
+/// whose name carries no diacritic, so this is an inline read on the overwhelming majority and a
+/// `strings` lookup only for the handful that need one.
+fn folded_name<'a>(card: &'a AOracleCard, strings: &'a AStrings) -> &'a str {
+    let id = u32::from(card.card_name_folded_id);
+    if id == NONE_STR {
+        return card.card_name_lower.as_str();
+    }
+    str_at(strings, id).unwrap_or_else(|| card.card_name_lower.as_str())
+}
+
+/// Build-time twin of `folded_name`, over unarchived rows and the interner's plain `Vec<String>`.
+fn folded_name_of<'a>(card: &'a OracleCard, strings: &'a [String]) -> &'a str {
+    if card.card_name_folded_id == NONE_STR {
+        return card.card_name_lower.as_str();
+    }
+    strings.get(card.card_name_folded_id as usize).map_or_else(|| card.card_name_lower.as_str(), String::as_str)
+}
+
 /// Sentinel for a printing with no artist (see Printing.card_artist_vid).
 pub(crate) const ARTIST_NONE: u16 = u16::MAX;
 
+/// Sentinel for an absent coll_vocab id, same convention as ARTIST_NONE. The compat fields need
+/// one because Scryfall OMITS a key rather than sending null, so a reconstructed card object has
+/// to tell "was not there" from "was empty".
+pub(crate) const VOCAB_NONE: u16 = u16::MAX;
+
 /// Resolve an interned id against the archived string table; None for absent.
 pub(crate) fn str_at(strings: &AStrings, id: u32) -> Option<&str> {
     if id == NONE_STR { None } else { Some(strings[id as usize].as_str()) }
@@ -677,6 +942,7 @@ fn jsonb_obj_to_ids(d: &Bound<PyDict>, key: &str, vocab: &mut VocabInterner) ->
 
 // ─── Format legality bitmap ──────────────────────────────────────────────────
 
+pub mod card_object;
 mod legality;
 use legality::*;
 
@@ -716,6 +982,183 @@ fn mana_cost_from_pydict(d: &Bound<PyDict>, cmc_val: Option<f32>, mana_vocab: &m
     Ok(ManaCost { core, hybrids, devotion, cmc: cmc_val.unwrap_or(0.0) })
 }
 
+fn opt_bool(d: &Bound<PyDict>, key: &str) -> bool {
+    d.get_item(key).ok().flatten().and_then(|v| v.extract::<bool>().ok()).unwrap_or(false)
+}
+
+/// Set a bit per member present in a string list, for a closed vocabulary.
+fn str_set_bits(d: &Bound<PyDict>, key: &str, table: &[(&str, u8)]) -> u8 {
+    let present = str_list(d, key);
+    table
+        .iter()
+        .filter(|(name, _)| present.iter().any(|p| p == name))
+        .fold(0u8, |acc, (_, bit)| acc | bit)
+}
+
+/// The residue Scryfall sends that no column holds, read out of `card_compat_blob`.
+///
+/// Absent keys stay at their zero value: `NONE_VOCAB` for interned ids, `None` for the optionals,
+/// clear bits for the flags. That matters for round-tripping, because Scryfall OMITS a key rather
+/// than sending null, so "zero" has to mean "was not there".
+/// Like `opt_u32`, but into a NonZeroU32 so rkyv can niche the None. A 0 reads as absent, which
+/// is right for every field this is used on: an id or a price of 0 is not a value Scryfall sends.
+fn opt_nonzero_u32(d: &Bound<PyDict>, key: &str) -> Option<NonZeroU32> {
+    opt_u32(d, key).and_then(NonZeroU32::new)
+}
+
+fn compat_from_pydict(d: &Bound<PyDict>, vocab: &mut VocabInterner) -> PyResult<CompatFields> {
+    let Some(blob) = d.get_item("card_compat_blob").ok().flatten().and_then(|v| v.cast_into::<PyDict>().ok()) else {
+        return Ok(CompatFields::default());
+    };
+    let prices = blob.get_item("prices").ok().flatten().and_then(|v| v.cast_into::<PyDict>().ok());
+    let price = |key: &str| prices.as_ref().and_then(|p| opt_price_cents(p, key));
+
+    let mut flags = 0u16;
+    for (key, bit) in [
+        ("booster", COMPAT_BOOSTER),
+        ("digital", COMPAT_DIGITAL),
+        ("foil", COMPAT_FOIL),
+        ("nonfoil", COMPAT_NONFOIL),
+        ("full_art", COMPAT_FULL_ART),
+        ("highres_image", COMPAT_HIGHRES_IMAGE),
+        ("oversized", COMPAT_OVERSIZED),
+        ("promo", COMPAT_PROMO),
+        ("reprint", COMPAT_REPRINT),
+        ("story_spotlight", COMPAT_STORY_SPOTLIGHT),
+        ("textless", COMPAT_TEXTLESS),
+        ("variation", COMPAT_VARIATION),
+    ] {
+        if opt_bool(&blob, key) {
+            flags |= bit;
+        }
+    }
+
+    let intern_opt = |vocab: &mut VocabInterner, value: Option<String>| -> PyResult<u16> {
+        match value {
+            Some(v) => vocab.intern(v),
+            None => Ok(VOCAB_NONE),
+        }
+    };
+
+    Ok(CompatFields {
+        arena_id: opt_nonzero_u32(&blob, "arena_id"),
+        mtgo_id: opt_nonzero_u32(&blob, "mtgo_id"),
+        mtgo_foil_id: opt_nonzero_u32(&blob, "mtgo_foil_id"),
+        tcgplayer_id: opt_nonzero_u32(&blob, "tcgplayer_id"),
+        tcgplayer_etched_id: opt_nonzero_u32(&blob, "tcgplayer_etched_id"),
+        cardmarket_id: opt_nonzero_u32(&blob, "cardmarket_id"),
+        penny_rank: opt_nonzero_u32(&blob, "penny_rank"),
+        image_updated_at: opt_nonzero_u32(&blob, "image_updated_at"),
+        price_usd_foil: price("usd_foil").and_then(NonZeroU32::new),
+        price_usd_etched: price("usd_etched").and_then(NonZeroU32::new),
+        price_eur_foil: price("eur_foil").and_then(NonZeroU32::new),
+        set_vid: intern_opt(vocab, opt_str(&blob, "set_id"))?,
+        lang_id: intern_opt(vocab, opt_str(&blob, "lang"))?,
+        image_status_id: intern_opt(vocab, opt_str(&blob, "image_status"))?,
+        set_type_id: intern_opt(vocab, opt_str(&blob, "set_type"))?,
+        security_stamp_id: intern_opt(vocab, opt_str(&blob, "security_stamp"))?,
+        games: str_set_bits(&blob, "games", &[("paper", GAME_PAPER), ("mtgo", GAME_MTGO), ("arena", GAME_ARENA)]),
+        finishes: str_set_bits(
+            &blob,
+            "finishes",
+            &[
+                ("nonfoil", FINISH_NONFOIL),
+                ("foil", FINISH_FOIL),
+                ("etched", FINISH_ETCHED),
+                ("glossy", FINISH_GLOSSY),
+            ],
+        ),
+        flags,
+        multiverse_ids: blob
+            .get_item("multiverse_ids")
+            .ok()
+            .flatten()
+            .and_then(|v| v.extract::<Vec<u32>>().ok())
+            .unwrap_or_default(),
+        promo_types: str_list_to_ids(&blob, "promo_types", vocab)?,
+        frame_effects: str_list_to_ids(&blob, "frame_effects", vocab)?,
+    })
+}
+
+/// Scryfall's `all_parts`, read out of the compat blob.
+///
+/// Kept in Scryfall's order: it is meaningful for melds (the two parts, then the result).
+fn all_parts_from_pydict(d: &Bound<PyDict>, it: &mut Interner, vocab: &mut VocabInterner) -> PyResult<Vec<RelatedCard>> {
+    let Some(blob) = d.get_item("card_compat_blob").ok().flatten().and_then(|v| v.cast_into::<PyDict>().ok()) else {
+        return Ok(Vec::new());
+    };
+    let Some(value) = blob.get_item("all_parts").ok().flatten() else {
+        return Ok(Vec::new());
+    };
+    let Ok(list) = value.cast::<PyList>() else {
+        return Ok(Vec::new());
+    };
+    let mut out = Vec::with_capacity(list.len());
+    for item in list.iter() {
+        let Ok(part) = item.cast::<PyDict>() else {
+            continue;
+        };
+        out.push(RelatedCard {
+            id: opt_str(part, "id").map_or(0, |s| parse_uuid_or_hash(&s)),
+            name_id: it.intern(opt_str(part, "name").unwrap_or_default()),
+            type_line_id: it.intern(opt_str(part, "type_line").unwrap_or_default()),
+            component_id: match opt_str(part, "component") {
+                Some(c) => vocab.intern(c)?,
+                None => VOCAB_NONE,
+            },
+        });
+    }
+    Ok(out)
+}
+
+/// Colors as Scryfall spells them on a FACE: a plain list (`["W"]`), not the row columns'
+/// jsonb object. Same mask either way.
+fn str_list_color_mask(d: &Bound<PyDict>, key: &str) -> u8 {
+    let colors = str_list(d, key);
+    color_list_to_mask(&colors.iter().map(String::as_str).collect::<Vec<_>>())
+}
+
+/// The card's faces, front first; empty for the ~82% of cards with one face.
+///
+/// Keys here are Scryfall's own (see `_FACE_OBJECT_FIELDS` in api/card_processing.py), not the
+/// row's column names, because a face record is a snapshot of what Scryfall sent for that face.
+/// A face that is missing a key keeps the interner's NONE_STR, which is how "Scryfall omitted it"
+/// round-trips back to an absent key rather than a null.
+fn faces_from_pydict(d: &Bound<PyDict>, it: &mut Interner, artists: &mut VocabInterner) -> PyResult<Vec<FaceRow>> {
+    let Some(value) = d.get_item("card_faces").ok().flatten() else {
+        return Ok(Vec::new());
+    };
+    let Ok(list) = value.cast::<PyList>() else {
+        return Ok(Vec::new());
+    };
+    let mut faces = Vec::with_capacity(list.len());
+    for item in list.iter() {
+        let Ok(face) = item.cast::<PyDict>() else {
+            continue;
+        };
+        let card_artist_vid = match opt_str(face, "artist") {
+            Some(a) => artists.intern(a.to_lowercase())?,
+            None => ARTIST_NONE,
+        };
+        faces.push(FaceRow {
+            card_name_id: it.intern(opt_str(face, "name").unwrap_or_default()),
+            mana_cost_text_id: it.intern_opt(opt_str(face, "mana_cost")),
+            type_line_id: it.intern(opt_str(face, "type_line").unwrap_or_default()),
+            oracle_text_id: it.intern(opt_str(face, "oracle_text").unwrap_or_default()),
+            creature_power_text_id: it.intern_opt(opt_str(face, "power")),
+            creature_toughness_text_id: it.intern_opt(opt_str(face, "toughness")),
+            planeswalker_loyalty_text_id: it.intern_opt(opt_str(face, "loyalty")),
+            defense_text_id: it.intern_opt(opt_str(face, "defense")),
+            card_colors: str_list_color_mask(face, "colors"),
+            color_indicator: str_list_color_mask(face, "color_indicator"),
+            illustration_id: opt_str(face, "illustration_id").map_or(0, |s| parse_uuid_or_hash(&s)),
+            card_artist_vid,
+            flavor_text_id: it.intern_opt(opt_str(face, "flavor_text")),
+        });
+    }
+    Ok(faces)
+}
+
 fn card_from_pydict(d: &Bound<PyDict>, it: &mut Interner, vocab: &mut VocabInterner, artists: &mut VocabInterner, mana: &mut ManaVocabInterner) -> PyResult<CardRow> {
     let released_at = opt_date_str(d, "released_at").unwrap_or_default();
     let released_at_int: Option<u32> = released_at.replace('-', "").parse().ok();
@@ -787,6 +1230,11 @@ fn card_from_pydict(d: &Bound<PyDict>, it: &mut Interner, vocab: &mut VocabInter
 
         creature_power_text_id: it.intern_opt(opt_str(d, "creature_power_text")),
         creature_toughness_text_id: it.intern_opt(opt_str(d, "creature_toughness_text")),
+        planeswalker_loyalty_text_id: it.intern_opt(opt_str(d, "planeswalker_loyalty_text")),
+
+        card_faces: faces_from_pydict(d, it, artists)?,
+        all_parts: all_parts_from_pydict(d, it, vocab)?,
+        compat: compat_from_pydict(d, vocab)?,
     })
 }
 
@@ -1226,11 +1674,11 @@ struct NameBigramIndex {
     n_cards: u32,
 }
 
-fn build_name_bigram_index(cards: &[OracleCard]) -> NameBigramIndex {
+fn build_name_bigram_index(cards: &[OracleCard], strings: &[String]) -> NameBigramIndex {
     let mut lists: HashMap<[u8; 2], Vec<u32>> = HashMap::new();
     for (i, card) in cards.iter().enumerate() {
         // Folded (#649) — this index backs the same fuzzy name: path as name_trigram.
-        let bytes = card.card_name_folded.as_str().as_bytes();
+        let bytes = folded_name_of(card, strings).as_bytes();
         let mut seen: Vec<[u8; 2]> = Vec::new(); // names are short; a vec beats a set
         for w in bytes.windows(2) {
             let bg = [w[0], w[1]];
@@ -1290,13 +1738,13 @@ struct NameUnigramIndex {
     n_cards: u32,
 }
 
-fn build_name_unigram_index(cards: &[OracleCard]) -> NameUnigramIndex {
+fn build_name_unigram_index(cards: &[OracleCard], strings: &[String]) -> NameUnigramIndex {
     let mut lists: HashMap<u8, Vec<u32>> = HashMap::new();
     for (i, card) in cards.iter().enumerate() {
         // Folded (#649), matching what `name_trigram` / `name_bigrams` index and what the walk evaluates
         // — that agreement is what makes the tight narrowing sound.
         let mut seen = [false; 256];
-        for &b in card.card_name_folded.as_str().as_bytes() {
+        for &b in folded_name_of(card, strings).as_bytes() {
             if !seen[b as usize] {
                 seen[b as usize] = true;
                 lists.entry(b).or_default().push(i as u32);
@@ -2179,9 +2627,12 @@ struct SortPermutations {
 }
 
 impl ArchivedSortPermutations {
-    /// The permutation for a streamable column/direction; None for the
-    /// printing-keyed columns (rarity, usd), whose sort key depends on the
-    /// prefer-chosen printing and cannot be precomputed.
+    /// The permutation for a streamable column/direction; None for the columns that have none.
+    ///
+    /// Those are the printing-keyed ones -- rarity, the three prices, released, set and artist --
+    /// whose sort key depends on the prefer-chosen printing and so cannot be precomputed per card.
+    /// Colour is card-level and could have one; it does not yet, and returning None here costs only
+    /// the streaming fast path, not correctness.
     fn get(&self, col: SortCol, descending: bool) -> Option<&Archived<Vec<u32>>> {
         let pair = match col {
             SortCol::EdhrecRank => &self.edhrec,
@@ -2190,7 +2641,14 @@ impl ArchivedSortPermutations {
             SortCol::Power      => &self.power,
             SortCol::Toughness  => &self.toughness,
             SortCol::Name       => &self.name,
-            SortCol::Rarity | SortCol::PriceUsd => return None,
+            SortCol::Rarity
+            | SortCol::PriceUsd
+            | SortCol::PriceEur
+            | SortCol::PriceTix
+            | SortCol::Released
+            | SortCol::Color
+            | SortCol::Set
+            | SortCol::Artist => return None,
         };
         Some(&pair[descending as usize])
     }
@@ -2204,7 +2662,14 @@ impl ArchivedSortPermutations {
             SortCol::Power      => &self.power_inv,
             SortCol::Toughness  => &self.toughness_inv,
             SortCol::Name       => &self.name_inv,
-            SortCol::Rarity | SortCol::PriceUsd => return None,
+            SortCol::Rarity
+            | SortCol::PriceUsd
+            | SortCol::PriceEur
+            | SortCol::PriceTix
+            | SortCol::Released
+            | SortCol::Color
+            | SortCol::Set
+            | SortCol::Artist => return None,
         };
         Some(&pair[descending as usize])
     }
@@ -2217,7 +2682,14 @@ impl ArchivedSortPermutations {
             SortCol::Power      => &self.power_printings_prefix,
             SortCol::Toughness  => &self.toughness_printings_prefix,
             SortCol::Name       => &self.name_printings_prefix,
-            SortCol::Rarity | SortCol::PriceUsd => return None,
+            SortCol::Rarity
+            | SortCol::PriceUsd
+            | SortCol::PriceEur
+            | SortCol::PriceTix
+            | SortCol::Released
+            | SortCol::Color
+            | SortCol::Set
+            | SortCol::Artist => return None,
         };
         Some(&pair[descending as usize])
     }
@@ -2288,6 +2760,44 @@ fn assign_name_ranks(cards: &mut [OracleCard]) {
     }
 }
 
+/// Dense-rank every printing by a key derived from it, writing the rank back through `set`.
+///
+/// The shape `assign_name_ranks` uses, lifted out because set code and artist need the same thing:
+/// sort an index permutation by the key, then walk it assigning a rank that advances only when the
+/// key changes, so equal keys tie and the sort secondaries decide between them.
+fn assign_printing_ranks<K: Ord>(
+    printings: &mut [Printing],
+    key: impl Fn(&Printing) -> K,
+    set: impl Fn(&mut Printing, u32),
+) {
+    let mut ids: Vec<u32> = (0..printings.len() as u32).collect();
+    ids.sort_unstable_by(|&a, &b| key(&printings[a as usize]).cmp(&key(&printings[b as usize])));
+    let mut rank = 0u32;
+    for i in 0..ids.len() {
+        if i > 0 && key(&printings[ids[i - 1] as usize]) != key(&printings[ids[i] as usize]) {
+            rank += 1;
+        }
+        set(&mut printings[ids[i] as usize], rank);
+    }
+}
+
+/// Rank printings by set code, the sort key for `order=set`.
+fn assign_set_ranks(printings: &mut [Printing]) {
+    assign_printing_ranks(printings, |p| p.card_set_code.as_str().to_owned(), |p, r| p.set_rank = r);
+}
+
+/// Rank printings by artist name, the sort key for `order=artist`.
+///
+/// Resolved through the vocab rather than sorting on `card_artist_vid`, which is intern order.
+/// A printing with no artist ranks last, matching how the absent side of every other order sorts.
+fn assign_artist_ranks(printings: &mut [Printing], artist_vocab: &[String]) {
+    let name_of = |p: &Printing| match p.card_artist_vid {
+        ARTIST_NONE => None,
+        vid => artist_vocab.get(vid as usize).cloned(),
+    };
+    assign_printing_ranks(printings, |p| (name_of(p).is_none(), name_of(p)), |p, r| p.artist_rank = r);
+}
+
 /// `inv[perm[i]] == i` — the position of each card within the permutation.
 fn invert_perm(perm: &[u32]) -> Vec<u32> {
     let mut inv = vec![0u32; perm.len()];
@@ -2389,8 +2899,8 @@ fn perm_primary_key(value: Option<f32>, descending: bool) -> u32 {
 }
 
 /// The sort column's value for one archived card, in the same units `build_sort_permutations` sorted
-/// on. Card-level columns only: `Rarity`/`PriceUsd` have no permutation (they depend on the
-/// prefer-chosen printing), which is why `ArchivedSortPermutations::get` returns `None` for them.
+/// on. Card-level columns only: every column `ArchivedSortPermutations::get` returns `None` for is
+/// unreachable here, because nothing walks a permutation that does not exist.
 fn sort_col_card_value(card: &AOracleCard, sort_col: SortCol) -> Option<f32> {
     match sort_col {
         SortCol::EdhrecRank => card.edhrec_rank.as_ref().map(|v| u32::from(*v) as f32),
@@ -2400,7 +2910,15 @@ fn sort_col_card_value(card: &AOracleCard, sort_col: SortCol) -> Option<f32> {
         SortCol::Power      => card.creature_power.as_ref().map(|v| f32::from(*v)),
         SortCol::Toughness  => card.creature_toughness.as_ref().map(|v| f32::from(*v)),
         SortCol::Name       => Some(u32::from(card.name_rank) as f32),
-        SortCol::Rarity | SortCol::PriceUsd => None,
+        // Unreachable: these have no permutation, so nothing walks them (see `get`).
+        SortCol::Rarity
+        | SortCol::PriceUsd
+        | SortCol::PriceEur
+        | SortCol::PriceTix
+        | SortCol::Released
+        | SortCol::Color
+        | SortCol::Set
+        | SortCol::Artist => None,
     }
 }
 
@@ -2463,6 +2981,696 @@ fn partition_point(len: usize, pred: impl Fn(usize) -> bool) -> usize {
     lo
 }
 
+// Namespaces in `external_id_index`. Scryfall routes /cards/{namespace}/:id for each of these, and
+// MTGO/TCGplayer each match two ids (the foil and etched variants resolve to the same printing).
+pub(crate) const EXT_MULTIVERSE: u8 = 0;
+pub(crate) const EXT_MTGO: u8 = 1;
+pub(crate) const EXT_ARENA: u8 = 2;
+pub(crate) const EXT_TCGPLAYER: u8 = 3;
+pub(crate) const EXT_CARDMARKET: u8 = 4;
+
+/// `(namespace, external id) -> printing`, sorted, for the /cards/{namespace}/:id routes.
+///
+/// Sparse triples rather than five dense columns: most printings carry two to four of the seven
+/// ids, and a multiverse id is a LIST, so one printing can contribute several entries. One binary
+/// search answers all five routes.
+///
+/// MEASURED at corpus scale: 347,625 entries. rkyv archives a `(u8, u64, u32)` as 24 bytes -- the
+/// u64 forces 8-byte alignment on a 13-byte payload -- so this is 8.34 MB, not the ~350 KB an
+/// earlier revision of this comment estimated. Every id Scryfall issues fits in a u32 (the largest
+/// live value is ~1.1M) and the namespace is a property of the block rather than of each entry, so
+/// `(u32, u32)` plus a five-entry offset table would take it to 2.78 MB. Left as it is here
+/// because Postgres has no archive ceiling; a deployment that serves the archive from a size-
+/// capped store will want the packed form.
+///
+/// mtgo_foil_id and tcgplayer_etched_id are folded into their base namespace on purpose -- Scryfall
+/// resolves /cards/mtgo/:id against either mtgo_id or mtgo_foil_id, and the answer is the same
+/// printing either way.
+fn build_external_id_index(printings: &[Printing]) -> Vec<(u8, u64, u32)> {
+    let mut out: Vec<(u8, u64, u32)> = Vec::new();
+    for (pid, p) in printings.iter().enumerate() {
+        let pid = pid as u32;
+        for mv in &p.compat.multiverse_ids {
+            out.push((EXT_MULTIVERSE, u64::from(*mv), pid));
+        }
+        for (ns, id) in [
+            (EXT_MTGO, p.compat.mtgo_id),
+            (EXT_MTGO, p.compat.mtgo_foil_id),
+            (EXT_ARENA, p.compat.arena_id),
+            (EXT_TCGPLAYER, p.compat.tcgplayer_id),
+            (EXT_TCGPLAYER, p.compat.tcgplayer_etched_id),
+            (EXT_CARDMARKET, p.compat.cardmarket_id),
+        ] {
+            if let Some(v) = id {
+                out.push((ns, u64::from(v.get()), pid));
+            }
+        }
+    }
+    // Sorting by the whole triple keeps it deterministic when two printings share an external id
+    // (etched and nonfoil TCGplayer entries do collide); the lowest printing id wins, which is the
+    // store's preferred printing because printings are stored in descending prefer order.
+    out.sort_unstable();
+    out
+}
+
+/// The printing for an external id, or None.
+pub(crate) fn find_printing_by_external_id(
+    index: &Archived<Vec<(u8, u64, u32)>>,
+    namespace: u8,
+    id: u64,
+) -> Option<u32> {
+    let found = index
+        .binary_search_by(|probe| (probe.0, u64::from(probe.1)).cmp(&(namespace, id)))
+        .ok()?;
+    // binary_search lands on ANY match; walk back to the first so a shared id resolves to the
+    // lowest printing rather than whichever the search happened to hit.
+    let mut i = found;
+    while i > 0 && (index[i - 1].0, u64::from(index[i - 1].1)) == (namespace, id) {
+        i -= 1;
+    }
+    Some(u32::from(index[i].2))
+}
+
+// ─── Fuzzy name matching ─────────────────────────────────────────────────────
+// A reimplementation of pg_trgm's similarity(), because the SQL path is a FALLBACK and the engine
+// has to answer `?fuzzy=` itself. Matching pg_trgm exactly matters: if the two paths scored
+// differently, the same query would resolve to different cards depending on which one served it.
+//
+// pg_trgm's algorithm: split on non-alphanumerics, pad each word with two leading spaces and one
+// trailing, take every 3-byte window, deduplicate, and score |intersection| / |union|.
+//
+// Nothing is stored for this. The name vocabulary is ~31,700 oracle names, so scoring the whole
+// corpus per request is a few milliseconds -- cheaper than carrying a trigram index for a route
+// that is a small fraction of traffic.
+
+/// Every distinct trigram of `s`, pg_trgm's way.
+fn trigrams(s: &str) -> std::collections::BTreeSet<[u8; 3]> {
+    let mut out = std::collections::BTreeSet::new();
+    for word in s.split(|c: char| !c.is_alphanumeric()).filter(|w| !w.is_empty()) {
+        // pg_trgm pads "  word " and windows over the bytes.
+        let mut padded = Vec::with_capacity(word.len() + 3);
+        padded.extend_from_slice(b"  ");
+        padded.extend_from_slice(word.as_bytes());
+        padded.push(b' ');
+        for w in padded.windows(3) {
+            out.insert([w[0], w[1], w[2]]);
+        }
+    }
+    out
+}
+
+/// pg_trgm's `similarity(a, b)`: Jaccard over trigram sets. 0.0 when both are empty.
+/// `trigrams`, written into a caller-owned buffer as a sorted, deduped run.
+///
+/// Same trigram definition as `trigrams` (pg_trgm's `"  word "` padding, windowed over bytes), and
+/// `fuzzy_name_match` reuses one buffer across every card so its scan allocates once instead of
+/// 31,724 times. Sorted+deduped so a merge can stand in for a set intersection.
+fn trigrams_into(s: &str, out: &mut Vec<[u8; 3]>) {
+    out.clear();
+    for word in s.split(|c: char| !c.is_alphanumeric()).filter(|w| !w.is_empty()) {
+        let bytes = word.as_bytes();
+        // The padded form is "  word ", so the windows are: two leading pairs that need no buffer,
+        // then the word's own windows, then the trailing one. Materialising the padded Vec was the
+        // other per-name allocation.
+        out.push([b' ', b' ', bytes[0]]);
+        if bytes.len() >= 2 {
+            out.push([b' ', bytes[0], bytes[1]]);
+        } else {
+            out.push([b' ', bytes[0], b' ']);
+        }
+        for w in bytes.windows(3) {
+            out.push([w[0], w[1], w[2]]);
+        }
+        if bytes.len() >= 2 {
+            let n = bytes.len();
+            out.push([bytes[n - 2], bytes[n - 1], b' ']);
+        }
+    }
+    out.sort_unstable();
+    out.dedup();
+}
+
+/// TEST-ONLY since the fuzzy scan stopped calling it: this is the REFERENCE statement of
+/// pg_trgm's similarity, pinned by `trigram_similarity_matches_pg_trgm` and used by
+/// `trigrams_into_matches_the_padded_definition` to hold the scan's faster route to it. Kept
+/// rather than deleted because a definition the tests check against is worth more than the call
+/// site it lost.
+#[cfg(test)]
+pub(crate) fn trigram_similarity(a: &str, b: &str) -> f32 {
+    let (ta, tb) = (trigrams(a), trigrams(b));
+    if ta.is_empty() || tb.is_empty() {
+        return 0.0;
+    }
+    let shared = ta.intersection(&tb).count();
+    let union = ta.len() + tb.len() - shared;
+    if union == 0 { 0.0 } else { shared as f32 / union as f32 }
+}
+
+/// What a `?fuzzy=` lookup resolved to.
+pub(crate) enum FuzzyOutcome {
+    /// The card index that won outright.
+    Hit(u32),
+    /// Two distinct names scored too close to choose between; Scryfall answers `ambiguous`.
+    Ambiguous,
+    /// Nothing cleared the floor.
+    Miss,
+}
+
+/// The typo-tolerant name match, with #912's thresholds.
+///
+/// A candidate must clear `floor`, and the best must lead the next DISTINCT name by `lead`. The
+/// distinctness matters: several printings of one card would otherwise look like a tie with
+/// themselves and report ambiguous.
+pub(crate) fn fuzzy_name_match(
+    cards: &Archived<Vec<OracleCard>>,
+    strings: &AStrings,
+    needle: &str,
+    floor: f32,
+    lead: f32,
+) -> FuzzyOutcome {
+    let needle = needle.to_lowercase();
+    // The needle's trigrams are LOOP-INVARIANT, and a sorted Vec is the shape this scan wants
+    // rather than the BTreeSet `trigram_similarity` returns. Calling that helper per card rebuilt
+    // this set 31,724 times and heap-allocated a fresh BTreeSet (plus a padded Vec per word) for
+    // every name besides — on a path that is one linear pass over every card in the corpus.
+    // Measured on the real corpus: 25,350 us for one `?fuzzy=` lookup before this.
+    //
+    // `trigram_similarity` itself is deliberately untouched: it is pinned to pg_trgm's definition
+    // by `trigram_similarity_matches_pg_trgm`, and this computes the identical Jaccard ratio by a
+    // different route (two sorted runs merged, instead of two sets intersected).
+    let mut needle_tg: Vec<[u8; 3]> = trigrams(&needle).into_iter().collect();
+    needle_tg.sort_unstable();
+    needle_tg.dedup();
+    if needle_tg.is_empty() {
+        return FuzzyOutcome::Miss;
+    }
+    // Reused across every card, so the scan allocates once rather than per name. Card names are
+    // InlineStr<61>, so a name yields at most ~64 trigrams and this never grows after the first.
+    let mut name_tg: Vec<[u8; 3]> = Vec::with_capacity(64);
+    let mut best: Option<(f32, u32, &str)> = None;
+    let mut runner_up: Option<f32> = None;
+    for (cid, card) in cards.iter().enumerate() {
+        let name = folded_name(card, strings);
+        trigrams_into(name, &mut name_tg);
+        if name_tg.is_empty() {
+            continue;
+        }
+        // Jaccard is bounded by the size ratio: `shared <= min(|a|,|b|)` and
+        // `union >= max(|a|,|b|)`, so `score <= min/max`. When that ceiling is already under the
+        // floor the merge below cannot change the outcome, and skipping it is exact rather than
+        // approximate — no candidate that could clear `floor` is dropped.
+        let (la, lb) = (name_tg.len(), needle_tg.len());
+        if (la.min(lb) as f32) < floor * la.max(lb) as f32 {
+            continue;
+        }
+        // Two sorted runs merged: no set, no allocation, no hashing.
+        let (mut i, mut j, mut shared) = (0usize, 0usize, 0usize);
+        while i < la && j < lb {
+            match name_tg[i].cmp(&needle_tg[j]) {
+                std::cmp::Ordering::Less => i += 1,
+                std::cmp::Ordering::Greater => j += 1,
+                std::cmp::Ordering::Equal => {
+                    shared += 1;
+                    i += 1;
+                    j += 1;
+                }
+            }
+        }
+        let union = la + lb - shared;
+        let score = if union == 0 { 0.0 } else { shared as f32 / union as f32 };
+        if score < floor {
+            continue;
+        }
+        match best {
+            Some((best_score, _, best_name)) if score <= best_score => {
+                // Only a DIFFERENT name can be the runner-up; other printings of the same card are
+                // the same answer, not a competing one.
+                if name != best_name && runner_up.is_none_or(|r| score > r) {
+                    runner_up = Some(score);
+                }
+            }
+            _ => {
+                if let Some((prev_score, _, prev_name)) = best
+                    && prev_name != name && runner_up.is_none_or(|r| prev_score > r) {
+                        runner_up = Some(prev_score);
+                    }
+                best = Some((score, cid as u32, name));
+            }
+        }
+    }
+    match (best, runner_up) {
+        (None, _) => FuzzyOutcome::Miss,
+        (Some((score, _, _)), Some(second)) if score - second < lead => FuzzyOutcome::Ambiguous,
+        (Some((_, cid, _)), _) => FuzzyOutcome::Hit(cid),
+    }
+}
+
+/// Card ids worth examining for a folded-name predicate, narrowed by `name_trigram`.
+///
+/// Every by-name lookup on the /cards/* surface walked all ~31,700 cards doing string work, while
+/// `name:` in the query language answers the same question -- "which cards' folded names contain
+/// this?" -- through this index. Measured on a ~31.7k-card corpus, the exact-name scan cost 884 us
+/// against 75 us for `name:ward`.
+///
+/// SOUND for the containment stage, whose needle is a CONTIGUOUS SUBSTRING of the stored folded
+/// name by construction, so a matching name holds every trigram of the needle and cannot lie
+/// outside the intersection. Callers still re-verify; this only decides who gets asked.
+///
+/// NOT sound on its own for the by-name lookups since they began comparing COLLATED names: a needle
+/// spelled `limduls vault` shares no trigram with the stored `lim-dul's vault` it matches. `name_best`
+/// therefore treats this as a FAST PATH and re-runs a miss as a full scan -- see the note there.
+///
+/// `None` from `trigram_candidates` means the needle is under 3 bytes, where the index has nothing
+/// to say and the full scan is the only answer. NOT usable for `autocomplete_names`, which matches
+/// `card_name_lower` while this index is built over `card_name_folded`.
+fn name_scan_candidates(data: &Archived<CardData>, needle: &str) -> Vec<u32> {
+    let idx = &data.indexes.name_trigram;
+    // APPLICABILITY CHECK, the same shape every other index gets (`sort_perms::order` length-checks
+    // its arrays, the planes compare `n_cards`). Narrowing through an index that was never built --
+    // or was built for a different card count -- would return NO candidates where the scan found
+    // matches, turning a stale index into silently wrong answers instead of slow ones. A fixture
+    // store that skips index construction is exactly that case.
+    if u32::from(idx.domain) as usize != data.cards.len() {
+        return (0..data.cards.len() as u32).collect();
+    }
+    trigram_candidates(idx, needle).unwrap_or_else(|| (0..data.cards.len() as u32).collect())
+}
+
+/// One by-name lookup: the `(cid, pid)` a needle resolves to under one scope, or None.
+/// `exact_name_match` and `collection_name_match` are the two, and `QueryEngine::card_by_name`
+/// takes whichever of them the route it is serving wants.
+type NameLookup = fn(&Archived<CardData>, &str, Option<&str>) -> Option<(usize, usize)>;
+
+/// Descending precedence for the name scan. Compared, never interpreted, so their ORDER is the
+/// contract and their magnitudes are not.
+const TIER_WHOLE_NAME: u8 = 2;
+const TIER_FACE_NAME: u8 = 1;
+
+/// Which name keys a lookup may match. `named?exact=` reads a strict SUPERSET of what a
+/// `POST /cards/collection` `{"name"}` identifier does -- see `collection_name_match` for the
+/// measurements that separate them.
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub(crate) enum NameScope {
+    Exact,
+    Collection,
+}
+
+/// A name COLLATED: every non-alphanumeric character removed. The needle side of the comparison.
+///
+/// Scryfall compares names this way, on both name surfaces. Measured on api.scryfall.com,
+/// 2026-08-31: `exact=delverofsecrets`, `exact=Lightning-Bolt`, `exact=limduls vault`,
+/// `exact=Kongming Sleeping Dragon` and `exact=whowhatwhenwherewhy` all resolve, as do the same
+/// spellings as collection identifiers -- and the folded comparison this code did before answered
+/// 404 to every one of them.
+///
+/// `char::is_alphanumeric`, not an ASCII class: the needle is accent-folded before it gets here
+/// (`fold_accents`, api/parsing/card_query_nodes.py), so a letter still non-ASCII at this point is
+/// one NFKD had no base letter for, and it must be KEPT rather than deleted. No name in the corpus
+/// exercises that today; this is the choice that fails safe when one arrives.
+fn collate_name(folded: &str) -> String {
+    folded.chars().filter(|c| c.is_alphanumeric()).collect()
+}
+
+/// Whether `stored` COLLATES to `collated_needle`, without collating `stored` into a `String`.
+///
+/// The scan runs this per candidate; allocating a name per card is the cost the trigram narrowing
+/// was added to avoid, and a mismatch here usually dies on the first character.
+fn collates_to(stored: &str, collated_needle: &str) -> bool {
+    let mut needle = collated_needle.chars();
+    for c in stored.chars().filter(|c| c.is_alphanumeric()) {
+        if needle.next() != Some(c) {
+            return false;
+        }
+    }
+    needle.next().is_none()
+}
+
+/// The tier at which `needle` -- already COLLATED -- is one of this card's name keys, or None for a
+/// card the needle does not name. `folded` is the card's stored folded name.
+///
+/// Measured against api.scryfall.com on 2026-08-31, ONE IDENTIFIER PER REQUEST -- a collection
+/// response's `data` is not in identifier order, and a batched probe silently mis-attributes its
+/// answers to the wrong needles:
+///
+///   {"name":"Delver of Secrets"}                   -> Delver of Secrets // Insectile Aberration
+///   {"name":"Insectile Aberration"}                -> the same card (a BACK face names it)
+///   {"name":"Delver of Secrets // Insectile ..."}  -> not_found   <- and `exact=` HITS it
+///   {"name":"Fire // Ice"}, {"name":"Wear // Tear"},
+///   {"name":"Bonecrusher Giant // Stomp"}          -> not_found, all three
+///   {"name":"Who // What // When // Where // Why"} -> und/75 (a FIVE-part name IS a key)
+///   {"name":"Who"}                                 -> not_found (so is `exact=Who`)
+///
+/// So a card answers to its two FACE names when its name splits in EXACTLY two, and to its whole
+/// name otherwise -- never both. `exact=` adds the joined name of a two-faced card, and that is the
+/// only key the two surfaces disagree about.
+///
+/// EXACTLY two is the load-bearing word, and `split_once(" // ")` got it wrong: it read
+/// *Who // What // When // Where // Why* as "Who" plus the rest, so `exact=Who` answered und/75
+/// where Scryfall 404s, while `exact=Why` -- the last part, and no more a key than the first --
+/// answered nothing either way.
+///
+/// The halves are split BEFORE they are collated, because the `" // "` join is itself
+/// non-alphanumeric: collating first would make the boundary vanish and let a needle straddle it.
+fn name_key_tier(folded: &str, needle: &str, scope: NameScope) -> Option<u8> {
+    let mut halves = folded.split(" // ");
+    let front = halves.next().unwrap_or("");
+    let back = halves.next();
+    if let Some(back) = back.filter(|_| halves.next().is_none()) {
+        if collates_to(front, needle) || collates_to(back, needle) {
+            return Some(TIER_FACE_NAME);
+        }
+        return (scope == NameScope::Exact && collates_to(folded, needle)).then_some(TIER_WHOLE_NAME);
+    }
+    collates_to(folded, needle).then_some(TIER_WHOLE_NAME)
+}
+
+/// The card's best printing, optionally restricted to a set.
+///
+/// Printings inside a card's range are stored in descending default-prefer order, so the first one
+/// that qualifies IS the best one and the walk stops there.
+fn best_printing_in_set(data: &Archived<CardData>, cid: usize, set_code: Option<&str>) -> Option<usize> {
+    let (from, to) = (u32::from(data.offsets[cid]) as usize, u32::from(data.offsets[cid + 1]) as usize);
+    match set_code {
+        None => (from < to).then_some(from),
+        Some(code) => (from..to).find(|&pid| data.printings[pid].card_set_code.as_str().eq_ignore_ascii_case(code)),
+    }
+}
+
+fn prefer_of(data: &Archived<CardData>, pid: usize) -> f32 {
+    data.printings[pid].prefer_score.as_ref().map_or(f32::MIN, |v| v.to_native())
+}
+
+/// `named?exact=`: the best printing of the card the needle NAMES, `exact=`'s keys.
+///
+/// `name_key_tier`'s keys plus the JOINED name of a two-faced card -- Scryfall answers
+/// `exact=Delver of Secrets // Insectile Aberration` with that card and reports the same string as
+/// a collection identifier not_found.
+///
+/// A whole-name match beats a face match rather than competing with it -- matching a face is right
+/// (Scryfall resolves `exact=Delver of Secrets` to the two-faced card) but on this corpus
+/// `exact=Lightning Bolt` would otherwise answer "Emeritus of Conflict // Lightning Bolt", whose
+/// prefer_score is the higher of the two. Ranked on (tier, prefer_score), in that order.
+///
+/// FLAVOR NAMES are the one part of Scryfall's `exact=` rule this cannot express: `exact=Godzilla,
+/// King of the Monsters` answers Zilortha, Strength Incarnate there and 404s here, because no
+/// column in this corpus carries a printing's flavor name. It is a pre-existing gap, not one the
+/// scope split opens -- and it happens to leave the COLLECTION surface right, since a flavor name
+/// is not a collection identifier's key either.
+pub(crate) fn exact_name_match(data: &Archived<CardData>, folded: &str, set_code: Option<&str>) -> Option<(usize, usize)> {
+    name_best(data, folded, set_code, NameScope::Exact)
+}
+
+/// `POST /cards/collection`'s `{"name": ...}` identifier: the best printing it names, within `set`.
+///
+/// The twin of `exact_name_match` over the same scan, differing only in scope. A collection
+/// identifier reads `name_key_tier`'s keys and NOTHING else -- the two FACE names when the name
+/// splits in exactly two, the whole name otherwise, never both, never the joined name. The
+/// measurements that separate the two surfaces are on `name_key_tier`.
+///
+/// Everything past the key rule is `exact=`'s: same tier ranking, same set filter, same printing
+/// chosen. Every needle both surfaces accept answers the same card on both.
+pub(crate) fn collection_name_match(data: &Archived<CardData>, folded: &str, set_code: Option<&str>) -> Option<(usize, usize)> {
+    name_best(data, folded, set_code, NameScope::Collection)
+}
+
+/// The shared scan behind both name surfaces: the best `(cid, pid)` for `folded` under `scope`.
+///
+/// TWO PASSES, and the second is a full scan, because the comparison is COLLATED while
+/// `name_trigram` is built over `card_name_folded`: `limduls vault` shares no trigram with the
+/// `lim-dul's vault` it matches, so narrowing alone would answer 404 to exactly the spellings this
+/// was changed to accept. The narrowed pass still answers every needle spelled the way the corpus
+/// stores the name -- which is nearly all of them, and the 884 us -> 4 us the index was added for --
+/// and only a miss pays for the scan.
+///
+/// WHAT THAT LEAVES, stated rather than hidden: two DISTINCT cards whose folded names collate alike
+/// but are spelled differently (`Lightning Bolt` and a hypothetical `Lightning-Bolt`). A needle
+/// spelled as one of them reaches only that one through the index, so if the other holds the better
+/// prefer_score the narrowed pass answers the lower-ranked card. Closing it needs the index rebuilt
+/// over a collated name, which is an archive-format change and not this commit's; whether the
+/// corpus holds such a pair at all is not something this commit measured.
+fn name_best(
+    data: &Archived<CardData>,
+    folded: &str,
+    set_code: Option<&str>,
+    scope: NameScope,
+) -> Option<(usize, usize)> {
+    let needle = collate_name(folded);
+    // Nobody's name. Worth its own line because the alternative is a full scan of every card for a
+    // needle that cannot match one: `{"name": "  "}` is a shape a collection POST can carry.
+    if needle.is_empty() {
+        return None;
+    }
+    let candidates = name_scan_candidates(data, folded);
+    let narrowed = candidates.len() < data.cards.len();
+    let best = name_best_over(data, candidates.into_iter(), &needle, set_code, scope);
+    if best.is_none() && narrowed {
+        return name_best_over(data, 0..data.cards.len() as u32, &needle, set_code, scope);
+    }
+    best
+}
+
+/// `name_best`'s inner loop over one candidate set. `needle` is already collated.
+fn name_best_over(
+    data: &Archived<CardData>,
+    candidates: impl Iterator<Item = u32>,
+    needle: &str,
+    set_code: Option<&str>,
+    scope: NameScope,
+) -> Option<(usize, usize)> {
+    let mut best: Option<(u8, f32, usize, usize)> = None;
+    for cid in candidates {
+        let cid = cid as usize;
+        let stored = folded_name(&data.cards[cid], &data.strings);
+        let Some(tier) = name_key_tier(stored, needle, scope) else { continue };
+        let Some(pid) = best_printing_in_set(data, cid, set_code) else { continue };
+        let score = prefer_of(data, pid);
+        if best.is_none_or(|(bt, bs, _, _)| (tier, score) > (bt, bs)) {
+            best = Some((tier, score, cid, pid));
+        }
+    }
+    best.map(|(_, _, cid, pid)| (cid, pid))
+}
+
+/// `named?fuzzy=`'s containment stage: one printing per DISTINCT card name whose folded name holds
+/// every query word. Two cards sharing a name are one answer, and more than one distinct name is
+/// what the caller reports as `ambiguous` rather than guessing between.
+pub(crate) fn names_containing_all_words(
+    data: &Archived<CardData>,
+    words: &[String],
+    set_code: Option<&str>,
+    limit: usize,
+) -> Vec<(usize, usize)> {
+    // Narrow on the LONGEST word: every word must be contained, so any one is a sound filter, and
+    // the longest has the most trigrams to intersect and so the fewest postings to survive them.
+    let longest = words.iter().max_by_key(|w| w.len()).map(String::as_str).unwrap_or("");
+    let mut by_name: Vec<(&str, f32, usize, usize)> = Vec::new();
+    for cid in name_scan_candidates(data, longest) {
+        let cid = cid as usize;
+        let name = folded_name(&data.cards[cid], &data.strings);
+        if !words.iter().all(|w| name.contains(w.as_str())) {
+            continue;
+        }
+        let Some(pid) = best_printing_in_set(data, cid, set_code) else { continue };
+        let score = prefer_of(data, pid);
+        match by_name.iter_mut().find(|(n, _, _, _)| *n == name) {
+            Some(slot) if score > slot.1 => *slot = (name, score, cid, pid),
+            Some(_) => {}
+            None => by_name.push((name, score, cid, pid)),
+        }
+        // One past the limit distinguishes "one match" from "ambiguous"; the caller needs no more.
+        if by_name.len() > limit {
+            break;
+        }
+    }
+    by_name.sort_unstable_by(|a, b| b.1.total_cmp(&a.1));
+    by_name.into_iter().take(limit).map(|(_, _, cid, pid)| (cid, pid)).collect()
+}
+
+/// Card names MATCHING `needle`, case-insensitively, in the SQL route's own order, up to `limit`.
+///
+/// Scryfall's autocomplete catalog. A scan for the same reason fuzzy is: ~31,700 names is small,
+/// and a prefix index would cost archive space for one low-traffic route.
+///
+/// The ordering is the SQL fallback's, reproduced rather than approximated, because the route now
+/// asks the engine FIRST and falls back only on failure -- so any disagreement between the two is
+/// not a fallback, it is two different answers to one request, and the engine's is the one that
+/// ships. That query is:
+///
+///   WHERE lower(card_name) LIKE '%needle%'
+///   ORDER BY rank, length(card_name), card_name
+///
+/// with rank 0 for a prefix match and 1 for a bare substring. Three things follow, and a
+/// prefix-only alphabetical scan gets all three wrong:
+///
+///   - SUBSTRING matches are in the result set. `bolt` must answer with `Firebolt` and `Rift Bolt`,
+///     not just the names starting with it.
+///   - A prefix match outranks a substring match regardless of name.
+///   - Within a rank the order is by LENGTH, not alphabetical: `Bolt Bend` before `Boltbender`.
+///
+/// Sorted whole rather than short-circuited, for the same reason: the ordering is by length, so a
+/// shorter name later in the corpus outranks a longer one already found, and stopping at `limit`
+/// matches would answer with the wrong ones.
+///
+/// MEASURED against api.scryfall.com, because the SQL is this project's approximation and Scryfall
+/// is the target. `q=bolt` there returns Bolt Bend, Boltwave, Bolt Hound, Boltbender,
+/// Bolt of Keranos, Boltwing Marauder, THEN Beacon Bolt, Twin Bolt, Firebolt, Rift Bolt.
+///
+///   - The rank split is real: every prefix match precedes every substring match, and the
+///     substring matches ARE in the catalog. That is the half this function was getting wrong,
+///     and it is the half that decides WHICH CARDS a client is offered.
+///   - The order WITHIN a rank is neither length nor alphabetical there (Bolt Bend 9 before
+///     Boltwave 8 before Bolt Hound 10), so it is some relevance signal we do not have here.
+///     `length, card_name` is the SQL's stand-in and is kept, deliberately: matching the SQL keeps
+///     the engine and fallback paths answering alike, which is a property this branch can hold,
+///     where matching Scryfall's ranking is not.
+pub(crate) fn autocomplete_names<'a>(data: &'a Archived<CardData>, needle: &str, limit: usize) -> Vec<&'a str> {
+    let needle = needle.to_lowercase();
+    let strings = &data.strings;
+    let mut hits: Vec<(u8, usize, &str)> = Vec::new();
+    // FOLDED, not lower, and the caller folds the needle to match. Comparing the lowercase name
+    // meant an ASCII query could not reach a name carrying diacritics: `q=eowyn` returned NOTHING
+    // while `q=éowyn` returned three cards, and `jotun` and `lim-dul` returned nothing at all.
+    // api.scryfall.com answers all three (3, 3 and 8), and this corpus stores `card_name_folded`
+    // precisely so an ASCII query can reach "Éowyn". Nobody types the accent.
+    //
+    // Folding also makes the predicate answerable from `name_trigram`, which is built over this
+    // same field -- a prefix and a substring are both containments, so the index narrows both ranks
+    // soundly and the loop only re-verifies. That is why this function was left on a full scan when
+    // the other by-name lookups were narrowed: through a folded index a lower-name predicate would
+    // have dropped exactly these cards, so the speedup was unreachable until the bug was fixed.
+    for cid in name_scan_candidates(data, &needle) {
+        let card = &data.cards[cid as usize];
+        let folded = folded_name(card, &data.strings);
+        let rank = if folded.starts_with(&needle) {
+            0u8
+        } else if folded.contains(&needle) {
+            1u8
+        } else {
+            continue;
+        };
+        // The PRINTED name, not the lowercased key it matched on. A catalog entry is something a
+        // client hands straight back to /cards/named?exact=, and "lightning bolt" is not the name
+        // Scryfall prints. This was invisible while the route went to SQL (which selects
+        // card_name); wiring the route to this function is what puts it on the wire.
+        let printed = str_at(strings, u32::from(card.card_name_id)).unwrap_or(folded);
+        // CHARACTERS, not bytes. The SQL orders by `length(card_name)`, which Postgres counts in
+        // characters, and this function's contract is to answer alike. `str::len()` is bytes, so
+        // "Éowyn, Shieldmaiden" measured 20 here against 19 there -- harmless while it shifted every
+        // accented name equally, and not harmless at a tie: "Éa" (2 chars, 3 bytes) sorts before
+        // "Aaa" (3 chars, 3 bytes) in SQL, and tied-then-alphabetical after it here. Only reachable
+        // at all since the catalog started matching folded names, which is what put accented names
+        // in front of a client.
+        hits.push((rank, printed.chars().count(), printed));
+    }
+    // GROUP BY card_name: several printings of one card are one suggestion. Deduped AFTER the sort
+    // so the surviving entry is the first in the route's order, and by name alone -- two printings
+    // differing only in rank must not both appear.
+    hits.sort_unstable();
+    let mut out: Vec<&str> = Vec::with_capacity(limit.min(hits.len()));
+    for (_, _, printed) in hits {
+        if out.last() != Some(&printed) && !out.contains(&printed) {
+            out.push(printed);
+            if out.len() == limit {
+                break;
+            }
+        }
+    }
+    out
+}
+
+/// Printing ids ordered by `scryfall_id`, for binary search.
+///
+/// A permutation rather than a `(id, index)` table: the ids are already stored on the printings, so
+/// duplicating them would cost 16 bytes a row to save one indirection on a lookup that happens once
+/// per request. Ids are unique (Scryfall's primary key), so the order is total.
+fn build_printing_by_scryfall_id(printings: &[Printing]) -> Vec<u32> {
+    let mut ids: Vec<u32> = (0..printings.len() as u32).collect();
+    ids.sort_unstable_by_key(|&i| printings[i as usize].scryfall_id);
+    ids
+}
+
+/// Printing indices ordered by `illustration_id`, for `find_printing_by_illustration_id`.
+///
+/// Same permutation trick and the same 4-bytes-a-row cost as `build_printing_by_scryfall_id`: the
+/// ids are already on the rows, so a table duplicating them would cost 16 bytes a row to save one
+/// indirection on a once-per-request lookup. `sort_unstable_by_key` is enough even though the ids
+/// are NOT unique -- ties inside a run are resolved by the caller, which takes the run's minimum.
+fn build_printing_by_illustration_id(printings: &[Printing]) -> Vec<u32> {
+    let mut ids: Vec<u32> = (0..printings.len() as u32).collect();
+    ids.sort_unstable_by_key(|&i| printings[i as usize].illustration_id);
+    ids
+}
+
+/// Card ids ordered by `oracle_id`, the same shape as `build_printing_by_scryfall_id`.
+fn build_oracle_by_oracle_id(cards: &[OracleCard]) -> Vec<u32> {
+    let mut ids: Vec<u32> = (0..cards.len() as u32).collect();
+    ids.sort_unstable_by_key(|&i| cards[i as usize].oracle_id);
+    ids
+}
+
+/// Binary search a permutation built by one of the two builders above.
+///
+/// `key_of` reads the id the permutation is ordered by. Returns the index into the ORIGINAL array
+/// (the permutation's payload), not the position within the permutation.
+fn find_by_sorted_id(perm: &Archived<Vec<u32>>, id: u128, key_of: impl Fn(u32) -> u128) -> Option<u32> {
+    // 0 is parse_uuid_or_hash's null, and no real id maps to it, so a missing/absent id can never
+    // collide with a stored one.
+    if id == 0 {
+        return None;
+    }
+    let found = perm.binary_search_by(|probe| key_of(u32::from(*probe)).cmp(&id)).ok()?;
+    Some(u32::from(perm[found]))
+}
+
+/// The FIRST printing carrying this illustration id, or None.
+///
+/// Unlike `scryfall_id`, an illustration id is NOT unique -- every reprint sharing art carries the
+/// same one -- so the binary search lands somewhere inside a run rather than on a single row, and
+/// `find_by_sorted_id` cannot be reused. Printings sit in descending default-prefer order within a
+/// card, so the FIRST match in corpus order is the representative printing every other by-artwork
+/// path shows; this reproduces that by taking the minimum pid across the whole run rather than
+/// whichever member the search happened to hit.
+pub(crate) fn find_printing_by_illustration_id(
+    perm: &Archived<Vec<u32>>,
+    printings: &Archived<Vec<Printing>>,
+    id: u128,
+) -> Option<u32> {
+    if id == 0 {
+        return None;
+    }
+    let key_of = |i: u32| u128::from(printings[i as usize].illustration_id);
+    let hit = perm.binary_search_by(|probe| key_of(u32::from(*probe)).cmp(&id)).ok()?;
+    // Walk out to the run's edges. A run is one card's printings sharing an artwork, so this stays
+    // far cheaper than the scan it replaces.
+    let mut lo = hit;
+    while lo > 0 && key_of(u32::from(perm[lo - 1])) == id {
+        lo -= 1;
+    }
+    let mut hi = hit;
+    while hi + 1 < perm.len() && key_of(u32::from(perm[hi + 1])) == id {
+        hi += 1;
+    }
+    perm[lo..=hi].iter().map(|p| u32::from(*p)).min()
+}
+
+/// The printing with this Scryfall id, or None. O(log n) against a full scan.
+pub(crate) fn find_printing_by_scryfall_id(
+    perm: &Archived<Vec<u32>>,
+    printings: &Archived<Vec<Printing>>,
+    id: u128,
+) -> Option<u32> {
+    find_by_sorted_id(perm, id, |i| u128::from(printings[i as usize].scryfall_id))
+}
+
+/// The oracle card with this oracle id, or None. Backs `oracleid:` and prints-of-this-card.
+pub(crate) fn find_oracle_by_oracle_id(
+    perm: &Archived<Vec<u32>>,
+    cards: &Archived<Vec<OracleCard>>,
+    id: u128,
+) -> Option<u32> {
+    find_by_sorted_id(perm, id, |i| u128::from(cards[i as usize].oracle_id))
+}
+
 fn build_perm_printings_prefix(perm: &[u32], offsets: &[u32]) -> Vec<u32> {
     let mut prefix = Vec::with_capacity(perm.len() + 1);
     prefix.push(0);
@@ -3801,6 +5009,24 @@ struct CardIndexes {
     name_unigrams:  NameUnigramIndex,          // card space: exact 1-byte name containment (#858)
     legal_divergent: Vec<u16>,                // card space: ids with divergent legality (#630 phase 2), postings not a plane — see build_divergent_ids
     arith_tuple:    ArithTupleIndex,           // card space: joint (cmc,power,toughness,loyalty) postings for arith predicates (#743)
+    // Lookup by id, which is the one addressing mode the store has never had. `Printing.scryfall_id`
+    // and `OracleCard.oracle_id` are already the UUID's exact bits (parse_uuid_or_hash keeps them,
+    // and the comment on that field says the reason is "so future lookup-by-id can match
+    // Scryfall's") — they were simply not findable except by scanning. These are permutations, not
+    // copies: 4 bytes per row, ~390 KB and ~127 KB at corpus scale, binary searched.
+    //
+    // Without them, every /cards/:id, /cards/collection and prints-of-this-card request is a full
+    // scan, which is what pushed that whole surface onto SQL.
+    printing_by_scryfall_id: Vec<u32>,        // printing space, ordered by scryfall_id
+    // Printing space, ordered by illustration_id. `/cards/collection` accepts an illustration_id
+    // identifier and was resolving it from SQL while every sibling in that same list -- id,
+    // oracle_id, mtgo_id, multiverse_id -- went through the engine. 380 KB buys it the same
+    // O(log n) the other ids have.
+    printing_by_illustration_id: Vec<u32>,
+    oracle_by_oracle_id:     Vec<u32>,        // card space, ordered by oracle_id
+    // (namespace, external id) -> printing, sorted. Answers /cards/multiverse|mtgo|arena|tcgplayer
+    // |cardmarket/:id, none of which the store could address before.
+    external_id_index:       Vec<(u8, u64, u32)>,
 }
 
 
@@ -5532,8 +6758,11 @@ fn narrow_rec(
 
 // ─── Sort / select / limit ────────────────────────────────────────────────────
 
+/// `EurLow`/`TixLow` have no `prefer=` spelling — they are not user-selectable, and
+/// `prefer_from_str` cannot produce them. They exist only so `prefer_for_sort` can
+/// express "cheapest printing" for the two price columns that have no `usd_low` twin.
 #[derive(Clone, Copy)]
-enum Prefer { Oldest, Newest, UsdLow, UsdHigh, Promo, Default }
+enum Prefer { Oldest, Newest, UsdLow, UsdHigh, EurLow, TixLow, Promo, Default }
 
 fn prefer_from_str(s: &str) -> Prefer {
     match s {
@@ -5546,6 +6775,39 @@ fn prefer_from_str(s: &str) -> Prefer {
     }
 }
 
+/// A price ordering ranks each card by its CHEAPEST printing, and the row it returns is
+/// that printing — so under `unique=card`/`unique=artwork` the group's representative has
+/// to be chosen by the price being ordered on, not by `prefer_score`.
+///
+/// Measured against api.scryfall.com on 2026-08-11, `unique=cards`, both directions:
+///
+/// ```text
+/// Birds of Paradise  order=usd -> msc #170 $9.60   (min; the dearest is leb #187 $1000)
+/// Counterspell       order=usd -> brb #15  $2.30   (min; the dearest is leb #55  $919.92)
+/// Gandalf the White  order=usd -> ltr #19  $10.22  (min; the dearest is ltr #299 $2999.99)
+/// Gandalf the White  order=tix -> ltr #470 0.02    (min; ltr #19 at 0.03 is NOT chosen)
+/// Juzám Djinn        order=usd -> arn #29  $1827   (its only priced printing)
+/// ```
+///
+/// Direction does not enter into it: `dir=asc` and `dir=desc` return the same printing and
+/// only reverse the list. Nor is the choice `prefer_score`-shaped — the cheapest printing is
+/// systematically the *least* canonical one (world-championship decks, bulk reprints), so no
+/// amount of `prefer_score` tuning reaches this answer. Left on `Prefer::Default` the engine
+/// instead ranks each card by whatever its most canonical printing costs, which drops cards
+/// whose canonical printing is unpriced (Juzám Djinn's oversized promo) and floats cards
+/// whose canonical printing is a premium variant (Gandalf's $2999.99 serialized ltr #299).
+///
+/// An explicit `prefer=` still wins: it is the caller saying which printing they want, and
+/// `usd_low` already IS this rule spelled out by hand.
+fn prefer_for_sort(prefer: Prefer, sort_col: SortCol) -> Prefer {
+    match (prefer, sort_col) {
+        (Prefer::Default, SortCol::PriceUsd) => Prefer::UsdLow,
+        (Prefer::Default, SortCol::PriceEur) => Prefer::EurLow,
+        (Prefer::Default, SortCol::PriceTix) => Prefer::TixLow,
+        _ => prefer,
+    }
+}
+
 /// The `unique` string → `Mode` mapping, in one place. Anything other than the
 /// literal `"artwork"`/`"printing"` is `Mode::Card` (not just the literal
 /// `"card"`) — see `split_planes`'s `unique_is_card` doc. Shared by `run_query`,
@@ -5566,8 +6828,13 @@ fn prefer_score(card: &AOracleCard, p: &APrinting, prefer: Prefer) -> f64 {
     match prefer {
         Prefer::Oldest  => -(p.released_at_int.as_ref().map(|v| u32::from(*v)).unwrap_or(99_999_999) as f64),
         Prefer::Newest  => p.released_at_int.as_ref().map(|v| u32::from(*v)).unwrap_or(0) as f64,
+        // The `*Low` arms negate, so a MISSING price scores -inf and loses to every priced
+        // printing — a group with any priced printing is represented by one, and a group with
+        // none keeps its first-in-store-order (highest `prefer_score`) printing.
         Prefer::UsdLow  => -p.price_usd.as_ref().map(|v| f64::from(u32::from(*v)) / 100.0).unwrap_or(f64::INFINITY),
         Prefer::UsdHigh => p.price_usd.as_ref().map(|v| f64::from(u32::from(*v)) / 100.0).unwrap_or(0.0),
+        Prefer::EurLow  => -p.price_eur.as_ref().map(|v| f64::from(u32::from(*v)) / 100.0).unwrap_or(f64::INFINITY),
+        Prefer::TixLow  => -p.price_tix.as_ref().map(|v| f64::from(u32::from(*v)) / 100.0).unwrap_or(f64::INFINITY),
         // Card-level (edhrec is oracle-scoped): every printing ties, so the
         // first printing in store order is chosen — same as before the split.
         Prefer::Promo   => -(card.edhrec_rank.as_ref().map(|r| u32::from(*r) as f64).unwrap_or(f64::INFINITY)),
@@ -5576,8 +6843,14 @@ fn prefer_score(card: &AOracleCard, p: &APrinting, prefer: Prefer) -> f64 {
 }
 
 #[derive(Clone, Copy)]
-enum SortCol { Cmc, Power, Toughness, Rarity, PriceUsd, Cubecobra, EdhrecRank, Name }
+enum SortCol {
+    Cmc, Power, Toughness, Rarity, PriceUsd, PriceEur, PriceTix,
+    Cubecobra, EdhrecRank, Name, Released, Color, Set, Artist,
+}
 
+/// Every arm here must have a `CardOrdering` member in api/enums.py and a `sql_orderby` entry in
+/// api_resource.py. The fallthrough is why: an order name the API knows and this does not sorts by
+/// edhrec here while SQL sorts by the real column, so the two paths disagree on identical input.
 fn orderby_to_col(orderby: &str) -> SortCol {
     match orderby {
         "cmc"       => SortCol::Cmc,
@@ -5585,12 +6858,50 @@ fn orderby_to_col(orderby: &str) -> SortCol {
         "rarity"    => SortCol::Rarity,
         "toughness" => SortCol::Toughness,
         "usd"       => SortCol::PriceUsd,
+        "eur"       => SortCol::PriceEur,
+        "tix"       => SortCol::PriceTix,
         "cubecobra" => SortCol::Cubecobra,
         "name"      => SortCol::Name,
+        "released"  => SortCol::Released,
+        "color"     => SortCol::Color,
+        "set"       => SortCol::Set,
+        "artist"    => SortCol::Artist,
         _           => SortCol::EdhrecRank,
     }
 }
 
+/// Pack a `yyyymmdd` date into a small order-preserving integer.
+///
+/// The sort key rounds its primary through f32, which is exact only below 2^24 (see `name_rank`).
+/// A raw `yyyymmdd` is ~20,260,809 -- past that, so two dates a day apart can collide. This keeps
+/// the ordering and drops the magnitude: distinct years are 372 apart, which exceeds the largest
+/// in-year offset (11*31 + 30 = 371), so the packing is strictly monotonic for valid dates and
+/// tops out near 755,000 for 2030. `released_at_int` itself stays `yyyymmdd`, which is what the
+/// date and year filters compare against.
+fn released_sort_ord(yyyymmdd: u32) -> u32 {
+    let (y, m, d) = (yyyymmdd / 10_000, (yyyymmdd / 100) % 100, yyyymmdd % 100);
+    y * 372 + m.saturating_sub(1) * 31 + d.saturating_sub(1)
+}
+
+/// Scryfall's `order=color` bucketing, measured 2026-08-09 over 923 cards spanning every colour
+/// shape: `W U B R G`, then multicolour by HOW MANY colours (not which -- guild pairs tie and fall
+/// to the secondary sort), then colourless, then lands. Two parts of that are not what a popcount
+/// would give: colourless sorts last rather than first, and lands sort after it.
+fn color_sort_rank(colors: u8, type_bits: u16) -> u32 {
+    // WUBRG in Scryfall's order; the bit values are color_to_bit's. The C bit is masked off rather
+    // than counted: a colourless card ranks by being colourless, and C alongside a real colour
+    // would otherwise read as an extra colour.
+    const MONO_ORDER: [u8; 5] = [1, 2, 4, 8, 16];
+    const WUBRG: u8 = 1 | 2 | 4 | 8 | 16;
+    let colors = colors & WUBRG;
+    match colors.count_ones() {
+        0 if type_bits & TYPE_LAND != 0 => 10,
+        0 => 9,
+        1 => MONO_ORDER.iter().position(|&bit| colors == bit).unwrap_or(0) as u32,
+        n => 3 + n, // 2 colours -> 5, 3 -> 6, 4 -> 7, 5 -> 8
+    }
+}
+
 /// Map an f32 to a u32 that orders like `f32::total_cmp` (sign-flip trick).
 fn f32_sort_bits(v: f32) -> u32 {
     let b = v.to_bits();
@@ -5622,9 +6933,27 @@ fn sort_key_bits(card: &AOracleCard, p: &APrinting, sort_col: SortCol, descendin
         // exposed value), and cents fit exactly in f32 (max real price 514,202 cents, f32
         // represents any integer up to 2^24 exactly), so skip the /100.0 dollars conversion.
         SortCol::PriceUsd   => p.price_usd.as_ref().map(|v| u32::from(*v) as f32),
+        SortCol::PriceEur   => p.price_eur.as_ref().map(|v| u32::from(*v) as f32),
+        SortCol::PriceTix   => p.price_tix.as_ref().map(|v| u32::from(*v) as f32),
         SortCol::Cubecobra  => card.cubecobra_score.as_ref().map(|v| f32::from(*v)),
         SortCol::EdhrecRank => card.edhrec_rank.as_ref().map(|v| u32::from(*v) as f32),
         SortCol::Name       => Some(u32::from(card.name_rank) as f32),
+        // Packed rather than raw: yyyymmdd exceeds the exact-f32 range (see released_sort_ord).
+        SortCol::Released   => p.released_at_int.as_ref().map(|v| released_sort_ord(u32::from(*v)) as f32),
+        SortCol::Color      => Some(color_sort_rank(card.card_colors, u16::from(card.card_types)) as f32),
+        // Dense ranks assigned post-load; the stored code and artist id do not sort alphabetically
+        // on their own (see assign_set_ranks / assign_artist_ranks).
+        SortCol::Set        => Some(u32::from(p.set_rank) as f32),
+        // Nullable, unlike `Set` beside it: `card_set_code` is non-null but an artist is not, and
+        // `assign_artist_ranks` puts the artistless printings in a trailing rank block keyed on
+        // `(name.is_none(), name)`. Reporting that block as a VALUE made `order=artist` the one
+        // ordering whose absent side moved with the direction in the wrong sense — artistless
+        // sorted last ascending (right) but FIRST descending (wrong), because a real rank reflects
+        // and the absent sentinel does not. Returning None puts it back under the same rule as
+        // every other column. No change to `assign_artist_ranks`: its trailing block is disjoint
+        // from every named rank, so it simply stops being read. 7 printings on the production
+        // corpus, so this is a correctness tidy rather than a visible reshuffle.
+        SortCol::Artist     => (p.card_artist_vid != ARTIST_NONE).then(|| u32::from(p.artist_rank) as f32),
     };
     let pk = primary.map_or(u32::MAX, |v| f32_sort_bits(if descending { -v } else { v }));
     let e = card.edhrec_rank.as_ref().map(|v| u32::from(*v)).unwrap_or(u32::MAX);
@@ -5863,10 +7192,14 @@ impl QueryParams {
     /// `orderby_to_col`/`== "desc"`/`prefer_from_str`/`mode_from_unique` block
     /// each used to repeat.
     fn from_strs(unique: &str, prefer: &str, orderby: &str, direction: &str, limit: usize, page_offset: usize) -> Self {
+        // `prefer` depends on `sort_col`, so bind the column first — see `prefer_for_sort`.
+        // This is the only `QueryParams` constructor, which is what makes one call here enough
+        // to cover `run_query`, `run_query_with_plan`, `explain_analyze` and `explain`.
+        let sort_col = orderby_to_col(orderby);
         QueryParams {
             mode: mode_from_unique(unique),
-            prefer: prefer_from_str(prefer),
-            sort_col: orderby_to_col(orderby),
+            prefer: prefer_for_sort(prefer_from_str(prefer), sort_col),
+            sort_col,
             descending: direction == "desc",
             limit,
             page_offset,
@@ -12918,6 +14251,7 @@ const FIELD_TABLE: &[(&str, FieldExtractor)] = &[
     ("collector_number", |py, _c, p, s, _v| Ok(str_at(s, u32::from(p.collector_number_id)).into_pyobject(py)?.into_any())),
     ("power", |py, c, _p, s, _v| Ok(str_at(s, u32::from(c.creature_power_text_id)).into_pyobject(py)?.into_any())),
     ("toughness", |py, c, _p, s, _v| Ok(str_at(s, u32::from(c.creature_toughness_text_id)).into_pyobject(py)?.into_any())),
+    ("loyalty", |py, c, _p, s, _v| Ok(str_at(s, u32::from(c.planeswalker_loyalty_text_id)).into_pyobject(py)?.into_any())),
     ("mana_cost", |py, c, _p, s, _v| Ok(str_at(s, u32::from(c.mana_cost_text_id)).into_pyobject(py)?.into_any())),
     ("oracle_text", |py, c, _p, s, _v| Ok(str_at(s, u32::from(c.oracle_text_id)).into_pyobject(py)?.into_any())),
     ("set_name", |py, _c, p, s, _v| Ok(str_at(s, u32::from(p.set_name_id)).into_pyobject(py)?.into_any())),
@@ -12928,6 +14262,10 @@ const FIELD_TABLE: &[(&str, FieldExtractor)] = &[
     // now see the true price (e.g. 1.47, not the nearest f32 to 1.47) instead of an
     // approximation.
     ("price_usd", |py, _c, p, _s, _v| Ok(p.price_usd.as_ref().map(|v| f64::from(u32::from(*v)) / 100.0).into_pyobject(py)?.into_any())),
+    // The other two currencies `order=` already sorts by. Without these a caller can rank a
+    // page by EUR or TIX and then have no way to read the number it was ranked on.
+    ("price_eur", |py, _c, p, _s, _v| Ok(p.price_eur.as_ref().map(|v| f64::from(u32::from(*v)) / 100.0).into_pyobject(py)?.into_any())),
+    ("price_tix", |py, _c, p, _s, _v| Ok(p.price_tix.as_ref().map(|v| f64::from(u32::from(*v)) / 100.0).into_pyobject(py)?.into_any())),
     ("prefer_score", |py, _c, p, _s, _v| Ok(p.prefer_score.as_ref().map(|v| f32::from(*v)).into_pyobject(py)?.into_any())),
     // card_subtypes preserves the printed order; the set-like collections are stored
     // sorted by vocab id (first-seen order), so they get re-sorted lexicographically
@@ -12955,18 +14293,192 @@ const FIELD_TABLE: &[(&str, FieldExtractor)] = &[
         let bits = if c.legality_divergent { u64::from(p.card_legalities) } else { u64::from(c.card_legalities) };
         Ok(legality_bits_to_pydict(py, bits)?.into_any())
     }),
+    // ── The compat residue, in Scryfall's own field names ────────────────────────────────────
+    // Each is requestable on its own, like every entry above, and together they are what a
+    // reconstructed card object needs beyond the columns and the derived URLs. Absent stays
+    // absent: these emit None rather than a zero value, because Scryfall OMITS a key it has no
+    // value for, and a card that sprouts nulls Scryfall never sent differs from Scryfall on
+    // every row.
+    ("lang", |py, _c, p, _s, v| Ok(coll_str_opt(v, u16::from(p.compat.lang_id)).into_pyobject(py)?.into_any())),
+    ("image_status", |py, _c, p, _s, v| Ok(coll_str_opt(v, u16::from(p.compat.image_status_id)).into_pyobject(py)?.into_any())),
+    ("set_type", |py, _c, p, _s, v| Ok(coll_str_opt(v, u16::from(p.compat.set_type_id)).into_pyobject(py)?.into_any())),
+    ("security_stamp", |py, _c, p, _s, v| Ok(coll_str_opt(v, u16::from(p.compat.security_stamp_id)).into_pyobject(py)?.into_any())),
+    ("set_id", |py, _c, p, _s, v| Ok(coll_str_opt(v, u16::from(p.compat.set_vid)).into_pyobject(py)?.into_any())),
+    ("arena_id", |py, _c, p, _s, _v| Ok(p.compat.arena_id.as_ref().map(|v| v.get()).into_pyobject(py)?.into_any())),
+    ("mtgo_id", |py, _c, p, _s, _v| Ok(p.compat.mtgo_id.as_ref().map(|v| v.get()).into_pyobject(py)?.into_any())),
+    ("mtgo_foil_id", |py, _c, p, _s, _v| Ok(p.compat.mtgo_foil_id.as_ref().map(|v| v.get()).into_pyobject(py)?.into_any())),
+    ("tcgplayer_id", |py, _c, p, _s, _v| Ok(p.compat.tcgplayer_id.as_ref().map(|v| v.get()).into_pyobject(py)?.into_any())),
+    ("tcgplayer_etched_id", |py, _c, p, _s, _v| Ok(p.compat.tcgplayer_etched_id.as_ref().map(|v| v.get()).into_pyobject(py)?.into_any())),
+    ("cardmarket_id", |py, _c, p, _s, _v| Ok(p.compat.cardmarket_id.as_ref().map(|v| v.get()).into_pyobject(py)?.into_any())),
+    ("penny_rank", |py, _c, p, _s, _v| Ok(p.compat.penny_rank.as_ref().map(|v| v.get()).into_pyobject(py)?.into_any())),
+    ("image_updated_at", |py, _c, p, _s, _v| Ok(p.compat.image_updated_at.as_ref().map(|v| v.get()).into_pyobject(py)?.into_any())),
+    // Dollars from integer cents, the same conversion price_usd uses.
+    ("price_usd_foil", |py, _c, p, _s, _v| Ok(p.compat.price_usd_foil.as_ref().map(|v| f64::from(v.get()) / 100.0).into_pyobject(py)?.into_any())),
+    ("price_usd_etched", |py, _c, p, _s, _v| Ok(p.compat.price_usd_etched.as_ref().map(|v| f64::from(v.get()) / 100.0).into_pyobject(py)?.into_any())),
+    ("price_eur_foil", |py, _c, p, _s, _v| Ok(p.compat.price_eur_foil.as_ref().map(|v| f64::from(v.get()) / 100.0).into_pyobject(py)?.into_any())),
+    ("multiverse_ids", |py, _c, p, _s, _v| {
+        let ids: Vec<u32> = p.compat.multiverse_ids.iter().map(|v| u32::from(*v)).collect();
+        Ok(ids.into_pyobject(py)?.into_any())
+    }),
+    ("promo_types", |py, _c, p, _s, v| Ok(sorted_strs(v, &p.compat.promo_types).into_pyobject(py)?.into_any())),
+    ("frame_effects", |py, _c, p, _s, v| Ok(sorted_strs(v, &p.compat.frame_effects).into_pyobject(py)?.into_any())),
+    ("games", |py, _c, p, _s, _v| Ok(bits_to_names(p.compat.games, GAME_NAMES).into_pyobject(py)?.into_any())),
+    ("finishes", |py, _c, p, _s, _v| Ok(bits_to_names(p.compat.finishes, FINISH_NAMES).into_pyobject(py)?.into_any())),
+    ("booster", |py, _c, p, _s, _v| Ok(compat_flag(p, COMPAT_BOOSTER).into_pyobject(py)?.to_owned().into_any())),
+    ("digital", |py, _c, p, _s, _v| Ok(compat_flag(p, COMPAT_DIGITAL).into_pyobject(py)?.to_owned().into_any())),
+    ("foil", |py, _c, p, _s, _v| Ok(compat_flag(p, COMPAT_FOIL).into_pyobject(py)?.to_owned().into_any())),
+    ("nonfoil", |py, _c, p, _s, _v| Ok(compat_flag(p, COMPAT_NONFOIL).into_pyobject(py)?.to_owned().into_any())),
+    ("full_art", |py, _c, p, _s, _v| Ok(compat_flag(p, COMPAT_FULL_ART).into_pyobject(py)?.to_owned().into_any())),
+    ("highres_image", |py, _c, p, _s, _v| Ok(compat_flag(p, COMPAT_HIGHRES_IMAGE).into_pyobject(py)?.to_owned().into_any())),
+    ("oversized", |py, _c, p, _s, _v| Ok(compat_flag(p, COMPAT_OVERSIZED).into_pyobject(py)?.to_owned().into_any())),
+    ("promo", |py, _c, p, _s, _v| Ok(compat_flag(p, COMPAT_PROMO).into_pyobject(py)?.to_owned().into_any())),
+    ("reprint", |py, _c, p, _s, _v| Ok(compat_flag(p, COMPAT_REPRINT).into_pyobject(py)?.to_owned().into_any())),
+    ("story_spotlight", |py, _c, p, _s, _v| Ok(compat_flag(p, COMPAT_STORY_SPOTLIGHT).into_pyobject(py)?.to_owned().into_any())),
+    ("textless", |py, _c, p, _s, _v| Ok(compat_flag(p, COMPAT_TEXTLESS).into_pyobject(py)?.to_owned().into_any())),
+    ("variation", |py, _c, p, _s, _v| Ok(compat_flag(p, COMPAT_VARIATION).into_pyobject(py)?.to_owned().into_any())),
+    // Each face as its own dict, front first, in Scryfall's key names. Empty list for a
+    // single-faced card, which is how Scryfall omits card_faces entirely.
+    ("card_faces", |py, c, p, s, v| Ok(faces_to_pylist(py, c, p, s, v)?.into_any())),
+    // Scryfall's related-card list. Each entry carries its own id/name/type_line because most
+    // point outside the corpus -- a `token` component references a card the import filters out.
+    ("all_parts", |py, c, _p, s, v| {
+        let mut out: Vec<Bound<PyDict>> = Vec::with_capacity(c.all_parts.len());
+        for part in c.all_parts.iter() {
+            let d = PyDict::new(py);
+            d.set_item("object", "related_card")?;
+            d.set_item("id", uuid_from_u128(u128::from(part.id)))?;
+            d.set_item("component", coll_str_opt(v, u16::from(part.component_id)))?;
+            d.set_item("name", str_at(s, u32::from(part.name_id)))?;
+            d.set_item("type_line", str_at(s, u32::from(part.type_line_id)))?;
+            out.push(d);
+        }
+        Ok(PyList::new(py, out)?.into_any())
+    }),
+    // `colors` is this PR's addition; #877 already supplies layout, cmc, rarity,
+    // color_identity and legalities, so those are not repeated here.
+    ("colors", |py, c, _p, _s, _v| Ok(identity_letters(c.card_colors).into_pyobject(py)?.into_any())),
+    // `to_scryfall_card` reads both of these, and neither had an entry here or a place in
+    // CARD_OBJECT_FIELDS -- so on the ENGINE path every card object carried `border_color: null`
+    // and no `frame` at all, where Scryfall always sends both. Only the accessors were missing;
+    // both values were already stored.
+    ("border_color", |py, _c, p, s, _v| Ok(str_at(s, u32::from(p.card_border_id)).into_pyobject(py)?.into_any())),
+    ("frame", |py, _c, p, _s, v| Ok(frame_of(p, v).into_pyobject(py)?.into_any())),
+    // ── The remaining fields a card object needs ─────────────────────────────────────────────
+    ("oracle_id", |py, c, _p, _s, _v| Ok(uuid_from_u128(u128::from(c.oracle_id)).into_pyobject(py)?.into_any())),
+    ("flavor_text", |py, _c, p, s, _v| Ok(str_at(s, u32::from(p.flavor_text_id)).into_pyobject(py)?.into_any())),
+    ("artist", |py, _c, p, _s, v| Ok(coll_str_opt(v, u16::from(p.card_artist_vid)).into_pyobject(py)?.into_any())),
+    ("watermark", |py, _c, p, s, _v| Ok(str_at(s, u32::from(p.card_watermark_id)).into_pyobject(py)?.into_any())),
+    ("edhrec_rank", |py, c, _p, _s, _v| Ok(c.edhrec_rank.as_ref().copied().map(u32::from).into_pyobject(py)?.into_any())),
+    ("price_eur", |py, _c, p, _s, _v| Ok(p.price_eur.as_ref().map(|v| f64::from(u32::from(*v)) / 100.0).into_pyobject(py)?.into_any())),
+    ("price_tix", |py, _c, p, _s, _v| Ok(p.price_tix.as_ref().map(|v| f64::from(u32::from(*v)) / 100.0).into_pyobject(py)?.into_any())),
+    // ISO date, the shape Scryfall sends and JSON can carry. The store holds it as an int.
+    ("released_at", |py, _c, p, _s, _v| {
+        Ok(p.released_at_int.as_ref().copied().map(u32::from).map(released_int_to_iso).into_pyobject(py)?.into_any())
+    }),
 ];
 
 /// Mirror of magic.rarity_int_to_text -- the import stores 0-5, Scryfall speaks words.
-const RARITY_NAMES: [&str; 6] = ["common", "uncommon", "rare", "mythic", "special", "bonus"];
-
 fn rarity_int_to_text(value: u8) -> Option<&'static str> {
-    RARITY_NAMES.get(value as usize).copied()
+    match value {
+        0 => Some("common"),
+        1 => Some("uncommon"),
+        2 => Some("rare"),
+        3 => Some("mythic"),
+        4 => Some("special"),
+        5 => Some("bonus"),
+        _ => None,
+    }
+}
+
+/// Decode a colour bitmap into Scryfall's WUBRG-ordered letter list (C last, as Scryfall lists it).
+///
+/// Used for color_identity, a card's own colors, and each face's colors and colour indicator.
+/// #877 introduced it; this PR widened its visibility rather than adding a second function with
+/// the same body under a different name.
+pub(crate) fn identity_letters(mask: u8) -> Vec<&'static str> {
+    [("W", 1u8), ("U", 2), ("B", 4), ("R", 8), ("G", 16), ("C", 32)]
+        .iter()
+        .filter(|(_, bit)| mask & bit != 0)
+        .map(|(letter, _)| *letter)
+        .collect()
+}
+
+
+
+/// `20200101` -> `"2020-01-01"`. The store packs the date as an int; Scryfall sends ISO.
+fn released_int_to_iso(value: u32) -> String {
+    format!("{:04}-{:02}-{:02}", value / 10_000, (value / 100) % 100, value % 100)
+}
+
+/// Scryfall's `frame`, recovered from `card_frame_data`.
+///
+/// The import folds Scryfall's `frame` and its `frame_effects` into one title-cased collection
+/// (card_processing.py), so the frame is whichever member belongs to Scryfall's closed frame
+/// vocabulary rather than "the first one" -- a card with no frame but an effect would otherwise
+/// report the effect as its frame.
+pub(crate) fn frame_of(p: &APrinting, vocab: &AStrings) -> Option<&'static str> {
+    const FRAMES: [(&str, &str); 5] =
+        [("1993", "1993"), ("1997", "1997"), ("2003", "2003"), ("2015", "2015"), ("Future", "future")];
+    p.card_frame_data.iter().find_map(|id| {
+        let name = coll_str(vocab, u16::from(*id));
+        FRAMES.iter().find(|(titled, _)| *titled == name).map(|(_, scryfall)| *scryfall)
+    })
+}
+
+/// Bitset member names, in the order Scryfall lists them.
+const GAME_NAMES: &[(&str, u8)] = &[("paper", GAME_PAPER), ("mtgo", GAME_MTGO), ("arena", GAME_ARENA)];
+const FINISH_NAMES: &[(&str, u8)] =
+    &[("nonfoil", FINISH_NONFOIL), ("foil", FINISH_FOIL), ("etched", FINISH_ETCHED), ("glossy", FINISH_GLOSSY)];
+
+fn bits_to_names(bits: u8, table: &[(&'static str, u8)]) -> Vec<&'static str> {
+    table.iter().filter(|(_, bit)| bits & bit != 0).map(|(name, _)| *name).collect()
 }
 
-/// Decode an identity bitmap into Scryfall's WUBRG-ordered letter list.
-fn identity_letters(mask: u8) -> Vec<&'static str> {
-    ["W", "U", "B", "R", "G", "C"].into_iter().filter(|c| mask & color_to_bit(c) != 0).collect()
+fn compat_flag(p: &APrinting, bit: u16) -> bool {
+    u16::from(p.compat.flags) & bit != 0
+}
+
+/// A compat vocab id, or None when the key was absent. Distinct from `coll_str`, which has no
+/// absent case: every collection element is a real entry, while a compat field routinely is not.
+fn coll_str_opt(vocab: &AStrings, id: u16) -> Option<&str> {
+    if id == VOCAB_NONE { None } else { Some(coll_str(vocab, id)) }
+}
+
+/// The card's faces as Scryfall shapes them: text from the oracle card, art from this printing.
+///
+/// `object` and `image_uris` are omitted deliberately -- the first is the constant "card_face" and
+/// the second is a pure function of the card's id and the face's position, so both are re-emitted
+/// by the caller rather than stored.
+fn faces_to_pylist<'py>(
+    py: Python<'py>,
+    card: &AOracleCard,
+    printing: &APrinting,
+    strings: &AStrings,
+    vocab: &AStrings,
+) -> PyResult<Bound<'py, PyList>> {
+    let mut out: Vec<Bound<PyDict>> = Vec::with_capacity(card.faces.len());
+    for (i, face) in card.faces.iter().enumerate() {
+        let d = PyDict::new(py);
+        d.set_item("name", str_at(strings, u32::from(face.card_name_id)))?;
+        d.set_item("mana_cost", str_at(strings, u32::from(face.mana_cost_text_id)))?;
+        d.set_item("type_line", str_at(strings, u32::from(face.type_line_id)))?;
+        d.set_item("oracle_text", str_at(strings, u32::from(face.oracle_text_id)))?;
+        d.set_item("power", str_at(strings, u32::from(face.creature_power_text_id)))?;
+        d.set_item("toughness", str_at(strings, u32::from(face.creature_toughness_text_id)))?;
+        d.set_item("loyalty", str_at(strings, u32::from(face.planeswalker_loyalty_text_id)))?;
+        d.set_item("defense", str_at(strings, u32::from(face.defense_text_id)))?;
+        d.set_item("colors", identity_letters(face.card_colors))?;
+        d.set_item("color_indicator", identity_letters(face.color_indicator))?;
+        // Art is per printing, and a printing may carry fewer face-art records than the card has
+        // faces; those faces simply have no art rather than borrowing the wrong face's.
+        if let Some(art) = printing.faces.get(i) {
+            d.set_item("artist", coll_str_opt(vocab, u16::from(art.card_artist_vid)))?;
+            d.set_item("illustration_id", uuid_from_u128(u128::from(art.illustration_id)))?;
+            d.set_item("flavor_text", str_at(strings, u32::from(art.flavor_text_id)))?;
+        }
+        out.push(d);
+    }
+    PyList::new(py, out)
 }
 
 /// Resolve one interned collection-element id against the archived vocab table.
@@ -13059,7 +14571,19 @@ const ARCHIVE_MAGIC: [u8; 8] = *b"ATCARDS\0";
 //
 // 2026082501 — `SortPermutations` gains per-order printing-span prefix sums, used to turn a bound on
 // cards visited into a sound O(1) bound on printings examined. Entirely inside `CardIndexes` again.
-const ARCHIVE_FORMAT_VERSION: u32 = 2026082501;
+//
+// 2026082703 — the scryfall-cards-api merge. This branch's layout changes land here: `Printing`
+// gains `set_rank` and `artist_rank`, the dense ranks the six new `order=` values sort by (#913),
+// and `OracleCard.card_name_folded` becomes an interned `card_name_folded_id` (304 -> 240 bytes;
+// it held a string identical to `card_name_lower` on every card whose name carries no diacritic —
+// 31,636 of 31,724 on the current corpus, so 61 bytes a card bought 88 exceptions). The struct
+// sizes move, so the header would catch these on its own — but both sides of the merge had spent
+// 2026082301/2026082302 on DIFFERENT layouts, and the check is equality with a never-reuse
+// invariant, so the merged layout takes a value strictly newer than either parent's. 01 and 02
+// are already spent the same way by two sibling branches (#920's `scryfall_prefer_score`, #913's
+// own re-pin of the rank fields) — three open branches, three distinct values, so no pair can
+// merge textually clean into one value meaning two layouts.
+const ARCHIVE_FORMAT_VERSION: u32 = 2026082703;
 const ARCHIVE_HEADER_LEN: usize = 16;
 
 fn archive_header() -> [u8; ARCHIVE_HEADER_LEN] {
@@ -13365,9 +14889,52 @@ impl QueryEngine {
                 self.shm_path.display(),
             )));
         }
+        // Adopt this archive's legality shifts NOW, while the mapping is being established, rather
+        // than leaving it to the first filter query. `legality_bits_to_pydict` and its JSON twin
+        // decode against the process-global FORMAT_SHIFTS registry and report an EMPTY object when
+        // it is unpopulated -- not an error -- and the only other caller of sync_format_shifts is
+        // bind_and_split_filter, on the filter path. A multi-process server is exactly the case
+        // that breaks: a worker that mmaps an archive it did not import has an empty registry, so
+        // every route resolving a card WITHOUT filtering (/cards/named, /cards/:id,
+        // /cards/collection) answered `"legalities": {}` until that worker happened to serve a
+        // search. Syncing here makes the registry a property of having an archive mapped.
+        //
+        // Safety: the same argument as every other access_unchecked on this mapping -- the header
+        // was just checked against this build's, and the file is replaced by rename, never
+        // modified in place while mapped.
+        let data = unsafe { rkyv::access_unchecked::<Archived<CardData>>(archive_payload(&mmap)) };
+        sync_format_shifts(&data.format_shifts);
         *guard = Some(CachedMmap { mmap: Arc::clone(&mmap), inode });
         Ok(mmap)
     }
+
+    /// The body shared by `exact_card_by_name` and `collection_card_by_name`.
+    ///
+    /// Off the `#[pymethods]` block on purpose: everything in there is exported to Python, and the
+    /// two name routes differ only by which lookup they hand in -- a Rust function with no Python
+    /// spelling, so this is not a signature a caller could reach.
+    fn card_by_name<'py>(
+        &self,
+        py: Python<'py>,
+        folded: &str,
+        set_code: Option<&str>,
+        fields: Option<Vec<String>>,
+        lookup: NameLookup,
+    ) -> PyResult<Option<Bound<'py, PyDict>>> {
+        let resolved_fields = resolve_fields(fields)?;
+        let mmap = self.get_mmap()?;
+        // Safety: see the access_unchecked justification in query().
+        let data = unsafe { rkyv::access_unchecked::<Archived<CardData>>(archive_payload(&mmap)) };
+        let Some((cid, pid)) = lookup(data, folded, set_code) else { return Ok(None) };
+        Ok(Some(card_to_pydict(
+            py,
+            &data.cards[cid],
+            &data.printings[pid],
+            &data.strings,
+            &data.coll_vocab,
+            &resolved_fields,
+        )?))
+    }
 }
 
 #[pymethods]
@@ -13477,7 +15044,7 @@ impl QueryEngine {
         let staging = self.staging.lock().unwrap().take().ok_or_else(|| {
             pyo3::exceptions::PyRuntimeError::new_err("reload_commit called without reload_begin")
         })?;
-        let Staging { mut rows, interner, vocab, artists, mana, lock_file } = staging;
+        let Staging { mut rows, mut interner, vocab, artists, mana, lock_file } = staging;
 
         // The store groups printings by oracle_id, so rows without one would all
         // collapse into a single card. The DB enforces NOT NULL; fail loudly here
@@ -13522,7 +15089,15 @@ impl QueryEngine {
                 offsets.push(printings.len() as u32);
                 cards.push(OracleCard {
                     card_name_lower: row.card_name_lower,
-                    card_name_folded: row.card_name_folded,
+                    // Only names that actually fold differently reach the table; the rest carry
+                    // NONE_STR, meaning "identical to card_name_lower". Interned rather than
+                    // appended because the interner is still whole here, so the handful of
+                    // exceptions dedupe against strings the corpus already holds.
+                    card_name_folded_id: if row.card_name_folded.as_str() == row.card_name_lower.as_str() {
+                        NONE_STR
+                    } else {
+                        interner.intern(row.card_name_folded.as_str().to_owned())
+                    },
                     card_colors: row.card_colors,
                     card_color_identity: row.card_color_identity,
                     produced_mana: row.produced_mana,
@@ -13550,6 +15125,27 @@ impl QueryEngine {
                     mana_cost: row.mana_cost.clone(),
                     creature_power_text_id: row.creature_power_text_id,
                     creature_toughness_text_id: row.creature_toughness_text_id,
+                    planeswalker_loyalty_text_id: row.planeswalker_loyalty_text_id,
+                    // Face TEXT is the same on every printing of a card, so the group's first row
+                    // supplies it, exactly like the scalars above. Borrowed rather than taken:
+                    // the Printing below still needs the art half of the same faces.
+                    faces: row
+                        .card_faces
+                        .iter()
+                        .map(|f| OracleFace {
+                            card_name_id: f.card_name_id,
+                            mana_cost_text_id: f.mana_cost_text_id,
+                            type_line_id: f.type_line_id,
+                            oracle_text_id: f.oracle_text_id,
+                            creature_power_text_id: f.creature_power_text_id,
+                            creature_toughness_text_id: f.creature_toughness_text_id,
+                            planeswalker_loyalty_text_id: f.planeswalker_loyalty_text_id,
+                            defense_text_id: f.defense_text_id,
+                            card_colors: f.card_colors,
+                            color_indicator: f.color_indicator,
+                        })
+                        .collect(),
+                    all_parts: std::mem::take(&mut row.all_parts),
                 });
             } else if row.card_legalities != cards.last().map(|c| c.card_legalities).unwrap_or(0) {
                 cards.last_mut().unwrap().legality_divergent = true;
@@ -13561,6 +15157,10 @@ impl QueryEngine {
                 flavor_text_lower_id: row.flavor_text_lower_id,
                 card_artist_vid: row.card_artist_vid,
                 card_set_code: row.card_set_code,
+                // Both assigned once the whole printing list exists, by assign_set_ranks /
+                // assign_artist_ranks -- a dense rank cannot be known one row at a time.
+                set_rank: 0,
+                artist_rank: 0,
                 card_border_id: row.card_border_id,
                 card_watermark_id: row.card_watermark_id,
                 collector_number_id: row.collector_number_id,
@@ -13577,6 +15177,19 @@ impl QueryEngine {
                 card_is_tags: row.card_is_tags,
                 card_frame_data: row.card_frame_data,
                 artwork_group_id: 0, // placeholder; assign_artwork_groups fills every printing below
+                // The art half of the same faces the OracleCard took the text from, so index i is
+                // the same face in both. Art and flavor differ per printing where the text does not.
+                faces: row
+                    .card_faces
+                    .into_iter()
+                    .map(|f| PrintingFace {
+                        illustration_id: f.illustration_id,
+                        card_artist_vid: f.card_artist_vid,
+                        flavor_text_id: f.flavor_text_id,
+                    })
+                    .collect(),
+            
+                compat: row.compat,
             });
         }
         offsets.push(printings.len() as u32);
@@ -13591,6 +15204,10 @@ impl QueryEngine {
         drop(vocab.map);
         let artist_vocab = artists.strings;
         drop(artists.map);
+        // After the vocab is final, before the printings are archived: both ranks are stored on the
+        // printing and must be in place when it is written out.
+        assign_set_ranks(&mut printings);
+        assign_artist_ranks(&mut printings, &artist_vocab);
         let mana_vocab = mana.strings;
         drop(mana.map);
         // String-sorted permutation of the vocab ids; VocabInterner caps the
@@ -13638,7 +15255,7 @@ impl QueryEngine {
             usize::from(artwork_group_counts.iter().copied().max().unwrap_or(0)),
         );
         let indexes = CardIndexes {
-            name_trigram:   build_trigram_index(&cards, |c| c.card_name_folded.as_str()),
+            name_trigram:   build_trigram_index(&cards, |c| folded_name_of(c, &strings)),
             oracle_trigram: build_oracle_text_index(&cards, &strings),
             cmc:            build_numeric_index(&cards, |c| c.cmc.map(|v| v as i16)),
             power:          build_numeric_index(&cards, |c| c.creature_power.map(|v| v as i16)),
@@ -13701,10 +15318,14 @@ impl QueryEngine {
             rarity_cards,
             value_totals,
             pair_totals,
-            name_bigrams:   build_name_bigram_index(&cards),
-            name_unigrams:  build_name_unigram_index(&cards),
+            name_bigrams:   build_name_bigram_index(&cards, &strings),
+            name_unigrams:  build_name_unigram_index(&cards, &strings),
             legal_divergent: build_divergent_ids(&cards),
             arith_tuple:    build_arith_tuple_index(&cards),
+            printing_by_scryfall_id: build_printing_by_scryfall_id(&printings),
+            printing_by_illustration_id: build_printing_by_illustration_id(&printings),
+            oracle_by_oracle_id:     build_oracle_by_oracle_id(&cards),
+            external_id_index:       build_external_id_index(&printings),
         };
 
         #[cfg(feature = "alloc-counter")]
@@ -14070,6 +15691,270 @@ impl QueryEngine {
         PyList::new(py, dicts)
     }
 
+    /// The printing with this Scryfall id, or None.
+    ///
+    /// Addressing one card by id is the mode the store has never had: the id was stored
+    /// (`Printing.scryfall_id` keeps the UUID's exact bits, deliberately) but only findable by
+    /// scanning every printing. `printing_by_scryfall_id` makes it O(log n), which is what lets a
+    /// by-id route be answered from memory instead of from Postgres.
+    /// The best printing carrying this illustration id, or None.
+    ///
+    /// `/cards/collection` accepts an `illustration_id` identifier, and it was the one entry in
+    /// that list still resolved from SQL while `id`, `oracle_id`, `mtgo_id` and `multiverse_id`
+    /// all went through the engine. The id is NOT unique, so the answer is the FIRST printing
+    /// carrying it in corpus order -- printings sit in descending default-prefer order within a
+    /// card, so that is the representative printing, and it is what the SQL's `prefer_score`
+    /// ordering returned.
+    #[pyo3(signature = (illustration_id, fields=None))]
+    fn card_by_illustration_id<'py>(
+        &self,
+        py: Python<'py>,
+        illustration_id: &str,
+        fields: Option<Vec<String>>,
+    ) -> PyResult<Option<Bound<'py, PyDict>>> {
+        let resolved_fields = resolve_fields(fields)?;
+        let mmap = self.get_mmap()?;
+        // Safety: see the access_unchecked justification in query().
+        let data = unsafe { rkyv::access_unchecked::<Archived<CardData>>(archive_payload(&mmap)) };
+        let Some(pid) = find_printing_by_illustration_id(
+            &data.indexes.printing_by_illustration_id,
+            &data.printings,
+            parse_uuid_or_hash(illustration_id),
+        ) else {
+            return Ok(None);
+        };
+        let cid = u32::from(data.indexes.printing_to_card[pid as usize]) as usize;
+        let dict = card_to_pydict(
+            py,
+            &data.cards[cid],
+            &data.printings[pid as usize],
+            &data.strings,
+            &data.coll_vocab,
+            &resolved_fields,
+        )?;
+        Ok(Some(dict))
+    }
+
+    #[pyo3(signature = (scryfall_id, fields=None))]
+    fn card_by_scryfall_id<'py>(
+        &self,
+        py: Python<'py>,
+        scryfall_id: &str,
+        fields: Option<Vec<String>>,
+    ) -> PyResult<Option<Bound<'py, PyDict>>> {
+        let resolved_fields = resolve_fields(fields)?;
+        let mmap = self.get_mmap()?;
+        // Safety: see the access_unchecked justification in query().
+        let data = unsafe { rkyv::access_unchecked::<Archived<CardData>>(archive_payload(&mmap)) };
+        let Some(pid) = find_printing_by_scryfall_id(
+            &data.indexes.printing_by_scryfall_id,
+            &data.printings,
+            parse_uuid_or_hash(scryfall_id),
+        ) else {
+            return Ok(None);
+        };
+        let cid = u32::from(data.indexes.printing_to_card[pid as usize]) as usize;
+        let dict = card_to_pydict(
+            py,
+            &data.cards[cid],
+            &data.printings[pid as usize],
+            &data.strings,
+            &data.coll_vocab,
+            &resolved_fields,
+        )?;
+        Ok(Some(dict))
+    }
+
+    /// Scryfall's `?fuzzy=` name lookup, typo-tolerant.
+    ///
+    /// Returns `(status, card)` where status is "hit", "ambiguous" or "miss". Ambiguous is a
+    /// distinct answer rather than a miss: Scryfall reports it with the candidates it could not
+    /// separate, and collapsing it to "not found" would tell the client the card does not exist.
+    #[pyo3(signature = (name, floor, lead, fields=None))]
+    fn fuzzy_card_by_name<'py>(
+        &self,
+        py: Python<'py>,
+        name: &str,
+        floor: f32,
+        lead: f32,
+        fields: Option<Vec<String>>,
+    ) -> PyResult<(String, Option<Bound<'py, PyDict>>)> {
+        let resolved_fields = resolve_fields(fields)?;
+        let mmap = self.get_mmap()?;
+        // Safety: see the access_unchecked justification in query().
+        let data = unsafe { rkyv::access_unchecked::<Archived<CardData>>(archive_payload(&mmap)) };
+        match fuzzy_name_match(&data.cards, &data.strings, name, floor, lead) {
+            FuzzyOutcome::Miss => Ok(("miss".to_string(), None)),
+            FuzzyOutcome::Ambiguous => Ok(("ambiguous".to_string(), None)),
+            FuzzyOutcome::Hit(cid) => {
+                let cid = cid as usize;
+                // The card's default-preferred printing, the same one every other by-name path shows.
+                let preferred = u32::from(data.offsets[cid]) as usize;
+                let dict = card_to_pydict(
+                    py,
+                    &data.cards[cid],
+                    &data.printings[preferred],
+                    &data.strings,
+                    &data.coll_vocab,
+                    &resolved_fields,
+                )?;
+                Ok(("hit".to_string(), Some(dict)))
+            }
+        }
+    }
+
+    /// The card `named?exact=folded` resolves to, restricted to `set`.
+    ///
+    /// `folded` must already be accent-folded and lowercased by the caller, the way
+    /// `card_name_folded` was at import (`fold_accents`); the COLLATING is done here, so the caller
+    /// passes the needle as typed and does not have to know the rule.
+    ///
+    /// `named?exact=` is the last lookup on this surface that answered from SQL. It is a scan of
+    /// every card's folded name, which is what `name_trigram` exists to avoid: measured on a
+    /// ~31.7k-card corpus, 884 us of scan against 4 us through the index.
+    #[pyo3(signature = (folded, set_code=None, fields=None))]
+    fn exact_card_by_name<'py>(
+        &self,
+        py: Python<'py>,
+        folded: &str,
+        set_code: Option<&str>,
+        fields: Option<Vec<String>>,
+    ) -> PyResult<Option<Bound<'py, PyDict>>> {
+        self.card_by_name(py, folded, set_code, fields, exact_name_match)
+    }
+
+    /// The card a `POST /cards/collection` `{"name": ...}` identifier resolves to, within `set`.
+    ///
+    /// Its own entry point and not a call to `exact_card_by_name`, because the KEYS ARE NOT THE
+    /// SAME: measured on api.scryfall.com, `{"name":"Delver of Secrets // Insectile Aberration"}`
+    /// is not_found while `exact=` of that string is the card. `name_key_tier` carries the rest of
+    /// the measurements.
+    #[pyo3(signature = (folded, set_code=None, fields=None))]
+    fn collection_card_by_name<'py>(
+        &self,
+        py: Python<'py>,
+        folded: &str,
+        set_code: Option<&str>,
+        fields: Option<Vec<String>>,
+    ) -> PyResult<Option<Bound<'py, PyDict>>> {
+        self.card_by_name(py, folded, set_code, fields, collection_name_match)
+    }
+
+    /// One printing per DISTINCT card name whose folded name contains every one of `words`.
+    ///
+    /// The containment stage of `named?fuzzy=`, which ran as a LIKE per word. The caller asks for 2
+    /// and reads the count: more than one distinct name is `ambiguous`, which Scryfall reports
+    /// rather than guessing between. 1,303 us of scan against 11 us through the index.
+    #[pyo3(signature = (words, set_code=None, limit=2, fields=None))]
+    fn cards_containing_all_words<'py>(
+        &self,
+        py: Python<'py>,
+        words: Vec<String>,
+        set_code: Option<&str>,
+        limit: usize,
+        fields: Option<Vec<String>>,
+    ) -> PyResult<Vec<Bound<'py, PyDict>>> {
+        let resolved_fields = resolve_fields(fields)?;
+        let mmap = self.get_mmap()?;
+        // Safety: see the access_unchecked justification in query().
+        let data = unsafe { rkyv::access_unchecked::<Archived<CardData>>(archive_payload(&mmap)) };
+        names_containing_all_words(data, &words, set_code, limit)
+            .into_iter()
+            .map(|(cid, pid)| {
+                card_to_pydict(
+                    py,
+                    &data.cards[cid],
+                    &data.printings[pid],
+                    &data.strings,
+                    &data.coll_vocab,
+                    &resolved_fields,
+                )
+            })
+            .collect()
+    }
+
+    /// Card names beginning with `prefix`, up to `limit`. Scryfall's autocomplete catalog.
+    #[pyo3(signature = (prefix, limit))]
+    fn autocomplete(&self, prefix: &str, limit: usize) -> PyResult<Vec<String>> {
+        let mmap = self.get_mmap()?;
+        // Safety: see the access_unchecked justification in query().
+        let data = unsafe { rkyv::access_unchecked::<Archived<CardData>>(archive_payload(&mmap)) };
+        Ok(autocomplete_names(data, prefix, limit).into_iter().map(str::to_string).collect())
+    }
+
+    /// The printing carrying this external id, or None.
+    ///
+    /// `namespace` is Scryfall's own path segment. mtgo also matches mtgo_foil_id and tcgplayer
+    /// also matches tcgplayer_etched_id, because Scryfall resolves those to the same printing.
+    #[pyo3(signature = (namespace, external_id, fields=None))]
+    fn card_by_external_id<'py>(
+        &self,
+        py: Python<'py>,
+        namespace: &str,
+        external_id: u64,
+        fields: Option<Vec<String>>,
+    ) -> PyResult<Option<Bound<'py, PyDict>>> {
+        let ns = match namespace {
+            "multiverse" => EXT_MULTIVERSE,
+            "mtgo" => EXT_MTGO,
+            "arena" => EXT_ARENA,
+            "tcgplayer" => EXT_TCGPLAYER,
+            "cardmarket" => EXT_CARDMARKET,
+            other => {
+                return Err(pyo3::exceptions::PyValueError::new_err(format!("unknown id namespace {other:?}")));
+            }
+        };
+        let resolved_fields = resolve_fields(fields)?;
+        let mmap = self.get_mmap()?;
+        // Safety: see the access_unchecked justification in query().
+        let data = unsafe { rkyv::access_unchecked::<Archived<CardData>>(archive_payload(&mmap)) };
+        let Some(pid) = find_printing_by_external_id(&data.indexes.external_id_index, ns, external_id) else {
+            return Ok(None);
+        };
+        let cid = u32::from(data.indexes.printing_to_card[pid as usize]) as usize;
+        let dict = card_to_pydict(
+            py,
+            &data.cards[cid],
+            &data.printings[pid as usize],
+            &data.strings,
+            &data.coll_vocab,
+            &resolved_fields,
+        )?;
+        Ok(Some(dict))
+    }
+
+    /// Every printing of the card with this oracle id, in stored (descending default-prefer) order.
+    ///
+    /// This is what `unique=prints` over one card asks for, and the shape a prints-of-this-card
+    /// link resolves to. Empty list when the oracle id is unknown.
+    #[pyo3(signature = (oracle_id, fields=None))]
+    fn printings_of_oracle_id<'py>(
+        &self,
+        py: Python<'py>,
+        oracle_id: &str,
+        fields: Option<Vec<String>>,
+    ) -> PyResult<Bound<'py, PyList>> {
+        let resolved_fields = resolve_fields(fields)?;
+        let mmap = self.get_mmap()?;
+        // Safety: see the access_unchecked justification in query().
+        let data = unsafe { rkyv::access_unchecked::<Archived<CardData>>(archive_payload(&mmap)) };
+        let Some(cid) =
+            find_oracle_by_oracle_id(&data.indexes.oracle_by_oracle_id, &data.cards, parse_uuid_or_hash(oracle_id))
+        else {
+            return Ok(PyList::empty(py));
+        };
+        let cid = cid as usize;
+        let start = u32::from(data.offsets[cid]) as usize;
+        let end = u32::from(data.offsets[cid + 1]) as usize;
+        let card = &data.cards[cid];
+        let dicts: Vec<Bound<PyDict>> = (start..end)
+            .map(|pid| {
+                card_to_pydict(py, card, &data.printings[pid], &data.strings, &data.coll_vocab, &resolved_fields)
+            })
+            .collect::<PyResult<_>>()?;
+        PyList::new(py, dicts)
+    }
+
 
     /// Count type and subtype occurrences across oracle cards.
     /// Returns {type_name: count} covering both supertypes/types (decoded from
diff --git a/card_engine/src/tests.rs b/card_engine/src/tests.rs
index 945f6bc20..51685c6f4 100644
--- a/card_engine/src/tests.rs
+++ b/card_engine/src/tests.rs
@@ -2,10 +2,10 @@ use super::{
     and_child_rank, assign_name_ranks,
     build_numeric_index, build_oracle_text_index, build_trigram_index,
     build_rarity_index, build_flavor_index, build_hybrid_tag_index, build_layout_hybrid_index, bitmap_beats_postings, HybridTagIndex, build_sort_permutations,
-    assign_artwork_groups, build_artwork_base_from, build_bit_planes, build_border_printing_planes, build_rarity_printing_planes, build_divergent_ids, build_name_bigram_index, build_name_unigram_index, build_printing_to_card, flavor_fingerprint, flavor_match_sets,
+    assign_artwork_groups, assign_artist_ranks, build_artwork_base_from, build_bit_planes, build_border_printing_planes, build_rarity_printing_planes, build_divergent_ids, build_name_bigram_index, build_name_unigram_index, build_printing_to_card, flavor_fingerprint, flavor_match_sets,
     cards_of_printings, count_common_keywords, count_common_types,
     build_artist_index, build_printing_value_index, build_arith_tuple_index, is_arith_tuple_route, range_candidates, narrow_candidates, narrow_candidates_exact, rarity_candidates,
-    range_too_broad_to_narrow, run_query, run_query_routed, run_query_with_plan, explain, explain_analyze, AcquireFacts, PlanEstimate, PlanTrial,
+    perm_primary_key, range_too_broad_to_narrow, run_query, run_query_routed, run_query_with_plan, explain, explain_analyze, AcquireFacts, PlanEstimate, PlanTrial,
     acquire_plan_features, take_phase_stats, PagingTaken, CountSource, NarrowedRepr,
     EXACT_VALUE_TOTALS, RangeCardCounts, narrow_rec, ValueTotals, PairTotals, build_all_value_totals, build_pair_totals, build_range_card_counts, exact_result_total,
     PhysicalPlan, PlanScope, CandidatePlan, ComposePaging, trigram_candidates, finalize_trigram_index, PrintingValueIndex, NARROW_FLOOR,
@@ -17,12 +17,18 @@ use super::{
     archive_header, archive_payload, ARCHIVE_HEADER_LEN, Mmap,
     bitmap_contains, bitmap_card_ids, compile_plane, eval_planes, split_planes,
     ArithOp, ArtistIndex, CardData, CardIndexes, Candidates, ColorField, NumExpr, NumField, RarityIndex,
-    CollField, CmpOp, FilterExpr, InlineStr, Interner, ManaCost, OracleCard, Printing, TagIndex,
+    CollField, CmpOp, FilterExpr, InlineStr, Interner, ManaCost, CompatFields, OracleCard, OracleFace, Printing, PrintingFace, RelatedCard, TagIndex,
+    build_printing_by_scryfall_id, build_oracle_by_oracle_id, find_printing_by_scryfall_id, find_oracle_by_oracle_id,
+    build_external_id_index, find_printing_by_external_id, EXT_MULTIVERSE, EXT_MTGO, EXT_ARENA, EXT_TCGPLAYER,
+    trigram_similarity, fuzzy_name_match, autocomplete_names, FuzzyOutcome,
+    exact_name_match, collection_name_match, names_containing_all_words,
+    VOCAB_NONE, COMPAT_PROMO, COMPAT_REPRINT, COMPAT_TEXTLESS, GAME_PAPER, GAME_ARENA, FINISH_FOIL, FINISH_NONFOIL,
     TextField, TextSearchField, Tri, SortedTrigramIndex, VocabInterner, ARTIST_NONE, NONE_STR, TYPE_ARTIFACT, TYPE_CREATURE,
     TYPE_ENCHANTMENT, TYPE_INSTANT, TYPE_LAND, TYPE_LEGENDARY, TYPE_PLANESWALKER, TYPE_SNOW, TYPE_SORCERY,
 };
 use rkyv::{rancor::Error, Archived};
 use std::collections::HashMap;
+use std::num::NonZeroU32;
 use std::sync::OnceLock;
 // Trait bringing random_range/random_bool/random into scope for the #677 fuzzer
 // helpers below (SmallRng's inherent methods live on this extension trait).
@@ -191,7 +197,7 @@ fn test_tag_index_str_lookup() {
 fn stub_card(oracle_id: u128, card_types: u16, subtypes: &[&str], vocab: &mut VocabInterner) -> OracleCard {
     OracleCard {
         card_name_lower: InlineStr::from_str(""),
-        card_name_folded: InlineStr::from_str(""),
+        card_name_folded_id: NONE_STR,
         card_colors: 0,
         card_color_identity: 0,
         produced_mana: 0,
@@ -218,6 +224,9 @@ fn stub_card(oracle_id: u128, card_types: u16, subtypes: &[&str], vocab: &mut Vo
         mana_cost: ManaCost { core: 0, hybrids: Vec::new(), devotion: 0, cmc: 0.0 },
         creature_power_text_id: NONE_STR,
         creature_toughness_text_id: NONE_STR,
+        planeswalker_loyalty_text_id: NONE_STR,
+        faces: Vec::new(),
+        all_parts: Vec::new(),
     }
 }
 
@@ -230,6 +239,8 @@ fn stub_printing(scryfall_id: u128, illustration_id: u128, prefer_score: Option<
         flavor_text_lower_id: NONE_STR,
         card_artist_vid: ARTIST_NONE,
         card_set_code: InlineStr::from_str(""),
+        set_rank: 0,
+        artist_rank: 0,
         card_border_id: NONE_STR,
         card_watermark_id: NONE_STR,
         collector_number_id: NONE_STR,
@@ -246,6 +257,8 @@ fn stub_printing(scryfall_id: u128, illustration_id: u128, prefer_score: Option<
         card_is_tags: Vec::new(),
         card_frame_data: Vec::new(),
         artwork_group_id: 0, // placeholder; store_of overwrites via assign_artwork_groups
+        faces: Vec::new(),
+        compat: CompatFields::default(),
     }
 }
 
@@ -293,8 +306,8 @@ fn store_of(cards: Vec<OracleCard>, printing_counts: &[usize], vocab: VocabInter
         // border_planes_fixture_store already does), so an empty string table is
         // safe here -- the border-scatter loop skips every printing regardless.
         planes: build_bit_planes(&cards, &printings, &offsets, &[]),
-        name_bigrams: build_name_bigram_index(&cards),
-        name_unigrams: build_name_unigram_index(&cards),
+        name_bigrams: build_name_bigram_index(&cards, &[]),
+        name_unigrams: build_name_unigram_index(&cards, &[]),
         legal_divergent: build_divergent_ids(&cards),
         sort_perms: build_sort_permutations(&cards, &offsets),
         max_artwork_groups: artwork_groups.iter().copied().max().unwrap_or(0),
@@ -2298,7 +2311,6 @@ fn fuzz_store_n(rng: &mut rand::rngs::SmallRng, ncards: usize) -> CardData {
         // tests indexing/algebra parity, not fold_accents() semantics (#649 covers that directly).
         let name = corpus[rng.random_range(0..corpus.len())].0;
         card.card_name_lower = InlineStr::from_str(name);
-        card.card_name_folded = card.card_name_lower;
         card.card_name_id = interner.intern(name.to_string());
         let vanilla = card.card_types & TYPE_CREATURE != 0 && rng.random_bool(VANILLA_CREATURE_FRAC);
         let oracle = if vanilla {
@@ -2474,9 +2486,9 @@ fn fuzz_store_n(rng: &mut rand::rngs::SmallRng, ncards: usize) -> CardData {
     data.indexes.artists = build_artist_index(&data.printings, data.artist_vocab.len());
     // Text narrowing indexes — same load-bearing property. name/oracle drive trigram + bigram
     // narrowing and the full-scan memoization; flavor is the printing-space CSR bind() resolves against.
-    data.indexes.name_trigram = build_trigram_index(&data.cards, |c| c.card_name_folded.as_str());
-    data.indexes.name_bigrams = build_name_bigram_index(&data.cards);
-    data.indexes.name_unigrams = build_name_unigram_index(&data.cards);
+    data.indexes.name_trigram = build_trigram_index(&data.cards, |c| crate::folded_name_of(c, &data.strings));
+    data.indexes.name_bigrams = build_name_bigram_index(&data.cards, &data.strings);
+    data.indexes.name_unigrams = build_name_unigram_index(&data.cards, &data.strings);
     data.indexes.oracle_trigram = build_oracle_text_index(&data.cards, &data.strings);
     data.indexes.flavor = build_flavor_index(&data.printings, &data.strings);
     data.indexes.planes = build_bit_planes(&data.cards, &data.printings, &data.offsets, &data.strings);
@@ -6595,7 +6607,6 @@ fn bench_checked_vs_unchecked_access() {
         );
         let mut card = stub_card((i + 1) as u128, TYPE_CREATURE, &["Benchmark", words[i % 10]], &mut vocab);
         card.card_name_lower = InlineStr::from_str(&name.to_lowercase());
-        card.card_name_folded = card.card_name_lower;
         card.card_name_id = interner.intern(name.clone());
         card.oracle_text_id = interner.intern(oracle.clone());
         card.oracle_text_lower_id = interner.intern(oracle.to_lowercase());
@@ -6620,8 +6631,8 @@ fn bench_checked_vs_unchecked_access() {
 
     let indexes = CardIndexes {
         artwork_base,
-        name_trigram:   build_trigram_index(&cards, |c| c.card_name_folded.as_str()),
-        name_unigrams:  build_name_unigram_index(&cards),
+        name_trigram:   build_trigram_index(&cards, |c| crate::folded_name_of(c, &[])),
+        name_unigrams:  build_name_unigram_index(&cards, &[]),
         oracle_trigram: build_oracle_text_index(&cards, &strings),
         cmc:            build_numeric_index(&cards, |c| c.cmc.map(|v| v as i16)),
         power:          build_numeric_index(&cards, |c| c.creature_power.map(|v| v as i16)),
@@ -6661,9 +6672,13 @@ fn bench_checked_vs_unchecked_access() {
         border_printing: build_border_printing_planes(&printings, &strings),
         rarity_printing: build_rarity_printing_planes(&printings),
         rarity_printing_ordered: build_printing_value_index(&printings, &cards, &offsets, |p| p.card_rarity_int.map(u32::from)),
-        name_bigrams:   build_name_bigram_index(&cards),
+        name_bigrams:   build_name_bigram_index(&cards, &[]),
         legal_divergent: build_divergent_ids(&cards),
         arith_tuple:    build_arith_tuple_index(&cards),
+        printing_by_scryfall_id: build_printing_by_scryfall_id(&printings),
+        printing_by_illustration_id: crate::build_printing_by_illustration_id(&printings),
+        oracle_by_oracle_id:     build_oracle_by_oracle_id(&cards),
+        external_id_index:       build_external_id_index(&printings),
     };
     let data = CardData {
         cards,
@@ -9142,7 +9157,6 @@ fn text_fixture_store() -> CardData {
         .map(|(i, &(name, text))| {
             let mut c = stub_card(i as u128 + 1, TYPE_CREATURE, &[], &mut vocab);
             c.card_name_lower = InlineStr::from_str(name);
-            c.card_name_folded = c.card_name_lower;
             c.card_name_id = interner.intern(name.to_string());
             c.oracle_text_lower_id = interner.intern(text.unwrap_or_default().to_string());
             c
@@ -9150,7 +9164,7 @@ fn text_fixture_store() -> CardData {
         .collect();
     let mut data = store_of(cards, &[1usize; 6], vocab);
     data.strings = interner.strings;
-    data.indexes.name_trigram = build_trigram_index(&data.cards, |c| c.card_name_folded.as_str());
+    data.indexes.name_trigram = build_trigram_index(&data.cards, |c| crate::folded_name_of(c, &data.strings));
     data.indexes.oracle_trigram = build_oracle_text_index(&data.cards, &data.strings);
     data
 }
@@ -10040,7 +10054,6 @@ fn name_bigrams_tiers_and_exactness() {
         let mut c = stub_card(u128::from(i) + 1, TYPE_CREATURE, &[], &mut vocab);
         let name = if i % 64 == 0 { format!("azz qx{i}") } else { format!("azz b{i}") };
         c.card_name_lower = InlineStr::from_str(&name);
-        c.card_name_folded = c.card_name_lower;
         c
     }).collect();
     let data = store_of(cards, &vec![1usize; 4096], vocab);
@@ -10065,7 +10078,7 @@ fn name_bigrams_tiers_and_exactness() {
     assert!(n.tight);
     let cand = n.set.into_cards(&archived.offsets, &archived.indexes.printing_to_card);
     let brute: Vec<u32> = archived.cards.iter().enumerate()
-        .filter(|(_, c)| c.card_name_folded.as_str().contains("qx"))
+        .filter(|(_, c)| crate::folded_name(c, &archived.strings).contains("qx"))
         .map(|(i, _)| i as u32)
         .collect();
     assert_eq!(cand, brute, "bigram membership IS containment for 2-byte needles");
@@ -10091,7 +10104,6 @@ fn not_over_unigram_is_tight_but_oracle_stays_loose() {
             let mut c = stub_card(u128::from(i) + 1, TYPE_CREATURE, &[], &mut vocab);
             let name = if i % 8 == 0 { format!("aq b{i}") } else { format!("ab c{i}") };
             c.card_name_lower = InlineStr::from_str(&name);
-            c.card_name_folded = c.card_name_lower;
             c
         })
         .collect();
@@ -10108,7 +10120,7 @@ fn not_over_unigram_is_tight_but_oracle_stays_loose() {
         .cards
         .iter()
         .enumerate()
-        .filter(|(_, c)| !c.card_name_folded.as_str().contains('q'))
+        .filter(|(_, c)| !crate::folded_name(c, &archived.strings).contains('q'))
         .map(|(i, _)| i as u32)
         .collect();
     assert_eq!(cand, brute, "-name:q must be exactly the cards whose name lacks 'q'");
@@ -10138,7 +10150,6 @@ fn name_unigrams_tiers_and_exactness() {
         let mut c = stub_card(u128::from(i) + 1, TYPE_CREATURE, &[], &mut vocab);
         let name = if i % 64 == 0 { format!("az q{i}") } else { format!("az b{i}") };
         c.card_name_lower = InlineStr::from_str(&name);
-        c.card_name_folded = c.card_name_lower;
         c
     }).collect();
     let data = store_of(cards, &vec![1usize; 4096], vocab);
@@ -10163,7 +10174,7 @@ fn name_unigrams_tiers_and_exactness() {
     assert!(n.tight);
     let cand = n.set.into_cards(&archived.offsets, &archived.indexes.printing_to_card);
     let brute: Vec<u32> = archived.cards.iter().enumerate()
-        .filter(|(_, c)| c.card_name_folded.as_str().contains('q'))
+        .filter(|(_, c)| crate::folded_name(c, &archived.strings).contains('q'))
         .map(|(i, _)| i as u32)
         .collect();
     assert_eq!(cand, brute, "byte membership IS containment for 1-byte needles");
@@ -10184,7 +10195,6 @@ fn name_bigrams_compose_and_memoize() {
     let cards: Vec<OracleCard> = names.iter().enumerate().map(|(i, name)| {
         let mut c = stub_card(i as u128 + 1, TYPE_CREATURE, &[], &mut vocab);
         c.card_name_lower = InlineStr::from_str(name);
-        c.card_name_folded = c.card_name_lower;
         c.card_name_id = interner.intern(name.to_string());
         c
     }).collect();
@@ -10222,7 +10232,7 @@ fn name_bigrams_compose_and_memoize() {
         _ => panic!("2-byte needle must memoize via bigrams"),
     }
     for (cid, card) in archived.cards.iter().enumerate() {
-        let want = card.card_name_folded.as_str().contains("fi");
+        let want = crate::folded_name(card, &archived.strings).contains("fi");
         assert!((f.eval_card(card, &archived.strings) == Tri::True) == want, "NameMatch parity at card {cid}");
     }
 }
@@ -10443,7 +10453,6 @@ fn named_store() -> CardData {
         .map(|(i, name)| {
             let mut c = stub_card((i + 1) as u128, TYPE_CREATURE, &[], &mut vocab);
             c.card_name_lower = InlineStr::from_str(name);
-            c.card_name_folded = c.card_name_lower;
             // Distinct, deliberately store-order-scrambled edhrec ranks: the
             // second "sol ring" (card 3) outranks the first (card 1).
             c.edhrec_rank = Some([40, 60, 10, 20, 30, 50][i]);
@@ -10531,13 +10540,21 @@ fn accent_folded_name_search_matches_unaccented_query() {
         ("éowyn, fearless knight", "eowyn, fearless knight"),
         ("ferocious knight", "ferocious knight"),
     ];
-    let cards: Vec<OracleCard> = rows.iter().enumerate().map(|(i, (lower, folded))| {
+    let cards: Vec<OracleCard> = rows.iter().enumerate().map(|(i, (lower, _))| {
         let mut c = stub_card(i as u128 + 1, TYPE_CREATURE, &[], &mut vocab);
         c.card_name_lower = InlineStr::from_str(lower);
-        c.card_name_folded = InlineStr::from_str(folded);
         c
     }).collect();
-    let data = store_of(cards, &[1usize; 2], vocab);
+    let mut data = store_of(cards, &[1usize; 2], vocab);
+    // Interned the way the builder does: a folded name that DIFFERS from the lower one is the only
+    // case that reaches the strings table, and this fixture exists precisely for that case.
+    for (i, (lower, folded)) in rows.iter().enumerate() {
+        if lower != folded {
+            data.strings.push((*folded).to_owned());
+            data.cards[i].card_name_folded_id = (data.strings.len() - 1) as u32;
+        }
+    }
+    let data = data;
     let bytes = rkyv::to_bytes::<Error>(&data).expect("serialize");
     let archived = rkyv::access::<Archived<CardData>, Error>(&bytes).expect("access");
 
@@ -12975,6 +12992,943 @@ fn arith_tuple_key_budget_catches_a_blown_domain() {
 /// clears `10*sqrt(n)+32` by a wide margin.
 const ARITH_TUPLE_BLOWUP_CARDS: usize = 6_000;
 
+// ─── Face storage ─────────────────────────────────────────────────────────────
+
+/// Two faces whose text and art both differ, so a merge-shaped answer cannot fake it.
+fn two_faces() -> (Vec<OracleFace>, Vec<PrintingFace>) {
+    let oracle = vec![
+        OracleFace {
+            card_name_id: 1,
+            mana_cost_text_id: 2,
+            type_line_id: 3,
+            oracle_text_id: 4,
+            creature_power_text_id: 5,
+            creature_toughness_text_id: 6,
+            planeswalker_loyalty_text_id: NONE_STR,
+            defense_text_id: NONE_STR,
+            card_colors: 0b0000_0001, // W
+            color_indicator: 0,
+        },
+        OracleFace {
+            card_name_id: 11,
+            mana_cost_text_id: NONE_STR, // a transform back has no mana cost at all
+            type_line_id: 13,
+            oracle_text_id: 14,
+            creature_power_text_id: 15,
+            creature_toughness_text_id: 16,
+            planeswalker_loyalty_text_id: NONE_STR,
+            defense_text_id: NONE_STR,
+            card_colors: 0b0000_1000, // R
+            color_indicator: 0b0000_1000,
+        },
+    ];
+    let printing = vec![
+        PrintingFace { illustration_id: 0xAAAA, card_artist_vid: 1, flavor_text_id: 7 },
+        PrintingFace { illustration_id: 0xBBBB, card_artist_vid: 2, flavor_text_id: NONE_STR },
+    ];
+    (oracle, printing)
+}
+
+#[test]
+fn faces_survive_the_archive_round_trip() {
+    let mut vocab = VocabInterner::new();
+    let (oracle_faces, printing_faces) = two_faces();
+    let mut card = stub_card(1, 0, &[], &mut vocab);
+    card.faces = oracle_faces;
+    let mut printing = stub_printing(1, 1, Some(1.0));
+    printing.faces = printing_faces;
+
+    let card_bytes = rkyv::to_bytes::<Error>(&card).expect("serialize card");
+    let archived_card = rkyv::access::<Archived<OracleCard>, Error>(&card_bytes).expect("access card");
+    let print_bytes = rkyv::to_bytes::<Error>(&printing).expect("serialize printing");
+    let archived_print = rkyv::access::<Archived<Printing>, Error>(&print_bytes).expect("access printing");
+
+    assert_eq!(archived_card.faces.len(), 2);
+    assert_eq!(archived_print.faces.len(), 2);
+
+    // Text: the back keeps its own name, types and stats -- the thing the merged row cannot say.
+    assert_eq!(archived_card.faces[0].card_name_id, 1);
+    assert_eq!(archived_card.faces[1].card_name_id, 11);
+    assert_eq!(archived_card.faces[1].mana_cost_text_id, NONE_STR);
+    assert_eq!(archived_card.faces[0].creature_power_text_id, 5);
+    assert_eq!(archived_card.faces[1].creature_power_text_id, 15);
+
+    // Colors are per face, which is how `c:r` reaches a red back on a white front.
+    assert_eq!(archived_card.faces[0].card_colors, 0b0000_0001);
+    assert_eq!(archived_card.faces[1].card_colors, 0b0000_1000);
+    assert_eq!(archived_card.faces[1].color_indicator, 0b0000_1000);
+
+    // Art: per printing, and distinct per face.
+    assert_eq!(archived_print.faces[0].illustration_id, 0xAAAA);
+    assert_eq!(archived_print.faces[1].illustration_id, 0xBBBB);
+    assert_ne!(archived_print.faces[0].card_artist_vid, archived_print.faces[1].card_artist_vid);
+    assert_eq!(archived_print.faces[1].flavor_text_id, NONE_STR);
+}
+
+#[test]
+fn single_faced_cards_carry_no_faces() {
+    let mut vocab = VocabInterner::new();
+    let card = stub_card(1, 0, &[], &mut vocab);
+    let bytes = rkyv::to_bytes::<Error>(&card).expect("serialize");
+    let archived = rkyv::access::<Archived<OracleCard>, Error>(&bytes).expect("access");
+    // ~82% of the corpus. An empty Vec archives to a length word, so the cost is bounded.
+    assert!(archived.faces.is_empty());
+}
+
+#[test]
+fn face_indexes_line_up_across_the_split() {
+    // OracleFace and PrintingFace are two halves of one face, so index i must mean the same face
+    // in both. The commit pass fills them from the same FaceRow list; this pins that contract.
+    let (oracle_faces, printing_faces) = two_faces();
+    assert_eq!(oracle_faces.len(), printing_faces.len());
+}
+
+// ─── Lookup by id ─────────────────────────────────────────────────────────────
+
+#[test]
+fn printings_are_findable_by_scryfall_id() {
+    // Ids deliberately out of order, and not dense: the permutation has to do real work.
+    let ids: [u128; 5] = [0xF00D, 0x0010, 0xBEEF, 0x0002, 0xCAFE];
+    let printings: Vec<Printing> = ids.iter().map(|&id| stub_printing(id, id, Some(1.0))).collect();
+    let perm = build_printing_by_scryfall_id(&printings);
+
+    let perm_bytes = rkyv::to_bytes::<Error>(&perm).expect("serialize perm");
+    let aperm = rkyv::access::<Archived<Vec<u32>>, Error>(&perm_bytes).expect("access perm");
+    let print_bytes = rkyv::to_bytes::<Error>(&printings).expect("serialize printings");
+    let aprint = rkyv::access::<Archived<Vec<Printing>>, Error>(&print_bytes).expect("access printings");
+
+    for (want_index, &id) in ids.iter().enumerate() {
+        let got = find_printing_by_scryfall_id(aperm, aprint, id);
+        assert_eq!(got, Some(want_index as u32), "id {id:#x} should resolve to its own row");
+    }
+    assert_eq!(find_printing_by_scryfall_id(aperm, aprint, 0xDEAD), None, "absent id");
+    // 0 is parse_uuid_or_hash's null. It must never resolve, even though it sorts first.
+    assert_eq!(find_printing_by_scryfall_id(aperm, aprint, 0), None, "null id");
+}
+
+#[test]
+fn cards_are_findable_by_oracle_id() {
+    let mut vocab = VocabInterner::new();
+    let ids: [u128; 4] = [0x30, 0x10, 0x40, 0x20];
+    let cards: Vec<OracleCard> = ids.iter().map(|&id| stub_card(id, 0, &[], &mut vocab)).collect();
+    let perm = build_oracle_by_oracle_id(&cards);
+
+    let perm_bytes = rkyv::to_bytes::<Error>(&perm).expect("serialize perm");
+    let aperm = rkyv::access::<Archived<Vec<u32>>, Error>(&perm_bytes).expect("access perm");
+    let card_bytes = rkyv::to_bytes::<Error>(&cards).expect("serialize cards");
+    let acards = rkyv::access::<Archived<Vec<OracleCard>>, Error>(&card_bytes).expect("access cards");
+
+    for (want_index, &id) in ids.iter().enumerate() {
+        assert_eq!(find_oracle_by_oracle_id(aperm, acards, id), Some(want_index as u32));
+    }
+    assert_eq!(find_oracle_by_oracle_id(aperm, acards, 0x99), None);
+}
+
+#[test]
+fn the_id_permutation_is_a_permutation() {
+    // Every row appears exactly once: a lookup index that drops a row silently 404s a real card.
+    let ids: [u128; 6] = [5, 3, 9, 1, 7, 3_000_000_000];
+    let printings: Vec<Printing> = ids.iter().map(|&id| stub_printing(id, id, None)).collect();
+    let mut perm = build_printing_by_scryfall_id(&printings);
+    assert_eq!(perm.len(), ids.len());
+    perm.sort_unstable();
+    assert_eq!(perm, (0..ids.len() as u32).collect::<Vec<_>>());
+}
+
+// ─── Compat residue ───────────────────────────────────────────────────────────
+
+#[test]
+fn compat_fields_survive_the_archive_round_trip() {
+    let compat = CompatFields {
+        arena_id: NonZeroU32::new(105_816),
+        mtgo_id: NonZeroU32::new(152_037),
+        tcgplayer_id: NonZeroU32::new(697_344),
+        cardmarket_id: NonZeroU32::new(892_161),
+        penny_rank: NonZeroU32::new(42),
+        image_updated_at: NonZeroU32::new(1_783_903_008),
+        price_usd_foil: NonZeroU32::new(282), // integer cents, same convention as the price columns
+        price_eur_foil: NonZeroU32::new(164),
+        set_vid: 7,
+        lang_id: 3,
+        set_type_id: 7,
+        games: GAME_PAPER | GAME_ARENA,
+        finishes: FINISH_NONFOIL | FINISH_FOIL,
+        flags: COMPAT_PROMO | COMPAT_REPRINT,
+        multiverse_ids: vec![1, 2, 3],
+        ..CompatFields::default()
+    };
+
+    let bytes = rkyv::to_bytes::<Error>(&compat).expect("serialize");
+    let a = rkyv::access::<Archived<CompatFields>, Error>(&bytes).expect("access");
+
+    assert_eq!(a.arena_id.as_ref().map(|v| v.get()), Some(105_816));
+    assert_eq!(a.price_usd_foil.as_ref().map(|v| v.get()), Some(282));
+    // set_vid is a vocab id now, not the raw UUID: ~1,000 sets against ~98,000
+    // printings, so interning it costs 2 bytes a row instead of 16.
+    assert_eq!(u16::from(a.set_vid), 7);
+    assert_eq!(u16::from(a.lang_id), 3);
+    assert_eq!(a.multiverse_ids.len(), 3);
+
+    // Bitsets are only useful if membership survives independently of each other.
+    assert_ne!(a.games & GAME_PAPER, 0);
+    assert_ne!(a.games & GAME_ARENA, 0);
+    assert_eq!(a.games & 0b0000_0010, 0, "mtgo was not set");
+    assert_ne!(u16::from(a.flags) & COMPAT_PROMO, 0);
+    assert_ne!(u16::from(a.flags) & COMPAT_REPRINT, 0);
+    assert_eq!(u16::from(a.flags) & COMPAT_TEXTLESS, 0, "textless was not set");
+}
+
+#[test]
+fn the_niche_actually_niches() {
+    // The size the "Halve What the Compat Residue Costs a Printing" reasoning depends on, pinned
+    // rather than asserted in a commit message. rkyv 0.8 does NOT niche an Option<NonZeroU32> on
+    // its own -- without `#[rkyv(with = NicheInto<Zero>)]` each of the eleven is 8 bytes and this
+    // struct is 128, which is what it measured at before the attribute was added. Multiplied by
+    // ~98,000 printings, the difference is 4.2 MB.
+    assert_eq!(std::mem::size_of::<Archived<CompatFields>>(), 84);
+    assert_eq!(std::mem::size_of::<Archived<Option<NonZeroU32>>>(), 8, "the bare Option is NOT niched");
+}
+
+#[test]
+fn absent_compat_values_stay_absent() {
+    // Scryfall OMITS a key rather than sending null, so a reconstructed card object has to be able
+    // to tell "was not there" from "was empty" -- otherwise every card sprouts nulls Scryfall never
+    // sent, and a client comparing shapes sees a difference on every single row.
+    let bytes = rkyv::to_bytes::<Error>(&CompatFields::default()).expect("serialize");
+    let a = rkyv::access::<Archived<CompatFields>, Error>(&bytes).expect("access");
+
+    assert!(a.arena_id.is_none());
+    assert!(a.mtgo_id.is_none());
+    assert!(a.penny_rank.is_none());
+    assert!(a.price_usd_foil.is_none());
+    assert_eq!(u16::from(a.lang_id), VOCAB_NONE, "absent lang is the sentinel, not vocab id 0");
+    assert_eq!(u16::from(a.set_type_id), VOCAB_NONE);
+    assert_eq!(u16::from(a.set_vid), VOCAB_NONE);
+    assert_eq!(a.games, 0);
+    assert_eq!(u16::from(a.flags), 0);
+    assert!(a.multiverse_ids.is_empty());
+    assert!(a.promo_types.is_empty());
+}
+
+/// An illustration id is NOT unique -- reprints sharing art carry the same one -- so the binary
+/// search lands anywhere inside a run. The SQL this replaces ordered by `prefer_score` and took the
+/// first, which is the first printing in CORPUS order, so the index must return the run's MINIMUM
+/// pid rather than whichever member the search happened to hit.
+#[test]
+fn an_illustration_id_resolves_to_its_first_printing() {
+    let mut vocab = VocabInterner::new();
+    let mut cards = Vec::new();
+    for i in 0..4u128 {
+        cards.push(stub_card(i + 1, 0, &[], &mut vocab));
+    }
+    let mut data = store_of(cards, &[1, 1, 1, 1], vocab);
+    // Shared art on three printings, deliberately NOT in pid order once sorted: 7 on pids 3, 1, 2.
+    data.printings[0].illustration_id = 9;
+    data.printings[1].illustration_id = 7;
+    data.printings[2].illustration_id = 7;
+    data.printings[3].illustration_id = 7;
+    data.indexes.printing_by_illustration_id = crate::build_printing_by_illustration_id(&data.printings);
+
+    let bytes = rkyv::to_bytes::<Error>(&data).expect("serialize");
+    let a = rkyv::access::<Archived<CardData>, Error>(&bytes).expect("access");
+    let perm = &a.indexes.printing_by_illustration_id;
+
+    assert_eq!(crate::find_printing_by_illustration_id(perm, &a.printings, 7), Some(1), "the FIRST, not any");
+    assert_eq!(crate::find_printing_by_illustration_id(perm, &a.printings, 9), Some(0));
+    assert_eq!(crate::find_printing_by_illustration_id(perm, &a.printings, 8), None, "a miss is None, not a neighbour");
+    // 0 is parse_uuid_or_hash's null and must never match a stored row.
+    assert_eq!(crate::find_printing_by_illustration_id(perm, &a.printings, 0), None);
+}
+
+#[test]
+fn external_ids_resolve_to_their_printing() {
+    let mut a = stub_printing(1, 1, Some(1.0));
+    a.compat = CompatFields {
+        multiverse_ids: vec![100, 101],
+        mtgo_id: NonZeroU32::new(200),
+        mtgo_foil_id: NonZeroU32::new(201),
+        arena_id: NonZeroU32::new(300),
+        ..CompatFields::default()
+    };
+    let mut b = stub_printing(2, 2, Some(1.0));
+    b.compat =
+        CompatFields { tcgplayer_id: NonZeroU32::new(400), tcgplayer_etched_id: NonZeroU32::new(401), ..CompatFields::default() };
+    let printings = vec![a, b];
+
+    let idx = build_external_id_index(&printings);
+    let bytes = rkyv::to_bytes::<Error>(&idx).expect("serialize");
+    let aidx = rkyv::access::<Archived<Vec<(u8, u64, u32)>>, Error>(&bytes).expect("access");
+
+    // A multiverse id is a LIST, so one printing contributes several entries.
+    assert_eq!(find_printing_by_external_id(aidx, EXT_MULTIVERSE, 100), Some(0));
+    assert_eq!(find_printing_by_external_id(aidx, EXT_MULTIVERSE, 101), Some(0));
+    // mtgo resolves against BOTH mtgo_id and mtgo_foil_id, as Scryfall's route does.
+    assert_eq!(find_printing_by_external_id(aidx, EXT_MTGO, 200), Some(0));
+    assert_eq!(find_printing_by_external_id(aidx, EXT_MTGO, 201), Some(0));
+    assert_eq!(find_printing_by_external_id(aidx, EXT_ARENA, 300), Some(0));
+    // ...and tcgplayer against both plain and etched.
+    assert_eq!(find_printing_by_external_id(aidx, EXT_TCGPLAYER, 400), Some(1));
+    assert_eq!(find_printing_by_external_id(aidx, EXT_TCGPLAYER, 401), Some(1));
+
+    // Namespaces are separate keyspaces: id 200 is an mtgo id, not an arena one.
+    assert_eq!(find_printing_by_external_id(aidx, EXT_ARENA, 200), None);
+    assert_eq!(find_printing_by_external_id(aidx, EXT_MTGO, 999), None);
+}
+
+#[test]
+fn a_shared_external_id_resolves_to_the_first_printing() {
+    // Etched and nonfoil rows do collide on a TCGplayer id. Printings are stored in descending
+    // prefer order, so the lowest index is the one the rest of the API would show.
+    let mut a = stub_printing(1, 1, Some(9.0));
+    a.compat = CompatFields { tcgplayer_id: NonZeroU32::new(500), ..CompatFields::default() };
+    let mut b = stub_printing(2, 2, Some(1.0));
+    b.compat = CompatFields { tcgplayer_id: NonZeroU32::new(500), ..CompatFields::default() };
+
+    let idx = build_external_id_index(&[a, b]);
+    let bytes = rkyv::to_bytes::<Error>(&idx).expect("serialize");
+    let aidx = rkyv::access::<Archived<Vec<(u8, u64, u32)>>, Error>(&bytes).expect("access");
+    assert_eq!(find_printing_by_external_id(aidx, EXT_TCGPLAYER, 500), Some(0));
+}
+
+#[test]
+fn related_cards_stand_alone_without_the_referenced_card() {
+    // The reason all_parts carries its own name and type line: a `token` component references a
+    // card the import FILTERS OUT (preprocess_card drops Token type lines), so an index into our
+    // cards would resolve to nothing. The reference has to be self-contained.
+    let mut vocab = VocabInterner::new();
+    let mut card = stub_card(1, 0, &[], &mut vocab);
+    card.all_parts = vec![
+        RelatedCard { id: 0xAAAA, name_id: 10, type_line_id: 11, component_id: 1 },
+        RelatedCard { id: 0xBBBB, name_id: 20, type_line_id: 21, component_id: 2 },
+    ];
+
+    let bytes = rkyv::to_bytes::<Error>(&card).expect("serialize");
+    let a = rkyv::access::<Archived<OracleCard>, Error>(&bytes).expect("access");
+
+    assert_eq!(a.all_parts.len(), 2);
+    // Order is meaningful for melds: the two parts, then the result.
+    assert_eq!(u128::from(a.all_parts[0].id), 0xAAAA);
+    assert_eq!(u128::from(a.all_parts[1].id), 0xBBBB);
+    assert_eq!(u32::from(a.all_parts[0].name_id), 10);
+    assert_eq!(u32::from(a.all_parts[0].type_line_id), 11);
+    assert_ne!(u16::from(a.all_parts[0].component_id), u16::from(a.all_parts[1].component_id));
+}
+
+#[test]
+fn cards_without_relations_carry_none() {
+    let mut vocab = VocabInterner::new();
+    let card = stub_card(1, 0, &[], &mut vocab);
+    let bytes = rkyv::to_bytes::<Error>(&card).expect("serialize");
+    let a = rkyv::access::<Archived<OracleCard>, Error>(&bytes).expect("access");
+    assert!(a.all_parts.is_empty(), "~59% of cards have no relations");
+}
+
+// ─── Fuzzy name matching ──────────────────────────────────────────────────────
+
+/// `trigrams_into` is a hand-rolled restatement of `trigrams`'s padded-window definition that
+/// avoids materialising the `"  word "` buffer, so the two must agree EXACTLY — a single dropped
+/// or extra window would shift every fuzzy score without failing anything else.
+///
+/// The word lengths are the interesting axis: 1 and 2 bytes are the cases where the padded form is
+/// shorter than a full 3-window and the leading/trailing windows overlap, which is precisely where
+/// an off-by-one would hide.
+#[test]
+fn trigrams_into_matches_the_padded_definition() {
+    let mut buf = Vec::new();
+    for s in [
+        "",
+        "a",
+        "ab",
+        "abc",
+        "abcd",
+        "a b",
+        "a bc def",
+        "jace beleren",
+        "urza's bauble",
+        "  leading and trailing  ",
+        "!!! ??? ---",
+        "eowyn",
+        "\u{e9}owyn",
+        "fire // ice",
+        "x",
+        "aaaa aaaa",
+        "\u{c6}therling",
+    ] {
+        crate::trigrams_into(s, &mut buf);
+        let want: Vec<[u8; 3]> = crate::trigrams(s).into_iter().collect();
+        assert_eq!(buf, want, "trigrams_into disagrees with trigrams for {s:?}");
+    }
+}
+
+#[test]
+fn trigram_similarity_matches_pg_trgm() {
+    // pg_trgm pads each word "  word " and windows over it, so "abc" yields exactly
+    // {"  a", " ab", "abc", "bc "}. Identical strings therefore score 1.0.
+    assert!((trigram_similarity("abc", "abc") - 1.0).abs() < 1e-6);
+
+    // "abc" vs "abd": {"  a"," ab","abc","bc "} vs {"  a"," ab","abd","bd "}.
+    // shared 2, union 4 + 4 - 2 = 6, so 1/3. Hand-computed against pg_trgm's definition.
+    assert!((trigram_similarity("abc", "abd") - 1.0 / 3.0).abs() < 1e-6);
+
+    // Non-alphanumerics are separators, not characters: punctuation between words changes nothing.
+    assert!((trigram_similarity("urza's bauble", "urza s bauble") - 1.0).abs() < 1e-6);
+
+    // Nothing in common scores 0, and an empty side scores 0 rather than dividing by zero.
+    assert_eq!(trigram_similarity("abc", "xyz"), 0.0);
+    assert_eq!(trigram_similarity("", "abc"), 0.0);
+    assert_eq!(trigram_similarity("", ""), 0.0);
+
+    // Symmetric, as Jaccard is.
+    assert_eq!(trigram_similarity("lightning", "lightnin"), trigram_similarity("lightnin", "lightning"));
+}
+
+/// The by-name lookups narrow through `name_trigram`, and narrowing must not change the answer.
+///
+/// Asserted DIFFERENTIALLY, over the same store built twice: once with the index (the narrowed
+/// path) and once without it (the full scan, which `store_of` produces because it does not build
+/// `name_trigram`). Every probe must agree. A test that only exercised the fast path would pass
+/// just as happily if the narrowing were fast and wrong.
+#[test]
+fn name_lookups_agree_with_and_without_the_trigram_index() {
+    // Built twice rather than cloned: neither OracleCard nor VocabInterner is Clone.
+    let fixture = || {
+        let mut vocab = VocabInterner::new();
+        let names = [
+            "lightning bolt",
+            "emeritus of conflict // lightning bolt",
+            "delver of secrets // insectile aberration",
+            "shock",
+            // Punctuated, so a COLLATED needle for it (`limduls vault`) shares no trigram with the
+            // stored spelling and the narrowed pass finds nothing -- the case the full-scan
+            // fallback in `name_best` exists for, and the one this test has to reach.
+            "lim-dul's vault",
+        ];
+        let mut cards = Vec::new();
+        for (i, name) in names.iter().enumerate() {
+            let mut c = stub_card(i as u128 + 1, 0, &[], &mut vocab);
+            c.card_name_lower = InlineStr::from_str(name);
+            cards.push(c);
+        }
+        store_of(cards, &[1, 1, 1, 1, 1], vocab)
+    };
+    // `store_of` does not build `name_trigram`, so this one takes the full-scan path.
+    let scan_data = fixture();
+    let mut idx_data = fixture();
+    idx_data.indexes.name_trigram = build_trigram_index(&idx_data.cards, |c| crate::folded_name_of(c, &[]));
+
+    let scan_bytes = rkyv::to_bytes::<Error>(&scan_data).expect("serialize");
+    let scan = rkyv::access::<Archived<CardData>, Error>(&scan_bytes).expect("access");
+    let idx_bytes = rkyv::to_bytes::<Error>(&idx_data).expect("serialize");
+    let idx = rkyv::access::<Archived<CardData>, Error>(&idx_bytes).expect("access");
+
+    for needle in [
+        "lightning bolt",
+        "delver of secrets",
+        "insectile aberration",
+        "emeritus of conflict",
+        "shock",
+        "no such card",
+        "li", // under 3 bytes: the index has nothing to say and both sides scan
+        // COLLATED spellings. Each of these matches a card whose stored folded name shares no
+        // trigram with it, so the narrowed side reaches its answer only through the full-scan
+        // fallback -- and an unnarrowed side that quietly disagreed would be the bug.
+        "limduls vault",
+        "limdulsvault",
+        "lim-duls vault",
+        "lightningbolt",
+        "lightning-bolt",
+        "delverofsecrets",
+    ] {
+        assert_eq!(
+            exact_name_match(scan, needle, None),
+            exact_name_match(idx, needle, None),
+            "exact_name_match disagrees for {needle:?}"
+        );
+        assert_eq!(
+            collection_name_match(scan, needle, None),
+            collection_name_match(idx, needle, None),
+            "collection_name_match disagrees for {needle:?}"
+        );
+    }
+    for words in [vec!["lightning".to_owned()], vec!["of".to_owned(), "secrets".to_owned()], vec!["zzz".to_owned()]] {
+        assert_eq!(
+            names_containing_all_words(scan, &words, None, 2),
+            names_containing_all_words(idx, &words, None, 2),
+            "names_containing_all_words disagrees for {words:?}"
+        );
+    }
+
+    // And the ranking rule the SQL carried in its ORDER BY: a WHOLE-name match beats a face match,
+    // even when the face's card scores higher. `lightning bolt` is card 0 and also the BACK face of
+    // card 1, whose printing has the better prefer_score.
+    assert_eq!(exact_name_match(idx, "lightning bolt", None).map(|(cid, _)| cid), Some(0));
+    // A face match is still found when nothing carries the whole name.
+    assert_eq!(exact_name_match(idx, "insectile aberration", None).map(|(cid, _)| cid), Some(2));
+}
+
+/// A store of `names`, folded == lowered (the fixture leaves `card_name_folded_id` unset), with
+/// `printing_counts[i]` printings on card i. The by-name tests below all want the same shape.
+fn name_store(names: &[&str], printing_counts: &[usize]) -> CardData {
+    let mut vocab = VocabInterner::new();
+    let mut cards = Vec::new();
+    for (i, name) in names.iter().enumerate() {
+        let mut c = stub_card(i as u128 + 1, 0, &[], &mut vocab);
+        c.card_name_lower = InlineStr::from_str(name);
+        cards.push(c);
+    }
+    store_of(cards, printing_counts, vocab)
+}
+
+/// The two name surfaces over one scan: a collection identifier's `{"name"}` reads a card's FACE
+/// names when the name splits in EXACTLY two and its whole name otherwise; `named?exact=` reads
+/// that set PLUS the joined name.
+///
+/// Measured against api.scryfall.com on 2026-08-31, one identifier per request -- a collection
+/// response's `data` is not in identifier order, so a batched probe answers the wrong needles:
+///
+///   {"name":"Delver of Secrets"}                   -> Delver of Secrets // Insectile Aberration
+///   {"name":"Insectile Aberration"}                -> the same card (a BACK face names it)
+///   {"name":"Delver of Secrets // Insectile ..."}  -> not_found, where `exact=` is the card
+///   {"name":"Fire // Ice"}                         -> not_found, likewise
+///   {"name":"Who // What // When // Where // Why"} -> und/75, a FIVE-part name IS a key
+///   {"name":"Who"}                                 -> not_found, and so is `exact=Who`
+#[test]
+fn a_collection_identifier_reads_faces_where_exact_also_reads_the_joined_name() {
+    let names = ["delver of secrets // insectile aberration", "who // what // when // where // why", "fire // ice"];
+    let data = name_store(&names, &[1, 1, 1]);
+    let bytes = rkyv::to_bytes::<Error>(&data).expect("serialize");
+    let d = rkyv::access::<Archived<CardData>, Error>(&bytes).expect("access");
+    let exact = |n: &str| exact_name_match(d, n, None).map(|(cid, _)| cid);
+    let coll = |n: &str| collection_name_match(d, n, None).map(|(cid, _)| cid);
+
+    // Either FACE names the card on both surfaces. The BACK is the half the SQL predicate the
+    // collection route carried never looked at: it split on ' // ' and compared part 1 only.
+    for needle in ["delver of secrets", "insectile aberration"] {
+        assert_eq!(exact(needle), Some(0), "exact= resolves a face name: {needle:?}");
+        assert_eq!(coll(needle), Some(0), "a collection identifier resolves a face name: {needle:?}");
+    }
+
+    // The JOINED name is the one key the two surfaces disagree about.
+    for (needle, cid) in [("delver of secrets // insectile aberration", 0), ("fire // ice", 2)] {
+        assert_eq!(exact(needle), Some(cid), "exact= answers the joined name: {needle:?}");
+        assert_eq!(coll(needle), None, "a collection identifier does not: {needle:?}");
+    }
+
+    // MORE than two halves: the whole name is the key and NO part of it is, on either surface.
+    // `split_once(" // ")` read this name as "who" plus the rest and answered und/75 for `who`.
+    let five = "who // what // when // where // why";
+    assert_eq!(exact(five), Some(1), "the five-part name is a key");
+    assert_eq!(coll(five), Some(1), "on both surfaces");
+    for part in ["who", "what", "when", "where", "why"] {
+        assert_eq!(exact(part), None, "no part of a five-part name is an exact= key: {part:?}");
+        assert_eq!(coll(part), None, "nor a collection identifier's: {part:?}");
+    }
+}
+
+/// Both name surfaces compare COLLATED names -- accent-folded (already, by the caller), lowercased,
+/// every non-alphanumeric character removed -- which is what Scryfall compares.
+///
+/// api.scryfall.com, 2026-08-31: `exact=limduls vault`, `exact=lim-duls vault`,
+/// `exact=Lightning-Bolt`, `exact=delverofsecrets` and `exact=whowhatwhenwherewhy` all resolve, and
+/// so do the same spellings as collection identifiers. Every one of them answered 404 here.
+#[test]
+fn both_name_surfaces_compare_collated_names() {
+    let names = ["lim-dul's vault", "lightning bolt", "delver of secrets // insectile aberration"];
+    let data = name_store(&names, &[1, 1, 1]);
+    let bytes = rkyv::to_bytes::<Error>(&data).expect("serialize");
+    let d = rkyv::access::<Archived<CardData>, Error>(&bytes).expect("access");
+    let exact = |n: &str| exact_name_match(d, n, None).map(|(cid, _)| cid);
+    let coll = |n: &str| collection_name_match(d, n, None).map(|(cid, _)| cid);
+
+    for needle in ["lim-dul's vault", "limduls vault", "lim-duls vault", "limdulsvault"] {
+        assert_eq!(exact(needle), Some(0), "exact= {needle:?}");
+        assert_eq!(coll(needle), Some(0), "collection {needle:?}");
+    }
+    for needle in ["lightning bolt", "lightning-bolt", "lightningbolt", "lightning  bolt"] {
+        assert_eq!(exact(needle), Some(1), "exact= {needle:?}");
+        assert_eq!(coll(needle), Some(1), "collection {needle:?}");
+    }
+
+    // A FACE collates the same way, and the " // " it sits beside does not leak into it: the
+    // halves are split BEFORE either side is collated, so no needle straddles the join.
+    assert_eq!(coll("delverofsecrets"), Some(2));
+    assert_eq!(coll("secretsinsectile"), None, "a needle across the join names nothing");
+
+    // Collating does not make the joined name a collection key, only a differently spelled one.
+    assert_eq!(exact("delverofsecretsinsectileaberration"), Some(2));
+    assert_eq!(coll("delverofsecretsinsectileaberration"), None);
+
+    // A KEY, not a substring. `{"name":"Elves"}` answers *Elves* (ffdn/9) on api.scryfall.com --
+    // the obscure card actually named that, not one of the hundreds whose names contain the word,
+    // which is what a containment lookup ordered by popularity would have said.
+    for needle in ["elves", "bolt", "vault", "dul"] {
+        assert_eq!(exact(needle), None, "exact= {needle:?}");
+        assert_eq!(coll(needle), None, "collection {needle:?}");
+    }
+    // A needle with no alphanumerics at all collates to nothing and names nothing -- answered
+    // without a scan, because `{"name":"  "}` is a shape a collection POST can carry.
+    for needle in ["", "  ", " // "] {
+        assert_eq!(exact(needle), None, "exact= {needle:?}");
+        assert_eq!(coll(needle), None, "collection {needle:?}");
+    }
+}
+
+/// A WHOLE-name match beats a FACE match on the collection surface too, and `set` filters the
+/// lookup rather than its answer.
+///
+/// The tier is not decoration: without it the collection rule is wrong wherever a needle is one
+/// card's whole name and another's face, and the loser scores higher. `{"name":"Delver of
+/// Secrets","set":"mid"}` answers mid/47 on api.scryfall.com -- the same card the unset identifier
+/// resolves, in the set asked for -- so the set narrows which PRINTING answers, and a card with no
+/// printing in that set drops out of the lookup entirely.
+#[test]
+fn a_collection_identifier_ranks_whole_over_face_and_takes_set_as_a_filter() {
+    // Card 1's printings score higher than card 0's (store_of scores a range descending from its
+    // length), so a rule ordering on prefer_score alone answers the FACE match here.
+    let names = ["lightning bolt", "emeritus of conflict // lightning bolt"];
+    let mut data = name_store(&names, &[1, 2]);
+    for (pid, code) in [(0, "aaa"), (1, "bbb"), (2, "ccc")] {
+        data.printings[pid].card_set_code = InlineStr::from_str(code);
+    }
+    let bytes = rkyv::to_bytes::<Error>(&data).expect("serialize");
+    let d = rkyv::access::<Archived<CardData>, Error>(&bytes).expect("access");
+
+    assert_eq!(collection_name_match(d, "lightning bolt", None), Some((0, 0)), "whole name beats the face");
+    assert_eq!(exact_name_match(d, "lightning bolt", None), Some((0, 0)), "on exact= alike");
+
+    // Restricted to the set the FACE card is printed in, the face match is the only candidate left.
+    assert_eq!(collection_name_match(d, "lightning bolt", Some("bbb")), Some((1, 1)));
+    assert_eq!(collection_name_match(d, "lightning bolt", Some("ccc")), Some((1, 2)));
+    // And a set nothing is printed in resolves nothing, rather than falling back to any printing.
+    assert_eq!(collection_name_match(d, "lightning bolt", Some("zzz")), None);
+}
+
+#[test]
+fn a_typo_resolves_to_the_intended_card() {
+    let mut vocab = VocabInterner::new();
+    let mut cards = Vec::new();
+    for (i, name) in ["lightning bolt", "shock", "counterspell"].iter().enumerate() {
+        let mut c = stub_card(i as u128 + 1, 0, &[], &mut vocab);
+        c.card_name_lower = InlineStr::from_str(name);
+        cards.push(c);
+    }
+    let bytes = rkyv::to_bytes::<Error>(&cards).expect("serialize");
+    let a = rkyv::access::<Archived<Vec<OracleCard>>, Error>(&bytes).expect("access");
+    // Every card here carries NONE_STR (folded == lower), so an EMPTY table is the right one:
+    // `folded_name` never reaches it, and a populated one would prove nothing extra.
+    let sbytes = rkyv::to_bytes::<Error>(&Vec::<String>::new()).expect("serialize strings");
+    let strs = rkyv::access::<Archived<Vec<String>>, Error>(&sbytes).expect("access strings");
+
+    match fuzzy_name_match(a, strs, "lightnig bolt", 0.4, 0.05) {
+        FuzzyOutcome::Hit(cid) => assert_eq!(cid, 0, "a one-letter typo still finds Lightning Bolt"),
+        _ => panic!("expected a hit"),
+    }
+    // Nothing close enough clears the floor.
+    assert!(matches!(fuzzy_name_match(a, strs, "zzzzzzzz", 0.4, 0.05), FuzzyOutcome::Miss));
+}
+
+#[test]
+fn two_close_names_are_ambiguous_not_a_guess() {
+    // Scryfall reports `ambiguous` rather than picking, and collapsing that to "not found" would
+    // tell the client the card does not exist.
+    let mut vocab = VocabInterner::new();
+    let mut cards = Vec::new();
+    for (i, name) in ["fire dragon", "fire dragoon"].iter().enumerate() {
+        let mut c = stub_card(i as u128 + 1, 0, &[], &mut vocab);
+        c.card_name_lower = InlineStr::from_str(name);
+        cards.push(c);
+    }
+    let bytes = rkyv::to_bytes::<Error>(&cards).expect("serialize");
+    let a = rkyv::access::<Archived<Vec<OracleCard>>, Error>(&bytes).expect("access");
+    // Every card here carries NONE_STR (folded == lower), so an EMPTY table is the right one:
+    // `folded_name` never reaches it, and a populated one would prove nothing extra.
+    let sbytes = rkyv::to_bytes::<Error>(&Vec::<String>::new()).expect("serialize strings");
+    let strs = rkyv::access::<Archived<Vec<String>>, Error>(&sbytes).expect("access strings");
+    assert!(matches!(fuzzy_name_match(a, strs, "fire dragen", 0.4, 0.05), FuzzyOutcome::Ambiguous));
+}
+
+#[test]
+fn printings_of_one_card_do_not_look_ambiguous() {
+    // Several cards sharing a NAME are one answer, not competing ones. Without the distinct-name
+    // rule they would tie with themselves and every fuzzy lookup would report ambiguous.
+    let mut vocab = VocabInterner::new();
+    let mut cards = Vec::new();
+    for i in 0..3u128 {
+        let mut c = stub_card(i + 1, 0, &[], &mut vocab);
+        // `card_name_folded_id` defaults to NONE_STR, i.e. "same as card_name_lower".
+        c.card_name_lower = InlineStr::from_str("lightning bolt");
+        cards.push(c);
+    }
+    let bytes = rkyv::to_bytes::<Error>(&cards).expect("serialize");
+    let a = rkyv::access::<Archived<Vec<OracleCard>>, Error>(&bytes).expect("access");
+    // Every card here carries NONE_STR (folded == lower), so an EMPTY table is the right one:
+    // `folded_name` never reaches it, and a populated one would prove nothing extra.
+    let sbytes = rkyv::to_bytes::<Error>(&Vec::<String>::new()).expect("serialize strings");
+    let strs = rkyv::access::<Archived<Vec<String>>, Error>(&sbytes).expect("access strings");
+    assert!(matches!(fuzzy_name_match(a, strs, "lightning bolt", 0.4, 0.05), FuzzyOutcome::Hit(_)));
+}
+
+#[test]
+fn autocomplete_matches_the_sql_routes_set_and_order() {
+    let mut vocab = VocabInterner::new();
+    let mut interner = Interner::new();
+    let mut cards = Vec::new();
+    // Matched on the lowercased key, ANSWERED with the printed name -- the two differ, which is
+    // the point: a catalog entry is something a client hands back to /cards/named?exact=.
+    // "Aftershock" is the substring case: it contains "sho" without starting with it.
+    for (i, name) in ["Shock", "Shatter", "Shockwave", "Aftershock", "Counterspell"].iter().enumerate() {
+        let mut c = stub_card(i as u128 + 1, 0, &[], &mut vocab);
+        c.card_name_lower = InlineStr::from_str(&name.to_lowercase());
+        // FOLDED is what the catalog now matches, so the fixture carries it. These names are ASCII,
+        // where folding is the identity -- the accented case is asserted separately below.
+        c.card_name_id = interner.intern((*name).to_string());
+        cards.push(c);
+    }
+    let n = cards.len();
+    let mut data = store_of(cards, &vec![1usize; n], vocab);
+    data.strings = interner.strings;
+    let bytes = rkyv::to_bytes::<Error>(&data).expect("serialize");
+    let a = rkyv::access::<Archived<CardData>, Error>(&bytes).expect("access");
+
+    // The SQL this route falls back to is
+    //   WHERE lower(card_name) LIKE '%needle%' ORDER BY rank, length(card_name), card_name
+    // with rank 0 for a prefix match and 1 for a bare substring. The route asks the ENGINE first,
+    // so a disagreement is not a fallback -- it is two different answers to one request, and this
+    // one is what ships. Every assertion below is that query's behaviour.
+
+    // Substring matches are IN the set, and rank behind every prefix match. Verified against
+    // api.scryfall.com, where q=bolt answers Bolt Bend .. Boltwing Marauder THEN Firebolt,
+    // Rift Bolt -- a prefix-only catalog would never offer the client "Aftershock" at all.
+    assert_eq!(
+        autocomplete_names(a, "sho", 20),
+        vec!["Shock", "Shockwave", "Aftershock"],
+        "prefix matches rank 0, substring matches rank 1"
+    );
+    assert_eq!(
+        autocomplete_names(a, "SHO", 20),
+        vec!["Shock", "Shockwave", "Aftershock"],
+        "case-insensitive"
+    );
+    // Within a rank the order is by LENGTH then name, not alphabetical: Shock(5), Shatter(7),
+    // Shockwave(9). Alphabetical would put Shatter first, which is what this returned before.
+    assert_eq!(
+        autocomplete_names(a, "sh", 20),
+        vec!["Shock", "Shatter", "Shockwave", "Aftershock"],
+        "length then name within a rank, and PRINTED -- a lowercase entry is not a name Scryfall prints"
+    );
+    // THE ACCENT CASE, which is why this matches the folded name at all. `q=eowyn` answered an
+    // EMPTY catalog before: the needle is ASCII, the stored lowercase name is not, and nobody types
+    // the accent. api.scryfall.com answers q=eowyn with three Éowyn cards, q=jotun with three Jötun
+    // ones and q=lim-dul with eight. The PRINTED name still comes back accented -- folding decides
+    // what MATCHES, not what is shown.
+    {
+        let mut vocab2 = VocabInterner::new();
+        let mut interner2 = Interner::new();
+        let mut accented = Vec::new();
+        for (i, (printed, folded)) in
+            [("Éowyn, Lady of Rohan", "eowyn, lady of rohan"), ("Jötun Grunt", "jotun grunt")].iter().enumerate()
+        {
+            let mut c = stub_card(i as u128 + 1, 0, &[], &mut vocab2);
+            c.card_name_lower = InlineStr::from_str(&printed.to_lowercase());
+            // A folded name that DIFFERS is the only case that reaches the strings table, which is
+            // exactly what these two names are here to exercise.
+            c.card_name_folded_id = interner2.intern((*folded).to_string());
+            c.card_name_id = interner2.intern((*printed).to_string());
+            accented.push(c);
+        }
+        let n2 = accented.len();
+        let mut d2 = store_of(accented, &vec![1usize; n2], vocab2);
+        d2.strings = interner2.strings;
+        let b2 = rkyv::to_bytes::<Error>(&d2).expect("serialize");
+        let a2 = rkyv::access::<Archived<CardData>, Error>(&b2).expect("access");
+        assert_eq!(autocomplete_names(a2, "eowyn", 20), vec!["Éowyn, Lady of Rohan"], "an ASCII needle reaches É");
+        assert_eq!(autocomplete_names(a2, "jotun", 20), vec!["Jötun Grunt"], "an ASCII needle reaches ö");
+        // Ordered by CHARACTERS, as Postgres `length()` counts, not bytes as `str::len()` does.
+        // Both names are prefix matches for "e", so rank cannot separate them: "Éxx" is 3
+        // characters and 4 bytes, "Exxx" is 4 of each. By characters "Éxx" wins outright, which is
+        // what the SQL answers; by bytes they TIE at 4 and fall to alphabetical, where 'E' precedes
+        // 'É' and the answer flips.
+        {
+            let mut v3 = VocabInterner::new();
+            let mut i3 = Interner::new();
+            let mut tie = Vec::new();
+            for (n, (printed, folded)) in [("Exxx", "exxx"), ("Éxx", "exx")].iter().enumerate() {
+                let mut c = stub_card(n as u128 + 1, 0, &[], &mut v3);
+                c.card_name_lower = InlineStr::from_str(&printed.to_lowercase());
+                c.card_name_folded_id = i3.intern((*folded).to_string());
+                c.card_name_id = i3.intern((*printed).to_string());
+                tie.push(c);
+            }
+            let n3 = tie.len();
+            let mut d3 = store_of(tie, &vec![1usize; n3], v3);
+            d3.strings = i3.strings;
+            let b3 = rkyv::to_bytes::<Error>(&d3).expect("serialize");
+            let a3 = rkyv::access::<Archived<CardData>, Error>(&b3).expect("access");
+            assert_eq!(autocomplete_names(a3, "e", 20), vec!["Éxx", "Exxx"], "shorter in CHARACTERS first");
+        }
+
+        // And the accented spelling still works, which is what it did before.
+        assert_eq!(autocomplete_names(a2, "jötun", 20), Vec::<&str>::new(), "the needle is folded by the caller");
+    }
+
+    // The cap applies to the ORDERED list, so it keeps the shortest prefix match rather than
+    // whichever name the corpus happened to reach first.
+    assert_eq!(autocomplete_names(a, "sh", 1), vec!["Shock"], "capped, after ordering");
+    assert!(autocomplete_names(a, "zzz", 20).is_empty());
+}
+
+// ─── Price orderings pick the group's cheapest printing ───────────────────────
+//
+// See `prefer_for_sort`. Scryfall ranks a card by its CHEAPEST printing in the ordered
+// currency and returns that printing, so under `unique=card`/`unique=artwork` the
+// representative has to be chosen by the ordered price rather than by `prefer_score`.
+
+/// One card whose three printings disagree about which is cheapest in each currency,
+/// plus a `prefer_score` order that agrees with none of them. `store_of` stores printings
+/// prefer-descending, so scryfall_id 1 is the default-preferred one.
+fn priced_store(prices: &[(Option<u32>, Option<u32>, Option<u32>)]) -> CardData {
+    let mut vocab = VocabInterner::new();
+    let card = stub_card(1, TYPE_CREATURE, &[], &mut vocab);
+    let mut data = store_of(vec![card], &[prices.len()], vocab);
+    for (p, &(usd, eur, tix)) in data.printings.iter_mut().zip(prices) {
+        p.price_usd = usd;
+        p.price_eur = eur;
+        p.price_tix = tix;
+    }
+    // Built, not left at their empty defaults: an empty index makes `walk_value_orderby_page`
+    // decline and fall back to the gather, which would leave the walk's `rep == pid` emission
+    // test — the one place the representative choice and the page order have to agree —
+    // silently uncovered.
+    data.indexes.price_usd = build_printing_value_index(&data.printings, &data.cards, &data.offsets, |p| p.price_usd);
+    data.indexes.price_eur = build_printing_value_index(&data.printings, &data.cards, &data.offsets, |p| p.price_eur);
+    data.indexes.price_tix = build_printing_value_index(&data.printings, &data.cards, &data.offsets, |p| p.price_tix);
+    data
+}
+
+/// The representative `unique=card` returns for `orderby`/`direction`, as a scryfall_id.
+fn representative(data: &CardData, prefer: &str, orderby: &str, direction: &str) -> u128 {
+    let bytes = rkyv::to_bytes::<Error>(data).expect("serialize");
+    let archived = rkyv::access::<Archived<CardData>, Error>(&bytes).expect("access");
+    let mut filter = FilterExpr::True;
+    let (total, page) = run_query(&QueryCtx::from(archived), &mut filter, None, "card", prefer, orderby, direction, 100, 0);
+    assert_eq!(total, 1, "unique=card collapses the fixture to one row");
+    u128::from(page[0].1.scryfall_id)
+}
+
+#[test]
+// Prices are integer CENTS, written `dollars_cents` so `1827_00` reads as $1827.00 at a
+// glance. clippy wants `182_700` and `50`; both are what the column holds and neither says
+// what the money is. The grouping is the documentation here, so the lints are allowed on
+// these three rather than the literals being flattened.
+#[allow(clippy::inconsistent_digit_grouping, clippy::zero_prefixed_literal)]
+fn price_orderby_represents_the_card_by_its_cheapest_printing() {
+    // id 1 is prefer-best; the cheapest is a different printing in each currency.
+    let data = priced_store(&[
+        (Some(9_00), Some(1_00), Some(9_00)), // id 1 — cheapest in EUR
+        (Some(5_00), Some(5_00), Some(0_50)), // id 2 — cheapest in TIX
+        (Some(1_00), Some(3_00), Some(3_00)), // id 3 — cheapest in USD
+    ]);
+    // The non-price ordering is untouched: it still gets the prefer_score pick.
+    assert_eq!(representative(&data, "default", "edhrec", "asc"), 1);
+    assert_eq!(representative(&data, "default", "name", "desc"), 1);
+    // Each price ordering gets that currency's cheapest printing...
+    assert_eq!(representative(&data, "default", "usd", "desc"), 3);
+    assert_eq!(representative(&data, "default", "eur", "desc"), 1);
+    assert_eq!(representative(&data, "default", "tix", "desc"), 2);
+    // ...in BOTH directions. Direction reverses the page; it does not re-pick the printing.
+    assert_eq!(representative(&data, "default", "usd", "asc"), 3);
+    assert_eq!(representative(&data, "default", "eur", "asc"), 1);
+    assert_eq!(representative(&data, "default", "tix", "asc"), 2);
+}
+
+/// The Juzám Djinn shape: the prefer-best printing is an unpriced oversized promo, so
+/// leaving the pick to `prefer_score` gave the card no USD price at all and dropped it out
+/// of a price sort entirely. A missing price must lose to any real one.
+#[test]
+// Prices are integer CENTS, written `dollars_cents` so `1827_00` reads as $1827.00 at a
+// glance. clippy wants `182_700` and `50`; both are what the column holds and neither says
+// what the money is. The grouping is the documentation here, so the lints are allowed on
+// these three rather than the literals being flattened.
+#[allow(clippy::inconsistent_digit_grouping, clippy::zero_prefixed_literal)]
+fn price_orderby_skips_a_printing_with_no_price_in_that_currency() {
+    let data = priced_store(&[
+        (None, None, Some(1_00)),          // id 1 — prefer-best, but unpriced in USD and EUR
+        (Some(1827_00), Some(1775_40), None), // id 2 — the only printing with a USD/EUR price
+    ]);
+    assert_eq!(representative(&data, "default", "edhrec", "asc"), 1);
+    assert_eq!(representative(&data, "default", "usd", "desc"), 2);
+    assert_eq!(representative(&data, "default", "eur", "desc"), 2);
+    // TIX is the mirror image: only the prefer-best printing has one.
+    assert_eq!(representative(&data, "default", "tix", "desc"), 1);
+}
+
+/// When NOTHING is priced there is no cheaper printing to prefer, so the card keeps its
+/// ordinary representative rather than silently changing which printing it shows.
+#[test]
+fn price_orderby_keeps_the_default_representative_when_no_printing_is_priced() {
+    let data = priced_store(&[(None, None, None), (None, None, None)]);
+    assert_eq!(representative(&data, "default", "usd", "desc"), 1);
+    assert_eq!(representative(&data, "default", "eur", "asc"), 1);
+    assert_eq!(representative(&data, "default", "tix", "desc"), 1);
+}
+
+/// An explicit `prefer=` is the caller naming the printing they want, and it still wins —
+/// `prefer_for_sort` only fills in a pick for callers that did not make one.
+#[test]
+// Prices are integer CENTS, written `dollars_cents` so `1827_00` reads as $1827.00 at a
+// glance. clippy wants `182_700` and `50`; both are what the column holds and neither says
+// what the money is. The grouping is the documentation here, so the lints are allowed on
+// these three rather than the literals being flattened.
+#[allow(clippy::inconsistent_digit_grouping, clippy::zero_prefixed_literal)]
+fn an_explicit_prefer_still_beats_the_price_orderby() {
+    let data = priced_store(&[
+        (Some(9_00), Some(1_00), Some(9_00)), // id 1 — prefer-best, dearest in USD
+        (Some(5_00), Some(5_00), Some(0_50)),
+        (Some(1_00), Some(3_00), Some(3_00)), // id 3 — cheapest in USD
+    ]);
+    assert_eq!(representative(&data, "usd_high", "usd", "desc"), 1);
+    assert_eq!(representative(&data, "usd_low", "usd", "desc"), 3);
+    // `oldest`/`newest` are price-blind: store_of makes the LAST printing the oldest.
+    assert_eq!(representative(&data, "oldest", "usd", "desc"), 3);
+    assert_eq!(representative(&data, "newest", "usd", "desc"), 1);
+}
+
+/// `order=artist` treats an artistless printing the way every other ordering treats an absent
+/// value, rather than as a real rank at the far end.
+///
+/// `assign_artist_ranks` parks the artistless printings in a trailing rank block, and reporting
+/// that block as a VALUE made this the one ordering whose absent side moved with the direction in
+/// the wrong sense: last ascending (correct) but FIRST descending (not), because a real rank
+/// reflects under `desc` and an absent sentinel does not.
+#[test]
+fn an_artistless_printing_sorts_like_an_absent_value() {
+    let mut vocab = VocabInterner::new();
+    let cards = vec![stub_card(1, TYPE_CREATURE, &[], &mut vocab), stub_card(2, TYPE_CREATURE, &[], &mut vocab)];
+    let mut data = store_of(cards, &[1, 1], vocab);
+    let artist_vocab = vec!["aaa".to_string()];
+    data.printings[0].card_artist_vid = 0;
+    data.printings[1].card_artist_vid = ARTIST_NONE;
+    assign_artist_ranks(&mut data.printings, &artist_vocab);
+    let bytes = rkyv::to_bytes::<Error>(&data).expect("serialize");
+    let archived = rkyv::access::<Archived<CardData>, Error>(&bytes).expect("access");
+
+    // Asserted RELATIVE to a column that is already nullable, not against a fixed direction, so
+    // this pins the property that matters -- artist's absent side behaves like everybody else's --
+    // without also pinning WHICH side that is. It therefore holds both before and after the
+    // nulls-sort-lowest change, and would fail if only one of the two were ever flipped.
+    for descending in [false, true] {
+        let artist_named = sort_key_bits(&archived.cards[0], &archived.printings[0], SortCol::Artist, descending);
+        let artist_absent = sort_key_bits(&archived.cards[1], &archived.printings[1], SortCol::Artist, descending);
+        let cmc_present = perm_primary_key(Some(1.0), descending);
+        let cmc_absent = perm_primary_key(None, descending);
+        assert_eq!(
+            artist_absent > artist_named,
+            cmc_absent > cmc_present,
+            "artist's absent side disagrees with cmc's (descending={descending})",
+        );
+    }
+}
+
 /// `super::sigma_bound`'s Rust port must agree with the Python original
 /// (`scripts/bench_compose_card_visited_safety_bound.py`) it was translated from -- that Python side
 /// is already Monte-Carlo-verified against simulated random placements (`selfcheck_nhg_moments`), so
diff --git a/client/query_sampler.py b/client/query_sampler.py
index b556f97e7..fa57917d8 100644
--- a/client/query_sampler.py
+++ b/client/query_sampler.py
@@ -136,16 +136,42 @@
 # ships in the client image, which contains no `api/`. Anything outside this set is accepted by the
 # engine and silently sorted by edhrec, so callers mapping external orderbys should fall back
 # explicitly rather than pass an unknown value through and mislabel the result.
-ENGINE_ORDERBYS = frozenset({"cmc", "cubecobra", "edhrec", "name", "power", "rarity", "toughness", "usd"})
+ENGINE_ORDERBYS = frozenset(
+    {
+        "artist",
+        "cmc",
+        "color",
+        "cubecobra",
+        "edhrec",
+        "eur",
+        "name",
+        "power",
+        "rarity",
+        "released",
+        "set",
+        "tix",
+        "toughness",
+        "usd",
+    },
+)
 REALISTIC_ORDERBY_WEIGHTS: dict[str, float] = {
     "edhrec": 40,
     "name": 15,
     "cmc": 10,
-    "usd": 10,
-    "rarity": 8,
-    "power": 6,
-    "toughness": 5,
-    "cubecobra": 6,
+    "usd": 8,
+    "rarity": 7,
+    "power": 5,
+    "toughness": 4,
+    "cubecobra": 5,
+    # The orders added with the Scryfall vocabulary. Weighted low because they are new rather than
+    # because they are known to be rare -- and non-zero because none of them has a precomputed sort
+    # permutation, so they exercise the general sort path the streaming plans skip.
+    "released": 2,
+    "set": 1,
+    "color": 1,
+    "artist": 1,
+    "eur": 0.5,
+    "tix": 0.5,
 }
 # Non-default result parameters skew hard to their defaults but are sampled so the paths that only
 # run off-default stay on the radar.
diff --git a/docs/changelog/2026-08-09-order-vocabulary.md b/docs/changelog/2026-08-09-order-vocabulary.md
new file mode 100644
index 000000000..722d8fcdc
--- /dev/null
+++ b/docs/changelog/2026-08-09-order-vocabulary.md
@@ -0,0 +1,44 @@
+# Six more `order=` values, and `dir=auto`
+
+## What this adds
+
+`order=` accepted `cmc`, `edhrec`, `name`, `power`, `rarity`, `toughness`, `usd` and `cubecobra`.
+It now also accepts `released`, `set`, `artist`, `color`, `eur` and `tix` — Scryfall's vocabulary
+minus `penny` and `review`.
+
+`dir=auto` is new. It is not a constant: measured against api.scryfall.com, `auto` means descending
+for `released`, `rarity`, `usd`, `tix` and `eur`, and ascending for everything else. Two of those
+are orderings that already existed, so `rarity` and `usd` were previously sorting the wrong way for
+any caller that asked for `auto`.
+
+All of it lands on `/search`, on `/cards/search`, and on the in-query `order:` / `sort:` /
+`direction:` / `dir:` directives at once, because every route resolves to `CardOrdering` and
+`SortDirection` before reaching a search path.
+
+## How
+
+The blocker was `orderby_to_col` in the engine, whose catch-all arm sorts by edhrec. An ordering
+added to the API and not to `SortCol` does not raise — it makes the engine and the SQL builder
+return differently-ordered pages for identical input. So each new ordering is an engine change
+first: a `SortCol` variant and a `sort_key_bits` arm, plus
+
+- **`released`** packs `yyyymmdd` down to `y*372 + (m-1)*31 + (d-1)` before the sort key. The key
+  rounds through f32, exact only below 2^24; a raw `20260809` is past that and collides dates a day
+  or two apart. `released_at_int` itself is unchanged, since the date and year filters read it.
+- **`color`** is eleven buckets — `W U B R G`, multicolour by how many colours, colourless, land.
+  Measured, because two parts are not what a colour bitmask gives: colourless sorts last rather
+  than first, and lands after it.
+- **`set` and `artist`** get dense ranks on the printing, assigned post-load like `name_rank`
+  already is. Neither sorts from what the key can reach: a set code is a string, and
+  `card_artist_vid` is intern order. `ARCHIVE_FORMAT_VERSION` bumps so an existing store rebuilds.
+
+`AUTO` resolves in `_search`, before either path sees it, so the engine and SQL always receive the
+same concrete direction and the cache keys on what actually ran.
+
+## Not covered
+
+`penny` needs `penny_rank` lifted out of `raw_card_blob` into a column; `review` is Scryfall-internal
+and not reproducible. Both keep falling back to `name`, which is what Scryfall does with an order it
+does not recognize — measured: it falls back silently rather than erroring.
+
+Full design and measurements: [docs/issues/local-engine-order-vocabulary.md](../issues/local-engine-order-vocabulary.md).
diff --git a/docs/changelog/2026-08-09-scryfall-cards-api.md b/docs/changelog/2026-08-09-scryfall-cards-api.md
new file mode 100644
index 000000000..5a6372c20
--- /dev/null
+++ b/docs/changelog/2026-08-09-scryfall-cards-api.md
@@ -0,0 +1,62 @@
+# Every Scryfall `/cards/*` route, so the base URL is the only thing a client changes
+
+## What this is for
+
+The engine already answers Scryfall's query syntax. `/search` returns it in this project's own
+response shape — selected fields, a `cards` array, `limit`/`offset` — which is what the frontend
+wants and stays exactly as it is.
+
+A Scryfall-shaped client wants something different: Scryfall's response objects and pagination, plus
+the per-card addressings it reaches for alongside search — `/cards/:id`, `/cards/named`,
+`/cards/:code/:number`, the external id namespaces, rulings. This adds that as a second surface, so
+such a client can be pointed here by changing its base URL and nothing else.
+
+## How
+
+`api/scryfall_compat/` adds every route Scryfall documents under `/cards`, answering with Scryfall's
+own response objects, its 175-per-page pagination, and its error bodies:
+
+- `GET /cards`, `/cards/search`, `/cards/named`, `/cards/autocomplete`, `/cards/random`
+- `POST /cards/collection`
+- `GET /cards/:id`, `/cards/:code/:number(/:lang)`, and the multiverse / mtgo / arena / tcgplayer /
+  cardmarket id namespaces
+- `GET /cards/:id/rulings` and its four sibling addressings
+
+The handlers are a mixin on `APIResource` — `iter_marked_routes` scans inherited attributes, so they
+register like any other route while the compatibility surface stays in files of its own. The
+existing router needed no change: it matches a full path before falling back to the first segment,
+so the five named sub-routes claim their exact paths and the other nine path shapes reach one
+handler as positional segments.
+
+Two things the stored data did not already support:
+
+- **The card object itself.** `raw_card_blob` is snapshotted after the importer adds three keys and
+  normalizes `flavor_text`; both are exactly reversible, and `to_scryfall_card` reverses them. This
+  nearly needed a second column: the blob for a multi-face row used to be the front face promoted to
+  top level, which no reader can undo, because which keys a real card carries at top level depends
+  on layout. That was fixed at the source instead — the merged row now stores the card-level object
+  with its faces re-attached — so no column holds a duplicate.
+- **Rulings.** New `magic.rulings`, loaded from the bulk `rulings` file the fetcher already knew
+  about, as a whole-table replace inside one transaction (the file carries no ruling id, and
+  rulings are occasionally retracted). Identity being the tuple means the file can repeat one — 37
+  of 77,998 entries on 2026-08-11 — so the count the import reports is what Postgres kept, not what
+  was sent to it. They are served **newest first** (`published_at DESC`), which is the order
+  api.scryfall.com uses: measured 2026-08-12, 16 of 16 cards whose rulings span several dates came
+  back newest-first and 0 oldest-first. The tie inside one date is Scryfall's own ruling id and
+  cannot be reproduced from the file — see the issue doc's divergence list.
+
+Lookups are index-backed on the 97,808-card corpus, including three folded-name expression indexes
+so that `named?exact=`, which matches either face of a `Front // Back` card, plans as a BitmapOr
+rather than a sequential scan.
+
+`/cards/random` is exempted from both cache layers: `_run_query` keys on SQL text plus parameters,
+which do not vary between draws, and `CachingMiddleware` would have pinned one card per generation.
+
+## Not covered
+
+The corpus remains a filtered subset of Scryfall's — cards illegal in every format, tokens, funny
+sets and digital-only printings are never imported — so a card this instance does not hold 404s here
+and resolves there. Two `order` values -- `penny` and `review` -- have no counterpart and fall back
+to `name` with a response warning, which is what Scryfall does with an order it does not recognize.
+Full list of divergences in
+[docs/issues/local-scryfall-cards-api.md](../issues/local-scryfall-cards-api.md).
diff --git a/docs/changelog/2026-08-11-scryfall-sets-catalogs-symbology.md b/docs/changelog/2026-08-11-scryfall-sets-catalogs-symbology.md
new file mode 100644
index 000000000..1c3822f93
--- /dev/null
+++ b/docs/changelog/2026-08-11-scryfall-sets-catalogs-symbology.md
@@ -0,0 +1,48 @@
+# The rest of the Scryfall API: sets, catalogs and symbology
+
+## What this is for
+
+The `/cards/*` work made every card route answer the way api.scryfall.com does. That left the half of
+the API that describes Magic rather than returning cards: what sets exist, what the game's
+vocabularies are, and what the mana symbols mean. A client pointed at this host would get its cards
+and then 404 on `/sets`.
+
+This adds those twenty-six routes, after which the Scryfall API surface is complete.
+
+## How
+
+- `GET /sets`, `/sets/:code`, `/sets/:id`, `/sets/tcgplayer/:id` — 1,047 Set objects
+- `GET /catalog/:name` — all twenty documented catalogs, 62,187 values between them
+- `GET /symbology` — 84 CardSymbol objects
+- `GET /symbology/parse-mana?cost=` — Scryfall's ManaCost object
+
+All of it except `parse-mana` is **mirrored from Scryfall rather than derived from the corpus**, into
+three new tables. That is the decision worth knowing about, and it is not the obvious one: this
+project already derives `/cards/autocomplete` from its own cards. It does not survive the data here.
+A Set object carries eight fields no card carries — `tcgplayer_id`, `icon_svg_uri`, `block`,
+`parent_set_code` among them — and `/sets/tcgplayer/:id` cannot be implemented at all without the
+first. `card_count` is a count of Scryfall's printings, and this corpus is a deliberate subset, so a
+derived one would report a number no other Scryfall client agrees with. A card symbol has no card to
+derive from.
+
+The three loads are whole-table replaces in one transaction each, wired into the existing import
+sequence beside the rulings load. They reach Scryfall through a new `fetch_api_json` on the bulk
+fetcher, reusing its retry policy rather than opening a second HTTP client. A failure in one of the
+three does not stop the other two, and inside the catalog load a single failing catalog keeps its
+previous contents rather than being written empty — nineteen fresh catalogs and one stale one beats
+one that claims Magic has no creature types.
+
+`parse-mana` is computed, so it answers before the first import. Two of its behaviours are
+undocumented and were measured rather than inferred: the normalized cost reorders colored pips into
+canonical colour order (`RUW` answers `{U}{R}{W}`), and emission order is X, generic, colored pips,
+`{C}` regardless of how the cost was written (`2XWU` answers `{X}{2}{W}{U}`). Both are pinned by 79
+goldens captured from the live API, covering all 31 colour combinations written forwards and
+backwards.
+
+## Not covered
+
+`card_count` reports Scryfall's number, not this instance's, and `/catalog/card-names` lists cards
+this instance may not hold — the mirroring decision, stated plainly. A catalog name Scryfall adds
+later 404s here until the list in code is extended, which is deliberate: an unknown name should not
+answer as an empty catalog. Full list in
+[docs/issues/local-scryfall-sets-catalogs-symbology.md](../issues/local-scryfall-sets-catalogs-symbology.md).
diff --git a/docs/issues/local-engine-order-vocabulary.md b/docs/issues/local-engine-order-vocabulary.md
new file mode 100644
index 000000000..a42b024af
--- /dev/null
+++ b/docs/issues/local-engine-order-vocabulary.md
@@ -0,0 +1,113 @@
+# The Six Missing `order` Values, and `dir=auto`
+
+Scryfall sorts by fifteen things. This engine sorts by eight, and `dir=auto` is not implemented at
+all. Closing that gap lands in three places at once — the `order=` parameter, the in-query `order:`
+directive (#893 builds its vocabulary from the `CardOrdering` enum), and the Scryfall-compatible
+`/cards/search` (#912) — because all three resolve to the same enum before reaching a search path.
+
+Everything below marked *measured* was taken from api.scryfall.com on 2026-08-09.
+
+## What blocks it
+
+`orderby_to_col` (`card_engine/src/lib.rs`) maps an order name to `SortCol`, with a catch-all:
+
+```rust
+_ => SortCol::EdhrecRank,
+```
+
+So adding a `CardOrdering` member and a `sql_orderby` entry without extending `SortCol` makes the
+SQL path sort by the new column while the engine silently sorts by edhrec. The two paths would
+disagree on identical input, which is the failure `RESULT_FIELD_COLUMNS` already warns about for
+result fields. **Every order below is an engine change first and an API change second.**
+
+## `dir=auto` — measured
+
+Scryfall's `auto` is per-order, not a constant. Taken over `q=t:creature s:dom` by comparing the
+`auto` page against the `asc` and `desc` pages:
+
+| resolves to `desc` | resolves to `asc` |
+| --- | --- |
+| `released`, `rarity`, `usd`, `tix`, `eur` | `name`, `set`, `color`, `cmc`, `power`, `toughness`, `edhrec`, `penny`, `artist`, `review` |
+
+Two of these are orders this engine already supports, so **`rarity` and `usd` are wrong today** for
+any caller that passes `auto` — they sort ascending where Scryfall sorts descending.
+
+`edhrec` resolves to **ascending**, which is the direction that puts rank 1 (Llanowar Elves, on that
+query) first. Rank-descending would surface the least-played cards, so "descending popularity" and
+"ascending rank" are the same thing here and the enum wants the latter.
+
+`auto` folds to a concrete direction *before* either search path sees it, so it belongs in `_search`
+next to the directive folding, not in the engine. That also means `/search` and `/cards/search` get
+it from one place, and `direction:auto` / `dir:auto` come free.
+
+## The six orders
+
+| order | data on the printing | work |
+| --- | --- | --- |
+| `eur` | `price_eur: Option<u32>` (cents) | one arm each in `orderby_to_col` and `sort_key_bits`, identical to `usd` |
+| `tix` | `price_tix: Option<u32>` (cents) | same |
+| `released` | `released_at_int: Option<u32>` | see the f32 trap below |
+| `color` | `card_colors: u8` bitmask + `TYPE_LAND` | rank function, see below |
+| `set` | `card_set_code: InlineStr<8>` | needs a dense rank; string, so nothing to sort on directly |
+| `artist` | `card_artist_vid: u16` | needs a dense rank; vid is intern order, not alphabetical |
+
+### The f32 trap on `released`
+
+`sort_key_bits` packs the primary into 32 bits via `f32_sort_bits`, and the comment on `name_rank`
+already records the constraint: *"Ranks stay below 2^24 so the f32 sort-key conversion is exact."*
+
+`released_at_int` is `yyyymmdd`, so 20260809 — three orders of magnitude past 2^24 = 16,777,216.
+Fed in raw it silently loses roughly a day or two of resolution, which is invisible in every test
+that does not compare two adjacent release dates.
+
+`released_at_int` must stay `yyyymmdd` (date and year filters read it), so the sort key packs it
+down instead: `y * 372 + (m - 1) * 31 + (d - 1)`, which is strictly order-preserving for valid dates
+and tops out near 755,000 for year 2030. Computed inline in `sort_key_bits` — it runs once per
+matching row while building the `Match` tuple, not once per comparison.
+
+### The colour ranking — measured
+
+Scryfall's `order=color` is eleven buckets, taken over 923 legendary creatures and lands spanning
+every colour shape:
+
+```
+W → U → B → R → G → 2-colour → 3-colour → 4-colour → 5-colour → colourless → land
+```
+
+Two things worth noting, because neither is what a reader would guess. Multicolour is bucketed by
+**how many** colours, not by which — within 2-colour the order is whatever the secondary sort gives,
+so all guild pairs tie. And colourless sorts *after* every coloured bucket rather than before,
+with lands after that; a naive popcount would put colourless first.
+
+The rank is `0..=10`, computable from the bitmask's popcount, its single set bit for the mono cases,
+and a `TYPE_LAND` check. Trivially inside the exact-f32 range.
+
+### `set` and `artist` need a stored rank
+
+Neither can be ordered from what the sort key can reach: a set code is a string, and
+`card_artist_vid` is assigned in first-seen order by the interner, not alphabetically. Both follow
+the existing `assign_name_ranks` shape — a post-load dense-rank pass writing a `u32` onto the
+printing — which means two new fields on `Printing`, inherited by `APrinting` through the rkyv
+derive, and a bump of `ARCHIVE_FORMAT_VERSION` so an existing store rebuilds rather than
+misreading. Cost is 8 bytes per printing, ~4 MB against the build's ~305 MB floor.
+
+## Deliberately not done
+
+- **`penny`** — `penny_rank` lives only inside `raw_card_blob`. Needs a migration, a column, an
+  import change and an engine field: a much larger change for the least-used order in the list.
+- **`review`** — Scryfall-internal ordering with no public input. Not reproducible at any cost, and
+  the one value on the list that should stay unsupported permanently.
+
+Both keep falling back to `name`, which is what Scryfall itself does with an order it does not
+recognize — *measured*: `order=bogus` returns the same page as no `order` at all, silently, with no
+error. The only divergence is the `warnings` entry this API adds saying so.
+
+## Order of work
+
+1. `eur`, `tix` — near-free, and they prove the seam.
+2. `released`, `color` — computed ranks, no store change.
+3. `set`, `artist` — the two stored ranks and the format bump.
+4. `SortDirection.AUTO` and the table above, folded in `_search`.
+
+Steps 1, 2 and 4 touch no archived layout, so they can ship without a store rebuild; step 3 forces
+one on next boot.
diff --git a/docs/issues/local-scryfall-cards-api.md b/docs/issues/local-scryfall-cards-api.md
new file mode 100644
index 000000000..d11f536d4
--- /dev/null
+++ b/docs/issues/local-scryfall-cards-api.md
@@ -0,0 +1,181 @@
+# A Drop-In `/cards/*`: Every Scryfall Card Route, Same Wire Format
+
+The goal is one sentence: a client written against api.scryfall.com should work against this host
+after changing its base URL and nothing else. That means the same paths, the same query parameters,
+the same response objects, the same pagination, and the same error bodies.
+
+This doc is the record of what was built, the two places the stored data did not permit an exact
+answer and what was done about them, and the divergences a reader should know about before pointing
+production traffic here.
+
+## The routes
+
+Every path Scryfall documents under `/cards`:
+
+| Route | Notes |
+| --- | --- |
+| `GET /cards` | Every card, 175 per page |
+| `GET /cards/search` | `q`, `unique`, `order`, `dir`, `page`, `format`, `pretty`, and the three `include_*` flags |
+| `GET /cards/named` | `exact` / `fuzzy`, `set`, `format`, `face`, `version`, `pretty` |
+| `GET /cards/autocomplete` | Catalog of ≤20 names |
+| `GET /cards/random` | Optional `q` |
+| `POST /cards/collection` | ≤75 identifiers, `not_found` echoed back |
+| `GET /cards/:id` | Scryfall UUID |
+| `GET /cards/:code/:number(/:lang)` | Language defaults to `en`, as Scryfall's does |
+| `GET /cards/multiverse\|mtgo\|arena\|tcgplayer\|cardmarket/:id` | MTGO also matches `mtgo_foil_id`, TCGplayer also `tcgplayer_etched_id` |
+| `GET /cards/:id/rulings` and the four sibling addressings | New `magic.rulings` table |
+
+`format=json` everywhere, plus `csv` on the two list routes and `text` / `image` on the single-card
+routes. `format=image` is a 302 to the card's own CDN URL, which is what Scryfall answers with, so
+the client ends up at the identical image.
+
+### How they attach to the router
+
+`_resolve_action` matches a full path first and then falls back to the first segment, passing the
+rest positionally. So the five named sub-routes register their exact paths and win outright, and
+everything else — nine path shapes across one to three segments — arrives at one `cards` handler
+that dispatches on the segments. No routing change was needed.
+
+The handlers live in `api/scryfall_compat/` as a mixin on `APIResource` rather than as more methods
+on it: `iter_marked_routes` scans inherited attributes, so they register identically, and the
+compatibility surface stays in files of its own.
+
+## The two places the data did not permit an exact answer
+
+### 1. The stored blob is not *quite* the object Scryfall sent
+
+`preprocess_card` snapshots `raw_card_blob` *after* it has added `card_name`, `face_name` and
+`face_idx`, and after it has normalized absent `flavor_text` to `""`. Both are exactly reversible,
+and `to_scryfall_card` reverses them: drop the three keys, and drop `flavor_text` when it is `""` —
+a value Scryfall never sends, so absent and empty are one state and the mapping is a bijection.
+
+That is the whole of it, and it is worth recording how close this came to being much more.
+
+This work originally carried a `cards.scryfall_json` column holding the untouched object for
+multi-face rows, because the blob for those rows was **the front face promoted to top level**:
+`card_faces` gone, `name` and `type_line` the front's, and eleven extra top-level keys. A reader
+could not undo that promotion, because which keys a real card carries at top level depends on
+layout — a split card has `mana_cost` and `image_uris` there, a transform card does not — so no
+strip rule is correct for both.
+
+The column was deleted in favour of fixing the blob at the source ([#894](https://github.com/jbylund/sylvan_librarian/pull/894)):
+the merged row now stores the card-level object with its faces re-attached. Auditing what depended
+on the promotion turned up exactly one thing, `image_uris`, and every reader of it already coalesced
+to `card_faces->0`. Everything else read from the blob — `lang`, `set_type`, `games`, `finishes`,
+`frame_effects`, `image_status`, `reserved`, `game_changer` — is card-level and identical either way.
+
+The general form: `raw_card_blob` holds what Scryfall sent and derived data lives in derived
+columns. A compatibility layer that needs the original should be able to read the column that is
+named after it, rather than carry a second copy because the first one was pre-chewed.
+
+**Deployment note.** Rows are rewritten by an import, not by a migration. Until the first bulk import
+after deploy, a multi-face row still holds a promoted front face, and `to_scryfall_card` falls back
+to presenting that face as its card — relabeled `object: "card"` under the card's full name rather
+than shipped as a `card_face` claiming to be a card. It is the one window in which a payload is not
+byte-identical, it affects ~2% of rows, and it closes on its own.
+
+### 2. Rulings did not exist
+
+New `magic.rulings` (oracle_id, source, published_at, comment), loaded from the bulk `rulings` file
+the fetcher already knew about, wired into the import sequence after the tag imports.
+
+The load is a whole-table replace in one transaction, not an upsert. The file carries no ruling id —
+a row's identity is the tuple itself — and rulings are occasionally retracted, so insert-only would
+accumulate withdrawn rows. It uses `DELETE` rather than `TRUNCATE` so readers keep seeing the
+previous contents through MVCC instead of blocking on an `ACCESS EXCLUSIVE` lock for the load, and a
+failure is logged rather than raised: rulings are the only thing in the import sequence nothing else
+reads, and aborting the corpus refresh to save a rulings refresh is the wrong trade.
+
+## Indexes
+
+The identifiers Scryfall routes by live inside `raw_card_blob`, not in columns, so the lookups need
+expression indexes. Each partial index predicates on the *same* expression its lookup compares, so
+the planner can prove the query implies the predicate — `((blob->>'mtgo_id')::bigint) IS NOT NULL`
+rather than `blob ? 'mtgo_id'`, which it cannot connect to the cast.
+
+Verified against the 97,808-card dev corpus:
+
+| Lookup | Plan |
+| --- | --- |
+| `/cards/mtgo/:id` | Index Scan, `idx_cards_mtgo_id` |
+| `/cards/multiverse/:id` | Bitmap Index Scan, `idx_cards_multiverse_ids` (GIN, `jsonb_path_ops`) |
+| `/cards/:code/:number/:lang` | Index Scan, `idx_cards_set_collector_lang` |
+| `/cards/named?exact=` | BitmapOr across the three folded-name indexes |
+| `/cards/named?fuzzy=` (trigram stage) | 5.6 ms |
+
+The set-code index is on `lower(card_set_code)`: Scryfall's set codes are case-insensitive and the
+lookup folds the segment. The corpus happens to store them lowercase already, but nothing constrains
+it to, and indexing the column instead cost the index — the planner fell back to
+`idx_cards_collector_number` and rechecked the set code and language per candidate row.
+
+`/cards/named?exact=` also matches one face of a `Front // Back` card, which is why two `split_part`
+expression indexes exist alongside the whole-name one: with all three indexed the lookup's `OR` is a
+BitmapOr instead of a sequential scan.
+
+## `/cards/random` must not be cached, twice over
+
+The draw is non-deterministic for a fixed query and parameter set, which is exactly what both cache
+layers assume away.
+
+- `_run_query` keys on SQL text plus parameters, both invariant here, so it would have replayed the
+  first card forever. The draw goes through `_run_uncached` instead.
+- `CachingMiddleware` would have pinned one card as "the" random card for the whole generation. The
+  response sets `Cache-Control: no-store`.
+
+Worth recording because the test that catches this **passes on a buggy implementation under the
+default suite settings**: with caching off, `_query_cache` holds one entry, so the count query and
+the draw evict each other and the bug hides. The test installs the multi-entry cache production has
+before drawing.
+
+## Known divergences
+
+Ordered by how likely they are to matter.
+
+1. **The corpus is a filtered subset.** `preprocess_card` drops cards illegal in every format,
+   tokens, playtest cards, funny sets and digital-only printings. A card this instance never
+   imported 404s here and resolves on Scryfall. This is a policy of the project, not of these
+   routes, and it is the largest single difference.
+2. **Query syntax parity is tracked separately.** `/cards/search` hands `q` to the existing parser;
+   whatever that parser supports is what these routes support. The in-flight parser work applies
+   here automatically.
+3. **Two `order` values have no counterpart** — `penny` and `review`. `penny_rank` lives only
+   inside `raw_card_blob`, and `review` is Scryfall-internal with no public input. Both fall back
+   to `name`, which is what Scryfall itself does with an order it does not recognize (measured: it
+   falls back silently, no error), plus a `warnings` entry saying so. The other six of Scryfall's
+   vocabulary are wired — see local-engine-order-vocabulary.md; `_ORDER_MAP` is built from
+   `CardOrdering`, so anything added there is accepted here without a second edit.
+4. **`include_extras`, `include_multilingual` and `include_variations` are accepted and ignored.**
+   There are no extras in the corpus to include, and every printing and language it holds is
+   returned unconditionally.
+5. **`format=csv` column parity is best-effort.** The column list is fixed and documented in
+   `routes.py` so a header does not change between pages of one result set, but it was not verified
+   cell-for-cell against Scryfall's export.
+6. **`format=text` is a faithful rendering, not a verified-identical one.**
+7. **Card URIs are not rewritten.** `uri`, `rulings_uri` and `prints_search_uri` in a returned card
+   still point at api.scryfall.com, because they are part of the payload and rewriting them would
+   make it non-identical. `next_page` is the exception — it must address this host or pagination
+   does not work, and its scheme comes from `Forwarded` / `X-Forwarded-Proto`. A deployment that
+   terminates TLS in front of this service has to send one of those, as it already must for
+   `X-Proxy-Host` to give the right host. Guessing `https` from the host name instead was tried
+   and rejected: it silently breaks a plain-HTTP deployment on a real hostname — a configuration
+   this project supports — to paper over one that is misconfigured.
+8. **`GET /cards` at a deep offset costs ~300 ms** (measured at page 501 of 559). The endpoint is
+   rarely used and the result is cached per import generation.
+9. **Same-day rulings are not in Scryfall's order.** The rulings routes sort `published_at DESC,
+   comment`. The descending half is Scryfall's own — measured 2026-08-12, 16 of 16 cards whose
+   rulings span several dates came back newest-first and 0 oldest-first — but the tie inside one
+   date is Scryfall's internal ruling id, which the bulk file does not carry. None of the file's
+   own line order, that order reversed, comment ascending or comment descending reproduced it on
+   any of 10 sampled cards, so `comment` is a deterministic stand-in rather than a match. It
+   affects 13,847 of the 19,770 cards that have rulings (2026-08-11 dump); the other 5,923 — one
+   ruling, or one per date — come back exactly as Scryfall orders them. Closing the rest would mean
+   an id only the API exposes, i.e. a per-card request, which is the dependency the bulk import
+   exists to avoid.
+
+## Follow-ups worth considering
+
+- Rewriting the self-referencing URIs behind a flag, for deployments that want clients to stay on
+  this host across a whole crawl.
+- `penny`, the one remaining order worth having. It needs `penny_rank` lifted out of
+  `raw_card_blob` into a column of its own, plus an import change and an engine field.
+- Verifying the CSV column set against a live Scryfall export.
diff --git a/docs/issues/local-scryfall-sets-catalogs-symbology.md b/docs/issues/local-scryfall-sets-catalogs-symbology.md
new file mode 100644
index 000000000..25e538a08
--- /dev/null
+++ b/docs/issues/local-scryfall-sets-catalogs-symbology.md
@@ -0,0 +1,159 @@
+# The reference half of the Scryfall API: /sets, /catalog/* and /symbology
+
+Depends on [local-scryfall-cards-api.md](local-scryfall-cards-api.md) (#912). That work covered every
+route under `/cards`. This covers what is left: the twenty-six routes that describe Magic rather than
+return cards, after which the Scryfall API surface is complete.
+
+| Route | Answers with |
+| --- | --- |
+| `GET /sets` | List of 1,047 Set objects |
+| `GET /sets/:code`, `/sets/:id` | One Set object |
+| `GET /sets/tcgplayer/:id` | One Set object, by TCGplayer group id |
+| `GET /catalog/:name` | Catalog object, over the twenty documented names |
+| `GET /symbology` | List of 84 CardSymbol objects |
+| `GET /symbology/parse-mana?cost=` | ManaCost object |
+
+## The decision: mirror, don't derive
+
+Every route above except `parse-mana` is served from a table mirrored off `api.scryfall.com`, not
+computed from `magic.cards`. Deriving was the obvious first instinct — `/cards/autocomplete` already
+derives its catalog from the corpus — and it does not survive contact with the data.
+
+**A Set object carries eight fields no card carries.** `tcgplayer_id`, `mtgo_code`, `arena_code`,
+`icon_svg_uri`, `block`, `block_code`, `parent_set_code`, `printed_size`. `GET /sets/tcgplayer/:id`
+is not merely degraded without the first of them; it cannot be implemented at all.
+
+**`card_count` is a count of Scryfall's printings, not of ours.** The corpus is a deliberate subset —
+no tokens, funny sets or digital-only printings. A derived `card_count` would report a number no
+other Scryfall client agrees with, on an object whose whole purpose is to be compared against theirs.
+
+**A card symbol has no card.** `svg_uri`, `gatherer_alternates`, `loose_variant` and `english` exist
+nowhere in the card data.
+
+So the honest choice is between "mirror it and be exact" and "derive it and be internally consistent
+but agree with nobody". The compatibility surface exists so a client can change its base URL and
+nothing else; mirroring is what makes that true. The cost is stated plainly under Divergences below.
+
+`parse-mana` is the exception and is computed, because it is a pure function of its parameter. That
+also means it is the one route here that works before the first import.
+
+## Schema
+
+`api/db/2026-08-11-02-scryfall-sets-catalogs-symbology.sql` adds three tables, each storing the
+upstream object whole in `jsonb` and lifting out only what a lookup keys on. Storing the object
+rather than mapping it column by column means a field Scryfall adds later is served without a
+migration, and it cannot be silently dropped in the mapping.
+
+- `magic.sets` — `id` PK, `code`, `tcgplayer_id`, `position`, `set_object`
+- `magic.catalogs` — `name` PK, `entries`
+- `magic.card_symbols` — `symbol` PK, `position`, `symbol_object`
+
+**`position` is the non-obvious column.** `/sets` is ordered by `released_at` descending, but sets
+sharing a release date come back in an order that is neither alphabetical by code nor by name — the
+four sets released 2026-11-13 arrive as `trk, trc, ttrk, sds` — and nothing in the object reproduces
+it. Recomputing the ordering would silently reshuffle those groups, so the index is stored. The E2E
+check asserts the served order matches upstream position for position, which is the only way to
+catch a regression there.
+
+`entries` rather than the obvious `values`, because `VALUES` is a reserved word and the column would
+need quoting at every use site.
+
+## Import
+
+`api/scryfall_reference_import.py`, three functions, wired into `_run_import_under_lock` beside the
+rulings load through `_import_reference_quietly`. Each is a whole-table replace in one transaction,
+for the reason the rulings load is: the upstream response is the entire truth each time.
+
+These are not bulk data — Scryfall publishes them as ordinary API responses — so they go through a
+new `ScryfallBulkDataFetcher.fetch_api_json`, which reuses the existing retrying session rather than
+opening a second HTTP client with its own behaviour.
+
+Two failure policies, deliberately different:
+
+- **Between the three steps**, a failure is logged and the next step still runs. Nothing downstream
+  reads these tables, so one bad upstream endpoint must not cost the other two their refresh, nor
+  the corpus its.
+- **Within `import_catalogs`**, a single catalog that fails to fetch keeps its previous row rather
+  than being written empty. Nineteen fresh catalogs and one stale one is a better answer than
+  nineteen fresh and one that claims Magic has no creature types.
+
+Measured against live Scryfall on 2026-08-11: 1,047 sets in 0.6 s, 20 catalogs / 62,187 values in
+2.65 s, 84 symbols in 0.1 s.
+
+## parse-mana, and the two rules nothing documents
+
+`api/scryfall_compat/mana.py`. Both of these were measured, not inferred, and both are the kind of
+thing a hand-written test would simply re-assert from the implementation:
+
+1. **The normalized cost reorders colored pips into canonical colour order.** `RUW` answers
+   `{U}{R}{W}`, not `{R}{U}{W}`. Every canonical ordering — allied pairs, enemy pairs, shards,
+   wedges, four-colour runs, WUBRG — turns out to be a walk around the colour wheel at a constant
+   step: one step for anything contiguous, two for anything not. Trying step 1 before step 2, from
+   starting points in WUBRG order, reproduces Scryfall for all 31 colour combinations.
+2. **Emission order is X, generic, colored pips, `{C}`**, regardless of input order, with generic
+   summed into one symbol. `2XWU` answers `{X}{2}{W}{U}`; `1{1}` answers `{2}`.
+
+An empty `cost` answers `null`; `cost=0` answers `{0}`. The two look like the same case and are not.
+An unparseable fragment is a **422**, not a 400.
+
+`api/tests/test_scryfall_mana.py` pins all of this against 79 goldens captured from the live API,
+including all 31 colour subsets written both forwards and backwards.
+
+## Cache headers are mirrored too
+
+Measured on 2026-08-11, these routes do **not** carry the `public, max-age=57600` the card routes do:
+
+| Route | Cache-Control |
+| --- | --- |
+| `/sets`, `/sets/:code`, `/sets/tcgplayer/:id`, `/catalog/*`, `/symbology` | `public` |
+| `/symbology/parse-mana` | `max-age=0, private, must-revalidate` |
+
+Both are mirrored rather than chosen, and both are mildly surprising. Bare `public` with no max-age
+leaves freshness to the cache's heuristics, which is weaker than an explicit lifetime; `parse-mana`
+is the one deterministic route here and would be perfectly safe to cache hard, yet upstream marks it
+private. Matching anyway is the point of the surface: a client that swapped its base URL would
+otherwise get a response held for 16 hours where Scryfall revalidates, and would not find out until
+it served something stale. `private` does not defeat this service's own `CachingMiddleware` — only
+`no-store` does, which is why `/cards/random` uses that — so repeat parses are still answered
+in-process.
+
+The first cut of this branch applied the card tier to all six routes. `test_scryfall_reference_routes.py`
+now pins each header to its measured upstream value.
+
+## Structure
+
+`ScryfallReferenceRoutes` is a second mixin on `APIResource` beside `ScryfallCardsRoutes`, not an
+addition to it. They answer from different places — the corpus and the engine on one side, the
+mirrored tables on the other — and share only the response plumbing, which moved into
+`ScryfallResponder` so the two surfaces cannot drift on how an error carries its status.
+
+One trap worth recording: `falcon` must be a **runtime** import in a routes module even when it
+appears only in annotations. `@route` registration runs every handler's annotations through
+`typing.get_type_hints`, which evaluates them for real, so a `TYPE_CHECKING`-only import fails
+registration with `NameError` before the app can serve anything. Ruff's TC002 will suggest exactly
+that move; the import carries a `noqa` and a comment saying why.
+
+## Divergences from api.scryfall.com
+
+1. **`card_count` counts Scryfall's printings, not this instance's.** A set reporting 135 cards may
+   return fewer from `/cards/search?q=e:code` here. Consistent with the corpus divergence the cards
+   surface already owns, and the alternative is a number nobody else agrees with.
+2. **`/catalog/card-names` and `/catalog/artist-names` list cards and artists this instance may not
+   hold**, for the same reason. A client that walks a catalog and fetches each name will 404 on some.
+3. **A catalog name Scryfall adds later 404s here until `CATALOG_NAMES` is extended.** The list is
+   fixed in code rather than discovered, so that an unknown name is a 404 rather than a silently
+   empty catalog.
+4. **`uri`, `search_uri` and `icon_svg_uri` on a Set object point at Scryfall**, not at this host —
+   the same rule the cards surface follows, since they are part of the payload rather than
+   pagination.
+5. **`parse-mana` accepts unknown bare letters** the way Scryfall does (`zzz` answers `{Z}{Z}{Z}`
+   with mana value 0) but has not been probed exhaustively for exotic braced symbols beyond the
+   hybrid, phyrexian and half-mana forms in the goldens.
+
+## Follow-ups worth considering
+
+- Serving `/sets` from the engine rather than SQL. 1,047 rows is small enough that it has not
+  mattered, and unlike the card routes there is no fallback path to keep in step.
+- A `set:` search operator backed by `magic.sets`, which would let `/cards/search` filter on set
+  attributes — `set_type`, `block`, `digital` — that the cards table does not carry.
+- Rewriting the self-referencing Set URIs behind the same flag proposed for card URIs in #912.
diff --git a/scripts/copy_images_to_s3.py b/scripts/copy_images_to_s3.py
index 29a6e3dd8..1e132730a 100644
--- a/scripts/copy_images_to_s3.py
+++ b/scripts/copy_images_to_s3.py
@@ -128,8 +128,8 @@ def fetch_cards_from_db(
         List of dictionaries containing
              card_set_code,
              collector_number,
-             png_url,
-             face_idx
+             png_url (the FRONT face),
+             back_png_url (the back face, or NULL for a card that has no physical back)
     """
     with conn.cursor() as cursor:
         where_clause = ""
@@ -146,12 +146,39 @@ def fetch_cards_from_db(
 
         where_clause = " AND ".join(conditions)
 
+        # Both URLs are DERIVED from scryfall_id rather than read out of raw_card_blob, and
+        # whether a back face exists is read from card_layout. Two reasons, both load-bearing:
+        #
+        # 1. The blob is wrong for exactly the cards this is about. Until the face merge, a
+        #    multi-face row WAS its last face, so `raw_card_blob->'image_uris'` is that face's
+        #    -- the BACK's -- because Scryfall omits top-level image_uris on a transform card
+        #    and puts one on each face. Every such card therefore has its back image uploaded
+        #    under the face-1 key, and its front uploaded nowhere. (Verified against the live
+        #    CDN: img/bot/6/1/*.webp is Slicer, High-Speed Antagonist -- the back.) A coalesce
+        #    onto card_faces[0] does not rescue it, because the first branch is non-NULL.
+        # 2. The blob is unavailable for the same cards. preprocess_card popped card_faces
+        #    before snapshotting, so no pre-merge row's blob has that key at all, which is why
+        #    2026-08-10-01's backfill leaves card_faces NULL corpus-wide and back_png_url with
+        #    it. Reading the blob means "correct only after a full reimport"; reading columns
+        #    means correct now.
+        #
+        # scryfall_id and card_layout are both NOT NULL/indexed columns populated for every
+        # row today, and Scryfall's image path is a pure function of the id, so this is right
+        # on the existing corpus with no reimport and self-heals rows the blob never captured.
         query = f"""
             SELECT
                 card_set_code,
                 collector_number,
-                raw_card_blob->'image_uris'->>'png' as png_url,
-                coalesce((raw_card_blob->>'face_idx')::int, 1) as face_idx
+                'https://cards.scryfall.io/png/front/'
+                    || left(scryfall_id::text, 1) || '/' || substr(scryfall_id::text, 2, 1)
+                    || '/' || scryfall_id::text || '.png' as png_url,
+                CASE WHEN card_layout IN (
+                        'transform', 'modal_dfc', 'reversible_card', 'double_faced_token', 'art_series'
+                     ) THEN
+                    'https://cards.scryfall.io/png/back/'
+                        || left(scryfall_id::text, 1) || '/' || substr(scryfall_id::text, 2, 1)
+                        || '/' || scryfall_id::text || '.png'
+                END as back_png_url
             FROM
                 magic.cards
             WHERE
@@ -344,7 +371,7 @@ def process_card(
                 continue
 
             # Face-aware key structure: img/{set_code}/{collector_number}/{face}/{size}.webp
-            s3_key = f"img/{set_code}/{collector_number}/{DEFAULT_FACE}/{size_name}.webp"
+            s3_key = f"img/{set_code}/{collector_number}/{card.get('face_idx', DEFAULT_FACE)}/{size_name}.webp"
 
             if upload_to_s3(s3_client, webp_path, bucket, s3_key):
                 results[size_name] = True
@@ -507,18 +534,23 @@ def get_db_cards(args: Args) -> set[tuple[str, str, str, str]]:
         return None
 
     sizes = [SMALL_KEY, MEDIUM_KEY, LARGE_KEY, XLARGE_KEY]
-    logger.info("Found %d cards in database, should create %d images", len(db_cards), len(db_cards) * len(sizes))
-    return {
+    images = {
         CardImage(
             set_code=card["card_set_code"],
             collector_number=card["collector_number"],
-            face_idx=str(card["face_idx"]),
-            png_url=card["png_url"],
+            face_idx=face_idx,
+            png_url=png_url,
             size=size,
         )
         for card in db_cards
+        # One image per face that actually has one: every card's front, plus the back for
+        # cards with a physical back face (the flip button's image on the site).
+        for face_idx, png_url in ((DEFAULT_FACE, card["png_url"]), ("2", card["back_png_url"]))
+        if png_url
         for size in sizes
     }
+    logger.info("Found %d cards in database, should create %d images", len(db_cards), len(images))
+    return images
 
 
 def get_s3_cards(args: Args) -> set[CardImage]:
diff --git a/scripts/prefer_weights.py b/scripts/prefer_weights.py
index dd13893cc..4ff6a9e61 100755
--- a/scripts/prefer_weights.py
+++ b/scripts/prefer_weights.py
@@ -133,7 +133,28 @@
 # Sourced from Scryfall's `normal` rather than the project CDN: the CDN 403s on
 # printings the site does not carry (e.g. pw26/20), which would leave the reviewer
 # comparing a broken image against a card. Scryfall covers 94,718/94,718.
-LEVELS_EXTRA_IMAGE = "raw_card_blob -> 'image_uris' ->> 'normal'"
+
+
+def front_image(size: str, alias: str = "") -> str:
+    """Build the SQL for a printing's front-face image URL at one size.
+
+    `raw_card_blob` holds Scryfall's own card object, and where a card carries its images decides
+    on layout: a single-face or split printing has `image_uris` at top level, a transform or MDFC
+    one has them only under `card_faces`. Reading the front therefore has to try both, which is
+    what every image read in this file goes through.
+
+    Args:
+        size: An `image_uris` key -- "normal", "art_crop", and so on.
+        alias: Table alias to qualify the column with, or "" for an unqualified column.
+
+    Returns:
+        A SQL expression yielding the URL, or NULL when the printing has no image of that size.
+    """
+    column = f"{alias}.raw_card_blob" if alias else "raw_card_blob"
+    return f"COALESCE({column} -> 'image_uris' ->> '{size}', {column} -> 'card_faces' -> 0 -> 'image_uris' ->> '{size}')"
+
+
+LEVELS_EXTRA_IMAGE = front_image("normal")
 
 LEVELS_SQL = """
 SELECT c.scryfall_id::text AS sid,
@@ -168,8 +189,8 @@
        ((c.card_art_tags ? 'external-ip' AND NOT (c.card_art_tags ?| {exempt}))
          OR c.card_art_tags ?| {departure})                           AS off_style,
        c.card_set_code, c.collector_number,
-       c.raw_card_blob -> 'image_uris' ->> 'art_crop'                 AS art_url,
-       c.raw_card_blob -> 'image_uris' ->> 'normal'                   AS card_url
+       {art_crop_url}                                                 AS art_url,
+       {normal_url}                                                   AS card_url
 FROM magic.cards c
 WHERE {where}
 """
@@ -275,7 +296,12 @@ def load(where: str) -> list[dict[str, str]]:
     """Fetch component levels for every printing matching `where`."""
     return run_query(
         LEVELS_SQL.format(
-            exempt=pg_arr(STYLE_EXEMPT_TAGS), departure=pg_arr(STYLE_DEPARTURE_TAGS), counted=COUNTED_PRINTING_SQL, where=where
+            exempt=pg_arr(STYLE_EXEMPT_TAGS),
+            departure=pg_arr(STYLE_DEPARTURE_TAGS),
+            counted=COUNTED_PRINTING_SQL,
+            where=where,
+            art_crop_url=front_image("art_crop", "c"),
+            normal_url=front_image("normal", "c"),
         )
     )
 
@@ -330,10 +356,7 @@ def cmd_swaps(sets: list[str], scales: list[str], out: Path, limit: int) -> None
     for k, a, b in changed:
         print(f"  {k:20s} {a:7.2f} -> {b:7.2f}")
 
-    rows = load(
-        "c.raw_card_blob ->> 'lang' = 'en' AND c.prefer_score IS NOT NULL "
-        "AND c.raw_card_blob -> 'image_uris' ->> 'art_crop' IS NOT NULL"
-    )
+    rows = load(f"c.raw_card_blob ->> 'lang' = 'en' AND c.prefer_score IS NOT NULL AND {front_image('art_crop', 'c')} IS NOT NULL")
     by_card: dict[str, list[dict[str, str]]] = {}
     for r in rows:
         by_card.setdefault(r["card_name"], []).append(r)
@@ -485,10 +508,7 @@ def cmd_step(comp: str, direction: str, out: Path) -> None:
     """Find the smallest change to one component that moves TARGET_SWAPS cards."""
     if comp not in WEIGHTS:
         sys.exit(f"unknown component {comp!r}; known: {', '.join(sorted(WEIGHTS))}")
-    rows = load(
-        "c.raw_card_blob ->> 'lang' = 'en' AND c.prefer_score IS NOT NULL "
-        "AND c.raw_card_blob -> 'image_uris' ->> 'art_crop' IS NOT NULL"
-    )
+    rows = load(f"c.raw_card_blob ->> 'lang' = 'en' AND c.prefer_score IS NOT NULL AND {front_image('art_crop', 'c')} IS NOT NULL")
     by: dict[str, list[dict[str, str]]] = {}
     for r in rows:
         by.setdefault(r["card_name"], []).append(r)
@@ -816,7 +836,7 @@ def cmd_countfix(  # noqa: C901, PLR0912, PLR0913, PLR0915, PLR0917
   SELECT c.card_name, c.illustration_id, c.card_set_code, c.card_frame_data, c.card_border,
          c.card_rarity_int, c.raw_card_blob ->> 'image_status' AS img,
          c.raw_card_blob ->> 'collector_number' AS cn,
-         c.raw_card_blob -> 'image_uris' ->> 'normal' AS url,
+         {normal_url} AS url,
          CASE WHEN c.raw_card_blob -> 'finishes' ? 'nonfoil' THEN 'nonfoil'
               WHEN c.raw_card_blob -> 'finishes' ? 'foil' THEN 'foil' ELSE 'etched' END AS fin,
          -- Sorted, so ["showcase","legendary"] and ["legendary","showcase"] compare equal --
@@ -836,7 +856,7 @@ def cmd_countfix(  # noqa: C901, PLR0912, PLR0913, PLR0915, PLR0917
          COALESCE(c.raw_card_blob ->> 'promo', 'f')         AS promo
   FROM magic.cards c
   WHERE c.raw_card_blob ->> 'lang' = 'en' AND c.illustration_id IS NOT NULL
-    AND c.raw_card_blob -> 'image_uris' ->> 'normal' IS NOT NULL),
+    AND {normal_url} IS NOT NULL),
 -- Grouped rather than self-joined: a self-join on jsonb frame data over 94k rows does not
 -- finish, while one pass bucketing by the same key does. A bucket qualifies when it holds
 -- both finishes, and everything in the key is by construction identical between them.
@@ -863,7 +883,7 @@ def cmd_finishtest(out: Path, n: int) -> None:
     dominated by the 7th-10th Edition `*` foils -- a verdict drawn only from those would
     say something about 2003-era foil stock, not about foil in general.
     """
-    rows = run_query(FINISH_PAIR_SQL)
+    rows = run_query(FINISH_PAIR_SQL.format(normal_url=front_image("normal", "c")))
     by_set: dict[str, list[dict[str, str]]] = {}
     for r in rows:
         by_set.setdefault(r["card_set_code"], []).append(r)
diff --git a/scripts/tests/test_copy_images_to_s3.py b/scripts/tests/test_copy_images_to_s3.py
index c0ddb8adf..8cfed76f7 100644
--- a/scripts/tests/test_copy_images_to_s3.py
+++ b/scripts/tests/test_copy_images_to_s3.py
@@ -9,6 +9,7 @@
 from scripts.copy_images_to_s3 import (
     download_image,
     fetch_cards_from_db,
+    get_db_cards,
 )
 
 
@@ -75,3 +76,81 @@ def test_fetch_cards_from_db() -> None:
     assert cards[0]["card_set_code"] == "iko"
     assert cards[0]["collector_number"] == "123"
     assert cards[1]["card_set_code"] == "thb"
+
+
+def test_get_db_cards_emits_back_face_images() -> None:
+    """A card with a physical back face yields face-2 images alongside the front's.
+
+    The back image feeds the site's flip button; single-faced cards (and split/adventure
+    faces, which carry no per-face images) must stay front-only.
+    """
+    rows = [
+        {"card_set_code": "mid", "collector_number": "5", "png_url": "https://x/front.png", "back_png_url": "https://x/back.png"},
+        {"card_set_code": "m21", "collector_number": "1", "png_url": "https://x/solo.png", "back_png_url": None},
+    ]
+    args = Mock(limit=None, set_code=None)
+    with (
+        patch("scripts.copy_images_to_s3.get_database_connection"),
+        patch("scripts.copy_images_to_s3.fetch_cards_from_db", return_value=rows),
+    ):
+        images = get_db_cards(args)
+
+    keys = {image.get_s3_key() for image in images}
+    assert "img/mid/5/1/388.webp" in keys
+    assert "img/mid/5/2/388.webp" in keys
+    assert "img/m21/1/1/388.webp" in keys
+    assert not any("/m21/1/2/" in key for key in keys)
+    assert len(images) == 12  # (front+back) * 4 sizes + front-only * 4 sizes
+
+
+def test_get_db_cards_back_face_carries_its_own_png_url() -> None:
+    """The face-2 image downloads the back PNG, not the front's."""
+    rows = [
+        {"card_set_code": "mid", "collector_number": "5", "png_url": "https://x/front.png", "back_png_url": "https://x/back.png"},
+    ]
+    args = Mock(limit=None, set_code=None)
+    with (
+        patch("scripts.copy_images_to_s3.get_database_connection"),
+        patch("scripts.copy_images_to_s3.fetch_cards_from_db", return_value=rows),
+    ):
+        images = get_db_cards(args)
+
+    by_face = {image.face_idx: image.png_url for image in images}
+    assert by_face == {"1": "https://x/front.png", "2": "https://x/back.png"}
+
+
+def test_face_urls_are_derived_from_columns_not_the_blob() -> None:
+    """Both face URLs come from scryfall_id/card_layout, never from raw_card_blob.
+
+    This is the bug that shipped every transform card's BACK image under its face-1 key
+    and its front image nowhere: `raw_card_blob->'image_uris'` is the stored face's, and
+    before the face merge the stored face was the back. Scryfall omits top-level
+    image_uris on a multi-face card, so there was nothing else for it to be.
+
+    Reading the blob is also unavailable, not merely wrong: preprocess_card popped
+    card_faces before snapshotting, so no pre-merge row has that key to fall back to.
+
+    Pinning the query text is unusual, and deliberate. The rest of this file mocks
+    fetchall, so every assertion holds equally well against a query reading the wrong
+    column -- which is precisely how this went unnoticed.
+    """
+    mock_conn = Mock()
+    mock_cursor = Mock()
+    mock_conn.cursor.return_value.__enter__ = Mock(return_value=mock_cursor)
+    mock_conn.cursor.return_value.__exit__ = Mock(return_value=False)
+    mock_cursor.fetchall.return_value = []
+
+    fetch_cards_from_db(mock_conn, limit=1, set_code=None)
+
+    query = mock_cursor.execute.call_args[0][0]
+    assert "scryfall_id" in query, "the image path is a pure function of the card's id"
+    assert "card_layout" in query, "whether a back face exists is a property of the layout"
+    assert "cards.scryfall.io/png/front/" in query
+    assert "cards.scryfall.io/png/back/" in query
+    # The layouts that actually have a second physical face. A split or adventure card
+    # shares a "//" name and must NOT get a back image.
+    assert "transform" in query
+    assert "modal_dfc" in query
+    assert "'split'" not in query
+    # The regression itself: no image URL may be read out of the blob.
+    assert "image_uris" not in query, "raw_card_blob->image_uris is the stored face's, not the front's"