@opentui/core 0.1.31 → 0.1.32

package/lib/KeyHandler.d.ts

@@ -10,6 +10,7 @@ export declare class KeyEvent implements ParsedKey {
     number: boolean;
     raw: string;
     eventType: KeyEventType;
+    source: "raw" | "kitty";
     code?: string;
     super?: boolean;
     hyper?: boolean;
@@ -37,11 +38,13 @@ export type KeyHandlerEventMap = {
 export declare class KeyHandler extends EventEmitter<KeyHandlerEventMap> {
     protected stdin: NodeJS.ReadStream;
     protected useKittyKeyboard: boolean;
-    protected listener: (key: Buffer) => void;
     protected pasteMode: boolean;
     protected pasteBuffer: string[];
     private suspended;
+    private stdinBuffer;
+    private dataListener;
     constructor(stdin?: NodeJS.ReadStream, useKittyKeyboard?: boolean);
+    private processSequence;
     destroy(): void;
     suspend(): void;
     resume(): void;

package/lib/index.d.ts

@@ -5,6 +5,7 @@ export * from "./hast-styled-text";
 export * from "./RGBA";
 export * from "./parse.keypress";
 export * from "./scroll-acceleration";
+export * from "./stdin-buffer";
 export * from "./styled-text";
 export * from "./yoga.options";
 export * from "./parse.mouse";

package/lib/parse.keypress.d.ts

@@ -11,6 +11,7 @@ export interface ParsedKey {
     number: boolean;
     raw: string;
     eventType: KeyEventType;
+    source: "raw" | "kitty";
     code?: string;
     super?: boolean;
     hyper?: boolean;

package/lib/stdin-buffer.d.ts

@@ -0,0 +1,42 @@
+/**
+ * StdinBuffer wraps a stdin stream and emits complete sequences.
+ *
+ * This is necessary because stdin data events can arrive in partial chunks,
+ * especially for escape sequences like mouse events. Without buffering,
+ * partial sequences can be misinterpreted as regular keypresses.
+ *
+ * For example, the mouse SGR sequence `\x1b[<35;20;5m` might arrive as:
+ * - Event 1: `\x1b`
+ * - Event 2: `[<35`
+ * - Event 3: `;20;5m`
+ *
+ * The buffer accumulates these until a complete sequence is detected.
+ */
+import { EventEmitter } from "events";
+export type StdinBufferOptions = {
+    /**
+     * Maximum time to wait for sequence completion (default: 10ms)
+     * After this time, the buffer is flushed even if incomplete
+     */
+    timeout?: number;
+};
+export type StdinBufferEventMap = {
+    data: [string];
+};
+/**
+ * Wraps a stdin stream and emits complete sequences via the 'data' event.
+ * Handles partial escape sequences that arrive across multiple chunks.
+ */
+export declare class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
+    private buffer;
+    private timeout;
+    private readonly timeoutMs;
+    private readonly stdin;
+    private readonly stdinListener;
+    constructor(stdin: NodeJS.ReadStream, options?: StdinBufferOptions);
+    private handleData;
+    flush(): string[];
+    clear(): void;
+    getBuffer(): string;
+    destroy(): void;
+}

package/lib/tree-sitter/client.d.ts

@@ -43,4 +43,5 @@ export declare class TreeSitterClient extends EventEmitter<TreeSitterClientEvent
     getAllBuffers(): BufferState[];
     isInitialized(): boolean;
     setDataPath(dataPath: string): Promise<void>;
+    clearCache(): Promise<void>;
 }

package/lib/tree-sitter/parsers-config.d.ts

@@ -0,0 +1,38 @@
+/**
+ * This file contains the configuration for the defaulttree-sitter parsers.
+ * It is used by ./assets/update.ts to generate the default-parsers.ts file.
+ * For changes here to be reflected in the default-parsers.ts file, you need to run `bun run ./assets/update.ts`
+ */
+declare const _default: {
+    parsers: ({
+        filetype: string;
+        wasm: string;
+        queries: {
+            highlights: string[];
+            injections?: undefined;
+        };
+        injectionMapping?: undefined;
+    } | {
+        filetype: string;
+        wasm: string;
+        queries: {
+            highlights: string[];
+            injections: string[];
+        };
+        injectionMapping: {
+            nodeTypes: {
+                inline: string;
+                pipe_table_cell: string;
+            };
+            infoStringMap: {
+                javascript: string;
+                js: string;
+                typescript: string;
+                ts: string;
+                markdown: string;
+                md: string;
+            };
+        };
+    })[];
+};
+export default _default;

package/lib/tree-sitter/types.d.ts

@@ -8,13 +8,30 @@ export interface HighlightResponse {
     highlights: HighlightRange[];
     droppedHighlights: HighlightRange[];
 }
-export type SimpleHighlight = [number, number, string];
+export interface HighlightMeta {
+    isInjection?: boolean;
+    injectionLang?: string;
+    containsInjection?: boolean;
+    conceal?: string | null;
+    concealLines?: string | null;
+}
+export type SimpleHighlight = [number, number, string, HighlightMeta?];
+export interface InjectionMapping {
+    nodeTypes?: {
+        [nodeType: string]: string;
+    };
+    infoStringMap?: {
+        [infoString: string]: string;
+    };
+}
 export interface FiletypeParserOptions {
     filetype: string;
     queries: {
         highlights: string[];
+        injections?: string[];
     };
     wasm: string;
+    injectionMapping?: InjectionMapping;
 }
 export interface BufferState {
     id: number;

package/lib/tree-sitter-styled-text.d.ts

@@ -3,5 +3,12 @@ import { StyledText } from "./styled-text";
 import { SyntaxStyle } from "../syntax-style";
 import { TreeSitterClient } from "./tree-sitter/client";
 import type { SimpleHighlight } from "./tree-sitter/types";
-export declare function treeSitterToTextChunks(content: string, highlights: SimpleHighlight[], syntaxStyle: SyntaxStyle): TextChunk[];
-export declare function treeSitterToStyledText(content: string, filetype: string, syntaxStyle: SyntaxStyle, client: TreeSitterClient): Promise<StyledText>;
+interface ConcealOptions {
+    enabled: boolean;
+}
+export declare function treeSitterToTextChunks(content: string, highlights: SimpleHighlight[], syntaxStyle: SyntaxStyle, options?: ConcealOptions): TextChunk[];
+export interface TreeSitterToStyledTextOptions {
+    conceal?: ConcealOptions;
+}
+export declare function treeSitterToStyledText(content: string, filetype: string, syntaxStyle: SyntaxStyle, client: TreeSitterClient, options?: TreeSitterToStyledTextOptions): Promise<StyledText>;
+export {};

package/package.json

@@ -4,7 +4,7 @@
   "main": "index.js",
   "types": "index.d.ts",
   "type": "module",
-  "version": "0.1.31",
+  "version": "0.1.32",
   "description": "OpenTUI is a TypeScript library for building terminal user interfaces (TUIs)",
   "license": "MIT",
   "repository": {
@@ -45,21 +45,21 @@
     "@types/three": "0.177.0",
     "commander": "^13.1.0",
     "typescript": "^5",
-    "web-tree-sitter": "^0.26.0"
+    "web-tree-sitter": "0.25.10"
   },
   "peerDependencies": {
-    "web-tree-sitter": ">=0.26.0"
+    "web-tree-sitter": "0.25.10"
   },
   "optionalDependencies": {
     "@dimforge/rapier2d-simd-compat": "^0.17.3",
     "bun-webgpu": "0.1.3",
     "planck": "^1.4.2",
     "three": "0.177.0",
-    "@opentui/core-darwin-x64": "0.1.31",
-    "@opentui/core-darwin-arm64": "0.1.31",
-    "@opentui/core-linux-x64": "0.1.31",
-    "@opentui/core-linux-arm64": "0.1.31",
-    "@opentui/core-win32-x64": "0.1.31",
-    "@opentui/core-win32-arm64": "0.1.31"
+    "@opentui/core-darwin-x64": "0.1.32",
+    "@opentui/core-darwin-arm64": "0.1.32",
+    "@opentui/core-linux-x64": "0.1.32",
+    "@opentui/core-linux-arm64": "0.1.32",
+    "@opentui/core-win32-x64": "0.1.32",
+    "@opentui/core-win32-arm64": "0.1.32"
   }
 }

package/parser.worker.js

@@ -144,6 +144,7 @@ class ParserWorker {
   initializePromise;
   performance;
   dataPath;
+  tsDataPath;
   initialized = false;
   constructor() {
     this.performance = {
@@ -153,11 +154,11 @@ class ParserWorker {
       queryTimes: []
     };
   }
-  async fetchHighlightQueries(sources, filetype) {
-    if (!this.dataPath) {
+  async fetchQueries(sources, filetype) {
+    if (!this.tsDataPath) {
       return "";
     }
-    return DownloadUtils.fetchHighlightQueries(sources, this.dataPath, filetype);
+    return DownloadUtils.fetchHighlightQueries(sources, this.tsDataPath, filetype);
   }
   async initialize({ dataPath }) {
     if (this.initializePromise) {
@@ -165,10 +166,11 @@ class ParserWorker {
     }
     this.initializePromise = new Promise(async (resolve, reject) => {
       this.dataPath = dataPath;
+      this.tsDataPath = path2.join(dataPath, "tree-sitter");
       try {
-        await mkdir2(path2.join(dataPath, "languages"), { recursive: true });
-        await mkdir2(path2.join(dataPath, "queries"), { recursive: true });
-        let { default: treeWasm } = await import("web-tree-sitter/web-tree-sitter.wasm", {
+        await mkdir2(path2.join(this.tsDataPath, "languages"), { recursive: true });
+        await mkdir2(path2.join(this.tsDataPath, "queries"), { recursive: true });
+        let { default: treeWasm } = await import("web-tree-sitter/tree-sitter.wasm", {
           with: { type: "wasm" }
         });
         if (/\$bunfs/.test(treeWasm)) {
@@ -192,25 +194,33 @@ class ParserWorker {
   }
   async createQueries(filetypeParser, language) {
     try {
-      const highlightQueryContent = await this.fetchHighlightQueries(filetypeParser.queries.highlights, filetypeParser.filetype);
+      const highlightQueryContent = await this.fetchQueries(filetypeParser.queries.highlights, filetypeParser.filetype);
       if (!highlightQueryContent) {
         console.error("Failed to fetch highlight queries for:", filetypeParser.filetype);
         return;
       }
-      const query = new Query(language, highlightQueryContent);
-      return {
-        highlights: query
+      const highlightsQuery = new Query(language, highlightQueryContent);
+      const result = {
+        highlights: highlightsQuery
       };
+      if (filetypeParser.queries.injections && filetypeParser.queries.injections.length > 0) {
+        const injectionQueryContent = await this.fetchQueries(filetypeParser.queries.injections, filetypeParser.filetype);
+        if (injectionQueryContent) {
+          result.injections = new Query(language, injectionQueryContent);
+        }
+      }
+      return result;
     } catch (error) {
+      console.error("Error creating queries for", filetypeParser.filetype, filetypeParser.queries);
       console.error(error);
       return;
     }
   }
   async loadLanguage(languageSource) {
-    if (!this.initialized || !this.dataPath) {
+    if (!this.initialized || !this.tsDataPath) {
       return;
     }
-    const result = await DownloadUtils.downloadOrLoad(languageSource, this.dataPath, "languages", ".wasm", false);
+    const result = await DownloadUtils.downloadOrLoad(languageSource, this.tsDataPath, "languages", ".wasm", false);
     if (result.error) {
       console.error(`Error loading language ${languageSource}:`, result.error);
       return;
@@ -297,7 +307,8 @@ class ParserWorker {
     parser.setLanguage(filetypeParser.language);
     const reusableState = {
       parser,
-      filetypeParser
+      filetypeParser,
+      queries: filetypeParser.queries
     };
     return reusableState;
   }
@@ -326,7 +337,14 @@ class ParserWorker {
       });
       return;
     }
-    const parserState = { parser, tree, queries: filetypeParser.queries };
+    const parserState = {
+      parser,
+      tree,
+      queries: filetypeParser.queries,
+      filetype,
+      content,
+      injectionMapping: filetypeParser.injectionMapping
+    };
     this.bufferParsers.set(bufferId, parserState);
     self.postMessage({
       type: "PARSER_INIT_RESPONSE",
@@ -334,7 +352,7 @@ class ParserWorker {
       messageId,
       hasParser: true
     });
-    const highlights = this.initialQuery(parserState);
+    const highlights = await this.initialQuery(parserState);
     self.postMessage({
       type: "HIGHLIGHT_RESPONSE",
       bufferId,
@@ -342,10 +360,111 @@ class ParserWorker {
       ...highlights
     });
   }
-  initialQuery(parserState) {
+  async initialQuery(parserState) {
     const query = parserState.queries.highlights;
     const matches = query.captures(parserState.tree.rootNode);
-    return this.getHighlights(parserState, matches);
+    let injectionRanges = new Map;
+    if (parserState.queries.injections) {
+      const injectionResult = await this.processInjections(parserState);
+      matches.push(...injectionResult.captures);
+      injectionRanges = injectionResult.injectionRanges;
+    }
+    return this.getHighlights(parserState, matches, injectionRanges);
+  }
+  getNodeText(node, content) {
+    return content.substring(node.startIndex, node.endIndex);
+  }
+  async processInjections(parserState) {
+    const injectionMatches = [];
+    const injectionRanges = new Map;
+    if (!parserState.queries.injections) {
+      return { captures: injectionMatches, injectionRanges };
+    }
+    const content = parserState.content;
+    const injectionCaptures = parserState.queries.injections.captures(parserState.tree.rootNode);
+    const languageGroups = new Map;
+    const injectionMapping = parserState.injectionMapping;
+    for (const capture of injectionCaptures) {
+      const captureName = capture.name;
+      if (captureName === "injection.content" || captureName.includes("injection")) {
+        const nodeType = capture.node.type;
+        let targetLanguage;
+        if (injectionMapping?.nodeTypes && injectionMapping.nodeTypes[nodeType]) {
+          targetLanguage = injectionMapping.nodeTypes[nodeType];
+        } else if (nodeType === "code_fence_content") {
+          const parent = capture.node.parent;
+          if (parent) {
+            const infoString = parent.children.find((child) => child.type === "info_string");
+            if (infoString) {
+              const languageNode = infoString.children.find((child) => child.type === "language");
+              if (languageNode) {
+                const languageName = this.getNodeText(languageNode, content);
+                if (injectionMapping?.infoStringMap && injectionMapping.infoStringMap[languageName]) {
+                  targetLanguage = injectionMapping.infoStringMap[languageName];
+                } else {
+                  targetLanguage = languageName;
+                }
+              }
+            }
+          }
+        }
+        if (targetLanguage) {
+          if (!languageGroups.has(targetLanguage)) {
+            languageGroups.set(targetLanguage, []);
+          }
+          languageGroups.get(targetLanguage).push({ node: capture.node, name: capture.name });
+        }
+      }
+    }
+    for (const [language, captures] of languageGroups.entries()) {
+      const injectedParser = await this.getReusableParser(language);
+      if (!injectedParser) {
+        console.warn(`No parser found for injection language: ${language}`);
+        continue;
+      }
+      if (!injectionRanges.has(language)) {
+        injectionRanges.set(language, []);
+      }
+      const parser = injectedParser.parser;
+      for (const { node: injectionNode } of captures) {
+        try {
+          injectionRanges.get(language).push({
+            start: injectionNode.startIndex,
+            end: injectionNode.endIndex
+          });
+          const injectionContent = this.getNodeText(injectionNode, content);
+          const tree = parser.parse(injectionContent);
+          if (tree) {
+            const matches = injectedParser.queries.highlights.captures(tree.rootNode);
+            for (const match of matches) {
+              const offsetCapture = {
+                name: match.name,
+                patternIndex: match.patternIndex,
+                _injectedQuery: injectedParser.queries.highlights,
+                node: {
+                  ...match.node,
+                  startPosition: {
+                    row: match.node.startPosition.row + injectionNode.startPosition.row,
+                    column: match.node.startPosition.row === 0 ? match.node.startPosition.column + injectionNode.startPosition.column : match.node.startPosition.column
+                  },
+                  endPosition: {
+                    row: match.node.endPosition.row + injectionNode.startPosition.row,
+                    column: match.node.endPosition.row === 0 ? match.node.endPosition.column + injectionNode.startPosition.column : match.node.endPosition.column
+                  },
+                  startIndex: match.node.startIndex + injectionNode.startIndex,
+                  endIndex: match.node.endIndex + injectionNode.startIndex
+                }
+              };
+              injectionMatches.push(offsetCapture);
+            }
+            tree.delete();
+          }
+        } catch (error) {
+          console.error(`Error processing injection for language ${language}:`, error);
+        }
+      }
+    }
+    return { captures: injectionMatches, injectionRanges };
   }
   editToRange(edit) {
     return {
@@ -366,6 +485,7 @@ class ParserWorker {
     if (!parserState) {
       return { warning: "No parser state found for buffer" };
     }
+    parserState.content = content;
     for (const edit of edits) {
       parserState.tree.edit(edit);
     }
@@ -413,6 +533,12 @@ class ParserWorker {
       const nodeCaptures = parserState.queries.highlights.captures(node);
       matches.push(...nodeCaptures);
     }
+    let injectionRanges = new Map;
+    if (parserState.queries.injections) {
+      const injectionResult = await this.processInjections(parserState);
+      matches.push(...injectionResult.captures);
+      injectionRanges = injectionResult.injectionRanges;
+    }
     const endQuery = performance.now();
     const queryTime = endQuery - startQuery;
     this.performance.queryTimes.push(queryTime);
@@ -420,12 +546,12 @@ class ParserWorker {
       this.performance.queryTimes.shift();
     }
     this.performance.averageQueryTime = this.performance.queryTimes.reduce((acc, time) => acc + time, 0) / this.performance.queryTimes.length;
-    return this.getHighlights(parserState, matches);
+    return this.getHighlights(parserState, matches, injectionRanges);
   }
   nodeContainsRange(node, range) {
     return node.startPosition.row <= range.startPosition.row && node.endPosition.row >= range.endPosition.row && (node.startPosition.row < range.startPosition.row || node.startPosition.column <= range.startPosition.column) && (node.endPosition.row > range.endPosition.row || node.endPosition.column >= range.endPosition.column);
   }
-  getHighlights(parserState, matches) {
+  getHighlights(parserState, matches, injectionRanges) {
     const lineHighlights = new Map;
     const droppedHighlights = new Map;
     for (const match of matches) {
@@ -467,12 +593,54 @@ class ParserWorker {
       }))
     };
   }
-  getSimpleHighlights(matches) {
+  getSimpleHighlights(matches, injectionRanges) {
     const highlights = [];
+    const flatInjectionRanges = [];
+    for (const [lang, ranges] of injectionRanges.entries()) {
+      for (const range of ranges) {
+        flatInjectionRanges.push({ ...range, lang });
+      }
+    }
     for (const match of matches) {
       const node = match.node;
-      highlights.push([node.startIndex, node.endIndex, match.name]);
+      let isInjection = false;
+      let injectionLang;
+      let containsInjection = false;
+      for (const injRange of flatInjectionRanges) {
+        if (node.startIndex >= injRange.start && node.endIndex <= injRange.end) {
+          isInjection = true;
+          injectionLang = injRange.lang;
+          break;
+        } else if (node.startIndex <= injRange.start && node.endIndex >= injRange.end) {
+          containsInjection = true;
+          break;
+        }
+      }
+      const matchQuery = match._injectedQuery;
+      const patternProperties = matchQuery?.setProperties?.[match.patternIndex];
+      const concealValue = patternProperties?.conceal ?? match.setProperties?.conceal;
+      const concealLines = patternProperties?.conceal_lines ?? match.setProperties?.conceal_lines;
+      const meta = {};
+      if (isInjection && injectionLang) {
+        meta.isInjection = true;
+        meta.injectionLang = injectionLang;
+      }
+      if (containsInjection) {
+        meta.containsInjection = true;
+      }
+      if (concealValue !== undefined) {
+        meta.conceal = concealValue;
+      }
+      if (concealLines !== undefined) {
+        meta.concealLines = concealLines;
+      }
+      if (Object.keys(meta).length > 0) {
+        highlights.push([node.startIndex, node.endIndex, match.name, meta]);
+      } else {
+        highlights.push([node.startIndex, node.endIndex, match.name]);
+      }
     }
+    highlights.sort((a, b) => a[0] - b[0]);
     return highlights;
   }
   async handleResetBuffer(bufferId, version, content) {
@@ -480,13 +648,20 @@ class ParserWorker {
     if (!parserState) {
       return { warning: "No parser state found for buffer" };
     }
+    parserState.content = content;
     const newTree = parserState.parser.parse(content);
     if (!newTree) {
       return { error: "Failed to parse buffer during reset" };
     }
     parserState.tree = newTree;
     const matches = parserState.queries.highlights.captures(parserState.tree.rootNode);
-    return this.getHighlights(parserState, matches);
+    let injectionRanges = new Map;
+    if (parserState.queries.injections) {
+      const injectionResult = await this.processInjections(parserState);
+      matches.push(...injectionResult.captures);
+      injectionRanges = injectionResult.injectionRanges;
+    }
+    return this.getHighlights(parserState, matches, injectionRanges);
   }
   disposeBuffer(bufferId) {
     const parserState = this.bufferParsers.get(bufferId);
@@ -508,7 +683,9 @@ class ParserWorker {
       });
       return;
     }
-    const tree = reusableState.parser.parse(content);
+    const parseContent = filetype === "markdown" && content.endsWith("```") ? content + `
+` : content;
+    const tree = reusableState.parser.parse(parseContent);
     if (!tree) {
       self.postMessage({
         type: "ONESHOT_HIGHLIGHT_RESPONSE",
@@ -520,7 +697,21 @@ class ParserWorker {
     }
     try {
       const matches = reusableState.filetypeParser.queries.highlights.captures(tree.rootNode);
-      const highlights = this.getSimpleHighlights(matches);
+      let injectionRanges = new Map;
+      if (reusableState.filetypeParser.queries.injections) {
+        const parserState = {
+          parser: reusableState.parser,
+          tree,
+          queries: reusableState.filetypeParser.queries,
+          filetype,
+          content,
+          injectionMapping: reusableState.filetypeParser.injectionMapping
+        };
+        const injectionResult = await this.processInjections(parserState);
+        matches.push(...injectionResult.captures);
+        injectionRanges = injectionResult.injectionRanges;
+      }
+      const highlights = this.getSimpleHighlights(matches, injectionRanges);
       self.postMessage({
         type: "ONESHOT_HIGHLIGHT_RESPONSE",
         messageId,
@@ -533,13 +724,32 @@ class ParserWorker {
   }
   async updateDataPath(dataPath) {
     this.dataPath = dataPath;
+    this.tsDataPath = path2.join(dataPath, "tree-sitter");
     try {
-      await mkdir2(path2.join(dataPath, "languages"), { recursive: true });
-      await mkdir2(path2.join(dataPath, "queries"), { recursive: true });
+      await mkdir2(path2.join(this.tsDataPath, "languages"), { recursive: true });
+      await mkdir2(path2.join(this.tsDataPath, "queries"), { recursive: true });
     } catch (error) {
       throw new Error(`Failed to update data path: ${error}`);
     }
   }
+  async clearCache() {
+    if (!this.dataPath || !this.tsDataPath) {
+      throw new Error("No data path configured");
+    }
+    const { rm } = await import("fs/promises");
+    try {
+      const treeSitterPath = path2.join(this.dataPath, "tree-sitter");
+      await rm(treeSitterPath, { recursive: true, force: true });
+      await mkdir2(path2.join(treeSitterPath, "languages"), { recursive: true });
+      await mkdir2(path2.join(treeSitterPath, "queries"), { recursive: true });
+      this.filetypeParsers.clear();
+      this.filetypeParserPromises.clear();
+      this.reusableParsers.clear();
+      this.reusableParserPromises.clear();
+    } catch (error) {
+      throw new Error(`Failed to clear cache: ${error}`);
+    }
+  }
 }
 if (!isMainThread) {
   let logMessage = function(type, ...args) {
@@ -552,6 +762,7 @@ if (!isMainThread) {
   const worker = new ParserWorker;
   console.log = (...args) => logMessage("log", ...args);
   console.error = (...args) => logMessage("error", ...args);
+  console.warn = (...args) => logMessage("warn", ...args);
   self.onmessage = async (e) => {
     const { type, bufferId, version, content, filetype, edits, filetypeParser, messageId, dataPath } = e.data;
     try {
@@ -619,6 +830,18 @@ if (!isMainThread) {
             });
           }
           break;
+        case "CLEAR_CACHE":
+          try {
+            await worker.clearCache();
+            self.postMessage({ type: "CLEAR_CACHE_RESPONSE", messageId });
+          } catch (error) {
+            self.postMessage({
+              type: "CLEAR_CACHE_RESPONSE",
+              messageId,
+              error: error instanceof Error ? error.message : String(error)
+            });
+          }
+          break;
         default:
           self.postMessage({
             type: "ERROR",
@@ -636,5 +859,5 @@ if (!isMainThread) {
   };
 }
 
-//# debugId=E28996FCD9507DC064756E2164756E21
+//# debugId=E1AC39235C034C8264756E2164756E21
 //# sourceMappingURL=parser.worker.js.map