@takazudo/zudo-doc 0.2.21 → 0.2.22

package/dist/doc-page-shell/index.js

@@ -0,0 +1,127 @@
+import { Fragment, jsx, jsxs } from "preact/jsx-runtime";
+import { Island } from "@takazudo/zfb";
+import { DocLayoutWithDefaults } from "../doclayout/index.js";
+import { Toc, MobileToc } from "../toc/index.js";
+import { Breadcrumb } from "../breadcrumb/index.js";
+import { NavCardGrid } from "../nav-indexing/index.js";
+function createDocPageShell(deps) {
+  const {
+    settings,
+    composeMetaTitle,
+    getTocTitle,
+    HeadWithDefaults,
+    SidebarWithDefaults,
+    HeaderWithDefaults,
+    FooterWithDefaults,
+    SidebarPrepaint,
+    DocBodyEnd,
+    DocPager
+  } = deps;
+  function DocPageShell(props) {
+    const {
+      kind,
+      locale,
+      title,
+      description,
+      canonical,
+      breadcrumbs,
+      prev,
+      next,
+      headings,
+      navSection,
+      sidebarPersistKey,
+      hideSidebar,
+      hideToc,
+      currentPath,
+      currentVersion,
+      versionSwitcher,
+      versionBanner,
+      versionBannerLatestUrl,
+      versionBannerLabels,
+      autoIndexLabel,
+      autoIndexChildren,
+      metainfoSlot,
+      contentHeaderSlot,
+      contentSlot,
+      docHistorySlot
+    } = props;
+    const tocTitle = getTocTitle(locale);
+    const shouldRenderToc = !hideToc && headings.length > 0;
+    const tocOverride = shouldRenderToc ? Island({
+      when: "load",
+      children: /* @__PURE__ */ jsx(Toc, { headings, title: tocTitle })
+    }) : void 0;
+    const mobileTocOverride = shouldRenderToc ? Island({
+      when: "load",
+      children: /* @__PURE__ */ jsx(MobileToc, { headings, title: tocTitle })
+    }) : void 0;
+    return /* @__PURE__ */ jsx(
+      DocLayoutWithDefaults,
+      {
+        title: composeMetaTitle(title),
+        description: settings.metaTags.description ? description : void 0,
+        head: /* @__PURE__ */ jsx(HeadWithDefaults, { title, description, canonical }),
+        lang: locale,
+        noindex: settings.noindex,
+        hideSidebar,
+        hideToc,
+        headings,
+        canonical,
+        sidebarPersistKey,
+        versionBanner: versionBanner ?? false,
+        versionBannerLatestUrl,
+        versionBannerLabels,
+        headerOverride: /* @__PURE__ */ jsx(
+          HeaderWithDefaults,
+          {
+            lang: locale,
+            currentSlug: props.slug,
+            navSection,
+            currentVersion,
+            currentPath
+          }
+        ),
+        breadcrumbOverride: breadcrumbs.length > 0 ? /* @__PURE__ */ jsx(Breadcrumb, { items: breadcrumbs, rightSlot: versionSwitcher }) : void 0,
+        sidebarOverride: /* @__PURE__ */ jsx(
+          SidebarWithDefaults,
+          {
+            currentSlug: props.slug,
+            lang: locale,
+            navSection,
+            currentVersion,
+            currentPath
+          }
+        ),
+        tocOverride,
+        mobileTocOverride,
+        afterSidebar: /* @__PURE__ */ jsx(SidebarPrepaint, { hideSidebar }),
+        footerOverride: /* @__PURE__ */ jsx(FooterWithDefaults, { lang: locale }),
+        bodyEndComponents: /* @__PURE__ */ jsx(DocBodyEnd, {}),
+        enableClientRouter: settings.dynamicPageTransition,
+        children: kind === "autoIndex" ? (
+          /* Auto-index page: category without an index.mdx.
+             Fragment (not <div>) so children become direct children of
+             <article class="zd-content">, picking up the flow-space rule. */
+          /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsx("h1", { class: "text-heading font-bold mb-vsp-xs", children: autoIndexLabel }),
+            metainfoSlot,
+            description && /* @__PURE__ */ jsx("p", { class: "mb-vsp-lg text-title text-muted", children: description }),
+            /* @__PURE__ */ jsx(NavCardGrid, { children: autoIndexChildren ?? [] })
+          ] })
+        ) : (
+          /* Regular doc page. Fragment (not <div>) for the same reason. */
+          /* @__PURE__ */ jsxs(Fragment, { children: [
+            contentHeaderSlot,
+            contentSlot,
+            /* @__PURE__ */ jsx(DocPager, { prev, next, locale }),
+            docHistorySlot
+          ] })
+        )
+      }
+    );
+  }
+  return DocPageShell;
+}
+export {
+  createDocPageShell
+};

