@takazudo/zudo-doc 1.3.0 → 2.0.1

package/dist/head-with-defaults/index.d.ts

@@ -3,6 +3,8 @@
 import type { JSX } from "preact";
 import type { HeadProps } from "../head/types.js";
 import type { ColorSchemeProviderColorMode } from "../theme/color-scheme-provider.js";
+import type { ChromeContext } from "../factory-context/index.js";
+import type { Settings } from "../settings.js";
 export interface HeadWithDefaultsProps {
     /** Page title forwarded to og:title. Required. */
     title: string;
@@ -14,7 +16,8 @@ export interface HeadWithDefaultsProps {
      */
     canonical?: string;
 }
-/** Settings subset read by {@link createHeadWithDefaults}. */
+/** Settings subset read by {@link createHeadWithDefaults}. Retained for the
+ *  `HeadProps`/`ColorSchemeProviderColorMode` type references it documents. */
 export interface HeadWithDefaultsSettings {
     metaTags: {
         description?: boolean | null;
@@ -29,21 +32,14 @@ export interface HeadWithDefaultsSettings {
     colorMode?: ColorSchemeProviderColorMode | null | false;
     sidebarResizer?: boolean;
 }
-/** Factory dependencies injected by the host stub. */
-export interface HeadWithDefaultsDeps {
-    settings: HeadWithDefaultsSettings;
-    composeMetaTitle: (title: string) => string;
-    withBase: (path: string) => string;
-    absoluteUrl: (pageUrl: string) => string | undefined;
-    generateCssCustomProperties: () => string;
-    generateLightDarkCssProperties: () => string;
-}
 /**
- * Create a `HeadWithDefaults` component bound to the host's settings and
- * URL helpers.
+ * Create a `HeadWithDefaults` component from the unified {@link ChromeContext}
+ * (epic Collapse Wiring Shells #2420, FACTORIES #2424 — breaking signature).
  *
- * The host stub calls this once with its concrete dependencies and re-exports
- * the result, mirroring the shape of `createComposeMetaTitle` (S1b) and
- * `createBuildFrontmatterPreviewEntries`.
+ * Derives its old `{ settings, composeMetaTitle, withBase, absoluteUrl,
+ * generate* }` bag from the context: `settings`/`withBase`/`absoluteUrl` are
+ * read directly, while `composeMetaTitle` and the color-scheme CSS generators
+ * are reconstructed from the context's `siteName` + `colorSchemes` payload via
+ * the shared `chrome/derive` helpers (identical to the pre-collapse wiring).
  */
-export declare function createHeadWithDefaults(deps: HeadWithDefaultsDeps): (props: HeadWithDefaultsProps) => JSX.Element;
+export declare function createHeadWithDefaults<S extends Settings = Settings>(ctx: ChromeContext<S>): (props: HeadWithDefaultsProps) => JSX.Element;

package/dist/head-with-defaults/index.js

@@ -2,15 +2,13 @@ import { Fragment, jsx, jsxs } from "preact/jsx-runtime";
 import { OgTags, TwitterCard } from "../head/index.js";
 import { SIDEBAR_RESIZER_RESTORE_SCRIPT } from "../sidebar-resizer/index.js";
 import ColorSchemeProvider from "../theme/color-scheme-provider.js";
-function createHeadWithDefaults(deps) {
-  const {
-    settings,
-    composeMetaTitle,
-    withBase,
-    absoluteUrl,
-    generateCssCustomProperties,
-    generateLightDarkCssProperties
-  } = deps;
+import { deriveComposeMetaTitle, deriveColorSchemeGenerators } from "../chrome/derive.js";
+function createHeadWithDefaults(ctx) {
+  const settings = ctx.settings;
+  const composeMetaTitle = deriveComposeMetaTitle(ctx);
+  const withBase = ctx.withBase;
+  const absoluteUrl = ctx.absoluteUrl;
+  const { generateCssCustomProperties, generateLightDarkCssProperties } = deriveColorSchemeGenerators(ctx);
   function HeadWithDefaults({
     title,
     description,
@@ -52,7 +50,92 @@ function createHeadWithDefaults(deps) {
       /* @__PURE__ */ jsx("link", { rel: "icon", href: withBase("/favicon.ico"), sizes: "any" }),
       /* @__PURE__ */ jsx("link", { rel: "icon", type: "image/png", sizes: "32x32", href: withBase("/favicon-32x32.png") }),
       /* @__PURE__ */ jsx("link", { rel: "icon", type: "image/png", sizes: "16x16", href: withBase("/favicon-16x16.png") }),
-      canonical !== void 0 && /* @__PURE__ */ jsx("link", { rel: "canonical", href: canonical })
+      canonical !== void 0 && /* @__PURE__ */ jsx("link", { rel: "canonical", href: canonical }),
+      ctx.settings.head && /* @__PURE__ */ jsxs(Fragment, { children: [
+        ctx.settings.head.preconnect?.map((p, i) => /* @__PURE__ */ jsx(
+          "link",
+          {
+            rel: "preconnect",
+            href: p.href,
+            ...p.crossorigin ? { crossorigin: p.crossorigin } : {}
+          },
+          i
+        )),
+        ctx.settings.head.preload?.map((p, i) => /* @__PURE__ */ jsx(
+          "link",
+          {
+            rel: "preload",
+            as: p.as,
+            href: p.href,
+            ...p.type ? { type: p.type } : {},
+            ...p.crossorigin ? { crossorigin: p.crossorigin } : {}
+          },
+          i
+        )),
+        ctx.settings.head.stylesheets?.map(
+          (s, i) => s.async ? (
+            // Non-render-blocking async stylesheet:
+            //   <link rel="stylesheet" href media="print" onload="this.media='all'">
+            //   <noscript><link rel="stylesheet" href></noscript>
+            //
+            // SSR note: preact-render-to-string emits string-valued on* props as
+            // literal HTML attributes (only function-valued event handlers are
+            // stripped). We use `as any` to bypass Preact's JSX types, which
+            // expect a function for onload. The new unit test pins the exact
+            // emitted string to guard this contract.
+            /* @__PURE__ */ jsxs(Fragment, { children: [
+              /* @__PURE__ */ jsx(
+                "link",
+                {
+                  rel: "stylesheet",
+                  href: s.href,
+                  ...s.crossorigin ? { crossorigin: s.crossorigin } : {},
+                  media: "print",
+                  ...{ onload: `this.media='${s.media ?? "all"}'` }
+                },
+                `${i}-link`
+              ),
+              /* @__PURE__ */ jsx(
+                "noscript",
+                {
+                  dangerouslySetInnerHTML: {
+                    __html: `<link rel="stylesheet" href="${s.href.replace(/"/g, "&quot;")}"${s.media ? ` media="${s.media}"` : ""}${s.crossorigin ? ` crossorigin="${s.crossorigin}"` : ""}>`
+                  }
+                },
+                `${i}-noscript`
+              )
+            ] })
+          ) : /* @__PURE__ */ jsx(
+            "link",
+            {
+              rel: "stylesheet",
+              href: s.href,
+              ...s.media ? { media: s.media } : {},
+              ...s.crossorigin ? { crossorigin: s.crossorigin } : {}
+            },
+            i
+          )
+        ),
+        ctx.settings.head.alternateLinks?.map((a, i) => /* @__PURE__ */ jsx(
+          "link",
+          {
+            rel: a.rel,
+            href: a.href,
+            ...a.type ? { type: a.type } : {},
+            ...a.title ? { title: a.title } : {}
+          },
+          i
+        )),
+        ctx.settings.head.meta?.map((m, i) => /* @__PURE__ */ jsx(
+          "meta",
+          {
+            ...m.name ? { name: m.name } : {},
+            ...m.property ? { property: m.property } : {},
+            content: m.content
+          },
+          i
+        ))
+      ] })
     ] });
   }
   return HeadWithDefaults;

package/dist/header-with-defaults/index.d.ts

@@ -1,8 +1,8 @@
 /** @jsxRuntime automatic */
 /** @jsxImportSource preact */
 import type { JSX } from "preact";
-import type { SidebarNavNode, SidebarRootMenuItem } from "../sidebar/types.js";
-import type { LocaleLink } from "../url-helpers/index.js";
+import type { ChromeContext } from "../factory-context/index.js";
+import type { Settings } from "../settings.js";
 export interface HeaderWithDefaultsProps {
     /** Active locale; defaults to the configured defaultLocale. */
     lang?: string;
@@ -44,34 +44,13 @@ export interface HeaderWithDefaultsSettings {
     versions?: HeaderVersionEntry[] | false;
     githubUrl?: string | false;
 }
-/** Dependencies injected by the host stub. */
-export interface HeaderWithDefaultsDeps {
-    settings: HeaderWithDefaultsSettings;
-    defaultLocale: string;
-    locales: readonly string[];
-    t: (key: string, lang: string) => string;
-    withBase: (path: string) => string;
-    stripBase: (path: string) => string;
-    docsUrl: (slug: string, lang: string) => string;
-    navHref: (path: string, lang: string | undefined, version: string | undefined) => string;
-    versionedDocsUrl: (slug: string, versionSlug: string, lang: string) => string;
-    buildLocaleLinksForNav: (currentPath: string, lang: string, localeCount: number) => LocaleLink[] | undefined;
-    buildRootMenuItems: (lang: string, currentVersion: string | undefined) => SidebarRootMenuItem[];
-    buildSidebarNodes: (lang: string, navSection: string | undefined, currentVersion: string | undefined) => SidebarNavNode[];
-    getThemeDefaultMode: () => "light" | "dark" | undefined;
-    buildGitHubRepoUrl: () => string | null;
-    SearchWidget: (props: {
-        placeholderText: string;
-        shortcutHint: string;
-        resultCountTemplate: string;
-        searchLabel: string;
-        searchUnavailableText: string;
-        loadingIndexText: string;
-        noResultsText: string;
-    }) => JSX.Element;
-}
 /**
- * Create a `HeaderWithDefaults` component bound to the host's settings
- * and data-prep utilities.
+ * Create a `HeaderWithDefaults` component from the unified {@link ChromeContext}
+ * (epic Collapse Wiring Shells #2420, FACTORIES #2424 — breaking signature).
+ *
+ * Derives its old wide deps bag from the context: the URL/i18n helpers
+ * (`t`/`withBase`/`docsUrl`/…) and `locales`/`defaultLocale` are read directly;
+ * the nav data-prep builders + SearchWidget slot come from the shared
+ * `chrome/derive` helpers; `buildGitHubRepoUrl` is bound to `settings.githubUrl`.
  */
-export declare function createHeaderWithDefaults(deps: HeaderWithDefaultsDeps): (props: HeaderWithDefaultsProps) => JSX.Element;
+export declare function createHeaderWithDefaults<S extends Settings = Settings>(ctx: ChromeContext<S>): (props: HeaderWithDefaultsProps) => JSX.Element;

package/dist/header-with-defaults/index.js

@@ -7,24 +7,21 @@ import {
 } from "../i18n-version/index.js";
 import { ThemeToggle } from "../theme-toggle/index.js";
 import { SidebarToggle } from "../sidebar-toggle-island/index.js";
-function createHeaderWithDefaults(deps) {
-  const {
-    settings,
-    defaultLocale,
-    locales,
-    t,
-    withBase,
-    stripBase,
-    docsUrl,
-    navHref,
-    versionedDocsUrl,
-    buildLocaleLinksForNav,
-    buildRootMenuItems,
-    buildSidebarNodes,
-    getThemeDefaultMode,
-    buildGitHubRepoUrl,
-    SearchWidget
-  } = deps;
+import { buildGitHubRepoUrl as buildGitHubRepoUrlBase } from "../github-helpers/index.js";
+import { deriveNavDataPrep, deriveSearchWidgetSlot } from "../chrome/derive.js";
+function createHeaderWithDefaults(ctx) {
+  const settings = ctx.settings;
+  const defaultLocale = ctx.defaultLocale;
+  const locales = ctx.locales;
+  const t = ctx.t;
+  const withBase = ctx.withBase;
+  const stripBase = ctx.stripBase;
+  const docsUrl = ctx.docsUrl;
+  const navHref = ctx.navHref;
+  const versionedDocsUrl = ctx.versionedDocsUrl;
+  const { buildRootMenuItems, buildLocaleLinksForNav, buildSidebarNodes, getThemeDefaultMode } = deriveNavDataPrep(ctx);
+  const buildGitHubRepoUrl = () => buildGitHubRepoUrlBase(ctx.settings.githubUrl);
+  const SearchWidget = deriveSearchWidgetSlot(ctx);
   function HeaderWithDefaults(props) {
     const {
       lang: langProp = defaultLocale,

package/dist/nav-source-docs/index.d.ts

@@ -1,5 +1,6 @@
 import type { CategoryMeta } from "../sidebar-tree/index.js";
 import type { DocPageEntry } from "../doc-page-props/index.js";
+import type { Settings } from "../settings.js";
 export type { CategoryMeta, DocPageEntry };
 export interface NavSourceDocs {
     /** Full doc list (merged + draft-filtered; unlisted retained per options). */
@@ -41,58 +42,32 @@ export interface VersionConfigEntry {
     }>;
 }
 /**
- * Injected context for `createNavSourceDocs`.
+ * Context slice `createNavSourceDocs` derives its bag from (epic Collapse
+ * Wiring Shells #2420, FACTORIES #2424 — breaking signature). This is a
+ * STRUCTURAL SUBSET of the unified `RouteContext`/`ChromeContext`, so callers
+ * pass the whole context: `docsDir`/`getVersions` are read off `settings`,
+ * `loadCategoryMeta` is imported from the package directly (it is a pure,
+ * `@/`-free helper), and the rest are reconstructed callables on the context.
  *
- * All host-specific singletons are passed in so the package factory never
- * imports `@/` aliases. The host stub calls `createNavSourceDocs(ctx)` once
- * and re-exports the returned resolver functions.
+ * NB: `createRouteContext` builds the route context incrementally and calls
+ * this factory with the partial-but-sufficient base context — every field
+ * below is present before the nav-source resolvers are assembled.
  */
 export interface NavSourceDocsContext {
-    /**
-     * Default locale code (served from the un-prefixed `/docs/...` routes).
-     * E.g. `"en"`.
-     */
+    /** The host's resolved settings object (reads `docsDir` + `versions`). */
+    settings: Settings;
+    /** Default locale code (un-prefixed `/docs/...` routes). E.g. `"en"`. */
     defaultLocale: string;
-    /**
-     * The configured docs content directory (e.g. `"src/content/docs"`).
-     * Used as the base dir for `loadCategoryMeta`.
-     */
-    docsDir: string;
-    /**
-     * Getter for the configured versions list (or false if versioning is not
-     * active). Called on every `resolveNavSource` invocation so test code that
-     * mutates `settings.versions` between calls sees the updated value.
-     * Structural equivalent of a getter for `settings.versions`.
-     *
-     * Pass `() => settings.versions` from the host stub.
-     */
-    getVersions: () => VersionConfigEntry[] | false | undefined;
-    /**
-     * Look up locale-specific config (dir, etc.) for a locale code.
-     * Host passes `getLocaleConfig` from `@/config/i18n`.
-     */
+    /** Per-locale config lookup (reconstructed on the context). */
     getLocaleConfig: (lang: string) => LocaleConfig | undefined;
-    /**
-     * Load category metadata for a content dir.
-     * Host passes `loadCategoryMeta` from `@/utils/docs` (re-exported from
-     * `@takazudo/zudo-doc/sidebar-tree`).
-     */
-    loadCategoryMeta: (dir: string) => Map<string, CategoryMeta>;
-    /**
-     * Filter predicate: true when a doc should appear in navigation.
-     * Host passes `isNavVisible` from `@/utils/docs`.
-     */
+    /** Filter predicate: true when a doc should appear in navigation. */
     isNavVisible: (doc: DocPageEntry) => boolean;
-    /**
-     * Returns true for paths that are only shown in the default locale.
-     * Host passes `isDefaultLocaleOnlyPath` from `@/utils/base`.
-     */
+    /** Returns true for paths that are only shown in the default locale. */
     isDefaultLocaleOnlyPath: (path: string) => boolean;
     /**
-     * Identity-stable, draft-filtered docs array for a collection.
-     * Host passes `stableDocs` from `pages/lib/_nav-source-cache.ts`.
-     * The function must anchor memoization on the zfb snapshot so the SAME
-     * array instance is returned on every call within one build.
+     * Identity-stable, draft-filtered docs array for a collection (the
+     * content-bridge handle). Anchors memoization on the zfb snapshot so the
+     * SAME array instance is returned on every call within one build.
      */
     stableDocs: (collectionName: string) => DocPageEntry[];
 }
@@ -154,16 +129,7 @@ export interface NavSourceDocsAPI {
  *   loadNavSourceDocs,
  *   stableMergeCategoryMeta,
  *   stableNavDocs,
- * } = createNavSourceDocs({
- *   defaultLocale,
- *   docsDir: settings.docsDir,
- *   getVersions: () => settings.versions,
- *   getLocaleConfig,
- *   loadCategoryMeta,
- *   isNavVisible,
- *   isDefaultLocaleOnlyPath,
- *   stableDocs,
- * });
+ * } = createNavSourceDocs(routeContext);
  * ```
  */
 export declare function createNavSourceDocs(ctx: NavSourceDocsContext): NavSourceDocsAPI;

package/dist/nav-source-docs/index.js

@@ -1,3 +1,4 @@
+import { loadCategoryMeta as loadCategoryMetaImpl } from "../sidebar-tree/index.js";
 import { memoizeDerived } from "../nav-source-cache/index.js";
 import { mergeLocaleDocs } from "../locale-merge/index.js";
 function optionSig(o) {
@@ -5,16 +6,14 @@ function optionSig(o) {
 }
 const EMPTY_SLUG_SET = /* @__PURE__ */ new Set();
 function createNavSourceDocs(ctx) {
-  const {
-    defaultLocale,
-    docsDir,
-    getVersions,
-    getLocaleConfig,
-    loadCategoryMeta,
-    isNavVisible,
-    isDefaultLocaleOnlyPath,
-    stableDocs
-  } = ctx;
+  const defaultLocale = ctx.defaultLocale;
+  const docsDir = ctx.settings.docsDir;
+  const getVersions = () => ctx.settings.versions;
+  const getLocaleConfig = ctx.getLocaleConfig;
+  const loadCategoryMeta = loadCategoryMetaImpl;
+  const isNavVisible = ctx.isNavVisible;
+  const isDefaultLocaleOnlyPath = ctx.isDefaultLocaleOnlyPath;
+  const stableDocs = ctx.stableDocs;
   const mergedCategoryMetaCache = /* @__PURE__ */ new Map();
   function stableMergeCategoryMeta(baseDir, localeDir) {
     const key = `${baseDir}

package/dist/route-context/index.d.ts

@@ -0,0 +1,24 @@
+import type { RouteContext, RouteContextPayload } from "../factory-context/index.js";
+import type { Settings } from "../settings.js";
+import type { DocPageEntry } from "../doc-page-props/index.js";
+export type { RouteContext, RouteContextPayload, TagInfo, } from "../factory-context/index.js";
+/** A content-bridge handle: identity-stable, draft-filtered docs loader. */
+export type ContentBridge = (collectionName: string) => DocPageEntry[];
+export interface CreateRouteContextOptions {
+    /**
+     * The content-bridge handle (`stableDocs`). Default: the package
+     * `stableDocs` from `routes/_docs-helpers` (reads `@takazudo/zfb/content`,
+     * snapshot-anchored for per-build identity stability). The host may inject
+     * its own content loader here.
+     */
+    stableDocs?: ContentBridge;
+}
+/**
+ * Reconstruct the full runtime route context from the serializable payload.
+ * Called ONCE per build (the route entrypoints share the returned singleton via
+ * the `routes/_context.ts` module), so the memoized closures inside
+ * (`createNavSourceDocs` / `createDocRouteEntries` / `createRouteEnumerators`)
+ * and the snapshot-anchored `stableDocs` keep array identity stable across all
+ * routes.
+ */
+export declare function createRouteContext<S extends Settings = Settings>(payload: RouteContextPayload<S>, options?: CreateRouteContextOptions): RouteContext<S>;

package/dist/route-context/index.js

@@ -0,0 +1,147 @@
+import { makeUrlHelpers } from "../url-helpers/index.js";
+import { loadCategoryMeta } from "../sidebar-tree/index.js";
+import { extractHeadings as extractHeadingsBase } from "../extract-headings/index.js";
+import { toRouteSlug, toSlugParams } from "../slug/index.js";
+import { resolveTag } from "../tag-helpers/index.js";
+import {
+  getCategoryOrder as getCategoryOrderBase,
+  getNavSectionForSlug as getNavSectionForSlugBase,
+  getNavSubtree as getNavSubtreeBase
+} from "../nav-scope/index.js";
+import { mergeLocaleDocs } from "../locale-merge/index.js";
+import {
+  createNavSourceDocs
+} from "../nav-source-docs/index.js";
+import {
+  createDocRouteEntries
+} from "../doc-route-entries/index.js";
+import {
+  createRouteEnumerators
+} from "../route-enumerators/index.js";
+import {
+  stableDocs as defaultStableDocs,
+  isNavVisible,
+  buildNavTree,
+  buildBreadcrumbs,
+  collectAutoIndexNodes,
+  groupSatelliteNodes,
+  findNode,
+  firstRoutedHref
+} from "../routes/_docs-helpers.js";
+function createRouteContext(payload, options = {}) {
+  const settings = payload.settings;
+  const translations = payload.translations;
+  const tagVocabulary = payload.tagVocabulary;
+  const colorSchemes = payload.colorSchemes;
+  const stableDocs = options.stableDocs ?? defaultStableDocs;
+  const defaultLocale = settings.defaultLocale;
+  const locales = [
+    defaultLocale,
+    ...Object.keys(settings.locales)
+  ];
+  function getLocaleConfig(locale) {
+    return settings.locales[locale];
+  }
+  function getLocaleLabel(locale) {
+    if (locale === defaultLocale) return defaultLocale.toUpperCase();
+    return getLocaleConfig(locale)?.label ?? locale.toUpperCase();
+  }
+  function t(key, locale = defaultLocale) {
+    return translations[locale]?.[key] ?? translations[defaultLocale]?.[key] ?? key;
+  }
+  const i18n = { defaultLocale, locales, getLocaleLabel, t };
+  const urlHelpers = makeUrlHelpers(settings, i18n);
+  const { withBase, docsUrl, versionedDocsUrl, navHref, isDefaultLocaleOnlyPath } = urlHelpers;
+  function getCategoryOrder() {
+    return getCategoryOrderBase(settings.headerNav);
+  }
+  function getNavSectionForSlug(slug) {
+    return getNavSectionForSlugBase(slug, settings.headerNav);
+  }
+  function getNavSubtree(tree, categoryMatch) {
+    return getNavSubtreeBase(tree, categoryMatch, settings.headerNav);
+  }
+  function extractHeadings(body) {
+    return extractHeadingsBase(body, {
+      tocMinDepth: settings.tocMinDepth,
+      tocMaxDepth: settings.tocMaxDepth,
+      strategy: settings.headingIdStrategy
+    });
+  }
+  function getVocab() {
+    return settings.tagVocabulary ? tagVocabulary : false;
+  }
+  function resolveTagBound(raw) {
+    return resolveTag(raw, getVocab(), settings.tagGovernance);
+  }
+  function collectTags(entries, slugFn) {
+    const tagMap = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      const rawTags = entry.data.tags ?? [];
+      const slug = slugFn(entry.id, entry.data);
+      const seen = /* @__PURE__ */ new Set();
+      for (const raw of rawTags) {
+        const resolved = resolveTagBound(raw);
+        if (resolved.deprecated) continue;
+        if (seen.has(resolved.canonical)) continue;
+        seen.add(resolved.canonical);
+        if (!tagMap.has(resolved.canonical)) {
+          tagMap.set(resolved.canonical, {
+            tag: resolved.canonical,
+            count: 0,
+            docs: []
+          });
+        }
+        const info = tagMap.get(resolved.canonical);
+        info.count++;
+        info.docs.push({
+          slug,
+          title: entry.data.title ?? "",
+          description: entry.data.description
+        });
+      }
+    }
+    return tagMap;
+  }
+  const base = {
+    settings,
+    colorSchemes,
+    i18n,
+    defaultLocale,
+    locales,
+    getLocaleConfig,
+    getLocaleLabel,
+    t,
+    urlHelpers,
+    ...urlHelpers,
+    getCategoryOrder,
+    getNavSectionForSlug,
+    getNavSubtree,
+    extractHeadings,
+    resolveTagBound,
+    collectTags,
+    buildNavTree,
+    groupSatelliteNodes,
+    findNode,
+    firstRoutedHref,
+    collectAutoIndexNodes,
+    isNavVisible,
+    stableDocs,
+    toRouteSlug,
+    toSlugParams
+  };
+  const navSourceDocs = createNavSourceDocs(base);
+  const docRouteEntries = createDocRouteEntries(base);
+  const baseWithNav = { ...base, ...navSourceDocs };
+  const routeEnumerators = createRouteEnumerators(
+    baseWithNav
+  );
+  return {
+    ...baseWithNav,
+    ...docRouteEntries,
+    ...routeEnumerators
+  };
+}
+export {
+  createRouteContext
+};