@youtyan/code-viewer 0.2.2 → 0.2.4

package/dist/code-viewer.js

@@ -2853,6 +2853,306 @@ var init_routes = __esm(() => {
   APP_ENTRY_PATHS = ["/", "/index.html"];
 });
 
+// web-src/views/media-embed.ts
+function isImage(p) {
+  return IMAGE_RE.test(p);
+}
+function isVideo(p) {
+  return VIDEO_RE.test(p);
+}
+function isAudio(p) {
+  return AUDIO_RE.test(p);
+}
+var IMAGE_RE, VIDEO_RE, AUDIO_RE;
+var init_media_embed = __esm(() => {
+  IMAGE_RE = /\.(png|jpe?g|gif|webp|svg|avif|bmp|ico)(\?.*)?$/i;
+  VIDEO_RE = /\.(mp4|webm|mov)$/i;
+  AUDIO_RE = /\.(mp3|wav|ogg|flac|m4a|aac|opus)$/i;
+});
+
+// web-src/core/source-meta.ts
+function sourceFileName(path) {
+  return (path.split("/").pop() || path).toLowerCase();
+}
+function sourceFileExtension(name) {
+  const index = name.lastIndexOf(".");
+  return index >= 0 ? name.slice(index + 1) : "";
+}
+function isDockerfileName(name) {
+  return /^dockerfile(?:[.-].+)?$/i.test(name);
+}
+function isMakefileName(name) {
+  return /^makefile(?:[.-].+)?$/i.test(name);
+}
+function isDotenvName(name) {
+  return /^(?:\.?env|.*\.env)(?:[.-].+)?$/i.test(name);
+}
+function sourceDisplayKind(path) {
+  if (isVideo(path))
+    return "video";
+  if (isAudio(path))
+    return "audio";
+  if (isImage(path))
+    return "image";
+  if (/\.pdf$/i.test(path))
+    return "pdf";
+  const name = sourceFileName(path);
+  const ext = sourceFileExtension(name);
+  if (TEXT_SOURCE_EXTENSIONS.has(ext))
+    return "text";
+  if (TEXT_SOURCE_FILENAMES.has(name))
+    return "text";
+  if (isDotenvName(name))
+    return "text";
+  if (isDockerfileName(name) || isMakefileName(name))
+    return "text";
+  return "unsupported";
+}
+var EXT_TO_LANG, TEXT_SOURCE_EXTENSIONS, TEXT_SOURCE_FILENAMES;
+var init_source_meta = __esm(() => {
+  init_media_embed();
+  EXT_TO_LANG = {
+    js: "javascript",
+    mjs: "javascript",
+    cjs: "javascript",
+    ts: "typescript",
+    tsx: "typescript",
+    jsx: "javascript",
+    py: "python",
+    rb: "ruby",
+    go: "go",
+    rs: "rust",
+    java: "java",
+    kt: "kotlin",
+    swift: "swift",
+    c: "c",
+    h: "c",
+    cc: "cpp",
+    cpp: "cpp",
+    hpp: "cpp",
+    cs: "csharp",
+    php: "php",
+    lua: "lua",
+    sh: "bash",
+    bash: "bash",
+    zsh: "bash",
+    fish: "bash",
+    sql: "sql",
+    json: "json",
+    yaml: "yaml",
+    yml: "yaml",
+    toml: "toml",
+    tf: "terraform",
+    tfvars: "terraform",
+    hcl: "terraform",
+    xml: "xml",
+    html: "xml",
+    vue: "xml",
+    css: "css",
+    scss: "scss",
+    md: "markdown",
+    dockerfile: "dockerfile",
+    proto: "protobuf",
+    gradle: "gradle",
+    properties: "properties",
+    patch: "diff",
+    diff: "diff",
+    nix: "nix",
+    cue: "cue",
+    rego: "rego",
+    bicep: "bicep",
+    bazel: "starlark",
+    bzl: "starlark",
+    cmake: "cmake",
+    groovy: "groovy",
+    dart: "dart",
+    scala: "scala",
+    clj: "clojure",
+    cljs: "clojure",
+    cljc: "clojure",
+    edn: "clojure",
+    ex: "elixir",
+    exs: "elixir",
+    erl: "erlang",
+    hrl: "erlang",
+    hs: "haskell",
+    lhs: "haskell",
+    ml: "ocaml",
+    mli: "ocaml",
+    jl: "julia",
+    r: "r",
+    rmd: "r",
+    pl: "perl",
+    pm: "perl",
+    tcl: "tcl",
+    vim: "vim",
+    f: "fortran",
+    f90: "fortran",
+    m: "objective-c",
+    mm: "objective-cpp",
+    tex: "tex",
+    bib: "bibtex",
+    rst: "rst"
+  };
+  TEXT_SOURCE_EXTENSIONS = new Set([
+    ...Object.keys(EXT_TO_LANG),
+    "txt",
+    "md",
+    "markdown",
+    "mdown",
+    "mkdn",
+    "mdx",
+    "json",
+    "jsonc",
+    "csv",
+    "tsv",
+    "yaml",
+    "yml",
+    "toml",
+    "hcl",
+    "tf",
+    "tfvars",
+    "tfstate",
+    "xml",
+    "html",
+    "htm",
+    "css",
+    "scss",
+    "sass",
+    "less",
+    "js",
+    "jsx",
+    "mjs",
+    "cjs",
+    "ts",
+    "tsx",
+    "mts",
+    "cts",
+    "vue",
+    "svelte",
+    "astro",
+    "rs",
+    "go",
+    "py",
+    "rb",
+    "php",
+    "java",
+    "kt",
+    "kts",
+    "c",
+    "cc",
+    "cpp",
+    "cxx",
+    "h",
+    "hpp",
+    "cs",
+    "swift",
+    "sh",
+    "bash",
+    "zsh",
+    "fish",
+    "ps1",
+    "sql",
+    "graphql",
+    "graphqls",
+    "gql",
+    "ini",
+    "conf",
+    "env",
+    "properties",
+    "gitignore",
+    "dockerignore",
+    "editorconfig",
+    "lock",
+    "log",
+    "patch",
+    "diff",
+    "sum",
+    "mk",
+    "proto",
+    "thrift",
+    "prisma",
+    "gradle",
+    "cmake",
+    "nix",
+    "cue",
+    "rego",
+    "bicep",
+    "bazel",
+    "bzl",
+    "dart",
+    "scala",
+    "clj",
+    "cljs",
+    "cljc",
+    "edn",
+    "ex",
+    "exs",
+    "erl",
+    "hrl",
+    "hs",
+    "lhs",
+    "ml",
+    "mli",
+    "jl",
+    "r",
+    "rmd",
+    "pl",
+    "pm",
+    "tcl",
+    "vim",
+    "groovy",
+    "f",
+    "f90",
+    "m",
+    "mm",
+    "pas",
+    "tex",
+    "bib",
+    "rst",
+    "adoc",
+    "org",
+    "ipynb",
+    "ejs",
+    "hbs",
+    "mustache",
+    "liquid",
+    "pug"
+  ]);
+  TEXT_SOURCE_FILENAMES = new Set([
+    "readme",
+    "license",
+    "copying",
+    "authors",
+    "contributors",
+    "notice",
+    "changelog",
+    "todo",
+    "manifest",
+    "version",
+    "codeowners",
+    "go.mod",
+    "build.bazel",
+    "workspace.bazel",
+    "module.bazel",
+    "gemfile",
+    "rakefile",
+    "procfile",
+    "brewfile",
+    "gnumakefile",
+    "bsdmakefile",
+    ".gitattributes",
+    ".gitmodules",
+    ".npmrc",
+    ".nvmrc",
+    ".yarnrc",
+    ".prettierrc",
+    ".eslintrc",
+    ".babelrc",
+    ".stylelintrc"
+  ]);
+});
+
 // web-src/server/cache.ts
 import { lstatSync as lstatSync2 } from "node:fs";
 import { join as join6 } from "node:path";
