@takazudo/zudo-doc 0.1.0

package/dist/integrations/llms-txt/load.js

@@ -0,0 +1,83 @@
+import { readFileSync, readdirSync } from "node:fs";
+import { join, relative, resolve } from "node:path";
+import matter from "gray-matter";
+import { stripImportsAndJsx, stripMarkdown } from "./strip.js";
+function collectMdFiles(dir) {
+  const results = [];
+  function walk(currentDir, baseDir) {
+    let entries;
+    try {
+      entries = readdirSync(currentDir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        walk(fullPath, baseDir);
+      } else if (/\.mdx?$/.test(entry.name) && !entry.name.startsWith("_")) {
+        const rel = relative(baseDir, fullPath).replace(/\.mdx?$/, "").replace(/\/index$/, "");
+        results.push({ filePath: fullPath, slug: rel });
+      }
+    }
+  }
+  walk(dir, dir);
+  return results;
+}
+function slugToUrl(slug, locale, base, siteUrl) {
+  const trimmedBase = base.replace(/\/$/, "");
+  const path = locale ? `${trimmedBase}/${locale}/docs/${slug}` : `${trimmedBase}/docs/${slug}`;
+  if (siteUrl) {
+    return `${siteUrl.replace(/\/$/, "")}${path}`;
+  }
+  return path;
+}
+function isExcluded(data) {
+  return Boolean(data.search_exclude || data.draft || data.unlisted);
+}
+function parseMarkdownFile(filePath) {
+  try {
+    const raw = readFileSync(filePath, "utf-8");
+    const parsed = matter(raw);
+    return { data: parsed.data, content: parsed.content };
+  } catch {
+    return null;
+  }
+}
+function loadDocEntries(options) {
+  const { contentDir, locale, base, siteUrl } = options;
+  const absDir = resolve(contentDir);
+  const files = collectMdFiles(absDir);
+  const entries = [];
+  for (const { filePath, slug } of files) {
+    const parsed = parseMarkdownFile(filePath);
+    if (!parsed) continue;
+    const { data, content } = parsed;
+    if (isExcluded(data)) continue;
+    let description = data.description ?? "";
+    if (!description) {
+      const stripped = stripMarkdown(content);
+      description = stripped.split("\n").find((l) => l.trim().length > 0) ?? "";
+    }
+    entries.push({
+      title: data.title ?? slug,
+      description,
+      url: slugToUrl(slug, locale, base, siteUrl),
+      content: stripImportsAndJsx(content),
+      sidebarPosition: data.sidebar_position
+    });
+  }
+  entries.sort((a, b) => {
+    const posA = a.sidebarPosition ?? Number.MAX_SAFE_INTEGER;
+    const posB = b.sidebarPosition ?? Number.MAX_SAFE_INTEGER;
+    return posA - posB;
+  });
+  return entries;
+}
+export {
+  collectMdFiles,
+  isExcluded,
+  loadDocEntries,
+  parseMarkdownFile,
+  slugToUrl
+};

package/dist/integrations/llms-txt/strip.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Markdown / JSX text-stripping helpers.
+ *
+ * The two functions below match the legacy Astro emitter's behaviour
+ * byte-for-byte. Any change here is a behaviour change and must be
+ * reflected in the byte-equality fixture corpus.
+ */
+/**
+ * Strip imports, exports, and HTML/JSX tags from MDX/MD content while
+ * keeping the prose layout (headings, lists, blockquotes) intact for
+ * LLM consumption. Used by `llms-full.txt`.
+ */
+declare function stripImportsAndJsx(content: string): string;
+/**
+ * Strip markdown formatting and produce plain prose. Used to derive a
+ * fallback `description` from the body when frontmatter doesn't carry
+ * one. The regex sequence matches the legacy `stripMarkdown` helper in
+ * `src/utils/content-files.ts` — keep them in sync.
+ */
+declare function stripMarkdown(md: string): string;
+
+export { stripImportsAndJsx, stripMarkdown };

package/dist/integrations/llms-txt/strip.js

