@adea-ai/ui 0.140.0 → 0.142.0

package/dist/components/ui/message/parse-message-text.js

@@ -0,0 +1,365 @@
+//#region src/components/ui/message/parse-message-text.ts
+var WHITESPACE = /\s/;
+/**
+* An opening fence: up to three spaces, a run of three or more backticks or of
+* three or more tildes, then an info string that holds no backtick. The first
+* word of the info string is the language. This is a scan, not one pattern,
+* because a pattern whose classes overlap (`[^\s`]*` then `[^`]*`) retries every
+* split of a long info string when a stray backtick ends it: three backticks, a
+* long run of `a` and a trailing backtick took quadratic time.
+*/
+function fenceOpen(line) {
+	let start = 0;
+	while (start < 3 && line.charCodeAt(start) === 32) start += 1;
+	const mark = line[start];
+	if (mark !== "`" && mark !== "~") return void 0;
+	let end = start + 1;
+	while (line[end] === mark) end += 1;
+	if (end - start < 3) return void 0;
+	if (line.includes("`", end)) return void 0;
+	let wordStart = end;
+	while (line[wordStart] === " " || line[wordStart] === "	") wordStart += 1;
+	let wordEnd = wordStart;
+	while (wordEnd < line.length && !WHITESPACE.test(line[wordEnd])) wordEnd += 1;
+	return {
+		marker: line.slice(start, end),
+		language: line.slice(wordStart, wordEnd)
+	};
+}
+var BULLET = /^ {0,3}[-*+][ \t]+(?![ \t])(.*)$/;
+var ORDERED = /^ {0,3}(\d{1,9})[.)][ \t]+(?![ \t])(.*)$/;
+var QUOTE = /^ {0,3}>[ \t]?(.*)$/;
+var isBlank = (char) => char === " " || char === "	";
+var LINE_TERMINATOR = /[\n\r\u2028\u2029]/;
+/**
+* An ATX heading: up to three spaces, one to four `#`, spaces or tabs, then the
+* text, with any trailing spaces and closing `#` run removed. This is a scan for
+* the reason `fenceOpen` is: the equivalent pattern (`(.+?)[ \t]*#*[ \t]*$`)
+* retries the closing check from every position of a long run of spaces.
+*/
+function headingOf(line) {
+	let start = 0;
+	while (start < 3 && line.charCodeAt(start) === 32) start += 1;
+	let marks = start;
+	while (line[marks] === "#") marks += 1;
+	const level = marks - start;
+	if (level < 1 || level > 4 || !isBlank(line[marks])) return void 0;
+	let textStart = marks;
+	while (isBlank(line[textStart])) textStart += 1;
+	if (textStart === line.length) return textStart - marks >= 2 ? {
+		level,
+		text: line[line.length - 1]
+	} : void 0;
+	if (LINE_TERMINATOR.test(line.slice(textStart))) return void 0;
+	let textEnd = line.length;
+	while (textEnd > textStart && isBlank(line[textEnd - 1])) textEnd -= 1;
+	while (textEnd > textStart && line[textEnd - 1] === "#") textEnd -= 1;
+	while (textEnd > textStart && isBlank(line[textEnd - 1])) textEnd -= 1;
+	return {
+		level,
+		text: line.slice(textStart, Math.max(textEnd, textStart + 1))
+	};
+}
+/** Only these schemes become links; everything else is shown as its text. */
+function safeHref(value) {
+	const trimmed = value.trim();
+	if (trimmed.length === 0 || trimmed.length > 2048) return void 0;
+	if (/[\u0000- \u007f]/.test(trimmed)) return void 0;
+	try {
+		const url = new URL(trimmed);
+		return url.protocol === "http:" || url.protocol === "https:" || url.protocol === "mailto:" ? trimmed : void 0;
+	} catch {
+		return;
+	}
+}
+var MAX_INLINE_DEPTH = 4;
+/** A marker may cite at most this many sources, so one cannot flood a sentence. */
+var MAX_CITED_SOURCES = 6;
+var CITATION = /\[\^(\d{1,4}(?:[ \t]*,[ \t]*\d{1,4}){0,5})\]/y;
+function citationAt(text, index, count) {
+	CITATION.lastIndex = index;
+	const match = CITATION.exec(text);
+	if (!match) return void 0;
+	const numbers = [...new Set(match[1].split(",").map((part) => Number(part.trim())))];
+	if (numbers.length > MAX_CITED_SOURCES) return void 0;
+	if (numbers.some((number) => number < 1 || number > count)) return void 0;
+	return {
+		kind: "cite",
+		numbers,
+		raw: match[0]
+	};
+}
+/** Inline spans. Delimiters must close on the same block, or they stay literal. */
+function parseInline(text, depth = 0, options = {}) {
+	const out = [];
+	let brackets;
+	let paren = -2;
+	let buffer = "";
+	const flush = () => {
+		if (buffer) out.push({
+			kind: "text",
+			text: buffer
+		});
+		buffer = "";
+	};
+	let index = 0;
+	while (index < text.length) {
+		const char = text[index];
+		if (char === "`") {
+			let ticks = 1;
+			while (text[index + ticks] === "`") ticks += 1;
+			const fence = "`".repeat(ticks);
+			const close = text.indexOf(fence, index + ticks);
+			if (close > index + ticks) {
+				flush();
+				out.push({
+					kind: "code",
+					text: text.slice(index + ticks, close).replace(/^ (.*) $/, "$1")
+				});
+				index = close + ticks;
+				continue;
+			}
+			buffer += fence;
+			index += ticks;
+			continue;
+		}
+		if (depth < MAX_INLINE_DEPTH && (char === "*" || char === "_")) {
+			const double = text[index + 1] === char;
+			const delimiter = double ? char + char : char;
+			const start = index + delimiter.length;
+			if (char === "_" && index > 0 && /[A-Za-z0-9]/.test(text[index - 1] ?? "")) {
+				buffer += delimiter;
+				index = start;
+				continue;
+			}
+			const next = text[start];
+			if (next !== void 0 && !/\s/.test(next)) {
+				const close = findClosing(text, delimiter, start);
+				if (double && !(close > start && !/\s/.test(text[close - 1] ?? " "))) {
+					buffer += delimiter;
+					index = start;
+					continue;
+				}
+				if (close > start && !/\s/.test(text[close - 1] ?? " ")) {
+					flush();
+					out.push({
+						kind: double ? "strong" : "em",
+						children: parseInline(text.slice(start, close), depth + 1, options)
+					});
+					index = close + delimiter.length;
+					continue;
+				}
+			}
+		}
+		if (char === "[" && text[index + 1] === "^" && options.citations && !options.inLink) {
+			const cite = citationAt(text, index, options.citations);
+			if (cite && cite.kind === "cite") {
+				flush();
+				out.push(cite);
+				index += cite.raw.length;
+				continue;
+			}
+		}
+		if (depth < MAX_INLINE_DEPTH && char === "[") {
+			brackets ??= bracketMatches(text);
+			const labelEnd = brackets.get(index) ?? -1;
+			if (labelEnd > index && text[labelEnd + 1] === "(") {
+				if (paren !== -1 && paren < labelEnd + 2) paren = text.indexOf(")", labelEnd + 2);
+				const hrefEnd = paren;
+				if (hrefEnd > labelEnd + 1) {
+					const href = safeHref(text.slice(labelEnd + 2, hrefEnd));
+					if (href) {
+						flush();
+						out.push({
+							kind: "link",
+							href,
+							children: parseInline(text.slice(index + 1, labelEnd), depth + 1, {
+								...options,
+								inLink: true
+							})
+						});
+						index = hrefEnd + 1;
+						continue;
+					}
+				}
+			}
+		}
+		buffer += char;
+		index += 1;
+	}
+	flush();
+	return out;
+}
+function findClosing(text, delimiter, from) {
+	let index = from;
+	while (index < text.length) {
+		if (text[index] === "`") {
+			const close = text.indexOf("`", index + 1);
+			if (close < 0) return -1;
+			index = close + 1;
+			continue;
+		}
+		if (text[index] === delimiter[0]) {
+			let end = index + 1;
+			while (text[end] === delimiter[0]) end += 1;
+			const run = end - index;
+			if (delimiter.length === 1) {
+				if (run % 2 === 1) return end - 1;
+			} else if (run >= delimiter.length) return end - delimiter.length;
+			index = end;
+			continue;
+		}
+		index += 1;
+	}
+	return -1;
+}
+/**
+* The `]` that closes each `[`, found in one pass. A match never crosses a
+* newline, and an unmatched `[` has no entry. Scanning forward from every `[`
+* instead is quadratic on a long line of unclosed brackets, which a pasted page
+* or a hostile model can use to hang the renderer.
+*/
+function bracketMatches(text) {
+	const matches = /* @__PURE__ */ new Map();
+	const open = [];
+	for (let index = 0; index < text.length; index += 1) {
+		const char = text[index];
+		if (char === "[") open.push(index);
+		else if (char === "]") {
+			const start = open.pop();
+			if (start !== void 0) matches.set(start, index);
+		} else if (char === "\n") open.length = 0;
+	}
+	return matches;
+}
+/** Parse text into blocks. Pure, total, and linear in the length of `text`. */
+function parseMessageText(text, options = {}) {
+	const inline = (source) => parseInline(source, 0, { citations: options.citations });
+	const lines = text.replace(/\r\n?/g, "\n").split("\n");
+	const blocks = [];
+	let paragraph = [];
+	const flushParagraph = () => {
+		if (paragraph.length === 0) return;
+		const raw = paragraph.join("\n");
+		blocks.push({
+			kind: "paragraph",
+			inline: inline(raw),
+			raw
+		});
+		paragraph = [];
+	};
+	let index = 0;
+	while (index < lines.length) {
+		const line = lines[index];
+		const fence = fenceOpen(line);
+		if (fence) {
+			flushParagraph();
+			const marker = fence.marker;
+			const language = fence.language || void 0;
+			const body = [];
+			let closed = false;
+			index += 1;
+			while (index < lines.length) {
+				const candidate = lines[index];
+				const close = /^ {0,3}(`{3,}|~{3,})[ \t]*$/.exec(candidate);
+				if (close && close[1][0] === marker[0] && close[1].length >= marker.length) {
+					closed = true;
+					index += 1;
+					break;
+				}
+				body.push(candidate);
+				index += 1;
+			}
+			const code = body.join("\n");
+			blocks.push({
+				kind: "code",
+				language,
+				code,
+				complete: closed || !options.streaming,
+				raw: `${marker}${language ?? ""}\n${code}${closed ? `\n${marker}` : ""}`
+			});
+			continue;
+		}
+		if (line.trim() === "") {
+			flushParagraph();
+			index += 1;
+			continue;
+		}
+		const heading = headingOf(line);
+		if (heading) {
+			flushParagraph();
+			blocks.push({
+				kind: "heading",
+				level: heading.level,
+				inline: inline(heading.text),
+				raw: line
+			});
+			index += 1;
+			continue;
+		}
+		const bullet = BULLET.exec(line);
+		const ordered = bullet ? null : ORDERED.exec(line);
+		if (bullet || ordered) {
+			flushParagraph();
+			const items = [];
+			const rawLines = [];
+			const isOrdered = ordered !== null;
+			const start = ordered ? Number(ordered[1]) : 1;
+			while (index < lines.length) {
+				const current = lines[index];
+				const match = isOrdered ? ORDERED.exec(current) : BULLET.exec(current);
+				if (match) {
+					items.push([...inline(isOrdered ? match[2] : match[1])]);
+					rawLines.push(current);
+					index += 1;
+					continue;
+				}
+				if (/^ {2,}\S/.test(current) && items.length > 0) {
+					const item = items[items.length - 1];
+					item.push({
+						kind: "text",
+						text: " "
+					});
+					for (const span of inline(current.trim())) item.push(span);
+					rawLines.push(current);
+					index += 1;
+					continue;
+				}
+				break;
+			}
+			blocks.push({
+				kind: "list",
+				ordered: isOrdered,
+				start,
+				items,
+				raw: rawLines.join("\n")
+			});
+			continue;
+		}
+		if (QUOTE.exec(line)) {
+			flushParagraph();
+			const quoted = [];
+			while (index < lines.length) {
+				const match = QUOTE.exec(lines[index]);
+				if (!match) break;
+				quoted.push(match[1]);
+				index += 1;
+			}
+			const raw = quoted.join("\n");
+			blocks.push({
+				kind: "quote",
+				inline: inline(raw),
+				raw
+			});
+			continue;
+		}
+		paragraph.push(line);
+		index += 1;
+	}
+	flushParagraph();
+	return blocks;
+}
+//#endregion
+export { parseInline, parseMessageText, safeHref };
+
+//# sourceMappingURL=parse-message-text.js.map

package/dist/components/ui/message/parse-message-text.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-message-text.js","names":[],"sources":["../../../../src/components/ui/message/parse-message-text.ts"],"sourcesContent":["/**\n * A small, safe reading of model and user text.\n *\n * Assistant output is untrusted: it can contain anything a model, a tool result\n * or a pasted web page put there. This parser therefore produces *data* —\n * blocks and inline spans — and the renderer turns that data into text nodes and\n * a fixed set of elements. There is no HTML pass, no `innerHTML`, and no\n * attribute built from the text other than a link `href` that has passed\n * `safeHref`.\n *\n * It reads a deliberately small subset of Markdown: fenced code, headings,\n * flat lists, block quotes, paragraphs, and inline code, bold, italic and links.\n * Anything it does not recognise stays as paragraph text with its line breaks\n * (the paragraph renders `white-space: pre-wrap`), so unsupported syntax\n * degrades to readable source instead of vanishing.\n *\n * A citation marker, `[^1]` or `[^1,2]`, is read only when the caller says how\n * many sources it has (`citations`) and every number names one of them. A marker\n * the host cannot resolve stays literal text: it is never a citation by shape\n * alone, and `arr[1]` or a footnote the model invented is not one either.\n *\n * Streaming is a first-class input. `streaming: true` means the text may end\n * mid-construct, so an unterminated fence is a *partial* code block — shown as\n * code from its first line, flagged incomplete — and an unterminated inline\n * span stays literal until its closing delimiter arrives. Once streaming stops,\n * an unterminated fence is just a code block that ends at the end of the text.\n */\n\nexport type MessageInline =\n  | Readonly<{ kind: 'text'; text: string }>\n  | Readonly<{ kind: 'code'; text: string }>\n  | Readonly<{ kind: 'strong'; children: readonly MessageInline[] }>\n  | Readonly<{ kind: 'em'; children: readonly MessageInline[] }>\n  | Readonly<{ kind: 'link'; href: string; children: readonly MessageInline[] }>\n  /** A resolved citation marker: 1-based source numbers, each within `citations`. */\n  | Readonly<{ kind: 'cite'; numbers: readonly number[]; raw: string }>\n\nexport type MessageBlock =\n  | Readonly<{ kind: 'paragraph'; inline: readonly MessageInline[]; raw: string }>\n  | Readonly<{\n      kind: 'heading'\n      level: 1 | 2 | 3 | 4\n      inline: readonly MessageInline[]\n      raw: string\n    }>\n  | Readonly<{\n      kind: 'list'\n      ordered: boolean\n      start: number\n      items: readonly (readonly MessageInline[])[]\n      raw: string\n    }>\n  | Readonly<{ kind: 'quote'; inline: readonly MessageInline[]; raw: string }>\n  | Readonly<{\n      kind: 'code'\n      language: string | undefined\n      code: string\n      /** False while the fence is still open and the text may still grow. */\n      complete: boolean\n      raw: string\n    }>\n\nconst WHITESPACE = /\\s/\n\n/**\n * An opening fence: up to three spaces, a run of three or more backticks or of\n * three or more tildes, then an info string that holds no backtick. The first\n * word of the info string is the language. This is a scan, not one pattern,\n * because a pattern whose classes overlap (`[^\\s`]*` then `[^`]*`) retries every\n * split of a long info string when a stray backtick ends it: three backticks, a\n * long run of `a` and a trailing backtick took quadratic time.\n */\nfunction fenceOpen(line: string): Readonly<{ marker: string; language: string }> | undefined {\n  let start = 0\n  while (start < 3 && line.charCodeAt(start) === 32) start += 1\n  const mark = line[start]\n  if (mark !== '`' && mark !== '~') return undefined\n  let end = start + 1\n  while (line[end] === mark) end += 1\n  if (end - start < 3) return undefined\n  if (line.includes('`', end)) return undefined\n  let wordStart = end\n  while (line[wordStart] === ' ' || line[wordStart] === '\\t') wordStart += 1\n  let wordEnd = wordStart\n  while (wordEnd < line.length && !WHITESPACE.test(line[wordEnd]!)) wordEnd += 1\n  return { marker: line.slice(start, end), language: line.slice(wordStart, wordEnd) }\n}\n// The lookahead after each marker's spaces makes that run maximal, so a line\n// that fails later (`.` stops at U+2028) cannot retry every shorter run.\nconst BULLET = /^ {0,3}[-*+][ \\t]+(?![ \\t])(.*)$/\nconst ORDERED = /^ {0,3}(\\d{1,9})[.)][ \\t]+(?![ \\t])(.*)$/\nconst QUOTE = /^ {0,3}>[ \\t]?(.*)$/\n\nconst isBlank = (char: string | undefined) => char === ' ' || char === '\\t'\nconst LINE_TERMINATOR = /[\\n\\r\\u2028\\u2029]/\n\n/**\n * An ATX heading: up to three spaces, one to four `#`, spaces or tabs, then the\n * text, with any trailing spaces and closing `#` run removed. This is a scan for\n * the reason `fenceOpen` is: the equivalent pattern (`(.+?)[ \\t]*#*[ \\t]*$`)\n * retries the closing check from every position of a long run of spaces.\n */\nfunction headingOf(line: string): Readonly<{ level: 1 | 2 | 3 | 4; text: string }> | undefined {\n  let start = 0\n  while (start < 3 && line.charCodeAt(start) === 32) start += 1\n  let marks = start\n  while (line[marks] === '#') marks += 1\n  const level = marks - start\n  if (level < 1 || level > 4 || !isBlank(line[marks])) return undefined\n  let textStart = marks\n  while (isBlank(line[textStart])) textStart += 1\n  if (textStart === line.length) {\n    // Only blanks follow the marker: the text is the last of them, which needs a second one.\n    return textStart - marks >= 2\n      ? { level: level as 1 | 2 | 3 | 4, text: line[line.length - 1]! }\n      : undefined\n  }\n  if (LINE_TERMINATOR.test(line.slice(textStart))) return undefined\n  // Drop the longest tail of blanks, a run of `#`, and blanks again.\n  let textEnd = line.length\n  while (textEnd > textStart && isBlank(line[textEnd - 1])) textEnd -= 1\n  while (textEnd > textStart && line[textEnd - 1] === '#') textEnd -= 1\n  while (textEnd > textStart && isBlank(line[textEnd - 1])) textEnd -= 1\n  // Text that is nothing but a closing run keeps its first character.\n  return {\n    level: level as 1 | 2 | 3 | 4,\n    text: line.slice(textStart, Math.max(textEnd, textStart + 1)),\n  }\n}\n\n/** Only these schemes become links; everything else is shown as its text. */\nexport function safeHref(value: string): string | undefined {\n  const trimmed = value.trim()\n  if (trimmed.length === 0 || trimmed.length > 2048) return undefined\n  // Control characters and whitespace inside a URL are a scheme-smuggling vector.\n  // oxlint-disable-next-line no-control-regex\n  if (/[\\u0000- \\u007f]/.test(trimmed)) return undefined\n  try {\n    const url = new URL(trimmed)\n    return url.protocol === 'http:' || url.protocol === 'https:' || url.protocol === 'mailto:'\n      ? trimmed\n      : undefined\n  } catch {\n    return undefined\n  }\n}\n\nconst MAX_INLINE_DEPTH = 4\n\n/** A marker may cite at most this many sources, so one cannot flood a sentence. */\nconst MAX_CITED_SOURCES = 6\nconst CITATION = /\\[\\^(\\d{1,4}(?:[ \\t]*,[ \\t]*\\d{1,4}){0,5})\\]/y\n\nexport type ParseInlineOptions = {\n  /** How many sources the host has. Without it no marker is a citation. */\n  citations?: number\n  /** Inside a link label, where a citation (itself a button) must not nest. */\n  inLink?: boolean\n}\n\nfunction citationAt(text: string, index: number, count: number): MessageInline | undefined {\n  CITATION.lastIndex = index\n  const match = CITATION.exec(text)\n  if (!match) return undefined\n  const numbers = [...new Set(match[1]!.split(',').map((part) => Number(part.trim())))]\n  if (numbers.length > MAX_CITED_SOURCES) return undefined\n  if (numbers.some((number) => number < 1 || number > count)) return undefined\n  return { kind: 'cite', numbers, raw: match[0] }\n}\n\n/** Inline spans. Delimiters must close on the same block, or they stay literal. */\nexport function parseInline(\n  text: string,\n  depth = 0,\n  options: ParseInlineOptions = {}\n): readonly MessageInline[] {\n  const out: MessageInline[] = []\n  let brackets: ReadonlyMap<number, number> | undefined\n  let paren = -2\n  let buffer = ''\n  const flush = () => {\n    if (buffer) out.push({ kind: 'text', text: buffer })\n    buffer = ''\n  }\n  let index = 0\n  while (index < text.length) {\n    const char = text[index]!\n    if (char === '`') {\n      let ticks = 1\n      while (text[index + ticks] === '`') ticks += 1\n      const fence = '`'.repeat(ticks)\n      const close = text.indexOf(fence, index + ticks)\n      if (close > index + ticks) {\n        flush()\n        out.push({ kind: 'code', text: text.slice(index + ticks, close).replace(/^ (.*) $/, '$1') })\n        index = close + ticks\n        continue\n      }\n      buffer += fence\n      index += ticks\n      continue\n    }\n    if (depth < MAX_INLINE_DEPTH && (char === '*' || char === '_')) {\n      const double = text[index + 1] === char\n      const delimiter = double ? char + char : char\n      const start = index + delimiter.length\n      // Word-internal underscores cannot open emphasis. Reject before scanning,\n      // and consume both marks so the second cannot rescan the remaining pairs.\n      if (char === '_' && index > 0 && /[A-Za-z0-9]/.test(text[index - 1] ?? '')) {\n        buffer += delimiter\n        index = start\n        continue\n      }\n      const next = text[start]\n      // A delimiter opens only before a non-space, so `a * b * c` and `2 * 3` stay arithmetic.\n      if (next !== undefined && !/\\s/.test(next)) {\n        const close = findClosing(text, delimiter, start)\n        if (double && !(close > start && !/\\s/.test(text[close - 1] ?? ' '))) {\n          // An opener that does not close stays literal as a pair. Retrying its\n          // second mark as emphasis would scan to the end of the line again, so a\n          // line of unclosed `**a ` would be quadratic.\n          buffer += delimiter\n          index = start\n          continue\n        }\n        if (close > start && !/\\s/.test(text[close - 1] ?? ' ')) {\n          flush()\n          out.push({\n            kind: double ? 'strong' : 'em',\n            children: parseInline(text.slice(start, close), depth + 1, options),\n          })\n          index = close + delimiter.length\n          continue\n        }\n      }\n    }\n    if (char === '[' && text[index + 1] === '^' && options.citations && !options.inLink) {\n      const cite = citationAt(text, index, options.citations)\n      if (cite && cite.kind === 'cite') {\n        flush()\n        out.push(cite)\n        index += cite.raw.length\n        continue\n      }\n    }\n    if (depth < MAX_INLINE_DEPTH && char === '[') {\n      brackets ??= bracketMatches(text)\n      const labelEnd = brackets.get(index) ?? -1\n      if (labelEnd > index && text[labelEnd + 1] === '(') {\n        // The nearest `)` is remembered: a run of `[a](` with no `)` after it\n        // would otherwise search to the end of the text from every opener.\n        if (paren !== -1 && paren < labelEnd + 2) paren = text.indexOf(')', labelEnd + 2)\n        const hrefEnd = paren\n        if (hrefEnd > labelEnd + 1) {\n          const href = safeHref(text.slice(labelEnd + 2, hrefEnd))\n          if (href) {\n            flush()\n            out.push({\n              kind: 'link',\n              href,\n              children: parseInline(text.slice(index + 1, labelEnd), depth + 1, {\n                ...options,\n                inLink: true,\n              }),\n            })\n            index = hrefEnd + 1\n            continue\n          }\n        }\n      }\n    }\n    buffer += char\n    index += 1\n  }\n  flush()\n  return out\n}\n\nfunction findClosing(text: string, delimiter: string, from: number): number {\n  let index = from\n  while (index < text.length) {\n    if (text[index] === '`') {\n      // Skip a code span so `**a `**` b**` closes where the code ends.\n      const close = text.indexOf('`', index + 1)\n      if (close < 0) return -1\n      index = close + 1\n      continue\n    }\n    if (text[index] === delimiter[0]) {\n      let end = index + 1\n      while (text[end] === delimiter[0]) end += 1\n      const run = end - index\n      if (delimiter.length === 1) {\n        // Emphasis closes on a run of one (or an odd run, whose last mark closes).\n        // An even run is `**` pairs: strong spans inside the emphasis, which the\n        // inner parse reads. One pass, and the scan stops at the next odd run, so\n        // a line of unclosed delimiters is still linear.\n        if (run % 2 === 1) return end - 1\n      } else if (run >= delimiter.length) {\n        // Strong closes on the last two marks of a run.\n        return end - delimiter.length\n      }\n      index = end\n      continue\n    }\n    index += 1\n  }\n  return -1\n}\n\n/**\n * The `]` that closes each `[`, found in one pass. A match never crosses a\n * newline, and an unmatched `[` has no entry. Scanning forward from every `[`\n * instead is quadratic on a long line of unclosed brackets, which a pasted page\n * or a hostile model can use to hang the renderer.\n */\nfunction bracketMatches(text: string): ReadonlyMap<number, number> {\n  const matches = new Map<number, number>()\n  const open: number[] = []\n  for (let index = 0; index < text.length; index += 1) {\n    const char = text[index]\n    if (char === '[') open.push(index)\n    else if (char === ']') {\n      const start = open.pop()\n      if (start !== undefined) matches.set(start, index)\n    } else if (char === '\\n') open.length = 0\n  }\n  return matches\n}\n\n/** Parse text into blocks. Pure, total, and linear in the length of `text`. */\nexport function parseMessageText(\n  text: string,\n  options: { streaming?: boolean; citations?: number } = {}\n): readonly MessageBlock[] {\n  const inline = (source: string) => parseInline(source, 0, { citations: options.citations })\n  const lines = text.replace(/\\r\\n?/g, '\\n').split('\\n')\n  const blocks: MessageBlock[] = []\n  let paragraph: string[] = []\n  const flushParagraph = () => {\n    if (paragraph.length === 0) return\n    const raw = paragraph.join('\\n')\n    blocks.push({ kind: 'paragraph', inline: inline(raw), raw })\n    paragraph = []\n  }\n\n  let index = 0\n  while (index < lines.length) {\n    const line = lines[index]!\n    const fence = fenceOpen(line)\n    if (fence) {\n      flushParagraph()\n      const marker = fence.marker\n      const language = fence.language || undefined\n      const body: string[] = []\n      let closed = false\n      index += 1\n      while (index < lines.length) {\n        const candidate = lines[index]!\n        const close = /^ {0,3}(`{3,}|~{3,})[ \\t]*$/.exec(candidate)\n        if (close && close[1]![0] === marker[0] && close[1]!.length >= marker.length) {\n          closed = true\n          index += 1\n          break\n        }\n        body.push(candidate)\n        index += 1\n      }\n      const code = body.join('\\n')\n      blocks.push({\n        kind: 'code',\n        language,\n        code,\n        complete: closed || !options.streaming,\n        raw: `${marker}${language ?? ''}\\n${code}${closed ? `\\n${marker}` : ''}`,\n      })\n      continue\n    }\n    if (line.trim() === '') {\n      flushParagraph()\n      index += 1\n      continue\n    }\n    const heading = headingOf(line)\n    if (heading) {\n      flushParagraph()\n      blocks.push({\n        kind: 'heading',\n        level: heading.level,\n        inline: inline(heading.text),\n        raw: line,\n      })\n      index += 1\n      continue\n    }\n    const bullet = BULLET.exec(line)\n    const ordered = bullet ? null : ORDERED.exec(line)\n    if (bullet || ordered) {\n      flushParagraph()\n      const items: MessageInline[][] = []\n      const rawLines: string[] = []\n      const isOrdered = ordered !== null\n      const start = ordered ? Number(ordered[1]) : 1\n      while (index < lines.length) {\n        const current = lines[index]!\n        const match = isOrdered ? ORDERED.exec(current) : BULLET.exec(current)\n        if (match) {\n          items.push([...inline(isOrdered ? match[2]! : match[1]!)])\n          rawLines.push(current)\n          index += 1\n          continue\n        }\n        // An indented continuation belongs to the previous item.\n        if (/^ {2,}\\S/.test(current) && items.length > 0) {\n          // Append in place: copying the accumulated spans on every continuation\n          // makes a long item quadratic in its number of lines. Push one span at\n          // a time, because spreading a line of many spans into `push` exceeds\n          // the engine's argument limit and throws.\n          const item = items[items.length - 1]!\n          item.push({ kind: 'text', text: ' ' })\n          for (const span of inline(current.trim())) item.push(span)\n          rawLines.push(current)\n          index += 1\n          continue\n        }\n        break\n      }\n      blocks.push({ kind: 'list', ordered: isOrdered, start, items, raw: rawLines.join('\\n') })\n      continue\n    }\n    const quote = QUOTE.exec(line)\n    if (quote) {\n      flushParagraph()\n      const quoted: string[] = []\n      while (index < lines.length) {\n        const match = QUOTE.exec(lines[index]!)\n        if (!match) break\n        quoted.push(match[1]!)\n        index += 1\n      }\n      const raw = quoted.join('\\n')\n      blocks.push({ kind: 'quote', inline: inline(raw), raw })\n      continue\n    }\n    paragraph.push(line)\n    index += 1\n  }\n  flushParagraph()\n  return blocks\n}\n"],"mappings":"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"}

package/dist/components/ui/questionnaire/index.d.ts

@@ -0,0 +1,2 @@
+export { isQuestionAnswered, Questionnaire, type QuestionnaireAnswer, type QuestionnaireAnswers, type QuestionnaireOption, type QuestionnaireProps, type QuestionnaireQuestion, type QuestionnaireStatus, } from './questionnaire';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/ui/questionnaire/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/ui/questionnaire/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,aAAa,EACb,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,qBAAqB,EAC1B,KAAK,mBAAmB,GACzB,MAAM,iBAAiB,CAAA"}

package/dist/components/ui/questionnaire/index.js

@@ -0,0 +1,2 @@
+import { Questionnaire, isQuestionAnswered } from "./questionnaire.js";
+export { Questionnaire, isQuestionAnswered };

package/dist/components/ui/questionnaire/questionnaire.d.ts

@@ -0,0 +1,83 @@
+import { type ComponentProps, type JSX } from 'solid-js';
+/**
+ * Questionnaire.
+ *
+ * The agent has stopped and is asking the person something before it continues.
+ * This is the one place in a transcript where the reader *must* act, so it is
+ * the one element allowed to look like a card — and it only ever asks what the
+ * runtime actually asked.
+ *
+ * ## What it models
+ *
+ * One question or several. Each has a prompt and, optionally, a closed set of
+ * options (single choice, or `multiple`) and/or a free-text answer. A question
+ * with only a prompt is a text box; the runtime contract that exists today is
+ * exactly that. Options are shown only when the producer supplied them, which is
+ * why they are data here and not something this component can invent.
+ *
+ * Several questions are asked one at a time, with "Question 2 of 3" and Back /
+ * Next, because a wall of unrelated fields is how a person answers none of them
+ * well. Moving between them returns focus to the question, so a screen-reader
+ * user hears what they are now answering.
+ *
+ * ## It does not decide whether you may answer
+ *
+ * `status` and `disabledReason` come from the host, which owns authority (is
+ * this session connected, is the generation current, does this client have the
+ * input). A disabled questionnaire says *why* in words next to the button.
+ * `answered` and `expired` render the exchange read-only, so a settled question
+ * stays in the record as what was asked and what was answered.
+ *
+ * Submit is `Cmd/Ctrl+Enter` from any text field; plain Enter stays a newline.
+ */
+export type QuestionnaireOption = Readonly<{
+    id: string;
+    label: string;
+    description?: string;
+}>;
+export type QuestionnaireQuestion = Readonly<{
+    id: string;
+    prompt: string;
+    description?: string;
+    options?: readonly QuestionnaireOption[];
+    /** Allow more than one option. */
+    multiple?: boolean;
+    /** Offer a free-text answer (always present when there are no options). */
+    allowText?: boolean;
+    textLabel?: string;
+    textPlaceholder?: string;
+    /** The question may be skipped. */
+    optional?: boolean;
+}>;
+export type QuestionnaireAnswer = Readonly<{
+    optionIds: readonly string[];
+    text: string;
+}>;
+export type QuestionnaireAnswers = Readonly<Record<string, QuestionnaireAnswer>>;
+export type QuestionnaireStatus = 'open' | 'submitting' | 'answered' | 'expired';
+/**
+ * The answer a record holds for a question. Question ids are host strings, and
+ * the record is an ordinary object, so `constructor`, `toString` and `__proto__`
+ * are valid ids that a plain index would resolve to inherited values and a
+ * summary or a validity check would then read `optionIds` from.
+ */
+export declare function answerFor(record: QuestionnaireAnswers, question: Pick<QuestionnaireQuestion, 'id'>): QuestionnaireAnswer | undefined;
+/** Whether a question has what it needs. */
+export declare function isQuestionAnswered(question: QuestionnaireQuestion, answer: QuestionnaireAnswer | undefined): boolean;
+export type QuestionnaireProps = Omit<ComponentProps<'section'>, 'onSubmit' | 'title'> & {
+    questions: readonly QuestionnaireQuestion[];
+    title?: string;
+    description?: string;
+    status?: QuestionnaireStatus;
+    answers?: QuestionnaireAnswers;
+    defaultAnswers?: QuestionnaireAnswers;
+    onAnswersChange?: (answers: QuestionnaireAnswers) => void;
+    onSubmit?: (answers: QuestionnaireAnswers) => void | Promise<void>;
+    /** Why answering is not possible right now; shown beside the button. */
+    disabledReason?: string;
+    /** A failed submit, in words. */
+    error?: string;
+    submitLabel?: string;
+};
+export declare function Questionnaire(props: QuestionnaireProps): JSX.Element;
+//# sourceMappingURL=questionnaire.d.ts.map

package/dist/components/ui/questionnaire/questionnaire.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"questionnaire.d.ts","sourceRoot":"","sources":["../../../../src/components/ui/questionnaire/questionnaire.tsx"],"names":[],"mappings":"AACA,OAAO,EASL,KAAK,cAAc,EACnB,KAAK,GAAG,EACT,MAAM,UAAU,CAAA;AAOjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,MAAM,mBAAmB,GAAG,QAAQ,CAAC;IACzC,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB,CAAC,CAAA;AAEF,MAAM,MAAM,qBAAqB,GAAG,QAAQ,CAAC;IAC3C,EAAE,EAAE,MAAM,CAAA;IACV,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,OAAO,CAAC,EAAE,SAAS,mBAAmB,EAAE,CAAA;IACxC,kCAAkC;IAClC,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,2EAA2E;IAC3E,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,mCAAmC;IACnC,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,CAAC,CAAA;AAEF,MAAM,MAAM,mBAAmB,GAAG,QAAQ,CAAC;IAAE,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAAA;AAC1F,MAAM,MAAM,oBAAoB,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC,CAAA;AAChF,MAAM,MAAM,mBAAmB,GAAG,MAAM,GAAG,YAAY,GAAG,UAAU,GAAG,SAAS,CAAA;AAIhF;;;;;GAKG;AACH,wBAAgB,SAAS,CACvB,MAAM,EAAE,oBAAoB,EAC5B,QAAQ,EAAE,IAAI,CAAC,qBAAqB,EAAE,IAAI,CAAC,GAC1C,mBAAmB,GAAG,SAAS,CAEjC;AAED,4CAA4C;AAC5C,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,qBAAqB,EAC/B,MAAM,EAAE,mBAAmB,GAAG,SAAS,GACtC,OAAO,CAGT;AAED,MAAM,MAAM,kBAAkB,GAAG,IAAI,CAAC,cAAc,CAAC,SAAS,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,GAAG;IACvF,SAAS,EAAE,SAAS,qBAAqB,EAAE,CAAA;IAC3C,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,MAAM,CAAC,EAAE,mBAAmB,CAAA;IAC5B,OAAO,CAAC,EAAE,oBAAoB,CAAA;IAC9B,cAAc,CAAC,EAAE,oBAAoB,CAAA;IACrC,eAAe,CAAC,EAAE,CAAC,OAAO,EAAE,oBAAoB,KAAK,IAAI,CAAA;IACzD,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE,oBAAoB,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAClE,wEAAwE;IACxE,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,iCAAiC;IACjC,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB,CAAA;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,kBAAkB,eA0UtD"}