@@ -3584,6 +3884,9 @@ import { spawn as spawn2, spawnSync as spawnSync3 } from "node:child_process";
 function dockerDatabasesCacheKey(serviceName, kind, cwd) {
   return `${serviceName}\x00${kind}\x00${cwd}`;
 }
+function dockerSchemasCacheKey(serviceName, kind, cwd, database) {
+  return `${serviceName}\x00${kind}\x00${cwd}\x00${database}`;
+}
 function setDockerDatabasesCache(key, value, ttlMs, now = Date.now()) {
   const cachedValue = [...value];
   dockerDatabasesCache.set(key, {
@@ -3592,6 +3895,14 @@ function setDockerDatabasesCache(key, value, ttlMs, now = Date.now()) {
   });
   return [...cachedValue];
 }
+function setDockerSchemasCache(key, value, ttlMs, now = Date.now()) {
+  const cachedValue = [...value];
+  dockerSchemasCache.set(key, {
+    value: cachedValue,
+    expiresAt: now + ttlMs
+  });
+  return [...cachedValue];
+}
 function fallbackDockerDatabases(defaultDb) {
   return defaultDb ? [defaultDb] : [];
 }
@@ -3909,10 +4220,26 @@ function createDockerAdapter(config) {
   }
   const columnCache = new Map;
   const tableMetaCache = createTableMetaCache();
+  function currentPostgresSchema() {
+    return config.schema || "public";
+  }
+  function postgresSchemaLiteral() {
+    return escapeSqlString(currentPostgresSchema());
+  }
+  function tableIdentifier(table) {
+    if (config.kind === "postgresql") {
+      return `${sanitizeIdentifier(currentPostgresSchema(), config.kind)}.${sanitizeIdentifier(table, config.kind)}`;
+    }
+    return sanitizeIdentifier(table, config.kind);
+  }
+  function postgresRegclassLiteral(table) {
+    return escapeSqlString(`${sanitizeIdentifier(currentPostgresSchema(), "postgresql")}.${sanitizeIdentifier(table, "postgresql")}`);
+  }
   function buildColumnsSql(table) {
     const tableLiteral = table.replace(/'/g, "''");
     if (config.kind === "postgresql") {
-      return `SELECT c.column_name, c.data_type, c.is_nullable, c.column_default, CASE WHEN pk.column_name IS NULL THEN 'NO' ELSE 'YES' END FROM information_schema.columns c LEFT JOIN (SELECT kcu.column_name FROM information_schema.table_constraints tc JOIN information_schema.key_column_usage kcu ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema AND tc.table_name = kcu.table_name WHERE tc.table_schema = 'public' AND tc.table_name = '${tableLiteral}' AND tc.constraint_type = 'PRIMARY KEY') pk ON pk.column_name = c.column_name WHERE c.table_schema = 'public' AND c.table_name = '${tableLiteral}' ORDER BY c.ordinal_position`;
+      const schemaLiteral = postgresSchemaLiteral();
+      return `SELECT c.column_name, c.data_type, c.is_nullable, c.column_default, CASE WHEN pk.column_name IS NULL THEN 'NO' ELSE 'YES' END FROM information_schema.columns c LEFT JOIN (SELECT kcu.column_name FROM information_schema.table_constraints tc JOIN information_schema.key_column_usage kcu ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema AND tc.table_name = kcu.table_name WHERE tc.table_schema = ${schemaLiteral} AND tc.table_name = '${tableLiteral}' AND tc.constraint_type = 'PRIMARY KEY') pk ON pk.column_name = c.column_name WHERE c.table_schema = ${schemaLiteral} AND c.table_name = '${tableLiteral}' ORDER BY c.ordinal_position`;
     }
     return `SELECT column_name, column_type, is_nullable, column_default, column_key FROM information_schema.columns WHERE table_schema = DATABASE() AND table_name = '${tableLiteral}' ORDER BY ordinal_position`;
   }
@@ -3950,37 +4277,8 @@ function createDockerAdapter(config) {
     return countResult.rows.length > 0 ? Number(countResult.rows[0][0]) || 0 : 0;
   }
   function fetchColumnsUncached(table) {
-    let sql;
-    if (config.kind === "postgresql") {
-      sql = `SELECT column_name, data_type, is_nullable, column_default FROM information_schema.columns WHERE table_schema = 'public' AND table_name = '${table.replace(/'/g, "''")}' ORDER BY ordinal_position`;
-    } else {
-      sql = `SELECT column_name, column_type, is_nullable, column_default, column_key FROM information_schema.columns WHERE table_schema = DATABASE() AND table_name = '${table.replace(/'/g, "''")}' ORDER BY ordinal_position`;
-    }
-    const result = exec(sql);
-    if (config.kind === "postgresql") {
-      const pkSql = `SELECT a.attname FROM pg_index i JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = ANY(i.indkey) WHERE i.indrelid = '${table.replace(/'/g, "''")}'::regclass AND i.indisprimary`;
-      let pkCols;
-      try {
-        const pkResult = exec(pkSql);
-        pkCols = new Set(pkResult.rows.map((r) => r[0]));
-      } catch {
-        pkCols = new Set;
-      }
-      return result.rows.map((row) => ({
-        name: row[0],
-        type: row[1],
-        nullable: row[2] === "YES",
-        primaryKey: pkCols.has(row[0]),
-        defaultValue: row[3] === "" ? null : row[3]
-      }));
-    }
-    return result.rows.map((row) => ({
-      name: row[0],
-      type: row[1],
-      nullable: row[2] === "YES",
-      primaryKey: row[4] === "PRI",
-      defaultValue: row[3] === "NULL" ? null : row[3]
-    }));
+    const result = exec(buildColumnsSql(table));
+    return columnsFromInfoRows(result.rows);
   }
   const adapter = {
     kind: config.kind,
@@ -3989,7 +4287,7 @@ function createDockerAdapter(config) {
     getTables() {
       let sql;
       if (config.kind === "postgresql") {
-        sql = `SELECT table_name, table_type FROM information_schema.tables WHERE table_schema = 'public' ORDER BY table_name`;
+        sql = `SELECT table_name, table_type FROM information_schema.tables WHERE table_schema = ${postgresSchemaLiteral()} ORDER BY table_name`;
       } else {
         sql = `SELECT table_name, table_type FROM information_schema.tables WHERE table_schema = DATABASE() ORDER BY table_name`;
       }
@@ -4011,7 +4309,7 @@ function createDockerAdapter(config) {
     getIndexes() {
       let sql;
       if (config.kind === "postgresql") {
-        sql = `SELECT indexname, tablename FROM pg_indexes WHERE schemaname = 'public' AND indexname NOT LIKE 'pg_%' ORDER BY indexname`;
+        sql = `SELECT indexname, tablename FROM pg_indexes WHERE schemaname = ${postgresSchemaLiteral()} AND indexname NOT LIKE 'pg_%' ORDER BY indexname`;
       } else {
         sql = `SELECT DISTINCT index_name, table_name, non_unique FROM information_schema.statistics WHERE table_schema = DATABASE() ORDER BY index_name`;
       }
@@ -4034,18 +4332,25 @@ function createDockerAdapter(config) {
     getForeignKeys() {
       let sql;
       if (config.kind === "postgresql") {
-        sql = `SELECT tc.table_name, kcu.column_name, ccu.table_name, ccu.column_name FROM information_schema.table_constraints tc JOIN information_schema.key_column_usage kcu ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema JOIN information_schema.constraint_column_usage ccu ON ccu.constraint_name = tc.constraint_name AND ccu.table_schema = tc.table_schema WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_schema = 'public'`;
+        sql = `SELECT tc.table_schema, tc.table_name, kcu.column_name, ccu.table_schema, ccu.table_name, ccu.column_name FROM information_schema.table_constraints tc JOIN information_schema.key_column_usage kcu ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema JOIN information_schema.constraint_column_usage ccu ON ccu.constraint_name = tc.constraint_name AND ccu.table_schema = tc.table_schema WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_schema = ${postgresSchemaLiteral()}`;
       } else {
         sql = `SELECT table_name, column_name, referenced_table_name, referenced_column_name FROM information_schema.key_column_usage WHERE table_schema = DATABASE() AND referenced_table_name IS NOT NULL`;
       }
       try {
         const result = exec(sql);
-        return result.rows.map((row) => ({
+        return result.rows.map((row) => config.kind === "postgresql" ? {
+          fromSchema: row[0],
+          fromTable: row[1],
+          fromColumn: row[2],
+          toSchema: row[3],
+          toTable: row[4],
+          toColumn: row[5]
+        } : {
           fromTable: row[0],
           fromColumn: row[1],
           toTable: row[2],
           toColumn: row[3]
-        }));
+        });
       } catch {
         return [];
       }
@@ -4063,7 +4368,7 @@ function createDockerAdapter(config) {
       let sql;
       if (config.kind === "postgresql") {
         const inList = uncached.map((t) => `'${t.replace(/'/g, "''")}'`).join(",");
-        sql = `SELECT table_name, column_name, data_type, is_nullable, column_default FROM information_schema.columns WHERE table_schema = 'public' AND table_name IN (${inList}) ORDER BY table_name, ordinal_position`;
+        sql = `SELECT table_name, column_name, data_type, is_nullable, column_default FROM information_schema.columns WHERE table_schema = ${postgresSchemaLiteral()} AND table_name IN (${inList}) ORDER BY table_name, ordinal_position`;
       } else {
         const inList = uncached.map((t) => `'${t.replace(/'/g, "''")}'`).join(",");
         sql = `SELECT table_name, column_name, column_type, is_nullable, column_default, column_key FROM information_schema.columns WHERE table_schema = DATABASE() AND table_name IN (${inList}) ORDER BY table_name, ordinal_position`;
@@ -4081,7 +4386,7 @@ function createDockerAdapter(config) {
         if (config.kind === "postgresql") {
           try {
             const pkInList = uncached.map((t) => `'${t.replace(/'/g, "''")}'`).join(",");
-            const pkResult = exec(`SELECT c.relname, a.attname FROM pg_index i JOIN pg_class c ON c.oid = i.indrelid JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = ANY(i.indkey) WHERE i.indisprimary AND c.relname IN (${pkInList})`);
+            const pkResult = exec(`SELECT c.relname, a.attname FROM pg_index i JOIN pg_class c ON c.oid = i.indrelid JOIN pg_namespace n ON n.oid = c.relnamespace JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = ANY(i.indkey) WHERE i.indisprimary AND n.nspname = ${postgresSchemaLiteral()} AND c.relname IN (${pkInList})`);
             for (const row of pkResult.rows) {
               const existing = pkMap.get(row[0]) || new Set;
               existing.add(row[1]);
@@ -4124,7 +4429,7 @@ function createDockerAdapter(config) {
       return result;
     },
     getTableRowCount(table) {
-      const id = sanitizeIdentifier(table, config.kind);
+      const id = tableIdentifier(table);
       const result = exec(`SELECT COUNT(*) FROM ${id}`);
       return result.rows.length > 0 ? Number(result.rows[0][0]) || 0 : 0;
     },
@@ -4133,7 +4438,7 @@ function createDockerAdapter(config) {
       if (tables.length === 0)
         return result;
       const parts = tables.map((t) => {
-        const id = sanitizeIdentifier(t, config.kind);
+        const id = tableIdentifier(t);
         return `SELECT '${t.replace(/'/g, "''")}' AS tbl, COUNT(*) AS cnt FROM ${id}`;
       });
       const sql = parts.join(" UNION ALL ");
@@ -4144,7 +4449,7 @@ function createDockerAdapter(config) {
         }
       } catch {
         for (const t of tables) {
-          const id = sanitizeIdentifier(t, config.kind);
+          const id = tableIdentifier(t);
           try {
             const r = exec(`SELECT COUNT(*) FROM ${id}`);
             result.set(t, r.rows.length > 0 ? Number(r.rows[0][0]) || 0 : 0);
@@ -4156,7 +4461,7 @@ function createDockerAdapter(config) {
       return result;
     },
     async getTablePageWithMeta(table, options) {
-      const id = sanitizeIdentifier(table, config.kind);
+      const id = tableIdentifier(table);
       const order = buildOrderClause(options.orderBy, config.kind);
       const countSql = `SELECT COUNT(*) AS cnt FROM ${id}`;
       const columnsPromise = tableMetaCache.getColumns(table, () => fetchColumnsAsyncUncached(table));
@@ -4171,7 +4476,7 @@ function createDockerAdapter(config) {
       return tablePageMetaFromResults(columns, dataResult, totalRows);
     },
     async getFilteredTablePageWithMeta(table, options) {
-      const id = sanitizeIdentifier(table, config.kind);
+      const id = tableIdentifier(table);
       const order = buildOrderClause(options.orderBy, config.kind);
       const where = buildDockerFilterWhere(options.grouped, config.kind);
       const whereClause = where ? ` WHERE ${where}` : "";
@@ -4188,7 +4493,7 @@ function createDockerAdapter(config) {
       return tablePageMetaFromResults(columns, dataResult, rowCountFromResult(countResult));
     },
     getTablePage(table, options) {
-      const id = sanitizeIdentifier(table, config.kind);
+      const id = tableIdentifier(table);
       const order = buildOrderClause(options.orderBy, config.kind);
       const cols = this.getColumns(table);
       const selectList = buildTableSelectList(cols, config.kind);
@@ -4222,10 +4527,8 @@ function createDockerAdapter(config) {
       if (BLOCKED_RE.test(upper)) {
         throw new Error("Query contains a disallowed statement keyword");
       }
-      const readOnlyPreamble = config.kind === "postgresql" ? "BEGIN TRANSACTION READ ONLY; " : "SET SESSION TRANSACTION READ ONLY; ";
-      const readOnlyPostamble = config.kind === "postgresql" ? "; COMMIT" : "; SET SESSION TRANSACTION READ WRITE";
       const stripped = trimmed.replace(/;\s*$/, "");
-      const limited = `${readOnlyPreamble}${stripped} LIMIT ${maxRows}${readOnlyPostamble}`;
+      const limited = config.kind === "postgresql" ? `BEGIN TRANSACTION READ ONLY; SET LOCAL search_path = ${sanitizeIdentifier(currentPostgresSchema(), config.kind)}; ${stripped} LIMIT ${maxRows}; COMMIT` : `SET SESSION TRANSACTION READ ONLY; ${stripped} LIMIT ${maxRows}; SET SESSION TRANSACTION READ WRITE`;
       const result = exec(limited);
       const columnNames = config.kind === "mysql" && result.columns.length > 0 ? result.columns : result.rows.length > 0 ? Array.from({ length: result.rows[0].length }, (_, i) => `col${i + 1}`) : [];
       return {
@@ -4241,14 +4544,14 @@ function createDockerAdapter(config) {
     getCreateStatement(table) {
       if (config.kind === "mysql") {
         try {
-          const result = exec(`SHOW CREATE TABLE ${sanitizeIdentifier(table, config.kind)}`);
+          const result = exec(`SHOW CREATE TABLE ${tableIdentifier(table)}`);
           return result.rows.length > 0 ? result.rows[0][1] || "" : "";
         } catch {
           return "";
         }
       }
       try {
-        const result = exec(`SELECT 'CREATE TABLE ' || '${table.replace(/'/g, "''")}' || ' (...)' AS ddl`);
+        const result = exec(`SELECT 'CREATE TABLE ' || ${escapeSqlString(tableIdentifier(table))} || ' (...)' AS ddl`);
         return result.rows.length > 0 ? result.rows[0][0] || "" : "";
       } catch {
         return "";
@@ -4259,7 +4562,7 @@ function createDockerAdapter(config) {
       if (config.kind === "mysql") {
         sql = `SELECT trigger_name, action_statement FROM information_schema.triggers WHERE event_object_schema = DATABASE() AND event_object_table = '${table.replace(/'/g, "''")}'`;
       } else {
-        sql = `SELECT tgname, pg_get_triggerdef(oid) FROM pg_trigger WHERE tgrelid = '${table.replace(/'/g, "''")}'::regclass AND NOT tgisinternal`;
+        sql = `SELECT tgname, pg_get_triggerdef(oid) FROM pg_trigger WHERE tgrelid = ${postgresRegclassLiteral(table)}::regclass AND NOT tgisinternal`;
       }
       try {
         const result = exec(sql);
@@ -4317,7 +4620,7 @@ function listDockerDatabases(serviceName, kind, env, cwd) {
     return [...cached.value];
   const containerName = resolveRunningComposeContainerName(serviceName, cwd);
   if (!containerName) {
-    return setDockerDatabasesCache(cacheKey, [], DOCKER_DATABASES_NEGATIVE_TTL_MS, now);
+    return setDockerSchemasCache(cacheKey, [], DOCKER_DATABASES_NEGATIVE_TTL_MS, now);
   }
   const user = env.POSTGRES_USER || env.MYSQL_USER || env.MARIADB_USER || env.POSTGRES_USERNAME || env.MYSQL_USERNAME || env.USER || "root";
   const password = env.POSTGRES_PASSWORD || env.MYSQL_PASSWORD || env.MARIADB_PASSWORD || "";
@@ -4354,7 +4657,43 @@ function listDockerDatabases(serviceName, kind, env, cwd) {
     return setDockerDatabasesCache(cacheKey, [], DOCKER_DATABASES_NEGATIVE_TTL_MS, now);
   }
 }
-function openDockerAdapter(serviceName, kind, env, cwd, overrideDatabase) {
+function listDockerSchemas(serviceName, kind, env, cwd, overrideDatabase) {
+  if (kind !== "postgresql")
+    return [];
+  const user = env.POSTGRES_USER || env.POSTGRES_USERNAME || "postgres";
+  const password = env.POSTGRES_PASSWORD || "";
+  const database = overrideDatabase || env.POSTGRES_DB || "postgres";
+  const cacheKey = dockerSchemasCacheKey(serviceName, kind, cwd, database);
+  const now = Date.now();
+  const cached = dockerSchemasCache.get(cacheKey);
+  if (cached && cached.expiresAt > now)
+    return [...cached.value];
+  const containerName = resolveRunningComposeContainerName(serviceName, cwd);
+  if (!containerName) {
+    return setDockerSchemasCache(cacheKey, [], DOCKER_DATABASES_NEGATIVE_TTL_MS, now);
+  }
+  const config = {
+    kind,
+    containerName,
+    user,
+    password,
+    database
+  };
+  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 = execInContainer(config, sql);
+    if (result.code !== 0) {
+      return setDockerSchemasCache(cacheKey, ["public"], DOCKER_DATABASES_NEGATIVE_TTL_MS, now);
+    }
+    const parsed = parseTsvOutput(result.stdout, false);
+    const schemas = parsed.rows.map((r) => r[0]).filter(Boolean);
+    const value = schemas.length > 0 ? schemas : ["public"];
+    return setDockerSchemasCache(cacheKey, value, DOCKER_DATABASES_POSITIVE_TTL_MS, now);
+  } catch {
+    return setDockerSchemasCache(cacheKey, ["public"], DOCKER_DATABASES_NEGATIVE_TTL_MS, now);
+  }
+}
+function openDockerAdapter(serviceName, kind, env, cwd, overrideDatabase, schema) {
   const containerName = resolveRunningComposeContainerNameOrThrow(serviceName, cwd);
   const user = env.POSTGRES_USER || env.MYSQL_USER || env.MARIADB_USER || (kind === "postgresql" ? "postgres" : "root");
   const password = env.POSTGRES_PASSWORD || env.MYSQL_PASSWORD || env.MYSQL_ROOT_PASSWORD || env.MARIADB_PASSWORD || env.MARIADB_ROOT_PASSWORD || "";
@@ -4364,14 +4703,16 @@ function openDockerAdapter(serviceName, kind, env, cwd, overrideDatabase) {
     containerName,
     user,
     password,
-    database
+    database,
+    ...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, spawnSyncImpl2, 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, MYSQL_SPATIAL_TYPES;
 var init_docker = __esm(() => {
   init_sql_snapshot();
   init_docker_utils();
   dockerDatabasesCache = new Map;
+  dockerSchemasCache = new Map;
   spawnSyncImpl2 = spawnSync3;
   MYSQL_SPATIAL_TYPES = new Set([
     "geometry",
@@ -5657,6 +5998,12 @@ function createDockerAdapterCache(maxEntries = DEFAULT_MAX_DOCKER_ADAPTER_CACHE,
       const cached = cache.get(key);
       if (cached)
         closeEntry(key, cached);
+    },
+    closePrefix(prefix) {
+      for (const [key, entry] of Array.from(cache)) {
+        if (key.startsWith(prefix))
+          closeEntry(key, entry);
+      }
     }
   };
 }
@@ -6749,12 +7096,18 @@ function deleteQueryHistoryEntry(state, id) {
     entries: state.entries.filter((e) => e.id !== id)
   };
 }
-function clearQueryHistory(state, dbId) {
+function clearQueryHistory(state, dbId, schema) {
   if (!dbId)
     return emptyState();
   return {
     version: 1,
-    entries: state.entries.filter((e) => e.dbId !== dbId)
+    entries: state.entries.filter((e) => {
+      if (e.dbId !== dbId)
+        return true;
+      if (schema === undefined)
+        return false;
+      return (e.schema || "public") !== schema;
+    })
   };
 }
 var CODE_VIEWER_DIR2 = ".code-viewer", HISTORY_FILE_NAME = "query-history.json", MAX_ENTRIES2 = 200, MAX_PREVIEW_ROWS = 100, MAX_JSON_BYTES = 1e6;
@@ -6795,6 +7148,9 @@ async function getStoreDb(cwd) {
   storeDb.exec("PRAGMA journal_mode=WAL");
   storeDb.exec("PRAGMA foreign_keys=ON");
   storeDb.exec(SCHEMA_SQL);
+  try {
+    storeDb.exec("ALTER TABLE snapshots ADD COLUMN schema_name TEXT");
+  } catch {}
   return storeDb;
 }
 function makeId2(prefix) {
@@ -6803,10 +7159,10 @@ function makeId2(prefix) {
 function hashPayload(payloadJson) {
   return createHash4("sha256").update(payloadJson).digest("hex");
 }
-async function createSnapshot(cwd, dbId, kind, tables, note) {
+async function createSnapshot(cwd, dbId, kind, tables, note, schema) {
   const db = await getStoreDb(cwd);
   const id = makeId2("snap");
-  db.prepare("INSERT INTO snapshots (id, db_id, kind, note, created_at, status) VALUES (?, ?, ?, ?, ?, ?)").run(id, dbId, kind, note, new Date().toISOString(), "running");
+  db.prepare("INSERT INTO snapshots (id, db_id, schema_name, kind, note, created_at, status) VALUES (?, ?, ?, ?, ?, ?, ?)").run(id, dbId, schema ?? null, kind, note, new Date().toISOString(), "running");
   for (const t of tables) {
     db.prepare("INSERT INTO snapshot_tables (snapshot_id, table_name) VALUES (?, ?)").run(id, t);
   }
@@ -6835,19 +7191,22 @@ async function finalizeSnapshot(cwd, snapshotId, error) {
     db.prepare("UPDATE snapshots SET status = 'done' WHERE id = ?").run(snapshotId);
   }
 }
-async function listSnapshots(cwd, dbId) {
+async function listSnapshots(cwd, dbId, schema) {
   const db = await getStoreDb(cwd);
   let rows;
-  if (dbId) {
-    rows = db.prepare("SELECT id, db_id, kind, note, created_at, status, error_message FROM snapshots WHERE db_id = ? ORDER BY created_at DESC").all(dbId);
+  if (dbId && schema !== undefined) {
+    rows = db.prepare("SELECT id, db_id, schema_name, kind, note, created_at, status, error_message FROM snapshots WHERE db_id = ? AND COALESCE(schema_name, 'public') = ? ORDER BY created_at DESC").all(dbId, schema);
+  } else if (dbId) {
+    rows = db.prepare("SELECT id, db_id, schema_name, kind, note, created_at, status, error_message FROM snapshots WHERE db_id = ? ORDER BY created_at DESC").all(dbId);
   } else {
-    rows = db.prepare("SELECT id, db_id, kind, note, created_at, status, error_message FROM snapshots ORDER BY created_at DESC").all();
+    rows = db.prepare("SELECT id, db_id, schema_name, kind, note, created_at, status, error_message FROM snapshots ORDER BY created_at DESC").all();
   }
   return rows.map((r) => {
     const tableRows = db.prepare("SELECT table_name FROM snapshot_tables WHERE snapshot_id = ?").all(r.id);
     return {
       id: r.id,
       dbId: r.db_id,
+      ...r.schema_name ? { schema: r.schema_name } : {},
       kind: r.kind,
       note: r.note,
       createdAt: r.created_at,
@@ -6872,8 +7231,22 @@ async function deleteSnapshot(cwd, snapshotId) {
     }
   }
 }
+function getSnapshotScope(db, snapshotId) {
+  const row = db.prepare("SELECT db_id, COALESCE(schema_name, 'public') AS schema_name FROM snapshots WHERE id = ?").get(snapshotId);
+  if (!row)
+    throw new Error(`snapshot not found: ${snapshotId}`);
+  return { dbId: row.db_id, schema: row.schema_name };
+}
+function assertSameSnapshotScope(db, beforeId, afterId) {
+  const before = getSnapshotScope(db, beforeId);
+  const after = getSnapshotScope(db, afterId);
+  if (before.dbId !== after.dbId || before.schema !== after.schema) {
+    throw new Error(`cannot compare snapshots from different database/schema (${before.dbId}:${before.schema} vs ${after.dbId}:${after.schema})`);
+  }
+}
 async function computeDiffTables(cwd, beforeId, afterId) {
   const db = await getStoreDb(cwd);
+  assertSameSnapshotScope(db, beforeId, afterId);
   const beforeTables = db.prepare("SELECT table_name, table_hash, row_count FROM snapshot_tables WHERE snapshot_id = ?").all(beforeId);
   const afterTables = db.prepare("SELECT table_name, table_hash, row_count FROM snapshot_tables WHERE snapshot_id = ?").all(afterId);
   const beforeMap = new Map(beforeTables.map((t) => [t.table_name, t]));
@@ -6896,7 +7269,7 @@ async function computeDiffTables(cwd, beforeId, afterId) {
     if (!b) {
       results.push({
         tableName: table,
-        insertedCount: a.row_count,
+        insertedCount: a ? a.row_count : 0,
         updatedCount: 0,
         deletedCount: 0,
         unchangedCount: 0
@@ -6945,6 +7318,7 @@ async function computeDiffTables(cwd, beforeId, afterId) {
 }
 async function computeDiffRows(cwd, beforeId, afterId, table, offset = 0, limit = 200) {
   const db = await getStoreDb(cwd);
+  assertSameSnapshotScope(db, beforeId, afterId);
   const allDiffRows = [];
   const inserted = db.prepare(`SELECT a.row_key_json, a.payload_hash
        FROM snapshot_rows a
@@ -7014,6 +7388,7 @@ var CODE_VIEWER_DIR3 = ".code-viewer", SNAPSHOT_DB_NAME = "db-snapshots.sqlite",
 CREATE TABLE IF NOT EXISTS snapshots (
   id TEXT PRIMARY KEY,
   db_id TEXT NOT NULL,
+  schema_name TEXT,
   kind TEXT NOT NULL,
   note TEXT NOT NULL DEFAULT '',
   created_at TEXT NOT NULL,
@@ -7067,7 +7442,7 @@ async function runSnapshot(cwd, source, dbId, containers, note, onProgress, opti
     throw new Error("data source does not support snapshot (missing SnapshotIterable capability)");
   }
   const snapshotSource = source;
-  const snapshotId = await createSnapshot(cwd, dbId, snapshotSource.kind, containers, note);
+  const snapshotId = await createSnapshot(cwd, dbId, snapshotSource.kind, containers, note, options.schema);
   try {
     options.onSnapshotId?.(snapshotId);
     for (const container of containers) {
@@ -7300,14 +7675,40 @@ function ensureInit() {
 async function getAdapter(r, _cwd) {
   if (r.docker) {
     const docker = r.docker;
-    return dockerAdapterCache.getOrOpen(r.dbId, () => openDockerAdapter(docker.serviceName, docker.kind, docker.env, docker.composeDir, docker.database));
+    const cacheKey = r.schema ? `${r.dbId}\x00schema=${r.schema}` : r.dbId;
+    return dockerAdapterCache.getOrOpen(cacheKey, () => openDockerAdapter(docker.serviceName, docker.kind, docker.env, docker.composeDir, docker.database, r.schema));
   }
   return getConnection(r.resolved);
 }
 function sanitizeFilename(name) {
   return name.replace(/["\\\r\n\x00-\x1f]/g, "_");
 }
-function resolveDb(cwd, dbParam, omitDirNames) {
+function normalizeSchemaParam(value) {
+  if (value === undefined || value === null || value === "")
+    return;
+  if (value.length > MAX_SCHEMA_NAME_LEN) {
+    return textError("invalid schema parameter", 400);
+  }
+  if (/[\x00-\x1f\x7f]/.test(value)) {
+    return textError("invalid schema parameter", 400);
+  }
+  return value;
+}
+function resolvePostgresSchema(info, requestedSchema) {
+  if (info.kind !== "postgresql")
+    return;
+  const schemas = listDockerSchemas(info.serviceName, "postgresql", info.env, info.composeDir, info.database);
+  if (requestedSchema) {
+    if (!schemas.includes(requestedSchema)) {
+      return textError(`schema not found: ${requestedSchema}`, 404);
+    }
+    return requestedSchema;
+  }
+  if (schemas.includes("public"))
+    return "public";
+  return schemas[0] || "public";
+}
+function resolveDb(cwd, dbParam, omitDirNames, schemaParam) {
   if (!dbParam)
     return textError("missing db parameter", 400);
   if (dbParam.startsWith("docker:")) {
@@ -7324,7 +7725,18 @@ function resolveDb(cwd, dbParam, omitDirNames) {
       return textError("elasticsearch services must use the /_db/elasticsearch/* routes", 400);
     }
     const resolved2 = parsed.database ? { ...info, database: parsed.database } : info;
-    return { resolved: dbParam, dbId: dbParam, docker: resolved2 };
+    const requestedSchema = normalizeSchemaParam(schemaParam);
+    if (requestedSchema instanceof Response)
+      return requestedSchema;
+    const schema = resolvePostgresSchema(resolved2, requestedSchema);
+    if (schema instanceof Response)
+      return schema;
+    return {
+      resolved: dbParam,
+      dbId: dbParam,
+      docker: resolved2,
+      ...schema ? { schema } : {}
+    };
   }
   const resolved = validateDbPath(cwd, dbParam);
   if (!resolved)
@@ -7379,8 +7791,24 @@ function handleFiles(cwd, omitDirNames) {
   };
   return json(body);
 }
+function handleSchemas(cwd, url, omitDirNames) {
+  const r = resolveDb(cwd, url.searchParams.get("db"), omitDirNames, url.searchParams.get("schema"));
+  if (r instanceof Response)
+    return r;
+  if (!r.docker || r.docker.kind !== "postgresql") {
+    const body2 = { dbId: r.dbId, schemas: [] };
+    return json(body2);
+  }
+  const schemas = listDockerSchemas(r.docker.serviceName, "postgresql", r.docker.env, r.docker.composeDir, r.docker.database);
+  const body = {
+    dbId: r.dbId,
+    schemas: schemas.map((name) => ({ name })),
+    selectedSchema: r.schema
+  };
+  return json(body);
+}
 async function handleSchema(cwd, url, omitDirNames) {
-  const r = resolveDb(cwd, url.searchParams.get("db"), omitDirNames);
+  const r = resolveDb(cwd, url.searchParams.get("db"), omitDirNames, url.searchParams.get("schema"));
   if (r instanceof Response)
     return r;
   const includeColumns = url.searchParams.get("includeColumns") === "1";
@@ -7405,6 +7833,7 @@ async function handleSchema(cwd, url, omitDirNames) {
     const foreignKeys = adapter.getForeignKeys();
     const body = {
       dbId: r.dbId,
+      ...r.schema ? { schema: r.schema } : {},
       tables: tablesWithCount,
       indexes,
       foreignKeys
@@ -7482,7 +7911,7 @@ function groupFiltersByValue(filters) {
   return grouped;
 }
 async function handleTable(cwd, url, omitDirNames) {
-  const r = resolveDb(cwd, url.searchParams.get("db"), omitDirNames);
+  const r = resolveDb(cwd, url.searchParams.get("db"), omitDirNames, url.searchParams.get("schema"));
   if (r instanceof Response)
     return r;
   const table = url.searchParams.get("table");
@@ -7517,6 +7946,7 @@ async function handleTable(cwd, url, omitDirNames) {
       }
       const body2 = {
         dbId: r.dbId,
+        ...r.schema ? { schema: r.schema } : {},
         table,
         columns: meta.columns,
         rows: serializeDbRows(meta.rows),
@@ -7539,6 +7969,7 @@ async function handleTable(cwd, url, omitDirNames) {
       }
       const body2 = {
         dbId: r.dbId,
+        ...r.schema ? { schema: r.schema } : {},
         table,
         columns: meta.columns,
         rows: serializeDbRows(meta.rows),
@@ -7570,6 +8001,7 @@ async function handleTable(cwd, url, omitDirNames) {
         const dataResult = adapter.executeReadonlyQuery(dataSql, filter.useParams ? [...filter.params, limit, offset] : undefined);
         const body2 = {
           dbId: r.dbId,
+          ...r.schema ? { schema: r.schema } : {},
           table,
           columns,
           rows: serializeDbRows(dataResult.rows),
@@ -7585,6 +8017,7 @@ async function handleTable(cwd, url, omitDirNames) {
     const totalRows = result.rowCount < limit ? offset + result.rowCount : adapter.getTableRowCount(table);
     const body = {
       dbId: r.dbId,
+      ...r.schema ? { schema: r.schema } : {},
       table,
       columns,
       rows: serializeDbRows(result.rows),
@@ -7637,7 +8070,7 @@ async function handleQuery(cwd, req, sendSse, omitDirNames) {
     return body;
   if (!body.db || !body.sql)
     return textError("missing db or sql", 400);
-  const r = resolveDb(cwd, body.db, omitDirNames);
+  const r = resolveDb(cwd, body.db, omitDirNames, body.schema);
   if (r instanceof Response)
     return r;
   const maxRows = Math.min(1e4, Math.max(1, body.maxRows || 1000));
@@ -7652,6 +8085,7 @@ async function handleQuery(cwd, req, sendSse, omitDirNames) {
     const columnTypes = inferredColumns.length > 0 ? inferredColumns.map((col) => col.type) : result.columnTypes;
     const response = {
       dbId: body.db,
+      ...r.schema ? { schema: r.schema } : {},
       columns,
       columnTypes,
       rows: serializedRows,
@@ -7663,6 +8097,7 @@ async function handleQuery(cwd, req, sendSse, omitDirNames) {
       const entry = {
         id: makeHistoryId(),
         dbId: body.db,
+        ...r.schema ? { schema: r.schema } : {},
         sql: body.sql,
         title: body.title,
         body: body.body,
@@ -7679,7 +8114,12 @@ async function handleQuery(cwd, req, sendSse, omitDirNames) {
       const state = loadQueryHistory(cwd);
       const updated = addQueryHistoryEntry(state, entry);
       saveQueryHistory(cwd, updated);
-      sendSse?.("db-query", JSON.stringify({ action: "add", dbId: body.db, id: entry.id }));
+      sendSse?.("db-query", JSON.stringify({
+        action: "add",
+        dbId: body.db,
+        schema: r.schema,
+        id: entry.id
+      }));
     }
     return json(response);
   } catch (err) {
@@ -7690,6 +8130,7 @@ async function handleQuery(cwd, req, sendSse, omitDirNames) {
     const elapsed = Date.now() - start;
     const response = {
       dbId: body.db,
+      ...r.schema ? { schema: r.schema } : {},
       columns: [],
       columnTypes: [],
       rows: [],
@@ -7703,11 +8144,20 @@ async function handleQuery(cwd, req, sendSse, omitDirNames) {
 }
 function handleHistory(cwd, url) {
   const dbId = url.searchParams.get("db") || undefined;
+  const schema = normalizeSchemaParam(url.searchParams.get("schema"));
+  if (schema instanceof Response)
+    return schema;
   const state = loadQueryHistory(cwd);
   if (dbId) {
     return json({
       version: 1,
-      entries: state.entries.filter((e) => e.dbId === dbId)
+      entries: state.entries.filter((e) => {
+        if (e.dbId !== dbId)
+          return false;
+        if (schema === undefined)
+          return true;
+        return (e.schema || "public") === schema;
+      })
     });
   }
   return json(state);
@@ -7722,7 +8172,12 @@ async function handleHistoryDelete(cwd, req, sendSse) {
   const deleted = state.entries.find((entry) => entry.id === body.id);
   const updated = deleteQueryHistoryEntry(state, body.id);
   saveQueryHistory(cwd, updated);
-  sendSse?.("db-query", JSON.stringify({ action: "delete", dbId: deleted?.dbId, id: body.id }));
+  sendSse?.("db-query", JSON.stringify({
+    action: "delete",
+    dbId: deleted?.dbId,
+    schema: deleted?.schema,
+    id: body.id
+  }));
   return json({ ok: true });
 }
 async function handleHistoryClear(cwd, req, sendSse) {
@@ -7735,9 +8190,12 @@ async function handleHistoryClear(cwd, req, sendSse) {
     body = {};
   }
   const state = loadQueryHistory(cwd);
-  const updated = clearQueryHistory(state, body.db);
+  const schema = normalizeSchemaParam(body.schema);
+  if (schema instanceof Response)
+    return schema;
+  const updated = clearQueryHistory(state, body.db, schema);
   saveQueryHistory(cwd, updated);
-  sendSse?.("db-query", JSON.stringify({ action: "clear", dbId: body.db }));
+  sendSse?.("db-query", JSON.stringify({ action: "clear", dbId: body.db, schema }));
   return json({ ok: true });
 }
 function formatCsvField(value) {
@@ -7755,7 +8213,7 @@ function formatCsvField(value) {
   return str;
 }
 async function handleExport(cwd, url, omitDirNames) {
-  const r = resolveDb(cwd, url.searchParams.get("db"), omitDirNames);
+  const r = resolveDb(cwd, url.searchParams.get("db"), omitDirNames, url.searchParams.get("schema"));
   if (r instanceof Response)
     return r;
   const table = url.searchParams.get("table");
@@ -7856,7 +8314,7 @@ async function handleExport(cwd, url, omitDirNames) {
   }
 }
 async function handleColumns(cwd, url, omitDirNames) {
-  const r = resolveDb(cwd, url.searchParams.get("db"), omitDirNames);
+  const r = resolveDb(cwd, url.searchParams.get("db"), omitDirNames, url.searchParams.get("schema"));
   if (r instanceof Response)
     return r;
   const table = url.searchParams.get("table");
@@ -7865,13 +8323,18 @@ async function handleColumns(cwd, url, omitDirNames) {
   try {
     const adapter = await getAdapter(r, cwd);
     const columns = adapter.getColumns(table);
-    return json({ dbId: r.dbId, table, columns });
+    return json({
+      dbId: r.dbId,
+      ...r.schema ? { schema: r.schema } : {},
+      table,
+      columns
+    });
   } catch (err) {
     return handleError("database", "get columns", err);
   }
 }
 async function handleDdl(cwd, url, omitDirNames) {
-  const r = resolveDb(cwd, url.searchParams.get("db"), omitDirNames);
+  const r = resolveDb(cwd, url.searchParams.get("db"), omitDirNames, url.searchParams.get("schema"));
   if (r instanceof Response)
     return r;
   const table = url.searchParams.get("table");
@@ -7881,7 +8344,13 @@ async function handleDdl(cwd, url, omitDirNames) {
     const adapter = await getAdapter(r, cwd);
     const sql = adapter.getCreateStatement(table);
     const triggers = adapter.getTriggers(table);
-    return json({ dbId: r.dbId, table, sql, triggers });
+    return json({
+      dbId: r.dbId,
+      ...r.schema ? { schema: r.schema } : {},
+      table,
+      sql,
+      triggers
+    });
   } catch (err) {
     return handleError("database", "get DDL", err);
   }
@@ -7892,7 +8361,7 @@ async function handleSearchStart(cwd, req, omitDirNames) {
     return body;
   if (!body.db || !body.term)
     return textError("missing db or term", 400);
-  const r = resolveDb(cwd, body.db, omitDirNames);
+  const r = resolveDb(cwd, body.db, omitDirNames, body.schema);
   if (r instanceof Response)
     return r;
   const jobId = makeId("search");
@@ -7900,6 +8369,7 @@ async function handleSearchStart(cwd, req, omitDirNames) {
   const job = {
     id: jobId,
     dbId: body.db,
+    ...r.schema ? { schema: r.schema } : {},
     scannedTables: 0,
     totalTables: 0,
     hits: [],
@@ -7937,7 +8407,10 @@ async function handleSearchStart(cwd, req, omitDirNames) {
         const pkCols = getPrimaryKeyColumns(adapter, table);
         const columns = adapter.getColumns(table);
         const hits = searchTable(adapter, table, columns, term, maxHitsPerTable, includeNonText, pkCols);
-        job.hits.push(...hits);
+        job.hits.push(...hits.map((hit) => ({
+          ...r.schema ? { schema: r.schema } : {},
+          ...hit
+        })));
         job.scannedTables++;
       }
       job.done = true;
@@ -7961,6 +8434,7 @@ function handleSearchStatus(url) {
   const result = {
     jobId: job.id,
     dbId: job.dbId,
+    schema: job.schema,
     scannedTables: job.scannedTables,
     totalTables: job.totalTables,
     currentTable: job.currentTable,
@@ -7992,7 +8466,10 @@ async function openRegisteredDockerSnapshotSource(info, requestedContainers) {
 }
 async function handleSnapshotList(cwd, url) {
   const dbId = url.searchParams.get("db") || undefined;
-  const snapshots = await listSnapshots(cwd, dbId);
+  const schema = normalizeSchemaParam(url.searchParams.get("schema"));
+  if (schema instanceof Response)
+    return schema;
+  const snapshots = await listSnapshots(cwd, dbId, schema);
   return json({ snapshots });
 }
 function sanitizeSnapshotTables(tables) {
@@ -8043,10 +8520,11 @@ async function handleSnapshotCreate(cwd, req, sendSse, omitDirNames) {
     }
   }
   if (!source) {
-    const r = resolveDb(cwd, body.db, omitDirNames);
+    const r = resolveDb(cwd, body.db, omitDirNames, body.schema);
     if (r instanceof Response)
       return r;
     source = await getAdapter(r, cwd);
+    body.schema = r.schema;
   }
   if (!containers || containers.length === 0) {
     const sqlAdapter = source;
@@ -8073,11 +8551,13 @@ async function handleSnapshotCreate(cwd, req, sendSse, omitDirNames) {
         sendSse?.("db-snapshot", JSON.stringify({
           action: "progress",
           dbId: snapshotDbId,
+          schema: body.schema,
           table,
           done
         }));
       }, {
         signal: abortController.signal,
+        schema: body.schema,
         onSnapshotId: (id) => {
           activeSnapshotId = id;
           snapshotJob.snapshotId = id;
@@ -8085,6 +8565,7 @@ async function handleSnapshotCreate(cwd, req, sendSse, omitDirNames) {
           sendSse?.("db-snapshot", JSON.stringify({
             action: "started",
             dbId: snapshotDbId,
+            schema: body.schema,
             id
           }));
         }
@@ -8092,6 +8573,7 @@ async function handleSnapshotCreate(cwd, req, sendSse, omitDirNames) {
       sendSse?.("db-snapshot", JSON.stringify({
         action: "created",
         dbId: snapshotDbId,
+        schema: body.schema,
         id: snapshotId
       }));
     } catch (err) {
@@ -8099,6 +8581,7 @@ async function handleSnapshotCreate(cwd, req, sendSse, omitDirNames) {
       sendSse?.("db-snapshot", JSON.stringify({
         action: "error",
         dbId: snapshotDbId,
+        schema: body.schema,
         error: err instanceof Error ? err.message : String(err)
       }));
     } finally {
@@ -8223,6 +8706,7 @@ async function handleClose(cwd, req, omitDirNames) {
     const info = findDockerServiceByDbId(cwd, body.db, undefined, omitDirNames);
     if (!info) {
       dockerAdapterCache.close(body.db);
+      dockerAdapterCache.closePrefix(`${body.db}\x00`);
       closeRedisAdapter(body.db);
       closeElasticsearchAdapter(body.db);
       return json({ ok: true });
@@ -8235,6 +8719,7 @@ async function handleClose(cwd, req, omitDirNames) {
     return r;
   if (r.docker) {
     dockerAdapterCache.close(r.dbId);
+    dockerAdapterCache.closePrefix(`${r.dbId}\x00`);
   } else {
     closeConnection(r.resolved);
   }
@@ -8267,6 +8752,10 @@ async function handleDatabaseRoute(req, url, cwd, omitDirNames, sideEffectAllowe
       methods: ["GET"],
       handler: () => handleFiles(cwd, omitDirNames)
     },
+    "/_db/schemas": {
+      methods: ["GET"],
+      handler: () => handleSchemas(cwd, url, omitDirNames)
+    },
     "/_db/schema": {
       methods: ["GET"],
       handler: () => handleSchema(cwd, url, omitDirNames)
@@ -8364,7 +8853,7 @@ async function handleDatabaseRoute(req, url, cwd, omitDirNames, sideEffectAllowe
     }
   }, sideEffectAllowed, wrapResponse, (err) => handleError("database", "handle database request", err));
 }
-var initialized = false, dockerAdapterCache, EXPORT_MAX_ROWS = 1e5, MAX_TABS_BODY_BYTES = 1e6, MAX_SNAPSHOT_TABLES = 512, MAX_SNAPSHOT_TABLE_NAME_LEN = 1024, searchJobs, snapshotJobs, DOCKER_CLOSE_REGISTRY, SNAPSHOT_DOCKER_SOURCE_REGISTRY;
+var initialized = false, dockerAdapterCache, MAX_SCHEMA_NAME_LEN = 1024, EXPORT_MAX_ROWS = 1e5, MAX_TABS_BODY_BYTES = 1e6, MAX_SNAPSHOT_TABLES = 512, MAX_SNAPSHOT_TABLE_NAME_LEN = 1024, searchJobs, snapshotJobs, DOCKER_CLOSE_REGISTRY, SNAPSHOT_DOCKER_SOURCE_REGISTRY;
 var init_handle = __esm(() => {
   init_docker();
   init_docker_utils();
@@ -8384,8 +8873,14 @@ var init_handle = __esm(() => {
   searchJobs = new Map;
   snapshotJobs = new Map;
   DOCKER_CLOSE_REGISTRY = {
-    postgresql: (dbId) => dockerAdapterCache.close(dbId),
-    mysql: (dbId) => dockerAdapterCache.close(dbId),
+    postgresql: (dbId) => {
+      dockerAdapterCache.close(dbId);
+      dockerAdapterCache.closePrefix(`${dbId}\x00`);
+    },
+    mysql: (dbId) => {
+      dockerAdapterCache.close(dbId);
+      dockerAdapterCache.closePrefix(`${dbId}\x00`);
+    },
     redis: closeRedisAdapter,
     elasticsearch: closeElasticsearchAdapter
   };
@@ -9572,7 +10067,7 @@ function rawFileHeaders(path, size = null, range, metadata = {}) {
     ".opus": "audio/ogg"
   };
   const headers = {
-    "Content-Type": mime[extname(path).toLowerCase()] || "application/octet-stream",
+    "Content-Type": mime[extname(path).toLowerCase()] || (sourceDisplayKind(path) === "text" ? "text/plain; charset=utf-8" : "application/octet-stream"),
     "Cache-Control": "no-store",
     "X-Content-Type-Options": "nosniff",
     "Content-Security-Policy": "sandbox",
@@ -10219,6 +10714,7 @@ async function shutdown(exitCode = 0) {
 var WEB_ROOT, VERSION, DEFAULT_ARGS, PREVIEW_HUNKS_DEFAULT = 3, PREVIEW_LINES_DEFAULT = 1200, WATCHED_ASSET_FILES, SIZE_SMALL = 2000, SIZE_MEDIUM = 8000, SIZE_LARGE = 20000, LINE_INDEX_MIN_START = 1e4, LINE_INDEX_MAX_FILE_BYTES, BLOB_LINE_CACHE_MAX_BYTES, MAX_UPLOAD_FILE_BYTES, MAX_UPLOAD_TOTAL_BYTES, MAX_UPLOAD_BODY_BYTES, MAX_UPLOAD_FILES = 50, SAFE_UPLOAD_EXTENSIONS, generation = 1, cwd, cliArgs, listenPort = 0, openAfterStart = false, scopeOmitDirNames, scopeOmitDirCliOverride = null, scopeExcludeNames, uploadDisabledByConfig = false, rgAvailableCache = null, enc, sseClients, sseKeepalives, fileCache, metaCache, fileListCache, lineIndexCache, blobLineIndexCache, blobBytesCache, blobLineCacheBytes = 0, server, worktreeWatch = null, shuttingDown = false;
 var init_preview = __esm(async () => {
   init_routes();
+  init_source_meta();
   init_annotations();
   init_cache();
   init_dev_assets();