@oh-my-pi/pi-tui 18.2.3 → 18.2.5

package/src/chat/image-loading.ts

@@ -0,0 +1,122 @@
+import type { ImageContent, Model } from "@oh-my-pi/pi-ai";
+import { formatBytes, parseImageMetadata, SUPPORTED_IMAGE_MIME_TYPES } from "@oh-my-pi/pi-utils";
+
+export const MAX_IMAGE_INPUT_BYTES = 20 * 1024 * 1024;
+
+export const SUPPORTED_INPUT_IMAGE_MIME_TYPES = SUPPORTED_IMAGE_MIME_TYPES;
+
+/**
+ * Ollama and its local-backend family decode image input through llama.cpp /
+ * `stb_image`, which is compiled without WebP support, so a WebP upload fails
+ * with an opaque HTTP 400. Detect those models so the resize pipeline encodes
+ * to PNG/JPEG instead — the automatic equivalent of `OMP_NO_WEBP=1`.
+ */
+export function modelLacksWebpSupport(
+	model: Pick<Model, "provider" | "api" | "imageInputDecoder"> | undefined,
+): boolean {
+	if (!model) return false;
+	return (
+		model.imageInputDecoder === "stb" ||
+		model.provider === "ollama" ||
+		model.provider === "ollama-cloud" ||
+		model.provider === "llama.cpp" ||
+		model.provider === "lm-studio" ||
+		model.provider === "local-server" ||
+		model.api === "ollama-chat"
+	);
+}
+
+/**
+ * `true` when `model` cannot decode WebP, otherwise `undefined` so the
+ * `OMP_NO_WEBP` env fallback in {@link resizeImage} still applies. Feed straight
+ * into {@link ImageResizeOptions.excludeWebP}.
+ */
+export function webpExclusionForModel(model: Pick<Model, "provider" | "api"> | undefined): true | undefined {
+	return modelLacksWebpSupport(model) ? true : undefined;
+}
+
+export class ImageInputTooLargeError extends Error {
+	readonly bytes: number;
+	readonly maxBytes: number;
+
+	constructor(bytes: number, maxBytes: number) {
+		super(`Image file too large: ${formatBytes(bytes)} exceeds ${formatBytes(maxBytes)} limit.`);
+		this.name = "ImageInputTooLargeError";
+		this.bytes = bytes;
+		this.maxBytes = maxBytes;
+	}
+}
+
+/**
+ * Raised when image bytes cannot be decoded — a truncated stream, a payload
+ * with a hole in the middle, or bytes that are not the container they claim.
+ * Failing at ingress keeps them out of the transcript, where they would
+ * otherwise be persisted and rejected by the provider on every later request,
+ * with no way to resume the session.
+ */
+export class InvalidImageDataError extends Error {
+	readonly reason: string;
+
+	constructor(label: string, mimeType: string, reason: string) {
+		super(`${label} is not a decodable ${mimeType} image: ${reason}`);
+		this.name = "InvalidImageDataError";
+		this.reason = reason;
+	}
+}
+
+/**
+ * Smallest raster the decode probe terminates into. The decode is the oracle,
+ * so the output size cannot change the verdict — a 1x1 sink keeps the check
+ * from allocating a full-size pixel buffer, a full-size PNG, and a base64
+ * string for a payload that may be up to {@link MAX_IMAGE_INPUT_BYTES}.
+ */
+const DECODE_PROBE_EDGE_PX = 1;
+
+/**
+ * Why an image cannot be decoded, or `null` when it decodes.
+ *
+ * A full decode is the only check that matches what vision backends accept: a
+ * middle-elided PNG keeps its signature, its header, and even a well-formed
+ * `IEND` trailer, so header sniffing and chunk-framing walks both pass it —
+ * while real-world images that decoders render happily do have odd framing, so
+ * a structural walk rejects payloads providers accept. Decoding is the ground
+ * truth on both sides. Callers on hot paths must cache the verdict.
+ */
+export async function imageDecodeFailureReason(image: ImageContent): Promise<string | null> {
+	if (!/^[A-Za-z0-9+/]*={0,2}$/.test(image.data)) return "invalid base64 image data";
+	const normalizedData = image.data.replace(/=+$/, "");
+	const bytes = Buffer.from(image.data, "base64");
+	if (bytes.length === 0) return "empty image data";
+	if (bytes.toString("base64").replace(/=+$/, "") !== normalizedData) return "invalid base64 image data";
+	const detected = parseImageMetadata(bytes);
+	if (detected && detected.mimeType !== image.mimeType.toLowerCase()) {
+		return `declared ${image.mimeType} but contains ${detected.mimeType}`;
+	}
+	try {
+		// Decode in full (that is what catches a hole in the compressed stream),
+		// then terminate into a 1x1 raster's bytes instead of re-encoding at the
+		// source dimensions and base64-ing a result nobody reads.
+		await new Bun.Image(bytes).resize(DECODE_PROBE_EDGE_PX, DECODE_PROBE_EDGE_PX).png().bytes();
+		return null;
+	} catch (error) {
+		return error instanceof Error ? error.message : String(error);
+	}
+}
+
+/** Converts an image to PNG, rejecting when the runtime cannot decode or encode it. */
+export async function convertImageToPng(image: ImageContent): Promise<ImageContent> {
+	const bytes = Buffer.from(image.data, "base64");
+	const data = await new Bun.Image(bytes).png().toBase64();
+	return { ...image, data, mimeType: "image/png" };
+}
+
+export async function ensureSupportedImageInput(image: ImageContent): Promise<ImageContent | null> {
+	if (SUPPORTED_INPUT_IMAGE_MIME_TYPES.has(image.mimeType)) {
+		return image;
+	}
+	try {
+		return await convertImageToPng(image);
+	} catch {
+		return null;
+	}
+}