package/dist/doc-pager/index.d.ts

@@ -0,0 +1,25 @@
+/** @jsxRuntime automatic */
+/** @jsxImportSource preact */
+import type { JSX } from "preact";
+interface PagerNode {
+    href?: string;
+    label: string;
+}
+export interface DocPagerProps {
+    /** Previous page node (null = no previous page → renders placeholder). */
+    prev: PagerNode | null;
+    /** Next page node (null = no next page → renders placeholder). */
+    next: PagerNode | null;
+    /** Active locale for translated "Previous" / "Next" labels. */
+    locale: string;
+}
+/** Dependencies injected by the host stub. */
+export interface DocPagerDeps {
+    /** Translate a UI string key for a locale. */
+    t: (key: string, locale: string) => string;
+}
+/**
+ * Create a `DocPager` component bound to the host's injected `t` translator.
+ */
+export declare function createDocPager(deps: DocPagerDeps): (props: DocPagerProps) => JSX.Element;
+export {};

package/dist/doc-pager/index.js

@@ -0,0 +1,41 @@
+import { jsx, jsxs } from "preact/jsx-runtime";
+import { ChevronLeft, ChevronRight } from "../icons/index.js";
+function createDocPager(deps) {
+  const { t } = deps;
+  function DocPager({ prev, next, locale }) {
+    return /* @__PURE__ */ jsxs("nav", { class: "mt-vsp-2xl grid grid-cols-2 gap-hsp-xl", children: [
+      prev ? /* @__PURE__ */ jsxs(
+        "a",
+        {
+          href: prev.href,
+          class: "group border border-muted rounded-lg p-hsp-lg hover:border-accent",
+          children: [
+            /* @__PURE__ */ jsxs("div", { class: "flex items-center gap-hsp-xs text-caption text-muted mb-vsp-2xs", children: [
+              /* @__PURE__ */ jsx(ChevronLeft, { className: "h-[1.125rem] w-[1.125rem]" }),
+              /* @__PURE__ */ jsx("span", { class: "no-underline", children: t("nav.previous", locale) })
+            ] }),
+            /* @__PURE__ */ jsx("p", { class: "text-small font-semibold underline group-hover:text-accent", children: prev.label })
+          ]
+        }
+      ) : /* @__PURE__ */ jsx("div", {}),
+      next ? /* @__PURE__ */ jsxs(
+        "a",
+        {
+          href: next.href,
+          class: "group border border-muted rounded-lg p-hsp-lg hover:border-accent text-right",
+          children: [
+            /* @__PURE__ */ jsxs("div", { class: "flex items-center justify-end gap-hsp-xs text-caption text-muted mb-vsp-2xs", children: [
+              /* @__PURE__ */ jsx("span", { class: "no-underline", children: t("nav.next", locale) }),
+              /* @__PURE__ */ jsx(ChevronRight, { className: "h-[1.125rem] w-[1.125rem]" })
+            ] }),
+            /* @__PURE__ */ jsx("p", { class: "text-small font-semibold underline group-hover:text-accent", children: next.label })
+          ]
+        }
+      ) : /* @__PURE__ */ jsx("div", {})
+    ] });
+  }
+  return DocPager;
+}
+export {
+  createDocPager
+};

package/dist/doc-route-entries/index.d.ts

