@takazudo/zudo-doc 5.14.0 → 5.16.0

package/dist/mdx-components/index.js

@@ -128,7 +128,10 @@ function makeEnlargeableParagraph(imageEnlarge, ContentImg, assetOptions) {
                       href: assetViewerHref({
                         base: assetOptions.base,
                         routePrefix: assetOptions.routePrefix,
-                        path: imageEntry.path
+                        path: imageEntry.path,
+                        locale: assetOptions.isDefaultLocaleOnlyPath?.(
+                          `/${assetOptions.routePrefix}/${imageEntry.path}`
+                        ) ? void 0 : assetOptions.locale
                       }),
                       children: `\u2922 Open asset page${dimensions}`
                     },
@@ -160,6 +163,8 @@ function createMdxComponents(options) {
   const {
     settings,
     assetManifest = null,
+    assetViewerLocale,
+    isDefaultLocaleOnlyPath,
     locale,
     currentVersion,
     currentSlug,
@@ -176,6 +181,8 @@ function createMdxComponents(options) {
       base: settings.base,
       dir: assetDir,
       routePrefix: assetRoutePrefix,
+      locale: assetViewerLocale,
+      isDefaultLocaleOnlyPath,
       manifest: assetManifest
     }
   );
@@ -183,7 +190,9 @@ function createMdxComponents(options) {
     base: settings.base,
     assetManifest,
     routePrefix: assetRoutePrefix,
-    dir: assetDir
+    dir: assetDir,
+    locale: assetViewerLocale,
+    isDefaultLocaleOnlyPath
   }) : defaultComponents.a;
   const CategoryNavBound = (props) => navData.CategoryNav({ ...props, lang: locale, currentVersion });
   const CategoryTreeNavBound = (props) => navData.CategoryTreeNav({ ...props, lang: locale, currentVersion });

package/dist/nav-indexing/versions-page-content.js