package/src/chat/late-diagnostics-message.ts

@@ -0,0 +1,92 @@
+import { Container } from "../tui";
+import { Disclosure } from "../components/disclosure";
+import { Text } from "../components/text";
+import { formatDiagnostics } from "../render/render-utils";
+import { getLanguageFromPath, theme } from "../theme";
+
+const EMPTY_ROWS: readonly string[] = [];
+
+/** One file's worth of late LSP diagnostics, as carried on the transcript message. */
+export interface LateDiagnosticsFile {
+	path?: string;
+	summary?: string;
+	errored?: boolean;
+	messages?: string[];
+}
+
+/**
+ * Renders late LSP diagnostics (arrived after edit/write returned) in the
+ * transcript, reusing the same tree renderer the edit/write tools use so the
+ * styling stays consistent. Supports the global tool-output expand toggle.
+ */
+export class LateDiagnosticsMessageComponent extends Container {
+	#toolActivityVisible = true;
+	// Controlled expansion delegate with no summary: the collapsed and
+	// expanded diagnostic trees are mutually exclusive slots, each formatted
+	// lazily on its first render. Only the tool-visibility gate stays here.
+	#disclosure: Disclosure | undefined;
+	readonly #files: LateDiagnosticsFile[];
+
+	constructor(files: LateDiagnosticsFile[]) {
+		super();
+		this.#files = files;
+
+		this.#rebuild();
+	}
+
+	setExpanded(expanded: boolean): void {
+		this.#disclosure?.setExpanded(expanded);
+	}
+
+	setToolActivityVisible(visible: boolean): void {
+		this.#toolActivityVisible = visible;
+	}
+
+	override render(width: number): readonly string[] {
+		if (!this.#toolActivityVisible) return EMPTY_ROWS;
+		return super.render(width);
+	}
+
+	override invalidate(): void {
+		this.#rebuild();
+	}
+
+	#rebuild(): void {
+		// Preserve controlled state across theme-invalidation rebuilds while
+		// leaving both diagnostic trees unmaterialized until their next render.
+		const expanded = this.#disclosure?.expanded ?? false;
+		this.clear();
+		this.#disclosure?.dispose();
+		this.#disclosure = undefined;
+
+		const input = this.#diagnosticInput() ?? { errored: false, summary: "", messages: [] };
+
+		this.#disclosure = new Disclosure({
+			collapsedBody: () => new Text(this.#format(input, false), 1, 0),
+			body: () => new Text(this.#format(input, true), 1, 0),
+			expanded,
+		});
+		this.addChild(this.#disclosure);
+	}
+
+	/** Aggregate file payloads; undefined when there is nothing to render. */
+	#diagnosticInput(): { errored: boolean; summary: string; messages: string[] } | undefined {
+		const messages: string[] = [];
+		const summaries: string[] = [];
+		let errored = false;
+		for (const file of this.#files) {
+			if (file.messages?.length) messages.push(...file.messages);
+			if (file.summary) summaries.push(file.summary);
+			if (file.errored) errored = true;
+		}
+		if (messages.length === 0) return undefined;
+		return { errored, summary: summaries.join(", "), messages };
+	}
+
+	/** Render one branch of the diagnostic tree, reusing the tool renderer. */
+	#format(input: { errored: boolean; summary: string; messages: string[] }, expanded: boolean): string {
+		return formatDiagnostics(input, expanded, theme, fp => theme.getLangIcon(getLanguageFromPath(fp)), {
+			title: "Late diagnostics",
+		}).replace(/^\n+/, "");
+	}
+}

