@arabold/docs-mcp-server 1.18.0 → 1.20.0

package/dist/index.js

@@ -1,5 +1,5 @@
 import "dotenv/config";
-import { Command } from "commander";
+import { Option, Command } from "commander";
 import path from "node:path";
 import formBody from "@fastify/formbody";
 import fastifyStatic from "@fastify/static";
@@ -21,6 +21,9 @@ import fs from "node:fs/promises";
 import * as mime from "mime-types";
 import axios from "axios";
 import { HeaderGenerator } from "header-generator";
+import { initTRPC } from "@trpc/server";
+import { fastifyTRPCPlugin } from "@trpc/server/adapters/fastify";
+import { z as z$1 } from "zod";
 import { jsxs, jsx, Fragment } from "@kitajs/html/jsx-runtime";
 import fs$1, { readFileSync, existsSync } from "node:fs";
 import { unified } from "unified";
@@ -30,15 +33,16 @@ import remarkHtml from "remark-html";
 import DOMPurify from "dompurify";
 import { fileURLToPath, URL as URL$1 } from "node:url";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createTRPCProxyClient, httpBatchLink } from "@trpc/client";
+import "env-paths";
+import "fuse.js";
+import "langchain/text_splitter";
+import "better-sqlite3";
+import "sqlite-vec";
 import { execSync } from "node:child_process";
 import { v4 } from "uuid";
-import psl from "psl";
+import "psl";
 import { minimatch } from "minimatch";
-import envPaths from "env-paths";
-import Fuse from "fuse.js";
-import { RecursiveCharacterTextSplitter } from "langchain/text_splitter";
-import Database from "better-sqlite3";
-import * as sqliteVec from "sqlite-vec";
 const LogLevel = {
   ERROR: 0,
   WARN: 1,
@@ -97,7 +101,7 @@ const logger = {
     }
   }
 };
-const version = "1.17.0";
+const version = "1.19.0";
 const packageJson = {
   version
 };
