jamdesk 1.1.35 → 1.1.38

package/vendored/components/navigation/LanguageSelector.tsx

@@ -164,28 +164,25 @@ export function LanguageSelector({
           ${compact ? 'px-2 py-1.5' : 'px-3 py-2 w-full'}
         `}
       >
-        <span className="text-base" role="img" aria-label={currentLanguage?.displayName}>
-          {currentLanguage?.flag}
-        </span>
-        {!compact && (
-          <>
-            <span className="flex-1 text-left text-sm font-medium truncate">
-              {currentLanguage?.displayName}
-            </span>
-            <i
-              className={`fa-solid fa-chevron-${position === 'up' ? 'up' : 'down'} h-3 w-3 transition-transform ${
-                isOpen ? (position === 'up' ? 'rotate-180' : 'rotate-180') : ''
-              }`}
-              aria-hidden="true"
-            />
-          </>
-        )}
-        {compact && (
-          <i
-            className={`fa-solid fa-chevron-down h-3 w-3 transition-transform ${isOpen ? 'rotate-180' : ''}`}
-            aria-hidden="true"
-          />
+        <i
+          className="fa-solid fa-globe text-[12px] text-[var(--color-text-tertiary)]"
+          aria-hidden="true"
+        />
+        {compact ? (
+          <span className="text-xs font-semibold tracking-wide">
+            {currentLanguage?.code.split('-')[0].toUpperCase()}
+          </span>
+        ) : (
+          <span className="flex-1 text-left text-sm font-medium truncate">
+            {currentLanguage?.displayName}
+          </span>
         )}
+        <i
+          className={`fa-solid fa-chevron-${position} text-[10px] text-[var(--color-text-tertiary)] transition-transform ${
+            isOpen ? 'rotate-180' : ''
+          }`}
+          aria-hidden="true"
+        />
       </button>
 
       {/* Dropdown menu */}

package/vendored/components/navigation/TableOfContents.tsx

@@ -360,13 +360,20 @@ export function TableOfContents({ content, className = '' }: TableOfContentsProp
         : window.innerHeight;
       const viewBottom = viewTop + viewHeight;
 
-      // Build position list: each heading's scroll offset
+      // `offsetTop` is relative to `offsetParent`, so for elements inside a
+      // positioned ancestor (e.g. <Step> inside <Steps className="relative">)
+      // it bears no relation to the scroll container. Use bounding-rect math
+      // so positions sit in the container's content coordinate frame
+      // regardless of the offsetParent chain.
+      const containerTop = contentContainer
+        ? contentContainer.getBoundingClientRect().top
+        : 0;
       const positions: { id: string; top: number }[] = [];
       for (const h of headings) {
         const el = document.getElementById(h.id);
         if (!el) continue;
         const top = contentContainer
-          ? el.offsetTop - contentContainer.offsetTop
+          ? el.getBoundingClientRect().top - containerTop + contentContainer.scrollTop
           : el.getBoundingClientRect().top + window.scrollY;
         positions.push({ id: h.id, top });
       }
@@ -398,7 +405,15 @@ export function TableOfContents({ content, className = '' }: TableOfContentsProp
         }
       }
 
-      setActiveAnchors(active.length > 0 ? active : [headings[0].id]);
+      const next = active.length > 0 ? active : [headings[0].id];
+      // Skip state update when the active set hasn't changed — otherwise
+      // every scroll tick allocates a new array and cascades re-renders
+      // through updateThumb (which reads layout per active anchor).
+      setActiveAnchors(prev =>
+        prev.length === next.length && prev.every((id, i) => id === next[i])
+          ? prev
+          : next,
+      );
     };
 
     computeActive();

package/vendored/components/search/SearchModal.tsx

@@ -1,7 +1,7 @@
 'use client';
 
 import { useEffect, useState, useRef, type ReactElement } from 'react';
-import { useRouter } from 'next/navigation';
+import { useRouter, usePathname } from 'next/navigation';
 import { getRecentSearches, addRecentSearch, clearRecentSearches } from '@/lib/recent-searches';
 import { useFocusTrap } from '@/hooks/useFocusTrap';
 import { useBodyScrollLock } from '@/hooks/useBodyScrollLock';
@@ -9,16 +9,7 @@ import { getSuggestions } from '@/lib/search-suggestions';
 import { trackSearch } from '@/lib/analytics-client';
 import { useLinkPrefix } from '@/lib/link-prefix-context';
 import { useProjectSlug } from '@/lib/project-slug-context';
-
-interface SearchResult {
-  id: string;
-  title: string;
-  description?: string;
-  content: string;
-  slug: string;
-  section?: string;
-  type?: 'api' | 'component' | 'guide' | 'help' | 'quickstart';
-}
+import type { SearchResult } from '@/lib/search-client';
 
 interface PopularPage {
   title: string;
@@ -102,6 +93,7 @@ function NoResultsState({ query, onSuggestionClick }: { query: string; onSuggest
 export function SearchModal({ isOpen, onClose, popularPages, onNavigate }: SearchModalProps) {
   const linkPrefix = useLinkPrefix();
   const projectSlug = useProjectSlug();
+  const pathname = usePathname() ?? '';
   const [query, setQuery] = useState('');
   const [results, setResults] = useState<SearchResult[]>([]);
   const [selectedIndex, setSelectedIndex] = useState(0);
@@ -210,8 +202,9 @@ export function SearchModal({ isOpen, onClose, popularPages, onNavigate }: Searc
 
     const timer = setTimeout(async () => {
       try {
-        const { search } = await import('@/lib/search-client');
-        const searchResults = await search(query, 15);
+        const { search, resolveActiveLocale } = await import('@/lib/search-client');
+        const activeLocale = resolveActiveLocale(pathname);
+        const searchResults = await search(query, 15, activeLocale);
         if (!cancelled) {
           setResults(searchResults);
           setSelectedIndex(0);
@@ -235,7 +228,7 @@ export function SearchModal({ isOpen, onClose, popularPages, onNavigate }: Searc
       cancelled = true;
       clearTimeout(timer);
     };
-  }, [query]);
+  }, [query, pathname]);
 
   // Scroll selected result into view
   useEffect(() => {

package/vendored/hooks/useChat.ts

@@ -3,6 +3,7 @@
 import { useState, useRef, useCallback, useEffect } from 'react';
 import { createTextStreamPacer, type TextStreamPacer } from './useTextStreamPacer';
 import { useMediaQuery } from './useMediaQuery';
+import { extractLanguageFromPath } from '@/lib/language-utils';
 
 export interface Citation {
   title: string;
@@ -120,13 +121,13 @@ export function useChat(endpoint = '/_chat'): {
   const markRevealComplete = useCallback(
     (
       assistantId: string,
-      pending: { citations?: Citation[]; clarificationOptions?: string[] },
+      pending: { citations?: Citation[]; clarificationOptions?: string[]; replacedContent?: string },
     ): void => {
       setMessages((prev) => {
         const idx = prev.findIndex((m) => m.id === assistantId);
         if (idx === -1) return prev;
         const msg = prev[idx];
-        if (!msg.content) {
+        if (!msg.content && !pending.replacedContent) {
           // Empty bubble — drop it entirely.
           return prev.filter((m) => m.id !== assistantId);
         }
@@ -134,6 +135,7 @@ export function useChat(endpoint = '/_chat'): {
         next[idx] = {
           ...msg,
           isStreaming: false,
+          ...(pending.replacedContent !== undefined ? { content: pending.replacedContent } : {}),
           ...(pending.citations ? { citations: pending.citations } : {}),
           ...(pending.clarificationOptions
             ? { clarificationOptions: pending.clarificationOptions }
@@ -154,7 +156,7 @@ export function useChat(endpoint = '/_chat'): {
       // Citations + clarifications arrive instantly from the server but we
       // want them to appear only after the prose is finished revealing —
       // otherwise the badges/buttons render above text that hasn't been typed.
-      const pending: { citations?: Citation[]; clarificationOptions?: string[] } = {};
+      const pending: { citations?: Citation[]; clarificationOptions?: string[]; replacedContent?: string } = {};
 
       const pacer = createTextStreamPacer({
         reducedMotion,
@@ -210,6 +212,15 @@ export function useChat(endpoint = '/_chat'): {
                 pacer.enqueue(event.content || '');
                 break;
 
+              case 'text_replace':
+                // Server has finalized the markdown (e.g. rewrote slug links to
+                // absolute URLs). Buffer it here and apply at reveal-end so it
+                // doesn't snap mid-typing-animation. Brief artifact: between the
+                // last text chunk and reveal-end, the user sees the pre-rewrite
+                // markdown rendered with non-canonical URLs.
+                pending.replacedContent = event.content || '';
+                break;
+
               case 'citations':
                 pending.citations = event.sources;
                 break;
@@ -304,11 +315,18 @@ export function useChat(endpoint = '/_chat'): {
         ? '/docs/_chat'
         : endpoint;
 
+      // extractLanguageFromPath returns undefined for root-level paths (default
+      // language). We omit `locale` in that case rather than guessing — the server
+      // only filters when a locale is explicitly sent AND the per-project flag is
+      // on, so omitting is the correct "use whatever you have, no filter" signal
+      // that's safe across mid-rollout client deployments.
+      const locale = extractLanguageFromPath(window.location.pathname);
+
       try {
         const response = await fetch(chatUrl, {
           method: 'POST',
           headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ message: trimmed, history }),
+          body: JSON.stringify(locale ? { message: trimmed, history, locale } : { message: trimmed, history }),
           signal: controller.signal,
         });
 

package/vendored/lib/chat-prompt.ts

@@ -99,7 +99,7 @@ Rules:
 - Use markdown formatting, including code blocks with language hints when showing code.
 - Never make up information not in the context.
 - Pick one of exactly two response shapes, based on whether any page in the Documentation context below is relevant to the question:
-  (a) RELEVANT PAGE EXISTS → answer by referring to it with a markdown link (e.g., "See [Changelog](.../changelog) for recent releases."). Do NOT prefix with "I don't have information".
+  (a) RELEVANT PAGE EXISTS → answer by referring to it with a markdown link. The link's URL must be either the pageSlug (e.g. "See [OpenAPI Example](api-reference/openapi-example) for a live endpoint page.") OR the full URL from the URL: line of the cited chunk. The system rewrites both forms to the canonical absolute URL automatically. Never invent a URL or use a relative path like ./ or ../. Do NOT prefix with "I don't have information".
   (b) NO RELEVANT PAGE → respond with this exact sentence and stop: "I don't have information about that in the documentation." Do not add "However", "but", "you could try", or any follow-up suggestion after it. The reply ends at the period.
   WRONG: "I don't have information about that in the documentation. However, if you're asking about X, you could..." ← This is forbidden. If the first sentence is true, stop there.
 - Never name a page ("the Changelog", "the API reference", "the Settings page", etc.) unless that page appears in the Documentation context below.

package/vendored/lib/chat-tools.ts

@@ -64,6 +64,9 @@ export const ANSWER_TOOL: AnswerToolSchema = {
         type: 'string',
         description:
           'The answer in markdown. Use code blocks with language hints when showing code. ' +
+          'When linking to a documentation page, prefer the pageSlug (from the [pageSlug: ...] label) as the URL: ' +
+          '[Anchor Text](api-reference/openapi-example). The full URL from the URL: line also works. ' +
+          'The system rewrites either form to the canonical absolute URL after generation. ' +
           'Do not embed citation text like "[Page Title]" — citations are listed in cited_page_slugs.',
       },
       cited_page_slugs: {

package/vendored/lib/embedding-chunker.ts

@@ -6,6 +6,13 @@
  * first, then at sentence boundaries for oversized sections.
  */
 import { extractSections } from './static-artifacts.js';
+import {
+  deriveChunkLocale,
+  normalizeLanguageList,
+  type LanguageEntry,
+} from './locale-helpers.js';
+
+export { normalizeLanguageList };
 
 export interface EmbeddingChunk {
   /** Unique ID: `${pageSlug}#${sectionIndex}` */
@@ -25,6 +32,9 @@ export interface EmbeddingChunk {
   prefix: string;
   /** Page title from frontmatter, or slug-derived fallback */
   pageTitle: string;
+  /** Locale derived from i18n config + leading slug segment. `null` for
+   *  single-language projects (no `i18n.languages` configured). */
+  locale: string | null;
 }
 
 /**
@@ -200,16 +210,21 @@ function sanitizeHeadingText(raw: string): string {
  * Chunk a documentation page into embedding-sized pieces.
  *
  * @param page - Page with file path, raw MDX content, and frontmatter
- * @param maxChars - Maximum characters per chunk (default 2000, ~500 tokens)
+ * @param options - maxChars cap (default 2000, ~500 tokens) and i18n languages
+ *                  (used to derive each chunk's locale tag)
  * @returns Array of embedding chunks with unique IDs
  */
 export function chunkPageForEmbedding(
   page: { path: string; content: string; frontmatter: Record<string, unknown> },
-  maxChars = 2000,
+  options: { maxChars?: number; languages?: LanguageEntry[] } = {},
 ): EmbeddingChunk[] {
+  const maxChars = options.maxChars ?? 2000;
+  const languages = options.languages ?? [];
+
   const slug = page.path.replace(/\.mdx?$/, '').replace(/\\/g, '/');
   const rawTitle = (page.frontmatter.title as string) || titleFromSlug(slug);
   const pageTitle = sanitizeHeadingText(rawTitle) || titleFromSlug(slug);
+  const locale = deriveChunkLocale(page.path, languages);
 
   // Normalize Windows line endings before extracting sections
   const normalizedContent = preprocessUpdateBlocks(page.content.replace(/\r\n/g, '\n'));
@@ -238,6 +253,7 @@ export function chunkPageForEmbedding(
         content: piece,
         prefix,
         pageTitle,
+        locale,
       });
       chunkIndex++;
     }

package/vendored/lib/language-codes.json

@@ -0,0 +1,27 @@
+[
+  "en",
+  "cn", "zh", "zh-Hans", "zh-Hant",
+  "es",
+  "fr", "fr-CA", "fr-ca",
+  "ja", "jp", "ja-jp",
+  "pt", "pt-BR",
+  "de",
+  "ko",
+  "it",
+  "ru",
+  "ro",
+  "cs",
+  "id",
+  "ar",
+  "tr",
+  "hi",
+  "sv",
+  "no",
+  "lv",
+  "nl",
+  "uk",
+  "vi",
+  "pl",
+  "uz",
+  "he"
+]

package/vendored/lib/language-utils.ts

@@ -4,7 +4,16 @@
  * Provides display names, flag emojis, and helper functions for multi-language support.
  */
 
-import type { LanguageCode } from './docs-types';
+import type { LanguageCode, LanguageConfig } from './docs-types';
+import LANGUAGE_CODES_JSON from './language-codes.json';
+
+/**
+ * Canonical language code list, shared with the CJS build script via
+ * `lib/language-codes.json`. Updates to LANGUAGE_DISPLAY_NAMES below MUST
+ * also update language-codes.json. The sync test in
+ * __tests__/lib/language-codes-sync.test.ts catches drift.
+ */
+export const LANGUAGE_CODES = LANGUAGE_CODES_JSON as readonly LanguageCode[];
 
 /**
  * Display names for each supported language code
@@ -275,21 +284,81 @@ export function isValidLanguageCode(code: string): code is LanguageCode {
   return code in LANGUAGE_DISPLAY_NAMES;
 }
 
+/** Lowercase → canonical lookup, built once. Lets `extractLanguageFromPath`
+ *  match URL segments regardless of case (`/pt-br/...` returns `'pt-BR'`).
+ *  Vercel and some CDN configs serve mixed-case folder paths under
+ *  lowercased URLs, so a strict case-sensitive match silently breaks
+ *  every locale-aware feature on those URL forms.
+ *  First insertion wins — iteration order MUST match the CJS map in
+ *  `scripts/build-search-index.cjs`, so we iterate the shared JSON list
+ *  (single source of truth) instead of `LANGUAGE_DISPLAY_NAMES` keys. */
+const LANGUAGE_CODE_BY_LOWER: Map<string, LanguageCode> = (() => {
+  const m = new Map<string, LanguageCode>();
+  for (const k of LANGUAGE_CODES) {
+    const lower = k.toLowerCase();
+    if (!m.has(lower)) m.set(lower, k);
+  }
+  return m;
+})();
+
 /**
  * Extract language code from a pathname
  *
  * @param pathname - The URL pathname (e.g., '/es/introduction' or '/docs/es/introduction')
- * @returns The language code if found, undefined otherwise
+ * @returns The canonical-cased language code if found, undefined otherwise
  */
 export function extractLanguageFromPath(pathname: string): LanguageCode | undefined {
   // Remove /docs prefix if present (for backward compatibility)
   const parts = pathname.replace(/^\/docs\/?/, '').replace(/^\//, '').split('/').filter(Boolean);
 
-  if (parts.length > 0 && isValidLanguageCode(parts[0])) {
-    return parts[0] as LanguageCode;
-  }
+  if (parts.length === 0) return undefined;
+  return LANGUAGE_CODE_BY_LOWER.get(parts[0].toLowerCase());
+}
 
-  return undefined;
+/**
+ * Resolve the active locale from a pathname, gated by the project's declared
+ * language whitelist.
+ *
+ * Returns:
+ *   - `''` when the path has no language prefix, OR the prefix is not in the
+ *     project's `navigation.languages[].language` whitelist (e.g. `dodo/de/foo`
+ *     where dodo only declares `en`).
+ *   - The canonical language code when the prefix matches the whitelist.
+ *
+ * Use this — not `extractLanguageFromPath` directly — for any feature that
+ * filters by language (search, language selector). The whitelist prevents
+ * false-positives on directories named after language codes but not actually
+ * translations.
+ */
+export function resolveLocaleFromPath(
+  pathname: string,
+  projectLanguages: readonly string[],
+): string {
+  return resolveLocaleWithLoweredSet(pathname, buildLoweredLocaleSet(projectLanguages));
+}
+
+/**
+ * Build the lowercase whitelist Set used by `resolveLocaleWithLoweredSet`.
+ * Hoist this out of hot paths (build-time per-page loops, runtime per-keystroke)
+ * to avoid re-allocating on every call.
+ */
+export function buildLoweredLocaleSet(
+  projectLanguages: readonly string[],
+): ReadonlySet<string> {
+  return new Set(projectLanguages.map((l) => l.toLowerCase()));
+}
+
+/**
+ * Hot-path variant of `resolveLocaleFromPath`: caller supplies a pre-built
+ * lowered Set. Same semantics; avoids per-call Set construction.
+ */
+export function resolveLocaleWithLoweredSet(
+  pathname: string,
+  loweredLanguageSet: ReadonlySet<string>,
+): string {
+  const candidate = extractLanguageFromPath(pathname);
+  if (!candidate) return '';
+  return loweredLanguageSet.has(candidate.toLowerCase()) ? candidate : '';
 }
 
 /**
@@ -336,3 +405,26 @@ export function clearLanguagePreference(): void {
     // localStorage not available
   }
 }
+
+/**
+ * Resolve the active locale by priority:
+ *   1. The path-derived language from the middleware header
+ *   2. The project's default language from docs.json (`default: true`,
+ *      else first entry)
+ *   3. "en"
+ *
+ * Pure function — no I/O, no headers, no config-fetching. Designed to be
+ * called once from `app/layout.tsx` after both inputs are resolved.
+ */
+export function resolveLanguageWithFallback(
+  headerLang: LanguageCode | null,
+  configLanguages: LanguageConfig[] | undefined,
+): LanguageCode {
+  if (headerLang) return headerLang;
+  if (configLanguages && configLanguages.length > 0) {
+    const explicitDefault = configLanguages.find((l) => l.default)?.language;
+    if (explicitDefault) return explicitDefault;
+    return configLanguages[0].language;
+  }
+  return 'en';
+}

package/vendored/lib/link-rewriter.ts

@@ -0,0 +1,67 @@
+/**
+ * Markdown link rewriter for chat responses.
+ *
+ * Rewrites two forms to absolute URLs from a `pageSlug → absoluteUrl` map:
+ *
+ * 1. Bare-slug:    `[Anchor](api-reference/foo)`     → `[Anchor](https://x/docs/api-reference/foo)`
+ * 2. Absolute URL: `[Anchor](https://anything/.../api-reference/foo)` → canonical absolute URL
+ *
+ * Both forms are needed because Haiku at temp 0.3 produces a mix:
+ * - Sometimes copies the `URL:` line from chunk context verbatim (form 2, correct host)
+ * - Sometimes emits the pageSlug (form 1)
+ * - Sometimes hallucinates a host (form 2, wrong host) — the slug suffix still resolves
+ * - Sometimes lowercases the leading segment of mixed-case locale folders
+ *   (`pt-BR/foo` → `pt-br/foo`) — hence the lowercase lookup map.
+ *
+ * Streaming note: this is NOT streaming-safe. Apply ONLY to a complete markdown
+ * string (the final tool input). The chat route streams the raw markdown live
+ * for typing-effect UX, then sends a `text_replace` SSE event with the
+ * rewritten string at end-of-stream.
+ */
+
+const MARKDOWN_LINK_RE = /\[([^\]]+)\]\(([^)]+)\)/g;
+
+export function rewriteSlugLinks(
+  text: string,
+  slugToUrl: Record<string, string>,
+): string {
+  const lookup: Record<string, string> = {};
+  for (const [key, value] of Object.entries(slugToUrl)) lookup[key.toLowerCase()] = value;
+
+  return text.replace(MARKDOWN_LINK_RE, (full, anchor: string, url: string, offset: number) => {
+    // Skip image syntax (![alt](url)). A leading "!" turns the same bracket
+    // pattern into an image — rewriting it would point the <img src> at a docs
+    // page if the URL happens to match a known slug.
+    if (offset > 0 && text[offset - 1] === '!') return full;
+    const resolved = resolveSlugFromUrl(url, lookup);
+    return resolved ? `[${anchor}](${resolved})` : full;
+  });
+}
+
+function resolveSlugFromUrl(
+  url: string,
+  lookup: Record<string, string>,
+): string | null {
+  let path = url;
+  let hash = '';
+
+  if (/^https?:\/\//i.test(url)) {
+    try {
+      const parsed = new URL(url);
+      path = parsed.pathname;
+      hash = parsed.hash;
+    } catch {
+      return null;
+    }
+  } else {
+    const hashIdx = path.indexOf('#');
+    if (hashIdx !== -1) {
+      hash = path.slice(hashIdx);
+      path = path.slice(0, hashIdx);
+    }
+  }
+
+  path = path.replace(/^\.?\/+/, '').toLowerCase();
+  const hit = lookup[path] ?? lookup[path.replace(/^docs\//, '')];
+  return hit ? hit + hash : null;
+}

package/vendored/lib/locale-helpers.ts

@@ -0,0 +1,62 @@
+/**
+ * Locale helpers for AI chat embedding + retrieval.
+ *
+ * The chunker uses these at build time to tag each EmbeddingChunk with the
+ * locale derived from the file path (using the project's i18n config). The
+ * chat API uses the same shape at query time to filter Upstash Vector
+ * results to a single locale, preventing cross-language pollution.
+ */
+
+export interface LanguageEntry {
+  code: string;
+  isDefault: boolean;
+}
+
+interface RawLanguageEntry {
+  language: string;
+  default?: boolean;
+}
+
+/**
+ * Normalize the raw `navigation.languages` array into a stable, lowercased shape.
+ *
+ * - If no entry has `default: true`, the first entry is treated as default
+ *   (matches resolveLanguageWithFallback() in language-utils.ts).
+ * - Codes are lowercased so `pt-BR` from docs.json matches `pt-br/...` paths.
+ */
+export function normalizeLanguageList(
+  raw: RawLanguageEntry[] | undefined,
+): LanguageEntry[] {
+  if (!raw || raw.length === 0) return [];
+  const hasExplicitDefault = raw.some((l) => l.default === true);
+  return raw.map((l, i) => ({
+    code: l.language.toLowerCase(),
+    isDefault: hasExplicitDefault ? l.default === true : i === 0,
+  }));
+}
+
+/**
+ * Derive the locale for a chunk from its file path.
+ *
+ * Returns:
+ * - `null` when no i18n config is present (single-language project) — the
+ *   filter must NOT be applied to chunks with no locale metadata, and a
+ *   blanket "en" default would silently mislabel Spanish-only docs sites.
+ * - The matching language code when the leading path segment is in the
+ *   configured allowlist.
+ * - The configured default language code otherwise.
+ *
+ * Critically, ONLY exact membership in the configured language list counts.
+ * Two-letter folders like `ai/`, `cn/`, `ui/`, `snippets/` are NOT treated as
+ * locales unless they are explicitly listed in `navigation.languages`.
+ */
+export function deriveChunkLocale(
+  filePath: string,
+  languages: LanguageEntry[],
+): string | null {
+  if (languages.length === 0) return null;
+  const defaultCode = languages.find((l) => l.isDefault)?.code ?? languages[0].code;
+  const firstSegment = filePath.replace(/\\/g, '/').split('/')[0].toLowerCase();
+  const match = languages.find((l) => l.code === firstSegment);
+  return match ? match.code : defaultCode;
+}