kennel 0.2.44 → 0.2.46

package/dist/core/runtime.js

@@ -17027,8 +17027,8 @@ var require__2020 = __commonJS(function(exports, module) {
 import {
   createServer
 } from "node:http";
-import { readFile as readFile11, realpath as realpath8, stat as stat10 } from "node:fs/promises";
-import { extname as extname7, isAbsolute as isAbsolute8, relative as relative12, resolve as resolve13 } from "node:path";
+import { readFile as readFile12, realpath as realpath10, stat as stat13 } from "node:fs/promises";
+import { extname as extname8, isAbsolute as isAbsolute9, relative as relative14, resolve as resolve17 } from "node:path";
 
 // packages/api/src/server/watcher.ts
 import { existsSync, statSync, watch } from "node:fs";
@@ -21739,6 +21739,7 @@ var plugin = object({
   icon: object({ paths: array(string2().min(1)).min(1) }).optional(),
   id: string2(),
   label: string2(),
+  pages: array(object({ id: string2(), label: string2() })).optional(),
   subpath: string2().optional()
 });
 var plugins = object({
@@ -21795,6 +21796,10 @@ var metadataQuerySchema = object({
   sort: _enum(["alpha", "recent"]).optional(),
   schema: string2().optional()
 });
+var deleteNoteSchema = object({
+  folder: string2(),
+  path: string2()
+});
 var documentEditSchema = object({
   folder: string2(),
   path: string2(),
@@ -21854,7 +21859,11 @@ var routes = {
     path: "/api/health",
     method: "get",
     query: emptyQuery,
-    response: object({ viewer: string2(), root: string2(), kernelKey: string2() })
+    response: object({
+      viewer: string2(),
+      root: string2(),
+      kernelKey: string2()
+    })
   },
   capabilities: {
     path: "/api/capabilities",
@@ -21942,6 +21951,13 @@ var routes = {
     path: "/api/open-path",
     method: "get",
     query: object({ path: string2() })
+  },
+  deleteNote: {
+    path: "/api/delete-note",
+    method: "post",
+    query: emptyQuery,
+    body: deleteNoteSchema,
+    response: object({ deleted: literal(true) })
   }
 };
 
@@ -21993,17 +22009,17 @@ function sendContract(response, url, body, headers = {}) {
 }
 
 // packages/api/src/server/folder-metadata-plugin.ts
-import { realpathSync as realpathSync2 } from "node:fs";
-import { readdir as readdir6, readFile as readFile10, realpath as realpath7, stat as stat9 } from "node:fs/promises";
+import { realpathSync as realpathSync3 } from "node:fs";
+import { readdir as readdir7, readFile as readFile11, realpath as realpath9, stat as stat12 } from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
 import {
-  basename as basename7,
-  dirname as dirname10,
-  extname as extname6,
-  isAbsolute as isAbsolute7,
-  relative as relative11,
-  resolve as resolve12,
-  sep as sep8
+  basename as basename8,
+  dirname as dirname13,
+  extname as extname7,
+  isAbsolute as isAbsolute8,
+  relative as relative13,
+  resolve as resolve16,
+  sep as sep11
 } from "node:path";
 
 // node_modules/.bun/@raggle-ai+barkdown@0.7.1+22117d1132b05fb8/node_modules/@raggle-ai/barkdown/dist/react.js
@@ -36708,7 +36724,11 @@ var run = promisify(execFile);
 var REPOSITORY_ID_KEY = "kennel.repoId";
 var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/u;
 var markdownExtensions = new Set([".md", ".markdown"]);
-var caseInsensitiveHosts = new Set(["github.com", "gitlab.com", "bitbucket.org"]);
+var caseInsensitiveHosts = new Set([
+  "github.com",
+  "gitlab.com",
+  "bitbucket.org"
+]);
 class RepositoryNotesError extends Error {
   code;
   constructor(code, message) {
@@ -36789,7 +36809,12 @@ async function resolveCheckout(folder) {
   }
   let output;
   try {
-    output = await git(["rev-parse", "--path-format=absolute", "--show-toplevel", "--git-common-dir"], start);
+    output = await git([
+      "rev-parse",
+      "--path-format=absolute",
+      "--show-toplevel",
+      "--git-common-dir"
+    ], start);
   } catch (error) {
     if (gitExitCode(error) === 128) {
       throw new RepositoryNotesError("not-git", `Not a Git repository: ${start}. Repository notes need a Git checkout.`);
@@ -37119,23 +37144,55 @@ async function loadEntityWorkspace(root, query, selectedPath, currentWorkspaceRo
   return { entities, query, rootPath, selected };
 }
 
+// packages/api/src/server/api/delete-note.ts
+import { realpath as realpath5, stat as stat5, unlink as unlink2 } from "node:fs/promises";
+import { extname as extname3, isAbsolute as isAbsolute5, relative as relative8, resolve as resolve8, sep as sep5 } from "node:path";
+var markdownExtensions2 = new Set([".md", ".markdown"]);
+var deleteNoteRoute = {
+  method: "POST",
+  maxBodyBytes: 4 * 1024,
+  async handle({ body, context, response }) {
+    const parsed = deleteNoteSchema.safeParse(parseJsonBody(body));
+    if (!parsed.success)
+      throw apiError("bad-request", "Invalid delete request.");
+    const folder = context.authorize(parsed.data.folder);
+    if (!markdownExtensions2.has(extname3(parsed.data.path).toLowerCase()))
+      throw apiError("bad-request", "Only Markdown notes can be deleted.");
+    const target = await containedTarget(parsed.data.path, folder);
+    const details = await stat5(target).catch(() => {
+      return;
+    });
+    if (!details?.isFile() || details.nlink !== 1)
+      throw apiError("forbidden", "Only regular, unlinked files can be deleted.");
+    await unlink2(target);
+    jsonResponse(response, 200, routes.deleteNote.response.parse({ deleted: true }));
+  }
+};
+async function containedTarget(path, folder) {
+  const target = await realpath5(resolve8(folder, path));
+  const local = relative8(folder, target);
+  if (!local || local === ".." || local.startsWith(`..${sep5}`) || isAbsolute5(local))
+    throw apiError("forbidden", "The note must be inside its folder.");
+  return target;
+}
+
 // packages/api/src/server/api/document-edit.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 import {
   readFile as readFile6,
-  realpath as realpath5,
+  realpath as realpath6,
   rename as rename3,
-  stat as stat5,
-  unlink as unlink2,
+  stat as stat6,
+  unlink as unlink3,
   writeFile as writeFile3
 } from "node:fs/promises";
 import {
   dirname as dirname7,
-  extname as extname3,
-  isAbsolute as isAbsolute5,
-  relative as relative8,
-  resolve as resolve8,
-  sep as sep5
+  extname as extname4,
+  isAbsolute as isAbsolute6,
+  relative as relative9,
+  resolve as resolve9,
+  sep as sep6
 } from "node:path";
 
 // packages/api/src/shared/selection.ts
@@ -37151,12 +37208,12 @@ async function editDocument(folder, input) {
   const { path, original, start, end, replacement } = input;
   if (typeof path !== "string" || typeof original !== "string" || typeof replacement !== "string" || typeof start !== "number" || typeof end !== "number")
     throw apiError("bad-request", "Invalid document edit.");
-  if (![".md", ".markdown"].includes(extname3(path).toLowerCase()))
+  if (![".md", ".markdown"].includes(extname4(path).toLowerCase()))
     throw apiError("bad-request", "Only Markdown notes can be edited.");
-  const root = await realpath5(folder);
-  const target = await realpath5(resolve8(root, path));
-  const local = relative8(root, target);
-  if (!local || local === ".." || local.startsWith(`..${sep5}`) || isAbsolute5(local))
+  const root = await realpath6(folder);
+  const target = await realpath6(resolve9(root, path));
+  const local = relative9(root, target);
+  if (!local || local === ".." || local.startsWith(`..${sep6}`) || isAbsolute6(local))
     throw apiError("forbidden", "The document must be inside its folder.");
   let content;
   try {
@@ -37166,12 +37223,12 @@ async function editDocument(folder, input) {
   }
   const previous = pending.get(target) ?? Promise.resolve();
   const operation = previous.catch(() => {}).then(async () => {
-    const details = await stat5(target);
+    const details = await stat6(target);
     if (!details.isFile() || details.nlink !== 1)
       throw apiError("forbidden", "Only regular, unlinked files can be edited.");
     if (await readFile6(target, "utf8") !== original)
       throw apiError("conflict", "This note changed on disk. Close this preview, reload the note, and try again.");
-    const temporary = resolve8(dirname7(target), `.kennel-edit-${randomUUID2()}.tmp`);
+    const temporary = resolve9(dirname7(target), `.kennel-edit-${randomUUID2()}.tmp`);
     try {
       await writeFile3(temporary, content, {
         flag: "wx",
@@ -37181,7 +37238,7 @@ async function editDocument(folder, input) {
         throw apiError("conflict", "This note changed on disk. Reload before applying an edit.");
       await rename3(temporary, target);
     } finally {
-      await unlink2(temporary).catch(() => {});
+      await unlink3(temporary).catch(() => {});
     }
     return content;
   });
@@ -37202,7 +37259,7 @@ var documentEditRoute = {
       throw apiError("bad-request", "Invalid document edit.");
     const input = parsed.data;
     const folder = context.authorize(input.folder);
-    if (context.lockedFile && (typeof input.path !== "string" || await realpath5(resolve8(folder, input.path)) !== context.lockedFile))
+    if (context.lockedFile && (typeof input.path !== "string" || await realpath6(resolve9(folder, input.path)) !== context.lockedFile))
       throw apiError("forbidden", "Only the selected document can be edited.");
     await editDocument(folder, input);
     jsonResponse(response, 200, routes.documentEdit.response.parse({ saved: true }));
@@ -37211,7 +37268,7 @@ var documentEditRoute = {
 
 // packages/api/src/server/api/create-agent-file.ts
 import { writeFile as writeFile4 } from "node:fs/promises";
-import { resolve as resolve9 } from "node:path";
+import { resolve as resolve10 } from "node:path";
 var createAgentFileRoute = {
   method: "POST",
   maxBodyBytes: 0,
@@ -37222,7 +37279,7 @@ var createAgentFileRoute = {
     } catch (error) {
       throw apiError("not-found", error instanceof Error ? error.message : "Folder not found");
     }
-    const target = resolve9(folder, "AGENTS.md");
+    const target = resolve10(folder, "AGENTS.md");
     try {
       await writeFile4(target, "", { flag: "wx" });
     } catch (error) {
@@ -37274,8 +37331,8 @@ async function folderWebsite(folder) {
 
 // packages/api/src/server/folder-icons.ts
 import { createHash as createHash4 } from "node:crypto";
-import { readFile as readFile8, stat as stat6 } from "node:fs/promises";
-import { extname as extname4 } from "node:path";
+import { readFile as readFile8, stat as stat7 } from "node:fs/promises";
+import { extname as extname5 } from "node:path";
 import { discoverFolderIcon } from "@raggle-ai/local";
 var maxIconBytes2 = 4 * 1024 * 1024;
 var iconTypes = new Map([
@@ -37312,8 +37369,8 @@ function iconUrl(folder, hash, mediaType) {
 }
 async function folderIcon(folder, assets, assetFiles, fallback) {
   const icon = discoverFolderIcon(folder);
-  const mediaType = icon ? iconTypes.get(extname4(icon).toLowerCase()) : null;
-  const details = icon && mediaType ? await stat6(icon).catch(() => {
+  const mediaType = icon ? iconTypes.get(extname5(icon).toLowerCase()) : null;
+  const details = icon && mediaType ? await stat7(icon).catch(() => {
     return;
   }) : undefined;
   if (!icon || !mediaType || !details?.size || details.size > maxIconBytes2) {
@@ -37335,10 +37392,10 @@ async function searchIconDataUrl(icon) {
     return;
   if (icon.startsWith("data:"))
     return icon;
-  const mediaType = searchIconTypes.get(extname4(icon).toLowerCase());
+  const mediaType = searchIconTypes.get(extname5(icon).toLowerCase());
   if (!mediaType)
     return;
-  const details = await stat6(icon).catch(() => {
+  const details = await stat7(icon).catch(() => {
     return;
   });
   if (!details?.size || details.size > maxSearchIconBytes)
@@ -37388,19 +37445,457 @@ async function workspaceBreadcrumbIcons(breadcrumbs, assetFiles, assets = {}) {
 
 // packages/api/src/server/plugins.ts
 import { pathToFileURL } from "node:url";
-import { existsSync as existsSync3 } from "node:fs";
-import { mkdir as mkdir3, readFile as readFile9, stat as stat8, writeFile as writeFile5 } from "node:fs/promises";
+import { existsSync as existsSync4 } from "node:fs";
+import { mkdir as mkdir3, readFile as readFile10, stat as stat11, writeFile as writeFile5 } from "node:fs/promises";
+import { dirname as dirname11, resolve as resolve15, sep as sep10 } from "node:path";
+
+// packages/knl/src/server.ts
+import { stat as stat9 } from "node:fs/promises";
+import { join as join5 } from "node:path";
+
+// packages/knl/src/knl.ts
+import { readdir as readdir5, stat as stat8 } from "node:fs/promises";
+import { basename as basename6, dirname as dirname10, relative as relative10, resolve as resolve13, sep as sep8 } from "node:path";
+import * as esbuild from "esbuild";
+
+// packages/knl/src/folder-guard.ts
+import { existsSync as existsSync3, realpathSync as realpathSync2 } from "node:fs";
+import { realpath as realpath7 } from "node:fs/promises";
 import { dirname as dirname8, resolve as resolve11, sep as sep7 } from "node:path";
+import { fileURLToPath } from "node:url";
+var knlHostResolveDir = dirname8(fileURLToPath(import.meta.url));
+var knlHostPackageFolders = (() => {
+  const folders = [];
+  let current = knlHostResolveDir;
+  while (true) {
+    const nodeModules = resolve11(current, "node_modules");
+    if (existsSync3(nodeModules))
+      folders.push(nodeModules);
+    const parent = dirname8(current);
+    if (parent === current)
+      return folders;
+    current = parent;
+  }
+})();
+async function knlRealRoot(owner) {
+  const expected = resolve11(await realpath7(owner), "knl");
+  const real = await realpath7(resolve11(owner, "knl"));
+  if (real !== expected)
+    throw new Error("knl/ must be a folder, not a link to another place.");
+  return real;
+}
+async function knlReadRoots(owner) {
+  const packages = await Promise.all(knlHostPackageFolders.map((folder) => realpath7(folder).catch(() => {
+    return;
+  })));
+  return [
+    await knlRealRoot(owner),
+    ...packages.filter((folder) => Boolean(folder))
+  ];
+}
+function isKnlReadable(file, roots) {
+  let real;
+  try {
+    real = realpathSync2(file);
+  } catch {
+    real = resolve11(file);
+  }
+  return roots.some((root) => real === root || real.startsWith(`${root}${sep7}`));
+}
+function knlReadError(file) {
+  return `KNL pages can only use files in knl/ and installed packages: ${file}`;
+}
+function assertKnlReadable(file, roots) {
+  if (!isKnlReadable(file, roots))
+    throw new Error(knlReadError(file));
+}
+
+// packages/knl/src/tailwind.ts
+import { readFile as readFile9 } from "node:fs/promises";
+import { createRequire as createRequire2 } from "node:module";
+import { dirname as dirname9, resolve as resolve12 } from "node:path";
+import { compile } from "@tailwindcss/node";
+import { Scanner } from "@tailwindcss/oxide";
+var require2 = createRequire2(import.meta.url);
+function starterKnlStyles() {
+  return `@layer theme, utilities;
+@import "tailwindcss/theme.css" layer(theme) prefix(knl);
+@import "tailwindcss/utilities.css" layer(utilities) source(none);
+
+@theme {
+  --font-sans: system-ui, sans-serif;
+}
+`;
+}
+async function compileKnlCss(js, stylesheet, roots) {
+  const base = dirname9(stylesheet);
+  assertKnlReadable(stylesheet, roots);
+  const css = await readFile9(stylesheet, "utf8").catch((error) => {
+    if (error.code === "ENOENT")
+      return starterKnlStyles();
+    throw error;
+  });
+  const compiler = await compile(css, {
+    base,
+    from: stylesheet,
+    onDependency: (path) => assertKnlReadable(path, roots),
+    customJsResolver: async (id) => {
+      throw new Error(`KNL does not load Tailwind plugins or configs (${id}).`);
+    },
+    customCssResolver: async (id) => id === "tailwindcss" || id.startsWith("tailwindcss/") ? require2.resolve(id) : undefined
+  });
+  const sources = [...compiler.sources];
+  if (compiler.root !== "none") {
+    sources.push({
+      ...compiler.root ?? { base, pattern: "**/*" },
+      negated: false
+    });
+  }
+  for (const source of sources) {
+    if (source.negated)
+      continue;
+    const fixed = source.pattern.split("/");
+    const glob = fixed.findIndex((part) => /[*?[{]/.test(part));
+    assertKnlReadable(resolve12(source.base, fixed.slice(0, glob < 0 ? undefined : glob).join("/")), roots);
+  }
+  const scanner = new Scanner({ sources });
+  const candidates = [
+    ...scanner.scan(),
+    ...scanner.scanFiles([{ content: js, extension: "js" }])
+  ];
+  return compiler.build(candidates);
+}
+
+// packages/knl/src/knl.ts
+var KNK_FOLDER = "knl";
+var MAX_SOURCE_BYTES = 512 * 1024;
+var MAX_JS_BYTES = 5 * 1024 * 1024;
+var MODULE_FILES = ["index.tsx", "index.ts"];
+function sourceFor(file, knlRoot, scanRoot, owner) {
+  const id = toModuleId(file, knlRoot);
+  return {
+    id,
+    file,
+    relative: relative10(scanRoot, file).split(sep8).join("/"),
+    folder: dirname10(file),
+    owner
+  };
+}
+function toModuleId(file, knlRoot) {
+  const relativeKnl = relative10(knlRoot, file).split(sep8).join("/");
+  return relativeKnl.replace(/\/?index\.(tsx|ts)$/, "") || "index";
+}
+async function collectKnlSources(scanRoot, owner) {
+  const knlRoot = resolve13(scanRoot, KNK_FOLDER);
+  const knlEntries = await readdir5(knlRoot, { withFileTypes: true }).catch(() => []);
+  const sources = [];
+  const addModule = async (folder) => {
+    for (const candidate of MODULE_FILES) {
+      const file = resolve13(folder, candidate);
+      if (await stat8(file).then((d) => d.isFile()).catch(() => false)) {
+        sources.push(sourceFor(file, knlRoot, scanRoot, owner));
+        return;
+      }
+    }
+  };
+  await addModule(knlRoot);
+  for (const entry of knlEntries) {
+    if (!entry.isDirectory())
+      continue;
+    if (entry.name.startsWith(".") || entry.name === "node_modules")
+      continue;
+    await addModule(resolve13(knlRoot, entry.name));
+  }
+  return sources.sort((left, right) => {
+    const rank = (left.id === "index" ? 0 : 1) - (right.id === "index" ? 0 : 1);
+    return rank !== 0 ? rank : left.id.localeCompare(right.id);
+  });
+}
+async function loadKnlSources(viewRoot, linkedFolders = []) {
+  const sources = [
+    ...await collectKnlSources(viewRoot, viewRoot),
+    ...(await Promise.all(linkedFolders.map(async (folder) => (await collectKnlSources(folder, folder)).map((source) => ({
+      ...source,
+      id: `${basename6(folder)}:${source.id}`,
+      relative: `${basename6(folder)}/${source.relative}`
+    }))))).flat()
+  ];
+  return { sources };
+}
+var MAX_CACHED_MODULES = 200;
+var compileCache = new Map;
+function knlNodePaths(knlRoot) {
+  return [resolve13(knlRoot, "node_modules"), ...knlHostPackageFolders];
+}
+async function compileKnlSource(source) {
+  const sourceBytes = (await stat8(source.file)).size;
+  const tooLarge = (bytes, what) => ({
+    id: source.id,
+    relative: source.relative,
+    js: "",
+    css: "",
+    issues: [
+      {
+        path: source.relative,
+        message: `Module ${what} is too large (${bytes} bytes; limit ${MAX_SOURCE_BYTES}).`
+      }
+    ]
+  });
+  if (sourceBytes > MAX_SOURCE_BYTES)
+    return tooLarge(sourceBytes, "source");
+  const cached = compileCache.get(source.file);
+  const unchanged = cached && (await Promise.all(cached.dependencies.map(async ({ file, mtimeMs }) => (await stat8(file).catch(() => {
+    return;
+  }))?.mtimeMs === mtimeMs))).every(Boolean);
+  const knlRoot = resolve13(source.owner, KNK_FOLDER);
+  let issuePath = source.relative;
+  try {
+    const nodePaths = knlNodePaths(knlRoot);
+    const roots = await knlReadRoots(source.owner);
+    assertKnlReadable(source.file, roots);
+    let js;
+    if (cached && unchanged) {
+      js = cached.js;
+    } else {
+      const result = await esbuild.build({
+        absWorkingDir: source.folder,
+        stdin: {
+          contents: `import { createElement } from "react"
+import { createRoot } from "react-dom/client"
+import Component from ${JSON.stringify(source.file)}
+
+globalThis.__knlMount = (container, context, onError) => {
+  const root = createRoot(container, { onUncaughtError: onError })
+  root.render(createElement(Component, context))
+}
+`,
+          sourcefile: `${source.file}.mount.ts`,
+          loader: "ts",
+          resolveDir: source.folder
+        },
+        bundle: true,
+        format: "iife",
+        target: "es2022",
+        jsx: "automatic",
+        platform: "browser",
+        write: false,
+        minify: false,
+        sourcemap: false,
+        logLevel: "silent",
+        metafile: true,
+        nodePaths,
+        plugins: [readGuard(roots)]
+      });
+      js = result.outputFiles?.[0]?.text ?? "";
+      const files = new Set([
+        resolve13(knlRoot, "package.json"),
+        ...Object.keys(result.metafile.inputs).map((file) => resolve13(source.folder, file)).filter((file) => file !== `${source.file}.mount.ts`)
+      ]);
+      const dependencies = await Promise.all([...files].map(async (file) => ({
+        file,
+        mtimeMs: (await stat8(file).catch(() => {
+          return;
+        }))?.mtimeMs
+      })));
+      compileCache.delete(source.file);
+      compileCache.set(source.file, { js, dependencies });
+      if (compileCache.size > MAX_CACHED_MODULES)
+        compileCache.delete(compileCache.keys().next().value);
+    }
+    const stylesheet = resolve13(knlRoot, "style.css");
+    issuePath = relative10(source.owner, stylesheet).split(sep8).join("/");
+    const css = await compileKnlCss(js, stylesheet, roots);
+    issuePath = source.relative;
+    if (js.length + css.length > MAX_JS_BYTES) {
+      return {
+        id: source.id,
+        relative: source.relative,
+        js: "",
+        css: "",
+        issues: [
+          {
+            path: source.relative,
+            message: `Compiled module is too large (${js.length + css.length} bytes; limit ${MAX_JS_BYTES}).`
+          }
+        ]
+      };
+    }
+    return { id: source.id, relative: source.relative, js, css, issues: [] };
+  } catch (error) {
+    return {
+      id: source.id,
+      relative: source.relative,
+      js: "",
+      css: "",
+      issues: knlBuildIssues(error, issuePath, source)
+    };
+  }
+}
+var guardResolve = Symbol("knl-guard");
+function readGuard(roots) {
+  return {
+    name: "knl-read-guard",
+    setup(build) {
+      build.onResolve({ filter: /.*/ }, async (args) => {
+        if (args.pluginData === guardResolve)
+          return;
+        const resolveFrom = (resolveDir) => build.resolve(args.path, {
+          importer: args.importer,
+          kind: args.kind,
+          pluginData: guardResolve,
+          resolveDir
+        });
+        const readable = (result) => result.namespace !== "file" || !result.path || isKnlReadable(result.path, roots);
+        let result = await resolveFrom(args.resolveDir);
+        const bare = !/^(?:\.{1,2}(?:\/|$)|\/)/.test(args.path);
+        if (bare && result.errors.length === 0 && !readable(result))
+          result = await resolveFrom(knlHostResolveDir);
+        if (result.errors.length > 0)
+          return { errors: result.errors };
+        if (!readable(result))
+          return { errors: [{ text: knlReadError(args.path) }] };
+        return result;
+      });
+    }
+  };
+}
+function knlBuildIssues(error, relativePath, source) {
+  const failures = error?.errors;
+  if (Array.isArray(failures) && failures.length > 0) {
+    const first = failures[0];
+    const file = first?.location?.file ? relative10(source.owner, resolve13(source.folder, first.location.file)).split(sep8).join("/") : relativePath;
+    const location = first?.location ? `${file}:${first.location.line ?? "?"}` : relativePath;
+    return [
+      { path: location, message: first?.text ?? "Module failed to compile." }
+    ];
+  }
+  return [
+    {
+      path: relativePath,
+      message: error instanceof Error && error.message ? error.message : "Module failed to compile."
+    }
+  ];
+}
+function starterKnlSource() {
+  return `// knl/index.tsx — this folder's homepage (KNL folder web framework).
+// Every other page lives in its own folder: knl/<page>/index.tsx.
+import * as React from "react"
+
+export default function Home() {
+  return (
+    <div className="knl:p-4 knl:font-sans">
+      <h1 className="knl:m-0 knl:text-2xl">Home</h1>
+      <p>Edit this file to build the homepage.</p>
+    </div>
+  )
+}
+`;
+}
+
+// packages/knl/src/manifest.ts
+var knlManifest = {
+  id: "knl",
+  label: "KNL"
+};
+
+// packages/knl/src/server.ts
+function createKnlPlugin() {
+  return {
+    ...knlManifest,
+    async detect(context) {
+      const hasKnlFolder = await stat9(join5(context.folder, KNK_FOLDER)).then((entry) => entry.isDirectory()).catch(() => false);
+      if (!hasKnlFolder)
+        return { status: "unavailable" };
+      const { sources } = await loadKnlSources(context.folder, context.linkedFolders ?? []);
+      if (!sources.some((source) => source.id === "index"))
+        return { status: "unavailable" };
+      return {
+        count: sources.length,
+        pages: sources.filter((source) => source.id !== "index" && !source.id.endsWith(":index")).map((source) => ({
+          id: source.id,
+          label: source.id.replaceAll(/[-_]/g, " ").replace(/^./, (letter) => letter.toUpperCase())
+        })),
+        status: "available"
+      };
+    },
+    async handle(context, subpath) {
+      const { sources } = await loadKnlSources(context.folder, context.linkedFolders ?? []);
+      const folder = context.folder;
+      if (sources.length === 0) {
+        return { kind: "available", data: { folder, status: "unavailable" } };
+      }
+      const requested = subpath.trim() || "index";
+      const selected = sources.filter((source) => source.id === requested);
+      if (selected.length === 0) {
+        return {
+          kind: "available",
+          data: {
+            folder,
+            status: "error",
+            message: `KNL page not found: ${requested}`
+          }
+        };
+      }
+      const compiled = await Promise.all(selected.map(compileKnlSource));
+      const entries = compiled.map((result) => {
+        const source = sources.find((item) => item.id === result.id);
+        return {
+          id: result.id,
+          relative: result.relative,
+          ...result.js ? { js: result.js } : {},
+          css: result.css,
+          ...result.issues.length > 0 ? { issues: result.issues } : {},
+          owner: source?.owner ?? folder
+        };
+      });
+      const failing = entries.filter((entry) => entry.issues?.length);
+      if (failing.length > 0) {
+        return {
+          kind: "available",
+          data: {
+            folder,
+            status: "error",
+            entries,
+            issues: failing[0]?.issues
+          }
+        };
+      }
+      return {
+        kind: "available",
+        data: {
+          folder,
+          status: "available",
+          entries
+        }
+      };
+    },
+    async init() {
+      return {
+        files: [
+          { path: "knl/index.tsx", content: starterKnlSource() },
+          { path: "knl/style.css", content: starterKnlStyles() },
+          {
+            path: "knl/package.json",
+            content: `${JSON.stringify({ private: true, type: "module" }, null, 2)}
+`
+          },
+          { path: "knl/.gitignore", content: `node_modules/
+` }
+        ]
+      };
+    }
+  };
+}
 
 // packages/notes/src/server.ts
-import { readdir as readdir5, realpath as realpath6, stat as stat7 } from "node:fs/promises";
+import { readdir as readdir6, realpath as realpath8, stat as stat10 } from "node:fs/promises";
 import {
-  basename as basename6,
-  extname as extname5,
-  isAbsolute as isAbsolute6,
-  relative as relative9,
-  resolve as resolve10,
-  sep as sep6
+  basename as basename7,
+  extname as extname6,
+  isAbsolute as isAbsolute7,
+  relative as relative11,
+  resolve as resolve14,
+  sep as sep9
 } from "node:path";
 
 // packages/notes/src/manifest.ts
@@ -37417,40 +37912,40 @@ var notesManifest = {
 };
 
 // packages/notes/src/server.ts
-var markdownExtensions2 = new Set([".md", ".markdown"]);
+var markdownExtensions3 = new Set([".md", ".markdown"]);
 var llmNoteLimit = 20;
 async function listMarkdownFiles(folder) {
   const files = [];
   const visit = async (current) => {
-    const entries = await readdir5(current, { withFileTypes: true }).catch(() => []);
+    const entries = await readdir6(current, { withFileTypes: true }).catch(() => []);
     for (const entry of entries) {
       if (entry.name === "node_modules" || entry.name.startsWith("."))
         continue;
-      const path = resolve10(current, entry.name);
+      const path = resolve14(current, entry.name);
       if (entry.isDirectory()) {
         await visit(path);
         continue;
       }
-      if (!entry.isFile() || !markdownExtensions2.has(extname5(entry.name))) {
+      if (!entry.isFile() || !markdownExtensions3.has(extname6(entry.name))) {
         continue;
       }
-      const details = await stat7(path).catch(() => {
+      const details = await stat10(path).catch(() => {
         return;
       });
       files.push({
         activityAt: details?.mtimeMs ?? 0,
-        name: basename6(entry.name, extname5(entry.name)),
-        relativePath: relative9(folder, path).split(sep6).join("/")
+        name: basename7(entry.name, extname6(entry.name)),
+        relativePath: relative11(folder, path).split(sep9).join("/")
       });
     }
   };
   await visit(folder);
   return files.sort((left, right) => right.activityAt - left.activityAt);
 }
-var canonical = (path) => realpath6(path).catch(() => path);
+var canonical = (path) => realpath8(path).catch(() => path);
 function inside5(path, root) {
-  const local = relative9(root, path);
-  return local === "" || !local.startsWith("..") && !isAbsolute6(local);
+  const local = relative11(root, path);
+  return local === "" || !local.startsWith("..") && !isAbsolute7(local);
 }
 async function withoutManaged(groups, managedRoots) {
   if (!managedRoots.length)
@@ -37461,7 +37956,7 @@ async function withoutManaged(groups, managedRoots) {
       return { ...group, files: [] };
     }
     const files = await Promise.all(group.files.map(async (file) => {
-      const real = await canonical(resolve10(group.folder, file.relativePath));
+      const real = await canonical(resolve14(group.folder, file.relativePath));
       return roots.some((root) => inside5(real, root)) ? undefined : file;
     }));
     return { ...group, files: files.filter((file) => file !== undefined) };
@@ -37511,7 +38006,7 @@ async function notesLlmSections({
       continue;
     seen.add(identity);
     const files = await listMarkdownFiles(source);
-    const paths = files.map((file) => resolve10(source, file.relativePath));
+    const paths = files.map((file) => resolve14(source, file.relativePath));
     groups.push({ folder: source, paths });
     files.forEach((file, index) => notes.push({ activityAt: file.activityAt, path: paths[index] }));
   }
@@ -37583,14 +38078,14 @@ function parsePluginRegistryConfig(content) {
   };
 }
 async function nearestKennelConfig(folder) {
-  for (let current = folder;; current = dirname8(current)) {
-    const candidate = resolve11(current, "kennel.json");
-    const details = await stat8(candidate).catch(() => {
+  for (let current = folder;; current = dirname11(current)) {
+    const candidate = resolve15(current, "kennel.json");
+    const details = await stat11(candidate).catch(() => {
       return;
     });
     if (details?.isFile())
       return candidate;
-    if (dirname8(current) === current)
+    if (dirname11(current) === current)
       return;
   }
 }
@@ -37599,13 +38094,13 @@ async function folderPluginRegistryConfig(folder) {
   if (!path)
     return defaultPluginRegistryConfig;
   try {
-    return parsePluginRegistryConfig(await readFile9(path, "utf8"));
+    return parsePluginRegistryConfig(await readFile10(path, "utf8"));
   } catch {
     return defaultPluginRegistryConfig;
   }
 }
 function createFolderServerPlugins() {
-  return [createNotesPlugin()];
+  return [createNotesPlugin(), createKnlPlugin()];
 }
 function folderServerRegistry() {
   return new Map(createFolderServerPlugins().map((plugin) => [plugin.id, plugin]));
@@ -37647,7 +38142,7 @@ async function folderServerRegistryAsync() {
       ...server,
       async detect(context) {
         const detection = await server.detect(context);
-        if (detection.status === "unavailable" && existsSync3(resolve11(context.folder, entry.trigger))) {
+        if (detection.status === "unavailable" && existsSync4(resolve15(context.folder, entry.trigger))) {
           return { status: "available" };
         }
         return detection;
@@ -37690,10 +38185,10 @@ import { execFile as execFile4 } from "node:child_process";
 
 // packages/api/src/server/linked-folder-discovery.ts
 import { execFile as execFile3 } from "node:child_process";
-import { existsSync as existsSync4 } from "node:fs";
-import { createRequire as createRequire2 } from "node:module";
-import { dirname as dirname9, join as join5 } from "node:path";
-import { fileURLToPath } from "node:url";
+import { existsSync as existsSync5 } from "node:fs";
+import { createRequire as createRequire3 } from "node:module";
+import { dirname as dirname12, join as join6 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 var script = `
 const local = require(process.argv[1]);
 const { stat } = require('node:fs/promises');
@@ -37710,24 +38205,24 @@ const { stat } = require('node:fs/promises');
 })().catch(error => { console.error(error); process.exitCode = 1; });
 `;
 function resolveLocalModule(from = import.meta.url) {
-  const require2 = createRequire2(from);
+  const require2 = createRequire3(from);
   const candidates = [];
   try {
     candidates.push(require2.resolve("@raggle-ai/local"));
   } catch {}
-  let directory = dirname9(fileURLToPath(from));
-  while (dirname9(directory) !== directory) {
-    if (existsSync4(join5(directory, "raggle.json"))) {
+  let directory = dirname12(fileURLToPath2(from));
+  while (dirname12(directory) !== directory) {
+    if (existsSync5(join6(directory, "raggle.json"))) {
       for (const candidate of [
-        join5(dirname9(directory), "raggle-ai-scout", "packages", "local"),
-        join5(directory, "..", "..", "raggle-ai-scout", "packages", "local")
+        join6(dirname12(directory), "raggle-ai-scout", "packages", "local"),
+        join6(directory, "..", "..", "raggle-ai-scout", "packages", "local")
       ]) {
         if (!candidates.includes(candidate))
           candidates.push(candidate);
       }
       break;
     }
-    directory = dirname9(directory);
+    directory = dirname12(directory);
   }
   for (const candidate of candidates) {
     try {
@@ -37736,7 +38231,7 @@ function resolveLocalModule(from = import.meta.url) {
         return candidate;
     } catch {}
   }
-  return candidates[0] ?? join5(dirname9(fileURLToPath(from)), "..", "..", "..", "raggle-ai-scout", "packages", "local");
+  return candidates[0] ?? join6(dirname12(fileURLToPath2(from)), "..", "..", "..", "raggle-ai-scout", "packages", "local");
 }
 function discoverLinkedFolders(folder, signal, modulePath = resolveLocalModule()) {
   return new Promise((resolve, reject) => {
@@ -38088,13 +38583,13 @@ var metadataExtensions = new Set([
   ".txt"
 ]);
 function metadataFile(path, root) {
-  const candidate = relative11(root, path);
-  if (!candidate || candidate.startsWith("..") || isAbsolute7(candidate))
+  const candidate = relative13(root, path);
+  if (!candidate || candidate.startsWith("..") || isAbsolute8(candidate))
     return false;
-  const parts = candidate.split(sep8);
+  const parts = candidate.split(sep11);
   if (parts.some((part) => part === "node_modules"))
     return false;
-  return metadataExtensions.has(extname6(candidate).toLowerCase());
+  return metadataExtensions.has(extname7(candidate).toLowerCase());
 }
 async function configuredAiInputModule(folder) {
   const config = folderWorkspace(folder).config;
@@ -38102,11 +38597,11 @@ async function configuredAiInputModule(folder) {
   return typeof module === "string" && module.trim() ? module.trim() : null;
 }
 function folderPath(value, root, lockedRoot) {
-  const folder = realpathSync2(resolve12(value ?? root));
+  const folder = realpathSync3(resolve16(value ?? root));
   if (!lockedRoot)
     return folder;
-  const path = relative11(lockedRoot, folder);
-  if (!path || !path.startsWith("..") && !isAbsolute7(path))
+  const path = relative13(lockedRoot, folder);
+  if (!path || !path.startsWith("..") && !isAbsolute8(path))
     return folder;
   throw new Error(`Folder is outside the viewer root: ${folder}`);
 }
@@ -38177,15 +38672,15 @@ function unique(values) {
   return [...new Set(values)];
 }
 function isMachineRoot(folder) {
-  return folder === homedir4() || dirname10(folder) === folder;
+  return folder === homedir4() || dirname13(folder) === folder;
 }
 async function shallowMetadata(folder) {
-  const entries = await readdir6(folder, { withFileTypes: true });
+  const entries = await readdir7(folder, { withFileTypes: true });
   const visible = entries.filter((entry) => !entry.name.startsWith(".") && entry.name !== "node_modules");
-  const files = await Promise.all(visible.filter((entry) => entry.isFile() && [".markdown", ".md"].includes(extname6(entry.name).toLowerCase())).map(async (entry) => {
-    const path = resolve12(folder, entry.name);
-    const details = await stat9(path);
-    const content = await readFile10(path, "utf8").catch(() => "");
+  const files = await Promise.all(visible.filter((entry) => entry.isFile() && [".markdown", ".md"].includes(extname7(entry.name).toLowerCase())).map(async (entry) => {
+    const path = resolve16(folder, entry.name);
+    const details = await stat12(path);
+    const content = await readFile11(path, "utf8").catch(() => "");
     const title = markdownMetadata(content).title;
     return {
       activityAt: details.mtimeMs,
@@ -38198,10 +38693,10 @@ async function shallowMetadata(folder) {
     };
   }));
   const projects = visible.filter((entry) => entry.isDirectory()).map((entry) => ({
-    id: createHash5("sha1").update(resolve12(folder, entry.name)).digest("hex"),
+    id: createHash5("sha1").update(resolve16(folder, entry.name)).digest("hex"),
     name: entry.name,
     relativePath: entry.name,
-    worktree: resolve12(folder, entry.name)
+    worktree: resolve16(folder, entry.name)
   })).sort((left, right) => left.name.localeCompare(right.name));
   return {
     changes: { items: [] },
@@ -38227,8 +38722,8 @@ async function loadFolderData(folder) {
       items: projects.map((project) => ({
         id: project.id,
         worktree: project.worktree,
-        name: project.name ?? basename7(project.worktree),
-        relativePath: relative11(folder, project.worktree)
+        name: project.name ?? basename8(project.worktree),
+        relativePath: relative13(folder, project.worktree)
       }))
     }
   };
@@ -38236,10 +38731,10 @@ async function loadFolderData(folder) {
 async function notesFiles(folder, files, origin) {
   return {
     items: await Promise.all(files.map(async (file) => {
-      const path = file.path ?? (file.relativePath ? resolve12(folder, file.relativePath) : undefined);
+      const path = file.path ?? (file.relativePath ? resolve16(folder, file.relativePath) : undefined);
       if (!path)
         return origin ? { ...file, folder: origin } : file;
-      const content = [".markdown", ".md"].includes(extname6(path).toLowerCase()) ? await readFile10(path, "utf8").catch(() => "") : "";
+      const content = [".markdown", ".md"].includes(extname7(path).toLowerCase()) ? await readFile11(path, "utf8").catch(() => "") : "";
       const title = content ? markdownMetadata(content).title : undefined;
       return {
         ...file,
@@ -38253,7 +38748,7 @@ async function notesFiles(folder, files, origin) {
 async function managedNotesFiles(directory) {
   const notes = await listManagedNotes(directory);
   return Promise.all(notes.map(async (note) => {
-    const content = await readFile10(note.path, "utf8").catch(() => "");
+    const content = await readFile11(note.path, "utf8").catch(() => "");
     const title = content ? markdownMetadata(content).title : undefined;
     return {
       ...note,
@@ -38263,10 +38758,10 @@ async function managedNotesFiles(directory) {
     };
   }));
 }
-var canonicalPath = (path) => realpath7(path).catch(() => path);
+var canonicalPath = (path) => realpath9(path).catch(() => path);
 function insideFolder(path, root) {
-  const local = relative11(root, path);
-  return local === "" || !local.startsWith("..") && !isAbsolute7(local);
+  const local = relative13(root, path);
+  return local === "" || !local.startsWith("..") && !isAbsolute8(local);
 }
 async function withoutManagedFiles(items, managedRoot) {
   if (!managedRoot)
@@ -38297,16 +38792,16 @@ async function localProjectSearchCache(cache) {
 function mediaTarget(folder, file, lockedTarget) {
   if (!file)
     return;
-  const rootReal = realpathSync2(resolve12(folder));
-  const path = resolve12(folder, file);
+  const rootReal = realpathSync3(resolve16(folder));
+  const path = resolve16(folder, file);
   let pathReal;
   try {
-    pathReal = realpathSync2(path);
+    pathReal = realpathSync3(path);
   } catch {
     return;
   }
-  const rel = relative11(rootReal, pathReal);
-  if (rel.startsWith("..") || isAbsolute7(rel))
+  const rel = relative13(rootReal, pathReal);
+  if (rel.startsWith("..") || isAbsolute8(rel))
     return;
   if (lockedTarget && pathReal !== lockedTarget)
     return;
@@ -38345,16 +38840,16 @@ function documentError(response) {
 function documentTarget(folder, file, lockedTarget) {
   if (!file)
     return;
-  const rootReal = realpathSync2(resolve12(folder));
-  const path = resolve12(folder, file);
+  const rootReal = realpathSync3(resolve16(folder));
+  const path = resolve16(folder, file);
   let pathReal;
   try {
-    pathReal = realpathSync2(path);
+    pathReal = realpathSync3(path);
   } catch {
     return;
   }
-  const rel = relative11(rootReal, pathReal);
-  if (rel.startsWith("..") || isAbsolute7(rel))
+  const rel = relative13(rootReal, pathReal);
+  if (rel.startsWith("..") || isAbsolute8(rel))
     return;
   if (lockedTarget && pathReal !== lockedTarget)
     return;
@@ -38411,7 +38906,8 @@ async function pluginAvailability(registry, folder, linkedFolders, configWarning
           error,
           icon: plugin.icon,
           id: plugin.id,
-          label: plugin.label
+          label: plugin.label,
+          ...detection.status === "available" && detection.pages ? { pages: detection.pages } : {}
         });
       }
     } catch {}
@@ -38426,8 +38922,8 @@ function createFolderApi({
   remoteAccess = false,
   lockedFile
 }) {
-  let lockedRoot = restrictToRoot ? realpathSync2(root) : undefined;
-  const lockedTarget = lockedFile ? realpathSync2(lockedFile) : undefined;
+  let lockedRoot = restrictToRoot ? realpathSync3(root) : undefined;
+  const lockedTarget = lockedFile ? realpathSync3(lockedFile) : undefined;
   let basePlugins;
   let baseExternalApiHandlers;
   const assetFiles = new Map;
@@ -38465,7 +38961,7 @@ function createFolderApi({
       const serverHost = server.host;
       const remote = remoteAccess || serverHost === true || typeof serverHost === "string" && !isLoopbackServerHost(serverHost);
       if (remote)
-        lockedRoot = lockedRoot ?? realpathSync2(root);
+        lockedRoot = lockedRoot ?? realpathSync3(root);
       const collectionServer = createSchemaCollectionServer(server, {
         boundary: lockedRoot,
         lockedTarget
@@ -38491,7 +38987,7 @@ function createFolderApi({
         if (!folder)
           return;
         server.emit({
-          data: { path: relative11(folder, path) },
+          data: { path: relative13(folder, path) },
           event: "kennel:metadata-changed",
           type: "custom"
         });
@@ -38574,7 +39070,7 @@ function createFolderApi({
               "Content-Type": asset.mediaType,
               ETag: `"${hash}"`
             });
-            response.end(await readFile10(asset.path));
+            response.end(await readFile11(asset.path));
           } catch (error) {
             response.writeHead(404, {
               "Content-Type": "text/plain; charset=utf-8"
@@ -38646,14 +39142,14 @@ function createFolderApi({
         }
         if (url.pathname === "/api/documents") {
           const folder = folderPath(url.searchParams.get("path"), root, lockedRoot);
-          const target = lockedTarget ? documentTarget(folder, relative11(folder, lockedTarget), lockedTarget) : undefined;
+          const target = lockedTarget ? documentTarget(folder, relative13(folder, lockedTarget), lockedTarget) : undefined;
           const dataset = lockedTarget ? {
             root: folder,
             documents: target ? [
               {
-                path: relative11(folder, target.path),
+                path: relative13(folder, target.path),
                 kind: target.kind,
-                content: previewTextKind(target.kind) ? await readFile10(target.path, "utf8") : ""
+                content: previewTextKind(target.kind) ? await readFile11(target.path, "utf8") : ""
               }
             ] : []
           } : await readFolder(folder);
@@ -38669,7 +39165,7 @@ function createFolderApi({
               documentError(response);
               return;
             }
-            const details = await stat9(target.path);
+            const details = await stat12(target.path);
             if (!details.isFile()) {
               documentError(response);
               return;
@@ -38681,16 +39177,16 @@ function createFolderApi({
               return;
             }
             watch(folder);
-            const content = previewTextKind(target.kind) ? await readFile10(target.path, "utf8") : "";
+            const content = previewTextKind(target.kind) ? await readFile11(target.path, "utf8") : "";
             sendContract(response, url, {
               content,
               kind: target.kind,
-              path: relative11(target.root, target.path),
+              path: relative13(target.root, target.path),
               root: folder,
               ...previewTextKind(target.kind) ? {} : {
                 rawUrl: `/api/raw?${new URLSearchParams({
                   path: folder,
-                  file: relative11(target.root, target.path)
+                  file: relative13(target.root, target.path)
                 })}`
               }
             }, {
@@ -38710,7 +39206,7 @@ function createFolderApi({
               documentError(response);
               return;
             }
-            const details = await stat9(target.path);
+            const details = await stat12(target.path);
             if (!details.isFile()) {
               documentError(response);
               return;
@@ -38731,10 +39227,10 @@ function createFolderApi({
               ETag: etag,
               "X-Content-Type-Options": "nosniff",
               ...download ? {
-                "Content-Disposition": `attachment; filename="${basename7(target.path)}"`
+                "Content-Disposition": `attachment; filename="${basename8(target.path)}"`
               } : {}
             });
-            response.end(await readFile10(target.path));
+            response.end(await readFile11(target.path));
           } catch (error) {
             documentError(response);
           }
@@ -38748,7 +39244,7 @@ function createFolderApi({
               documentError(response);
               return;
             }
-            const details = await stat9(target.path);
+            const details = await stat12(target.path);
             if (!details.isFile()) {
               documentError(response);
               return;
@@ -38760,7 +39256,7 @@ function createFolderApi({
               return;
             }
             watch(folder);
-            const data = await readFile10(target.path);
+            const data = await readFile11(target.path);
             const baseHeaders = {
               "Accept-Ranges": "bytes",
               "Cache-Control": "private, max-age=0, must-revalidate",
@@ -38869,6 +39365,19 @@ function createFolderApi({
           }))
             return;
         }
+        if (url.pathname === "/api/delete-note") {
+          if (remote) {
+            response.writeHead(403, {
+              "Content-Type": "text/plain; charset=utf-8"
+            });
+            response.end("Host actions are disabled for remote access");
+            return;
+          }
+          await runApiRoute(request, response, url, deleteNoteRoute, {
+            authorize: (folder) => folderPath(folder, root, lockedRoot)
+          });
+          return;
+        }
         if (url.pathname === "/api/create-agent-file") {
           if (remote) {
             response.writeHead(403, {
@@ -38923,7 +39432,7 @@ function createFolderApi({
             workspace.breadcrumbs = await workspaceBreadcrumbIcons(workspace.breadcrumbs ?? [], assetFiles);
             const files = [
               workspace.configPath,
-              resolve12(workspace.root, "raggle.json")
+              resolve16(workspace.root, "raggle.json")
             ].filter((path) => Boolean(path));
             for (const path of files)
               contexts.add(path);
@@ -39082,36 +39591,36 @@ var contentTypes = {
   ".ttf": "font/ttf"
 };
 async function sendFile(request, response, directory, pathname, fallback) {
-  const root = await realpath8(directory);
+  const root = await realpath10(directory);
   const inside = (path) => {
-    const local = relative12(root, path);
-    return local !== ".." && !local.startsWith("../") && !isAbsolute8(local);
+    const local = relative14(root, path);
+    return local !== ".." && !local.startsWith("../") && !isAbsolute9(local);
   };
-  let target = resolve13(root, `.${decodeURIComponent(pathname)}`);
+  let target = resolve17(root, `.${decodeURIComponent(pathname)}`);
   if (!inside(target)) {
     response.writeHead(403);
     response.end();
     return;
   }
-  if (!(await stat10(target).catch(() => null))?.isFile()) {
+  if (!(await stat13(target).catch(() => null))?.isFile()) {
     if (!fallback) {
       response.writeHead(404);
       response.end();
       return;
     }
-    target = resolve13(root, fallback);
+    target = resolve17(root, fallback);
   }
-  target = await realpath8(target);
+  target = await realpath10(target);
   if (!inside(target)) {
     response.writeHead(403);
     response.end();
     return;
   }
   response.writeHead(200, {
-    "Content-Type": contentTypes[extname7(target)] ?? "application/octet-stream",
+    "Content-Type": contentTypes[extname8(target)] ?? "application/octet-stream",
     "X-Content-Type-Options": "nosniff"
   });
-  response.end(request.method === "HEAD" ? undefined : await readFile11(target));
+  response.end(request.method === "HEAD" ? undefined : await readFile12(target));
 }
 function createKennelApi(options) {
   const remote = options.remoteAccess || !isLoopbackServerHost(options.host);