CRISPR M2: paste-anything input + fix phantom progress bar

Resolver (dee/core/resolve.py, new): one input box auto-detects and
resolves a gene symbol, an accession (ENST…/ENSG…/NM_…/XM_…), or raw
DNA into an editable sequence + a human label.
- gene symbol → Ensembl canonical-transcript CDS (reuses
exon.fetch_gene_structure; human/mouse).
- Ensembl ID → /sequence/id?type=cds (gene IDs resolve to canonical tx).
- RefSeq → NCBI efetch FASTA.
- raw / FASTA → used as-is, makes NO network call (privacy: a pasted
sequence never leaves the Space; only the identifier is sent).
Conservative classifier: a long DNA-dominant blob is always a sequence.

Endpoint POST /api/crispr/resolve (sign-in gated, same as design),
returns {ok, kind, sequence, gene_symbol, label, source}.

Frontend: a resolver row above the paste box (input + Fetch, Enter to
submit) fills the textarea with the resolved sequence, shows a result
chip, and auto-sets the gene-symbol field so base-edit AA consequences
and exon context get the reading frame.

Bug fix surfaced during verification: `.progress-shell { display:flex }`
overrode the UA `[hidden]` rule, so the progress shell stayed visible
showing its default "Designing… 0.0s" text — a permanent phantom bar
under BOTH the CRISPR and directed-evolution Design buttons (live for
the 6 customers). Added `.progress-shell[hidden] { display:none }`.

Tests: tests/test_resolve.py (22, network mocked). Full suite 109 green.
Verified desktop + mobile; TP53→ENST00000269305 (1182 nt) and NM_000546
resolve live. Cache-buster → 20260529-paste-anything.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

dee/core/resolve.py