@@ -324,14 +328,43 @@ class HtmlLinkExtractorMiddleware {
       return;
     }
     try {
+      let docBase = context.source;
+      try {
+        const baseEl = $("base[href]").first();
+        const rawBase = baseEl.attr("href");
+        if (rawBase && rawBase.trim() !== "") {
+          try {
+            const trimmed = rawBase.trim();
+            const candidate = new URL(trimmed, context.source);
+            const hasScheme = /^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(trimmed);
+            const protocolRelative = trimmed.startsWith("//");
+            const firstSlash = trimmed.indexOf("/");
+            const firstColon = trimmed.indexOf(":");
+            const colonBeforeSlash = firstColon !== -1 && (firstSlash === -1 || firstColon < firstSlash);
+            const suspiciousColon = colonBeforeSlash && !hasScheme && !protocolRelative;
+            if (suspiciousColon || trimmed.startsWith(":")) {
+              logger.debug(
+                `Ignoring suspicious <base href> value (colon misuse): ${rawBase}`
+              );
+            } else {
+              docBase = candidate.href;
+            }
+          } catch {
+            logger.debug(`Ignoring invalid <base href> value: ${rawBase}`);
+          }
+        }
+      } catch {
+      }
       const linkElements = $("a[href]");
-      logger.debug(`Found ${linkElements.length} potential links in ${context.source}`);
+      logger.debug(
+        `Found ${linkElements.length} potential links in ${context.source} (base=${docBase})`
+      );
       const extractedLinks = [];
       linkElements.each((_index, element) => {
         const href = $(element).attr("href");
         if (href && href.trim() !== "") {
           try {
-            const urlObj = new URL(href, context.source);
+            const urlObj = new URL(href, docBase);
             if (!["http:", "https:", "file:"].includes(urlObj.protocol)) {
               logger.debug(`Ignoring link with invalid protocol: ${href}`);
               return;
@@ -405,6 +438,7 @@ const SPLITTER_MIN_CHUNK_SIZE = 500;
 const SPLITTER_PREFERRED_CHUNK_SIZE = 1500;
 const SPLITTER_MAX_CHUNK_SIZE = 5e3;
 const EMBEDDING_BATCH_SIZE = 100;
+const EMBEDDING_BATCH_CHARS = 5e4;
 const MIGRATION_MAX_RETRIES = 5;
 const MIGRATION_RETRY_DELAY_MS = 300;
 var ScrapeMode = /* @__PURE__ */ ((ScrapeMode2) => {
@@ -1319,8 +1353,15 @@ class ListLibrariesTool {
     const rawLibraries = await this.docService.listLibraries();
     const libraries = rawLibraries.map(({ library, versions }) => ({
       name: library,
-      versions
-      // Directly assign the detailed versions array
+      versions: versions.map((v) => ({
+        version: v.ref.version,
+        documentCount: v.counts.documents,
+        uniqueUrlCount: v.counts.uniqueUrls,
+        indexedAt: v.indexedAt,
+        status: v.status,
+        ...v.progress ? { progress: v.progress } : void 0,
+        sourceUrl: v.sourceUrl
+      }))
     }));
     return { libraries };
   }
@@ -1400,7 +1441,8 @@ class ScrapeTool {
     }
     internalVersion = internalVersion.toLowerCase();
     const pipeline = this.pipeline;
-    const jobId = await pipeline.enqueueJob(library, internalVersion, {
+    const enqueueVersion = internalVersion === "" ? null : internalVersion;
+    const jobId = await pipeline.enqueueJob(library, enqueueVersion, {
       url,
       library,
       version: internalVersion,
@@ -1447,13 +1489,13 @@ class SearchTool {
       await this.docService.validateLibraryExists(library);
       const allLibraries = await this.docService.listLibraries();
       const libraryInfo = allLibraries.find((lib) => lib.library === library);
-      const detailedVersions = libraryInfo ? libraryInfo.versions : [];
-      throw new VersionNotFoundError(
-        library,
-        "latest",
-        // Or perhaps the original 'version' if it wasn't 'latest'? Check logic.
-        detailedVersions
-      );
+      const detailedVersions = libraryInfo ? libraryInfo.versions.map((v) => ({
+        version: v.ref.version,
+        documentCount: v.counts.documents,
+        uniqueUrlCount: v.counts.uniqueUrls,
+        indexedAt: v.indexedAt
+      })) : [];
+      throw new VersionNotFoundError(library, version2 ?? "latest", detailedVersions);
     }
     const resolvedVersion = version2 || "latest";
     logger.info(
@@ -2081,12 +2123,18 @@ class HttpFetcher {
         } else {
           content = Buffer.from(response.data);
         }
+        const finalUrl = (
+          // Node follow-redirects style
+          response.request?.res?.responseUrl || // Some adapters may expose directly
+          response.request?.responseUrl || // Fallback to axios recorded config URL
+          response.config?.url || source
+        );
         return {
           content,
           mimeType,
           charset,
           encoding: contentEncoding,
-          source
+          source: finalUrl
         };
       } catch (error) {
         const axiosError = error;
@@ -2224,134 +2272,229 @@ async function cleanupMcpService(mcpServer) {
     throw error;
   }
 }
-class PipelineApiService {
-  pipeline;
-  constructor(pipeline) {
-    this.pipeline = pipeline;
-  }
-  /**
-   * Registers all pipeline API routes with the given Fastify instance.
-   */
-  async registerRoutes(server) {
-    server.get("/api/health", async (_request, reply) => {
-      return reply.send({ status: "ok", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
-    });
-    server.get(
-      "/api/health/detailed",
-      async (_request, reply) => {
-        try {
-          const jobs = await this.pipeline.getJobs();
-          return reply.send({
-            status: "ok",
-            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-            jobCounts: {
-              total: jobs.length,
-              queued: jobs.filter((j) => j.status === PipelineJobStatus.QUEUED).length,
-              running: jobs.filter((j) => j.status === PipelineJobStatus.RUNNING).length,
-              completed: jobs.filter((j) => j.status === PipelineJobStatus.COMPLETED).length,
-              failed: jobs.filter((j) => j.status === PipelineJobStatus.FAILED).length,
-              cancelled: jobs.filter((j) => j.status === PipelineJobStatus.CANCELLED).length
-            }
-          });
-        } catch (error) {
-          return reply.status(500).send({
-            status: "error",
-            error: error instanceof Error ? error.message : String(error)
-          });
-        }
-      }
-    );
-    server.post(
-      "/api/jobs",
-      async (request, reply) => {
-        try {
-          const { library, version: version2, options } = request.body;
-          if (!library || !options) {
-            return reply.status(400).send({ error: "Missing required fields: library, options" });
-          }
-          const jobId = await this.pipeline.enqueueJob(library, version2, options);
-          logger.debug(
-            `API: Enqueued job ${jobId} for ${library}@${version2 || "unversioned"}`
-          );
-          return reply.send({ jobId });
-        } catch (error) {
-          logger.error(`API: Failed to enqueue job: ${error}`);
-          return reply.status(500).send({
-            error: error instanceof Error ? error.message : String(error)
-          });
-        }
-      }
-    );
-    server.get(
-      "/api/jobs",
-      async (request, reply) => {
-        try {
-          const { status } = request.query;
-          const jobs = await this.pipeline.getJobs(status);
-          return reply.send({ jobs });
-        } catch (error) {
-          logger.error(`API: Failed to get jobs: ${error}`);
-          return reply.status(500).send({
-            error: error instanceof Error ? error.message : String(error)
-          });
-        }
+const t$1 = initTRPC.context().create();
+const nonEmptyTrimmed = z$1.string().transform((s) => s.trim()).refine((s) => s.length > 0, "must not be empty");
+const optionalTrimmed = z$1.preprocess(
+  (v) => typeof v === "string" ? v.trim() : v,
+  z$1.string().min(1).optional().nullable()
+);
+const enqueueInput = z$1.object({
+  library: nonEmptyTrimmed,
+  version: optionalTrimmed,
+  options: z$1.custom()
+});
+const jobIdInput = z$1.object({ id: z$1.string().min(1) });
+const getJobsInput = z$1.object({
+  status: z$1.nativeEnum(PipelineJobStatus).optional()
+});
+function createPipelineRouter(trpc) {
+  const tt = trpc;
+  return tt.router({
+    enqueueJob: tt.procedure.input(enqueueInput).mutation(
+      async ({
+        ctx,
+        input
+      }) => {
+        const jobId = await ctx.pipeline.enqueueJob(
+          input.library,
+          input.version ?? null,
+          input.options
+        );
+        return { jobId };
+      }
+    ),
+    getJob: tt.procedure.input(jobIdInput).query(
+      async ({
+        ctx,
+        input
+      }) => {
+        return ctx.pipeline.getJob(input.id);
+      }
+    ),
+    getJobs: tt.procedure.input(getJobsInput.optional()).query(
+      async ({
+        ctx,
+        input
+      }) => {
+        const jobs = await ctx.pipeline.getJobs(input?.status);
+        return { jobs };
+      }
+    ),
+    cancelJob: tt.procedure.input(jobIdInput).mutation(
+      async ({
+        ctx,
+        input
+      }) => {
+        await ctx.pipeline.cancelJob(input.id);
+        return { success: true };
+      }
+    ),
+    clearCompletedJobs: tt.procedure.mutation(
+      async ({ ctx }) => {
+        const count = await ctx.pipeline.clearCompletedJobs();
+        return { count };
       }
-    );
-    server.get(
-      "/api/jobs/:id",
-      async (request, reply) => {
-        try {
-          const { id } = request.params;
-          const job = await this.pipeline.getJob(id);
-          if (!job) {
-            return reply.status(404).send({ error: "Job not found" });
-          }
-          return reply.send(job);
-        } catch (error) {
-          logger.error(`API: Failed to get job ${request.params.id}: ${error}`);
-          return reply.status(500).send({
-            error: error instanceof Error ? error.message : String(error)
-          });
-        }
+    )
+  });
+}
+createPipelineRouter(t$1);
+const t = initTRPC.context().create();
+const nonEmpty = z$1.string().min(1).transform((s) => s.trim());
+const optionalVersion = z$1.string().optional().nullable().transform((v) => typeof v === "string" ? v.trim() : v);
+function createDataRouter(trpc) {
+  const tt = trpc;
+  return tt.router({
+    listLibraries: tt.procedure.query(async ({ ctx }) => {
+      return await ctx.docService.listLibraries();
+    }),
+    findBestVersion: tt.procedure.input(z$1.object({ library: nonEmpty, targetVersion: z$1.string().optional() })).query(
+      async ({
+        ctx,
+        input
+      }) => {
+        const result = await ctx.docService.findBestVersion(
+          input.library,
+          input.targetVersion
+        );
+        return result;
+      }
+    ),
+    validateLibraryExists: tt.procedure.input(z$1.object({ library: nonEmpty })).mutation(
+      async ({ ctx, input }) => {
+        await ctx.docService.validateLibraryExists(input.library);
+        return { ok: true };
+      }
+    ),
+    search: tt.procedure.input(
+      z$1.object({
+        library: nonEmpty,
+        version: optionalVersion,
+        query: nonEmpty,
+        limit: z$1.number().int().positive().max(50).optional()
+      })
+    ).query(
+      async ({
+        ctx,
+        input
+      }) => {
+        const results = await ctx.docService.searchStore(
+          input.library,
+          input.version ?? null,
+          input.query,
+          input.limit ?? 5
+        );
+        return results;
+      }
+    ),
+    removeAllDocuments: tt.procedure.input(z$1.object({ library: nonEmpty, version: optionalVersion })).mutation(
+      async ({
+        ctx,
+        input
+      }) => {
+        await ctx.docService.removeAllDocuments(input.library, input.version ?? null);
+        return { ok: true };
+      }
+    ),
+    // Status and version helpers
+    getVersionsByStatus: tt.procedure.input(z$1.object({ statuses: z$1.array(z$1.string()) })).query(
+      async ({
+        ctx,
+        input
+      }) => {
+        const statuses = input.statuses;
+        return await ctx.docService.getVersionsByStatus(
+          statuses
+        );
       }
-    );
-    server.delete(
-      "/api/jobs/:id",
-      async (request, reply) => {
-        try {
-          const { id } = request.params;
-          await this.pipeline.cancelJob(id);
-          logger.debug(`API: Cancelled job ${id}`);
-          return reply.send({ success: true });
-        } catch (error) {
-          logger.error(`API: Failed to cancel job ${request.params.id}: ${error}`);
-          return reply.status(500).send({
-            error: error instanceof Error ? error.message : String(error)
-          });
-        }
+    ),
+    findVersionsBySourceUrl: tt.procedure.input(z$1.object({ url: nonEmpty })).query(async ({ ctx, input }) => {
+      return await ctx.docService.findVersionsBySourceUrl(
+        input.url
+      );
+    }),
+    getScraperOptions: tt.procedure.input(z$1.object({ versionId: z$1.number().int().positive() })).query(
+      async ({
+        ctx,
+        input
+      }) => {
+        return await ctx.docService.getScraperOptions(input.versionId);
+      }
+    ),
+    updateVersionStatus: tt.procedure.input(
+      z$1.object({
+        versionId: z$1.number().int().positive(),
+        status: z$1.string(),
+        errorMessage: z$1.string().optional().nullable()
+      })
+    ).mutation(
+      async ({
+        ctx,
+        input
+      }) => {
+        await ctx.docService.updateVersionStatus(
+          input.versionId,
+          input.status,
+          input.errorMessage ?? void 0
+        );
+        return { ok: true };
+      }
+    ),
+    updateVersionProgress: tt.procedure.input(
+      z$1.object({
+        versionId: z$1.number().int().positive(),
+        pages: z$1.number().int().nonnegative(),
+        maxPages: z$1.number().int().positive()
+      })
+    ).mutation(
+      async ({
+        ctx,
+        input
+      }) => {
+        await ctx.docService.updateVersionProgress(
+          input.versionId,
+          input.pages,
+          input.maxPages
+        );
+        return { ok: true };
       }
-    );
-    server.delete(
-      "/api/jobs",
-      async (_request, reply) => {
-        try {
-          const count = await this.pipeline.clearCompletedJobs();
-          logger.debug(`API: Cleared ${count} completed jobs`);
-          return reply.send({ count });
-        } catch (error) {
-          logger.error(`API: Failed to clear completed jobs: ${error}`);
-          return reply.status(500).send({
-            error: error instanceof Error ? error.message : String(error)
-          });
-        }
+    ),
+    storeScraperOptions: tt.procedure.input(
+      z$1.object({
+        versionId: z$1.number().int().positive(),
+        options: z$1.unknown()
+      })
+    ).mutation(
+      async ({
+        ctx,
+        input
+      }) => {
+        await ctx.docService.storeScraperOptions(
+          input.versionId,
+          input.options
+        );
+        return { ok: true };
       }
-    );
-    logger.debug("Pipeline API routes registered");
-  }
+    )
+  });
 }
-async function registerPipelineApiService(server, pipeline) {
-  const pipelineApiService = new PipelineApiService(pipeline);
-  await pipelineApiService.registerRoutes(server);
+createDataRouter(t);
+async function registerTrpcService(server, pipeline, docService) {
+  const t2 = initTRPC.context().create();
+  const healthRouter = t2.router({
+    ping: t2.procedure.query(async () => ({ status: "ok", ts: Date.now() }))
+  });
+  const router = t2.mergeRouters(
+    healthRouter,
+    createPipelineRouter(t2),
+    createDataRouter(t2)
+  );
+  await server.register(fastifyTRPCPlugin, {
+    prefix: "/api",
+    trpcOptions: {
+      router,
+      createContext: async () => ({ pipeline, docService })
+    }
+  });
 }
 const Layout = ({ title, version: version2, children }) => {
   let versionString = version2;
@@ -2522,7 +2665,7 @@ function normalizeVersionName(name) {
   return name ?? "";
 }
 function denormalizeVersionName(name) {
-  return name === "" ? null : name;
+  return name === "" ? "" : name;
 }
 function getStatusDescription(status) {
   const descriptions = {
@@ -3426,8 +3569,8 @@ const VersionDetailsRow = ({
   // Default to true
 }) => {
   const indexedDate = version2.indexedAt ? new Date(version2.indexedAt).toLocaleDateString() : "N/A";
-  const versionLabel = version2.version || "Unversioned";
-  const versionParam = version2.version || "";
+  const versionLabel = version2.ref.version || "Unversioned";
+  const versionParam = version2.ref.version || "";
   const sanitizedLibraryName = libraryName.replace(/[^a-zA-Z0-9-_]/g, "-");
   const sanitizedVersionParam = versionParam.replace(/[^a-zA-Z0-9-_]/g, "-");
   const rowId = `row-${sanitizedLibraryName}-${sanitizedVersionParam}`;
@@ -3446,19 +3589,19 @@ const VersionDetailsRow = ({
             {
               class: "text-sm text-gray-900 dark:text-white w-1/4 truncate",
               title: versionLabel,
-              children: version2.version ? /* @__PURE__ */ jsx(VersionBadge, { version: version2.version }) : /* @__PURE__ */ jsx("span", { children: "Unversioned" })
+              children: version2.ref.version ? /* @__PURE__ */ jsx(VersionBadge, { version: version2.ref.version }) : /* @__PURE__ */ jsx("span", { children: "Unversioned" })
             }
           ),
           /* @__PURE__ */ jsxs("div", { class: "flex space-x-2 text-sm text-gray-600 dark:text-gray-400 w-3/4 justify-end items-center", children: [
             /* @__PURE__ */ jsxs("span", { title: "Number of unique pages indexed", children: [
               "Pages:",
               " ",
-              /* @__PURE__ */ jsx("span", { class: "font-semibold", safe: true, children: version2.uniqueUrlCount.toLocaleString() })
+              /* @__PURE__ */ jsx("span", { class: "font-semibold", safe: true, children: version2.counts.uniqueUrls.toLocaleString() })
             ] }),
             /* @__PURE__ */ jsxs("span", { title: "Number of indexed snippets", children: [
               "Snippets:",
               " ",
-              /* @__PURE__ */ jsx("span", { class: "font-semibold", safe: true, children: version2.documentCount.toLocaleString() })
+              /* @__PURE__ */ jsx("span", { class: "font-semibold", safe: true, children: version2.counts.documents.toLocaleString() })
             ] }),
             /* @__PURE__ */ jsxs("span", { title: "Date last indexed", children: [
               "Last Update:",
@@ -3558,17 +3701,28 @@ const LibraryDetailCard = ({ library }) => (
   // Use Flowbite Card structure with updated padding and border, and white background
   /* @__PURE__ */ jsxs("div", { class: "block p-4 bg-white dark:bg-gray-800 rounded-lg shadow-sm border border-gray-300 dark:border-gray-600 mb-4", children: [
     /* @__PURE__ */ jsx("h3", { class: "text-lg font-medium text-gray-900 dark:text-white mb-1", children: /* @__PURE__ */ jsx("span", { safe: true, children: library.name }) }),
-    /* @__PURE__ */ jsx("div", { class: "mt-1", children: library.versions.length > 0 ? library.versions.map((version2) => /* @__PURE__ */ jsx(
-      VersionDetailsRow,
-      {
-        libraryName: library.name,
-        version: version2,
-        showDelete: false
-      }
-    )) : (
-      // Display message if no versions are indexed
-      /* @__PURE__ */ jsx("p", { class: "text-sm text-gray-500 dark:text-gray-400 italic", children: "No versions indexed." })
-    ) })
+    /* @__PURE__ */ jsx("div", { class: "mt-1", children: library.versions.length > 0 ? library.versions.map((v) => {
+      const adapted = {
+        id: -1,
+        ref: { library: library.name, version: v.version },
+        status: v.status,
+        progress: v.progress,
+        counts: {
+          documents: v.documentCount,
+          uniqueUrls: v.uniqueUrlCount
+        },
+        indexedAt: v.indexedAt,
+        sourceUrl: v.sourceUrl ?? void 0
+      };
+      return /* @__PURE__ */ jsx(
+        VersionDetailsRow,
+        {
+          libraryName: library.name,
+          version: adapted,
+          showDelete: false
+        }
+      );
+    }) : /* @__PURE__ */ jsx("p", { class: "text-sm text-gray-500 dark:text-gray-400 italic", children: "No versions indexed." }) })
   ] })
 );
 const LibrarySearchCard = ({ library }) => {
@@ -3733,7 +3887,21 @@ const LibraryItem = ({ library }) => (
         children: /* @__PURE__ */ jsx("span", { safe: true, children: library.name })
       }
     ) }),
-    /* @__PURE__ */ jsx("div", { class: "mt-1", children: library.versions.length > 0 ? library.versions.map((version2) => /* @__PURE__ */ jsx(VersionDetailsRow, { libraryName: library.name, version: version2 })) : (
+    /* @__PURE__ */ jsx("div", { class: "mt-1", children: library.versions.length > 0 ? library.versions.map((v) => {
+      const adapted = {
+        id: -1,
+        ref: { library: library.name, version: v.version },
+        status: v.status,
+        progress: v.progress,
+        counts: {
+          documents: v.documentCount,
+          uniqueUrls: v.uniqueUrlCount
+        },
+        indexedAt: v.indexedAt,
+        sourceUrl: v.sourceUrl ?? void 0
+      };
+      return /* @__PURE__ */ jsx(VersionDetailsRow, { libraryName: library.name, version: adapted });
+    }) : (
       // Display message if no versions are indexed
       /* @__PURE__ */ jsx("p", { class: "text-sm text-gray-500 dark:text-gray-400 italic", children: "No versions indexed." })
     ) })
@@ -3861,9 +4029,9 @@ class AppServer {
         );
       }
     }
-    if (this.config.enableWorker && !this.config.enablePipelineApi) {
+    if (this.config.enableWorker && !this.config.enableApiServer) {
       logger.warn(
-        "Warning: Worker is enabled but Pipeline API is disabled. Consider enabling Pipeline API for better observability."
+        "Warning: Worker is enabled but API server is disabled. Consider enabling the API for better observability."
       );
     }
   }
@@ -3915,8 +4083,8 @@ class AppServer {
     if (this.config.enableMcpServer) {
       await this.enableMcpServer();
     }
-    if (this.config.enablePipelineApi) {
-      await this.enablePipelineApi();
+    if (this.config.enableApiServer) {
+      await this.enableTrpcApi();
     }
     if (this.config.enableWorker) {
       await this.enableWorker();
@@ -3944,11 +4112,11 @@ class AppServer {
     logger.debug("MCP server service enabled");
   }
   /**
-   * Enable Pipeline API service.
+   * Enable Pipeline RPC (tRPC) service.
    */
-  async enablePipelineApi() {
-    await registerPipelineApiService(this.server, this.pipeline);
-    logger.debug("Pipeline API service enabled");
+  async enableTrpcApi() {
+    await registerTrpcService(this.server, this.pipeline, this.docService);
+    logger.debug("API server (tRPC) enabled");
   }
   /**
    * Enable worker service.
@@ -3977,10 +4145,10 @@ class AppServer {
       enabledServices.push(`Web interface: ${address}`);
     }
     if (this.config.enableMcpServer) {
-      enabledServices.push(`MCP endpoint: ${address}/mcp, ${address}/sse`);
+      enabledServices.push(`MCP endpoints: ${address}/mcp, ${address}/sse`);
     }
-    if (this.config.enablePipelineApi) {
-      enabledServices.push(`Pipeline API: ${address}/api`);
+    if (this.config.enableApiServer) {
+      enabledServices.push(`API: ${address}/api`);
     }
     if (this.config.enableWorker) {
       enabledServices.push("Embedded worker: enabled");
@@ -4005,6 +4173,161 @@ async function startStdioServer(tools) {
   logger.info("🤖 MCP server listening on stdio");
   return server;
 }
+class StoreError extends Error {
+  constructor(message, cause) {
+    super(cause ? `${message} caused by ${cause}` : message);
+    this.cause = cause;
+    this.name = this.constructor.name;
+    const causeError = cause instanceof Error ? cause : cause ? new Error(String(cause)) : void 0;
+    if (causeError?.stack) {
+      this.stack = causeError.stack;
+    }
+  }
+}
+class DimensionError extends StoreError {
+  constructor(modelName, modelDimension, dbDimension) {
+    super(
+      `Model "${modelName}" produces ${modelDimension}-dimensional vectors, which exceeds the database's fixed dimension of ${dbDimension}. Please use a model with dimension ≤ ${dbDimension}.`
+    );
+    this.modelName = modelName;
+    this.modelDimension = modelDimension;
+    this.dbDimension = dbDimension;
+  }
+}
+class ConnectionError extends StoreError {
+}
+const MIGRATIONS_DIR = path.join(getProjectRoot(), "db", "migrations");
+const MIGRATIONS_TABLE = "_schema_migrations";
+function ensureMigrationsTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS ${MIGRATIONS_TABLE} (
+      id TEXT PRIMARY KEY,
+      applied_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    );
+  `);
+}
+function getAppliedMigrations(db) {
+  const stmt = db.prepare(`SELECT id FROM ${MIGRATIONS_TABLE}`);
+  const rows = stmt.all();
+  return new Set(rows.map((row) => row.id));
+}
+async function applyMigrations(db) {
+  try {
+    db.pragma("journal_mode = OFF");
+    db.pragma("synchronous = OFF");
+    db.pragma("mmap_size = 268435456");
+    db.pragma("cache_size = -64000");
+    db.pragma("temp_store = MEMORY");
+    logger.debug("Applied performance optimizations for migration");
+  } catch (_error) {
+    logger.warn("⚠️ Could not apply all performance optimizations for migration");
+  }
+  const overallTransaction = db.transaction(() => {
+    logger.debug("Checking database migrations...");
+    ensureMigrationsTable(db);
+    const appliedMigrations = getAppliedMigrations(db);
+    if (!fs$1.existsSync(MIGRATIONS_DIR)) {
+      throw new StoreError("Migrations directory not found");
+    }
+    const migrationFiles = fs$1.readdirSync(MIGRATIONS_DIR).filter((file) => file.endsWith(".sql")).sort();
+    const pendingMigrations = migrationFiles.filter(
+      (filename) => !appliedMigrations.has(filename)
+    );
+    if (pendingMigrations.length > 0) {
+      logger.info(`🔄 Applying ${pendingMigrations.length} database migration(s)...`);
+    }
+    let appliedCount = 0;
+    for (const filename of pendingMigrations) {
+      logger.debug(`Applying migration: ${filename}`);
+      const filePath = path.join(MIGRATIONS_DIR, filename);
+      const sql = fs$1.readFileSync(filePath, "utf8");
+      try {
+        db.exec(sql);
+        const insertStmt = db.prepare(`INSERT INTO ${MIGRATIONS_TABLE} (id) VALUES (?)`);
+        insertStmt.run(filename);
+        logger.debug(`✅ Applied migration: ${filename}`);
+        appliedCount++;
+      } catch (error) {
+        logger.error(`❌ Failed to apply migration: ${filename} - ${error}`);
+        throw new StoreError(`Migration failed: ${filename}`, error);
+      }
+    }
+    if (appliedCount > 0) {
+      logger.info(`✅ Successfully applied ${appliedCount} migration(s)`);
+    } else {
+      logger.debug("Database schema is up to date");
+    }
+    return appliedCount;
+  });
+  let retries = 0;
+  let appliedMigrationsCount = 0;
+  while (true) {
+    try {
+      appliedMigrationsCount = overallTransaction.immediate();
+      logger.debug("Database migrations completed successfully");
+      if (appliedMigrationsCount > 0) {
+        try {
+          logger.debug(
+            `Running VACUUM after applying ${appliedMigrationsCount} migration(s)...`
+          );
+          db.exec("VACUUM");
+          logger.debug("Database vacuum completed successfully");
+        } catch (error) {
+          logger.warn(`⚠️ Could not vacuum database after migrations: ${error}`);
+        }
+      } else {
+        logger.debug("Skipping VACUUM - no migrations were applied");
+      }
+      break;
+    } catch (error) {
+      if (error?.code === "SQLITE_BUSY" && retries < MIGRATION_MAX_RETRIES) {
+        retries++;
+        logger.warn(
+          `⚠️  Migrations busy (SQLITE_BUSY), retrying attempt ${retries}/${MIGRATION_MAX_RETRIES} in ${MIGRATION_RETRY_DELAY_MS}ms...`
+        );
+        await new Promise((resolve) => setTimeout(resolve, MIGRATION_RETRY_DELAY_MS));
+      } else {
+        if (error?.code === "SQLITE_BUSY") {
+          logger.error(
+            `❌ Migrations still busy after ${MIGRATION_MAX_RETRIES} retries. Giving up: ${error}`
+          );
+        }
+        if (error instanceof StoreError) {
+          throw error;
+        }
+        throw new StoreError("Failed during migration process", error);
+      }
+    }
+  }
+  try {
+    db.pragma("journal_mode = WAL");
+    db.pragma("wal_autocheckpoint = 1000");
+    db.pragma("busy_timeout = 30000");
+    db.pragma("foreign_keys = ON");
+    db.pragma("synchronous = NORMAL");
+    logger.debug(
+      "Applied production database configuration (WAL mode, autocheckpoint, foreign keys, busy timeout)"
+    );
+  } catch (_error) {
+    logger.warn("⚠️ Could not apply all production database settings");
+  }
+}
+async function createDocumentManagement(options = {}) {
+  if (options.serverUrl) {
+    const { DocumentManagementClient } = await import("./DocumentManagementClient-CAFdDwTu.js");
+    const client = new DocumentManagementClient(options.serverUrl);
+    await client.initialize();
+    return client;
+  }
+  const service = new (await import("./DocumentManagementService-BH02TJEe.js")).DocumentManagementService();
+  await service.initialize();
+  return service;
+}
+async function createLocalDocumentManagement() {
+  const service = new (await import("./DocumentManagementService-BH02TJEe.js")).DocumentManagementService();
+  await service.initialize();
+  return service;
+}
 function deserializeJob(serializedJob) {
   return {
     ...serializedJob,
@@ -4016,21 +4339,22 @@ function deserializeJob(serializedJob) {
 }
 class PipelineClient {
   baseUrl;
+  client;
   pollingInterval = 1e3;
   // 1 second
   activePolling = /* @__PURE__ */ new Set();
   // Track jobs being polled for completion
   constructor(serverUrl) {
     this.baseUrl = serverUrl.replace(/\/$/, "");
-    logger.debug(`PipelineClient created for: ${this.baseUrl}`);
+    this.client = createTRPCProxyClient({
+      links: [httpBatchLink({ url: this.baseUrl })]
+    });
+    logger.debug(`PipelineClient (tRPC) created for: ${this.baseUrl}`);
   }
   async start() {
     try {
-      const response = await fetch(`${this.baseUrl}/health`);
-      if (!response.ok) {
-        throw new Error(`External worker health check failed: ${response.status}`);
-      }
-      logger.debug("PipelineClient connected to external worker");
+      await this.client.ping.query();
+      logger.debug("PipelineClient connected to external worker via tRPC");
     } catch (error) {
       throw new Error(
         `Failed to connect to external worker at ${this.baseUrl}: ${error instanceof Error ? error.message : String(error)}`
@@ -4043,25 +4367,14 @@ class PipelineClient {
   }
   async enqueueJob(library, version2, options) {
     try {
-      const response = await fetch(`${this.baseUrl}/jobs`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          library,
-          version: version2,
-          options
-        })
+      const normalizedVersion = typeof version2 === "string" && version2.trim().length === 0 ? null : version2 ?? null;
+      const result = await this.client.enqueueJob.mutate({
+        library,
+        version: normalizedVersion,
+        options
       });
-      if (!response.ok) {
-        const errorText = await response.text();
-        throw new Error(`Failed to enqueue job: ${response.status} ${errorText}`);
-      }
-      const result = await response.json();
-      const jobId = result.jobId;
-      logger.debug(`Job ${jobId} enqueued successfully`);
-      return jobId;
+      logger.debug(`Job ${result.jobId} enqueued successfully`);
+      return result.jobId;
     } catch (error) {
       throw new Error(
         `Failed to enqueue job: ${error instanceof Error ? error.message : String(error)}`
@@ -4070,15 +4383,8 @@ class PipelineClient {
   }
   async getJob(jobId) {
     try {
-      const response = await fetch(`${this.baseUrl}/jobs/${jobId}`);
-      if (response.status === 404) {
-        return void 0;
-      }
-      if (!response.ok) {
-        throw new Error(`Failed to get job: ${response.status} ${response.statusText}`);
-      }
-      const serializedJob = await response.json();
-      return deserializeJob(serializedJob);
+      const serializedJob = await this.client.getJob.query({ id: jobId });
+      return serializedJob ? deserializeJob(serializedJob) : void 0;
     } catch (error) {
       throw new Error(
         `Failed to get job ${jobId}: ${error instanceof Error ? error.message : String(error)}`
@@ -4087,18 +4393,11 @@ class PipelineClient {
   }
   async getJobs(status) {
     try {
-      const url = new URL(`${this.baseUrl}/jobs`);
-      if (status) {
-        url.searchParams.set("status", status);
-      }
-      const response = await fetch(url.toString());
-      if (!response.ok) {
-        const errorText = await response.text();
-        throw new Error(`Failed to get jobs: ${response.status} ${errorText}`);
-      }
-      const result = await response.json();
+      const result = await this.client.getJobs.query({ status });
       const serializedJobs = result.jobs || [];
-      return serializedJobs.map(deserializeJob);
+      return serializedJobs.map(
+        (j) => deserializeJob(j)
+      );
     } catch (error) {
       logger.error(`Failed to get jobs from external worker: ${error}`);
       throw error;
@@ -4106,13 +4405,7 @@ class PipelineClient {
   }
   async cancelJob(jobId) {
     try {
-      const response = await fetch(`${this.baseUrl}/jobs/${jobId}`, {
-        method: "DELETE"
-      });
-      if (!response.ok) {
-        const errorText = await response.text();
-        throw new Error(`Failed to cancel job: ${response.status} ${errorText}`);
-      }
+      await this.client.cancelJob.mutate({ id: jobId });
       logger.debug(`Job cancelled via external worker: ${jobId}`);
     } catch (error) {
       logger.error(`Failed to cancel job ${jobId} via external worker: ${error}`);
@@ -4121,16 +4414,7 @@ class PipelineClient {
   }
   async clearCompletedJobs() {
     try {
-      const response = await fetch(`${this.baseUrl}/jobs`, {
-        method: "DELETE"
-      });
-      if (!response.ok) {
-        const errorText = await response.text();
-        throw new Error(
-          `Failed to clear completed jobs: ${response.status} ${errorText}`
-        );
-      }
-      const result = await response.json();
+      const result = await this.client.clearCompletedJobs.mutate();
       logger.debug(`Cleared ${result.count} completed jobs via external worker`);
       return result.count || 0;
     } catch (error) {
@@ -4210,17 +4494,33 @@ function validateUrl(url) {
     throw new InvalidUrlError(url, error instanceof Error ? error : void 0);
   }
 }
-function hasSameHostname(urlA, urlB) {
-  return urlA.hostname.toLowerCase() === urlB.hostname.toLowerCase();
-}
-function hasSameDomain(urlA, urlB) {
-  const domainA = psl.get(urlA.hostname.toLowerCase());
-  const domainB = psl.get(urlB.hostname.toLowerCase());
-  return domainA !== null && domainA === domainB;
+function computeBaseDirectory(pathname) {
+  if (pathname === "") return "/";
+  if (pathname.endsWith("/")) return pathname;
+  const lastSegment = pathname.split("/").at(-1) || "";
+  const looksLikeFile = lastSegment.includes(".");
+  if (looksLikeFile) {
+    return pathname.replace(/\/[^/]*$/, "/");
+  }
+  return `${pathname}/`;
 }
-function isSubpath(baseUrl, targetUrl) {
-  const basePath = baseUrl.pathname.endsWith("/") ? baseUrl.pathname : `${baseUrl.pathname}/`;
-  return targetUrl.pathname.startsWith(basePath);
+function isInScope(baseUrl, targetUrl, scope) {
+  if (baseUrl.protocol !== targetUrl.protocol) return false;
+  switch (scope) {
+    case "subpages": {
+      if (baseUrl.hostname !== targetUrl.hostname) return false;
+      const baseDir = computeBaseDirectory(baseUrl.pathname);
+      return targetUrl.pathname.startsWith(baseDir);
+    }
+    case "hostname":
+      return baseUrl.hostname === targetUrl.hostname;
+    case "domain": {
+      const getDomain = (host) => host.split(".").slice(-2).join(".");
+      return getDomain(baseUrl.hostname) === getDomain(targetUrl.hostname);
+    }
+    default:
+      return false;
+  }
 }
 function isRegexPattern(pattern) {
   return pattern.length > 2 && pattern.startsWith("/") && pattern.endsWith("/");
@@ -4268,24 +4568,6 @@ function shouldIncludeUrl(url, includePatterns, excludePatterns) {
   if (!includePatterns || includePatterns.length === 0) return true;
   return matchesAnyPattern(normalizedPath, includePatterns) || (basename ? matchesAnyPattern(basename, stripSlash(includePatterns)) : false);
 }
-function isInScope(baseUrl, targetUrl, scope) {
-  if (baseUrl.protocol !== targetUrl.protocol) return false;
-  switch (scope) {
-    case "subpages": {
-      if (baseUrl.hostname !== targetUrl.hostname) return false;
-      const baseDir = baseUrl.pathname.endsWith("/") ? baseUrl.pathname : baseUrl.pathname.replace(/\/[^/]*$/, "/");
-      return targetUrl.pathname.startsWith(baseDir);
-    }
-    case "hostname":
-      return baseUrl.hostname === targetUrl.hostname;
-    case "domain": {
-      const getDomain = (host) => host.split(".").slice(-2).join(".");
-      return getDomain(baseUrl.hostname) === getDomain(targetUrl.hostname);
-    }
-    default:
-      return false;
-  }
-}
 const DEFAULT_MAX_DEPTH = 3;
 const DEFAULT_CONCURRENCY = 3;
 class BaseScraperStrategy {
@@ -4294,6 +4576,8 @@ class BaseScraperStrategy {
   totalDiscovered = 0;
   // Track total URLs discovered (unlimited)
   effectiveTotal = 0;
+  // Track effective total (limited by maxPages)
+  canonicalBaseUrl;
   options;
   constructor(options = {}) {
     this.options = options;
@@ -4305,7 +4589,7 @@ class BaseScraperStrategy {
   shouldProcessUrl(url, options) {
     if (options.scope) {
       try {
-        const base = new URL$1(options.url);
+        const base = this.canonicalBaseUrl ?? new URL$1(options.url);
         const target = new URL$1(url);
         if (!isInScope(base, target, options.scope)) return false;
       } catch {
@@ -4328,6 +4612,23 @@ class BaseScraperStrategy {
         }
         try {
           const result = await this.processItem(item, options, void 0, signal);
+          if (item.depth === 0 && !this.canonicalBaseUrl && result?.finalUrl) {
+            try {
+              const finalUrlStr = result.finalUrl;
+              const original = new URL$1(options.url);
+              const finalUrlObj = new URL$1(finalUrlStr);
+              if (finalUrlObj.href !== original.href && (finalUrlObj.protocol === "http:" || finalUrlObj.protocol === "https:")) {
+                this.canonicalBaseUrl = finalUrlObj;
+                logger.debug(
+                  `Updated scope base after redirect: ${original.href} -> ${finalUrlObj.href}`
+                );
+              } else {
+                this.canonicalBaseUrl = original;
+              }
+            } catch {
+              this.canonicalBaseUrl = new URL$1(options.url);
+            }
+          }
           if (result.document) {
             this.pageCount++;
             logger.info(
@@ -4388,7 +4689,8 @@ class BaseScraperStrategy {
     this.pageCount = 0;
     this.totalDiscovered = 1;
     this.effectiveTotal = 1;
-    const baseUrl = new URL$1(options.url);
+    this.canonicalBaseUrl = new URL$1(options.url);
+    let baseUrl = this.canonicalBaseUrl;
     const queue = [{ url: options.url, depth: 0 }];
     this.visited.add(normalizeUrl(options.url, this.options.urlNormalizerOptions));
     const maxPages = options.maxPages ?? DEFAULT_MAX_PAGES;
@@ -4409,6 +4711,7 @@ class BaseScraperStrategy {
         queue.length
       );
       const batch = queue.splice(0, batchSize);
+      baseUrl = this.canonicalBaseUrl ?? baseUrl;
       const newUrls = await this.processBatch(
         batch,
         baseUrl,
@@ -4441,22 +4744,7 @@ class WebScraperStrategy extends BaseScraperStrategy {
       return false;
     }
   }
-  /**
-   * Determines if a target URL should be followed based on the scope setting.
-   */
-  isInScope(baseUrl, targetUrl, scope) {
-    try {
-      if (scope === "domain") {
-        return hasSameDomain(baseUrl, targetUrl);
-      }
-      if (scope === "hostname") {
-        return hasSameHostname(baseUrl, targetUrl);
-      }
-      return hasSameHostname(baseUrl, targetUrl) && isSubpath(baseUrl, targetUrl);
-    } catch {
-      return false;
-    }
-  }
+  // Removed custom isInScope logic; using shared scope utility for consistent behavior
   /**
    * Processes a single queue item by fetching its content and processing it through pipelines.
    * @param item - The queue item to process.
@@ -4497,12 +4785,12 @@ class WebScraperStrategy extends BaseScraperStrategy {
         );
         return { document: void 0, links: processed.links };
       }
-      const baseUrl = new URL(options.url);
+      const baseUrl = item.depth === 0 ? new URL(rawContent.source) : this.canonicalBaseUrl ?? new URL(options.url);
       const filteredLinks = processed.links.filter((link) => {
         try {
           const targetUrl = new URL(link);
           const scope = options.scope || "subpages";
-          return this.isInScope(baseUrl, targetUrl, scope) && (!this.shouldFollowLinkFn || this.shouldFollowLinkFn(baseUrl, targetUrl));
+          return isInScope(baseUrl, targetUrl, scope) && (!this.shouldFollowLinkFn || this.shouldFollowLinkFn(baseUrl, targetUrl));
         } catch {
           return false;
         }
@@ -4518,7 +4806,8 @@ class WebScraperStrategy extends BaseScraperStrategy {
             ...processed.metadata
           }
         },
-        links: filteredLinks
+        links: filteredLinks,
+        finalUrl: rawContent.source
       };
     } catch (error) {
       logger.error(`❌ Failed processing page ${url}: ${error}`);
@@ -4901,7 +5190,9 @@ class PipelineManager {
    */
   async recoverPendingJobs() {
     try {
-      const runningVersions = await this.store.getRunningVersions();
+      const runningVersions = await this.store.getVersionsByStatus([
+        VersionStatus.RUNNING
+      ]);
       for (const version2 of runningVersions) {
         await this.store.updateVersionStatus(version2.id, VersionStatus.QUEUED);
         logger.info(
@@ -5056,25 +5347,25 @@ class PipelineManager {
   async enqueueJobWithStoredOptions(library, version2) {
     const normalizedVersion = version2 ?? "";
     try {
-      const versionId = await this.store.ensureLibraryAndVersion(
+      const versionId = await this.store.ensureVersion({
         library,
-        normalizedVersion
-      );
-      const versionRecord = await this.store.getVersionWithStoredOptions(versionId);
-      if (!versionRecord?.scraper_options || !versionRecord.source_url) {
+        version: normalizedVersion
+      });
+      const stored = await this.store.getScraperOptions(versionId);
+      if (!stored) {
         throw new Error(
           `No stored scraper options found for ${library}@${normalizedVersion || "unversioned"}`
         );
       }
-      const storedOptions = JSON.parse(versionRecord.scraper_options);
+      const storedOptions = stored.options;
       const completeOptions = {
-        url: versionRecord.source_url,
+        url: stored.sourceUrl,
         library,
         version: normalizedVersion,
         ...storedOptions
       };
       logger.info(
-        `🔄 Re-indexing ${library}@${normalizedVersion || "unversioned"} with stored options from ${versionRecord.source_url}`
+        `🔄 Re-indexing ${library}@${normalizedVersion || "unversioned"} with stored options from ${stored.sourceUrl}`
       );
       return this.enqueueJob(library, normalizedVersion, completeOptions);
     } catch (error) {
@@ -5351,2130 +5642,123 @@ var PipelineFactory;
       logger.debug(`Creating PipelineClient for external worker at: ${serverUrl}`);
       return new PipelineClient(serverUrl);
     }
-    return new PipelineManager(docService, concurrency, { recoverJobs });
+    return new PipelineManager(docService, concurrency, {
+      recoverJobs
+    });
   }
   PipelineFactory2.createPipeline = createPipeline;
 })(PipelineFactory || (PipelineFactory = {}));
-class SplitterError extends Error {
-}
-class MinimumChunkSizeError extends SplitterError {
-  constructor(size, maxSize) {
-    super(
-      `Cannot split content any further. Content requires minimum chunk size of ${size} bytes, but maximum allowed is ${maxSize} bytes.`
+function ensurePlaywrightBrowsersInstalled() {
+  const chromiumEnvPath = process.env.PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH;
+  if (chromiumEnvPath && existsSync(chromiumEnvPath)) {
+    logger.debug(
+      `PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH is set to '${chromiumEnvPath}', skipping Playwright browser install.`
     );
+    return;
   }
-}
-class ContentSplitterError extends SplitterError {
-}
-class GreedySplitter {
-  baseSplitter;
-  minChunkSize;
-  preferredChunkSize;
-  /**
-   * Combines a base document splitter with size constraints to produce optimally-sized chunks.
-   * The base splitter handles the initial semantic splitting, while this class handles
-   * the concatenation strategy.
-   */
-  constructor(baseSplitter, minChunkSize, preferredChunkSize) {
-    this.baseSplitter = baseSplitter;
-    this.minChunkSize = minChunkSize;
-    this.preferredChunkSize = preferredChunkSize;
-  }
-  /**
-   * Uses a greedy concatenation strategy to build optimally-sized chunks. Small chunks
-   * are combined until they reach the minimum size, but splits are preserved at major
-   * section boundaries to maintain document structure. This balances the need for
-   * context with semantic coherence.
-   */
-  async splitText(markdown) {
-    const initialChunks = await this.baseSplitter.splitText(markdown);
-    const concatenatedChunks = [];
-    let currentChunk = null;
-    for (const nextChunk of initialChunks) {
-      if (currentChunk) {
-        if (this.wouldExceedMaxSize(currentChunk, nextChunk)) {
-          concatenatedChunks.push(currentChunk);
-          currentChunk = this.cloneChunk(nextChunk);
-          continue;
-        }
-        if (currentChunk.content.length >= this.minChunkSize && this.startsNewMajorSection(nextChunk)) {
-          concatenatedChunks.push(currentChunk);
-          currentChunk = this.cloneChunk(nextChunk);
-          continue;
-        }
-        currentChunk.content += `
-${nextChunk.content}`;
-        currentChunk.section = this.mergeSectionInfo(currentChunk, nextChunk);
-        currentChunk.types = this.mergeTypes(currentChunk.types, nextChunk.types);
-      } else {
-        currentChunk = this.cloneChunk(nextChunk);
-      }
-    }
-    if (currentChunk) {
-      concatenatedChunks.push(currentChunk);
-    }
-    return concatenatedChunks;
-  }
-  cloneChunk(chunk) {
-    return {
-      types: [...chunk.types],
-      content: chunk.content,
-      section: {
-        level: chunk.section.level,
-        path: [...chunk.section.path]
-      }
-    };
-  }
-  /**
-   * H1 and H2 headings represent major conceptual breaks in the document.
-   * Preserving these splits helps maintain the document's logical structure.
-   */
-  startsNewMajorSection(chunk) {
-    return chunk.section.level === 1 || chunk.section.level === 2;
-  }
-  /**
-   * Size limit check to ensure chunks remain within embedding model constraints.
-   * Essential for maintaining consistent embedding quality and avoiding truncation.
-   */
-  wouldExceedMaxSize(currentChunk, nextChunk) {
-    if (!currentChunk) {
-      return false;
-    }
-    return currentChunk.content.length + nextChunk.content.length > this.preferredChunkSize;
-  }
-  /**
-   * Checks if one path is a prefix of another path, indicating a parent-child relationship
-   */
-  isPathIncluded(parentPath, childPath) {
-    if (parentPath.length >= childPath.length) return false;
-    return parentPath.every((part, i) => part === childPath[i]);
-  }
-  /**
-   * Merges section metadata when concatenating chunks, following these rules:
-   * 1. Level: Always uses the lowest (most general) level between chunks
-   * 2. Path selection:
-   *    - For parent-child relationships (one path includes the other), uses the child's path
-   *    - For siblings/unrelated sections, uses the common parent path
-   *    - If no common path exists, uses the root path ([])
-   */
-  mergeSectionInfo(currentChunk, nextChunk) {
-    const level = Math.min(currentChunk.section.level, nextChunk.section.level);
-    if (currentChunk.section.level === nextChunk.section.level && currentChunk.section.path.length === nextChunk.section.path.length && currentChunk.section.path.every((p, i) => p === nextChunk.section.path[i])) {
-      return currentChunk.section;
-    }
-    if (this.isPathIncluded(currentChunk.section.path, nextChunk.section.path)) {
-      return {
-        path: nextChunk.section.path,
-        level
-      };
-    }
-    if (this.isPathIncluded(nextChunk.section.path, currentChunk.section.path)) {
-      return {
-        path: currentChunk.section.path,
-        level
-      };
+  try {
+    const chromiumPath = chromium.executablePath();
+    if (!chromiumPath || !existsSync(chromiumPath)) {
+      throw new Error("Playwright Chromium browser not found");
     }
-    const commonPath = this.findCommonPrefix(
-      currentChunk.section.path,
-      nextChunk.section.path
+  } catch (_err) {
+    logger.debug(
+      "Playwright browsers not found. Installing Chromium browser for dynamic scraping (this may take a minute)..."
     );
-    return {
-      path: commonPath,
-      level
-    };
-  }
-  mergeTypes(currentTypes, nextTypes) {
-    return [.../* @__PURE__ */ new Set([...currentTypes, ...nextTypes])];
-  }
-  /**
-   * Returns longest common prefix between two paths
-   */
-  findCommonPrefix(path1, path2) {
-    const common = [];
-    for (let i = 0; i < Math.min(path1.length, path2.length); i++) {
-      if (path1[i] === path2[i]) {
-        common.push(path1[i]);
-      } else {
-        break;
-      }
+    try {
+      logger.debug("Installing Playwright Chromium browser...");
+      execSync("npm exec -y playwright install --no-shell --with-deps chromium", {
+        stdio: "ignore",
+        // Suppress output
+        cwd: getProjectRoot()
+      });
+    } catch (_installErr) {
+      console.error(
+        "❌ Failed to install Playwright browsers automatically. Please run:\n  npx playwright install --no-shell --with-deps chromium\nand try again."
+      );
+      process.exit(1);
     }
-    return common;
   }
 }
-const fullTrim = (str) => {
-  return str.replace(/^[\s\r\n\t]+|[\s\r\n\t]+$/g, "");
-};
-class CodeContentSplitter {
-  constructor(options) {
-    this.options = options;
-  }
-  async split(content) {
-    const language = content.match(/^```(\w+)\n/)?.[1];
-    const strippedContent = content.replace(/^```(\w*)\n/, "").replace(/```\s*$/, "");
-    const lines = strippedContent.split("\n");
-    const chunks = [];
-    let currentChunkLines = [];
-    for (const line of lines) {
-      const singleLineSize = this.wrap(line, language).length;
-      if (singleLineSize > this.options.chunkSize) {
-        throw new MinimumChunkSizeError(singleLineSize, this.options.chunkSize);
-      }
-      currentChunkLines.push(line);
-      const newChunkContent = this.wrap(currentChunkLines.join("\n"), language);
-      const newChunkSize = newChunkContent.length;
-      if (newChunkSize > this.options.chunkSize && currentChunkLines.length > 1) {
-        const lastLine = currentChunkLines.pop();
-        chunks.push(this.wrap(currentChunkLines.join("\n"), language));
-        currentChunkLines = [lastLine];
-      }
-    }
-    if (currentChunkLines.length > 0) {
-      chunks.push(this.wrap(currentChunkLines.join("\n"), language));
+function resolveProtocol(protocol) {
+  if (protocol === "auto") {
+    if (!process.stdin.isTTY && !process.stdout.isTTY) {
+      return "stdio";
     }
-    return chunks;
+    return "http";
   }
-  wrap(content, language) {
-    return `\`\`\`${language || ""}
-${content.replace(/\n+$/, "")}
-\`\`\``;
+  if (protocol === "stdio" || protocol === "http") {
+    return protocol;
   }
+  throw new Error(`Invalid protocol: ${protocol}. Must be 'auto', 'stdio', or 'http'`);
 }
-class TableContentSplitter {
-  constructor(options) {
-    this.options = options;
-  }
-  /**
-   * Splits table content into chunks while preserving table structure
-   */
-  async split(content) {
-    const parsedTable = this.parseTable(content);
-    if (!parsedTable) {
-      return [content];
-    }
-    const { headers, rows } = parsedTable;
-    const chunks = [];
-    let currentRows = [];
-    for (const row of rows) {
-      const singleRowSize = this.wrap(row, headers).length;
-      if (singleRowSize > this.options.chunkSize) {
-        throw new MinimumChunkSizeError(singleRowSize, this.options.chunkSize);
-      }
-      const newChunkContent = this.wrap([...currentRows, row].join("\n"), headers);
-      const newChunkSize = newChunkContent.length;
-      if (newChunkSize > this.options.chunkSize && currentRows.length > 0) {
-        chunks.push(this.wrap(currentRows.join("\n"), headers));
-        currentRows = [row];
-      } else {
-        currentRows.push(row);
-      }
-    }
-    if (currentRows.length > 0) {
-      chunks.push(this.wrap(currentRows.join("\n"), headers));
-    }
-    return chunks;
-  }
-  wrap(content, headers) {
-    const headerRow = `| ${headers.join(" | ")} |`;
-    const separatorRow = `|${headers.map(() => "---").join("|")}|`;
-    return [headerRow, separatorRow, content].join("\n");
-  }
-  parseTable(content) {
-    const lines = content.trim().split("\n");
-    if (lines.length < 3) return null;
-    const headers = this.parseRow(lines[0]);
-    if (!headers) return null;
-    const separator = lines[1];
-    if (!this.isValidSeparator(separator)) return null;
-    const rows = lines.slice(2).filter((row) => row.trim() !== "");
-    return { headers, separator, rows };
-  }
-  /**
-   * Parses a table row into cells
-   */
-  parseRow(row) {
-    if (!row.includes("|")) return null;
-    return row.split("|").map((cell) => cell.trim()).filter((cell) => cell !== "");
+const formatOutput = (data) => JSON.stringify(data, null, 2);
+function setupLogging(options, protocol) {
+  if (options.silent) {
+    setLogLevel(LogLevel.ERROR);
+  } else if (options.verbose) {
+    setLogLevel(LogLevel.DEBUG);
   }
-  /**
-   * Validates the separator row of the table
-   */
-  isValidSeparator(separator) {
-    return separator.includes("|") && /^\|?[\s-|]+\|?$/.test(separator);
+  if (protocol === "stdio") {
+    setLogLevel(LogLevel.ERROR);
   }
 }
-class TextContentSplitter {
-  constructor(options) {
-    this.options = options;
+function validatePort(portString) {
+  const port = Number.parseInt(portString, 10);
+  if (Number.isNaN(port) || port < 1 || port > 65535) {
+    throw new Error("❌ Invalid port number");
   }
-  /**
-   * Splits text content into chunks while trying to preserve semantic boundaries.
-   * Prefers paragraph breaks, then line breaks, finally falling back to word boundaries.
-   */
-  async split(content) {
-    const trimmedContent = fullTrim(content);
-    if (trimmedContent.length <= this.options.chunkSize) {
-      return [trimmedContent];
-    }
-    const words = trimmedContent.split(/\s+/);
-    const longestWord = words.reduce(
-      (max, word) => word.length > max.length ? word : max
-    );
-    if (longestWord.length > this.options.chunkSize) {
-      throw new MinimumChunkSizeError(longestWord.length, this.options.chunkSize);
-    }
-    const paragraphChunks = this.splitByParagraphs(trimmedContent);
-    if (this.areChunksValid(paragraphChunks)) {
-      return paragraphChunks;
+  return port;
+}
+async function createPipelineWithCallbacks(docService, options = {}) {
+  logger.debug(`Initializing pipeline with options: ${JSON.stringify(options)}`);
+  const { serverUrl, ...rest } = options;
+  const pipeline = serverUrl ? await PipelineFactory.createPipeline(void 0, { serverUrl, ...rest }) : await (async () => {
+    if (!docService) {
+      throw new Error("Local pipeline requires a DocumentManagementService instance");
     }
-    const lineChunks = this.splitByLines(trimmedContent);
-    if (this.areChunksValid(lineChunks)) {
-      return this.mergeChunks(lineChunks, "\n");
+    return PipelineFactory.createPipeline(docService, rest);
+  })();
+  pipeline.setCallbacks({
+    onJobProgress: async (job, progress) => {
+      logger.debug(
+        `📊 Job ${job.id} progress: ${progress.pagesScraped}/${progress.totalPages} pages`
+      );
+    },
+    onJobStatusChange: async (job) => {
+      logger.debug(`🔄 Job ${job.id} status changed to: ${job.status}`);
+    },
+    onJobError: async (job, error, document) => {
+      logger.warn(
+        `⚠️ Job ${job.id} error ${document ? `on document ${document.metadata.url}` : ""}: ${error.message}`
+      );
     }
-    const wordChunks = await this.splitByWords(trimmedContent);
-    return this.mergeChunks(wordChunks, " ");
-  }
-  /**
-   * Checks if all chunks are within the maximum size limit
-   */
-  areChunksValid(chunks) {
-    return chunks.every((chunk) => chunk.length <= this.options.chunkSize);
-  }
-  /**
-   * Splits text into chunks by paragraph boundaries (double newlines)
-   */
-  splitByParagraphs(text) {
-    const paragraphs = text.split(/\n\s*\n/).map((p) => fullTrim(p)).filter(Boolean);
-    return paragraphs.filter((chunk) => chunk.length > 2);
-  }
-  /**
-   * Splits text into chunks by line boundaries
-   */
-  splitByLines(text) {
-    const lines = text.split(/\n/).map((line) => fullTrim(line)).filter(Boolean);
-    return lines.filter((chunk) => chunk.length > 1);
-  }
-  /**
-   * Uses LangChain's recursive splitter for word-based splitting as a last resort
-   */
-  async splitByWords(text) {
-    const splitter = new RecursiveCharacterTextSplitter({
-      chunkSize: this.options.chunkSize,
-      chunkOverlap: 0
-    });
-    const chunks = await splitter.splitText(text);
-    return chunks;
-  }
-  /**
-   * Attempts to merge small chunks with previous chunks to minimize fragmentation.
-   * Only merges if combined size is within maxChunkSize.
-   */
-  mergeChunks(chunks, separator) {
-    const mergedChunks = [];
-    let currentChunk = null;
-    for (const chunk of chunks) {
-      if (currentChunk === null) {
-        currentChunk = chunk;
-        continue;
-      }
-      const currentChunkSize = this.getChunkSize(currentChunk);
-      const nextChunkSize = this.getChunkSize(chunk);
-      if (currentChunkSize + nextChunkSize + separator.length <= this.options.chunkSize) {
-        currentChunk = `${currentChunk}${separator}${chunk}`;
-      } else {
-        mergedChunks.push(currentChunk);
-        currentChunk = chunk;
+  });
+  return pipeline;
+}
+function createAppServerConfig(options) {
+  return {
+    enableWebInterface: options.enableWebInterface ?? false,
+    enableMcpServer: options.enableMcpServer ?? true,
+    enableApiServer: options.enableApiServer ?? false,
+    enableWorker: options.enableWorker ?? true,
+    port: options.port,
+    externalWorkerUrl: options.externalWorkerUrl
+  };
+}
+function parseHeaders(headerOptions) {
+  const headers = {};
+  if (Array.isArray(headerOptions)) {
+    for (const entry of headerOptions) {
+      const idx = entry.indexOf(":");
+      if (idx > 0) {
+        const name = entry.slice(0, idx).trim();
+        const value = entry.slice(idx + 1).trim();
+        if (name) headers[name] = value;
       }
     }
-    if (currentChunk) {
-      mergedChunks.push(currentChunk);
-    }
-    return mergedChunks;
-  }
-  getChunkSize(chunk) {
-    return chunk.length;
-  }
-  wrap(content) {
-    return content;
   }
-}
-class SemanticMarkdownSplitter {
-  constructor(preferredChunkSize, maxChunkSize) {
-    this.preferredChunkSize = preferredChunkSize;
-    this.maxChunkSize = maxChunkSize;
-    this.turndownService = new TurndownService({
-      headingStyle: "atx",
-      hr: "---",
-      bulletListMarker: "-",
-      codeBlockStyle: "fenced",
-      emDelimiter: "_",
-      strongDelimiter: "**",
-      linkStyle: "inlined"
-    });
-    this.turndownService.addRule("table", {
-      filter: ["table"],
-      replacement: (_content, node) => {
-        const table = node;
-        const headers = Array.from(table.querySelectorAll("th")).map(
-          (th) => th.textContent?.trim() || ""
-        );
-        const rows = Array.from(table.querySelectorAll("tr")).filter(
-          (tr) => !tr.querySelector("th")
-        );
-        if (headers.length === 0 && rows.length === 0) return "";
-        let markdown = "\n";
-        if (headers.length > 0) {
-          markdown += `| ${headers.join(" | ")} |
-`;
-          markdown += `|${headers.map(() => "---").join("|")}|
-`;
-        }
-        for (const row of rows) {
-          const cells = Array.from(row.querySelectorAll("td")).map(
-            (td) => td.textContent?.trim() || ""
-          );
-          markdown += `| ${cells.join(" | ")} |
-`;
-        }
-        return markdown;
-      }
-    });
-    this.textSplitter = new TextContentSplitter({
-      chunkSize: this.preferredChunkSize
-    });
-    this.codeSplitter = new CodeContentSplitter({
-      chunkSize: this.maxChunkSize
-    });
-    this.tableSplitter = new TableContentSplitter({
-      chunkSize: this.maxChunkSize
-    });
-  }
-  turndownService;
-  textSplitter;
-  codeSplitter;
-  tableSplitter;
-  /**
-   * Main entry point for splitting markdown content
-   */
-  async splitText(markdown) {
-    const html = await this.markdownToHtml(markdown);
-    const dom = await this.parseHtml(html);
-    const sections = await this.splitIntoSections(dom);
-    return this.splitSectionContent(sections);
-  }
-  /**
-   * Step 1: Split document into sections based on H1-H6 headings,
-   * as well as code blocks and tables.
-   */
-  async splitIntoSections(dom) {
-    const body = dom.querySelector("body");
-    if (!body) {
-      throw new Error("Invalid HTML structure: no body element found");
-    }
-    let currentSection = this.createRootSection();
-    const sections = [];
-    const stack = [currentSection];
-    for (const element of Array.from(body.children)) {
-      const headingMatch = element.tagName.match(/H([1-6])/);
-      if (headingMatch) {
-        const level = Number.parseInt(headingMatch[1], 10);
-        const title = fullTrim(element.textContent || "");
-        while (stack.length > 1 && stack[stack.length - 1].level >= level) {
-          stack.pop();
-        }
-        currentSection = {
-          level,
-          path: [
-            ...stack.slice(1).reduce((acc, s) => {
-              const lastPath = s.path[s.path.length - 1];
-              if (lastPath) acc.push(lastPath);
-              return acc;
-            }, []),
-            title
-          ],
-          content: [
-            {
-              type: "heading",
-              text: `${"#".repeat(level)} ${title}`
-            }
-          ]
-        };
-        sections.push(currentSection);
-        stack.push(currentSection);
-      } else if (element.tagName === "PRE") {
-        const code = element.querySelector("code");
-        const language = code?.className.replace("language-", "") || "";
-        const content = code?.textContent || element.textContent || "";
-        const markdown = `${"```"}${language}
-${content}
-${"```"}`;
-        currentSection = {
-          level: currentSection.level,
-          path: currentSection.path,
-          content: [
-            {
-              type: "code",
-              text: markdown
-            }
-          ]
-        };
-        sections.push(currentSection);
-      } else if (element.tagName === "TABLE") {
-        const markdown = fullTrim(this.turndownService.turndown(element.outerHTML));
-        currentSection = {
-          level: currentSection.level,
-          path: currentSection.path,
-          content: [
-            {
-              type: "table",
-              text: markdown
-            }
-          ]
-        };
-        sections.push(currentSection);
-      } else {
-        const markdown = fullTrim(this.turndownService.turndown(element.innerHTML));
-        if (markdown) {
-          currentSection = {
-            level: currentSection.level,
-            path: currentSection.path,
-            content: [
-              {
-                type: "text",
-                text: markdown
-              }
-            ]
-          };
-          sections.push(currentSection);
-        }
-      }
-    }
-    return sections;
-  }
-  /**
-   * Step 2: Split section content into smaller chunks
-   */
-  async splitSectionContent(sections) {
-    const chunks = [];
-    for (const section of sections) {
-      for (const content of section.content) {
-        let splitContent = [];
-        try {
-          switch (content.type) {
-            case "heading":
-            case "text": {
-              splitContent = await this.textSplitter.split(content.text);
-              break;
-            }
-            case "code": {
-              splitContent = await this.codeSplitter.split(content.text);
-              break;
-            }
-            case "table": {
-              splitContent = await this.tableSplitter.split(content.text);
-              break;
-            }
-          }
-        } catch (err) {
-          if (err instanceof MinimumChunkSizeError) {
-            logger.warn(
-              `⚠ Cannot split ${content.type} chunk normally, using RecursiveCharacterTextSplitter: ${err.message}`
-            );
-            const splitter = new RecursiveCharacterTextSplitter({
-              chunkSize: this.maxChunkSize,
-              chunkOverlap: Math.min(20, Math.floor(this.maxChunkSize * 0.1)),
-              // Use more aggressive separators including empty string as last resort
-              separators: [
-                "\n\n",
-                "\n",
-                " ",
-                "	",
-                ".",
-                ",",
-                ";",
-                ":",
-                "-",
-                "(",
-                ")",
-                "[",
-                "]",
-                "{",
-                "}",
-                ""
-              ]
-            });
-            const chunks2 = await splitter.splitText(content.text);
-            if (chunks2.length === 0) {
-              splitContent = [content.text.substring(0, this.maxChunkSize)];
-            } else {
-              splitContent = chunks2;
-            }
-          } else {
-            const errMessage = err instanceof Error ? err.message : String(err);
-            throw new ContentSplitterError(
-              `Failed to split ${content.type} content: ${errMessage}`
-            );
-          }
-        }
-        chunks.push(
-          ...splitContent.map(
-            (text) => ({
-              types: [content.type],
-              content: text,
-              section: {
-                level: section.level,
-                path: section.path
-              }
-            })
-          )
-        );
-      }
-    }
-    return chunks;
-  }
-  /**
-   * Helper to create the root section
-   */
-  createRootSection() {
-    return {
-      level: 0,
-      path: [],
-      content: []
-    };
-  }
-  /**
-   * Convert markdown to HTML using remark
-   */
-  async markdownToHtml(markdown) {
-    const html = await unified().use(remarkParse).use(remarkGfm).use(remarkHtml).process(markdown);
-    return `<!DOCTYPE html>
-      <html>
-        <body>
-          ${String(html)}
-        </body>
-      </html>`;
-  }
-  /**
-   * Parse HTML
-   */
-  async parseHtml(html) {
-    const { window } = createJSDOM(html);
-    return window.document;
-  }
-}
-const CHILD_LIMIT = 5;
-const SIBLING_LIMIT = 2;
-class DocumentRetrieverService {
-  documentStore;
-  constructor(documentStore) {
-    this.documentStore = documentStore;
-  }
-  /**
-   * Collects all related chunk IDs for a given initial hit.
-   * Returns an object with url, hitId, relatedIds (Set), and score.
-   */
-  async getRelatedChunkIds(library, version2, doc, siblingLimit = SIBLING_LIMIT, childLimit = CHILD_LIMIT) {
-    const id = doc.id;
-    const url = doc.metadata.url;
-    const score = doc.metadata.score;
-    const relatedIds = /* @__PURE__ */ new Set();
-    relatedIds.add(id);
-    const parent = await this.documentStore.findParentChunk(library, version2, id);
-    if (parent) {
-      relatedIds.add(parent.id);
-    }
-    const precedingSiblings = await this.documentStore.findPrecedingSiblingChunks(
-      library,
-      version2,
-      id,
-      siblingLimit
-    );
-    for (const sib of precedingSiblings) {
-      relatedIds.add(sib.id);
-    }
-    const childChunks = await this.documentStore.findChildChunks(
-      library,
-      version2,
-      id,
-      childLimit
-    );
-    for (const child of childChunks) {
-      relatedIds.add(child.id);
-    }
-    const subsequentSiblings = await this.documentStore.findSubsequentSiblingChunks(
-      library,
-      version2,
-      id,
-      siblingLimit
-    );
-    for (const sib of subsequentSiblings) {
-      relatedIds.add(sib.id);
-    }
-    return { url, hitId: id, relatedIds, score };
-  }
-  /**
-   * Groups related chunk info by URL, deduplicates IDs, and finds max score per URL.
-   */
-  groupAndPrepareFetch(relatedInfos) {
-    const urlMap = /* @__PURE__ */ new Map();
-    for (const info of relatedInfos) {
-      let entry = urlMap.get(info.url);
-      if (!entry) {
-        entry = { uniqueChunkIds: /* @__PURE__ */ new Set(), maxScore: info.score };
-        urlMap.set(info.url, entry);
-      }
-      for (const id of info.relatedIds) {
-        entry.uniqueChunkIds.add(id);
-      }
-      if (info.score > entry.maxScore) {
-        entry.maxScore = info.score;
-      }
-    }
-    return urlMap;
-  }
-  /**
-   * Finalizes the merged result for a URL group by fetching, sorting, and joining content.
-   */
-  async finalizeResult(library, version2, url, uniqueChunkIds, maxScore) {
-    const ids = Array.from(uniqueChunkIds);
-    const docs = await this.documentStore.findChunksByIds(library, version2, ids);
-    const content = docs.map((d) => d.pageContent).join("\n\n");
-    return {
-      url,
-      content,
-      score: maxScore
-    };
-  }
-  /**
-   * Searches for documents and expands the context around the matches.
-   * @param library The library name.
-   * @param version The library version.
-   * @param query The search query.
-   * @param version The library version (optional, defaults to searching documents without a version).
-   * @param query The search query.
-   * @param limit The optional limit for the initial search results.
-   * @returns An array of strings representing the aggregated content of the retrieved chunks.
-   */
-  async search(library, version2, query, limit) {
-    const normalizedVersion = (version2 ?? "").toLowerCase();
-    const initialResults = await this.documentStore.findByContent(
-      library,
-      normalizedVersion,
-      query,
-      limit ?? 10
-    );
-    const relatedInfos = await Promise.all(
-      initialResults.map(
-        (doc) => this.getRelatedChunkIds(library, normalizedVersion, doc)
-      )
-    );
-    const urlMap = this.groupAndPrepareFetch(relatedInfos);
-    const results = [];
-    for (const [url, { uniqueChunkIds, maxScore }] of urlMap.entries()) {
-      const result = await this.finalizeResult(
-        library,
-        normalizedVersion,
-        url,
-        uniqueChunkIds,
-        maxScore
-      );
-      results.push(result);
-    }
-    return results;
-  }
-}
-class StoreError extends Error {
-  constructor(message, cause) {
-    super(cause ? `${message} caused by ${cause}` : message);
-    this.cause = cause;
-    this.name = this.constructor.name;
-    const causeError = cause instanceof Error ? cause : cause ? new Error(String(cause)) : void 0;
-    if (causeError?.stack) {
-      this.stack = causeError.stack;
-    }
-  }
-}
-class DimensionError extends StoreError {
-  constructor(modelName, modelDimension, dbDimension) {
-    super(
-      `Model "${modelName}" produces ${modelDimension}-dimensional vectors, which exceeds the database's fixed dimension of ${dbDimension}. Please use a model with dimension ≤ ${dbDimension}.`
-    );
-    this.modelName = modelName;
-    this.modelDimension = modelDimension;
-    this.dbDimension = dbDimension;
-  }
-}
-class ConnectionError extends StoreError {
-}
-const MIGRATIONS_DIR = path.join(getProjectRoot(), "db", "migrations");
-const MIGRATIONS_TABLE = "_schema_migrations";
-function ensureMigrationsTable(db) {
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS ${MIGRATIONS_TABLE} (
-      id TEXT PRIMARY KEY,
-      applied_at DATETIME DEFAULT CURRENT_TIMESTAMP
-    );
-  `);
-}
-function getAppliedMigrations(db) {
-  const stmt = db.prepare(`SELECT id FROM ${MIGRATIONS_TABLE}`);
-  const rows = stmt.all();
-  return new Set(rows.map((row) => row.id));
-}
-async function applyMigrations(db) {
-  try {
-    db.pragma("journal_mode = OFF");
-    db.pragma("synchronous = OFF");
-    db.pragma("mmap_size = 268435456");
-    db.pragma("cache_size = -64000");
-    db.pragma("temp_store = MEMORY");
-    logger.debug("Applied performance optimizations for migration");
-  } catch (_error) {
-    logger.warn("⚠️ Could not apply all performance optimizations for migration");
-  }
-  const overallTransaction = db.transaction(() => {
-    logger.debug("Checking database migrations...");
-    ensureMigrationsTable(db);
-    const appliedMigrations = getAppliedMigrations(db);
-    if (!fs$1.existsSync(MIGRATIONS_DIR)) {
-      throw new StoreError("Migrations directory not found");
-    }
-    const migrationFiles = fs$1.readdirSync(MIGRATIONS_DIR).filter((file) => file.endsWith(".sql")).sort();
-    const pendingMigrations = migrationFiles.filter(
-      (filename) => !appliedMigrations.has(filename)
-    );
-    if (pendingMigrations.length > 0) {
-      logger.info(`🔄 Applying ${pendingMigrations.length} database migration(s)...`);
-    }
-    let appliedCount = 0;
-    for (const filename of pendingMigrations) {
-      logger.debug(`Applying migration: ${filename}`);
-      const filePath = path.join(MIGRATIONS_DIR, filename);
-      const sql = fs$1.readFileSync(filePath, "utf8");
-      try {
-        db.exec(sql);
-        const insertStmt = db.prepare(`INSERT INTO ${MIGRATIONS_TABLE} (id) VALUES (?)`);
-        insertStmt.run(filename);
-        logger.debug(`✅ Applied migration: ${filename}`);
-        appliedCount++;
-      } catch (error) {
-        logger.error(`❌ Failed to apply migration: ${filename} - ${error}`);
-        throw new StoreError(`Migration failed: ${filename}`, error);
-      }
-    }
-    if (appliedCount > 0) {
-      logger.info(`✅ Successfully applied ${appliedCount} migration(s)`);
-    } else {
-      logger.debug("Database schema is up to date");
-    }
-    return appliedCount;
-  });
-  let retries = 0;
-  let appliedMigrationsCount = 0;
-  while (true) {
-    try {
-      appliedMigrationsCount = overallTransaction.immediate();
-      logger.debug("Database migrations completed successfully");
-      if (appliedMigrationsCount > 0) {
-        try {
-          logger.debug(
-            `Running VACUUM after applying ${appliedMigrationsCount} migration(s)...`
-          );
-          db.exec("VACUUM");
-          logger.debug("Database vacuum completed successfully");
-        } catch (error) {
-          logger.warn(`⚠️ Could not vacuum database after migrations: ${error}`);
-        }
-      } else {
-        logger.debug("Skipping VACUUM - no migrations were applied");
-      }
-      break;
-    } catch (error) {
-      if (error?.code === "SQLITE_BUSY" && retries < MIGRATION_MAX_RETRIES) {
-        retries++;
-        logger.warn(
-          `⚠️  Migrations busy (SQLITE_BUSY), retrying attempt ${retries}/${MIGRATION_MAX_RETRIES} in ${MIGRATION_RETRY_DELAY_MS}ms...`
-        );
-        await new Promise((resolve) => setTimeout(resolve, MIGRATION_RETRY_DELAY_MS));
-      } else {
-        if (error?.code === "SQLITE_BUSY") {
-          logger.error(
-            `❌ Migrations still busy after ${MIGRATION_MAX_RETRIES} retries. Giving up: ${error}`
-          );
-        }
-        if (error instanceof StoreError) {
-          throw error;
-        }
-        throw new StoreError("Failed during migration process", error);
-      }
-    }
-  }
-  try {
-    db.pragma("journal_mode = WAL");
-    db.pragma("wal_autocheckpoint = 1000");
-    db.pragma("busy_timeout = 30000");
-    db.pragma("foreign_keys = ON");
-    db.pragma("synchronous = NORMAL");
-    logger.debug(
-      "Applied production database configuration (WAL mode, autocheckpoint, foreign keys, busy timeout)"
-    );
-  } catch (_error) {
-    logger.warn("⚠️ Could not apply all production database settings");
-  }
-}
-class DocumentStore {
-  db;
-  embeddings;
-  dbDimension = VECTOR_DIMENSION;
-  modelDimension;
-  statements;
-  /**
-   * Calculates Reciprocal Rank Fusion score for a result
-   */
-  calculateRRF(vecRank, ftsRank, k = 60) {
-    let rrf = 0;
-    if (vecRank !== void 0) {
-      rrf += 1 / (k + vecRank);
-    }
-    if (ftsRank !== void 0) {
-      rrf += 1 / (k + ftsRank);
-    }
-    return rrf;
-  }
-  /**
-   * Assigns ranks to search results based on their scores
-   */
-  assignRanks(results) {
-    const vecRanks = /* @__PURE__ */ new Map();
-    const ftsRanks = /* @__PURE__ */ new Map();
-    results.filter((r) => r.vec_score !== void 0).sort((a, b) => (b.vec_score ?? 0) - (a.vec_score ?? 0)).forEach((result, index) => {
-      vecRanks.set(Number(result.id), index + 1);
-    });
-    results.filter((r) => r.fts_score !== void 0).sort((a, b) => (b.fts_score ?? 0) - (a.fts_score ?? 0)).forEach((result, index) => {
-      ftsRanks.set(Number(result.id), index + 1);
-    });
-    return results.map((result) => ({
-      ...result,
-      vec_rank: vecRanks.get(Number(result.id)),
-      fts_rank: ftsRanks.get(Number(result.id)),
-      rrf_score: this.calculateRRF(
-        vecRanks.get(Number(result.id)),
-        ftsRanks.get(Number(result.id))
-      )
-    }));
-  }
-  constructor(dbPath) {
-    if (!dbPath) {
-      throw new StoreError("Missing required database path");
-    }
-    this.db = new Database(dbPath);
-  }
-  /**
-   * Sets up prepared statements for database queries
-   */
-  prepareStatements() {
-    const statements = {
-      getById: this.db.prepare("SELECT * FROM documents WHERE id = ?"),
-      insertDocument: this.db.prepare(
-        "INSERT INTO documents (library_id, version_id, url, content, metadata, sort_order, indexed_at) VALUES (?, ?, ?, ?, ?, ?, ?)"
-      ),
-      insertEmbedding: this.db.prepare(
-        "INSERT INTO documents_vec (rowid, library_id, version_id, embedding) VALUES (?, ?, ?, ?)"
-      ),
-      insertLibrary: this.db.prepare(
-        "INSERT INTO libraries (name) VALUES (?) ON CONFLICT(name) DO NOTHING"
-      ),
-      getLibraryIdByName: this.db.prepare(
-        "SELECT id FROM libraries WHERE name = ?"
-      ),
-      // New version-related statements
-      insertVersion: this.db.prepare(
-        "INSERT INTO versions (library_id, name, status) VALUES (?, ?, 'not_indexed') ON CONFLICT(library_id, name) DO NOTHING"
-      ),
-      resolveVersionId: this.db.prepare(
-        "SELECT id FROM versions WHERE library_id = ? AND name IS ?"
-      ),
-      getVersionById: this.db.prepare("SELECT * FROM versions WHERE id = ?"),
-      queryVersionsByLibraryId: this.db.prepare(
-        "SELECT * FROM versions WHERE library_id = ? ORDER BY name"
-      ),
-      deleteLibraryDocuments: this.db.prepare(
-        `DELETE FROM documents
-         WHERE library_id = (SELECT id FROM libraries WHERE name = ?)
-         AND version_id = (
-           SELECT v.id FROM versions v 
-           WHERE v.library_id = (SELECT id FROM libraries WHERE name = ?)
-           AND COALESCE(v.name, '') = COALESCE(?, '')
-         )`
-      ),
-      deleteDocuments: this.db.prepare(
-        `DELETE FROM documents
-         WHERE library_id = (SELECT id FROM libraries WHERE name = ?)
-         AND version_id = (
-           SELECT v.id FROM versions v 
-           WHERE v.library_id = (SELECT id FROM libraries WHERE name = ?)
-           AND COALESCE(v.name, '') = COALESCE(?, '')
-         )`
-      ),
-      deleteDocumentsByUrl: this.db.prepare(
-        `DELETE FROM documents
-         WHERE url = ?
-         AND library_id = (SELECT id FROM libraries WHERE name = ?)
-         AND version_id = (
-           SELECT v.id FROM versions v 
-           WHERE v.library_id = (SELECT id FROM libraries WHERE name = ?)
-           AND COALESCE(v.name, '') = COALESCE(?, '')
-         )`
-      ),
-      getDocumentBySort: this.db.prepare(
-        `SELECT d.id
-         FROM documents d
-         JOIN versions v ON d.version_id = v.id
-         JOIN libraries l ON v.library_id = l.id
-         WHERE l.name = ?
-         AND COALESCE(v.name, '') = COALESCE(?, '')
-         LIMIT 1`
-      ),
-      queryVersions: this.db.prepare(
-        `SELECT DISTINCT v.name
-         FROM versions v
-         JOIN libraries l ON v.library_id = l.id
-         WHERE l.name = ?
-         ORDER BY v.name`
-      ),
-      checkExists: this.db.prepare(
-        `SELECT d.id FROM documents d
-         JOIN versions v ON d.version_id = v.id
-         JOIN libraries l ON v.library_id = l.id
-         WHERE l.name = ?
-         AND COALESCE(v.name, '') = COALESCE(?, '')
-         LIMIT 1`
-      ),
-      queryLibraryVersions: this.db.prepare(
-        `SELECT
-          l.name as library,
-          v.name as version,
-          COUNT(*) as documentCount,
-          COUNT(DISTINCT d.url) as uniqueUrlCount,
-          MIN(d.indexed_at) as indexedAt
-        FROM documents d
-        JOIN versions v ON d.version_id = v.id
-        JOIN libraries l ON v.library_id = l.id
-        GROUP BY l.name, v.name
-        ORDER BY l.name, v.name`
-      ),
-      getChildChunks: this.db.prepare(`
-        SELECT d.* FROM documents d
-        JOIN versions v ON d.version_id = v.id
-        JOIN libraries l ON v.library_id = l.id
-        WHERE l.name = ?
-        AND COALESCE(v.name, '') = COALESCE(?, '')
-        AND d.url = ?
-        AND json_array_length(json_extract(d.metadata, '$.path')) = ?
-        AND json_extract(d.metadata, '$.path') LIKE ? || '%'
-        AND d.sort_order > (SELECT sort_order FROM documents WHERE id = ?)
-        ORDER BY d.sort_order
-        LIMIT ?
-      `),
-      getPrecedingSiblings: this.db.prepare(`
-        SELECT d.* FROM documents d
-        JOIN versions v ON d.version_id = v.id
-        JOIN libraries l ON v.library_id = l.id
-        WHERE l.name = ?
-        AND COALESCE(v.name, '') = COALESCE(?, '')
-        AND d.url = ?
-        AND d.sort_order < (SELECT sort_order FROM documents WHERE id = ?)
-        AND json_extract(d.metadata, '$.path') = ?
-        ORDER BY d.sort_order DESC
-        LIMIT ?
-      `),
-      getSubsequentSiblings: this.db.prepare(`
-        SELECT d.* FROM documents d
-        JOIN versions v ON d.version_id = v.id
-        JOIN libraries l ON v.library_id = l.id
-        WHERE l.name = ?
-        AND COALESCE(v.name, '') = COALESCE(?, '')
-        AND d.url = ?
-        AND d.sort_order > (SELECT sort_order FROM documents WHERE id = ?)
-        AND json_extract(d.metadata, '$.path') = ?
-        ORDER BY d.sort_order
-        LIMIT ?
-      `),
-      getParentChunk: this.db.prepare(`
-        SELECT d.* FROM documents d
-        JOIN versions v ON d.version_id = v.id
-        JOIN libraries l ON v.library_id = l.id
-        WHERE l.name = ?
-        AND COALESCE(v.name, '') = COALESCE(?, '')
-        AND d.url = ?
-        AND json_extract(d.metadata, '$.path') = ?
-        AND d.sort_order < (SELECT sort_order FROM documents WHERE id = ?)
-        ORDER BY d.sort_order DESC
-        LIMIT 1
-      `),
-      // Status tracking statements
-      updateVersionStatus: this.db.prepare(
-        "UPDATE versions SET status = ?, error_message = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?"
-      ),
-      updateVersionProgress: this.db.prepare(
-        "UPDATE versions SET progress_pages = ?, progress_max_pages = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?"
-      ),
-      getVersionsByStatus: this.db.prepare(
-        "SELECT v.*, l.name as library_name FROM versions v JOIN libraries l ON v.library_id = l.id WHERE v.status IN (SELECT value FROM json_each(?))"
-      ),
-      getRunningVersions: this.db.prepare(
-        "SELECT v.*, l.name as library_name FROM versions v JOIN libraries l ON v.library_id = l.id WHERE v.status = 'running' ORDER BY v.started_at"
-      ),
-      getActiveVersions: this.db.prepare(
-        "SELECT v.*, l.name as library_name FROM versions v JOIN libraries l ON v.library_id = l.id WHERE v.status IN ('queued', 'running', 'updating') ORDER BY v.created_at"
-      ),
-      // Scraper options statements
-      updateVersionScraperOptions: this.db.prepare(
-        "UPDATE versions SET source_url = ?, scraper_options = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?"
-      ),
-      getVersionWithOptions: this.db.prepare(
-        "SELECT * FROM versions WHERE id = ?"
-      ),
-      getVersionsBySourceUrl: this.db.prepare(
-        "SELECT v.*, l.name as library_name FROM versions v JOIN libraries l ON v.library_id = l.id WHERE v.source_url = ? ORDER BY v.created_at DESC"
-      )
-    };
-    this.statements = statements;
-  }
-  /**
-   * Pads a vector to the fixed database dimension by appending zeros.
-   * Throws an error if the input vector is longer than the database dimension.
-   */
-  padVector(vector) {
-    if (vector.length > this.dbDimension) {
-      throw new Error(
-        `Vector dimension ${vector.length} exceeds database dimension ${this.dbDimension}`
-      );
-    }
-    if (vector.length === this.dbDimension) {
-      return vector;
-    }
-    return [...vector, ...new Array(this.dbDimension - vector.length).fill(0)];
-  }
-  /**
-   * Initializes embeddings client using environment variables for configuration.
-   *
-   * The embedding model is configured using DOCS_MCP_EMBEDDING_MODEL environment variable.
-   * Format: "provider:model_name" (e.g., "google:text-embedding-004") or just "model_name"
-   * for OpenAI (default).
-   *
-   * Supported providers and their required environment variables:
-   * - openai: OPENAI_API_KEY (and optionally OPENAI_API_BASE, OPENAI_ORG_ID)
-   * - google: GOOGLE_APPLICATION_CREDENTIALS (path to service account JSON)
-   * - aws: AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_REGION (or BEDROCK_AWS_REGION)
-   * - microsoft: Azure OpenAI credentials (AZURE_OPENAI_API_*)
-   */
-  async initializeEmbeddings() {
-    const modelSpec = process.env.DOCS_MCP_EMBEDDING_MODEL || "text-embedding-3-small";
-    const { createEmbeddingModel } = await import("./EmbeddingFactory-CElwVk3X.js");
-    this.embeddings = createEmbeddingModel(modelSpec);
-    const testVector = await this.embeddings.embedQuery("test");
-    this.modelDimension = testVector.length;
-    if (this.modelDimension > this.dbDimension) {
-      throw new DimensionError(modelSpec, this.modelDimension, this.dbDimension);
-    }
-  }
-  /**
-   * Escapes a query string for use with SQLite FTS5 MATCH operator.
-   * Wraps the query in double quotes and escapes internal double quotes.
-   */
-  escapeFtsQuery(query) {
-    const escapedQuotes = query.replace(/"/g, '""');
-    return `"${escapedQuotes}"`;
-  }
-  /**
-   * Initializes database connection and ensures readiness
-   */
-  async initialize() {
-    try {
-      sqliteVec.load(this.db);
-      applyMigrations(this.db);
-      this.prepareStatements();
-      await this.initializeEmbeddings();
-    } catch (error) {
-      if (error instanceof StoreError) {
-        throw error;
-      }
-      throw new ConnectionError("Failed to initialize database connection", error);
-    }
-  }
-  /**
-   * Gracefully closes database connections
-   */
-  async shutdown() {
-    this.db.close();
-  }
-  /**
-   * Resolves a library name and version string to library_id and version_id.
-   * Creates library and version records if they don't exist.
-   */
-  async resolveLibraryAndVersionIds(library, version2) {
-    const normalizedLibrary = library.toLowerCase();
-    const normalizedVersion = denormalizeVersionName(version2.toLowerCase());
-    this.statements.insertLibrary.run(normalizedLibrary);
-    const libraryIdRow = this.statements.getLibraryIdByName.get(normalizedLibrary);
-    if (!libraryIdRow || typeof libraryIdRow.id !== "number") {
-      throw new StoreError(`Failed to resolve library_id for library: ${library}`);
-    }
-    const libraryId = libraryIdRow.id;
-    this.statements.insertVersion.run(libraryId, normalizedVersion);
-    const versionIdRow = this.statements.resolveVersionId.get(
-      libraryId,
-      normalizedVersion
-    );
-    if (!versionIdRow || typeof versionIdRow.id !== "number") {
-      throw new StoreError(
-        `Failed to resolve version_id for library: ${library}, version: ${version2}`
-      );
-    }
-    return { libraryId, versionId: versionIdRow.id };
-  }
-  /**
-   * Retrieves all unique versions for a specific library
-   */
-  async queryUniqueVersions(library) {
-    try {
-      const rows = this.statements.queryVersions.all(library.toLowerCase());
-      return rows.map((row) => normalizeVersionName(row.name));
-    } catch (error) {
-      throw new ConnectionError("Failed to query versions", error);
-    }
-  }
-  /**
-   * Updates the status of a version record in the database.
-   * @param versionId The version ID to update
-   * @param status The new status to set
-   * @param errorMessage Optional error message for failed statuses
-   */
-  async updateVersionStatus(versionId, status, errorMessage) {
-    try {
-      this.statements.updateVersionStatus.run(status, errorMessage ?? null, versionId);
-    } catch (error) {
-      throw new StoreError(`Failed to update version status: ${error}`);
-    }
-  }
-  /**
-   * Updates the progress counters for a version being indexed.
-   * @param versionId The version ID to update
-   * @param pages Current number of pages processed
-   * @param maxPages Total number of pages to process
-   */
-  async updateVersionProgress(versionId, pages, maxPages) {
-    try {
-      this.statements.updateVersionProgress.run(pages, maxPages, versionId);
-    } catch (error) {
-      throw new StoreError(`Failed to update version progress: ${error}`);
-    }
-  }
-  /**
-   * Retrieves versions by their status.
-   * @param statuses Array of statuses to filter by
-   * @returns Array of version records matching the statuses
-   */
-  async getVersionsByStatus(statuses) {
-    try {
-      const statusJson = JSON.stringify(statuses);
-      const rows = this.statements.getVersionsByStatus.all(
-        statusJson
-      );
-      return rows;
-    } catch (error) {
-      throw new StoreError(`Failed to get versions by status: ${error}`);
-    }
-  }
-  /**
-   * Retrieves all versions currently in RUNNING status.
-   * @returns Array of running version records with library names
-   */
-  async getRunningVersions() {
-    try {
-      const rows = this.statements.getRunningVersions.all();
-      return rows;
-    } catch (error) {
-      throw new StoreError(`Failed to get running versions: ${error}`);
-    }
-  }
-  /**
-   * Retrieves all versions in active states (queued, running, updating).
-   * @returns Array of active version records with library names
-   */
-  async getActiveVersions() {
-    try {
-      const rows = this.statements.getActiveVersions.all();
-      return rows;
-    } catch (error) {
-      throw new StoreError(`Failed to get active versions: ${error}`);
-    }
-  }
-  /**
-   * Stores scraper options for a version to enable reproducible indexing.
-   * @param versionId The version ID to update
-   * @param options Complete scraper options used for indexing
-   */
-  async storeScraperOptions(versionId, options) {
-    try {
-      const { url: source_url, library, version: version2, signal, ...scraper_options } = options;
-      const optionsJson = JSON.stringify(scraper_options);
-      this.statements.updateVersionScraperOptions.run(source_url, optionsJson, versionId);
-    } catch (error) {
-      throw new StoreError(`Failed to store scraper options: ${error}`);
-    }
-  }
-  /**
-  * Retrieves stored scraper options for a version.
-  * @param versionId The version ID to query
-  * @returns Stored scraper options or null if none stored
-  */
-  async getVersionScraperOptions(versionId) {
-    try {
-      const row = this.statements.getVersionWithOptions.get(versionId);
-      if (!row?.scraper_options) {
-        return null;
-      }
-      return JSON.parse(row.scraper_options);
-    } catch (error) {
-      throw new StoreError(`Failed to get version scraper options: ${error}`);
-    }
-  }
-  /**
-   * Retrieves a version record with all stored options.
-   * @param versionId The version ID to query
-   * @returns Complete version record or null if not found
-   */
-  async getVersionWithStoredOptions(versionId) {
-    try {
-      const row = this.statements.getVersionWithOptions.get(versionId);
-      return row || null;
-    } catch (error) {
-      throw new StoreError(`Failed to get version with stored options: ${error}`);
-    }
-  }
-  /**
-   * Finds versions that were indexed from the same source URL.
-   * Useful for finding similar configurations or detecting duplicates.
-   * @param url Source URL to search for
-   * @returns Array of versions with the same source URL
-   */
-  async findVersionsBySourceUrl(url) {
-    try {
-      const rows = this.statements.getVersionsBySourceUrl.all(
-        url
-      );
-      return rows;
-    } catch (error) {
-      throw new StoreError(`Failed to find versions by source URL: ${error}`);
-    }
-  }
-  /**
-   * Verifies existence of documents for a specific library version
-   */
-  async checkDocumentExists(library, version2) {
-    try {
-      const normalizedVersion = version2.toLowerCase();
-      const result = this.statements.checkExists.get(
-        library.toLowerCase(),
-        normalizedVersion
-      );
-      return result !== void 0;
-    } catch (error) {
-      throw new ConnectionError("Failed to check document existence", error);
-    }
-  }
-  /**
-   * Retrieves a mapping of all libraries to their available versions with details.
-   */
-  async queryLibraryVersions() {
-    try {
-      const rows = this.statements.queryLibraryVersions.all();
-      const libraryMap = /* @__PURE__ */ new Map();
-      for (const row of rows) {
-        const library = row.library;
-        if (!libraryMap.has(library)) {
-          libraryMap.set(library, []);
-        }
-        const indexedAtISO = row.indexedAt ? new Date(row.indexedAt).toISOString() : null;
-        libraryMap.get(library)?.push({
-          version: row.version,
-          documentCount: row.documentCount,
-          uniqueUrlCount: row.uniqueUrlCount,
-          indexedAt: indexedAtISO
-        });
-      }
-      for (const versions of libraryMap.values()) {
-        versions.sort((a, b) => {
-          if (a.version === "" && b.version !== "") {
-            return -1;
-          }
-          if (a.version !== "" && b.version === "") {
-            return 1;
-          }
-          if (a.version === "" && b.version === "") {
-            return 0;
-          }
-          try {
-            return semver__default.compare(a.version, b.version);
-          } catch (_error) {
-            return a.version.localeCompare(b.version);
-          }
-        });
-      }
-      return libraryMap;
-    } catch (error) {
-      throw new ConnectionError("Failed to query library versions", error);
-    }
-  }
-  /**
-   * Stores documents with library and version metadata, generating embeddings
-   * for vector similarity search. Automatically removes any existing documents
-   * for the same URLs before adding new ones to prevent UNIQUE constraint violations.
-   */
-  async addDocuments(library, version2, documents) {
-    try {
-      if (documents.length === 0) {
-        return;
-      }
-      const urls = /* @__PURE__ */ new Set();
-      for (const doc of documents) {
-        const url = doc.metadata.url;
-        if (!url || typeof url !== "string" || !url.trim()) {
-          throw new StoreError("Document metadata must include a valid URL");
-        }
-        urls.add(url);
-      }
-      const texts = documents.map((doc) => {
-        const header = `<title>${doc.metadata.title}</title>
-<url>${doc.metadata.url}</url>
-<path>${doc.metadata.path.join(" / ")}</path>
-`;
-        return `${header}${doc.pageContent}`;
-      });
-      const rawEmbeddings = [];
-      for (let i = 0; i < texts.length; i += EMBEDDING_BATCH_SIZE) {
-        const batchTexts = texts.slice(i, i + EMBEDDING_BATCH_SIZE);
-        const batchEmbeddings = await this.embeddings.embedDocuments(batchTexts);
-        rawEmbeddings.push(...batchEmbeddings);
-      }
-      const paddedEmbeddings = rawEmbeddings.map((vector) => this.padVector(vector));
-      const { libraryId, versionId } = await this.resolveLibraryAndVersionIds(
-        library,
-        version2
-      );
-      for (const url of urls) {
-        const deletedCount = await this.deleteDocumentsByUrl(library, version2, url);
-        if (deletedCount > 0) {
-          logger.debug(`🗑️ Deleted ${deletedCount} existing documents for URL: ${url}`);
-        }
-      }
-      const transaction = this.db.transaction((docs) => {
-        for (let i = 0; i < docs.length; i++) {
-          const doc = docs[i];
-          const url = doc.metadata.url;
-          const result = this.statements.insertDocument.run(
-            BigInt(libraryId),
-            BigInt(versionId),
-            url,
-            doc.pageContent,
-            JSON.stringify(doc.metadata),
-            i,
-            (/* @__PURE__ */ new Date()).toISOString()
-            // Pass current timestamp for indexed_at
-          );
-          const rowId = result.lastInsertRowid;
-          this.statements.insertEmbedding.run(
-            BigInt(rowId),
-            BigInt(libraryId),
-            BigInt(versionId),
-            JSON.stringify(paddedEmbeddings[i])
-          );
-        }
-      });
-      transaction(documents);
-    } catch (error) {
-      throw new ConnectionError("Failed to add documents to store", error);
-    }
-  }
-  /**
-   * Removes documents matching specified library and version
-   * @returns Number of documents deleted
-   */
-  async deleteDocuments(library, version2) {
-    try {
-      const normalizedVersion = version2.toLowerCase();
-      const result = this.statements.deleteDocuments.run(
-        library.toLowerCase(),
-        library.toLowerCase(),
-        // library name appears twice in the query
-        normalizedVersion
-      );
-      return result.changes;
-    } catch (error) {
-      throw new ConnectionError("Failed to delete documents", error);
-    }
-  }
-  /**
-   * Removes documents for a specific URL within a library and version
-   * @returns Number of documents deleted
-   */
-  async deleteDocumentsByUrl(library, version2, url) {
-    try {
-      const normalizedVersion = version2.toLowerCase();
-      const result = this.statements.deleteDocumentsByUrl.run(
-        url,
-        library.toLowerCase(),
-        library.toLowerCase(),
-        // library name appears twice in the query
-        normalizedVersion
-      );
-      return result.changes;
-    } catch (error) {
-      throw new ConnectionError("Failed to delete documents by URL", error);
-    }
-  }
-  /**
-   * Retrieves a document by its ID.
-   * @param id The ID of the document.
-   * @returns The document, or null if not found.
-   */
-  async getById(id) {
-    try {
-      const row = this.statements.getById.get(BigInt(id));
-      if (!row) {
-        return null;
-      }
-      return mapDbDocumentToDocument(row);
-    } catch (error) {
-      throw new ConnectionError(`Failed to get document by ID ${id}`, error);
-    }
-  }
-  /**
-   * Finds documents matching a text query using hybrid search.
-   * Combines vector similarity search with full-text search using Reciprocal Rank Fusion.
-   */
-  async findByContent(library, version2, query, limit) {
-    try {
-      const rawEmbedding = await this.embeddings.embedQuery(query);
-      const embedding = this.padVector(rawEmbedding);
-      const ftsQuery = this.escapeFtsQuery(query);
-      const normalizedVersion = version2.toLowerCase();
-      const stmt = this.db.prepare(`
-        WITH vec_distances AS (
-          SELECT
-            dv.rowid as id,
-            dv.distance as vec_distance
-          FROM documents_vec dv
-          JOIN versions v ON dv.version_id = v.id
-          JOIN libraries l ON v.library_id = l.id
-          WHERE l.name = ?
-            AND COALESCE(v.name, '') = COALESCE(?, '')
-            AND dv.embedding MATCH ?
-            AND dv.k = ?
-          ORDER BY dv.distance
-        ),
-        fts_scores AS (
-          SELECT
-            f.rowid as id,
-            bm25(documents_fts, 10.0, 1.0, 5.0, 1.0) as fts_score
-          FROM documents_fts f
-          JOIN documents d ON f.rowid = d.id
-          JOIN versions v ON d.version_id = v.id
-          JOIN libraries l ON v.library_id = l.id
-          WHERE l.name = ?
-            AND COALESCE(v.name, '') = COALESCE(?, '')
-            AND documents_fts MATCH ?
-          ORDER BY fts_score
-          LIMIT ?
-        )
-        SELECT
-          d.id,
-          d.content,
-          d.metadata,
-          COALESCE(1 / (1 + v.vec_distance), 0) as vec_score,
-          COALESCE(-MIN(f.fts_score, 0), 0) as fts_score
-        FROM documents d
-        LEFT JOIN vec_distances v ON d.id = v.id
-        LEFT JOIN fts_scores f ON d.id = f.id
-        WHERE v.id IS NOT NULL OR f.id IS NOT NULL
-      `);
-      const rawResults = stmt.all(
-        library.toLowerCase(),
-        normalizedVersion,
-        JSON.stringify(embedding),
-        limit,
-        library.toLowerCase(),
-        normalizedVersion,
-        ftsQuery,
-        // Use the escaped query
-        limit
-      );
-      const rankedResults = this.assignRanks(rawResults);
-      const topResults = rankedResults.sort((a, b) => b.rrf_score - a.rrf_score).slice(0, limit);
-      return topResults.map((row) => ({
-        ...mapDbDocumentToDocument(row),
-        metadata: {
-          ...JSON.parse(row.metadata),
-          id: row.id,
-          score: row.rrf_score,
-          vec_rank: row.vec_rank,
-          fts_rank: row.fts_rank
-        }
-      }));
-    } catch (error) {
-      throw new ConnectionError(
-        `Failed to find documents by content with query "${query}"`,
-        error
-      );
-    }
-  }
-  /**
-   * Finds child chunks of a given document based on path hierarchy.
-   */
-  async findChildChunks(library, version2, id, limit) {
-    try {
-      const parent = await this.getById(id);
-      if (!parent) {
-        return [];
-      }
-      const parentPath = parent.metadata.path ?? [];
-      const parentUrl = parent.metadata.url;
-      const normalizedVersion = version2.toLowerCase();
-      const result = this.statements.getChildChunks.all(
-        library.toLowerCase(),
-        normalizedVersion,
-        parentUrl,
-        parentPath.length + 1,
-        JSON.stringify(parentPath),
-        BigInt(id),
-        limit
-      );
-      return result.map((row) => mapDbDocumentToDocument(row));
-    } catch (error) {
-      throw new ConnectionError(`Failed to find child chunks for ID ${id}`, error);
-    }
-  }
-  /**
-   * Finds preceding sibling chunks of a given document.
-   */
-  async findPrecedingSiblingChunks(library, version2, id, limit) {
-    try {
-      const reference = await this.getById(id);
-      if (!reference) {
-        return [];
-      }
-      const refMetadata = reference.metadata;
-      const normalizedVersion = version2.toLowerCase();
-      const result = this.statements.getPrecedingSiblings.all(
-        library.toLowerCase(),
-        normalizedVersion,
-        refMetadata.url,
-        BigInt(id),
-        JSON.stringify(refMetadata.path),
-        limit
-      );
-      return result.reverse().map((row) => mapDbDocumentToDocument(row));
-    } catch (error) {
-      throw new ConnectionError(
-        `Failed to find preceding sibling chunks for ID ${id}`,
-        error
-      );
-    }
-  }
-  /**
-   * Finds subsequent sibling chunks of a given document.
-   */
-  async findSubsequentSiblingChunks(library, version2, id, limit) {
-    try {
-      const reference = await this.getById(id);
-      if (!reference) {
-        return [];
-      }
-      const refMetadata = reference.metadata;
-      const normalizedVersion = version2.toLowerCase();
-      const result = this.statements.getSubsequentSiblings.all(
-        library.toLowerCase(),
-        normalizedVersion,
-        refMetadata.url,
-        BigInt(id),
-        JSON.stringify(refMetadata.path),
-        limit
-      );
-      return result.map((row) => mapDbDocumentToDocument(row));
-    } catch (error) {
-      throw new ConnectionError(
-        `Failed to find subsequent sibling chunks for ID ${id}`,
-        error
-      );
-    }
-  }
-  /**
-   * Finds the parent chunk of a given document.
-   */
-  async findParentChunk(library, version2, id) {
-    try {
-      const child = await this.getById(id);
-      if (!child) {
-        return null;
-      }
-      const childMetadata = child.metadata;
-      const path2 = childMetadata.path ?? [];
-      const parentPath = path2.slice(0, -1);
-      if (parentPath.length === 0) {
-        return null;
-      }
-      const normalizedVersion = version2.toLowerCase();
-      const result = this.statements.getParentChunk.get(
-        library.toLowerCase(),
-        normalizedVersion,
-        childMetadata.url,
-        JSON.stringify(parentPath),
-        BigInt(id)
-      );
-      if (!result) {
-        return null;
-      }
-      return mapDbDocumentToDocument(result);
-    } catch (error) {
-      throw new ConnectionError(`Failed to find parent chunk for ID ${id}`, error);
-    }
-  }
-  /**
-   * Fetches multiple documents by their IDs in a single call.
-   * Returns an array of Document objects, sorted by their sort_order.
-   */
-  async findChunksByIds(library, version2, ids) {
-    if (!ids.length) return [];
-    try {
-      const normalizedVersion = version2.toLowerCase();
-      const placeholders = ids.map(() => "?").join(",");
-      const stmt = this.db.prepare(
-        `SELECT d.* FROM documents d
-         JOIN libraries l ON d.library_id = l.id
-         JOIN versions v ON d.version_id = v.id
-         WHERE l.name = ? 
-           AND COALESCE(v.name, '') = COALESCE(?, '')
-           AND d.id IN (${placeholders}) 
-         ORDER BY d.sort_order`
-      );
-      const rows = stmt.all(
-        library.toLowerCase(),
-        normalizedVersion,
-        ...ids
-      );
-      return rows.map((row) => mapDbDocumentToDocument(row));
-    } catch (error) {
-      throw new ConnectionError("Failed to fetch documents by IDs", error);
-    }
-  }
-}
-class DocumentManagementService {
-  store;
-  documentRetriever;
-  splitter;
-  /**
-   * Normalizes a version string, converting null or undefined to an empty string
-   * and converting to lowercase.
-   */
-  normalizeVersion(version2) {
-    return (version2 ?? "").toLowerCase();
-  }
-  constructor() {
-    let dbPath;
-    let dbDir;
-    const envStorePath = process.env.DOCS_MCP_STORE_PATH;
-    if (envStorePath) {
-      dbDir = envStorePath;
-      dbPath = path.join(dbDir, "documents.db");
-      logger.debug(`💾 Using database directory from DOCS_MCP_STORE_PATH: ${dbDir}`);
-    } else {
-      const projectRoot2 = getProjectRoot();
-      const oldDbDir = path.join(projectRoot2, ".store");
-      const oldDbPath = path.join(oldDbDir, "documents.db");
-      const oldDbExists = fs$1.existsSync(oldDbPath);
-      if (oldDbExists) {
-        dbPath = oldDbPath;
-        dbDir = oldDbDir;
-        logger.debug(`💾 Using legacy database path: ${dbPath}`);
-      } else {
-        const standardPaths = envPaths("docs-mcp-server", { suffix: "" });
-        dbDir = standardPaths.data;
-        dbPath = path.join(dbDir, "documents.db");
-        logger.debug(`💾 Using standard database directory: ${dbDir}`);
-      }
-    }
-    try {
-      fs$1.mkdirSync(dbDir, { recursive: true });
-    } catch (error) {
-      logger.error(`⚠️  Failed to create database directory ${dbDir}: ${error}`);
-    }
-    this.store = new DocumentStore(dbPath);
-    this.documentRetriever = new DocumentRetrieverService(this.store);
-    const semanticSplitter = new SemanticMarkdownSplitter(
-      SPLITTER_PREFERRED_CHUNK_SIZE,
-      SPLITTER_MAX_CHUNK_SIZE
-    );
-    const greedySplitter = new GreedySplitter(
-      semanticSplitter,
-      SPLITTER_MIN_CHUNK_SIZE,
-      SPLITTER_PREFERRED_CHUNK_SIZE
-    );
-    this.splitter = greedySplitter;
-  }
-  /**
-   * Initializes the underlying document store.
-   */
-  async initialize() {
-    await this.store.initialize();
-  }
-  /**
-   * Shuts down the underlying document store.
-   */
-  async shutdown() {
-    logger.debug("Shutting down store manager");
-    await this.store.shutdown();
-  }
-  // Status tracking methods for pipeline integration
-  /**
-   * Gets versions by their current status.
-   */
-  async getVersionsByStatus(statuses) {
-    return this.store.getVersionsByStatus(statuses);
-  }
-  /**
-   * Gets all versions currently in RUNNING status.
-   */
-  async getRunningVersions() {
-    return this.store.getRunningVersions();
-  }
-  /**
-   * Updates the status of a version.
-   */
-  async updateVersionStatus(versionId, status, errorMessage) {
-    return this.store.updateVersionStatus(versionId, status, errorMessage);
-  }
-  /**
-   * Updates the progress of a version being indexed.
-   */
-  async updateVersionProgress(versionId, pages, maxPages) {
-    return this.store.updateVersionProgress(versionId, pages, maxPages);
-  }
-  /**
-   * Stores scraper options for a version to enable reproducible indexing.
-   */
-  async storeScraperOptions(versionId, options) {
-    return this.store.storeScraperOptions(versionId, options);
-  }
-  /**
-   * Retrieves stored scraper options for a version.
-   */
-  async getVersionScraperOptions(versionId) {
-    return this.store.getVersionScraperOptions(versionId);
-  }
-  /**
-   * Retrieves a version record with all stored options.
-   */
-  async getVersionWithStoredOptions(versionId) {
-    return this.store.getVersionWithStoredOptions(versionId);
-  }
-  /**
-   * Finds versions that were indexed from the same source URL.
-   */
-  async findVersionsBySourceUrl(url) {
-    return this.store.findVersionsBySourceUrl(url);
-  }
-  /**
-   * Validates if a library exists in the store (either versioned or unversioned).
-   * Throws LibraryNotFoundError with suggestions if the library is not found.
-   * @param library The name of the library to validate.
-   * @throws {LibraryNotFoundError} If the library does not exist.
-   */
-  async validateLibraryExists(library) {
-    logger.info(`🔎 Validating existence of library: ${library}`);
-    const normalizedLibrary = library.toLowerCase();
-    const versions = await this.listVersions(normalizedLibrary);
-    const hasUnversioned = await this.exists(normalizedLibrary, "");
-    if (versions.length === 0 && !hasUnversioned) {
-      logger.warn(`⚠️  Library '${library}' not found.`);
-      const allLibraries = await this.listLibraries();
-      const libraryNames = allLibraries.map((lib) => lib.library);
-      let suggestions = [];
-      if (libraryNames.length > 0) {
-        const fuse = new Fuse(libraryNames, {
-          // Configure fuse.js options if needed (e.g., threshold)
-          // isCaseSensitive: false, // Handled by normalizing library names
-          // includeScore: true,
-          threshold: 0.4
-          // Adjust threshold for desired fuzziness (0=exact, 1=match anything)
-        });
-        const results = fuse.search(normalizedLibrary);
-        suggestions = results.slice(0, 3).map((result) => result.item);
-        logger.info(`🔍 Found suggestions: ${suggestions.join(", ")}`);
-      }
-      throw new LibraryNotFoundError(library, suggestions);
-    }
-    logger.info(`✅ Library '${library}' confirmed to exist.`);
-  }
-  /**
-   * Returns a list of all available semantic versions for a library.
-   */
-  async listVersions(library) {
-    const versions = await this.store.queryUniqueVersions(library);
-    return versions.filter((v) => semver__default.valid(v));
-  }
-  /**
-   * Checks if documents exist for a given library and optional version.
-   * If version is omitted, checks for documents without a specific version.
-   */
-  async exists(library, version2) {
-    const normalizedVersion = this.normalizeVersion(version2);
-    return this.store.checkDocumentExists(library, normalizedVersion);
-  }
-  /**
-   * Finds the most appropriate version of documentation based on the requested version.
-   * When no target version is specified, returns the latest version.
-   *
-   * Version matching behavior:
-   * - Exact versions (e.g., "18.0.0"): Matches that version or any earlier version
-   * - X-Range patterns (e.g., "5.x", "5.2.x"): Matches within the specified range
-   * - "latest" or no version: Returns the latest available version
-   *
-   * For documentation, we prefer matching older versions over no match at all,
-   * since older docs are often still relevant and useful.
-   * Also checks if unversioned documents exist for the library.
-   */
-  async findBestVersion(library, targetVersion) {
-    const libraryAndVersion = `${library}${targetVersion ? `@${targetVersion}` : ""}`;
-    logger.info(`🔍 Finding best version for ${libraryAndVersion}`);
-    const hasUnversioned = await this.store.checkDocumentExists(library, "");
-    const versionStrings = await this.listVersions(library);
-    if (versionStrings.length === 0) {
-      if (hasUnversioned) {
-        logger.info(`ℹ️ Unversioned documents exist for ${library}`);
-        return { bestMatch: null, hasUnversioned: true };
-      }
-      logger.warn(`⚠️  No valid versions found for ${library}`);
-      const allLibraryDetails = await this.store.queryLibraryVersions();
-      const libraryDetails = allLibraryDetails.get(library) ?? [];
-      throw new VersionNotFoundError(library, targetVersion ?? "", libraryDetails);
-    }
-    let bestMatch = null;
-    if (!targetVersion || targetVersion === "latest") {
-      bestMatch = semver__default.maxSatisfying(versionStrings, "*");
-    } else {
-      const versionRegex = /^(\d+)(?:\.(?:x(?:\.x)?|\d+(?:\.(?:x|\d+))?))?$|^$/;
-      if (!versionRegex.test(targetVersion)) {
-        logger.warn(`⚠️  Invalid target version format: ${targetVersion}`);
-      } else {
-        let range = targetVersion;
-        if (!semver__default.validRange(targetVersion)) {
-          range = `~${targetVersion}`;
-        } else if (semver__default.valid(targetVersion)) {
-          range = `${range} || <=${targetVersion}`;
-        }
-        bestMatch = semver__default.maxSatisfying(versionStrings, range);
-      }
-    }
-    if (bestMatch) {
-      logger.info(`✅ Found best match version ${bestMatch} for ${libraryAndVersion}`);
-    } else {
-      logger.warn(`⚠️  No matching semver version found for ${libraryAndVersion}`);
-    }
-    if (!bestMatch && !hasUnversioned) {
-      const allLibraryDetails = await this.store.queryLibraryVersions();
-      const libraryDetails = allLibraryDetails.get(library) ?? [];
-      throw new VersionNotFoundError(library, targetVersion ?? "", libraryDetails);
-    }
-    return { bestMatch, hasUnversioned };
-  }
-  /**
-   * Removes all documents for a specific library and optional version.
-   * If version is omitted, removes documents without a specific version.
-   */
-  async removeAllDocuments(library, version2) {
-    const normalizedVersion = this.normalizeVersion(version2);
-    logger.info(
-      `🗑️ Removing all documents from ${library}@${normalizedVersion || "[no version]"} store`
-    );
-    const count = await this.store.deleteDocuments(library, normalizedVersion);
-    logger.info(`📊 Deleted ${count} documents`);
-  }
-  /**
-   * Adds a document to the store, splitting it into smaller chunks for better search results.
-   * Uses SemanticMarkdownSplitter to maintain markdown structure and content types during splitting.
-   * Preserves hierarchical structure of documents and distinguishes between text and code segments.
-   * If version is omitted, the document is added without a specific version.
-   */
-  async addDocument(library, version2, document) {
-    const normalizedVersion = this.normalizeVersion(version2);
-    const url = document.metadata.url;
-    if (!url || typeof url !== "string" || !url.trim()) {
-      throw new StoreError("Document metadata must include a valid URL");
-    }
-    logger.info(`📚 Adding document: ${document.metadata.title}`);
-    if (!document.pageContent.trim()) {
-      throw new Error("Document content cannot be empty");
-    }
-    const chunks = await this.splitter.splitText(document.pageContent);
-    const splitDocs = chunks.map((chunk) => ({
-      pageContent: chunk.content,
-      metadata: {
-        ...document.metadata,
-        level: chunk.section.level,
-        path: chunk.section.path
-      }
-    }));
-    logger.info(`✂️  Split document into ${splitDocs.length} chunks`);
-    await this.store.addDocuments(library, normalizedVersion, splitDocs);
-  }
-  /**
-   * Searches for documentation content across versions.
-   * Uses hybrid search (vector + FTS).
-   * If version is omitted, searches documents without a specific version.
-   */
-  async searchStore(library, version2, query, limit = 5) {
-    const normalizedVersion = this.normalizeVersion(version2);
-    return this.documentRetriever.search(library, normalizedVersion, query, limit);
-  }
-  async listLibraries() {
-    const libraryMap = await this.store.queryLibraryVersions();
-    return Array.from(libraryMap.entries()).map(([library, versions]) => ({
-      library,
-      versions
-      // The versions array already contains LibraryVersionDetails
-    }));
-  }
-  /**
-   * Gets all versions in active states (queued, running, updating).
-   */
-  async getActiveVersions() {
-    return this.store.getActiveVersions();
-  }
-  /**
-   * Ensures a library and version exist in the database and returns the version ID.
-   * Creates the library and version records if they don't exist.
-   */
-  async ensureLibraryAndVersion(library, version2) {
-    const normalizedLibrary = library.toLowerCase();
-    const normalizedVersion = this.normalizeVersion(version2);
-    const { versionId } = await this.store.resolveLibraryAndVersionIds(
-      normalizedLibrary,
-      normalizedVersion
-    );
-    return versionId;
-  }
-}
-function ensurePlaywrightBrowsersInstalled() {
-  const chromiumEnvPath = process.env.PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH;
-  if (chromiumEnvPath && existsSync(chromiumEnvPath)) {
-    logger.debug(
-      `PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH is set to '${chromiumEnvPath}', skipping Playwright browser install.`
-    );
-    return;
-  }
-  try {
-    const chromiumPath = chromium.executablePath();
-    if (!chromiumPath || !existsSync(chromiumPath)) {
-      throw new Error("Playwright Chromium browser not found");
-    }
-  } catch (_err) {
-    logger.debug(
-      "Playwright browsers not found. Installing Chromium browser for dynamic scraping (this may take a minute)..."
-    );
-    try {
-      logger.debug("Installing Playwright Chromium browser...");
-      execSync("npm exec -y playwright install --no-shell --with-deps chromium", {
-        stdio: "ignore",
-        // Suppress output
-        cwd: getProjectRoot()
-      });
-    } catch (_installErr) {
-      console.error(
-        "❌ Failed to install Playwright browsers automatically. Please run:\n  npx playwright install --no-shell --with-deps chromium\nand try again."
-      );
-      process.exit(1);
-    }
-  }
-}
-function resolveProtocol(protocol) {
-  if (protocol === "auto") {
-    if (!process.stdin.isTTY && !process.stdout.isTTY) {
-      return "stdio";
-    }
-    return "http";
-  }
-  if (protocol === "stdio" || protocol === "http") {
-    return protocol;
-  }
-  throw new Error(`Invalid protocol: ${protocol}. Must be 'auto', 'stdio', or 'http'`);
-}
-const formatOutput = (data) => JSON.stringify(data, null, 2);
-function setupLogging(options, protocol) {
-  if (options.silent) {
-    setLogLevel(LogLevel.ERROR);
-  } else if (options.verbose) {
-    setLogLevel(LogLevel.DEBUG);
-  }
-  if (protocol === "stdio") {
-    setLogLevel(LogLevel.ERROR);
-  }
-}
-function validatePort(portString) {
-  const port = Number.parseInt(portString, 10);
-  if (Number.isNaN(port) || port < 1 || port > 65535) {
-    throw new Error("❌ Invalid port number");
-  }
-  return port;
-}
-async function initializeDocumentService() {
-  const docService = new DocumentManagementService();
-  await docService.initialize();
-  return docService;
-}
-async function initializePipeline(docService, options = {}) {
-  logger.debug(`Initializing PipelineManager with options: ${JSON.stringify(options)}`);
-  const manager = await PipelineFactory.createPipeline(docService, options);
-  manager.setCallbacks({
-    onJobProgress: async (job, progress) => {
-      logger.debug(
-        `📊 Job ${job.id} progress: ${progress.pagesScraped}/${progress.totalPages} pages`
-      );
-    },
-    onJobStatusChange: async (job) => {
-      logger.debug(`🔄 Job ${job.id} status changed to: ${job.status}`);
-    },
-    onJobError: async (job, error, document) => {
-      logger.warn(
-        `⚠️ Job ${job.id} error ${document ? `on document ${document.metadata.url}` : ""}: ${error.message}`
-      );
-    }
-  });
-  return manager;
-}
-function createAppServerConfig(options) {
-  return {
-    enableWebInterface: options.enableWebInterface ?? false,
-    enableMcpServer: options.enableMcpServer ?? true,
-    enablePipelineApi: options.enablePipelineApi ?? false,
-    enableWorker: options.enableWorker ?? true,
-    port: options.port,
-    externalWorkerUrl: options.externalWorkerUrl
-  };
-}
-function parseHeaders(headerOptions) {
-  const headers = {};
-  if (Array.isArray(headerOptions)) {
-    for (const entry of headerOptions) {
-      const idx = entry.indexOf(":");
-      if (idx > 0) {
-        const name = entry.slice(0, idx).trim();
-        const value = entry.slice(idx + 1).trim();
-        if (name) headers[name] = value;
-      }
-    }
-  }
-  return headers;
+  return headers;
 }
 const CLI_DEFAULTS = {
   PROTOCOL: DEFAULT_PROTOCOL,
@@ -7483,11 +5767,17 @@ const CLI_DEFAULTS = {
   MAX_CONCURRENCY: DEFAULT_MAX_CONCURRENCY
 };
 function createDefaultAction(program) {
-  return program.option(
-    "--protocol <type>",
-    "Protocol for MCP server: 'auto' (default), 'stdio', or 'http'",
-    "auto"
-  ).option("--port <number>", "Port for the server", CLI_DEFAULTS.HTTP_PORT.toString()).option("--resume", "Resume interrupted jobs on startup", false).action(
+  return program.addOption(
+    new Option("--protocol <protocol>", "Protocol for MCP server").choices(["auto", "stdio", "http"]).default("auto")
+  ).addOption(
+    new Option("--port <number>", "Port for the server").argParser((v) => {
+      const n = Number(v);
+      if (!Number.isInteger(n) || n < 1 || n > 65535) {
+        throw new Error("Port must be an integer between 1 and 65535");
+      }
+      return String(n);
+    }).default(CLI_DEFAULTS.HTTP_PORT.toString())
+  ).option("--resume", "Resume interrupted jobs on startup", false).option("--no-resume", "Do not resume jobs on startup").action(
     async (options, command) => {
       const globalOptions = command.opts();
       const resolvedProtocol = resolveProtocol(options.protocol);
@@ -7495,13 +5785,13 @@ function createDefaultAction(program) {
       logger.debug("No subcommand specified, starting unified server by default...");
       const port = validatePort(options.port);
       ensurePlaywrightBrowsersInstalled();
-      const docService = await initializeDocumentService();
+      const docService = await createLocalDocumentManagement();
       const pipelineOptions = {
         recoverJobs: options.resume || false,
         // Use --resume flag for job recovery
         concurrency: 3
       };
-      const pipeline = await initializePipeline(docService, pipelineOptions);
+      const pipeline = await createPipelineWithCallbacks(docService, pipelineOptions);
       if (resolvedProtocol === "stdio") {
         logger.debug(`🔍 Auto-detected stdio protocol (no TTY)`);
         await pipeline.start();
@@ -7516,8 +5806,8 @@ function createDefaultAction(program) {
           // Enable web interface in http mode
           enableMcpServer: true,
           // Always enable MCP server
-          enablePipelineApi: true,
-          // Enable pipeline API in http mode
+          enableApiServer: true,
+          // Enable API (tRPC) in http mode
           enableWorker: true,
           // Always enable in-process worker for unified server
           port
@@ -7529,6 +5819,19 @@ function createDefaultAction(program) {
     }
   );
 }
+async function fetchUrlAction(url, options, command) {
+  const globalOptions = command.parent?.opts() || {};
+  setupLogging(globalOptions);
+  const headers = parseHeaders(options.header);
+  const fetchUrlTool = new FetchUrlTool(new HttpFetcher(), new FileFetcher());
+  const content = await fetchUrlTool.execute({
+    url,
+    followRedirects: options.followRedirects,
+    scrapeMode: options.scrapeMode,
+    headers: Object.keys(headers).length > 0 ? headers : void 0
+  });
+  console.log(content);
+}
 function createFetchUrlCommand(program) {
   return program.command("fetch-url <url>").description("Fetch a URL and convert its content to Markdown").option(
     "--no-follow-redirects",
@@ -7552,66 +5855,64 @@ function createFetchUrlCommand(program) {
     "Custom HTTP header to send with the request (can be specified multiple times)",
     (val, prev = []) => prev.concat([val]),
     []
-  ).action(
-    async (url, options, command) => {
-      const globalOptions = command.parent?.opts() || {};
-      setupLogging(globalOptions);
-      const headers = parseHeaders(options.header);
-      const fetchUrlTool = new FetchUrlTool(new HttpFetcher(), new FileFetcher());
-      const content = await fetchUrlTool.execute({
-        url,
-        followRedirects: options.followRedirects,
-        scrapeMode: options.scrapeMode,
-        headers: Object.keys(headers).length > 0 ? headers : void 0
-      });
-      console.log(content);
-    }
-  );
+  ).action(fetchUrlAction);
+}
+async function findVersionAction(library, options, command) {
+  const globalOptions = command.parent?.opts() || {};
+  setupLogging(globalOptions);
+  const serverUrl = options.serverUrl;
+  const docService = await createDocumentManagement({ serverUrl });
+  try {
+    const findVersionTool = new FindVersionTool(docService);
+    const versionInfo = await findVersionTool.execute({
+      library,
+      targetVersion: options.version
+    });
+    if (!versionInfo) throw new Error("Failed to get version information");
+    console.log(versionInfo);
+  } finally {
+    await docService.shutdown();
+  }
 }
 function createFindVersionCommand(program) {
-  return program.command("find-version <library>").description("Find the best matching version for a library").option("-v, --version <string>", "Pattern to match (optional, supports ranges)").action(async (library, options, command) => {
-    const globalOptions = command.parent?.opts() || {};
-    setupLogging(globalOptions);
-    const docService = await initializeDocumentService();
-    try {
-      const findVersionTool = new FindVersionTool(docService);
-      const versionInfo = await findVersionTool.execute({
-        library,
-        targetVersion: options.version
-      });
-      if (!versionInfo) throw new Error("Failed to get version information");
-      console.log(versionInfo);
-    } finally {
-      await docService.shutdown();
-    }
-  });
+  return program.command("find-version <library>").description("Find the best matching version for a library").option("-v, --version <string>", "Pattern to match (optional, supports ranges)").option(
+    "--server-url <url>",
+    "URL of external pipeline worker RPC (e.g., http://localhost:6280/api)"
+  ).action(findVersionAction);
+}
+async function listAction(options, command) {
+  const globalOptions = command.parent?.opts() || {};
+  setupLogging(globalOptions);
+  const { serverUrl } = options;
+  const docService = await createDocumentManagement({ serverUrl });
+  try {
+    const listLibrariesTool = new ListLibrariesTool(docService);
+    const result = await listLibrariesTool.execute();
+    console.log(formatOutput(result.libraries));
+  } finally {
+    await docService.shutdown();
+  }
 }
 function createListCommand(program) {
-  return program.command("list").description("List all available libraries and their versions").action(async (command) => {
-    const globalOptions = command.opts() || {};
-    setupLogging(globalOptions);
-    const docService = await initializeDocumentService();
-    try {
-      const listLibrariesTool = new ListLibrariesTool(docService);
-      const result = await listLibrariesTool.execute();
-      console.log(formatOutput(result.libraries));
-    } finally {
-      await docService.shutdown();
-    }
-  });
+  return program.command("list").description("List all available libraries and their versions").option(
+    "--server-url <url>",
+    "URL of external pipeline worker RPC (e.g., http://localhost:6280/api)"
+  ).action(listAction);
 }
 function createMcpCommand(program) {
-  return program.command("mcp").description("Start MCP server only").option(
-    "--protocol <type>",
-    "Protocol for MCP server: 'auto' (default), 'stdio', or 'http'",
-    CLI_DEFAULTS.PROTOCOL
-  ).option(
-    "--port <number>",
-    "Port for the MCP server",
-    CLI_DEFAULTS.HTTP_PORT.toString()
+  return program.command("mcp").description("Start MCP server only").addOption(
+    new Option("--protocol <protocol>", "Protocol for MCP server").choices(["auto", "stdio", "http"]).default(CLI_DEFAULTS.PROTOCOL)
+  ).addOption(
+    new Option("--port <number>", "Port for the MCP server").argParser((v) => {
+      const n = Number(v);
+      if (!Number.isInteger(n) || n < 1 || n > 65535) {
+        throw new Error("Port must be an integer between 1 and 65535");
+      }
+      return String(n);
+    }).default(CLI_DEFAULTS.HTTP_PORT.toString())
   ).option(
     "--server-url <url>",
-    "URL of external pipeline worker API (e.g., http://localhost:6280/api)"
+    "URL of external pipeline worker RPC (e.g., http://localhost:6280/api)"
   ).action(
     async (cmdOptions, command) => {
       const globalOptions = command.parent?.opts() || {};
@@ -7620,14 +5921,19 @@ function createMcpCommand(program) {
       const resolvedProtocol = resolveProtocol(cmdOptions.protocol);
       setupLogging(globalOptions, resolvedProtocol);
       try {
-        const docService = await initializeDocumentService();
+        const docService = await createDocumentManagement({
+          serverUrl
+        });
         const pipelineOptions = {
           recoverJobs: false,
           // MCP command doesn't support job recovery
           serverUrl,
           concurrency: 3
         };
-        const pipeline = await initializePipeline(docService, pipelineOptions);
+        const pipeline = await createPipelineWithCallbacks(
+          serverUrl ? void 0 : docService,
+          pipelineOptions
+        );
         if (resolvedProtocol === "stdio") {
           logger.debug(`🔍 Auto-detected stdio protocol (no TTY)`);
           logger.info("🚀 Starting MCP server (stdio mode)");
@@ -7643,8 +5949,8 @@ function createMcpCommand(program) {
             enableWebInterface: false,
             // Never enable web interface in mcp command
             enableMcpServer: true,
-            enablePipelineApi: false,
-            // Never enable pipeline API in mcp command
+            enableApiServer: false,
+            // Never enable API in mcp command
             enableWorker: !serverUrl,
             port,
             externalWorkerUrl: serverUrl
@@ -7660,30 +5966,81 @@ function createMcpCommand(program) {
     }
   );
 }
+async function removeAction(library, options, command) {
+  const globalOptions = command.parent?.opts() || {};
+  setupLogging(globalOptions);
+  const serverUrl = options.serverUrl;
+  const docService = await createDocumentManagement({ serverUrl });
+  const { version: version2 } = options;
+  try {
+    await docService.removeAllDocuments(library, version2);
+    console.log(
+      `✅ Successfully removed documents for ${library}${version2 ? `@${version2}` : " (unversioned)"}.`
+    );
+  } catch (error) {
+    console.error(
+      `❌ Failed to remove documents for ${library}${version2 ? `@${version2}` : " (unversioned)"}:`,
+      error instanceof Error ? error.message : String(error)
+    );
+    throw error;
+  } finally {
+    await docService.shutdown();
+  }
+}
 function createRemoveCommand(program) {
   return program.command("remove <library>").description("Remove documents for a specific library and version").option(
     "-v, --version <string>",
     "Version to remove (optional, removes unversioned if omitted)"
-  ).action(async (library, options, command) => {
-    const globalOptions = command.parent?.opts() || {};
-    setupLogging(globalOptions);
-    const docService = await initializeDocumentService();
-    const { version: version2 } = options;
-    try {
-      await docService.removeAllDocuments(library, version2);
-      console.log(
-        `✅ Successfully removed documents for ${library}${version2 ? `@${version2}` : " (unversioned)"}.`
-      );
-    } catch (error) {
-      console.error(
-        `❌ Failed to remove documents for ${library}${version2 ? `@${version2}` : " (unversioned)"}:`,
-        error instanceof Error ? error.message : String(error)
-      );
-      throw error;
-    } finally {
-      await docService.shutdown();
+  ).option(
+    "--server-url <url>",
+    "URL of external pipeline worker RPC (e.g., http://localhost:6280/api)"
+  ).action(removeAction);
+}
+async function scrapeAction(library, url, options, command) {
+  const globalOptions = command.parent?.opts() || {};
+  setupLogging(globalOptions);
+  const serverUrl = options.serverUrl;
+  const docService = await createDocumentManagement({ serverUrl });
+  let pipeline = null;
+  try {
+    const pipelineOptions = {
+      recoverJobs: false,
+      concurrency: 1,
+      serverUrl
+    };
+    pipeline = await createPipelineWithCallbacks(
+      serverUrl ? void 0 : docService,
+      pipelineOptions
+    );
+    await pipeline.start();
+    const scrapeTool = new ScrapeTool(pipeline);
+    const headers = parseHeaders(options.header);
+    const result = await scrapeTool.execute({
+      url,
+      library,
+      version: options.version,
+      options: {
+        maxPages: Number.parseInt(options.maxPages),
+        maxDepth: Number.parseInt(options.maxDepth),
+        maxConcurrency: Number.parseInt(options.maxConcurrency),
+        ignoreErrors: options.ignoreErrors,
+        scope: options.scope,
+        followRedirects: options.followRedirects,
+        scrapeMode: options.scrapeMode,
+        includePatterns: Array.isArray(options.includePattern) && options.includePattern.length > 0 ? options.includePattern : void 0,
+        excludePatterns: Array.isArray(options.excludePattern) && options.excludePattern.length > 0 ? options.excludePattern : void 0,
+        headers: Object.keys(headers).length > 0 ? headers : void 0
+      }
+    });
+    if ("pagesScraped" in result) {
+      console.log(`✅ Successfully scraped ${result.pagesScraped} pages`);
+    } else {
+      console.log(`🚀 Scraping job started with ID: ${result.jobId}`);
     }
-  });
+  } finally {
+    if (pipeline) await pipeline.stop();
+    await docService.shutdown();
+  }
 }
 function createScrapeCommand(program) {
   return program.command("scrape <library> <url>").description(
@@ -7746,55 +6103,27 @@ function createScrapeCommand(program) {
     []
   ).option(
     "--server-url <url>",
-    "URL of external pipeline worker API (e.g., http://localhost:6280/api)"
-  ).action(
-    async (library, url, options, command) => {
-      const globalOptions = command.parent?.opts() || {};
-      setupLogging(globalOptions);
-      const docService = new DocumentManagementService();
-      let pipeline = null;
-      try {
-        await docService.initialize();
-        const pipelineOptions = {
-          recoverJobs: false,
-          // CLI: no job recovery (immediate execution)
-          concurrency: 1,
-          // CLI: single job at a time
-          serverUrl: options.serverUrl
-          // Use external worker if specified
-        };
-        pipeline = await PipelineFactory.createPipeline(docService, pipelineOptions);
-        await pipeline.start();
-        const scrapeTool = new ScrapeTool(pipeline);
-        const headers = parseHeaders(options.header);
-        const result = await scrapeTool.execute({
-          url,
-          library,
-          version: options.version,
-          options: {
-            maxPages: Number.parseInt(options.maxPages),
-            maxDepth: Number.parseInt(options.maxDepth),
-            maxConcurrency: Number.parseInt(options.maxConcurrency),
-            ignoreErrors: options.ignoreErrors,
-            scope: options.scope,
-            followRedirects: options.followRedirects,
-            scrapeMode: options.scrapeMode,
-            includePatterns: Array.isArray(options.includePattern) && options.includePattern.length > 0 ? options.includePattern : void 0,
-            excludePatterns: Array.isArray(options.excludePattern) && options.excludePattern.length > 0 ? options.excludePattern : void 0,
-            headers: Object.keys(headers).length > 0 ? headers : void 0
-          }
-        });
-        if ("pagesScraped" in result) {
-          console.log(`✅ Successfully scraped ${result.pagesScraped} pages`);
-        } else {
-          console.log(`🚀 Scraping job started with ID: ${result.jobId}`);
-        }
-      } finally {
-        if (pipeline) await pipeline.stop();
-        await docService.shutdown();
-      }
-    }
-  );
+    "URL of external pipeline worker RPC (e.g., http://localhost:6280/api)"
+  ).action(scrapeAction);
+}
+async function searchAction(library, query, options, command) {
+  const globalOptions = command.parent?.opts() || {};
+  setupLogging(globalOptions);
+  const serverUrl = options.serverUrl;
+  const docService = await createDocumentManagement({ serverUrl });
+  try {
+    const searchTool = new SearchTool(docService);
+    const result = await searchTool.execute({
+      library,
+      version: options.version,
+      query,
+      limit: Number.parseInt(options.limit),
+      exactMatch: options.exactMatch
+    });
+    console.log(formatOutput(result.results));
+  } finally {
+    await docService.shutdown();
+  }
 }
 function createSearchCommand(program) {
   return program.command("search <library> <query>").description(
@@ -7802,35 +6131,23 @@ function createSearchCommand(program) {
   ).option(
     "-v, --version <string>",
     "Version of the library (optional, supports ranges)"
-  ).option("-l, --limit <number>", "Maximum number of results", "5").option("-e, --exact-match", "Only use exact version match (default: false)", false).action(
-    async (library, query, options, command) => {
-      const globalOptions = command.parent?.opts() || {};
-      setupLogging(globalOptions);
-      const docService = await initializeDocumentService();
-      try {
-        const searchTool = new SearchTool(docService);
-        const result = await searchTool.execute({
-          library,
-          version: options.version,
-          query,
-          limit: Number.parseInt(options.limit),
-          exactMatch: options.exactMatch
-        });
-        console.log(formatOutput(result.results));
-      } finally {
-        await docService.shutdown();
-      }
-    }
-  );
+  ).option("-l, --limit <number>", "Maximum number of results", "5").option("-e, --exact-match", "Only use exact version match (default: false)", false).option(
+    "--server-url <url>",
+    "URL of external pipeline worker RPC (e.g., http://localhost:6280/api)"
+  ).action(searchAction);
 }
 function createWebCommand(program) {
-  return program.command("web").description("Start web interface only").option(
-    "--port <number>",
-    "Port for the web interface",
-    CLI_DEFAULTS.WEB_PORT.toString()
+  return program.command("web").description("Start web interface only").addOption(
+    new Option("--port <number>", "Port for the web interface").argParser((v) => {
+      const n = Number(v);
+      if (!Number.isInteger(n) || n < 1 || n > 65535) {
+        throw new Error("Port must be an integer between 1 and 65535");
+      }
+      return String(n);
+    }).default(CLI_DEFAULTS.WEB_PORT.toString())
   ).option(
     "--server-url <url>",
-    "URL of external pipeline worker API (e.g., http://localhost:6280/api)"
+    "URL of external pipeline worker RPC (e.g., http://localhost:6280/api)"
   ).action(
     async (cmdOptions, command) => {
       const globalOptions = command.parent?.opts() || {};
@@ -7838,18 +6155,23 @@ function createWebCommand(program) {
       const serverUrl = cmdOptions.serverUrl;
       setupLogging(globalOptions);
       try {
-        const docService = await initializeDocumentService();
+        const docService = await createDocumentManagement({
+          serverUrl
+        });
         const pipelineOptions = {
           recoverJobs: false,
           // Web command doesn't support job recovery
           serverUrl,
           concurrency: 3
         };
-        const pipeline = await initializePipeline(docService, pipelineOptions);
+        const pipeline = await createPipelineWithCallbacks(
+          serverUrl ? void 0 : docService,
+          pipelineOptions
+        );
         const config = createAppServerConfig({
           enableWebInterface: true,
           enableMcpServer: false,
-          enablePipelineApi: false,
+          enableApiServer: false,
           enableWorker: !serverUrl,
           port,
           externalWorkerUrl: serverUrl
@@ -7868,28 +6190,35 @@ function createWebCommand(program) {
   );
 }
 function createWorkerCommand(program) {
-  return program.command("worker").description("Start external pipeline worker (HTTP API)").option("--port <number>", "Port for worker API", "8080").option("--resume", "Resume interrupted jobs on startup", true).action(async (cmdOptions, command) => {
+  return program.command("worker").description("Start external pipeline worker (HTTP API)").addOption(
+    new Option("--port <number>", "Port for worker API").argParser((v) => {
+      const n = Number(v);
+      if (!Number.isInteger(n) || n < 1 || n > 65535) {
+        throw new Error("Port must be an integer between 1 and 65535");
+      }
+      return String(n);
+    }).default("8080")
+  ).option("--resume", "Resume interrupted jobs on startup", true).option("--no-resume", "Do not resume jobs on startup").action(async (cmdOptions, command) => {
     const globalOptions = command.parent?.opts() || {};
     const port = validatePort(cmdOptions.port);
     setupLogging(globalOptions);
     try {
       logger.info(`🚀 Starting external pipeline worker on port ${port}`);
       ensurePlaywrightBrowsersInstalled();
-      const docService = await initializeDocumentService();
+      const docService = await createLocalDocumentManagement();
       const pipelineOptions = {
         recoverJobs: cmdOptions.resume,
         // Use the resume option
         concurrency: CLI_DEFAULTS.MAX_CONCURRENCY
       };
-      const pipeline = await initializePipeline(docService, pipelineOptions);
+      const pipeline = await createPipelineWithCallbacks(docService, pipelineOptions);
       const config = createAppServerConfig({
         enableWebInterface: false,
         enableMcpServer: false,
-        enablePipelineApi: true,
+        enableApiServer: true,
         enableWorker: true,
         port
       });
-      logger.info(`🚀 Starting external pipeline worker with HTTP API`);
       await startAppServer(docService, pipeline, config);
       await new Promise(() => {
       });
@@ -7901,7 +6230,9 @@ function createWorkerCommand(program) {
 }
 function createCliProgram() {
   const program = new Command();
-  program.name("docs-mcp-server").description("Unified CLI, MCP Server, and Web Interface for Docs MCP Server.").version(packageJson.version).option("--verbose", "Enable verbose (debug) logging", false).option("--silent", "Disable all logging except errors", false).enablePositionalOptions().showHelpAfterError(true);
+  program.name("docs-mcp-server").description("Unified CLI, MCP Server, and Web Interface for Docs MCP Server.").version(packageJson.version).addOption(
+    new Option("--verbose", "Enable verbose (debug) logging").conflicts("silent")
+  ).addOption(new Option("--silent", "Disable all logging except errors")).enablePositionalOptions().allowExcessArguments(false).showHelpAfterError(true);
   program.hook("preAction", (thisCommand, _actionCommand) => {
     const globalOptions = thisCommand.opts();
     if (globalOptions.silent) setLogLevel(LogLevel.ERROR);
@@ -8023,7 +6354,23 @@ runCli().catch((error) => {
   process.exit(1);
 });
 export {
+  ConnectionError as C,
   DimensionError as D,
-  VECTOR_DIMENSION as V
+  EMBEDDING_BATCH_CHARS as E,
+  LibraryNotFoundError as L,
+  StoreError as S,
+  VECTOR_DIMENSION as V,
+  applyMigrations as a,
+  EMBEDDING_BATCH_SIZE as b,
+  createJSDOM as c,
+  denormalizeVersionName as d,
+  SPLITTER_PREFERRED_CHUNK_SIZE as e,
+  SPLITTER_MAX_CHUNK_SIZE as f,
+  getProjectRoot as g,
+  VersionNotFoundError as h,
+  SPLITTER_MIN_CHUNK_SIZE as i,
+  logger as l,
+  mapDbDocumentToDocument as m,
+  normalizeVersionName as n
 };
 //# sourceMappingURL=index.js.map