@a-company/paradigm 5.11.0 → 5.21.0

package/dist/chunk-2T6BTYBN.js

@@ -1,712 +0,0 @@
-#!/usr/bin/env node
-
-// ../paradigm-mcp/src/utils/docs-loader.ts
-import * as fs from "fs";
-import * as path from "path";
-import * as yaml from "js-yaml";
-var SCAN_INDEX_PATH = ".paradigm/scan-index.json";
-var FLOW_INDEX_PATH = ".paradigm/flow-index.json";
-var CONFIG_PATH = ".paradigm/config.yaml";
-var PORTAL_FILE = "portal.yaml";
-var UNIVERSITY_INDEX_PATH = ".paradigm/university/index.yaml";
-var DEFAULT_CONFIG = {
-  enabled: true,
-  title: null,
-  theme: "dark",
-  customCss: null,
-  customContent: "docs/",
-  exclude: { tags: [], patterns: [] },
-  sidebar: { collapsed: [] },
-  output: ".paradigm/docs-site"
-};
-function loadDocsConfig(rootDir) {
-  const configPath = path.join(rootDir, CONFIG_PATH);
-  if (!fs.existsSync(configPath)) {
-    return { ...DEFAULT_CONFIG };
-  }
-  try {
-    const raw = fs.readFileSync(configPath, "utf8");
-    const data = yaml.load(raw);
-    if (!data || !data.docs) return { ...DEFAULT_CONFIG };
-    const docs = data.docs;
-    return {
-      enabled: docs.enabled ?? DEFAULT_CONFIG.enabled,
-      title: docs.title ?? DEFAULT_CONFIG.title,
-      theme: docs.theme ?? DEFAULT_CONFIG.theme,
-      customCss: docs.customCss ?? DEFAULT_CONFIG.customCss,
-      customContent: docs.customContent ?? DEFAULT_CONFIG.customContent,
-      exclude: {
-        tags: docs.exclude?.tags ?? DEFAULT_CONFIG.exclude.tags,
-        patterns: docs.exclude?.patterns ?? DEFAULT_CONFIG.exclude.patterns
-      },
-      sidebar: {
-        collapsed: docs.sidebar?.collapsed ?? DEFAULT_CONFIG.sidebar.collapsed
-      },
-      output: docs.output ?? DEFAULT_CONFIG.output
-    };
-  } catch {
-    return { ...DEFAULT_CONFIG };
-  }
-}
-function loadScanIndex(rootDir) {
-  const filePath = path.join(rootDir, SCAN_INDEX_PATH);
-  if (!fs.existsSync(filePath)) return null;
-  try {
-    const raw = fs.readFileSync(filePath, "utf8");
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-function loadFlowIndex(rootDir) {
-  const filePath = path.join(rootDir, FLOW_INDEX_PATH);
-  if (!fs.existsSync(filePath)) return null;
-  try {
-    const raw = fs.readFileSync(filePath, "utf8");
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-function loadPortal(rootDir) {
-  const filePath = path.join(rootDir, PORTAL_FILE);
-  if (!fs.existsSync(filePath)) return null;
-  try {
-    const raw = fs.readFileSync(filePath, "utf8");
-    return yaml.load(raw);
-  } catch {
-    return null;
-  }
-}
-function loadUniversityIndex(rootDir) {
-  const filePath = path.join(rootDir, UNIVERSITY_INDEX_PATH);
-  if (!fs.existsSync(filePath)) return null;
-  try {
-    const raw = fs.readFileSync(filePath, "utf8");
-    return yaml.load(raw);
-  } catch {
-    return null;
-  }
-}
-function parseFrontmatter(content) {
-  const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
-  if (!match) return null;
-  try {
-    const frontmatter = yaml.load(match[1]);
-    return { frontmatter, body: match[2].trim() };
-  } catch {
-    return null;
-  }
-}
-function allEntries(scanIndex) {
-  const entries = /* @__PURE__ */ new Map();
-  const categories = [
-    scanIndex.components,
-    scanIndex.features,
-    scanIndex.flows,
-    scanIndex.state,
-    scanIndex.gates,
-    scanIndex.signals,
-    scanIndex.aspects
-  ];
-  for (const cat of categories) {
-    if (!cat) continue;
-    for (const [id, entry] of Object.entries(cat)) {
-      entries.set(id, entry);
-    }
-  }
-  return entries;
-}
-function categoryToSearchKind(category) {
-  const mapping = {
-    components: "component",
-    features: "component",
-    flows: "flow",
-    state: "component",
-    gates: "gate",
-    signals: "signal",
-    aspects: "aspect"
-  };
-  return mapping[category] || "component";
-}
-function isExcluded(entry, config) {
-  if (config.exclude.tags.length > 0 && entry.visualTags) {
-    for (const tag of entry.visualTags) {
-      if (config.exclude.tags.includes(tag)) return true;
-    }
-  }
-  if (config.exclude.patterns.length > 0 && entry.path) {
-    for (const pattern of config.exclude.patterns) {
-      if (pattern.endsWith("*")) {
-        const prefix = pattern.slice(0, -1);
-        if (entry.path.includes(prefix)) return true;
-      } else if (entry.path.includes(pattern)) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-function loadCustomPages(rootDir, customContentDir) {
-  const dir = path.join(rootDir, customContentDir);
-  if (!fs.existsSync(dir)) return [];
-  const pages = [];
-  try {
-    const files = fs.readdirSync(dir).filter((f) => f.endsWith(".md"));
-    for (const file of files) {
-      try {
-        const raw = fs.readFileSync(path.join(dir, file), "utf8");
-        const slug = file.replace(/\.md$/, "");
-        const parsed = parseFrontmatter(raw);
-        if (parsed) {
-          pages.push({
-            slug,
-            title: parsed.frontmatter.title || slug,
-            body: parsed.body,
-            order: typeof parsed.frontmatter.order === "number" ? parsed.frontmatter.order : void 0,
-            description: parsed.frontmatter.description || void 0
-          });
-        } else {
-          pages.push({
-            slug,
-            title: slug,
-            body: raw.trim()
-          });
-        }
-      } catch {
-      }
-    }
-  } catch {
-  }
-  pages.sort((a, b) => {
-    if (a.order != null && b.order != null) return a.order - b.order;
-    if (a.order != null) return -1;
-    if (b.order != null) return 1;
-    return a.title.localeCompare(b.title);
-  });
-  return pages;
-}
-function loadCustomPage(rootDir, slug, config) {
-  const resolvedConfig = config || loadDocsConfig(rootDir);
-  const dir = path.join(rootDir, resolvedConfig.customContent);
-  const filePath = path.join(dir, `${slug}.md`);
-  if (!fs.existsSync(filePath)) return null;
-  try {
-    const raw = fs.readFileSync(filePath, "utf8");
-    const parsed = parseFrontmatter(raw);
-    if (parsed) {
-      return {
-        slug,
-        title: parsed.frontmatter.title || slug,
-        body: parsed.body,
-        order: typeof parsed.frontmatter.order === "number" ? parsed.frontmatter.order : void 0,
-        description: parsed.frontmatter.description || void 0
-      };
-    }
-    return {
-      slug,
-      title: slug,
-      body: raw.trim()
-    };
-  } catch {
-    return null;
-  }
-}
-function buildDocsManifest(rootDir, config) {
-  const resolvedConfig = config || loadDocsConfig(rootDir);
-  const scanIndex = loadScanIndex(rootDir);
-  const flowIndex = loadFlowIndex(rootDir);
-  const portal = loadPortal(rootDir);
-  const customPages = loadCustomPages(rootDir, resolvedConfig.customContent);
-  const uniIndex = loadUniversityIndex(rootDir);
-  const projectName = scanIndex?.$meta?.project || path.basename(rootDir);
-  const title = resolvedConfig.title || `${projectName} Docs`;
-  const groups = [];
-  const symbolCounts = {};
-  let totalSymbols = 0;
-  if (customPages.length > 0) {
-    groups.push({
-      id: "custom-pages",
-      label: "Pages",
-      collapsed: resolvedConfig.sidebar.collapsed.includes("custom-pages"),
-      items: customPages.map((p) => ({
-        id: p.slug,
-        label: p.title,
-        kind: "custom",
-        description: p.description
-      }))
-    });
-  }
-  if (uniIndex && uniIndex.entries.length > 0) {
-    const guideEntries = uniIndex.entries.filter(
-      (e) => (e.type === "note" || e.type === "policy") && e.symbols.length > 0
-    );
-    if (guideEntries.length > 0) {
-      groups.push({
-        id: "guides",
-        label: "Guides",
-        collapsed: resolvedConfig.sidebar.collapsed.includes("guides"),
-        items: guideEntries.map((e) => ({
-          id: e.id,
-          label: e.title,
-          kind: "guide",
-          description: void 0,
-          badge: e.symbols.length > 0 ? `${e.symbols.length} symbols` : void 0
-        }))
-      });
-    }
-  }
-  if (scanIndex) {
-    const componentEntries = Object.values(scanIndex.components || {}).filter((e) => !isExcluded(e, resolvedConfig));
-    if (componentEntries.length > 0) {
-      const byType = /* @__PURE__ */ new Map();
-      for (const entry of componentEntries) {
-        const cType = entry.componentType || "other";
-        if (!byType.has(cType)) byType.set(cType, []);
-        byType.get(cType).push(entry);
-      }
-      const sortedTypes = [...byType.entries()].sort((a, b) => b[1].length - a[1].length);
-      const subgroups = sortedTypes.map(([cType, entries]) => ({
-        id: `components-${cType}`,
-        label: `${cType.charAt(0).toUpperCase() + cType.slice(1)} (${entries.length})`,
-        collapsed: resolvedConfig.sidebar.collapsed.includes(`components-${cType}`),
-        items: entries.sort((a, b) => a.name.localeCompare(b.name)).map((e) => ({
-          id: e.id,
-          label: e.name,
-          kind: "component",
-          description: e.description,
-          badge: e.componentType
-        }))
-      }));
-      groups.push({
-        id: "components",
-        label: `Components (${componentEntries.length})`,
-        collapsed: resolvedConfig.sidebar.collapsed.includes("components"),
-        items: [],
-        subgroups
-      });
-      symbolCounts["components"] = componentEntries.length;
-      totalSymbols += componentEntries.length;
-    }
-    const featureEntries = Object.values(scanIndex.features || {}).filter((e) => !isExcluded(e, resolvedConfig));
-    if (featureEntries.length > 0) {
-      groups.push({
-        id: "features",
-        label: `Features (${featureEntries.length})`,
-        collapsed: resolvedConfig.sidebar.collapsed.includes("features"),
-        items: featureEntries.sort((a, b) => a.name.localeCompare(b.name)).map((e) => ({
-          id: e.id,
-          label: e.name,
-          kind: "component",
-          description: e.description
-        }))
-      });
-      symbolCounts["features"] = featureEntries.length;
-      totalSymbols += featureEntries.length;
-    }
-    const flowEntries = Object.values(scanIndex.flows || {}).filter((e) => !isExcluded(e, resolvedConfig));
-    const flowIds = new Set(flowEntries.map((f) => f.id));
-    const additionalFlows = [];
-    if (flowIndex) {
-      for (const [fId, flow] of Object.entries(flowIndex.flows)) {
-        const cleanId = fId.replace(/^\$/, "");
-        if (!flowIds.has(cleanId)) {
-          additionalFlows.push({
-            id: cleanId,
-            label: flow.name || cleanId,
-            kind: "flow",
-            description: flow.description
-          });
-        }
-      }
-    }
-    const allFlowItems = [
-      ...flowEntries.sort((a, b) => a.name.localeCompare(b.name)).map((e) => ({
-        id: e.id,
-        label: e.name,
-        kind: "flow",
-        description: e.description
-      })),
-      ...additionalFlows
-    ];
-    if (allFlowItems.length > 0) {
-      groups.push({
-        id: "flows",
-        label: `Flows (${allFlowItems.length})`,
-        collapsed: resolvedConfig.sidebar.collapsed.includes("flows"),
-        items: allFlowItems
-      });
-      symbolCounts["flows"] = allFlowItems.length;
-      totalSymbols += allFlowItems.length;
-    }
-    const gateEntries = Object.values(scanIndex.gates || {}).filter((e) => !isExcluded(e, resolvedConfig));
-    if (gateEntries.length > 0) {
-      groups.push({
-        id: "gates",
-        label: `Gates (${gateEntries.length})`,
-        collapsed: resolvedConfig.sidebar.collapsed.includes("gates"),
-        items: gateEntries.sort((a, b) => a.name.localeCompare(b.name)).map((e) => ({
-          id: e.id,
-          label: e.name,
-          kind: "gate",
-          description: e.description
-        }))
-      });
-      symbolCounts["gates"] = gateEntries.length;
-      totalSymbols += gateEntries.length;
-    }
-    const signalEntries = Object.values(scanIndex.signals || {}).filter((e) => !isExcluded(e, resolvedConfig));
-    if (signalEntries.length > 0) {
-      groups.push({
-        id: "signals",
-        label: `Signals (${signalEntries.length})`,
-        collapsed: resolvedConfig.sidebar.collapsed.includes("signals"),
-        items: signalEntries.sort((a, b) => a.name.localeCompare(b.name)).map((e) => ({
-          id: e.id,
-          label: e.name,
-          kind: "signal",
-          description: e.description
-        }))
-      });
-      symbolCounts["signals"] = signalEntries.length;
-      totalSymbols += signalEntries.length;
-    }
-    const aspectEntries = Object.values(scanIndex.aspects || {}).filter((e) => !isExcluded(e, resolvedConfig));
-    if (aspectEntries.length > 0) {
-      groups.push({
-        id: "aspects",
-        label: `Aspects (${aspectEntries.length})`,
-        collapsed: resolvedConfig.sidebar.collapsed.includes("aspects"),
-        items: aspectEntries.sort((a, b) => a.name.localeCompare(b.name)).map((e) => ({
-          id: e.id,
-          label: e.name,
-          kind: "aspect",
-          description: e.description
-        }))
-      });
-      symbolCounts["aspects"] = aspectEntries.length;
-      totalSymbols += aspectEntries.length;
-    }
-  }
-  if (portal) {
-    const routeCount = Object.keys(portal.routes || {}).length;
-    const gateCount = Object.keys(portal.gates || {}).length;
-    groups.push({
-      id: "portal",
-      label: "Portal",
-      collapsed: resolvedConfig.sidebar.collapsed.includes("portal"),
-      items: [{
-        id: "portal-overview",
-        label: "Authorization Overview",
-        kind: "portal",
-        description: `${gateCount} gates, ${routeCount} routes`,
-        badge: `${routeCount} routes`
-      }]
-    });
-  }
-  return {
-    title,
-    project: projectName,
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    groups,
-    totalSymbols,
-    symbolCounts
-  };
-}
-function buildSymbolPage(rootDir, symbolId) {
-  const scanIndex = loadScanIndex(rootDir);
-  if (!scanIndex) return null;
-  const entries = allEntries(scanIndex);
-  const entry = entries.get(symbolId);
-  if (!entry) return null;
-  const referencedBy = [];
-  for (const [otherId, otherEntry] of entries) {
-    if (otherId === symbolId) continue;
-    if (otherEntry.related && otherEntry.related.includes(entry.symbol)) {
-      referencedBy.push(otherEntry.symbol);
-    }
-  }
-  const references = (entry.related || []).slice();
-  const flows = [];
-  const flowIndex = loadFlowIndex(rootDir);
-  if (flowIndex) {
-    for (const [fId, flow] of Object.entries(flowIndex.flows)) {
-      const stepSymbols = (flow.steps || []).map((s) => s.symbol);
-      if (stepSymbols.includes(entry.symbol) || stepSymbols.includes(`#${symbolId}`)) {
-        flows.push({ id: fId.replace(/^\$/, ""), name: flow.name || fId });
-      }
-    }
-  }
-  if (scanIndex.flows) {
-    for (const [fId, flow] of Object.entries(scanIndex.flows)) {
-      if (flows.some((f) => f.id === fId)) continue;
-      const stepSymbols = (flow.steps || []).map((s) => s.symbol).filter(Boolean);
-      if (stepSymbols.includes(entry.symbol) || stepSymbols.includes(`#${symbolId}`)) {
-        flows.push({ id: fId, name: flow.name });
-      }
-    }
-  }
-  const gates = [];
-  const portal = loadPortal(rootDir);
-  if (portal && entry.category === "gates") {
-    const gateKey = Object.keys(portal.gates || {}).find(
-      (k) => k.replace(/^\^/, "") === symbolId
-    );
-    if (gateKey) {
-      gates.push({
-        id: gateKey.replace(/^\^/, ""),
-        description: portal.gates[gateKey].description
-      });
-    }
-  } else if (portal) {
-    const relatedGateSymbols = new Set((entry.related || []).filter((r) => r.startsWith("^")));
-    for (const [_route, routeGates] of Object.entries(portal.routes || {})) {
-      for (const gateRef of routeGates) {
-        const cleanGate = gateRef.replace(/^\^/, "");
-        if (relatedGateSymbols.has(gateRef) || relatedGateSymbols.has(`^${cleanGate}`)) {
-          const gateEntry = portal.gates[gateRef] || portal.gates[`^${cleanGate}`] || portal.gates[cleanGate];
-          if (gateEntry && !gates.some((g) => g.id === cleanGate)) {
-            gates.push({ id: cleanGate, description: gateEntry.description });
-          }
-        }
-      }
-    }
-  }
-  const aspects = [];
-  if (scanIndex.aspects) {
-    for (const [_aId, aspect] of Object.entries(scanIndex.aspects)) {
-      if (aspect.related && aspect.related.includes(entry.symbol)) {
-        aspects.push(aspect.symbol);
-      }
-    }
-  }
-  for (const ref of entry.related || []) {
-    if (ref.startsWith("~") && !aspects.includes(ref)) {
-      aspects.push(ref);
-    }
-  }
-  const guides = [];
-  const uniIndex = loadUniversityIndex(rootDir);
-  if (uniIndex) {
-    for (const uEntry of uniIndex.entries) {
-      if (uEntry.symbols.includes(entry.symbol)) {
-        guides.push({ id: uEntry.id, title: uEntry.title });
-      }
-    }
-  }
-  const parent = entry.parent || void 0;
-  const children = [];
-  if (scanIndex.components) {
-    for (const comp of Object.values(scanIndex.components)) {
-      if (comp.parent === entry.symbol) {
-        children.push(comp.symbol);
-      }
-    }
-  }
-  return {
-    id: entry.id,
-    symbol: entry.symbol,
-    name: entry.name,
-    description: entry.description || "",
-    category: entry.category || "components",
-    componentType: entry.componentType,
-    tags: entry.visualTags || [],
-    path: entry.path || "",
-    related: entry.related || [],
-    referencedBy,
-    references,
-    flows,
-    gates,
-    aspects,
-    guides,
-    parent,
-    children
-  };
-}
-function buildFlowPage(rootDir, flowId) {
-  const flowIndex = loadFlowIndex(rootDir);
-  const scanIndex = loadScanIndex(rootDir);
-  if (flowIndex) {
-    const flowKey = flowIndex.flows[`$${flowId}`] ? `$${flowId}` : flowId;
-    const flow = flowIndex.flows[flowKey];
-    if (flow) {
-      const steps = (flow.steps || []).map((s) => ({
-        type: s.type || "action",
-        symbol: s.symbol || "",
-        description: s.description
-      }));
-      const scanEntry = scanIndex?.flows?.[flowId.replace(/^\$/, "")];
-      return {
-        id: flowId.replace(/^\$/, ""),
-        symbol: `$${flowId.replace(/^\$/, "")}`,
-        name: flow.name || flowId,
-        description: flow.description,
-        trigger: flow.trigger,
-        steps,
-        successSignal: flow.successSignal,
-        errorSignal: flow.errorSignal,
-        tags: scanEntry?.visualTags || [],
-        path: scanEntry?.path || flow.definedIn || ""
-      };
-    }
-  }
-  if (scanIndex?.flows) {
-    const cleanId = flowId.replace(/^\$/, "");
-    const scanFlow = scanIndex.flows[cleanId];
-    if (scanFlow) {
-      const steps = (scanFlow.steps || []).map((s) => ({
-        type: "action",
-        symbol: s.symbol || "",
-        description: s.action || s.name
-      }));
-      return {
-        id: cleanId,
-        symbol: `$${cleanId}`,
-        name: scanFlow.name,
-        description: scanFlow.description,
-        steps,
-        tags: scanFlow.visualTags || [],
-        path: scanFlow.path || ""
-      };
-    }
-  }
-  return null;
-}
-function buildPortalPage(rootDir) {
-  const portal = loadPortal(rootDir);
-  if (!portal) {
-    return { version: "0", gates: [], routes: [] };
-  }
-  const gateRouteMap = /* @__PURE__ */ new Map();
-  for (const [routeKey, routeGates] of Object.entries(portal.routes || {})) {
-    for (const gateRef of routeGates) {
-      const cleanGate = gateRef.replace(/^\^/, "");
-      if (!gateRouteMap.has(cleanGate)) gateRouteMap.set(cleanGate, []);
-      gateRouteMap.get(cleanGate).push(routeKey);
-    }
-  }
-  const gates = Object.entries(portal.gates || {}).map(([key, gate]) => {
-    const cleanKey = key.replace(/^\^/, "");
-    return {
-      symbol: `^${cleanKey}`,
-      description: gate.description,
-      check: gate.check,
-      routes: gateRouteMap.get(cleanKey) || []
-    };
-  });
-  const routes = Object.entries(portal.routes || {}).map(([routeKey, routeGates]) => {
-    const spaceIdx = routeKey.indexOf(" ");
-    const method = spaceIdx > 0 ? routeKey.substring(0, spaceIdx) : "GET";
-    const route = spaceIdx > 0 ? routeKey.substring(spaceIdx + 1) : routeKey;
-    return {
-      route,
-      method,
-      gates: routeGates.map((gateRef) => {
-        const cleanGate = gateRef.replace(/^\^/, "");
-        const gateEntry = portal.gates[gateRef] || portal.gates[`^${cleanGate}`] || portal.gates[cleanGate];
-        return {
-          symbol: `^${cleanGate}`,
-          description: gateEntry?.description
-        };
-      })
-    };
-  });
-  return {
-    version: portal.version || "1.0",
-    gates,
-    routes
-  };
-}
-function searchDocs(rootDir, query, limit) {
-  const maxResults = limit || 20;
-  const results = [];
-  const queryLower = query.toLowerCase();
-  const scanIndex = loadScanIndex(rootDir);
-  if (scanIndex) {
-    const entries = allEntries(scanIndex);
-    for (const [_id, entry] of entries) {
-      const score = scoreMatch(entry.name, entry.description || "", entry.visualTags || [], queryLower);
-      if (score > 0) {
-        results.push({
-          id: entry.id,
-          kind: categoryToSearchKind(entry.category),
-          label: entry.name,
-          description: entry.description || "",
-          matchContext: buildMatchContext(entry.name, entry.description || "", queryLower),
-          score
-        });
-      }
-    }
-  }
-  const config = loadDocsConfig(rootDir);
-  const customPages = loadCustomPages(rootDir, config.customContent);
-  for (const page of customPages) {
-    const bodySnippet = page.body.substring(0, 200);
-    const score = scoreMatch(page.title, bodySnippet, [], queryLower);
-    if (score > 0) {
-      results.push({
-        id: page.slug,
-        kind: "custom",
-        label: page.title,
-        description: page.description || bodySnippet.substring(0, 100),
-        matchContext: buildMatchContext(page.title, page.body, queryLower),
-        score
-      });
-    }
-  }
-  const portal = loadPortal(rootDir);
-  if (portal) {
-    for (const [key, gate] of Object.entries(portal.gates || {})) {
-      const cleanKey = key.replace(/^\^/, "");
-      const score = scoreMatch(cleanKey, gate.description, [], queryLower);
-      if (score > 0) {
-        results.push({
-          id: cleanKey,
-          kind: "portal",
-          label: `^${cleanKey}`,
-          description: gate.description,
-          score
-        });
-      }
-    }
-  }
-  results.sort((a, b) => b.score - a.score || a.label.localeCompare(b.label));
-  return results.slice(0, maxResults);
-}
-function scoreMatch(name, description, tags, queryLower) {
-  const nameLower = name.toLowerCase();
-  const descLower = description.toLowerCase();
-  if (nameLower === queryLower) return 1;
-  if (nameLower.startsWith(queryLower)) return 0.8;
-  if (nameLower.includes(queryLower)) return 0.6;
-  if (descLower.includes(queryLower)) return 0.5;
-  if (tags.some((t) => t.toLowerCase().includes(queryLower))) return 0.3;
-  return 0;
-}
-function buildMatchContext(name, text, queryLower) {
-  const textLower = text.toLowerCase();
-  const idx = textLower.indexOf(queryLower);
-  if (idx < 0) {
-    if (name.toLowerCase().includes(queryLower)) {
-      return name;
-    }
-    return void 0;
-  }
-  const start = Math.max(0, idx - 40);
-  const end = Math.min(text.length, idx + queryLower.length + 40);
-  let snippet = text.substring(start, end).trim();
-  if (start > 0) snippet = `...${snippet}`;
-  if (end < text.length) snippet = `${snippet}...`;
-  return snippet;
-}
-
-export {
-  loadDocsConfig,
-  loadCustomPages,
-  loadCustomPage,
-  buildDocsManifest,
-  buildSymbolPage,
-  buildFlowPage,
-  buildPortalPage,
-  searchDocs
-};