From 4730e60a388de2e7a99c63b8b185728a8503ca1f Mon Sep 17 00:00:00 2001 From: phase3dev <77866949+phase3dev@users.noreply.github.com> Date: Wed, 10 Jun 2026 02:15:38 -1000 Subject: [PATCH] fix(md-copy): leading semicolon on the injected payload (ASI safety) When appended after a bundle whose final statement is an expression with no trailing semicolon, the IIFE would parse as a call on that expression and throw before the webview app initializes. Prefix the payload with ';' so the patch is safe regardless of the bundle's final token. Regenerated the three embeds; adds a node-exec test on a no-semicolon bundle. Not triggered by the current 2.1.170 bundle (it ends with '}'); this hardens against future builds. Codex PR review, P2. Co-Authored-By: Claude Opus 4.8 (1M context) --- fixes/markdown-copy-export/add-md-copy.py | 2 +- fixes/markdown-copy-export/webview-inject.js | 5 ++++- launcher/claudemax | 5 ++++- launcher/claudemax.win.js | 2 +- tests/test_md_patcher.py | 11 +++++++++++ 5 files changed, 21 insertions(+), 4 deletions(-) diff --git a/fixes/markdown-copy-export/add-md-copy.py b/fixes/markdown-copy-export/add-md-copy.py index 2958e3e..619b3fc 100644 --- a/fixes/markdown-copy-export/add-md-copy.py +++ b/fixes/markdown-copy-export/add-md-copy.py @@ -31,7 +31,7 @@ BACKUP_SUFFIX = ".bak-md-copy" # >>>CCWA-MD-COPY-EMBED>>> (generated by tools/gen-embeds; do not edit) -INJECT_JS = base64.b64decode("/* cc-md-copy: per-message and whole-conversation copy (markdown/plain) for the
 * Claude Code VS Code webview. Self-contained IIFE appended to webview/index.js.
 * Additive and read-only w.r.t. app state; keyed on stable CSS-module class
 * prefixes, so it fails safe (controls simply do not appear) if a prefix moves.
 * Exposes its pure functions for node unit tests; boot()s only in a real webview. */