@@ -0,0 +1,171 @@
+"""Paste-anything target resolution (Phase 3, M2).
+
+One input box, three kinds of input — auto-detected and resolved to an
+editable DNA sequence (plus a human-readable label and, where known, a
+gene symbol that feeds base-edit AA consequences + the structure viewer):
+
+  * raw DNA / FASTA  → used as-is (never leaves the Space).
+  * gene symbol      → Ensembl canonical-transcript CDS (human / mouse),
+                        via the existing exon.fetch_gene_structure().
+  * accession        → Ensembl transcript/gene ID (ENST…/ENSG…) or RefSeq
+                        (NM_/XM_/NR_/XR_) fetched from Ensembl / NCBI.
+
+Privacy: for symbol/accession lookups, ONLY the (organism, identifier)
+leaves the Space — never the user's pasted sequence. The raw-sequence
+path makes no network calls at all.
+
+Classification is conservative: a long, DNA-looking blob is always a
+sequence; a short token that matches an ID pattern is an accession; an
+alphanumeric token is a gene symbol (needs an organism). Ambiguous short
+tokens fall through to a symbol lookup, which fails gracefully.
+"""
+from __future__ import annotations
+
+import re
+from typing import Dict, Tuple
+
+from dee.core import exon as _exon
+
+# ─── Identifier patterns ─────────────────────────────────────────────
+_ENSEMBL_TX   = re.compile(r"^ENS[A-Z]*T\d{6,}(?:\.\d+)?$", re.I)   # ENST…, ENSMUST…
+_ENSEMBL_GENE = re.compile(r"^ENS[A-Z]*G\d{6,}(?:\.\d+)?$", re.I)   # ENSG…, ENSMUSG…
+_REFSEQ       = re.compile(r"^[NX][MR]_\d+(?:\.\d+)?$", re.I)        # NM_/NR_/XM_/XR_
+_SYMBOL       = re.compile(r"^[A-Za-z][A-Za-z0-9._-]{0,19}$")        # TP53, BRCA1, …
+
+_NCBI_EFETCH = ("https://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi"
+                "?db=nuccore&rettype=fasta&retmode=text&id=")
+
+MIN_TARGET_LEN = 23   # shortest usable target (Cas12a spacer+PAM)
+MAX_TARGET_LEN = 1_000_000
+
+
+def _clean_dna(text: str) -> str:
+    """Strip FASTA headers + whitespace + non-ACGTN, uppercase."""
+    lines = [ln for ln in text.splitlines() if not ln.strip().startswith(">")]
+    return re.sub(r"[^ACGTNacgtn]", "", "".join(lines)).upper()
+
+
+def classify(text: str) -> Tuple[str, str]:
+    """Return (kind, value). kind ∈ {empty, sequence, symbol, ensembl_tx,
+    ensembl_gene, refseq, unknown}. `value` is the cleaned sequence (for
+    'sequence') or the identifier token otherwise."""
+    t = (text or "").strip()
+    if not t:
+        return ("empty", "")
+    if t.lstrip().startswith(">"):
+        return ("sequence", _clean_dna(t))
+
+    cleaned = _clean_dna(t)
+    letters = re.sub(r"[^A-Za-z]", "", re.sub(r"\s", "", t))
+    dna_ratio = len(cleaned) / max(1, len(letters))
+    has_ws = bool(re.search(r"\s", t))
+    # A long, DNA-dominant blob (or any multi-line / spaced DNA) is a sequence.
+    if len(cleaned) >= MIN_TARGET_LEN and dna_ratio >= 0.9 and (has_ws or len(cleaned) > 20):
+        return ("sequence", cleaned)
+
+    token = t.split()[0] if t.split() else ""
+    if _ENSEMBL_TX.match(token):
+        return ("ensembl_tx", token)
+    if _ENSEMBL_GENE.match(token):
+        return ("ensembl_gene", token)
+    if _REFSEQ.match(token):
+        return ("refseq", token.upper())
+    if _SYMBOL.match(token):
+        return ("symbol", token.upper())
+    if len(cleaned) >= MIN_TARGET_LEN and dna_ratio >= 0.9:
+        return ("sequence", cleaned)
+    return ("unknown", token)
+
+
+def _err(msg: str) -> Dict:
+    return {"ok": False, "error": msg, "kind": "", "sequence": "",
+            "gene_symbol": "", "label": "", "source": ""}
+
+
+def _ok(kind: str, sequence: str, label: str, source: str,
+        gene_symbol: str = "") -> Dict:
+    return {"ok": True, "kind": kind, "sequence": sequence,
+            "gene_symbol": gene_symbol, "label": label, "source": source}
+
+
+def _fetch_ensembl_cds(identifier: str, is_gene: bool) -> Tuple[str, str]:
+    """Fetch a CDS sequence for an Ensembl transcript or gene ID.
+    Returns (sequence, label) or ("", "")."""
+    tx_id = identifier
+    if is_gene:
+        # Resolve gene → canonical transcript first.
+        info = _exon._http_get_json(
+            f"{_exon.ENSEMBL_BASE}/lookup/id/{identifier}?expand=1")
+        if not info:
+            return ("", "")
+        transcripts = info.get("Transcript", []) or []
+        if not transcripts:
+            return ("", "")
+        canonical = next((t for t in transcripts if t.get("is_canonical") == 1),
+                         transcripts[0])
+        tx_id = canonical.get("id") or ""
+        if not tx_id:
+            return ("", "")
+    fasta = _exon._http_get_text(
+        f"{_exon.ENSEMBL_BASE}/sequence/id/{tx_id}?type=cds")
+    seq = _exon._fasta_to_seq(fasta) if fasta else ""
+    if not seq:
+        return ("", "")
+    label = (f"{identifier} → {tx_id} · CDS {len(seq):,} nt"
+             if is_gene else f"{tx_id} · CDS {len(seq):,} nt")
+    return (seq, label)
+
+
+def _fetch_refseq(accession: str) -> str:
+    fasta = _exon._http_get_text(_NCBI_EFETCH + accession)
+    return _exon._fasta_to_seq(fasta) if fasta else ""
+
+
+def resolve_target(text: str, organism: str = "") -> Dict:
+    """Resolve pasted text to an editable sequence.
+
+    Returns a dict: {ok, kind, sequence, gene_symbol, label, source, error?}.
+    """
+    organism = (organism or "").lower().strip()
+    kind, val = classify(text)
+
+    if kind == "empty":
+        return _err("Paste a DNA sequence, a gene symbol, or an accession.")
+
+    if kind == "sequence":
+        if len(val) < MIN_TARGET_LEN:
+            return _err(f"Sequence is only {len(val)} nt — need at least "
+                        f"{MIN_TARGET_LEN} nt. Check you pasted DNA, not protein.")
+        if len(val) > MAX_TARGET_LEN:
+            return _err("Sequence too long. Cap is 1 Mbp — paste just the "
+                        "gene / region you're editing.")
+        return _ok("sequence", val, f"pasted sequence · {len(val):,} nt", "input")
+
+    if kind == "symbol":
+        if organism not in ("human", "mouse"):
+            return _err(f"To look up “{val}” by gene symbol, pick Human or "
+                        f"Mouse — or paste the sequence directly.")
+        gene = _exon.fetch_gene_structure(organism, val)
+        if gene is None:
+            return _err(f"Couldn't find “{val}” in {organism}. Check the "
+                        f"symbol, or paste the sequence directly.")
+        return _ok("gene", gene.cds_sequence,
+                   f"{val} · {gene.transcript_id} · CDS {len(gene.cds_sequence):,} nt",
+                   "ensembl", gene_symbol=val)
+
+    if kind in ("ensembl_tx", "ensembl_gene"):
+        seq, label = _fetch_ensembl_cds(val, is_gene=(kind == "ensembl_gene"))
+        if not seq:
+            return _err(f"Couldn't fetch “{val}” from Ensembl. Check the ID, "
+                        f"or paste the sequence directly.")
+        return _ok("ensembl", seq, label, "ensembl")
+
+    if kind == "refseq":
+        seq = _fetch_refseq(val)
+        if not seq:
+            return _err(f"Couldn't fetch “{val}” from NCBI. Check the "
+                        f"accession, or paste the sequence directly.")
+        return _ok("refseq", seq, f"{val} · {len(seq):,} nt", "ncbi")
+
+    return _err("Unrecognized input. Paste a DNA sequence, a gene symbol "
+                "(with Human/Mouse selected), or an accession (ENST…, NM_…).")

