@larose/pi-web 0.3.0

package/dist/client/session.js

@@ -0,0 +1,3703 @@
+// src/client/display-title.ts
+var UNNAMED_SESSION_TITLE = "Unnamed session";
+var MAX_FALLBACK_TITLE_CHARS = 60;
+function normalizedFirstSentence(value) {
+  const normalized = value.replace(/\s+/gu, " ").trim();
+  const sentenceEnd = /[.!?。！？](?=\s|$)/u.exec(normalized);
+  return sentenceEnd ? normalized.slice(0, sentenceEnd.index + sentenceEnd[0].length) : normalized;
+}
+function boundedTitle(value) {
+  const characters = Array.from(value);
+  if (characters.length <= MAX_FALLBACK_TITLE_CHARS) {
+    return value;
+  }
+  const prefix = characters.slice(0, MAX_FALLBACK_TITLE_CHARS - 1).join("").trimEnd();
+  return `${prefix}\u2026`;
+}
+function displaySessionTitle(source) {
+  const nativeName = source.name?.trim();
+  if (nativeName) {
+    return nativeName;
+  }
+  const firstSentence = normalizedFirstSentence(source.firstMessage ?? "");
+  return firstSentence ? boundedTitle(firstSentence) : UNNAMED_SESSION_TITLE;
+}
+
+// src/client/event-stream.ts
+var defaultScheduler = {
+  setTimeout: (callback, delay) => globalThis.setTimeout(callback, delay),
+  clearTimeout: (timer) => globalThis.clearTimeout(timer)
+};
+var SessionEventStream = class {
+  createEventSource;
+  heartbeatTimeoutMs;
+  retryDelayMs;
+  scheduler;
+  onReady;
+  onRuntime;
+  onStateChange;
+  source;
+  sessionId;
+  retryTimer;
+  watchdogTimer;
+  cursor;
+  hasConnected = false;
+  ready = false;
+  constructor(options) {
+    this.createEventSource = options.createEventSource ?? ((url) => new EventSource(url));
+    this.heartbeatTimeoutMs = options.heartbeatTimeoutMs ?? 45e3;
+    this.retryDelayMs = options.retryDelayMs ?? 2e3;
+    this.scheduler = options.scheduler ?? defaultScheduler;
+    this.onReady = options.onReady;
+    this.onRuntime = options.onRuntime;
+    this.onStateChange = options.onStateChange;
+  }
+  get isReady() {
+    return this.ready;
+  }
+  start(sessionId) {
+    this.stop();
+    this.sessionId = sessionId;
+    this.open("connecting");
+  }
+  stop() {
+    this.clearRetry();
+    this.clearWatchdog();
+    this.source?.close();
+    this.source = void 0;
+    this.sessionId = void 0;
+    this.cursor = void 0;
+    this.hasConnected = false;
+    this.ready = false;
+  }
+  reconnectNow() {
+    if (!this.sessionId) {
+      return;
+    }
+    this.open("reconnecting");
+  }
+  ensureConnected() {
+    if (!this.ready) {
+      this.reconnectNow();
+    }
+  }
+  open(state) {
+    const sessionId = this.sessionId;
+    if (!sessionId) {
+      return;
+    }
+    this.clearRetry();
+    this.clearWatchdog();
+    this.source?.close();
+    this.ready = false;
+    this.onStateChange(state);
+    const path = `/api/sessions/${encodeURIComponent(sessionId)}/events`;
+    const url = this.cursor === void 0 ? path : `${path}?lastEventId=${this.cursor}`;
+    const source = this.createEventSource(url);
+    this.source = source;
+    this.watch(source);
+    source.addEventListener("ready", (rawEvent) => {
+      if (source !== this.source) {
+        return;
+      }
+      this.markActivity(source);
+      this.ready = true;
+      const recovered = this.hasConnected;
+      this.hasConnected = true;
+      this.onStateChange("connected");
+      this.onReady(rawEvent, recovered);
+    });
+    source.addEventListener("runtime", (rawEvent) => {
+      if (source !== this.source) {
+        return;
+      }
+      this.markActivity(source);
+      const event = rawEvent;
+      const cursor = Number(event.lastEventId);
+      if (event.lastEventId && Number.isSafeInteger(cursor) && cursor >= 0) {
+        this.cursor = cursor;
+      }
+      this.onRuntime(event);
+    });
+    source.addEventListener("heartbeat", () => {
+      if (source === this.source) {
+        this.markActivity(source);
+      }
+    });
+    source.onerror = () => {
+      if (source === this.source) {
+        this.fail(source);
+      }
+    };
+  }
+  fail(source) {
+    if (source !== this.source) {
+      return;
+    }
+    source.close();
+    this.source = void 0;
+    this.ready = false;
+    this.clearWatchdog();
+    this.onStateChange("reconnecting");
+    this.clearRetry();
+    this.retryTimer = this.scheduler.setTimeout(() => {
+      this.retryTimer = void 0;
+      this.open("reconnecting");
+    }, this.retryDelayMs);
+  }
+  markActivity(source) {
+    if (source !== this.source) {
+      return;
+    }
+    this.clearWatchdog();
+    this.watch(source);
+  }
+  watch(source) {
+    this.watchdogTimer = this.scheduler.setTimeout(() => {
+      this.watchdogTimer = void 0;
+      if (source === this.source) {
+        this.open("reconnecting");
+      }
+    }, this.heartbeatTimeoutMs);
+  }
+  clearRetry() {
+    if (this.retryTimer === void 0) {
+      return;
+    }
+    this.scheduler.clearTimeout(this.retryTimer);
+    this.retryTimer = void 0;
+  }
+  clearWatchdog() {
+    if (this.watchdogTimer === void 0) {
+      return;
+    }
+    this.scheduler.clearTimeout(this.watchdogTimer);
+    this.watchdogTimer = void 0;
+  }
+};
+
+// node_modules/marked/lib/marked.esm.js
+function A() {
+  return { async: false, breaks: false, extensions: null, gfm: true, hooks: null, pedantic: false, renderer: null, silent: false, tokenizer: null, walkTokens: null };
+}
+var T = A();
+function j(u3) {
+  T = u3;
+}
+var E = { exec: () => null };
+function I(u3) {
+  let e = [];
+  return (t) => {
+    let n = Math.max(0, Math.min(3, t - 1)), s = e[n];
+    return s || (s = u3(n), e[n] = s), s;
+  };
+}
+function k(u3, e = "") {
+  let t = typeof u3 == "string" ? u3 : u3.source, n = { replace: (s, r) => {
+    let o = typeof r == "string" ? r : r.source;
+    return o = o.replace(m.caret, "$1"), t = t.replace(s, o), n;
+  }, getRegex: () => new RegExp(t, e) };
+  return n;
+}
+var Te = ((u3 = "") => {
+  try {
+    return !!new RegExp("(?<=1)(?<!1)" + u3);
+  } catch {
+    return false;
+  }
+})();
+var m = { codeRemoveIndent: /^(?: {1,4}| {0,3}\t)/gm, outputLinkReplace: /\\([\[\]])/g, indentCodeCompensation: /^(\s+)(?:```)/, beginningSpace: /^\s+/, endingHash: /#$/, startingSpaceChar: /^ /, endingSpaceChar: / $/, endingSpaceTabChar: /[ \t]$/, nonSpaceChar: /[^ ]/, newLineCharGlobal: /\n/g, tabCharGlobal: /\t/g, multipleSpaceGlobal: /\s+/g, blankLine: /^[ \t]*$/, doubleBlankLine: /\n[ \t]*\n[ \t]*$/, blockquoteStart: /^ {0,3}>/, blockquoteSetextReplace: /\n {0,3}((?:=+|-+) *)(?=\n|$)/g, blockquoteSetextReplace2: /^ {0,3}>[ \t]?/gm, listReplaceNesting: /^ {1,4}(?=( {4})*[^ ])/g, listIsTask: /^\[[ xX]\] +\S/, listReplaceTask: /^\[[ xX]\] +/, listTaskCheckbox: /\[[ xX]\]/, anyLine: /\n.*\n/, hrefBrackets: /^<(.*)>$/, tableDelimiter: /[:|]/, tableAlignChars: /^\||\| *$/g, tableRowBlankLine: /\n[ \t]*$/, tableAlignRight: /^ *-+: *$/, tableAlignCenter: /^ *:-+: *$/, tableAlignLeft: /^ *:-+ *$/, startATag: /^<a /i, endATag: /^<\/a>/i, startPreScriptTag: /^<(pre|code|kbd|script)(\s|>)/i, endPreScriptTag: /^<\/(pre|code|kbd|script)(\s|>)/i, startAngleBracket: /^</, endAngleBracket: />$/, pedanticHrefTitle: /^([^'"]*[^\s])\s+(['"])(.*)\2/, unicodeAlphaNumeric: /[\p{L}\p{N}]/u, escapeTest: /[&<>"']/, escapeReplace: /[&<>"']/g, escapeTestNoEncode: /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/, escapeReplaceNoEncode: /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/g, caret: /(^|[^\[])\^/g, percentDecode: /%25/g, findPipe: /\|/g, splitPipe: / \|/, slashPipe: /\\\|/g, carriageReturn: /\r\n|\r/g, spaceLine: /^ +$/gm, notSpaceStart: /^\S*/, endingNewline: /\n$/, listItemRegex: (u3) => new RegExp(`^( {0,3}${u3})((?:[	 ][^\\n]*)?(?:\\n|$))`), nextBulletRegex: I((u3) => new RegExp(`^ {0,${u3}}(?:[*+-]|\\d{1,9}[.)])((?:[ 	][^\\n]*)?(?:\\n|$))`)), hrRegex: I((u3) => new RegExp(`^ {0,${u3}}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$)`)), fencesBeginRegex: I((u3) => new RegExp(`^ {0,${u3}}(?:\`\`\`|~~~)`)), headingBeginRegex: I((u3) => new RegExp(`^ {0,${u3}}#`)), htmlBeginRegex: I((u3) => new RegExp(`^ {0,${u3}}<(?:[a-z].*>|!--)`, "i")), blockquoteBeginRegex: I((u3) => new RegExp(`^ {0,${u3}}>`)) };
+var Oe = /^(?:[ \t]*(?:\n|$))+/;
+var we = /^((?: {4}| {0,3}\t)[^\n]+(?:\n(?:[ \t]*(?:\n|$))*)?)+/;
+var ye = /^ {0,3}(`{3,}(?=[^`\n]*(?:\n|$))|~{3,})([^\n]*)(?:\n|$)(?:|([\s\S]*?)(?:\n|$))(?: {0,3}\1[~`]* *(?=\n|$)|$)/;
+var q = /^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/;
+var Pe = /^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/;
+var U = / {0,3}(?:[*+-]|\d{1,9}[.)])/;
+var oe = /^(?!bull |blockCode|fences|blockquote|heading|html|table)((?:.|\n(?!\s*?\n|bull |blockCode|fences|blockquote|heading|html|table))+?)\n {0,3}(=+|-+) *(?:\n+|$)/;
+var ae = k(oe).replace(/bull/g, U).replace(/blockCode/g, /(?: {4}| {0,3}\t)/).replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/).replace(/blockquote/g, / {0,3}>/).replace(/heading/g, / {0,3}#{1,6}(?:\s|$)/).replace(/html/g, / {0,3}<[^\n>]+>\n/).replace(/\|table/g, "").getRegex();
+var Se = k(oe).replace(/bull/g, U).replace(/blockCode/g, /(?: {4}| {0,3}\t)/).replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/).replace(/blockquote/g, / {0,3}>/).replace(/heading/g, / {0,3}#{1,6}(?:\s|$)/).replace(/html/g, / {0,3}<[^\n>]+>\n/).replace(/table/g, / {0,3}\|?(?:[:\- ]*\|)+[\:\- ]*\n/).getRegex();
+var K = /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table|[ \t]+\n)[^\n]+)*)/;
+var _e = /^[^\n]+/;
+var W = /(?!\s*\])(?:\\[\s\S]|[^\[\]\\])+/;
+var $e = k(/^ {0,3}\[(label)\]: *(?:\n[ \t]*)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n[ \t]*)?| *\n[ \t]*)(title))? *(?:\n+|$)/).replace("label", W).replace("title", /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/).getRegex();
+var Le = k(/^(bull)([ \t][^\n]*?)?(?:\n|$)/).replace(/bull/g, U).getRegex();
+var Q = "address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|search|section|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul";
+var X = /<!--(?:-?>|[\s\S]*?(?:-->|$))/;
+var ze = k("^ {0,3}(?:<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:</\\1>[^\\n]*\\n*|$)|comment[^\\n]*(\\n+|$)|<\\?[\\s\\S]*?(?:\\?>[^\\n]*\\n*|$)|<![A-Z][\\s\\S]*?(?:>[^\\n]*\\n*|$)|<!\\[CDATA\\[[\\s\\S]*?(?:\\]\\]>[^\\n]*\\n*|$)|</?(tag)(?: +|\\n|/?>)[\\s\\S]*?(?:(?:\\n[ 	]*)+\\n|$)|<(?!script|pre|style|textarea)([a-z][a-z0-9-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ 	]*)+\\n|$)|</(?!script|pre|style|textarea)[a-z][a-z0-9-]*\\s*>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ 	]*)+\\n|$))", "i").replace("comment", X).replace("tag", Q).replace("attribute", / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex();
+var le = (u3) => k(K).replace("hr", q).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("|table", "").replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*(?:\\n|$))|~~~)[^\\n]*(?:\\n|$)").replace("list", u3).replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", Q).getRegex();
+var Ee = le(/ {0,3}(?:[*+-]|1[.)])[ \t]+[^ \t\n]/);
+var Me = le(/ {0,3}(?:[*+-]|\d{1,9}[.)])(?:[ \t]|\n|$)/);
+var Ae = k(/^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/).replace("paragraph", Me).getRegex();
+var J = { blockquote: Ae, code: we, def: $e, fences: ye, heading: Pe, hr: q, html: ze, lheading: ae, list: Le, newline: Oe, paragraph: Ee, table: E, text: _e };
+var se = k("^ *([^\\n ].*)\\n {0,3}((?:\\| *)?:?-+:? *(?:\\| *:?-+:? *)*(?:\\| *)?)(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)").replace("hr", q).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("blockquote", " {0,3}>").replace("code", "(?: {4}| {0,3}	)[^\\n]").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*(?:\\n|$))|~~~)[^\\n]*(?:\\n|$)").replace("list", " {0,3}(?:[*+-]|1[.)])[ \\t]").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", Q).getRegex();
+var Ie = { ...J, lheading: Se, table: se, paragraph: k(K).replace("hr", q).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("table", se).replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*(?:\\n|$))|~~~)[^\\n]*(?:\\n|$)").replace("list", " {0,3}(?:[*+-]|1[.)])[ \\t]+[^ \\t\\n]").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", Q).getRegex() };
+var Ce = { ...J, html: k(`^ *(?:comment *(?:\\n|\\s*$)|<(tag)[\\s\\S]+?</\\1> *(?:\\n{2,}|\\s*$)|<tag(?:"[^"]*"|'[^']*'|\\s[^'"/>\\s]*)*?/?> *(?:\\n{2,}|\\s*$))`).replace("comment", X).replace(/tag/g, "(?!(?:a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)\\b)\\w+(?!:|[^\\w\\s@]*@)\\b").getRegex(), def: /^ *\[([^\]]+)\]: *<?([^\s>]+)>?(?: +(["(][^\n]+[")]))? *(?:\n+|$)/, heading: /^(#{1,6})(.*)(?:\n+|$)/, fences: E, lheading: /^(.+?)\n {0,3}(=+|-+) *(?:\n+|$)/, paragraph: k(K).replace("hr", q).replace("heading", ` *#{1,6} *[^
+]`).replace("lheading", ae).replace("|table", "").replace("blockquote", " {0,3}>").replace("|fences", "").replace("|list", "").replace("|html", "").replace("|tag", "").getRegex() };
+var Be = /^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/;
+var De = /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/;
+var ue = /^( {2,}|\\)\n(?!\s*$)/;
+var qe = /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*_]|\b_|$)|[^ ](?= {2,}\n)))/;
+var _ = /[\p{P}\p{S}]/u;
+var C = /[\s\p{P}\p{S}]/u;
+var v = /[^\s\p{P}\p{S}]/u;
+var ve = k(/^((?![*_])punctSpace)/, "u").replace(/punctSpace/g, C).getRegex();
+var He = /[\p{Pi}\p{Ps}"']/u;
+var pe = /(?!~)[\p{P}\p{S}]/u;
+var Ze = /(?!~)[\s\p{P}\p{S}]/u;
+var Ge = /(?:[^\s\p{P}\p{S}]|~)/u;
+var Qe = k(/link|precode-code|html/, "g").replace("link", /\[(?:[^\[\]`]|(?<a>`+)[^`]+\k<a>(?!`))*?\]\((?:\\[\s\S]|[^\\\(\)]|\((?:\\[\s\S]|[^\\\(\)])*\))*\)/).replace("precode-", Te ? "(?<!`)()" : "(^^|[^`])").replace("code", /(?<b>`+)[^`]+\k<b>(?!`)/).replace("html", /<(?! )[^<>]*?>/).getRegex();
+var ce = /^(?:\*+(?:((?!\*)punct)|([^\s*]))?)|^_+(?:((?!_)punct)|([^\s_]))?/;
+var Ne = k(ce, "u").replace(/punct/g, _).getRegex();
+var je = k(ce, "u").replace(/punct/g, pe).getRegex();
+var Fe = /^(?:\*+(?:((?!\*)(?!openQuote)punct)|([^\s*]))?)|^_+(?:((?!_)(?!openQuote)punct)|([^\s_]))?/;
+var Ue = k(Fe, "u").replace(/openQuote/g, He).replace(/punct/g, _).getRegex();
+var he = "^[^_*]*?__[^_*]*?\\*[^_*]*?(?=__)|[^*]+(?=[^*])|(?!\\*)punct(\\*+)(?=[\\s]|$)|notPunctSpace(\\*+)(?!\\*)(?=punctSpace|$)|(?!\\*)punctSpace(\\*+)(?=notPunctSpace)|[\\s](\\*+)(?!\\*)(?=punct)|(?!\\*)punct(\\*+)(?!\\*)(?=punct)|notPunctSpace(\\*+)(?=notPunctSpace)";
+var Ke = k(he, "gu").replace(/notPunctSpace/g, v).replace(/punctSpace/g, C).replace(/punct/g, _).getRegex();
+var We = k(he, "gu").replace(/notPunctSpace/g, Ge).replace(/punctSpace/g, Ze).replace(/punct/g, pe).getRegex();
+var Xe = "^[^_*]*?__[^_*]*?\\*[^_*]*?(?=__)|[^*]+(?=[^*])|(?!\\*)punct(\\*+)(?=[\\s]|$)|notPunctSpace(\\*+)(?!\\*)(?=punctSpace|$)|(?!\\*)[\\s](\\*+)(?=notPunctSpace)|[\\s](\\*+)(?!\\*)(?=punct)|(?!\\*)punct(\\*+)(?!\\*)(?=punct)|(?:(?!\\*)punct|notPunctSpace)(\\*+)(?!\\*)(?=notPunctSpace)";
+var Je = k(Xe, "gu").replace(/notPunctSpace/g, v).replace(/punctSpace/g, C).replace(/punct/g, _).getRegex();
+var Ve = k("^[^_*]*?\\*\\*[^_*]*?_[^_*]*?(?=\\*\\*)|[^_]+(?=[^_])|(?!_)punct(_+)(?=[\\s]|$)|notPunctSpace(_+)(?!_)(?=punctSpace|$)|(?!_)punctSpace(_+)(?=notPunctSpace)|[\\s](_+)(?!_)(?=punct)|(?!_)punct(_+)(?!_)(?=punct)", "gu").replace(/notPunctSpace/g, v).replace(/punctSpace/g, C).replace(/punct/g, _).getRegex();
+var Ye = "^[^_*]*?\\*\\*[^_*]*?_[^_*]*?(?=\\*\\*)|[^_]+(?=[^_])|(?!_)punct(_+)(?=[\\s]|$)|notPunctSpace(_+)(?!_)(?=punctSpace|$)|(?!_)[\\s](_+)(?=notPunctSpace)|[\\s](_+)(?!_)(?=punct)|(?!_)punct(_+)(?!_)(?=punct)|(?:(?!_)punct|notPunctSpace)(_+)(?!_)(?=notPunctSpace)";
+var et = k(Ye, "gu").replace(/notPunctSpace/g, v).replace(/punctSpace/g, C).replace(/punct/g, _).getRegex();
+var tt = k(/^~~?(?:((?!~)punct)|[^\s~])/, "u").replace(/punct/g, _).getRegex();
+var nt = "^[^~]+(?=[^~])|(?!~)punct(~~?)(?=[\\s]|$)|notPunctSpace(~~?)(?!~)(?=punctSpace|$)|(?!~)punctSpace(~~?)(?=notPunctSpace)|[\\s](~~?)(?!~)(?=punct)|(?!~)punct(~~?)(?!~)(?=punct)|notPunctSpace(~~?)(?=notPunctSpace)";
+var rt = k(nt, "gu").replace(/notPunctSpace/g, v).replace(/punctSpace/g, C).replace(/punct/g, _).getRegex();
+var st = k(/\\(punct)/, "gu").replace(/punct/g, _).getRegex();
+var it = k(/^<(scheme:[^\s\x00-\x1f<>]*|email)>/).replace("scheme", /[a-zA-Z][a-zA-Z0-9+.-]{1,31}/).replace("email", /[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+(@)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?![-_])/).getRegex();
+var ot = k(X).replace("(?:-->|$)", "-->").getRegex();
+var at = k("^comment|^</[a-zA-Z][a-zA-Z0-9-]*\\s*>|^<[a-zA-Z][a-zA-Z0-9-]*(?:attribute)*?\\s*/?>|^<\\?[\\s\\S]*?\\?>|^<![a-zA-Z]+\\s[\\s\\S]*?>|^<!\\[CDATA\\[[\\s\\S]*?\\]\\]>").replace("comment", ot).replace("attribute", /\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/).getRegex();
+var lt = /\[(?:\\[\s\S]|[^\[\]\\])*\]/;
+var G = k(/(?:\[(?:brackets|\\[\s\S]|[^\[\]\\])*\]|\\[\s\S]|`+(?!`)[^`]*?`+(?!`)|``+(?=\])|[^\[\]\\`])*?/).replace("brackets", lt).getRegex();
+var ut = k(/^!?\[(label)\]\(\s*(href)(?:(?:[ \t]+(?:\n[ \t]*)?|\n[ \t]*)(title))?\s*\)/).replace("label", G).replace("href", /<(?:\\.|[^\n<>\\])+>|[^ \t\n\x00-\x1f]+|(?=\))/).replace("title", /"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/).getRegex();
+var ke = k(/^!?\[(label)\]\[(ref)\]/).replace("label", G).replace("ref", W).getRegex();
+var de = k(/^!?\[(ref)\](?:\[\])?/).replace("ref", W).getRegex();
+var pt = k("reflink|nolink(?!\\()", "g").replace("reflink", ke).replace("nolink", de).getRegex();
+var ie = /[hH][tT][tT][pP][sS]?|[fF][tT][pP]/;
+var V = { _backpedal: E, anyPunctuation: st, autolink: it, blockSkip: Qe, br: ue, code: De, del: E, delLDelim: E, delRDelim: E, emStrongLDelim: Ne, emStrongRDelimAst: Ke, emStrongRDelimUnd: Ve, escape: Be, link: ut, nolink: de, punctuation: ve, reflink: ke, reflinkSearch: pt, tag: at, text: qe, url: E };
+var ct = { ...V, emStrongLDelim: Ue, emStrongRDelimAst: Je, emStrongRDelimUnd: et, link: k(/^!?\[(label)\]\((.*?)\)/).replace("label", G).getRegex(), reflink: k(/^!?\[(label)\]\s*\[([^\]]*)\]/).replace("label", G).getRegex() };
+var F = { ...V, emStrongRDelimAst: We, emStrongLDelim: je, delLDelim: tt, delRDelim: rt, url: k(/^((?:protocol):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/).replace("protocol", ie).replace("email", /[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![\w-])/).getRegex(), _backpedal: /(?:[^?!.,:;*_'"~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_'"~)]+(?!$))+/, del: /^(~~?)(?=[^\s~])((?:\\[\s\S]|[^\\])*?(?:\\[\s\S]|[^\s~\\]))\1(?=[^~]|$)/, text: k(/^(`+|~+|[^`~])(?:(?=[`~])|(?= {2,}\n)|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)|[\s\S]*?(?:(?=[\\<!\[`*~_]|\b_|protocol:\/\/|www\.|$)|[^ ](?= {2,}\n)|[^a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-](?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)))/).replace("protocol", ie).getRegex() };
+var ht = { ...F, br: k(ue).replace("{2,}", "*").getRegex(), text: k(F.text).replace("\\b_", "\\b_| {2,}\\n").replace(/\{2,\}/g, "*").getRegex() };
+var H = { normal: J, gfm: Ie, pedantic: Ce };
+var B = { normal: V, gfm: F, breaks: ht, pedantic: ct };
+var kt = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" };
+var ge = (u3) => kt[u3];
+function R(u3, e) {
+  if (e) {
+    if (m.escapeTest.test(u3)) return u3.replace(m.escapeReplace, ge);
+  } else if (m.escapeTestNoEncode.test(u3)) return u3.replace(m.escapeReplaceNoEncode, ge);
+  return u3;
+}
+function Y(u3) {
+  try {
+    u3 = encodeURI(u3).replace(m.percentDecode, "%");
+  } catch {
+    return null;
+  }
+  return u3;
+}
+function ee(u3, e) {
+  let t = u3.replace(m.findPipe, (r, o, i) => {
+    let l = false, a = o;
+    for (; --a >= 0 && i[a] === "\\"; ) l = !l;
+    return l ? "|" : " |";
+  }), n = t.split(m.splitPipe), s = 0;
+  if (n[0].trim() || n.shift(), n.length > 0 && !n.at(-1)?.trim() && n.pop(), e) if (n.length > e) n.splice(e);
+  else for (; n.length < e; ) n.push("");
+  for (; s < n.length; s++) n[s] = n[s].trim().replace(m.slashPipe, "|");
+  return n;
+}
+function $(u3, e, t) {
+  let n = u3.length;
+  if (n === 0) return "";
+  let s = 0;
+  for (; s < n; ) {
+    let r = u3.charAt(n - s - 1);
+    if (r === e && !t) s++;
+    else if (r !== e && t) s++;
+    else break;
+  }
+  return u3.slice(0, n - s);
+}
+function te(u3) {
+  let e = u3.split(`
+`), t = e.length - 1;
+  for (; t >= 0 && m.blankLine.test(e[t]); ) t--;
+  return e.length - t <= 2 ? u3 : e.slice(0, t + 1).join(`
+`);
+}
+function fe(u3, e) {
+  if (u3.indexOf(e[1]) === -1) return -1;
+  let t = 0;
+  for (let n = 0; n < u3.length; n++) if (u3[n] === "\\") n++;
+  else if (u3[n] === e[0]) t++;
+  else if (u3[n] === e[1] && (t--, t < 0)) return n;
+  return t > 0 ? -2 : -1;
+}
+function me(u3, e = 0) {
+  let t = e, n = "";
+  for (let s of u3) if (s === "	") {
+    let r = 4 - t % 4;
+    n += " ".repeat(r), t += r;
+  } else n += s, t++;
+  return n;
+}
+function xe(u3, e, t, n, s) {
+  let r = e.href, o = e.title || null, i = u3[1].replace(s.other.outputLinkReplace, "$1"), l = u3[0].charAt(0) === "!";
+  n.state.inLink = true;
+  let a = n.state.linkEmitted, p = n.state.inRawBlock;
+  n.state.linkEmitted = false;
+  let c = n.inlineTokens(i), h = n.state.linkEmitted;
+  if (n.state.linkEmitted = a, n.state.inLink = false, !l) {
+    if (h) {
+      n.state.inRawBlock = p;
+      return;
+    }
+    n.state.linkEmitted = true;
+  }
+  return { type: l ? "image" : "link", raw: t, href: r, title: o, text: i, tokens: c };
+}
+function dt(u3, e, t) {
+  let n = u3.match(t.other.indentCodeCompensation);
+  if (n === null) return e;
+  let s = n[1];
+  return e.split(`
+`).map((r) => {
+    let o = r.match(t.other.beginningSpace);
+    if (o === null) return r;
+    let [i] = o;
+    return r.slice(Math.min(i.length, s.length));
+  }).join(`
+`);
+}
+var y = class {
+  options;
+  rules;
+  lexer;
+  constructor(e) {
+    this.options = e || T;
+  }
+  space(e) {
+    let t = this.rules.block.newline.exec(e);
+    if (t && t[0].length > 0) return { type: "space", raw: t[0] };
+  }
+  code(e) {
+    let t = this.rules.block.code.exec(e);
+    if (t) {
+      let n = this.options.pedantic ? t[0] : te(t[0]), s = n.replace(this.rules.other.codeRemoveIndent, "");
+      return { type: "code", raw: n, codeBlockStyle: "indented", text: s };
+    }
+  }
+  fences(e) {
+    let t = this.rules.block.fences.exec(e);
+    if (t) {
+      let n = t[0], s = dt(n, t[3] || "", this.rules);
+      return { type: "code", raw: n, lang: t[2] ? t[2].trim().replace(this.rules.inline.anyPunctuation, "$1") : t[2], text: s };
+    }
+  }
+  heading(e) {
+    let t = this.rules.block.heading.exec(e);
+    if (t) {
+      let n = t[2].trim();
+      if (this.rules.other.endingHash.test(n)) {
+        let s = $(n, "#");
+        (this.options.pedantic || !s || this.rules.other.endingSpaceTabChar.test(s)) && (n = s.trim());
+      }
+      return { type: "heading", raw: $(t[0], `
+`), depth: t[1].length, text: n, tokens: this.lexer.inline(n) };
+    }
+  }
+  hr(e) {
+    let t = this.rules.block.hr.exec(e);
+    if (t) return { type: "hr", raw: $(t[0], `
+`) };
+  }
+  blockquote(e) {
+    let t = this.rules.block.blockquote.exec(e);
+    if (t) {
+      let n = $(t[0], `
+`).split(`
+`), s = "", r = "", o = [];
+      for (; n.length > 0; ) {
+        let i = false, l = [], a;
+        for (a = 0; a < n.length; a++) if (this.rules.other.blockquoteStart.test(n[a])) l.push(n[a]), i = true;
+        else if (!i) l.push(n[a]);
+        else break;
+        n = n.slice(a);
+        let p = l.join(`
+`), c = p.replace(this.rules.other.blockquoteSetextReplace, `
+    $1`).replace(this.rules.other.blockquoteSetextReplace2, "");
+        s = s ? `${s}
+${p}` : p, r = r ? `${r}
+${c}` : c;
+        let h = this.lexer.state.top;
+        if (this.lexer.state.top = true, this.lexer.blockTokens(c, o, true), this.lexer.state.top = h, n.length === 0) break;
+        let d = o.at(-1);
+        if (d?.type === "code") break;
+        if (d?.type === "blockquote") {
+          let O = d, g = n.join(`
+`), w = O.raw + `
+` + g.replace(this.rules.other.blockquoteSetextReplace2, ""), z = this.blockquote(w);
+          o[o.length - 1] = z, s = `${s}
+${g}`, r = r.substring(0, r.length - O.text.length) + z.text;
+          break;
+        } else if (d?.type === "list") {
+          let O = d, g = O.raw + `
+` + n.join(`
+`), w = this.list(g);
+          o[o.length - 1] = w, s = s.substring(0, s.length - d.raw.length) + w.raw, r = r.substring(0, r.length - O.raw.length) + w.raw, n = g.substring(o.at(-1).raw.length).split(`
+`);
+          continue;
+        }
+      }
+      return { type: "blockquote", raw: s, tokens: o, text: r };
+    }
+  }
+  list(e) {
+    let t = this.rules.block.list.exec(e);
+    if (t) {
+      let n = t[1].trim(), s = n.length > 1, r = { type: "list", raw: "", ordered: s, start: s ? +n.slice(0, -1) : "", loose: false, items: [] };
+      n = s ? `\\d{1,9}\\${n.slice(-1)}` : `\\${n}`, this.options.pedantic && (n = s ? n : "[*+-]");
+      let o = this.rules.other.listItemRegex(n), i = false;
+      for (; e; ) {
+        let a = false, p = "", c = "";
+        if (!(t = o.exec(e)) || this.rules.block.hr.test(e)) break;
+        p = t[0], e = e.substring(p.length);
+        let h = me(t[2].split(`
+`, 1)[0], t[1].length), d = e.split(`
+`, 1)[0], O = !h.trim(), g = 0;
+        if (this.options.pedantic ? (g = 2, c = h.trimStart()) : O ? g = t[1].length + 1 : (g = h.search(this.rules.other.nonSpaceChar), g = g > 4 ? 1 : g, c = h.slice(g), g += t[1].length), O && this.rules.other.blankLine.test(d) && (p += d + `
+`, e = e.substring(d.length + 1), a = true), !a) {
+          let w = this.rules.other.nextBulletRegex(g), z = this.rules.other.hrRegex(g), ne = this.rules.other.fencesBeginRegex(g), re = this.rules.other.headingBeginRegex(g), be = this.rules.other.htmlBeginRegex(g), Re = this.rules.other.blockquoteBeginRegex(g);
+          for (; e; ) {
+            let N = e.split(`
+`, 1)[0], D;
+            if (d = N, this.options.pedantic ? (d = d.replace(this.rules.other.listReplaceNesting, "  "), D = d) : D = d.replace(this.rules.other.tabCharGlobal, "    "), ne.test(d) || re.test(d) || be.test(d) || Re.test(d) || w.test(d) || z.test(d)) break;
+            if (D.search(this.rules.other.nonSpaceChar) >= g || !d.trim()) c += `
+` + D.slice(g);
+            else {
+              if (O || h.replace(this.rules.other.tabCharGlobal, "    ").search(this.rules.other.nonSpaceChar) >= 4 || ne.test(h) || re.test(h) || z.test(h)) break;
+              c += `
+` + d;
+            }
+            O = !d.trim(), p += N + `
+`, e = e.substring(N.length + 1), h = D.slice(g);
+          }
+        }
+        r.loose || (i ? r.loose = true : this.rules.other.doubleBlankLine.test(p) && (i = true)), r.items.push({ type: "list_item", raw: p, task: !!this.options.gfm && this.rules.other.listIsTask.test(c), loose: false, text: c, tokens: [] }), r.raw += p;
+      }
+      let l = r.items.at(-1);
+      if (l) l.raw = l.raw.trimEnd(), l.text = l.text.trimEnd();
+      else return;
+      r.raw = r.raw.trimEnd();
+      for (let a of r.items) if (this.lexer.state.top = false, a.tokens = this.lexer.blockTokens(a.text, []), !r.loose) {
+        let p = a.tokens.filter((h) => h.type === "space"), c = p.length > 0 && p.some((h) => this.rules.other.anyLine.test(h.raw));
+        r.loose = c;
+      }
+      for (let a of r.items) {
+        let p = a.tokens[0];
+        if (a.task && (p?.type === "text" || p?.type === "paragraph")) {
+          a.text = a.text.replace(this.rules.other.listReplaceTask, ""), p.raw = p.raw.replace(this.rules.other.listReplaceTask, ""), p.text = p.text.replace(this.rules.other.listReplaceTask, "");
+          for (let h = this.lexer.inlineQueue.length - 1; h >= 0; h--) if (this.rules.other.listIsTask.test(this.lexer.inlineQueue[h].src)) {
+            this.lexer.inlineQueue[h].src = this.lexer.inlineQueue[h].src.replace(this.rules.other.listReplaceTask, "");
+            break;
+          }
+          let c = this.rules.other.listTaskCheckbox.exec(a.raw);
+          if (c) {
+            let h = { type: "checkbox", raw: c[0] + " ", checked: c[0] !== "[ ]" };
+            a.checked = h.checked, r.loose ? a.tokens[0] && ["paragraph", "text"].includes(a.tokens[0].type) && "tokens" in a.tokens[0] && a.tokens[0].tokens ? (a.tokens[0].raw = h.raw + a.tokens[0].raw, a.tokens[0].text = h.raw + a.tokens[0].text, a.tokens[0].tokens.unshift(h)) : a.tokens.unshift({ type: "paragraph", raw: h.raw, text: h.raw, tokens: [h] }) : a.tokens.unshift(h);
+          }
+        } else a.task && (a.task = false);
+      }
+      if (r.loose) for (let a of r.items) {
+        a.loose = true;
+        for (let p of a.tokens) p.type === "text" && (p.type = "paragraph");
+      }
+      return r;
+    }
+  }
+  html(e) {
+    let t = this.rules.block.html.exec(e);
+    if (t) {
+      let n = te(t[0]);
+      return { type: "html", block: true, raw: n, pre: t[1] === "pre" || t[1] === "script" || t[1] === "style", text: n };
+    }
+  }
+  def(e) {
+    let t = this.rules.block.def.exec(e);
+    if (t) {
+      let n = t[1].toLowerCase().replace(this.rules.other.multipleSpaceGlobal, " "), s = t[2] ? t[2].replace(this.rules.other.hrefBrackets, "$1").replace(this.rules.inline.anyPunctuation, "$1") : "", r = t[3] ? t[3].substring(1, t[3].length - 1).replace(this.rules.inline.anyPunctuation, "$1") : t[3];
+      return { type: "def", tag: n, raw: $(t[0], `
+`), href: s, title: r };
+    }
+  }
+  table(e) {
+    let t = this.rules.block.table.exec(e);
+    if (!t || !this.rules.other.tableDelimiter.test(t[2])) return;
+    let n = ee(t[1]), s = t[2].replace(this.rules.other.tableAlignChars, "").split("|"), r = t[3]?.trim() ? t[3].replace(this.rules.other.tableRowBlankLine, "").split(`
+`) : [], o = { type: "table", raw: $(t[0], `
+`), header: [], align: [], rows: [] };
+    if (n.length === s.length) {
+      for (let i of s) this.rules.other.tableAlignRight.test(i) ? o.align.push("right") : this.rules.other.tableAlignCenter.test(i) ? o.align.push("center") : this.rules.other.tableAlignLeft.test(i) ? o.align.push("left") : o.align.push(null);
+      for (let i = 0; i < n.length; i++) o.header.push({ text: n[i], tokens: this.lexer.inline(n[i]), header: true, align: o.align[i] });
+      for (let i of r) o.rows.push(ee(i, o.header.length).map((l, a) => ({ text: l, tokens: this.lexer.inline(l), header: false, align: o.align[a] })));
+      return o;
+    }
+  }
+  lheading(e) {
+    let t = this.rules.block.lheading.exec(e);
+    if (t) {
+      let n = t[1].trim();
+      return { type: "heading", raw: $(t[0], `
+`), depth: t[2].charAt(0) === "=" ? 1 : 2, text: n, tokens: this.lexer.inline(n) };
+    }
+  }
+  paragraph(e) {
+    let t = this.rules.block.paragraph.exec(e);
+    if (t) {
+      let n = t[1].charAt(t[1].length - 1) === `
+` ? t[1].slice(0, -1) : t[1];
+      return { type: "paragraph", raw: t[0], text: n, tokens: this.lexer.inline(n) };
+    }
+  }
+  text(e) {
+    let t = this.rules.block.text.exec(e);
+    if (t) return { type: "text", raw: t[0], text: t[0], tokens: this.lexer.inline(t[0]) };
+  }
+  escape(e) {
+    let t = this.rules.inline.escape.exec(e);
+    if (t) return { type: "escape", raw: t[0], text: t[1] };
+  }
+  tag(e) {
+    let t = this.rules.inline.tag.exec(e);
+    if (t) return !this.lexer.state.inLink && this.rules.other.startATag.test(t[0]) ? this.lexer.state.inLink = true : this.lexer.state.inLink && this.rules.other.endATag.test(t[0]) && (this.lexer.state.inLink = false), !this.lexer.state.inRawBlock && this.rules.other.startPreScriptTag.test(t[0]) ? this.lexer.state.inRawBlock = true : this.lexer.state.inRawBlock && this.rules.other.endPreScriptTag.test(t[0]) && (this.lexer.state.inRawBlock = false), { type: "html", raw: t[0], inLink: this.lexer.state.inLink, inRawBlock: this.lexer.state.inRawBlock, block: false, text: t[0] };
+  }
+  link(e) {
+    let t = this.rules.inline.link.exec(e);
+    if (t) {
+      let n = t[2].trim();
+      if (!this.options.pedantic && this.rules.other.startAngleBracket.test(n)) {
+        if (!this.rules.other.endAngleBracket.test(n)) return;
+        let o = $(n.slice(0, -1), "\\");
+        if ((n.length - o.length) % 2 === 0) return;
+      } else {
+        let o = fe(t[2], "()");
+        if (o === -2) return;
+        if (o > -1) {
+          let l = (t[0].indexOf("!") === 0 ? 5 : 4) + t[1].length + o;
+          t[2] = t[2].substring(0, o), t[0] = t[0].substring(0, l).trim(), t[3] = "";
+        }
+      }
+      let s = t[2], r = "";
+      if (this.options.pedantic) {
+        let o = this.rules.other.pedanticHrefTitle.exec(s);
+        o && (s = o[1], r = o[3]);
+      } else r = t[3] ? t[3].slice(1, -1) : "";
+      return s = s.trim(), this.rules.other.startAngleBracket.test(s) && (this.options.pedantic && !this.rules.other.endAngleBracket.test(n) ? s = s.slice(1) : s = s.slice(1, -1)), xe(t, { href: s && s.replace(this.rules.inline.anyPunctuation, "$1"), title: r && r.replace(this.rules.inline.anyPunctuation, "$1") }, t[0], this.lexer, this.rules);
+    }
+  }
+  reflink(e, t) {
+    let n;
+    if ((n = this.rules.inline.reflink.exec(e)) || (n = this.rules.inline.nolink.exec(e))) {
+      let s = (n[2] || n[1]).replace(this.rules.other.multipleSpaceGlobal, " "), r = t[s.toLowerCase()];
+      if (!r) {
+        let o = n[0].charAt(0);
+        return { type: "text", raw: o, text: o };
+      }
+      return xe(n, r, n[0], this.lexer, this.rules);
+    }
+  }
+  emStrong(e, t, n = "") {
+    let s = this.rules.inline.emStrongLDelim.exec(e);
+    if (!s || !s[1] && !s[2] && !s[3] && !s[4] || s[4] && n.match(this.rules.other.unicodeAlphaNumeric)) return;
+    if (!(s[1] || s[3] || "") || !n || this.rules.inline.punctuation.exec(n)) {
+      let o = [...s[0]].length - 1, i, l, a = o, p = 0, c = s[0][0], h = n === c, d = c === "*" ? this.rules.inline.emStrongRDelimAst : this.rules.inline.emStrongRDelimUnd;
+      for (d.lastIndex = 0, t = t.slice(-1 * e.length + o); (s = d.exec(t)) !== null; ) {
+        if (i = s[1] || s[2] || s[3] || s[4] || s[5] || s[6], !i) continue;
+        if (l = [...i].length, s[3] || s[4]) {
+          a += l;
+          continue;
+        } else if (s[5] || s[6]) {
+          if (o % 3 && !((o + l) % 3)) {
+            p += l;
+            continue;
+          }
+          if (h) break;
+        }
+        if (a -= l, a > 0) continue;
+        l = Math.min(l, l + a + p);
+        let O = [...s[0]][0].length, g = e.slice(0, o + s.index + O + l);
+        if (Math.min(o, l) % 2) {
+          let z = g.slice(1, -1);
+          return { type: "em", raw: g, text: z, tokens: this.lexer.inlineTokens(z) };
+        }
+        let w = g.slice(2, -2);
+        return { type: "strong", raw: g, text: w, tokens: this.lexer.inlineTokens(w) };
+      }
+    }
+  }
+  codespan(e) {
+    let t = this.rules.inline.code.exec(e);
+    if (t) {
+      let n = t[2].replace(this.rules.other.newLineCharGlobal, " "), s = this.rules.other.nonSpaceChar.test(n), r = this.rules.other.startingSpaceChar.test(n) && this.rules.other.endingSpaceChar.test(n);
+      return s && r && (n = n.substring(1, n.length - 1)), { type: "codespan", raw: t[0], text: n };
+    }
+  }
+  br(e) {
+    let t = this.rules.inline.br.exec(e);
+    if (t) return { type: "br", raw: t[0] };
+  }
+  del(e, t, n = "") {
+    let s = this.rules.inline.delLDelim.exec(e);
+    if (!s) return;
+    if (!(s[1] || "") || !n || this.rules.inline.punctuation.exec(n)) {
+      let o = [...s[0]].length - 1, i, l, a = o, p = this.rules.inline.delRDelim;
+      for (p.lastIndex = 0, t = t.slice(-1 * e.length + o); (s = p.exec(t)) !== null; ) {
+        if (i = s[1] || s[2] || s[3] || s[4] || s[5] || s[6], !i || (l = [...i].length, l !== o)) continue;
+        if (s[3] || s[4]) {
+          a += l;
+          continue;
+        }
+        if (a -= l, a > 0) continue;
+        l = Math.min(l, l + a);
+        let c = [...s[0]][0].length, h = e.slice(0, o + s.index + c + l), d = h.slice(o, -o);
+        return { type: "del", raw: h, text: d, tokens: this.lexer.inlineTokens(d) };
+      }
+    }
+  }
+  autolink(e) {
+    let t = this.rules.inline.autolink.exec(e);
+    if (t) {
+      let n, s;
+      return t[2] === "@" ? (n = t[1], s = "mailto:" + n) : (n = t[1], s = n), { type: "link", raw: t[0], text: n, href: s, autolink: true, tokens: [{ type: "text", raw: n, text: n }] };
+    }
+  }
+  url(e) {
+    let t;
+    if (t = this.rules.inline.url.exec(e)) {
+      let n, s;
+      if (t[2] === "@") n = t[0], s = "mailto:" + n;
+      else {
+        let r;
+        do
+          r = t[0], t[0] = this.rules.inline._backpedal.exec(t[0])?.[0] ?? "";
+        while (r !== t[0]);
+        n = t[0], t[1] === "www." ? s = "http://" + t[0] : s = t[0];
+      }
+      return { type: "link", raw: t[0], text: n, href: s, autolink: true, tokens: [{ type: "text", raw: n, text: n }] };
+    }
+  }
+  inlineText(e) {
+    let t = this.rules.inline.text.exec(e);
+    if (t) {
+      let n = this.lexer.state.inRawBlock;
+      return { type: "text", raw: t[0], text: t[0], escaped: n };
+    }
+  }
+};
+var x = class u {
+  tokens;
+  options;
+  state;
+  inlineQueue;
+  tokenizer;
+  constructor(e) {
+    this.tokens = [], this.tokens.links = /* @__PURE__ */ Object.create(null), this.options = e || T, this.options.tokenizer = this.options.tokenizer || new y(), this.tokenizer = this.options.tokenizer, this.tokenizer.options = this.options, this.tokenizer.lexer = this, this.inlineQueue = [], this.state = { inLink: false, inRawBlock: false, linkEmitted: false, top: true };
+    let t = { other: m, block: H.normal, inline: B.normal };
+    this.options.pedantic ? (t.block = H.pedantic, t.inline = B.pedantic) : this.options.gfm && (t.block = H.gfm, this.options.breaks ? t.inline = B.breaks : t.inline = B.gfm), this.tokenizer.rules = t;
+  }
+  static get rules() {
+    return { block: H, inline: B };
+  }
+  static lex(e, t) {
+    return new u(t).lex(e);
+  }
+  static lexInline(e, t) {
+    return new u(t).inlineTokens(e);
+  }
+  lex(e) {
+    e = e.replace(m.carriageReturn, `
+`), this.blockTokens(e, this.tokens);
+    for (let t = 0; t < this.inlineQueue.length; t++) {
+      let n = this.inlineQueue[t];
+      this.inlineTokens(n.src, n.tokens);
+    }
+    return this.inlineQueue = [], this.tokens;
+  }
+  blockTokens(e, t = [], n = false) {
+    this.tokenizer.lexer = this, this.options.pedantic && (e = e.replace(m.tabCharGlobal, "    ").replace(m.spaceLine, ""));
+    let s = 1 / 0;
+    for (; e; ) {
+      if (e.length < s) s = e.length;
+      else {
+        this.infiniteLoopError(e.charCodeAt(0));
+        break;
+      }
+      let r;
+      if (this.options.extensions?.block?.some((i) => (r = i.call({ lexer: this }, e, t)) ? (e = e.substring(r.raw.length), t.push(r), true) : false)) continue;
+      if (r = this.tokenizer.space(e)) {
+        e = e.substring(r.raw.length);
+        let i = t.at(-1);
+        r.raw.length === 1 && i !== void 0 ? i.raw += `
+` : t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.code(e)) {
+        e = e.substring(r.raw.length);
+        let i = t.at(-1);
+        i?.type === "paragraph" || i?.type === "text" ? (i.raw += (i.raw.endsWith(`
+`) ? "" : `
+`) + r.raw, i.text += `
+` + r.text, this.inlineQueue.at(-1).src = i.text) : t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.fences(e)) {
+        e = e.substring(r.raw.length), t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.heading(e)) {
+        e = e.substring(r.raw.length), t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.hr(e)) {
+        e = e.substring(r.raw.length), t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.blockquote(e)) {
+        e = e.substring(r.raw.length), t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.list(e)) {
+        e = e.substring(r.raw.length), t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.html(e)) {
+        e = e.substring(r.raw.length), t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.def(e)) {
+        e = e.substring(r.raw.length);
+        let i = t.at(-1);
+        i?.type === "paragraph" || i?.type === "text" ? (i.raw += (i.raw.endsWith(`
+`) ? "" : `
+`) + r.raw, i.text += `
+` + r.raw, this.inlineQueue.at(-1).src = i.text) : this.tokens.links[r.tag] || (this.tokens.links[r.tag] = { href: r.href, title: r.title }, t.push(r));
+        continue;
+      }
+      if (r = this.tokenizer.table(e)) {
+        e = e.substring(r.raw.length), t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.lheading(e)) {
+        e = e.substring(r.raw.length), t.push(r);
+        continue;
+      }
+      let o = e;
+      if (this.options.extensions?.startBlock) {
+        let i = 1 / 0, l = e.slice(1), a;
+        this.options.extensions.startBlock.forEach((p) => {
+          a = p.call({ lexer: this }, l), typeof a == "number" && a >= 0 && (i = Math.min(i, a));
+        }), i < 1 / 0 && i >= 0 && (o = e.substring(0, i + 1));
+      }
+      if (this.state.top && (r = this.tokenizer.paragraph(o))) {
+        let i = t.at(-1);
+        n && i?.type === "paragraph" ? (i.raw += (i.raw.endsWith(`
+`) ? "" : `
+`) + r.raw, i.text += `
+` + r.text, this.inlineQueue.pop(), this.inlineQueue.at(-1).src = i.text) : t.push(r), n = o.length !== e.length, e = e.substring(r.raw.length);
+        continue;
+      }
+      if (r = this.tokenizer.text(e)) {
+        e = e.substring(r.raw.length);
+        let i = t.at(-1);
+        i?.type === "text" ? (i.raw += (i.raw.endsWith(`
+`) ? "" : `
+`) + r.raw, i.text += `
+` + r.text, this.inlineQueue.pop(), this.inlineQueue.at(-1).src = i.text) : t.push(r);
+        continue;
+      }
+      if (e) {
+        this.infiniteLoopError(e.charCodeAt(0));
+        break;
+      }
+    }
+    return this.state.top = true, t;
+  }
+  inline(e, t = []) {
+    return this.inlineQueue.push({ src: e, tokens: t }), t;
+  }
+  linkInText(e) {
+    if (!e.includes("[")) return false;
+    let t = this.tokenizer.rules.inline.link;
+    for (let n of e.matchAll(this.tokenizer.rules.inline.blockSkip)) if (t.test(n[0]) && e.charAt(n.index - 1) !== "!") return true;
+    for (let n of e.matchAll(this.tokenizer.rules.inline.reflinkSearch)) {
+      let s = n[0], r = s.lastIndexOf("[");
+      if (!(s.charAt(0) === "!" || !Object.hasOwn(this.tokens.links, s.slice(r + 1, -1))) && !(r > 1 && this.linkInText(s.slice(1, r - 1)))) return true;
+    }
+    return false;
+  }
+  inlineTokens(e, t = []) {
+    this.tokenizer.lexer = this;
+    let n = e;
+    if (this.tokens.links && e.includes("[")) {
+      let i = this.tokenizer.rules.inline.reflinkSearch, l = (a) => {
+        let p = a.lastIndexOf("[");
+        if (!Object.hasOwn(this.tokens.links, a.slice(p + 1, -1))) return a;
+        if (p > 1 && a.charAt(0) !== "!") {
+          let c = a.slice(1, p - 1);
+          if (this.linkInText(c)) return "[" + c.replace(i, l) + "][" + "a".repeat(a.length - p - 2) + "]";
+        }
+        return "[" + "a".repeat(a.length - 2) + "]";
+      };
+      n = n.replace(i, l);
+    }
+    n = n.replace(this.tokenizer.rules.inline.anyPunctuation, (i) => "+".repeat(i.length)), n = n.replace(this.tokenizer.rules.inline.blockSkip, (i, l, a) => {
+      let p = a ? a.length : 0;
+      return i.slice(0, p) + "[" + "a".repeat(i.length - p - 2) + "]";
+    }), n = this.options.hooks?.emStrongMask?.call({ lexer: this }, n) ?? n;
+    let s = false, r = "", o = 1 / 0;
+    for (; e; ) {
+      if (e.length < o) o = e.length;
+      else {
+        this.infiniteLoopError(e.charCodeAt(0));
+        break;
+      }
+      s || (r = ""), s = false;
+      let i;
+      if (this.options.extensions?.inline?.some((a) => (i = a.call({ lexer: this }, e, t)) ? (e = e.substring(i.raw.length), t.push(i), true) : false)) continue;
+      if (i = this.tokenizer.escape(e)) {
+        e = e.substring(i.raw.length), t.push(i);
+        continue;
+      }
+      if (i = this.tokenizer.tag(e)) {
+        e = e.substring(i.raw.length), t.push(i);
+        continue;
+      }
+      if (i = this.tokenizer.link(e)) {
+        e = e.substring(i.raw.length), t.push(i);
+        continue;
+      }
+      if (i = this.tokenizer.reflink(e, this.tokens.links)) {
+        e = e.substring(i.raw.length);
+        let a = t.at(-1);
+        i.type === "text" && a?.type === "text" ? (a.raw += i.raw, a.text += i.text) : t.push(i);
+        continue;
+      }
+      if (i = this.tokenizer.emStrong(e, n, r)) {
+        e = e.substring(i.raw.length), t.push(i);
+        continue;
+      }
+      if (i = this.tokenizer.codespan(e)) {
+        e = e.substring(i.raw.length), t.push(i);
+        continue;
+      }
+      if (i = this.tokenizer.br(e)) {
+        e = e.substring(i.raw.length), t.push(i);
+        continue;
+      }
+      if (i = this.tokenizer.del(e, n, r)) {
+        e = e.substring(i.raw.length), t.push(i);
+        continue;
+      }
+      if (i = this.tokenizer.autolink(e)) {
+        e = e.substring(i.raw.length), t.push(i);
+        continue;
+      }
+      if (!this.state.inLink && (i = this.tokenizer.url(e))) {
+        e = e.substring(i.raw.length), t.push(i);
+        continue;
+      }
+      let l = e;
+      if (this.options.extensions?.startInline) {
+        let a = 1 / 0, p = e.slice(1), c;
+        this.options.extensions.startInline.forEach((h) => {
+          c = h.call({ lexer: this }, p), typeof c == "number" && c >= 0 && (a = Math.min(a, c));
+        }), a < 1 / 0 && a >= 0 && (l = e.substring(0, a + 1));
+      }
+      if (i = this.tokenizer.inlineText(l)) {
+        e = e.substring(i.raw.length), i.raw.slice(-1) !== "_" && (r = i.raw.slice(-1)), s = true;
+        let a = t.at(-1);
+        a?.type === "text" ? (a.raw += i.raw, a.text += i.text) : t.push(i);
+        continue;
+      }
+      if (e) {
+        this.infiniteLoopError(e.charCodeAt(0));
+        break;
+      }
+    }
+    return t;
+  }
+  infiniteLoopError(e) {
+    let t = "Infinite loop on byte: " + e;
+    if (this.options.silent) console.error(t);
+    else throw new Error(t);
+  }
+};
+var P = class {
+  options;
+  parser;
+  constructor(e) {
+    this.options = e || T;
+  }
+  space(e) {
+    return "";
+  }
+  code({ text: e, lang: t, escaped: n }) {
+    let s = (t || "").match(m.notSpaceStart)?.[0], r = e ? e.replace(m.endingNewline, "") + `
+` : "";
+    return s ? '<pre><code class="language-' + R(s) + '">' + (n ? r : R(r, true)) + `</code></pre>
+` : "<pre><code>" + (n ? r : R(r, true)) + `</code></pre>
+`;
+  }
+  blockquote({ tokens: e }) {
+    return `<blockquote>
+${this.parser.parse(e)}</blockquote>
+`;
+  }
+  html({ text: e }) {
+    return e;
+  }
+  def(e) {
+    return "";
+  }
+  heading({ tokens: e, depth: t }) {
+    return `<h${t}>${this.parser.parseInline(e)}</h${t}>
+`;
+  }
+  hr(e) {
+    return `<hr>
+`;
+  }
+  list(e) {
+    let t = e.ordered, n = e.start, s = "";
+    for (let i = 0; i < e.items.length; i++) {
+      let l = e.items[i];
+      s += this.listitem(l);
+    }
+    let r = t ? "ol" : "ul", o = t && n !== 1 ? ' start="' + n + '"' : "";
+    return "<" + r + o + `>
+` + s + "</" + r + `>
+`;
+  }
+  listitem(e) {
+    return `<li>${this.parser.parse(e.tokens)}</li>
+`;
+  }
+  checkbox({ checked: e }) {
+    return "<input " + (e ? 'checked="" ' : "") + 'disabled="" type="checkbox"> ';
+  }
+  paragraph({ tokens: e }) {
+    return `<p>${this.parser.parseInline(e)}</p>
+`;
+  }
+  table(e) {
+    let t = "", n = "";
+    for (let r = 0; r < e.header.length; r++) n += this.tablecell(e.header[r]);
+    t += this.tablerow({ text: n });
+    let s = "";
+    for (let r = 0; r < e.rows.length; r++) {
+      let o = e.rows[r];
+      n = "";
+      for (let i = 0; i < o.length; i++) n += this.tablecell(o[i]);
+      s += this.tablerow({ text: n });
+    }
+    return s && (s = `<tbody>${s}</tbody>`), `<table>
+<thead>
+` + t + `</thead>
+` + s + `</table>
+`;
+  }
+  tablerow({ text: e }) {
+    return `<tr>
+${e}</tr>
+`;
+  }
+  tablecell(e) {
+    let t = this.parser.parseInline(e.tokens), n = e.header ? "th" : "td";
+    return (e.align ? `<${n} align="${e.align}">` : `<${n}>`) + t + `</${n}>
+`;
+  }
+  strong({ tokens: e }) {
+    return `<strong>${this.parser.parseInline(e)}</strong>`;
+  }
+  em({ tokens: e }) {
+    return `<em>${this.parser.parseInline(e)}</em>`;
+  }
+  codespan({ text: e }) {
+    return `<code>${R(e, true)}</code>`;
+  }
+  br(e) {
+    return "<br>";
+  }
+  del({ tokens: e }) {
+    return `<del>${this.parser.parseInline(e)}</del>`;
+  }
+  link({ href: e, title: t, text: n, tokens: s, autolink: r }) {
+    let o = r ? R(n, true) : this.parser.parseInline(s), i = Y(e);
+    if (i === null) return o;
+    e = R(i, r);
+    let l = '<a href="' + e + '"';
+    return t && (l += ' title="' + R(t) + '"'), l += ">" + o + "</a>", l;
+  }
+  image({ href: e, title: t, text: n, tokens: s }) {
+    s && (n = this.parser.parseInline(s, this.parser.textRenderer));
+    let r = Y(e);
+    if (r === null) return R(n);
+    e = r;
+    let o = `<img src="${R(e)}" alt="${R(n)}"`;
+    return t && (o += ` title="${R(t)}"`), o += ">", o;
+  }
+  text(e) {
+    return "tokens" in e && e.tokens ? this.parser.parseInline(e.tokens) : "escaped" in e && e.escaped ? e.text : R(e.text);
+  }
+};
+var L = class {
+  strong({ text: e }) {
+    return e;
+  }
+  em({ text: e }) {
+    return e;
+  }
+  codespan({ text: e }) {
+    return e;
+  }
+  del({ text: e }) {
+    return e;
+  }
+  html({ text: e }) {
+    return e;
+  }
+  text({ text: e }) {
+    return e;
+  }
+  link({ text: e }) {
+    return "" + e;
+  }
+  image({ text: e }) {
+    return "" + e;
+  }
+  br() {
+    return "";
+  }
+  checkbox({ raw: e }) {
+    return e;
+  }
+};
+var b = class u2 {
+  options;
+  renderer;
+  textRenderer;
+  constructor(e) {
+    this.options = e || T, this.options.renderer = this.options.renderer || new P(), this.renderer = this.options.renderer, this.renderer.options = this.options, this.renderer.parser = this, this.textRenderer = new L();
+  }
+  static parse(e, t) {
+    return new u2(t).parse(e);
+  }
+  static parseInline(e, t) {
+    return new u2(t).parseInline(e);
+  }
+  parse(e) {
+    this.renderer.parser = this;
+    let t = "";
+    for (let n = 0; n < e.length; n++) {
+      let s = e[n];
+      if (this.options.extensions?.renderers?.[s.type]) {
+        let o = s, i = this.options.extensions.renderers[o.type].call({ parser: this }, o);
+        if (i !== false || !["space", "hr", "heading", "code", "table", "blockquote", "list", "checkbox", "html", "def", "paragraph", "text"].includes(o.type)) {
+          t += i || "";
+          continue;
+        }
+      }
+      let r = s;
+      switch (r.type) {
+        case "space": {
+          t += this.renderer.space(r);
+          break;
+        }
+        case "hr": {
+          t += this.renderer.hr(r);
+          break;
+        }
+        case "heading": {
+          t += this.renderer.heading(r);
+          break;
+        }
+        case "code": {
+          t += this.renderer.code(r);
+          break;
+        }
+        case "table": {
+          t += this.renderer.table(r);
+          break;
+        }
+        case "blockquote": {
+          t += this.renderer.blockquote(r);
+          break;
+        }
+        case "list": {
+          t += this.renderer.list(r);
+          break;
+        }
+        case "checkbox": {
+          t += this.renderer.checkbox(r);
+          break;
+        }
+        case "html": {
+          t += this.renderer.html(r);
+          break;
+        }
+        case "def": {
+          t += this.renderer.def(r);
+          break;
+        }
+        case "paragraph": {
+          t += this.renderer.paragraph(r);
+          break;
+        }
+        case "text": {
+          t += this.renderer.text(r);
+          break;
+        }
+        default: {
+          let o = 'Token with "' + r.type + '" type was not found.';
+          if (this.options.silent) return console.error(o), "";
+          throw new Error(o);
+        }
+      }
+    }
+    return t;
+  }
+  parseInline(e, t = this.renderer) {
+    this.renderer.parser = this;
+    let n = "";
+    for (let s = 0; s < e.length; s++) {
+      let r = e[s];
+      if (this.options.extensions?.renderers?.[r.type]) {
+        let i = this.options.extensions.renderers[r.type].call({ parser: this }, r);
+        if (i !== false || !["escape", "html", "link", "image", "checkbox", "strong", "em", "codespan", "br", "del", "text"].includes(r.type)) {
+          n += i || "";
+          continue;
+        }
+      }
+      let o = r;
+      switch (o.type) {
+        case "escape": {
+          n += t.text(o);
+          break;
+        }
+        case "html": {
+          n += t.html(o);
+          break;
+        }
+        case "link": {
+          n += t.link(o);
+          break;
+        }
+        case "image": {
+          n += t.image(o);
+          break;
+        }
+        case "checkbox": {
+          n += t.checkbox(o);
+          break;
+        }
+        case "strong": {
+          n += t.strong(o);
+          break;
+        }
+        case "em": {
+          n += t.em(o);
+          break;
+        }
+        case "codespan": {
+          n += t.codespan(o);
+          break;
+        }
+        case "br": {
+          n += t.br(o);
+          break;
+        }
+        case "del": {
+          n += t.del(o);
+          break;
+        }
+        case "text": {
+          n += t.text(o);
+          break;
+        }
+        default: {
+          let i = 'Token with "' + o.type + '" type was not found.';
+          if (this.options.silent) return console.error(i), "";
+          throw new Error(i);
+        }
+      }
+    }
+    return n;
+  }
+};
+var S = class {
+  options;
+  block;
+  constructor(e) {
+    this.options = e || T;
+  }
+  static passThroughHooks = /* @__PURE__ */ new Set(["preprocess", "postprocess", "processAllTokens", "emStrongMask"]);
+  static passThroughHooksRespectAsync = /* @__PURE__ */ new Set(["preprocess", "postprocess", "processAllTokens"]);
+  preprocess(e) {
+    return e;
+  }
+  postprocess(e) {
+    return e;
+  }
+  processAllTokens(e) {
+    return e;
+  }
+  emStrongMask(e) {
+    return e;
+  }
+  provideLexer(e = this.block) {
+    return e ? x.lex : x.lexInline;
+  }
+  provideParser(e = this.block) {
+    return e ? b.parse : b.parseInline;
+  }
+};
+var Z = class {
+  defaults = A();
+  options = this.setOptions;
+  parse = this.parseMarkdown(true);
+  parseInline = this.parseMarkdown(false);
+  Parser = b;
+  Renderer = P;
+  TextRenderer = L;
+  Lexer = x;
+  Tokenizer = y;
+  Hooks = S;
+  constructor(...e) {
+    this.use(...e);
+  }
+  walkTokens(e, t) {
+    let n = [];
+    for (let s of e) switch (n = n.concat(t.call(this, s)), s.type) {
+      case "table": {
+        let r = s;
+        for (let o of r.header) n = n.concat(this.walkTokens(o.tokens, t));
+        for (let o of r.rows) for (let i of o) n = n.concat(this.walkTokens(i.tokens, t));
+        break;
+      }
+      case "list": {
+        let r = s;
+        n = n.concat(this.walkTokens(r.items, t));
+        break;
+      }
+      default: {
+        let r = s;
+        this.defaults.extensions?.childTokens?.[r.type] ? this.defaults.extensions.childTokens[r.type].forEach((o) => {
+          let i = r[o].flat(1 / 0);
+          n = n.concat(this.walkTokens(i, t));
+        }) : r.tokens && (n = n.concat(this.walkTokens(r.tokens, t)));
+      }
+    }
+    return n;
+  }
+  use(...e) {
+    let t = this.defaults.extensions || { renderers: {}, childTokens: {} };
+    return e.forEach((n) => {
+      let s = { ...n };
+      if (s.async = this.defaults.async || s.async || false, n.extensions && (n.extensions.forEach((r) => {
+        if (!r.name) throw new Error("extension name required");
+        if ("renderer" in r) {
+          let o = t.renderers[r.name];
+          o ? t.renderers[r.name] = function(...i) {
+            let l = r.renderer.apply(this, i);
+            return l === false && (l = o.apply(this, i)), l;
+          } : t.renderers[r.name] = r.renderer;
+        }
+        if ("tokenizer" in r) {
+          if (!r.level || r.level !== "block" && r.level !== "inline") throw new Error("extension level must be 'block' or 'inline'");
+          let o = t[r.level];
+          o ? o.unshift(r.tokenizer) : t[r.level] = [r.tokenizer], r.start && (r.level === "block" ? t.startBlock ? t.startBlock.push(r.start) : t.startBlock = [r.start] : r.level === "inline" && (t.startInline ? t.startInline.push(r.start) : t.startInline = [r.start]));
+        }
+        "childTokens" in r && r.childTokens && (t.childTokens[r.name] = r.childTokens);
+      }), s.extensions = t), n.renderer) {
+        let r = this.defaults.renderer || new P(this.defaults);
+        for (let o in n.renderer) {
+          if (!(o in r)) throw new Error(`renderer '${o}' does not exist`);
+          if (["options", "parser"].includes(o)) continue;
+          let i = o, l = n.renderer[i], a = r[i];
+          r[i] = (...p) => {
+            let c = l.apply(r, p);
+            return c === false && (c = a.apply(r, p)), c || "";
+          };
+        }
+        s.renderer = r;
+      }
+      if (n.tokenizer) {
+        let r = this.defaults.tokenizer || new y(this.defaults);
+        for (let o in n.tokenizer) {
+          if (!(o in r)) throw new Error(`tokenizer '${o}' does not exist`);
+          if (["options", "rules", "lexer"].includes(o)) continue;
+          let i = o, l = n.tokenizer[i], a = r[i];
+          r[i] = (...p) => {
+            let c = l.apply(r, p);
+            return c === false && (c = a.apply(r, p)), c;
+          };
+        }
+        s.tokenizer = r;
+      }
+      if (n.hooks) {
+        let r = this.defaults.hooks || new S();
+        for (let o in n.hooks) {
+          if (!(o in r)) throw new Error(`hook '${o}' does not exist`);
+          if (["options", "block"].includes(o)) continue;
+          let i = o, l = n.hooks[i], a = r[i];
+          S.passThroughHooks.has(o) ? r[i] = (p) => {
+            if (this.defaults.async && S.passThroughHooksRespectAsync.has(o)) return (async () => {
+              let h = await l.call(r, p);
+              return a.call(r, h);
+            })();
+            let c = l.call(r, p);
+            return a.call(r, c);
+          } : r[i] = (...p) => {
+            if (this.defaults.async) return (async () => {
+              let h = await l.apply(r, p);
+              return h === false && (h = await a.apply(r, p)), h;
+            })();
+            let c = l.apply(r, p);
+            return c === false && (c = a.apply(r, p)), c;
+          };
+        }
+        s.hooks = r;
+      }
+      if (n.walkTokens) {
+        let r = this.defaults.walkTokens, o = n.walkTokens;
+        s.walkTokens = function(i) {
+          let l = [];
+          return l.push(o.call(this, i)), r && (l = l.concat(r.call(this, i))), l;
+        };
+      }
+      this.defaults = { ...this.defaults, ...s };
+    }), this;
+  }
+  setOptions(e) {
+    return this.defaults = { ...this.defaults, ...e }, this;
+  }
+  lexer(e, t) {
+    return x.lex(e, t ?? this.defaults);
+  }
+  parser(e, t) {
+    return b.parse(e, t ?? this.defaults);
+  }
+  parseMarkdown(e) {
+    return (n, s) => {
+      let r = { ...s }, o = { ...this.defaults, ...r }, i = this.onError(!!o.silent, !!o.async);
+      if (this.defaults.async === true && r.async === false) return i(new Error("marked(): The async option was set to true by an extension. Remove async: false from the parse options object to return a Promise."));
+      if (typeof n > "u" || n === null) return i(new Error("marked(): input parameter is undefined or null"));
+      if (typeof n != "string") return i(new Error("marked(): input parameter is of type " + Object.prototype.toString.call(n) + ", string expected"));
+      if (o.hooks && (o.hooks.options = o, o.hooks.block = e), o.async) return (async () => {
+        let l = o.hooks ? await o.hooks.preprocess(n) : n, p = await (o.hooks ? await o.hooks.provideLexer(e) : e ? x.lex : x.lexInline)(l, o), c = o.hooks ? await o.hooks.processAllTokens(p) : p;
+        o.walkTokens && await Promise.all(this.walkTokens(c, o.walkTokens));
+        let d = await (o.hooks ? await o.hooks.provideParser(e) : e ? b.parse : b.parseInline)(c, o);
+        return o.hooks ? await o.hooks.postprocess(d) : d;
+      })().catch(i);
+      try {
+        o.hooks && (n = o.hooks.preprocess(n));
+        let a = (o.hooks ? o.hooks.provideLexer(e) : e ? x.lex : x.lexInline)(n, o);
+        o.hooks && (a = o.hooks.processAllTokens(a)), o.walkTokens && this.walkTokens(a, o.walkTokens);
+        let c = (o.hooks ? o.hooks.provideParser(e) : e ? b.parse : b.parseInline)(a, o);
+        return o.hooks && (c = o.hooks.postprocess(c)), c;
+      } catch (l) {
+        return i(l);
+      }
+    };
+  }
+  onError(e, t) {
+    return (n) => {
+      if (n.message += `
+Please report this to https://github.com/markedjs/marked.`, e) {
+        let s = "<p>An error occurred:</p><pre>" + R(n.message + "", true) + "</pre>";
+        return t ? Promise.resolve(s) : s;
+      }
+      if (t) return Promise.reject(n);
+      throw n;
+    };
+  }
+};
+var M = new Z();
+function f(u3, e) {
+  return M.parse(u3, e);
+}
+f.options = f.setOptions = function(u3) {
+  return M.setOptions(u3), f.defaults = M.defaults, j(f.defaults), f;
+};
+f.getDefaults = A;
+f.defaults = T;
+function gt(...u3) {
+  return M.use(...u3), f.defaults = M.defaults, j(f.defaults), f;
+}
+f.use = gt;
+f.walkTokens = function(u3, e) {
+  return M.walkTokens(u3, e);
+};
+f.parseInline = M.parseInline;
+f.Parser = b;
+f.parser = b.parse;
+f.Renderer = P;
+f.TextRenderer = L;
+f.Lexer = x;
+f.lexer = x.lex;
+f.Tokenizer = y;
+f.Hooks = S;
+f.parse = f;
+var rn = f.options;
+var sn = f.setOptions;
+var on = f.walkTokens;
+var an = f.parseInline;
+var un = b.parse;
+var pn = x.lex;
+
+// src/client/markdown.ts
+var fallbackOrigin = "http://localhost";
+var safeLinkProtocols = /* @__PURE__ */ new Set(["http:", "https:", "mailto:"]);
+var safeImageProtocols = /* @__PURE__ */ new Set(["http:", "https:"]);
+function escapeHtml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+}
+function currentOrigin() {
+  return typeof window === "undefined" ? fallbackOrigin : window.location.origin;
+}
+function normalizeUrl(value, origin) {
+  try {
+    const base = new URL(origin);
+    const url = new URL(value, base);
+    return {
+      href: url.href,
+      protocol: url.protocol.toLowerCase(),
+      sameOrigin: url.origin === base.origin
+    };
+  } catch {
+    return void 0;
+  }
+}
+function titleAttribute(title) {
+  return title === null || title === void 0 ? "" : ` title="${escapeHtml(title)}"`;
+}
+function renderLink(token, origin, parseInline) {
+  const label = parseInline(token.tokens);
+  const url = normalizeUrl(token.href, origin);
+  if (!url || !safeLinkProtocols.has(url.protocol)) {
+    return `<span class="markdown-unsafe-link">${label}</span>`;
+  }
+  return `<a href="${escapeHtml(url.href)}"${titleAttribute(token.title)} target="_blank" rel="noopener noreferrer">${label}</a>`;
+}
+function renderImage(token, origin) {
+  const alt = token.text || "image";
+  const escapedAlt = escapeHtml(alt);
+  const url = normalizeUrl(token.href, origin);
+  if (!url || !safeImageProtocols.has(url.protocol)) {
+    return `<span class="markdown-image-unavailable">${escapedAlt}</span>`;
+  }
+  if (!url.sameOrigin) {
+    return `<a class="markdown-external-image" href="${escapeHtml(url.href)}"${titleAttribute(token.title)} target="_blank" rel="noopener noreferrer">Open image: ${escapedAlt}</a>`;
+  }
+  return `<img class="markdown-image" src="${escapeHtml(url.href)}" alt="${escapedAlt}"${titleAttribute(token.title)}>`;
+}
+function renderMarkdown(source, origin = currentOrigin()) {
+  try {
+    const parser = new Z({
+      async: false,
+      gfm: true,
+      renderer: {
+        html(token) {
+          return escapeHtml(token.text);
+        },
+        link(token) {
+          return renderLink(token, origin, (tokens) => this.parser.parseInline(tokens));
+        },
+        image(token) {
+          return renderImage(token, origin);
+        }
+      }
+    });
+    return parser.parse(source, { async: false });
+  } catch {
+    return `<pre class="markdown-fallback">${escapeHtml(source)}</pre>`;
+  }
+}
+
+// src/client/message-queue.ts
+function copyMessageQueue(queue) {
+  return {
+    steering: [...queue?.steering ?? []],
+    followUp: [...queue?.followUp ?? []]
+  };
+}
+function messageQueueFromEvent(event) {
+  return {
+    steering: Array.isArray(event.steering) ? event.steering.filter((message) => typeof message === "string") : [],
+    followUp: Array.isArray(event.followUp) ? event.followUp.filter((message) => typeof message === "string") : []
+  };
+}
+function removedSteeringPrefix(previous, next) {
+  const removedCount = previous.steering.length - next.steering.length;
+  if (removedCount <= 0) {
+    return [];
+  }
+  const unchangedRemainder = next.steering.every(
+    (message, index) => previous.steering[index + removedCount] === message
+  );
+  return unchangedRemainder ? previous.steering.slice(0, removedCount) : [];
+}
+function steeringQueueGrew(previous, next) {
+  if (next.steering.length <= previous.steering.length) {
+    return false;
+  }
+  return previous.steering.every((message, index) => next.steering[index] === message);
+}
+function reconcileMessageQueue(previous, next, discardRemoved = false) {
+  return {
+    queue: copyMessageQueue(next),
+    dequeuedSteering: discardRemoved ? [] : removedSteeringPrefix(previous, next)
+  };
+}
+function withoutSteeringMessage(queue, index, expectedMessage) {
+  if (!Number.isSafeInteger(index) || index < 0 || queue.steering[index] !== expectedMessage) {
+    return void 0;
+  }
+  const next = copyMessageQueue(queue);
+  next.steering.splice(index, 1);
+  return next;
+}
+
+// src/client/slash-completion.ts
+function fuzzyMatch(query, text) {
+  const queryLower = query.toLowerCase();
+  const textLower = text.toLowerCase();
+  const matchQuery = (normalizedQuery) => {
+    if (normalizedQuery.length === 0) {
+      return { matches: true, score: 0 };
+    }
+    if (normalizedQuery.length > textLower.length) {
+      return { matches: false, score: 0 };
+    }
+    let queryIndex = 0;
+    let score = 0;
+    let lastMatchIndex = -1;
+    let consecutiveMatches = 0;
+    for (let index = 0; index < textLower.length && queryIndex < normalizedQuery.length; index += 1) {
+      if (textLower[index] !== normalizedQuery[queryIndex]) {
+        continue;
+      }
+      const isWordBoundary = index === 0 || /[\s\-_./:]/.test(textLower[index - 1] ?? "");
+      if (lastMatchIndex === index - 1) {
+        consecutiveMatches += 1;
+        score -= consecutiveMatches * 5;
+      } else {
+        consecutiveMatches = 0;
+        if (lastMatchIndex >= 0) {
+          score += (index - lastMatchIndex - 1) * 2;
+        }
+      }
+      if (isWordBoundary) {
+        score -= 10;
+      }
+      score += index * 0.1;
+      lastMatchIndex = index;
+      queryIndex += 1;
+    }
+    if (queryIndex < normalizedQuery.length) {
+      return { matches: false, score: 0 };
+    }
+    if (normalizedQuery === textLower) {
+      score -= 100;
+    }
+    return { matches: true, score };
+  };
+  const primaryMatch = matchQuery(queryLower);
+  if (primaryMatch.matches) {
+    return primaryMatch;
+  }
+  const alphaNumericMatch = queryLower.match(/^(?<letters>[a-z]+)(?<digits>[0-9]+)$/);
+  const numericAlphaMatch = queryLower.match(/^(?<digits>[0-9]+)(?<letters>[a-z]+)$/);
+  const swappedQuery = alphaNumericMatch ? `${alphaNumericMatch.groups?.digits ?? ""}${alphaNumericMatch.groups?.letters ?? ""}` : numericAlphaMatch ? `${numericAlphaMatch.groups?.letters ?? ""}${numericAlphaMatch.groups?.digits ?? ""}` : "";
+  if (!swappedQuery) {
+    return primaryMatch;
+  }
+  const swappedMatch = matchQuery(swappedQuery);
+  return swappedMatch.matches ? { matches: true, score: swappedMatch.score + 5 } : primaryMatch;
+}
+function fuzzyFilter(items, query, getText) {
+  if (!query.trim()) {
+    return [...items];
+  }
+  const tokens = query.trim().split(/[\s/]+/).filter((token) => token.length > 0);
+  if (tokens.length === 0) {
+    return [...items];
+  }
+  const results = [];
+  for (const item of items) {
+    let totalScore = 0;
+    let allMatch = true;
+    for (const token of tokens) {
+      const match = fuzzyMatch(token, getText(item));
+      if (!match.matches) {
+        allMatch = false;
+        break;
+      }
+      totalScore += match.score;
+    }
+    if (allMatch) {
+      results.push({ item, totalScore });
+    }
+  }
+  results.sort((left, right) => left.totalScore - right.totalScore);
+  return results.map(({ item }) => item);
+}
+function slashCommandQuery(value) {
+  return /^\/(\S*)$/.exec(value)?.[1] ?? null;
+}
+function createSlashCompletionState(commands, value, selectedName) {
+  const query = slashCommandQuery(value);
+  if (query === null) {
+    return null;
+  }
+  const matches = fuzzyFilter(commands, query, (command) => command.name);
+  if (matches.length === 0) {
+    return null;
+  }
+  const previousIndex = selectedName === void 0 ? -1 : matches.findIndex((command) => command.name === selectedName);
+  return {
+    query,
+    matches,
+    selectedIndex: previousIndex >= 0 ? previousIndex : 0
+  };
+}
+function moveSlashCompletionSelection(state, offset) {
+  const count = state.matches.length;
+  const selectedIndex = ((state.selectedIndex + offset) % count + count) % count;
+  return { ...state, selectedIndex };
+}
+function getSlashCompletionWindow(state, maxVisible = 5) {
+  const size = Math.max(1, Math.floor(maxVisible));
+  const startIndex = Math.max(0, Math.min(state.matches.length - size, state.selectedIndex - Math.floor(size / 2)));
+  return {
+    startIndex,
+    items: state.matches.slice(startIndex, startIndex + size)
+  };
+}
+function completeSlashCommand(command) {
+  return `/${command.name} `;
+}
+
+// src/client/shared.ts
+function requiredElement(selector, root = document) {
+  const element = root.querySelector(selector);
+  if (!element) {
+    throw new Error(`Missing required element: ${selector}`);
+  }
+  return element;
+}
+function textElement(tag, className, text) {
+  const element = document.createElement(tag);
+  element.className = className;
+  element.textContent = text;
+  return element;
+}
+function readableError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function api(path, options) {
+  const response = await fetch(path, options);
+  const body = await response.json().catch(() => void 0);
+  if (!response.ok) {
+    throw new Error(body?.error?.message ?? `Request failed (${response.status})`);
+  }
+  return body;
+}
+function sessionPath(id) {
+  return `/sessions/${encodeURIComponent(id)}`;
+}
+
+// src/client/transcript-activity.ts
+var MAX_ACTIVITY_PREVIEW_CHARS = 120;
+function boundedText(value, maximum) {
+  const characters = Array.from(value);
+  if (characters.length <= maximum) {
+    return value;
+  }
+  const prefix = characters.slice(0, maximum - 1).join("").trimEnd();
+  return `${prefix}\u2026`;
+}
+function activityPreview(value) {
+  const plainText = value.replace(/\[([^\]]+)\]\([^\s)]+\)/gu, "$1").replace(/`([^`]+)`/gu, "$1").replace(/[*~]{1,3}/gu, "").replace(/^#{1,6}\s+/gmu, "");
+  const normalized = plainText.replace(/\s+/gu, " ").trim();
+  const sentenceEnd = /[.!?。！？](?=\s|$)/u.exec(normalized);
+  const sentence = sentenceEnd ? normalized.slice(0, sentenceEnd.index + sentenceEnd[0].length) : normalized;
+  return boundedText(sentence, MAX_ACTIVITY_PREVIEW_CHARS);
+}
+function toolActionLabel(toolName, completed = false) {
+  const name = typeof toolName === "string" && toolName.trim() ? toolName.trim() : "tool";
+  return `Tool \xB7 ${name}${completed ? " \xB7 done" : ""}`;
+}
+function partitionAssistantContent(content) {
+  if (!Array.isArray(content)) {
+    return {
+      activity: [],
+      responseContent: content,
+      hasResponse: content !== void 0 && content !== ""
+    };
+  }
+  const activity = [];
+  const response = [];
+  for (const part of content) {
+    if (!part || typeof part !== "object") {
+      response.push(part);
+      continue;
+    }
+    const block = part;
+    if (block.type === "thinking") {
+      activity.push({ kind: "thinking", text: typeof block.thinking === "string" ? block.thinking : "" });
+      continue;
+    }
+    if (block.type === "toolCall") {
+      activity.push({
+        kind: "toolCall",
+        name: typeof block.name === "string" && block.name.trim() ? block.name : "tool",
+        arguments: block.arguments
+      });
+      continue;
+    }
+    response.push(part);
+  }
+  return { activity, responseContent: response, hasResponse: response.length > 0 };
+}
+function appendActivityItem(group, item) {
+  group.items.push(item);
+  if (item.kind === "thinking") {
+    const preview = activityPreview(item.text);
+    if (preview) {
+      group.preview = preview;
+    }
+  } else if (item.kind === "toolCall") {
+    group.lastAction = toolActionLabel(item.name);
+  } else {
+    group.lastAction = toolActionLabel(item.message.toolName, true);
+  }
+}
+function groupTranscriptActivity(entries) {
+  const grouped = [];
+  let activity;
+  const ensureActivity = () => {
+    if (activity) {
+      return activity;
+    }
+    activity = { kind: "activity", items: [] };
+    grouped.push(activity);
+    return activity;
+  };
+  for (const entry of entries) {
+    if (entry.kind !== "message") {
+      grouped.push(entry);
+      continue;
+    }
+    const { message } = entry;
+    if (message.role === "user") {
+      activity = void 0;
+      grouped.push(entry);
+      continue;
+    }
+    if (message.role === "assistant") {
+      const partitioned = partitionAssistantContent(message.content);
+      for (const item of partitioned.activity) {
+        appendActivityItem(ensureActivity(), item);
+      }
+      if (message.stopReason === "aborted") {
+        ensureActivity().outcome = "aborted";
+      }
+      if (partitioned.hasResponse) {
+        grouped.push({
+          ...entry,
+          message: { ...message, content: partitioned.responseContent }
+        });
+      }
+      continue;
+    }
+    if (message.role === "toolResult" || message.role === "live-tool") {
+      appendActivityItem(ensureActivity(), { kind: "toolResult", message });
+      continue;
+    }
+    grouped.push(entry);
+  }
+  return grouped;
+}
+
+// src/client/usage-format.ts
+var fullNumberFormatter = new Intl.NumberFormat("en-US", { maximumFractionDigits: 0 });
+function formatCompactTokens(count) {
+  if (count < 1e3) {
+    return count.toString();
+  }
+  if (count < 1e4) {
+    return `${(count / 1e3).toFixed(1)}k`;
+  }
+  if (count < 1e6) {
+    return `${Math.round(count / 1e3)}k`;
+  }
+  if (count < 1e7) {
+    return `${(count / 1e6).toFixed(1)}M`;
+  }
+  return `${Math.round(count / 1e6)}M`;
+}
+function fullTokens(count) {
+  return `${fullNumberFormatter.format(count)} tokens`;
+}
+function punctuate(parts, fallback) {
+  return `${parts.length > 0 ? parts.join("; ") : fallback}.`;
+}
+function formatSessionUsage(usage, autoCompactionEnabled) {
+  if (!usage) {
+    return {
+      tokenLines: ["Loading\u2026"],
+      tokenAccessibleText: "Token usage is loading.",
+      context: {
+        state: "loading",
+        percentageText: "Loading\u2026",
+        capacityText: null,
+        meterPercent: null,
+        autoCompactionEnabled: false,
+        accessibleText: "Context usage is loading."
+      }
+    };
+  }
+  const tokenLines = [];
+  const tokenAccessibleParts = [];
+  const inputOutputParts = [];
+  const cacheParts = [];
+  if (usage.tokens.input) {
+    inputOutputParts.push(`In ${formatCompactTokens(usage.tokens.input)}`);
+    tokenAccessibleParts.push(`Input: ${fullTokens(usage.tokens.input)}`);
+  }
+  if (usage.tokens.output) {
+    inputOutputParts.push(`Out ${formatCompactTokens(usage.tokens.output)}`);
+    tokenAccessibleParts.push(`Output: ${fullTokens(usage.tokens.output)}`);
+  }
+  if (usage.tokens.cacheRead) {
+    cacheParts.push(`Cache read ${formatCompactTokens(usage.tokens.cacheRead)}`);
+    tokenAccessibleParts.push(`Cache read: ${fullTokens(usage.tokens.cacheRead)}`);
+  }
+  if (usage.tokens.cacheWrite) {
+    cacheParts.push(`write ${formatCompactTokens(usage.tokens.cacheWrite)}`);
+    tokenAccessibleParts.push(`Cache write: ${fullTokens(usage.tokens.cacheWrite)}`);
+  }
+  if (inputOutputParts.length > 0) {
+    tokenLines.push(inputOutputParts.join(" \xB7 "));
+  }
+  if (cacheParts.length > 0) {
+    tokenLines.push(cacheParts.join(" \xB7 "));
+  }
+  const tokenAccessibleText = punctuate(tokenAccessibleParts, "No token usage yet");
+  if (!usage.context) {
+    return {
+      tokenLines,
+      tokenAccessibleText,
+      context: {
+        state: "unavailable",
+        percentageText: "Unavailable",
+        capacityText: null,
+        meterPercent: null,
+        autoCompactionEnabled,
+        accessibleText: autoCompactionEnabled ? "Context usage unavailable; auto-compaction enabled." : "Context usage unavailable."
+      }
+    };
+  }
+  const contextWindow = formatCompactTokens(usage.context.contextWindow);
+  if (usage.context.tokens === null || usage.context.percent === null) {
+    return {
+      tokenLines,
+      tokenAccessibleText,
+      context: {
+        state: "unknown",
+        percentageText: "\u2014",
+        capacityText: `? / ${contextWindow} tokens`,
+        meterPercent: null,
+        autoCompactionEnabled,
+        accessibleText: `Context: unknown of ${fullTokens(usage.context.contextWindow)} until the next model response; auto-compaction ${autoCompactionEnabled ? "enabled" : "disabled"}.`
+      }
+    };
+  }
+  const roundedPercent = Math.round(usage.context.percent);
+  return {
+    tokenLines,
+    tokenAccessibleText,
+    context: {
+      state: "known",
+      percentageText: `${roundedPercent}% used`,
+      capacityText: `${formatCompactTokens(usage.context.tokens)} / ${contextWindow} tokens`,
+      meterPercent: Math.min(100, Math.max(0, usage.context.percent)),
+      autoCompactionEnabled,
+      accessibleText: `Context: ${fullTokens(usage.context.tokens)} of ${fullTokens(usage.context.contextWindow)} (${roundedPercent}%); auto-compaction ${autoCompactionEnabled ? "enabled" : "disabled"}.`
+    }
+  };
+}
+
+// src/client/workspace-browser.ts
+function relativePathWithin(root, candidate) {
+  const separator = root.includes("\\") && !root.includes("/") ? "\\" : "/";
+  const normalizedRoot = root.replaceAll("\\", "/").replace(/\/+$/, "") || "/";
+  const normalizedCandidate = candidate.replaceAll("\\", "/").replace(/\/+$/, "") || "/";
+  const caseInsensitive = /^[A-Za-z]:/.test(normalizedRoot);
+  const comparableRoot = caseInsensitive ? normalizedRoot.toLocaleLowerCase() : normalizedRoot;
+  const comparableCandidate = caseInsensitive ? normalizedCandidate.toLocaleLowerCase() : normalizedCandidate;
+  if (comparableCandidate === comparableRoot) {
+    return ".";
+  }
+  const rootPrefix = comparableRoot === "/" ? "/" : `${comparableRoot}/`;
+  if (!comparableCandidate.startsWith(rootPrefix)) {
+    return null;
+  }
+  return normalizedCandidate.slice(rootPrefix.length).replaceAll("/", separator);
+}
+
+// src/client/session.ts
+var elements = {
+  abort: requiredElement("[data-abort]"),
+  composer: requiredElement("[data-composer]"),
+  connection: requiredElement("[data-connection]"),
+  createSession: requiredElement("[data-create-session]"),
+  extensionPrompt: requiredElement("[data-extension-prompt]"),
+  extensionStatusItem: requiredElement("[data-extension-status-item]"),
+  extensionStatuses: requiredElement("[data-extension-statuses]"),
+  extensionWidgetsAbove: requiredElement("[data-extension-widgets-above]"),
+  extensionWidgetsBelow: requiredElement("[data-extension-widgets-below]"),
+  prompt: requiredElement("[data-prompt]"),
+  send: requiredElement("[data-send]"),
+  sessionContext: requiredElement(".session-context"),
+  sessionContextToggle: requiredElement("[data-session-context-toggle]"),
+  sessionContextUsage: requiredElement("[data-session-context-usage]"),
+  sessionModel: requiredElement("[data-session-model]"),
+  sessionTokens: requiredElement("[data-session-tokens]"),
+  sessionWorkspaceRepository: requiredElement("[data-session-workspace-repository]"),
+  sessionWorkspaceRepositoryPath: requiredElement("[data-session-workspace-repository-path]"),
+  sessionWorkspaceState: requiredElement("[data-session-workspace-state]"),
+  sessionWorkspaceWorkingDirectory: requiredElement("[data-session-workspace-working-directory]"),
+  sessionWorkspaceWorkingDirectoryPath: requiredElement("[data-session-workspace-working-directory-path]"),
+  sessionWorkspaceWorktree: requiredElement("[data-session-workspace-worktree]"),
+  sessionWorkspaceWorktreePath: requiredElement("[data-session-workspace-worktree-path]"),
+  slashCompletion: requiredElement("[data-slash-completion]"),
+  sessionTitle: requiredElement("[data-session-title]"),
+  transcript: requiredElement("[data-transcript]")
+};
+var currentSession;
+var currentRuntime = null;
+var currentSessionId;
+var liveMessage;
+var liveActivity;
+var streamBlocks = /* @__PURE__ */ new Map();
+var markdownRenderFrame;
+var pendingMarkdownBlocks = /* @__PURE__ */ new Set();
+var sending = false;
+var renaming = false;
+var extensionUI = { pending: [], statuses: [], widgets: [] };
+var renderedExtensionRequestId;
+var slashCompletion = null;
+var dismissedSlashCompletionValue;
+var reconcileSequence = 0;
+var optimisticSubmission;
+var submittedTurnAnchor;
+var submittedTurnRunwayFrame;
+var dequeuedSteering = [];
+var discardingQueue = false;
+var liveTools = /* @__PURE__ */ new Map();
+var SLASH_COMPLETION_MAX_VISIBLE = 5;
+function currentNativeName() {
+  return currentRuntime?.sessionName?.trim() || currentSession?.name?.trim() || void 0;
+}
+function updateSessionHeading() {
+  if (!currentSessionId) {
+    return;
+  }
+  const title = displaySessionTitle({
+    name: currentNativeName(),
+    firstMessage: currentSession?.firstMessage
+  });
+  const renameLabel = `Rename session title: ${title}`;
+  elements.sessionTitle.textContent = title;
+  elements.sessionTitle.title = renameLabel;
+  elements.sessionTitle.setAttribute("aria-label", renameLabel);
+  document.title = `${title} \xB7 Pi`;
+}
+function applyCurrentSessionName(name) {
+  if (currentRuntime) {
+    if (name) {
+      currentRuntime.sessionName = name;
+    } else {
+      delete currentRuntime.sessionName;
+    }
+  }
+  if (currentSession) {
+    if (name) {
+      currentSession.name = name;
+    } else {
+      delete currentSession.name;
+    }
+  }
+  updateSessionHeading();
+}
+function setConnection(label, state) {
+  elements.connection.textContent = label;
+  elements.connection.dataset.state = state;
+}
+function setSessionContextCollapsed(collapsed) {
+  const label = `${collapsed ? "Expand" : "Collapse"} session context`;
+  elements.sessionContext.classList.toggle("is-collapsed", collapsed);
+  elements.sessionContextToggle.setAttribute("aria-expanded", String(!collapsed));
+  elements.sessionContextToggle.setAttribute("aria-label", label);
+  elements.sessionContextToggle.title = label;
+}
+function resizePrompt() {
+  elements.prompt.style.height = "auto";
+  elements.prompt.style.overflowY = "hidden";
+  const styles = getComputedStyle(elements.prompt);
+  const borderHeight = Number.parseFloat(styles.borderTopWidth) + Number.parseFloat(styles.borderBottomWidth);
+  const naturalHeight = elements.prompt.scrollHeight + borderHeight;
+  elements.prompt.style.height = `${naturalHeight}px`;
+  const renderedHeight = elements.prompt.getBoundingClientRect().height;
+  elements.prompt.style.overflowY = naturalHeight > renderedHeight + 0.5 ? "auto" : "hidden";
+}
+function closeSlashCompletion(dismiss = false) {
+  if (dismiss) {
+    dismissedSlashCompletionValue = elements.prompt.value;
+  }
+  slashCompletion = null;
+  elements.slashCompletion.hidden = true;
+  elements.slashCompletion.replaceChildren();
+  elements.prompt.setAttribute("aria-expanded", "false");
+  elements.prompt.removeAttribute("aria-activedescendant");
+}
+function applySelectedSlashCompletion(submit) {
+  const command = slashCompletion?.matches[slashCompletion.selectedIndex];
+  if (!command) {
+    return;
+  }
+  setPromptValue(completeSlashCommand(command));
+  elements.prompt.setSelectionRange(elements.prompt.value.length, elements.prompt.value.length);
+  elements.prompt.focus();
+  if (submit) {
+    void sendMessage();
+  }
+}
+function renderSlashCompletion(resetSelection = false) {
+  if (elements.prompt.disabled || dismissedSlashCompletionValue === elements.prompt.value) {
+    closeSlashCompletion();
+    return;
+  }
+  const selectedName = resetSelection ? void 0 : slashCompletion?.matches[slashCompletion.selectedIndex]?.name;
+  const nextState = createSlashCompletionState(currentRuntime?.commands ?? [], elements.prompt.value, selectedName);
+  if (!nextState) {
+    closeSlashCompletion();
+    return;
+  }
+  slashCompletion = nextState;
+  const visible = getSlashCompletionWindow(nextState, SLASH_COMPLETION_MAX_VISIBLE);
+  const options = visible.items.map((command, visibleIndex) => {
+    const index = visible.startIndex + visibleIndex;
+    const selected = index === nextState.selectedIndex;
+    const option = document.createElement("button");
+    option.type = "button";
+    option.className = "slash-completion-option";
+    option.id = `slash-command-option-${index}`;
+    option.dataset.commandIndex = String(index);
+    option.setAttribute("role", "option");
+    option.setAttribute("aria-selected", String(selected));
+    const name = textElement("span", "slash-completion-name", `/${command.name}`);
+    option.append(name);
+    if (command.description) {
+      option.append(textElement("span", "slash-completion-description", command.description));
+    }
+    option.addEventListener("pointerdown", (event) => event.preventDefault());
+    option.addEventListener("click", () => {
+      if (!slashCompletion) {
+        return;
+      }
+      slashCompletion = { ...slashCompletion, selectedIndex: index };
+      applySelectedSlashCompletion(false);
+    });
+    return option;
+  });
+  elements.slashCompletion.replaceChildren(...options);
+  elements.slashCompletion.hidden = false;
+  elements.prompt.setAttribute("aria-expanded", "true");
+  elements.prompt.setAttribute("aria-activedescendant", `slash-command-option-${nextState.selectedIndex}`);
+}
+function setPromptValue(value) {
+  dismissedSlashCompletionValue = void 0;
+  elements.prompt.value = value;
+  resizePrompt();
+  renderSlashCompletion(true);
+}
+function updateControls() {
+  const selected = currentSessionId !== void 0;
+  const working = currentRuntime?.isWorking ?? false;
+  elements.prompt.disabled = !selected;
+  elements.send.disabled = !selected || sending;
+  elements.abort.disabled = !selected || !working || sending;
+  elements.sessionTitle.disabled = !selected || renaming;
+  renderSlashCompletion();
+}
+function setContextValue(element, value, title = value) {
+  element.textContent = value;
+  element.title = value ? title : "";
+}
+function setWorkspaceRow(row, path, value = "", title = value) {
+  row.hidden = !value;
+  setContextValue(path, value, title);
+}
+function setWorkspace(cwd, context) {
+  elements.sessionWorkspaceState.hidden = true;
+  setContextValue(elements.sessionWorkspaceState, "");
+  setWorkspaceRow(elements.sessionWorkspaceRepository, elements.sessionWorkspaceRepositoryPath);
+  setWorkspaceRow(elements.sessionWorkspaceWorktree, elements.sessionWorkspaceWorktreePath);
+  setWorkspaceRow(elements.sessionWorkspaceWorkingDirectory, elements.sessionWorkspaceWorkingDirectoryPath);
+  if (context === void 0) {
+    return;
+  }
+  if (context === null) {
+    elements.sessionWorkspaceState.hidden = false;
+    setContextValue(elements.sessionWorkspaceState, "Not a Git working tree");
+    setWorkspaceRow(elements.sessionWorkspaceWorkingDirectory, elements.sessionWorkspaceWorkingDirectoryPath, cwd);
+    return;
+  }
+  setWorkspaceRow(elements.sessionWorkspaceRepository, elements.sessionWorkspaceRepositoryPath, context.repositoryRoot);
+  if (context.isLinkedWorktree) {
+    const relativeWorktree = relativePathWithin(context.repositoryRoot, context.worktreeRoot);
+    const worktreePath = relativeWorktree && relativeWorktree !== "." ? relativeWorktree : context.worktreeRoot;
+    setWorkspaceRow(
+      elements.sessionWorkspaceWorktree,
+      elements.sessionWorkspaceWorktreePath,
+      worktreePath,
+      context.worktreeRoot
+    );
+  }
+  setWorkspaceRow(elements.sessionWorkspaceWorkingDirectory, elements.sessionWorkspaceWorkingDirectoryPath, cwd);
+}
+function updateSessionUsage(usage, autoCompactionEnabled = false) {
+  const formatted = formatSessionUsage(usage, autoCompactionEnabled);
+  const tokenLines = formatted.tokenLines.length > 0 ? formatted.tokenLines.map((line) => textElement("span", "session-token-line", line)) : [textElement("span", "session-token-line is-empty", "No usage yet")];
+  for (const line of tokenLines) {
+    line.setAttribute("aria-hidden", "true");
+  }
+  elements.sessionTokens.replaceChildren(...tokenLines);
+  elements.sessionTokens.title = formatted.tokenAccessibleText;
+  elements.sessionTokens.setAttribute("aria-label", formatted.tokenAccessibleText);
+  const contextVisual = document.createElement("div");
+  contextVisual.className = "session-context-usage-visual";
+  contextVisual.setAttribute("aria-hidden", "true");
+  const contextSummary = document.createElement("div");
+  contextSummary.className = "session-context-usage-summary";
+  contextSummary.append(textElement("span", "session-context-percentage", formatted.context.percentageText));
+  if (formatted.context.capacityText) {
+    contextSummary.append(textElement("span", "session-context-capacity", formatted.context.capacityText));
+  }
+  contextVisual.append(contextSummary);
+  if (formatted.context.meterPercent !== null) {
+    const meter = document.createElement("span");
+    meter.className = "session-context-meter";
+    const fill = document.createElement("span");
+    fill.className = "session-context-meter-fill";
+    fill.style.width = `${formatted.context.meterPercent}%`;
+    meter.append(fill);
+    contextVisual.append(meter);
+  }
+  if (formatted.context.autoCompactionEnabled) {
+    contextVisual.append(textElement("span", "session-context-auto", "Auto-compact enabled"));
+  }
+  elements.sessionContextUsage.dataset.state = formatted.context.state;
+  elements.sessionContextUsage.replaceChildren(contextVisual);
+  elements.sessionContextUsage.title = formatted.context.accessibleText;
+  elements.sessionContextUsage.setAttribute("aria-label", formatted.context.accessibleText);
+}
+function updateSessionContext() {
+  const runtimeModel = currentRuntime?.model;
+  const persistedModel = currentSession?.model;
+  const modelIdentifier = runtimeModel ? `${runtimeModel.provider}/${runtimeModel.id}` : persistedModel ? `${persistedModel.provider}/${persistedModel.modelId}` : "Unavailable";
+  const modelName = runtimeModel?.name.trim() || modelIdentifier;
+  const thinking = currentRuntime?.thinkingLevel ?? currentSession?.thinkingLevel ?? "off";
+  const modelValue = modelIdentifier === "Unavailable" ? modelIdentifier : `${modelName} (${thinking})`;
+  const modelTitle = modelIdentifier === "Unavailable" ? modelIdentifier : `${modelIdentifier} \xB7 Thinking level: ${thinking}`;
+  setContextValue(elements.sessionModel, modelValue, modelTitle);
+  elements.sessionModel.setAttribute(
+    "aria-label",
+    modelIdentifier === "Unavailable" ? "Model unavailable" : `Model: ${modelName}; identifier: ${modelIdentifier}; thinking level: ${thinking}`
+  );
+  updateSessionUsage(currentRuntime?.usage ?? null, currentRuntime?.autoCompactionEnabled);
+}
+function safeJson(value) {
+  try {
+    return JSON.stringify(value, null, 2) ?? String(value);
+  } catch {
+    return String(value);
+  }
+}
+function createActivityCard(group, running = false) {
+  const root = document.createElement("details");
+  root.className = "assistant-activity";
+  root.open = false;
+  root.dataset.state = running ? "running" : group?.outcome ?? "complete";
+  const summary = document.createElement("summary");
+  const icon = document.createElement("span");
+  icon.className = "assistant-activity-status";
+  icon.setAttribute("aria-hidden", "true");
+  const summaryCopy = document.createElement("span");
+  summaryCopy.className = "assistant-activity-summary-copy";
+  const title = textElement(
+    "span",
+    "assistant-activity-title",
+    group?.preview ?? (running ? "Working\u2026" : "Assistant activity")
+  );
+  const action = textElement("span", "assistant-activity-action", "");
+  action.hidden = true;
+  summaryCopy.append(title, action);
+  const statusText = textElement(
+    "span",
+    "sr-only",
+    running ? "Assistant working." : group?.outcome === "aborted" ? "Assistant work stopped." : "Assistant work complete."
+  );
+  summary.append(icon, summaryCopy, statusText);
+  const content = document.createElement("div");
+  content.className = "assistant-activity-content";
+  root.append(summary, content);
+  const card = {
+    root,
+    content,
+    title,
+    action,
+    statusText,
+    manuallyToggled: false
+  };
+  summary.addEventListener("click", () => {
+    card.manuallyToggled = true;
+  });
+  summary.addEventListener("keydown", (event) => {
+    if (event.key === "Enter" || event.key === " ") {
+      card.manuallyToggled = true;
+    }
+  });
+  if (group) {
+    for (const item of group.items) {
+      appendActivityItem2(card, item);
+    }
+    updateActivitySummary(card, group.preview, group.lastAction);
+  }
+  if (!running) {
+    card.action.hidden = true;
+  }
+  return card;
+}
+function updateActivitySummary(card, preview, action) {
+  if (preview) {
+    card.title.textContent = preview;
+  }
+  if (action) {
+    card.action.textContent = action;
+    card.action.hidden = false;
+  }
+}
+function setActivityRunning(card, running) {
+  card.root.dataset.state = running ? "running" : "complete";
+  card.statusText.textContent = running ? "Assistant working." : "Assistant work complete.";
+  if (running && card.action.textContent) {
+    card.action.hidden = false;
+  } else if (!running) {
+    card.action.hidden = true;
+  }
+}
+function setActivityAborted(card) {
+  card.root.dataset.state = "aborted";
+  card.statusText.textContent = "Assistant work stopped.";
+  card.action.hidden = true;
+  collapseActivity(card);
+}
+function collapseActivity(card) {
+  if (!card.manuallyToggled) {
+    card.root.open = false;
+  }
+}
+function appendActivityItem2(card, item, append = true) {
+  const details = document.createElement("details");
+  details.className = `assistant-activity-item ${item.kind}`;
+  const summary = document.createElement("summary");
+  const body = document.createElement("div");
+  body.className = "assistant-activity-item-content";
+  if (item.kind === "thinking") {
+    summary.textContent = "Thinking";
+    body.append(textElement("pre", "", item.text));
+    const preview = activityPreview(item.text);
+    updateActivitySummary(card, preview || void 0);
+  } else if (item.kind === "toolCall") {
+    summary.textContent = toolActionLabel(item.name);
+    body.append(textElement("pre", "", safeJson(item.arguments)));
+    updateActivitySummary(card, void 0, toolActionLabel(item.name));
+  } else {
+    summary.textContent = `Tool result \xB7 ${item.message.toolName ?? "tool"}`;
+    appendContent(body, item.message.content);
+    updateActivitySummary(card, void 0, toolActionLabel(item.message.toolName, true));
+  }
+  details.append(summary, body);
+  if (append) {
+    card.content.append(details);
+  }
+  return details;
+}
+function markdownElement(source) {
+  const element = document.createElement("div");
+  element.className = "message-text markdown-content";
+  element.innerHTML = renderMarkdown(source);
+  return element;
+}
+function appendContent(container, content, markdown = false) {
+  if (typeof content === "string") {
+    container.append(markdown ? markdownElement(content) : textElement("p", "message-text", content));
+    return;
+  }
+  if (!Array.isArray(content)) {
+    if (content !== void 0) {
+      container.append(textElement("pre", "", safeJson(content)));
+    }
+    return;
+  }
+  for (const part of content) {
+    if (!part || typeof part !== "object") {
+      if (part !== void 0 && part !== null) {
+        container.append(textElement("pre", "", safeJson(part)));
+      }
+      continue;
+    }
+    const block = part;
+    if (block.type === "text") {
+      const text = typeof block.text === "string" ? block.text : "";
+      container.append(markdown ? markdownElement(text) : textElement("p", "message-text", text));
+      continue;
+    }
+    if (block.type === "thinking") {
+      const details = document.createElement("details");
+      const summary = document.createElement("summary");
+      summary.textContent = "Thinking";
+      details.append(summary, textElement("pre", "", typeof block.thinking === "string" ? block.thinking : ""));
+      container.append(details);
+      continue;
+    }
+    if (block.type === "toolCall") {
+      const details = document.createElement("details");
+      const summary = document.createElement("summary");
+      summary.textContent = `Tool \xB7 ${String(block.name ?? "unknown")}`;
+      details.append(summary, textElement("pre", "", safeJson(block.arguments)));
+      container.append(details);
+      continue;
+    }
+    if (block.type === "image") {
+      container.append(textElement("p", "message-text", "[Image]"));
+      continue;
+    }
+    container.append(textElement("pre", "", safeJson(block)));
+  }
+}
+function createMessage(message, label) {
+  const collapsible = message.role === "toolResult" || message.role === "live-tool";
+  let root;
+  let header;
+  let content;
+  if (collapsible) {
+    root = document.createElement("details");
+    root.className = "message";
+    header = document.createElement("summary");
+    content = document.createElement("div");
+    content.className = "message-content";
+    root.append(header, content);
+  } else {
+    const template = requiredElement("#message-template");
+    const fragment = template.content.cloneNode(true);
+    root = requiredElement("article", fragment);
+    header = requiredElement("header", root);
+    content = requiredElement(".message-content", root);
+  }
+  root.classList.add(message.role);
+  if (message.isError) {
+    root.classList.add("error");
+  }
+  header.textContent = label ?? (message.role === "toolResult" ? `Tool result \xB7 ${message.toolName ?? "tool"}` : message.role === "custom" ? "extension" : message.role);
+  appendContent(content, message.content, message.role === "assistant");
+  return root;
+}
+function renderEmpty(title, description) {
+  const empty = document.createElement("div");
+  empty.className = "empty-state";
+  empty.append(textElement("strong", "", title), textElement("span", "", description));
+  elements.transcript.replaceChildren(empty);
+}
+function setSubmittedTurnAnchor(active) {
+  elements.transcript.classList.toggle("has-submitted-turn-anchor", active);
+  if (!active) {
+    elements.transcript.style.removeProperty("--submitted-turn-runway");
+  }
+}
+function updateSubmittedTurnRunway() {
+  submittedTurnRunwayFrame = void 0;
+  const turn = submittedTurnAnchor;
+  if (!turn || turn.sessionId !== currentSessionId || !turn.root.isConnected) {
+    return;
+  }
+  const transcriptRect = elements.transcript.getBoundingClientRect();
+  const rootRect = turn.root.getBoundingClientRect();
+  const scrollPadding = Number.parseFloat(getComputedStyle(elements.transcript).scrollPaddingBlockStart) || 0;
+  const rootContentTop = elements.transcript.scrollTop + rootRect.top - transcriptRect.top;
+  const anchoredScrollTop = Math.max(0, rootContentTop - scrollPadding);
+  const previousScrollTop = elements.transcript.scrollTop;
+  elements.transcript.style.setProperty("--submitted-turn-runway", "0px");
+  const naturalScrollHeight = elements.transcript.scrollHeight;
+  const runway = Math.max(0, Math.ceil(anchoredScrollTop + elements.transcript.clientHeight - naturalScrollHeight));
+  elements.transcript.style.setProperty("--submitted-turn-runway", `${runway}px`);
+  const maximumScrollTop = elements.transcript.scrollHeight - elements.transcript.clientHeight;
+  elements.transcript.scrollTop = Math.min(previousScrollTop, maximumScrollTop);
+}
+function scheduleSubmittedTurnRunwayUpdate() {
+  if (submittedTurnRunwayFrame !== void 0) {
+    return;
+  }
+  submittedTurnRunwayFrame = requestAnimationFrame(updateSubmittedTurnRunway);
+}
+function alignSubmittedTurn(root) {
+  const turn = submittedTurnAnchor;
+  if (!turn || turn.sessionId !== currentSessionId) {
+    return;
+  }
+  turn.root = root;
+  updateSubmittedTurnRunway();
+  if (!turn.needsAlignment) {
+    return;
+  }
+  root.scrollIntoView({ block: "start" });
+  turn.needsAlignment = false;
+}
+function insertBeforePendingQueue(node) {
+  const firstPending = elements.transcript.querySelector("[data-pending-steering]");
+  elements.transcript.insertBefore(node, firstPending);
+}
+function renderPendingQueue() {
+  for (const pending of elements.transcript.querySelectorAll("[data-pending-steering]")) {
+    pending.remove();
+  }
+  const messages = currentRuntime?.queue.steering ?? [];
+  if (messages.length === 0) {
+    return;
+  }
+  elements.transcript.querySelector(".empty-state")?.remove();
+  messages.forEach((message, index) => {
+    const root = createMessage({ role: "user", content: message });
+    root.classList.add("pending");
+    root.dataset.pendingSteering = "true";
+    root.dataset.state = "pending";
+    const header = requiredElement("header", root);
+    const label = textElement("span", "pending-message-label", "Pending");
+    const remove = textElement("button", "pending-message-remove", "\xD7");
+    const removeLabel = `Remove pending message ${index + 1}`;
+    remove.type = "button";
+    remove.disabled = sending;
+    remove.title = removeLabel;
+    remove.setAttribute("aria-label", removeLabel);
+    remove.addEventListener("click", () => void removePendingSteering(index, message));
+    header.replaceChildren(label, remove);
+    elements.transcript.append(root);
+  });
+}
+function anchorPendingSteeringMessage(index) {
+  const pending = elements.transcript.querySelectorAll("[data-pending-steering]")[index];
+  if (pending) {
+    alignSubmittedTurn(pending);
+  }
+}
+function renderConversation(session, runtime) {
+  const preservedActivityOpen = liveActivity?.manuallyToggled ? liveActivity.root.open : void 0;
+  const preservedActivityAborted = liveActivity?.root.dataset.state === "aborted";
+  liveMessage = void 0;
+  liveActivity = void 0;
+  resetStreamBlocks();
+  liveTools.clear();
+  const fragment = document.createDocumentFragment();
+  let latestTurnActivity;
+  for (const entry of groupTranscriptActivity(session.transcriptEntries)) {
+    if (entry.kind === "activity") {
+      latestTurnActivity = createActivityCard(entry);
+      fragment.append(latestTurnActivity.root);
+      continue;
+    }
+    if (entry.kind === "message") {
+      if (entry.message.role === "user") {
+        latestTurnActivity = void 0;
+      }
+      if (entry.message.role !== "custom" || entry.message.display !== false) {
+        fragment.append(createMessage(entry.message));
+      }
+      continue;
+    }
+    if (!entry.data || typeof entry.data !== "object") {
+      continue;
+    }
+    const data = entry.data;
+    if (typeof data.markdown !== "string") {
+      continue;
+    }
+    const fileName = typeof data.path === "string" ? data.path.split("/").at(-1) : void 0;
+    const label = fileName ? `extension snapshot \xB7 ${fileName}` : "extension snapshot";
+    const snapshot = createMessage({ role: "extension", content: [] }, label);
+    requiredElement(".message-content", snapshot).append(markdownElement(data.markdown));
+    fragment.append(snapshot);
+  }
+  if (fragment.childNodes.length === 0 && !runtime?.isWorking && !runtime?.queue.steering.length) {
+    renderEmpty("Start a conversation", "Send a message to begin this session.");
+  } else {
+    elements.transcript.replaceChildren(fragment);
+  }
+  if (latestTurnActivity && preservedActivityOpen !== void 0) {
+    latestTurnActivity.manuallyToggled = true;
+    latestTurnActivity.root.open = preservedActivityOpen;
+  }
+  if (runtime?.isWorking) {
+    liveActivity = latestTurnActivity ?? ensureLiveActivity();
+    if (preservedActivityOpen !== void 0) {
+      liveActivity.manuallyToggled = true;
+      liveActivity.root.open = preservedActivityOpen;
+    }
+    setActivityRunning(liveActivity, true);
+    if (runtime.streamingMessage) {
+      hydrateStreamingMessage(runtime.streamingMessage);
+    }
+  } else if (preservedActivityAborted) {
+    liveActivity = latestTurnActivity ?? ensureLiveActivity();
+    setActivityAborted(liveActivity);
+  }
+  renderPendingQueue();
+}
+function ensureLiveActivity() {
+  if (liveActivity) {
+    return liveActivity;
+  }
+  elements.transcript.querySelector(".empty-state")?.remove();
+  liveActivity = createActivityCard(void 0, true);
+  insertBeforePendingQueue(liveActivity.root);
+  return liveActivity;
+}
+function ensureLiveMessage() {
+  if (liveMessage) {
+    return liveMessage;
+  }
+  const activity = ensureLiveActivity();
+  collapseActivity(activity);
+  const root = createMessage({ role: "assistant", content: [] }, "assistant \xB7 streaming");
+  const content = requiredElement(".message-content", root);
+  liveMessage = { root, content };
+  insertBeforePendingQueue(root);
+  return liveMessage;
+}
+function renderLiveMarkdown(block) {
+  if (block.kind !== "text") {
+    return;
+  }
+  block.target.innerHTML = renderMarkdown(block.source ?? "");
+}
+function flushLiveMarkdown() {
+  markdownRenderFrame = void 0;
+  const blocks = [...pendingMarkdownBlocks];
+  pendingMarkdownBlocks.clear();
+  for (const block of blocks) {
+    renderLiveMarkdown(block);
+  }
+}
+function scheduleLiveMarkdown(block) {
+  pendingMarkdownBlocks.add(block);
+  if (markdownRenderFrame !== void 0) {
+    return;
+  }
+  markdownRenderFrame = requestAnimationFrame(flushLiveMarkdown);
+}
+function resetStreamBlocks() {
+  if (markdownRenderFrame !== void 0) {
+    cancelAnimationFrame(markdownRenderFrame);
+  }
+  markdownRenderFrame = void 0;
+  pendingMarkdownBlocks.clear();
+  streamBlocks = /* @__PURE__ */ new Map();
+}
+function ensureStreamBlock(index, kind, initial) {
+  const existing = streamBlocks.get(index);
+  if (existing) {
+    return existing;
+  }
+  let block;
+  if (kind === "thinking") {
+    const card = ensureLiveActivity();
+    const details = appendActivityItem2(card, { kind: "thinking", text: "" });
+    block = {
+      kind,
+      target: requiredElement("pre", details),
+      summary: requiredElement("summary", details)
+    };
+  } else if (kind.toLowerCase().startsWith("toolcall")) {
+    const name = String(initial?.toolName ?? initial?.name ?? "tool");
+    const card = ensureLiveActivity();
+    const details = appendActivityItem2(card, { kind: "toolCall", name, arguments: {} });
+    block = {
+      kind: "toolcall",
+      target: requiredElement("pre", details),
+      summary: requiredElement("summary", details)
+    };
+  } else {
+    const live = ensureLiveMessage();
+    const markdown = markdownElement("");
+    live.content.append(markdown);
+    block = { kind: "text", target: markdown, source: "" };
+  }
+  streamBlocks.set(index, block);
+  return block;
+}
+function hydrateStreamingMessage(partial) {
+  resetStreamBlocks();
+  if (typeof partial.content === "string") {
+    const block = ensureStreamBlock(0, "text");
+    block.source = partial.content;
+    renderLiveMarkdown(block);
+    return;
+  }
+  if (!Array.isArray(partial.content)) {
+    return;
+  }
+  partial.content.forEach((part, index) => {
+    if (!part || typeof part !== "object") {
+      return;
+    }
+    const value = part;
+    const kind = typeof value.type === "string" ? value.type : "text";
+    const block = ensureStreamBlock(index, kind, value);
+    if (kind === "text" && typeof value.text === "string") {
+      block.source = value.text;
+      renderLiveMarkdown(block);
+    }
+    if (kind === "thinking" && typeof value.thinking === "string") {
+      block.target.textContent = value.thinking;
+      updateActivitySummary(ensureLiveActivity(), activityPreview(value.thinking) || void 0);
+    }
+    if (kind === "toolCall" && value.arguments !== void 0) {
+      block.target.textContent = safeJson(value.arguments);
+    }
+  });
+}
+function handleMessageUpdate(event) {
+  const update = event.assistantMessageEvent;
+  if (!update || typeof update !== "object") {
+    return;
+  }
+  const delta = update;
+  const type = typeof delta.type === "string" ? delta.type : "";
+  const index = typeof delta.contentIndex === "number" ? delta.contentIndex : 0;
+  if (type === "text_start") {
+    ensureStreamBlock(index, "text");
+  }
+  if (type === "thinking_start") {
+    ensureStreamBlock(index, "thinking");
+  }
+  if (type === "toolcall_start") {
+    ensureStreamBlock(index, "toolcall", delta);
+  }
+  if (type === "text_delta" || type === "thinking_delta" || type === "toolcall_delta") {
+    const kind = type === "thinking_delta" ? "thinking" : type === "toolcall_delta" ? "toolcall" : "text";
+    const block = ensureStreamBlock(index, kind, delta);
+    if (typeof delta.delta === "string") {
+      if (kind === "text") {
+        block.source = (block.source ?? "") + delta.delta;
+        scheduleLiveMarkdown(block);
+      } else {
+        block.target.append(document.createTextNode(delta.delta));
+      }
+    }
+    if (kind === "thinking") {
+      updateActivitySummary(ensureLiveActivity(), activityPreview(block.target.textContent ?? "") || void 0);
+    }
+  }
+  if (type === "toolcall_end") {
+    const block = ensureStreamBlock(index, "toolcall", delta);
+    const toolCall = delta.toolCall;
+    const name = toolCall?.name ?? delta.toolName;
+    if (block.summary) {
+      block.summary.textContent = toolActionLabel(name);
+    }
+    if (toolCall?.arguments !== void 0) {
+      block.target.textContent = safeJson(toolCall.arguments);
+    }
+    updateActivitySummary(ensureLiveActivity(), void 0, toolActionLabel(name));
+  }
+}
+function resultText(value) {
+  if (!value || typeof value !== "object") {
+    return "";
+  }
+  const content = value.content;
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  return content.filter(
+    (part) => Boolean(
+      part && typeof part === "object" && part.type === "text" && typeof part.text === "string"
+    )
+  ).map((part) => part.text).join("\n");
+}
+function updateTool(event, finished) {
+  const id = typeof event.toolCallId === "string" ? event.toolCallId : void 0;
+  if (!id) {
+    return;
+  }
+  const card = ensureLiveActivity();
+  const name = String(event.toolName ?? "tool");
+  let root = liveTools.get(id);
+  if (!root) {
+    root = document.createElement("details");
+    root.className = "assistant-activity-item toolResult live-tool";
+    const summary = textElement("summary", "", `Tool result \xB7 ${name}`);
+    const content2 = document.createElement("div");
+    content2.className = "assistant-activity-item-content";
+    root.append(summary, content2);
+    card.content.append(root);
+    liveTools.set(id, root);
+  }
+  const content = requiredElement(".assistant-activity-item-content", root);
+  const result = finished ? event.result : event.partialResult;
+  content.replaceChildren(textElement("pre", "", resultText(result)));
+  if (finished) {
+    requiredElement("summary", root).textContent = `Tool result \xB7 ${name} \xB7 done`;
+  }
+  updateActivitySummary(card, void 0, toolActionLabel(name, finished));
+}
+function messageText(message) {
+  if (typeof message.content === "string") {
+    return message.content;
+  }
+  if (!Array.isArray(message.content)) {
+    return void 0;
+  }
+  const text = message.content.filter(
+    (part) => Boolean(
+      part && typeof part === "object" && part.type === "text" && typeof part.text === "string"
+    )
+  ).map((part) => part.text).join("\n");
+  return text || void 0;
+}
+function appendUserMessage(message) {
+  const text = messageText(message);
+  const candidate = optimisticSubmission;
+  const optimistic = candidate && candidate.sessionId === currentSessionId && candidate.root.isConnected && candidate.message === text ? candidate : void 0;
+  const dequeuedIndex = text === void 0 ? -1 : dequeuedSteering.indexOf(text);
+  if (!optimistic && dequeuedIndex < 0) {
+    return;
+  }
+  if (dequeuedIndex >= 0) {
+    dequeuedSteering.splice(dequeuedIndex, 1);
+  }
+  const final = createMessage(message);
+  if (optimistic) {
+    optimistic.root.replaceWith(final);
+    optimisticSubmission = void 0;
+    alignSubmittedTurn(final);
+  } else {
+    insertBeforePendingQueue(final);
+    const turn = submittedTurnAnchor;
+    if (turn && turn.sessionId === currentSessionId && turn.message === text) {
+      alignSubmittedTurn(final);
+    }
+  }
+  if (!optimistic) {
+    if (liveActivity) {
+      setActivityRunning(liveActivity, false);
+      collapseActivity(liveActivity);
+    }
+    liveMessage = void 0;
+    liveActivity = void 0;
+    resetStreamBlocks();
+    liveTools.clear();
+  }
+}
+function appendMessage(message) {
+  if (message.role === "custom" && message.display === false) {
+    return;
+  }
+  elements.transcript.querySelector(".empty-state")?.remove();
+  if (message.role === "user") {
+    appendUserMessage(message);
+  } else if (message.role === "assistant") {
+    const partitioned = partitionAssistantContent(message.content);
+    const sawStreamedActivity = [...streamBlocks.values()].some((block) => block.kind !== "text");
+    if (!sawStreamedActivity) {
+      const card = partitioned.activity.length > 0 ? ensureLiveActivity() : void 0;
+      if (card) {
+        for (const item of partitioned.activity) {
+          appendActivityItem2(card, item);
+        }
+      }
+    }
+    if (partitioned.hasResponse) {
+      const final = createMessage({ ...message, content: partitioned.responseContent });
+      collapseActivity(ensureLiveActivity());
+      if (liveMessage) {
+        liveMessage.root.replaceWith(final);
+      } else {
+        insertBeforePendingQueue(final);
+      }
+      liveMessage = void 0;
+    }
+    if (message.stopReason === "aborted") {
+      setActivityAborted(ensureLiveActivity());
+    }
+    resetStreamBlocks();
+  } else if (message.role === "toolResult") {
+    const card = ensureLiveActivity();
+    const placeholder = message.toolCallId ? liveTools.get(message.toolCallId) : void 0;
+    const final = appendActivityItem2(card, { kind: "toolResult", message }, !placeholder);
+    if (placeholder) {
+      placeholder.replaceWith(final);
+    }
+    if (message.toolCallId) {
+      liveTools.delete(message.toolCallId);
+    }
+  } else {
+    insertBeforePendingQueue(createMessage(message));
+  }
+}
+function appendError(message) {
+  const root = createMessage({ role: "error", content: message, isError: true }, "error");
+  elements.transcript.querySelector(".empty-state")?.remove();
+  insertBeforePendingQueue(root);
+}
+function cloneExtensionUIState(state) {
+  return state ? {
+    pending: state.pending.map((request) => ({ ...request })),
+    statuses: state.statuses.map((status) => ({ ...status })),
+    widgets: state.widgets.map((widget) => ({ ...widget, lines: [...widget.lines] }))
+  } : { pending: [], statuses: [], widgets: [] };
+}
+function renderExtensionState() {
+  const statuses = document.createDocumentFragment();
+  for (const status of extensionUI.statuses) {
+    statuses.append(textElement("span", "extension-status", status.text));
+  }
+  const above = document.createDocumentFragment();
+  const below = document.createDocumentFragment();
+  for (const widget of extensionUI.widgets) {
+    const section = document.createElement("section");
+    section.className = "extension-widget";
+    section.append(textElement("pre", "extension-widget-content", widget.lines.join("\n")));
+    (widget.placement === "belowEditor" ? below : above).append(section);
+  }
+  const hasStatuses = statuses.childNodes.length > 0;
+  const hasAbove = above.childNodes.length > 0;
+  const hasBelow = below.childNodes.length > 0;
+  elements.extensionStatuses.replaceChildren(statuses);
+  elements.extensionWidgetsAbove.replaceChildren(above);
+  elements.extensionWidgetsBelow.replaceChildren(below);
+  elements.extensionStatusItem.hidden = !hasStatuses;
+  elements.extensionStatuses.hidden = !hasStatuses;
+  elements.extensionWidgetsAbove.hidden = !hasAbove;
+  elements.extensionWidgetsBelow.hidden = !hasBelow;
+}
+async function respondToExtensionUI(request, response, reconcileAfterResponse = true) {
+  if (!currentSessionId) {
+    return;
+  }
+  const sessionId = currentSessionId;
+  applyExtensionUIState({
+    ...extensionUI,
+    pending: extensionUI.pending.filter((candidate) => candidate.id !== request.id)
+  });
+  try {
+    await api(`/api/sessions/${encodeURIComponent(sessionId)}/extension-ui`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ type: "extension_ui_response", id: request.id, ...response })
+    });
+    if (currentSessionId === sessionId && reconcileAfterResponse) {
+      await reconcileSession();
+    }
+  } catch (error) {
+    appendError(`Could not answer extension request: ${readableError(error)}`);
+    if (currentSessionId === sessionId && reconcileAfterResponse) {
+      void reconcileSession();
+    }
+  }
+}
+function renderExtensionPrompt() {
+  const request = extensionUI.pending[0];
+  if (!request) {
+    const closedRequest = renderedExtensionRequestId !== void 0;
+    renderedExtensionRequestId = void 0;
+    elements.extensionPrompt.hidden = true;
+    elements.extensionPrompt.replaceChildren();
+    if (closedRequest && currentSessionId) {
+      queueMicrotask(() => elements.prompt.focus());
+    }
+    return;
+  }
+  if (request.id === renderedExtensionRequestId && elements.extensionPrompt.childElementCount > 0) {
+    return;
+  }
+  renderedExtensionRequestId = request.id;
+  const panel = document.createElement("section");
+  panel.className = "extension-prompt-panel";
+  panel.setAttribute("role", "dialog");
+  panel.setAttribute("aria-labelledby", "extension-prompt-title");
+  panel.addEventListener("keydown", (event) => {
+    if (event.key !== "Escape") {
+      return;
+    }
+    event.preventDefault();
+    void respondToExtensionUI(request, { cancelled: true });
+  });
+  const header = document.createElement("header");
+  const title = document.createElement("h2");
+  title.id = "extension-prompt-title";
+  const titleToggle = textElement("button", "extension-prompt-title-toggle", request.title);
+  titleToggle.type = "button";
+  title.append(titleToggle);
+  const body = document.createElement("div");
+  body.id = "extension-prompt-body";
+  body.className = "extension-prompt-body";
+  const actions = document.createElement("footer");
+  actions.id = "extension-prompt-actions";
+  actions.className = "extension-prompt-actions";
+  titleToggle.setAttribute("aria-controls", `${body.id} ${actions.id}`);
+  const setCollapsed = (collapsed) => {
+    const label = `${collapsed ? "Expand" : "Collapse"} extension request`;
+    panel.classList.toggle("is-collapsed", collapsed);
+    titleToggle.title = label;
+    titleToggle.setAttribute("aria-expanded", String(!collapsed));
+  };
+  const toggleCollapsed = () => {
+    setCollapsed(!panel.classList.contains("is-collapsed"));
+  };
+  setCollapsed(false);
+  titleToggle.addEventListener("click", toggleCollapsed);
+  titleToggle.addEventListener("keydown", (event) => {
+    if (event.key !== "Enter" && event.key !== " ") {
+      return;
+    }
+    event.preventDefault();
+    toggleCollapsed();
+  });
+  const cancel = textElement("button", "extension-prompt-cancel secondary", "Cancel");
+  cancel.type = "button";
+  cancel.addEventListener("click", () => void respondToExtensionUI(request, { cancelled: true }));
+  const headerActions = document.createElement("div");
+  headerActions.className = "extension-prompt-header-actions";
+  headerActions.append(cancel);
+  header.append(title, headerActions);
+  header.addEventListener("click", (event) => {
+    if (event.target instanceof Element && event.target.closest("button")) {
+      return;
+    }
+    toggleCollapsed();
+  });
+  let initialFocus = cancel;
+  if (request.method === "select") {
+    const choices = document.createElement("div");
+    choices.className = "extension-prompt-choices";
+    for (const option of request.options) {
+      const button = textElement("button", "secondary", option);
+      button.type = "button";
+      button.addEventListener("click", () => void respondToExtensionUI(request, { value: option }));
+      choices.append(button);
+      if (choices.childElementCount === 1) {
+        initialFocus = button;
+      }
+    }
+    body.append(choices);
+  } else if (request.method === "confirm") {
+    body.append(textElement("p", "message-text", request.message));
+    const confirm = textElement("button", "", "Confirm");
+    confirm.type = "button";
+    confirm.addEventListener("click", () => void respondToExtensionUI(request, { confirmed: true }));
+    actions.append(confirm);
+    initialFocus = confirm;
+  } else {
+    const field = request.method === "editor" ? document.createElement("textarea") : document.createElement("input");
+    field.className = "extension-prompt-field";
+    if (field instanceof HTMLTextAreaElement) {
+      field.rows = 8;
+      field.value = "prefill" in request ? request.prefill ?? "" : "";
+    } else {
+      field.type = "text";
+      field.placeholder = "placeholder" in request ? request.placeholder ?? "" : "";
+    }
+    const submit = textElement("button", "", "Submit");
+    submit.type = "button";
+    submit.addEventListener("click", () => void respondToExtensionUI(request, { value: field.value }));
+    field.addEventListener("keydown", (event) => {
+      const keyboardEvent = event;
+      if (keyboardEvent.key === "Enter" && (request.method === "input" || keyboardEvent.ctrlKey || keyboardEvent.metaKey)) {
+        keyboardEvent.preventDefault();
+        void respondToExtensionUI(request, { value: field.value });
+      }
+    });
+    body.append(field);
+    actions.append(submit);
+    initialFocus = field;
+  }
+  panel.append(header, body, actions);
+  elements.extensionPrompt.replaceChildren(panel);
+  elements.extensionPrompt.hidden = false;
+  queueMicrotask(() => initialFocus.focus());
+}
+function applyExtensionUIState(state) {
+  extensionUI = cloneExtensionUIState(state);
+  if (currentRuntime) {
+    currentRuntime = { ...currentRuntime, extensionUI: cloneExtensionUIState(extensionUI) };
+  }
+  renderExtensionState();
+  renderExtensionPrompt();
+  updateControls();
+}
+function handleExtensionUIRequest(request) {
+  if (request.method === "select" || request.method === "confirm" || request.method === "input" || request.method === "editor") {
+    applyExtensionUIState({
+      ...extensionUI,
+      pending: [...extensionUI.pending.filter((candidate) => candidate.id !== request.id), request]
+    });
+    void reconcileSession();
+    return;
+  }
+  if (request.method === "notify") {
+    const notification = createMessage(
+      { role: "extension", content: request.message, isError: request.notifyType === "error" },
+      `extension \xB7 ${request.notifyType ?? "info"}`
+    );
+    elements.transcript.querySelector(".empty-state")?.remove();
+    insertBeforePendingQueue(notification);
+    return;
+  }
+  if (request.method === "setStatus") {
+    const statuses = extensionUI.statuses.filter((status) => status.key !== request.statusKey);
+    if (request.statusText !== void 0) {
+      statuses.push({ key: request.statusKey, text: request.statusText });
+    }
+    applyExtensionUIState({ ...extensionUI, statuses });
+    return;
+  }
+  if (request.method === "setWidget") {
+    const widgets = extensionUI.widgets.filter((widget) => widget.key !== request.widgetKey);
+    if (request.widgetLines !== void 0) {
+      widgets.push({
+        key: request.widgetKey,
+        lines: [...request.widgetLines],
+        placement: request.widgetPlacement ?? "aboveEditor"
+      });
+    }
+    applyExtensionUIState({ ...extensionUI, widgets });
+    return;
+  }
+  if (request.method === "setTitle") {
+    document.title = request.title;
+    return;
+  }
+  setPromptValue(request.text);
+}
+function applyRuntimeState(runtime) {
+  const previousQueue = copyMessageQueue(currentRuntime?.queue);
+  const nextRuntime = runtime ? { ...runtime, queue: copyMessageQueue(runtime.queue) } : null;
+  if (!nextRuntime) {
+    resetStreamBlocks();
+  }
+  const submittedQueueIndex = optimisticSubmission && nextRuntime && steeringQueueGrew(previousQueue, nextRuntime.queue) ? previousQueue.steering.length : void 0;
+  if (submittedQueueIndex !== void 0) {
+    optimisticSubmission?.root.remove();
+    optimisticSubmission = void 0;
+  }
+  currentRuntime = nextRuntime;
+  if (nextRuntime && currentSession) {
+    if (nextRuntime.sessionName) {
+      currentSession.name = nextRuntime.sessionName;
+    } else {
+      delete currentSession.name;
+    }
+  }
+  applyExtensionUIState(nextRuntime?.extensionUI);
+  renderPendingQueue();
+  if (submittedQueueIndex !== void 0) {
+    anchorPendingSteeringMessage(submittedQueueIndex);
+  }
+  updateControls();
+  updateSessionContext();
+  updateSessionHeading();
+}
+function patchRuntimeState(patch) {
+  const existing = currentRuntime ?? emptyRuntime();
+  currentRuntime = {
+    ...existing,
+    ...patch,
+    queue: copyMessageQueue(patch.queue ?? existing.queue),
+    extensionUI: cloneExtensionUIState(extensionUI)
+  };
+  renderPendingQueue();
+  updateControls();
+  updateSessionContext();
+}
+async function reconcileSession() {
+  if (!currentSessionId) {
+    return;
+  }
+  const selectedId = currentSessionId;
+  const sequence = ++reconcileSequence;
+  try {
+    const response = await api(`/api/sessions/${encodeURIComponent(selectedId)}`);
+    if (currentSessionId !== selectedId || sequence !== reconcileSequence) {
+      return;
+    }
+    currentSession = response.session;
+    applyRuntimeState(response.runtime);
+    updateSessionHeading();
+    setWorkspace(response.session.cwd, response.session.gitContext);
+    optimisticSubmission = void 0;
+    dequeuedSteering = [];
+    renderConversation(response.session, currentRuntime);
+    const latestUserEntry = [...response.session.transcriptEntries].reverse().find(
+      (entry) => entry.kind === "message" && entry.message.role === "user"
+    );
+    if (submittedTurnAnchor?.sessionId === selectedId && latestUserEntry && messageText(latestUserEntry.message) === submittedTurnAnchor.message) {
+      const renderedUsers = elements.transcript.querySelectorAll(".message.user:not(.pending)");
+      const renderedUser = renderedUsers[renderedUsers.length - 1];
+      if (renderedUser) {
+        alignSubmittedTurn(renderedUser);
+      }
+    }
+  } catch (error) {
+    if (currentSessionId === selectedId && sequence === reconcileSequence) {
+      appendError(readableError(error));
+    }
+  }
+}
+function handleAgentEvent(event) {
+  const type = typeof event.type === "string" ? event.type : "";
+  if (type === "agent_start") {
+    patchRuntimeState({ isStreaming: true, isWorking: true });
+    ensureLiveActivity();
+  } else if (type === "message_start") {
+    const message = event.message;
+    if (message?.role === "assistant") {
+      resetStreamBlocks();
+    }
+  } else if (type === "message_update") {
+    handleMessageUpdate(event);
+  } else if (type === "message_end") {
+    const message = event.message;
+    if (message) {
+      appendMessage(message);
+    }
+  } else if (type === "entry_appended") {
+    const entry = event.entry;
+    if (entry?.type === "custom" || entry?.type === "custom_message") {
+      void reconcileSession();
+    }
+  } else if (type === "tool_execution_start") {
+    updateTool(event, false);
+    patchRuntimeState({ isWorking: true });
+  } else if (type === "tool_execution_update") {
+    updateTool(event, false);
+  } else if (type === "tool_execution_end") {
+    updateTool(event, true);
+  } else if (type === "queue_update") {
+    const previousQueue = copyMessageQueue(currentRuntime?.queue);
+    const update = reconcileMessageQueue(previousQueue, messageQueueFromEvent(event), discardingQueue);
+    const pendingMessageCount = update.queue.steering.length + update.queue.followUp.length;
+    const submittedQueueIndex = optimisticSubmission && steeringQueueGrew(previousQueue, update.queue) ? previousQueue.steering.length : void 0;
+    if (discardingQueue) {
+      dequeuedSteering = [];
+    }
+    dequeuedSteering.push(...update.dequeuedSteering);
+    if (submittedQueueIndex !== void 0) {
+      optimisticSubmission?.root.remove();
+      optimisticSubmission = void 0;
+    }
+    patchRuntimeState({
+      queue: update.queue,
+      pendingMessageCount,
+      ...pendingMessageCount > 0 ? { isWorking: true } : {}
+    });
+    if (submittedQueueIndex !== void 0) {
+      anchorPendingSteeringMessage(submittedQueueIndex);
+    }
+  } else if (type === "compaction_start" || type === "auto_retry_start") {
+    patchRuntimeState({ isCompacting: type === "compaction_start", isWorking: true });
+    ensureLiveActivity();
+  } else if (type === "session_info_changed") {
+    const name = typeof event.name === "string" && event.name.trim() ? event.name.trim() : void 0;
+    applyCurrentSessionName(name);
+  } else if (type === "agent_settled") {
+    dequeuedSteering = [];
+    patchRuntimeState({
+      isStreaming: false,
+      isCompacting: false,
+      isWorking: false,
+      pendingMessageCount: 0,
+      queue: { steering: [], followUp: [] }
+    });
+    if (liveActivity) {
+      if (liveActivity.root.dataset.state !== "aborted") {
+        setActivityRunning(liveActivity, false);
+      }
+      collapseActivity(liveActivity);
+    }
+    void reconcileSession();
+  }
+}
+function emptyRuntime() {
+  return {
+    id: currentSessionId ?? "",
+    cwd: currentSession?.cwd ?? "",
+    isStreaming: false,
+    isCompacting: false,
+    isWorking: false,
+    pendingMessageCount: 0,
+    queue: { steering: [], followUp: [] },
+    model: currentSession?.model ? {
+      provider: currentSession.model.provider,
+      id: currentSession.model.modelId,
+      name: currentSession.model.modelId
+    } : null,
+    thinkingLevel: currentSession?.thinkingLevel ?? "off",
+    autoCompactionEnabled: false,
+    usage: {
+      tokens: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+      context: null
+    },
+    commands: [],
+    extensionUI
+  };
+}
+function handleRuntimeEnvelope(envelope) {
+  if (envelope.type === "agent_event") {
+    handleAgentEvent(envelope.event);
+  }
+  if (envelope.type === "extension_ui_request") {
+    handleExtensionUIRequest(envelope);
+  }
+  if (envelope.type === "extension_ui_closed") {
+    applyExtensionUIState({
+      ...extensionUI,
+      pending: extensionUI.pending.filter((request) => request.id !== envelope.id)
+    });
+  }
+  if (envelope.type === "extension_ui_reset") {
+    applyExtensionUIState(void 0);
+  }
+  if (envelope.type === "session_replaced" && envelope.sessionId !== currentSessionId) {
+    void selectSession(envelope.sessionId);
+  }
+  if (envelope.type === "runtime_error") {
+    appendError(envelope.message);
+    void reconcileSession();
+  }
+  if (envelope.type === "runtime_disposed") {
+    dequeuedSteering = [];
+    resetStreamBlocks();
+    patchRuntimeState({ pendingMessageCount: 0, queue: { steering: [], followUp: [] } });
+    eventStream.reconnectNow();
+  }
+}
+function renderConnectionState(state) {
+  if (state === "connected") {
+    setConnection("Connected", "online");
+  } else if (state === "connecting") {
+    setConnection("Connecting", "offline");
+  } else {
+    setConnection("Reconnecting", "error");
+  }
+}
+var eventStream = new SessionEventStream({
+  onStateChange: renderConnectionState,
+  onReady: (event, recovered) => {
+    if (!currentSessionId) {
+      return;
+    }
+    try {
+      const ready = JSON.parse(event.data);
+      applyRuntimeState(ready.state);
+      if (ready.state.isWorking) {
+        setActivityRunning(ensureLiveActivity(), true);
+      } else if (liveActivity) {
+        if (liveActivity.root.dataset.state !== "aborted") {
+          setActivityRunning(liveActivity, false);
+        }
+        collapseActivity(liveActivity);
+      }
+      if (ready.state.streamingMessage && !liveMessage && streamBlocks.size === 0) {
+        hydrateStreamingMessage(ready.state.streamingMessage);
+      }
+      if (ready.gap || recovered) {
+        void reconcileSession();
+      }
+    } catch (error) {
+      appendError(`Could not read agent state: ${readableError(error)}`);
+    }
+  },
+  onRuntime: (event) => {
+    if (!currentSessionId) {
+      return;
+    }
+    try {
+      handleRuntimeEnvelope(JSON.parse(event.data));
+    } catch (error) {
+      appendError(`Could not read agent event: ${readableError(error)}`);
+    }
+  }
+});
+function connectEvents(id) {
+  eventStream.start(id);
+}
+async function selectSession(id, updateHistory = true) {
+  if (id === currentSessionId && currentSession) {
+    return;
+  }
+  eventStream.stop();
+  setSubmittedTurnAnchor(false);
+  currentSessionId = id;
+  currentSession = void 0;
+  elements.createSession.href = `${sessionPath(id)}/new`;
+  currentRuntime = null;
+  applyExtensionUIState(void 0);
+  optimisticSubmission = void 0;
+  submittedTurnAnchor = void 0;
+  dequeuedSteering = [];
+  discardingQueue = false;
+  liveMessage = void 0;
+  liveActivity = void 0;
+  resetStreamBlocks();
+  liveTools.clear();
+  sending = false;
+  renaming = false;
+  if (updateHistory) {
+    history.pushState(null, "", sessionPath(id));
+  }
+  setPromptValue("");
+  elements.sessionTitle.textContent = "Loading\u2026";
+  elements.sessionTitle.title = "Session title is loading";
+  elements.sessionTitle.setAttribute("aria-label", "Session title is loading");
+  setWorkspace("", void 0);
+  setContextValue(elements.sessionModel, "");
+  elements.sessionModel.setAttribute("aria-label", "Model and thinking level are loading.");
+  updateSessionUsage(null);
+  renderEmpty("Loading conversation", "Reading the saved Pi session\u2026");
+  updateControls();
+  try {
+    const response = await api(`/api/sessions/${encodeURIComponent(id)}`);
+    if (currentSessionId !== id) {
+      return;
+    }
+    currentSession = response.session;
+    applyRuntimeState(response.runtime);
+    updateSessionHeading();
+    setWorkspace(response.session.cwd, response.session.gitContext);
+    renderConversation(response.session, response.runtime);
+    connectEvents(id);
+    if (window.matchMedia("(hover: hover) and (pointer: fine)").matches) {
+      elements.prompt.focus();
+    }
+  } catch (error) {
+    if (currentSessionId !== id) {
+      return;
+    }
+    appendError(readableError(error));
+    setConnection("Unavailable", "error");
+  }
+}
+async function renameCurrentSession() {
+  if (!currentSessionId || renaming) {
+    return;
+  }
+  const value = window.prompt("Session title (leave blank to clear)", currentNativeName() ?? "");
+  if (value === null) {
+    return;
+  }
+  const id = currentSessionId;
+  renaming = true;
+  updateControls();
+  try {
+    const response = await api(
+      `/api/sessions/${encodeURIComponent(id)}/name`,
+      {
+        method: "PUT",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ name: value })
+      }
+    );
+    if (currentSessionId !== id) {
+      return;
+    }
+    applyRuntimeState(response.state);
+    applyCurrentSessionName(response.name ?? void 0);
+  } catch (error) {
+    if (currentSessionId === id) {
+      appendError(`Could not rename session: ${readableError(error)}`);
+    }
+  } finally {
+    renaming = false;
+    updateControls();
+  }
+}
+async function sendMessage() {
+  if (!currentSessionId || sending) {
+    return;
+  }
+  const message = elements.prompt.value;
+  if (!message.trim()) {
+    return;
+  }
+  const id = currentSessionId;
+  const pendingExtensionRequest = extensionUI.pending[0];
+  const previousFirstMessage = currentSession?.firstMessage;
+  const shouldUpdateFirstMessage = Boolean(currentSession && !currentSession.firstMessage.trim());
+  if (currentSession && shouldUpdateFirstMessage) {
+    currentSession.firstMessage = message;
+    updateSessionHeading();
+  }
+  const activatedTurnAnchor = !elements.transcript.classList.contains("has-submitted-turn-anchor");
+  const previousSubmittedTurnAnchor = submittedTurnAnchor;
+  setSubmittedTurnAnchor(true);
+  elements.transcript.querySelector(".empty-state")?.remove();
+  if (!currentRuntime?.isWorking) {
+    liveActivity = void 0;
+    resetStreamBlocks();
+  }
+  const optimistic = createMessage({ role: "user", content: message });
+  optimistic.dataset.optimistic = "true";
+  optimisticSubmission = { sessionId: id, message, root: optimistic };
+  submittedTurnAnchor = { sessionId: id, message, root: optimistic, needsAlignment: true };
+  elements.transcript.append(optimistic);
+  updateSubmittedTurnRunway();
+  optimistic.scrollIntoView({ block: "start" });
+  setPromptValue("");
+  sending = true;
+  updateControls();
+  eventStream.ensureConnected();
+  try {
+    if (pendingExtensionRequest) {
+      await respondToExtensionUI(pendingExtensionRequest, { cancelled: true }, false);
+      if (currentSessionId !== id) {
+        return;
+      }
+    }
+    const response = await api(
+      `/api/sessions/${encodeURIComponent(id)}/messages`,
+      {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ message })
+      }
+    );
+    if (currentSessionId !== id) {
+      return;
+    }
+    applyRuntimeState(response.state);
+    if (response.state.isWorking) {
+      ensureLiveActivity();
+    }
+    void reconcileSession();
+  } catch (error) {
+    optimistic.remove();
+    if (optimisticSubmission?.root === optimistic) {
+      optimisticSubmission = void 0;
+    }
+    if (currentSessionId === id) {
+      submittedTurnAnchor = previousSubmittedTurnAnchor;
+      if (activatedTurnAnchor) {
+        setSubmittedTurnAnchor(false);
+      } else {
+        updateSubmittedTurnRunway();
+      }
+      if (currentSession && shouldUpdateFirstMessage) {
+        currentSession.firstMessage = previousFirstMessage ?? "";
+        updateSessionHeading();
+      }
+      setPromptValue(message);
+      appendError(readableError(error));
+      void reconcileSession();
+    }
+  } finally {
+    sending = false;
+    updateControls();
+  }
+}
+async function removePendingSteering(index, message) {
+  if (!currentSessionId || !currentRuntime || sending) {
+    return;
+  }
+  const id = currentSessionId;
+  const expectedQueue = copyMessageQueue(currentRuntime.queue);
+  const nextQueue = withoutSteeringMessage(expectedQueue, index, message);
+  if (!nextQueue) {
+    void reconcileSession();
+    return;
+  }
+  sending = true;
+  discardingQueue = true;
+  dequeuedSteering = [];
+  patchRuntimeState({
+    pendingMessageCount: nextQueue.steering.length + nextQueue.followUp.length,
+    queue: nextQueue
+  });
+  updateControls();
+  try {
+    const response = await api(`/api/sessions/${encodeURIComponent(id)}/pending-steering`, {
+      method: "DELETE",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ index, message, queue: expectedQueue.steering })
+    });
+    if (currentSessionId !== id) {
+      return;
+    }
+    applyRuntimeState(response.state);
+    await reconcileSession();
+  } catch (error) {
+    if (currentSessionId === id) {
+      appendError(`Could not remove pending message: ${readableError(error)}`);
+      await reconcileSession();
+    }
+  } finally {
+    sending = false;
+    discardingQueue = false;
+    renderPendingQueue();
+    updateControls();
+  }
+}
+async function abortRun() {
+  if (!currentSessionId || sending) {
+    return;
+  }
+  const id = currentSessionId;
+  sending = true;
+  discardingQueue = true;
+  dequeuedSteering = [];
+  patchRuntimeState({ pendingMessageCount: 0, queue: { steering: [], followUp: [] } });
+  updateControls();
+  try {
+    const response = await api(`/api/sessions/${encodeURIComponent(id)}/abort`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: "{}"
+    });
+    if (currentSessionId !== id) {
+      return;
+    }
+    if (response.restoredMessages.length > 0) {
+      setPromptValue(response.restoredMessages.join("\n\n"));
+    }
+    if (liveActivity) {
+      setActivityAborted(liveActivity);
+    }
+    await reconcileSession();
+  } catch (error) {
+    if (currentSessionId === id) {
+      appendError(readableError(error));
+      void reconcileSession();
+    }
+  } finally {
+    sending = false;
+    discardingQueue = false;
+    updateControls();
+  }
+}
+var submittedTurnRunwayObserver = new MutationObserver(scheduleSubmittedTurnRunwayUpdate);
+submittedTurnRunwayObserver.observe(elements.transcript, {
+  attributeFilter: ["open"],
+  attributes: true,
+  characterData: true,
+  childList: true,
+  subtree: true
+});
+elements.composer.addEventListener("submit", (event) => {
+  event.preventDefault();
+  void sendMessage();
+});
+elements.prompt.addEventListener("input", () => {
+  dismissedSlashCompletionValue = void 0;
+  resizePrompt();
+  renderSlashCompletion(true);
+});
+elements.prompt.addEventListener("keydown", (event) => {
+  if (slashCompletion && !event.isComposing) {
+    if (event.key === "ArrowDown" || event.key === "ArrowUp") {
+      event.preventDefault();
+      slashCompletion = moveSlashCompletionSelection(slashCompletion, event.key === "ArrowDown" ? 1 : -1);
+      renderSlashCompletion();
+      return;
+    }
+    if (event.key === "Tab") {
+      event.preventDefault();
+      applySelectedSlashCompletion(false);
+      return;
+    }
+    if (event.key === "Enter" && !event.shiftKey) {
+      event.preventDefault();
+      applySelectedSlashCompletion(true);
+      return;
+    }
+    if (event.key === "Escape") {
+      event.preventDefault();
+      closeSlashCompletion(true);
+      return;
+    }
+  }
+  if (event.key === "Enter" && !event.shiftKey && !event.isComposing) {
+    event.preventDefault();
+    void sendMessage();
+  }
+});
+elements.abort.addEventListener("click", () => void abortRun());
+elements.sessionTitle.addEventListener("click", () => void renameCurrentSession());
+elements.sessionContextToggle.addEventListener("click", () => {
+  setSessionContextCollapsed(!elements.sessionContext.classList.contains("is-collapsed"));
+});
+window.addEventListener("popstate", () => {
+  const route = routeFromLocation();
+  if (route) {
+    void selectSession(route, false);
+  } else {
+    location.reload();
+  }
+});
+document.addEventListener("visibilitychange", () => {
+  if (document.visibilityState !== "visible" || !currentSessionId) {
+    return;
+  }
+  eventStream.ensureConnected();
+  void reconcileSession();
+});
+window.addEventListener("online", () => {
+  if (!currentSessionId) {
+    return;
+  }
+  eventStream.reconnectNow();
+  void reconcileSession();
+});
+window.addEventListener("resize", () => {
+  resizePrompt();
+  scheduleSubmittedTurnRunwayUpdate();
+});
+function routeFromLocation() {
+  const match = /^\/sessions\/([^/]+)\/?$/.exec(location.pathname);
+  if (!match?.[1]) {
+    return void 0;
+  }
+  try {
+    return decodeURIComponent(match[1]);
+  } catch {
+    return void 0;
+  }
+}
+var requestedSession = routeFromLocation();
+if (requestedSession) {
+  void selectSession(requestedSession, false);
+} else {
+  location.assign("/");
+}