package/src/chat/messages.ts

@@ -0,0 +1,305 @@
+import type { AssistantMessage, ImageContent, MessageAttribution, TextContent } from "@oh-my-pi/pi-ai";
+import * as AIError from "@oh-my-pi/pi-ai/error";
+import { COLLAB_PROMPT_MESSAGE_TYPE } from "@oh-my-pi/pi-wire";
+import type { OutputMeta } from "../tools/output-meta";
+import type { BranchSummaryMessage, CompactionSummaryMessage } from "@oh-my-pi/pi-agent-core/compaction/messages";
+
+declare module "@oh-my-pi/pi-agent-core" {
+	interface CustomAgentMessages {
+		bashExecution: BashExecutionMessage;
+		pythonExecution: PythonExecutionMessage;
+		custom: CustomMessage;
+		hookMessage: HookMessage;
+		branchSummary: BranchSummaryMessage;
+		compactionSummary: CompactionSummaryMessage;
+		fileMention: FileMentionMessage;
+	}
+}
+export { COLLAB_PROMPT_MESSAGE_TYPE, type CollabPromptDetails } from "@oh-my-pi/pi-wire";
+export type { BranchSummaryMessage, CompactionSummaryMessage } from "@oh-my-pi/pi-agent-core/compaction/messages";
+
+export const SKILL_PROMPT_MESSAGE_TYPE = "skill-prompt";
+
+export const LSP_LATE_DIAGNOSTIC_MESSAGE_TYPE = "lsp-late-diagnostic";
+
+export const BACKGROUND_TAN_DISPATCH_MESSAGE_TYPE = "background-tan-dispatch";
+
+export const PREWALK_PLAN_MESSAGE_TYPE = "prewalk-plan";
+
+/** Custom message type for the transient Vibe mode directive. */
+export const VIBE_MODE_CONTEXT_MESSAGE_TYPE = "vibe-mode-context";
+
+/** Fallback type for extension-injected messages that omit a custom type. */
+export const DEFAULT_CUSTOM_MESSAGE_TYPE = "custom-message";
+
+/** Custom message carrying a coding request delegated by the live voice model. */
+export const LIVE_DELEGATION_MESSAGE_TYPE = "live-delegation";
+
+/** Content shape accepted for extension-injected messages. */
+export type CustomMessageContent = string | (TextContent | ImageContent)[];
+
+/** Public input accepted by `pi.sendMessage` and `AgentSession.sendCustomMessage`. */
+export type CustomMessagePayload<T = unknown> =
+	| string
+	| Partial<Pick<CustomMessage<T>, "customType" | "content" | "display" | "details" | "attribution">>;
+
+/** Custom message payload after applying runtime defaults. */
+export type NormalizedCustomMessagePayload<T = unknown> = Pick<
+	CustomMessage<T>,
+	"customType" | "content" | "display" | "details" | "attribution"
+>;
+
+/** Details persisted on a `/tan` background-dispatch breadcrumb. */
+export interface BackgroundTanDispatchDetails {
+	jobId: string;
+	work: string;
+	/** Forked clone session file, named `<agentId>.jsonl`; the Agent Hub reads its transcript. */
+	sessionFile: string;
+}
+
+export interface SkillPromptDetails {
+	name: string;
+	path: string;
+	args?: string;
+	/** The draft as submitted with its `/skill:<name>` token in place. A leading
+	 *  token renders as a skill callout, a mid-prompt token as an inline chip in
+	 *  a plain user bubble. Absent on sessions recorded before chips existed. */
+	prompt?: string;
+	lineCount: number;
+	/** Internal: compact label shown for a queued custom message. Optional —
+	 *  non-streaming skill prompts never set it. Stripped from persisted
+	 *  `details` by `SessionManager.appendCustomMessageEntry` via the
+	 *  `INTERNAL_DETAILS_FIELDS` allowlist below. */
+	__queueChipText?: string;
+}
+
+/** Sentinel value for `AssistantMessage.errorMessage` indicating that the abort
+ *  was an *expected internal transition* (plan-mode → execution compaction)
+ *  and must NOT surface as a red "Operation aborted" line. Distinct from
+ *  `undefined` (default) so user-cancel aborts with no errorMessage still
+ *  render normally. Persists through SessionManager so history replay
+ *  branches identically.
+ *
+ *  Consumers: `AgentSession.#handleAgentEvent` (stamper) writes this value;
+ *  `EventController.#handleMessageEnd`, `AssistantMessageComponent`,
+ *  `ui-helpers.addMessageToChat` (renderers), `AgentHubOverlayComponent
+ *  #buildTranscriptLines`, `runPrintMode`, and `AcpAgent#replayAssistantMessage`
+ *  (fallback error emission) read it via `isSilentAbort`. */
+export const SILENT_ABORT_MARKER = "__omp.silent_abort__";
+
+/** Type-guard for silent aborts. Renderers MUST call this helper so structured
+ *  `errorId` and legacy persisted marker messages stay in lockstep. */
+export function isSilentAbort(message: Pick<AssistantMessage, "errorId" | "errorMessage">): boolean {
+	return AIError.is(message.errorId, AIError.Flag.SilentAbort) || message.errorMessage === SILENT_ABORT_MARKER;
+}
+
+/** Reason threaded through `AbortController.abort(reason)` when the user aborts
+ *  the turn with Esc (see `AgentSession.abort`). The agent keeps it on the
+ *  aborted assistant message's `errorMessage` so queued follow-ups/tool-result
+ *  placeholders can distinguish a deliberate interrupt from a bare lifecycle
+ *  abort, but interactive renderers suppress this redundant transcript line. */
+export const USER_INTERRUPT_LABEL = "Interrupted by user";
+
+export function isUserInterruptAbort(message: Pick<AssistantMessage, "errorId" | "errorMessage">): boolean {
+	return AIError.is(message.errorId, AIError.Flag.UserInterrupt) || message.errorMessage === USER_INTERRUPT_LABEL;
+}
+
+export function shouldRenderAbortReason(message: Pick<AssistantMessage, "errorId" | "errorMessage">): boolean {
+	return !isSilentAbort(message) && !isUserInterruptAbort(message);
+}
+
+/** Sentinel `errorMessage` the agent stamps on any abort that carried no custom
+ *  reason (bare `abort()`). Renderers treat it as "no specific reason given". */
+export const GENERIC_ABORT_SENTINEL = "Request was aborted";
+
+/** Resolve the operator-facing label for an aborted assistant turn. A custom
+ *  abort reason threaded onto `errorMessage` is returned verbatim; aborts with
+ *  no threaded reason fall back to the retry-aware generic label. Call
+ *  `shouldRenderAbortReason` before rendering when user interrupts should stay
+ *  visually quiet. */
+export function resolveAbortLabel(
+	message: Pick<AssistantMessage, "errorId" | "errorMessage">,
+	retryAttempt = 0,
+): string {
+	const genericAbort =
+		AIError.is(message.errorId, AIError.Flag.Abort) ||
+		!message.errorMessage ||
+		message.errorMessage === GENERIC_ABORT_SENTINEL ||
+		isSilentAbort(message);
+	if (!genericAbort) {
+		return message.errorMessage!;
+	}
+	if (retryAttempt > 0) {
+		return `Aborted after ${retryAttempt} retry attempt${retryAttempt > 1 ? "s" : ""}`;
+	}
+	return "Operation aborted";
+}
+
+/** True when a persisted or extension-supplied value can be sent as custom-message content. */
+export function isCustomMessageContent(content: unknown): content is CustomMessageContent {
+	return typeof content === "string" || Array.isArray(content);
+}
+
+function normalizeCustomMessageContent(content: unknown): CustomMessageContent {
+	return isCustomMessageContent(content) ? content : "";
+}
+
+function normalizeCustomMessageType(customType: unknown): string {
+	return typeof customType === "string" && customType.length > 0 ? customType : DEFAULT_CUSTOM_MESSAGE_TYPE;
+}
+
+function normalizeCustomMessageAttribution(attribution: unknown): MessageAttribution {
+	return attribution === "user" ? "user" : "agent";
+}
+
+function isCustomMessagePayloadObject<T>(
+	payload: unknown,
+): payload is Partial<Pick<CustomMessage<T>, "customType" | "content" | "display" | "details" | "attribution">> {
+	return payload !== null && typeof payload === "object" && !Array.isArray(payload);
+}
+
+/** Normalizes extension-provided custom message input before it reaches session state or disk. */
+export function normalizeCustomMessagePayload<T = unknown>(
+	payload: CustomMessagePayload<T> | unknown,
+): NormalizedCustomMessagePayload<T> {
+	if (typeof payload === "string") {
+		return {
+			customType: DEFAULT_CUSTOM_MESSAGE_TYPE,
+			content: payload,
+			display: true,
+			attribution: "agent",
+		};
+	}
+	if (!isCustomMessagePayloadObject<T>(payload)) {
+		const content = payload === undefined || payload === null ? "" : String(payload);
+		return {
+			customType: DEFAULT_CUSTOM_MESSAGE_TYPE,
+			content,
+			display: content.length > 0,
+			attribution: "agent",
+		};
+	}
+	return {
+		customType: normalizeCustomMessageType(payload.customType),
+		content: normalizeCustomMessageContent(payload.content),
+		display: typeof payload.display === "boolean" ? payload.display : false,
+		details: payload.details,
+		attribution: normalizeCustomMessageAttribution(payload.attribution),
+	};
+}
+
+/**
+ * Message type for bash executions via the ! command.
+ */
+export interface BashExecutionMessage {
+	role: "bashExecution";
+	command: string;
+	output: string;
+	exitCode: number | undefined;
+	cancelled: boolean;
+	truncated: boolean;
+	/** Images extracted from terminal graphics in the command's stdout. */
+	images?: ImageContent[];
+	meta?: OutputMeta;
+	timestamp: number;
+	/** If true, this message is excluded from LLM context (!! prefix) */
+	excludeFromContext?: boolean;
+}
+
+/**
+ * Message type for user-initiated Python executions via the $ command.
+ * Shares the same kernel session as eval's Python backend.
+ */
+export interface PythonExecutionMessage {
+	role: "pythonExecution";
+	code: string;
+	output: string;
+	exitCode: number | undefined;
+	cancelled: boolean;
+	truncated: boolean;
+	meta?: OutputMeta;
+	timestamp: number;
+	/** If true, this message is excluded from LLM context ($ prefix) */
+	excludeFromContext?: boolean;
+}
+
+/**
+ * Message type for extension-injected messages via sendMessage().
+ */
+export interface CustomMessage<T = unknown> {
+	role: "custom";
+	customType: string;
+	content: CustomMessageContent;
+	display: boolean;
+	details?: T;
+	/** Who initiated this message for billing/attribution semantics. */
+	attribution?: MessageAttribution;
+	timestamp: number;
+}
+
+/**
+ * Legacy hook message type (pre-extensions). Kept for session migration.
+ */
+export interface HookMessage<T = unknown> {
+	role: "hookMessage";
+	customType: string;
+	content: CustomMessageContent;
+	display: boolean;
+	details?: T;
+	/** Who initiated this message for billing/attribution semantics. */
+	attribution?: MessageAttribution;
+	timestamp: number;
+}
+
+/**
+ * Message type for auto-read file mentions via @filepath syntax.
+ */
+export interface FileMentionMessage {
+	role: "fileMention";
+	files: Array<{
+		path: string;
+		content: string;
+		lineCount?: number;
+		/** File size in bytes, if known. */
+		byteSize?: number;
+		/** Why the file contents were omitted from auto-read. */
+		skippedReason?: "tooLarge" | "binary";
+		image?: ImageContent;
+	}>;
+	timestamp: number;
+}
+
+/** True for a `/skill:<name>` prompt the user invoked directly (attribution `user`), as opposed to an agent/autoload injection. */
+export function isUserInvokedSkillPrompt(message: CustomMessage): boolean {
+	return message.customType === SKILL_PROMPT_MESSAGE_TYPE && message.attribution === "user";
+}
+
+/**
+ * True for a custom message that initiates a user-attributed turn: a directly
+ * invoked `/skill:` prompt or a writable-collab peer's prompt. Agent redirects,
+ * reminders, and auto-continues are not turn starts.
+ */
+export function isUserTurnInitiator(message: CustomMessage): boolean {
+	return (
+		isUserInvokedSkillPrompt(message) ||
+		(message.customType === COLLAB_PROMPT_MESSAGE_TYPE && message.attribution === "user")
+	);
+}
+
+export type AdvisorSeverity = "nit" | "concern" | "blocker";
+
+/** One queued advice note. */
+export interface AdvisorNote {
+	note: string;
+	severity?: AdvisorSeverity;
+	/** Which configured advisor produced this note (omitted for the default advisor). */
+	advisor?: string;
+}
+
+/** Details payload on the batched `advisor` custom message rendered in the transcript. */
+export interface AdvisorMessageDetails {
+	notes: AdvisorNote[];
+}
+
+/** Custom message type for supervised process completions. */
+export const LAUNCH_COMPLETION_MESSAGE_TYPE = "launch-completion";

