@fresh-editor/fresh-editor 0.1.13 → 0.1.15

package/npm-shrinkwrap.json

@@ -23,7 +23,7 @@
       "hasInstallScript": true,
       "license": "GPL-2.0",
       "name": "@fresh-editor/fresh-editor",
-      "version": "0.1.13"
+      "version": "0.1.15"
     },
     "node_modules/@isaacs/balanced-match": {
       "engines": {
@@ -896,5 +896,5 @@
     }
   },
   "requires": true,
-  "version": "0.1.13"
+  "version": "0.1.15"
 }

package/package.json

@@ -1,5 +1,5 @@
 {
-  "artifactDownloadUrl": "https://github.com/sinelaw/fresh/releases/download/v0.1.13",
+  "artifactDownloadUrl": "https://github.com/sinelaw/fresh/releases/download/v0.1.15",
   "author": "Noam Lewis",
   "bin": {
     "fresh": "run-fresh.js"
@@ -92,7 +92,7 @@
       "zipExt": ".tar.xz"
     }
   },
-  "version": "0.1.13",
+  "version": "0.1.15",
   "volta": {
     "node": "18.14.1",
     "npm": "9.5.0"

package/plugins/buffer_modified.ts

@@ -94,6 +94,38 @@ function markLinesModified(bufferId: number, startLine: number, endLine: number)
   }
 }
 
+function reapplyIndicatorsFromDiff(bufferId: number): void {
+  const diff = editor.getBufferSavedDiff(bufferId);
+  if (!diff) return;
+
+  // If buffer matches saved snapshot, clear everything.
+  if (diff.equal) {
+    editor.clearLineIndicators(bufferId, NAMESPACE);
+    return;
+  }
+
+  const ranges = diff.line_ranges;
+  // If line info is unavailable, leave existing indicators (best effort).
+  if (!ranges) return;
+
+  // Reset namespace to drop stale indicators outside the changed ranges.
+  editor.clearLineIndicators(bufferId, NAMESPACE);
+  for (const [start, end] of ranges) {
+    for (let line = start; line < end; line++) {
+      editor.setLineIndicator(
+        bufferId,
+        line,
+        NAMESPACE,
+        SYMBOL,
+        COLOR[0],
+        COLOR[1],
+        COLOR[2],
+        PRIORITY
+      );
+    }
+  }
+}
+
 // =============================================================================
 // Event Handlers
 // =============================================================================