dee/server.py

@@ -1103,6 +1103,42 @@ def create_app() -> Flask:
             ],
         })
 
+    @app.post("/api/crispr/resolve")
+    def crispr_resolve() -> Response:
+        """Paste-anything resolver (Phase 3, M2). Body: {text, organism}.
+        Resolves a gene symbol / accession / raw sequence to an editable
+        DNA sequence + a human label. Same sign-in gate as /design.
+        Privacy: only (organism, identifier) leaves the Space for lookups;
+        a raw sequence makes no outbound call."""
+        auth = _auth.get_auth()
+        if auth.anonymous:
+            return jsonify({
+                "ok": False,
+                "error": "Sign in or create a free account to keep going.",
+                "kind": "signin_required",
+                "signup_url": "https://turingdna.com/signin/?from=crispr",
+            }), 403
+
+        body = request.get_json(force=True, silent=True) or {}
+        text = (body.get("text") or "").strip()
+        if not text:
+            return jsonify({"ok": False, "error": "missing 'text'"}), 400
+        # Bound input: a sequence paste can be up to 1 Mbp; an identifier is
+        # tiny. Cap defensively so a giant blob can't tie up the resolver.
+        if len(text) > 1_000_000:
+            return jsonify({"ok": False, "error": "Input too long (1 Mbp cap)."}), 400
+        organism = str(body.get("organism", "")).lower().strip()
+        if organism not in ("", "ecoli", "human", "mouse"):
+            organism = ""
+
+        from dee.core import resolve as _resolve
+        try:
+            result = _resolve.resolve_target(text, organism=organism)
+        except Exception as exc:  # noqa: BLE001
+            logger.exception("CRISPR resolve failed.")
+            return jsonify({"ok": False, "error": f"{type(exc).__name__}: {exc}"}), 500
+        return jsonify(result), (200 if result.get("ok") else 422)
+
     @app.post("/api/crispr/download")
     def crispr_download() -> Response:
         """Return the CSV body for a fresh design. We re-design from the

dee/static/app.css

@@ -1213,6 +1213,12 @@ input:focus, textarea:focus, select:focus {
     flex-direction: column;
     gap: 8px;
 }
+/* The `display: flex` above overrides the UA `[hidden]` rule, so the
+ * shell stayed visible (showing its default "Designing… 0.0s" text)
+ * even when hidden=true. Restore hide-when-hidden. Fixes a permanent
+ * phantom progress bar under the CRISPR + directed-evolution Design
+ * buttons. */
+.progress-shell[hidden] { display: none; }
 .progress-bar {
     height: 4px;
     background: var(--gray-3);
@@ -4349,6 +4355,35 @@ h3, h4 {
 .crispr-opt-disabled { opacity: 0.4; cursor: not-allowed; }
 .crispr-opt-disabled input[type="radio"] { cursor: not-allowed; }
 
+/* ─── Phase 3 (M2): paste-anything resolver ─────────────────────────
+ * A single row above the paste box: text input + Fetch button, with a
+ * result chip below. Flex with min-width:0 so it shrinks cleanly on
+ * mobile rather than overflowing. */
+.crispr-resolve-row {
+    display: flex;
+    gap: 8px;
+    align-items: stretch;
+    margin-bottom: 10px;
+}
+.crispr-resolve-input { flex: 1 1 auto; min-width: 0; }
+.crispr-resolve-row .ghost { flex: 0 0 auto; white-space: nowrap; }
+.crispr-resolve-chip {
+    margin: -2px 0 12px;
+    padding: 7px 11px;
+    border-radius: var(--r-1);
+    background: var(--gray-1);
+    border: 1px solid var(--line);
+    font-size: 12px;
+    line-height: 1.45;
+    color: var(--ink-soft);
+}
+.crispr-resolve-chip-error {
+    background: #FFFBEB;
+    border-color: #FCD34D;
+    color: #92400E;
+}
+.crispr-resolve-ok { color: #047857; font-weight: 700; }
+
 /* ─── Enzyme picker (Phase 1) ───────────────────────────────────────
  * Hairline row above the paste-actions block. Mono label, radio
  * controls styled as text-buttons with archival-blue selected state

dee/static/app.js

@@ -3686,6 +3686,64 @@ if (_quitBtn) {
     });
     if (beSelectEl) beSelectEl.addEventListener('change', updateBaseEditorMeta);
 
+    // ─── Phase 3 (M2): paste-anything resolver ──────────────────────
+    // Type a gene symbol / accession → fill the paste box with the
+    // resolved sequence + set the gene context. Raw paste is unchanged.
+    const resolveInput = document.getElementById('crisprResolveInput');
+    const resolveBtn   = document.getElementById('crisprResolveBtn');
+    const resolveChip  = document.getElementById('crisprResolveChip');
+    function _showResolveChip(html, isError) {
+        if (!resolveChip) return;
+        resolveChip.hidden = false;
+        resolveChip.className = 'crispr-resolve-chip' + (isError ? ' crispr-resolve-chip-error' : '');
+        resolveChip.innerHTML = html;
+    }
+    async function _doResolve() {
+        const text = (resolveInput && resolveInput.value.trim()) || '';
+        if (!text) return;
+        const organismEl = document.getElementById('crisprOrganism');
+        const organism = (organismEl && organismEl.value) || '';
+        if (resolveBtn) { resolveBtn.disabled = true; resolveBtn.textContent = 'Fetching…'; }
+        try {
+            const res = await fetch('/api/crispr/resolve', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ text, organism }),
+            });
+            const data = await res.json();
+            if (res.status === 403 && data.kind === 'signin_required') {
+                _openSigninModal();
+                return;
+            }
+            if (!data.ok) {
+                _showResolveChip(escapeHtml(data.error || 'Could not resolve that input.'), true);
+                return;
+            }
+            // Fill the paste box + refresh gutter / stats / button state.
+            if (ta) {
+                ta.value = data.sequence;
+                ta.dispatchEvent(new Event('input', { bubbles: true }));
+            }
+            // Resolved a named gene → set the gene-symbol field so exon
+            // context + base-edit AA consequences get the reading frame.
+            if (data.kind === 'gene' && data.gene_symbol) {
+                const geneEl = document.getElementById('crisprGeneSymbol');
+                if (geneEl) geneEl.value = data.gene_symbol;
+            }
+            _showResolveChip(
+                '<span class="crispr-resolve-ok">&check;</span> ' + escapeHtml(data.label),
+                false);
+        } catch (err) {
+            _showResolveChip(escapeHtml(err.message || 'Network error.'), true);
+        } finally {
+            if (resolveBtn) { resolveBtn.disabled = false; resolveBtn.textContent = 'Fetch'; }
+        }
+    }
+    if (resolveBtn) resolveBtn.addEventListener('click', _doResolve);
+    if (resolveInput) resolveInput.addEventListener('keydown', (e) => {
+        if (e.key === 'Enter') { e.preventDefault(); _doResolve(); }
+    });
+
     // ─── Phase 2C-1: vector + vendor loader ─────────────────────────
     // Fetches /api/crispr/vectors on first design call, caches in memory
     // for the rest of the session, populates the picker + vendor row.

dee/static/index.html

@@ -7,7 +7,7 @@
     <!-- ?v= query bumps invalidate browser + iframe asset caches when app.css /
          app.js change. Bump these numbers whenever you ship a frontend update —
          without them, users keep getting the stale file for up to a week. -->
-    <link rel="stylesheet" href="/static/app.css?v=20260529-base-edit" />
+    <link rel="stylesheet" href="/static/app.css?v=20260529-paste-anything" />
     <link rel="icon" type="image/svg+xml" href="/static/favicon.svg?v=2" />
     <link rel="apple-touch-icon" href="/static/favicon.svg?v=2" />
     <!-- Mol* (PDBe) viewer for AlphaFold structure embed. Loaded async; the
@@ -472,6 +472,27 @@
                           </p>
                       </header>
 
+                      <!-- Phase 3 (M2): paste-anything resolver. Type a gene
+                           symbol (TP53), an accession (ENST… / NM_…), or just
+                           paste DNA below. Resolving a symbol/accession fills
+                           the box and sets the gene context that base-edit
+                           amino-acid consequences and the structure view use.
+                           Only the (organism, identifier) is sent for lookups —
+                           a pasted sequence never leaves the Space. -->
+                      <div class="crispr-resolve-row">
+                          <input
+                              id="crisprResolveInput"
+                              class="crispr-context-input crispr-resolve-input"
+                              type="text"
+                              maxlength="64"
+                              autocomplete="off"
+                              autocapitalize="characters"
+                              spellcheck="false"
+                              placeholder="Gene symbol (TP53), accession (ENST… / NM_…), or paste DNA below" />
+                          <button id="crisprResolveBtn" type="button" class="ghost">Fetch</button>
+                      </div>
+                      <div class="crispr-resolve-chip" id="crisprResolveChip" hidden></div>
+
                       <!-- Same line-numbered gutter pattern as the
                            directed-evolution paste textarea (see #pasteGutter).
                            Gutter spans render via app.js renderCrisprGutter()
@@ -1046,10 +1067,10 @@
          Authorization header on every same-origin /api/* call. Without
          this, signed-in users would still hit the anonymous-quota
          gate. -->
-    <script src="/static/auth.js?v=20260529-base-edit"></script>
+    <script src="/static/auth.js?v=20260529-paste-anything"></script>
     <!-- Cloning reference data must load before app.js so the Designer
          can read VECTORS / ENZYMES / CLONING_METHODS / TAGS / LINKERS. -->
-    <script src="/static/cloning_db.js?v=20260529-base-edit" defer></script>
-    <script src="/static/app.js?v=20260529-base-edit" defer></script>
+    <script src="/static/cloning_db.js?v=20260529-paste-anything" defer></script>
+    <script src="/static/app.js?v=20260529-paste-anything" defer></script>
 </body>
 </html>

tests/test_resolve.py

@@ -0,0 +1,127 @@
+"""Paste-anything target resolution (dee/core/resolve.py).
+
+NO NETWORK — Ensembl/NCBI fetchers are monkeypatched. Locks the input
+classifier (sequence vs symbol vs accession) and the resolve dispatch,
+including the privacy-preserving rule that raw sequences make no calls.
+"""
+import pytest
+
+from dee.core import resolve as R
+from dee.core import exon as E
+from dee.core.exon import Exon, GeneStructure
+
+
+# ─────────────────────────── classifier ───────────────────────────
+
+@pytest.mark.parametrize("text,kind", [
+    ("",                         "empty"),
+    ("ACGT" * 10,                "sequence"),          # 40 nt one-liner
+    (">hdr\nACGTACGTACGTACGTACGTACGT", "sequence"),    # FASTA
+    ("TP53",                     "symbol"),
+    ("BRCA1",                    "symbol"),
+    ("ENST00000269305",          "ensembl_tx"),
+    ("ENSMUST00000000001",       "ensembl_tx"),
+    ("ENSG00000141510",          "ensembl_gene"),
+    ("NM_000546",                "refseq"),
+    ("NM_000546.6",              "refseq"),
+    ("XM_011535573",             "refseq"),
+    ("!!!",                      "unknown"),
+])
+def test_classify(text, kind):
+    assert R.classify(text)[0] == kind
+
+
+def test_classify_sequence_strips_to_clean_dna():
+    kind, val = R.classify("acgt ACGT\nnnNN gtca gtca gtca")
+    assert kind == "sequence"
+    assert val == "ACGTACGTNNNNGTCAGTCAGTCA"
+
+
+# ─────────────────────────── raw sequence (offline) ───────────────────────────
+
+def test_resolve_raw_sequence_makes_no_network_call(monkeypatch):
+    # Any network helper firing would be a privacy bug for raw input.
+    def _boom(*a, **k):
+        raise AssertionError("network call on raw-sequence path!")
+    monkeypatch.setattr(E, "_http_get_text", _boom)
+    monkeypatch.setattr(E, "_http_get_json", _boom)
+    monkeypatch.setattr(E, "fetch_gene_structure", _boom)
+    out = R.resolve_target("ACGT" * 20)
+    assert out["ok"] and out["kind"] == "sequence"
+    assert out["sequence"] == "ACGT" * 20
+    assert "pasted sequence" in out["label"]
+
+
+def test_resolve_short_sequence_errors():
+    out = R.resolve_target("ACGTACGT")          # < 23 nt → symbol attempt → fails
+    assert out["ok"] is False
+
+
+# ─────────────────────────── gene symbol ───────────────────────────
+
+def _fake_gene():
+    return GeneStructure(
+        organism="human", gene_symbol="TP53", transcript_id="ENST00000269305",
+        strand=1, cds_sequence="ATG" + "GCT" * 50 + "TAA",
+        exons=[Exon(1, 1, 99, 0, 156)], last_junction_cds_pos=0,
+    )
+
+
+def test_resolve_symbol_requires_organism():
+    out = R.resolve_target("TP53", organism="")
+    assert out["ok"] is False and "Human or" in out["error"]
+
+
+def test_resolve_symbol_with_organism(monkeypatch):
+    monkeypatch.setattr(E, "fetch_gene_structure", lambda org, sym: _fake_gene())
+    out = R.resolve_target("TP53", organism="human")
+    assert out["ok"] and out["kind"] == "gene"
+    assert out["gene_symbol"] == "TP53"
+    assert out["sequence"].startswith("ATG")
+    assert "ENST00000269305" in out["label"]
+
+
+def test_resolve_symbol_not_found(monkeypatch):
+    monkeypatch.setattr(E, "fetch_gene_structure", lambda org, sym: None)
+    out = R.resolve_target("ZZZ9", organism="mouse")
+    assert out["ok"] is False and "Couldn't find" in out["error"]
+
+
+# ─────────────────────────── accessions ───────────────────────────
+
+def test_resolve_ensembl_transcript(monkeypatch):
+    monkeypatch.setattr(E, "_http_get_text",
+                        lambda url, **k: ">ENST\nATGAAACCCGGGTTTACGTACGTACGT")
+    out = R.resolve_target("ENST00000269305")
+    assert out["ok"] and out["kind"] == "ensembl"
+    assert out["sequence"] == "ATGAAACCCGGGTTTACGTACGTACGT"
+
+
+def test_resolve_ensembl_gene_resolves_canonical(monkeypatch):
+    monkeypatch.setattr(E, "_http_get_json", lambda url, **k: {
+        "Transcript": [
+            {"id": "ENST_other", "is_canonical": 0},
+            {"id": "ENST_canon", "is_canonical": 1},
+        ]})
+    captured = {}
+    def _seq(url, **k):
+        captured["url"] = url
+        return ">x\nATGCGTACGTACGTACGTACGTACG"
+    monkeypatch.setattr(E, "_http_get_text", _seq)
+    out = R.resolve_target("ENSG00000141510")
+    assert out["ok"] and out["kind"] == "ensembl"
+    assert "ENST_canon" in captured["url"]          # used the canonical transcript
+
+
+def test_resolve_refseq(monkeypatch):
+    monkeypatch.setattr(E, "_http_get_text",
+                        lambda url, **k: ">NM_000546\nATGGAGGAGCCGCAGTCAGAT")
+    out = R.resolve_target("NM_000546")
+    assert out["ok"] and out["kind"] == "refseq"
+    assert out["sequence"] == "ATGGAGGAGCCGCAGTCAGAT"
+
+
+def test_resolve_ensembl_fetch_failure(monkeypatch):
+    monkeypatch.setattr(E, "_http_get_text", lambda url, **k: None)
+    out = R.resolve_target("ENST00000269305")
+    assert out["ok"] is False and "Ensembl" in out["error"]