package/src/chat/reaction.ts

@@ -0,0 +1,65 @@
+/**
+ * Agent reactions. A reply whose text opens with an emoji is reacting to the
+ * transcript block before it: the emoji is lifted out of the prose and shown as
+ * a badge on that block instead. While the reply streams, an incomplete opening
+ * run is withheld until it either completes an emoji or proves to be ordinary
+ * text, so the emoji never flashes inside the reply.
+ *
+ * Reactions are derived from the persisted assistant text, never stored, so a
+ * rebuilt transcript reproduces them exactly.
+ */
+import { type Component } from "../tui";
+
+/** A transcript block that can display an agent reaction badge. */
+export interface ReactionTarget {
+	setReaction(emoji: string): void;
+}
+
+/** Whether `component` accepts a reaction badge. */
+export function isReactionTarget(component: Component | undefined): component is Component & ReactionTarget {
+	return component !== undefined && "setReaction" in component && typeof component.setReaction === "function";
+}
+
+/** Longest emoji grapheme (UTF-16 units) still worth withholding for. */
+const MAX_REACTION_UNITS = 32;
+/** One emoji grapheme: an RGI sequence, or a bare pictograph with optional VS16. */
+const REACTION_HEAD_RE = /^(?:\p{RGI_Emoji}|\p{Extended_Pictographic}\uFE0F?)/v;
+/** Unicode characters that can extend a preceding emoji code point into a longer grapheme. */
+const EMOJI_EXTENSION_RE = /^(?:[\p{Emoji_Modifier}\u{E0020}-\u{E007F}]|\uFE0F|\u200D|\u20E3)/u;
+/** A still-streaming run that can only ever be an emoji grapheme (plus trailing blanks): pictographs, skin tones, flag letters, tag letters, VS16, ZWJ, keycap. */
+const REACTION_PREFIX_RE =
+	/^(?:[\p{Extended_Pictographic}\p{Emoji_Modifier}\p{Regional_Indicator}\u{E0020}-\u{E007F}]|\uFE0F|\u200D|\u20E3)*[ \t]*$/u;
+/** Whitespace immediately following the opening emoji to consume: an inline newline or a run of horizontal spaces/tabs. */
+const NEXT_WHITESPACE_RE = /^[ \t]*\r?\n|^[ \t]+/;
+
+export interface ReactionSplit {
+	/** The reaction emoji when the text opens with an emoji. */
+	emoji?: string;
+	/** Text with the opening emoji and any following whitespace removed; the input when there is none. */
+	body: string;
+	/** True while the text could still grow into an emoji. */
+	pending: boolean;
+}
+
+/**
+ * Split an opening reaction emoji off the front of assistant text, consuming
+ * the next whitespace if any. Leading whitespace is tolerated.
+ */
+export function splitReaction(text: string): ReactionSplit {
+	const start = text.length - text.trimStart().length;
+	const head = text.slice(start);
+	if (head.length === 0) {
+		return { body: text, pending: true };
+	}
+	const match = head.match(REACTION_HEAD_RE);
+	if (match) {
+		const rest = head.slice(match[0].length);
+		if (head.length <= MAX_REACTION_UNITS && EMOJI_EXTENSION_RE.test(rest)) {
+			return { body: text, pending: true };
+		}
+		const wsMatch = rest.match(NEXT_WHITESPACE_RE);
+		const body = rest.slice(wsMatch ? wsMatch[0].length : 0);
+		return { emoji: match[0], body, pending: false };
+	}
+	return { body: text, pending: head.length <= MAX_REACTION_UNITS && REACTION_PREFIX_RE.test(head) };
+}

package/src/chat/read-target.ts

@@ -0,0 +1,7 @@
+/** Host-owned internal protocol classifier used by compact read cards. */
+export let internalReadTargetPredicate: ((target: string) => boolean) | undefined;
+
+/** Supply protocol classification without loading the host router in a renderer. */
+export function setInternalReadTargetPredicate(predicate: (target: string) => boolean): void {
+	internalReadTargetPredicate = predicate;
+}