@fitchmultz/pi-subagents 0.44.7 → 0.46.0

package/src/pi-intercom/types.ts

@@ -1,271 +1,369 @@
+import {
+  finiteNumber,
+  isRecord,
+  isUnknownArray,
+  optionalBoolean,
+  optionalFiniteNumber,
+  optionalLabel,
+  safeLabel,
+  safeText,
+} from "./validation.ts";
+
 export interface SessionInfo {
-  id: string;
-  name?: string;
-  cwd: string;
-  model: string;
+  readonly id: string;
+  readonly name?: string;
+  readonly cwd: string;
+  readonly model: string;
   /** Opaque same-repository/worktree identity used for ambient peer awareness. */
-  projectId?: string;
-  status?: string;
-  /** Last time the broker observed any activity from this session (liveness). */
-  lastSeen?: number;
-  /** Last time this session exchanged an intercom message (send/receive). */
-  lastIntercomActivity?: number;
-  /** Number of inbound asks this session still owes a reply to. */
-  pendingAsks?: number;
-  /** Whether this session is currently willing/able to answer asks. */
-  acceptsAsks?: boolean;
-  subscriptions?: TopicSubscription[];
-  topics?: TopicUpdate[];
+  readonly projectId?: string;
+  readonly status?: string;
+  readonly lastSeen?: number;
+  readonly lastIntercomActivity?: number;
+  readonly pendingAsks?: number;
+  readonly acceptsAsks?: boolean;
+  readonly subscriptions?: readonly TopicSubscription[];
+  readonly topics?: readonly TopicUpdate[];
 }
 
-export interface TopicSubscription { topic: string; awaitRelease?: boolean }
+export interface TopicSubscription {
+  readonly topic: string;
+  readonly awaitRelease?: boolean;
+}
 export interface TopicUpdate {
-  topic: string;
-  text: string;
-  event: "update" | "blocker" | "decision" | "release";
-  resource?: string;
-  ownership?: "held" | "released";
-  revision: number;
-  updatedAt: number;
+  readonly topic: string;
+  readonly text: string;
+  readonly event: "update" | "blocker" | "decision" | "release";
+  readonly resource?: string;
+  readonly ownership?: "held" | "released";
+  readonly revision: number;
+  readonly updatedAt: number;
 }
 
 export function isTopicSubscription(value: unknown): value is TopicSubscription {
-  if (!value || typeof value !== "object") return false;
-  const item = value as Record<string, unknown>;
-  return typeof item.topic === "string" && safeLabel(item.topic.trim()) && (item.awaitRelease === undefined || typeof item.awaitRelease === "boolean");
+  return (
+    isRecord(value) &&
+    typeof value.topic === "string" &&
+    safeLabel(value.topic.trim()) &&
+    optionalBoolean(value.awaitRelease)
+  );
+}
+
+function validTopicOwnership(item: Readonly<Record<string, unknown>>): boolean {
+  if (!optionalLabel(item.resource)) {
+    return false;
+  }
+  if (item.ownership === undefined) {
+    return true;
+  }
+  return (
+    typeof item.resource === "string" &&
+    (item.ownership === "held" || (item.ownership === "released" && item.event === "release"))
+  );
+}
+
+function validRevision(value: number): boolean {
+  return Number.isSafeInteger(value) && value > 0;
 }
 export function isTopicUpdate(value: unknown): value is TopicUpdate {
-  if (!value || typeof value !== "object") return false;
-  const item = value as Record<string, unknown>;
-  return typeof item.topic === "string" && safeLabel(item.topic.trim()) && typeof item.text === "string" && safeText(item.text)
-    && ["update", "blocker", "decision", "release"].includes(String(item.event))
-    && typeof item.revision === "number" && Number.isSafeInteger(item.revision) && item.revision > 0
-    && typeof item.updatedAt === "number" && Number.isFinite(item.updatedAt)
-    && (item.ownership !== "released" || item.event === "release")
-    && (item.resource === undefined || typeof item.resource === "string" && safeLabel(item.resource))
-    && (item.ownership === undefined || typeof item.resource === "string" && (item.ownership === "held" || item.ownership === "released"));
+  if (!isRecord(value) || typeof value.topic !== "string" || !safeLabel(value.topic.trim())) {
+    return false;
+  }
+  return (
+    safeText(value.text) &&
+    typeof value.event === "string" &&
+    ["update", "blocker", "decision", "release"].includes(value.event) &&
+    finiteNumber(value.revision) &&
+    validRevision(value.revision) &&
+    finiteNumber(value.updatedAt) &&
+    validTopicOwnership(value)
+  );
 }
 
 export type MessageDelivery = "queue" | "steer" | "passive";
 export type QueueMode = "stack" | "replace";
