kennel 0.2.43 → 0.2.45

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 realpath9, stat as stat12 } from "node:fs/promises";
+import { extname as extname7, isAbsolute as isAbsolute8, relative as relative13, resolve as resolve16 } 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({
@@ -21993,17 +21994,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 realpath8, stat as stat11 } from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
 import {
-  basename as basename7,
-  dirname as dirname10,
+  basename as basename8,
+  dirname as dirname13,
   extname as extname6,
   isAbsolute as isAbsolute7,
-  relative as relative11,
-  resolve as resolve12,
-  sep as sep8
+  relative as relative12,
+  resolve as resolve15,
+  sep as sep10
 } from "node:path";
 
 // node_modules/.bun/@raggle-ai+barkdown@0.7.1+22117d1132b05fb8/node_modules/@raggle-ai/barkdown/dist/react.js
@@ -36708,7 +36709,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 +36794,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.`);
@@ -37388,19 +37398,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 { dirname as dirname8, resolve as resolve11, sep as sep7 } from "node:path";
+import { existsSync as existsSync4 } from "node:fs";
+import { mkdir as mkdir3, readFile as readFile10, stat as stat10, writeFile as writeFile5 } from "node:fs/promises";
+import { dirname as dirname11, resolve as resolve14, sep as sep9 } from "node:path";
+
+// packages/knl/src/server.ts
+import { stat as stat8 } from "node:fs/promises";
+import { join as join5 } from "node:path";
+
+// packages/knl/src/knl.ts
+import { readdir as readdir5, stat as stat7 } from "node:fs/promises";
+import { basename as basename6, dirname as dirname10, relative as relative9, resolve as resolve12, sep as sep7 } 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 realpath6 } from "node:fs/promises";
+import { dirname as dirname8, resolve as resolve10, sep as sep6 } 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 = resolve10(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 = resolve10(await realpath6(owner), "knl");
+  const real = await realpath6(resolve10(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) => realpath6(folder).catch(() => {
+    return;
+  })));
+  return [
+    await knlRealRoot(owner),
+    ...packages.filter((folder) => Boolean(folder))
+  ];
+}
+function isKnlReadable(file, roots) {
+  let real;
+  try {
+    real = realpathSync2(file);
+  } catch {
+    real = resolve10(file);
+  }
+  return roots.some((root) => real === root || real.startsWith(`${root}${sep6}`));
+}
+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 resolve11 } 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(resolve11(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: relative9(scanRoot, file).split(sep7).join("/"),
+    folder: dirname10(file),
+    owner
+  };
+}
+function toModuleId(file, knlRoot) {
+  const relativeKnl = relative9(knlRoot, file).split(sep7).join("/");
+  return relativeKnl.replace(/\/?index\.(tsx|ts)$/, "") || "index";
+}
+async function collectKnlSources(scanRoot, owner) {
+  const knlRoot = resolve12(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 = resolve12(folder, candidate);
+      if (await stat7(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(resolve12(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 [resolve12(knlRoot, "node_modules"), ...knlHostPackageFolders];
+}
+async function compileKnlSource(source) {
+  const sourceBytes = (await stat7(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 stat7(file).catch(() => {
+    return;
+  }))?.mtimeMs === mtimeMs))).every(Boolean);
+  const knlRoot = resolve12(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([
+        resolve12(knlRoot, "package.json"),
+        ...Object.keys(result.metafile.inputs).map((file) => resolve12(source.folder, file)).filter((file) => file !== `${source.file}.mount.ts`)
+      ]);
+      const dependencies = await Promise.all([...files].map(async (file) => ({
+        file,
+        mtimeMs: (await stat7(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 = resolve12(knlRoot, "style.css");
+    issuePath = relative9(source.owner, stylesheet).split(sep7).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 ? relative9(source.owner, resolve12(source.folder, first.location.file)).split(sep7).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 stat8(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 realpath7, stat as stat9 } from "node:fs/promises";
 import {
-  basename as basename6,
+  basename as basename7,
   extname as extname5,
   isAbsolute as isAbsolute6,
-  relative as relative9,
-  resolve as resolve10,
-  sep as sep6
+  relative as relative10,
+  resolve as resolve13,
+  sep as sep8
 } from "node:path";
 
 // packages/notes/src/manifest.ts
@@ -37422,11 +37870,11 @@ 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 = resolve13(current, entry.name);
       if (entry.isDirectory()) {
         await visit(path);
         continue;
@@ -37434,22 +37882,22 @@ async function listMarkdownFiles(folder) {
       if (!entry.isFile() || !markdownExtensions2.has(extname5(entry.name))) {
         continue;
       }
-      const details = await stat7(path).catch(() => {
+      const details = await stat9(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, extname5(entry.name)),
+        relativePath: relative10(folder, path).split(sep8).join("/")
       });
     }
   };
   await visit(folder);
   return files.sort((left, right) => right.activityAt - left.activityAt);
 }
-var canonical = (path) => realpath6(path).catch(() => path);
+var canonical = (path) => realpath7(path).catch(() => path);
 function inside5(path, root) {
-  const local = relative9(root, path);
+  const local = relative10(root, path);
   return local === "" || !local.startsWith("..") && !isAbsolute6(local);
 }
 async function withoutManaged(groups, managedRoots) {
@@ -37461,7 +37909,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(resolve13(group.folder, file.relativePath));
       return roots.some((root) => inside5(real, root)) ? undefined : file;
     }));
     return { ...group, files: files.filter((file) => file !== undefined) };
@@ -37511,7 +37959,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) => resolve13(source, file.relativePath));
     groups.push({ folder: source, paths });
     files.forEach((file, index) => notes.push({ activityAt: file.activityAt, path: paths[index] }));
   }
@@ -37583,14 +38031,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 = resolve14(current, "kennel.json");
+    const details = await stat10(candidate).catch(() => {
       return;
     });
     if (details?.isFile())
       return candidate;
-    if (dirname8(current) === current)
+    if (dirname11(current) === current)
       return;
   }
 }
@@ -37599,13 +38047,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 +38095,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(resolve14(context.folder, entry.trigger))) {
           return { status: "available" };
         }
         return detection;
@@ -37690,10 +38138,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 +38158,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 +38184,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,10 +38536,10 @@ var metadataExtensions = new Set([
   ".txt"
 ]);
 function metadataFile(path, root) {
-  const candidate = relative11(root, path);
+  const candidate = relative12(root, path);
   if (!candidate || candidate.startsWith("..") || isAbsolute7(candidate))
     return false;
-  const parts = candidate.split(sep8);
+  const parts = candidate.split(sep10);
   if (parts.some((part) => part === "node_modules"))
     return false;
   return metadataExtensions.has(extname6(candidate).toLowerCase());
@@ -38102,10 +38550,10 @@ 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(resolve15(value ?? root));
   if (!lockedRoot)
     return folder;
-  const path = relative11(lockedRoot, folder);
+  const path = relative12(lockedRoot, folder);
   if (!path || !path.startsWith("..") && !isAbsolute7(path))
     return folder;
   throw new Error(`Folder is outside the viewer root: ${folder}`);
@@ -38177,15 +38625,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 path = resolve15(folder, entry.name);
+    const details = await stat11(path);
+    const content = await readFile11(path, "utf8").catch(() => "");
     const title = markdownMetadata(content).title;
     return {
       activityAt: details.mtimeMs,
@@ -38198,10 +38646,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(resolve15(folder, entry.name)).digest("hex"),
     name: entry.name,
     relativePath: entry.name,
-    worktree: resolve12(folder, entry.name)
+    worktree: resolve15(folder, entry.name)
   })).sort((left, right) => left.name.localeCompare(right.name));
   return {
     changes: { items: [] },
@@ -38227,8 +38675,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: relative12(folder, project.worktree)
       }))
     }
   };
@@ -38236,10 +38684,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 ? resolve15(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(extname6(path).toLowerCase()) ? await readFile11(path, "utf8").catch(() => "") : "";
       const title = content ? markdownMetadata(content).title : undefined;
       return {
         ...file,
@@ -38253,7 +38701,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,9 +38711,9 @@ async function managedNotesFiles(directory) {
     };
   }));
 }
-var canonicalPath = (path) => realpath7(path).catch(() => path);
+var canonicalPath = (path) => realpath8(path).catch(() => path);
 function insideFolder(path, root) {
-  const local = relative11(root, path);
+  const local = relative12(root, path);
   return local === "" || !local.startsWith("..") && !isAbsolute7(local);
 }
 async function withoutManagedFiles(items, managedRoot) {
@@ -38297,15 +38745,15 @@ 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(resolve15(folder));
+  const path = resolve15(folder, file);
   let pathReal;
   try {
-    pathReal = realpathSync2(path);
+    pathReal = realpathSync3(path);
   } catch {
     return;
   }
-  const rel = relative11(rootReal, pathReal);
+  const rel = relative12(rootReal, pathReal);
   if (rel.startsWith("..") || isAbsolute7(rel))
     return;
   if (lockedTarget && pathReal !== lockedTarget)
@@ -38345,15 +38793,15 @@ function documentError(response) {
 function documentTarget(folder, file, lockedTarget) {
   if (!file)
     return;
-  const rootReal = realpathSync2(resolve12(folder));
-  const path = resolve12(folder, file);
+  const rootReal = realpathSync3(resolve15(folder));
+  const path = resolve15(folder, file);
   let pathReal;
   try {
-    pathReal = realpathSync2(path);
+    pathReal = realpathSync3(path);
   } catch {
     return;
   }
-  const rel = relative11(rootReal, pathReal);
+  const rel = relative12(rootReal, pathReal);
   if (rel.startsWith("..") || isAbsolute7(rel))
     return;
   if (lockedTarget && pathReal !== lockedTarget)
@@ -38411,7 +38859,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 +38875,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 +38914,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 +38940,7 @@ function createFolderApi({
         if (!folder)
           return;
         server.emit({
-          data: { path: relative11(folder, path) },
+          data: { path: relative12(folder, path) },
           event: "kennel:metadata-changed",
           type: "custom"
         });
@@ -38574,7 +39023,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 +39095,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, relative12(folder, lockedTarget), lockedTarget) : undefined;
           const dataset = lockedTarget ? {
             root: folder,
             documents: target ? [
               {
-                path: relative11(folder, target.path),
+                path: relative12(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 +39118,7 @@ function createFolderApi({
               documentError(response);
               return;
             }
-            const details = await stat9(target.path);
+            const details = await stat11(target.path);
             if (!details.isFile()) {
               documentError(response);
               return;
@@ -38681,16 +39130,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: relative12(target.root, target.path),
               root: folder,
               ...previewTextKind(target.kind) ? {} : {
                 rawUrl: `/api/raw?${new URLSearchParams({
                   path: folder,
-                  file: relative11(target.root, target.path)
+                  file: relative12(target.root, target.path)
                 })}`
               }
             }, {
@@ -38710,7 +39159,7 @@ function createFolderApi({
               documentError(response);
               return;
             }
-            const details = await stat9(target.path);
+            const details = await stat11(target.path);
             if (!details.isFile()) {
               documentError(response);
               return;
@@ -38731,10 +39180,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 +39197,7 @@ function createFolderApi({
               documentError(response);
               return;
             }
-            const details = await stat9(target.path);
+            const details = await stat11(target.path);
             if (!details.isFile()) {
               documentError(response);
               return;
@@ -38760,7 +39209,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",
@@ -38923,7 +39372,7 @@ function createFolderApi({
             workspace.breadcrumbs = await workspaceBreadcrumbIcons(workspace.breadcrumbs ?? [], assetFiles);
             const files = [
               workspace.configPath,
-              resolve12(workspace.root, "raggle.json")
+              resolve15(workspace.root, "raggle.json")
             ].filter((path) => Boolean(path));
             for (const path of files)
               contexts.add(path);
@@ -39082,26 +39531,26 @@ var contentTypes = {
   ".ttf": "font/ttf"
 };
 async function sendFile(request, response, directory, pathname, fallback) {
-  const root = await realpath8(directory);
+  const root = await realpath9(directory);
   const inside = (path) => {
-    const local = relative12(root, path);
+    const local = relative13(root, path);
     return local !== ".." && !local.startsWith("../") && !isAbsolute8(local);
   };
-  let target = resolve13(root, `.${decodeURIComponent(pathname)}`);
+  let target = resolve16(root, `.${decodeURIComponent(pathname)}`);
   if (!inside(target)) {
     response.writeHead(403);
     response.end();
     return;
   }
-  if (!(await stat10(target).catch(() => null))?.isFile()) {
+  if (!(await stat12(target).catch(() => null))?.isFile()) {
     if (!fallback) {
       response.writeHead(404);
       response.end();
       return;
     }
-    target = resolve13(root, fallback);
+    target = resolve16(root, fallback);
   }
-  target = await realpath8(target);
+  target = await realpath9(target);
   if (!inside(target)) {
     response.writeHead(403);
     response.end();
@@ -39111,7 +39560,7 @@ async function sendFile(request, response, directory, pathname, fallback) {
     "Content-Type": contentTypes[extname7(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);