Improve editor binary handling and perf tracing

Author: mehmetozguldev

src/features/editor/components/editor.tsx

@@ -279,7 +279,7 @@ export function Editor({
   const lineHeight = useMemo(() => calculateLineHeight(fontSize), [fontSize]);
   const shouldVirtualizeRendering =
     lines.length >= EDITOR_CONSTANTS.RENDER_VIRTUALIZATION_THRESHOLD;
-  const useIncrementalTokenization = hasSyntaxHighlighting;
+  const useIncrementalTokenization = hasSyntaxHighlighting && shouldVirtualizeRendering;
 
   const {
     viewportRange,

src/features/editor/components/layers/highlight-layer.tsx

@@ -304,12 +304,7 @@ export const HighlightLayer = memo(HighlightLayerComponent, (prev, next) => {
     );
   }
 
-  const tokensUnchanged =
-    prev.tokens === next.tokens ||
-    (prev.tokens.length === next.tokens.length &&
-      (prev.tokens.length === 0 ||
-        (prev.tokens[0]?.start === next.tokens[0]?.start &&
-          prev.tokens[prev.tokens.length - 1]?.end === next.tokens[prev.tokens.length - 1]?.end)));
+  const tokensUnchanged = prev.tokens === next.tokens;
 
   // If only content changed but tokens haven't updated yet, skip the intermediate render.
   // The tokenizer will produce new tokens shortly, triggering a proper re-render then.

src/features/editor/hooks/use-performance.ts

@@ -35,9 +35,6 @@ export function usePerformanceMonitor(componentName: string) {
           const entries = performance.getEntriesByName(measureName);
           const lastEntry = entries[entries.length - 1];
           if (lastEntry) {
-            console.info(
-              `[Performance] [${componentName}] ${metricName}: ${lastEntry.duration.toFixed(2)}ms`,
-            );
             frontendTrace(
               lastEntry.duration >= 250 ? "warn" : "info",
               "bench:perf",

src/features/file-system/controllers/file-utils.ts

@@ -118,6 +118,16 @@ export const isPdfFile = (path: string): boolean => {
  */
 export const isBinaryFile = (path: string): boolean => {
   const lowerPath = path.toLowerCase();
+  const binarySuffixes = [
+    ".tar.gz",
+    ".tgz",
+    ".tar.bz2",
+    ".tbz2",
+    ".tar.xz",
+    ".txz",
+    ".tar.zst",
+    ".tzst",
+  ];
   const binaryExtensions = [
     ".wasm",
     ".exe",
@@ -151,9 +161,41 @@ export const isBinaryFile = (path: string): boolean => {
     ".dmg",
     ".msi",
   ];
+  if (binarySuffixes.some((suffix) => lowerPath.endsWith(suffix))) {
+    return true;
+  }
   return binaryExtensions.some((ext) => lowerPath.endsWith(ext));
 };
 
+/**
+ * Best-effort binary sniffing for files with unknown extensions.
+ * Treat null bytes and a high ratio of control bytes as unsupported for the text editor.
+ */
+export const isBinaryContent = (data: Uint8Array, sampleSize = 8192): boolean => {
+  const limit = Math.min(data.length, sampleSize);
+  if (limit === 0) return false;
+
+  let suspiciousBytes = 0;
+
+  for (let i = 0; i < limit; i++) {
+    const byte = data[i];
+
+    if (byte === 0) {
+      return true;
+    }
+
+    const isPrintableAscii = byte >= 0x20 && byte <= 0x7e;
+    const isCommonWhitespace = byte === 0x09 || byte === 0x0a || byte === 0x0d || byte === 0x0c;
+    const isLikelyUtf8Lead = byte >= 0xc2;
+
+    if (!isPrintableAscii && !isCommonWhitespace && !isLikelyUtf8Lead) {
+      suspiciousBytes++;
+    }
+  }
+
+  return suspiciousBytes / limit > 0.3;
+};
+
 /**
  * Extract filename from a path
  */

src/features/file-system/controllers/store.ts

@@ -1,6 +1,6 @@
 import { invoke } from "@tauri-apps/api/core";
 import { basename, dirname, extname, join } from "@tauri-apps/api/path";
-import { copyFile } from "@tauri-apps/plugin-fs";
+import { copyFile, readFile } from "@tauri-apps/plugin-fs";
 import { revealItemInDir } from "@tauri-apps/plugin-opener";
 import { create } from "zustand";
 import { immer } from "zustand/middleware/immer";
@@ -53,6 +53,7 @@ import {
 import {
   getDatabaseTypeFromPath,
   getFilenameFromPath,
+  isBinaryContent,
   isBinaryFile,
   isImageFile,
   isPdfFile,
@@ -743,6 +744,38 @@ export const useFileSystemStore = createSelectors(
           );
           fileOpenBenchmark.finish(path, "binary-buffer-opened");
         } else {
+          if (!path.startsWith("remote://")) {
+            try {
+              const fileData = await readFile(resolvedPath);
+
+              if (isStaleRequest()) return;
+
+              if (isBinaryContent(fileData)) {
+                openBuffer(
+                  path,
+                  fileName,
+                  "",
+                  false,
+                  undefined,
+                  false,
+                  false,
+                  undefined,
+                  false,
+                  false,
+                  false,
+                  undefined,
+                  false,
+                  false,
+                  true,
+                );
+                fileOpenBenchmark.finish(path, "binary-sniff-buffer-opened");
+                return;
+              }
+            } catch (error) {
+              console.error("Failed to inspect file bytes before opening:", error);
+            }
+          }
+
           // Check if external editor is enabled for text files
           const { settings } = useSettingsStore.getState();
           const { openExternalEditorBuffer } = useBufferStore.getState().actions;

src/utils/frontend-trace.ts

@@ -27,6 +27,10 @@ export function frontendTrace(
   message: string,
   payload?: Record<string, unknown>,
 ) {
+  if (scope.startsWith("bench:")) {
+    return;
+  }
+
   void invoke("frontend_trace", {
     level,
     scope,