-
 export interface HumanMessageOrigin {
-  ownerSessionId: string;
-  runId: string;
-  index: number;
+  readonly ownerSessionId: string;
+  readonly runId: string;
+  readonly index: number;
 }
-
 export function isHumanMessageOrigin(value: unknown): value is HumanMessageOrigin {
-  if (!value || typeof value !== "object") return false;
-  const origin = value as Record<string, unknown>;
-  return typeof origin.ownerSessionId === "string" && /^[a-zA-Z0-9_-]+$/.test(origin.ownerSessionId)
-    && typeof origin.runId === "string" && /^[a-zA-Z0-9_-]+$/.test(origin.runId)
-    && typeof origin.index === "number" && Number.isSafeInteger(origin.index) && origin.index >= 0;
+  if (!isRecord(value)) {
+    return false;
+  }
+  return (
+    typeof value.ownerSessionId === "string" &&
+    /^[a-zA-Z0-9_-]+$/.test(value.ownerSessionId) &&
+    typeof value.runId === "string" &&
+    /^[a-zA-Z0-9_-]+$/.test(value.runId) &&
+    finiteNumber(value.index) &&
+    Number.isSafeInteger(value.index) &&
+    value.index >= 0
+  );
 }
 
 export interface Message {
-  id: string;
-  timestamp: number;
-  replyTo?: string;
-  expectsReply?: boolean;
-  /** Only the owning parent's human UI sets this; recipients verify ownership before elevating it. */
-  human?: HumanMessageOrigin;
-  topic?: TopicUpdate;
-  /** Active-recipient behavior. Omitted delivery defaults to steer unless expectsReply is true. */
-  delivery?: MessageDelivery;
-  /** For delivery="queue": stack normally, or replace older undelivered messages in the same thread. */
-  queueMode?: QueueMode;
-  /** Stable topic key for queueMode="replace". */
-  threadId?: string;
-  /** If true, render without waking the recipient model. Discouraged for agent-to-agent messages. */
-  passive?: boolean;
-  content: {
-    text: string;
-    attachments?: Attachment[];
+  readonly id: string;
+  readonly timestamp: number;
+  readonly replyTo?: string;
+  readonly expectsReply?: boolean;
+  /** Recipients verify parent ownership before elevating human origin. */
+  readonly human?: HumanMessageOrigin;
+  readonly topic?: TopicUpdate;
+  readonly delivery?: MessageDelivery;
+  readonly queueMode?: QueueMode;
+  readonly threadId?: string;
+  readonly passive?: boolean;
+  readonly content: {
+    readonly text: string;
+    readonly attachments?: readonly Attachment[];
   };
 }
-
-const UNSAFE_TEXT_CONTROLS = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f]/;
-const UNSAFE_LABEL_CONTROLS = /[\u0000-\u001f\u007f-\u009f]/;
-
-function safeText(value: string): boolean {
-  return !UNSAFE_TEXT_CONTROLS.test(value);
-}
-
-function safeLabel(value: string): boolean {
-  return value.length > 0 && !UNSAFE_LABEL_CONTROLS.test(value);
-}
-
 export interface Attachment {
-  type: "file" | "snippet" | "context";
-  name: string;
-  content: string;
-  language?: string;
+  readonly type: "file" | "snippet" | "context";
+  readonly name: string;
+  readonly content: string;
+  readonly language?: string;
 }
