npm - @aravindc26/velu - Versions diffs - 0.11.0 → 0.11.3 - Mend

@aravindc26/velu 0.11.0 → 0.11.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (60) hide show

package/package.json +15 -6
package/schema/velu.schema.json +1251 -115
package/src/build.ts +1121 -304
package/src/cli.ts +90 -26
package/src/engine/_server.mjs +1684 -277
package/src/engine/app/(docs)/[...slug]/layout.tsx +371 -0
package/src/engine/app/(docs)/[...slug]/page.tsx +926 -0
package/src/engine/app/api/proxy/route.ts +23 -0
package/src/engine/app/copy-page.css +59 -1
package/src/engine/app/global.css +3157 -3
package/src/engine/app/layout.tsx +56 -1
package/src/engine/app/llms-file/route.ts +87 -0
package/src/engine/app/llms-full-file/route.ts +62 -0
package/src/engine/app/md-file/[...slug]/route.ts +409 -0
package/src/engine/app/page.tsx +45 -0
package/src/engine/app/robots.txt/route.ts +63 -0
package/src/engine/app/rss-file/[...slug]/route.ts +169 -0
package/src/engine/app/sitemap.xml/route.ts +82 -0
package/src/engine/components/assistant.tsx +16 -5
package/src/engine/components/changelog-filters.tsx +114 -0
package/src/engine/components/code-group.tsx +383 -0
package/src/engine/components/color.tsx +118 -0
package/src/engine/components/expandable.tsx +77 -0
package/src/engine/components/icon.tsx +136 -0
package/src/engine/components/image-zoom-fallback.tsx +147 -0
package/src/engine/components/image.tsx +111 -0
package/src/engine/components/manual-api-playground.tsx +154 -0
package/src/engine/components/mermaid.tsx +142 -0
package/src/engine/components/openapi-toc-sync.tsx +59 -0
package/src/engine/components/openapi.tsx +1682 -0
package/src/engine/components/page-feedback.tsx +153 -0
package/src/engine/components/product-switcher.tsx +27 -3
package/src/engine/components/prompt.tsx +90 -0
package/src/engine/components/providers.tsx +1 -6
package/src/engine/components/search.tsx +4 -0
package/src/engine/components/sidebar-links.tsx +13 -15
package/src/engine/components/synced-tabs.tsx +57 -0
package/src/engine/components/toc-examples.tsx +110 -0
package/src/engine/components/view.tsx +344 -0
package/src/engine/generated/redirects.ts +3 -0
package/src/engine/lib/changelog.ts +246 -0
package/src/engine/lib/layout.shared.ts +30 -2
package/src/engine/lib/llms.ts +444 -0
package/src/engine/lib/navigation-normalize.mjs +481 -412
package/src/engine/lib/navigation-normalize.ts +261 -54
package/src/engine/lib/redirects.ts +194 -0
package/src/engine/lib/source.ts +107 -4
package/src/engine/lib/velu.ts +368 -2
package/src/engine/mdx-components.tsx +648 -0
package/src/engine/middleware.ts +66 -0
package/src/engine/public/icons/cursor-dark.svg +12 -0
package/src/engine/public/icons/cursor-light.svg +12 -0
package/src/engine/source.config.ts +98 -1
package/src/engine/src/components/PageTitle.astro +16 -5
package/src/engine/src/lib/velu.ts +11 -3
package/src/navigation-normalize.ts +252 -54
package/src/themes.ts +6 -6
package/src/validate.ts +119 -6
package/src/engine/app/(docs)/[[...slug]]/layout.tsx +0 -87
package/src/engine/app/(docs)/[[...slug]]/page.tsx +0 -146

package/src/engine/app/layout.tsx CHANGED Viewed

@@ -1,5 +1,6 @@
+import type { Metadata } from 'next';
 import type { ReactNode } from 'react';
-import { getAppearance } from '@/lib/velu';
+import { getAppearance, getSeoConfig, getSiteFavicon, getSiteName, getSiteOrigin, getSitePrimaryColor } from '@/lib/velu';
 import { Providers } from '@/components/providers';
 import { VeluAssistant } from '@/components/assistant';
 import './global.css';