(function () {
  "use strict";

  var CONTROL_PREFIX = "cc-md-copy"; // every injected node's class starts with this
  var USER_BUBBLE = '[class*="userMessageContainer_"]';
  // Assistant message wrapper. Verified on 2.1.170: the render emits exactly one
  // `data-testid="assistant-message"` div per assistant turn, with the rating
  // widget and content blocks as its children. (The earlier `[data-message-rating]`
  // was WRONG: that attribute sits on the nested rating control, which is also only
  // rendered behind an experiment+analytics gate.) Re-pinned in Task 6.
  var ASSISTANT_BUBBLE = '[data-testid="assistant-message"]';
  var MESSAGES_CONTAINER = '[class*="messagesContainer_"]'; // e.g. '[class*="timeline_"]'; "" -> observe document.body
  // Optional narrowing only. MUST be a single wrapper around ALL content blocks,
  // not a per-block class (a turn has multiple blocks). "" -> use the bubble itself
  // (already aggregates all blocks; sanitizeClone is the correctness gate).
  var ASSISTANT_CONTENT = "";
  var FEEDBACK_MS = 1800;

  // ---- HTML -> Markdown (DOM walk) -------------------------------------------
  // Uses only: nodeType, tagName, childNodes, textContent, getAttribute, className.
  function htmlToMarkdown(root) {
    // Longest run of consecutive backticks in s, so a code delimiter/fence can be
    // chosen longer than anything inside it (else ``` in the content closes early).
    function backtickRun(s) {
      var max = 0, cur = 0;
      for (var i = 0; i < s.length; i++) {
        if (s.charAt(i) === "`") { cur++; if (cur > max) max = cur; } else cur = 0;
      }
      return max;
    }
    function fence(s, min) { var n = backtickRun(s) + 1; if (n < min) n = min; return new Array(n + 1).join("`"); }
    function inline(node) {
      var out = "";
      var kids = node.childNodes || [];
      for (var i = 0; i < kids.length; i++) {
        var c = kids[i];
        if (c.nodeType === 3) { out += c.textContent || ""; continue; }
        if (c.nodeType !== 1) continue;
        var tag = (c.tagName || "").toUpperCase();
        if (tag === "BR") out += "\n";
        else if (tag === "STRONG" || tag === "B") out += "**" + inline(c) + "**";
        else if (tag === "EM" || tag === "I") out += "*" + inline(c) + "*";
        else if (tag === "DEL" || tag === "S") out += "~~" + inline(c) + "~~";
        else if (tag === "CODE") {
          var ct = c.textContent || "";
          var d = fence(ct, 1);
          // CommonMark strips one leading+trailing space, so pad when an edge is a
          // backtick to keep it from merging with the delimiter.
          var p = (ct.charAt(0) === "`" || ct.charAt(ct.length - 1) === "`") ? " " : "";
          out += d + p + ct + p + d;
        }
        else if (tag === "A") {
          var href = c.getAttribute ? c.getAttribute("href") : null;
          var t = inline(c);
          out += href ? "[" + t + "](" + href + ")" : t;
        } else out += inline(c); // unknown inline wrapper: keep text, drop tag
      }
      return out;
    }
    function langOf(codeEl) {
      var cls = "";
      if (codeEl) cls = (codeEl.getAttribute && codeEl.getAttribute("class")) || codeEl.className || "";
      var m = /language-([A-Za-z0-9+#.\-]+)/.exec(cls || "");
      return m ? m[1] : "";
    }
    function findChildTag(node, tag) {
      var kids = node.childNodes || [];
      for (var i = 0; i < kids.length; i++) {
        if (kids[i].nodeType === 1 && (kids[i].tagName || "").toUpperCase() === tag) return kids[i];
      }
      return null;
    }
    function list(node, ordered, depth) {
      var out = "", n = 1;
      var kids = node.childNodes || [];
      for (var i = 0; i < kids.length; i++) {
        var li = kids[i];
        if (li.nodeType !== 1 || (li.tagName || "").toUpperCase() !== "LI") continue;
        var marker = ordered ? n++ + ". " : "- ";
        var indent = new Array(depth + 1).join("  ");
        var lead = "", nested = "";
        var lk = li.childNodes || [];
        for (var j = 0; j < lk.length; j++) {
          var ch = lk[j];
          var ct = ch.nodeType === 1 ? (ch.tagName || "").toUpperCase() : "";
          if (ct === "UL") nested += list(ch, false, depth + 1);
          else if (ct === "OL") nested += list(ch, true, depth + 1);
          else if (ch.nodeType === 3) lead += ch.textContent || "";
          else lead += inline(ch);
        }
        out += indent + marker + lead.trim() + "\n" + nested;
      }
      return out;
    }
    function table(node) {
      var rows = [];
      (function collect(container) {
        var kids = container.childNodes || [];
        for (var i = 0; i < kids.length; i++) {
          var c = kids[i];
          if (c.nodeType !== 1) continue;
          var t = (c.tagName || "").toUpperCase();
          if (t === "THEAD" || t === "TBODY" || t === "TFOOT") collect(c);
          else if (t === "TR") {
            var cells = [], cc = c.childNodes || [];
            for (var j = 0; j < cc.length; j++) {
              var d = cc[j];
              if (d.nodeType !== 1) continue;
              var dt = (d.tagName || "").toUpperCase();
              if (dt === "TH" || dt === "TD") cells.push(inline(d).trim());
            }
            rows.push(cells);
          }
        }
      })(node);
      if (!rows.length) return "";
      var head = rows[0], body = rows.slice(1);
      var sep = head.map(function () { return "---"; });
      var out = "| " + head.join(" | ") + " |\n| " + sep.join(" | ") + " |\n";
      for (var k = 0; k < body.length; k++) out += "| " + body[k].join(" | ") + " |\n";
      return out;
    }
    function block(node) {
      var out = "";
      var kids = node.childNodes || [];
      for (var i = 0; i < kids.length; i++) {
        var c = kids[i];
        if (c.nodeType === 3) { if ((c.textContent || "").trim()) out += c.textContent; continue; }
        if (c.nodeType !== 1) continue;
        var tag = (c.tagName || "").toUpperCase();
        if (/^H[1-6]$/.test(tag)) out += new Array(+tag[1] + 1).join("#") + " " + inline(c).trim() + "\n\n";
        else if (tag === "P") out += inline(c).trim() + "\n\n";
        else if (tag === "UL") out += list(c, false, 0) + "\n";
        else if (tag === "OL") out += list(c, true, 0) + "\n";
        else if (tag === "PRE") {
          var code = findChildTag(c, "CODE");
          var lang = langOf(code || c);
          var body = (code || c).textContent || "";
          var f = fence(body, 3);
          out += f + lang + "\n" + body.replace(/\n$/, "") + "\n" + f + "\n\n";
        } else if (tag === "BLOCKQUOTE") {
          var inner = block(c).trim().split("\n").map(function (l) { return "> " + l; }).join("\n");
          out += inner + "\n\n";
        } else if (tag === "HR") out += "---\n\n";
        else if (tag === "TABLE") out += table(c) + "\n";
        else if (tag === "BR") out += "\n";
        else if (tag === "STRONG" || tag === "B" || tag === "EM" || tag === "I" ||
                 tag === "A" || tag === "CODE" || tag === "DEL" || tag === "S")
          out += inline(c) + "\n\n";
        else out += block(c); // unknown wrapper: recurse (drop tag, keep content)
      }
      return out;
    }
    // block() dispatches on each CHILD's tag, treating the passed node as a plain
    // container. Wrap root in a one-off container so root's OWN tag is dispatched
    // too: callers pass either the bubble container (its block children render) or
    // a single block element like <pre>/<ul>/<table> (now handled, not flattened).
    return block({ childNodes: [root] }).replace(/\n{3,}/g, "\n\n").trim();
  }

  // ---- pure helpers ----------------------------------------------------------
  function hasPrefix(node, prefix) {
    if (node.nodeType !== 1 || typeof node.className !== "string") return false;
    var parts = node.className.split(/\s+/);
    for (var i = 0; i < parts.length; i++) if (parts[i].indexOf(prefix) === 0) return true;
    return false;
  }

  // Class-prefix hooks for non-content chrome that renders *inside* an assistant
  // bubble (verified on 2.1.170; Task 6 re-pins these). tool*/thinking_ are the v1
  // exclusions; unknownContent_ is the renderer's fallback for unrecognized block
  // types, so stripping it makes a *future* block type fail safe to excluded rather
  // than leaking "Unsupported content" into the copy. Re-pin if a prefix moves.
  var CHROME_PREFIXES = ["toolUse_", "toolResult_", "toolReference_", "thinking_", "unknownContent_"];

  // True for any node that must never appear in copied output: our own controls,
  // the rating widget (`data-message-rating` + its "Thanks for your feedback"
  // text), any button (copy-code chrome), and the excluded content blocks above.
  function isChrome(node) {
    if (node.nodeType !== 1) return false;
    if ((node.tagName || "").toUpperCase() === "BUTTON") return true;
    if (node.getAttribute && node.getAttribute("data-message-rating") !== null) return true;
    if (hasPrefix(node, CONTROL_PREFIX)) return true;
    for (var i = 0; i < CHROME_PREFIXES.length; i++) if (hasPrefix(node, CHROME_PREFIXES[i])) return true;
    return false;
  }

  // Deep-clone `contentNode`, then strip every chrome node so copied output is the
  // message's text content only. This is a CORRECTNESS GATE, not cosmetic: the
  // default content node is the whole bubble (all content-block siblings, so multi-
  // block assistant turns are captured), and this strip-list is the only thing
  // keeping the rating widget and v1-excluded blocks out of the copy.
  function sanitizeClone(contentNode) {
    var clone = contentNode.cloneNode(true);
    (function strip(node) {
      var kids = (node.childNodes || []).slice();
      for (var i = 0; i < kids.length; i++) {
        var c = kids[i];
        if (c.nodeType === 1 && isChrome(c)) { node.removeChild(c); continue; }
        if (c.nodeType === 1) strip(c);
      }
    })(clone);
    return clone;
  }

  function classifyBubble(node) {
    if (node.nodeType !== 1) return null;
    if (hasPrefix(node, "userMessageContainer_")) return "user";
    if (node.getAttribute && node.getAttribute("data-testid") === "assistant-message") return "assistant";
    return null;
  }

  // Build the whole-conversation markdown from an ordered list of bubbles.
  // `contentOf(bubble)` resolves the content node (default: the bubble itself, so
  // every content block is included; sanitizeClone drops chrome); a default is
  // provided for tests.
  function conversationToMarkdown(bubbles, contentOf) {
    contentOf = contentOf || function (b) { return b; };
    var parts = [];
    for (var i = 0; i < bubbles.length; i++) {
      var role = classifyBubble(bubbles[i]);
      if (!role) continue;
      var clean = sanitizeClone(contentOf(bubbles[i]));
      var body = role === "assistant" ? htmlToMarkdown(clean) : (clean.textContent || "").trim();
      if (!body) continue;
      parts.push((role === "user" ? "## User" : "## Assistant") + "\n\n" + body);
    }
    return parts.join("\n\n") + (parts.length ? "\n" : "");
  }

  // ---- exports (node tests) / boot (real webview) ----------------------------
  if (typeof document !== "undefined") {
    boot();
  } else if (typeof module !== "undefined" && module.exports) {
    module.exports = { htmlToMarkdown: htmlToMarkdown, sanitizeClone: sanitizeClone,
                       classifyBubble: classifyBubble, conversationToMarkdown: conversationToMarkdown };
  }

  // ---- live-webview wiring (runs only when a document exists) ----------------
  function qs(node, sel) { try { return sel && node.querySelector ? node.querySelector(sel) : null; } catch (_) { return null; } }
  function qsa(sel) { try { return Array.prototype.slice.call(document.querySelectorAll(sel)); } catch (_) { return []; } }

  // The content node to convert/copy: the optional ASSISTANT_CONTENT wrapper if
  // pinned and present, else the bubble itself. The bubble already contains every
  // content-block sibling of a multi-block turn, and sanitizeClone strips the
  // chrome (rating widget, tool/thinking/unknown blocks, buttons, our controls)
  // either way -- so this is a narrowing, never the thing that guarantees
  // correctness.
  function contentNodeOf(bubble, role) {
    if (role === "assistant" && ASSISTANT_CONTENT) {
      var n = qs(bubble, ASSISTANT_CONTENT);
      if (n) return n;
    }
    return bubble;
  }

  function copyText(text) {
    try {
      if (navigator.clipboard && navigator.clipboard.writeText) return navigator.clipboard.writeText(text);
    } catch (_) {}
    return Promise.resolve(); // best-effort; never throw into the app
  }

  function flashFeedback(host) {
    try {
      var fb = document.createElement("span");
      fb.className = CONTROL_PREFIX + "-feedback";
      fb.textContent = "Copied";
      host.appendChild(fb);
      setTimeout(function () { if (fb && fb.parentNode) fb.parentNode.removeChild(fb); }, FEEDBACK_MS);
    } catch (_) {}
  }

  function bubbleMarkdown(bubble, role) {
    var clean = sanitizeClone(contentNodeOf(bubble, role));
    return role === "assistant" ? htmlToMarkdown(clean) : (clean.textContent || "").trim();
  }
  function bubblePlain(bubble, role) {
    return (sanitizeClone(contentNodeOf(bubble, role)).textContent || "").trim();
  }

  // Build a single control: a primary "Copy" (markdown) plus a small caret that
  // toggles a menu with "Copy as plain text". All nodes carry the CONTROL_PREFIX
  // class so sanitizeClone removes them from any copied content.
  function buildControl(onMarkdown, onPlain) {
    var wrap = document.createElement("span");
    wrap.className = CONTROL_PREFIX;
    var primary = document.createElement("button");
    primary.type = "button";
    primary.className = CONTROL_PREFIX + "-btn";
    primary.title = "Copy as Markdown";
    primary.textContent = "Copy";
    primary.addEventListener("click", function (e) { e.stopPropagation(); onMarkdown(primary); });
    var caret = document.createElement("button");
    caret.type = "button";
    caret.className = CONTROL_PREFIX + "-caret";
    caret.title = "Copy options";
    caret.textContent = "▾"; // black down-pointing small triangle
    var menu = document.createElement("span");
    menu.className = CONTROL_PREFIX + "-menu";
    menu.style.display = "none";
    var plain = document.createElement("button");
    plain.type = "button";
    plain.className = CONTROL_PREFIX + "-btn";
    plain.textContent = "Copy as plain text";
    plain.addEventListener("click", function (e) { e.stopPropagation(); menu.style.display = "none"; onPlain(plain); });
    menu.appendChild(plain);
    caret.addEventListener("click", function (e) {
      e.stopPropagation();
      menu.style.display = menu.style.display === "none" ? "inline-block" : "none";
    });
    wrap.appendChild(primary);
    wrap.appendChild(caret);
    wrap.appendChild(menu);
    return wrap;
  }

  function decorate(bubble) {
    try {
      var role = classifyBubble(bubble);
      if (!role) return;
      if (qs(bubble, "." + CONTROL_PREFIX)) return; // already decorated
      var control = buildControl(
        function (host) { copyText(bubbleMarkdown(bubble, role)).then(function () { flashFeedback(control); }); },
        function (host) { copyText(bubblePlain(bubble, role)).then(function () { flashFeedback(control); }); }
      );
      bubble.appendChild(control);
    } catch (_) {}
  }

  function copyConversation(format) {
    var bubbles = qsa(USER_BUBBLE + "," + ASSISTANT_BUBBLE);
    if (format === "text") {
      var lines = [];
      for (var i = 0; i < bubbles.length; i++) {
        var role = classifyBubble(bubbles[i]);
        if (!role) continue;
        var body = bubblePlain(bubbles[i], role);
        if (body) lines.push(body);
      }
      return copyText(lines.join("\n\n") + (lines.length ? "\n" : ""));
    }
    return copyText(conversationToMarkdown(bubbles, function (b) {
      return contentNodeOf(b, classifyBubble(b));
    }));
  }

  function installConversationControl() {
    try {
      if (qs(document, "." + CONTROL_PREFIX + "-conversation")) return;
      var bar = document.createElement("div");
      bar.className = CONTROL_PREFIX + "-conversation";
      var control = buildControl(
        function () { copyConversation("markdown").then(function () { flashFeedback(bar); }); },
        function () { copyConversation("text").then(function () { flashFeedback(bar); }); }
      );
      control.title = "Copy entire conversation";
      bar.appendChild(control);
      document.body.appendChild(bar); // fixed-position via CSS; placement refined in Task 6
    } catch (_) {}
  }

  function sweep() { var b = qsa(USER_BUBBLE + "," + ASSISTANT_BUBBLE); for (var i = 0; i < b.length; i++) decorate(b[i]); }

  function boot() {
    try {
      var target = (MESSAGES_CONTAINER && qs(document, MESSAGES_CONTAINER)) || document.body;
      sweep();
      installConversationControl();
      if (typeof MutationObserver === "undefined") return;
      var obs = new MutationObserver(function () { sweep(); });
      obs.observe(target, { childList: true, subtree: true });
    } catch (_) {}
  }
})();
").decode("utf-8") +INJECT_JS = base64.b64decode("/* cc-md-copy: per-message and whole-conversation copy (markdown/plain) for the
 * Claude Code VS Code webview. Self-contained IIFE appended to webview/index.js.
 * Additive and read-only w.r.t. app state; keyed on stable CSS-module class
 * prefixes, so it fails safe (controls simply do not appear) if a prefix moves.
 * Exposes its pure functions for node unit tests; boot()s only in a real webview. */
/* Leading ';' so that, appended after the bundle, this IIFE can never be parsed as
 * a call on the bundle's final expression if it lacks a trailing semicolon (ASI
 * safety across extension builds). */
;(function () {
  "use strict";

  var CONTROL_PREFIX = "cc-md-copy"; // every injected node's class starts with this
  var USER_BUBBLE = '[class*="userMessageContainer_"]';
  // Assistant message wrapper. Verified on 2.1.170: the render emits exactly one
  // `data-testid="assistant-message"` div per assistant turn, with the rating
  // widget and content blocks as its children. (The earlier `[data-message-rating]`
  // was WRONG: that attribute sits on the nested rating control, which is also only
  // rendered behind an experiment+analytics gate.) Re-pinned in Task 6.
  var ASSISTANT_BUBBLE = '[data-testid="assistant-message"]';
  var MESSAGES_CONTAINER = '[class*="messagesContainer_"]'; // e.g. '[class*="timeline_"]'; "" -> observe document.body
  // Optional narrowing only. MUST be a single wrapper around ALL content blocks,
  // not a per-block class (a turn has multiple blocks). "" -> use the bubble itself
  // (already aggregates all blocks; sanitizeClone is the correctness gate).
  var ASSISTANT_CONTENT = "";
  var FEEDBACK_MS = 1800;

  // ---- HTML -> Markdown (DOM walk) -------------------------------------------
  // Uses only: nodeType, tagName, childNodes, textContent, getAttribute, className.
  function htmlToMarkdown(root) {
    // Longest run of consecutive backticks in s, so a code delimiter/fence can be
    // chosen longer than anything inside it (else ``` in the content closes early).
    function backtickRun(s) {
      var max = 0, cur = 0;
      for (var i = 0; i < s.length; i++) {
        if (s.charAt(i) === "`") { cur++; if (cur > max) max = cur; } else cur = 0;
      }
      return max;
    }
    function fence(s, min) { var n = backtickRun(s) + 1; if (n < min) n = min; return new Array(n + 1).join("`"); }
    function inline(node) {
      var out = "";
      var kids = node.childNodes || [];
      for (var i = 0; i < kids.length; i++) {
        var c = kids[i];
        if (c.nodeType === 3) { out += c.textContent || ""; continue; }
        if (c.nodeType !== 1) continue;
        var tag = (c.tagName || "").toUpperCase();
        if (tag === "BR") out += "\n";
        else if (tag === "STRONG" || tag === "B") out += "**" + inline(c) + "**";
        else if (tag === "EM" || tag === "I") out += "*" + inline(c) + "*";
        else if (tag === "DEL" || tag === "S") out += "~~" + inline(c) + "~~";
        else if (tag === "CODE") {
          var ct = c.textContent || "";
          var d = fence(ct, 1);
          // CommonMark strips one leading+trailing space, so pad when an edge is a
          // backtick to keep it from merging with the delimiter.
          var p = (ct.charAt(0) === "`" || ct.charAt(ct.length - 1) === "`") ? " " : "";
          out += d + p + ct + p + d;
        }
        else if (tag === "A") {
          var href = c.getAttribute ? c.getAttribute("href") : null;
          var t = inline(c);
          out += href ? "[" + t + "](" + href + ")" : t;
        } else out += inline(c); // unknown inline wrapper: keep text, drop tag
      }
      return out;
    }
    function langOf(codeEl) {
      var cls = "";
      if (codeEl) cls = (codeEl.getAttribute && codeEl.getAttribute("class")) || codeEl.className || "";
      var m = /language-([A-Za-z0-9+#.\-]+)/.exec(cls || "");
      return m ? m[1] : "";
    }
    function findChildTag(node, tag) {
      var kids = node.childNodes || [];
      for (var i = 0; i < kids.length; i++) {
        if (kids[i].nodeType === 1 && (kids[i].tagName || "").toUpperCase() === tag) return kids[i];
      }
      return null;
    }
    function list(node, ordered, depth) {
      var out = "", n = 1;
      var kids = node.childNodes || [];
      for (var i = 0; i < kids.length; i++) {
        var li = kids[i];
        if (li.nodeType !== 1 || (li.tagName || "").toUpperCase() !== "LI") continue;
        var marker = ordered ? n++ + ". " : "- ";
        var indent = new Array(depth + 1).join("  ");
        var lead = "", nested = "";
        var lk = li.childNodes || [];
        for (var j = 0; j < lk.length; j++) {
          var ch = lk[j];
          var ct = ch.nodeType === 1 ? (ch.tagName || "").toUpperCase() : "";
          if (ct === "UL") nested += list(ch, false, depth + 1);
          else if (ct === "OL") nested += list(ch, true, depth + 1);
          else if (ch.nodeType === 3) lead += ch.textContent || "";
          else lead += inline(ch);
        }
        out += indent + marker + lead.trim() + "\n" + nested;
      }
      return out;
    }
    function table(node) {
      var rows = [];
      (function collect(container) {
        var kids = container.childNodes || [];
        for (var i = 0; i < kids.length; i++) {
          var c = kids[i];
          if (c.nodeType !== 1) continue;
          var t = (c.tagName || "").toUpperCase();
          if (t === "THEAD" || t === "TBODY" || t === "TFOOT") collect(c);
          else if (t === "TR") {
            var cells = [], cc = c.childNodes || [];
            for (var j = 0; j < cc.length; j++) {
              var d = cc[j];
              if (d.nodeType !== 1) continue;
              var dt = (d.tagName || "").toUpperCase();
              if (dt === "TH" || dt === "TD") cells.push(inline(d).trim());
            }
            rows.push(cells);
          }
        }
      })(node);
      if (!rows.length) return "";
      var head = rows[0], body = rows.slice(1);
      var sep = head.map(function () { return "---"; });
      var out = "| " + head.join(" | ") + " |\n| " + sep.join(" | ") + " |\n";
      for (var k = 0; k < body.length; k++) out += "| " + body[k].join(" | ") + " |\n";
      return out;
    }
    function block(node) {
      var out = "";
      var kids = node.childNodes || [];
      for (var i = 0; i < kids.length; i++) {
        var c = kids[i];
        if (c.nodeType === 3) { if ((c.textContent || "").trim()) out += c.textContent; continue; }
        if (c.nodeType !== 1) continue;
        var tag = (c.tagName || "").toUpperCase();
        if (/^H[1-6]$/.test(tag)) out += new Array(+tag[1] + 1).join("#") + " " + inline(c).trim() + "\n\n";
        else if (tag === "P") out += inline(c).trim() + "\n\n";
        else if (tag === "UL") out += list(c, false, 0) + "\n";
        else if (tag === "OL") out += list(c, true, 0) + "\n";
        else if (tag === "PRE") {
          var code = findChildTag(c, "CODE");
          var lang = langOf(code || c);
          var body = (code || c).textContent || "";
          var f = fence(body, 3);
          out += f + lang + "\n" + body.replace(/\n$/, "") + "\n" + f + "\n\n";
        } else if (tag === "BLOCKQUOTE") {
          var inner = block(c).trim().split("\n").map(function (l) { return "> " + l; }).join("\n");
          out += inner + "\n\n";
        } else if (tag === "HR") out += "---\n\n";
        else if (tag === "TABLE") out += table(c) + "\n";
        else if (tag === "BR") out += "\n";
        else if (tag === "STRONG" || tag === "B" || tag === "EM" || tag === "I" ||
                 tag === "A" || tag === "CODE" || tag === "DEL" || tag === "S")
          out += inline(c) + "\n\n";
        else out += block(c); // unknown wrapper: recurse (drop tag, keep content)
      }
      return out;
    }
    // block() dispatches on each CHILD's tag, treating the passed node as a plain
    // container. Wrap root in a one-off container so root's OWN tag is dispatched
    // too: callers pass either the bubble container (its block children render) or
    // a single block element like <pre>/<ul>/<table> (now handled, not flattened).
    return block({ childNodes: [root] }).replace(/\n{3,}/g, "\n\n").trim();
  }

  // ---- pure helpers ----------------------------------------------------------
  function hasPrefix(node, prefix) {
    if (node.nodeType !== 1 || typeof node.className !== "string") return false;
    var parts = node.className.split(/\s+/);
    for (var i = 0; i < parts.length; i++) if (parts[i].indexOf(prefix) === 0) return true;
    return false;
  }

  // Class-prefix hooks for non-content chrome that renders *inside* an assistant
  // bubble (verified on 2.1.170; Task 6 re-pins these). tool*/thinking_ are the v1
  // exclusions; unknownContent_ is the renderer's fallback for unrecognized block
  // types, so stripping it makes a *future* block type fail safe to excluded rather
  // than leaking "Unsupported content" into the copy. Re-pin if a prefix moves.
  var CHROME_PREFIXES = ["toolUse_", "toolResult_", "toolReference_", "thinking_", "unknownContent_"];

  // True for any node that must never appear in copied output: our own controls,
  // the rating widget (`data-message-rating` + its "Thanks for your feedback"
  // text), any button (copy-code chrome), and the excluded content blocks above.
  function isChrome(node) {
    if (node.nodeType !== 1) return false;
    if ((node.tagName || "").toUpperCase() === "BUTTON") return true;
    if (node.getAttribute && node.getAttribute("data-message-rating") !== null) return true;
    if (hasPrefix(node, CONTROL_PREFIX)) return true;
    for (var i = 0; i < CHROME_PREFIXES.length; i++) if (hasPrefix(node, CHROME_PREFIXES[i])) return true;
    return false;
  }

  // Deep-clone `contentNode`, then strip every chrome node so copied output is the
  // message's text content only. This is a CORRECTNESS GATE, not cosmetic: the
  // default content node is the whole bubble (all content-block siblings, so multi-
  // block assistant turns are captured), and this strip-list is the only thing
  // keeping the rating widget and v1-excluded blocks out of the copy.
  function sanitizeClone(contentNode) {
    var clone = contentNode.cloneNode(true);
    (function strip(node) {
      var kids = (node.childNodes || []).slice();
      for (var i = 0; i < kids.length; i++) {
        var c = kids[i];
        if (c.nodeType === 1 && isChrome(c)) { node.removeChild(c); continue; }
        if (c.nodeType === 1) strip(c);
      }
    })(clone);
    return clone;
  }

  function classifyBubble(node) {
    if (node.nodeType !== 1) return null;
    if (hasPrefix(node, "userMessageContainer_")) return "user";
    if (node.getAttribute && node.getAttribute("data-testid") === "assistant-message") return "assistant";
    return null;
  }

  // Build the whole-conversation markdown from an ordered list of bubbles.
  // `contentOf(bubble)` resolves the content node (default: the bubble itself, so
  // every content block is included; sanitizeClone drops chrome); a default is
  // provided for tests.
  function conversationToMarkdown(bubbles, contentOf) {
    contentOf = contentOf || function (b) { return b; };
    var parts = [];
    for (var i = 0; i < bubbles.length; i++) {
      var role = classifyBubble(bubbles[i]);
      if (!role) continue;
      var clean = sanitizeClone(contentOf(bubbles[i]));
      var body = role === "assistant" ? htmlToMarkdown(clean) : (clean.textContent || "").trim();
      if (!body) continue;
      parts.push((role === "user" ? "## User" : "## Assistant") + "\n\n" + body);
    }
    return parts.join("\n\n") + (parts.length ? "\n" : "");
  }

  // ---- exports (node tests) / boot (real webview) ----------------------------
  if (typeof document !== "undefined") {
    boot();
  } else if (typeof module !== "undefined" && module.exports) {
    module.exports = { htmlToMarkdown: htmlToMarkdown, sanitizeClone: sanitizeClone,
                       classifyBubble: classifyBubble, conversationToMarkdown: conversationToMarkdown };
  }

  // ---- live-webview wiring (runs only when a document exists) ----------------
  function qs(node, sel) { try { return sel && node.querySelector ? node.querySelector(sel) : null; } catch (_) { return null; } }
  function qsa(sel) { try { return Array.prototype.slice.call(document.querySelectorAll(sel)); } catch (_) { return []; } }

  // The content node to convert/copy: the optional ASSISTANT_CONTENT wrapper if
  // pinned and present, else the bubble itself. The bubble already contains every
  // content-block sibling of a multi-block turn, and sanitizeClone strips the
  // chrome (rating widget, tool/thinking/unknown blocks, buttons, our controls)
  // either way -- so this is a narrowing, never the thing that guarantees
  // correctness.
  function contentNodeOf(bubble, role) {
    if (role === "assistant" && ASSISTANT_CONTENT) {
      var n = qs(bubble, ASSISTANT_CONTENT);
      if (n) return n;
    }
    return bubble;
  }

  function copyText(text) {
    try {
      if (navigator.clipboard && navigator.clipboard.writeText) return navigator.clipboard.writeText(text);
    } catch (_) {}
    return Promise.resolve(); // best-effort; never throw into the app
  }

  function flashFeedback(host) {
    try {
      var fb = document.createElement("span");
      fb.className = CONTROL_PREFIX + "-feedback";
      fb.textContent = "Copied";
      host.appendChild(fb);
      setTimeout(function () { if (fb && fb.parentNode) fb.parentNode.removeChild(fb); }, FEEDBACK_MS);
    } catch (_) {}
  }

  function bubbleMarkdown(bubble, role) {
    var clean = sanitizeClone(contentNodeOf(bubble, role));
    return role === "assistant" ? htmlToMarkdown(clean) : (clean.textContent || "").trim();
  }
  function bubblePlain(bubble, role) {
    return (sanitizeClone(contentNodeOf(bubble, role)).textContent || "").trim();
  }

  // Build a single control: a primary "Copy" (markdown) plus a small caret that
  // toggles a menu with "Copy as plain text". All nodes carry the CONTROL_PREFIX
  // class so sanitizeClone removes them from any copied content.
  function buildControl(onMarkdown, onPlain) {
    var wrap = document.createElement("span");
    wrap.className = CONTROL_PREFIX;
    var primary = document.createElement("button");
    primary.type = "button";
    primary.className = CONTROL_PREFIX + "-btn";
    primary.title = "Copy as Markdown";
    primary.textContent = "Copy";
    primary.addEventListener("click", function (e) { e.stopPropagation(); onMarkdown(primary); });
    var caret = document.createElement("button");
    caret.type = "button";
    caret.className = CONTROL_PREFIX + "-caret";
    caret.title = "Copy options";
    caret.textContent = "▾"; // black down-pointing small triangle
    var menu = document.createElement("span");
    menu.className = CONTROL_PREFIX + "-menu";
    menu.style.display = "none";
    var plain = document.createElement("button");
    plain.type = "button";
    plain.className = CONTROL_PREFIX + "-btn";
    plain.textContent = "Copy as plain text";
    plain.addEventListener("click", function (e) { e.stopPropagation(); menu.style.display = "none"; onPlain(plain); });
    menu.appendChild(plain);
    caret.addEventListener("click", function (e) {
      e.stopPropagation();
      menu.style.display = menu.style.display === "none" ? "inline-block" : "none";
    });
    wrap.appendChild(primary);
    wrap.appendChild(caret);
    wrap.appendChild(menu);
    return wrap;
  }

  function decorate(bubble) {
    try {
      var role = classifyBubble(bubble);
      if (!role) return;
      if (qs(bubble, "." + CONTROL_PREFIX)) return; // already decorated
      var control = buildControl(
        function (host) { copyText(bubbleMarkdown(bubble, role)).then(function () { flashFeedback(control); }); },
        function (host) { copyText(bubblePlain(bubble, role)).then(function () { flashFeedback(control); }); }
      );
      bubble.appendChild(control);
    } catch (_) {}
  }

  function copyConversation(format) {
    var bubbles = qsa(USER_BUBBLE + "," + ASSISTANT_BUBBLE);
    if (format === "text") {
      var lines = [];
      for (var i = 0; i < bubbles.length; i++) {
        var role = classifyBubble(bubbles[i]);
        if (!role) continue;
        var body = bubblePlain(bubbles[i], role);
        if (body) lines.push(body);
      }
      return copyText(lines.join("\n\n") + (lines.length ? "\n" : ""));
    }
    return copyText(conversationToMarkdown(bubbles, function (b) {
      return contentNodeOf(b, classifyBubble(b));
    }));
  }

  function installConversationControl() {
    try {
      if (qs(document, "." + CONTROL_PREFIX + "-conversation")) return;
      var bar = document.createElement("div");
      bar.className = CONTROL_PREFIX + "-conversation";
      var control = buildControl(
        function () { copyConversation("markdown").then(function () { flashFeedback(bar); }); },
        function () { copyConversation("text").then(function () { flashFeedback(bar); }); }
      );
      control.title = "Copy entire conversation";
      bar.appendChild(control);
      document.body.appendChild(bar); // fixed-position via CSS; placement refined in Task 6
    } catch (_) {}
  }

  function sweep() { var b = qsa(USER_BUBBLE + "," + ASSISTANT_BUBBLE); for (var i = 0; i < b.length; i++) decorate(b[i]); }

  function boot() {
    try {
      var target = (MESSAGES_CONTAINER && qs(document, MESSAGES_CONTAINER)) || document.body;
      sweep();
      installConversationControl();
      if (typeof MutationObserver === "undefined") return;
      var obs = new MutationObserver(function () { sweep(); });
      obs.observe(target, { childList: true, subtree: true });
    } catch (_) {}
  }
})();
").decode("utf-8") INJECT_CSS = base64.b64decode("LmNjLW1kLWNvcHkgewogIGRpc3BsYXk6IGlubGluZS1mbGV4OwogIGFsaWduLWl0ZW1zOiBjZW50ZXI7CiAgZ2FwOiAycHg7CiAgdmVydGljYWwtYWxpZ246IG1pZGRsZTsKICBtYXJnaW4tbGVmdDogNnB4Owp9Ci5jYy1tZC1jb3B5LWJ0biwKLmNjLW1kLWNvcHktY2FyZXQgewogIGZvbnQ6IGluaGVyaXQ7CiAgZm9udC1zaXplOiAxMXB4OwogIGxpbmUtaGVpZ2h0OiAxLjQ7CiAgcGFkZGluZzogMXB4IDZweDsKICBjb2xvcjogdmFyKC0tdnNjb2RlLWZvcmVncm91bmQpOwogIGJhY2tncm91bmQ6IHRyYW5zcGFyZW50OwogIGJvcmRlcjogMXB4IHNvbGlkIHZhcigtLXZzY29kZS13aWRnZXQtYm9yZGVyLCB0cmFuc3BhcmVudCk7CiAgYm9yZGVyLXJhZGl1czogNHB4OwogIGN1cnNvcjogcG9pbnRlcjsKICBvcGFjaXR5OiAwLjY1Owp9Ci5jYy1tZC1jb3B5LWJ0bjpob3ZlciwKLmNjLW1kLWNvcHktY2FyZXQ6aG92ZXIgewogIG9wYWNpdHk6IDE7CiAgYmFja2dyb3VuZDogdmFyKC0tdnNjb2RlLXRvb2xiYXItaG92ZXJCYWNrZ3JvdW5kLCByZ2JhKDEyOCwgMTI4LCAxMjgsIDAuMTUpKTsKfQouY2MtbWQtY29weS1tZW51IHsKICBwb3NpdGlvbjogcmVsYXRpdmU7CiAgbWFyZ2luLWxlZnQ6IDRweDsKICBwYWRkaW5nOiAycHg7CiAgYmFja2dyb3VuZDogdmFyKC0tdnNjb2RlLW1lbnUtYmFja2dyb3VuZCwgdmFyKC0tdnNjb2RlLWVkaXRvcldpZGdldC1iYWNrZ3JvdW5kKSk7CiAgYm9yZGVyOiAxcHggc29saWQgdmFyKC0tdnNjb2RlLW1lbnUtYm9yZGVyLCB2YXIoLS12c2NvZGUtd2lkZ2V0LWJvcmRlciwgdHJhbnNwYXJlbnQpKTsKICBib3JkZXItcmFkaXVzOiA0cHg7CiAgei1pbmRleDogNTsKfQouY2MtbWQtY29weS1mZWVkYmFjayB7CiAgbWFyZ2luLWxlZnQ6IDZweDsKICBmb250LXNpemU6IDExcHg7CiAgb3BhY2l0eTogMC44NTsKICBjb2xvcjogdmFyKC0tdnNjb2RlLWZvcmVncm91bmQpOwp9Ci5jYy1tZC1jb3B5LWNvbnZlcnNhdGlvbiB7CiAgcG9zaXRpb246IGZpeGVkOwogIHJpZ2h0OiAxNnB4OwogIGJvdHRvbTogNTZweDsKICB6LWluZGV4OiAxMDsKICBwYWRkaW5nOiAycHg7CiAgYmFja2dyb3VuZDogdmFyKC0tdnNjb2RlLWVkaXRvcldpZGdldC1iYWNrZ3JvdW5kKTsKICBib3JkZXI6IDFweCBzb2xpZCB2YXIoLS12c2NvZGUtd2lkZ2V0LWJvcmRlciwgdHJhbnNwYXJlbnQpOwogIGJvcmRlci1yYWRpdXM6IDZweDsKICBvcGFjaXR5OiAwLjg1Owp9Ci5jYy1tZC1jb3B5LWNvbnZlcnNhdGlvbjpob3ZlciB7CiAgb3BhY2l0eTogMTsKfQo=").decode("utf-8") # <<>>CCWA-MD-COPY-EMBED>>> (generated by tools/gen-embeds; do not edit) -const MD_COPY_JS = "/* cc-md-copy: per-message and whole-conversation copy (markdown/plain) for the\n * Claude Code VS Code webview. Self-contained IIFE appended to webview/index.js.\n * Additive and read-only w.r.t. app state; keyed on stable CSS-module class\n * prefixes, so it fails safe (controls simply do not appear) if a prefix moves.\n * Exposes its pure functions for node unit tests; boot()s only in a real webview. */\n(function () {\n \"use strict\";\n\n var CONTROL_PREFIX = \"cc-md-copy\"; // every injected node's class starts with this\n var USER_BUBBLE = '[class*=\"userMessageContainer_\"]';\n // Assistant message wrapper. Verified on 2.1.170: the render emits exactly one\n // `data-testid=\"assistant-message\"` div per assistant turn, with the rating\n // widget and content blocks as its children. (The earlier `[data-message-rating]`\n // was WRONG: that attribute sits on the nested rating control, which is also only\n // rendered behind an experiment+analytics gate.) Re-pinned in Task 6.\n var ASSISTANT_BUBBLE = '[data-testid=\"assistant-message\"]';\n var MESSAGES_CONTAINER = '[class*=\"messagesContainer_\"]'; // e.g. '[class*=\"timeline_\"]'; \"\" -> observe document.body\n // Optional narrowing only. MUST be a single wrapper around ALL content blocks,\n // not a per-block class (a turn has multiple blocks). \"\" -> use the bubble itself\n // (already aggregates all blocks; sanitizeClone is the correctness gate).\n var ASSISTANT_CONTENT = \"\";\n var FEEDBACK_MS = 1800;\n\n // ---- HTML -> Markdown (DOM walk) -------------------------------------------\n // Uses only: nodeType, tagName, childNodes, textContent, getAttribute, className.\n function htmlToMarkdown(root) {\n // Longest run of consecutive backticks in s, so a code delimiter/fence can be\n // chosen longer than anything inside it (else ``` in the content closes early).\n function backtickRun(s) {\n var max = 0, cur = 0;\n for (var i = 0; i < s.length; i++) {\n if (s.charAt(i) === \"`\") { cur++; if (cur > max) max = cur; } else cur = 0;\n }\n return max;\n }\n function fence(s, min) { var n = backtickRun(s) + 1; if (n < min) n = min; return new Array(n + 1).join(\"`\"); }\n function inline(node) {\n var out = \"\";\n var kids = node.childNodes || [];\n for (var i = 0; i < kids.length; i++) {\n var c = kids[i];\n if (c.nodeType === 3) { out += c.textContent || \"\"; continue; }\n if (c.nodeType !== 1) continue;\n var tag = (c.tagName || \"\").toUpperCase();\n if (tag === \"BR\") out += \"\\n\";\n else if (tag === \"STRONG\" || tag === \"B\") out += \"**\" + inline(c) + \"**\";\n else if (tag === \"EM\" || tag === \"I\") out += \"*\" + inline(c) + \"*\";\n else if (tag === \"DEL\" || tag === \"S\") out += \"~~\" + inline(c) + \"~~\";\n else if (tag === \"CODE\") {\n var ct = c.textContent || \"\";\n var d = fence(ct, 1);\n // CommonMark strips one leading+trailing space, so pad when an edge is a\n // backtick to keep it from merging with the delimiter.\n var p = (ct.charAt(0) === \"`\" || ct.charAt(ct.length - 1) === \"`\") ? \" \" : \"\";\n out += d + p + ct + p + d;\n }\n else if (tag === \"A\") {\n var href = c.getAttribute ? c.getAttribute(\"href\") : null;\n var t = inline(c);\n out += href ? \"[\" + t + \"](\" + href + \")\" : t;\n } else out += inline(c); // unknown inline wrapper: keep text, drop tag\n }\n return out;\n }\n function langOf(codeEl) {\n var cls = \"\";\n if (codeEl) cls = (codeEl.getAttribute && codeEl.getAttribute(\"class\")) || codeEl.className || \"\";\n var m = /language-([A-Za-z0-9+#.\\-]+)/.exec(cls || \"\");\n return m ? m[1] : \"\";\n }\n function findChildTag(node, tag) {\n var kids = node.childNodes || [];\n for (var i = 0; i < kids.length; i++) {\n if (kids[i].nodeType === 1 && (kids[i].tagName || \"\").toUpperCase() === tag) return kids[i];\n }\n return null;\n }\n function list(node, ordered, depth) {\n var out = \"\", n = 1;\n var kids = node.childNodes || [];\n for (var i = 0; i < kids.length; i++) {\n var li = kids[i];\n if (li.nodeType !== 1 || (li.tagName || \"\").toUpperCase() !== \"LI\") continue;\n var marker = ordered ? n++ + \". \" : \"- \";\n var indent = new Array(depth + 1).join(\" \");\n var lead = \"\", nested = \"\";\n var lk = li.childNodes || [];\n for (var j = 0; j < lk.length; j++) {\n var ch = lk[j];\n var ct = ch.nodeType === 1 ? (ch.tagName || \"\").toUpperCase() : \"\";\n if (ct === \"UL\") nested += list(ch, false, depth + 1);\n else if (ct === \"OL\") nested += list(ch, true, depth + 1);\n else if (ch.nodeType === 3) lead += ch.textContent || \"\";\n else lead += inline(ch);\n }\n out += indent + marker + lead.trim() + \"\\n\" + nested;\n }\n return out;\n }\n function table(node) {\n var rows = [];\n (function collect(container) {\n var kids = container.childNodes || [];\n for (var i = 0; i < kids.length; i++) {\n var c = kids[i];\n if (c.nodeType !== 1) continue;\n var t = (c.tagName || \"\").toUpperCase();\n if (t === \"THEAD\" || t === \"TBODY\" || t === \"TFOOT\") collect(c);\n else if (t === \"TR\") {\n var cells = [], cc = c.childNodes || [];\n for (var j = 0; j < cc.length; j++) {\n var d = cc[j];\n if (d.nodeType !== 1) continue;\n var dt = (d.tagName || \"\").toUpperCase();\n if (dt === \"TH\" || dt === \"TD\") cells.push(inline(d).trim());\n }\n rows.push(cells);\n }\n }\n })(node);\n if (!rows.length) return \"\";\n var head = rows[0], body = rows.slice(1);\n var sep = head.map(function () { return \"---\"; });\n var out = \"| \" + head.join(\" | \") + \" |\\n| \" + sep.join(\" | \") + \" |\\n\";\n for (var k = 0; k < body.length; k++) out += \"| \" + body[k].join(\" | \") + \" |\\n\";\n return out;\n }\n function block(node) {\n var out = \"\";\n var kids = node.childNodes || [];\n for (var i = 0; i < kids.length; i++) {\n var c = kids[i];\n if (c.nodeType === 3) { if ((c.textContent || \"\").trim()) out += c.textContent; continue; }\n if (c.nodeType !== 1) continue;\n var tag = (c.tagName || \"\").toUpperCase();\n if (/^H[1-6]$/.test(tag)) out += new Array(+tag[1] + 1).join(\"#\") + \" \" + inline(c).trim() + \"\\n\\n\";\n else if (tag === \"P\") out += inline(c).trim() + \"\\n\\n\";\n else if (tag === \"UL\") out += list(c, false, 0) + \"\\n\";\n else if (tag === \"OL\") out += list(c, true, 0) + \"\\n\";\n else if (tag === \"PRE\") {\n var code = findChildTag(c, \"CODE\");\n var lang = langOf(code || c);\n var body = (code || c).textContent || \"\";\n var f = fence(body, 3);\n out += f + lang + \"\\n\" + body.replace(/\\n$/, \"\") + \"\\n\" + f + \"\\n\\n\";\n } else if (tag === \"BLOCKQUOTE\") {\n var inner = block(c).trim().split(\"\\n\").map(function (l) { return \"> \" + l; }).join(\"\\n\");\n out += inner + \"\\n\\n\";\n } else if (tag === \"HR\") out += \"---\\n\\n\";\n else if (tag === \"TABLE\") out += table(c) + \"\\n\";\n else if (tag === \"BR\") out += \"\\n\";\n else if (tag === \"STRONG\" || tag === \"B\" || tag === \"EM\" || tag === \"I\" ||\n tag === \"A\" || tag === \"CODE\" || tag === \"DEL\" || tag === \"S\")\n out += inline(c) + \"\\n\\n\";\n else out += block(c); // unknown wrapper: recurse (drop tag, keep content)\n }\n return out;\n }\n // block() dispatches on each CHILD's tag, treating the passed node as a plain\n // container. Wrap root in a one-off container so root's OWN tag is dispatched\n // too: callers pass either the bubble container (its block children render) or\n // a single block element like 
/
    / (now handled, not flattened).\n    return block({ childNodes: [root] }).replace(/\\n{3,}/g, \"\\n\\n\").trim();\n  }\n\n  // ---- pure helpers ----------------------------------------------------------\n  function hasPrefix(node, prefix) {\n    if (node.nodeType !== 1 || typeof node.className !== \"string\") return false;\n    var parts = node.className.split(/\\s+/);\n    for (var i = 0; i < parts.length; i++) if (parts[i].indexOf(prefix) === 0) return true;\n    return false;\n  }\n\n  // Class-prefix hooks for non-content chrome that renders *inside* an assistant\n  // bubble (verified on 2.1.170; Task 6 re-pins these). tool*/thinking_ are the v1\n  // exclusions; unknownContent_ is the renderer's fallback for unrecognized block\n  // types, so stripping it makes a *future* block type fail safe to excluded rather\n  // than leaking \"Unsupported content\" into the copy. Re-pin if a prefix moves.\n  var CHROME_PREFIXES = [\"toolUse_\", \"toolResult_\", \"toolReference_\", \"thinking_\", \"unknownContent_\"];\n\n  // True for any node that must never appear in copied output: our own controls,\n  // the rating widget (`data-message-rating` + its \"Thanks for your feedback\"\n  // text), any button (copy-code chrome), and the excluded content blocks above.\n  function isChrome(node) {\n    if (node.nodeType !== 1) return false;\n    if ((node.tagName || \"\").toUpperCase() === \"BUTTON\") return true;\n    if (node.getAttribute && node.getAttribute(\"data-message-rating\") !== null) return true;\n    if (hasPrefix(node, CONTROL_PREFIX)) return true;\n    for (var i = 0; i < CHROME_PREFIXES.length; i++) if (hasPrefix(node, CHROME_PREFIXES[i])) return true;\n    return false;\n  }\n\n  // Deep-clone `contentNode`, then strip every chrome node so copied output is the\n  // message's text content only. This is a CORRECTNESS GATE, not cosmetic: the\n  // default content node is the whole bubble (all content-block siblings, so multi-\n  // block assistant turns are captured), and this strip-list is the only thing\n  // keeping the rating widget and v1-excluded blocks out of the copy.\n  function sanitizeClone(contentNode) {\n    var clone = contentNode.cloneNode(true);\n    (function strip(node) {\n      var kids = (node.childNodes || []).slice();\n      for (var i = 0; i < kids.length; i++) {\n        var c = kids[i];\n        if (c.nodeType === 1 && isChrome(c)) { node.removeChild(c); continue; }\n        if (c.nodeType === 1) strip(c);\n      }\n    })(clone);\n    return clone;\n  }\n\n  function classifyBubble(node) {\n    if (node.nodeType !== 1) return null;\n    if (hasPrefix(node, \"userMessageContainer_\")) return \"user\";\n    if (node.getAttribute && node.getAttribute(\"data-testid\") === \"assistant-message\") return \"assistant\";\n    return null;\n  }\n\n  // Build the whole-conversation markdown from an ordered list of bubbles.\n  // `contentOf(bubble)` resolves the content node (default: the bubble itself, so\n  // every content block is included; sanitizeClone drops chrome); a default is\n  // provided for tests.\n  function conversationToMarkdown(bubbles, contentOf) {\n    contentOf = contentOf || function (b) { return b; };\n    var parts = [];\n    for (var i = 0; i < bubbles.length; i++) {\n      var role = classifyBubble(bubbles[i]);\n      if (!role) continue;\n      var clean = sanitizeClone(contentOf(bubbles[i]));\n      var body = role === \"assistant\" ? htmlToMarkdown(clean) : (clean.textContent || \"\").trim();\n      if (!body) continue;\n      parts.push((role === \"user\" ? \"## User\" : \"## Assistant\") + \"\\n\\n\" + body);\n    }\n    return parts.join(\"\\n\\n\") + (parts.length ? \"\\n\" : \"\");\n  }\n\n  // ---- exports (node tests) / boot (real webview) ----------------------------\n  if (typeof document !== \"undefined\") {\n    boot();\n  } else if (typeof module !== \"undefined\" && module.exports) {\n    module.exports = { htmlToMarkdown: htmlToMarkdown, sanitizeClone: sanitizeClone,\n                       classifyBubble: classifyBubble, conversationToMarkdown: conversationToMarkdown };\n  }\n\n  // ---- live-webview wiring (runs only when a document exists) ----------------\n  function qs(node, sel) { try { return sel && node.querySelector ? node.querySelector(sel) : null; } catch (_) { return null; } }\n  function qsa(sel) { try { return Array.prototype.slice.call(document.querySelectorAll(sel)); } catch (_) { return []; } }\n\n  // The content node to convert/copy: the optional ASSISTANT_CONTENT wrapper if\n  // pinned and present, else the bubble itself. The bubble already contains every\n  // content-block sibling of a multi-block turn, and sanitizeClone strips the\n  // chrome (rating widget, tool/thinking/unknown blocks, buttons, our controls)\n  // either way -- so this is a narrowing, never the thing that guarantees\n  // correctness.\n  function contentNodeOf(bubble, role) {\n    if (role === \"assistant\" && ASSISTANT_CONTENT) {\n      var n = qs(bubble, ASSISTANT_CONTENT);\n      if (n) return n;\n    }\n    return bubble;\n  }\n\n  function copyText(text) {\n    try {\n      if (navigator.clipboard && navigator.clipboard.writeText) return navigator.clipboard.writeText(text);\n    } catch (_) {}\n    return Promise.resolve(); // best-effort; never throw into the app\n  }\n\n  function flashFeedback(host) {\n    try {\n      var fb = document.createElement(\"span\");\n      fb.className = CONTROL_PREFIX + \"-feedback\";\n      fb.textContent = \"Copied\";\n      host.appendChild(fb);\n      setTimeout(function () { if (fb && fb.parentNode) fb.parentNode.removeChild(fb); }, FEEDBACK_MS);\n    } catch (_) {}\n  }\n\n  function bubbleMarkdown(bubble, role) {\n    var clean = sanitizeClone(contentNodeOf(bubble, role));\n    return role === \"assistant\" ? htmlToMarkdown(clean) : (clean.textContent || \"\").trim();\n  }\n  function bubblePlain(bubble, role) {\n    return (sanitizeClone(contentNodeOf(bubble, role)).textContent || \"\").trim();\n  }\n\n  // Build a single control: a primary \"Copy\" (markdown) plus a small caret that\n  // toggles a menu with \"Copy as plain text\". All nodes carry the CONTROL_PREFIX\n  // class so sanitizeClone removes them from any copied content.\n  function buildControl(onMarkdown, onPlain) {\n    var wrap = document.createElement(\"span\");\n    wrap.className = CONTROL_PREFIX;\n    var primary = document.createElement(\"button\");\n    primary.type = \"button\";\n    primary.className = CONTROL_PREFIX + \"-btn\";\n    primary.title = \"Copy as Markdown\";\n    primary.textContent = \"Copy\";\n    primary.addEventListener(\"click\", function (e) { e.stopPropagation(); onMarkdown(primary); });\n    var caret = document.createElement(\"button\");\n    caret.type = \"button\";\n    caret.className = CONTROL_PREFIX + \"-caret\";\n    caret.title = \"Copy options\";\n    caret.textContent = \"\u25be\"; // black down-pointing small triangle\n    var menu = document.createElement(\"span\");\n    menu.className = CONTROL_PREFIX + \"-menu\";\n    menu.style.display = \"none\";\n    var plain = document.createElement(\"button\");\n    plain.type = \"button\";\n    plain.className = CONTROL_PREFIX + \"-btn\";\n    plain.textContent = \"Copy as plain text\";\n    plain.addEventListener(\"click\", function (e) { e.stopPropagation(); menu.style.display = \"none\"; onPlain(plain); });\n    menu.appendChild(plain);\n    caret.addEventListener(\"click\", function (e) {\n      e.stopPropagation();\n      menu.style.display = menu.style.display === \"none\" ? \"inline-block\" : \"none\";\n    });\n    wrap.appendChild(primary);\n    wrap.appendChild(caret);\n    wrap.appendChild(menu);\n    return wrap;\n  }\n\n  function decorate(bubble) {\n    try {\n      var role = classifyBubble(bubble);\n      if (!role) return;\n      if (qs(bubble, \".\" + CONTROL_PREFIX)) return; // already decorated\n      var control = buildControl(\n        function (host) { copyText(bubbleMarkdown(bubble, role)).then(function () { flashFeedback(control); }); },\n        function (host) { copyText(bubblePlain(bubble, role)).then(function () { flashFeedback(control); }); }\n      );\n      bubble.appendChild(control);\n    } catch (_) {}\n  }\n\n  function copyConversation(format) {\n    var bubbles = qsa(USER_BUBBLE + \",\" + ASSISTANT_BUBBLE);\n    if (format === \"text\") {\n      var lines = [];\n      for (var i = 0; i < bubbles.length; i++) {\n        var role = classifyBubble(bubbles[i]);\n        if (!role) continue;\n        var body = bubblePlain(bubbles[i], role);\n        if (body) lines.push(body);\n      }\n      return copyText(lines.join(\"\\n\\n\") + (lines.length ? \"\\n\" : \"\"));\n    }\n    return copyText(conversationToMarkdown(bubbles, function (b) {\n      return contentNodeOf(b, classifyBubble(b));\n    }));\n  }\n\n  function installConversationControl() {\n    try {\n      if (qs(document, \".\" + CONTROL_PREFIX + \"-conversation\")) return;\n      var bar = document.createElement(\"div\");\n      bar.className = CONTROL_PREFIX + \"-conversation\";\n      var control = buildControl(\n        function () { copyConversation(\"markdown\").then(function () { flashFeedback(bar); }); },\n        function () { copyConversation(\"text\").then(function () { flashFeedback(bar); }); }\n      );\n      control.title = \"Copy entire conversation\";\n      bar.appendChild(control);\n      document.body.appendChild(bar); // fixed-position via CSS; placement refined in Task 6\n    } catch (_) {}\n  }\n\n  function sweep() { var b = qsa(USER_BUBBLE + \",\" + ASSISTANT_BUBBLE); for (var i = 0; i < b.length; i++) decorate(b[i]); }\n\n  function boot() {\n    try {\n      var target = (MESSAGES_CONTAINER && qs(document, MESSAGES_CONTAINER)) || document.body;\n      sweep();\n      installConversationControl();\n      if (typeof MutationObserver === \"undefined\") return;\n      var obs = new MutationObserver(function () { sweep(); });\n      obs.observe(target, { childList: true, subtree: true });\n    } catch (_) {}\n  }\n})();\n";
+const MD_COPY_JS = "/* cc-md-copy: per-message and whole-conversation copy (markdown/plain) for the\n * Claude Code VS Code webview. Self-contained IIFE appended to webview/index.js.\n * Additive and read-only w.r.t. app state; keyed on stable CSS-module class\n * prefixes, so it fails safe (controls simply do not appear) if a prefix moves.\n * Exposes its pure functions for node unit tests; boot()s only in a real webview. */\n/* Leading ';' so that, appended after the bundle, this IIFE can never be parsed as\n * a call on the bundle's final expression if it lacks a trailing semicolon (ASI\n * safety across extension builds). */\n;(function () {\n  \"use strict\";\n\n  var CONTROL_PREFIX = \"cc-md-copy\"; // every injected node's class starts with this\n  var USER_BUBBLE = '[class*=\"userMessageContainer_\"]';\n  // Assistant message wrapper. Verified on 2.1.170: the render emits exactly one\n  // `data-testid=\"assistant-message\"` div per assistant turn, with the rating\n  // widget and content blocks as its children. (The earlier `[data-message-rating]`\n  // was WRONG: that attribute sits on the nested rating control, which is also only\n  // rendered behind an experiment+analytics gate.) Re-pinned in Task 6.\n  var ASSISTANT_BUBBLE = '[data-testid=\"assistant-message\"]';\n  var MESSAGES_CONTAINER = '[class*=\"messagesContainer_\"]'; // e.g. '[class*=\"timeline_\"]'; \"\" -> observe document.body\n  // Optional narrowing only. MUST be a single wrapper around ALL content blocks,\n  // not a per-block class (a turn has multiple blocks). \"\" -> use the bubble itself\n  // (already aggregates all blocks; sanitizeClone is the correctness gate).\n  var ASSISTANT_CONTENT = \"\";\n  var FEEDBACK_MS = 1800;\n\n  // ---- HTML -> Markdown (DOM walk) -------------------------------------------\n  // Uses only: nodeType, tagName, childNodes, textContent, getAttribute, className.\n  function htmlToMarkdown(root) {\n    // Longest run of consecutive backticks in s, so a code delimiter/fence can be\n    // chosen longer than anything inside it (else ``` in the content closes early).\n    function backtickRun(s) {\n      var max = 0, cur = 0;\n      for (var i = 0; i < s.length; i++) {\n        if (s.charAt(i) === \"`\") { cur++; if (cur > max) max = cur; } else cur = 0;\n      }\n      return max;\n    }\n    function fence(s, min) { var n = backtickRun(s) + 1; if (n < min) n = min; return new Array(n + 1).join(\"`\"); }\n    function inline(node) {\n      var out = \"\";\n      var kids = node.childNodes || [];\n      for (var i = 0; i < kids.length; i++) {\n        var c = kids[i];\n        if (c.nodeType === 3) { out += c.textContent || \"\"; continue; }\n        if (c.nodeType !== 1) continue;\n        var tag = (c.tagName || \"\").toUpperCase();\n        if (tag === \"BR\") out += \"\\n\";\n        else if (tag === \"STRONG\" || tag === \"B\") out += \"**\" + inline(c) + \"**\";\n        else if (tag === \"EM\" || tag === \"I\") out += \"*\" + inline(c) + \"*\";\n        else if (tag === \"DEL\" || tag === \"S\") out += \"~~\" + inline(c) + \"~~\";\n        else if (tag === \"CODE\") {\n          var ct = c.textContent || \"\";\n          var d = fence(ct, 1);\n          // CommonMark strips one leading+trailing space, so pad when an edge is a\n          // backtick to keep it from merging with the delimiter.\n          var p = (ct.charAt(0) === \"`\" || ct.charAt(ct.length - 1) === \"`\") ? \" \" : \"\";\n          out += d + p + ct + p + d;\n        }\n        else if (tag === \"A\") {\n          var href = c.getAttribute ? c.getAttribute(\"href\") : null;\n          var t = inline(c);\n          out += href ? \"[\" + t + \"](\" + href + \")\" : t;\n        } else out += inline(c); // unknown inline wrapper: keep text, drop tag\n      }\n      return out;\n    }\n    function langOf(codeEl) {\n      var cls = \"\";\n      if (codeEl) cls = (codeEl.getAttribute && codeEl.getAttribute(\"class\")) || codeEl.className || \"\";\n      var m = /language-([A-Za-z0-9+#.\\-]+)/.exec(cls || \"\");\n      return m ? m[1] : \"\";\n    }\n    function findChildTag(node, tag) {\n      var kids = node.childNodes || [];\n      for (var i = 0; i < kids.length; i++) {\n        if (kids[i].nodeType === 1 && (kids[i].tagName || \"\").toUpperCase() === tag) return kids[i];\n      }\n      return null;\n    }\n    function list(node, ordered, depth) {\n      var out = \"\", n = 1;\n      var kids = node.childNodes || [];\n      for (var i = 0; i < kids.length; i++) {\n        var li = kids[i];\n        if (li.nodeType !== 1 || (li.tagName || \"\").toUpperCase() !== \"LI\") continue;\n        var marker = ordered ? n++ + \". \" : \"- \";\n        var indent = new Array(depth + 1).join(\"  \");\n        var lead = \"\", nested = \"\";\n        var lk = li.childNodes || [];\n        for (var j = 0; j < lk.length; j++) {\n          var ch = lk[j];\n          var ct = ch.nodeType === 1 ? (ch.tagName || \"\").toUpperCase() : \"\";\n          if (ct === \"UL\") nested += list(ch, false, depth + 1);\n          else if (ct === \"OL\") nested += list(ch, true, depth + 1);\n          else if (ch.nodeType === 3) lead += ch.textContent || \"\";\n          else lead += inline(ch);\n        }\n        out += indent + marker + lead.trim() + \"\\n\" + nested;\n      }\n      return out;\n    }\n    function table(node) {\n      var rows = [];\n      (function collect(container) {\n        var kids = container.childNodes || [];\n        for (var i = 0; i < kids.length; i++) {\n          var c = kids[i];\n          if (c.nodeType !== 1) continue;\n          var t = (c.tagName || \"\").toUpperCase();\n          if (t === \"THEAD\" || t === \"TBODY\" || t === \"TFOOT\") collect(c);\n          else if (t === \"TR\") {\n            var cells = [], cc = c.childNodes || [];\n            for (var j = 0; j < cc.length; j++) {\n              var d = cc[j];\n              if (d.nodeType !== 1) continue;\n              var dt = (d.tagName || \"\").toUpperCase();\n              if (dt === \"TH\" || dt === \"TD\") cells.push(inline(d).trim());\n            }\n            rows.push(cells);\n          }\n        }\n      })(node);\n      if (!rows.length) return \"\";\n      var head = rows[0], body = rows.slice(1);\n      var sep = head.map(function () { return \"---\"; });\n      var out = \"| \" + head.join(\" | \") + \" |\\n| \" + sep.join(\" | \") + \" |\\n\";\n      for (var k = 0; k < body.length; k++) out += \"| \" + body[k].join(\" | \") + \" |\\n\";\n      return out;\n    }\n    function block(node) {\n      var out = \"\";\n      var kids = node.childNodes || [];\n      for (var i = 0; i < kids.length; i++) {\n        var c = kids[i];\n        if (c.nodeType === 3) { if ((c.textContent || \"\").trim()) out += c.textContent; continue; }\n        if (c.nodeType !== 1) continue;\n        var tag = (c.tagName || \"\").toUpperCase();\n        if (/^H[1-6]$/.test(tag)) out += new Array(+tag[1] + 1).join(\"#\") + \" \" + inline(c).trim() + \"\\n\\n\";\n        else if (tag === \"P\") out += inline(c).trim() + \"\\n\\n\";\n        else if (tag === \"UL\") out += list(c, false, 0) + \"\\n\";\n        else if (tag === \"OL\") out += list(c, true, 0) + \"\\n\";\n        else if (tag === \"PRE\") {\n          var code = findChildTag(c, \"CODE\");\n          var lang = langOf(code || c);\n          var body = (code || c).textContent || \"\";\n          var f = fence(body, 3);\n          out += f + lang + \"\\n\" + body.replace(/\\n$/, \"\") + \"\\n\" + f + \"\\n\\n\";\n        } else if (tag === \"BLOCKQUOTE\") {\n          var inner = block(c).trim().split(\"\\n\").map(function (l) { return \"> \" + l; }).join(\"\\n\");\n          out += inner + \"\\n\\n\";\n        } else if (tag === \"HR\") out += \"---\\n\\n\";\n        else if (tag === \"TABLE\") out += table(c) + \"\\n\";\n        else if (tag === \"BR\") out += \"\\n\";\n        else if (tag === \"STRONG\" || tag === \"B\" || tag === \"EM\" || tag === \"I\" ||\n                 tag === \"A\" || tag === \"CODE\" || tag === \"DEL\" || tag === \"S\")\n          out += inline(c) + \"\\n\\n\";\n        else out += block(c); // unknown wrapper: recurse (drop tag, keep content)\n      }\n      return out;\n    }\n    // block() dispatches on each CHILD's tag, treating the passed node as a plain\n    // container. Wrap root in a one-off container so root's OWN tag is dispatched\n    // too: callers pass either the bubble container (its block children render) or\n    // a single block element like 
    /
      /
     (now handled, not flattened).\n    return block({ childNodes: [root] }).replace(/\\n{3,}/g, \"\\n\\n\").trim();\n  }\n\n  // ---- pure helpers ----------------------------------------------------------\n  function hasPrefix(node, prefix) {\n    if (node.nodeType !== 1 || typeof node.className !== \"string\") return false;\n    var parts = node.className.split(/\\s+/);\n    for (var i = 0; i < parts.length; i++) if (parts[i].indexOf(prefix) === 0) return true;\n    return false;\n  }\n\n  // Class-prefix hooks for non-content chrome that renders *inside* an assistant\n  // bubble (verified on 2.1.170; Task 6 re-pins these). tool*/thinking_ are the v1\n  // exclusions; unknownContent_ is the renderer's fallback for unrecognized block\n  // types, so stripping it makes a *future* block type fail safe to excluded rather\n  // than leaking \"Unsupported content\" into the copy. Re-pin if a prefix moves.\n  var CHROME_PREFIXES = [\"toolUse_\", \"toolResult_\", \"toolReference_\", \"thinking_\", \"unknownContent_\"];\n\n  // True for any node that must never appear in copied output: our own controls,\n  // the rating widget (`data-message-rating` + its \"Thanks for your feedback\"\n  // text), any button (copy-code chrome), and the excluded content blocks above.\n  function isChrome(node) {\n    if (node.nodeType !== 1) return false;\n    if ((node.tagName || \"\").toUpperCase() === \"BUTTON\") return true;\n    if (node.getAttribute && node.getAttribute(\"data-message-rating\") !== null) return true;\n    if (hasPrefix(node, CONTROL_PREFIX)) return true;\n    for (var i = 0; i < CHROME_PREFIXES.length; i++) if (hasPrefix(node, CHROME_PREFIXES[i])) return true;\n    return false;\n  }\n\n  // Deep-clone `contentNode`, then strip every chrome node so copied output is the\n  // message's text content only. This is a CORRECTNESS GATE, not cosmetic: the\n  // default content node is the whole bubble (all content-block siblings, so multi-\n  // block assistant turns are captured), and this strip-list is the only thing\n  // keeping the rating widget and v1-excluded blocks out of the copy.\n  function sanitizeClone(contentNode) {\n    var clone = contentNode.cloneNode(true);\n    (function strip(node) {\n      var kids = (node.childNodes || []).slice();\n      for (var i = 0; i < kids.length; i++) {\n        var c = kids[i];\n        if (c.nodeType === 1 && isChrome(c)) { node.removeChild(c); continue; }\n        if (c.nodeType === 1) strip(c);\n      }\n    })(clone);\n    return clone;\n  }\n\n  function classifyBubble(node) {\n    if (node.nodeType !== 1) return null;\n    if (hasPrefix(node, \"userMessageContainer_\")) return \"user\";\n    if (node.getAttribute && node.getAttribute(\"data-testid\") === \"assistant-message\") return \"assistant\";\n    return null;\n  }\n\n  // Build the whole-conversation markdown from an ordered list of bubbles.\n  // `contentOf(bubble)` resolves the content node (default: the bubble itself, so\n  // every content block is included; sanitizeClone drops chrome); a default is\n  // provided for tests.\n  function conversationToMarkdown(bubbles, contentOf) {\n    contentOf = contentOf || function (b) { return b; };\n    var parts = [];\n    for (var i = 0; i < bubbles.length; i++) {\n      var role = classifyBubble(bubbles[i]);\n      if (!role) continue;\n      var clean = sanitizeClone(contentOf(bubbles[i]));\n      var body = role === \"assistant\" ? htmlToMarkdown(clean) : (clean.textContent || \"\").trim();\n      if (!body) continue;\n      parts.push((role === \"user\" ? \"## User\" : \"## Assistant\") + \"\\n\\n\" + body);\n    }\n    return parts.join(\"\\n\\n\") + (parts.length ? \"\\n\" : \"\");\n  }\n\n  // ---- exports (node tests) / boot (real webview) ----------------------------\n  if (typeof document !== \"undefined\") {\n    boot();\n  } else if (typeof module !== \"undefined\" && module.exports) {\n    module.exports = { htmlToMarkdown: htmlToMarkdown, sanitizeClone: sanitizeClone,\n                       classifyBubble: classifyBubble, conversationToMarkdown: conversationToMarkdown };\n  }\n\n  // ---- live-webview wiring (runs only when a document exists) ----------------\n  function qs(node, sel) { try { return sel && node.querySelector ? node.querySelector(sel) : null; } catch (_) { return null; } }\n  function qsa(sel) { try { return Array.prototype.slice.call(document.querySelectorAll(sel)); } catch (_) { return []; } }\n\n  // The content node to convert/copy: the optional ASSISTANT_CONTENT wrapper if\n  // pinned and present, else the bubble itself. The bubble already contains every\n  // content-block sibling of a multi-block turn, and sanitizeClone strips the\n  // chrome (rating widget, tool/thinking/unknown blocks, buttons, our controls)\n  // either way -- so this is a narrowing, never the thing that guarantees\n  // correctness.\n  function contentNodeOf(bubble, role) {\n    if (role === \"assistant\" && ASSISTANT_CONTENT) {\n      var n = qs(bubble, ASSISTANT_CONTENT);\n      if (n) return n;\n    }\n    return bubble;\n  }\n\n  function copyText(text) {\n    try {\n      if (navigator.clipboard && navigator.clipboard.writeText) return navigator.clipboard.writeText(text);\n    } catch (_) {}\n    return Promise.resolve(); // best-effort; never throw into the app\n  }\n\n  function flashFeedback(host) {\n    try {\n      var fb = document.createElement(\"span\");\n      fb.className = CONTROL_PREFIX + \"-feedback\";\n      fb.textContent = \"Copied\";\n      host.appendChild(fb);\n      setTimeout(function () { if (fb && fb.parentNode) fb.parentNode.removeChild(fb); }, FEEDBACK_MS);\n    } catch (_) {}\n  }\n\n  function bubbleMarkdown(bubble, role) {\n    var clean = sanitizeClone(contentNodeOf(bubble, role));\n    return role === \"assistant\" ? htmlToMarkdown(clean) : (clean.textContent || \"\").trim();\n  }\n  function bubblePlain(bubble, role) {\n    return (sanitizeClone(contentNodeOf(bubble, role)).textContent || \"\").trim();\n  }\n\n  // Build a single control: a primary \"Copy\" (markdown) plus a small caret that\n  // toggles a menu with \"Copy as plain text\". All nodes carry the CONTROL_PREFIX\n  // class so sanitizeClone removes them from any copied content.\n  function buildControl(onMarkdown, onPlain) {\n    var wrap = document.createElement(\"span\");\n    wrap.className = CONTROL_PREFIX;\n    var primary = document.createElement(\"button\");\n    primary.type = \"button\";\n    primary.className = CONTROL_PREFIX + \"-btn\";\n    primary.title = \"Copy as Markdown\";\n    primary.textContent = \"Copy\";\n    primary.addEventListener(\"click\", function (e) { e.stopPropagation(); onMarkdown(primary); });\n    var caret = document.createElement(\"button\");\n    caret.type = \"button\";\n    caret.className = CONTROL_PREFIX + \"-caret\";\n    caret.title = \"Copy options\";\n    caret.textContent = \"\u25be\"; // black down-pointing small triangle\n    var menu = document.createElement(\"span\");\n    menu.className = CONTROL_PREFIX + \"-menu\";\n    menu.style.display = \"none\";\n    var plain = document.createElement(\"button\");\n    plain.type = \"button\";\n    plain.className = CONTROL_PREFIX + \"-btn\";\n    plain.textContent = \"Copy as plain text\";\n    plain.addEventListener(\"click\", function (e) { e.stopPropagation(); menu.style.display = \"none\"; onPlain(plain); });\n    menu.appendChild(plain);\n    caret.addEventListener(\"click\", function (e) {\n      e.stopPropagation();\n      menu.style.display = menu.style.display === \"none\" ? \"inline-block\" : \"none\";\n    });\n    wrap.appendChild(primary);\n    wrap.appendChild(caret);\n    wrap.appendChild(menu);\n    return wrap;\n  }\n\n  function decorate(bubble) {\n    try {\n      var role = classifyBubble(bubble);\n      if (!role) return;\n      if (qs(bubble, \".\" + CONTROL_PREFIX)) return; // already decorated\n      var control = buildControl(\n        function (host) { copyText(bubbleMarkdown(bubble, role)).then(function () { flashFeedback(control); }); },\n        function (host) { copyText(bubblePlain(bubble, role)).then(function () { flashFeedback(control); }); }\n      );\n      bubble.appendChild(control);\n    } catch (_) {}\n  }\n\n  function copyConversation(format) {\n    var bubbles = qsa(USER_BUBBLE + \",\" + ASSISTANT_BUBBLE);\n    if (format === \"text\") {\n      var lines = [];\n      for (var i = 0; i < bubbles.length; i++) {\n        var role = classifyBubble(bubbles[i]);\n        if (!role) continue;\n        var body = bubblePlain(bubbles[i], role);\n        if (body) lines.push(body);\n      }\n      return copyText(lines.join(\"\\n\\n\") + (lines.length ? \"\\n\" : \"\"));\n    }\n    return copyText(conversationToMarkdown(bubbles, function (b) {\n      return contentNodeOf(b, classifyBubble(b));\n    }));\n  }\n\n  function installConversationControl() {\n    try {\n      if (qs(document, \".\" + CONTROL_PREFIX + \"-conversation\")) return;\n      var bar = document.createElement(\"div\");\n      bar.className = CONTROL_PREFIX + \"-conversation\";\n      var control = buildControl(\n        function () { copyConversation(\"markdown\").then(function () { flashFeedback(bar); }); },\n        function () { copyConversation(\"text\").then(function () { flashFeedback(bar); }); }\n      );\n      control.title = \"Copy entire conversation\";\n      bar.appendChild(control);\n      document.body.appendChild(bar); // fixed-position via CSS; placement refined in Task 6\n    } catch (_) {}\n  }\n\n  function sweep() { var b = qsa(USER_BUBBLE + \",\" + ASSISTANT_BUBBLE); for (var i = 0; i < b.length; i++) decorate(b[i]); }\n\n  function boot() {\n    try {\n      var target = (MESSAGES_CONTAINER && qs(document, MESSAGES_CONTAINER)) || document.body;\n      sweep();\n      installConversationControl();\n      if (typeof MutationObserver === \"undefined\") return;\n      var obs = new MutationObserver(function () { sweep(); });\n      obs.observe(target, { childList: true, subtree: true });\n    } catch (_) {}\n  }\n})();\n";
 const MD_COPY_CSS = ".cc-md-copy {\n  display: inline-flex;\n  align-items: center;\n  gap: 2px;\n  vertical-align: middle;\n  margin-left: 6px;\n}\n.cc-md-copy-btn,\n.cc-md-copy-caret {\n  font: inherit;\n  font-size: 11px;\n  line-height: 1.4;\n  padding: 1px 6px;\n  color: var(--vscode-foreground);\n  background: transparent;\n  border: 1px solid var(--vscode-widget-border, transparent);\n  border-radius: 4px;\n  cursor: pointer;\n  opacity: 0.65;\n}\n.cc-md-copy-btn:hover,\n.cc-md-copy-caret:hover {\n  opacity: 1;\n  background: var(--vscode-toolbar-hoverBackground, rgba(128, 128, 128, 0.15));\n}\n.cc-md-copy-menu {\n  position: relative;\n  margin-left: 4px;\n  padding: 2px;\n  background: var(--vscode-menu-background, var(--vscode-editorWidget-background));\n  border: 1px solid var(--vscode-menu-border, var(--vscode-widget-border, transparent));\n  border-radius: 4px;\n  z-index: 5;\n}\n.cc-md-copy-feedback {\n  margin-left: 6px;\n  font-size: 11px;\n  opacity: 0.85;\n  color: var(--vscode-foreground);\n}\n.cc-md-copy-conversation {\n  position: fixed;\n  right: 16px;\n  bottom: 56px;\n  z-index: 10;\n  padding: 2px;\n  background: var(--vscode-editorWidget-background);\n  border: 1px solid var(--vscode-widget-border, transparent);\n  border-radius: 6px;\n  opacity: 0.85;\n}\n.cc-md-copy-conversation:hover {\n  opacity: 1;\n}\n";
 // <<