@@ -0,0 +1,125 @@
+import type { DocPageEntry, DocNavNode, AutoIndexNode, DocPageBaseProps } from "../doc-page-props/index.js";
+import type { NavSourceDocs } from "../nav-source-docs/index.js";
+import type { BreadcrumbItem } from "../breadcrumb/types.js";
+import type { HeadingItem } from "../extract-headings/index.js";
+export type { DocPageEntry, DocNavNode, AutoIndexNode, DocPageBaseProps, NavSourceDocs };
+/** One enumerated doc route: a content entry or an auto-generated category
+ *  index, with all per-page derived data pre-computed. */
+export interface DocRouteEntry {
+    /** Canonical route slug ("" for the docs root index — #1891). */
+    slug: string;
+    /** Optional-catchall params array — `toSlugParams(slug)` ([] for the root). */
+    slugParams: string[];
+    /**
+     * True when the entry came from the base collection rather than the locale
+     * collection (`!localeSlugSet.has(slug)`). Only meaningful on routes whose
+     * nav source performs a locale merge — routes without one (default-locale /
+     * versioned-EN, where `localeSlugSet` is empty) must ignore this field.
+     * Always false for autoIndex items.
+     */
+    isFallback: boolean;
+    /** Shared page props (kind/entry/autoIndex/breadcrumbs/prev/next/headings). */
+    props: DocPageBaseProps;
+}
+export interface BuildDocRouteEntriesArgs {
+    /** Identity-stable nav source for this route's (locale, version) context. */
+    source: NavSourceDocs;
+    /** Active locale for nav-tree labels and breadcrumbs. */
+    locale: string;
+    /**
+     * Unique memo signature for this route context. Each route file passes its
+     * own prefix plus the loop variables (version slug / locale), e.g.
+     * "docs;en", "locale-docs;ja", "v-docs;1.0", "v-locale-docs;1.0;ja" —
+     * call sites that share a docs array identity must never collide on a key.
+     */
+    routeSig: string;
+    /** Versioned URL closure bound to the route's version (+ locale). Presence
+     *  switches the versioned behaviors (breadcrumbs, prev/next, child hrefs). */
+    urlFor?: (slug: string) => string;
+}
+export type { BreadcrumbItem, HeadingItem };
+/**
+ * Injected context for `createDocRouteEntries`.
+ */
+export interface DocRouteEntriesContext {
+    /**
+     * Build the nav tree for a locale from a flat entry array and category meta.
+     * Host passes `buildNavTree` from `@/utils/docs`.
+     */
+    buildNavTree: (docs: DocPageEntry[], locale: string, categoryMeta: Map<string, unknown>) => DocNavNode[];
+    /**
+     * Build breadcrumb trail by walking the nav tree.
+     * Host passes `buildBreadcrumbs` from `@/utils/docs`.
+     */
+    buildBreadcrumbs: (tree: DocNavNode[], slug: string, locale: string, urlFor?: (slug: string) => string) => BreadcrumbItem[];
+    /**
+     * Collect all auto-generated index nodes (categories without index.mdx).
+     * Host passes `collectAutoIndexNodes` from `@/utils/docs`.
+     */
+    collectAutoIndexNodes: (tree: DocNavNode[]) => AutoIndexNode[];
+    /**
+     * Determine the nav section (categoryMatch) for a slug.
+     * Host passes `getNavSectionForSlug` from `@/utils/nav-scope`.
+     */
+    getNavSectionForSlug: (slug: string) => string | undefined;
+    /**
+     * Filter top-level nav nodes by a categoryMatch value.
+     * Host passes `getNavSubtree` from `@/utils/nav-scope`.
+     */
+    getNavSubtree: (tree: DocNavNode[], categoryMatch?: string) => DocNavNode[];
+    /**
+     * Convert a content entry slug to a canonical route slug.
+     * Host passes `toRouteSlug` from `@/utils/slug` (or the package's
+     * `@takazudo/zudo-doc/slug`).
+     */
+    toRouteSlug: (id: string) => string;
+    /**
+     * Convert a canonical route slug to an optional-catchall params array.
+     * Host passes `toSlugParams` from `@/utils/slug`.
+     */
+    toSlugParams: (slug: string) => string[];
+    /**
+     * Extract headings from a raw MDX body.
+     * Host passes the wrapper from `pages/lib/_extract-headings.ts`.
+     */
+    extractHeadings: (body: string) => HeadingItem[];
+}
+/**
+ * Result of `createDocRouteEntries`. Contains the `buildDocRouteEntries`
+ * function bound to the injected context.
+ */
+export interface DocRouteEntriesAPI {
+    /**
+     * Enumerate all doc routes for one (locale, version) context, with per-entry
+     * derived data pre-computed. Memoized per build on the identity-stable
+     * `source.docs` array.
+     */
+    buildDocRouteEntries: (args: BuildDocRouteEntriesArgs) => DocRouteEntry[];
+}
+/**
+ * Create the `buildDocRouteEntries` function bound to the host's injected
+ * context.
+ *
+ * @example
+ * ```ts
+ * // pages/lib/_doc-route-entries.ts (thin stub)
+ * import { createDocRouteEntries } from "@takazudo/zudo-doc/doc-route-entries";
+ * import { buildNavTree, buildBreadcrumbs, collectAutoIndexNodes } from "@/utils/docs";
+ * import { getNavSectionForSlug, getNavSubtree } from "@/utils/nav-scope";
+ * import { toRouteSlug, toSlugParams } from "@/utils/slug";
+ * import { extractHeadings } from "./_extract-headings";
+ *
+ * export const { buildDocRouteEntries } = createDocRouteEntries({
+ *   buildNavTree,
+ *   buildBreadcrumbs,
+ *   collectAutoIndexNodes,
+ *   getNavSectionForSlug,
+ *   getNavSubtree,
+ *   toRouteSlug,
+ *   toSlugParams,
+ *   extractHeadings,
+ * });
+ * export type { DocRouteEntry, BuildDocRouteEntriesArgs };
+ * ```
+ */
+export declare function createDocRouteEntries(ctx: DocRouteEntriesContext): DocRouteEntriesAPI;