-
 export function isAttachment(value: unknown): value is Attachment {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-
-  const attachment = value as Record<string, unknown>;
-
-  if (
-    attachment.type !== "file"
-    && attachment.type !== "snippet"
-    && attachment.type !== "context"
-  ) {
+  if (!isRecord(value)) {
     return false;
   }
-
-  if (typeof attachment.name !== "string" || !safeLabel(attachment.name) || typeof attachment.content !== "string" || !safeText(attachment.content)) return false;
-  return attachment.language === undefined || (typeof attachment.language === "string" && safeLabel(attachment.language));
-}
-
-export function normalizeSessionInfo(value: unknown): SessionInfo | null {
-  if (typeof value !== "object" || value === null || typeof (value as { id?: unknown }).id !== "string") return null;
-  if (isSessionRegistration(value)) return value as SessionInfo;
-  if (!("projectId" in value)) return null;
-  const { projectId: _projectId, ...withoutProjectId } = value as Record<string, unknown>;
-  return isSessionRegistration(withoutProjectId) ? withoutProjectId as unknown as SessionInfo : null;
+  const validType = value.type === "file" || value.type === "snippet" || value.type === "context";
+  return (
+    validType && safeLabel(value.name) && safeText(value.content) && optionalLabel(value.language)
+  );
 }
 
-export function isMessage(value: unknown): value is Message {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-
-  const message = value as Record<string, unknown>;
-
-  if (typeof message.id !== "string" || !safeLabel(message.id) || typeof message.timestamp !== "number" || !Number.isFinite(message.timestamp)) {
+function validMessageOrigin(message: Readonly<Record<string, unknown>>): boolean {
+  if (message.human !== undefined && !isHumanMessageOrigin(message.human)) {
     return false;
   }
-
-  if (message.replyTo !== undefined && (typeof message.replyTo !== "string" || !safeLabel(message.replyTo))) {
-    return false;
-  }
-
-  if (message.human !== undefined && !isHumanMessageOrigin(message.human)) return false;
-  if (message.topic !== undefined && (!isTopicUpdate(message.topic) || message.human !== undefined || message.expectsReply || message.replyTo)) return false;
-
-  if (message.expectsReply !== undefined && typeof message.expectsReply !== "boolean") {
-    return false;
+  if (message.topic === undefined) {
+    return true;
   }
+  return (
+    isTopicUpdate(message.topic) &&
+    message.human === undefined &&
+    (message.expectsReply === undefined || message.expectsReply === false) &&
+    message.replyTo === undefined
+  );
+}
 
-  if (message.passive !== undefined && typeof message.passive !== "boolean") {
+function validDelivery(message: Readonly<Record<string, unknown>>): boolean {
+  if (
+    message.delivery !== undefined &&
+    message.delivery !== "queue" &&
+    message.delivery !== "steer" &&
+    message.delivery !== "passive"
+  ) {
     return false;
   }
-
   if (
-    message.delivery !== undefined
-    && message.delivery !== "queue"
-    && message.delivery !== "steer"
-    && message.delivery !== "passive"
+    message.passive === true &&
+    message.delivery !== undefined &&
+    message.delivery !== "passive"
   ) {
     return false;
   }
+  return !(
+    (message.passive === true || message.delivery === "passive") &&
+    message.expectsReply === true
+  );
+}
 
+function validQueue(message: Readonly<Record<string, unknown>>): boolean {
   if (
-    message.queueMode !== undefined
-    && message.queueMode !== "stack"
-    && message.queueMode !== "replace"
+    message.queueMode !== undefined &&
+    message.queueMode !== "stack" &&
+    message.queueMode !== "replace"
   ) {
     return false;
   }
-
-  if (message.threadId !== undefined && (typeof message.threadId !== "string" || !safeLabel(message.threadId.trim()))) {
+  if (message.queueMode !== undefined && message.delivery !== "queue") {
     return false;
   }
-
-  if (message.passive === true && message.delivery !== undefined && message.delivery !== "passive") {
+  if (message.queueMode === "replace" && typeof message.threadId !== "string") {
     return false;
   }
-
-  if ((message.passive === true || message.delivery === "passive") && message.expectsReply === true) {
-    return false;
+  if (message.threadId === undefined) {
+    return true;
   }
+  return validThread(message);
+}
 
-  if (message.queueMode !== undefined && message.delivery !== "queue") {
-    return false;
-  }
+function validThread(message: Readonly<Record<string, unknown>>): boolean {
+  return (
+    typeof message.threadId === "string" &&
+    safeLabel(message.threadId.trim()) &&
+    message.queueMode === "replace"
+  );
+}
 
-  if (message.queueMode === "replace" && typeof message.threadId !== "string") {
+function validContent(value: unknown): boolean {
+  if (!isRecord(value) || !safeText(value.text)) {
     return false;
   }
+  return (
+    value.attachments === undefined ||
+    (isUnknownArray(value.attachments) && value.attachments.every(isAttachment))
+  );
+}
 
-  if (message.threadId !== undefined && message.queueMode !== "replace") {
+export function isMessage(value: unknown): value is Message {
+  if (!isRecord(value) || !safeLabel(value.id) || !finiteNumber(value.timestamp)) {
     return false;
   }
+  return (
+    optionalLabel(value.replyTo) &&
+    optionalBoolean(value.expectsReply) &&
+    optionalBoolean(value.passive) &&
+    validMessageOrigin(value) &&
+    validDelivery(value) &&
+    validQueue(value) &&
+    validContent(value.content)
+  );
+}
 
-  if (typeof message.content !== "object" || message.content === null) {
+function validSessionHealth(session: Readonly<Record<string, unknown>>): boolean {
+  if (
+    !optionalFiniteNumber(session.lastSeen) ||
+    !optionalFiniteNumber(session.lastIntercomActivity) ||
+    !optionalBoolean(session.acceptsAsks)
+  ) {
     return false;
   }
+  return (
+    session.pendingAsks === undefined ||
+    (finiteNumber(session.pendingAsks) &&
+      Number.isInteger(session.pendingAsks) &&
+      session.pendingAsks >= 0)
+  );
+}
+
+function validSessionTopics(session: Readonly<Record<string, unknown>>): boolean {
+  return (
+    (session.subscriptions === undefined ||
+      (isUnknownArray(session.subscriptions) &&
+        session.subscriptions.every(isTopicSubscription))) &&
+    (session.topics === undefined ||
+      (isUnknownArray(session.topics) && session.topics.every(isTopicUpdate)))
+  );
+}
 
-  const content = message.content as Record<string, unknown>;
-  if (typeof content.text !== "string" || !safeText(content.text)) {
+export function isSessionRegistration(value: unknown): value is Omit<SessionInfo, "id"> {
+  if (!isRecord(value) || !safeLabel(value.cwd) || !safeLabel(value.model)) {
     return false;
   }
-
-  return content.attachments === undefined
-    || (Array.isArray(content.attachments) && content.attachments.every(isAttachment));
+  const validProject =
+    value.projectId === undefined ||
+    (typeof value.projectId === "string" && /^[a-f0-9]{64}$/.test(value.projectId));
+  return (
+    optionalLabel(value.name) &&
+    optionalLabel(value.status) &&
+    validProject &&
+    validSessionHealth(value) &&
+    validSessionTopics(value)
+  );
 }
 
-export function isSessionRegistration(value: unknown): value is Omit<SessionInfo, "id"> {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
-  const session = value as Record<string, unknown>;
-  if (typeof session.cwd !== "string" || !safeLabel(session.cwd) || typeof session.model !== "string" || !safeLabel(session.model)) return false;
-  if (session.name !== undefined && (typeof session.name !== "string" || !safeLabel(session.name))) return false;
-  if (session.projectId !== undefined && (typeof session.projectId !== "string" || !/^[a-f0-9]{64}$/.test(session.projectId))) return false;
-  if (session.status !== undefined && (typeof session.status !== "string" || !safeLabel(session.status))) return false;
-  if (session.lastSeen !== undefined && (typeof session.lastSeen !== "number" || !Number.isFinite(session.lastSeen))) return false;
-  if (session.lastIntercomActivity !== undefined && (typeof session.lastIntercomActivity !== "number" || !Number.isFinite(session.lastIntercomActivity))) return false;
-  if (session.pendingAsks !== undefined && (typeof session.pendingAsks !== "number" || !Number.isInteger(session.pendingAsks) || session.pendingAsks < 0)) return false;
-  if (session.subscriptions !== undefined && (!Array.isArray(session.subscriptions) || !session.subscriptions.every(isTopicSubscription))) return false;
-  if (session.topics !== undefined && (!Array.isArray(session.topics) || !session.topics.every(isTopicUpdate))) return false;
-  return session.acceptsAsks === undefined || typeof session.acceptsAsks === "boolean";
+export function normalizeSessionInfo(value: unknown): SessionInfo | null {
+  if (!isRecord(value) || typeof value.id !== "string") {
+    return null;
+  }
+  const id = value.id;
+  if (isSessionRegistration(value)) {
+    return { ...value, id };
+  }
+  if (!("projectId" in value)) {
+    return null;
+  }
+  const { projectId: _projectId, ...withoutProjectId } = value;
+  return isSessionRegistration(withoutProjectId) ? { ...withoutProjectId, id } : null;
 }
 
 export interface SendResult {
-  id: string;
-  accepted: boolean;
-  delivered: boolean;
-  queued?: boolean;
-  reason?: string;
+  readonly id: string;
+  readonly accepted: boolean;
+  readonly delivered: boolean;
+  readonly queued?: boolean;
+  readonly reason?: string;
 }
-
 export type TopicChange =
-  | { action: "publish" | "restore"; topic: TopicUpdate }
-  | { action: "subscribe" | "restore"; subscription: TopicSubscription }
-  | { action: "unsubscribe"; topic: string };
+  | { readonly action: "publish" | "restore"; readonly topic: TopicUpdate }
+  | { readonly action: "subscribe" | "restore"; readonly subscription: TopicSubscription }
+  | { readonly action: "unsubscribe"; readonly topic: string };
 export interface SessionSnapshot {
-  sessions: SessionInfo[];
-  receipts: Array<SendResult & { to: string }>;
+  readonly sessions: readonly SessionInfo[];
+  readonly receipts: readonly (SendResult & { readonly to: string })[];
 }
 
+type CompactTopicMessage = Omit<Message, "topic"> & {
+  readonly topic?: Omit<TopicUpdate, "text"> & { readonly text?: string };
+};
 /** Topic text and the standard coalescing key need only one copy on the wire. */
-export function compactTopicMessage(message: Message) {
-  if (!message.topic) return message;
-  return { ...message,
-    topic: message.topic.text === message.content.text ? { ...message.topic, text: undefined } : message.topic,
-    threadId: message.queueMode === "replace" && message.threadId === `topic:${message.topic.topic}` ? undefined : message.threadId,
+export function compactTopicMessage(message: Message): CompactTopicMessage {
+  if (!message.topic) {
+    return message;
+  }
+  return {
+    ...message,
+    topic:
+      message.topic.text === message.content.text
+        ? { ...message.topic, text: undefined }
+        : message.topic,
+    threadId:
+      message.queueMode === "replace" && message.threadId === `topic:${message.topic.topic}`
+        ? undefined
+        : message.threadId,
   };
 }
 
 export function normalizeMessage(value: unknown): Message | null {
-  if (isMessage(value)) return value;
-  if (!value || typeof value !== "object") return null;
-  const message = value as Partial<Message>;
-  if (!message.topic || typeof message.topic !== "object" || !message.content) return null;
-  const restored = { ...message, topic: { ...message.topic, text: message.topic.text === undefined ? message.content.text : message.topic.text },
-    ...(message.queueMode === "replace" && message.threadId === undefined ? { threadId: `topic:${message.topic.topic}` } : {}) };
+  if (isMessage(value)) {
+    return value;
+  }
+  if (
+    !isRecord(value) ||
+    !isRecord(value.topic) ||
+    !isRecord(value.content) ||
+    typeof value.topic.topic !== "string"
+  ) {
+    return null;
+  }
+  const restored = {
+    ...value,
+    topic: {
+      ...value.topic,
+      text: value.topic.text === undefined ? value.content.text : value.topic.text,
+    },
+    ...(value.queueMode === "replace" && value.threadId === undefined
+      ? { threadId: `topic:${value.topic.topic}` }
+      : {}),
+  };
   return isMessage(restored) ? restored : null;
 }
 
 export type BrokerMessage =
-  | { type: "registered"; sessionId: string; topicsSupported?: true; topicFrames?: true }
-  | { type: "sessions"; requestId: string; sessions: Array<Partial<SessionInfo> & Pick<SessionInfo, "id">>; more?: boolean; receipts?: SessionSnapshot["receipts"]; error?: string }
-  | { type: "message"; from: SessionInfo; message: Message | ReturnType<typeof compactTopicMessage> }
-  | { type: "session_left"; sessionId: string }
-  | { type: "delivered"; messageId: string }
-  | { type: "delivery_queued"; messageId: string; reason: string }
-  | { type: "delivery_failed"; messageId: string; reason: string };
+  | {
+      readonly type: "registered";
+      readonly sessionId: string;
+      readonly topicsSupported?: true;
+      readonly topicFrames?: true;
+    }
+  | {
+      readonly type: "sessions";
+      readonly requestId: string;
+      readonly sessions: readonly (Partial<SessionInfo> & Pick<SessionInfo, "id">)[];
+      readonly more?: boolean;
+      readonly receipts?: SessionSnapshot["receipts"];
+      readonly error?: string;
+    }
+  | {
+      readonly type: "message";
+      readonly from: SessionInfo;
+      readonly message: Message | CompactTopicMessage;
+    }
+  | { readonly type: "session_left"; readonly sessionId: string }
+  | { readonly type: "delivered"; readonly messageId: string }
+  | { readonly type: "delivery_queued"; readonly messageId: string; readonly reason: string }
+  | { readonly type: "delivery_failed"; readonly messageId: string; readonly reason: string };

package/src/pi-intercom/ui/compose-paste.ts

@@ -0,0 +1,109 @@
+const START = "\x1b[200~";
+const END = "\x1b[201~";
+const MAX_PASTE_CHARS = 1_000_000;
+const IDLE_MS = 200;
+export const PASTE_RENDER_TAIL_CHARS = 8192;
+
+export function printableInput(text: string): string {
+  return Array.from(text)
+    .filter((character) => character >= " " || character === "\n" || character === "\t")
+    .join("");
+}
+
+interface PasteHandlers {
+  readonly flush: (text: string) => void;
+  readonly escape: (prefix: string) => void;
+  readonly render: () => void;
+}
+
+/** Owns split bracketed-paste prefixes, bounded buffering and the idle fallback timer. */
+export class ComposePaste {
+  private buffer: string | null = null;
+  private prefix = "";
+  private timer: NodeJS.Timeout | null = null;
+
+  private readonly handlers: PasteHandlers;
+
+  constructor(handlers: PasteHandlers) {
+    this.handlers = handlers;
+  }
+
+  dispose(): void {
+    this.clearTimer();
+  }
+  get busy(): boolean {
+    return this.buffer !== null || this.prefix.length > 0;
+  }
+  get preview(): string {
+    return printableInput(this.buffer?.slice(-PASTE_RENDER_TAIL_CHARS) ?? "");
+  }
+
+  private clearTimer(): void {
+    if (this.timer) {
+      clearTimeout(this.timer);
+    }
+    this.timer = null;
+  }
+
+  private waitForBody(): void {
+    this.clearTimer();
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      if (this.buffer === null) {
+        return;
+      }
+      const text = printableInput(this.buffer.replace(/\r\n?/g, "\n"));
+      this.buffer = null;
+      this.handlers.flush(text);
+    }, IDLE_MS);
+    this.timer.unref();
+    this.handlers.render();
+  }
+
+  private waitForPrefix(text: string): void {
+    this.prefix = text;
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      const prefix = this.prefix;
+      this.prefix = "";
+      if (prefix === "\x1b") {
+        this.handlers.escape(prefix);
+      }
+    }, IDLE_MS);
+    this.timer.unref();
+  }
+
+  private consumeBody(body: string): string | undefined {
+    const end = body.indexOf(END);
+    if (end === -1 && body.length <= MAX_PASTE_CHARS) {
+      this.buffer = body;
+      this.waitForBody();
+      return;
+    }
+    this.buffer = null;
+    this.clearTimer();
+    const text = end === -1 ? body : body.slice(0, end) + body.slice(end + END.length);
+    return text.replace(/\r\n?/g, "\n");
+  }
+
+  consume(input: string): { readonly text: string; readonly pasted: boolean } | undefined {
+    if (this.buffer !== null) {
+      const text = this.consumeBody(this.buffer + input);
+      return text === undefined ? undefined : { text, pasted: true };
+    }
+    const text = this.prefix + input;
+    if (this.prefix.length > 0) {
+      this.clearTimer();
+      this.prefix = "";
+    }
+    if (text !== START && START.startsWith(text)) {
+      this.waitForPrefix(text);
+      return;
+    }
+    if (text.startsWith(START)) {
+      const body = this.consumeBody(text.slice(START.length));
+      return body === undefined ? undefined : { text: body, pasted: true };
+    }
+    return { text: text.replaceAll(END, ""), pasted: false };
+  }
+}