@@ -179,6 +211,7 @@ globalThis.onBufferModifiedAfterInsert = function (args: {
   // Mark all affected lines (from start_line to end_line inclusive)
   // The indicator markers will automatically track their positions
   markLinesModified(bufferId, args.start_line, args.end_line);
+  reapplyIndicatorsFromDiff(bufferId);
 
   return true;
 };
@@ -209,6 +242,7 @@ globalThis.onBufferModifiedAfterDelete = function (args: {
   // Mark the line where deletion occurred
   // Markers for deleted lines are automatically cleaned up
   markLinesModified(bufferId, args.start_line, args.start_line);
+  reapplyIndicatorsFromDiff(bufferId);
 
   return true;
 };

package/plugins/lib/fresh.d.ts

@@ -123,6 +123,13 @@ interface BufferInfo {
   length: number;
 }
 
+/** Diff vs last save for a buffer */
+interface TsBufferSavedDiff {
+  equal: boolean;
+  byte_ranges: [number, number][];
+  line_ranges?: [number, number][] | null;
+}
+
 /** Selection range */
 interface SelectionRange {
   /** Start byte position */
@@ -341,6 +348,8 @@ interface EditorAPI {
    * @returns true if process is running, false if not found or exited
    */
   isProcessRunning(#[bigint] process_id: number): boolean;
+  /** Get diff vs last saved snapshot for a buffer */
+  getBufferSavedDiff(buffer_id: number): TsBufferSavedDiff | null;
 
   // === Buffer Info Queries ===
   /**

package/plugins/markdown_compose.ts

@@ -1,7 +1,11 @@
 // Markdown Compose Mode Plugin
-// Provides beautiful, semi-WYSIWYG rendering of Markdown documents
-// - Highlighting: automatically enabled for all markdown files
-// - Compose mode: explicitly toggled, adds margins, soft-wrapping, different editing
+// Provides compose mode for Markdown documents with:
+// - Soft wrapping at a configurable width
+// - Hanging indents for lists and block quotes
+// - Centered margins
+//
+// Syntax highlighting is handled by the TextMate grammar (built-in to the editor)
+// This plugin only adds the compose mode layout features.
 
 interface MarkdownConfig {
   composeWidth: number;
@@ -15,52 +19,9 @@ const config: MarkdownConfig = {
   hideLineNumbers: true,
 };
 
-// Track buffers with highlighting enabled (auto for markdown files)
-const highlightingBuffers = new Set<number>();
-
 // Track buffers in compose mode (explicit toggle)
 const composeBuffers = new Set<number>();
 
-// Track which buffers need their overlays refreshed (content changed)
-const dirtyBuffers = new Set<number>();
-
-// Markdown token types for parsing
-enum TokenType {
-  Header1,
-  Header2,
-  Header3,
-  Header4,
-  Header5,
-  Header6,
-  ListItem,
-  OrderedListItem,
-  Checkbox,
-  CodeBlockFence,
-  CodeBlockContent,
-  BlockQuote,
-  HorizontalRule,
-  Paragraph,
-  HardBreak,
-  Image,  // Images should have hard breaks (not soft breaks)
-  InlineCode,
-  Bold,
-  Italic,
-  Strikethrough,
-  Link,
-  LinkText,
-  LinkUrl,
-  Text,
-}
-
-interface Token {
-  type: TokenType;
-  start: number;  // byte offset
-  end: number;    // byte offset
-  text: string;
-  level?: number; // For headers, list indentation
-  checked?: boolean; // For checkboxes
-}
-
 // Types match the Rust ViewTokenWire structure
 interface ViewTokenWire {
   source_offset: number | null;
@@ -343,669 +304,6 @@ function parseMarkdownBlocks(text: string): ParsedBlock[] {
   return blocks;
 }
 
-// Colors for styling (RGB tuples)
-const COLORS = {
-  header: [100, 149, 237] as [number, number, number], // Cornflower blue
-  code: [152, 195, 121] as [number, number, number],   // Green
-  codeBlock: [152, 195, 121] as [number, number, number],
-  fence: [80, 80, 80] as [number, number, number],     // Subdued gray for ```
-  link: [86, 156, 214] as [number, number, number],    // Light blue
-  linkUrl: [80, 80, 80] as [number, number, number],   // Subdued gray
-  bold: [255, 255, 220] as [number, number, number],   // Bright for bold text
-  boldMarker: [80, 80, 80] as [number, number, number], // Subdued for ** markers
-  italic: [198, 180, 221] as [number, number, number], // Light purple for italic
-  italicMarker: [80, 80, 80] as [number, number, number], // Subdued for * markers
-  quote: [128, 128, 128] as [number, number, number],  // Gray
-  checkbox: [152, 195, 121] as [number, number, number], // Green
-  listBullet: [86, 156, 214] as [number, number, number], // Light blue
-};
-
-// Simple Markdown parser
-class MarkdownParser {
-  private text: string;
-  private tokens: Token[] = [];
-
-  constructor(text: string) {
-    this.text = text;
-  }
-
-  parse(): Token[] {
-    const lines = this.text.split('\n');
-    let byteOffset = 0;
-    let inCodeBlock = false;
-    let codeFenceStart = -1;
-
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      const lineStart = byteOffset;
-      const lineEnd = byteOffset + line.length;
-
-      // Code block detection
-      if (line.trim().startsWith('```')) {
-        if (!inCodeBlock) {
-          inCodeBlock = true;
-          codeFenceStart = lineStart;
-          this.tokens.push({
-            type: TokenType.CodeBlockFence,
-            start: lineStart,
-            end: lineEnd,
-            text: line,
-          });
-        } else {
-          this.tokens.push({
-            type: TokenType.CodeBlockFence,
-            start: lineStart,
-            end: lineEnd,
-            text: line,
-          });
-          inCodeBlock = false;
-        }
-      } else if (inCodeBlock) {
-        this.tokens.push({
-          type: TokenType.CodeBlockContent,
-          start: lineStart,
-          end: lineEnd,
-          text: line,
-        });
-      } else {
-        // Parse line structure
-        this.parseLine(line, lineStart, lineEnd);
-      }
-
-      byteOffset = lineEnd + 1; // +1 for newline
-    }
-
-    // Parse inline styles after structure
-    this.parseInlineStyles();
-
-    return this.tokens;
-  }
-
-  private parseLine(line: string, start: number, end: number): void {
-    const trimmed = line.trim();
-
-    // Headers
-    const headerMatch = trimmed.match(/^(#{1,6})\s+(.+)$/);
-    if (headerMatch) {
-      const level = headerMatch[1].length;
-      const type = [
-        TokenType.Header1,
-        TokenType.Header2,
-        TokenType.Header3,
-        TokenType.Header4,
-        TokenType.Header5,
-        TokenType.Header6,
-      ][level - 1];
-      this.tokens.push({
-        type,
-        start,
-        end,
-        text: line,
-        level,
-      });
-      return;
-    }
-
-    // Horizontal rule
-    if (trimmed.match(/^(-{3,}|\*{3,}|_{3,})$/)) {
-      this.tokens.push({
-        type: TokenType.HorizontalRule,
-        start,
-        end,
-        text: line,
-      });
-      return;
-    }
-
-    // List items
-    const bulletMatch = line.match(/^(\s*)([-*+])\s+(.*)$/);
-    if (bulletMatch) {
-      const indent = bulletMatch[1].length;
-      const hasCheckbox = bulletMatch[3].match(/^\[([ x])\]\s+/);
-
-      if (hasCheckbox) {
-        this.tokens.push({
-          type: TokenType.Checkbox,
-          start,
-          end,
-          text: line,
-          level: indent,
-          checked: hasCheckbox[1] === 'x',
-        });
-      } else {
-        this.tokens.push({
-          type: TokenType.ListItem,
-          start,
-          end,
-          text: line,
-          level: indent,
-        });
-      }
-      return;
-    }
-
-    // Ordered list
-    const orderedMatch = line.match(/^(\s*)(\d+\.)\s+(.*)$/);
-    if (orderedMatch) {
-      const indent = orderedMatch[1].length;
-      this.tokens.push({
-        type: TokenType.OrderedListItem,
-        start,
-        end,
-        text: line,
-        level: indent,
-      });
-      return;
-    }
-
-    // Block quote
-    if (trimmed.startsWith('>')) {
-      this.tokens.push({
-        type: TokenType.BlockQuote,
-        start,
-        end,
-        text: line,
-      });
-      return;
-    }
-
-    // Hard breaks (two spaces + newline, or backslash + newline)
-    if (line.endsWith('  ') || line.endsWith('\\')) {
-      this.tokens.push({
-        type: TokenType.HardBreak,
-        start,
-        end,
-        text: line,
-      });
-      return;
-    }
-
-    // Images: ![alt](url) - these should have hard breaks to keep each on its own line
-    if (trimmed.match(/^!\[.*\]\(.*\)$/)) {
-      this.tokens.push({
-        type: TokenType.Image,
-        start,
-        end,
-        text: line,
-      });
-      return;
-    }
-
-    // Default: paragraph
-    if (trimmed.length > 0) {
-      this.tokens.push({
-        type: TokenType.Paragraph,
-        start,
-        end,
-        text: line,
-      });
-    }
-  }
-
-  private parseInlineStyles(): void {
-    // Parse inline markdown (bold, italic, code, links) within text
-    // This is a simplified parser - a full implementation would use a proper MD parser
-
-    for (const token of this.tokens) {
-      if (token.type === TokenType.Paragraph ||
-          token.type === TokenType.ListItem ||
-          token.type === TokenType.OrderedListItem) {
-        // Find inline code
-        this.findInlineCode(token);
-        // Find bold/italic
-        this.findEmphasis(token);
-        // Find links
-        this.findLinks(token);
-      }
-    }
-  }
-
-  private findInlineCode(token: Token): void {
-    const regex = /`([^`]+)`/g;
-    let match;
-    while ((match = regex.exec(token.text)) !== null) {
-      this.tokens.push({
-        type: TokenType.InlineCode,
-        start: token.start + match.index,
-        end: token.start + match.index + match[0].length,
-        text: match[0],
-      });
-    }
-  }
-
-  private findEmphasis(token: Token): void {
-    // Bold: **text** or __text__
-    const boldRegex = /(\*\*|__)([^*_]+)\1/g;
-    let match;
-    while ((match = boldRegex.exec(token.text)) !== null) {
-      this.tokens.push({
-        type: TokenType.Bold,
-        start: token.start + match.index,
-        end: token.start + match.index + match[0].length,
-        text: match[0],
-      });
-    }
-
-    // Italic: *text* or _text_
-    const italicRegex = /(\*|_)([^*_]+)\1/g;
-    while ((match = italicRegex.exec(token.text)) !== null) {
-      // Skip if it's part of bold
-      const isBold = this.tokens.some(t =>
-        t.type === TokenType.Bold &&
-        t.start <= token.start + match.index &&
-        t.end >= token.start + match.index + match[0].length
-      );
-      if (!isBold) {
-        this.tokens.push({
-          type: TokenType.Italic,
-          start: token.start + match.index,
-          end: token.start + match.index + match[0].length,
-          text: match[0],
-        });
-      }
-    }
-
-    // Strikethrough: ~~text~~
-    const strikeRegex = /~~([^~]+)~~/g;
-    while ((match = strikeRegex.exec(token.text)) !== null) {
-      this.tokens.push({
-        type: TokenType.Strikethrough,
-        start: token.start + match.index,
-        end: token.start + match.index + match[0].length,
-        text: match[0],
-      });
-    }
-  }
-
-  private findLinks(token: Token): void {
-    // Links: [text](url)
-    const linkRegex = /\[([^\]]+)\]\(([^)]+)\)/g;
-    let match;
-    while ((match = linkRegex.exec(token.text)) !== null) {
-      const fullStart = token.start + match.index;
-      const textStart = fullStart + 1; // After [
-      const textEnd = textStart + match[1].length;
-      const urlStart = textEnd + 2; // After ](
-      const urlEnd = urlStart + match[2].length;
-
-      this.tokens.push({
-        type: TokenType.Link,
-        start: fullStart,
-        end: fullStart + match[0].length,
-        text: match[0],
-      });
-
-      this.tokens.push({
-        type: TokenType.LinkText,
-        start: textStart,
-        end: textEnd,
-        text: match[1],
-      });
-
-      this.tokens.push({
-        type: TokenType.LinkUrl,
-        start: urlStart,
-        end: urlEnd,
-        text: match[2],
-      });
-    }
-  }
-}
-
-// Apply styling overlays based on parsed tokens
-function applyMarkdownStyling(bufferId: number, tokens: Token[]): void {
-  // Clear existing markdown overlays
-  editor.clearNamespace(bufferId, "md");
-
-  for (const token of tokens) {
-    let color: [number, number, number] | null = null;
-    let underline = false;
-    let overlayId = "md";
-
-    switch (token.type) {
-      case TokenType.Header1:
-      case TokenType.Header2:
-      case TokenType.Header3:
-      case TokenType.Header4:
-      case TokenType.Header5:
-      case TokenType.Header6:
-        color = COLORS.header;
-        underline = true;
-        break;
-
-      case TokenType.InlineCode:
-        color = COLORS.code;
-        break;
-
-      case TokenType.CodeBlockFence:
-        color = COLORS.fence;
-        break;
-
-      case TokenType.CodeBlockContent:
-        color = COLORS.codeBlock;
-        break;
-
-      case TokenType.BlockQuote:
-        color = COLORS.quote;
-        break;
-
-      case TokenType.Bold:
-        // Style bold markers (** or __) subdued, content bold
-        const boldMatch = token.text.match(/^(\*\*|__)(.*)(\*\*|__)$/);
-        if (boldMatch) {
-          const markerLen = boldMatch[1].length;
-          // Subdued markers
-          editor.addOverlay(bufferId, "md",
-            token.start, token.start + markerLen,
-            COLORS.boldMarker[0], COLORS.boldMarker[1], COLORS.boldMarker[2], false, false, false);
-          editor.addOverlay(bufferId, "md",
-            token.end - markerLen, token.end,
-            COLORS.boldMarker[0], COLORS.boldMarker[1], COLORS.boldMarker[2], false, false, false);
-          // Bold content with bold=true
-          editor.addOverlay(bufferId, "md",
-            token.start + markerLen, token.end - markerLen,
-            COLORS.bold[0], COLORS.bold[1], COLORS.bold[2], false, true, false);
-        } else {
-          color = COLORS.bold;
-        }
-        break;
-
-      case TokenType.Italic:
-        // Style italic markers (* or _) subdued, content italic
-        const italicMatch = token.text.match(/^(\*|_)(.*)(\*|_)$/);
-        if (italicMatch) {
-          const markerLen = 1;
-          // Subdued markers
-          editor.addOverlay(bufferId, "md",
-            token.start, token.start + markerLen,
-            COLORS.italicMarker[0], COLORS.italicMarker[1], COLORS.italicMarker[2], false, false, false);
-          editor.addOverlay(bufferId, "md",
-            token.end - markerLen, token.end,
-            COLORS.italicMarker[0], COLORS.italicMarker[1], COLORS.italicMarker[2], false, false, false);
-          // Italic content with italic=true
-          editor.addOverlay(bufferId, "md",
-            token.start + markerLen, token.end - markerLen,
-            COLORS.italic[0], COLORS.italic[1], COLORS.italic[2], false, false, true);
-        } else {
-          color = COLORS.italic;
-        }
-        break;
-
-      case TokenType.LinkText:
-        color = COLORS.link;
-        underline = true;
-        break;
-
-      case TokenType.LinkUrl:
-        color = COLORS.linkUrl;
-        break;
-
-      case TokenType.ListItem:
-      case TokenType.OrderedListItem:
-        // Style just the bullet/number
-        const bulletMatch = token.text.match(/^(\s*)([-*+]|\d+\.)/);
-        if (bulletMatch) {
-          const bulletEnd = token.start + bulletMatch[0].length;
-          editor.addOverlay(
-            bufferId,
-            "md",
-            token.start,
-            bulletEnd,
-            COLORS.listBullet[0],
-            COLORS.listBullet[1],
-            COLORS.listBullet[2],
-            false
-          );
-        }
-        break;
-
-      case TokenType.Checkbox:
-        // Style checkbox and bullet
-        const checkboxMatch = token.text.match(/^(\s*[-*+]\s+\[[ x]\])/);
-        if (checkboxMatch) {
-          const checkboxEnd = token.start + checkboxMatch[0].length;
-          editor.addOverlay(
-            bufferId,
-            "md",
-            token.start,
-            checkboxEnd,
-            COLORS.checkbox[0],
-            COLORS.checkbox[1],
-            COLORS.checkbox[2],
-            false
-          );
-        }
-        break;
-    }
-
-    if (color) {
-      editor.addOverlay(
-        bufferId,
-        overlayId,
-        token.start,
-        token.end,
-        color[0],
-        color[1],
-        color[2],
-        underline
-      );
-    }
-  }
-}
-
-// Highlight a single line for markdown (used with lines_changed event)
-function highlightLine(
-  bufferId: number,
-  lineNumber: number,
-  byteStart: number,
-  content: string
-): void {
-  const trimmed = content.trim();
-  if (trimmed.length === 0) return;
-
-  // Headers
-  const headerMatch = trimmed.match(/^(#{1,6})\s/);
-  if (headerMatch) {
-    editor.addOverlay(
-      bufferId,
-      "md",
-      byteStart,
-      byteStart + content.length,
-      COLORS.header[0], COLORS.header[1], COLORS.header[2],
-      false, true, false  // bold
-    );
-    return;
-  }
-
-  // Code block fences
-  if (trimmed.startsWith('```')) {
-    editor.addOverlay(
-      bufferId,
-      "md",
-      byteStart,
-      byteStart + content.length,
-      COLORS.fence[0], COLORS.fence[1], COLORS.fence[2],
-      false
-    );
-    return;
-  }
-
-  // Block quotes
-  if (trimmed.startsWith('>')) {
-    editor.addOverlay(
-      bufferId,
-      "md",
-      byteStart,
-      byteStart + content.length,
-      COLORS.quote[0], COLORS.quote[1], COLORS.quote[2],
-      false
-    );
-    return;
-  }
-
-  // Horizontal rules
-  if (trimmed.match(/^[-*_]{3,}$/)) {
-    editor.addOverlay(
-      bufferId,
-      "md",
-      byteStart,
-      byteStart + content.length,
-      COLORS.quote[0], COLORS.quote[1], COLORS.quote[2],
-      false
-    );
-    return;
-  }
-
-  // List items (unordered)
-  const listMatch = content.match(/^(\s*)([-*+])\s/);
-  if (listMatch) {
-    const bulletStart = byteStart + listMatch[1].length;
-    const bulletEnd = bulletStart + 1;
-    editor.addOverlay(
-      bufferId,
-      "md",
-      bulletStart,
-      bulletEnd,
-      COLORS.listBullet[0], COLORS.listBullet[1], COLORS.listBullet[2],
-      false
-    );
-  }
-
-  // Ordered list items
-  const orderedMatch = content.match(/^(\s*)(\d+\.)\s/);
-  if (orderedMatch) {
-    const numStart = byteStart + orderedMatch[1].length;
-    const numEnd = numStart + orderedMatch[2].length;
-    editor.addOverlay(
-      bufferId,
-      "md",
-      numStart,
-      numEnd,
-      COLORS.listBullet[0], COLORS.listBullet[1], COLORS.listBullet[2],
-      false
-    );
-  }
-
-  // Checkboxes
-  const checkMatch = content.match(/^(\s*[-*+]\s+)(\[[ x]\])/);
-  if (checkMatch) {
-    const checkStart = byteStart + checkMatch[1].length;
-    const checkEnd = checkStart + checkMatch[2].length;
-    editor.addOverlay(
-      bufferId,
-      "md",
-      checkStart,
-      checkEnd,
-      COLORS.checkbox[0], COLORS.checkbox[1], COLORS.checkbox[2],
-      false
-    );
-  }
-
-  // Inline elements
-
-  // Inline code: `code`
-  const codeRegex = /`([^`]+)`/g;
-  let match;
-  while ((match = codeRegex.exec(content)) !== null) {
-    editor.addOverlay(
-      bufferId,
-      "md",
-      byteStart + match.index,
-      byteStart + match.index + match[0].length,
-      COLORS.code[0], COLORS.code[1], COLORS.code[2],
-      false
-    );
-  }
-
-  // Bold: **text** or __text__
-  const boldRegex = /(\*\*|__)([^*_]+)\1/g;
-  while ((match = boldRegex.exec(content)) !== null) {
-    const markerLen = match[1].length;
-    const fullStart = byteStart + match.index;
-    const fullEnd = fullStart + match[0].length;
-    // Subdued markers
-    editor.addOverlay(
-      bufferId,
-      "md",
-      fullStart, fullStart + markerLen,
-      COLORS.boldMarker[0], COLORS.boldMarker[1], COLORS.boldMarker[2],
-      false, false, false
-    );
-    editor.addOverlay(
-      bufferId,
-      "md",
-      fullEnd - markerLen, fullEnd,
-      COLORS.boldMarker[0], COLORS.boldMarker[1], COLORS.boldMarker[2],
-      false, false, false
-    );
-    // Bold content
-    editor.addOverlay(
-      bufferId,
-      "md",
-      fullStart + markerLen, fullEnd - markerLen,
-      COLORS.bold[0], COLORS.bold[1], COLORS.bold[2],
-      false, true, false
-    );
-  }
-
-  // Italic: *text* or _text_ (but not inside bold)
-  const italicRegex = /(?<!\*|\w)(\*|_)(?!\*|_)([^*_\n]+)(?<!\*|_)\1(?!\*|\w)/g;
-  while ((match = italicRegex.exec(content)) !== null) {
-    const fullStart = byteStart + match.index;
-    const fullEnd = fullStart + match[0].length;
-    // Subdued markers
-    editor.addOverlay(
-      bufferId,
-      "md",
-      fullStart, fullStart + 1,
-      COLORS.italicMarker[0], COLORS.italicMarker[1], COLORS.italicMarker[2],
-      false, false, false
-    );
-    editor.addOverlay(
-      bufferId,
-      "md",
-      fullEnd - 1, fullEnd,
-      COLORS.italicMarker[0], COLORS.italicMarker[1], COLORS.italicMarker[2],
-      false, false, false
-    );
-    // Italic content
-    editor.addOverlay(
-      bufferId,
-      "md",
-      fullStart + 1, fullEnd - 1,
-      COLORS.italic[0], COLORS.italic[1], COLORS.italic[2],
-      false, false, true
-    );
-  }
-
-  // Links: [text](url)
-  const linkRegex = /\[([^\]]+)\]\(([^)]+)\)/g;
-  while ((match = linkRegex.exec(content)) !== null) {
-    const fullStart = byteStart + match.index;
-    const textStart = fullStart + 1;
-    const textEnd = textStart + match[1].length;
-    const urlStart = textEnd + 2;
-    const urlEnd = urlStart + match[2].length;
-
-    // Link text (underlined)
-    editor.addOverlay(
-      bufferId,
-      "md",
-      textStart, textEnd,
-      COLORS.link[0], COLORS.link[1], COLORS.link[2],
-      true  // underline
-    );
-    // Link URL (subdued)
-    editor.addOverlay(
-      bufferId,
-      "md",
-      urlStart, urlEnd,
-      COLORS.linkUrl[0], COLORS.linkUrl[1], COLORS.linkUrl[2],
-      false
-    );
-  }
-}
-
 // Check if a file is a markdown file
 function isMarkdownFile(path: string): boolean {
   return path.endsWith('.md') || path.endsWith('.markdown');
@@ -1025,19 +323,6 @@ function processBuffer(bufferId: number, _splitId?: number): void {
   editor.refreshLines(bufferId);
 }
 
-// Enable highlighting for a markdown buffer (auto on file open)
-function enableHighlighting(bufferId: number): void {
-  const info = editor.getBufferInfo(bufferId);
-  if (!info || !isMarkdownFile(info.path)) return;
-
-  if (!highlightingBuffers.has(bufferId)) {
-    highlightingBuffers.add(bufferId);
-    // Trigger a refresh so lines_changed will process visible lines
-    editor.refreshLines(bufferId);
-    editor.debug(`Markdown highlighting enabled for buffer ${bufferId}`);
-  }
-}
-
 // Enable full compose mode for a buffer (explicit toggle)
 function enableMarkdownCompose(bufferId: number): void {
   const info = editor.getBufferInfo(bufferId);
@@ -1045,7 +330,6 @@ function enableMarkdownCompose(bufferId: number): void {
 
   if (!composeBuffers.has(bufferId)) {
     composeBuffers.add(bufferId);
-    highlightingBuffers.add(bufferId);  // Also ensure highlighting is on
 
     // Hide line numbers in compose mode
     editor.setLineNumbers(bufferId, false);
@@ -1055,7 +339,7 @@ function enableMarkdownCompose(bufferId: number): void {
   }
 }
 
-// Disable compose mode for a buffer (but keep highlighting)
+// Disable compose mode for a buffer
 function disableMarkdownCompose(bufferId: number): void {
   if (composeBuffers.has(bufferId)) {
     composeBuffers.delete(bufferId);
@@ -1066,7 +350,6 @@ function disableMarkdownCompose(bufferId: number): void {
     // Clear view transform to return to normal rendering
     editor.clearViewTransform(bufferId);
 
-    // Keep highlighting on, just clear the view transform
     editor.refreshLines(bufferId);
     editor.debug(`Markdown compose disabled for buffer ${bufferId}`);
   }
@@ -1092,7 +375,7 @@ globalThis.markdownToggleCompose = function(): void {
     enableMarkdownCompose(bufferId);
     // Trigger a re-render to apply the transform
     editor.refreshLines(bufferId);
-    editor.setStatus("Markdown Compose: ON (soft breaks, styled)");
+    editor.setStatus("Markdown Compose: ON (soft breaks, centered)");
   }
 };
 
@@ -1243,7 +526,7 @@ function transformMarkdownTokens(
 }
 
 // Handle view transform request - receives tokens from core for transformation
-// Only applies transforms when in compose mode (not just highlighting)
+// Only applies transforms when in compose mode
 globalThis.onMarkdownViewTransform = function(data: {
   buffer_id: number;
   split_id: number;
@@ -1251,7 +534,7 @@ globalThis.onMarkdownViewTransform = function(data: {
   viewport_end: number;
   tokens: ViewTokenWire[];
 }): void {
-  // Only transform when in compose mode (view transforms change line wrapping etc)
+  // Only transform when in compose mode
   if (!composeBuffers.has(data.buffer_id)) return;
 
   const info = editor.getBufferInfo(data.buffer_id);
@@ -1266,18 +549,6 @@ globalThis.onMarkdownViewTransform = function(data: {
     data.viewport_start
   );
 
-  // Extract text for overlay styling
-  const text = extractTextFromTokens(data.tokens);
-  const parser = new MarkdownParser(text);
-  const mdTokens = parser.parse();
-
-  // Adjust token offsets for viewport
-  for (const token of mdTokens) {
-    token.start += data.viewport_start;
-    token.end += data.viewport_start;
-  }
-  applyMarkdownStyling(data.buffer_id, mdTokens);
-
   // Submit the transformed tokens - keep compose_width for margins/centering
   const layoutHints: LayoutHints = {
     compose_width: config.composeWidth,
@@ -1294,103 +565,13 @@ globalThis.onMarkdownViewTransform = function(data: {
   );
 };
 
-// Handle render_start - enable highlighting for markdown files
-globalThis.onMarkdownRenderStart = function(data: { buffer_id: number }): void {
-  // Auto-enable highlighting for markdown files on first render
-  if (!highlightingBuffers.has(data.buffer_id)) {
-    const info = editor.getBufferInfo(data.buffer_id);
-    if (info && isMarkdownFile(info.path)) {
-      highlightingBuffers.add(data.buffer_id);
-      editor.debug(`Markdown highlighting auto-enabled for buffer ${data.buffer_id}`);
-    } else {
-      return;
-    }
-  }
-  // Note: Don't clear overlays here - the after-insert/after-delete handlers
-  // already clear affected ranges via clearOverlaysInRange(). Clearing all
-  // overlays here would cause flicker since lines_changed hasn't fired yet.
-};
-
-// Handle lines_changed - process visible lines incrementally
-globalThis.onMarkdownLinesChanged = function(data: {
-  buffer_id: number;
-  lines: Array<{
-    line_number: number;
-    byte_start: number;
-    byte_end: number;
-    content: string;
-  }>;
-}): void {
-  // Auto-enable highlighting for markdown files
-  if (!highlightingBuffers.has(data.buffer_id)) {
-    const info = editor.getBufferInfo(data.buffer_id);
-    if (info && isMarkdownFile(info.path)) {
-      highlightingBuffers.add(data.buffer_id);
-    } else {
-      return;
-    }
-  }
-
-  // Process all changed lines
-  for (const line of data.lines) {
-    highlightLine(data.buffer_id, line.line_number, line.byte_start, line.content);
-  }
-};
-
-// Handle buffer activation - auto-enable highlighting for markdown files
-globalThis.onMarkdownBufferActivated = function(data: { buffer_id: number }): void {
-  enableHighlighting(data.buffer_id);
-};
-
-// Handle content changes - clear affected overlays for efficient updates
-globalThis.onMarkdownAfterInsert = function(data: {
-  buffer_id: number;
-  position: number;
-  text: string;
-  affected_start: number;
-  affected_end: number;
-}): void {
-  if (!highlightingBuffers.has(data.buffer_id)) return;
-
-  // Clear only overlays in the affected byte range
-  // These overlays may now span incorrect content after the insertion
-  // The affected lines will be re-processed via lines_changed with correct content
-  editor.clearOverlaysInRange(data.buffer_id, data.affected_start, data.affected_end);
-};
-
-globalThis.onMarkdownAfterDelete = function(data: {
-  buffer_id: number;
-  start: number;
-  end: number;
-  deleted_text: string;
-  affected_start: number;
-  deleted_len: number;
-}): void {
-  if (!highlightingBuffers.has(data.buffer_id)) return;
-
-  // Clear overlays that overlapped with the deleted range
-  // Overlays entirely within the deleted range are already gone (their markers were deleted)
-  // But overlays spanning the deletion boundary may now be incorrect
-  // Use a slightly expanded range to catch boundary cases
-  const clearStart = data.affected_start > 0 ? data.affected_start - 1 : 0;
-  const clearEnd = data.affected_start + data.deleted_len + 1;
-  editor.clearOverlaysInRange(data.buffer_id, clearStart, clearEnd);
-};
-
-// Handle buffer close events
+// Handle buffer close events - clean up compose mode tracking
 globalThis.onMarkdownBufferClosed = function(data: { buffer_id: number }): void {
-  highlightingBuffers.delete(data.buffer_id);
   composeBuffers.delete(data.buffer_id);
-  dirtyBuffers.delete(data.buffer_id);
 };
 
 // Register hooks
 editor.on("view_transform_request", "onMarkdownViewTransform");
-editor.on("render_start", "onMarkdownRenderStart");
-editor.on("lines_changed", "onMarkdownLinesChanged");
-editor.on("buffer_activated", "onMarkdownBufferActivated");
-editor.on("after-insert", "onMarkdownAfterInsert");
-editor.on("after-delete", "onMarkdownAfterDelete");
 editor.on("buffer_closed", "onMarkdownBufferClosed");
 editor.on("prompt_confirmed", "onMarkdownComposeWidthConfirmed");
 
@@ -1430,7 +611,7 @@ globalThis.onMarkdownComposeWidthConfirmed = function(args: {
 // Register commands
 editor.registerCommand(
   "Markdown: Toggle Compose",
-  "Toggle beautiful Markdown rendering (soft breaks, syntax highlighting)",
+  "Toggle compose mode (soft wrapping, centered margins)",
   "markdownToggleCompose",
   "normal"
 );