@youtyan/code-viewer 0.1.14 → 0.1.16

package/web-src/server/preview.ts

@@ -3,11 +3,22 @@
 import { closeSync, constants, existsSync, lstatSync, openSync, readFileSync, realpathSync, statSync, unlinkSync, watch, writeFileSync } from 'node:fs';
 import { basename, dirname, extname, join, normalize, relative } from 'node:path';
 import { APP_ENTRY_PATHS, SPA_PATHS } from '../routes';
-import type { DiffMeta, FileDiffResponse, FileMeta, FileRangeResponse, FileSearchListResponse, GrepMatch, GrepResponse, RepoTreeResponse } from '../types';
+import type { DiffMeta, FileDiffResponse, FileMeta, FileRangeResponse, FileSearchListResponse, GrepMatch, GrepResponse, RepoTreeResponse, SettingsResponse } from '../types';
 import { cacheFresh, fileDiffCacheKey, setTimedCacheEntry, type TimedCacheEntry } from './cache';
 import { startDevAssetReload } from './dev-assets';
 import * as git from './git';
-import { isSameWorktreeRange } from './range';
+import {
+  buildLineOffsetIndexFromStream,
+  collectByteRangeFromStream,
+  collectBytesWithLineOffsetIndexFromStream,
+  collectLineRangeFromIndexedText,
+  collectLineRangeFromStream,
+  isSameWorktreeRange,
+  lineByteRangeForIndex,
+  parseHttpByteRange,
+  type LineOffsetIndex,
+  type LineRangeResult,
+} from './range';
 import {
   GREP_MAX_FILE_BYTES,
   buildFileSearchList,
@@ -29,6 +40,9 @@ const WATCHED_ASSET_FILES = ['index.html', 'style.css', 'app.js'];
 const SIZE_SMALL = 2000;
 const SIZE_MEDIUM = 8000;
 const SIZE_LARGE = 20000;
+const LINE_INDEX_MIN_START = 10000;
+const LINE_INDEX_MAX_FILE_BYTES = 256 * 1024 * 1024;
+const BLOB_LINE_CACHE_MAX_BYTES = 128 * 1024 * 1024;
 const MAX_UPLOAD_FILE_BYTES = 10 * 1024 * 1024;
 const MAX_UPLOAD_TOTAL_BYTES = 50 * 1024 * 1024;
 const MAX_UPLOAD_BODY_BYTES = MAX_UPLOAD_TOTAL_BYTES + 1024 * 1024;
@@ -45,6 +59,8 @@ let cliArgs = DEFAULT_ARGS;
 let listenPort = 0;
 let allowUpload = false;
 let uploadAllowedByCli = false;
+let scopeOmitDirNames = git.DEFAULT_WORKTREE_OMIT_DIR_NAMES;
+let scopeOmitDirCliOverride: string[] | null = null;
 let rgAvailableCache: boolean | null = null;
 
 const enc = new TextEncoder();
@@ -52,6 +68,10 @@ const sseClients = new Set<ReadableStreamDefaultController<Uint8Array>>();
 const fileCache = new Map<string, TimedCacheEntry<{ diffText: string }>>();
 const metaCache = new Map<string, TimedCacheEntry<{ body: string; sig: string }>>();
 const fileListCache = new Map<string, { generation: number; body: FileSearchListResponse }>();
+const lineIndexCache = new Map<string, { signature: string; index: LineOffsetIndex }>();
+const blobLineIndexCache = new Map<string, LineOffsetIndex>();
+const blobBytesCache = new Map<string, Uint8Array>();
+let blobLineCacheBytes = 0;
 
 function parseCli() {
   const rest: string[] = [];
@@ -79,7 +99,12 @@ Examples:
         console.error('--cwd requires a value');
         process.exit(1);
       }
-      cwd = git.repoRoot(next) || cwd;
+      try {
+        cwd = git.repoRoot(next) || realpathSync(next);
+      } catch {
+        console.error('--cwd must point to an existing directory');
+        process.exit(1);
+      }
     } else if (arg === '--port') {
       const next = process.argv[++i];
       const parsed = Number(next);
@@ -93,12 +118,25 @@ Examples:
     } else if (arg === '--allow-upload') {
       allowUpload = true;
       uploadAllowedByCli = true;
+    } else if (arg === '--scope-omit-dir') {
+      const next = process.argv[++i];
+      if (!next) {
+        console.error('--scope-omit-dir requires a directory name');
+        process.exit(1);
+      }
+      scopeOmitDirCliOverride = normalizeScopeOmitDirNames([...(scopeOmitDirCliOverride || []), next]);
     } else {
       rest.push(arg);
     }
   }
   if (rest.length) cliArgs = rest;
   if (!uploadAllowedByCli) allowUpload = loadProjectConfigUploadEnabled();