package/dist/doc-route-entries/index.js

@@ -0,0 +1,76 @@
+import { memoizeDerived } from "../nav-source-cache/index.js";
+import {
+  resolveDocPrevNext,
+  flattenSubtree,
+  rewriteNavHref,
+  remapNavChildHrefs
+} from "../doc-route-paths/index.js";
+function createDocRouteEntries(ctx) {
+  const {
+    buildNavTree,
+    buildBreadcrumbs,
+    collectAutoIndexNodes,
+    getNavSectionForSlug,
+    getNavSubtree,
+    toRouteSlug,
+    toSlugParams,
+    extractHeadings
+  } = ctx;
+  function buildDocRouteEntries(args) {
+    const { source, locale, routeSig, urlFor } = args;
+    return memoizeDerived([source.docs], `docRouteEntries;${routeSig}`, () => {
+      const { docs, navDocs, categoryMeta, localeSlugSet } = source;
+      const tree = buildNavTree(navDocs, locale, categoryMeta);
+      const breadcrumbTree = urlFor ? tree : buildNavTree(docs, locale, categoryMeta);
+      const result = [];
+      for (const entry of docs) {
+        if (entry.data.category_no_page === true) continue;
+        const slug = entry.data.slug ?? toRouteSlug(entry.slug);
+        const navSection = getNavSectionForSlug(slug);
+        const subtree = getNavSubtree(tree, navSection);
+        const { prev: prevNode, next: nextNode } = resolveDocPrevNext(
+          tree,
+          flattenSubtree(subtree),
+          slug,
+          entry.data
+        );
+        result.push({
+          slug,
+          slugParams: toSlugParams(slug),
+          isFallback: !localeSlugSet.has(slug),
+          props: {
+            kind: "entry",
+            entry,
+            breadcrumbs: buildBreadcrumbs(breadcrumbTree, slug, locale, urlFor),
+            prev: rewriteNavHref(prevNode, urlFor),
+            next: rewriteNavHref(nextNode, urlFor),
+            headings: extractHeadings(entry.body ?? "")
+          }
+        });
+      }
+      for (const node of collectAutoIndexNodes(tree)) {
+        result.push({
+          slug: node.slug,
+          slugParams: toSlugParams(node.slug),
+          isFallback: false,
+          props: {
+            kind: "autoIndex",
+            autoIndex: urlFor ? {
+              ...node,
+              children: remapNavChildHrefs(node.children, urlFor)
+            } : node,
+            breadcrumbs: buildBreadcrumbs(breadcrumbTree, node.slug, locale, urlFor),
+            prev: null,
+            next: null,
+            headings: []
+          }
+        });
+      }
+      return result;
+    });
+  }
+  return { buildDocRouteEntries };
+}
+export {
+  createDocRouteEntries
+};

