@astrosheep/square 0.3.88 → 0.3.90

package/plugins/paseo/client/markdown.tsx

@@ -1,135 +1,22 @@
-import { useMemo } from "react";
-import { Text, View, type TextStyle } from "react-native";
+import { useMemo, type ReactNode } from "react";
+import { Platform, Text, View, type TextStyle } from "react-native";
 import type { PluginTheme } from "@getpaseo/plugin";
+import { Lexer, lexer, type Token, type Tokens } from "marked";
+import { parseSquareBlocks } from "../shared/message.ts";
 
-interface InlinePart { text: string; bold?: boolean; italic?: boolean; code?: boolean }
+export { parseSquareBlocks };
 
-// Minimal inline grammar: **bold**, *italic*, `code`. The first marker wins;
-// no nesting, so action lines like *leans over* survive intact.
-const INLINE_RE = /(\*\*[^*\n]+\*\*|\*[^*\n]+\*|`[^`\n]+`)/g;
+export const MONO = Platform.select({ ios: "Menlo", android: "monospace", default: "ui-monospace, Menlo, monospace" });
 
-export function parseInline(line: string): InlinePart[] {
-  const parts: InlinePart[] = [];
-  let last = 0;
-  for (const match of line.matchAll(INLINE_RE)) {
-    const index = match.index ?? 0;
-    if (index > last) parts.push({ text: line.slice(last, index) });
-    const token = match[0];
-    if (token.startsWith("**")) parts.push({ text: token.slice(2, -2), bold: true });
-    else if (token.startsWith("`")) parts.push({ text: token.slice(1, -1), code: true });
-    else parts.push({ text: token.slice(1, -1), italic: true });
-    last = index + token.length;
-  }
-  if (last < line.length) parts.push({ text: line.slice(last) });
-  return parts;
-}
-
-type Block =
-  | { kind: "code"; text: string }
-  | { kind: "heading"; level: number; text: string }
-  | { kind: "quote"; lines: string[] }
-  | { kind: "list"; items: string[] }
-  | { kind: "paragraph"; text: string };
-
-function parseBlocks(markdown: string): Block[] {
-  const lines = markdown.replace(/\r\n/g, "\n").split("\n");
-  const blocks: Block[] = [];
-  let paragraph: string[] = [];
-  const flushParagraph = () => {
-    if (paragraph.length > 0) blocks.push({ kind: "paragraph", text: paragraph.join(" ") });
-    paragraph = [];
-  };
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i]!;
-    if (line.trimStart().startsWith("```")) {
-      flushParagraph();
-      const body: string[] = [];
-      i += 1;
-      while (i < lines.length && !lines[i]!.trimStart().startsWith("```")) { body.push(lines[i]!); i += 1; }
-      blocks.push({ kind: "code", text: body.join("\n") });
-      continue;
-    }
-    const heading = /^(#{1,6})\s+(.*)$/.exec(line);
-    if (heading) {
-      flushParagraph();
-      blocks.push({ kind: "heading", level: heading[1]!.length, text: heading[2]! });
-      continue;
-    }
-    if (line.startsWith(">")) {
-      flushParagraph();
-      const quote: string[] = [];
-      while (i < lines.length && lines[i]!.startsWith(">")) { quote.push(lines[i]!.replace(/^>\s?/, "")); i += 1; }
-      i -= 1;
-      blocks.push({ kind: "quote", lines: quote });
-      continue;
-    }
-    if (/^\s*(?:[-*+]|\d+\.)\s+/.test(line)) {
-      flushParagraph();
-      const items: string[] = [];
-      while (i < lines.length && /^\s*(?:[-*+]|\d+\.)\s+/.test(lines[i]!)) {
-        const item = /^\s*(?:[-*+]|\d+\.)\s+(.*)$/.exec(lines[i]!);
-        items.push(item?.[1] ?? lines[i]!);
-        i += 1;
-      }
-      i -= 1;
-      blocks.push({ kind: "list", items });
-      continue;
-    }
-    if (line.trim() === "") { flushParagraph(); continue; }
-    paragraph.push(line.trim());
-  }
-  flushParagraph();
-  return blocks;
-}
-
-interface SquareBlock { meta?: string; actor?: string; body: string }
-
-function parseAttributes(source: string): Record<string, string> {
-  const attributes: Record<string, string> = {};
-  for (const match of source.matchAll(/([a-z]+)="([^"]*)"/g)) {
-    attributes[match[1]!] = match[2]!.replace(/&quot;/g, '"').replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
-  }
-  return attributes;
-}
-
-// A square notification is one or more <square-activity> blocks. Split them out so the
-// envelope becomes styled chrome and only the body goes through markdown: where and which
-// activity come from tag attributes, and the first inner line is the route sentence.
-function parseSquareBlocks(text: string): SquareBlock[] {
-  const blocks: SquareBlock[] = [];
-  const re = /<square-activity([^>]*)>\n([\s\S]*?)\n<\/square-activity>/g;
-  let last = 0;
-  for (const match of text.matchAll(re)) {
-    const index = match.index ?? 0;
-    const before = text.slice(last, index).trim();
-    if (before !== "") blocks.push({ body: before });
-    const attributes = parseAttributes(match[1]!);
-    const innerLines = match[2]!.split("\n");
-    const described = [attributes.square, attributes.as, attributes.id].filter((value) => value !== undefined);
-    const meta = described.length > 0 ? `· ${described.join(" · ")}` : undefined;
-    const actor = innerLines.shift();
-    blocks.push({ meta, actor, body: innerLines.join("\n").trim() });
-    last = index + match[0].length;
-  }
-  const rest = text.slice(last).trim();
-  if (rest !== "") blocks.push({ body: rest });
-  if (blocks.length === 0) blocks.push({ body: text });
-  return blocks;
-}
-
-export function SquareMarkdown({ text, theme }: { text: string; theme: PluginTheme }) {
-  const { colors } = theme;
-  const styles = useMemo(() => ({
+function makeStyles(colors: PluginTheme["colors"]) {
+  return {
     block: { gap: 6 },
-    paragraph: { color: colors.foreground, fontSize: 13, lineHeight: 20 },
-    bold: { fontWeight: "700" as const },
-    italic: { fontStyle: "italic" as const },
-    inlineCode: {
-      fontFamily: "Menlo",
-      fontSize: 12,
-      backgroundColor: colors.surface2,
-      color: colors.foreground,
-    },
+    text: { color: colors.foreground, fontSize: 13, lineHeight: 19 },
+    strong: { fontWeight: "700" as const },
+    em: { fontStyle: "italic" as const },
+    del: { textDecorationLine: "line-through" as const },
+    link: { color: colors.accent, textDecorationLine: "underline" as const },
+    inlineCode: { fontFamily: MONO, fontSize: 12, backgroundColor: colors.surface2, color: colors.foreground },
     codeBlock: {
       backgroundColor: colors.surface0,
       borderRadius: 8,
@@ -138,92 +25,145 @@ export function SquareMarkdown({ text, theme }: { text: string; theme: PluginThe
       paddingHorizontal: 9,
       paddingVertical: 7,
     },
-    codeText: { fontFamily: "Menlo", fontSize: 11.5, lineHeight: 17, color: colors.foreground },
-    heading: { color: colors.foreground, fontWeight: "700" as const },
-    quote: {
-      borderLeftWidth: 2,
-      borderLeftColor: colors.border,
-      paddingLeft: 8,
-      gap: 2,
-    },
-    quoteText: { color: colors.foregroundMuted, fontSize: 13, lineHeight: 20, fontStyle: "italic" as const },
-    meta: { color: colors.foregroundMuted, fontSize: 11, lineHeight: 15, fontFamily: "Menlo" },
+    codeText: { fontFamily: MONO, fontSize: 11.5, lineHeight: 17, color: colors.foreground },
+    quote: { borderLeftWidth: 2, borderLeftColor: colors.border, paddingLeft: 8, gap: 2 },
+    quoteText: { color: colors.foregroundMuted, fontStyle: "italic" as const },
+    meta: { color: colors.foregroundMuted, fontSize: 11, lineHeight: 15, fontFamily: MONO },
     actor: { color: colors.accent, fontSize: 12, lineHeight: 17 },
     separator: { height: 1, backgroundColor: colors.border, marginVertical: 4 },
     listRow: { flexDirection: "row" as const, gap: 6 },
-    bullet: { color: colors.accent, fontSize: 13, lineHeight: 20 },
-  }), [colors]);
+    listItem: { flexShrink: 1, gap: 2 },
+    bullet: { color: colors.accent, fontSize: 13, lineHeight: 19 },
+    tableRow: { flexDirection: "row" as const, gap: 8 },
+    tableCell: { flex: 1, fontSize: 12 },
+  };
+}
 
-  const renderInline = (line: string, keyPrefix: string, extra?: TextStyle) => (
-    <Text key={keyPrefix} style={[styles.paragraph, extra]}>
-      {parseInline(line).map((part, index) => (
-        <Text
-          key={`${keyPrefix}-${index}`}
-          style={[
-            part.bold ? styles.bold : undefined,
-            part.italic ? styles.italic : undefined,
-            part.code ? styles.inlineCode : undefined,
-          ]}
-        >{part.code ? ` ${part.text} ` : part.text}</Text>
-      ))}
-    </Text>
-  );
+type Styles = ReturnType<typeof makeStyles>;
+
+/** Children of a token, if it has any: `Token` is a union, so the optional field needs one cast. */
+const children = (node: Token | { tokens?: Token[] }): Token[] => (node as { tokens?: Token[] }).tokens ?? [];
 
-  const renderBlock = (block: Block, key: string) => {
-    switch (block.kind) {
+function renderInlines(tokens: Token[], styles: Styles, prefix: string, extra?: TextStyle): ReactNode[] {
+  return tokens.map((token, index) => {
+    const key = `${prefix}-${index}`;
+    const nested = (style: TextStyle): ReactNode => (
+      <Text key={key} style={[styles.text, extra, style]}>{renderInlines(children(token), styles, key)}</Text>
+    );
+    switch (token.type) {
+      case "strong": return nested(styles.strong);
+      case "em": return nested(styles.em);
+      case "del": return nested(styles.del);
+      case "link": return nested(styles.link);
+      case "codespan": return <Text key={key} style={[styles.text, extra, styles.inlineCode]}>{` ${token.text} `}</Text>;
+      case "br": return "\n";
+      case "image": return token.text;
+      default: {
+        const inline = token as Tokens.Generic;
+        if (inline.tokens !== undefined) return nested({});
+        return inline.text ?? inline.raw;
+      }
+    }
+  });
+}
+
+function renderBlocks(tokens: Token[], styles: Styles, prefix: string, textStyle?: TextStyle): ReactNode[] {
+  return tokens.map((token, index) => {
+    const key = `${prefix}-${index}`;
+    switch (token.type) {
+      case "space":
+      case "checkbox":
+      case "def":
+      case "html":
+        return null;
+      case "hr":
+        return <View key={key} style={styles.separator} />;
       case "code":
         return (
           <View key={key} style={styles.codeBlock}>
-            <Text selectable style={styles.codeText}>{block.text}</Text>
+            <Text selectable style={styles.codeText}>{token.text}</Text>
           </View>
         );
       case "heading":
-        return renderInline(block.text, key, { fontSize: Math.max(13, 18 - block.level), fontWeight: "700" });
-      case "quote":
         return (
-          <View key={key} style={styles.quote}>
-            {block.lines.map((line, index) => (
-              <Text key={`${key}-${index}`} style={styles.quoteText}>{line}</Text>
+          <Text key={key} style={[styles.text, textStyle, styles.strong, { fontSize: Math.max(13, 18 - token.depth) }]}>
+            {renderInlines(children(token), styles, key)}
+          </Text>
+        );
+      case "blockquote":
+        return <View key={key} style={styles.quote}>{renderBlocks(children(token), styles, key, styles.quoteText)}</View>;
+      case "list": {
+        const list = token as Tokens.List;
+        const start = typeof list.start === "number" ? list.start : 1;
+        return (
+          <View key={key} style={{ gap: 2 }}>
+            {list.items.map((item, itemIndex) => (
+              <View key={`${key}-${itemIndex}`} style={styles.listRow}>
+                <Text style={styles.bullet}>
+                  {item.task ? (item.checked === true ? "☑" : "☐") : list.ordered ? `${start + itemIndex}.` : "•"}
+                </Text>
+                <View style={styles.listItem}>{renderBlocks(children(item), styles, `${key}-${itemIndex}`, textStyle)}</View>
+              </View>
             ))}
           </View>
         );
-      case "list":
+      }
+      case "table": {
+        const table = token as Tokens.Table;
+        const rows = [table.header, ...table.rows];
         return (
           <View key={key} style={{ gap: 2 }}>
-            {block.items.map((item, index) => (
-              <View key={`${key}-${index}`} style={styles.listRow}>
-                <Text style={styles.bullet}>•</Text>
-                <Text style={[styles.paragraph, { flexShrink: 1 }]}>
-                  {parseInline(item).map((part, partIndex) => (
-                    <Text
-                      key={partIndex}
-                      style={[
-                        part.bold ? styles.bold : undefined,
-                        part.italic ? styles.italic : undefined,
-                        part.code ? styles.inlineCode : undefined,
-                      ]}
-                    >{part.code ? ` ${part.text} ` : part.text}</Text>
-                  ))}
-                </Text>
+            {rows.map((cells, rowIndex) => (
+              <View key={`${key}-${rowIndex}`} style={styles.tableRow}>
+                {cells.map((cell, cellIndex) => (
+                  <Text
+                    key={`${key}-${rowIndex}-${cellIndex}`}
+                    style={[styles.text, textStyle, styles.tableCell, rowIndex === 0 ? styles.strong : undefined]}
+                  >{renderInlines(children(cell), styles, `${key}-${rowIndex}-${cellIndex}`)}</Text>
+                ))}
               </View>
             ))}
           </View>
         );
-      case "paragraph":
-        return renderInline(block.text, key);
+      }
+      default: {
+        const block = token as Tokens.Generic;
+        return (
+          <Text key={key} style={[styles.text, textStyle]}>
+            {renderInlines(block.tokens ?? Lexer.lexInline(block.text ?? block.raw), styles, key)}
+          </Text>
+        );
+      }
     }
-  };
+  });
+}
 
-  const blocks = useMemo(() => parseSquareBlocks(text), [text]);
+/** One line (or a few) of Markdown, inline only: the collapsed preview on a notification card. */
+export function SquareInline({ text, theme, numberOfLines, style }: {
+  text: string;
+  theme: PluginTheme;
+  numberOfLines?: number;
+  style?: TextStyle;
+}) {
+  const styles = useMemo(() => makeStyles(theme.colors), [theme.colors]);
+  return (
+    <Text numberOfLines={numberOfLines} style={[styles.text, style]}>
+      {renderInlines(Lexer.lexInline(text), styles, "inline")}
+    </Text>
+  );
+}
 
+export function SquareMarkdown({ text, theme }: { text: string; theme: PluginTheme }) {
+  const styles = useMemo(() => makeStyles(theme.colors), [theme.colors]);
+  const blocks = useMemo(() => parseSquareBlocks(text), [text]);
   return (
     <View style={styles.block}>
-      {blocks.map((block, blockIndex) => (
-        <View key={blockIndex} style={styles.block}>
-          {blockIndex > 0 && <View style={styles.separator} />}
+      {blocks.map((block, index) => (
+        <View key={index} style={styles.block}>
+          {index > 0 && <View style={styles.separator} />}
           {block.meta !== undefined && <Text style={styles.meta}>{block.meta}</Text>}
           {block.actor !== undefined && <Text style={styles.actor}>{block.actor}</Text>}
-          {parseBlocks(block.body).map((inner, innerIndex) => renderBlock(inner, `${blockIndex}-${innerIndex}`))}
+          {renderBlocks(lexer(block.body), styles, `${index}`)}
         </View>
       ))}
     </View>

package/plugins/paseo/client/square-message.tsx

@@ -2,15 +2,15 @@ import type { PluginTimelineItemProps } from "@getpaseo/plugin/client";
 import { Icon } from "@getpaseo/plugin/client/react-native";
 import { useMemo, useState } from "react";
 import { Pressable, ScrollView, Text, View } from "react-native";
-import { squareHeadline, type SquareMessageData } from "../shared/message";
-import { parseInline, SquareMarkdown } from "./markdown";
+import { outputPreview, squareHeadline, type SquareMessageData } from "../shared/message";
+import { SquareInline, SquareMarkdown } from "./markdown";
 
 /** A plain card: who, what they did, where, then what they said. No badge, no chrome — the words carry the place. */
 export function SquareMessage({ item, theme, layout }: PluginTimelineItemProps<SquareMessageData>) {
   const [expanded, setExpanded] = useState(false);
-  const { text, fullText, items } = item.data;
+  const { text, items } = item.data;
   const latest = items?.[items.length - 1];
-  // Preview typography only; expansion prefers the complete renderer-only text.
+  // Transform already bounded the collapsed preview; only normalise whitespace for the single line.
   const preview = latest?.preview?.replace(/\s+/g, " ").trim();
   const muted = theme.colors.foregroundMuted;
   const foreground = theme.colors.foreground;
@@ -27,15 +27,11 @@ export function SquareMessage({ item, theme, layout }: PluginTimelineItemProps<S
       paddingVertical: 8,
       gap: 4,
     },
-    whoRow: { flexDirection: "row" as const, alignItems: "baseline" as const, gap: 6 },
+    whoRow: { flexDirection: "row" as const, alignItems: "center" as const, gap: 6 },
     glyph: { color: theme.colors.accent, fontSize: 9 },
     actor: { color: foreground, fontSize: 12.5, fontWeight: "600" as const },
-    route: { color: muted, fontSize: 12.5, flexShrink: 1 },
+    route: { color: muted, fontSize: 12.5, flex: 1 },
     count: { color: muted, fontSize: 11 },
-    preview: { color: foreground, fontSize: 13, lineHeight: 19 },
-    action: { color: muted, fontStyle: "italic" as const },
-    bold: { fontWeight: "700" as const },
-    code: { fontFamily: "Menlo", fontSize: 12 },
   }), [foreground, layout.compact, muted, theme.colors.accent, theme.colors.border, theme.colors.surface1]);
 
   const headline = latest !== undefined ? squareHeadline(latest) : "Square context";
@@ -58,28 +54,16 @@ export function SquareMessage({ item, theme, layout }: PluginTimelineItemProps<S
           <Text numberOfLines={1} style={styles.route}>
             {routeText}{latest?.square !== undefined && ` · ${latest.square}`}
           </Text>
-          <View style={{ flex: 1 }} />
           {items !== undefined && items.length > 1 && <Text style={styles.count}>{items.length}</Text>}
           <Icon name={expanded ? "ChevronUp" : "ChevronDown"} size={16} color={muted} />
         </View>
         {!expanded && preview !== undefined && preview !== "" && (
-          <Text numberOfLines={2} style={styles.preview}>
-            {parseInline(preview).map((part, index) => (
-              <Text
-                key={index}
-                style={[
-                  part.italic ? styles.action : undefined,
-                  part.bold ? styles.bold : undefined,
-                  part.code ? styles.code : undefined,
-                ]}
-              >{part.text}</Text>
-            ))}
-          </Text>
+          <SquareInline text={preview} theme={theme} numberOfLines={2} />
         )}
       </Pressable>
       {expanded && (
-        <ScrollView style={{ maxHeight: layout.compact ? 280 : 400, marginTop: 2 }} nestedScrollEnabled>
-          <SquareMarkdown text={fullText ?? text} theme={theme} />
+        <ScrollView style={{ maxHeight: layout.compact ? 280 : 400, marginTop: 2, borderTopWidth: 1, borderTopColor: theme.colors.border }} contentContainerStyle={{ paddingTop: 8 }} nestedScrollEnabled>
+          <SquareMarkdown text={outputPreview(text)} theme={theme} />
         </ScrollView>
       )}
     </View>

package/plugins/paseo/client/transform.ts

@@ -1,5 +1,5 @@
 import type { PluginTimelineTransformerContribution } from "@getpaseo/plugin/client";
-import { squareCardDetailsSchema } from "../shared/message.ts";
+import { COLLAPSED_PREVIEW_MAX_CHARS, outputPreview, squareCardDetailsSchema } from "../shared/message.ts";
 
 // Recognition is metadata-based, not a guess from a tool name or body text.
 // The same projection applies to live events and fetched history.
@@ -16,10 +16,11 @@ export const transformSquareMessage: PluginTimelineTransformerContribution<"tool
       kind: "square-message",
       version: 1,
       data: {
-        text: item.detail.text,
+        text: outputPreview(details.success && details.data.fullText !== undefined ? details.data.fullText : item.detail.text),
         ...(details.success ? {
-          items: details.data.items,
-          ...(details.data.fullText === undefined ? {} : { fullText: details.data.fullText }),
+          // Only the last item's preview is rendered, so only it takes the visible budget.
+          items: details.data.items.map((item, index, all) =>
+            index < all.length - 1 || item.preview === undefined ? item : { ...item, preview: outputPreview(item.preview, COLLAPSED_PREVIEW_MAX_CHARS) }),
         } : {}),
       },
     }],

package/plugins/paseo/index.client.tsx

@@ -4,16 +4,18 @@ import { transformSquareMessage } from "./client/transform";
 import { squareMessageSchema } from "./shared/message";
 
 export default function contribute(client: PluginClientContext) {
-  client.addTimelineTransformer({
-    id: "square-message",
-    query: { itemType: "tool_call" },
-    transform: transformSquareMessage,
-  });
-  client.addTimelineRenderer({
-    kind: "square-message",
-    version: 1,
-    schema: squareMessageSchema,
-    Component: SquareMessage,
-  });
-  return () => {};
+  const removals = [
+    client.addTimelineTransformer({
+      id: "square-message",
+      query: { itemType: "tool_call" },
+      transform: transformSquareMessage,
+    }),
+    client.addTimelineRenderer({
+      kind: "square-message",
+      version: 1,
+      schema: squareMessageSchema,
+      Component: SquareMessage,
+    }),
+  ];
+  return () => { for (const remove of removals) remove(); };
 }

package/plugins/paseo/package.json

@@ -7,6 +7,9 @@
     "typecheck": "tsc --noEmit",
     "test": "node --experimental-strip-types --test test/*.test.ts"
   },
+  "dependencies": {
+    "marked": "^17.0.6"
+  },
   "devDependencies": {
     "@getpaseo/plugin": "0.11.2",
     "@types/react": "~19.2.0",

package/plugins/paseo/shared/message.ts

@@ -1,5 +1,55 @@
 import { z } from "zod";
 
+/** Client display budget, including the omission line; source history stays unchanged. */
+export const OUTPUT_DISPLAY_MAX_CHARS = 32_000;
+export const COLLAPSED_PREVIEW_MAX_CHARS = 1_000;
+export function outputPreview(text: string, maxChars = OUTPUT_DISPLAY_MAX_CHARS): string {
+  if (text.length <= maxChars) return text;
+  const middle = "\n\n… Showing the beginning and end; the middle is hidden in this preview. …\n\n";
+  const headChars = Math.floor((maxChars - middle.length) / 2);
+  // Budget in UTF-16 units, but never split a surrogate pair.
+  const head = text.slice(0, headChars).replace(/[\uD800-\uDBFF]$/, "");
+  const tail = text.slice(-(maxChars - middle.length - headChars)).replace(/^[\uDC00-\uDFFF]/, "");
+  return head + middle + tail;
+}
+
+export interface SquareBlock { meta?: string; actor?: string; body: string }
+
+function parseAttributes(source: string): Record<string, string> {
+  const attributes: Record<string, string> = {};
+  for (const match of source.matchAll(/([a-z]+)="([^"]*)"/g)) {
+    attributes[match[1]!] = match[2]!.replace(/&quot;/g, '"').replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
+  }
+  return attributes;
+}
+
+// A square notification is one or more <square-activity> blocks. Split them out so the
+// envelope becomes styled chrome and only the body goes through markdown: where and which
+// activity come from tag attributes, or from the leading `· ...` line when the tag has none.
+export function parseSquareBlocks(text: string): SquareBlock[] {
+  const blocks: SquareBlock[] = [];
+  const re = /<square-activity([^>]*)>\n([\s\S]*?)\n<\/square-activity>/g;
+  let last = 0;
+  for (const match of text.matchAll(re)) {
+    const index = match.index ?? 0;
+    const before = text.slice(last, index).trim();
+    if (before !== "") blocks.push({ body: before });
+    const attributes = parseAttributes(match[1]!);
+    const innerLines = match[2]!.split("\n");
+    const described = [attributes.square, attributes.as, attributes.id].filter((value) => value !== undefined);
+    const meta = described.length > 0
+      ? `· ${described.join(" · ")}`
+      : innerLines[0]?.startsWith("· ") ? innerLines.shift() : undefined;
+    const actor = innerLines.shift();
+    blocks.push({ meta, actor, body: innerLines.join("\n").trim() });
+    last = index + match[0].length;
+  }
+  const rest = text.slice(last).trim();
+  if (rest !== "") blocks.push({ body: rest });
+  if (blocks.length === 0) blocks.push({ body: text });
+  return blocks;
+}
+
 export const squareCardDetailsSchema = z.object({
   fullText: z.string().optional(),
   items: z.array(z.object({
@@ -26,7 +76,6 @@ export function squareHeadline(item: z.output<typeof squareCardDetailsSchema>["i
 
 export const squareMessageSchema = z.object({
   text: z.string(),
-  fullText: z.string().optional(),
   items: squareCardDetailsSchema.shape.items.optional(),
 });
 export type SquareMessageData = z.output<typeof squareMessageSchema>;