+  const configScopeOmitDirs = loadProjectConfigScopeOmitDirs();
+  if (scopeOmitDirCliOverride) {
+    scopeOmitDirNames = scopeOmitDirCliOverride;
+  } else if (configScopeOmitDirs) {
+    scopeOmitDirNames = configScopeOmitDirs;
+  }
 }
 
 function json(data: unknown, init: ResponseInit = {}) {
@@ -306,29 +344,68 @@ function safeRepoPath(path: string) {
   return path === '' || safePath(path);
 }
 
-function loadProjectConfigUploadEnabled(): boolean {
+function normalizeScopeOmitDirNames(names: unknown): string[] {
+  if (!Array.isArray(names)) return [];
+  return [...new Set(names
+    .filter((name): name is string => typeof name === 'string')
+    .map(name => name.trim())
+    .filter(name => name && name.length <= 64 && !name.includes('/') && !name.includes('\\') && !name.includes('\0') && name !== '.' && name !== '..' && name !== '.git'))]
+    .sort((a, b) => a.localeCompare(b));
+}
+
+function parseScopeOmitDirNamesQuery(value: string): string[] | null {
+  const names = value ? value.split(',') : [];
+  if (names.length > 100) return null;
+  for (const raw of names) {
+    const name = raw.trim();
+    if (!name || name.length > 64 || name.includes('/') || name.includes('\\') || name.includes('\0') || name === '.' || name === '..' || name === '.git') return null;
+  }
+  return normalizeScopeOmitDirNames(names);
+}
+
+function loadProjectConfig(): Record<string, unknown> | null {
   const full = join(cwd, '.code-viewer.json');
-  if (!existsSync(full)) return false;
+  if (!existsSync(full)) return null;
   let realCwd: string;
   let realConfig: string;
   try {
     realCwd = realpathSync(cwd);
     realConfig = realpathSync(full);
   } catch {
-    return false;
+    return null;
   }
-  if (dirname(realConfig) !== realCwd || basename(realConfig) !== '.code-viewer.json') return false;
+  if (dirname(realConfig) !== realCwd || basename(realConfig) !== '.code-viewer.json') return null;
   try {
-    const config = JSON.parse(readFileSync(realConfig, 'utf8')) as {
-      upload?: { enabled?: unknown };
-    };
-    if (!config.upload) return false;
-    return config.upload.enabled === true;
+    const parsed = JSON.parse(readFileSync(realConfig, 'utf8'));
+    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed) && 'version' in parsed && (parsed as { version?: unknown }).version !== 1) return null;
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+      ? parsed as Record<string, unknown>
+      : null;
   } catch {
-    return false;
+    return null;
   }
 }
 
+function loadProjectConfigUploadEnabled(): boolean {
+  const config = loadProjectConfig() as { upload?: { enabled?: unknown } } | null;
+  return config?.upload?.enabled === true;
+}
+
+function loadProjectConfigScopeOmitDirs(): string[] | null {
+  const config = loadProjectConfig() as { scope?: { omitDirs?: unknown } } | null;
+  if (!config?.scope || !Array.isArray(config.scope.omitDirs)) return null;
+  return normalizeScopeOmitDirNames(config.scope.omitDirs);
+}
+
+function scopeOmitDirNamesFromQuery(url: URL): string[] {
+  if (!url.searchParams.has('omit_dirs')) return scopeOmitDirNames;
+  return parseScopeOmitDirNamesQuery(url.searchParams.get('omit_dirs') || '') || scopeOmitDirNames;
+}
+
+function invalidScopeOmitDirNamesQuery(url: URL): boolean {
+  return url.searchParams.has('omit_dirs') && !parseScopeOmitDirNamesQuery(url.searchParams.get('omit_dirs') || '');
+}
+
 function isGitInternalPath(path: string): boolean {
   return path.split(/[\\/]+/).some(part => part.toLowerCase() === '.git');
 }
