@youtyan/code-viewer 0.6.8 → 0.6.10

package/dist/code-viewer.js

@@ -96,7 +96,7 @@ var init_sqlite_driver = __esm(() => {
 
 // web-src/server/json-store.ts
 import { randomBytes } from "node:crypto";
-import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
 function isEnoent(err) {
   return err?.code === "ENOENT";
@@ -140,8 +140,15 @@ function createJsonFileStore(options) {
     }
     await mkdir(dirname(file), { recursive: true });
     const tmp = tmpPath(file);
-    await writeFile(tmp, content, "utf8");
-    await rename(tmp, file);
+    try {
+      await writeFile(tmp, content, "utf8");
+      await rename(tmp, file);
+    } catch (err) {
+      await unlink(tmp).catch(() => {
+        return;
+      });
+      throw err;
+    }
   }
   async function load(root) {
     const pendingWrite = queues.get(options.filePath(root));
@@ -841,6 +848,7 @@ function runSync(args, cwd, options = {}) {
     encoding: "buffer",
     stdio: ["ignore", "pipe", "pipe"],
     timeout: options.timeout,
+    maxBuffer: options.maxBuffer ?? 64 * 1024 * 1024,
     killSignal: "SIGKILL"
   });
   return {
@@ -849,20 +857,6 @@ function runSync(args, cwd, options = {}) {
     stderr: appendProcessError(new TextDecoder().decode(proc.stderr || new Uint8Array), proc.error)
   };
 }
-function runBytesSync(args, cwd, options = {}) {
-  const proc = spawnSync(args[0], args.slice(1), {
-    cwd,
-    encoding: "buffer",
-    stdio: ["ignore", "pipe", "pipe"],
-    timeout: options.timeout,
-    killSignal: "SIGKILL"
-  });
-  return {
-    code: proc.status ?? (proc.error ? 1 : 0),
-    stdout: new Uint8Array(proc.stdout || new Uint8Array),
-    stderr: appendProcessError(new TextDecoder().decode(proc.stderr || new Uint8Array), proc.error)
-  };
-}
 function spawnDetached(args) {
   const child = spawn(args[0], args.slice(1), {
     detached: true,
@@ -1035,10 +1029,13 @@ var init_runtime = () => {};
 
 // web-src/server/git.ts
 import {
+  closeSync,
   existsSync,
   lstatSync,
+  openSync,
   readdirSync,
   readFileSync,
+  readSync,
   statSync as statSync2
 } from "node:fs";
 import { join as join3 } from "node:path";
@@ -1061,11 +1058,6 @@ function run(args, cwd) {
     timeout: GIT_COMMAND_TIMEOUT_MS
   });
 }
-function runBytes(args, cwd) {
-  return runBytesSync(resolveGitArgs(args), cwd, {
-    timeout: GIT_COMMAND_TIMEOUT_MS
-  });
-}
 function resolveGitArgs(args) {
   if (args[0] !== "git")
     return args;
@@ -1135,9 +1127,6 @@ function statusPorcelainForPath(path, cwd) {
 function show(ref, path, cwd) {
   return run(["git", "show", `${ref}:${path}`], cwd);
 }
-function showBytes(ref, path, cwd) {
-  return runBytes(["git", "show", `${ref}:${path}`], cwd);
-}
 function catFileBlobStream(oid, cwd) {
   return spawnStream(resolveGitArgs(["git", "cat-file", "blob", oid]), cwd);
 }
@@ -1961,21 +1950,19 @@ function listTreeResult(ref, path, cwd, options = {}) {
 function untrackedMeta(cwd) {
   return untracked(cwd).flatMap((path) => {
     const full = join3(cwd, path);
-    let binary = false;
-    let lines = 0;
     let fileExists = false;
     try {
       fileExists = existsSync(full) && statSync2(full).isFile();
     } catch {
       fileExists = false;
     }
+    let scan;
     if (fileExists) {
-      const data = readFileSync(full);
-      const probe = data.subarray(0, 8192);
-      binary = probe.includes(0);
-      if (!binary)
-        lines = data.toString("utf8").split(`
-`).length - 1;
+      try {
+        scan = scanFileBinaryAndNewlines(full);
+      } catch {
+        return [];
+      }
     } else {
       return [];
     }
@@ -1983,14 +1970,40 @@ function untrackedMeta(cwd) {
       {
         path,
         status: "A",
-        additions: binary ? 0 : lines,
+        additions: scan.binary ? 0 : scan.newlines,
         deletions: 0,
-        binary,
+        binary: scan.binary,
         untracked: true
       }
     ];
   });
 }
+function scanFileBinaryAndNewlines(full) {
+  const fd = openSync(full, "r");
+  const buffer = Buffer.allocUnsafe(64 * 1024);
+  let newlines = 0;
+  let inspected = 0;
+  try {
+    while (true) {
+      const read = readSync(fd, buffer, 0, buffer.length, null);
+      if (read <= 0)
+        break;
+      const binaryProbeBytes = Math.min(read, Math.max(0, 8192 - inspected));
+      for (let i = 0;i < binaryProbeBytes; i++) {
+        if (buffer[i] === 0)
+          return { binary: true, newlines: 0 };
+      }
+      inspected += read;
+      for (let i = 0;i < read; i++) {
+        if (buffer[i] === 10)
+          newlines++;
+      }
+    }
+  } finally {
+    closeSync(fd);
+  }
+  return { binary: false, newlines };
+}
 function fileMetaResult(args, cwd, includeUntracked = false) {
   const ns = nameStatusResult(args, cwd);
   if (ns.error)
@@ -2052,13 +2065,17 @@ function untrackedFileDiff(extras, path, cwd) {
 function splitHunks(diffText) {
   if (!diffText)
     return { header: "", hunks: [] };
-  const first = diffText.startsWith("@@") ? 0 : diffText.indexOf(`
-@@`) + 1;
-  if (first <= 0)
+  const startsWithHunk = diffText.startsWith("@@");
+  const first = startsWithHunk ? 0 : diffText.indexOf(`
+@@`);
+  if (first < 0)
     return { header: diffText, hunks: [] };
-  const header = diffText.slice(0, first);
+  const hunkStart = startsWithHunk ? 0 : first + 1;
+  if (hunkStart >= diffText.length)
+    return { header: diffText, hunks: [] };
+  const header = diffText.slice(0, hunkStart);
   const hunks = [];
-  let cur = first;
+  let cur = hunkStart;
   while (cur < diffText.length) {
     const next = diffText.indexOf(`
 @@`, cur + 1);
@@ -7839,11 +7856,106 @@ function computeFuzzyMatch(query, path) {
     tier
   };
 }
-function rankFuzzyPaths(query, items) {
-  return items.map((item) => {
+function rankFuzzyPaths(query, items, limit) {
+  const bounded = Number.isInteger(limit) && limit !== undefined && limit > 0 ? Math.floor(limit) : 0;
+  const compare = (a, b) => b.tier - a.tier || b.score - a.score || a.item.path.localeCompare(b.item.path);
+  if (!bounded) {
+    return items.map((item) => {
+      const match = computeFuzzyMatch(query, item.path);
+      return match ? { item, score: match.score, ranges: match.ranges, tier: match.tier } : null;
+    }).filter((item) => item !== null).sort(compare).map(({ item, score, ranges }) => ({ item, score, ranges }));
+  }
+  const top = [];
+  for (const item of items) {
     const match = computeFuzzyMatch(query, item.path);
-    return match ? { item, score: match.score, ranges: match.ranges, tier: match.tier } : null;
-  }).filter((item) => item !== null).sort((a, b) => b.tier - a.tier || b.score - a.score || a.item.path.localeCompare(b.item.path)).map(({ item, score, ranges }) => ({ item, score, ranges }));
+    if (!match)
+      continue;
+    const ranked = {
+      item,
+      score: match.score,
+      ranges: match.ranges,
+      tier: match.tier
+    };
+    pushBoundedTop(top, ranked, bounded, compare);
+  }
+  return top.sort(compare).map(({ item, score, ranges }) => ({ item, score, ranges }));
+}
+function pushBoundedTop(heap, item, limit, compareBestFirst) {
+  const isWorse = (a, b) => compareBestFirst(a, b) > 0;
+  const siftUp = (index) => {
+    while (index > 0) {
+      const parent = Math.floor((index - 1) / 2);
+      if (!isWorse(heap[index], heap[parent]))
+        break;
+      [heap[index], heap[parent]] = [heap[parent], heap[index]];
+      index = parent;
+    }
+  };
+  const siftDown = (index) => {
+    while (true) {
+      const left = index * 2 + 1;
+      const right = left + 1;
+      let worst = index;
+      if (left < heap.length && isWorse(heap[left], heap[worst]))
+        worst = left;
+      if (right < heap.length && isWorse(heap[right], heap[worst]))
+        worst = right;
+      if (worst === index)
+        break;
+      [heap[index], heap[worst]] = [heap[worst], heap[index]];
+      index = worst;
+    }
+  };
+  if (heap.length < limit) {
+    heap.push(item);
+    siftUp(heap.length - 1);
+    return;
+  }
+  if (compareBestFirst(item, heap[0]) >= 0)
+    return;
+  heap[0] = item;
+  siftDown(0);
+}
+function rankGlobPathMatches(query, items, limit) {
+  const matchPath = createGlobPathMatcher(query);
+  if (!matchPath)
+    return [];
+  const bounded = Number.isInteger(limit) && limit !== undefined && limit > 0 ? Math.floor(limit) : 0;
+  const compare = (a, b) => b.score - a.score || a.item.path.localeCompare(b.item.path);
+  if (!bounded) {
+    return items.map((item) => {
+      const match = matchPath(item.path);
+      return match ? {
+        item,
+        score: match.score,
+        ranges: match.ranges,
+        mode: "glob"
+      } : null;
+    }).filter((item) => item !== null).sort(compare);
+  }
+  const top = [];
+  for (const item of items) {
+    const match = matchPath(item.path);
+    if (!match)
+      continue;
+    const ranked = {
+      item,
+      score: match.score,
+      ranges: match.ranges,
+      mode: "glob"
+    };
+    pushBoundedTop(top, ranked, bounded, compare);
+  }
+  return top.sort(compare);
+}
+function rankPathMatches(query, items, limit) {
+  if (isGlobPathQuery(query)) {
+    return rankGlobPathMatches(query, items, limit);
+  }
+  return rankFuzzyPaths(query, items, limit).map((item) => ({
+    ...item,
+    mode: "fuzzy"
+  }));
 }
 function isGlobPathQuery(query) {
   return /[*?]/.test(query.trim());
@@ -7887,49 +7999,37 @@ function globToRegExp(query) {
     return null;
   }
 }
-function globMatchPath(query, path) {
+function createGlobPathMatcher(query) {
   const regex = globToRegExp(query);
-  const baseStart = basenameStart(path);
-  const basename = path.slice(baseStart);
-  if (!regex || !regex.test(path) && (query.includes("/") || !regex.test(basename)))
+  if (!regex)
     return null;
   const literal = query.replace(/[*?[\]]+/g, " ").trim().split(/\s+/).filter(Boolean);
-  const ranges = [];
-  const lowerPath = path.toLowerCase();
-  for (const part of literal) {
-    const start = lowerPath.indexOf(part.toLowerCase());
-    if (start >= 0)
-      ranges.push({ start, end: start + part.length });
-  }
-  ranges.sort((a, b) => a.start - b.start || a.end - b.end);
-  const mergedRanges = [];
-  for (const range of ranges) {
-    const last = mergedRanges[mergedRanges.length - 1];
-    if (last && last.end >= range.start) {
-      last.end = Math.max(last.end, range.end);
-    } else {
-      mergedRanges.push({ ...range });
+  const suffix = query.replace(/^\*+/, "").toLowerCase();
+  return (path) => {
+    const baseStart = basenameStart(path);
+    const basename = path.slice(baseStart);
+    if (!regex.test(path) && (query.includes("/") || !regex.test(basename)))
+      return null;
+    const ranges = [];
+    const lowerPath = path.toLowerCase();
+    for (const part of literal) {
+      const start = lowerPath.indexOf(part.toLowerCase());
+      if (start >= 0)
+        ranges.push({ start, end: start + part.length });
+    }
+    ranges.sort((a, b) => a.start - b.start || a.end - b.end);
+    const mergedRanges = [];
+    for (const range of ranges) {
+      const last = mergedRanges[mergedRanges.length - 1];
+      if (last && last.end >= range.start) {
+        last.end = Math.max(last.end, range.end);
+      } else {
+        mergedRanges.push({ ...range });
+      }
     }
-  }
-  const score = 1000 - Math.min(path.length, 200) + (path.slice(baseStart).toLowerCase().endsWith(query.replace(/^\*+/, "").toLowerCase()) ? 50 : 0);
-  return { score, ranges: mergedRanges };
-}
-function rankPathMatches(query, items) {
-  if (isGlobPathQuery(query)) {
-    return items.map((item) => {
-      const match = globMatchPath(query, item.path);
-      return match ? {
-        item,
-        score: match.score,
-        ranges: match.ranges,
-        mode: "glob"
-      } : null;
-    }).filter((item) => item !== null).sort((a, b) => b.score - a.score || a.item.path.localeCompare(b.item.path));
-  }
-  return rankFuzzyPaths(query, items).map((item) => ({
-    ...item,
-    mode: "fuzzy"
-  }));
+    const score = 1000 - Math.min(path.length, 200) + (path.slice(baseStart).toLowerCase().endsWith(suffix) ? 50 : 0);
+    return { score, ranges: mergedRanges };
+  };
 }
 
 // web-src/server/search.ts
@@ -8020,9 +8120,11 @@ function parseRgOutput(stdout, max, omitDirNames = [], excludeNames = []) {
   const matches = [];
   for (const line of stdout.split(`
 `)) {
-    if (!line || matches.length >= max)
+    if (!line)
       continue;
-    const parsed = /^(.*):(\d+):(\d+):(.*)$/.exec(line);
+    if (matches.length >= max)
+      break;
+    const parsed = /^(.*?):(\d+):(\d+):(.*)$/.exec(line);
     if (!parsed)
       continue;
     const path = parsed[1];
@@ -9612,7 +9714,7 @@ var init_spawn_runner = () => {};
 // web-src/server/database/adapters/docker-utils.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
 function isDockerComposeServiceUnavailableError(err) {
-  return err instanceof DockerComposeServiceUnavailableError || err instanceof DockerCommandUnavailableError;
+  return err instanceof DockerComposeServiceUnavailableError || err instanceof DockerCommandUnavailableError || err instanceof SupabaseDbContainerUnavailableError;
 }
 function dockerCommand() {
   return commandForExternal("docker");
@@ -9629,10 +9731,15 @@ function throwIfCachedComposeDockerCommandUnavailable(cwd) {
   const failure = composePsCache.get(cwd)?.error || "";
   throwIfDockerCommandUnavailableResult({ code: 1, stderr: failure });
 }
-function parseComposePsOutput(stdout) {
+function parseDockerJsonLines(stdout) {
   const output = stdout.trim();
-  const containers = output.startsWith("[") ? JSON.parse(output) : output.split(`
+  if (!output)
+    return [];
+  return output.startsWith("[") ? JSON.parse(output) : output.split(`
 `).filter(Boolean).map((line) => JSON.parse(line));
+}
+function parseComposePsOutput(stdout) {
+  const containers = parseDockerJsonLines(stdout);
   const byService = new Map;
   for (const container of containers) {
     if (container.Service && container.Name && container.State === "running") {
@@ -9651,15 +9758,14 @@ function cacheComposePsFailure(cwd, result, now) {
     error: stderr
   });
 }
-function runComposePsAsync(cwd, signal) {
-  throwIfAborted(signal, "docker compose ps aborted");
+function runDockerCliAsync(args, opts) {
+  throwIfAborted(opts.signal, opts.abortMessage);
   if (spawnSyncImpl !== spawnSync2) {
-    const command = dockerCommand();
-    const proc = spawnSyncImpl(command, ["compose", "ps", "--format", "json", "--status", "running"], {
+    const proc = spawnSyncImpl(dockerCommand(), args, {
       encoding: "utf8",
       timeout: 5000,
       stdio: ["ignore", "pipe", "pipe"],
-      cwd
+      ...opts.cwd ? { cwd: opts.cwd } : {}
     });
     return Promise.resolve({
       stdout: String(proc.stdout || ""),
@@ -9670,16 +9776,24 @@ ${proc.error.message}` : ""}`,
   }
   return spawnTextAsync({
     command: dockerCommand(),
-    args: ["compose", "ps", "--format", "json", "--status", "running"],
-    cwd,
+    args,
+    ...opts.cwd ? { cwd: opts.cwd } : {},
     timeoutMs: 5000,
-    signal,
+    signal: opts.signal,
     killSignal: "SIGKILL",
-    abortMessage: "docker compose ps aborted",
-    timeoutMessage: "docker compose ps timed out",
+    abortMessage: opts.abortMessage,
+    timeoutMessage: opts.timeoutMessage,
     rejectOnError: false
   });
 }
+function runComposePsAsync(cwd, signal) {
+  return runDockerCliAsync(["compose", "ps", "--format", "json", "--status", "running"], {
+    cwd,
+    signal,
+    abortMessage: "docker compose ps aborted",
+    timeoutMessage: "docker compose ps timed out"
+  });
+}
 async function resolveRunningComposeContainerNameAsync(serviceName, cwd, signal) {
   throwIfAborted(signal, "docker compose ps aborted");
   const now = Date.now();
@@ -9777,7 +9891,128 @@ async function resolveRunningComposeContainerNameOrThrowAsync(serviceName, cwd,
   }
   return containerName;
 }
-var COMPOSE_CONTAINER_NAME_POSITIVE_TTL_MS = 30000, COMPOSE_CONTAINER_NAME_NEGATIVE_TTL_MS = 3000, COMPOSE_PS_FAILURE_TTL_MS = 15000, composePsCache, composePsPending, spawnSyncImpl, DockerComposeServiceUnavailableError, DockerCommandUnavailableError;
+function supabaseDbContainerName(projectId) {
+  return `supabase_db_${projectId}`;
+}
+function parseDockerPsOutput(stdout) {
+  return parseDockerJsonLines(stdout);
+}
+function runDockerPsAsync(args, signal) {
+  return runDockerCliAsync(args, {
+    signal,
+    abortMessage: "docker ps aborted",
+    timeoutMessage: "docker ps timed out"
+  });
+}
+async function resolveRunningSupabaseDbContainerAsync(projectId, signal) {
+  throwIfAborted(signal, "docker ps aborted");
+  const containerName = supabaseDbContainerName(projectId);
+  const now = Date.now();
+  const cached = supabaseContainerCache.get(projectId);
+  if (cached) {
+    if (cached.containerName && cached.positiveExpiresAt > now) {
+      return cached.containerName;
+    }
+    if (!cached.containerName && cached.negativeExpiresAt > now) {
+      return null;
+    }
+  }
+  let pending = supabaseContainerPending.get(projectId);
+  if (!pending) {
+    const controller = new AbortController;
+    pending = {
+      controller,
+      refs: 0,
+      done: false,
+      promise: (async () => {
+        const startedAt = Date.now();
+        const cacheMiss = (negativeTtlMs) => {
+          supabaseContainerCache.set(projectId, {
+            containerName: null,
+            positiveExpiresAt: startedAt,
+            negativeExpiresAt: startedAt + negativeTtlMs
+          });
+          return null;
+        };
+        let proc;
+        try {
+          proc = await runDockerPsAsync([
+            "ps",
+            "--filter",
+            `name=^/${containerName}$`,
+            "--filter",
+            `label=com.supabase.cli.project=${projectId}`,
+            "--filter",
+            "status=running",
+            "--format",
+            "json"
+          ], controller.signal);
+        } catch (err) {
+          if (isAbortLikeError(err, controller.signal))
+            throw err;
+          return cacheMiss(SUPABASE_CONTAINER_NEGATIVE_TTL_MS);
+        }
+        if (proc.code !== 0) {
+          throwIfDockerCommandUnavailableResult(proc);
+          return cacheMiss(SUPABASE_CONTAINER_NEGATIVE_TTL_MS);
+        }
+        let containers;
+        try {
+          containers = parseDockerPsOutput(proc.stdout);
+        } catch {
+          return cacheMiss(SUPABASE_CONTAINER_NEGATIVE_TTL_MS);
+        }
+        const match = containers.some((c) => (c.Names || "").replace(/^\//, "") === containerName);
+        if (!match)
+          return cacheMiss(SUPABASE_CONTAINER_NEGATIVE_TTL_MS);
+        supabaseContainerCache.set(projectId, {
+          containerName,
+          positiveExpiresAt: startedAt + SUPABASE_CONTAINER_POSITIVE_TTL_MS,
+          negativeExpiresAt: startedAt
+        });
+        return containerName;
+      })().finally(() => {
+        if (supabaseContainerPending.get(projectId) === pending) {
+          supabaseContainerPending.delete(projectId);
+        }
+        if (pending)
+          pending.done = true;
+      })
+    };
+    supabaseContainerPending.set(projectId, pending);
+  }
+  pending.refs++;
+  let released = false;
+  const release = () => {
+    if (released)
+      return;
+    released = true;
+    pending.refs--;
+    if (pending.refs <= 0 && !pending.done) {
+      pending.controller.abort();
+    }
+  };
+  signal?.addEventListener("abort", release, { once: true });
+  if (signal?.aborted) {
+    signal.removeEventListener("abort", release);
+    release();
+    throwIfAborted(signal, "docker ps aborted");
+  }
+  try {
+    return await pending.promise;
+  } finally {
+    signal?.removeEventListener("abort", release);
+    release();
+  }
+}
+async function resolveRunningSupabaseDbContainerOrThrowAsync(projectId, signal) {
+  const containerName = await resolveRunningSupabaseDbContainerAsync(projectId, signal);
+  if (!containerName) {
+    throw new SupabaseDbContainerUnavailableError(projectId);
+  }
+  return containerName;
+}
+var COMPOSE_CONTAINER_NAME_POSITIVE_TTL_MS = 30000, COMPOSE_CONTAINER_NAME_NEGATIVE_TTL_MS = 3000, COMPOSE_PS_FAILURE_TTL_MS = 15000, composePsCache, composePsPending, spawnSyncImpl, DockerComposeServiceUnavailableError, DockerCommandUnavailableError, SupabaseDbContainerUnavailableError, SUPABASE_CONTAINER_POSITIVE_TTL_MS = 15000, SUPABASE_CONTAINER_NEGATIVE_TTL_MS = 3000, supabaseContainerCache, supabaseContainerPending;
 var init_docker_utils = __esm(() => {
   init_command_resolver();
   init_spawn_runner();
@@ -9802,6 +10037,17 @@ var init_docker_utils = __esm(() => {
       this.name = "DockerCommandUnavailableError";
     }
   };
+  SupabaseDbContainerUnavailableError = class SupabaseDbContainerUnavailableError extends Error {
+    projectId;
+    status = 503;
+    constructor(projectId) {
+      super(`Supabase local DB container for project "${projectId}" is not running. Start it with: supabase start`);
+      this.name = "SupabaseDbContainerUnavailableError";
+      this.projectId = projectId;
+    }
+  };
+  supabaseContainerCache = new Map;
+  supabaseContainerPending = new Map;
 });
 
 // web-src/server/database/adapters/sql-capture.ts
@@ -10674,13 +10920,9 @@ async function listDockerSchemasAsync(serviceName, kind, env, cwd, overrideDatab
     throwIfCachedComposeDockerCommandUnavailable(cwd);
     return setDockerSchemasCache(cacheKey, [], DOCKER_DATABASES_NEGATIVE_TTL_MS, now);
   }
-  const config = {
-    kind,
-    containerName,
-    user,
-    password,
-    database
-  };
+  return fetchPostgresSchemasViaContainerAsync({ kind, containerName, user, password, database }, cacheKey, now, signal);
+}
+async function fetchPostgresSchemasViaContainerAsync(config, cacheKey, now, signal) {
   try {
     const sql = `SELECT schema_name FROM information_schema.schemata WHERE schema_name NOT IN ('pg_catalog', 'information_schema') AND schema_name NOT LIKE 'pg_toast%' AND schema_name NOT LIKE 'pg_temp_%' AND schema_name NOT LIKE 'pg_toast_temp_%' AND has_schema_privilege(schema_name, 'USAGE') ORDER BY CASE WHEN schema_name = 'public' THEN 0 ELSE 1 END, schema_name`;
     const result = await execInContainerAsync(config, sql, 1e4, signal);
@@ -10699,6 +10941,38 @@ async function listDockerSchemasAsync(serviceName, kind, env, cwd, overrideDatab
     return setDockerSchemasCache(cacheKey, ["public"], DOCKER_DATABASES_NEGATIVE_TTL_MS, now);
   }
 }
+function supabaseSchemasCacheKey(projectId) {
+  return `supabase\x00${projectId}`;
+}
+async function listSupabaseSchemasAsync(projectId, signal) {
+  const cacheKey = supabaseSchemasCacheKey(projectId);
+  const now = Date.now();
+  const cached = dockerSchemasCache.get(cacheKey);
+  if (cached && cached.expiresAt > now)
+    return [...cached.value];
+  const containerName = await resolveRunningSupabaseDbContainerAsync(projectId, signal);
+  if (!containerName) {
+    return setDockerSchemasCache(cacheKey, [], DOCKER_DATABASES_NEGATIVE_TTL_MS, now);
+  }
+  return fetchPostgresSchemasViaContainerAsync({
+    kind: "postgresql",
+    containerName,
+    user: SUPABASE_LOCAL_DB_USER,
+    password: SUPABASE_LOCAL_DB_PASSWORD,
+    database: SUPABASE_LOCAL_DB_NAME
+  }, cacheKey, now, signal);
+}
+async function openSupabaseDockerAdapterAsync(projectId, schema, signal) {
+  const containerName = await resolveRunningSupabaseDbContainerOrThrowAsync(projectId, signal);
+  return createDockerAdapter({
+    kind: "postgresql",
+    containerName,
+    user: SUPABASE_LOCAL_DB_USER,
+    password: SUPABASE_LOCAL_DB_PASSWORD,
+    database: SUPABASE_LOCAL_DB_NAME,
+    ...schema ? { schema } : {}
+  });
+}
 async function openDockerAdapterAsync(serviceName, kind, env, cwd, overrideDatabase, schema, signal) {
   const containerName = await resolveRunningComposeContainerNameOrThrowAsync(serviceName, cwd, signal);
   const user = env.POSTGRES_USER || env.MYSQL_USER || env.MARIADB_USER || (kind === "postgresql" ? "postgres" : "root");
@@ -10713,7 +10987,7 @@ async function openDockerAdapterAsync(serviceName, kind, env, cwd, overrideDatab
     ...kind === "postgresql" && schema ? { schema } : {}
   });
 }
-var COLUMNS_TTL_MS = 30000, ROWCOUNT_TTL_MS = 15000, DOCKER_DATABASES_POSITIVE_TTL_MS = 15000, DOCKER_DATABASES_NEGATIVE_TTL_MS = 3000, dockerDatabasesCache, dockerSchemasCache, spawnSyncImpl2, PG_RECORD_SEPARATOR = "\x1E", MYSQL_SPATIAL_TYPES;
+var COLUMNS_TTL_MS = 30000, ROWCOUNT_TTL_MS = 15000, DOCKER_DATABASES_POSITIVE_TTL_MS = 15000, DOCKER_DATABASES_NEGATIVE_TTL_MS = 3000, dockerDatabasesCache, dockerSchemasCache, spawnSyncImpl2, PG_RECORD_SEPARATOR = "\x1E", MYSQL_SPATIAL_TYPES, SUPABASE_LOCAL_DB_USER = "postgres", SUPABASE_LOCAL_DB_PASSWORD = "postgres", SUPABASE_LOCAL_DB_NAME = "postgres";
 var init_docker = __esm(() => {
   init_mutate();
   init_sql_snapshot();
@@ -13136,10 +13410,10 @@ function hasControlCharacter(value) {
 
 // web-src/server/database/discovery.ts
 import {
-  closeSync,
+  closeSync as closeSync2,
   existsSync as existsSync6,
-  openSync,
-  readSync,
+  openSync as openSync2,
+  readSync as readSync2,
   realpathSync as realpathSync4,
   statSync as statSync4
 } from "node:fs";
@@ -13151,11 +13425,11 @@ function isSqliteFile(fullPath) {
     if (!stat2.isFile() || stat2.size < 16)
       return false;
     const buf = Buffer.alloc(16);
-    const fd = openSync(fullPath, "r");
+    const fd = openSync2(fullPath, "r");
     try {
-      readSync(fd, buf, 0, 16, 0);
+      readSync2(fd, buf, 0, 16, 0);
     } finally {
-      closeSync(fd);
+      closeSync2(fd);
     }
     return buf.toString("utf8", 0, 16) === SQLITE_MAGIC;
   } catch {
@@ -13599,6 +13873,39 @@ async function pathExistsAsync(path) {
     return false;
   }
 }
+async function walkForMarkerFileAsync(dir, depth, omitSet, hasCapacity, visitDir, signal) {
+  if (signal?.aborted || !hasCapacity())
+    return;
+  if (depth > MAX_SCAN_DEPTH)
+    return;
+  await visitDir(dir);
+  if (signal?.aborted || !hasCapacity())
+    return;
+  let entries;
+  try {
+    entries = await readdir(dir);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (signal?.aborted || !hasCapacity())
+      return;
+    if (omitSet.has(entry.toLowerCase()))
+      continue;
+    const full = join8(dir, entry);
+    let entryStat;
+    try {
+      entryStat = await lstat(full);
+    } catch {
+      continue;
+    }
+    if (entryStat.isSymbolicLink())
+      continue;
+    if (entryStat.isDirectory()) {
+      await walkForMarkerFileAsync(full, depth + 1, omitSet, hasCapacity, visitDir, signal);
+    }
+  }
+}
 async function discoverDockerDatabasesAsync(cwd, omitDirNames = [], signal) {
   const cacheKey = dockerDiscoveryCacheKey(cwd, omitDirNames);
   const now = Date.now();
@@ -13610,13 +13917,7 @@ async function discoverDockerDatabasesAsync(cwd, omitDirNames = [], signal) {
   const omitSet = new Set(omitDirNames.map((d) => d.toLowerCase()));
   omitSet.add(".git");
   omitSet.add("node_modules");
-  async function scan(dir, depth) {
-    if (signal?.aborted)
-      return;
-    if (results.length >= MAX_DOCKER_SERVICES)
-      return;
-    if (depth > MAX_SCAN_DEPTH)
-      return;
+  await walkForMarkerFileAsync(cwd, 0, omitSet, () => results.length < MAX_DOCKER_SERVICES, async (dir) => {
     for (const filename of COMPOSE_FILENAMES) {
       const filepath = join8(dir, filename);
       if (await pathExistsAsync(filepath)) {
@@ -13624,37 +13925,7 @@ async function discoverDockerDatabasesAsync(cwd, omitDirNames = [], signal) {
         break;
       }
     }
-    if (signal?.aborted)
-      return;
-    if (results.length >= MAX_DOCKER_SERVICES)
-      return;
-    let entries;
-    try {
-      entries = await readdir(dir);
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      if (signal?.aborted)
-        return;
-      if (results.length >= MAX_DOCKER_SERVICES)
-        return;
-      if (omitSet.has(entry.toLowerCase()))
-        continue;
-      const full = join8(dir, entry);
-      let entryStat;
-      try {
-        entryStat = await lstat(full);
-      } catch {
-        continue;
-      }
-      if (entryStat.isSymbolicLink())
-        continue;
-      if (entryStat.isDirectory())
-        await scan(full, depth + 1);
-    }
-  }
-  await scan(cwd, 0);
+  }, signal);
   if (signal?.aborted)
     return cloneDockerDiscoveryResult(results);
   if (results.length >= MAX_DOCKER_SERVICES) {
@@ -13749,7 +14020,120 @@ function isSafeDockerDatabaseName(value) {
     return false;
   return /^[A-Za-z0-9_$.-]+$/.test(value);
 }
-var SQLITE_EXTENSIONS, SQLITE_MAGIC = "SQLite format 3\x00", MAX_SCAN_DEPTH = 3, MAX_ENTRIES = 50, DOCKER_DISCOVERY_TTL_MS = 5000, SQLITE_DISCOVERY_TTL_MS = 5000, sqliteDiscoveryCache, COMPOSE_FILENAMES, MAX_DOCKER_SERVICES = 30, dockerDiscoveryCache;
+function cloneSupabaseDiscoveryResult(result) {
+  return result.map((entry) => ({ ...entry }));
+}
+function parseSupabaseConfigToml(content) {
+  let section = null;
+  let projectId = null;
+  let dbPort = null;
+  for (const rawLine of content.split(`
+`)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#"))
+      continue;
+    const sectionMatch = line.match(/^\[([^\]]+)\]$/);
+    if (sectionMatch) {
+      section = sectionMatch[1];
+      continue;
+    }
+    const kvMatch = line.match(/^([A-Za-z_][A-Za-z0-9_.-]*)\s*=\s*(.+)$/);
+    if (!kvMatch)
+      continue;
+    const value = stripScalarSyntax(kvMatch[2]);
+    if (section === null && kvMatch[1] === "project_id") {
+      projectId = value;
+    } else if (section === "db" && kvMatch[1] === "port") {
+      dbPort = value;
+    }
+  }
+  if (!projectId || !isSafeDockerServiceName(projectId))
+    return null;
+  return {
+    projectId,
+    dbPort: dbPort && /^\d+$/.test(dbPort) ? dbPort : DEFAULT_SUPABASE_DB_PORT
+  };
+}
+async function discoverSupabaseCliProjectsAsync(cwd, omitDirNames = [], signal) {
+  const cacheKey = discoveryCacheKey(cwd, omitDirNames);
+  const now = Date.now();
+  const cached = supabaseDiscoveryCache.get(cacheKey);
+  if (cached && cached.expiresAt > now) {
+    return cloneSupabaseDiscoveryResult(cached.result);
+  }
+  const omitSet = new Set(omitDirNames.map((d) => d.toLowerCase()));
+  omitSet.add(".git");
+  omitSet.add("node_modules");
+  const results = [];
+  await walkForMarkerFileAsync(cwd, 0, omitSet, () => results.length < MAX_SUPABASE_PROJECTS, async (dir) => {
+    const configPath = join8(dir, "supabase", "config.toml");
+    if (!await pathExistsAsync(configPath))
+      return;
+    try {
+      const content = await readFile2(configPath, "utf-8");
+      const parsed = parseSupabaseConfigToml(content);
+      if (!parsed)
+        return;
+      const relDir = relative3(cwd, dir);
+      const isRoot = relDir === "" || relDir === ".";
+      const relDirSlash = relDir.replace(/\\/g, "/");
+      const id = isRoot ? `supabase:${parsed.projectId}` : `supabase:${parsed.projectId}@${encodeURIComponent(relDirSlash)}`;
+      const labelPath = isRoot ? "" : ` — ${relDirSlash}`;
+      results.push({
+        id,
+        path: isRoot ? "supabase/config.toml" : `${relDirSlash}/supabase/config.toml`,
+        name: `${parsed.projectId} (Supabase CLI, postgres@127.0.0.1:${parsed.dbPort}/postgres${labelPath})`,
+        sizeBytes: 0,
+        kind: "postgresql",
+        projectId: parsed.projectId,
+        relDirSlash,
+        dbPort: parsed.dbPort
+      });
+    } catch {}
+  }, signal);
+  if (signal?.aborted)
+    return cloneSupabaseDiscoveryResult(results);
+  supabaseDiscoveryCache.set(cacheKey, {
+    expiresAt: now + SUPABASE_DISCOVERY_TTL_MS,
+    result: cloneSupabaseDiscoveryResult(results)
+  });
+  return cloneSupabaseDiscoveryResult(results);
+}
+function parseSupabaseDbId(dbId) {
+  if (!dbId.startsWith("supabase:"))
+    return null;
+  const rest = dbId.slice("supabase:".length);
+  if (!rest)
+    return null;
+  const atIdx = rest.indexOf("@");
+  let projectId;
+  let relDir = "";
+  if (atIdx >= 0) {
+    if (rest.indexOf("@", atIdx + 1) >= 0)
+      return null;
+    projectId = rest.slice(0, atIdx);
+    try {
+      relDir = decodeURIComponent(rest.slice(atIdx + 1));
+    } catch {
+      return null;
+    }
+    if (!isSafeDockerRelDir(relDir))
+      return null;
+  } else {
+    projectId = rest;
+  }
+  if (!isSafeDockerServiceName(projectId))
+    return null;
+  return { projectId, relDir };
+}
+async function findSupabaseCliProjectByDbIdAsync(cwd, dbId, omitDirNames, signal) {
+  const parsed = parseSupabaseDbId(dbId);
+  if (!parsed)
+    return null;
+  const projects = await discoverSupabaseCliProjectsAsync(cwd, omitDirNames, signal);
+  return projects.find((p) => p.projectId === parsed.projectId && p.relDirSlash === parsed.relDir) || null;
+}
+var SQLITE_EXTENSIONS, SQLITE_MAGIC = "SQLite format 3\x00", MAX_SCAN_DEPTH = 3, MAX_ENTRIES = 50, DOCKER_DISCOVERY_TTL_MS = 5000, SQLITE_DISCOVERY_TTL_MS = 5000, sqliteDiscoveryCache, COMPOSE_FILENAMES, MAX_DOCKER_SERVICES = 30, dockerDiscoveryCache, MAX_SUPABASE_PROJECTS = 30, SUPABASE_DISCOVERY_TTL_MS = 5000, DEFAULT_SUPABASE_DB_PORT = "54322", supabaseDiscoveryCache;
 var init_discovery = __esm(() => {
   SQLITE_EXTENSIONS = new Set([".db", ".sqlite", ".sqlite3", ".s3db"]);
   sqliteDiscoveryCache = new Map;
@@ -13760,6 +14144,7 @@ var init_discovery = __esm(() => {
     "compose.yaml"
   ];
   dockerDiscoveryCache = new Map;
+  supabaseDiscoveryCache = new Map;
 });
 
 // web-src/core/id.ts
@@ -16754,8 +17139,9 @@ function sanitizeCssSize(v) {
   return isValidCssSize(v) ? v : undefined;
 }
 function isToolInternalDbId(dbId) {
-  if (!dbId || dbId.startsWith("docker:"))
+  if (!dbId || dbId.startsWith("docker:") || dbId.startsWith("supabase:")) {
     return false;
+  }
   return dbId.split(/[\\/]+/).some((part) => part.toLowerCase() === ".code-viewer");
 }
 function sanitizeRedis(v) {
@@ -16934,6 +17320,11 @@ async function getAdapter(r, _cwd, signal) {
     const cacheKey = r.schema ? `${r.dbId}\x00schema=${r.schema}` : r.dbId;
     return dockerAdapterCache.getOrOpenAsync(cacheKey, () => openDockerAdapterAsync(docker.serviceName, docker.kind, docker.env, docker.composeDir, docker.database, r.schema, signal));
   }
+  if (r.supabase) {
+    const projectId = r.supabase.projectId;
+    const cacheKey = r.schema ? `${r.dbId}\x00schema=${r.schema}` : r.dbId;
+    return dockerAdapterCache.getOrOpenAsync(cacheKey, () => openSupabaseDockerAdapterAsync(projectId, r.schema, signal));
+  }
   return getConnection(r.resolved);
 }
 function sanitizeFilename(name) {
@@ -16960,9 +17351,35 @@ async function resolvePostgresSchema(info, requestedSchema, signal) {
     return "public";
   return schemas[0] || "public";
 }
+async function resolveSupabaseSchema(info, requestedSchema, signal) {
+  if (requestedSchema)
+    return requestedSchema;
+  const schemas = await listSupabaseSchemasAsync(info.projectId, signal);
+  if (schemas.includes("public"))
+    return "public";
+  return schemas[0] || "public";
+}
 async function resolveDb(cwd, dbParam, omitDirNames, schemaParam, signal) {
   if (!dbParam)
     return textError("missing db parameter", 400);
+  if (dbParam.startsWith("supabase:")) {
+    const parsed = parseSupabaseDbId(dbParam);
+    if (!parsed)
+      return textError("invalid supabase db id", 400);
+    const info = await findSupabaseCliProjectByDbIdAsync(cwd, dbParam, omitDirNames, signal);
+    if (!info)
+      return textError("supabase project not found", 404);
+    const requestedSchema = normalizeSchemaParam(schemaParam);
+    if (requestedSchema instanceof Response)
+      return requestedSchema;
+    const schema = await resolveSupabaseSchema(info, requestedSchema, signal);
+    return {
+      resolved: dbParam,
+      dbId: dbParam,
+      supabase: info,
+      ...schema ? { schema } : {}
+    };
+  }
   if (dbParam.startsWith("docker:")) {
     const parsed = parseDockerDbId(dbParam);
     if (!parsed)
@@ -17049,17 +17466,22 @@ async function expandDockerServicesForFiles(dockerServices, listDockerDatabases,
 }
 async function createDbFilesResponse(cwd, omitDirNames, signal, deps = DEFAULT_DB_FILE_DISCOVERY_DEPS) {
   ensureInit();
-  const [sqliteSettled, dockerSettled] = await Promise.allSettled([
+  const [sqliteSettled, dockerSettled, supabaseSettled] = await Promise.allSettled([
     deps.discoverSqliteFiles(cwd, omitDirNames, signal),
-    deps.discoverDockerDatabases(cwd, omitDirNames, signal)
+    deps.discoverDockerDatabases(cwd, omitDirNames, signal),
+    deps.discoverSupabaseCliProjects(cwd, omitDirNames, signal)
   ]);
   if (sqliteSettled.status === "rejected") {
     throw sqliteSettled.reason;
   }
+  if (supabaseSettled.status === "rejected") {
+    throw supabaseSettled.reason;
+  }
   if (dockerSettled.status === "rejected" && isAbortLikeError(dockerSettled.reason, signal)) {
     throw dockerSettled.reason;
   }
   const sqliteFiles = sqliteSettled.value;
+  const supabaseProjects = supabaseSettled.value;
   const dockerServices = dockerSettled.status === "fulfilled" ? dockerSettled.value : [];
   const dockerErrors = [];
   if (dockerSettled.status === "rejected") {
@@ -17077,7 +17499,8 @@ async function createDbFilesResponse(cwd, omitDirNames, signal, deps = DEFAULT_D
         sizeBytes: f.sizeBytes,
         kind: "sqlite"
       })),
-      ...dockerEntries.map(toFileInfo)
+      ...dockerEntries.map(toFileInfo),
+      ...supabaseProjects.map(toFileInfo)
     ],
     ...dockerTruncated ? { truncated: true } : {},
     ...dockerErrors.length > 0 ? { dockerError: dockerErrors.join("; ") } : {}
@@ -17091,6 +17514,17 @@ async function createDbSchemasResponse(cwd, dbParam, schemaParam, omitDirNames,
   const r = await resolveDb(cwd, dbParam, omitDirNames, schemaParam, signal);
   if (r instanceof Response)
     return { ok: false, response: r };
+  if (r.supabase) {
+    const projectId = r.supabase.projectId;
+    const { result: schemas2, executedSql: executedSql2 } = await captureSql(() => listSupabaseSchemasAsync(projectId, signal));
+    const body2 = {
+      dbId: r.dbId,
+      schemas: schemas2.map((name) => ({ name })),
+      selectedSchema: r.schema,
+      executedSql: executedSql2
+    };
+    return { ok: true, value: body2 };
+  }
   if (!r.docker || r.docker.kind !== "postgresql") {
     const body2 = { dbId: r.dbId, schemas: [] };
     return { ok: true, value: body2 };
@@ -18132,7 +18566,7 @@ async function handleClose(cwd, req, omitDirNames) {
   const r = await resolveDb(cwd, body.db, omitDirNames, undefined, req.signal);
   if (r instanceof Response)
     return r;
-  if (r.docker) {
+  if (r.docker || r.supabase) {
     dockerAdapterCache.close(r.dbId);
     dockerAdapterCache.closePrefix(`${r.dbId}\x00`);
   } else {
@@ -18347,7 +18781,8 @@ var init_handle = __esm(() => {
   DEFAULT_DB_FILE_DISCOVERY_DEPS = {
     discoverSqliteFiles: discoverSqliteFilesAsync,
     discoverDockerDatabases: discoverDockerDatabasesAsync,
-    listDockerDatabases: listDockerDatabasesAsync
+    listDockerDatabases: listDockerDatabasesAsync,
+    discoverSupabaseCliProjects: discoverSupabaseCliProjectsAsync
   };
   searchJobs = new Map;
   snapshotJobs = new Map;
@@ -19085,6 +19520,9 @@ async function checkDiscovery(cwd, scopeOmitDirNames, signal) {
   };
 }
 async function defaultDatastoreProbe(file, cwd, signal) {
+  if (file.id.startsWith("supabase:")) {
+    return probeSupabaseSource(file, cwd, signal);
+  }
   switch (file.kind) {
     case "sqlite":
       return probeSqliteSource(file, cwd, signal);
@@ -19135,6 +19573,23 @@ async function probeDockerSqlSource(file, cwd, signal) {
     } catch {}
   }
 }
+async function probeSupabaseSource(file, cwd, signal) {
+  const parsed = parseSupabaseDbId(file.id);
+  if (!parsed)
+    throw new Error("invalid supabase db id");
+  const info = await findSupabaseCliProjectByDbIdAsync(cwd, file.id, undefined, signal);
+  if (!info)
+    throw new Error("supabase project not found");
+  const adapter = await openSupabaseDockerAdapterAsync(info.projectId, undefined, signal);
+  try {
+    signal.throwIfAborted();
+    await adapter.getTablesAsync(signal);
+  } finally {
+    try {
+      adapter.close();
+    } catch {}
+  }
+}
 async function probeRedisSource(file, cwd, signal) {
   const info = await findDockerServiceByDbIdAsync(cwd, file.id, "redis", undefined, signal);
   if (!info)
@@ -20290,6 +20745,21 @@ function rgAvailable(cwd) {
   rgAvailableCache = proc.code === 0;
   return rgAvailableCache;
 }
+async function rgAvailableAsync(cwd) {
+  if (rgAvailableCache !== null)
+    return rgAvailableCache;
+  const proc = await spawnTextAsync({
+    command: commandForExternal("rg"),
+    args: ["--version"],
+    cwd,
+    timeoutMs: 5000,
+    abortMessage: "rg version aborted",
+    timeoutMessage: "rg version timed out after 5000ms",
+    rejectOnError: false
+  });
+  rgAvailableCache = proc.code === 0;
+  return rgAvailableCache;
+}
 function isExcludedScopePath(path, excludeNames) {
   return path.split(/[\\/]+/).some((part) => excludeNames.some((name) => part.toLowerCase() === name.toLowerCase()));
 }
@@ -20391,6 +20861,44 @@ function grepWorktree(env, req) {
     matches
   };
 }
+async function grepWorktreeAsync(env, req) {
+  const paths = filterCallerPaths(env, req.paths);
+  if (await rgAvailableAsync(env.cwd)) {
+    const safePaths = paths.filter((path) => safeWorktreePath(env, path));
+    const args = buildRgArgs(req.query, req.max, safePaths, req.regex, env.omitDirNames, env.excludeNames);
+    const proc = await spawnTextAsync({
+      command: commandForExternal("rg"),
+      args: args.slice(1),
+      cwd: env.cwd,
+      timeoutMs: 5000,
+      abortMessage: "grep aborted",
+      timeoutMessage: "grep timed out after 5000ms",
+      rejectOnError: false
+    });
+    const matches2 = parseRgOutput(proc.stdout, req.max, env.omitDirNames, env.excludeNames).filter((match) => isSafePath(match.path) && !isGitInternalPath(match.path) && !isSkippableSearchPath(match.path, env.omitDirNames, env.excludeNames) && !!safeWorktreePath(env, match.path));
+    return {
+      ref: "worktree",
+      engine: "rg",
+      truncated: matches2.length >= req.max,
+      matches: matches2
+    };
+  }
+  if (req.regex) {
+    return {
+      ref: "worktree",
+      engine: "fallback",
+      truncated: false,
+      matches: []
+    };
+  }
+  const matches = grepWorktreeFallback(env, req.query, req.max, paths);
+  return {
+    ref: "worktree",
+    engine: "fallback",
+    truncated: matches.length >= req.max,
+    matches
+  };
+}
 function grepTreeRef(env, req) {
   const safePaths = filterCallerPaths(env, req.paths);
   const args = [
@@ -20419,6 +20927,40 @@ function grepTreeRef(env, req) {
     matches
   };
 }
+async function grepTreeRefAsync(env, req) {
+  const safePaths = filterCallerPaths(env, req.paths);
+  const args = [
+    "-c",
+    "core.quotepath=false",
+    "grep",
+    "-n",
+    "--column",
+    "-i",
+    req.regex ? "-E" : "-F",
+    "--no-color",
+    "-e",
+    req.query,
+    req.ref,
+    "--",
+    ...safePaths
+  ];
+  const proc = await spawnTextAsync({
+    command: commandForExternal("git"),
+    args,
+    cwd: env.cwd,
+    timeoutMs: 5000,
+    abortMessage: "git grep aborted",
+    timeoutMessage: "git grep timed out after 5000ms",
+    rejectOnError: false
+  });
+  const matches = parseGitGrepOutput(proc.stdout, req.ref, req.max, env.omitDirNames, env.excludeNames).slice(0, req.max);
+  return {
+    ref: req.ref,
+    engine: "git",
+    truncated: matches.length >= req.max,
+    matches
+  };
+}
 function grepRepo(env, req) {
   const isWorktree = req.ref === "worktree" || req.ref === "";
   if (!isWorktree) {
@@ -20447,6 +20989,34 @@ function grepRepo(env, req) {
   }
   return { ok: true, value: grepTreeRef(env, req) };
 }
+async function grepRepoAsync(env, req) {
+  const isWorktree = req.ref === "worktree" || req.ref === "";
+  if (!isWorktree) {
+    const refCheck = verifyTreeRefResult(req.ref, env.cwd);
+    if (refCheck.ok !== true) {
+      return {
+        ok: false,
+        error: refCheck.error,
+        status: refCheck.status
+      };
+    }
+  }
+  if (!req.query.trim()) {
+    return {
+      ok: true,
+      value: {
+        ref: req.ref,
+        engine: req.ref === "worktree" ? "fallback" : "git",
+        truncated: false,
+        matches: []
+      }
+    };
+  }
+  if (isWorktree) {
+    return { ok: true, value: await grepWorktreeAsync(env, req) };
+  }
+  return { ok: true, value: await grepTreeRefAsync(env, req) };
+}
 function listRepoFiles(env, ref, generation) {
   if (ref !== "worktree" && ref !== "") {
     const refCheck = verifyTreeRefResult(ref, env.cwd);
@@ -20476,6 +21046,7 @@ function listRepoFiles(env, ref, generation) {
 var rgAvailableCache = null;
 var init_search_service = __esm(() => {
   init_command_resolver();
+  init_spawn_runner();
   init_git();
   init_runtime();
   init_search();
@@ -21734,7 +22305,7 @@ function validateMcpOptionalDbId(raw) {
   const parsed = validateMcpDbId(raw);
   if (parsed.ok !== true)
     return parsed;
-  if (!parsed.value.startsWith("docker:")) {
+  if (!parsed.value.startsWith("docker:") && !parsed.value.startsWith("supabase:")) {
     const pathError = validateMcpPath(parsed.value);
     if (pathError)
       return { ok: false, error: "invalid database path" };
@@ -22038,12 +22609,12 @@ var init_state_route = __esm(() => {
 // web-src/server/preview.ts
 var exports_preview = {};
 import {
-  closeSync as closeSync2,
+  closeSync as closeSync3,
   constants as constants3,
   existsSync as existsSync8,
   lstatSync as lstatSync5,
   mkdirSync as mkdirSync4,
-  openSync as openSync2,
+  openSync as openSync3,
   readFileSync as readFileSync9,
   realpathSync as realpathSync6,
   renameSync,
@@ -22723,9 +23294,15 @@ function handleFiles2(url) {
   if (result.ok !== true)
     return text(result.error, result.status ?? 400);
   fileListCache.set(key, { generation, body: result.value });
+  while (fileListCache.size > MAX_TIMED_CACHE_ENTRIES) {
+    const oldest = fileListCache.keys().next().value;
+    if (oldest === undefined)
+      break;
+    fileListCache.delete(oldest);
+  }
   return json2(result.value);
 }
-function handleGrep(url) {
+async function handleGrep(url) {
   const query = url.searchParams.get("q") || "";
   const ref = url.searchParams.get("ref") || "worktree";
   const max = normalizeGrepMax(url.searchParams.get("max"));
@@ -22737,7 +23314,7 @@ function handleGrep(url) {
   const excludeNames = scopeExcludeNamesFromQuery(url);
   const paths = url.searchParams.getAll("path");
   const regex = url.searchParams.get("regex") === "1";
-  const result = grepRepo(currentSearchEnv(omitDirNames, excludeNames), {
+  const result = await grepRepoAsync(currentSearchEnv(omitDirNames, excludeNames), {
     query,
     ref,
     paths,
@@ -22916,16 +23493,16 @@ function handleFileDiff(url) {
     if (isUntracked) {
       const res = untrackedFileDiff(extras, path, cwd);
       diffText = res.stdout || "";
-      if (res.code !== 0) {
-        errText = res.stderr;
-        errStatus = res.status;
+      if (res.code !== 0 && !(res.code === 1 && diffText)) {
+        errText = res.stderr || "diff failed";
+        errStatus = res.status ?? 500;
       }
     } else {
       const res = fileDiffText([...extras, ...args], oldPath ? [oldPath, path] : path, cwd);
       diffText = res.stdout || "";
       if (res.code !== 0) {
-        errText = res.stderr;
-        errStatus = res.status;
+        errText = res.stderr || "diff failed";
+        errStatus = res.status ?? 500;
       }
     }
     if (!errText)
@@ -23101,6 +23678,7 @@ async function handleFileRange(url) {
     const full = safeWorktreePath2(path);
     if (!full)
       return text("no file", 404);
+    const responseGeneration = generation;
     const result = await collectIndexedWorktreeLineRange(full, start, end);
     const body = {
       path,
@@ -23110,10 +23688,11 @@ async function handleFileRange(url) {
       lines: result.lines,
       total: result.total,
       complete: result.complete,
-      generation
+      generation: responseGeneration
     };
     return json2(body);
   } else {
+    const responseGeneration = generation;
     const refCheck = verifyTreeRefResult(ref, cwd);
     if (refCheck.ok !== true)
       return text(refCheck.error, refCheck.status ?? 400);
@@ -23134,34 +23713,64 @@ async function handleFileRange(url) {
       lines: result.lines,
       total: result.total,
       complete: result.complete,
-      generation
+      generation: responseGeneration
     };
     return json2(body);
   }
 }
-function handleRawFile(req, url) {
+async function handleRawFile(req, url) {
   const path = url.searchParams.get("path") || "";
   if (!safePath(path))
     return text("forbidden", 403);
   const ref = url.searchParams.get("ref") || "worktree";
-  let body;
   if (ref !== "worktree" && ref !== "") {
     const refCheck = verifyTreeRefResult(ref, cwd);
     if (refCheck.ok !== true)
       return text(refCheck.error, refCheck.status ?? 400);
-    const size = rawFileSize(path, ref);
-    if (size == null)
+    const oid = objectId(ref, path, cwd);
+    if (oid.code !== 0 || !oid.oid)
       return text("not in ref", 404);
+    const sizeResult = objectByteSize(oid.oid, cwd);
+    if (sizeResult.code !== 0)
+      return text("cannot read ref", 500);
+    const size = sizeResult.size;
     const metadata = gitFileMetadata(ref, path, size);
+    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, metadata }),
+          "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, metadata })
+        });
+      }
+      const shown2 = catFileBlobStream(oid.oid, cwd);
+      const bytes = await collectByteRangeFromStream(shown2.stream, range.start, range.end + 1);
+      const code = await shown2.exited;
+      if (code !== 0)
+        return text("not in ref", 404);
+      const body = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+      return new Response(body, {
+        status: 206,
+        headers: rawFileHeaders(path, { size, range, metadata })
+      });
+    }
     if (req.method === "HEAD")
       return new Response(null, {
         headers: rawFileHeaders(path, { size, metadata })
       });
-    const res = showBytes(ref, path, cwd);
-    if (res.code !== 0)
-      return text("not in ref", 404);
-    body = res.stdout.buffer.slice(res.stdout.byteOffset, res.stdout.byteOffset + res.stdout.byteLength);
-    return new Response(body, {
+    const shown = catFileBlobStream(oid.oid, cwd);
+    return new Response(shown.stream, {
       headers: rawFileHeaders(path, { size, metadata })
     });
   } else {
@@ -23311,11 +23920,11 @@ async function handleUploadFiles(req) {
   const written = [];
   try {
     for (const upload of uploads) {
-      const fd = openSync2(upload.target, uploadOpenFlags(), 420);
+      const fd = openSync3(upload.target, uploadOpenFlags(), 420);
       try {
         writeFileSync2(fd, new Uint8Array(await upload.file.arrayBuffer()));
       } finally {
-        closeSync2(fd);
+        closeSync3(fd);
       }
       written.push(upload.target);
     }
@@ -24313,7 +24922,7 @@ var init_preview = __esm(async () => {
       if (url.pathname === "/_files")
         return handleFiles2(url);
       if (url.pathname === "/_grep")
-        return handleGrep(url);
+        return await handleGrep(url);
       if (url.pathname === "/_commits")
         return handleRefCommits(url);
       if (url.pathname === "/_log")
@@ -24325,7 +24934,7 @@ var init_preview = __esm(async () => {
       if (url.pathname === "/file_range")
         return handleFileRange(url);
       if (url.pathname === "/_file")
-        return handleRawFile(req, url);
+        return await handleRawFile(req, url);
       if (url.pathname === "/_open_path")
         return handleOpenPath(req);
       if (url.pathname === "/_trash_path")