@@ -3,7 +3,7 @@ import { ChevronRight } from "../icons/index.js";
 function VersionsPageContent(props) {
   const { latestHref, versions, labels } = props;
   return /* @__PURE__ */ jsxs(Fragment, { children: [
-    /* @__PURE__ */ jsx("h1", { class: "text-heading font-bold mb-vsp-lg", children: labels.pageTitle }),
+    /* @__PURE__ */ jsx("h1", { class: "text-heading font-bold mb-vsp-lg break-words", children: labels.pageTitle }),
     /* @__PURE__ */ jsxs("section", { class: "mb-vsp-xl", children: [
       /* @__PURE__ */ jsx("h2", { class: "text-title font-bold mb-vsp-xs", children: labels.latestTitle }),
       /* @__PURE__ */ jsx("p", { class: "text-small text-muted mb-vsp-sm", children: labels.latestDescription }),

package/dist/plugins/claude-resources.js

@@ -13,17 +13,31 @@ const plugin = {
     const projectRootOpt = ctx.options["projectRoot"];
     const scanRootOpt = ctx.options["scanRoot"];
     const docsDirOpt = ctx.options["docsDir"];
+    const localesOpt = ctx.options["locales"];
+    const defaultLocaleOpt = ctx.options["defaultLocale"];
+    const translationsOpt = ctx.options["translations"];
+    const defaultLocaleOnlyPrefixesOpt = ctx.options["defaultLocaleOnlyPrefixes"];
     const result = await runClaudeResourcesPreStep({
       claudeDir,
       projectRoot: typeof projectRootOpt === "string" ? projectRootOpt : ctx.projectRoot,
       scanRoot: typeof scanRootOpt === "string" ? scanRootOpt : void 0,
-      docsDir: typeof docsDirOpt === "string" ? docsDirOpt : "src/content/docs"
+      docsDir: typeof docsDirOpt === "string" ? docsDirOpt : "src/content/docs",
+      locales: isRecord(localesOpt) ? localesOpt : void 0,
+      defaultLocale: typeof defaultLocaleOpt === "string" ? defaultLocaleOpt : void 0,
+      translations: isRecord(translationsOpt) ? translationsOpt : void 0,
+      defaultLocaleOnlyPrefixes: isStringArray(defaultLocaleOnlyPrefixesOpt) ? defaultLocaleOnlyPrefixesOpt : void 0
     });
     ctx.logger.info(
       `claude-resources: ${result.claudemd} CLAUDE.md, ${result.commands} commands, ${result.skills} skills, ${result.agents} agents`
     );
   }
 };
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
 var claude_resources_default = plugin;
 export {
   claude_resources_default as default,

package/dist/plugins/codex-resources.js

@@ -13,17 +13,31 @@ const plugin = {
     const projectRootOpt = ctx.options["projectRoot"];
     const scanRootOpt = ctx.options["scanRoot"];
     const docsDirOpt = ctx.options["docsDir"];
+    const localesOpt = ctx.options["locales"];
+    const defaultLocaleOpt = ctx.options["defaultLocale"];
+    const translationsOpt = ctx.options["translations"];
+    const defaultLocaleOnlyPrefixesOpt = ctx.options["defaultLocaleOnlyPrefixes"];
     const result = runCodexResourcesPreStep({
       codexDir,
       projectRoot: typeof projectRootOpt === "string" ? projectRootOpt : ctx.projectRoot,
       scanRoot: typeof scanRootOpt === "string" ? scanRootOpt : void 0,
-      docsDir: typeof docsDirOpt === "string" ? docsDirOpt : "src/content/docs"
+      docsDir: typeof docsDirOpt === "string" ? docsDirOpt : "src/content/docs",
+      locales: isRecord(localesOpt) ? localesOpt : void 0,
+      defaultLocale: typeof defaultLocaleOpt === "string" ? defaultLocaleOpt : void 0,
+      translations: isRecord(translationsOpt) ? translationsOpt : void 0,
+      defaultLocaleOnlyPrefixes: isStringArray(defaultLocaleOnlyPrefixesOpt) ? defaultLocaleOnlyPrefixesOpt : void 0
     });
     ctx.logger.info(
       `codex-resources: ${result.agentsMd} AGENTS.md, ${result.config} config, ${result.agents} agents, ${result.hooks} hooks, ${result.rules} rules, ${result.skills} skills`
     );
   }
 };
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
 var codex_resources_default = plugin;
 export {
   codex_resources_default as default,

package/dist/plugins/internal/asset-viewer/asset-pages.d.ts

@@ -0,0 +1,53 @@
+import type { AssetViewerIndexingConfig } from "../../../settings.js";
+/** The serialized asset-viewer settings shared by index consumers. */
+export interface AssetScanProjection {
+    assetViewer: boolean;
+    assetViewerIndexing: AssetViewerIndexingConfig | false;
+    assetViewerDir: string;
+    assetViewerRoutePrefix: string;
+    assetViewerExclude: readonly string[];
+    base: string;
+    /** Non-default locales, keyed by locale code. */
+    locales: Record<string, {
+        dir?: string;
+    }>;
+    /** Route prefixes whose generated pages exist only in the default locale. */
+    defaultLocaleOnlyPrefixes: readonly string[];
+}
+/** The asset-page output currently supported by a consumer. */
+export type AssetIndexConsumer = keyof AssetViewerIndexingConfig;
+/** Minimal normalized descriptor consumed by search, llms.txt, and sitemap. */
+export interface AssetPageDescriptor {
+    /** NFC-normalized POSIX path relative to `assetViewerDir`. */
+    path: string;
+    /** Base-prefixed, trailing-slashed generated asset-viewer URL. */
+    url: string;
+    /** Non-default locale segment; omitted for the default locale. */
+    locale?: string;
+    /** Whether the asset has a text-like extension understood by the viewer. */
+    isText: boolean;
+    /** Current byte size of the public asset. */
+    size: number;
+}
+export interface AssetPageDescriptorOptions {
+    /** Runtime project root injected by the zfb plugin wrapper. */
+    projectRoot: string;
+    /** Serialized projection from `zudoDocPreset()`. */
+    assetScan?: AssetScanProjection;
+    /** The output whose explicit indexing gate must be enabled. */
+    consumer: AssetIndexConsumer;
+}
+/**
+ * Scan the public asset directory and materialize one descriptor per emitted
+ * asset page. The default-locale descriptor is emitted first, followed by
+ * configured locales in object iteration order. Every descriptor URL is
+ * minted by `assetViewerHref()` so encoding, base, and trailing-slash rules
+ * cannot diverge between consumers.
+ *
+ * The descriptor path is intentionally synchronous. Search and llms.txt are
+ * synchronous build/dev paths, and `connect-adapter.ts` does not await a
+ * middleware's returned promise. Callers must pass the runtime `projectRoot`
+ * supplied by the plugin wrapper; it is never part of the serialized preset
+ * projection.
+ */
+export declare function collectAssetPageDescriptors(options: AssetPageDescriptorOptions): AssetPageDescriptor[];

package/dist/plugins/internal/asset-viewer/asset-pages.js

@@ -0,0 +1,98 @@
+import { closeSync, openSync, readSync, statSync } from "node:fs";
+import { extname, resolve } from "node:path";
+import { assetViewerHref } from "../../../asset-path/index.js";
+import { scanAssetsSync } from "./scan.js";
+const TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
+  "js",
+  "ts",
+  "tsx",
+  "jsx",
+  "mjs",
+  "cjs",
+  "json",
+  "yaml",
+  "yml",
+  "toml",
+  "css",
+  "scss",
+  "html",
+  "md",
+  "mdx",
+  "sh",
+  "bash",
+  "py",
+  "rb",
+  "go",
+  "rs",
+  "java",
+  "kt",
+  "swift",
+  "c",
+  "h",
+  "cpp",
+  "hpp",
+  "cs",
+  "php",
+  "sql",
+  "xml",
+  "txt",
+  "log",
+  "csv",
+  "tsv",
+  "env",
+  "conf",
+  "ini"
+]);
+function hasBinaryPrefix(absPath) {
+  const fd = openSync(absPath, "r");
+  try {
+    const sample = Buffer.allocUnsafe(8 * 1024);
+    const bytesRead = readSync(fd, sample, 0, sample.length, 0);
+    return sample.subarray(0, bytesRead).includes(0);
+  } finally {
+    closeSync(fd);
+  }
+}
+function isTextAsset(absPath, path) {
+  const extension = extname(path).slice(1).toLowerCase();
+  if (extension.length !== 0 && !TEXT_EXTENSIONS.has(extension)) return false;
+  return !hasBinaryPrefix(absPath);
+}
+function isDefaultLocaleOnlyAsset(routePrefix, path, prefixes) {
+  const routePath = assetViewerHref({ base: "/", routePrefix, path });
+  return prefixes.some((prefix) => routePath.startsWith(prefix));
+}
+function hasConsumerGate(assetScan, consumer) {
+  const indexing = assetScan.assetViewerIndexing;
+  return assetScan.assetViewer === true && indexing !== false && typeof indexing === "object" && indexing !== null && indexing[consumer] === true;
+}
+function collectAssetPageDescriptors(options) {
+  const { projectRoot, assetScan, consumer } = options;
+  if (assetScan === void 0 || !hasConsumerGate(assetScan, consumer)) return [];
+  const dir = assetScan.assetViewerDir;
+  const routePrefix = assetScan.assetViewerRoutePrefix;
+  const base = assetScan.base;
+  const exclude = assetScan.assetViewerExclude ?? [];
+  const paths = scanAssetsSync(projectRoot, dir, exclude);
+  const assetRoot = resolve(projectRoot, "public", dir);
+  const descriptorFor = (path, locale) => ({
+    path,
+    url: assetViewerHref({ base, routePrefix, path, ...locale === void 0 ? {} : { locale } }),
+    ...locale === void 0 ? {} : { locale },
+    isText: isTextAsset(resolve(assetRoot, path), path),
+    size: statSync(resolve(assetRoot, path)).size
+  });
+  const descriptors = paths.map((path) => descriptorFor(path));
+  for (const locale of Object.keys(assetScan.locales ?? {})) {
+    for (const path of paths) {
+      if (isDefaultLocaleOnlyAsset(routePrefix, path, assetScan.defaultLocaleOnlyPrefixes ?? [])) {
+        continue;
+      }
+      descriptors.push(descriptorFor(path, locale));
+    }
+  }
+  return descriptors;
+}
+export {
+  collectAssetPageDescriptors
+};

package/dist/plugins/internal/asset-viewer/scan.d.ts

@@ -1,2 +1,19 @@
-/** Recursively enumerate safe, public assets in deterministic path order. */
+/**
+ * Recursively enumerate safe, public assets in deterministic path order.
+ *
+ * This synchronous implementation is the canonical walk. Search and llms.txt
+ * build/dev consumers are synchronous, while the routes setup hook already
+ * exposes an async `scanAssets()` contract. Keeping one walk here gives both
+ * boundaries identical symlink, exclusion, and collision behavior.
+ */
+export declare function scanAssetsSync(projectRoot: string, dir: string, exclude?: readonly string[]): string[];
+/**
+ * Async-compatible asset scan used by the routes setup hook.
+ *
+ * The route plugin's public lifecycle contract is async, but its scan itself
+ * is only filesystem enumeration. Delegating to the canonical sync walk keeps
+ * it behaviorally identical to `scanAssetsSync()` without introducing a
+ * second implementation (or a promise that synchronous middleware cannot
+ * consume).
+ */
 export declare function scanAssets(projectRoot: string, dir: string, exclude?: readonly string[]): Promise<string[]>;

package/dist/plugins/internal/asset-viewer/scan.js

@@ -1,11 +1,27 @@
-import { readdir, realpath, stat } from "node:fs/promises";
+import { readdirSync, realpathSync, statSync } from "node:fs";
 import { basename, relative, resolve, sep } from "node:path";
 import { matchExclude, normalizeAssetPath } from "../../../asset-path/index.js";
 function isWithin(root, candidate) {
   const rel = relative(root, candidate);
   return rel === "" || !rel.startsWith(`..${sep}`) && rel !== "..";
 }
-async function scanAssets(projectRoot, dir, exclude = []) {
+function finishScan(paths) {
+  paths.sort((a, b) => a.localeCompare(b, "en"));
+  const folded = /* @__PURE__ */ new Map();
+  for (const path of paths) {
+    const key = path.toLocaleLowerCase("en-US");
+    const existing = folded.get(key);
+    if (existing !== void 0) {
+      throw new Error(`[asset-viewer] case-insensitive or Unicode-normalized URL collision: ${existing} and ${path}`);
+    }
+    folded.set(key, path);
+    if (path === "client" || path.startsWith("client/")) {
+      console.warn(`[asset-viewer] reserved client/ asset path: ${path}`);
+    }
+  }
+  return paths;
+}
+function scanAssetsSync(projectRoot, dir, exclude = []) {
   const publicRoot = resolve(projectRoot, "public");
   const assetRoot = resolve(publicRoot, dir);
   if (!isWithin(publicRoot, assetRoot)) {
@@ -13,8 +29,8 @@ async function scanAssets(projectRoot, dir, exclude = []) {
   }
   let canonicalRoot;
   try {
-    const canonicalPublicRoot = await realpath(publicRoot);
-    canonicalRoot = await realpath(assetRoot);
+    const canonicalPublicRoot = realpathSync(publicRoot);
+    canonicalRoot = realpathSync(assetRoot);
     if (!isWithin(canonicalPublicRoot, canonicalRoot)) {
       throw new Error(`[asset-viewer] asset directory symlink escapes public/: ${dir}`);
     }
@@ -23,29 +39,29 @@ async function scanAssets(projectRoot, dir, exclude = []) {
     throw error;
   }
   const paths = [];
-  async function walk(absDir, relDir, canonicalAncestors) {
-    const canonicalDir = await realpath(absDir);
+  function walk(absDir, relDir, canonicalAncestors) {
+    const canonicalDir = realpathSync(absDir);
     if (!isWithin(canonicalRoot, canonicalDir)) {
       throw new Error(`[asset-viewer] symlink escapes public/${dir}: ${relDir || basename(absDir)}`);
     }
     if (canonicalAncestors.has(canonicalDir)) return;
     const nextAncestors = new Set(canonicalAncestors).add(canonicalDir);
-    const entries = await readdir(absDir, { withFileTypes: true });
+    const entries = readdirSync(absDir, { withFileTypes: true });
     entries.sort((a, b) => a.name.localeCompare(b.name, "en"));
     for (const entry of entries) {
       if (entry.name.startsWith(".")) continue;
       const relPath = relDir ? `${relDir}/${entry.name}` : entry.name;
       if (entry.name.endsWith(".meta.json")) continue;
       const absPath = resolve(absDir, entry.name);
-      const canonical = await realpath(absPath);
+      const canonical = realpathSync(absPath);
       if (!isWithin(canonicalRoot, canonical)) {
         throw new Error(`[asset-viewer] symlink escapes public/${dir}: ${relPath}`);
       }
       if (entry.isDirectory()) {
-        await walk(absPath, relPath, nextAncestors);
+        walk(absPath, relPath, nextAncestors);
       } else if (entry.isSymbolicLink()) {
-        const target = await stat(canonical);
-        if (target.isDirectory()) await walk(absPath, relPath, nextAncestors);
+        const target = statSync(canonical);
+        if (target.isDirectory()) walk(absPath, relPath, nextAncestors);
         else {
           const path = normalizeAssetPath(relPath);
           if (!matchExclude(path, exclude)) paths.push(path);
@@ -56,22 +72,13 @@ async function scanAssets(projectRoot, dir, exclude = []) {
       }
     }
   }
-  await walk(assetRoot, "", /* @__PURE__ */ new Set());
-  paths.sort((a, b) => a.localeCompare(b, "en"));
-  const folded = /* @__PURE__ */ new Map();
-  for (const path of paths) {
-    const key = path.toLocaleLowerCase("en-US");
-    const existing = folded.get(key);
-    if (existing !== void 0) {
-      throw new Error(`[asset-viewer] case-insensitive or Unicode-normalized URL collision: ${existing} and ${path}`);
-    }
-    folded.set(key, path);
-    if (path === "client" || path.startsWith("client/")) {
-      console.warn(`[asset-viewer] reserved client/ asset path: ${path}`);
-    }
-  }
-  return paths;
+  walk(assetRoot, "", /* @__PURE__ */ new Set());
+  return finishScan(paths);
+}
+async function scanAssets(projectRoot, dir, exclude = []) {
+  return scanAssetsSync(projectRoot, dir, exclude);
 }
 export {
-  scanAssets
+  scanAssets,
+  scanAssetsSync
 };

package/dist/plugins/internal/claude-resources/generate.d.ts

@@ -1,3 +1,4 @@
+import { type ResourceLocaleConfig, type ResourceTranslations } from "../resource-docs-shared/index.js";
 export interface ClaudeResourcesConfig {
     claudeDir: string;
     /**
@@ -13,6 +14,14 @@ export interface ClaudeResourcesConfig {
      */
     scanRoot?: string;
     docsDir: string;
+    /** Additional locale content roots, resolved by the runner when possible. */
+    locales?: Record<string, ResourceLocaleConfig>;
+    /** Default locale code (the unprefixed docs directory). */
+    defaultLocale?: string;
+    /** UI-string translation table used by localized generated indexes. */
+    translations?: ResourceTranslations;
+    /** Route prefixes that must not receive non-default-locale indexes. */
+    defaultLocaleOnlyPrefixes?: string[];
 }
 export declare function generateClaudeResourcesDocs(config: ClaudeResourcesConfig): {
     claudemd: number;

package/dist/plugins/internal/claude-resources/generate.js

@@ -8,10 +8,38 @@ import {
   escapeForMdx,
   escapeTitle,
   findNamedFiles,
+  formatFrontmatterString,
   generateSkillsCategory,
   parseFrontmatter,
-  writeCategoryIndex
+  removeGeneratedIndex,
+  resolveLocaleDirs,
+  resolveResourceLabel,
+  shouldEmitResourceLocaleRoute,
+  writeCategoryIndex,
+  writeGeneratedIndex
 } from "../resource-docs-shared/index.js";
+const DEFAULT_RESOURCE_LOCALE = "en";
+function resourceLabel(config, locale, key, fallbackLiteral) {
+  return resolveResourceLabel({
+    translations: config.translations,
+    locale,
+    defaultLocale: config.defaultLocale,
+    key,
+    fallbackLiteral
+  });
+}
+function defaultResourceLabel(config, key, fallbackLiteral) {
+  return resourceLabel(
+    config,
+    config.defaultLocale ?? DEFAULT_RESOURCE_LOCALE,
+    key,
+    fallbackLiteral
+  );
+}
+function formatClaudeFrontmatterString(value) {
+  const formatted = formatFrontmatterString(value);
+  return formatted === value ? JSON.stringify(value) : formatted;
+}
 function generateClaudemdDocs(config) {
   const projectRoot = config.projectRoot ?? config.claudeDir;
   const scanRoot = config.scanRoot ?? projectRoot;
@@ -66,7 +94,16 @@ ${escapeForMdx(downgradeRepoRelativeLinks(content.trim()))}
 `;
     fs.writeFileSync(path.join(outputDir, `${item.slug}.mdx`), mdx);
   });
-  writeCategoryIndex(outputDir, "CLAUDE.md", 900, "Project-specific instructions");
+  writeCategoryIndex(
+    outputDir,
+    defaultResourceLabel(config, "resource.claudeMd.label", "CLAUDE.md"),
+    900,
+    defaultResourceLabel(
+      config,
+      "resource.claudeMd.description",
+      "Project-specific instructions"
+    )
+  );
   return items;
 }
 function generateCommandsDocs(config) {
@@ -101,16 +138,29 @@ ${escapeForMdx(parsed.content.trim())}
     fs.writeFileSync(path.join(outputDir, `${name}.mdx`), mdx);
   }
   items.sort((a, b) => a.name.localeCompare(b.name));
-  writeCategoryIndex(outputDir, "Commands", 901, "Custom slash commands");
+  writeCategoryIndex(
+    outputDir,
+    defaultResourceLabel(config, "resource.claudeCommands.label", "Commands"),
+    901,
+    defaultResourceLabel(
+      config,
+      "resource.claudeCommands.description",
+      "Custom slash commands"
+    )
+  );
   return items;
 }
 function generateSkillsDocs(config) {
   return generateSkillsCategory({
     skillsDirs: [path.join(config.claudeDir, "skills")],
     outputDir: path.join(config.docsDir, "claude-skills"),
-    label: "Skills",
+    label: defaultResourceLabel(config, "resource.claudeSkills.label", "Skills"),
     position: 902,
-    description: "Skill packages",
+    description: defaultResourceLabel(
+      config,
+      "resource.claudeSkills.description",
+      "Skill packages"
+    ),
     sourceLabel: ".claude/skills"
   });
 }
@@ -151,7 +201,16 @@ ${escapeForMdx(parsed.content.trim())}
     fs.writeFileSync(path.join(outputDir, `${fileSlug}.mdx`), mdx);
   }
   items.sort((a, b) => a.name.localeCompare(b.name));
-  writeCategoryIndex(outputDir, "Agents", 903, "Custom subagents");
+  writeCategoryIndex(
+    outputDir,
+    defaultResourceLabel(config, "resource.claudeAgents.label", "Agents"),
+    903,
+    defaultResourceLabel(
+      config,
+      "resource.claudeAgents.description",
+      "Custom subagents"
+    )
+  );
   return items;
 }
 function generateOverviewIndex(config, {
@@ -168,26 +227,137 @@ function generateOverviewIndex(config, {
   if (hasSkills) categorySlugs.push("claude-skills");
   if (hasAgents) categorySlugs.push("claude-agents");
   if (hasCommands) categorySlugs.push("claude-commands");
-  const categoriesAttr = JSON.stringify(categorySlugs);
-  const index = `---
-title: "Claude"
-description: "Claude Code configuration reference."
+  const index = renderOverviewIndex(
+    config,
+    config.defaultLocale ?? DEFAULT_RESOURCE_LOCALE,
+    categorySlugs
+  );
+  fs.writeFileSync(path.join(outputDir, "index.mdx"), index);
+  for (const [locale, localeConfig] of Object.entries(config.locales ?? {})) {
+    emitLocaleCategoryIndexes(config, locale, localeConfig.dir, {
+      hasCommands,
+      hasSkills,
+      hasAgents,
+      hasClaudemd
+    });
+    const overviewPath = path.join(localeConfig.dir, "claude", "index.mdx");
+    if (shouldEmitResourceLocaleRoute({
+      slug: "claude",
+      locale,
+      defaultLocale: config.defaultLocale,
+      defaultLocaleOnlyPrefixes: config.defaultLocaleOnlyPrefixes
+    })) {
+      writeGeneratedIndex(
+        overviewPath,
+        renderOverviewIndex(config, locale, categorySlugs)
+      );
+    } else {
+      removeGeneratedIndex(overviewPath);
+    }
+  }
+}
+function renderOverviewIndex(config, locale, categorySlugs) {
+  return `---
+title: ${formatClaudeFrontmatterString(resourceLabel(config, locale, "resource.claude.title", "Claude"))}
+description: ${formatClaudeFrontmatterString(resourceLabel(
+    config,
+    locale,
+    "resource.claude.description",
+    "Claude Code configuration reference."
+  ))}
 sidebar_position: 899
 generated: true
 ---
 
-## Resources
+## ${escapeForMdx(resourceLabel(config, locale, "resource.resources", "Resources"))}
 
-<CategoryNav categories={${categoriesAttr}} />
+<CategoryNav categories={${JSON.stringify(categorySlugs)}} />
 `;
-  fs.writeFileSync(path.join(outputDir, "index.mdx"), index);
+}
+function emitLocaleCategoryIndexes(config, locale, localeDir, presence) {
+  writeLocaleCategoryIndex(
+    config,
+    locale,
+    localeDir,
+    "claude-md",
+    presence.hasClaudemd,
+    "resource.claudeMd.label",
+    "CLAUDE.md",
+    900,
+    "resource.claudeMd.description",
+    "Project-specific instructions"
+  );
+  writeLocaleCategoryIndex(
+    config,
+    locale,
+    localeDir,
+    "claude-commands",
+    presence.hasCommands,
+    "resource.claudeCommands.label",
+    "Commands",
+    901,
+    "resource.claudeCommands.description",
+    "Custom slash commands"
+  );
+  writeLocaleCategoryIndex(
+    config,
+    locale,
+    localeDir,
+    "claude-skills",
+    presence.hasSkills,
+    "resource.claudeSkills.label",
+    "Skills",
+    902,
+    "resource.claudeSkills.description",
+    "Skill packages"
+  );
+  writeLocaleCategoryIndex(
+    config,
+    locale,
+    localeDir,
+    "claude-agents",
+    presence.hasAgents,
+    "resource.claudeAgents.label",
+    "Agents",
+    903,
+    "resource.claudeAgents.description",
+    "Custom subagents"
+  );
+}
+function writeLocaleCategoryIndex(config, locale, localeDir, categoryDir, present, labelKey, fallbackLabel, position, descriptionKey, fallbackDescription) {
+  const indexPath = path.join(localeDir, categoryDir, "index.mdx");
+  if (!present || !shouldEmitResourceLocaleRoute({
+    slug: categoryDir,
+    locale,
+    defaultLocale: config.defaultLocale,
+    defaultLocaleOnlyPrefixes: config.defaultLocaleOnlyPrefixes
+  })) {
+    removeGeneratedIndex(indexPath);
+    return;
+  }
+  writeCategoryIndex(
+    path.join(localeDir, categoryDir),
+    resourceLabel(config, locale, labelKey, fallbackLabel),
+    position,
+    resourceLabel(config, locale, descriptionKey, fallbackDescription),
+    formatClaudeFrontmatterString,
+    writeGeneratedIndex
+  );
 }
 function generateClaudeResourcesDocs(config) {
-  const claudemds = generateClaudemdDocs(config);
-  const commands = generateCommandsDocs(config);
-  const skills = generateSkillsDocs(config);
-  const agents = generateAgentsDocs(config);
-  generateOverviewIndex(config, {
+  const normalizedConfig = config.locales === void 0 ? config : {
+    ...config,
+    locales: resolveLocaleDirs({
+      projectRoot: path.resolve(config.projectRoot ?? config.claudeDir),
+      docsDir: config.docsDir,
+      locales: config.locales
+    })
+  };
+  const claudemds = generateClaudemdDocs(normalizedConfig);
+  const commands = generateCommandsDocs(normalizedConfig);
+  const skills = generateSkillsDocs(normalizedConfig);
+  const agents = generateAgentsDocs(normalizedConfig);
+  generateOverviewIndex(normalizedConfig, {
     hasClaudemd: claudemds.length > 0,
     hasCommands: commands.length > 0,
     hasSkills: skills.length > 0,