package/dist/doc-route-paths/index.d.ts

@@ -0,0 +1,54 @@
+import type { DocNavNode } from "../doc-page-props/index.js";
+export type { DocNavNode };
+/**
+ * Flatten a nav tree into a pre-order traversal array.
+ * Mirrors `flattenTree` from `src/utils/docs.ts`.
+ */
+export declare function flattenTree(nodes: DocNavNode[]): DocNavNode[];
+/**
+ * Find a single nav node by slug in a tree.
+ * Mirrors `findNode` from `src/utils/docs.ts`.
+ */
+export declare function findNode(nodes: DocNavNode[], slug: string): DocNavNode | undefined;
+/** The two pagination-override fields read off entry frontmatter. */
+export interface PaginationOverrides {
+    /** `undefined` = no override; `null` = suppress; string = target slug. */
+    pagination_prev?: string | null;
+    pagination_next?: string | null;
+}
+/**
+ * Resolve prev/next nav nodes for an entry against the route's OWN nav tree.
+ *
+ * - Sequential prev/next come from the flattened sub-tree (`subtreeFlat`).
+ * - Frontmatter `pagination_prev` / `pagination_next` overrides resolve via
+ *   `findNode(tree, …)` against the SAME `tree` the route built — never a
+ *   foreign tree. The caller passes its own version/locale-scoped tree, so a
+ *   `/v/` override resolves to a `/v/` node and a latest override to a latest
+ *   node. (#1916 — pagination-override must bind to the correct tree.)
+ *
+ * Returns the raw DocNavNodes (hrefs untouched). Callers that need versioned
+ * hrefs run the result through `rewriteNavHref` with their `urlFor` closure.
+ */
+export declare function resolveDocPrevNext(tree: DocNavNode[], subtreeFlat: DocNavNode[], slug: string, overrides: PaginationOverrides): {
+    prev: DocNavNode | null;
+    next: DocNavNode | null;
+};
+/** Flatten the relevant sub-tree for an entry — convenience over flattenTree. */
+export declare function flattenSubtree(subtree: DocNavNode[]): DocNavNode[];
+/**
+ * Rewrite a single nav node's href via the route's `urlFor` closure.
+ *
+ * Returns `null` for a `null` node. Latest routes pass `undefined` (leave the
+ * href as the latest `docsUrl` already baked into the node); versioned routes
+ * pass `urlFor` so prev/next links point at the versioned URL.
+ */
+export declare function rewriteNavHref(node: DocNavNode | null, urlFor: ((slug: string) => string) | undefined): DocNavNode | null;
+/**
+ * Remap an auto-index node's child-card hrefs via `urlFor`.
+ *
+ * #1916 #2: on versioned routes the children carry latest `docsUrl` hrefs
+ * (every nav node does — see toNavNodes). They MUST be overridden to the
+ * versioned URL ALWAYS, not only when `c.href` is missing. Passing `urlFor`
+ * here does exactly that. Latest routes pass `undefined` to keep the original.
+ */
+export declare function remapNavChildHrefs(children: DocNavNode[], urlFor: ((slug: string) => string) | undefined): DocNavNode[];

package/dist/doc-route-paths/index.js