@@ -7,6 +8,57 @@ import './search.css';
 import './assistant.css';
 import './copy-page.css';
+function toAbsoluteUrl(origin: string, value: string): string {
+  const trimmed = value.trim();
+  if (!trimmed) return trimmed;
+  if (/^https?:\/\//i.test(trimmed)) return trimmed;
+  const path = trimmed.startsWith('/') ? trimmed : `/${trimmed}`;
+  return `${origin}${path}`;
+}
+const siteName = getSiteName();
+const siteOrigin = getSiteOrigin();
+const seo = getSeoConfig();
+const favicon = getSiteFavicon();
+const primaryColor = getSitePrimaryColor();
+const generatedDefaultSocialImage = '/og/index.svg';
+const defaultSocialImage = seo.metatags['og:image'] ?? seo.metatags['twitter:image'] ?? generatedDefaultSocialImage;
+const absoluteDefaultSocialImage = defaultSocialImage ? toAbsoluteUrl(siteOrigin, defaultSocialImage) : undefined;
+export const metadata: Metadata = {
+  metadataBase: new URL(siteOrigin),
+  title: {
+    default: siteName,
+    template: `%s - ${siteName}`,
+  },
+  applicationName: siteName,
+  generator: seo.metatags.generator || 'Mintlify',
+  appleWebApp: {
+    title: siteName,
+  },
+  openGraph: {
+    type: 'website',
+    siteName,
+    ...(absoluteDefaultSocialImage
+      ? { images: [{ url: absoluteDefaultSocialImage, width: 1200, height: 630 }] }
+      : {}),
+  },
+  twitter: {
+    card: 'summary_large_image',
+    ...(absoluteDefaultSocialImage ? { images: [absoluteDefaultSocialImage] } : {}),
+  },
+  ...(favicon
+    ? {
+        icons: {
+          icon: [{ url: favicon }],
+          shortcut: [{ url: favicon }],
+          apple: [{ url: favicon }],
+        },
+      }
+    : {}),
+  ...(primaryColor ? { other: { 'msapplication-TileColor': primaryColor } } : {}),
+};
 export default function RootLayout({ children }: { children: ReactNode }) {
   const appearance = getAppearance();
   const theme =
@@ -19,6 +71,9 @@ export default function RootLayout({ children }: { children: ReactNode }) {
   return (
     <html lang="en" suppressHydrationWarning>
+      <head>
+        <link rel="sitemap" type="application/xml" href={`${siteOrigin}/sitemap.xml`} />
+      </head>
       <body className="min-h-screen" suppressHydrationWarning>
         <Providers theme={theme}>
           {children}

package/src/engine/app/llms-file/route.ts ADDED Viewed

@@ -0,0 +1,87 @@
+import {
+  collectLlmsPages,
+  getSiteTitle,
+  normalizePath,
+  readCustomLlmsFile,
+} from '@/lib/llms';
+import { getSiteOrigin } from '@/lib/velu';
+export const dynamic = 'force-static';
+function cleanInlineText(value: string): string {
+  return value.replace(/\s+/g, ' ').trim();
+}
+function toMarkdownPath(path: string): string {
+  const normalized = normalizePath(path);
+  if (normalized.endsWith('.md')) return normalized;
+  return `${normalized}.md`;
+}
+function toSpecUrl(origin: string, spec: string): string {
+  const trimmed = spec.trim();
+  if (/^https?:\/\//i.test(trimmed)) return trimmed;
+  return `${origin}${normalizePath(trimmed)}`;
+}
+export async function GET() {
+  const custom = await readCustomLlmsFile('llms.txt');
+  if (custom !== null) {
+    return new Response(custom, {
+      status: 200,
+      headers: {
+        'content-type': 'text/plain; charset=utf-8',
+        'cache-control': 'public, max-age=300',
+        'x-content-type-options': 'nosniff',
+      },
+    });
+  }
+  const siteTitle = getSiteTitle();
+  const origin = getSiteOrigin();
+  const pages = await collectLlmsPages();
+  const docsPages = pages.filter((page) => !page.noindex && !(page.sourceKind === 'generated' && page.isOpenApiOperation));
+  const openApiSpecs = Array.from(
+    new Set(
+      pages
+        .filter((page) => !page.noindex && page.sourceKind === 'generated' && page.isOpenApiOperation && typeof page.openapiSpec === 'string')
+        .map((page) => page.openapiSpec!.trim())
+        .filter((spec) => spec.length > 0),
+    ),
+  );
+  const lines: string[] = [];
+  lines.push(`# ${siteTitle}`);
+  lines.push('');
+  lines.push('## Docs');
+  lines.push('');
+  for (const page of docsPages) {
+    const url = `${origin}${toMarkdownPath(page.path)}`;
+    const description = page.description ? cleanInlineText(page.description) : '';
+    if (description) {
+      lines.push(`- [${page.title}](${url}): ${description}`);
+    } else {
+      lines.push(`- [${page.title}](${url})`);
+    }
+  }
+  if (openApiSpecs.length > 0) {
+    lines.push('');
+    lines.push('## OpenAPI Specs');
+    lines.push('');
+    for (const spec of openApiSpecs) {
+      const url = toSpecUrl(origin, spec);
+      lines.push(`- [${spec}](${url})`);
+    }
+  }
+  lines.push('');
+  const body = `${lines.join('\n').trimEnd()}\n`;
+  return new Response(body, {
+    status: 200,
+    headers: {
+      'content-type': 'text/plain; charset=utf-8',
+      'cache-control': 'public, max-age=300',
+      'x-content-type-options': 'nosniff',
+    },
+  });
+}

package/src/engine/app/llms-full-file/route.ts ADDED Viewed

@@ -0,0 +1,62 @@
+import {
+  collectLlmsPages,
+  getSiteTitle,
+  normalizePath,
+  readCustomLlmsFile,
+} from '@/lib/llms';
+import { getSiteOrigin } from '@/lib/velu';
+export const dynamic = 'force-static';
+export async function GET() {
+  const custom = await readCustomLlmsFile('llms-full.txt');
+  if (custom !== null) {
+    return new Response(custom, {
+      status: 200,
+      headers: {
+        'content-type': 'text/plain; charset=utf-8',
+        'cache-control': 'public, max-age=300',
+        'x-content-type-options': 'nosniff',
+      },
+    });
+  }
+  const siteTitle = getSiteTitle();
+  const origin = getSiteOrigin();
+  const pages = await collectLlmsPages({ includeMarkdown: true });
+  const includedPages = pages.filter((page) => {
+    if (page.noindex) return false;
+    const hasBodyContent = typeof page.markdown === 'string' && page.markdown.trim().length > 0;
+    if (page.isOpenApiOperation && !hasBodyContent) return false;
+    if (page.sourceKind === 'generated' && page.isOpenApiOperation) return false;
+    return true;
+  });
+  const lines: string[] = [];
+  lines.push(`# ${siteTitle}`);
+  lines.push('');
+  for (const page of includedPages) {
+    const url = `${origin}${normalizePath(page.path)}`;
+    lines.push(`## ${page.title}`);
+    lines.push('');
+    lines.push(`Source: ${url}`);
+    lines.push('');
+    if (page.description) {
+      lines.push(`> ${page.description.replace(/\s+/g, ' ').trim()}`);
+      lines.push('');
+    }
+    lines.push(page.markdown && page.markdown.length > 0 ? page.markdown : '_No content._');
+    lines.push('');
+  }
+  const body = `${lines.join('\n').trimEnd()}\n`;
+  return new Response(body, {
+    status: 200,
+    headers: {
+      'content-type': 'text/plain; charset=utf-8',
+      'cache-control': 'public, max-age=300',
+      'x-content-type-options': 'nosniff',
+    },
+  });
+}

package/src/engine/app/md-file/[...slug]/route.ts ADDED Viewed

@@ -0,0 +1,409 @@
+import { readFile } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+import { source } from '@/lib/source';
+import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
+import { getApiConfig, getLanguages } from '@/lib/velu';
+interface RouteParams {
+  slug?: string[];
+}
+interface ParsedOpenApiFrontmatter {
+  spec?: string;
+  method: string;
+  endpoint: string;
+  kind: 'path' | 'webhook';
+}
+const OPENAPI_METHODS = ['get', 'post', 'put', 'patch', 'delete', 'options', 'head', 'trace'] as const;
+export const dynamic = 'force-static';
+export async function generateStaticParams() {
+  const generated = source.generateParams('slug') as Array<{ slug?: string[] }>;
+  const seen = new Set<string>();
+  const out: Array<{ slug: string[] }> = [];
+  for (const entry of generated) {
+    const slug = entry.slug ?? [];
+    if (slug.length === 0) continue;
+    const mdSlug = [...slug];
+    mdSlug[mdSlug.length - 1] = `${mdSlug[mdSlug.length - 1]}.md`;
+    const key = mdSlug.join('/');
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push({ slug: mdSlug });
+  }
+  return out;
+}
+function resolveLocaleSlug(slugInput: string[] | undefined) {
+  const languages = getLanguages();
+  const defaultLanguage = languages[0] ?? 'en';
+  const slug = slugInput ?? [];
+  const firstSeg = slug[0];
+  const hasLocalePrefix = languages.includes(firstSeg ?? '');
+  return {
+    locale: hasLocalePrefix ? firstSeg! : defaultLanguage,
+    pageSlug: hasLocalePrefix ? slug.slice(1) : slug,
+  };
+}
+async function loadMarkdownForSlug(slug: string[], locale: string, hasI18n: boolean): Promise<string | undefined> {
+  const rel = slug.join('/');
+  const docsRoots = [
+    join(process.cwd(), 'content', 'docs'),
+    join(process.cwd(), '.velu-out', 'content', 'docs'),
+  ];
+  const roots = hasI18n
+    ? docsRoots.flatMap((root) => [join(root, locale), root])
+    : docsRoots;
+  const paths = roots.flatMap((root) => [join(root, `${rel}.md`), join(root, `${rel}.mdx`)]);
+  for (const filePath of paths) {
+    try {
+      return await readFile(filePath, 'utf-8');
+    } catch {
+      // ignore and continue
+    }
+  }
+  return undefined;
+}
+function parseFrontmatterMap(markdown?: string): Record<string, string> {
+  if (!markdown) return {};
+  const match = markdown.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match) return {};
+  const output: Record<string, string> = {};
+  const lines = match[1].split(/\r?\n/);
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith('#')) continue;
+    const entry = line.match(/^([A-Za-z0-9_-]+)\s*:\s*(.+)$/);
+    if (!entry) continue;
+    const key = entry[1];
+    const rawValue = entry[2].trim();
+    const value = rawValue.replace(/^['"]|['"]$/g, '').trim();
+    output[key] = value;
+  }
+  return output;
+}
+function stripFrontmatter(markdown: string): string {
+  return markdown.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, '');
+}
+function parseOpenApiFrontmatter(rawValue: string | undefined, defaultSpec?: string): ParsedOpenApiFrontmatter | null {
+  if (!rawValue) return null;
+  const trimmed = rawValue.trim();
+  if (!trimmed) return null;
+  const withInlineSpec = trimmed.match(/^(\S+)\s+([A-Za-z]+)\s+(.+)$/);
+  if (withInlineSpec) {
+    const method = withInlineSpec[2].toUpperCase();
+    const endpoint = withInlineSpec[3].trim();
+    if (!endpoint) return null;
+    const kind = method === 'WEBHOOK' ? 'webhook' : 'path';
+    if (kind === 'path' && !endpoint.startsWith('/')) return null;
+    return {
+      spec: withInlineSpec[1].trim(),
+      method,
+      endpoint,
+      kind,
+    };
+  }
+  const withDefaultSpec = trimmed.match(/^([A-Za-z]+)\s+(.+)$/);
+  if (withDefaultSpec) {
+    const method = withDefaultSpec[1].toUpperCase();
+    const endpoint = withDefaultSpec[2].trim();
+    if (!endpoint) return null;
+    const kind = method === 'WEBHOOK' ? 'webhook' : 'path';
+    if (kind === 'path' && !endpoint.startsWith('/')) return null;
+    return {
+      spec: defaultSpec,
+      method,
+      endpoint,
+      kind,
+    };
+  }
+  return null;
+}
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : undefined;
+}
+function parseOpenApiDocument(rawSource: string): Record<string, unknown> | null {
+  const sourceText = rawSource.trim();
+  if (!sourceText) return null;
+  try {
+    const parsed = JSON.parse(sourceText);
+    if (parsed && typeof parsed === 'object') return parsed as Record<string, unknown>;
+  } catch {
+    // Fall through to YAML parse.
+  }
+  try {
+    const parsed = parseYaml(sourceText);
+    if (parsed && typeof parsed === 'object') return parsed as Record<string, unknown>;
+  } catch {
+    // ignore
+  }
+  return null;
+}
+async function loadOpenApiDocument(specSource: string): Promise<Record<string, unknown> | null> {
+  const sourceText = specSource.trim();
+  if (!sourceText) return null;
+  if (/^https?:\/\//i.test(sourceText)) {
+    try {
+      const response = await fetch(sourceText, { cache: 'force-cache' });
+      if (!response.ok) return null;
+      const text = await response.text();
+      return parseOpenApiDocument(text);
+    } catch {
+      return null;
+    }
+  }
+  const relative = sourceText.replace(/^\/+/, '');
+  const candidates = sourceText.startsWith('/')
+    ? [
+        join(process.cwd(), 'public', relative),
+        join(process.cwd(), relative),
+        join(process.cwd(), 'content', 'docs', relative),
+      ]
+    : [
+        join(process.cwd(), sourceText),
+        join(process.cwd(), 'public', sourceText),
+        join(process.cwd(), 'content', 'docs', sourceText),
+      ];
+  for (const candidate of candidates) {
+    try {
+      const text = await readFile(candidate, 'utf-8');
+      const parsed = parseOpenApiDocument(text);
+      if (parsed) return parsed;
+    } catch {
+      // ignore and continue
+    }
+  }
+  return null;
+}
+function pickOperationMethod(pathItem: Record<string, unknown>, preferred?: string): string | undefined {
+  const preferredLower = preferred?.toLowerCase();
+  if (preferredLower && OPENAPI_METHODS.includes(preferredLower as (typeof OPENAPI_METHODS)[number])) {
+    const selected = asRecord(pathItem[preferredLower]);
+    if (selected) return preferredLower;
+  }
+  for (const method of OPENAPI_METHODS) {
+    if (asRecord(pathItem[method])) return method;
+  }
+  return undefined;
+}
+function resolvePathOperation(
+  document: Record<string, unknown>,
+  endpoint: string,
+  method: string,
+): { endpoint: string; method: string; operation: Record<string, unknown> } | null {
+  const paths = asRecord(document.paths);
+  if (!paths) return null;
+  const candidates = endpoint.startsWith('/')
+    ? [endpoint, endpoint.replace(/^\/+/, '')]
+    : [`/${endpoint}`, endpoint];
+  const methodLower = method.toLowerCase();
+  for (const candidate of candidates) {
+    const pathItem = asRecord(paths[candidate]);
+    if (!pathItem) continue;
+    const resolvedMethod = pickOperationMethod(pathItem, methodLower);
+    if (!resolvedMethod) continue;
+    const operation = asRecord(pathItem[resolvedMethod]);
+    if (!operation) continue;
+    const resolvedEndpoint = candidate.startsWith('/') ? candidate : `/${candidate}`;
+    return { endpoint: resolvedEndpoint, method: resolvedMethod, operation };
+  }
+  return null;
+}
+function resolveWebhookOperation(
+  document: Record<string, unknown>,
+  endpoint: string,
+): { endpoint: string; method: string; operation: Record<string, unknown> } | null {
+  const webhooks = asRecord(document.webhooks);
+  if (!webhooks) return null;
+  const normalized = endpoint.startsWith('/') ? endpoint : `/${endpoint}`;
+  const candidates = [endpoint, normalized, endpoint.replace(/^\/+/, ''), normalized.replace(/^\/+/, '')];
+  for (const candidate of candidates) {
+    const pathItem = asRecord(webhooks[candidate]);
+    if (!pathItem) continue;
+    const resolvedMethod = pickOperationMethod(pathItem);
+    if (!resolvedMethod) continue;
+    const operation = asRecord(pathItem[resolvedMethod]);
+    if (!operation) continue;
+    return { endpoint: candidate, method: resolvedMethod, operation };
+  }
+  return null;
+}
+function displaySpecName(specSource: string | undefined): string {
+  if (!specSource || !specSource.trim()) return 'openapi.json';
+  const trimmed = specSource.trim();
+  if (/^https?:\/\//i.test(trimmed)) {
+    try {
+      const url = new URL(trimmed);
+      const name = basename(url.pathname || '');
+      return name || 'openapi.json';
+    } catch {
+      return 'openapi.json';
+    }
+  }
+  return basename(trimmed.replace(/\\/g, '/')) || 'openapi.json';
+}
+function buildMintlifyStyleApiMarkdown(input: {
+  title: string;
+  description?: string;
+  body?: string;
+  specLabel: string;
+  endpoint: string;
+  method: string;
+  kind: 'path' | 'webhook';
+  snippet: Record<string, unknown>;
+}): string {
+  const lines: string[] = [];
+  lines.push(`# ${input.title}`);
+  lines.push('');
+  if (input.description) {
+    lines.push(`> ${input.description}`);
+    lines.push('');
+  }
+  if (input.body) {
+    lines.push(input.body.trim());
+    lines.push('');
+  }
+  lines.push('## OpenAPI');
+  lines.push('');
+  const opLabel = input.kind === 'webhook'
+    ? `webhook ${input.endpoint}`
+    : `${input.method.toLowerCase()} ${input.endpoint}`;
+  const yaml = stringifyYaml(input.snippet).trimEnd();
+  lines.push(`\`\`\`\`yaml ${input.specLabel} ${opLabel}`);
+  lines.push(yaml);
+  lines.push('````');
+  lines.push('');
+  return lines.join('\n');
+}
+export async function GET(_request: Request, { params }: { params: Promise<RouteParams> }) {
+  const resolvedParams = await params;
+  const fullSlug = resolvedParams.slug ?? [];
+  if (fullSlug.length === 0) {
+    return new Response('Not Found', {
+      status: 404,
+      headers: { 'content-type': 'text/plain; charset=utf-8' },
+    });
+  }
+  const normalized = [...fullSlug];
+  const lastIndex = normalized.length - 1;
+  const last = normalized[lastIndex] ?? '';
+  if (last.toLowerCase().endsWith('.md')) {
+    const stripped = last.slice(0, -3);
+    if (stripped) normalized[lastIndex] = stripped;
+  }
+  const { locale, pageSlug } = resolveLocaleSlug(normalized);
+  const hasI18n = getLanguages().length > 1;
+  const page = hasI18n ? source.getPage(pageSlug, locale) : source.getPage(pageSlug);
+  if (!page) {
+    return new Response('Not Found', {
+      status: 404,
+      headers: { 'content-type': 'text/plain; charset=utf-8' },
+    });
+  }
+  const fromFile = await loadMarkdownForSlug(pageSlug, locale, hasI18n);
+  const fromData = ((page.data as unknown) as Record<string, unknown>).processedMarkdown;
+  const markdown = typeof fromFile === 'string' && fromFile.trim().length > 0
+    ? fromFile
+    : (typeof fromData === 'string' ? fromData : `# ${page.data.title}\n`);
+  const frontmatter = parseFrontmatterMap(markdown);
+  const markdownBody = stripFrontmatter(markdown).trim();
+  const apiConfig = getApiConfig();
+  const parsedOpenApi = parseOpenApiFrontmatter(frontmatter.openapi, apiConfig.defaultOpenApiSpec);
+  if (parsedOpenApi?.spec) {
+    const document = await loadOpenApiDocument(parsedOpenApi.spec);
+    if (document) {
+      const resolved = parsedOpenApi.kind === 'webhook'
+        ? resolveWebhookOperation(document, parsedOpenApi.endpoint)
+        : resolvePathOperation(document, parsedOpenApi.endpoint, parsedOpenApi.method);
+      if (resolved) {
+        const title = frontmatter.title
+          || (typeof resolved.operation.summary === 'string' ? resolved.operation.summary : '')
+          || `${resolved.method.toUpperCase()} ${resolved.endpoint}`;
+        const description = frontmatter.description
+          || (typeof resolved.operation.description === 'string' ? resolved.operation.description : undefined);
+        const snippet: Record<string, unknown> = {
+          openapi: typeof document.openapi === 'string' ? document.openapi : '3.0.0',
+          info: asRecord(document.info) ?? { title: 'API', version: '1.0.0' },
+          ...(Array.isArray(document.servers) ? { servers: document.servers } : {}),
+          ...(Array.isArray(document.security) ? { security: document.security } : {}),
+          ...(parsedOpenApi.kind === 'webhook'
+            ? { webhooks: { [resolved.endpoint]: { [resolved.method]: resolved.operation } } }
+            : { paths: { [resolved.endpoint]: { [resolved.method]: resolved.operation } } }),
+          ...(asRecord(document.components) ? { components: document.components } : {}),
+        };
+        const output = buildMintlifyStyleApiMarkdown({
+          title,
+          description,
+          body: markdownBody || undefined,
+          specLabel: displaySpecName(parsedOpenApi.spec),
+          endpoint: resolved.endpoint,
+          method: resolved.method,
+          kind: parsedOpenApi.kind,
+          snippet,
+        });
+        return new Response(output, {
+          status: 200,
+          headers: {
+            'content-type': 'text/markdown; charset=utf-8',
+            'content-disposition': 'inline',
+            'x-content-type-options': 'nosniff',
+          },
+        });
+      }
+    }
+  }
+  return new Response(markdown, {
+    status: 200,
+    headers: {
+      'content-type': 'text/markdown; charset=utf-8',
+      'content-disposition': 'inline',
+      'x-content-type-options': 'nosniff',
+    },
+  });
+}

package/src/engine/app/page.tsx ADDED Viewed

@@ -0,0 +1,45 @@
+import { redirect } from 'next/navigation';
+import { source } from '@/lib/source';
+import { getLanguages } from '@/lib/velu';
+interface PageTreeNode {
+  type?: string;
+  url?: string;
+  external?: boolean;
+  index?: { url?: string };
+  children?: unknown[];
+}
+function findFirstPageUrl(node: unknown): string | undefined {
+  if (!node || typeof node !== 'object') return undefined;
+  const entry = node as PageTreeNode;
+  if (entry.type === 'page' && !entry.external && typeof entry.url === 'string' && entry.url.length > 0) {
+    return entry.url;
+  }
+  if (entry.type === 'folder') {
+    if (typeof entry.index?.url === 'string' && entry.index.url.length > 0) {
+      return entry.index.url;
+    }
+  }
+  const children = Array.isArray(entry.children) ? entry.children : [];
+  for (const child of children) {
+    const nested = findFirstPageUrl(child);
+    if (nested) return nested;
+  }
+  return undefined;
+}
+function resolveDefaultDocsHref(): string {
+  const defaultLanguage = getLanguages()[0] ?? 'en';
+  const tree = source.getPageTree(defaultLanguage);
+  const first = findFirstPageUrl(tree);
+  return first || '/';
+}
+export default function HomePage() {
+  redirect(resolveDefaultDocsHref());
+}