viberoom 0.5.9 → 0.6.0

package/dist/server.js

@@ -1,16 +1,19 @@
 // viberoom - Copyright (c) 2026 Todor Rusev - AGPL-3.0-or-later; see LICENSE
 import { spawn } from "node:child_process";
 import { createServer } from "node:http";
-import { readFile, stat } from "node:fs/promises";
+import { readFile, realpath, stat } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 import { createRequire } from "node:module";
-import { dirname, join } from "node:path";
-import { existsSync as fileExists } from "node:fs";
+import { dirname, isAbsolute, join, resolve, sep } from "node:path";
+import { createReadStream, existsSync as fileExists } from "node:fs";
+import { createInterface } from "node:readline";
 import { classifyOpenTarget, describeOpen, detectEditor, editorCommand, isExecutablePath, openCommand } from "./open.js";
-import { parseCsv, viewerKind, VIEWER_MAX_BYTES } from "./viewer.js";
+import { imageMediaType, languageOf, looksBinary, parseCsv, sliceLines, viewerKind, IMAGE_VIEW_MAX_BYTES, STREAM_MAX_BYTES, VIEWER_MAX_BYTES, WINDOW_MAX_LINES } from "./viewer.js";
 import { createFolder, homeFolder, listFolders, listRoots } from "./fsbrowse.js";
 import { contentTypeOf, isStoredFileName, IMAGE_MAX_BYTES, IMAGES_PER_MESSAGE } from "./files.js";
+import { QUOTES_PER_MESSAGE } from "./quotes.js";
 import { commandTarget, parseRoomCommand } from "./commands.js";