@@ -0,0 +1,10 @@
+function stripImportsAndJsx(content) {
+  return content.replace(/^import\s+.*$/gm, "").replace(/^export\s+.*$/gm, "").replace(/<\/?[a-zA-Z][a-zA-Z0-9]*[^>]*>/g, "").replace(/\n{3,}/g, "\n\n").trim();
+}
+function stripMarkdown(md) {
+  return md.replace(/```[\s\S]*?```/g, "").replace(/`[^`]+`/g, "").replace(/<[^>]+>/g, "").replace(/^#{1,6}\s+/gm, "").replace(/\*{1,3}([^*]+)\*{1,3}/g, "$1").replace(/_{1,3}([^_]+)_{1,3}/g, "$1").replace(/!\[[^\]]*\]\([^)]+\)/g, "").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/^>\s+/gm, "").replace(/^[-*_]{3,}\s*$/gm, "").replace(/^[\s]*[-*+]\s+/gm, "").replace(/^[\s]*\d+\.\s+/gm, "").replace(/^import\s+.*$/gm, "").replace(/^export\s+.*$/gm, "").replace(/\n{3,}/g, "\n\n").trim();
+}
+export {
+  stripImportsAndJsx,
+  stripMarkdown
+};

package/dist/integrations/llms-txt/types.d.ts

@@ -0,0 +1,145 @@
+/**
+ * Public types for the framework-agnostic llms-txt build emitter.
+ *
+ * The shapes here are deliberately decoupled from `astro:content` and
+ * Astro's `AstroIntegration` API so the emitter can run on top of any
+ * pipeline that exposes a `dist/` output directory and a list of
+ * markdown content roots — Astro today, zfb tomorrow, plain Node tooling
+ * in a unit test, etc.
+ */
+/**
+ * Frontmatter fields the loader reads off of each MDX/MD file. Callers
+ * are free to extend this; unrecognised fields are ignored.
+ */
+interface LlmsTxtFrontmatter {
+    title?: string;
+    description?: string;
+    sidebar_position?: number;
+    draft?: boolean;
+    unlisted?: boolean;
+    /**
+     * `true` when the page is excluded from search and llms.txt indexing.
+     * Mirrors the `search_exclude` flag used by the existing project.
+     */
+    search_exclude?: boolean;
+    [key: string]: unknown;
+}
+/**
+ * One entry in the generated llms.txt / llms-full.txt files. Pure data,
+ * already sorted, already stripped — generators (`generateLlmsTxt`,
+ * `generateLlmsFullTxt`) consume this without further processing.
+ */
+interface LlmsDocEntry {
+    /** Page title (frontmatter `title`, with the slug as a fallback). */
+    title: string;
+    /**
+     * Short description used as the bullet's right-hand side in
+     * `llms.txt`. Falls back to the first non-blank prose line of the
+     * stripped body when `frontmatter.description` is absent.
+     */
+    description: string;
+    /**
+     * Public URL for the page. Absolute when `siteUrl` is supplied to the
+     * loader, otherwise a path-only URL beginning with `base`.
+     */
+    url: string;
+    /**
+     * Body content with imports/exports/JSX tags removed. Used verbatim
+     * inside `llms-full.txt`.
+     */
+    content: string;
+    /** `frontmatter.sidebar_position`, undefined when not declared. */
+    sidebarPosition: number | undefined;
+}
+/**
+ * Site-level metadata threaded through the generators. Matches the
+ * `siteName` / `siteDescription` fields on the legacy settings object
+ * one-for-one so callers can pass `settings` straight through.
+ */
+interface LlmsTxtSiteMeta {
+    siteName: string;
+    siteDescription: string;
+}
+/**
+ * One locale's content directory + URL prefix. The default locale is
+ * represented separately on {@link LlmsTxtEmitOptions}; this type
+ * describes the *additional* locales (e.g. `ja`).
+ */
+interface LlmsTxtLocaleConfig {
+    /** Locale code used as both the URL segment and the output subfolder. */
+    code: string;
+    /** Absolute or cwd-relative path to the locale's content root. */
+    dir: string;
+}
+/**
+ * Options for {@link loadDocEntries} — one content directory at a time.
+ */
+interface LlmsTxtLoadOptions {
+    /** Absolute or cwd-relative path to the markdown content root. */
+    contentDir: string;
+    /**
+     * Locale segment for the generated URLs. Pass `null` to omit the
+     * locale segment (the default locale).
+     */
+    locale: string | null;
+    /**
+     * URL base, with or without a trailing slash. The loader strips the
+     * trailing slash before joining.
+     */
+    base: string;
+    /**
+     * Optional absolute site URL. When set, the loader produces fully
+     * qualified URLs by prefixing the base+path with `siteUrl`. When
+     * empty, URLs are returned path-only (matching the legacy emitter's
+     * behaviour for projects that omit `siteUrl`).
+     */
+    siteUrl?: string;
+}
+/**
+ * Top-level options for {@link emitLlmsTxt}. Mirrors the inputs the
+ * legacy Astro emitter pulled implicitly off of the project's `settings`
+ * module so that a one-line registration in `zfb.config.ts` (or a
+ * `b4-build` hook in Astro) can wire the same behaviour.
+ */
+interface LlmsTxtEmitOptions extends LlmsTxtSiteMeta {
+    /** Absolute output directory — typically `dist/`. */
+    outDir: string;
+    /** URL base used when materialising per-page links. */
+    base: string;
+    /** Optional absolute site URL; see {@link LlmsTxtLoadOptions}. */
+    siteUrl?: string;
+    /**
+     * Default-locale content directory. Emitted at `outDir/llms.txt` and
+     * `outDir/llms-full.txt`.
+     */
+    defaultLocaleDir: string;
+    /**
+     * Additional locales. Each one emits to
+     * `outDir/<code>/llms.txt` and `outDir/<code>/llms-full.txt`.
+     */
+    locales?: LlmsTxtLocaleConfig[];
+    /**
+     * Optional logger. Defaults to a no-op so unit tests stay quiet; the
+     * Astro adapter can wire `astro:build:done`'s `logger` through, and
+     * a future zfb plugin can pipe its own.
+     */
+    logger?: LlmsTxtLogger;
+}
+/**
+ * Minimal logger interface — a structural subset of both Astro's
+ * `logger` and `console`. Only `info` is used today; the wider shape is
+ * provided so the option can hold either object without type acrobatics.
+ */
+interface LlmsTxtLogger {
+    info: (msg: string) => void;
+}
+/**
+ * Result returned by {@link emitLlmsTxt}. Useful for tests and for
+ * callers that want to log / further process the emitted set.
+ */
+interface LlmsTxtEmitResult {
+    /** Absolute paths of every file written, in emit order. */
+    written: string[];
+}
+
+export type { LlmsDocEntry, LlmsTxtEmitOptions, LlmsTxtEmitResult, LlmsTxtFrontmatter, LlmsTxtLoadOptions, LlmsTxtLocaleConfig, LlmsTxtLogger, LlmsTxtSiteMeta };

package/dist/integrations/search-index/build-emitter.d.ts

@@ -0,0 +1,30 @@
+import { SearchIndexConfig, SearchIndexEntry } from './types.js';
+
+interface SearchIndexBuildResult {
+    /** Absolute path of the JSON file that was written. */
+    jsonPath: string;
+    /** Number of entries serialised. */
+    entryCount: number;
+    /** The raw entries — exposed so callers can pipe the same data into a Worker bundle if needed. */
+    entries: SearchIndexEntry[];
+}
+interface SearchIndexBuildOptions extends SearchIndexConfig {
+    /** Absolute path of the build output directory (e.g. zfb's `outDir`). */
+    outDir: string;
+    /** Optional logger; defaults to a no-op so builds stay quiet by default. */
+    logger?: {
+        info: (msg: string) => void;
+    };
+}
+/**
+ * Walk the configured content directories, build the flat search index,
+ * and write `search-index.json` to `outDir`. Returns the entries so
+ * callers (e.g. a downstream `search-worker` bundler) can reuse the
+ * same data without re-walking the filesystem.
+ *
+ * Schema is byte-identical to today's Astro integration — see
+ * `types.ts` for the locked-in shape.
+ */
+declare function emitSearchIndex(options: SearchIndexBuildOptions): SearchIndexBuildResult;
+
+export { type SearchIndexBuildOptions, type SearchIndexBuildResult, emitSearchIndex };

package/dist/integrations/search-index/build-emitter.js

@@ -0,0 +1,15 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { collectSearchEntries } from "./collect.js";
+function emitSearchIndex(options) {
+  const { outDir, logger, ...config } = options;
+  const entries = collectSearchEntries(config);
+  mkdirSync(outDir, { recursive: true });
+  const jsonPath = join(outDir, "search-index.json");
+  writeFileSync(jsonPath, JSON.stringify(entries));
+  logger?.info(`Generated search index with ${entries.length} entries`);
+  return { jsonPath, entryCount: entries.length, entries };
+}
+export {
+  emitSearchIndex
+};

package/dist/integrations/search-index/collect.d.ts

@@ -0,0 +1,12 @@
+import { SearchIndexConfig, SearchIndexEntry } from './types.js';
+
+/**
+ * Collect every search-index entry across the default locale plus all
+ * configured non-default locales. The traversal order matches today's
+ * Astro integration: default locale first, then locales in the iteration
+ * order of the `locales` map. Downstream consumers should not rely on
+ * order beyond that, but keep it stable for diff-friendly builds.
+ */
+declare function collectSearchEntries(config: SearchIndexConfig): SearchIndexEntry[];
+
+export { collectSearchEntries };

package/dist/integrations/search-index/collect.js

@@ -0,0 +1,48 @@
+import { resolve } from "node:path";
+import {
+  collectMdFiles,
+  isExcluded,
+  parseMarkdownFile,
+  slugToUrl,
+  stripMarkdown
+} from "./content-files.js";
+import {
+  MAX_BODY_LENGTH
+} from "./types.js";
+function truncateBody(text) {
+  return text.length > MAX_BODY_LENGTH ? text.substring(0, MAX_BODY_LENGTH) : text;
+}
+function buildEntries(contentDir, locale, base) {
+  const absDir = resolve(contentDir);
+  const files = collectMdFiles(absDir);
+  const entries = [];
+  for (const { filePath, slug } of files) {
+    const parsed = parseMarkdownFile(filePath);
+    if (!parsed) continue;
+    const { data, content } = parsed;
+    if (isExcluded(data)) continue;
+    const id = locale ? `${locale}/${slug}` : slug;
+    entries.push({
+      id,
+      title: data.title ?? slug,
+      body: truncateBody(stripMarkdown(content)),
+      url: slugToUrl(slug, locale, base),
+      description: data.description ?? ""
+    });
+  }
+  return entries;
+}
+function collectSearchEntries(config) {
+  const base = config.base ?? "";
+  const entries = [];
+  entries.push(...buildEntries(config.docsDir, null, base));
+  if (config.locales) {
+    for (const [code, locale] of Object.entries(config.locales)) {
+      entries.push(...buildEntries(locale.dir, code, base));
+    }
+  }
+  return entries;
+}
+export {
+  collectSearchEntries
+};

package/dist/integrations/search-index/content-files.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Strip markdown formatting to plain text. Conservative-by-design — the
+ * regex pipeline is identical to today's Astro integration so search
+ * excerpts stay byte-equal across the cutover. Do not add new rules
+ * without also updating the byte-equality fixtures (topic-plugin-audit).
+ */
+declare function stripMarkdown(md: string): string;
+/** Walk a directory recursively and collect all `.md`/`.mdx` files. */
+declare function collectMdFiles(dir: string): Array<{
+    filePath: string;
+    slug: string;
+}>;
+/** Compute the site-relative URL for a slug + locale, honouring `base`. */
+declare function slugToUrl(slug: string, locale: string | null, base: string): string;
+/** Frontmatter fields the integration cares about. Extra keys pass through. */
+interface DocFrontmatter {
+    title?: string;
+    description?: string;
+    draft?: boolean;
+    unlisted?: boolean;
+    search_exclude?: boolean;
+    [key: string]: unknown;
+}
+/** Parse a markdown file. Returns null when the file cannot be read. */
+declare function parseMarkdownFile(filePath: string): {
+    data: DocFrontmatter;
+    content: string;
+} | null;
+/** A page is excluded from indexing when explicitly opted out, drafted, or unlisted. */
+declare function isExcluded(data: DocFrontmatter): boolean;
+
+export { type DocFrontmatter, collectMdFiles, isExcluded, parseMarkdownFile, slugToUrl, stripMarkdown };

package/dist/integrations/search-index/content-files.js

@@ -0,0 +1,50 @@
+import { readFileSync, readdirSync } from "node:fs";
+import { join, relative } from "node:path";
+import matter from "gray-matter";
+function stripMarkdown(md) {
+  return md.replace(/```[\s\S]*?```/g, "").replace(/`[^`]+`/g, "").replace(/<[^>]+>/g, "").replace(/^#{1,6}\s+/gm, "").replace(/\*{1,3}([^*]+)\*{1,3}/g, "$1").replace(/_{1,3}([^_]+)_{1,3}/g, "$1").replace(/!\[[^\]]*\]\([^)]+\)/g, "").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/^>\s+/gm, "").replace(/^[-*_]{3,}\s*$/gm, "").replace(/^[\s]*[-*+]\s+/gm, "").replace(/^[\s]*\d+\.\s+/gm, "").replace(/^import\s+.*$/gm, "").replace(/^export\s+.*$/gm, "").replace(/\n{3,}/g, "\n\n").trim();
+}
+function collectMdFiles(dir) {
+  const results = [];
+  function walk(currentDir, baseDir) {
+    let entries;
+    try {
+      entries = readdirSync(currentDir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        walk(fullPath, baseDir);
+      } else if (/\.mdx?$/.test(entry.name) && !entry.name.startsWith("_")) {
+        const rel = relative(baseDir, fullPath).replace(/\.mdx?$/, "").replace(/\/index$/, "");
+        results.push({ filePath: fullPath, slug: rel });
+      }
+    }
+  }
+  walk(dir, dir);
+  return results;
+}
+function slugToUrl(slug, locale, base) {
+  const normalizedBase = base.replace(/\/$/, "");
+  return locale ? `${normalizedBase}/${locale}/docs/${slug}` : `${normalizedBase}/docs/${slug}`;
+}
+function parseMarkdownFile(filePath) {
+  try {
+    const raw = readFileSync(filePath, "utf-8");
+    return matter(raw);
+  } catch {
+    return null;
+  }
+}
+function isExcluded(data) {
+  return !!(data.search_exclude || data.draft || data.unlisted);
+}
+export {
+  collectMdFiles,
+  isExcluded,
+  parseMarkdownFile,
+  slugToUrl,
+  stripMarkdown
+};

package/dist/integrations/search-index/dev-middleware.d.ts

@@ -0,0 +1,16 @@
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { SearchIndexConfig } from './types.js';
+
+type SearchIndexNextFn = (err?: unknown) => void;
+type SearchIndexMiddleware = (req: IncomingMessage, res: ServerResponse, next: SearchIndexNextFn) => void;
+/**
+ * Build a dev-server middleware that responds to GET requests for
+ * `/search-index.json` (or any URL ending in that suffix, mirroring the
+ * tolerant matcher in the Astro integration so a `base` prefix at the
+ * dev server does not break the route). Every request rebuilds the
+ * index from disk — that matches the Astro behaviour and keeps content
+ * edits visible without a dev-server restart.
+ */
+declare function createSearchIndexDevMiddleware(config: SearchIndexConfig): SearchIndexMiddleware;
+
+export { type SearchIndexMiddleware, type SearchIndexNextFn, createSearchIndexDevMiddleware };

package/dist/integrations/search-index/dev-middleware.js

@@ -0,0 +1,30 @@
+import { collectSearchEntries } from "./collect.js";
+import {
+  SEARCH_INDEX_ROUTE
+} from "./types.js";
+function createSearchIndexDevMiddleware(config) {
+  return (req, res, next) => {
+    const url = req.url ?? "";
+    const matches = url === SEARCH_INDEX_ROUTE || url.endsWith(SEARCH_INDEX_ROUTE);
+    if (!matches) {
+      next();
+      return;
+    }
+    try {
+      const entries = collectSearchEntries(config);
+      res.setHeader("Content-Type", "application/json");
+      res.end(JSON.stringify(entries));
+    } catch (err) {
+      res.statusCode = 500;
+      res.setHeader("Content-Type", "application/json");
+      res.end(
+        JSON.stringify({
+          error: err instanceof Error ? err.message : "Internal error"
+        })
+      );
+    }
+  };
+}
+export {
+  createSearchIndexDevMiddleware
+};

package/dist/integrations/search-index/index.d.ts

@@ -0,0 +1,5 @@
+export { SearchIndexBuildOptions, SearchIndexBuildResult, emitSearchIndex } from './build-emitter.js';
+export { collectSearchEntries } from './collect.js';
+export { SearchIndexMiddleware, SearchIndexNextFn, createSearchIndexDevMiddleware } from './dev-middleware.js';
+export { MAX_BODY_LENGTH, SEARCH_INDEX_ROUTE, SearchIndexConfig, SearchIndexEntry, SearchIndexLocaleConfig } from './types.js';
+import 'node:http';

package/dist/integrations/search-index/index.js

@@ -0,0 +1,14 @@
+import { emitSearchIndex } from "./build-emitter.js";
+import { collectSearchEntries } from "./collect.js";
+import { createSearchIndexDevMiddleware } from "./dev-middleware.js";
+import {
+  MAX_BODY_LENGTH,
+  SEARCH_INDEX_ROUTE
+} from "./types.js";
+export {
+  MAX_BODY_LENGTH,
+  SEARCH_INDEX_ROUTE,
+  collectSearchEntries,
+  createSearchIndexDevMiddleware,
+  emitSearchIndex
+};

package/dist/integrations/search-index/types.d.ts

@@ -0,0 +1,38 @@
+/**
+ * One page in the search index. The shape mirrors today's Astro
+ * integration output verbatim — keep it byte-identical so downstream
+ * consumers (search.astro client island and packages/search-worker via
+ * MiniSearch) keep working unchanged after the zfb cutover.
+ */
+interface SearchIndexEntry {
+    /** Stable identifier — `slug` for the default locale, `${locale}/${slug}` otherwise. */
+    id: string;
+    /** Frontmatter title, falling back to the slug when missing. */
+    title: string;
+    /** Plain-text body excerpt, capped at MAX_BODY_LENGTH characters. */
+    body: string;
+    /** Site-relative URL (respecting `base`). */
+    url: string;
+    /** Frontmatter description, or the empty string when absent. */
+    description: string;
+}
+/** A locale entry that mirrors the Astro `settings.locales` shape we already have. */
+interface SearchIndexLocaleConfig {
+    /** Absolute or project-relative directory holding this locale's MDX content. */
+    dir: string;
+}
+/** Build-time configuration for collecting search entries. */
+interface SearchIndexConfig {
+    /** Default-locale content directory (e.g. `src/content/docs`). */
+    docsDir: string;
+    /** Optional non-default locales, keyed by locale code (e.g. `{ ja: { dir: "src/content/docs-ja" } }`). */
+    locales?: Record<string, SearchIndexLocaleConfig>;
+    /** Site base path (e.g. `""`, `"/docs"`); trailing slash is normalised away. */
+    base?: string;
+}
+/** Maximum body text stored per entry (display excerpt cap). */
+declare const MAX_BODY_LENGTH = 300;
+/** Public route the dev middleware and build emitter agree on. */
+declare const SEARCH_INDEX_ROUTE = "/search-index.json";
+
+export { MAX_BODY_LENGTH, SEARCH_INDEX_ROUTE, type SearchIndexConfig, type SearchIndexEntry, type SearchIndexLocaleConfig };

package/dist/integrations/search-index/types.js

@@ -0,0 +1,6 @@
+const MAX_BODY_LENGTH = 300;
+const SEARCH_INDEX_ROUTE = "/search-index.json";
+export {
+  MAX_BODY_LENGTH,
+  SEARCH_INDEX_ROUTE
+};

package/dist/metainfo/doc-metainfo.d.ts

@@ -0,0 +1,50 @@
+import { VNode } from 'preact';
+
+/** @jsxRuntime automatic */
+/** @jsxImportSource preact */
+
+interface DocMetainfoProps {
+    /**
+     * Pre-formatted creation date string (e.g. `"Jan 1, 2024"`).
+     * The legacy `doc-metainfo.astro` called `formatDate(gitInfo.createdAt,
+     * locale)` inline; v2 delegates that computation to the caller.
+     * Omit (or pass `null`) to suppress the "created" row.
+     */
+    createdAt?: string | null;
+    /**
+     * Pre-formatted last-updated date string. Suppressed when equal to
+     * `createdAt` (matching the original template's guard
+     * `updatedAt !== createdAt`), or when null / omitted.
+     */
+    updatedAt?: string | null;
+    /**
+     * Git author name (or any attribution string). Omit to suppress.
+     */
+    author?: string | null;
+    /**
+     * Label for the "created" entry. Defaults to `"Created"`. Pass the
+     * i18n-resolved string (`t("doc.created", locale)`) from upstream.
+     */
+    createdLabel?: string;
+    /**
+     * Label for the "updated" entry. Defaults to `"Updated"`.
+     */
+    updatedLabel?: string;
+}
+declare const DEFAULT_CREATED_LABEL = "Created";
+declare const DEFAULT_UPDATED_LABEL = "Updated";
+/**
+ * Document meta-information strip (created date, updated date, author)
+ * — JSX port of `src/components/doc-metainfo.astro`.
+ *
+ * The legacy component owned three responsibilities: reading
+ * `settings.docMetainfo`, calling `getGitInfo(filePath)`, and
+ * presentation. v2 keeps only presentation; the caller resolves git
+ * info and date formatting upstream.
+ *
+ * Returns `null` when no displayable field is provided, mirroring the
+ * original `hasInfo && (...)` guard.
+ */
+declare function DocMetainfo(props: DocMetainfoProps): VNode | null;
+
+export { DEFAULT_CREATED_LABEL, DEFAULT_UPDATED_LABEL, DocMetainfo, type DocMetainfoProps };