searchsocket 0.2.0

package/dist/cli.js

@@ -0,0 +1,3860 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import fs9 from "fs";
+import fsp from "fs/promises";
+import path13 from "path";
+import { execSync as execSync2 } from "child_process";
+import { config as dotenvConfig } from "dotenv";
+import chokidar from "chokidar";
+import { Command } from "commander";
+
+// package.json
+var package_default = {
+  name: "searchsocket",
+  version: "0.2.0",
+  description: "Semantic site search and MCP retrieval for SvelteKit static sites",
+  license: "MIT",
+  author: "Greg Priday <greg@siteorigin.com>",
+  repository: {
+    type: "git",
+    url: "https://github.com/gregpriday/searchsocket.git"
+  },
+  homepage: "https://github.com/gregpriday/searchsocket",
+  bugs: {
+    url: "https://github.com/gregpriday/searchsocket/issues"
+  },
+  keywords: [
+    "search",
+    "semantic-search",
+    "sveltekit",
+    "mcp",
+    "embeddings",
+    "vector-search",
+    "site-search",
+    "static-site"
+  ],
+  type: "module",
+  files: [
+    "dist",
+    "README.md"
+  ],
+  bin: {
+    searchsocket: "dist/cli.js"
+  },
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js",
+      require: "./dist/index.cjs"
+    },
+    "./sveltekit": {
+      types: "./dist/sveltekit.d.ts",
+      import: "./dist/sveltekit.js",
+      require: "./dist/sveltekit.cjs"
+    },
+    "./client": {
+      types: "./dist/client.d.ts",
+      import: "./dist/client.js",
+      require: "./dist/client.cjs"
+    }
+  },
+  scripts: {
+    build: "tsup",
+    clean: "rm -rf dist",
+    typecheck: "tsc --noEmit",
+    test: "vitest run",
+    "test:watch": "vitest"
+  },
+  engines: {
+    node: ">=20"
+  },
+  packageManager: "pnpm@10.29.2",
+  dependencies: {
+    "@libsql/client": "^0.17.0",
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    cheerio: "^1.2.0",
+    chokidar: "^5.0.0",
+    commander: "^14.0.3",
+    dotenv: "^17.3.1",
+    express: "^5.2.1",
+    "fast-glob": "^3.3.3",
+    "gray-matter": "^4.0.3",
+    jiti: "^2.6.1",
+    openai: "^6.19.0",
+    "p-limit": "^7.3.0",
+    turndown: "^7.2.2",
+    "turndown-plugin-gfm": "^1.0.2",
+    zod: "^4.3.6"
+  },
+  devDependencies: {
+    "@types/express": "^5.0.6",
+    "@types/node": "^25.2.2",
+    "@types/turndown": "^5.0.6",
+    tsup: "^8.5.1",
+    typescript: "^5.9.3",
+    vitest: "^4.0.18"
+  }
+};
+
+// src/config/load.ts
+import fs from "fs";
+import path from "path";
+import { createJiti } from "jiti";
+
+// src/config/schema.ts
+import { z } from "zod";
+var searchSocketConfigSchema = z.object({
+  project: z.object({
+    id: z.string().min(1).optional(),
+    baseUrl: z.string().url().optional()
+  }).optional(),
+  scope: z.object({
+    mode: z.enum(["fixed", "git", "env"]).optional(),
+    fixed: z.string().min(1).optional(),
+    envVar: z.string().min(1).optional(),
+    sanitize: z.boolean().optional()
+  }).optional(),
+  source: z.object({
+    mode: z.enum(["static-output", "crawl", "content-files", "build"]).optional(),
+    staticOutputDir: z.string().min(1).optional(),
+    strictRouteMapping: z.boolean().optional(),
+    crawl: z.object({
+      baseUrl: z.string().url(),
+      routes: z.array(z.string()).optional(),
+      sitemapUrl: z.string().optional()
+    }).optional(),
+    contentFiles: z.object({
+      globs: z.array(z.string()).min(1),
+      baseDir: z.string().optional()
+    }).optional(),
+    build: z.object({
+      outputDir: z.string().min(1).optional(),
+      paramValues: z.record(z.string(), z.array(z.string())).optional(),
+      exclude: z.array(z.string()).optional(),
+      previewTimeout: z.number().int().positive().optional()
+    }).optional()
+  }).optional(),
+  extract: z.object({
+    mainSelector: z.string().optional(),
+    dropTags: z.array(z.string()).optional(),
+    dropSelectors: z.array(z.string()).optional(),
+    ignoreAttr: z.string().optional(),
+    noindexAttr: z.string().optional(),
+    respectRobotsNoindex: z.boolean().optional()
+  }).optional(),
+  transform: z.object({
+    output: z.literal("markdown").optional(),
+    preserveCodeBlocks: z.boolean().optional(),
+    preserveTables: z.boolean().optional()
+  }).optional(),
+  chunking: z.object({
+    strategy: z.literal("hybrid").optional(),
+    maxChars: z.number().int().positive().optional(),
+    overlapChars: z.number().int().nonnegative().optional(),
+    minChars: z.number().int().positive().optional(),
+    headingPathDepth: z.number().int().positive().optional(),
+    dontSplitInside: z.array(z.enum(["code", "table", "blockquote"])).optional(),
+    prependTitle: z.boolean().optional(),
+    pageSummaryChunk: z.boolean().optional()
+  }).optional(),
+  embeddings: z.object({
+    provider: z.literal("openai").optional(),
+    model: z.string().min(1).optional(),
+    apiKeyEnv: z.string().min(1).optional(),
+    batchSize: z.number().int().positive().optional(),
+    concurrency: z.number().int().positive().optional(),
+    pricePer1kTokens: z.number().positive().optional()
+  }).optional(),
+  vector: z.object({
+    dimension: z.number().int().positive().optional(),
+    turso: z.object({
+      urlEnv: z.string().optional(),
+      authTokenEnv: z.string().optional(),
+      localPath: z.string().optional()
+    }).optional()
+  }).optional(),
+  rerank: z.object({
+    provider: z.enum(["none", "jina"]).optional(),
+    topN: z.number().int().positive().optional(),
+    jina: z.object({
+      apiKeyEnv: z.string().optional(),
+      model: z.string().optional()
+    }).optional()
+  }).optional(),
+  ranking: z.object({
+    enableIncomingLinkBoost: z.boolean().optional(),
+    enableDepthBoost: z.boolean().optional(),
+    pageWeights: z.record(z.string(), z.number().positive()).optional(),
+    aggregationCap: z.number().int().positive().optional(),
+    aggregationDecay: z.number().min(0).max(1).optional(),
+    minChunkScoreRatio: z.number().min(0).max(1).optional(),
+    weights: z.object({
+      incomingLinks: z.number().optional(),
+      depth: z.number().optional(),
+      rerank: z.number().optional(),
+      aggregation: z.number().optional()
+    }).optional()
+  }).optional(),
+  api: z.object({
+    path: z.string().optional(),
+    cors: z.object({
+      allowOrigins: z.array(z.string()).optional()
+    }).optional(),
+    rateLimit: z.object({
+      windowMs: z.number().int().positive().optional(),
+      max: z.number().int().positive().optional()
+    }).optional()
+  }).optional(),
+  mcp: z.object({
+    enable: z.boolean().optional(),
+    transport: z.enum(["stdio", "http"]).optional(),
+    http: z.object({
+      port: z.number().int().positive().optional(),
+      path: z.string().optional()
+    }).optional()
+  }).optional(),
+  state: z.object({
+    dir: z.string().optional(),
+    writeMirror: z.boolean().optional()
+  }).optional()
+});
+
+// src/config/defaults.ts
+var DEFAULT_DROP_SELECTORS = [
+  ".sidebar",
+  ".toc",
+  ".table-of-contents",
+  ".breadcrumbs",
+  ".breadcrumb",
+  "[role='navigation']"
+];
+function createDefaultConfig(projectId) {
+  return {
+    project: {
+      id: projectId
+    },
+    scope: {
+      mode: "fixed",
+      fixed: "main",
+      envVar: "SEARCHSOCKET_SCOPE",
+      sanitize: true
+    },
+    source: {
+      mode: "static-output",
+      staticOutputDir: "build",
+      strictRouteMapping: false
+    },
+    extract: {
+      mainSelector: "main",
+      dropTags: ["header", "nav", "footer", "aside"],
+      dropSelectors: DEFAULT_DROP_SELECTORS,
+      ignoreAttr: "data-search-ignore",
+      noindexAttr: "data-search-noindex",
+      respectRobotsNoindex: true
+    },
+    transform: {
+      output: "markdown",
+      preserveCodeBlocks: true,
+      preserveTables: true
+    },
+    chunking: {
+      strategy: "hybrid",
+      maxChars: 2200,
+      overlapChars: 200,
+      minChars: 250,
+      headingPathDepth: 3,
+      dontSplitInside: ["code", "table", "blockquote"],
+      prependTitle: true,
+      pageSummaryChunk: true
+    },
+    embeddings: {
+      provider: "openai",
+      model: "text-embedding-3-small",
+      apiKeyEnv: "OPENAI_API_KEY",
+      batchSize: 64,
+      concurrency: 4
+    },
+    vector: {
+      turso: {
+        urlEnv: "TURSO_DATABASE_URL",
+        authTokenEnv: "TURSO_AUTH_TOKEN",
+        localPath: ".searchsocket/vectors.db"
+      }
+    },
+    rerank: {
+      provider: "none",
+      topN: 20,
+      jina: {
+        apiKeyEnv: "JINA_API_KEY",
+        model: "jina-reranker-v2-base-multilingual"
+      }
+    },
+    ranking: {
+      enableIncomingLinkBoost: true,
+      enableDepthBoost: true,
+      pageWeights: {},
+      aggregationCap: 5,
+      aggregationDecay: 0.5,
+      minChunkScoreRatio: 0.5,
+      weights: {
+        incomingLinks: 0.05,
+        depth: 0.03,
+        rerank: 1,
+        aggregation: 0.1
+      }
+    },
+    api: {
+      path: "/api/search",
+      cors: {
+        allowOrigins: []
+      }
+    },
+    mcp: {
+      enable: process.env.NODE_ENV !== "production",
+      transport: "stdio",
+      http: {
+        port: 3338,
+        path: "/mcp"
+      }
+    },
+    state: {
+      dir: ".searchsocket",
+      writeMirror: false
+    }
+  };
+}
+
+// src/errors/index.ts
+var SearchSocketError = class extends Error {
+  code;
+  status;
+  constructor(code, message, status = 500) {
+    super(message);
+    this.code = code;
+    this.status = status;
+  }
+};
+
+// src/config/load.ts
+function inferProjectId(cwd) {
+  const packageJsonPath = path.join(cwd, "package.json");
+  if (!fs.existsSync(packageJsonPath)) {
+    return path.basename(cwd);
+  }
+  const raw = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+  return (raw.name ?? path.basename(cwd)).replace(/[^a-zA-Z0-9._-]/g, "-");
+}
+function detectSourceMode(cwd, config, parsedInput) {
+  if (parsedInput.source?.mode) {
+    return parsedInput.source.mode;
+  }
+  if (parsedInput.source?.build) {
+    return "build";
+  }
+  if (parsedInput.source?.crawl) {
+    return "crawl";
+  }
+  if (parsedInput.source?.contentFiles) {
+    return "content-files";
+  }
+  const staticOutputPath = path.resolve(cwd, config.source.staticOutputDir);
+  if (fs.existsSync(staticOutputPath)) {
+    return "static-output";
+  }
+  throw new SearchSocketError(
+    "CONFIG_MISSING",
+    `Unable to auto-detect source mode because ${staticOutputPath} does not exist. Set \`source.mode\` explicitly (static-output, crawl, content-files, or build).`
+  );
+}
+function mergeConfig(cwd, rawConfig) {
+  const projectId = rawConfig.project?.id ?? inferProjectId(cwd);
+  const defaults = createDefaultConfig(projectId);
+  const parseResult = searchSocketConfigSchema.safeParse(rawConfig);
+  if (!parseResult.success) {
+    const issues = parseResult.error.issues.map((issue) => `  ${issue.path.join(".")}: ${issue.message}`).join("\n");
+    throw new SearchSocketError(
+      "CONFIG_MISSING",
+      `Invalid searchsocket.config.ts:
+${issues}`
+    );
+  }
+  const parsed = parseResult.data;
+  const merged = {
+    ...defaults,
+    project: {
+      ...defaults.project,
+      ...parsed.project
+    },
+    scope: {
+      ...defaults.scope,
+      ...parsed.scope
+    },
+    source: {
+      ...defaults.source,
+      ...parsed.source,
+      crawl: parsed.source?.crawl ? {
+        ...defaults.source.crawl,
+        ...parsed.source.crawl,
+        routes: parsed.source.crawl.routes ?? []
+      } : defaults.source.crawl,
+      contentFiles: parsed.source?.contentFiles ? {
+        ...defaults.source.contentFiles,
+        ...parsed.source.contentFiles,
+        baseDir: parsed.source.contentFiles.baseDir ?? defaults.source.contentFiles?.baseDir ?? cwd
+      } : defaults.source.contentFiles,
+      build: parsed.source?.build ? {
+        outputDir: parsed.source.build.outputDir ?? ".svelte-kit/output",
+        paramValues: parsed.source.build.paramValues ?? {},
+        exclude: parsed.source.build.exclude ?? [],
+        previewTimeout: parsed.source.build.previewTimeout ?? 3e4
+      } : void 0
+    },
+    extract: {
+      ...defaults.extract,
+      ...parsed.extract
+    },
+    transform: {
+      ...defaults.transform,
+      ...parsed.transform
+    },
+    chunking: {
+      ...defaults.chunking,
+      ...parsed.chunking
+    },
+    embeddings: {
+      ...defaults.embeddings,
+      ...parsed.embeddings
+    },
+    vector: {
+      ...defaults.vector,
+      ...parsed.vector,
+      turso: {
+        ...defaults.vector.turso,
+        ...parsed.vector?.turso
+      }
+    },
+    rerank: {
+      ...defaults.rerank,
+      ...parsed.rerank,
+      jina: {
+        ...defaults.rerank.jina,
+        ...parsed.rerank?.jina
+      }
+    },
+    ranking: {
+      ...defaults.ranking,
+      ...parsed.ranking,
+      pageWeights: {
+        ...defaults.ranking.pageWeights,
+        ...parsed.ranking?.pageWeights
+      },
+      weights: {
+        ...defaults.ranking.weights,
+        ...parsed.ranking?.weights
+      }
+    },
+    api: {
+      ...defaults.api,
+      ...parsed.api,
+      cors: {
+        ...defaults.api.cors,
+        ...parsed.api?.cors,
+        allowOrigins: parsed.api?.cors?.allowOrigins ?? defaults.api.cors.allowOrigins
+      },
+      rateLimit: parsed.api?.rateLimit ? {
+        windowMs: parsed.api.rateLimit.windowMs ?? 6e4,
+        max: parsed.api.rateLimit.max ?? 60
+      } : defaults.api.rateLimit
+    },
+    mcp: {
+      ...defaults.mcp,
+      ...parsed.mcp,
+      http: {
+        ...defaults.mcp.http,
+        ...parsed.mcp?.http
+      }
+    },
+    state: {
+      ...defaults.state,
+      ...parsed.state
+    }
+  };
+  merged.project.id = projectId;
+  merged.source.mode = detectSourceMode(cwd, merged, parsed);
+  if (merged.source.mode === "build" && !merged.source.build) {
+    merged.source.build = {
+      outputDir: ".svelte-kit/output",
+      paramValues: {},
+      exclude: [],
+      previewTimeout: 3e4
+    };
+  }
+  if (merged.source.mode === "crawl" && !merged.source.crawl?.baseUrl) {
+    throw new SearchSocketError("CONFIG_MISSING", "`source.crawl.baseUrl` is required when source.mode is crawl.");
+  }
+  if (merged.source.mode === "content-files" && (!merged.source.contentFiles || merged.source.contentFiles.globs.length === 0)) {
+    throw new SearchSocketError(
+      "CONFIG_MISSING",
+      "`source.contentFiles.globs` is required when source.mode is content-files."
+    );
+  }
+  return merged;
+}
+async function loadConfig(options = {}) {
+  const cwd = path.resolve(options.cwd ?? process.cwd());
+  const configPath = path.resolve(cwd, options.configPath ?? "searchsocket.config.ts");
+  if (!fs.existsSync(configPath)) {
+    if (options.allowMissing) {
+      return mergeConfig(cwd, {
+        source: {
+          mode: "static-output"
+        }
+      });
+    }
+    throw new SearchSocketError(
+      "CONFIG_MISSING",
+      `Configuration file not found at ${configPath}. Run \`searchsocket init\` first.`
+    );
+  }
+  const jiti = createJiti(cwd, { interopDefault: true });
+  const loaded = await jiti.import(configPath);
+  const raw = loaded.default ?? loaded;
+  return mergeConfig(cwd, raw);
+}
+function writeMinimalConfig(cwd) {
+  const target = path.join(cwd, "searchsocket.config.ts");
+  if (fs.existsSync(target)) {
+    return target;
+  }
+  const content = `export default {
+  embeddings: { apiKeyEnv: "OPENAI_API_KEY" }
+};
+`;
+  fs.writeFileSync(target, content, "utf8");
+  return target;
+}
+
+// src/core/logger.ts
+var Logger = class {
+  json;
+  verbose;
+  stderrOnly;
+  constructor(opts = {}) {
+    this.json = opts.json ?? false;
+    this.verbose = opts.verbose ?? false;
+    this.stderrOnly = opts.stderrOnly ?? false;
+  }
+  info(message) {
+    if (this.json) {
+      return;
+    }
+    this.writeOut(`${message}
+`);
+  }
+  debug(message) {
+    if (!this.verbose) {
+      return;
+    }
+    if (this.json) {
+      this.logJson("debug", { message });
+      return;
+    }
+    this.writeOut(`${message}
+`);
+  }
+  warn(message) {
+    if (this.json) {
+      this.logJson("warn", { message });
+      return;
+    }
+    process.stderr.write(`WARN: ${message}
+`);
+  }
+  error(message) {
+    if (this.json) {
+      this.logJson("error", { message });
+      return;
+    }
+    process.stderr.write(`ERROR: ${message}
+`);
+  }
+  event(event, data) {
+    if (!this.json && !this.verbose) {
+      return;
+    }
+    if (this.json) {
+      this.logJson(event, data);
+      return;
+    }
+    this.writeOut(`[${event}] ${data ? JSON.stringify(data) : ""}
+`);
+  }
+  writeOut(text) {
+    if (this.stderrOnly) {
+      process.stderr.write(text);
+    } else {
+      process.stdout.write(text);
+    }
+  }
+  logJson(event, data) {
+    const entry = {
+      event,
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      data
+    };
+    this.writeOut(`${JSON.stringify(entry)}
+`);
+  }
+};
+
+// src/core/scope.ts
+import { execSync } from "child_process";
+
+// src/utils/text.ts
+function normalizeText(input) {
+  return input.replace(/\r\n/g, "\n").replace(/\s+/g, " ").trim();
+}
+function normalizeMarkdown(input) {
+  return input.replace(/\r\n/g, "\n").replace(/[ \t]+$/gm, "").trim() + "\n";
+}
+function sanitizeScopeName(scopeName) {
+  return scopeName.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
+}
+function toSnippet(markdown, maxLen = 220) {
+  const plain = markdown.replace(/```[\s\S]*?```/g, " ").replace(/`([^`]+)`/g, "$1").replace(/[#>*_|\-]/g, " ").replace(/\s+/g, " ").trim();
+  if (plain.length <= maxLen) {
+    return plain;
+  }
+  return `${plain.slice(0, Math.max(0, maxLen - 1)).trim()}\u2026`;
+}
+function extractFirstParagraph(markdown) {
+  const lines = markdown.split("\n");
+  let inFence = false;
+  const collected = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (/^(```|~~~)/.test(trimmed)) {
+      inFence = !inFence;
+      if (collected.length > 0) break;
+      continue;
+    }
+    if (inFence) continue;
+    if (/^#{1,6}\s/.test(trimmed)) {
+      if (collected.length > 0) break;
+      continue;
+    }
+    if (!trimmed) {
+      if (collected.length > 0) break;
+      continue;
+    }
+    collected.push(trimmed);
+  }
+  return collected.join(" ");
+}
+
+// src/core/scope.ts
+function resolveRawScopeName(config) {
+  if (config.scope.mode === "fixed") {
+    return config.scope.fixed;
+  }
+  if (config.scope.mode === "env") {
+    const value = process.env[config.scope.envVar];
+    if (!value) {
+      throw new Error(`Scope mode is env but ${config.scope.envVar} is not set.`);
+    }
+    return value;
+  }
+  try {
+    return execSync("git rev-parse --abbrev-ref HEAD", {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return config.scope.fixed;
+  }
+}
+function resolveScope(config, override) {
+  const rawName = override ?? resolveRawScopeName(config);
+  const scopeName = config.scope.sanitize ? sanitizeScopeName(rawName) : rawName;
+  return {
+    projectId: config.project.id,
+    scopeName,
+    scopeId: `${config.project.id}:${scopeName}`
+  };
+}
+
+// src/core/state.ts
+import fs2 from "fs";
+import path2 from "path";
+function ensureStateDirs(cwd, stateDir, scope) {
+  const statePath = path2.resolve(cwd, stateDir);
+  const pagesPath = path2.join(statePath, "pages", scope.scopeName);
+  fs2.mkdirSync(pagesPath, { recursive: true });
+  return { statePath, pagesPath };
+}
+
+// src/embeddings/openai.ts
+import OpenAI from "openai";
+import pLimit from "p-limit";
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+var OpenAIEmbeddingsProvider = class {
+  client;
+  batchSize;
+  concurrency;
+  constructor(options) {
+    if (!Number.isInteger(options.batchSize) || options.batchSize <= 0) {
+      throw new Error(`Invalid batchSize: ${options.batchSize}. batchSize must be a positive integer.`);
+    }
+    if (!Number.isInteger(options.concurrency) || options.concurrency <= 0) {
+      throw new Error(`Invalid concurrency: ${options.concurrency}. concurrency must be a positive integer.`);
+    }
+    this.client = new OpenAI({
+      apiKey: options.apiKey
+    });
+    this.batchSize = options.batchSize;
+    this.concurrency = options.concurrency;
+  }
+  estimateTokens(text) {
+    const normalized = text.trim();
+    if (!normalized) {
+      return 0;
+    }
+    const wordCount = normalized.match(/[A-Za-z0-9_]+/g)?.length ?? 0;
+    const punctuationCount = normalized.match(/[^\s\w]/g)?.length ?? 0;
+    const cjkCount = normalized.match(/[\u3400-\u9fff]/g)?.length ?? 0;
+    const charEstimate = Math.ceil(normalized.length / 4);
+    const lexicalEstimate = Math.ceil(wordCount * 1.25 + punctuationCount * 0.45 + cjkCount * 1.6);
+    return Math.max(1, Math.max(charEstimate, lexicalEstimate));
+  }
+  async embedTexts(texts, modelId) {
+    if (texts.length === 0) {
+      return [];
+    }
+    const batches = [];
+    for (let i = 0; i < texts.length; i += this.batchSize) {
+      batches.push({
+        index: i,
+        values: texts.slice(i, i + this.batchSize)
+      });
+    }
+    const outputs = new Array(batches.length);
+    const limit = pLimit(this.concurrency);
+    await Promise.all(
+      batches.map(
+        (batch, position) => limit(async () => {
+          outputs[position] = await this.embedWithRetry(batch.values, modelId);
+        })
+      )
+    );
+    return outputs.flat();
+  }
+  async embedWithRetry(texts, modelId) {
+    const maxAttempts = 5;
+    let attempt = 0;
+    while (attempt < maxAttempts) {
+      attempt += 1;
+      try {
+        const response = await this.client.embeddings.create({
+          model: modelId,
+          input: texts,
+          encoding_format: "float"
+        });
+        return response.data.map((entry) => entry.embedding);
+      } catch (error) {
+        const status = error.status;
+        const retryable = status === 429 || typeof status === "number" && status >= 500;
+        if (!retryable || attempt >= maxAttempts) {
+          throw error;
+        }
+        const delay = Math.min(2 ** attempt * 300, 5e3);
+        await sleep(delay);
+      }
+    }
+    throw new Error("Unreachable retry state");
+  }
+};
+
+// src/embeddings/factory.ts
+function createEmbeddingsProvider(config) {
+  if (config.embeddings.provider !== "openai") {
+    throw new SearchSocketError(
+      "CONFIG_MISSING",
+      `Unsupported embeddings provider ${config.embeddings.provider}`
+    );
+  }
+  const apiKey = process.env[config.embeddings.apiKeyEnv];
+  if (!apiKey) {
+    throw new SearchSocketError(
+      "CONFIG_MISSING",
+      `Missing embeddings API key env var: ${config.embeddings.apiKeyEnv}`
+    );
+  }
+  return new OpenAIEmbeddingsProvider({
+    apiKey,
+    batchSize: config.embeddings.batchSize,
+    concurrency: config.embeddings.concurrency
+  });
+}
+
+// src/indexing/pipeline.ts
+import path11 from "path";
+
+// src/vector/factory.ts
+import fs3 from "fs";
+import path3 from "path";
+
+// src/vector/turso.ts
+var TursoVectorStore = class {
+  client;
+  dimension;
+  chunksReady = false;
+  registryReady = false;
+  pagesReady = false;
+  constructor(opts) {
+    this.client = opts.client;
+    this.dimension = opts.dimension;
+  }
+  async ensureRegistry() {
+    if (this.registryReady) return;
+    await this.client.execute(`
+      CREATE TABLE IF NOT EXISTS registry (
+        scope_key   TEXT PRIMARY KEY,
+        project_id  TEXT NOT NULL,
+        scope_name  TEXT NOT NULL,
+        model_id    TEXT NOT NULL,
+        last_indexed_at TEXT NOT NULL,
+        vector_count INTEGER,
+        last_estimate_tokens INTEGER,
+        last_estimate_cost_usd REAL,
+        last_estimate_changed_chunks INTEGER
+      )
+    `);
+    const estimateCols = [
+      { name: "last_estimate_tokens", def: "INTEGER" },
+      { name: "last_estimate_cost_usd", def: "REAL" },
+      { name: "last_estimate_changed_chunks", def: "INTEGER" }
+    ];
+    for (const col of estimateCols) {
+      try {
+        await this.client.execute(`ALTER TABLE registry ADD COLUMN ${col.name} ${col.def}`);
+      } catch (error) {
+        if (error instanceof Error && !error.message.includes("duplicate column")) {
+          throw error;
+        }
+      }
+    }
+    this.registryReady = true;
+  }
+  async ensureChunks(dim) {
+    if (this.chunksReady) return;
+    await this.client.batch([
+      `CREATE TABLE IF NOT EXISTS chunks (
+        id             TEXT PRIMARY KEY,
+        project_id     TEXT NOT NULL,
+        scope_name     TEXT NOT NULL,
+        url            TEXT NOT NULL,
+        path           TEXT NOT NULL,
+        title          TEXT NOT NULL,
+        section_title  TEXT NOT NULL DEFAULT '',
+        heading_path   TEXT NOT NULL DEFAULT '[]',
+        snippet        TEXT NOT NULL DEFAULT '',
+        content_hash   TEXT NOT NULL DEFAULT '',
+        model_id       TEXT NOT NULL DEFAULT '',
+        depth          INTEGER NOT NULL DEFAULT 0,
+        incoming_links INTEGER NOT NULL DEFAULT 0,
+        route_file     TEXT NOT NULL DEFAULT '',
+        tags           TEXT NOT NULL DEFAULT '[]',
+        embedding      F32_BLOB(${dim})
+      )`,
+      `CREATE INDEX IF NOT EXISTS idx ON chunks (libsql_vector_idx(embedding, 'metric=cosine'))`
+    ]);
+    this.chunksReady = true;
+  }
+  async ensurePages() {
+    if (this.pagesReady) return;
+    await this.client.execute(`
+      CREATE TABLE IF NOT EXISTS pages (
+        project_id       TEXT NOT NULL,
+        scope_name       TEXT NOT NULL,
+        url              TEXT NOT NULL,
+        title            TEXT NOT NULL,
+        markdown         TEXT NOT NULL,
+        route_file       TEXT NOT NULL DEFAULT '',
+        route_resolution TEXT NOT NULL DEFAULT 'exact',
+        incoming_links   INTEGER NOT NULL DEFAULT 0,
+        outgoing_links   INTEGER NOT NULL DEFAULT 0,
+        depth            INTEGER NOT NULL DEFAULT 0,
+        tags             TEXT NOT NULL DEFAULT '[]',
+        indexed_at       TEXT NOT NULL,
+        PRIMARY KEY (project_id, scope_name, url)
+      )
+    `);
+    this.pagesReady = true;
+  }
+  async chunksTableExists() {
+    try {
+      await this.client.execute("SELECT 1 FROM chunks LIMIT 0");
+      return true;
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("no such table")) {
+        return false;
+      }
+      throw error;
+    }
+  }
+  async upsert(records, _scope) {
+    if (records.length === 0) return;
+    const dim = this.dimension ?? records[0].vector.length;
+    await this.ensureChunks(dim);
+    const BATCH_SIZE = 100;
+    for (let i = 0; i < records.length; i += BATCH_SIZE) {
+      const batch = records.slice(i, i + BATCH_SIZE);
+      const stmts = batch.map((r) => ({
+        sql: `INSERT OR REPLACE INTO chunks
+              (id, project_id, scope_name, url, path, title, section_title,
+               heading_path, snippet, content_hash, model_id, depth,
+               incoming_links, route_file, tags, embedding)
+              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, vector(?))`,
+        args: [
+          r.id,
+          r.metadata.projectId,
+          r.metadata.scopeName,
+          r.metadata.url,
+          r.metadata.path,
+          r.metadata.title,
+          r.metadata.sectionTitle,
+          JSON.stringify(r.metadata.headingPath),
+          r.metadata.snippet,
+          r.metadata.contentHash,
+          r.metadata.modelId,
+          r.metadata.depth,
+          r.metadata.incomingLinks,
+          r.metadata.routeFile,
+          JSON.stringify(r.metadata.tags),
+          JSON.stringify(r.vector)
+        ]
+      }));
+      await this.client.batch(stmts);
+    }
+  }
+  async query(queryVector, opts, scope) {
+    const dim = this.dimension ?? queryVector.length;
+    await this.ensureChunks(dim);
+    const queryJson = JSON.stringify(queryVector);
+    const rs = await this.client.execute({
+      sql: `SELECT c.id, c.project_id, c.scope_name, c.url, c.path, c.title,
+                   c.section_title, c.heading_path, c.snippet, c.content_hash,
+                   c.model_id, c.depth, c.incoming_links, c.route_file, c.tags,
+                   vector_distance_cos(c.embedding, vector(?)) AS distance
+            FROM vector_top_k('idx', vector(?), ?) AS v
+            JOIN chunks AS c ON c.rowid = v.id`,
+      args: [queryJson, queryJson, opts.topK]
+    });
+    let hits = [];
+    for (const row of rs.rows) {
+      const projectId = row.project_id;
+      const scopeName = row.scope_name;
+      if (projectId !== scope.projectId || scopeName !== scope.scopeName) {
+        continue;
+      }
+      const rowPath = row.path;
+      if (opts.pathPrefix) {
+        const rawPrefix = opts.pathPrefix.startsWith("/") ? opts.pathPrefix : `/${opts.pathPrefix}`;
+        const prefix = rawPrefix.endsWith("/") ? rawPrefix : `${rawPrefix}/`;
+        const normalizedPath = rowPath.replace(/\/$/, "");
+        const normalizedPrefix = rawPrefix.replace(/\/$/, "");
+        if (normalizedPath !== normalizedPrefix && !rowPath.startsWith(prefix)) {
+          continue;
+        }
+      }
+      const tags = JSON.parse(row.tags || "[]");
+      if (opts.tags && opts.tags.length > 0) {
+        if (!opts.tags.every((t) => tags.includes(t))) {
+          continue;
+        }
+      }
+      const distance = row.distance;
+      const score = 1 - distance;
+      hits.push({
+        id: row.id,
+        score,
+        metadata: {
+          projectId,
+          scopeName,
+          url: row.url,
+          path: rowPath,
+          title: row.title,
+          sectionTitle: row.section_title,
+          headingPath: JSON.parse(row.heading_path || "[]"),
+          snippet: row.snippet,
+          contentHash: row.content_hash,
+          modelId: row.model_id,
+          depth: row.depth,
+          incomingLinks: row.incoming_links,
+          routeFile: row.route_file,
+          tags
+        }
+      });
+    }
+    hits.sort((a, b) => b.score - a.score);
+    return hits;
+  }
+  async deleteByIds(ids, scope) {
+    if (ids.length === 0) return;
+    const BATCH_SIZE = 500;
+    for (let i = 0; i < ids.length; i += BATCH_SIZE) {
+      const batch = ids.slice(i, i + BATCH_SIZE);
+      const placeholders = batch.map(() => "?").join(", ");
+      await this.client.execute({
+        sql: `DELETE FROM chunks WHERE project_id = ? AND scope_name = ? AND id IN (${placeholders})`,
+        args: [scope.projectId, scope.scopeName, ...batch]
+      });
+    }
+  }
+  async deleteScope(scope) {
+    await this.ensureRegistry();
+    try {
+      await this.client.execute({
+        sql: `DELETE FROM chunks WHERE project_id = ? AND scope_name = ?`,
+        args: [scope.projectId, scope.scopeName]
+      });
+    } catch (error) {
+      if (error instanceof Error && !error.message.includes("no such table")) {
+        throw error;
+      }
+    }
+    try {
+      await this.client.execute({
+        sql: `DELETE FROM pages WHERE project_id = ? AND scope_name = ?`,
+        args: [scope.projectId, scope.scopeName]
+      });
+    } catch (error) {
+      if (error instanceof Error && !error.message.includes("no such table")) {
+        throw error;
+      }
+    }
+    await this.client.execute({
+      sql: `DELETE FROM registry WHERE project_id = ? AND scope_name = ?`,
+      args: [scope.projectId, scope.scopeName]
+    });
+  }
+  async listScopes(scopeProjectId) {
+    await this.ensureRegistry();
+    const rs = await this.client.execute({
+      sql: `SELECT project_id, scope_name, model_id, last_indexed_at, vector_count,
+                   last_estimate_tokens, last_estimate_cost_usd, last_estimate_changed_chunks
+            FROM registry WHERE project_id = ?`,
+      args: [scopeProjectId]
+    });
+    return rs.rows.map((row) => ({
+      projectId: row.project_id,
+      scopeName: row.scope_name,
+      modelId: row.model_id,
+      lastIndexedAt: row.last_indexed_at,
+      vectorCount: row.vector_count,
+      lastEstimateTokens: row.last_estimate_tokens,
+      lastEstimateCostUSD: row.last_estimate_cost_usd,
+      lastEstimateChangedChunks: row.last_estimate_changed_chunks
+    }));
+  }
+  async recordScope(info) {
+    await this.ensureRegistry();
+    const key = `${info.projectId}:${info.scopeName}`;
+    await this.client.execute({
+      sql: `INSERT OR REPLACE INTO registry
+            (scope_key, project_id, scope_name, model_id, last_indexed_at, vector_count,
+             last_estimate_tokens, last_estimate_cost_usd, last_estimate_changed_chunks)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      args: [
+        key,
+        info.projectId,
+        info.scopeName,
+        info.modelId,
+        info.lastIndexedAt,
+        info.vectorCount ?? null,
+        info.lastEstimateTokens ?? null,
+        info.lastEstimateCostUSD ?? null,
+        info.lastEstimateChangedChunks ?? null
+      ]
+    });
+  }
+  async getContentHashes(scope) {
+    const exists = await this.chunksTableExists();
+    if (!exists) return /* @__PURE__ */ new Map();
+    const rs = await this.client.execute({
+      sql: `SELECT id, content_hash FROM chunks WHERE project_id = ? AND scope_name = ?`,
+      args: [scope.projectId, scope.scopeName]
+    });
+    const map = /* @__PURE__ */ new Map();
+    for (const row of rs.rows) {
+      map.set(row.id, row.content_hash);
+    }
+    return map;
+  }
+  async upsertPages(pages, scope) {
+    if (pages.length === 0) return;
+    await this.ensurePages();
+    for (const page of pages) {
+      if (page.projectId !== scope.projectId || page.scopeName !== scope.scopeName) {
+        throw new Error(
+          `Page scope mismatch: page has ${page.projectId}:${page.scopeName} but scope is ${scope.projectId}:${scope.scopeName}`
+        );
+      }
+    }
+    const BATCH_SIZE = 100;
+    for (let i = 0; i < pages.length; i += BATCH_SIZE) {
+      const batch = pages.slice(i, i + BATCH_SIZE);
+      const stmts = batch.map((p) => ({
+        sql: `INSERT OR REPLACE INTO pages
+              (project_id, scope_name, url, title, markdown, route_file,
+               route_resolution, incoming_links, outgoing_links, depth, tags, indexed_at)
+              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        args: [
+          p.projectId,
+          p.scopeName,
+          p.url,
+          p.title,
+          p.markdown,
+          p.routeFile,
+          p.routeResolution,
+          p.incomingLinks,
+          p.outgoingLinks,
+          p.depth,
+          JSON.stringify(p.tags),
+          p.indexedAt
+        ]
+      }));
+      await this.client.batch(stmts);
+    }
+  }
+  async getPage(url, scope) {
+    await this.ensurePages();
+    const rs = await this.client.execute({
+      sql: `SELECT * FROM pages WHERE project_id = ? AND scope_name = ? AND url = ?`,
+      args: [scope.projectId, scope.scopeName, url]
+    });
+    if (rs.rows.length === 0) return null;
+    const row = rs.rows[0];
+    return {
+      url: row.url,
+      title: row.title,
+      markdown: row.markdown,
+      projectId: row.project_id,
+      scopeName: row.scope_name,
+      routeFile: row.route_file,
+      routeResolution: row.route_resolution,
+      incomingLinks: row.incoming_links,
+      outgoingLinks: row.outgoing_links,
+      depth: row.depth,
+      tags: JSON.parse(row.tags || "[]"),
+      indexedAt: row.indexed_at
+    };
+  }
+  async deletePages(scope) {
+    await this.ensurePages();
+    await this.client.execute({
+      sql: `DELETE FROM pages WHERE project_id = ? AND scope_name = ?`,
+      args: [scope.projectId, scope.scopeName]
+    });
+  }
+  async getScopeModelId(scope) {
+    await this.ensureRegistry();
+    const rs = await this.client.execute({
+      sql: `SELECT model_id FROM registry WHERE project_id = ? AND scope_name = ?`,
+      args: [scope.projectId, scope.scopeName]
+    });
+    if (rs.rows.length === 0) return null;
+    return rs.rows[0].model_id;
+  }
+  async health() {
+    try {
+      await this.client.execute("SELECT 1");
+      return { ok: true };
+    } catch (error) {
+      return {
+        ok: false,
+        details: error instanceof Error ? error.message : "unknown error"
+      };
+    }
+  }
+};
+
+// src/vector/factory.ts
+async function createVectorStore(config, cwd) {
+  const turso = config.vector.turso;
+  const remoteUrl = process.env[turso.urlEnv];
+  if (remoteUrl) {
+    const { createClient: createClient2 } = await import("@libsql/client/http");
+    const authToken = process.env[turso.authTokenEnv];
+    const client2 = createClient2({
+      url: remoteUrl,
+      authToken
+    });
+    return new TursoVectorStore({
+      client: client2,
+      dimension: config.vector.dimension
+    });
+  }
+  const { createClient } = await import("@libsql/client");
+  const localPath = path3.resolve(cwd, turso.localPath);
+  fs3.mkdirSync(path3.dirname(localPath), { recursive: true });
+  const client = createClient({
+    url: `file:${localPath}`
+  });
+  return new TursoVectorStore({
+    client,
+    dimension: config.vector.dimension
+  });
+}
+
+// src/utils/hash.ts
+import { createHash } from "crypto";
+function sha1(input) {
+  return createHash("sha1").update(input).digest("hex");
+}
+function sha256(input) {
+  return createHash("sha256").update(input).digest("hex");
+}
+
+// src/utils/path.ts
+import path4 from "path";
+function normalizeUrlPath(rawPath) {
+  let out = rawPath.trim();
+  if (!out.startsWith("/")) {
+    out = `/${out}`;
+  }
+  out = out.replace(/\/+/g, "/");
+  if (out.length > 1 && out.endsWith("/")) {
+    out = out.slice(0, -1);
+  }
+  return out;
+}
+function urlPathToMirrorRelative(urlPath) {
+  const normalized = normalizeUrlPath(urlPath);
+  if (normalized === "/") {
+    return "index.md";
+  }
+  return `${normalized.slice(1)}.md`;
+}
+function staticHtmlFileToUrl(filePath, rootDir) {
+  const relative = path4.relative(rootDir, filePath).replace(/\\/g, "/");
+  if (relative === "index.html") {
+    return "/";
+  }
+  if (relative.endsWith("/index.html")) {
+    return normalizeUrlPath(relative.slice(0, -"/index.html".length));
+  }
+  if (relative.endsWith(".html")) {
+    return normalizeUrlPath(relative.slice(0, -".html".length));
+  }
+  return normalizeUrlPath(relative);
+}
+function getUrlDepth(urlPath) {
+  if (urlPath === "/") {
+    return 0;
+  }
+  return normalizeUrlPath(urlPath).split("/").filter(Boolean).length;
+}
+function humanizeUrlPath(urlPath) {
+  const normalized = normalizeUrlPath(urlPath);
+  if (normalized === "/") return "";
+  return normalized.slice(1).split("/").map((segment) => segment.replace(/[-_]/g, " ")).join(" / ");
+}
+function ensureLeadingSlash(value) {
+  return value.startsWith("/") ? value : `/${value}`;
+}
+function joinUrl(baseUrl, route) {
+  const base = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+  const routePart = ensureLeadingSlash(route);
+  return `${base}${routePart}`;
+}
+
+// src/indexing/chunker.ts
+var FENCE_LINE_RE = /^(```|~~~)/;
+function parseHeadingSections(markdown, headingPathDepth) {
+  const lines = markdown.split("\n");
+  const sections = [];
+  const headingStack = [];
+  let inFence = false;
+  let current = {
+    sectionTitle: void 0,
+    headingPath: [],
+    text: ""
+  };
+  const flush = () => {
+    if (normalizeText(current.text)) {
+      sections.push({
+        sectionTitle: current.sectionTitle,
+        headingPath: current.headingPath,
+        text: current.text.trim()
+      });
+    }
+  };
+  for (const line of lines) {
+    if (FENCE_LINE_RE.test(line.trim())) {
+      inFence = !inFence;
+    }
+    const headingMatch = !inFence ? line.match(/^(#{1,6})\s+(.+)$/) : null;
+    if (headingMatch) {
+      flush();
+      const level = (headingMatch[1] ?? "#").length;
+      const title = (headingMatch[2] ?? "").trim();
+      headingStack[level - 1] = title;
+      headingStack.length = level;
+      current = {
+        sectionTitle: title,
+        headingPath: headingStack.filter((entry) => Boolean(entry)).slice(0, headingPathDepth),
+        text: `${line}
+`
+      };
+      continue;
+    }
+    current.text += `${line}
+`;
+  }
+  flush();
+  if (sections.length === 0 && normalizeText(markdown)) {
+    sections.push({
+      sectionTitle: void 0,
+      headingPath: [],
+      text: markdown.trim()
+    });
+  }
+  return sections;
+}
+function blockify(text, config) {
+  const lines = text.split("\n");
+  const blocks = [];
+  let inFence = false;
+  let current = [];
+  const flush = () => {
+    const value = current.join("\n").trim();
+    if (value) {
+      blocks.push(value);
+    }
+    current = [];
+  };
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i] ?? "";
+    const trimmed = line.trim();
+    if (FENCE_LINE_RE.test(trimmed)) {
+      inFence = !inFence;
+      current.push(line);
+      continue;
+    }
+    if (inFence) {
+      current.push(line);
+      continue;
+    }
+    const isTableLine = /^\|.*\|$/.test(trimmed) || /^\|?\s*:?-+:?\s*\|/.test(trimmed);
+    const isQuoteLine = /^>/.test(trimmed);
+    if (isTableLine && config.dontSplitInside.includes("table")) {
+      current.push(line);
+      while (i + 1 < lines.length) {
+        const next = lines[i + 1];
+        if (!next || !/^\|/.test(next.trim())) {
+          break;
+        }
+        i += 1;
+        current.push(lines[i] ?? "");
+      }
+      continue;
+    }
+    if (isQuoteLine && config.dontSplitInside.includes("blockquote")) {
+      current.push(line);
+      while (i + 1 < lines.length) {
+        const next = lines[i + 1];
+        if (!next || !/^>/.test(next.trim())) {
+          break;
+        }
+        i += 1;
+        current.push(lines[i] ?? "");
+      }
+      continue;
+    }
+    if (!trimmed) {
+      flush();
+      continue;
+    }
+    current.push(line);
+  }
+  flush();
+  return blocks;
+}
+function isProtectedBlock(block, config) {
+  const lines = block.trim().split("\n");
+  const first = (lines[0] ?? "").trim();
+  const last = (lines[lines.length - 1] ?? "").trim();
+  const isCodeBlock = FENCE_LINE_RE.test(first) && FENCE_LINE_RE.test(last);
+  if (isCodeBlock && config.dontSplitInside.includes("code")) {
+    return true;
+  }
+  const isTableBlock = lines.every((line) => {
+    const trimmed = line.trim();
+    return trimmed.length === 0 || /^\|.*\|$/.test(trimmed) || /^\|?\s*:?-+:?\s*\|/.test(trimmed);
+  });
+  if (isTableBlock && config.dontSplitInside.includes("table")) {
+    return true;
+  }
+  const isQuoteBlock = lines.every((line) => {
+    const trimmed = line.trim();
+    return trimmed.length === 0 || trimmed.startsWith(">");
+  });
+  return isQuoteBlock && config.dontSplitInside.includes("blockquote");
+}
+function splitOversizedBlock(block, config) {
+  const trimmed = block.trim();
+  if (trimmed.length <= config.maxChars || isProtectedBlock(trimmed, config)) {
+    return [trimmed];
+  }
+  const chunks = [];
+  let start = 0;
+  while (start < trimmed.length) {
+    let end = Math.min(start + config.maxChars, trimmed.length);
+    if (end < trimmed.length) {
+      const boundary = trimmed.lastIndexOf(" ", end);
+      if (boundary > start + Math.floor(config.maxChars * 0.6)) {
+        end = boundary;
+      }
+    }
+    const chunk = trimmed.slice(start, end).trim();
+    if (chunk) {
+      chunks.push(chunk);
+    }
+    if (end >= trimmed.length) {
+      break;
+    }
+    const nextStart = Math.max(0, end - config.overlapChars);
+    start = nextStart > start ? nextStart : end;
+  }
+  return chunks.length > 0 ? chunks : [trimmed];
+}
+function splitSection(section, config) {
+  const text = section.text.trim();
+  if (!text) {
+    return [];
+  }
+  if (text.length <= config.maxChars) {
+    return [
+      {
+        sectionTitle: section.sectionTitle,
+        headingPath: section.headingPath,
+        chunkText: text
+      }
+    ];
+  }
+  const blocks = blockify(text, config);
+  const chunks = [];
+  let current = "";
+  for (const block of blocks) {
+    const pieces = splitOversizedBlock(block, config);
+    for (const piece of pieces) {
+      if (!current) {
+        current = piece;
+        continue;
+      }
+      const candidate = `${current}
+
+${piece}`;
+      if (candidate.length <= config.maxChars) {
+        current = candidate;
+        continue;
+      }
+      chunks.push(current);
+      const overlap = current.slice(Math.max(0, current.length - config.overlapChars)).trim();
+      const withOverlap = overlap ? `${overlap}
+
+${piece}` : piece;
+      current = withOverlap.length <= config.maxChars ? withOverlap : piece;
+    }
+  }
+  if (current.trim()) {
+    chunks.push(current.trim());
+  }
+  const merged = [];
+  for (const chunk of chunks) {
+    if (merged.length === 0) {
+      merged.push(chunk);
+      continue;
+    }
+    const canMerge = chunk.length < config.minChars && merged[merged.length - 1] !== void 0 && (merged[merged.length - 1]?.length ?? 0) + 2 + chunk.length <= config.maxChars;
+    if (canMerge) {
+      merged[merged.length - 1] = `${merged[merged.length - 1]}
+
+${chunk}`;
+    } else {
+      merged.push(chunk);
+    }
+  }
+  return merged.map((chunkText) => ({
+    sectionTitle: section.sectionTitle,
+    headingPath: section.headingPath,
+    chunkText
+  }));
+}
+function buildSummaryChunkText(page) {
+  const parts = [page.title];
+  const humanized = humanizeUrlPath(page.url);
+  if (humanized) parts.push(humanized);
+  const body = page.description ?? extractFirstParagraph(page.markdown);
+  if (body) parts.push(body);
+  if (page.keywords && page.keywords.length > 0) {
+    parts.push(page.keywords.join(", "));
+  }
+  return parts.join("\n\n");
+}
+function buildEmbeddingText(chunk, prependTitle) {
+  if (!prependTitle) return chunk.chunkText;
+  const prefix = chunk.sectionTitle ? `${chunk.title} \u2014 ${chunk.sectionTitle}` : chunk.title;
+  return `${prefix}
+
+${chunk.chunkText}`;
+}
+function chunkMirrorPage(page, config, scope) {
+  const sections = parseHeadingSections(page.markdown, config.chunking.headingPathDepth);
+  const rawChunks = sections.flatMap((section) => splitSection(section, config.chunking));
+  const chunks = [];
+  if (config.chunking.pageSummaryChunk) {
+    const summaryText = buildSummaryChunkText(page);
+    const summaryChunkKey = sha1(`${scope.scopeName}|${page.url}|__summary__`);
+    const summaryChunk = {
+      chunkKey: summaryChunkKey,
+      ordinal: 0,
+      url: page.url,
+      path: page.url,
+      title: page.title,
+      sectionTitle: void 0,
+      headingPath: [],
+      chunkText: summaryText,
+      snippet: toSnippet(summaryText),
+      depth: page.depth,
+      incomingLinks: page.incomingLinks,
+      routeFile: page.routeFile,
+      tags: page.tags,
+      contentHash: ""
+    };
+    const embeddingText = buildEmbeddingText(summaryChunk, config.chunking.prependTitle);
+    summaryChunk.contentHash = sha256(normalizeText(embeddingText));
+    chunks.push(summaryChunk);
+  }
+  const ordinalOffset = config.chunking.pageSummaryChunk ? 1 : 0;
+  for (let index = 0; index < rawChunks.length; index++) {
+    const entry = rawChunks[index];
+    const sectionTitleNormalized = normalizeText(entry.sectionTitle ?? "").toLowerCase();
+    const chunkKey = sha1(
+      `${scope.scopeName}|${page.url}|${index}|${sectionTitleNormalized}`
+    );
+    const chunk = {
+      chunkKey,
+      ordinal: index + ordinalOffset,
+      url: page.url,
+      path: page.url,
+      title: page.title,
+      sectionTitle: entry.sectionTitle,
+      headingPath: entry.headingPath,
+      chunkText: entry.chunkText,
+      snippet: toSnippet(entry.chunkText),
+      depth: page.depth,
+      incomingLinks: page.incomingLinks,
+      routeFile: page.routeFile,
+      tags: page.tags,
+      contentHash: ""
+    };
+    const embeddingText = buildEmbeddingText(chunk, config.chunking.prependTitle);
+    chunk.contentHash = sha256(normalizeText(embeddingText));
+    chunks.push(chunk);
+  }
+  return chunks;
+}
+
+// src/indexing/extractor.ts
+import { load } from "cheerio";
+import matter from "gray-matter";
+import TurndownService from "turndown";
+import { gfm, highlightedCodeBlock, strikethrough, tables, taskListItems } from "turndown-plugin-gfm";
+function hasTopLevelNoindexComment(markdown) {
+  const lines = markdown.split(/\r?\n/);
+  let inFence = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (/^(```|~~~)/.test(trimmed)) {
+      inFence = !inFence;
+      continue;
+    }
+    if (!inFence && /<!--\s*noindex\s*-->/i.test(line)) {
+      return true;
+    }
+  }
+  return false;
+}
+function extractFromHtml(url, html, config) {
+  const $ = load(html);
+  const normalizedUrl = normalizeUrlPath(url);
+  const pageBaseUrl = new URL(`https://searchsocket.local${normalizedUrl}`);
+  const title = normalizeText($("title").first().text() || "") || normalizeText($(`${config.extract.mainSelector} h1`).first().text() || "") || normalizedUrl;
+  if (config.extract.respectRobotsNoindex) {
+    const robots = $("meta[name='robots']").attr("content") ?? "";
+    if (/\bnoindex\b/i.test(robots)) {
+      return null;
+    }
+  }
+  if ($(`[${config.extract.noindexAttr}]`).length > 0) {
+    return null;
+  }
+  const description = $("meta[name='description']").attr("content")?.trim() || $("meta[property='og:description']").attr("content")?.trim() || void 0;
+  const keywordsRaw = $("meta[name='keywords']").attr("content")?.trim();
+  const keywords = keywordsRaw ? keywordsRaw.split(",").map((k) => k.trim()).filter(Boolean) : void 0;
+  const root = $(config.extract.mainSelector).first().length ? $(config.extract.mainSelector).first().clone() : $("body").first().clone();
+  for (const tagName of config.extract.dropTags) {
+    root.find(tagName).remove();
+  }
+  for (const selector of config.extract.dropSelectors) {
+    root.find(selector).remove();
+  }
+  root.find(`[${config.extract.ignoreAttr}]`).remove();
+  const outgoingLinks = [];
+  root.find("a[href]").each((_index, node) => {
+    const href = $(node).attr("href");
+    if (!href || href.startsWith("#") || href.startsWith("mailto:") || href.startsWith("tel:")) {
+      return;
+    }
+    try {
+      const parsed = new URL(href, pageBaseUrl);
+      if (!["http:", "https:"].includes(parsed.protocol)) {
+        return;
+      }
+      outgoingLinks.push(normalizeUrlPath(parsed.pathname));
+    } catch {
+    }
+  });
+  const turndown = new TurndownService({
+    headingStyle: "atx",
+    codeBlockStyle: "fenced"
+  });
+  if (config.transform.preserveCodeBlocks && config.transform.preserveTables) {
+    turndown.use(gfm);
+  } else {
+    turndown.use(strikethrough);
+    turndown.use(taskListItems);
+    if (config.transform.preserveTables) {
+      turndown.use(tables);
+    }
+    if (config.transform.preserveCodeBlocks) {
+      turndown.use(highlightedCodeBlock);
+    }
+  }
+  const markdown = normalizeMarkdown(turndown.turndown(root.html() ?? ""));
+  if (!normalizeText(markdown)) {
+    return null;
+  }
+  const tags = normalizeUrlPath(url).split("/").filter(Boolean).slice(0, 1);
+  return {
+    url: normalizeUrlPath(url),
+    title,
+    markdown,
+    outgoingLinks: [...new Set(outgoingLinks)],
+    noindex: false,
+    tags,
+    description,
+    keywords
+  };
+}
+function extractFromMarkdown(url, markdown, title) {
+  if (hasTopLevelNoindexComment(markdown)) {
+    return null;
+  }
+  const parsed = matter(markdown);
+  const frontmatter = parsed.data;
+  const searchsocketMeta = frontmatter.searchsocket;
+  if (frontmatter.noindex === true || searchsocketMeta?.noindex === true) {
+    return null;
+  }
+  const content = parsed.content;
+  const normalized = normalizeMarkdown(content);
+  if (!normalizeText(normalized)) {
+    return null;
+  }
+  const resolvedTitle = title ?? (typeof frontmatter.title === "string" ? frontmatter.title : void 0) ?? normalizeUrlPath(url);
+  const fmDescription = typeof frontmatter.description === "string" ? frontmatter.description.trim() || void 0 : void 0;
+  let fmKeywords;
+  if (Array.isArray(frontmatter.keywords)) {
+    fmKeywords = frontmatter.keywords.filter((k) => typeof k === "string" && k.trim().length > 0).map((k) => k.trim());
+  } else if (typeof frontmatter.keywords === "string" && frontmatter.keywords.trim()) {
+    fmKeywords = frontmatter.keywords.split(",").map((k) => k.trim()).filter(Boolean);
+  }
+  if (fmKeywords && fmKeywords.length === 0) fmKeywords = void 0;
+  return {
+    url: normalizeUrlPath(url),
+    title: resolvedTitle,
+    markdown: normalized,
+    outgoingLinks: [],
+    noindex: false,
+    tags: normalizeUrlPath(url).split("/").filter(Boolean).slice(0, 1),
+    description: fmDescription,
+    keywords: fmKeywords
+  };
+}
+
+// src/indexing/mirror.ts
+import fs4 from "fs/promises";
+import path5 from "path";
+function yamlString(value) {
+  return JSON.stringify(value);
+}
+function yamlArray(values) {
+  return `[${values.map((v) => JSON.stringify(v)).join(", ")}]`;
+}
+function buildMirrorMarkdown(page) {
+  const frontmatterLines = [
+    "---",
+    `url: ${yamlString(page.url)}`,
+    `title: ${yamlString(page.title)}`,
+    `scope: ${yamlString(page.scope)}`,
+    `routeFile: ${yamlString(page.routeFile)}`,
+    `routeResolution: ${yamlString(page.routeResolution)}`,
+    `generatedAt: ${yamlString(page.generatedAt)}`,
+    `incomingLinks: ${page.incomingLinks}`,
+    `outgoingLinks: ${page.outgoingLinks}`,
+    `depth: ${page.depth}`,
+    `tags: ${yamlArray(page.tags)}`,
+    "---",
+    ""
+  ];
+  return `${frontmatterLines.join("\n")}${normalizeMarkdown(page.markdown)}`;
+}
+function stripGeneratedAt(content) {
+  return content.replace(/^generatedAt: .*$/m, "");
+}
+async function writeMirrorPage(statePath, scope, page) {
+  const relative = urlPathToMirrorRelative(page.url);
+  const outputPath = path5.join(statePath, "pages", scope.scopeName, relative);
+  await fs4.mkdir(path5.dirname(outputPath), { recursive: true });
+  const newContent = buildMirrorMarkdown(page);
+  try {
+    const existing = await fs4.readFile(outputPath, "utf8");
+    if (stripGeneratedAt(existing) === stripGeneratedAt(newContent)) {
+      return outputPath;
+    }
+  } catch {
+  }
+  await fs4.writeFile(outputPath, newContent, "utf8");
+  return outputPath;
+}
+async function cleanMirrorForScope(statePath, scope) {
+  const target = path5.join(statePath, "pages", scope.scopeName);
+  await fs4.rm(target, { recursive: true, force: true });
+  await fs4.mkdir(target, { recursive: true });
+}
+
+// src/indexing/route-mapper.ts
+import path6 from "path";
+import fg from "fast-glob";
+function segmentToRegex(segment) {
+  if (segment.startsWith("(") && segment.endsWith(")")) {
+    return { regex: "", score: 0 };
+  }
+  if (/^\[\[\.\.\.[^\]]+\]\]$/.test(segment)) {
+    return { regex: "(?:/.+)?", score: -2 };
+  }
+  if (/^\[\.\.\.[^\]]+\]$/.test(segment)) {
+    return { regex: "/.+", score: 0 };
+  }
+  if (/^\[\[[^\]]+\]\]$/.test(segment)) {
+    return { regex: "(?:/[^/]+)?", score: -1 };
+  }
+  if (/^\[[^\]]+\]$/.test(segment)) {
+    return { regex: "/[^/]+", score: 3 };
+  }
+  return { regex: `/${segment.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`, score: 10 };
+}
+function routeFileToPattern(routeFile, cwd) {
+  const relative = path6.relative(cwd, routeFile).replace(/\\/g, "/");
+  const withoutPrefix = relative.replace(/^src\/routes\/?/, "");
+  const withoutPage = withoutPrefix.replace(/\/\+page\.[^/]+$/, "");
+  const segments = withoutPage.split("/").filter(Boolean);
+  let regex = "^";
+  let score = 0;
+  if (segments.length === 0) {
+    regex += "/";
+  } else {
+    for (const segment of segments) {
+      const converted = segmentToRegex(segment);
+      regex += converted.regex;
+      score += converted.score;
+    }
+  }
+  regex += "/?$";
+  return {
+    routeFile: relative,
+    regex: new RegExp(regex),
+    score
+  };
+}
+async function buildRoutePatterns(cwd) {
+  const files = await fg("src/routes/**/+page.svelte", {
+    cwd,
+    absolute: true
+  });
+  return files.map((file) => routeFileToPattern(file, cwd)).sort((a, b) => b.score - a.score || b.routeFile.length - a.routeFile.length);
+}
+function mapUrlToRoute(urlPath, patterns) {
+  const normalized = normalizeUrlPath(urlPath);
+  for (const pattern of patterns) {
+    if (pattern.regex.test(normalized)) {
+      return {
+        routeFile: pattern.routeFile,
+        routeResolution: "exact"
+      };
+    }
+  }
+  const rootRoute = patterns.find((pattern) => pattern.routeFile === "src/routes/+page.svelte");
+  if (rootRoute) {
+    return {
+      routeFile: rootRoute.routeFile,
+      routeResolution: "best-effort"
+    };
+  }
+  const fallback = patterns[0];
+  return {
+    routeFile: fallback?.routeFile ?? "src/routes/+page.svelte",
+    routeResolution: "best-effort"
+  };
+}
+
+// src/indexing/sources/build/index.ts
+import pLimit2 from "p-limit";
+
+// src/indexing/sources/build/manifest-parser.ts
+import fs5 from "fs/promises";
+import path7 from "path";
+function routeIdToFile(routeId) {
+  if (routeId === "/") {
+    return "src/routes/+page.svelte";
+  }
+  return `src/routes${routeId}/+page.svelte`;
+}
+function routeIdToUrl(routeId) {
+  if (routeId === "/") return "/";
+  return routeId.split("/").filter((seg) => !(seg.startsWith("(") && seg.endsWith(")"))).join("/") || "/";
+}
+async function parseManifest(cwd, outputDir) {
+  const manifestPath = path7.resolve(cwd, outputDir, "server", "manifest-full.js");
+  let content;
+  try {
+    content = await fs5.readFile(manifestPath, "utf8");
+  } catch {
+    throw new SearchSocketError(
+      "BUILD_MANIFEST_NOT_FOUND",
+      `SvelteKit build manifest not found at ${manifestPath}. Run \`vite build\` first.`
+    );
+  }
+  const routes = [];
+  const idRegex = /id:\s*"([^"]+)"/g;
+  const idMatches = [];
+  let idMatch;
+  while ((idMatch = idRegex.exec(content)) !== null) {
+    idMatches.push({ id: idMatch[1], index: idMatch.index });
+  }
+  for (let i = 0; i < idMatches.length; i++) {
+    const current = idMatches[i];
+    const nextIndex = idMatches[i + 1]?.index ?? content.length;
+    const block = content.slice(current.index, nextIndex);
+    const isPage = /page:\s*\{/.test(block);
+    if (!isPage) continue;
+    const isDynamic = current.id.includes("[");
+    routes.push({
+      id: current.id,
+      isPage: true,
+      isDynamic,
+      routeFile: routeIdToFile(current.id)
+    });
+  }
+  return routes;
+}
+function expandRoutes(routes, paramValues, exclude, logger3) {
+  const expanded = [];
+  for (const route of routes) {
+    const url = routeIdToUrl(route.id);
+    if (isExcluded(url, exclude)) continue;
+    if (!route.isDynamic) {
+      expanded.push({ url, routeFile: route.routeFile });
+      continue;
+    }
+    const values = paramValues[route.id] ?? paramValues[url];
+    if (!values || values.length === 0) {
+      logger3.warn(
+        `Skipping dynamic route ${route.id}: no paramValues provided. Add paramValues["${route.id}"] or paramValues["${url}"] to your build config.`
+      );
+      continue;
+    }
+    for (const value of values) {
+      const expandedUrl = expandDynamicUrl(url, value);
+      if (!isExcluded(expandedUrl, exclude)) {
+        expanded.push({ url: expandedUrl, routeFile: route.routeFile });
+      }
+    }
+  }
+  return expanded;
+}
+function expandDynamicUrl(url, value) {
+  return url.replace(/\[\[?\.\.\.[^\]]+\]?\]|\[\[[^\]]+\]\]|\[[^\]]+\]/g, value);
+}
+function isExcluded(url, patterns) {
+  for (const pattern of patterns) {
+    if (pattern.endsWith("/*")) {
+      const prefix = pattern.slice(0, -1);
+      if (url.startsWith(prefix) || url === prefix.slice(0, -1)) return true;
+    } else if (url === pattern) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/indexing/sources/build/preview-server.ts
+import net from "net";
+import path8 from "path";
+import fs6 from "fs";
+import { spawn } from "child_process";
+function findFreePort() {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      if (!addr || typeof addr === "string") {
+        server.close(() => reject(new Error("Failed to get port")));
+        return;
+      }
+      const port = addr.port;
+      server.close(() => resolve(port));
+    });
+    server.on("error", reject);
+  });
+}
+async function waitForReady(url, timeout, child) {
+  const deadline = Date.now() + timeout;
+  while (Date.now() < deadline) {
+    if (child.exitCode !== null) {
+      throw new SearchSocketError(
+        "BUILD_SERVER_FAILED",
+        `vite preview exited with code ${child.exitCode} before becoming ready.`
+      );
+    }
+    try {
+      const res = await fetch(url, { signal: AbortSignal.timeout(2e3) });
+      if (res.status < 500) return;
+    } catch {
+    }
+    await new Promise((resolve) => setTimeout(resolve, 250));
+  }
+  throw new SearchSocketError(
+    "BUILD_SERVER_FAILED",
+    `vite preview did not become ready within ${timeout}ms. Check that \`vite build\` completed successfully.`
+  );
+}
+async function startPreviewServer(cwd, options, logger3) {
+  const viteBin = path8.join(cwd, "node_modules", ".bin", "vite");
+  if (!fs6.existsSync(viteBin)) {
+    throw new SearchSocketError(
+      "BUILD_SERVER_FAILED",
+      `vite binary not found at ${viteBin}. Ensure vite is installed.`
+    );
+  }
+  const port = await findFreePort();
+  const baseUrl = `http://127.0.0.1:${port}`;
+  logger3.event("preview_server_starting", { port });
+  const child = spawn(viteBin, ["preview", "--port", String(port), "--strictPort", "--host", "127.0.0.1"], {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    env: { ...process.env }
+  });
+  let stderr = "";
+  child.stderr?.on("data", (chunk) => {
+    stderr += chunk.toString();
+  });
+  const shutdown = async () => {
+    if (child.exitCode !== null) return;
+    child.kill("SIGTERM");
+    await Promise.race([
+      new Promise((resolve) => child.on("close", () => resolve())),
+      new Promise((resolve) => setTimeout(() => {
+        if (child.exitCode === null) child.kill("SIGKILL");
+        resolve();
+      }, 3e3))
+    ]);
+  };
+  try {
+    await waitForReady(baseUrl, options.previewTimeout, child);
+  } catch (error) {
+    await shutdown();
+    if (stderr) {
+      logger3.warn(`vite preview stderr: ${stderr.slice(0, 500)}`);
+    }
+    throw error;
+  }
+  logger3.event("preview_server_ready", { port, baseUrl });
+  return { baseUrl, port, shutdown };
+}
+
+// src/indexing/sources/build/index.ts
+var logger = new Logger();
+async function loadBuildPages(cwd, config, maxPages) {
+  const buildConfig = config.source.build;
+  if (!buildConfig) {
+    throw new Error("build source config is missing");
+  }
+  const routes = await parseManifest(cwd, buildConfig.outputDir);
+  const expanded = expandRoutes(routes, buildConfig.paramValues, buildConfig.exclude, logger);
+  logger.event("build_routes_discovered", {
+    manifestRoutes: routes.length,
+    expandedRoutes: expanded.length
+  });
+  const maxCount = typeof maxPages === "number" ? Math.max(0, Math.floor(maxPages)) : void 0;
+  const selected = typeof maxCount === "number" ? expanded.slice(0, maxCount) : expanded;
+  const server = await startPreviewServer(cwd, { previewTimeout: buildConfig.previewTimeout }, logger);
+  try {
+    const concurrencyLimit = pLimit2(8);
+    const results = await Promise.allSettled(
+      selected.map(
+        (route) => concurrencyLimit(async () => {
+          const fetchUrl = joinUrl(server.baseUrl, route.url);
+          const response = await fetch(fetchUrl);
+          if (!response.ok) {
+            throw new Error(`Failed to fetch ${route.url}: ${response.status} ${response.statusText}`);
+          }
+          return {
+            url: normalizeUrlPath(route.url),
+            html: await response.text(),
+            sourcePath: route.routeFile,
+            outgoingLinks: [],
+            routeFile: route.routeFile,
+            routeResolution: "exact"
+          };
+        })
+      )
+    );
+    const pages = [];
+    for (let i = 0; i < results.length; i += 1) {
+      const result = results[i];
+      if (!result) continue;
+      if (result.status === "fulfilled") {
+        pages.push(result.value);
+      } else {
+        const route = selected[i]?.url ?? "unknown";
+        logger.warn(
+          `Skipping build route ${route}: ${result.reason instanceof Error ? result.reason.message : String(result.reason)}`
+        );
+      }
+    }
+    return pages;
+  } finally {
+    await server.shutdown();
+  }
+}
+
+// src/indexing/sources/content-files.ts
+import fs7 from "fs/promises";
+import path9 from "path";
+import fg2 from "fast-glob";
+function filePathToUrl(filePath, baseDir) {
+  const relative = path9.relative(baseDir, filePath).replace(/\\/g, "/");
+  const segments = relative.split("/").filter(Boolean);
+  if (/(^|\/)\+page\.svelte$/.test(relative)) {
+    const routeSegments = segments.slice();
+    if ((routeSegments[0] ?? "").toLowerCase() === "src" && (routeSegments[1] ?? "").toLowerCase() === "routes") {
+      routeSegments.splice(0, 2);
+    } else if ((routeSegments[0] ?? "").toLowerCase() === "routes") {
+      routeSegments.splice(0, 1);
+    }
+    const routePath = routeSegments.filter((segment) => segment !== "+page.svelte").filter((segment) => segment && !segment.startsWith("(")).map(
+      (segment) => segment.replace(/^\[\[[^\]]+\]\]$/, "optional").replace(/^\[\.\.\.[^\]]+\]$/, "splat").replace(/^\[[^\]]+\]$/, "param")
+    ).join("/");
+    return normalizeUrlPath(routePath || "/");
+  }
+  const noExt = relative.replace(/\.md$/i, "").replace(/\/index$/i, "");
+  return normalizeUrlPath(noExt || "/");
+}
+function normalizeSvelteToMarkdown(source) {
+  return source.replace(/<script[\s\S]*?<\/script>/g, "").replace(/<style[\s\S]*?<\/style>/g, "").replace(/<[^>]+>/g, " ").replace(/\{[^}]+\}/g, " ").replace(/\s+/g, " ").trim();
+}
+async function loadContentFilesPages(cwd, config, maxPages) {
+  const contentConfig = config.source.contentFiles;
+  if (!contentConfig) {
+    throw new Error("content-files config is missing");
+  }
+  const baseDir = path9.resolve(cwd, contentConfig.baseDir);
+  const files = await fg2(contentConfig.globs, {
+    cwd: baseDir,
+    absolute: true,
+    onlyFiles: true
+  });
+  const limit = typeof maxPages === "number" ? Math.max(0, Math.floor(maxPages)) : void 0;
+  const selected = typeof limit === "number" ? files.slice(0, limit) : files;
+  const pages = [];
+  for (const filePath of selected) {
+    const raw = await fs7.readFile(filePath, "utf8");
+    const markdown = filePath.endsWith(".md") ? raw : normalizeSvelteToMarkdown(raw);
+    pages.push({
+      url: filePathToUrl(filePath, baseDir),
+      markdown,
+      sourcePath: path9.relative(cwd, filePath).replace(/\\/g, "/"),
+      outgoingLinks: []
+    });
+  }
+  return pages;
+}
+
+// src/indexing/sources/crawl.ts
+import { gunzipSync } from "zlib";
+import { load as cheerioLoad } from "cheerio";
+import pLimit3 from "p-limit";
+var logger2 = new Logger();
+function extractLocs(xml) {
+  const $ = cheerioLoad(xml, { xmlMode: true });
+  const locs = [];
+  $("loc").each((_i, el) => {
+    const text = $(el).text().trim();
+    if (text) {
+      locs.push(text);
+    }
+  });
+  return locs;
+}
+function isSitemapIndex(xml) {
+  const $ = cheerioLoad(xml, { xmlMode: true });
+  return $("sitemapindex").length > 0;
+}
+async function fetchSitemapXml(url) {
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw new Error(`Failed to fetch sitemap ${url}: ${res.status} ${res.statusText}`);
+  }
+  if (url.endsWith(".gz")) {
+    const buffer = Buffer.from(await res.arrayBuffer());
+    return gunzipSync(buffer).toString("utf8");
+  }
+  return res.text();
+}
+function resolveSitemapUrl(baseUrl, candidate) {
+  return candidate.startsWith("http") ? candidate : joinUrl(baseUrl, candidate);
+}
+async function parseSitemap(xml, baseUrl, visitedSitemaps) {
+  if (isSitemapIndex(xml)) {
+    const childUrls = extractLocs(xml);
+    const routes2 = [];
+    for (const childUrl of childUrls) {
+      const childRoutes = await parseSitemapFromUrl(childUrl, baseUrl, visitedSitemaps);
+      routes2.push(...childRoutes);
+    }
+    return [...new Set(routes2)];
+  }
+  const locs = extractLocs(xml);
+  const routes = [];
+  for (const loc of locs) {
+    try {
+      const parsed = loc.startsWith("http://") || loc.startsWith("https://") ? new URL(loc) : new URL(loc, baseUrl);
+      if (!["http:", "https:"].includes(parsed.protocol)) {
+        continue;
+      }
+      routes.push(normalizeUrlPath(parsed.pathname));
+    } catch {
+    }
+  }
+  return [...new Set(routes)];
+}
+async function parseSitemapFromUrl(url, baseUrl, visitedSitemaps) {
+  const resolved = resolveSitemapUrl(baseUrl, url);
+  if (visitedSitemaps.has(resolved)) {
+    return [];
+  }
+  visitedSitemaps.add(resolved);
+  const xml = await fetchSitemapXml(resolved);
+  return parseSitemap(xml, baseUrl, visitedSitemaps);
+}
+async function resolveRoutes(config) {
+  const crawlConfig = config.source.crawl;
+  if (!crawlConfig) {
+    return [];
+  }
+  if (crawlConfig.routes.length > 0) {
+    return [...new Set(crawlConfig.routes.map((route) => normalizeUrlPath(ensureLeadingSlash(route))))];
+  }
+  if (!crawlConfig.sitemapUrl) {
+    return ["/"];
+  }
+  return parseSitemapFromUrl(crawlConfig.sitemapUrl, crawlConfig.baseUrl, /* @__PURE__ */ new Set());
+}
+async function loadCrawledPages(config, maxPages) {
+  const crawlConfig = config.source.crawl;
+  if (!crawlConfig) {
+    throw new Error("crawl source config is missing");
+  }
+  const routes = await resolveRoutes(config);
+  const maxCount = typeof maxPages === "number" ? Math.max(0, Math.floor(maxPages)) : void 0;
+  const selected = typeof maxCount === "number" ? routes.slice(0, maxCount) : routes;
+  const concurrencyLimit = pLimit3(8);
+  const results = await Promise.allSettled(
+    selected.map(
+      (route) => concurrencyLimit(async () => {
+        const url = joinUrl(crawlConfig.baseUrl, route);
+        const response = await fetch(url);
+        if (!response.ok) {
+          throw new Error(`Failed to fetch route ${route}: ${response.status} ${response.statusText}`);
+        }
+        return {
+          url: normalizeUrlPath(route),
+          html: await response.text(),
+          sourcePath: url,
+          outgoingLinks: []
+        };
+      })
+    )
+  );
+  const pages = [];
+  for (let i = 0; i < results.length; i += 1) {
+    const result = results[i];
+    if (!result) continue;
+    if (result.status === "fulfilled") {
+      pages.push(result.value);
+    } else {
+      const route = selected[i] ?? "unknown";
+      logger2.warn(`Skipping route ${route}: ${result.reason instanceof Error ? result.reason.message : String(result.reason)}`);
+    }
+  }
+  return pages;
+}
+
+// src/indexing/sources/static-output.ts
+import fs8 from "fs/promises";
+import path10 from "path";
+import fg3 from "fast-glob";
+async function loadStaticOutputPages(cwd, config, maxPages) {
+  const outputDir = path10.resolve(cwd, config.source.staticOutputDir);
+  const htmlFiles = await fg3(["**/*.html"], {
+    cwd: outputDir,
+    absolute: true
+  });
+  const limit = typeof maxPages === "number" ? Math.max(0, Math.floor(maxPages)) : void 0;
+  const selected = typeof limit === "number" ? htmlFiles.slice(0, limit) : htmlFiles;
+  const pages = [];
+  for (const filePath of selected) {
+    const html = await fs8.readFile(filePath, "utf8");
+    pages.push({
+      url: staticHtmlFileToUrl(filePath, outputDir),
+      html,
+      sourcePath: path10.relative(cwd, filePath).replace(/\\/g, "/"),
+      outgoingLinks: []
+    });
+  }
+  return pages;
+}
+
+// src/utils/time.ts
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function hrTimeMs(start) {
+  return Number(process.hrtime.bigint() - start) / 1e6;
+}
+
+// src/indexing/pipeline.ts
+var EMBEDDING_PRICE_PER_1K_TOKENS_USD = {
+  "text-embedding-3-small": 2e-5,
+  "text-embedding-3-large": 13e-5,
+  "text-embedding-ada-002": 1e-4
+};
+var DEFAULT_EMBEDDING_PRICE_PER_1K = 2e-5;
+var IndexPipeline = class _IndexPipeline {
+  cwd;
+  config;
+  embeddings;
+  vectorStore;
+  logger;
+  constructor(options) {
+    this.cwd = options.cwd;
+    this.config = options.config;
+    this.embeddings = options.embeddings;
+    this.vectorStore = options.vectorStore;
+    this.logger = options.logger;
+  }
+  static async create(options = {}) {
+    const cwd = path11.resolve(options.cwd ?? process.cwd());
+    const config = options.config ?? await loadConfig({ cwd, configPath: options.configPath });
+    const embeddings = options.embeddingsProvider ?? createEmbeddingsProvider(config);
+    const vectorStore = options.vectorStore ?? await createVectorStore(config, cwd);
+    return new _IndexPipeline({
+      cwd,
+      config,
+      embeddings,
+      vectorStore,
+      logger: options.logger ?? new Logger()
+    });
+  }
+  getConfig() {
+    return this.config;
+  }
+  async run(rawOptions = {}) {
+    const options = {
+      changedOnly: rawOptions.changedOnly ?? true,
+      force: rawOptions.force ?? false,
+      dryRun: rawOptions.dryRun ?? false,
+      ...rawOptions
+    };
+    const stageTimingsMs = {};
+    const stageStart = () => process.hrtime.bigint();
+    const stageEnd = (name, start) => {
+      stageTimingsMs[name] = Math.round(hrTimeMs(start));
+    };
+    const scope = resolveScope(this.config, options.scopeOverride);
+    const { statePath } = ensureStateDirs(this.cwd, this.config.state.dir, scope);
+    if (options.force) {
+      await cleanMirrorForScope(statePath, scope);
+    }
+    const manifestStart = stageStart();
+    const existingHashes = await this.vectorStore.getContentHashes(scope);
+    const existingModelId = await this.vectorStore.getScopeModelId(scope);
+    if (existingModelId && existingModelId !== this.config.embeddings.model && !options.force) {
+      throw new SearchSocketError(
+        "EMBEDDING_MODEL_MISMATCH",
+        `Scope ${scope.scopeName} uses model ${existingModelId}. Re-run with --force to migrate.`
+      );
+    }
+    stageEnd("manifest", manifestStart);
+    const sourceStart = stageStart();
+    const sourceMode = options.sourceOverride ?? this.config.source.mode;
+    let sourcePages;
+    if (sourceMode === "static-output") {
+      sourcePages = await loadStaticOutputPages(this.cwd, this.config, options.maxPages);
+    } else if (sourceMode === "crawl") {
+      sourcePages = await loadCrawledPages(this.config, options.maxPages);
+    } else if (sourceMode === "build") {
+      sourcePages = await loadBuildPages(this.cwd, this.config, options.maxPages);
+    } else {
+      sourcePages = await loadContentFilesPages(this.cwd, this.config, options.maxPages);
+    }
+    stageEnd("source", sourceStart);
+    const routeStart = stageStart();
+    const routePatterns = await buildRoutePatterns(this.cwd);
+    stageEnd("route_map", routeStart);
+    const extractStart = stageStart();
+    const extractedPages = [];
+    for (const sourcePage of sourcePages) {
+      const extracted = sourcePage.html ? extractFromHtml(sourcePage.url, sourcePage.html, this.config) : extractFromMarkdown(sourcePage.url, sourcePage.markdown ?? "", sourcePage.title);
+      if (!extracted) {
+        this.logger.warn(
+          `Page ${sourcePage.url} produced no extractable content and was skipped. Check extract.mainSelector, extract.dropTags, and extract.dropSelectors settings.`
+        );
+        continue;
+      }
+      extractedPages.push(extracted);
+      this.logger.event("page_extracted", {
+        url: extracted.url
+      });
+    }
+    extractedPages.sort((a, b) => a.url.localeCompare(b.url));
+    const uniquePages = [];
+    const seenUrls = /* @__PURE__ */ new Set();
+    for (const page of extractedPages) {
+      if (seenUrls.has(page.url)) {
+        this.logger.warn(
+          `Duplicate page source for ${page.url}; keeping first extracted page and skipping the duplicate.`
+        );
+        continue;
+      }
+      seenUrls.add(page.url);
+      uniquePages.push(page);
+    }
+    stageEnd("extract", extractStart);
+    const linkStart = stageStart();
+    const pageSet = new Set(uniquePages.map((page) => normalizeUrlPath(page.url)));
+    const incomingLinkCount = /* @__PURE__ */ new Map();
+    for (const page of uniquePages) {
+      incomingLinkCount.set(page.url, incomingLinkCount.get(page.url) ?? 0);
+    }
+    for (const page of uniquePages) {
+      for (const outgoing of page.outgoingLinks) {
+        if (!pageSet.has(outgoing)) {
+          continue;
+        }
+        incomingLinkCount.set(outgoing, (incomingLinkCount.get(outgoing) ?? 0) + 1);
+      }
+    }
+    stageEnd("links", linkStart);
+    const mirrorStart = stageStart();
+    const mirrorPages = [];
+    let routeExact = 0;
+    let routeBestEffort = 0;
+    const precomputedRoutes = /* @__PURE__ */ new Map();
+    for (const sp of sourcePages) {
+      if (sp.routeFile) {
+        precomputedRoutes.set(normalizeUrlPath(sp.url), {
+          routeFile: sp.routeFile,
+          routeResolution: sp.routeResolution ?? "exact"
+        });
+      }
+    }
+    for (const page of uniquePages) {
+      const routeMatch = precomputedRoutes.get(normalizeUrlPath(page.url)) ?? mapUrlToRoute(page.url, routePatterns);
+      if (routeMatch.routeResolution === "best-effort") {
+        if (this.config.source.strictRouteMapping) {
+          throw new SearchSocketError(
+            "ROUTE_MAPPING_FAILED",
+            `Strict route mapping enabled: no exact route match for ${page.url} (resolved to ${routeMatch.routeFile}). Disable source.strictRouteMapping or add the missing route file.`,
+            400
+          );
+        }
+        this.logger.warn(
+          `No exact route match for ${page.url}, falling back to ${routeMatch.routeFile}.`
+        );
+        routeBestEffort += 1;
+      } else {
+        routeExact += 1;
+      }
+      const mirror = {
+        url: page.url,
+        title: page.title,
+        scope: scope.scopeName,
+        routeFile: routeMatch.routeFile,
+        routeResolution: routeMatch.routeResolution,
+        generatedAt: nowIso(),
+        incomingLinks: incomingLinkCount.get(page.url) ?? 0,
+        outgoingLinks: page.outgoingLinks.length,
+        depth: getUrlDepth(page.url),
+        tags: page.tags,
+        markdown: page.markdown,
+        description: page.description,
+        keywords: page.keywords
+      };
+      mirrorPages.push(mirror);
+      if (this.config.state.writeMirror) {
+        await writeMirrorPage(statePath, scope, mirror);
+      }
+      this.logger.event("markdown_written", { url: page.url });
+    }
+    if (!options.dryRun) {
+      const pageRecords = mirrorPages.map((mp) => ({
+        url: mp.url,
+        title: mp.title,
+        markdown: mp.markdown,
+        projectId: scope.projectId,
+        scopeName: scope.scopeName,
+        routeFile: mp.routeFile,
+        routeResolution: mp.routeResolution,
+        incomingLinks: mp.incomingLinks,
+        outgoingLinks: mp.outgoingLinks,
+        depth: mp.depth,
+        tags: mp.tags,
+        indexedAt: mp.generatedAt
+      }));
+      await this.vectorStore.deletePages(scope);
+      await this.vectorStore.upsertPages(pageRecords, scope);
+    }
+    stageEnd("mirror", mirrorStart);
+    const chunkStart = stageStart();
+    let chunks = mirrorPages.flatMap((page) => chunkMirrorPage(page, this.config, scope));
+    const maxChunks = typeof options.maxChunks === "number" ? Math.max(0, Math.floor(options.maxChunks)) : void 0;
+    if (typeof maxChunks === "number") {
+      chunks = chunks.slice(0, maxChunks);
+    }
+    for (const chunk of chunks) {
+      this.logger.event("chunked", {
+        url: chunk.url,
+        chunkKey: chunk.chunkKey
+      });
+    }
+    stageEnd("chunk", chunkStart);
+    const currentChunkMap = /* @__PURE__ */ new Map();
+    for (const chunk of chunks) {
+      currentChunkMap.set(chunk.chunkKey, chunk);
+    }
+    const changedChunks = chunks.filter((chunk) => {
+      if (options.force) {
+        return true;
+      }
+      const existingHash = existingHashes.get(chunk.chunkKey);
+      if (!existingHash) {
+        return true;
+      }
+      if (!options.changedOnly) {
+        return true;
+      }
+      return existingHash !== chunk.contentHash;
+    });
+    const deletes = [...existingHashes.keys()].filter((chunkKey) => !currentChunkMap.has(chunkKey));
+    const embedStart = stageStart();
+    const chunkTokenEstimates = /* @__PURE__ */ new Map();
+    for (const chunk of changedChunks) {
+      chunkTokenEstimates.set(chunk.chunkKey, this.embeddings.estimateTokens(buildEmbeddingText(chunk, this.config.chunking.prependTitle)));
+    }
+    const estimatedTokens = changedChunks.reduce(
+      (sum, chunk) => sum + (chunkTokenEstimates.get(chunk.chunkKey) ?? 0),
+      0
+    );
+    const pricePer1k = this.config.embeddings.pricePer1kTokens ?? EMBEDDING_PRICE_PER_1K_TOKENS_USD[this.config.embeddings.model] ?? DEFAULT_EMBEDDING_PRICE_PER_1K;
+    const estimatedCostUSD = estimatedTokens / 1e3 * pricePer1k;
+    let newEmbeddings = 0;
+    const vectorsByChunk = /* @__PURE__ */ new Map();
+    if (!options.dryRun && changedChunks.length > 0) {
+      const embeddings = await this.embeddings.embedTexts(
+        changedChunks.map((chunk) => buildEmbeddingText(chunk, this.config.chunking.prependTitle)),
+        this.config.embeddings.model
+      );
+      if (embeddings.length !== changedChunks.length) {
+        throw new SearchSocketError(
+          "VECTOR_BACKEND_UNAVAILABLE",
+          `Embedding provider returned ${embeddings.length} vectors for ${changedChunks.length} chunks.`
+        );
+      }
+      for (let i = 0; i < changedChunks.length; i += 1) {
+        const chunk = changedChunks[i];
+        const embedding = embeddings[i];
+        if (!chunk || !embedding || embedding.length === 0 || embedding.some((value) => !Number.isFinite(value))) {
+          throw new SearchSocketError(
+            "VECTOR_BACKEND_UNAVAILABLE",
+            `Embedding provider returned an invalid vector for chunk index ${i}.`
+          );
+        }
+        vectorsByChunk.set(chunk.chunkKey, embedding);
+        newEmbeddings += 1;
+        this.logger.event("embedded_new", { chunkKey: chunk.chunkKey });
+      }
+    }
+    stageEnd("embedding", embedStart);
+    const syncStart = stageStart();
+    if (!options.dryRun) {
+      const upserts = [];
+      for (const chunk of changedChunks) {
+        const vector = vectorsByChunk.get(chunk.chunkKey);
+        if (!vector) {
+          continue;
+        }
+        upserts.push({
+          id: chunk.chunkKey,
+          vector,
+          metadata: {
+            projectId: scope.projectId,
+            scopeName: scope.scopeName,
+            url: chunk.url,
+            path: chunk.path,
+            title: chunk.title,
+            sectionTitle: chunk.sectionTitle ?? "",
+            headingPath: chunk.headingPath,
+            snippet: chunk.snippet,
+            contentHash: chunk.contentHash,
+            modelId: this.config.embeddings.model,
+            depth: chunk.depth,
+            incomingLinks: chunk.incomingLinks,
+            routeFile: chunk.routeFile,
+            tags: chunk.tags
+          }
+        });
+      }
+      if (upserts.length > 0) {
+        await this.vectorStore.upsert(upserts, scope);
+        this.logger.event("upserted", { count: upserts.length });
+      }
+      if (deletes.length > 0) {
+        await this.vectorStore.deleteByIds(deletes, scope);
+        this.logger.event("deleted", { count: deletes.length });
+      }
+    }
+    stageEnd("sync", syncStart);
+    const finalizeStart = stageStart();
+    if (!options.dryRun) {
+      const scopeInfo = {
+        projectId: scope.projectId,
+        scopeName: scope.scopeName,
+        modelId: this.config.embeddings.model,
+        lastIndexedAt: nowIso(),
+        vectorCount: chunks.length,
+        lastEstimateTokens: estimatedTokens,
+        lastEstimateCostUSD: Number(estimatedCostUSD.toFixed(8)),
+        lastEstimateChangedChunks: changedChunks.length
+      };
+      await this.vectorStore.recordScope(scopeInfo);
+      this.logger.event("registry_updated", {
+        scope: scope.scopeName,
+        vectorCount: chunks.length
+      });
+    }
+    stageEnd("finalize", finalizeStart);
+    return {
+      pagesProcessed: mirrorPages.length,
+      chunksTotal: chunks.length,
+      chunksChanged: changedChunks.length,
+      newEmbeddings,
+      deletes: deletes.length,
+      estimatedTokens,
+      estimatedCostUSD: Number(estimatedCostUSD.toFixed(8)),
+      routeExact,
+      routeBestEffort,
+      stageTimingsMs
+    };
+  }
+};
+
+// src/mcp/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { createMcpExpressApp } from "@modelcontextprotocol/sdk/server/express.js";
+import { z as z3 } from "zod";
+
+// src/search/engine.ts
+import path12 from "path";
+import { z as z2 } from "zod";
+
+// src/rerank/jina.ts
+function sleep2(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+var JinaReranker = class {
+  apiKey;
+  model;
+  maxRetries;
+  constructor(options) {
+    this.apiKey = options.apiKey;
+    this.model = options.model;
+    this.maxRetries = options.maxRetries ?? 4;
+  }
+  async rerank(query, candidates, topN) {
+    if (candidates.length === 0) {
+      return [];
+    }
+    const body = {
+      model: this.model,
+      query,
+      documents: candidates.map((candidate) => candidate.text),
+      top_n: topN ?? candidates.length
+    };
+    let attempt = 0;
+    while (attempt <= this.maxRetries) {
+      attempt += 1;
+      let response;
+      try {
+        response = await fetch("https://api.jina.ai/v1/rerank", {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            authorization: `Bearer ${this.apiKey}`
+          },
+          body: JSON.stringify(body)
+        });
+      } catch (error) {
+        if (attempt <= this.maxRetries) {
+          await sleep2(Math.min(300 * 2 ** attempt, 4e3));
+          continue;
+        }
+        throw error;
+      }
+      if (!response.ok) {
+        const retryable = response.status === 429 || response.status >= 500;
+        if (retryable && attempt <= this.maxRetries) {
+          await sleep2(Math.min(300 * 2 ** attempt, 4e3));
+          continue;
+        }
+        const errorBody = await response.text();
+        throw new Error(`Jina rerank failed (${response.status}): ${errorBody}`);
+      }
+      const payload = await response.json();
+      const rawResults = payload.results ?? payload.data ?? [];
+      if (!Array.isArray(rawResults)) {
+        throw new Error("Invalid Jina rerank response format");
+      }
+      return rawResults.flatMap((item) => {
+        const index = item.index;
+        if (typeof index !== "number" || index < 0 || index >= candidates.length) {
+          return [];
+        }
+        const candidate = candidates[index];
+        if (!candidate) {
+          return [];
+        }
+        const score = typeof item.relevance_score === "number" ? item.relevance_score : item.score ?? 0;
+        return [
+          {
+            id: candidate.id,
+            score
+          }
+        ];
+      }).sort((a, b) => b.score - a.score);
+    }
+    throw new Error("Jina rerank request failed after retries");
+  }
+};
+
+// src/rerank/factory.ts
+function createReranker(config) {
+  if (config.rerank.provider === "none") {
+    return null;
+  }
+  if (config.rerank.provider === "jina") {
+    const apiKey = process.env[config.rerank.jina.apiKeyEnv];
+    if (!apiKey) {
+      return null;
+    }
+    return new JinaReranker({
+      apiKey,
+      model: config.rerank.jina.model
+    });
+  }
+  return null;
+}
+
+// src/search/ranking.ts
+function nonNegativeOrZero(value) {
+  if (!Number.isFinite(value)) {
+    return 0;
+  }
+  return Math.max(0, value);
+}
+function rankHits(hits, config) {
+  return hits.map((hit) => {
+    let score = Number.isFinite(hit.score) ? hit.score : Number.NEGATIVE_INFINITY;
+    if (config.ranking.enableIncomingLinkBoost) {
+      const incomingBoost = Math.log(1 + nonNegativeOrZero(hit.metadata.incomingLinks));
+      score += incomingBoost * config.ranking.weights.incomingLinks;
+    }
+    if (config.ranking.enableDepthBoost) {
+      const depthBoost = 1 / (1 + nonNegativeOrZero(hit.metadata.depth));
+      score += depthBoost * config.ranking.weights.depth;
+    }
+    return {
+      hit,
+      finalScore: Number.isFinite(score) ? score : Number.NEGATIVE_INFINITY
+    };
+  }).sort((a, b) => {
+    const delta = b.finalScore - a.finalScore;
+    return Number.isNaN(delta) ? 0 : delta;
+  });
+}
+function findPageWeight(url, pageWeights) {
+  const norm = (p) => p !== "/" && p.endsWith("/") ? p.slice(0, -1) : p;
+  const normalizedUrl = norm(url);
+  for (const [pattern, weight] of Object.entries(pageWeights)) {
+    if (norm(pattern) === normalizedUrl) {
+      return weight;
+    }
+  }
+  let bestPrefix = "";
+  let bestWeight = 1;
+  for (const [pattern, weight] of Object.entries(pageWeights)) {
+    const normalizedPattern = norm(pattern);
+    if (normalizedPattern === "/") continue;
+    const prefix = `${normalizedPattern}/`;
+    if (normalizedUrl.startsWith(prefix) && prefix.length > bestPrefix.length) {
+      bestPrefix = prefix;
+      bestWeight = weight;
+    }
+  }
+  return bestWeight;
+}
+function aggregateByPage(ranked, config) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const hit of ranked) {
+    const url = hit.hit.metadata.url;
+    const group = groups.get(url);
+    if (group) group.push(hit);
+    else groups.set(url, [hit]);
+  }
+  const { aggregationCap, aggregationDecay } = config.ranking;
+  const pages = [];
+  for (const [url, chunks] of groups) {
+    chunks.sort((a, b) => {
+      const delta = b.finalScore - a.finalScore;
+      return Number.isNaN(delta) ? 0 : delta;
+    });
+    const best = chunks[0];
+    const maxScore = Number.isFinite(best.finalScore) ? best.finalScore : Number.NEGATIVE_INFINITY;
+    const topChunks = chunks.slice(0, aggregationCap);
+    let aggregationBonus = 0;
+    for (let i = 1; i < topChunks.length; i++) {
+      const chunkScore = Number.isFinite(topChunks[i].finalScore) ? topChunks[i].finalScore : 0;
+      aggregationBonus += chunkScore * Math.pow(aggregationDecay, i);
+    }
+    let pageScore = maxScore + aggregationBonus * config.ranking.weights.aggregation;
+    const pageWeight = findPageWeight(url, config.ranking.pageWeights);
+    if (pageWeight !== 1) {
+      pageScore *= pageWeight;
+    }
+    pages.push({
+      url,
+      title: best.hit.metadata.title,
+      routeFile: best.hit.metadata.routeFile,
+      pageScore: Number.isFinite(pageScore) ? pageScore : Number.NEGATIVE_INFINITY,
+      bestChunk: best,
+      matchingChunks: chunks
+    });
+  }
+  return pages.sort((a, b) => {
+    const delta = b.pageScore - a.pageScore;
+    return Number.isNaN(delta) ? 0 : delta;
+  });
+}
+
+// src/search/engine.ts
+var requestSchema = z2.object({
+  q: z2.string().trim().min(1),
+  topK: z2.number().int().positive().max(100).optional(),
+  scope: z2.string().optional(),
+  pathPrefix: z2.string().optional(),
+  tags: z2.array(z2.string()).optional(),
+  rerank: z2.boolean().optional(),
+  groupBy: z2.enum(["page", "chunk"]).optional()
+});
+var SearchEngine = class _SearchEngine {
+  cwd;
+  config;
+  embeddings;
+  vectorStore;
+  reranker;
+  constructor(options) {
+    this.cwd = options.cwd;
+    this.config = options.config;
+    this.embeddings = options.embeddings;
+    this.vectorStore = options.vectorStore;
+    this.reranker = options.reranker;
+  }
+  static async create(options = {}) {
+    const cwd = path12.resolve(options.cwd ?? process.cwd());
+    const config = options.config ?? await loadConfig({ cwd, configPath: options.configPath });
+    const embeddings = options.embeddingsProvider ?? createEmbeddingsProvider(config);
+    const vectorStore = options.vectorStore ?? await createVectorStore(config, cwd);
+    const reranker = options.reranker === void 0 ? createReranker(config) : options.reranker;
+    return new _SearchEngine({
+      cwd,
+      config,
+      embeddings,
+      vectorStore,
+      reranker
+    });
+  }
+  getConfig() {
+    return this.config;
+  }
+  async search(request) {
+    const parsed = requestSchema.safeParse(request);
+    if (!parsed.success) {
+      throw new SearchSocketError("INVALID_REQUEST", parsed.error.issues[0]?.message ?? "Invalid request", 400);
+    }
+    const input = parsed.data;
+    const totalStart = process.hrtime.bigint();
+    const resolvedScope = resolveScope(this.config, input.scope);
+    await this.assertModelCompatibility(resolvedScope);
+    const topK = input.topK ?? 10;
+    const wantsRerank = Boolean(input.rerank);
+    const groupByPage = (input.groupBy ?? "page") === "page";
+    const candidateK = groupByPage ? Math.max(topK * 10, 50) : Math.max(50, topK);
+    const embedStart = process.hrtime.bigint();
+    const queryEmbeddings = await this.embeddings.embedTexts([input.q], this.config.embeddings.model);
+    const queryVector = queryEmbeddings[0];
+    if (!queryVector || queryVector.length === 0 || queryVector.some((value) => !Number.isFinite(value))) {
+      throw new SearchSocketError("VECTOR_BACKEND_UNAVAILABLE", "Unable to create query embedding.");
+    }
+    const embedMs = hrTimeMs(embedStart);
+    const vectorStart = process.hrtime.bigint();
+    const hits = await this.vectorStore.query(
+      queryVector,
+      {
+        topK: candidateK,
+        pathPrefix: input.pathPrefix,
+        tags: input.tags
+      },
+      resolvedScope
+    );
+    const vectorMs = hrTimeMs(vectorStart);
+    const ranked = rankHits(hits, this.config);
+    let usedRerank = false;
+    let rerankMs = 0;
+    let ordered = ranked;
+    if (wantsRerank) {
+      const rerankStart = process.hrtime.bigint();
+      ordered = await this.rerankHits(input.q, ranked, topK);
+      rerankMs = hrTimeMs(rerankStart);
+      usedRerank = true;
+    }
+    let results;
+    if (groupByPage) {
+      const pages = aggregateByPage(ordered, this.config);
+      const minRatio = this.config.ranking.minChunkScoreRatio;
+      results = pages.slice(0, topK).map((page) => {
+        const bestScore = page.bestChunk.finalScore;
+        const minScore = Number.isFinite(bestScore) ? bestScore * minRatio : Number.NEGATIVE_INFINITY;
+        const meaningful = page.matchingChunks.filter((c) => c.finalScore >= minScore).slice(0, 5);
+        return {
+          url: page.url,
+          title: page.title,
+          sectionTitle: page.bestChunk.hit.metadata.sectionTitle || void 0,
+          snippet: page.bestChunk.hit.metadata.snippet,
+          score: Number(page.pageScore.toFixed(6)),
+          routeFile: page.routeFile,
+          chunks: meaningful.length > 1 ? meaningful.map((c) => ({
+            sectionTitle: c.hit.metadata.sectionTitle || void 0,
+            snippet: c.hit.metadata.snippet,
+            headingPath: c.hit.metadata.headingPath,
+            score: Number(c.finalScore.toFixed(6))
+          })) : void 0
+        };
+      });
+    } else {
+      results = ordered.slice(0, topK).map(({ hit, finalScore }) => ({
+        url: hit.metadata.url,
+        title: hit.metadata.title,
+        sectionTitle: hit.metadata.sectionTitle || void 0,
+        snippet: hit.metadata.snippet,
+        score: Number(finalScore.toFixed(6)),
+        routeFile: hit.metadata.routeFile
+      }));
+    }
+    return {
+      q: input.q,
+      scope: resolvedScope.scopeName,
+      results,
+      meta: {
+        timingsMs: {
+          embed: Math.round(embedMs),
+          vector: Math.round(vectorMs),
+          rerank: Math.round(rerankMs),
+          total: Math.round(hrTimeMs(totalStart))
+        },
+        usedRerank,
+        modelId: this.config.embeddings.model
+      }
+    };
+  }
+  async getPage(pathOrUrl, scope) {
+    const resolvedScope = resolveScope(this.config, scope);
+    const urlPath = this.resolveInputPath(pathOrUrl);
+    const page = await this.vectorStore.getPage(urlPath, resolvedScope);
+    if (!page) {
+      throw new SearchSocketError("INVALID_REQUEST", `Indexed page not found for ${urlPath}`, 404);
+    }
+    return {
+      url: page.url,
+      frontmatter: {
+        url: page.url,
+        title: page.title,
+        routeFile: page.routeFile,
+        routeResolution: page.routeResolution,
+        incomingLinks: page.incomingLinks,
+        outgoingLinks: page.outgoingLinks,
+        depth: page.depth,
+        tags: page.tags,
+        indexedAt: page.indexedAt
+      },
+      markdown: page.markdown
+    };
+  }
+  async health() {
+    return this.vectorStore.health();
+  }
+  resolveInputPath(pathOrUrl) {
+    try {
+      if (/^https?:\/\//.test(pathOrUrl)) {
+        return normalizeUrlPath(new URL(pathOrUrl).pathname);
+      }
+    } catch {
+    }
+    const withoutQueryOrHash = pathOrUrl.split(/[?#]/)[0] ?? pathOrUrl;
+    return normalizeUrlPath(withoutQueryOrHash);
+  }
+  async assertModelCompatibility(scope) {
+    const modelId = await this.vectorStore.getScopeModelId(scope);
+    if (modelId && modelId !== this.config.embeddings.model) {
+      throw new SearchSocketError(
+        "EMBEDDING_MODEL_MISMATCH",
+        `Scope ${scope.scopeName} was indexed with ${modelId}. Current config uses ${this.config.embeddings.model}. Re-index with --force.`
+      );
+    }
+  }
+  async rerankHits(query, ranked, topK) {
+    if (this.config.rerank.provider !== "jina") {
+      throw new SearchSocketError(
+        "INVALID_REQUEST",
+        "rerank=true requested but rerank.provider is not configured as 'jina'.",
+        400
+      );
+    }
+    if (!this.reranker) {
+      throw new SearchSocketError(
+        "CONFIG_MISSING",
+        `rerank=true requested but ${this.config.rerank.jina.apiKeyEnv} is not set.`,
+        400
+      );
+    }
+    const candidates = ranked.map(({ hit }) => ({
+      id: hit.id,
+      text: [hit.metadata.title, hit.metadata.sectionTitle, hit.metadata.snippet].filter(Boolean).join("\n")
+    }));
+    const reranked = await this.reranker.rerank(
+      query,
+      candidates,
+      Math.max(topK, this.config.rerank.topN)
+    );
+    const rerankScoreById = new Map(reranked.map((entry) => [entry.id, entry.score]));
+    return ranked.map((entry) => {
+      const rerankScore = rerankScoreById.get(entry.hit.id);
+      const safeBaseScore = Number.isFinite(entry.finalScore) ? entry.finalScore : Number.NEGATIVE_INFINITY;
+      if (rerankScore === void 0 || !Number.isFinite(rerankScore)) {
+        return {
+          ...entry,
+          finalScore: safeBaseScore
+        };
+      }
+      const combinedScore = rerankScore * this.config.ranking.weights.rerank + safeBaseScore * 1e-3;
+      return {
+        ...entry,
+        finalScore: Number.isFinite(combinedScore) ? combinedScore : safeBaseScore
+      };
+    }).sort((a, b) => {
+      const delta = b.finalScore - a.finalScore;
+      return Number.isNaN(delta) ? 0 : delta;
+    });
+  }
+};
+
+// src/mcp/server.ts
+function createServer(engine) {
+  const server = new McpServer({
+    name: "searchsocket-mcp",
+    version: "0.1.0"
+  });
+  server.registerTool(
+    "search",
+    {
+      description: "Semantic site search. Returns url/title/snippet/score/routeFile for each match. Supports optional scope, pathPrefix, tags, and topK.",
+      inputSchema: {
+        query: z3.string().min(1),
+        scope: z3.string().optional(),
+        topK: z3.number().int().positive().max(100).optional(),
+        pathPrefix: z3.string().optional(),
+        tags: z3.array(z3.string()).optional(),
+        groupBy: z3.enum(["page", "chunk"]).optional()
+      }
+    },
+    async (input) => {
+      const result = await engine.search({
+        q: input.query,
+        topK: input.topK,
+        scope: input.scope,
+        pathPrefix: input.pathPrefix,
+        tags: input.tags,
+        groupBy: input.groupBy
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.registerTool(
+    "get_page",
+    {
+      description: "Fetch indexed markdown for a specific path or URL, including frontmatter and routeFile mapping.",
+      inputSchema: {
+        pathOrUrl: z3.string().min(1),
+        scope: z3.string().optional()
+      }
+    },
+    async (input) => {
+      const page = await engine.getPage(input.pathOrUrl, input.scope);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(page, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  return server;
+}
+function redirectConsoleToStderr() {
+  const originalLog = console.log;
+  console.log = (...args) => {
+    process.stderr.write(`[LOG] ${args.map(String).join(" ")}
+`);
+  };
+  console.warn = (...args) => {
+    process.stderr.write(`[WARN] ${args.map(String).join(" ")}
+`);
+  };
+  void originalLog;
+}
+async function startHttpServer(serverFactory, config, opts) {
+  const app = createMcpExpressApp();
+  const port = opts.httpPort ?? config.mcp.http.port;
+  const endpointPath = opts.httpPath ?? config.mcp.http.path;
+  app.post(endpointPath, async (req, res) => {
+    const server = serverFactory();
+    const transport = new StreamableHTTPServerTransport({
+      sessionIdGenerator: void 0
+    });
+    try {
+      await server.connect(transport);
+      await transport.handleRequest(req, res, req.body);
+      res.on("close", () => {
+        transport.close();
+        server.close();
+      });
+    } catch (error) {
+      if (!res.headersSent) {
+        res.status(500).json({
+          jsonrpc: "2.0",
+          error: {
+            code: -32603,
+            message: error instanceof Error ? error.message : "Internal server error"
+          },
+          id: null
+        });
+      }
+    }
+  });
+  app.get(endpointPath, (_req, res) => {
+    res.writeHead(405).end(
+      JSON.stringify({
+        jsonrpc: "2.0",
+        error: {
+          code: -32e3,
+          message: "Method not allowed"
+        },
+        id: null
+      })
+    );
+  });
+  app.delete(endpointPath, (_req, res) => {
+    res.writeHead(405).end(
+      JSON.stringify({
+        jsonrpc: "2.0",
+        error: {
+          code: -32e3,
+          message: "Method not allowed"
+        },
+        id: null
+      })
+    );
+  });
+  await new Promise((resolve, reject) => {
+    const instance = app.listen(port, "127.0.0.1", () => {
+      process.stderr.write(`SearchSocket MCP HTTP server listening on http://127.0.0.1:${port}${endpointPath}
+`);
+      resolve();
+    });
+    instance.once("error", reject);
+    process.on("SIGINT", async () => {
+      await new Promise((shutdownResolve) => instance.close(() => shutdownResolve()));
+      process.exit(0);
+    });
+  });
+}
+async function runMcpServer(options = {}) {
+  const config = await loadConfig({
+    cwd: options.cwd,
+    configPath: options.configPath
+  });
+  const resolvedTransport = options.transport ?? config.mcp.transport;
+  if (resolvedTransport === "stdio") {
+    redirectConsoleToStderr();
+  }
+  const engine = await SearchEngine.create({
+    cwd: options.cwd,
+    configPath: options.configPath,
+    config
+  });
+  if (resolvedTransport === "http") {
+    await startHttpServer(() => createServer(engine), config, options);
+    return;
+  }
+  const server = createServer(engine);
+  const stdioTransport = new StdioServerTransport();
+  await server.connect(stdioTransport);
+}
+
+// src/cli.ts
+function parsePositiveInt(value, flag) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new SearchSocketError("INVALID_REQUEST", `${flag} must be a positive integer`, 400);
+  }
+  return parsed;
+}
+function parseDurationMs(value) {
+  const match = value.trim().match(/^(\d+)(ms|s|m|h|d)$/i);
+  if (!match) {
+    throw new SearchSocketError(
+      "INVALID_REQUEST",
+      "Duration must look like 30d, 12h, 15m, 45s, or 500ms",
+      400
+    );
+  }
+  const amount = Number(match[1]);
+  const unit = (match[2] ?? "").toLowerCase();
+  switch (unit) {
+    case "ms":
+      return amount;
+    case "s":
+      return amount * 1e3;
+    case "m":
+      return amount * 6e4;
+    case "h":
+      return amount * 36e5;
+    case "d":
+      return amount * 864e5;
+    default:
+      throw new SearchSocketError("INVALID_REQUEST", `Unsupported duration unit: ${unit}`, 400);
+  }
+}
+function formatUsd(value) {
+  return `$${value.toFixed(6)}`;
+}
+function printIndexSummary(stats) {
+  process.stdout.write(`pages processed: ${stats.pagesProcessed}
+`);
+  process.stdout.write(`chunks total: ${stats.chunksTotal}
+`);
+  process.stdout.write(`chunks changed: ${stats.chunksChanged}
+`);
+  process.stdout.write(`embeddings created: ${stats.newEmbeddings}
+`);
+  process.stdout.write(`deletes: ${stats.deletes}
+`);
+  process.stdout.write(`estimated tokens: ${stats.estimatedTokens}
+`);
+  process.stdout.write(`estimated cost (USD): ${formatUsd(stats.estimatedCostUSD)}
+`);
+  process.stdout.write(`route mapping: ${stats.routeExact} exact, ${stats.routeBestEffort} best-effort
+`);
+  process.stdout.write("stage timings (ms):\n");
+  for (const [stage, ms] of Object.entries(stats.stageTimingsMs)) {
+    process.stdout.write(`  ${stage}: ${ms}
+`);
+  }
+}
+function collectWatchPaths(config, cwd) {
+  const paths = ["src/routes/**"];
+  if (config.source.mode === "content-files" && config.source.contentFiles) {
+    for (const pattern of config.source.contentFiles.globs) {
+      paths.push(path13.join(config.source.contentFiles.baseDir, pattern));
+    }
+  }
+  if (config.source.mode === "static-output") {
+    paths.push(config.source.staticOutputDir);
+  }
+  if (config.source.mode === "crawl") {
+    paths.push("searchsocket.config.ts");
+  }
+  if (config.source.mode === "build" && config.source.build) {
+    paths.push("searchsocket.config.ts");
+    paths.push(config.source.build.outputDir);
+  }
+  return paths.map((value) => path13.resolve(cwd, value));
+}
+function ensureStateDir(cwd) {
+  const target = path13.join(cwd, ".searchsocket");
+  fs9.mkdirSync(target, { recursive: true });
+  return target;
+}
+function ensureGitignore(cwd) {
+  const gitignorePath = path13.join(cwd, ".gitignore");
+  const entries = [
+    ".searchsocket/vectors.db",
+    ".searchsocket/vectors.db-shm",
+    ".searchsocket/vectors.db-wal",
+    ".searchsocket/manifest.json",
+    ".searchsocket/registry.json"
+  ];
+  let content = "";
+  if (fs9.existsSync(gitignorePath)) {
+    content = fs9.readFileSync(gitignorePath, "utf8");
+  }
+  const lines = content.split("\n");
+  const missing = entries.filter((entry) => !lines.some((line) => line.trim() === entry));
+  if (missing.length === 0) {
+    return;
+  }
+  const block = `
+# SearchSocket local state
+${missing.join("\n")}
+`;
+  fs9.writeFileSync(gitignorePath, content.trimEnd() + block, "utf8");
+}
+function readScopesFromFile(filePath) {
+  const raw = fs9.readFileSync(filePath, "utf8");
+  return new Set(
+    raw.split(/\r?\n/).map((line) => line.trim()).filter(Boolean)
+  );
+}
+function readRemoteGitBranches(cwd) {
+  try {
+    const output = execSync2("git branch -r --format='%(refname:short)'", {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const scopes = output.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((line) => line.replace(/^origin\//, ""));
+    if (scopes.length <= 1) {
+      process.stdout.write(
+        "warning: git branch -r returned 1 or fewer branches. If running in CI, ensure the checkout step uses fetch-depth: 0 to avoid accidentally pruning active branch scopes.\n"
+      );
+    }
+    return new Set(scopes);
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+async function loadResolvedConfigForDev(cwd, configPath) {
+  const resolvedConfigPath = path13.resolve(cwd, configPath ?? "searchsocket.config.ts");
+  if (fs9.existsSync(resolvedConfigPath)) {
+    return loadConfig({ cwd, configPath });
+  }
+  return mergeConfig(cwd, {});
+}
+function getRootOptions(command) {
+  const maybeParent = command.parent;
+  const optsFn = maybeParent?.opts;
+  if (typeof optsFn !== "function") {
+    return {};
+  }
+  return optsFn.call(maybeParent);
+}
+async function runIndexCommand(opts) {
+  const logger3 = new Logger({
+    verbose: opts.verbose,
+    json: opts.json
+  });
+  const pipeline = await IndexPipeline.create({
+    cwd: opts.cwd,
+    configPath: opts.configPath,
+    logger: logger3
+  });
+  const stats = await pipeline.run({
+    scopeOverride: opts.scope,
+    changedOnly: opts.changedOnly,
+    force: opts.force,
+    dryRun: opts.dryRun,
+    sourceOverride: opts.source,
+    maxPages: opts.maxPages,
+    maxChunks: opts.maxChunks,
+    verbose: opts.verbose
+  });
+  if (opts.json) {
+    process.stdout.write(`${JSON.stringify(stats, null, 2)}
+`);
+    return;
+  }
+  printIndexSummary(stats);
+}
+var program = new Command();
+program.name("searchsocket").description("Semantic site search and MCP retrieval for SvelteKit").version(package_default.version).option("-C, --cwd <path>", "working directory", process.cwd()).option("--config <path>", "config path (defaults to searchsocket.config.ts)");
+program.command("init").description("Create searchsocket.config.ts and .searchsocket state directory").action(async (_opts, command) => {
+  const root = getRootOptions(command).cwd ?? process.cwd();
+  const cwd = path13.resolve(root);
+  const configPath = writeMinimalConfig(cwd);
+  const stateDir = ensureStateDir(cwd);
+  ensureGitignore(cwd);
+  process.stdout.write(`created/verified config: ${configPath}
+`);
+  process.stdout.write(`created/verified state dir: ${stateDir}
+
+`);
+  process.stdout.write("SvelteKit hook snippet:\n\n");
+  process.stdout.write('import { searchsocketHandle } from "searchsocket/sveltekit";\n\n');
+  process.stdout.write("export const handle = searchsocketHandle();\n\n");
+  process.stdout.write("Optional build-triggered indexing plugin:\n\n");
+  process.stdout.write('import { searchsocketVitePlugin } from "searchsocket/sveltekit";\n\n');
+  process.stdout.write("// svelte.config.js / vite plugins:\n");
+  process.stdout.write("// searchsocketVitePlugin({ enabled: true, changedOnly: true })\n");
+  process.stdout.write("// or env-driven: SEARCHSOCKET_AUTO_INDEX=1 pnpm build\n");
+});
+program.command("index").description("Index site content into markdown mirror + vector store").option("--scope <name>", "scope override").option("--changed-only", "only process changed chunks", true).option("--no-changed-only", "re-index regardless of previous manifest").option("--force", "force full mirror rebuild and re-upsert", false).option("--dry-run", "compute plan and cost, no API writes", false).option("--source <mode>", "source mode override: static-output|crawl|content-files|build").option("--max-pages <n>", "limit pages processed").option("--max-chunks <n>", "limit chunks processed").option("--verbose", "verbose output", false).option("--json", "emit JSON logs and summary", false).action(async (opts, command) => {
+  const rootOpts = getRootOptions(command);
+  const cwd = path13.resolve(rootOpts?.cwd ?? process.cwd());
+  await runIndexCommand({
+    cwd,
+    configPath: rootOpts?.config,
+    scope: opts.scope,
+    changedOnly: opts.changedOnly,
+    force: opts.force,
+    dryRun: opts.dryRun,
+    source: opts.source,
+    maxPages: opts.maxPages ? parsePositiveInt(opts.maxPages, "--max-pages") : void 0,
+    maxChunks: opts.maxChunks ? parsePositiveInt(opts.maxChunks, "--max-chunks") : void 0,
+    verbose: opts.verbose,
+    json: opts.json
+  });
+});
+program.command("status").description("Show scope, indexing state, backend health, and recent cost estimate").option("--scope <name>", "scope override").action(async (opts, command) => {
+  const rootOpts = getRootOptions(command);
+  const cwd = path13.resolve(rootOpts?.cwd ?? process.cwd());
+  const config = await loadConfig({ cwd, configPath: rootOpts?.config });
+  const scope = resolveScope(config, opts.scope);
+  let vectorStore;
+  let health = { ok: false, details: "not checked" };
+  try {
+    vectorStore = await createVectorStore(config, cwd);
+    health = await vectorStore.health();
+  } catch (error) {
+    health = {
+      ok: false,
+      details: error instanceof Error ? error.message : "unknown error"
+    };
+    process.stdout.write(`project: ${config.project.id}
+`);
+    process.stdout.write(`vector health: error (${health.details})
+`);
+    process.exitCode = 1;
+    return;
+  }
+  let scopeRegistry = [];
+  let scopeInfo;
+  let hashes = /* @__PURE__ */ new Map();
+  try {
+    scopeRegistry = await vectorStore.listScopes(config.project.id);
+    scopeInfo = scopeRegistry.find((entry) => entry.scopeName === scope.scopeName);
+    hashes = await vectorStore.getContentHashes(scope);
+  } catch (error) {
+    process.stdout.write(`project: ${config.project.id}
+`);
+    process.stdout.write(`resolved scope: ${scope.scopeName}
+`);
+    process.stdout.write(`vector health: error (${error instanceof Error ? error.message : "unknown error"})
+`);
+    process.exitCode = 1;
+    return;
+  }
+  process.stdout.write(`project: ${config.project.id}
+`);
+  process.stdout.write(`resolved scope: ${scope.scopeName}
+`);
+  process.stdout.write(`embedding model: ${config.embeddings.model}
+`);
+  const tursoUrl = process.env[config.vector.turso.urlEnv];
+  const vectorMode = tursoUrl ? `remote (${tursoUrl})` : `local (${config.vector.turso.localPath})`;
+  process.stdout.write(`vector backend: turso/libsql (${vectorMode})
+`);
+  process.stdout.write(`vector health: ${health.ok ? "ok" : `error (${health.details ?? "n/a"})`}
+`);
+  if (scopeInfo) {
+    process.stdout.write(`last indexed (${scope.scopeName}): ${scopeInfo.lastIndexedAt ?? "never"}
+`);
+    process.stdout.write(`tracked chunks: ${hashes.size}
+`);
+    if (scopeInfo.lastEstimateTokens != null) {
+      process.stdout.write(`last estimated tokens: ${scopeInfo.lastEstimateTokens}
+`);
+    }
+    if (scopeInfo.lastEstimateCostUSD != null) {
+      process.stdout.write(`last estimated cost: ${formatUsd(scopeInfo.lastEstimateCostUSD)}
+`);
+    }
+  } else {
+    process.stdout.write(`last indexed (${scope.scopeName}): never
+`);
+  }
+  if (scopeRegistry.length > 0) {
+    process.stdout.write("\nregistry scopes:\n");
+    for (const item of scopeRegistry) {
+      process.stdout.write(
+        `  - ${item.scopeName} model=${item.modelId} lastIndexedAt=${item.lastIndexedAt} vectors=${item.vectorCount ?? "unknown"}
+`
+      );
+    }
+  }
+});
+program.command("dev").description("Watch content files/routes and incrementally reindex on changes").option("--scope <name>", "scope override").option("--mcp", "start MCP server (http transport) alongside watcher", false).option("--mcp-port <n>", "MCP HTTP port", "3338").option("--mcp-path <path>", "MCP HTTP path", "/mcp").option("--verbose", "verbose logs", false).action(async (opts, command) => {
+  const rootOpts = getRootOptions(command);
+  const cwd = path13.resolve(rootOpts?.cwd ?? process.cwd());
+  const config = await loadResolvedConfigForDev(cwd, rootOpts?.config);
+  const watchPaths = collectWatchPaths(config, cwd);
+  process.stdout.write("starting searchsocket dev watcher...\n");
+  process.stdout.write(`watching:
+${watchPaths.map((entry) => `  - ${entry}`).join("\n")}
+`);
+  let running = false;
+  let pending = false;
+  let timer = null;
+  const run = async () => {
+    if (running) {
+      pending = true;
+      return;
+    }
+    running = true;
+    try {
+      await runIndexCommand({
+        cwd,
+        configPath: rootOpts?.config,
+        scope: opts.scope,
+        changedOnly: true,
+        force: false,
+        dryRun: false,
+        verbose: opts.verbose,
+        json: false
+      });
+    } catch (error) {
+      process.stderr.write(`index error: ${error instanceof Error ? error.message : String(error)}
+`);
+    } finally {
+      running = false;
+      if (pending) {
+        pending = false;
+        await run();
+      }
+    }
+  };
+  await run();
+  const watcher = chokidar.watch(watchPaths, {
+    ignoreInitial: true
+  });
+  watcher.on("all", (event, changedPath) => {
+    process.stdout.write(`detected ${event}: ${changedPath}
+`);
+    if (timer) {
+      clearTimeout(timer);
+    }
+    timer = setTimeout(() => {
+      void run();
+    }, 350);
+  });
+  if (opts.mcp) {
+    void runMcpServer({
+      cwd,
+      configPath: rootOpts?.config,
+      transport: "http",
+      httpPort: parsePositiveInt(opts.mcpPort, "--mcp-port"),
+      httpPath: opts.mcpPath
+    });
+  }
+  await new Promise((resolve) => {
+    process.on("SIGINT", () => {
+      void watcher.close().then(() => resolve());
+    });
+  });
+});
+program.command("clean").description("Delete local state and optionally delete remote vectors for a scope").option("--scope <name>", "scope override").option("--remote", "delete remote scope vectors", false).action(async (opts, command) => {
+  const rootOpts = getRootOptions(command);
+  const cwd = path13.resolve(rootOpts?.cwd ?? process.cwd());
+  const config = await loadConfig({ cwd, configPath: rootOpts?.config });
+  const scope = resolveScope(config, opts.scope);
+  const statePath = path13.join(cwd, config.state.dir);
+  await fsp.rm(statePath, { recursive: true, force: true });
+  process.stdout.write(`deleted local state directory: ${statePath}
+`);
+  if (opts.remote) {
+    const vectorStore = await createVectorStore(config, cwd);
+    await vectorStore.deleteScope(scope);
+    process.stdout.write(`deleted remote vectors for scope ${scope.scopeName}
+`);
+  }
+});
+program.command("prune").description("List/delete stale scopes (dry-run by default)").option("--apply", "apply deletions", false).option("--scopes-file <path>", "file containing active scopes").option("--older-than <duration>", "ttl cutoff like 30d").action(async (opts, command) => {
+  const rootOpts = getRootOptions(command);
+  const cwd = path13.resolve(rootOpts?.cwd ?? process.cwd());
+  const config = await loadConfig({ cwd, configPath: rootOpts?.config });
+  const baseScope = resolveScope(config);
+  let vectorStore;
+  let scopes;
+  try {
+    vectorStore = await createVectorStore(config, cwd);
+    scopes = await vectorStore.listScopes(config.project.id);
+  } catch (error) {
+    process.stderr.write(
+      `error: failed to access Turso vector store: ${error instanceof Error ? error.message : String(error)}
+`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  process.stdout.write(`using remote registry
+`);
+  let keepScopes = /* @__PURE__ */ new Set();
+  if (opts.scopesFile) {
+    keepScopes = readScopesFromFile(path13.resolve(cwd, opts.scopesFile));
+  } else {
+    keepScopes = readRemoteGitBranches(cwd);
+  }
+  if (config.scope.sanitize && keepScopes.size > 0) {
+    keepScopes = new Set([...keepScopes].map(sanitizeScopeName));
+  }
+  const olderThanMs = opts.olderThan ? parseDurationMs(opts.olderThan) : void 0;
+  const now = Date.now();
+  const stale = scopes.filter((entry) => {
+    if (entry.scopeName === "main") {
+      return false;
+    }
+    let staleByList = false;
+    if (keepScopes.size > 0) {
+      staleByList = !keepScopes.has(entry.scopeName);
+    }
+    let staleByTtl = false;
+    if (olderThanMs) {
+      staleByTtl = now - Date.parse(entry.lastIndexedAt) > olderThanMs;
+    }
+    if (keepScopes.size > 0 && olderThanMs) {
+      return staleByList || staleByTtl;
+    }
+    if (keepScopes.size > 0) {
+      return staleByList;
+    }
+    if (olderThanMs) {
+      return staleByTtl;
+    }
+    return false;
+  });
+  if (stale.length === 0) {
+    process.stdout.write("no stale scopes found\n");
+    return;
+  }
+  process.stdout.write(`stale scopes (${stale.length}):
+`);
+  for (const entry of stale) {
+    process.stdout.write(`  - ${entry.scopeName} lastIndexedAt=${entry.lastIndexedAt}
+`);
+  }
+  if (!opts.apply) {
+    process.stdout.write("dry-run only. pass --apply to delete these scopes.\n");
+    return;
+  }
+  let deleted = 0;
+  for (const entry of stale) {
+    const scope = {
+      projectId: config.project.id,
+      scopeName: entry.scopeName,
+      scopeId: `${config.project.id}:${entry.scopeName}`
+    };
+    try {
+      await vectorStore.deleteScope(scope);
+      deleted += 1;
+    } catch (error) {
+      process.stdout.write(
+        `failed to delete scope ${entry.scopeName}: ${error instanceof Error ? error.message : String(error)}
+`
+      );
+    }
+  }
+  process.stdout.write(`deleted scopes: ${deleted}
+`);
+  if (baseScope.scopeName === "main") {
+    process.stdout.write("main scope retained\n");
+  }
+});
+program.command("doctor").description("Validate config, env vars, provider connectivity, and local write access").action(async (_opts, command) => {
+  const rootOpts = getRootOptions(command);
+  const cwd = path13.resolve(rootOpts?.cwd ?? process.cwd());
+  const checks = [];
+  let config = null;
+  try {
+    config = await loadConfig({ cwd, configPath: rootOpts?.config });
+    checks.push({ name: "config parse", ok: true });
+  } catch (error) {
+    checks.push({
+      name: "config parse",
+      ok: false,
+      details: error instanceof Error ? error.message : "unknown error"
+    });
+  }
+  if (config) {
+    const embKey = process.env[config.embeddings.apiKeyEnv];
+    checks.push({
+      name: `env ${config.embeddings.apiKeyEnv}`,
+      ok: Boolean(embKey),
+      details: embKey ? void 0 : "missing"
+    });
+    {
+      const tursoUrl = process.env[config.vector.turso.urlEnv];
+      checks.push({
+        name: "turso/libsql",
+        ok: true,
+        details: tursoUrl ? `remote: ${tursoUrl}` : `local file: ${config.vector.turso.localPath}`
+      });
+    }
+    if (config.rerank.provider === "jina") {
+      const jinaKey = process.env[config.rerank.jina.apiKeyEnv];
+      checks.push({
+        name: `env ${config.rerank.jina.apiKeyEnv}`,
+        ok: Boolean(jinaKey),
+        details: jinaKey ? void 0 : "missing"
+      });
+    }
+    if (config.source.mode === "static-output") {
+      const outputDir = path13.resolve(cwd, config.source.staticOutputDir);
+      const exists = fs9.existsSync(outputDir);
+      checks.push({
+        name: "source: static output dir",
+        ok: exists,
+        details: exists ? outputDir : `${outputDir} not found (run your build first)`
+      });
+    } else if (config.source.mode === "build") {
+      const buildConfig = config.source.build;
+      if (buildConfig) {
+        const manifestPath = path13.resolve(cwd, buildConfig.outputDir, "server", "manifest-full.js");
+        const manifestExists = fs9.existsSync(manifestPath);
+        checks.push({
+          name: "source: build manifest",
+          ok: manifestExists,
+          details: manifestExists ? manifestPath : `${manifestPath} not found (run \`vite build\` first)`
+        });
+        const viteBin = path13.resolve(cwd, "node_modules", ".bin", "vite");
+        const viteExists = fs9.existsSync(viteBin);
+        checks.push({
+          name: "source: vite binary",
+          ok: viteExists,
+          details: viteExists ? viteBin : `${viteBin} not found (install vite)`
+        });
+      } else {
+        checks.push({
+          name: "source: build config",
+          ok: false,
+          details: "source.build config missing"
+        });
+      }
+    } else if (config.source.mode === "content-files") {
+      const contentConfig = config.source.contentFiles;
+      if (contentConfig) {
+        const fg4 = await import("fast-glob");
+        const baseDir = path13.resolve(cwd, contentConfig.baseDir);
+        const files = await fg4.default(contentConfig.globs, { cwd: baseDir, onlyFiles: true });
+        checks.push({
+          name: "source: content files",
+          ok: files.length > 0,
+          details: files.length > 0 ? `${files.length} files matched` : `no files matched globs ${contentConfig.globs.join(", ")} in ${baseDir}`
+        });
+      } else {
+        checks.push({
+          name: "source: content files",
+          ok: false,
+          details: "source.contentFiles config missing"
+        });
+      }
+    }
+    try {
+      const provider = createEmbeddingsProvider(config);
+      await provider.embedTexts(["searchsocket doctor ping"], config.embeddings.model);
+      checks.push({ name: "embedding provider connectivity", ok: true });
+    } catch (error) {
+      checks.push({
+        name: "embedding provider connectivity",
+        ok: false,
+        details: error instanceof Error ? error.message : "unknown error"
+      });
+    }
+    let store = null;
+    try {
+      store = await createVectorStore(config, cwd);
+      const health = await store.health();
+      checks.push({
+        name: "vector backend connectivity",
+        ok: health.ok,
+        details: health.details
+      });
+    } catch (error) {
+      checks.push({
+        name: "vector backend connectivity",
+        ok: false,
+        details: error instanceof Error ? error.message : "unknown error"
+      });
+    }
+    if (store) {
+      try {
+        const testScope = {
+          projectId: config.project.id,
+          scopeName: "_searchsocket_doctor_probe",
+          scopeId: `${config.project.id}:_searchsocket_doctor_probe`
+        };
+        await store.recordScope({
+          projectId: testScope.projectId,
+          scopeName: testScope.scopeName,
+          modelId: config.embeddings.model,
+          lastIndexedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          vectorCount: 0
+        });
+        await store.deleteScope(testScope);
+        checks.push({ name: "vector backend write permission", ok: true });
+      } catch (error) {
+        checks.push({
+          name: "vector backend write permission",
+          ok: false,
+          details: error instanceof Error ? error.message : "write test failed"
+        });
+      }
+    }
+    try {
+      const scope = resolveScope(config);
+      const { statePath } = ensureStateDirs(cwd, config.state.dir, scope);
+      const testPath = path13.join(statePath, ".write-test");
+      await fsp.writeFile(testPath, "ok\n", "utf8");
+      await fsp.rm(testPath, { force: true });
+      checks.push({ name: "state directory writable", ok: true });
+    } catch (error) {
+      checks.push({
+        name: "state directory writable",
+        ok: false,
+        details: error instanceof Error ? error.message : "unknown error"
+      });
+    }
+  }
+  let hasFailure = false;
+  for (const check of checks) {
+    process.stdout.write(`${check.ok ? "PASS" : "FAIL"} ${check.name}`);
+    if (check.details) {
+      process.stdout.write(` (${check.details})`);
+    }
+    process.stdout.write("\n");
+    if (!check.ok) {
+      hasFailure = true;
+    }
+  }
+  if (hasFailure) {
+    process.exitCode = 1;
+  }
+});
+program.command("mcp").description("Run SearchSocket MCP server").option("--transport <transport>", "stdio|http", "stdio").option("--port <n>", "HTTP port", "3338").option("--path <path>", "HTTP path", "/mcp").action(async (opts, command) => {
+  const rootOpts = getRootOptions(command);
+  const cwd = path13.resolve(rootOpts?.cwd ?? process.cwd());
+  await runMcpServer({
+    cwd,
+    configPath: rootOpts?.config,
+    transport: opts.transport,
+    httpPort: parsePositiveInt(opts.port, "--port"),
+    httpPath: opts.path
+  });
+});
+program.command("search").description("Quick local CLI search against indexed vectors").requiredOption("--q <query>", "search query").option("--scope <name>", "scope override").option("--top-k <n>", "top K results", "10").option("--path-prefix <prefix>", "path prefix filter").option("--rerank", "enable configured reranker", false).action(async (opts, command) => {
+  const rootOpts = getRootOptions(command);
+  const cwd = path13.resolve(rootOpts?.cwd ?? process.cwd());
+  const engine = await SearchEngine.create({
+    cwd,
+    configPath: rootOpts?.config
+  });
+  const result = await engine.search({
+    q: opts.q,
+    scope: opts.scope,
+    topK: parsePositiveInt(opts.topK, "--top-k"),
+    pathPrefix: opts.pathPrefix,
+    rerank: opts.rerank
+  });
+  process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+});
+async function main() {
+  dotenvConfig({ path: path13.resolve(process.cwd(), ".env") });
+  await program.parseAsync(process.argv);
+}
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  process.stderr.write(`searchsocket error: ${message}
+`);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map