@@ -0,0 +1,61 @@
+function flattenTree(nodes) {
+  const result = [];
+  flattenInto(nodes, result);
+  return result;
+}
+function flattenInto(nodes, acc) {
+  for (const node of nodes) {
+    if (node.hasPage) acc.push(node);
+    flattenInto(node.children, acc);
+  }
+}
+function findNode(nodes, slug) {
+  for (const node of nodes) {
+    if (node.slug === slug) return node;
+    const found = findNode(node.children, slug);
+    if (found) return found;
+  }
+  return void 0;
+}
+function resolveDocPrevNext(tree, subtreeFlat, slug, overrides) {
+  const idx = subtreeFlat.findIndex((n) => n.slug === slug);
+  let prev = idx > 0 ? subtreeFlat[idx - 1] ?? null : null;
+  let next = idx >= 0 && idx < subtreeFlat.length - 1 ? subtreeFlat[idx + 1] ?? null : null;
+  if (overrides.pagination_prev !== void 0) {
+    if (overrides.pagination_prev === null) {
+      prev = null;
+    } else {
+      const found = findNode(tree, overrides.pagination_prev);
+      prev = found ?? prev;
+    }
+  }
+  if (overrides.pagination_next !== void 0) {
+    if (overrides.pagination_next === null) {
+      next = null;
+    } else {
+      const found = findNode(tree, overrides.pagination_next);
+      next = found ?? next;
+    }
+  }
+  return { prev, next };
+}
+function flattenSubtree(subtree) {
+  return flattenTree(subtree);
+}
+function rewriteNavHref(node, urlFor) {
+  if (!node) return null;
+  if (!urlFor) return node;
+  return { ...node, href: urlFor(node.slug) };
+}
+function remapNavChildHrefs(children, urlFor) {
+  if (!urlFor) return children;
+  return children.map((c) => ({ ...c, href: urlFor(c.slug) }));
+}
+export {
+  findNode,
+  flattenSubtree,
+  flattenTree,
+  remapNavChildHrefs,
+  resolveDocPrevNext,
+  rewriteNavHref
+};

package/dist/doc-tags-area/index.d.ts

@@ -0,0 +1,38 @@
+/** @jsxRuntime automatic */
+/** @jsxImportSource preact */
+import type { VNode } from "preact";
+import type { TagVocabularyEntry, TagGovernanceMode } from "../settings.js";
+/** Settings subset read by the DocTagsArea factory. */
+export interface DocTagsAreaSettings {
+    docTags: boolean;
+    tagVocabulary: boolean | readonly TagVocabularyEntry[];
+    tagGovernance: TagGovernanceMode;
+}
+/** Dependencies injected by the host stub. */
+export interface DocTagsAreaDeps {
+    settings: DocTagsAreaSettings;
+    /** Default locale code (e.g. "en"). */
+    defaultLocale: string;
+    /** Tag vocabulary entries (from the host's `@/config/tag-vocabulary`). */
+    tagVocabularyEntries: readonly TagVocabularyEntry[];
+    /**
+     * Build the base-prefixed tag detail page href for the given tag and locale.
+     * Host passes a pre-bound function using `withBase` and `defaultLocale`.
+     */
+    tagHref: (tag: string, locale: string) => string;
+    /** Translate a UI string key for a locale. */
+    t: (key: string, locale: string) => string;
+}
+export interface DocTagsAreaProps {
+    /** Page slug, e.g. "guides/sidebar". */
+    slug: string;
+    /** Active locale string, e.g. "en", "ja". */
+    locale: string;
+    /** Raw tag strings from the page frontmatter (entry.data.tags). */
+    tags: readonly string[] | undefined;
+}
+/**
+ * Create a `DocTagsArea` component bound to the host's settings and
+ * injected dependencies.
+ */
+export declare function createDocTagsArea(deps: DocTagsAreaDeps): (props: DocTagsAreaProps) => VNode | null;

package/dist/doc-tags-area/index.js