@@ -396,7 +473,8 @@ function handleTree(url: URL) {
   if ((target === 'worktree' || target === '') && isGitInternalPath(path)) return text('forbidden', 403);
   if (target !== 'worktree' && !git.verifyTreeRef(target, cwd)) return text('invalid target', 400);
   const recursive = url.searchParams.get('recursive') === '1';
-  const entries = git.listTree(target, path, cwd, { recursive }).entries;
+  if (invalidScopeOmitDirNamesQuery(url)) return text('invalid omit dirs', 400);
+  const entries = git.listTree(target, path, cwd, { recursive, omitDirNames: scopeOmitDirNamesFromQuery(url) }).entries;
   return json({
     ref: target,
     path,
@@ -408,20 +486,34 @@ function handleTree(url: URL) {
   } satisfies RepoTreeResponse);
 }
 
+function handleSettings() {
+  return json({
+    project: basename(cwd),
+    scope: {
+      omit_dirs_effective: scopeOmitDirNames,
+      omit_dirs_built_in: git.DEFAULT_WORKTREE_OMIT_DIR_NAMES,
+      max_entries: git.WORKTREE_RECURSIVE_ENTRY_LIMIT,
+    },
+  } satisfies SettingsResponse);
+}
+
 function handleFiles(url: URL) {
   const target = url.searchParams.get('ref') || url.searchParams.get('target') || 'worktree';
   if (target !== 'worktree' && !git.verifyTreeRef(target, cwd)) return text('invalid target', 400);
-  const key = target || 'worktree';
+  if (invalidScopeOmitDirNamesQuery(url)) return text('invalid omit dirs', 400);
+  const omitDirNames = scopeOmitDirNamesFromQuery(url);
+  const key = `${target || 'worktree'}\0${omitDirNames.join('\0')}`;
   const cached = fileListCache.get(key);
   if (cached && cached.generation === generation) return json(cached.body);
-  const entries = git.listTree(key, '', cwd, { recursive: true }).entries;
-  const body = buildFileSearchList(key, generation, entries);
+  const ref = target || 'worktree';
+  const entries = git.listTree(ref, '', cwd, { recursive: true, omitDirNames }).entries;
+  const body = buildFileSearchList(ref, generation, entries);
   fileListCache.set(key, { generation, body });
   return json(body);
 }
 
-function parseGrepPaths(url: URL): string[] {
-  return url.searchParams.getAll('path').filter(path => safePath(path) && !isGitInternalPath(path));
+function parseGrepPaths(url: URL, omitDirNames: string[]): string[] {
+  return url.searchParams.getAll('path').filter(path => safePath(path) && !isGitInternalPath(path) && !isSkippableSearchPath(path, omitDirNames));
 }
 
 function rgAvailable(): boolean {
@@ -431,12 +523,12 @@ function rgAvailable(): boolean {
   return rgAvailableCache;
 }
 
-function grepWorktreeFallback(query: string, max: number, paths: string[]): GrepMatch[] {
+function grepWorktreeFallback(query: string, max: number, paths: string[], omitDirNames: string[]): GrepMatch[] {
   const candidates = paths.length ? paths : git.worktreeFiles(cwd).map(entry => entry.path);
   const matches: GrepMatch[] = [];
   for (const path of candidates) {
     if (matches.length >= max) break;
-    if (!safePath(path) || isGitInternalPath(path) || isSkippableSearchPath(path)) continue;
+    if (!safePath(path) || isGitInternalPath(path) || isSkippableSearchPath(path, omitDirNames)) continue;
     const full = safeWorktreePath(path);
     if (!full) continue;
     let stat;
@@ -458,23 +550,23 @@ function grepWorktreeFallback(query: string, max: number, paths: string[]): Grep
   return matches;
 }
 
-function grepWorktree(query: string, max: number, paths: string[], regex: boolean): GrepResponse {
+function grepWorktree(query: string, max: number, paths: string[], regex: boolean, omitDirNames: string[]): GrepResponse {
   if (rgAvailable()) {
-    const safePaths = paths.filter(path => safePath(path) && !isGitInternalPath(path) && safeWorktreePath(path));
-    const args = buildRgArgs(query, max, safePaths, regex);
+    const safePaths = paths.filter(path => safePath(path) && !isGitInternalPath(path) && !isSkippableSearchPath(path, omitDirNames) && safeWorktreePath(path));
+    const args = buildRgArgs(query, max, safePaths, regex, omitDirNames);
     const proc = Bun.spawnSync(args, { cwd, stdout: 'pipe', stderr: 'pipe', stdin: 'ignore', timeout: 5000, killSignal: 'SIGKILL' });
     const stdout = new TextDecoder().decode(proc.stdout);
-    const matches = parseRgOutput(stdout, max)
-      .filter(match => safePath(match.path) && !isGitInternalPath(match.path) && !!safeWorktreePath(match.path));
+    const matches = parseRgOutput(stdout, max, omitDirNames)
+      .filter(match => safePath(match.path) && !isGitInternalPath(match.path) && !isSkippableSearchPath(match.path, omitDirNames) && !!safeWorktreePath(match.path));
     return { ref: 'worktree', engine: 'rg', truncated: matches.length >= max, matches };
   }
   if (regex) return { ref: 'worktree', engine: 'fallback', truncated: false, matches: [] };
-  const matches = grepWorktreeFallback(query, max, paths);
+  const matches = grepWorktreeFallback(query, max, paths, omitDirNames);
   return { ref: 'worktree', engine: 'fallback', truncated: matches.length >= max, matches };
 }
 
-function grepTreeRef(ref: string, query: string, max: number, paths: string[], regex: boolean): GrepResponse {
-  const safePaths = paths.filter(path => safePath(path) && !isGitInternalPath(path));
+function grepTreeRef(ref: string, query: string, max: number, paths: string[], regex: boolean, omitDirNames: string[]): GrepResponse {
+  const safePaths = paths.filter(path => safePath(path) && !isGitInternalPath(path) && !isSkippableSearchPath(path, omitDirNames));
   const args = [
     'git', '-c', 'core.quotepath=false', 'grep',
     '-n', '--column', '-i', regex ? '-E' : '-F', '--no-color',
@@ -484,7 +576,7 @@ function grepTreeRef(ref: string, query: string, max: number, paths: string[], r
   ];
   const proc = Bun.spawnSync(args, { cwd, stdout: 'pipe', stderr: 'pipe', stdin: 'ignore', timeout: 5000, killSignal: 'SIGKILL' });
   const stdout = new TextDecoder().decode(proc.stdout);
-  const matches = parseGitGrepOutput(stdout, ref, max).slice(0, max);
+  const matches = parseGitGrepOutput(stdout, ref, max, omitDirNames).slice(0, max);
   return { ref, engine: 'git', truncated: matches.length >= max, matches };
 }
 
@@ -492,12 +584,14 @@ function handleGrep(url: URL) {
   const query = url.searchParams.get('q') || '';
   const ref = url.searchParams.get('ref') || 'worktree';
   const max = normalizeGrepMax(url.searchParams.get('max'));
-  const paths = parseGrepPaths(url);
+  if (invalidScopeOmitDirNamesQuery(url)) return text('invalid omit dirs', 400);
+  const omitDirNames = scopeOmitDirNamesFromQuery(url);
+  const paths = parseGrepPaths(url, omitDirNames);
   const regex = url.searchParams.get('regex') === '1';
   if (!query.trim()) return json({ ref, engine: ref === 'worktree' ? 'fallback' : 'git', truncated: false, matches: [] } satisfies GrepResponse);
-  if (ref === 'worktree' || ref === '') return json(grepWorktree(query, max, paths, regex));
+  if (ref === 'worktree' || ref === '') return json(grepWorktree(query, max, paths, regex, omitDirNames));
   if (!git.verifyTreeRef(ref, cwd)) return text('invalid target', 400);
-  return json(grepTreeRef(ref, query, max, paths, regex));
+  return json(grepTreeRef(ref, query, max, paths, regex, omitDirNames));
 }
 
 function handleFileDiff(url: URL) {
@@ -571,7 +665,138 @@ function handleFileDiff(url: URL) {
   return json(body);
 }
 
-function handleFileRange(url: URL) {
+function worktreeLineIndexSignature(full: string): string | null {
+  try {
+    const stat = statSync(full) as unknown as { size: number; mtimeMs: number; ctimeMs: number; ino?: number };
+    return `size:${stat.size}|mtime:${stat.mtimeMs}|ctime:${stat.ctimeMs}|ino:${stat.ino || 0}`;
+  } catch {
+    return null;
+  }
+}
+
+async function getWorktreeLineIndex(full: string): Promise<LineOffsetIndex | null> {
+  const signature = worktreeLineIndexSignature(full);
+  if (!signature) return null;
+  const cached = lineIndexCache.get(full);
+  if (cached?.signature === signature) {
+    lineIndexCache.delete(full);
+    lineIndexCache.set(full, cached);
+    return cached.index;
+  }
+  const stat = statSync(full) as unknown as { size: number };
+  if (stat.size > LINE_INDEX_MAX_FILE_BYTES) return null;
+  const index = await buildLineOffsetIndexFromStream(Bun.file(full).stream(), stat.size);
+  lineIndexCache.delete(full);
+  lineIndexCache.set(full, { signature, index });
+  while (lineIndexCache.size > 32) {
+    const oldest = lineIndexCache.keys().next().value;
+    if (oldest === undefined) break;
+    lineIndexCache.delete(oldest);
+  }
+  return index;
+}
+
+function cachedBlobLineRange(cacheKey: string, start: number, end: number): LineRangeResult | null {
+  const bytes = blobBytesCache.get(cacheKey);
+  const index = blobLineIndexCache.get(cacheKey);
+  if (!bytes || !index) return null;
+  blobBytesCache.delete(cacheKey);
+  blobBytesCache.set(cacheKey, bytes);
+  blobLineIndexCache.delete(cacheKey);
+  blobLineIndexCache.set(cacheKey, index);
+  const range = lineByteRangeForIndex(index, start, end);
+  const textValue = range
+    ? new TextDecoder().decode(bytes.subarray(range.start, range.endExclusive))
+    : '';
+  return collectLineRangeFromIndexedText(textValue, index, start, end);
+}
+
+function setBlobLineCache(cacheKey: string, bytes: Uint8Array, index: LineOffsetIndex): void {
+  setBlobLineIndexCache(cacheKey, index);
+  const existing = blobBytesCache.get(cacheKey);
+  if (existing) blobLineCacheBytes -= existing.byteLength;
+  blobBytesCache.delete(cacheKey);
+  if (bytes.byteLength > BLOB_LINE_CACHE_MAX_BYTES) return;
+  blobBytesCache.set(cacheKey, bytes);
+  blobLineCacheBytes += bytes.byteLength;
+  while (blobBytesCache.size > 16 || blobLineCacheBytes > BLOB_LINE_CACHE_MAX_BYTES) {
+    const oldest = blobBytesCache.keys().next().value;
+    if (oldest === undefined) break;
+    const evicted = blobBytesCache.get(oldest);
+    if (evicted) blobLineCacheBytes -= evicted.byteLength;
+    blobBytesCache.delete(oldest);
+  }
+}
+
+function setBlobLineIndexCache(cacheKey: string, index: LineOffsetIndex): void {
+  blobLineIndexCache.delete(cacheKey);
+  blobLineIndexCache.set(cacheKey, index);
+  while (blobLineIndexCache.size > 128) {
+    const oldest = blobLineIndexCache.keys().next().value;
+    if (oldest === undefined) break;
+    blobLineIndexCache.delete(oldest);
+  }
+}
+
+async function collectGitBlobLineRangeWithIndex(cacheKey: string, oid: string, index: LineOffsetIndex, start: number, end: number): Promise<LineRangeResult | null> {
+  blobLineIndexCache.delete(cacheKey);
+  blobLineIndexCache.set(cacheKey, index);
+  const range = lineByteRangeForIndex(index, start, end);
+  if (!range) return collectLineRangeFromIndexedText('', index, start, end);
+  const shown = git.catFileBlobStream(oid, cwd);
+  const bytes = await collectByteRangeFromStream(shown.stream, range.start, range.endExclusive);
+  await shown.exited;
+  if (bytes.byteLength !== range.endExclusive - range.start) return null;
+  const textValue = new TextDecoder().decode(bytes);
+  return collectLineRangeFromIndexedText(textValue, index, start, end);
+}
+
+async function readGitBlobBytesWithIndex(oid: string, sizeHint: number): Promise<{ bytes: Uint8Array; index: LineOffsetIndex } | null> {
+  const shown = git.catFileBlobStream(oid, cwd);
+  const result = await collectBytesWithLineOffsetIndexFromStream(shown.stream, sizeHint);
+  const code = await shown.exited;
+  if (code !== 0) return null;
+  return result;
+}
+
+async function collectGitBlobLineRangeFromStream(oid: string, start: number, end: number): Promise<LineRangeResult | null> {
+  const shown = git.catFileBlobStream(oid, cwd);
+  const result = await collectLineRangeFromStream(shown.stream, start, end);
+  const code = await shown.exited;
+  if (code !== 0 && result.complete) return null;
+  return result;
+}
+
+async function collectIndexedGitBlobLineRange(path: string, oid: string, size: number, start: number, end: number): Promise<LineRangeResult | null> {
+  const cacheKey = `${oid}\0${path}`;
+  const cached = cachedBlobLineRange(cacheKey, start, end);
+  if (cached) return cached;
+  const cachedIndex = blobLineIndexCache.get(cacheKey);
+  if (cachedIndex) return collectGitBlobLineRangeWithIndex(cacheKey, oid, cachedIndex, start, end);
+  if (start < LINE_INDEX_MIN_START) {
+    return collectGitBlobLineRangeFromStream(oid, start, end);
+  }
+  if (size > LINE_INDEX_MAX_FILE_BYTES) return collectGitBlobLineRangeFromStream(oid, start, end);
+  const indexedBlob = await readGitBlobBytesWithIndex(oid, size);
+  if (!indexedBlob) return null;
+  setBlobLineCache(cacheKey, indexedBlob.bytes, indexedBlob.index);
+  return cachedBlobLineRange(cacheKey, start, end) || collectGitBlobLineRangeWithIndex(cacheKey, oid, indexedBlob.index, start, end);
+}
+
+async function collectIndexedWorktreeLineRange(full: string, start: number, end: number): Promise<LineRangeResult> {
+  if (start < LINE_INDEX_MIN_START && !lineIndexCache.has(full)) {
+    return collectLineRangeFromStream(Bun.file(full).stream(), start, end);
+  }
+  const index = await getWorktreeLineIndex(full);
+  if (!index) return collectLineRangeFromStream(Bun.file(full).stream(), start, end);
+  const range = lineByteRangeForIndex(index, start, end);
+  const textValue = range
+    ? await Bun.file(full).slice(range.start, range.endExclusive).text()
+    : '';
+  return collectLineRangeFromIndexedText(textValue, index, start, end);
+}
+
+async function handleFileRange(url: URL) {
   const path = url.searchParams.get('path') || '';
   if (!safePath(path)) return text('invalid path', 400);
   let start = Number(url.searchParams.get('start') || '1') || 1;
@@ -579,22 +804,23 @@ function handleFileRange(url: URL) {
   if (start < 1) start = 1;
   if (end < start) end = start;
   const ref = url.searchParams.get('ref') || 'worktree';
-  let content = '';
   if (ref === 'worktree' || ref === '') {
     const full = safeWorktreePath(path);
     if (!full) return text('no file', 404);
-    content = readFileSync(full, 'utf8');
+    const result = await collectIndexedWorktreeLineRange(full, start, end);
+    const body: FileRangeResponse = { path, ref, start, end, lines: result.lines, total: result.total, complete: result.complete, generation };
+    return json(body);
   } else {
     if (!git.verifyTreeRef(ref, cwd)) return text('invalid ref', 400);
-    const res = git.show(ref, path, cwd);
-    if (res.code !== 0) return text('not in ref', 404);
-    content = res.stdout;
+    const oid = git.objectId(ref, path, cwd);
+    if (oid.code !== 0 || !oid.oid) return text('not in ref', 404);
+    const size = git.objectByteSize(oid.oid, cwd);
+    if (size.code !== 0) return text('cannot read ref', 500);
+    const result = await collectIndexedGitBlobLineRange(path, oid.oid, size.size, start, end);
+    if (!result) return text('cannot read ref', 500);
+    const body: FileRangeResponse = { path, ref, start, end, lines: result.lines, total: result.total, complete: result.complete, generation };
+    return json(body);
   }
-  const lines: string[] = [];
-  const all = `${content}\n`.split('\n');
-  for (let i = start; i <= end && i <= all.length; i++) lines.push(all[i - 1]);
-  const body: FileRangeResponse = { path, ref, start, end, lines, total: Math.min(all.length, end + 1), generation };
-  return json(body);
 }
 
 function handleRawFile(req: Request, url: URL) {
@@ -616,10 +842,29 @@ function handleRawFile(req: Request, url: URL) {
     if (!full) return text('not found', 404);
     const size = rawFileSize(path, ref);
     if (size == null) return text('not found', 404);
+    const rangeResult = req.headers.get('range') ? parseHttpByteRange(req.headers.get('range'), size) : null;
+    if (rangeResult?.kind === 'unsatisfiable') {
+      return new Response(null, {
+        status: 416,
+        headers: { ...rawFileHeaders(path, size), 'Content-Range': `bytes */${size}`, 'Content-Length': '0' },
+      });
+    }
+    if (rangeResult?.kind === 'range') {
+      const range = rangeResult.range;
+      if (req.method === 'HEAD') {
+        return new Response(null, {
+          status: 206,
+          headers: rawFileHeaders(path, size, range),
+        });
+      }
+      const file = Bun.file(full).slice(range.start, range.end + 1);
+      return new Response(file, {
+        status: 206,
+        headers: rawFileHeaders(path, size, range),
+      });
+    }
     if (req.method === 'HEAD') return new Response(null, { headers: rawFileHeaders(path, size) });
-    const bytes = new Uint8Array(readFileSync(full));
-    body = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength) as ArrayBuffer;
-    return new Response(body, { headers: rawFileHeaders(path, size) });
+    return new Response(Bun.file(full).stream(), { headers: rawFileHeaders(path, size) });
   }
 }
 
@@ -638,7 +883,7 @@ function rawFileSize(path: string, ref: string): number | null {
   }
 }
 
-function rawFileHeaders(path: string, size: number | null = null): HeadersInit {
+function rawFileHeaders(path: string, size: number | null = null, range?: { start: number; end: number }): HeadersInit {
   const mime: Record<string, string> = {
     '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.gif': 'image/gif',
     '.webp': 'image/webp', '.svg': 'image/svg+xml', '.mp4': 'video/mp4', '.webm': 'video/webm',
@@ -651,8 +896,14 @@ function rawFileHeaders(path: string, size: number | null = null): HeadersInit {
     'Cache-Control': 'no-store',
     'X-Content-Type-Options': 'nosniff',
     'Content-Security-Policy': 'sandbox',
+    'Accept-Ranges': 'bytes',
   };
-  if (size != null) headers['Content-Length'] = String(size);
+  if (range && size != null) {
+    headers['Content-Length'] = String(range.end - range.start + 1);
+    headers['Content-Range'] = `bytes ${range.start}-${range.end}/${size}`;
+  } else if (size != null) {
+    headers['Content-Length'] = String(size);
+  }
   return headers;
 }
 
@@ -845,6 +1096,7 @@ const server = Bun.serve({
     const staticResponse = staticFile(url.pathname);
     if (staticResponse) return staticResponse;
     if (url.pathname === '/diff.json') return handleDiffJson(url);
+    if (url.pathname === '/_settings') return handleSettings();
     if (url.pathname === '/_tree') return handleTree(url);
     if (url.pathname === '/_files') return handleFiles(url);
     if (url.pathname === '/_grep') return handleGrep(url);