+import { acceptUpgrade } from "./ws.js";
 let editorFound;
 function currentEditor() {
     if (editorFound === undefined)
@@ -19,12 +22,6 @@ function currentEditor() {
 }
 const STATIC_FILES = {
     "/": { file: "index.html", type: "text/html; charset=utf-8" },
-    "/index.html": { file: "index.html", type: "text/html; charset=utf-8" },
-    "/app.js": { file: "app.js", type: "text/javascript; charset=utf-8" },
-    "/avatars.js": { file: "avatars.js", type: "text/javascript; charset=utf-8" },
-    "/icons.js": { file: "icons.js", type: "text/javascript; charset=utf-8" },
-    "/theme.css": { file: "theme.css", type: "text/css; charset=utf-8" },
-    "/app.css": { file: "app.css", type: "text/css; charset=utf-8" },
     "/styleguide": { file: "styleguide.html", type: "text/html; charset=utf-8" },
     "/manifest.json": { file: "manifest.json", type: "application/manifest+json; charset=utf-8" },
     "/icon.svg": { file: "icon.svg", type: "image/svg+xml", dir: "assets" },
@@ -39,9 +36,21 @@ const STATIC_FILES = {
     "/vendor-icons/copilot.svg": { file: "vendors/copilot.svg", type: "image/svg+xml", dir: "assets" },
     "/vendor/mermaid.min.js": { file: "mermaid/dist/mermaid.min.js", type: "text/javascript; charset=utf-8", dir: "node_modules" },
     "/vendor/marked.umd.js": { file: "marked/lib/marked.umd.js", type: "text/javascript; charset=utf-8", dir: "node_modules" },
+    "/vendor/prism.js": { file: "prismjs/prism.js", type: "text/javascript; charset=utf-8", dir: "node_modules" },
+};
+const PRISM_LANGUAGE = /^\/vendor\/prism-lang\/([a-z0-9-]{1,32})\.js$/;
+const UI_FILE = /^\/([a-z0-9_-]+\.(js|css|html|svg|json|png|ico))$/i;
+const UI_TYPES = {
+    js: "text/javascript; charset=utf-8",
+    css: "text/css; charset=utf-8",
+    html: "text/html; charset=utf-8",
+    svg: "image/svg+xml",
+    json: "application/json; charset=utf-8",
+    png: "image/png",
+    ico: "image/x-icon",
 };
 import { checkForUpdate, installUpdate, restartWithNewBuild, runsFromSourceCheckout } from "./update.js";
-export function startServer(hub, port, log, info, onShutdownRequest) {
+export function startServer(hub, port, log, info, onShutdownRequest, onRestartRequest) {
     const uiDir = fileURLToPath(new URL("../ui/", import.meta.url));
     const assetsDir = fileURLToPath(new URL("../assets/", import.meta.url));
     const resolveModule = createRequire(import.meta.url).resolve;
@@ -53,16 +62,26 @@ export function startServer(hub, port, log, info, onShutdownRequest) {
         return join(packageDir(entry.file.slice(0, slash)), entry.file.slice(slash + 1));
     };
     const clients = new Set();
-    const snapshot = () => ({ ...hub.snapshot(), version: info });
+    const sockets = new Set();
+    const snapshot = () => ({ ...hub.snapshot(), version: { ...info, pid: process.pid } });
     const broadcast = (event) => {
-        const payload = `event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`;
+        const json = JSON.stringify(event);
+        const payload = `event: ${event.type}\ndata: ${json}\n\n`;
         for (const res of clients)
             res.write(payload);
+        for (const peer of sockets)
+            peer.send(json);
     };
     hub.on("event", broadcast);
     const heartbeat = setInterval(() => {
         for (const res of clients)
             res.write(": ping\n\n");
+        for (const peer of sockets) {
+            if (!peer.alive)
+                peer.close(1001, "no pong");
+            else
+                peer.ping();
+        }
     }, 20_000);
     const server = createServer(async (req, res) => {
         try {
@@ -77,6 +96,20 @@ export function startServer(hub, port, log, info, onShutdownRequest) {
                 res.end();
         }
     });
+    server.on("upgrade", (req, socket, head) => {
+        const path = new URL(req.url ?? "/", "http://localhost").pathname;
+        if (path !== "/ws") {
+            socket.write("HTTP/1.1 404 Not Found\r\nConnection: close\r\n\r\n");
+            socket.destroy();
+            return;
+        }
+        const peer = acceptUpgrade(req, socket, head);
+        if (!peer)
+            return;
+        sockets.add(peer);
+        peer.onClose(() => sockets.delete(peer));
+        peer.send(JSON.stringify({ type: "snapshot", snapshot: snapshot() }));
+    });
     async function handle(req, res) {
         const url = new URL(req.url ?? "/", "http://localhost");
         const path = url.pathname;
@@ -92,6 +125,18 @@ export function startServer(hub, port, log, info, onShutdownRequest) {
             }
             return;
         }
+        const prismLanguage = req.method === "GET" && path.match(PRISM_LANGUAGE);
+        if (prismLanguage) {
+            try {
+                const body = await readFile(staticPath({ file: `prismjs/components/prism-${prismLanguage[1]}.min.js`, dir: "node_modules" }));
+                res.writeHead(200, { "Content-Type": "text/javascript; charset=utf-8", "Cache-Control": "public, max-age=3600" });
+                res.end(body);
+            }
+            catch {
+                sendJson(res, 404, { error: `no highlighting for "${prismLanguage[1]}"` });
+            }
+            return;
+        }
         if (req.method === "GET" && STATIC_FILES[path]) {
             const entry = STATIC_FILES[path];
             const body = await readFile(staticPath(entry));
@@ -99,6 +144,20 @@ export function startServer(hub, port, log, info, onShutdownRequest) {
             res.end(body);
             return;
         }
+        const uiFile = req.method === "GET" && path.match(UI_FILE);
+        if (uiFile) {
+            let body;
+            try {
+                body = await readFile(`${uiDir}${uiFile[1]}`);
+            }
+            catch {
+                sendJson(res, 404, { error: `no such file: ${uiFile[1]}` });
+                return;
+            }
+            res.writeHead(200, { "Content-Type": UI_TYPES[uiFile[2].toLowerCase()], "Cache-Control": "no-cache" });
+            res.end(body);
+            return;
+        }
         if (req.method === "GET" && path === "/events") {
             res.writeHead(200, {
                 "Content-Type": "text/event-stream",
@@ -130,13 +189,55 @@ export function startServer(hub, port, log, info, onShutdownRequest) {
             }
             return;
         }
+        if (req.method === "GET" && path === "/api/resolve") {
+            const asked = url.searchParams.get("path") ?? "";
+            const inRoom = await resolveInRoom(hub, url.searchParams.get("room"), asked);
+            const target = inRoom ?? (classifyOpenTarget(asked)?.kind === "path" ? classifyOpenTarget(asked).value : null);
+            if (!target) {
+                sendJson(res, 404, { error: "not a file of this room's folder" });
+                return;
+            }
+            try {
+                const info = await stat(target);
+                sendJson(res, 200, { ok: true, path: target, kind: info.isFile() ? "file" : info.isDirectory() ? "dir" : "other" });
+            }
+            catch {
+                sendJson(res, 404, { error: `no such file or folder: ${target}` });
+            }
+            return;
+        }
+        if (req.method === "GET" && path === "/api/image") {
+            const asked = url.searchParams.get("path") ?? "";
+            const inRoom = await resolveInRoom(hub, url.searchParams.get("room"), asked);
+            const target = classifyOpenTarget(inRoom ?? asked);
+            if (!target || target.kind !== "path")
+                throw new Error("only absolute paths, or a path inside the room's folder, can be shown");
+            const media = imageMediaType(target.value);
+            if (!media)
+                throw new Error("not a picture the room can show");
+            let info;
+            try {
+                info = await stat(target.value);
+            }
+            catch {
+                sendJson(res, 404, { error: `no such file: ${target.value}` });
+                return;
+            }
+            if (!info.isFile())
+                throw new Error(`not a file: ${target.value}`);
+            if (info.size > IMAGE_VIEW_MAX_BYTES)
+                throw new Error(`too big to show here (${Math.round(info.size / 1024 / 1024)} MB); it opens with the default app`);
+            res.writeHead(200, { "Content-Type": media, "Content-Length": String(info.size), "Cache-Control": "no-cache" });
+            createReadStream(target.value).pipe(res);
+            return;
+        }
         if (req.method === "GET" && path === "/api/file") {
-            const target = classifyOpenTarget(url.searchParams.get("path") ?? "");
+            const asked = url.searchParams.get("path") ?? "";
+            const relative = await resolveInRoom(hub, url.searchParams.get("room"), asked);
+            const target = classifyOpenTarget(relative ?? asked);
             if (!target || target.kind !== "path")
-                throw new Error("only absolute paths can be viewed");
+                throw new Error("only absolute paths, or a path inside the room's folder, can be viewed");
             const kind = viewerKind(target.value);
-            if (!kind)
-                throw new Error("only Markdown and CSV files can be viewed in the room");
             let info;
             try {
                 info = await stat(target.value);
@@ -147,10 +248,41 @@ export function startServer(hub, port, log, info, onShutdownRequest) {
             }
             if (!info.isFile())
                 throw new Error(`not a file: ${target.value}`);
-            if (info.size > VIEWER_MAX_BYTES)
-                throw new Error(`too big to view here (${Math.round(info.size / 1024)} kB); open it in an editor`);
-            const text = await readFile(target.value, "utf8");
-            sendJson(res, 200, kind === "csv" ? { ok: true, kind, path: target.value, rows: parseCsv(text) } : { ok: true, kind, path: target.value, text });
+            const asNumber = (name) => {
+                const raw = url.searchParams.get(name);
+                if (raw === null || raw === "")
+                    return undefined;
+                const value = Number(raw);
+                if (!Number.isFinite(value))
+                    throw new Error(`${name} must be a line number`);
+                return Math.max(1, Math.floor(value));
+            };
+            const from = asNumber("from");
+            const to = asNumber("to");
+            const language = languageOf(target.value);
+            if (info.size > VIEWER_MAX_BYTES) {
+                if (kind !== "text")
+                    throw new Error(`too big to view here (${Math.round(info.size / 1024)} kB); open it in an editor`);
+                const window = await readLineWindow(target.value, from ?? 1, to);
+                if (window.binary)
+                    throw new Error("not a text file; opening it with the default app instead");
+                sendJson(res, 200, { ok: true, kind, path: target.value, language, text: window.text, from: window.from, to: window.to, lines: window.lines, more: true, bytes: info.size });
+                return;
+            }
+            const buffer = await readFile(target.value);
+            if (looksBinary(buffer.subarray(0, 8192)))
+                throw new Error("not a text file; opening it with the default app instead");
+            const text = buffer.toString("utf8");
+            if (kind === "csv") {
+                sendJson(res, 200, { ok: true, kind, path: target.value, rows: parseCsv(text) });
+                return;
+            }
+            if (kind === "markdown" && from === undefined) {
+                sendJson(res, 200, { ok: true, kind, path: target.value, text, lines: text.split(/\r?\n/).length });
+                return;
+            }
+            const window = sliceLines(text, from, to);
+            sendJson(res, 200, { ok: true, kind, path: target.value, language, ...window, bytes: info.size });
             return;
         }
         const roomFile = req.method === "GET" && path.match(/^\/api\/rooms\/([^/]+)\/files\/([^/]+)$/);
@@ -202,7 +334,7 @@ export function startServer(hub, port, log, info, onShutdownRequest) {
             return;
         }
         if (req.method === "GET" && path === "/api/version") {
-            sendJson(res, 200, info);
+            sendJson(res, 200, { ...info, dataDir: hub.dataDir, pid: process.pid });
             return;
         }
         if (req.method === "GET" && path === "/api/skills") {
@@ -228,6 +360,18 @@ export function startServer(hub, port, log, info, onShutdownRequest) {
             sendJson(res, 200, target.room.describeRoomForAgent(target.participantId));
             return;
         }
+        if (req.method === "GET" && path === "/api/mcp/message") {
+            const target = hub.resolveMcpToken(url.searchParams.get("token") ?? "");
+            if (!target) {
+                sendJson(res, 403, { error: "unknown skills token (the session it belonged to is gone)" });
+                return;
+            }
+            const seq = Number(url.searchParams.get("seq"));
+            if (!Number.isInteger(seq))
+                throw new Error("seq must be the message number, the N of #N");
+            sendJson(res, 200, target.room.readMessageForAgent(target.participantId, seq, Number(url.searchParams.get("around") ?? 0)));
+            return;
+        }
         if (req.method === "GET" && path === "/api/mcp/skill") {
             const target = hub.resolveMcpToken(url.searchParams.get("token") ?? "");
             if (!target) {
@@ -416,6 +560,16 @@ export function startServer(hub, port, log, info, onShutdownRequest) {
             sendJson(res, 200, { ok: true });
             return;
         }
+        if (path === "/api/restart") {
+            if (!onRestartRequest) {
+                sendJson(res, 400, { error: "this hub cannot restart itself" });
+                return;
+            }
+            log.info("restart requested from the window");
+            sendJson(res, 200, { ok: true });
+            setTimeout(onRestartRequest, 50);
+            return;
+        }
         if (path === "/api/shutdown") {
             log.info("shutdown requested over the API");
             sendJson(res, 200, { ok: true });
@@ -465,7 +619,7 @@ export function startServer(hub, port, log, info, onShutdownRequest) {
                     sendJson(res, 200, { ok: true, command: command.name, participant: target.name });
                     return;
                 }
-                const message = room.postHumanMessage(text, imageList(body.images));
+                const message = room.postHumanMessage(text, imageList(body.images), quoteList(body.quotes));
                 sendJson(res, 200, { ok: true, id: message.id });
             }
             else if (action === "template-preview") {
@@ -554,8 +708,10 @@ export function startServer(hub, port, log, info, onShutdownRequest) {
             const room = hub.getRoom(decodeURIComponent(participantAction[1]));
             const id = decodeURIComponent(participantAction[2]);
             const action = participantAction[3];
-            if (action === "cancel")
-                room.cancelTurn(id);
+            if (action === "cancel") {
+                sendJson(res, 200, { ok: true, stopped: room.cancelTurn(id) });
+                return;
+            }
             else if (action === "respawn") {
                 const replay = body.replay === undefined || body.replay === null || body.replay === "" ? undefined : Number(body.replay);
                 await room.respawnAgent(id, { memory: body.memory === true || body.memory === "true", replay: replay !== undefined && Number.isFinite(replay) ? Math.max(0, Math.min(500, Math.round(replay))) : undefined });
@@ -592,14 +748,18 @@ export function startServer(hub, port, log, info, onShutdownRequest) {
             else if (action === "unmute")
                 room.setMuted(id, false);
             else if (action === "persona") {
-                room.updatePersona(id, {
+                const patch = {
                     name: body.name === undefined ? undefined : String(body.name),
                     tagline: body.tagline === undefined ? undefined : String(body.tagline),
                     role: body.role === undefined ? undefined : String(body.role),
                     avatar: body.avatar === undefined ? undefined : String(body.avatar),
                     replyDelay: body.replyDelay === undefined ? undefined : body.replyDelay === null || body.replyDelay === "" ? null : Number(body.replyDelay),
                     skills: stringList(body.skills),
-                });
+                };
+                if (body.restart === true || body.restart === "true")
+                    await room.restartWithPersona(id, patch);
+                else
+                    room.updatePersona(id, patch);
             }
             else
                 await room.setConfig(id, String(body.configId ?? ""), body.value);
@@ -629,6 +789,8 @@ export function startServer(hub, port, log, info, onShutdownRequest) {
                     clearInterval(heartbeat);
                     for (const res of clients)
                         res.end();
+                    for (const peer of sockets)
+                        peer.close(1001, "hub closing");
                     server.close();
                 },
             });
@@ -658,6 +820,68 @@ function imageList(value) {
         return { name: optionalString(image.name) ?? undefined, mimeType: String(image.mimeType ?? ""), data: String(image.data ?? ""), n: Number.isInteger(n) && n > 0 ? n : undefined };
     });
 }
+function inside(child, root) {
+    const [c, r] = process.platform === "linux" ? [child, root] : [child.toLowerCase(), root.toLowerCase()];
+    return c === r || c.startsWith(r.endsWith(sep) ? r : r + sep);
+}
+async function resolveInRoom(hub, roomId, asked) {
+    const text = String(asked ?? "").trim();
+    if (!roomId || !text || isAbsolute(text) || /^[a-z]:[\\/]/i.test(text) || /^[a-z][a-z0-9+.-]*:/i.test(text) || text.startsWith("~"))
+        return null;
+    const room = hub.getRoom(roomId);
+    const dir = room?.dir;
+    if (!dir)
+        return null;
+    const full = resolve(dir, text);
+    const root = resolve(dir);
+    if (!inside(full, root))
+        return null;
+    try {
+        const realFull = await realpath(full);
+        const realRoot = await realpath(root);
+        return inside(realFull, realRoot) ? full : null;
+    }
+    catch {
+        return full;
+    }
+}
+async function readLineWindow(path, from, to) {
+    const end = Math.max(from, Math.min(to ?? from + WINDOW_MAX_LINES - 1, from + WINDOW_MAX_LINES - 1));
+    const stream = createReadStream(path, { encoding: "utf8", highWaterMark: 256 * 1024 });
+    const lines = createInterface({ input: stream, crlfDelay: Infinity });
+    const kept = [];
+    let n = 0;
+    let bytes = 0;
+    let binary = false;
+    try {
+        for await (const line of lines) {
+            n++;
+            bytes += line.length + 1;
+            if (n === 1 && looksBinary(Buffer.from(line.slice(0, 4096), "utf8"))) {
+                binary = true;
+                break;
+            }
+            if (n >= from && n <= end)
+                kept.push(line);
+            if (n >= end || bytes > STREAM_MAX_BYTES)
+                break;
+        }
+    }
+    finally {
+        lines.close();
+        stream.destroy();
+    }
+    return { text: kept.join("\n"), from, to: Math.min(end, n), lines: n, binary };
+}
+function quoteList(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.slice(0, QUOTES_PER_MESSAGE).map((entry) => {
+        const quote = (entry ?? {});
+        const n = Number(quote.n);
+        return { seq: Number(quote.seq), text: String(quote.text ?? ""), n: Number.isInteger(n) && n > 0 ? n : undefined };
+    });
+}
 function sendJson(res, status, body) {
     res.writeHead(status, { "Content-Type": "application/json; charset=utf-8" });
     res.end(JSON.stringify(body));

package/dist/update.js

@@ -1,7 +1,7 @@
 // viberoom - Copyright (c) 2026 Todor Rusev - AGPL-3.0-or-later; see LICENSE
 import { spawn } from "node:child_process";
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+import { existsSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { join, relative } from "node:path";
 import { fileURLToPath } from "node:url";
 export const REGISTRY_URL = "https://registry.npmjs.org/viberoom/latest";
 export const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
@@ -69,6 +69,36 @@ export function runsFromSourceCheckout(mainModuleUrl) {
     const path = decodeURIComponent(new URL(mainModuleUrl).pathname);
     return !/\/node_modules\/viberoom\//.test(path);
 }
+export function newerSourceThanBuild(mainModuleUrl) {
+    if (!runsFromSourceCheckout(mainModuleUrl))
+        return null;
+    const root = fileURLToPath(new URL("../", mainModuleUrl));
+    const src = join(root, "src");
+    if (!existsSync(src))
+        return null;
+    let built;
+    try {
+        built = statSync(fileURLToPath(mainModuleUrl)).mtimeMs;
+    }
+    catch {
+        return null;
+    }
+    let newest = null;
+    const walk = (dir) => {
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+            const path = join(dir, entry.name);
+            if (entry.isDirectory())
+                walk(path);
+            else if (entry.name.endsWith(".ts")) {
+                const mtime = statSync(path).mtimeMs;
+                if (mtime > built + 1000 && (!newest || mtime > newest.mtime))
+                    newest = { path, mtime };
+            }
+        }
+    };
+    walk(src);
+    return newest ? relative(root, newest.path).split("\\").join("/") : null;
+}
 export function installCommandLine(version) {
     if (!parseVersion(version))
         throw new Error(`not a version: ${version}`);

package/dist/viewer.js

@@ -1,9 +1,76 @@
 // viberoom - Copyright (c) 2026 Todor Rusev - AGPL-3.0-or-later; see LICENSE
-import { extname } from "node:path";
+import { extname, basename } from "node:path";
 export const VIEWER_MAX_BYTES = 2 * 1024 * 1024;
+export const WINDOW_MAX_LINES = 500;
+export const STREAM_MAX_BYTES = 64 * 1024 * 1024;
 const KINDS = { ".md": "markdown", ".markdown": "markdown", ".csv": "csv", ".tsv": "csv" };
 export function viewerKind(path) {
-    return KINDS[extname(path).toLowerCase()] ?? null;
+    return KINDS[extname(path).toLowerCase()] ?? "text";
+}
+const LANGUAGES = {
+    ".ts": "typescript", ".mts": "typescript", ".cts": "typescript", ".tsx": "tsx",
+    ".js": "javascript", ".mjs": "javascript", ".cjs": "javascript", ".jsx": "jsx",
+    ".json": "json", ".jsonc": "json", ".json5": "json",
+    ".py": "python", ".rb": "ruby", ".php": "php", ".pl": "perl", ".lua": "lua", ".r": "r",
+    ".rs": "rust", ".go": "go", ".java": "java", ".kt": "kotlin", ".kts": "kotlin", ".swift": "swift",
+    ".c": "c", ".h": "c", ".cpp": "cpp", ".cc": "cpp", ".cxx": "cpp", ".hpp": "cpp", ".hh": "cpp",
+    ".cs": "csharp", ".fs": "fsharp", ".scala": "scala", ".dart": "dart", ".ex": "elixir", ".exs": "elixir",
+    ".sh": "bash", ".bash": "bash", ".zsh": "bash", ".ps1": "powershell", ".psm1": "powershell", ".bat": "batch", ".cmd": "batch",
+    ".sql": "sql", ".graphql": "graphql", ".gql": "graphql", ".proto": "protobuf",
+    ".yaml": "yaml", ".yml": "yaml", ".toml": "toml", ".ini": "ini", ".cfg": "ini", ".conf": "ini", ".env": "bash",
+    ".xml": "xml", ".html": "html", ".htm": "html", ".svg": "xml", ".vue": "html",
+    ".css": "css", ".scss": "scss", ".sass": "scss", ".less": "less",
+    ".diff": "diff", ".patch": "diff",
+};
+const NAMED_FILES = {
+    dockerfile: "docker",
+    makefile: "makefile",
+    ".gitignore": "bash",
+    ".npmrc": "ini",
+    ".editorconfig": "ini",
+};
+export function languageOf(path) {
+    const name = basename(path).toLowerCase();
+    if (NAMED_FILES[name])
+        return NAMED_FILES[name];
+    return LANGUAGES[extname(path).toLowerCase()] || null;
+}
+const IMAGE_MEDIA = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".bmp": "image/bmp",
+    ".avif": "image/avif",
+    ".ico": "image/x-icon",
+    ".svg": "image/svg+xml",
+};
+export const IMAGE_VIEW_MAX_BYTES = 20 * 1024 * 1024;
+export function imageMediaType(path) {
+    return IMAGE_MEDIA[extname(path).toLowerCase()] ?? null;
+}
+export function looksBinary(head) {
+    if (!head.length)
+        return false;
+    let control = 0;
+    for (const byte of head) {
+        if (byte === 0)
+            return true;
+        if (byte < 32 && byte !== 9 && byte !== 10 && byte !== 13 && byte !== 12)
+            control++;
+    }
+    return control / head.length > 0.1;
+}
+export function sliceLines(text, from, to) {
+    const all = text.split(/\r?\n/);
+    if (all.length && all[all.length - 1] === "")
+        all.pop();
+    const lines = all.length;
+    const start = Math.max(1, Math.min(Math.floor(from ?? 1) || 1, Math.max(1, lines)));
+    const wanted = Math.floor(to ?? start + WINDOW_MAX_LINES - 1) || start;
+    const end = Math.max(start, Math.min(wanted, lines, start + WINDOW_MAX_LINES - 1));
+    return { text: all.slice(start - 1, end).join("\n"), from: start, to: end, lines };
 }
 export function detectDelimiter(text) {
     const first = text.split(/\r?\n/, 1)[0] ?? "";