@@ -0,0 +1,30 @@
+import { jsx } from "preact/jsx-runtime";
+import { DocTags } from "../metainfo/index.js";
+import { resolvePageTags } from "../tag-helpers/index.js";
+function createDocTagsArea(deps) {
+  const { settings, tagVocabularyEntries, tagHref, t } = deps;
+  function DocTagsArea({ locale, tags }) {
+    if (!settings.docTags) return null;
+    const rawTags = tags ?? [];
+    const vocab = settings.tagVocabulary ? tagVocabularyEntries : false;
+    const canonicalTags = resolvePageTags(rawTags, vocab, settings.tagGovernance);
+    if (canonicalTags.length === 0) return null;
+    const resolvedTags = canonicalTags.map((tag) => ({
+      tag,
+      href: tagHref(tag, locale)
+    }));
+    return /* @__PURE__ */ jsx(
+      DocTags,
+      {
+        placement: "after-title",
+        tags: resolvedTags,
+        tagsLabel: t("doc.tags", locale),
+        taggedWithLabel: t("doc.taggedWith", locale)
+      }
+    );
+  }
+  return DocTagsArea;
+}
+export {
+  createDocTagsArea
+};

package/dist/doclayout/anchors.d.ts

@@ -3,7 +3,7 @@
  * the literal anchor text. This is the stable key the drift checker keys
  * off of; the surrounding comment syntax is derived from `kind`.
  */
-type DocLayoutAnchorId = "imports" | "frontmatter" | "head-scripts" | "head-links" | "header-call:start" | "header-call:end" | "after-sidebar" | "content-wrapper:start" | "content-wrapper:end" | "breadcrumb:start" | "breadcrumb:end" | "after-breadcrumb" | "after-content" | "footer" | "body-end-components" | "body-end-scripts";
+export type DocLayoutAnchorId = "imports" | "frontmatter" | "head-scripts" | "head-links" | "header-call:start" | "header-call:end" | "after-sidebar" | "content-wrapper:start" | "content-wrapper:end" | "breadcrumb:start" | "breadcrumb:end" | "after-breadcrumb" | "after-content" | "footer" | "body-end-components" | "body-end-scripts";
 /**
  * Whether the anchor lives in the frontmatter region (`---` block in
  * Astro / module-scope in JSX) or in the body markup region.
@@ -15,8 +15,8 @@ type DocLayoutAnchorId = "imports" | "frontmatter" | "head-scripts" | "head-link
  *   literal HTML form for byte-for-byte parity with the existing
  *   create-zudo-doc anchor strings).
  */
-type DocLayoutAnchorKind = "frontmatter" | "body";
-interface DocLayoutAnchor {
+export type DocLayoutAnchorKind = "frontmatter" | "body";
+export interface DocLayoutAnchor {
     readonly id: DocLayoutAnchorId;
     readonly kind: DocLayoutAnchorKind;
 }
@@ -25,7 +25,7 @@ interface DocLayoutAnchor {
  * doc-layout file. Order is informational (useful for the drift
  * checker's diagnostic output); identity is what matters.
  */
-declare const DOC_LAYOUT_ANCHORS: readonly DocLayoutAnchor[];
+export declare const DOC_LAYOUT_ANCHORS: readonly DocLayoutAnchor[];
 /**
  * Build the literal anchor *comment string* the drift checker greps for
  * in a scaffolded file.
@@ -39,17 +39,15 @@ declare const DOC_LAYOUT_ANCHORS: readonly DocLayoutAnchor[];
  *   anchorComment({ id: "footer", kind: "body" })
  *     // "<!-- @slot:doc-layout:footer -->"
  */
-declare function anchorComment(anchor: DocLayoutAnchor): string;
+export declare function anchorComment(anchor: DocLayoutAnchor): string;
 /**
  * Convenience: every anchor's comment string, in declaration order. The
  * drift checker can iterate this and assert each substring appears in the
  * scaffolded doc-layout file.
  */
-declare function allAnchorComments(): readonly string[];
+export declare function allAnchorComments(): readonly string[];
 /**
  * Convenience: anchor IDs as a typed set. Useful when a caller wants to
  * verify "is this id one of ours?" without scanning the full list.
  */
-declare const DOC_LAYOUT_ANCHOR_IDS: ReadonlySet<DocLayoutAnchorId>;
-
-export { DOC_LAYOUT_ANCHORS, DOC_LAYOUT_ANCHOR_IDS, type DocLayoutAnchor, type DocLayoutAnchorId, type DocLayoutAnchorKind, allAnchorComments, anchorComment };
+export declare const DOC_LAYOUT_ANCHOR_IDS: ReadonlySet<DocLayoutAnchorId>;